{"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"Tools.hpp\"\n#define PI 3.14159265\nusing namespace std;\n\n/***********************************************************************\n\nSecond Case: 2D drag! DragObject2D is a class for a point particle in\n2D coordinates. Instead of individual accessor methods like Euler1D,\ngetAttrs returns a vector of the four instance variables. The Euler\nstep and updating code is all built in as well. A frequently used data\ntype in this program is vector>, usually called path.\nThe data stored is a vector of x values and y values in a projectile's \ntrajectory, ex. {{x1,x2,x3...},{y1,y2,y3...}}. Passing a data type like\nthis around is much easier than writing two methods or using evil\nlibraries to make functions return multiple values.\n\nThe getPath function takes an initial x and y velocity and performs the\nEuler method on an instance of DragObject2D, saving the x and y values\nin vectors. It simulates until a sign change is detected in y, meaning\nthe object has returned to the ground. For that reason,\nmaking v_i negative is a bad idea. After simulation, the function \nreturns a path. plotPath just plots the path given with axes of path[0],\npath[1].\n\nRangeVAngle is more complicated, as it performs all calculation and \nplots the range vs. angle graph. It iterates from -pi/2 to pi/2 with a \nstep size of dth. For each iteration, it gets the path with getPath. The\nfinal x value is the range when the object returns to the ground, by\nthe definition of the getPath function.\n\n***********************************************************************/\n\nconst double v_i = 10;\t\t// Initial velocity for both the trajectory and the range v. angle plot\nconst double th = PI/6;\t\t// Firing angle for the trajectory plot\nconst double y_0 = 1;\t\t// Global starting height, Should be either zero or something positive, as the range vs. angle graph must be complete.\n\nconst double g = 9.8;\t\t// Gravitational acceleration (negative)\nconst double b = 0;//.56832;\t// Calculated drag constant for Syd Miyasaki\nconst double dt = 0.001;\t// Timestep\nconst double dth = 0.001;\t// Step in angle for the range v. angle plot\n\nclass DragObject2D{\t// Problem-specific class\npublic:\n\tDragObject2D(double vx_0, double vy_0);\t// Constructor\n\tvector getAttrs() const;\t\t// Accessor method for instance variables\n\tdouble getSpeed() const;\t\t\t\t// Accessor / calculation method for speed\n\tvoid update();\t// Euler step and updating\nprivate:\n\tdouble x, y, vx, vy;\n};\n\nDragObject2D::DragObject2D(double vx_0, double vy_0){\t// Constructor sets x to zero, y to starting height, initial velocities as arguments\n\tx = 0;\n\ty = y_0;\n\tvx = vx_0;\n\tvy = vy_0;\n}\n\nvector DragObject2D::getAttrs() const {\t// Usage of anonymously declared vectors to return all instance variables\n\treturn vector{x,y,vx,vy};\n}\n\ndouble DragObject2D::getSpeed() const {\t// *trivial* mechanics (component velocity to speed)\n\treturn sqrt(vx*vx + vy*vy);\n}\n\nvoid DragObject2D::update(){\t// Update all the things!\n\tdouble v = this->getSpeed();// Get speed on the current object instance. \"this\" returns a pointer to the instance, and -> is an abbreviation of (*this).getSpeed()\n\tx += vx*dt;\t\t\t\t// Update x and y\n\ty += vy*dt;\n\n\tvx += -(b*v*vx)*dt;\t\t// Euler step for x and y\n\tvy += -(g+b*v*vy)*dt;\n}\n\n\nvector> getPath(double vx_0, double vy_0){\t// Get the path thing\n\tvector x_n;\t// Vectors for the path\n\tvector y_n;\n\tdouble yval = 0;\t// The value of y\n\n\tDragObject2D object(vx_0, vy_0);// The object to track\n\n\twhile(yval >= 0){\t\t\t\t// Only track until the object hits the ground\n\t\tvector attrs = object.getAttrs();\t// Get attributes (x, y, vx, vy)\n\t\tx_n.push_back(attrs[0]);\t// Add attributes to vectors, update y value\n\t\ty_n.push_back(attrs[1]);\n\t\tyval = attrs[1];\n\n\t\tobject.update();\t\t\t// Perform Euler step and updates\n\t}\n\n\treturn vector>{x_n,y_n};\t// Return the two vectors of x and y together\n}\n\n\nvoid plotPath(vector>& path){\t// Plot the path; pretty basic stuff\n\tGnuplot gp;\n\n\tgp << setprecision(3);\n\tgp << \"set xrange [0:\" << path[0].back() << \"]\\n\";\n\tgp << \"set yrange [0:\" << getMaxVal(path[1])*1.1 << \"]\\n\";\n\tgp << \"set format y \\\"%.1f\\\"\\n\";\n\tgp << \"set term png size 720,480 font \\\"FreeSerif,12\\\"\\n\";\n\tgp << \"set xlabel \\\"x (m)\\\"\\n\";\n\tgp << \"set ylabel \\\"y (m)\\\"\\n\";\n\tgp << \"set title \\\"Trajectory of Syd Under Rayleigh's Drag Equation\\\\nb = \" << b;\n\tgp << \", v_i = \" << v_i << \", {/Symbol q}_i = \" << th << \"\\\"\\n\";\n\tgp << \"set output \\\"Trajectory.png\\\"\\n\";\n\tgp << \"plot '-' with dots lc rgb \\\"black\\\" notitle\\n\";\n\tgp.send1d(boost::make_tuple(path[0],path[1]));\n}\n\n\nvoid rangeVAngle(){\t\t\t// Calculation and plotting of the range vs. angle plot\n\tvector ranges;\t// Declare vectors\n\tvector angles;\n\n\tfor(double ang = -PI/2; ang < PI/2; ang += dth){\t// From -pi/2 to pi/2, steps of dth\n\n\t\tdouble vx_0 = v_i*cos(ang);\t// From v_i and ang, determine the initial velocities\n\t\tdouble vy_0 = v_i*sin(ang);\t\n\t\tvector> path = getPath(vx_0, vy_0);\t// Generate path\n\t\tdouble range = path[0].back();\t// The last x value is the range\n\n\t\tangles.push_back(ang);\t// Save angle and range\n\t\tranges.push_back(range);\n\t}\n\n\tGnuplot gp;\t\t// Now plot!\n\n\tgp << setprecision(3);\n\tgp << \"set xrange [\" << -PI/2 << \":\" << PI/2 << \"]\\n\";\n\tgp << \"set yrange [0:\" << getMaxVal(ranges)*1.1 << \"]\\n\";\n\tgp << \"set format y \\\"%.1f\\\"\\n\";\n\tgp << \"set term png size 720,480 font \\\"FreeSerif,12\\\"\\n\";\n\tgp << \"set xlabel \\\"angle (rad)\\\"\\n\";\n\tgp << \"set ylabel \\\"range (m)\\\"\\n\";\n\tgp << \"set title \\\"Range vs. Firing Angle of Syd Under Rayleigh's Drag Equation, b = \" << b << \"\\\"\\n\"; \n\tgp << \"set output \\\"RangeAngle.png\\\"\\n\";\n\tgp << \"plot '-' with dots lc rgb \\\"black\\\" notitle\\n\";\n\tgp.send1d(boost::make_tuple(angles,ranges));\n}\n\n\nint main(){\t\t// Main function\n\tdouble vx_0 = v_i*cos(th);\t// Use v_i and the launch angle th to determine initial velocities by components\n\tdouble vy_0 = v_i*sin(th);\n\tvector> path = getPath(vx_0, vy_0);\t// Generate the path\n\tplotPath(path);\t// Plot it\n\n\trangeVAngle();\t// And make the range vs. angle plot!\n\n\treturn 0;\t// If it all worked, return 0\n}", "meta": {"hexsha": "f93e4d08b918c90d8a80c784a61bc257c80bb923", "size": 6309, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Drag/SecondCase.cpp", "max_stars_repo_name": "GEslinger/PhysClass", "max_stars_repo_head_hexsha": "5e34167c34ca0e8779e4002063d95ffa24a24c9d", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Drag/SecondCase.cpp", "max_issues_repo_name": "GEslinger/PhysClass", "max_issues_repo_head_hexsha": "5e34167c34ca0e8779e4002063d95ffa24a24c9d", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Drag/SecondCase.cpp", "max_forks_repo_name": "GEslinger/PhysClass", "max_forks_repo_head_hexsha": "5e34167c34ca0e8779e4002063d95ffa24a24c9d", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.9444444444, "max_line_length": 163, "alphanum_fraction": 0.6712632747, "num_tokens": 1808, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891261650248, "lm_q2_score": 0.6688802735722128, "lm_q1q2_score": 0.5499460876373604}} {"text": "/*\n * CurvatureFilter.cpp\n *\n * Created on: Sep 23, 2017\n * Author: Peter Fankhauser\n * Institute: ETH Zurich, ANYbotics\n */\n\n#include \n\n#include \n#include \n\n#include \n\nusing namespace filters;\n\nnamespace grid_map {\n\ntemplate\nCurvatureFilter::CurvatureFilter()\n{\n}\n\ntemplate\nCurvatureFilter::~CurvatureFilter()\n{\n}\n\ntemplate\nbool CurvatureFilter::configure()\n{\n if (!FilterBase < T > ::getParam(std::string(\"input_layer\"), inputLayer_)) {\n ROS_ERROR(\"Curvature filter did not find parameter `input_layer`.\");\n return false;\n }\n ROS_DEBUG(\"Curvature filter input layer is = %s.\", inputLayer_.c_str());\n\n if (!FilterBase < T > ::getParam(std::string(\"output_layer\"), outputLayer_)) {\n ROS_ERROR(\"Curvature filter did not find parameter `output_layer`.\");\n return false;\n }\n ROS_DEBUG(\"Curvature filter output_layer = %s.\", outputLayer_.c_str());\n\n return true;\n}\n\ntemplate\nbool CurvatureFilter::update(const T& mapIn, T& mapOut)\n{\n if (!mapIn.isDefaultStartIndex()) throw std::runtime_error(\n \"CurvatureFilter cannot be used with grid maps that don't have a default buffer start index.\");\n\n mapOut = mapIn;\n mapOut.add(outputLayer_);\n auto& input = mapOut[inputLayer_];\n auto& curvature = mapOut[outputLayer_];\n const float L2 = mapOut.getResolution() * mapOut.getResolution();\n\n for (Eigen::Index j{0}; j < input.cols(); ++j) {\n for (Eigen::Index i{0}; i < input.rows(); ++i) {\n // http://help.arcgis.com/en/arcgisdesktop/10.0/help/index.html#/How_Curvature_works/00q90000000t000000/\n if (!std::isfinite(input(i, j))) continue;\n float D = ((input(i, j==0 ? j : j-1) + input(i, j==input.cols()-1 ? j : j + 1)) / 2.0 - input(i, j)) / L2;\n float E = ((input(i==0 ? i : i-1, j) + input(i==input.rows()-1 ? i : i + 1, j)) / 2.0 - input(i, j)) / L2;\n if (!std::isfinite(D)) D = 0.0;\n if (!std::isfinite(E)) E = 0.0;\n curvature(i, j) = -2.0 * (D + E);\n }\n }\n\n return true;\n}\n\n} /* namespace */\n\nPLUGINLIB_EXPORT_CLASS(grid_map::CurvatureFilter, filters::FilterBase)\n", "meta": {"hexsha": "b880f2285d91dee0bc0ba3e0c74a240913dfffe3", "size": 2253, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "grid_map_filters/src/CurvatureFilter.cpp", "max_stars_repo_name": "Yibin-Li/grid_map", "max_stars_repo_head_hexsha": "a0dd138c2235ce5d316aca6ea0dd4eb54e6d4a02", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1305.0, "max_stars_repo_stars_event_min_datetime": "2018-08-06T14:40:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T17:44:18.000Z", "max_issues_repo_path": "grid_map_filters/src/CurvatureFilter.cpp", "max_issues_repo_name": "Yibin-Li/grid_map", "max_issues_repo_head_hexsha": "a0dd138c2235ce5d316aca6ea0dd4eb54e6d4a02", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 174.0, "max_issues_repo_issues_event_min_datetime": "2018-08-06T21:41:44.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-29T04:45:09.000Z", "max_forks_repo_path": "grid_map_filters/src/CurvatureFilter.cpp", "max_forks_repo_name": "Yibin-Li/grid_map", "max_forks_repo_head_hexsha": "a0dd138c2235ce5d316aca6ea0dd4eb54e6d4a02", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 423.0, "max_forks_repo_forks_event_min_datetime": "2018-08-07T13:37:56.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-25T08:07:26.000Z", "avg_line_length": 28.8846153846, "max_line_length": 112, "alphanum_fraction": 0.6608965823, "num_tokens": 658, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891392358014, "lm_q2_score": 0.6688802603710086, "lm_q1q2_score": 0.5499460855262582}} {"text": "/* Boost example/filter.cpp\r\n * two examples of filters for computing the sign of a determinant\r\n * the second filter is based on an idea presented in\r\n * \"Interval arithmetic yields efficient dynamic filters for computational\r\n * geometry\" by Brönnimann, Burnikel and Pion, 2001\r\n *\r\n * Copyright 2003 Guillaume Melquiond\r\n *\r\n * Distributed under the Boost Software License, Version 1.0.\r\n * (See accompanying file LICENSE_1_0.txt or\r\n * copy at http://www.boost.org/LICENSE_1_0.txt)\r\n */\r\n\r\n#include \r\n#include \r\n#include \r\n\r\nnamespace dummy {\r\n using namespace boost;\r\n using namespace numeric;\r\n using namespace interval_lib;\r\n typedef save_state > R;\r\n typedef checking_no_nan > P;\r\n typedef interval > I;\r\n}\r\n\r\ntemplate\r\nclass vector {\r\n T* ptr;\r\npublic:\r\n vector(int d) { ptr = (T*)malloc(sizeof(T) * d); }\r\n ~vector() { free(ptr); }\r\n const T& operator[](int i) const { return ptr[i]; }\r\n T& operator[](int i) { return ptr[i]; }\r\n};\r\n\r\ntemplate\r\nclass matrix {\r\n int dim;\r\n T* ptr;\r\npublic:\r\n matrix(int d): dim(d) { ptr = (T*)malloc(sizeof(T) * dim * dim); }\r\n ~matrix() { free(ptr); }\r\n int get_dim() const { return dim; }\r\n void assign(const matrix &a) { memcpy(ptr, a.ptr, sizeof(T) * dim * dim); }\r\n const T* operator[](int i) const { return &(ptr[i * dim]); }\r\n T* operator[](int i) { return &(ptr[i * dim]); }\r\n};\r\n\r\ntypedef dummy::I I_dbl;\r\n\r\n/* compute the sign of a determinant using an interval LU-decomposition; the\r\n function answers 1 or -1 if the determinant is positive or negative (and\r\n more importantly, the result must be provable), or 0 if the algorithm was\r\n unable to get a correct sign */\r\nint det_sign_algo1(const matrix &a) {\r\n int dim = a.get_dim();\r\n vector p(dim);\r\n for(int i = 0; i < dim; i++) p[i] = i;\r\n int sig = 1;\r\n I_dbl::traits_type::rounding rnd;\r\n typedef boost::numeric::interval_lib::unprotect::type I;\r\n matrix u(dim);\r\n for(int i = 0; i < dim; i++) {\r\n const double* line1 = a[i];\r\n I* line2 = u[i];\r\n for(int j = 0; j < dim; j++)\r\n line2[j] = line1[j];\r\n }\r\n // computation of L and U\r\n for(int i = 0; i < dim; i++) {\r\n // partial pivoting\r\n {\r\n int pivot = i;\r\n double max = 0;\r\n for(int j = i; j < dim; j++) {\r\n const I &v = u[p[j]][i];\r\n if (zero_in(v)) continue;\r\n double m = norm(v);\r\n if (m > max) { max = m; pivot = j; }\r\n }\r\n if (max == 0) return 0;\r\n if (pivot != i) {\r\n sig = -sig;\r\n int tmp = p[i];\r\n p[i] = p[pivot];\r\n p[pivot] = tmp;\r\n }\r\n }\r\n // U[i,?]\r\n {\r\n I *line1 = u[p[i]];\r\n const I &pivot = line1[i];\r\n if (boost::numeric::interval_lib::cerlt(pivot, 0.)) sig = -sig;\r\n for(int k = i + 1; k < dim; k++) {\r\n I *line2 = u[p[k]];\r\n I fact = line2[i] / pivot;\r\n for(int j = i + 1; j < dim; j++) line2[j] -= fact * line1[j];\r\n }\r\n }\r\n }\r\n return sig;\r\n}\r\n\r\n/* compute the sign of a determinant using a floating-point LU-decomposition\r\n and an a posteriori interval validation; the meaning of the answer is the\r\n same as previously */\r\nint det_sign_algo2(const matrix &a) {\r\n int dim = a.get_dim();\r\n vector p(dim);\r\n for(int i = 0; i < dim; i++) p[i] = i;\r\n int sig = 1;\r\n matrix lui(dim);\r\n {\r\n // computation of L and U\r\n matrix lu(dim);\r\n lu.assign(a);\r\n for(int i = 0; i < dim; i++) {\r\n // partial pivoting\r\n {\r\n int pivot = i;\r\n double max = std::abs(lu[p[i]][i]);\r\n for(int j = i + 1; j < dim; j++) {\r\n double m = std::abs(lu[p[j]][i]);\r\n if (m > max) { max = m; pivot = j; }\r\n }\r\n if (max == 0) return 0;\r\n if (pivot != i) {\r\n sig = -sig;\r\n int tmp = p[i];\r\n p[i] = p[pivot];\r\n p[pivot] = tmp;\r\n }\r\n }\r\n // L[?,i] and U[i,?]\r\n {\r\n double *line1 = lu[p[i]];\r\n double pivot = line1[i];\r\n if (pivot < 0) sig = -sig;\r\n for(int k = i + 1; k < dim; k++) {\r\n double *line2 = lu[p[k]];\r\n double fact = line2[i] / pivot;\r\n line2[i] = fact;\r\n for(int j = i + 1; j < dim; j++) line2[j] -= line1[j] * fact;\r\n }\r\n }\r\n }\r\n\r\n // computation of approximate inverses: Li and Ui\r\n for(int j = 0; j < dim; j++) {\r\n for(int i = j + 1; i < dim; i++) {\r\n double *line = lu[p[i]];\r\n double s = - line[j];\r\n for(int k = j + 1; k < i; k++) s -= line[k] * lui[k][j];\r\n lui[i][j] = s;\r\n }\r\n lui[j][j] = 1 / lu[p[j]][j];\r\n for(int i = j - 1; i >= 0; i--) {\r\n double *line = lu[p[i]];\r\n double s = 0;\r\n for(int k = i + 1; k <= j; k++) s -= line[k] * lui[k][j];\r\n lui[i][j] = s / line[i];\r\n }\r\n }\r\n }\r\n\r\n // norm of PAUiLi-I computed with intervals\r\n {\r\n I_dbl::traits_type::rounding rnd;\r\n typedef boost::numeric::interval_lib::unprotect::type I;\r\n vector m1(dim);\r\n vector m2(dim);\r\n for(int i = 0; i < dim; i++) {\r\n for(int j = 0; j < dim; j++) m1[j] = 0;\r\n const double *l1 = a[p[i]];\r\n for(int j = 0; j < dim; j++) {\r\n double v = l1[j]; // PA[i,j]\r\n double *l2 = lui[j]; // Ui[j,?]\r\n for(int k = j; k < dim; k++) {\r\n using boost::numeric::interval_lib::mul;\r\n m1[k] += mul(v, l2[k]); // PAUi[i,k]\r\n }\r\n }\r\n for(int j = 0; j < dim; j++) m2[j] = m1[j]; // PAUi[i,j] * Li[j,j]\r\n for(int j = 1; j < dim; j++) {\r\n const I &v = m1[j]; // PAUi[i,j]\r\n double *l2 = lui[j]; // Li[j,?]\r\n for(int k = 0; k < j; k++)\r\n m2[k] += v * l2[k]; // PAUiLi[i,k]\r\n }\r\n m2[i] -= 1; // PAUiLi-I\r\n double ss = 0;\r\n for(int i = 0; i < dim; i++) ss = rnd.add_up(ss, norm(m2[i]));\r\n if (ss >= 1) return 0;\r\n }\r\n }\r\n return sig;\r\n}\r\n\r\nint main() {\r\n int dim = 20;\r\n matrix m(dim);\r\n for(int i = 0; i < dim; i++) for(int j = 0; j < dim; j++)\r\n m[i][j] = /*1 / (i-j-0.001)*/ cos(1+i*sin(1 + j)) /*1./(1+i+j)*/;\r\n\r\n // compute the sign of the determinant of a \"strange\" matrix with the two\r\n // algorithms, the first should fail and the second succeed\r\n std::cout << det_sign_algo1(m) << \" \" << det_sign_algo2(m) << std::endl;\r\n}\r\n", "meta": {"hexsha": "4ad0f30220ec98399130b0a37ade3d9c7d79efe6", "size": 6471, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "third_party/boost/libs/numeric/interval/examples/filter.cpp", "max_stars_repo_name": "Jackarain/tinyrpc", "max_stars_repo_head_hexsha": "07060e3466776aa992df8574ded6c1616a1a31af", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 32.0, "max_stars_repo_stars_event_min_datetime": "2019-02-27T06:57:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-29T10:56:19.000Z", "max_issues_repo_path": "third_party/boost/libs/numeric/interval/examples/filter.cpp", "max_issues_repo_name": "avplayer/cxxrpc", "max_issues_repo_head_hexsha": "7049b4079fac78b3828e68f787d04d699ce52f6d", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2019-03-04T11:21:00.000Z", "max_issues_repo_issues_event_max_datetime": "2019-05-24T01:36:31.000Z", "max_forks_repo_path": "third_party/boost/libs/numeric/interval/examples/filter.cpp", "max_forks_repo_name": "avplayer/cxxrpc", "max_forks_repo_head_hexsha": "7049b4079fac78b3828e68f787d04d699ce52f6d", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2019-08-20T13:45:04.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-01T18:23:49.000Z", "avg_line_length": 30.8142857143, "max_line_length": 81, "alphanum_fraction": 0.5022407665, "num_tokens": 2030, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.822189121808099, "lm_q2_score": 0.6688802669716106, "lm_q1q2_score": 0.5499460792961554}} {"text": "/*\n * Copyright 2020 Netherlands eScience Center\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#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\nnamespace py = pybind11;\n\nusing ComplexMatrix = Eigen::MatrixXcd;\nusing ComplexVector = Eigen::VectorXcd;\nusing Matrix = Eigen::MatrixXd;\nusing Vector = Eigen::VectorXd;\nusing Eigen::Index;\n\nSpectra::SortRule string_to_sortrule(const std::string& name)\n{\n std::unordered_map rules = {\n {\"LargestMagn\", Spectra::SortRule::LargestMagn},\n {\"LargestReal\", Spectra::SortRule::LargestReal},\n {\"LargestImag\", Spectra::SortRule::LargestImag},\n {\"LargestAlge\", Spectra::SortRule::LargestAlge},\n {\"SmallestMagn\", Spectra::SortRule::SmallestMagn},\n {\"SmallestReal\", Spectra::SortRule::SmallestReal},\n {\"SmallestImag\", Spectra::SortRule::SmallestImag},\n {\"SmallestAlge\", Spectra::SortRule::SmallestAlge},\n {\"BothEnds\", Spectra::SortRule::BothEnds}};\n auto it = rules.find(name);\n if (it != rules.cend())\n {\n return it->second;\n }\n else\n {\n std::ostringstream oss;\n oss << \"There is no selection rule named: \" << name << \"\\n\"\n << \"Available selection rules:\\n\";\n for (const auto& pair : rules)\n {\n oss << pair.first << \"\\n\";\n }\n throw std::runtime_error(oss.str());\n }\n}\n\n/// \\brief Run the computation and throw and error if it fails\ntemplate \nstd::pair compute_and_check(\n Solver& eigs, const std::string& selection)\n{\n // Initialize and compute\n eigs.init();\n // Compute using the user provided selection rule\n eigs.compute(string_to_sortrule(selection));\n\n // Retrieve results\n if (eigs.info() == Spectra::CompInfo::Successful)\n {\n return std::make_pair(eigs.eigenvalues(), eigs.eigenvectors());\n }\n else\n {\n throw std::runtime_error(\n \"The Spectra SymEigsSolver calculation has failed!\");\n }\n}\n\n/// \\brief Call the Spectra::GenEigsSolver eigensolver\nstd::pair geneigssolver(\n const Matrix& mat, Index nvalues, Index nvectors,\n const std::string& selection)\n{\n using DenseOp = Spectra::DenseGenMatProd;\n\n // Construct matrix operation object using the wrapper class DenseSymMatProd\n Spectra::DenseGenMatProd op(mat);\n Spectra::GenEigsSolver eigs(op, nvalues, nvectors);\n return compute_and_check(eigs, selection);\n}\n\n/// \\brief Call the Spectra::GenEigsRealShiftSolver eigensolver\nstd::pair geneigsrealshiftsolver(\n const Matrix& mat, Index nvalues, Index nvectors, double sigma,\n const std::string& selection)\n{\n using DenseOp = Spectra::DenseGenRealShiftSolve;\n DenseOp op(mat);\n Spectra::GenEigsRealShiftSolver eigs(op, nvalues, nvectors,\n sigma);\n return compute_and_check(eigs, selection);\n}\n\n/// \\brief Call the Spectra::GenEigsComplexShiftSolver eigensolver\nstd::pair geneigscomplexshiftsolver(\n const Matrix& mat, Index nvalues, Index nvectors, double sigmar,\n double sigmai, const std::string& selection)\n{\n using DenseOp = Spectra::DenseGenComplexShiftSolve;\n DenseOp op(mat);\n Spectra::GenEigsComplexShiftSolver eigs(\n op, nvalues, nvectors, sigmar, sigmai);\n return compute_and_check(eigs, selection);\n}\n\n/// \\brief Call the Spectra::DenseSymMatProd eigensolver\nstd::pair symeigssolver(const Matrix& mat, Index nvalues,\n Index nvectors,\n const std::string& selection)\n{\n using DenseSym = Spectra::DenseSymMatProd;\n // Construct matrix operation object using the wrapper class DenseSymMatProd\n DenseSym op(mat);\n Spectra::SymEigsSolver eigs(op, nvalues, nvectors);\n\n return compute_and_check(eigs, selection);\n}\n\n/// \\brief Call the Spectra::SymEigsShiftSolver eigensolver\nstd::pair symeigsshiftsolver(const Matrix& mat, Index nvalues,\n Index nvectors, double sigma,\n const std::string& selection)\n{\n using DenseSymShift = Spectra::DenseSymShiftSolve;\n // Construct matrix operation object using the wrapper class DenseSymMatProd\n DenseSymShift op(mat);\n Spectra::SymEigsShiftSolver eigs(op, nvalues, nvectors,\n sigma);\n\n return compute_and_check(eigs, selection);\n}\n\n/// \\brief Call the Spectra::SymGEigsShiftSolver eigensolver\nstd::pair symgeneigsshiftsolver(const Matrix& mat_A,\n const Matrix& mat_B, Index nvalues,\n Index nvectors, double sigma,\n const std::string& selection)\n{\n using SymShiftInvert =\n Spectra::SymShiftInvert;\n using DenseSym = Spectra::DenseSymMatProd;\n\n // Construct matrix operation object using the wrapper class DenseSymMatProd\n SymShiftInvert op_A(mat_A, mat_B);\n DenseSym op_B(mat_B);\n Spectra::SymGEigsShiftSolver\n eigs(op_A, op_B, nvalues, nvectors, sigma);\n\n return compute_and_check(eigs, selection);\n}\n\nPYBIND11_MODULE(spectra_dense_interface, m)\n{\n m.doc() =\n \"Interface to the C++ spectra library, see: \"\n \"https://github.com/yixuan/spectra\";\n\n m.def(\"general_eigensolver\", &geneigssolver,\n py::return_value_policy::reference_internal);\n\n m.def(\"general_real_shift_eigensolver\", &geneigsrealshiftsolver,\n py::return_value_policy::reference_internal);\n\n m.def(\"general_complex_shift_eigensolver\", &geneigscomplexshiftsolver,\n py::return_value_policy::reference_internal);\n\n m.def(\"symmetric_eigensolver\", &symeigssolver,\n py::return_value_policy::reference_internal);\n\n m.def(\"symmetric_shift_eigensolver\", &symeigsshiftsolver,\n py::return_value_policy::reference_internal);\n\n m.def(\"symmetric_generalized_shift_eigensolver\", &symgeneigsshiftsolver,\n py::return_value_policy::reference_internal);\n}\n", "meta": {"hexsha": "4a62d900b7665a24f46ee830b7afe452a5928657", "size": 7803, "ext": "cc", "lang": "C++", "max_stars_repo_path": "pyspectra/interface/spectra_dense_interface.cc", "max_stars_repo_name": "NLESC-JCER/pyspectra", "max_stars_repo_head_hexsha": "b7ece1fff537039f3306b23e00812aa1c8ffc729", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-01-05T01:52:31.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-05T01:52:31.000Z", "max_issues_repo_path": "pyspectra/interface/spectra_dense_interface.cc", "max_issues_repo_name": "NLESC-JCER/pyspectra", "max_issues_repo_head_hexsha": "b7ece1fff537039f3306b23e00812aa1c8ffc729", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2020-07-03T07:54:46.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-03T07:59:08.000Z", "max_forks_repo_path": "pyspectra/interface/spectra_dense_interface.cc", "max_forks_repo_name": "NLESC-JCER/pyspectra", "max_forks_repo_head_hexsha": "b7ece1fff537039f3306b23e00812aa1c8ffc729", "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": 38.4384236453, "max_line_length": 99, "alphanum_fraction": 0.6852492631, "num_tokens": 1925, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8397339676722393, "lm_q2_score": 0.6548947155710233, "lm_q1q2_score": 0.549937337914038}} {"text": "/** View a conflict graph as an implication graph and run Tarjan's strongly connected components algorithm */\n\n#include \"cliquetable_scc.hpp\"\n#include \n#include \n\nusing namespace boost;\n\n\nvoid make_domain_consistent(CliqueTableInstance* inst, IntSet* state_intset)\n{\n\ttypedef adjacency_list>> ImplGraph;\n\ttypedef graph_traits::vertex_descriptor Vertex;\n\n\tImplGraph graph(2 * inst->nvars);\n\n\t// cout << \"Clique table:\" << endl;\n\t// inst->print();\n\n\t// For every edge (i,j), we have two arcs (i, not j) and (j, not i)\n\tfor (int i = 0; i < inst->nvars; ++i) {\n\t\tfor (int j = inst->adj[i].get_first(); j != inst->adj[i].get_end(); j = inst->adj[i].get_next(j)) {\n\t\t\tif (i < j && i != inst->get_complement(j)) {\n\t\t\t\tadd_edge(i, inst->get_complement(j), graph);\n\t\t\t\tadd_edge(j, inst->get_complement(i), graph);\n\t\t\t}\n\t\t}\n\t}\n\n\ttypedef graph_traits::edge_iterator edge_iterator;\n\tpair ei = edges(graph);\n\n\t// Debugging info\n\t// cout << endl << \"Implication graph:\" << endl;\n\t// for (edge_iterator it = ei.first; it != ei.second; ++it) {\n\t// \tcout << \"(\" << source(*it, graph) << \", \" << target(*it, graph) << \")\" << \" \";\n\t// }\n\t// cout << endl;\n\n\t// Find strongly connected components\n\tint nv = num_vertices(graph);\n\tvector component(nv), discover_time(nv);\n\tvector color(nv);\n\tvector root(nv);\n\tint num = strong_components(graph, make_iterator_property_map(component.begin(), get(vertex_index, graph)),\n\t root_map(make_iterator_property_map(root.begin(), get(vertex_index, graph))).\n\t color_map(make_iterator_property_map(color.begin(), get(vertex_index, graph))).\n\t discover_time_map(make_iterator_property_map(discover_time.begin(), get(vertex_index, graph))));\n\n\t// cout << num << \" strong components\" << endl;\n\n\t// for (int j = num - 1; j >= 0; --j) {\n\t// \tcout << \"[ \";\n\t// \tfor (int i = 0; i < component.size(); ++i) {\n\t// \t\tif (j == component[i]) {\n\t// \t\t\tcout << i << \" \";\n\t// \t\t}\n\t// \t}\n\t// \tcout << \"] \";\n\t// }\n\n\t// Assert reverse topological ordering\n\tfor (edge_iterator it = ei.first; it != ei.second; ++it) {\n\t\tassert(component[source(*it, graph)] >= component[target(*it, graph)]);\n\t}\n\n\tvector topological_order;\n\tfor (int j = num - 1; j >= 0; --j) {\n\t\tfor (int i = 0; i < (int) component.size(); ++i) {\n\t\t\tif (j == component[i]) {\n\t\t\t\ttopological_order.push_back(i);\n\t\t\t}\n\t\t}\n\t}\n\n\t// cout << \"Topological order: \";\n\t// for (int i : topological_order) {\n\t// \tcout << i << \" \";\n\t// }\n\t// cout << endl;\n\n\tvector> vertices_in_component(component.size());\n\tfor (int i = 0; i < nv; ++i) {\n\t\tvertices_in_component[component[i]].push_back(i);\n\t}\n\n\t// // Debugging info\n\t// for (int i = 0; i < component.size(); ++i) {\n\t// \tcout << \"Component \" << i << \": \";\n\t// \tfor (int j : vertices_in_component[i]) {\n\t// \t\tcout << j << \" \";\n\t// \t}\n\t// \tcout << endl;\n\t// }\n\n\t// Traverse components in topological order\n\tvector> ancestors(component.size());\n\tfor (int c = nv - 1; c >= 0; --c) {\n\t\tfor (int v : vertices_in_component[c]) {\n\t\t\ttypename graph_traits::adjacency_iterator u, u_end;\n\t\t\tfor (tie(u, u_end) = adjacent_vertices(v, graph); u != u_end; ++u) {\n\t\t\t\t// Add current component and its own ancestors to ancestor list of adjacent component\n\t\t\t\tancestors[component[*u]].insert(c);\n\t\t\t\tfor (int ancestor : ancestors[c]) {\n\t\t\t\t\tancestors[component[*u]].insert(ancestor);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// // Debugging info\n\t// for (int i = 0; i < ancestors.size(); ++i) {\n\t// \tcout << \"Component \" << i << \" - ancestors: \";\n\t// \tfor (int j : ancestors[i]) {\n\t// \t\tcout << j << \" \";\n\t// \t}\n\t// \tcout << endl;\n\t// }\n\n\t// If the same component contains both complement nodes, remove them\n\tfor (int v = 0; v < inst->nvars; ++v) {\n\t\tif (component[v] == component[inst->get_complement(v)]) {\n\t\t\tstate_intset->remove(v);\n\t\t\tstate_intset->remove(inst->get_complement(v));\n\t\t}\n\t}\n\n\t// For each vertex, check if it precedes its component; if so, remove the vertex from the domain\n\tfor (int v = 0; v < nv; ++v) {\n\t\tint complement = component[inst->get_complement(v)];\n\t\tif (ancestors[complement].find(component[v]) != ancestors[complement].end()) {\n\t\t\t// There exists a path from v to complement of v\n\t\t\tstate_intset->remove(v);\n\t\t}\n\t}\n}\n", "meta": {"hexsha": "b816484295022041562d3e48e8935bb1d5b2d598", "size": 4498, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/problem/cliquetable/cliquetable_scc.cpp", "max_stars_repo_name": "ctjandra/ddopt-bounds", "max_stars_repo_head_hexsha": "aaf7407da930503a17969cee71718ffcf0c1fe96", "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/problem/cliquetable/cliquetable_scc.cpp", "max_issues_repo_name": "ctjandra/ddopt-bounds", "max_issues_repo_head_hexsha": "aaf7407da930503a17969cee71718ffcf0c1fe96", "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/problem/cliquetable/cliquetable_scc.cpp", "max_forks_repo_name": "ctjandra/ddopt-bounds", "max_forks_repo_head_hexsha": "aaf7407da930503a17969cee71718ffcf0c1fe96", "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.5942028986, "max_line_length": 125, "alphanum_fraction": 0.6151622944, "num_tokens": 1293, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.839733955639775, "lm_q2_score": 0.6548947223065755, "lm_q1q2_score": 0.5499373356901127}} {"text": "// This file is part of libigl, a simple c++ geometry processing library.\n// \n// Copyright (C) 2013 Alec Jacobson \n// \n// This Source Code Form is subject to the terms of the Mozilla Public License \n// v. 2.0. If a copy of the MPL was not distributed with this file, You can \n// obtain one at http://mozilla.org/MPL/2.0/.\n#include \"all_pairs_distances.h\"\n#include \n\ntemplate \nIGL_INLINE void igl::all_pairs_distances(\n const Mat & V,\n const Mat & U,\n const bool squared,\n Mat & D)\n{\n // dimension should be the same\n assert(V.cols() == U.cols());\n // resize output\n D.resize(V.rows(),U.rows());\n for(int i = 0;i >(Eigen::Matrix const&, Eigen::Matrix const&, bool, Eigen::Matrix&);\n#endif\n", "meta": {"hexsha": "608cf9b85773608c84336675b7d34ba16c6771f7", "size": 1187, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "igl/all_pairs_distances.cpp", "max_stars_repo_name": "aviadtzemah/animation2", "max_stars_repo_head_hexsha": "9a3f980fbe27672fe71f8f61f73b5713f2af5089", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2392.0, "max_stars_repo_stars_event_min_datetime": "2016-12-17T14:14:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T19:40:40.000Z", "max_issues_repo_path": "igl/all_pairs_distances.cpp", "max_issues_repo_name": "aviadtzemah/animation2", "max_issues_repo_head_hexsha": "9a3f980fbe27672fe71f8f61f73b5713f2af5089", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 106.0, "max_issues_repo_issues_event_min_datetime": "2018-04-19T17:47:31.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-01T19:44:11.000Z", "max_forks_repo_path": "igl/all_pairs_distances.cpp", "max_forks_repo_name": "aviadtzemah/animation2", "max_forks_repo_head_hexsha": "9a3f980fbe27672fe71f8f61f73b5713f2af5089", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 184.0, "max_forks_repo_forks_event_min_datetime": "2017-11-15T09:55:37.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-21T16:30:46.000Z", "avg_line_length": 29.675, "max_line_length": 229, "alphanum_fraction": 0.6259477675, "num_tokens": 369, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7490872243177518, "lm_q2_score": 0.7341195327172402, "lm_q1q2_score": 0.5499195630806024}} {"text": "////////////////////////////////////////////////////////////////////////////////\n#include \"vertex_degree.h\"\n#include \n#include \n#include \n////////////////////////////////////////////////////////////////////////////////\n\nnamespace cellogram {\n\n// -----------------------------------------------------------------------------\n\nvoid vertex_degree(const Eigen::MatrixXi &F, Eigen::VectorXi °ree)\n{\n\tdegree = Eigen::VectorXi::Zero(F.maxCoeff()+1);\n\t/*for (int i = 0; i < F.rows(); i++)\n\t{\n\t\tfor (int j = 0; j < 3; j++)\n\t\t{\n\t\t\tdegree(F(i, j))++;\n\t\t\tdegree(F(i, (j + 1) % 3))++;\n\t\t}\n\t}*/\n\n\tEigen::MatrixXi E;\n\tigl::edges(F, E);\n\n\t//std::cout << E.transpose() << std::endl;\n\n\tfor (int i = 0; i < E.rows(); i++)\n\t{\n\t\tfor (int j = 0; j < 2; j++)\n\t\t{\n\t\t\tdegree(E(i, j))++;\n\t\t\tdegree(E(i, (j + 1) % 2))++;\n\t\t}\n\n\t}\n\tdegree /= 2;\n}\n\n// -----------------------------------------------------------------------------\n\n} // namespace cellogram\n", "meta": {"hexsha": "357e701b60efd8054f2558ed646dbcbe6fcb77f3", "size": 965, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/cellogram/vertex_degree.cpp", "max_stars_repo_name": "cellogram/cellogram", "max_stars_repo_head_hexsha": "d378e9b87e56b879b2fb352b08b0fed714481968", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2019-09-25T15:04:27.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-20T08:17:44.000Z", "max_issues_repo_path": "src/cellogram/vertex_degree.cpp", "max_issues_repo_name": "cellogram/cellogram", "max_issues_repo_head_hexsha": "d378e9b87e56b879b2fb352b08b0fed714481968", "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/cellogram/vertex_degree.cpp", "max_forks_repo_name": "cellogram/cellogram", "max_forks_repo_head_hexsha": "d378e9b87e56b879b2fb352b08b0fed714481968", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2019-10-14T01:36:20.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-11T20:27:57.000Z", "avg_line_length": 21.9318181818, "max_line_length": 80, "alphanum_fraction": 0.3523316062, "num_tokens": 251, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7341195269001831, "lm_q2_score": 0.7490872131147276, "lm_q1q2_score": 0.5499195504987605}} {"text": "#include \"cutting_plane.hpp\"\r\n#include \"ell.hpp\"\r\n#include \"profit_oracle.hpp\"\r\n#include \"ldlt_ext.hpp\"\r\n//#include \r\n#include \r\n#include \r\n//#include \r\n#include \r\n\r\n//#include \r\n\r\n// Versions: (latest first)\r\n// http://melpon.org/wandbox/permlink/CcvL0BHfVJhHZH4M\r\n// http://melpon.org/wandbox/permlink/ExQoromITFQ7WOxO\r\n// http://melpon.org/wandbox/permlink/YiLtKIriWtkigZs8\r\n\r\nint test1() {\r\n //namespace bnu = boost::numeric::ublas;\r\n //using Vec = bnu::vector;\r\n //using Mat = xt::xarray;\r\n using Vec = xt::xarray;\r\n \r\n double p = 20, A = 40, alpha = 0.1, beta = 0.4;\r\n double v1 = 10, v2 = 35, k = 30.5;\r\n double fb;\r\n int niter, status;\r\n bool feasible;\r\n\r\n {\r\n ell E(100., Vec{0., 0.});\r\n profit_oracle P(p, A, alpha, beta, v1, v2, k);\r\n std::tie(std::ignore, fb, niter, feasible, status) =\r\n cutting_plane_dc(P, E, 0.);\r\n // fmt::print(\"{:f} {} {} {} \\n\", fb, niter, feasible, status);\r\n std::cout << fb << \", \" << niter << \", \" << feasible << \", \" << status << \"\\n\";\r\n }\r\n\r\n double ui = 1., e1 = 0.003, e2 = 0.007, e3 = 1.;\r\n\r\n {\r\n ell E1(100., Vec{0., 0.});\r\n profit_rb_oracle P1(p, A, alpha, beta, v1, v2, k, ui, e1, e2, e3);\r\n std::tie(std::ignore, fb, niter, feasible, status) =\r\n cutting_plane_dc(P1, E1, 0.);\r\n // fmt::print(\"{:f} {} {} {} \\n\", fb, niter, feasible, status);\r\n std::cout << fb << \", \" << niter << \", \" << feasible << \", \" << status\r\n << \"\\n\";\r\n }\r\n\r\n {\r\n ell E2(100., Vec{2., 0.});\r\n profit_q_oracle P2(p, A, alpha, beta, v1, v2, k);\r\n std::tie(std::ignore, fb, niter, feasible, status) =\r\n cutting_plane_q(P2, E2, 0.);\r\n // fmt::print(\"{:f} {} {} {} \\n\", fb, niter, feasible, status);\r\n std::cout << fb << \", \" << niter << \", \" << feasible << \", \" << status\r\n << \"\\n\";\r\n }\r\n\r\n return 0;\r\n}\r\n\r\nint main() {\r\n using Arr = xt::xarray;\r\n using xt::placeholders::_;\r\n using xt::linalg::dot;\r\n\r\n auto m1 = Arr({{25., 15., -5.},\r\n {15., 18., 0.},\r\n {-5., 0., 11.}});\r\n std::cout << m1.shape()[0] << \"\\n\";\r\n auto Q1 = ldlt_ext(m1.shape()[0]);\r\n Q1.factorize(m1);\r\n if (!Q1.is_sd()) {\r\n auto v = Q1.witness();\r\n auto p = v.size();\r\n auto sub = xt::range(0, p);\r\n Arr App = xt::view(m1, sub, sub);\r\n Arr Appv = dot(App, v);\r\n auto fj = -dot(v, Appv)();\r\n std::cout << fj << std::endl;\r\n }\r\n\r\n\r\n auto m2 = Arr({{18., 22., 54., 42.},\r\n {22., -70., 86., 62.},\r\n {54., 86., -174., 134.},\r\n {42., 62., 134., -106.}});\r\n std::cout << m2.shape()[0] << \"\\n\";\r\n auto Q2 = ldlt_ext(m2.shape()[0]);\r\n Q2.factorize(m2);\r\n if (!Q2.is_sd()) {\r\n auto v = Q2.witness();\r\n auto p = v.size();\r\n auto sub = xt::range(0, p);\r\n Arr App = xt::view(m2, sub, sub);\r\n Arr Appv = dot(App, v);\r\n auto fj = -dot(v, Appv)();\r\n std::cout << fj << std::endl;\r\n }\r\n\r\n return 0;\r\n}", "meta": {"hexsha": "7a47ba2c56fa439289366e8488b55f1b326e60ba", "size": 3167, "ext": "tpp", "lang": "C++", "max_stars_repo_path": "app/src/profit_main.tpp", "max_stars_repo_name": "luk036/ellcpp", "max_stars_repo_head_hexsha": "3415e7ffb70b63edb9ce4d6c2b9fee92898538bc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2020-07-26T04:58:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-26T06:29:59.000Z", "max_issues_repo_path": "app/src/profit_main.tpp", "max_issues_repo_name": "luk036/ellcpp", "max_issues_repo_head_hexsha": "3415e7ffb70b63edb9ce4d6c2b9fee92898538bc", "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": "app/src/profit_main.tpp", "max_forks_repo_name": "luk036/ellcpp", "max_forks_repo_head_hexsha": "3415e7ffb70b63edb9ce4d6c2b9fee92898538bc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2018-06-03T08:20:20.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-30T10:41:49.000Z", "avg_line_length": 30.4519230769, "max_line_length": 84, "alphanum_fraction": 0.509314809, "num_tokens": 1103, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8056322076481139, "lm_q2_score": 0.6825737473266735, "lm_q1q2_score": 0.5499033949414339}} {"text": "/*\n Copyright (C) 2015-2021 by Synge Todo \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// Critical temperature of hexagonal lattice Ising model\n\n#pragma once\n\n#include \n#include \n#include \n#include \n\nnamespace {\n \ntemplate\nstruct func {\n func(T Ja, T Jb, T Jc) : Ja_(Ja), Jb_(Jb), Jc_(Jc) {}\n auto operator()(T beta) const -> decltype(boost::math::differentiation::make_fvar(beta)) {\n using std::tanh;\n auto beta_fvar = boost::math::differentiation::make_fvar(beta);\n auto za = tanh(beta_fvar * Ja_);\n auto zb = tanh(beta_fvar * Jb_);\n auto zc = tanh(beta_fvar * Jc_);\n return za * zb + zb * zc + zc * za - 1;\n }\n T Ja_, Jb_, Jc_;\n};\n\n}\n\nnamespace ising {\nnamespace tc {\n\ntemplate\ninline T hexagonal(T Ja, T Jb, T Jc) {\n Ja = abs(Ja);\n Jb = abs(Jb);\n Jc = abs(Jc);\n if (Ja * Jb * Jc <= 0) throw(std::invalid_argument(\"Ja * Jb * Jc should be non-zero\"));\n auto result = standards::newton_1d(func(Ja, Jb, Jc), 1 / (Ja + Jb + Jc));\n if (!result.second) throw(std::runtime_error(\"convergence error\"));\n return 1 / result.first;\n}\n\n} // end namespace tc\n} // end namespace ising\n", "meta": {"hexsha": "55b4198ffdd04248c56a91dfd81dd3660c356e36", "size": 1767, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "ising/tc/hexagonal.hpp", "max_stars_repo_name": "todo-group/exact", "max_stars_repo_head_hexsha": "ee76421fab9b2b1eaf77d6b01830a18e66f7180a", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-07-27T14:45:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-27T14:45:49.000Z", "max_issues_repo_path": "ising/tc/hexagonal.hpp", "max_issues_repo_name": "todo-group/exact", "max_issues_repo_head_hexsha": "ee76421fab9b2b1eaf77d6b01830a18e66f7180a", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2018-11-30T14:48:41.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-30T14:48:41.000Z", "max_forks_repo_path": "ising/tc/hexagonal.hpp", "max_forks_repo_name": "todo-group/exact", "max_forks_repo_head_hexsha": "ee76421fab9b2b1eaf77d6b01830a18e66f7180a", "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.45, "max_line_length": 98, "alphanum_fraction": 0.6791171477, "num_tokens": 515, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8056321983146848, "lm_q2_score": 0.6825737473266735, "lm_q1q2_score": 0.5499033885706802}} {"text": "#include \n#include \"stochastic_euler.hpp\"\n#include \"cahnhilliard.h\"\n#include \"cahnhilliard_thermal.h\"\n#include \"cahnhilliard_thermal_nodiffusion.h\"\n#include \"run_ch_solver.h\"\n\nvoid run_ch_solver_non_thermal( CHparamsVector& chparams , SimInfo& info )\n{\n\n // Instantiate rhs\n CahnHilliard2DRHS rhs = CahnHilliard2DRHS( chparams , info );\n \n std::vector x;\n if (info.t0 == 0) {\n rhs.setInitialConditions(x);\n int iter = 0;\n }\n else {\n x = info.x;\n int iter = info.iter;\n }\n \n // define adaptive stepper\n typedef boost::numeric::odeint::runge_kutta_cash_karp54> error_stepper_type;\n\n // define runge kutta\n typedef boost::numeric::odeint::controlled_runge_kutta controlled_stepper_type;\n\n controlled_stepper_type controlled_stepper;\n\n const double stability_limit = chparams.compute_stability_limit(info.dx , info.dy); // just an estimate\n const double res0 = rhs.l2residual(x);\n\n std::cout << \"residual at initial condition: \" << res0 << std::endl;\n if (info.iter == 0)\n rhs.write_state(x,0,info.nx,info.ny,info.outdir);\n\n if (chparams.sigma_noise < 1e-2) {\n std::cout << \"Solving deterministic (noise-free) CH\" << std::endl;\n integrate_adaptive(controlled_stepper, rhs, x, info.t0, info.tf, stability_limit/2.);\n //boost::numeric::odeint::integrate_const(controlled_stepper, rhs, x, info.t0, info.tf, stability_limit/2.);\n }\n else {\n std::cout << \"Solving stochastic CH\" << std::endl;\n boost::mt19937 rng;\n boost::numeric::odeint::integrate_const( stochastic_euler() ,\n\t\t std::make_pair( rhs , ornstein_stoch( rng , chparams.sigma_noise ) ),\n\t\t x , info.t0 , info.tf , stability_limit/40. );\n }\n info.iter += 1;\n std::cout << \"iter: \" << info.iter << \" , t = \" << info.tf << \", relative residual: \" << rhs.l2residual(x) / res0 << std::endl;\n rhs.write_state(x,info.iter,info.nx,info.ny,info.outdir);\n info.x = x;\n\n};\n\n\nvoid run_ch_solver_thermal_no_diffusion( CHparamsVector& chparams , SimInfo& info )\n{\n\n // Instantiate rhs\n CahnHilliard2DRHS_thermal_nodiffusion rhs = CahnHilliard2DRHS_thermal_nodiffusion( chparams , info );\n \n std::vector x;\n if (info.t0 == 0) {\n rhs.setInitialConditions(x);\n int iter = 0;\n }\n else {\n x = info.x;\n int iter = info.iter;\n }\n \n // define adaptive stepper\n typedef boost::numeric::odeint::runge_kutta_cash_karp54> error_stepper_type;\n\n // define runge kutta\n typedef boost::numeric::odeint::controlled_runge_kutta controlled_stepper_type;\n\n controlled_stepper_type controlled_stepper;\n\n const double stability_limit = chparams.compute_stability_limit(info.dx , info.dy); // just an estimate\n const double res0 = rhs.l2residual(x);\n\n std::cout << \"residual at initial condition: \" << res0 << std::endl;\n if (info.iter == 0)\n rhs.write_state(x,0,info.nx,info.ny,info.outdir);\n\n if (chparams.sigma_noise < 1e-2) {\n std::cout << \"Solving deterministic (noise-free) CH\" << std::endl;\n integrate_adaptive(controlled_stepper, rhs, x, info.t0, info.tf, stability_limit/2.);\n //boost::numeric::odeint::integrate_const(controlled_stepper, rhs, x, info.t0, info.tf, stability_limit/2.);\n }\n else {\n std::cout << \"Solving stochastic CH\" << std::endl;\n boost::mt19937 rng;\n boost::numeric::odeint::integrate_const( stochastic_euler() ,\n\t\t std::make_pair( rhs , ornstein_stoch( rng , chparams.sigma_noise ) ),\n\t\t x , info.t0 , info.tf , stability_limit/40. );\n }\n info.iter += 1;\n std::cout << \"iter: \" << info.iter << \" , t = \" << info.tf << \", relative residual: \" << rhs.l2residual(x) / res0 << std::endl;\n rhs.write_state(x,info.iter,info.nx,info.ny,info.outdir);\n info.x = x;\n\n};\n\n\nvoid run_ch_solver_thermal_with_diffusion( CHparamsVector& chparams , SimInfo& info )\n{\n\n // Instantiate rhs\n CahnHilliard2DRHS_thermal rhs = CahnHilliard2DRHS_thermal( chparams , info );\n \n std::vector x;\n if (info.t0 == 0) {\n rhs.setInitialConditions(x);\n int iter = 0;\n }\n else {\n x = info.x;\n int iter = info.iter;\n }\n \n // define adaptive stepper\n typedef boost::numeric::odeint::runge_kutta_cash_karp54> error_stepper_type;\n\n // define runge kutta\n typedef boost::numeric::odeint::controlled_runge_kutta controlled_stepper_type;\n\n controlled_stepper_type controlled_stepper;\n\n const double stability_limit = chparams.compute_stability_limit(info.dx , info.dy); // just an estimate\n const double res0 = rhs.l2residual(x);\n\n std::cout << \"residual at initial condition: \" << res0 << std::endl;\n if (info.iter == 0)\n rhs.write_state(x,0,info.nx,info.ny,info.outdir);\n\n if (chparams.sigma_noise < 1e-2) {\n std::cout << \"Solving deterministic (noise-free) CH\" << std::endl;\n integrate_adaptive(controlled_stepper, rhs, x, info.t0, info.tf, stability_limit/2.);\n //boost::numeric::odeint::integrate_const(controlled_stepper, rhs, x, info.t0, info.tf, stability_limit/2.);\n }\n else {\n std::cout << \"Solving stochastic CH\" << std::endl;\n boost::mt19937 rng;\n boost::numeric::odeint::integrate_const( stochastic_euler() ,\n\t\t std::make_pair( rhs , ornstein_stoch( rng , chparams.sigma_noise ) ),\n\t\t x , info.t0 , info.tf , stability_limit/40. );\n }\n info.iter += 1;\n std::cout << \"iter: \" << info.iter << \" , t = \" << info.tf << \", relative residual: \" << rhs.l2residual(x) / res0 << std::endl;\n rhs.write_state(x,info.iter,info.nx,info.ny,info.outdir);\n info.x = x;\n\n};\n\n\nvoid run_ch_solver_non_thermal( CHparamsScalar& chparams , SimInfo& info )\n{\n\n // Instantiate rhs\n CahnHilliard2DRHS rhs = CahnHilliard2DRHS( chparams , info );\n \n std::vector x;\n if (info.t0 == 0) {\n rhs.setInitialConditions(x);\n int iter = 0;\n }\n else {\n x = info.x;\n int iter = info.iter;\n }\n \n // define adaptive stepper\n typedef boost::numeric::odeint::runge_kutta_cash_karp54> error_stepper_type;\n\n // define runge kutta\n typedef boost::numeric::odeint::controlled_runge_kutta controlled_stepper_type;\n\n controlled_stepper_type controlled_stepper;\n\n const double stability_limit = chparams.compute_stability_limit(info.dx , info.dy); // just an estimate\n const double res0 = rhs.l2residual(x);\n\n std::cout << \"residual at initial condition: \" << res0 << std::endl;\n if (info.iter == 0)\n rhs.write_state(x,0,info.nx,info.ny,info.outdir);\n\n if (chparams.sigma_noise < 1e-2) {\n std::cout << \"Solving deterministic (noise-free) CH\" << std::endl;\n integrate_adaptive(controlled_stepper, rhs, x, info.t0, info.tf, stability_limit/2.);\n //boost::numeric::odeint::integrate_const(controlled_stepper, rhs, x, info.t0, info.tf, stability_limit/2.);\n }\n else {\n std::cout << \"Solving stochastic CH\" << std::endl;\n boost::mt19937 rng;\n boost::numeric::odeint::integrate_const( stochastic_euler() ,\n\t\t std::make_pair( rhs , ornstein_stoch( rng , chparams.sigma_noise ) ),\n\t\t x , info.t0 , info.tf , stability_limit/40. );\n }\n info.iter += 1;\n std::cout << \"iter: \" << info.iter << \" , t = \" << info.tf << \", relative residual: \" << rhs.l2residual(x) / res0 << std::endl;\n rhs.write_state(x,info.iter,info.nx,info.ny,info.outdir);\n info.x = x;\n\n};\n\n\nvoid run_ch_solver_thermal_no_diffusion( CHparamsScalar& chparams , SimInfo& info )\n{\n\n // Instantiate rhs\n CahnHilliard2DRHS_thermal_nodiffusion rhs = CahnHilliard2DRHS_thermal_nodiffusion( chparams , info );\n \n std::vector x;\n if (info.t0 == 0) {\n rhs.setInitialConditions(x);\n int iter = 0;\n }\n else {\n x = info.x;\n int iter = info.iter;\n }\n \n // define adaptive stepper\n typedef boost::numeric::odeint::runge_kutta_cash_karp54> error_stepper_type;\n\n // define runge kutta\n typedef boost::numeric::odeint::controlled_runge_kutta controlled_stepper_type;\n\n controlled_stepper_type controlled_stepper;\n\n const double stability_limit = chparams.compute_stability_limit(info.dx , info.dy); // just an estimate\n const double res0 = rhs.l2residual(x);\n\n std::cout << \"residual at initial condition: \" << res0 << std::endl;\n if (info.iter == 0)\n rhs.write_state(x,0,info.nx,info.ny,info.outdir);\n\n if (chparams.sigma_noise < 1e-2) {\n std::cout << \"Solving deterministic (noise-free) CH\" << std::endl;\n integrate_adaptive(controlled_stepper, rhs, x, info.t0, info.tf, stability_limit/2.);\n //boost::numeric::odeint::integrate_const(controlled_stepper, rhs, x, info.t0, info.tf, stability_limit/2.);\n }\n else {\n std::cout << \"Solving stochastic CH\" << std::endl;\n boost::mt19937 rng;\n boost::numeric::odeint::integrate_const( stochastic_euler() ,\n\t\t std::make_pair( rhs , ornstein_stoch( rng , chparams.sigma_noise ) ),\n\t\t x , info.t0 , info.tf , stability_limit/40. );\n }\n info.iter += 1;\n std::cout << \"iter: \" << info.iter << \" , t = \" << info.tf << \", relative residual: \" << rhs.l2residual(x) / res0 << std::endl;\n rhs.write_state(x,info.iter,info.nx,info.ny,info.outdir);\n info.x = x;\n\n};\n\n\nvoid run_ch_solver_thermal_with_diffusion( CHparamsScalar& chparams , SimInfo& info )\n{\n\n // Instantiate rhs\n CahnHilliard2DRHS_thermal rhs = CahnHilliard2DRHS_thermal( chparams , info );\n \n std::vector x;\n if (info.t0 == 0) {\n rhs.setInitialConditions(x);\n int iter = 0;\n }\n else {\n x = info.x;\n int iter = info.iter;\n }\n \n // define adaptive stepper\n typedef boost::numeric::odeint::runge_kutta_cash_karp54> error_stepper_type;\n\n // define runge kutta\n typedef boost::numeric::odeint::controlled_runge_kutta controlled_stepper_type;\n\n controlled_stepper_type controlled_stepper;\n\n const double stability_limit = chparams.compute_stability_limit(info.dx , info.dy); // just an estimate\n const double res0 = rhs.l2residual(x);\n\n std::cout << \"residual at initial condition: \" << res0 << std::endl;\n if (info.iter == 0)\n rhs.write_state(x,0,info.nx,info.ny,info.outdir);\n\n if (chparams.sigma_noise < 1e-2) {\n std::cout << \"Solving deterministic (noise-free) CH\" << std::endl;\n integrate_adaptive(controlled_stepper, rhs, x, info.t0, info.tf, stability_limit/2.);\n //boost::numeric::odeint::integrate_const(controlled_stepper, rhs, x, info.t0, info.tf, stability_limit/2.);\n }\n else {\n std::cout << \"Solving stochastic CH\" << std::endl;\n boost::mt19937 rng;\n boost::numeric::odeint::integrate_const( stochastic_euler() ,\n\t\t std::make_pair( rhs , ornstein_stoch( rng , chparams.sigma_noise ) ),\n\t\t x , info.t0 , info.tf , stability_limit/40. );\n }\n info.iter += 1;\n std::cout << \"iter: \" << info.iter << \" , t = \" << info.tf << \", relative residual: \" << rhs.l2residual(x) / res0 << std::endl;\n rhs.write_state(x,info.iter,info.nx,info.ny,info.outdir);\n info.x = x;\n\n};\n\nvoid run_ch_solver( CHparamsVector& chparams , SimInfo& info )\n{\n \n if (info.rhs_type.compare(\"ch_non_thermal\") == 0) {\n run_ch_solver_non_thermal( chparams , info );\n }\n else if (info.rhs_type.compare(\"ch_thermal_no_diffusion\") == 0) {\n run_ch_solver_thermal_no_diffusion( chparams , info );\n }\n else if (info.rhs_type.compare(\"ch_thermal_with_diffusion\") == 0) {\n run_ch_solver_thermal_with_diffusion( chparams , info );\n }\n\n};\n\nvoid run_ch_solver( CHparamsScalar& chparams , SimInfo& info )\n{\n \n if (info.rhs_type.compare(\"ch_non_thermal\") == 0) {\n run_ch_solver_non_thermal( chparams , info );\n }\n else if (info.rhs_type.compare(\"ch_thermal_no_diffusion\") == 0) {\n run_ch_solver_thermal_no_diffusion( chparams , info );\n }\n else if (info.rhs_type.compare(\"ch_thermal_with_diffusion\") == 0) {\n run_ch_solver_thermal_with_diffusion( chparams , info );\n }\n\n};\n", "meta": {"hexsha": "0999bcb243f735ef9d5bee77b5773bcc913375f0", "size": 11906, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "cpp/src/run_ch_solver.cpp", "max_stars_repo_name": "ISI-apex/cahnhilliard_2d", "max_stars_repo_head_hexsha": "dc9992866e92ed09b431ebb9612002f207805d18", "max_stars_repo_licenses": ["0BSD"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2019-12-21T09:25:35.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-10T04:11:59.000Z", "max_issues_repo_path": "cpp/src/run_ch_solver.cpp", "max_issues_repo_name": "exalearn/cahnhilliard_2d", "max_issues_repo_head_hexsha": "cbf272bbac8080ff97c1cc93e7e7246bee04e075", "max_issues_repo_licenses": ["0BSD"], "max_issues_count": 4.0, "max_issues_repo_issues_event_min_datetime": "2019-07-08T23:06:44.000Z", "max_issues_repo_issues_event_max_datetime": "2019-07-24T18:51:15.000Z", "max_forks_repo_path": "cpp/src/run_ch_solver.cpp", "max_forks_repo_name": "exalearn/cahnhilliard_2d", "max_forks_repo_head_hexsha": "cbf272bbac8080ff97c1cc93e7e7246bee04e075", "max_forks_repo_licenses": ["0BSD"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-03-04T01:09:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-04T01:10:50.000Z", "avg_line_length": 34.8128654971, "max_line_length": 129, "alphanum_fraction": 0.6783974467, "num_tokens": 3504, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8056321983146848, "lm_q2_score": 0.6825737344123242, "lm_q1q2_score": 0.5499033781664645}} {"text": "/**\n * \\file boost/numeric/ublasx/operation/rcond.hpp\n *\n * \\brief Matrix reciprocal condition number estimate.\n *\n * The condition number of a regular (square) matrix is the product\n * of the \\e norm of the matrix and the norm of its inverse (or\n * pseudo-inverse), and hence depends on the kind of matrix-norm.\n *\n * Copyright (c) 2010, 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_RCOND_HPP\n#define BOOST_NUMERIC_UBLASX_OPERATION_RCOND_HPP\n\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\nnamespace boost { namespace numeric { namespace ublasx {\n\nusing namespace ::boost::numeric::ublas;\n\n\nnamespace detail {\n\nenum matrix_norm_category\n{\n\tmatrix_norm_1,\n\tmatrix_norm_2,\n\tmatrix_norm_frobenius,\n\tmatrix_norm_inf\n};\n\n\n//template <\n//\ttypename ValueT,\n//\ttypename LayoutT,\n//\ttypename StorageT\n//>\n//ValueT* band_mat_to_lapack_vec(banded_matrix const& A, ::fortran_int_t& n)\n//{\n//\ttypedef banded_matrix matrix_type;\n//\ttypedef typename matrix_traits::size_type size_type;\n//\n//\tconst size_type kl = A.lower();\n//\tconst size_type ku = A.upper();\n//\tconst size_type nr = num_rows(A);\n//\tconst size_type nc = num_columns(A);\n//\n//\tn = (2*kl+ku+1)*nc;\n//\n//\tValueT* v = new ValueT[n];\n//\n//\tfor (size_type r = 0; r < nr; ++r)\n//\t{\n//\t\tfor (size_type c = 0; c < nc; ++c)\n//\t\t{\n//\t\t\tsize_type rr = kl+ku+r-c;\n//\t\t\tsize_type k = (2*kl+ku+1)*c+rr;\n//\n//\t\t\tif ((r == c) || (c <= (ku+r) && r <= (c+kl)))\n//\t\t\t{\n//\t\t\t\t// In band\n//\t\t\t\tv[k] = A(r,c);\n//\t\t\t}\n//\t\t\telse\n//\t\t\t{\n//\t\t\t\t// Out of band\n//\t\t\t\tv[k] = ValueT();\n//\t\t\t}\n//\t\t}\n//\t}\n//\n//\treturn v;\n//}\n\n//template \n//void print_vector(std::string const& desc, T const* a, std::size_t n)\n//{\n//\tstd::cout << std::endl << desc << std::endl << \" [\";\n//\tfor(std::size_t i = 0; i < n; ++i)\n//\t{\n//\t\tstd::cout << \" \" << std::fixed << a[i];\n//\t}\n//\tstd::cout << \"]\" << std::endl;\n//}\n\n\n\ntemplate \ntypename type_traits<\n\ttypename matrix_traits::value_type\n>::real_type rcond_impl(MatrixT const& A, matrix_norm_category norm_category, column_major_tag)\n{\n typedef typename matrix_traits::value_type value_type;\n\ttypedef typename type_traits::real_type result_type;\n\ttypedef typename matrix_traits::size_type size_type;\n\ttypedef matrix work_matrix_type;\n\n\tsize_type nr = num_rows(A);\n\tsize_type nc = num_columns(A);\n\tsize_type k = ::std::min(nr,nc);\n\n\t// Check if A is a square matrix\n\tif (nr != nc)\n\t{\n\t\t// Non-square matrix -> Use QR decomposition\n\t\tif (nr < nc)\n\t\t{\n\t\t\treturn rcond_impl(qr_decompose(trans(A)).R(false), norm_category, column_major_tag());\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn rcond_impl(qr_decompose(A).R(false), norm_category, column_major_tag());\n\t\t}\n\t}\n\n\tchar what_norm;\n\tresult_type norm;\n\tresult_type res;\n\n\t//FIXME: actually, in bindings this function is broken\n//\tswitch (norm_category)\n//\t{\n//\t\tcase matrix_norm_1:\n//\t\t\twhat_norm = 'O';\n//\t\t\tbreak;\n//\t\tcase matrix_norm_inf:\n//\t\t\twhat_norm = 'I';\n//\t\t\tbreak;\n////\t\tcase matrix_norm_frobenius:\n////\t\t\twhat_norm = 'F';\n////\t\t\tbreak;\n//\t\tdefault:\n//\t\t\tthrow std::runtime_error(\"[rcond::detail::rcond_impl] Unsupported norm category.\");\n//\t}\n\n\t// Compute the norm of A\n\t//FIXME: actually, in bindings this function is broken\n//\t::boost::numeric::bindings::lapack::lange(\n//\t\twhat_norm,\n//\t\tA\n//\t);\n\tswitch (norm_category)\n\t{\n\t\tcase matrix_norm_1:\n\t\t\twhat_norm = 'O';\n\t\t\tnorm = norm_1(A);\n\t\t\tbreak;\n\t\tcase matrix_norm_inf:\n\t\t\twhat_norm = 'I';\n\t\t\tnorm = norm_inf(A);\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"[rcond::detail::rcond_impl] Unsupported norm category.\");\n\t}\n\n\t// Compute the LUP factorization of A\n\twork_matrix_type tmp_LU(A);\n\tvector< ::fortran_int_t > dummy_ipiv(k);\n\t::boost::numeric::bindings::lapack::getrf(\n\t\ttmp_LU,\n\t\tdummy_ipiv\n\t);\n\tdummy_ipiv.resize(0, false); // free memory\n\n\t// Finally, compute the reciprocal condition number\n\t::boost::numeric::bindings::lapack::gecon(\n\t\twhat_norm,\n\t\ttmp_LU,\n\t\tnorm,\n\t\tres\n\t);\n\n\treturn res;\n}\n\n\ntemplate \ntypename type_traits<\n\ttypename matrix_traits::value_type\n>::real_type rcond_impl(MatrixT const& A, matrix_norm_category norm_category, row_major_tag)\n{\n\ttypedef matrix<\n\t\t\t\ttypename matrix_traits::value_type,\n\t\t\t\tcolumn_major\n\t\t\t> work_matrix_type;\n\n\twork_matrix_type tmp_A(A);\n\n\treturn rcond_impl(tmp_A, norm_category, column_major_tag());\n}\n\n\ntemplate <\n\ttypename ValueT,\n\ttypename TriangularT,\n\ttypename StorageT\n>\ntypename type_traits::real_type rcond_impl(triangular_matrix const& A, matrix_norm_category norm_category, column_major_tag)\n{\n\ttypedef triangular_matrix matrix_type;\n typedef typename matrix_traits::value_type value_type;\n\ttypedef typename matrix_traits::size_type size_type;\n\ttypedef typename type_traits::real_type result_type;\n\ttypedef matrix auxiliary_matrix_type;\n\ttypedef triangular_adaptor work_matrix_type;\n\n\tsize_type nr = num_rows(A);\n\tsize_type nc = num_columns(A);\n\n\t// Check if A is a square matrix\n\tif (nr != nc)\n\t{\n\t\t// Non-square matrix -> Use QR decomposition\n\t\tif (nr < nc)\n\t\t{\n\t\t\treturn rcond_impl(qr_decompose(trans(A)).R(), norm_category, column_major_tag());\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn rcond_impl(qr_decompose(A).R(), norm_category, column_major_tag());\n\t\t}\n\t}\n\n\n\tchar what_norm;\n\tresult_type res;\n\n\tswitch (norm_category)\n\t{\n\t\tcase matrix_norm_1:\n\t\t\twhat_norm = 'O';\n\t\t\tbreak;\n\t\tcase matrix_norm_inf:\n\t\t\twhat_norm = 'I';\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"[rcond::detail::rcond_impl] Unsupported norm category.\");\n\t}\n\n\tauxiliary_matrix_type aux_A(A);\n\twork_matrix_type tmp_A(aux_A);\n\n\t// Finally, compute the reciprocal condition number\n\t::boost::numeric::bindings::lapack::trcon(\n\t\twhat_norm,\n\t\ttmp_A,\n\t\tres\n\t);\n\n\treturn res;\n}\n\n\ntemplate <\n\ttypename ValueT,\n\ttypename TriangularT,\n\ttypename StorageT\n>\ntypename type_traits::real_type rcond_impl(triangular_matrix const& A, matrix_norm_category norm_category, row_major_tag)\n{\n\ttypedef triangular_matrix work_matrix_type;\n\n\twork_matrix_type tmp_A(A);\n\n\treturn rcond_impl(tmp_A, norm_category, column_major_tag());\n}\n\n\n/*\ntemplate <\n\ttypename ValueT,\n\ttypename StorageT\n>\ntypename type_traits::real_type rcond_impl(banded_matrix const& A, matrix_norm_category norm_category, column_major_tag)\n{\n\ttypedef banded_matrix matrix_type;\n typedef typename matrix_traits::value_type value_type;\n\ttypedef typename matrix_traits::size_type size_type;\n\ttypedef typename type_traits::real_type result_type;\n\t//typedef matrix auxiliary_matrix_type;\n\t//typedef banded_adaptor work_matrix_type;\n\ttypedef banded_matrix work_matrix_type;\n\ttypedef vector< ::fortran_int_t > vector_type;\n\n\tsize_type nr = num_rows(A);\n\tsize_type nc = num_columns(A);\n\n\t// Check if A is a square matrix\n\tif (nr != nc)\n\t{\n\t\t// Non-square matrix -> Use QR decomposition\n\t\tif (nr < nc)\n\t\t{\n\t\t\treturn rcond_impl(qr_decompose(trans(A)).R(), norm_category, column_major_tag());\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn rcond_impl(qr_decompose(A).R(), norm_category, column_major_tag());\n\t\t}\n\t}\n\n\tchar what_norm;\n\tresult_type norm;\n\tresult_type res;\n\tsize_type k = ::std::min(nr,nc);\n\tsize_type kl = A.lower();\n\tsize_type ku = A.upper();\n//\tsize_type ldab = 2*kl+ku+1;\n\n\tswitch (norm_category)\n\t{\n\t\tcase matrix_norm_1:\n\t\t\twhat_norm = 'O';\n\t\t\tbreak;\n\t\tcase matrix_norm_inf:\n\t\t\twhat_norm = 'I';\n\t\t\tbreak;\n//\t\tcase matrix_norm_frobenius:\n//\t\t\twhat_norm = 'F';\n//\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"[rcond::detail::rcond_impl] Unsupported norm category.\");\n\t}\n\n\t// Compute the norm of A\n\t//FIXME: actually, in bindings this function is broken\n//\t::boost::numeric::bindings::lapack::lange(\n//\t\twhat_norm,\n//\t\tA\n//\t);\n\tswitch (norm_category)\n\t{\n\t\tcase matrix_norm_1:\n\t\t\tnorm = norm_1(A);\n\t\t\tbreak;\n\t\tcase matrix_norm_inf:\n\t\t\tnorm = norm_inf(A);\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"[rcond::detail::rcond_impl] Unsupported norm category.\");\n\t}\n\n\t// Compute the LUP factorization of A\n//\t::fortran_int_t* aux_ab = band_mat_to_lapack_vec(A, n);\n//\tvector< ::fortran_int_t> tmp_ipiv(k);\n//\t::std::ptrdiff_t info;\n//\tinfo = ::boost::numeric::bindings::lapack::detail::gbtrf(\n//\t\tnr,\n//\t\tnc,\n//\t\tkl,\n//\t\tku,\n//\t\taux_ab,\n//\t\tldab,\n//\t\ttmp_ipiv.data().begin()\n//\t);\n\twork_matrix_type AB(A, kl, kl+ku); //NOTE: \"kl+ku\" is not a typo\n\tvector_type ipiv(k);\n\t::boost::numeric::bindings::lapack::gbtrf(AB, ipiv);\n\n\t// Finally, compute the reciprocal condition number\n\t::boost::numeric::bindings::lapack::gbcon(\n\t\twhat_norm,\n\t\tAB,\n\t\tipiv,\n\t\tnorm,\n\t\tres\n\t);\n\n\treturn res;\n}\n*/\n\n\ntemplate <\n\ttypename ValueT,\n\ttypename StorageT\n>\ntypename type_traits::real_type rcond_impl(banded_matrix const& A, matrix_norm_category norm_category, column_major_tag)\n{\n\ttypedef banded_matrix work_matrix_type;\n\n\twork_matrix_type tmp_A(A, A.lower(), A.upper());\n\n\treturn rcond_impl(tmp_A, norm_category, row_major_tag());\n}\n\n\ntemplate <\n\ttypename ValueT,\n\ttypename StorageT\n>\ntypename type_traits::real_type rcond_impl(banded_matrix const& A, matrix_norm_category norm_category, row_major_tag)\n{\n\ttypedef banded_matrix matrix_type;\n typedef typename matrix_traits::value_type value_type;\n\ttypedef typename matrix_traits::size_type size_type;\n\ttypedef typename type_traits::real_type result_type;\n\ttypedef banded_matrix work_matrix_type;\n\ttypedef vector< ::fortran_int_t > vector_type;\n\n\tsize_type nr = num_rows(A);\n\tsize_type nc = num_columns(A);\n\n\t// Check if A is a square matrix\n\tif (nr != nc)\n\t{\n\t\t// Non-square matrix -> Use QR decomposition\n\t\tif (nr < nc)\n\t\t{\n\t\t\treturn rcond_impl(qr_decompose(trans(A)).R(), norm_category, column_major_tag());\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn rcond_impl(qr_decompose(A).R(), norm_category, column_major_tag());\n\t\t}\n\t}\n\n\tchar what_norm;\n\tresult_type norm;\n\tresult_type res;\n\tsize_type k = ::std::min(nr,nc);\n\tsize_type kl = A.lower();\n\tsize_type ku = A.upper();\n//\tsize_type ldab = 2*kl+ku+1;\n\n\tswitch (norm_category)\n\t{\n\t\tcase matrix_norm_1:\n\t\t\twhat_norm = 'O';\n\t\t\tbreak;\n\t\tcase matrix_norm_inf:\n\t\t\twhat_norm = 'I';\n\t\t\tbreak;\n//\t\tcase matrix_norm_frobenius:\n//\t\t\twhat_norm = 'F';\n//\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"[rcond::detail::rcond_impl] Unsupported norm category.\");\n\t}\n\n\t// Compute the norm of A\n\t//FIXME: actually, in bindings this function is broken\n//\t::boost::numeric::bindings::lapack::lange(\n//\t\twhat_norm,\n//\t\tA\n//\t);\n\tswitch (norm_category)\n\t{\n\t\tcase matrix_norm_1:\n\t\t\tnorm = norm_1(A);\n\t\t\tbreak;\n\t\tcase matrix_norm_inf:\n\t\t\tnorm = norm_inf(A);\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"[rcond::detail::rcond_impl] Unsupported norm category.\");\n\t}\n\n\t// Compute the LUP factorization of A\n//\t::fortran_int_t* aux_ab = band_mat_to_lapack_vec(A, n);\n//\tvector< ::fortran_int_t> tmp_ipiv(k);\n//\t::std::ptrdiff_t info;\n//\tinfo = ::boost::numeric::bindings::lapack::detail::gbtrf(\n//\t\tnr,\n//\t\tnc,\n//\t\tkl,\n//\t\tku,\n//\t\taux_ab,\n//\t\tldab,\n//\t\ttmp_ipiv.data().begin()\n//\t);\n\twork_matrix_type AB(A, kl, kl+ku); //NOTE: \"kl+ku\" is not a typo\n\tvector_type ipiv(k);\n\t::boost::numeric::bindings::lapack::gbtrf(AB, ipiv);\n\n\t// Finally, compute the reciprocal condition number\n\t::boost::numeric::bindings::lapack::gbcon(\n\t\twhat_norm,\n\t\tAB,\n\t\tipiv,\n\t\tnorm,\n\t\tres\n\t);\n\n\treturn res;\n}\n\n\ntemplate <\n\ttypename ValueT,\n\ttypename TriangularT,\n\ttypename StorageT\n>\ntypename type_traits::real_type rcond_impl(symmetric_matrix const& A, matrix_norm_category norm_category, column_major_tag)\n{\n\ttypedef symmetric_matrix matrix_type;\n typedef typename matrix_traits::value_type value_type;\n\ttypedef typename matrix_traits::size_type size_type;\n\ttypedef typename type_traits::real_type result_type;\n\ttypedef matrix auxiliary_matrix_type;\n\ttypedef symmetric_adaptor work_matrix_type;\n\ttypedef vector< ::fortran_int_t > vector_type;\n\n\tsize_type nr = num_rows(A);\n\tsize_type nc = num_columns(A);\n\tsize_type n = ::std::min(nr, nc);\n\n\t// Check if A is a square matrix\n\tif (nr != nc)\n\t{\n\t\t// Non-square matrix -> Use QR decomposition\n\t\tif (nr < nc)\n\t\t{\n\t\t\treturn rcond_impl(qr_decompose(trans(A)).R(), norm_category, column_major_tag());\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn rcond_impl(qr_decompose(A).R(), norm_category, column_major_tag());\n\t\t}\n\t}\n\n\tresult_type norm;\n\tresult_type res;\n\n\t// Compute the norm of A\n\t//FIXME: actually, in bindings this function is broken\n//\t::boost::numeric::bindings::lapack::lange(\n//\t\twhat_norm,\n//\t\tA\n//\t);\n\tswitch (norm_category)\n\t{\n\t\tcase matrix_norm_1:\n\t\t\tnorm = norm_1(A);\n\t\t\tbreak;\n\t\tcase matrix_norm_inf:\n\t\t\tnorm = norm_inf(A);\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"[rcond::detail::rcond_impl] Unsupported norm category.\");\n\t}\n\n\t// Compute the LUP factorization of A\n\t//work_matrix_type AB(A);\n\tauxiliary_matrix_type aux_A(A);\n\twork_matrix_type AB(aux_A);\n\tvector_type ipiv(n);\n\t::boost::numeric::bindings::lapack::sytrf(AB, ipiv);\n\n\t// Finally, compute the reciprocal condition number\n\t::boost::numeric::bindings::lapack::sycon(\n\t\tAB,\n\t\tipiv,\n\t\tnorm,\n\t\tres\n\t);\n\n\treturn res;\n}\n\n\ntemplate <\n\ttypename ValueT,\n\ttypename TriangularT,\n\ttypename StorageT\n>\ntypename type_traits::real_type rcond_impl(symmetric_matrix const& A, matrix_norm_category norm_category, row_major_tag)\n{\n\ttypedef symmetric_matrix work_matrix_type;\n\n\twork_matrix_type tmp_A(A);\n\n\treturn rcond_impl(tmp_A, norm_category, column_major_tag());\n}\n\n\ntemplate <\n\ttypename ValueT,\n\ttypename TriangularT,\n\ttypename StorageT\n>\ntypename type_traits::real_type rcond_impl(hermitian_matrix const& A, matrix_norm_category norm_category, column_major_tag)\n{\n\ttypedef hermitian_matrix matrix_type;\n typedef typename matrix_traits::value_type value_type;\n\ttypedef typename matrix_traits::size_type size_type;\n\ttypedef typename type_traits::real_type result_type;\n\ttypedef matrix auxiliary_matrix_type;\n\ttypedef hermitian_adaptor work_matrix_type;\n\ttypedef vector< ::fortran_int_t > vector_type;\n\n\tsize_type nr = num_rows(A);\n\tsize_type nc = num_columns(A);\n\tsize_type n = ::std::min(nr, nc);\n\n\t// Check if A is a square matrix\n\tif (nr != nc)\n\t{\n\t\t// Non-square matrix -> Use QR decomposition\n\t\tif (nr < nc)\n\t\t{\n\t\t\treturn rcond_impl(qr_decompose(trans(A)).R(), norm_category, column_major_tag());\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn rcond_impl(qr_decompose(A).R(), norm_category, column_major_tag());\n\t\t}\n\t}\n\n\tresult_type norm;\n\tresult_type res;\n\n\t// Compute the norm of A\n\t//FIXME: actually, in bindings this function is broken\n//\t::boost::numeric::bindings::lapack::lange(\n//\t\twhat_norm,\n//\t\tA\n//\t);\n\tswitch (norm_category)\n\t{\n\t\tcase matrix_norm_1:\n\t\t\tnorm = norm_1(A);\n\t\t\tbreak;\n\t\tcase matrix_norm_inf:\n\t\t\tnorm = norm_inf(A);\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"[rcond::detail::rcond_impl] Unsupported norm category.\");\n\t}\n\n\t// Compute the LUP factorization of A\n\tauxiliary_matrix_type aux_A(A);\n\twork_matrix_type AB(aux_A);\n\tvector_type ipiv(n);\n\t::boost::numeric::bindings::lapack::hetrf(AB, ipiv);\n\n\t// Finally, compute the reciprocal condition number\n\t::boost::numeric::bindings::lapack::hecon(\n\t\tAB,\n\t\tipiv,\n\t\tnorm,\n\t\tres\n\t);\n\n\treturn res;\n}\n\n\ntemplate <\n\ttypename ValueT,\n\ttypename TriangularT,\n\ttypename StorageT\n>\ntypename type_traits::real_type rcond_impl(hermitian_matrix const& A, matrix_norm_category norm_category, row_major_tag)\n{\n\ttypedef hermitian_matrix work_matrix_type;\n\n\twork_matrix_type tmp_A(A);\n\n\treturn rcond_impl(tmp_A, norm_category, column_major_tag());\n}\n\n} // Namespace detail\n\n\n/**\n * \\brief Matrix reciprocal condition number estimate based on 1-norm.\n *\n * \\tparam MatrixExprT The type of the input matrix expression.\n *\n * \\param A The input \\e square matrix expression.\n * \\return The estimate of the reciprocal condition number of \\a A.\n *\n * \\author Marco Guazzone, marco.guazzone@gmail.com\n */\ntemplate \ntypename type_traits<\n\ttypename matrix_traits::value_type\n>::real_type rcond(matrix_expression const& A)\n{\n\ttypedef typename matrix_traits::orientation_category orientation_category;\n\n\treturn detail::rcond_impl(A(), detail::matrix_norm_1, orientation_category());\n}\n\n\n//FIXME: Does we also need this?\n///**\n// * \\brief Matrix reciprocal condition number estimate based on the matrix norm\n// * defined by parameter \\a what_norm.\n// *\n// * \\tparam MatrixExprT The type of the input matrix expression.\n// * \\tparam NormTagT The type of the matrix norm category.\n// *\n// * \\param A The input \\e square matrix expression.\n// * \\param what_norm The matrix norm category.\n// * \\return The estimate of the reciprocal condition number of \\a A.\n// *\n// * \\author Marco Guazzone, marco.guazzone@gmail.com\n// */\n//template \n//typename type_traits<\n//\ttypename matrix_traits::value_type\n//>::real_type rcond(matrix_expression const& A, NormTagT what_norm)\n//{\n//\ttypedef typename matrix_traits::orientation_category orientation_category;\n//\n//\treturn detail::rcond_impl(A(), detail::matrix_norm_1, orientation_category());\n//}\n\n}}} // Namespace boost::numeric::ublasx\n\n\n#endif // BOOST_NUMERIC_UBLASX_OPERATION_RCOND_HPP\n", "meta": {"hexsha": "9321b8ce761ee98e8036e356b0c2d647cdafb0d1", "size": 19671, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "boost/numeric/ublasx/operation/rcond.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/rcond.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/rcond.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": 26.2630173565, "max_line_length": 174, "alphanum_fraction": 0.7274668293, "num_tokens": 5407, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8056321983146848, "lm_q2_score": 0.6825737214979745, "lm_q1q2_score": 0.5499033677622486}} {"text": "#pragma once\n\n\n#include \n\n\ntemplate\nvoid clip_pixel(std::int64_t const& x, std::int64_t const& y, Pixel const& pixel, View& view)\n{\n\tif(x < 0 || y < 0)\n\t{\n\t\treturn;\n\t}\n\telse if(x < view.width() && y < view.height())\n\t{\n\t\tview(x, y) = pixel;\n\t}\n}\n\n\ntemplate\nvoid bresenham_line(std::int64_t const& x1, std::int64_t const& y1, std::int64_t const& x2, std::int64_t const& y2, Pixel const& pixel, View& view)\n{\n\t// Adapted from http://www.etechplanet.com/codesnippets/computer-graphics-draw-a-line-using-bresenham-algorithm.aspx\n\n\tstd::int64_t const dx(x2 - x1);\n\tstd::int64_t const dy(y2 - y1);\n\tstd::int64_t const adx(std::abs(dx));\n\tstd::int64_t const ady(std::abs(dy));\n\tstd::int64_t px(2 * ady - adx);\n\tstd::int64_t py(2 * adx - ady);\n\tstd::int64_t x, y, xe, ye;\n\tif(adx < ady)\n\t{\n\t\tif(dy < 0)\n\t\t{\n\t\t\tx = x2;\n\t\t\ty = y2;\n\t\t\tye = y1;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tx = x1;\n\t\t\ty = y1;\n\t\t\tye = y2;\n\t\t}\n\t\tclip_pixel(x, y, pixel, view);\n\n\t\tfor(std::int64_t i(0); y < ye; ++ i)\n\t\t{\n\t\t\ty = y + 1;\n\t\t\tif(py > 0)\n\t\t\t{\n\t\t\t\tif((dx < 0 && dy < 0) || (dx > 0 && dy > 0))\n\t\t\t\t{\n\t\t\t\t\tx = x + 1;\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tx = x - 1;\n\t\t\t\t}\n\t\t\t\tpy = py + 2 * (adx - ady);\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tpy = py + 2 * adx;\n\t\t\t}\n\t\t\tclip_pixel(x, y, pixel, view);\n\t\t}\n\t}\n\telse\n\t{\n\t\tif(dx < 0)\n\t\t{\n\t\t\tx = x2;\n\t\t\ty = y2;\n\t\t\txe = x1;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tx = x1;\n\t\t\ty = y1;\n\t\t\txe = x2;\n\t\t}\n\t\tclip_pixel(x, y, pixel, view);\n\n\t\tfor(std::int64_t i(0); x < xe; ++ i)\n\t\t{\n\t\t\tx = x + 1;\n\t\t\tif(px < 0)\n\t\t\t{\n\t\t\t\tpx = px + 2 * ady;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tif((dx < 0 && dy < 0) || (dx > 0 && dy > 0))\n\t\t\t\t{\n\t\t\t\t\ty = y + 1;\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\ty = y - 1;\n\t\t\t\t}\n\t\t\t\tpx = px + 2 * (ady - adx);\n\t\t\t}\n\t\t\tclip_pixel(x, y, pixel, view);\n\t\t}\n\t}\n}\n", "meta": {"hexsha": "b8aeb267681a68ed9966ee133c2400cb08683194", "size": 1770, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "bresenham.hpp", "max_stars_repo_name": "mdyring/tumor_phenotyping", "max_stars_repo_head_hexsha": "dcc5ee38bc56128d649759b96a2f984b54375d18", "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": "bresenham.hpp", "max_issues_repo_name": "mdyring/tumor_phenotyping", "max_issues_repo_head_hexsha": "dcc5ee38bc56128d649759b96a2f984b54375d18", "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": "bresenham.hpp", "max_forks_repo_name": "mdyring/tumor_phenotyping", "max_forks_repo_head_hexsha": "dcc5ee38bc56128d649759b96a2f984b54375d18", "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": 16.0909090909, "max_line_length": 147, "alphanum_fraction": 0.4943502825, "num_tokens": 747, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624789529375, "lm_q2_score": 0.7025300636233416, "lm_q1q2_score": 0.5498439211344094}} {"text": "// Copyright 2017 Nest Labs, Inc.\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#include \"graph.hpp\"\n#include \"detector.hpp\"\n#include \"graphanalyzer.hpp\"\n#include \"processorcontainer.hpp\"\n#include \"lag.hpp\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace DetectorGraph;\nusing namespace Eigen;\n\n/**\n * @file robotlocalization.cpp\n * @brief A localization system for a mobile robot with Lag-based feedback loop.\n *\n * @section ex-rl-intro Introduction\n * Back in the 2000s all [_citation needed_] robots were _differential wheeled\n * robots_ [1] and localization with sensor fusion was a popular problem.\n * This example shows a simple solution to that problem using DetectorGraph.\n * It uses an Extended Kalman Filter [2] to continuously predict and correct\n * the robot's Pose (and associated uncertainty) from two information sources:\n * the input to the wheels and a GPS-like system.\n *\n * @section ex-rl-fpvslag FuturePublisher vs. Lag\\\n * This localization algorithm depends on a feedback-loop in that the output of\n * one graph evaluation (i.e. `LocalizationBelief`) is used as an input for the\n * next one (i.e. `Lagged`):\n @snippetlineno robotlocalization.cpp KalmanPoseCorrector Feedback Loop\n * Note that in this graph the TopicState where the feedback loop closes is a\n * legitimate output in itself and it's very likely that new Detectors in the\n * graph would subscribe to it. In cases like this the use of\n * DetectorGraph::Lag is preferred as it is more extensible and it preserves\n * the normal TopicState guarantee for the TopicState in question as well as it\n * makes the Lagged version of the TopicState clearly documented and also\n * available. Lag allows even for detectors that subscribes to both the immediate\n * and the Lagged version of a TopicState - this could be useful for things like\n * differentiation etc.\n *\n * @section ex-rl-conf-topicstates Configuration TopicStates\n * It also shows how TopicStates can be used for static/configuration data\n * (e.g. `RobotConfig`). This allows for easy dependency tracking, visualization\n * and testing at pretty much no runtime cost.\n *\n * @section ex-rl-localization Localization Algorithm\n * Regarding the Localization algorithm itself, it's mostly taken from [3]\n * except for the correction model where this example uses a different input\n * (i.e. `GPSPosition`) with much simpler transfer function to the Pose vector.\n *\n * @section ex-rl-arch Architecture\n * The graph below shows the relationships between the topics (rectangles) and\n * detectors (ellipses). Note that this graph can be automatically generated\n * for any instance of DetectorGraph::Graph using DetectorGraph::GraphAnalyzer.\n * @dot \"RobotBrain\"\ndigraph GraphAnalyzer {\n rankdir = \"LR\";\n node[fontname=Helvetica];\n size=\"12,5\";\n\n \"RobotConfig\" [label=\"0:RobotConfig\",style=filled, shape=box, color=lightblue];\n \"RobotConfig\" -> \"ExtendedKalmanPosePredictor\";\n \"InitialPose\" [label=\"1:InitialPose\",style=filled, shape=box, color=lightblue];\n \"InitialPose\" -> \"ExtendedKalmanPosePredictor\";\n \"WheelSpeeds\" [label=\"2:WheelSpeeds\",style=filled, shape=box, color=lightblue];\n \"WheelSpeeds\" -> \"ExtendedKalmanPosePredictor\";\n \"GPSPosition\" [label=\"3:GPSPosition\",style=filled, shape=box, color=lightblue];\n \"GPSPosition\" -> \"KalmanPoseCorrector\";\n \"LaggedLocalizationBelief\" [label=\"4:Lagged\",style=filled, shape=box, color=lightblue];\n \"LaggedLocalizationBelief\" -> \"ExtendedKalmanPosePredictor\";\n \"LaggedLocalizationBelief\" -> \"KalmanPoseCorrector\";\n \"KalmanPoseCorrector\" [label=\"6:KalmanPoseCorrector\", color=blue];\n \"KalmanPoseCorrector\" -> \"LocalizationBelief\";\n \"ExtendedKalmanPosePredictor\" [label=\"5:ExtendedKalmanPosePredictor\", color=blue];\n \"ExtendedKalmanPosePredictor\" -> \"LocalizationBelief\";\n \"LocalizationBelief\" [label=\"7:LocalizationBelief\",style=filled, shape=box, color=red];\n \"LocalizationBelief\" -> \"LagLocalizationBelief\";\n \"LagLocalizationBelief\" [label=\"8:Lag\", color=blue];\n \"LagLocalizationBelief\" -> \"LaggedLocalizationBelief\" [style=dotted, color=red, constraint=false];\n}\n * @enddot\n *\n *\n * @section ex-rl-other-notes Other Notes\n * This example also uses the Eigen library [4] for matrix/vector arithmetic\n * and linear-algebraic operations.\n *\n * Note that this entire algorithm is contained in a single file for the sake\n * of unity as an example. In real-world scenarios the suggested pattern is to\n * split the code into:\n *\n @verbatim\n detectorgraph/\n include/\n robotbrain.hpp (RobotBrain header)\n src/\n robotbrain.hpp (RobotBrain implementation)\n detectors/\n include/\n ExtendedKalmanPosePredictor.hpp\n KalmanPoseCorrector.hpp\n src/\n ExtendedKalmanPosePredictor.cpp\n KalmanPoseCorrector.cpp\n topicstates/\n include/\n RobotConfig.hpp\n InitialPose.hpp\n WheelSpeeds.hpp\n LocalizationBelief.hpp\n GPSPosition.hpp\n@endverbatim\n *\n * @section ex-rl-refs References\n * - [1] Differential Wheeled Robots - https://en.wikipedia.org/wiki/Differential_wheeled_robot\n * - [2] Extended Kalman Filter - https://en.wikipedia.org/wiki/Extended_Kalman_filter\n * - [3] EKF applied to Mobile Robot’s Localization (Section 2.4.4, page 17) - http://cpscotti.com/pdf/pfc_scotti.pdf\n * - [4] Eigen - http://eigen.tuxfamily.org/dox/index.html\n */\n\n/// @cond DO_NOT_DOCUMENT\n\n// Contains the configuration parameters of this differential mobile Robot\n// or vehicle.\nstruct RobotConfig : public TopicState\n{\n RobotConfig() : r(), b(), e() {}\n RobotConfig(double aR, double aB, double aE)\n : r(aR), b(aB), e(aE) {}\n double r; // wheels r\n double b; // displacement between wheels 2*l (l=d(wheel,center))\n\n double e; // relative wheel slippage/error\n};\n\nstruct InitialPose : public TopicState\n{\n InitialPose() : timestampMs(0), pose(Vector3d::Zero()) {}\n InitialPose(Vector3d aPose) : timestampMs(0), pose(aPose) {}\n InitialPose(uint64_t aTimestampMs, Vector3d aPose) : timestampMs(aTimestampMs), pose(aPose) {}\n uint64_t timestampMs;\n Vector3d pose;\n};\n\n// The measured (via encoders or other odometry method) wheel speeds\nstruct WheelSpeeds : public TopicState\n{\n WheelSpeeds() : timestampMs(), phi(Vector2d::Zero()) {}\n WheelSpeeds(uint64_t ts, Vector2d aPhi) : timestampMs(ts), phi(aPhi) {}\n WheelSpeeds(uint64_t ts, double r, double l) : timestampMs(ts), phi(r, l) {}\n uint64_t timestampMs;\n\n // phi_r, phi_l in radians\n Vector2d phi;\n};\n\n//! [TopicStates Composition Example]\nstruct KalmanState\n{\n KalmanState() : pose(Vector3d::Zero()), error(Matrix3d::Zero()) {}\n KalmanState(Vector3d aPose, Matrix3d aError) : pose(aPose), error(aError) {}\n Vector3d pose;\n Matrix3d error;\n};\n\n//! [Mutually Atomic Variables]\nstruct LocalizationBelief : public TopicState\n{\n LocalizationBelief() : timestampMs(), state() {}\n LocalizationBelief(uint64_t ts, const KalmanState& aState) : timestampMs(ts), state(aState) {}\n LocalizationBelief(uint64_t ts, const Vector3d& aPose, const Matrix3d& aError) : timestampMs(ts), state(aPose, aError) {}\n uint64_t timestampMs;\n KalmanState state;\n};\n//! [Mutually Atomic Variables]\n\nstruct GPSPosition : public TopicState\n{\n GPSPosition() : timestampMs(), state() {}\n GPSPosition(uint64_t ts, const KalmanState& aState) : timestampMs(ts), state(aState) {}\n uint64_t timestampMs;\n KalmanState state;\n};\n//! [TopicStates Composition Example]\n\ndouble WrapAngle(double th)\n{\n // remainder requires C++11\n return std::remainder(th, 2. * M_PI);\n}\n\nclass ExtendedKalmanPosePredictor : public Detector,\n public SubscriberInterface,\n public SubscriberInterface,\n public SubscriberInterface< Lagged >,\n public SubscriberInterface,\n public Publisher\n{\npublic:\n ExtendedKalmanPosePredictor(Graph* graph) : Detector(graph), mCurrentBelief(), mConfig()\n {\n Subscribe(this);\n Subscribe(this);\n Subscribe< Lagged >(this);\n Subscribe(this);\n SetupPublishing(this);\n }\n\n virtual void Evaluate(const RobotConfig& aConfig)\n {\n mConfig = aConfig;\n }\n\n virtual void Evaluate(const InitialPose& aInitialPose)\n {\n mCurrentBelief.state = KalmanState(aInitialPose.pose, Matrix3d::Zero());\n mCurrentBelief.timestampMs = aInitialPose.timestampMs;\n }\n\n virtual void Evaluate(const Lagged& aLaggedBelief)\n {\n mCurrentBelief.state = aLaggedBelief.data.state;\n mCurrentBelief.timestampMs = aLaggedBelief.data.timestampMs;\n }\n\n virtual void Evaluate(const WheelSpeeds& aWheelSpeeds)\n {\n // [\\Delta S_{r}, \\Delta S_{l}] from phi\n Vector2d wheelLinearSpeed = aWheelSpeeds.phi * mConfig.r;\n\n // Eq. 2.36\n double d_th = (wheelLinearSpeed.x() - wheelLinearSpeed.y()) / mConfig.b;\n // Eq. 2.37\n double d_travel = (wheelLinearSpeed.x() + wheelLinearSpeed.y()) / 2.;\n\n double theta = mCurrentBelief.state.pose.z();\n\n // Used on most equations below\n double th_dth2 = theta + d_th / 2.;\n\n // Eq. 2.33 on [3]\n Vector3d cartesianSpeed;\n cartesianSpeed << d_travel * cos(th_dth2),\n d_travel * sin(th_dth2),\n d_th;\n\n\n // Compute Time Delta\n double tDelta = (aWheelSpeeds.timestampMs - mCurrentBelief.timestampMs) * 1e-3;\n\n // Eq. 2.33 (i.e. 2.23) on [3]\n mCurrentBelief.state.pose = mCurrentBelief.state.pose + (cartesianSpeed * tDelta);\n mCurrentBelief.state.pose.z() = WrapAngle(mCurrentBelief.state.pose.z());\n\n // Eq. 2.34 on [3]\n Matrix3d G;\n G << 1, 0, -d_travel * sin(th_dth2),\n 0, 1, d_travel * cos(th_dth2),\n 0, 0, 1;\n\n // Eq. 2.35 on [3]\n Matrix V;\n V << 0.5 * cos(th_dth2) - (d_travel / (2. * mConfig.b)) * sin(th_dth2), 0.5 * cos(th_dth2) + (d_travel / (2. * mConfig.b)) * sin(th_dth2),\n 0.5 * sin(th_dth2) + (d_travel / (2. * mConfig.b)) * cos(th_dth2), 0.5 * sin(th_dth2) - (d_travel / (2. * mConfig.b)) * cos(th_dth2),\n 1./mConfig.b, -1./mConfig.b;\n\n // Eq. 2.38 on [3]\n Matrix2d M;\n M << mConfig.e * abs(wheelLinearSpeed.x()), 0,\n 0, mConfig.e * abs(wheelLinearSpeed.y());\n\n // Eq. 2.24 on [3]\n mCurrentBelief.state.error = G * mCurrentBelief.state.error * G.transpose() + V * M * V.transpose();\n\n mCurrentBelief.timestampMs = aWheelSpeeds.timestampMs;\n Publish(mCurrentBelief);\n }\n\n LocalizationBelief mCurrentBelief;\n RobotConfig mConfig;\n};\n\n///! [KalmanPoseCorrector Feedback Loop]\nclass KalmanPoseCorrector : public Detector,\n public SubscriberInterface< Lagged >,\n public SubscriberInterface,\n public Publisher\n{\npublic:\n KalmanPoseCorrector(Graph* graph) : Detector(graph), mCurrentBelief()\n {\n Subscribe< Lagged >(this);\n Subscribe(this);\n SetupPublishing(this);\n }\n///! [KalmanPoseCorrector Feedback Loop]\n\n virtual void Evaluate(const Lagged& aLaggedBelief)\n {\n mCurrentBelief.state = aLaggedBelief.data.state;\n mCurrentBelief.timestampMs = aLaggedBelief.data.timestampMs;\n }\n\n virtual void Evaluate(const GPSPosition& aCorrectionInput)\n {\n // C = Identity(3)\n\n // Eq. 2.15 on [3]\n Matrix3d K = mCurrentBelief.state.error * (mCurrentBelief.state.error + aCorrectionInput.state.error).inverse();\n\n // Eq. 2.13 on [3]\n mCurrentBelief.state.pose = mCurrentBelief.state.pose + K * (aCorrectionInput.state.pose - mCurrentBelief.state.pose);\n\n // Eq. 2.14 on [3]\n mCurrentBelief.state.error = (Matrix3d::Identity() - K) * mCurrentBelief.state.error;\n\n Publish(mCurrentBelief);\n }\n\n LocalizationBelief mCurrentBelief;\n};\n\n//![RobotBrain Static]\nclass RobotBrain : public ProcessorContainer\n{\npublic:\n RobotBrain()\n : mPosePredictor(&mGraph)\n , mKalmanPoseCorrector(&mGraph)\n , mBeliefFeedback(&mGraph)\n {\n }\n\n ExtendedKalmanPosePredictor mPosePredictor;\n KalmanPoseCorrector mKalmanPoseCorrector;\n Lag mBeliefFeedback;\n //![RobotBrain Static]\n\n virtual void ProcessOutput()\n {\n Topic* correctedStateTopic = mGraph.ResolveTopic();\n if (correctedStateTopic->HasNewValue())\n {\n const LocalizationBelief& belief = correctedStateTopic->GetNewValue();\n const auto& pose = belief.state.pose;\n cout << \"Pose = [\" << pose.x() << \", \" << pose.y() << \", \" << pose.z() << \"], \";\n const auto& error = belief.state.error.diagonal();\n cout << \"Error = [\" << error.x() << \", \" << error.y() << \", \" << error.z() << \"]\";\n cout << endl;\n }\n }\n};\n\nint main()\n{\n RobotBrain robot;\n\n uint64_t kSimStep = 1000;\n uint64_t dataIndex = 0;\n\n robot.ProcessData(RobotConfig(1, 1, 0.1));\n robot.ProcessData(InitialPose(Vector3d(10.0, 10.0, 0.0)));\n\n // Circular Movement\n // for (int i=0;i<100;i++) robot.ProcessData(WheelSpeeds((dataIndex++)*kSimStep, 1., 0.5));\n\n // Fwd, Rotate ~180, Fwd, GPS Update\n robot.ProcessData(WheelSpeeds((dataIndex++)*kSimStep, 1, 1));\n robot.ProcessData(WheelSpeeds((dataIndex++)*kSimStep, 1, 1));\n robot.ProcessData(WheelSpeeds((dataIndex++)*kSimStep, 1, 1));\n robot.ProcessData(WheelSpeeds((dataIndex++)*kSimStep, 1, 1));\n robot.ProcessData(WheelSpeeds((dataIndex++)*kSimStep, 1, 1));\n robot.ProcessData(WheelSpeeds((dataIndex++)*kSimStep, 1, -1));\n robot.ProcessData(WheelSpeeds((dataIndex++)*kSimStep, 1, -1));\n robot.ProcessData(WheelSpeeds((dataIndex++)*kSimStep, 1, 1));\n robot.ProcessData(WheelSpeeds((dataIndex++)*kSimStep, 1, 1));\n robot.ProcessData(WheelSpeeds((dataIndex++)*kSimStep, 1, 1));\n robot.ProcessData(WheelSpeeds((dataIndex++)*kSimStep, 1, 1));\n robot.ProcessData(WheelSpeeds((dataIndex++)*kSimStep, 1, 1));\n robot.ProcessData(GPSPosition((dataIndex++)*kSimStep,\n KalmanState(Vector3d(10., 10., 4), // Position\n Vector3d(0.1,0.1,300000).asDiagonal() // Error\n )));\n\n cout << \"---- Done ----\" << endl;\n\n GraphAnalyzer analyzer(robot.mGraph);\n analyzer.GenerateDotFile(\"robot_localization.dot\");\n\n return 0;\n}\n\n/// @endcond DO_NOT_DOCUMENT\n", "meta": {"hexsha": "9e6fad6a627fd0873645a24f665d491e33385479", "size": 15760, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/robotlocalization.cpp", "max_stars_repo_name": "google/detectorgraph", "max_stars_repo_head_hexsha": "d6c923f8e495a21137312b236e35c36a55d3a755", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 43.0, "max_stars_repo_stars_event_min_datetime": "2018-05-17T07:13:18.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-02T01:54:06.000Z", "max_issues_repo_path": "examples/robotlocalization.cpp", "max_issues_repo_name": "google/detectorgraph", "max_issues_repo_head_hexsha": "d6c923f8e495a21137312b236e35c36a55d3a755", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 4.0, "max_issues_repo_issues_event_min_datetime": "2018-09-20T04:14:11.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-21T08:05:33.000Z", "max_forks_repo_path": "examples/robotlocalization.cpp", "max_forks_repo_name": "google/detectorgraph", "max_forks_repo_head_hexsha": "d6c923f8e495a21137312b236e35c36a55d3a755", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 12.0, "max_forks_repo_forks_event_min_datetime": "2018-05-17T09:03:31.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-13T16:38:15.000Z", "avg_line_length": 38.2524271845, "max_line_length": 146, "alphanum_fraction": 0.6680837563, "num_tokens": 4076, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7025300573952054, "lm_q2_score": 0.7826624738835052, "lm_q1q2_score": 0.5498439126984523}} {"text": "/**\n * @file utils.cpp\n * @brief Usefult utilities\n * @author Parker Lusk \n * @date 12 October 2020\n */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \"clipper/utils.h\"\n\nnamespace clipper {\nnamespace utils {\n\nEigen::VectorXd randvec(size_t n)\n{\n std::random_device rd;\n std::mt19937 gen(rd());\n std::uniform_real_distribution dis(0, 1);\n\n return Eigen::VectorXd::NullaryExpr(n, 1, [&](){ return dis(gen); });\n}\n\n// ----------------------------------------------------------------------------\n\nstd::vector findIndicesOfkLargest(const Eigen::VectorXd& x, int k)\n{\n using T = std::pair; // pair value to be compared and index\n if (k < 1) return {}; // invalid input\n // n.b., the top of this queue is smallest element\n std::priority_queue, std::greater> q;\n for (size_t i=0; i indices(k);\n for (size_t i=0; i\n\ntypedef unsigned long long nombre;\ntypedef std::vector vecteur;\n\nnamespace {\n bool intersection(const std::set &a, const std::set &b) {\n std::set i;\n std::set_intersection(a.begin(), a.end(), b.begin(), b.end(), std::inserter(i, i.begin()));\n return i.empty();\n }\n}\n\nENREGISTRER_PROBLEME(215, \"Crack-free Walls\") {\n // Consider the problem of building a wall out of 2×1 and 3×1 bricks (horizontal×vertical dimensions) such that, for\n // extra strength, the gaps between horizontally-adjacent bricks never line up in consecutive layers, i.e. never\n // form a \"running crack\".\n //\n // For example, the following 9×3 wall is not acceptable due to the running crack shown in red:\n //\n // There are eight ways of forming a crack-free 9×3 wall, written W(9,3) = 8.\n //\n // Calculate W(32,10).\n nombre taille = 32;\n nombre hauteur = 10;\n std::vector> murs;\n for (nombre n = 0; 3 * n <= taille; ++n) {\n if ((taille - 3 * n) % 2 == 0) {\n vecteur mur((taille - 3 * n) / 2, 2);\n mur.insert(mur.end(), n, 3);\n do {\n std::set set_mur;\n nombre l = 0;\n for (auto m: mur) {\n set_mur.insert(l);\n l += m;\n }\n set_mur.erase(set_mur.begin());\n murs.push_back(set_mur);\n } while (std::next_permutation(mur.begin(), mur.end()));\n }\n }\n\n std::map, std::vector>> I;\n for (const auto &m1: murs)\n for (const auto &m2: murs) {\n if (intersection(m1, m2))\n I[m1].push_back(m2);\n }\n\n std::map, nombre> dp;\n for (const auto&[k, v]: I)\n dp[k] = v.size();\n\n for (nombre h = 2; h < hauteur; ++h) {\n std::map, nombre> suite_dp;\n for (const auto&[k, v]: dp) {\n for (const auto &i: I[k])\n suite_dp[i] += v;\n }\n\n std::swap(suite_dp, dp);\n }\n\n nombre resultat = 0;\n for (const auto&[k, v]: dp)\n resultat += v;\n\n return std::to_string(resultat);\n}\n", "meta": {"hexsha": "e5bf861b38149cb21f087301e041db14226e0c9b", "size": 2316, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "problemes/probleme2xx/probleme215.cpp", "max_stars_repo_name": "ZongoForSpeed/ProjectEuler", "max_stars_repo_head_hexsha": "2e2d45f984d48a1da8275886c976f909a0de94ce", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2015-10-13T17:07:21.000Z", "max_stars_repo_stars_event_max_datetime": "2018-05-08T11:50:22.000Z", "max_issues_repo_path": "problemes/probleme2xx/probleme215.cpp", "max_issues_repo_name": "ZongoForSpeed/ProjectEuler", "max_issues_repo_head_hexsha": "2e2d45f984d48a1da8275886c976f909a0de94ce", "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": "problemes/probleme2xx/probleme215.cpp", "max_forks_repo_name": "ZongoForSpeed/ProjectEuler", "max_forks_repo_head_hexsha": "2e2d45f984d48a1da8275886c976f909a0de94ce", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.2972972973, "max_line_length": 120, "alphanum_fraction": 0.5349740933, "num_tokens": 659, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125737597972, "lm_q2_score": 0.7310585727705127, "lm_q1q2_score": 0.5497652388783173}} {"text": "// =============================================================================\n// BoostIncludes.hpp\n//\n// MIT License\n//\n// Copyright (c) 2007-2018 Dairoku Sekiguchi\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n// =============================================================================\n/*!\n\t\\file\t\tBoostIncludes.hpp\n\t\\author\t\tDairoku Sekiguchi\n\t\\version\t1.0\n\t\\date\t\t2008/02/22\n\t\\brief\n*/\n#ifndef __BOOST_INCLUDES_H\n#define __BOOST_INCLUDES_H\n\n\n#pragma warning(disable:4996)\t\t// to suppress std::uninitialized_copy warning\n\n\n// -----------------------------------------------------------------------------\n// \tinclude files\n// -----------------------------------------------------------------------------\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace ublas = boost::numeric::ublas;\nnamespace lapack = boost::numeric::bindings::lapack;\nnamespace traits = boost::numeric::bindings::traits;\n\n\n#endif\t// #ifdef __BOOST_INCLUDES_H\n", "meta": {"hexsha": "5a7c37eeab2e6557037bf63618d1a0a5c99cc399", "size": 2224, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/Applications/Sources/BoostIncludes.hpp", "max_stars_repo_name": "dairoku/Calibra", "max_stars_repo_head_hexsha": "f482cf414c24ddbe103b49c1d3a22a8605bb9b03", "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/Applications/Sources/BoostIncludes.hpp", "max_issues_repo_name": "dairoku/Calibra", "max_issues_repo_head_hexsha": "f482cf414c24ddbe103b49c1d3a22a8605bb9b03", "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/Applications/Sources/BoostIncludes.hpp", "max_forks_repo_name": "dairoku/Calibra", "max_forks_repo_head_hexsha": "f482cf414c24ddbe103b49c1d3a22a8605bb9b03", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-08-10T12:43:26.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-10T12:43:26.000Z", "avg_line_length": 39.7142857143, "max_line_length": 82, "alphanum_fraction": 0.6470323741, "num_tokens": 482, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434978390747, "lm_q2_score": 0.712232184238947, "lm_q1q2_score": 0.5497317803565531}} {"text": "#include \n#include \n#include \n#include \n#include \n\n#ifndef SOLVER_ASSERT\n#define SOLVER_ASSERT(x) eigen_assert(x)\n#endif\n\nnamespace sqp {\n\ntemplate \nSQP::SQP() {\n // TODO(mi): Performance strongly depends on QP solver settings, which is bad.\n qp_solver_.settings().warm_start = true;\n qp_solver_.settings().check_termination = 10;\n qp_solver_.settings().eps_abs = 1e-4;\n qp_solver_.settings().eps_rel = 1e-4;\n qp_solver_.settings().max_iter = 100;\n qp_solver_.settings().adaptive_rho = true;\n qp_solver_.settings().adaptive_rho_interval = 50;\n qp_solver_.settings().alpha = 1.6;\n}\n\ntemplate \nvoid SQP::solve(Problem& prob, const Vector& x0, const Vector& lambda0) {\n x_ = x0;\n lambda_ = lambda0;\n run_solve(prob);\n}\n\ntemplate \nvoid SQP::solve(Problem& prob) {\n const int nx = prob.num_var;\n const int nc = prob.num_constr;\n\n x_.setZero(nx);\n lambda_.setZero(nc);\n run_solve(prob);\n}\n\ntemplate \nvoid SQP::run_solve(Problem& prob) {\n Vector p; // search direction\n Vector p_lambda; // dual search direction\n Scalar alpha; // step size\n\n const int nx = prob.num_var;\n const int nc = prob.num_constr;\n\n p.resize(nx);\n p_lambda.resize(nc);\n\n step_prev_.resize(nx);\n grad_L_.resize(nx);\n delta_grad_L_.resize(nx);\n\n Hess_.resize(nx, nx);\n grad_obj_.resize(nx);\n Jac_constr_.resize(nc, nx);\n constr_.resize(nc);\n l_.resize(nc);\n u_.resize(nc);\n\n info_.qp_solver_iter = 0;\n\n if (settings_.iteration_callback) {\n settings_.iteration_callback(*this);\n }\n\n int& iter = info_.iter;\n for (iter = 1; iter <= settings_.max_iter; iter++) {\n // Solve QP\n solve_qp(prob, p, p_lambda);\n p_lambda -= lambda_;\n\n alpha = line_search(prob, p);\n\n // take step\n x_ = x_ + alpha * p;\n lambda_ = lambda_ + alpha * p_lambda;\n\n // update step info\n step_prev_ = alpha * p;\n primal_step_norm_ = alpha * p.template lpNorm();\n dual_step_norm_ = alpha * p_lambda.template lpNorm();\n\n if (settings_.iteration_callback) {\n settings_.iteration_callback(*this);\n }\n\n if (termination_criteria(x_, prob)) {\n info_.status = SOLVED;\n break;\n }\n }\n if (iter > settings_.max_iter) {\n info_.status = MAX_ITER_EXCEEDED;\n }\n}\n\ntemplate \nbool is_posdef_eigen(Matrix H) {\n Eigen::EigenSolver eigensolver(H);\n for (int i = 0; i < eigensolver.eigenvalues().rows(); i++) {\n double v = eigensolver.eigenvalues()(i).real();\n if (v <= 0) {\n return false;\n }\n }\n return true;\n}\n\ntemplate \nbool is_posdef(Matrix H) {\n Eigen::LLT llt(H);\n if (llt.info() == Eigen::NumericalIssue) {\n return false;\n }\n return true;\n}\n\ntemplate \nbool SQP::termination_criteria(const Vector& x, Problem& prob) {\n if (primal_step_norm_ <= settings_.eps_prim && dual_step_norm_ <= settings_.eps_dual &&\n max_constraint_violation(x, prob) <= settings_.eps_prim) {\n return true;\n }\n return false;\n}\n\ntemplate \ninline bool is_nan(const Eigen::MatrixBase& x) {\n // return ((x.array() == x.array())).all();\n return x.array().isNaN().any();\n}\n\ntemplate \nvoid SQP::solve_qp(Problem& prob, Vector& step, Vector& lambda) {\n /* QP from linearized NLP:\n * minimize 0.5 x'.P.x + q'.x\n * subject to l <= A.x + b <= u\n *\n * with:\n * P Hessian of Lagrangian\n * q objective gradient\n * A,b linearized constraint at current iterate\n * l,u constraint bounds\n *\n * transform to:\n * minimize 0.5 x'.P.x + q'.x\n * subject to l <= A.x <= u\n *\n * Where the constraint bounds l,u set to l=u for equality constraints or\n * set to +/-INFINITY if unbounded.\n */\n prob.objective_linearized(x_, grad_obj_, obj_);\n prob.constraint_linearized(x_, Jac_constr_, constr_, l_, u_);\n\n delta_grad_L_ = -grad_L_;\n grad_L_ = grad_obj_ + Jac_constr_.transpose() * lambda_;\n\n // BFGS update\n if (info_.iter == 1) {\n Hess_.setIdentity();\n } else {\n delta_grad_L_ += grad_L_; // delta_grad_L_ = grad_L_prev - grad_L\n BFGS_update(Hess_, step_prev_, delta_grad_L_);\n }\n\n if (!is_posdef(Hess_)) {\n std::cout << \"Hessian not positive definite\\n\";\n Scalar tau = 1e-3;\n Vector v = Vector(prob.num_var);\n while (!is_posdef(Hess_)) {\n v.setConstant(tau);\n Hess_ += v.asDiagonal();\n tau *= 10;\n }\n }\n if (is_nan(Hess_)) {\n std::cout << \"Hessian is NaN\\n\";\n }\n\n SOLVER_ASSERT(is_posdef(Hess_));\n SOLVER_ASSERT(!is_nan(Hess_));\n\n // Constraints\n // from l <= A.x + b <= u\n // to l-b <= A.x <= u-b\n Vector l = l_ - constr_;\n Vector u = u_ - constr_;\n Matrix& A = Jac_constr_;\n Matrix& P = Hess_;\n Vector& q = grad_obj_;\n\n // solve the QP\n run_solve_qp(P, q, A, l, u, step, lambda);\n\n if (settings_.second_order_correction) {\n second_order_correction(prob, step, lambda);\n }\n\n // TODO:\n // B is not convex then use grad_L as step direction\n // i.e. fallback to steepest descent of Lagrangian\n}\n\ntemplate \nbool SQP::run_solve_qp(const Matrix& P, const Vector& q, const Matrix& A, const Vector& l,\n const Vector& u, Vector& prim, Vector& dual) {\n qp_solver::QuadraticProblem qp_;\n\n qp_.P = &P;\n qp_.q = &q;\n qp_.A = &A;\n qp_.l = &l;\n qp_.u = &u;\n\n qp_solver_.setup(qp_);\n qp_solver_.solve(qp_);\n\n info_.qp_solver_iter += qp_solver_.info().iter;\n\n if (qp_solver_.info().status == qp_solver::NUMERICAL_ISSUES) {\n std::cout << \"QPSolver NUMERICAL_ISSUES\\n\";\n return false;\n }\n // if (qp_solver_.info().status == qp_solver::MAX_ITER_EXCEEDED) {\n // std::cout << \"QPSolver MAX_ITER_EXCEEDED\\n\";\n // return false;\n // }\n\n prim = qp_solver_.primal_solution();\n dual = qp_solver_.dual_solution();\n\n SOLVER_ASSERT(!is_nan(prim));\n SOLVER_ASSERT(!is_nan(dual));\n\n return true;\n}\n\ntemplate \nvoid SQP::second_order_correction(Problem& prob, Vector& p, Vector& lambda) {\n // Scalar mu, constr_l1, phi_l1;\n // constr_l1 = constraint_norm(constr_, l_, u_);\n // mu = (grad_obj_.dot(p) + 0.5 * p.dot(Hess_ * p)) / ((1 - settings_.rho) * constr_l1);\n // phi_l1 = obj_ + mu * constr_l1;\n\n // Scalar obj_step, constr_l1_step, phi_l1_step;\n // Vector x_step = x_ + p;\n // prob.objective(x_step, obj_step);\n // constr_l1_step = constraint_norm(x_step, prob);\n // phi_l1_step = obj_step + mu * constr_l1_step;\n\n // printf(\"phi_l1_step %f phi_l1 %f constr_l1_step %f constr_l1 %f\\n\", phi_l1_step, phi_l1,\n // constr_l1_step, constr_l1);\n // if (phi_l1_step >= phi_l1 && constr_l1_step >= constr_l1) {\n {\n Vector x_step = x_ + p;\n Vector constr_step(constr_.rows());\n prob.constraint(x_step, constr_step, l_, u_);\n\n Matrix& A = Jac_constr_;\n Matrix& P = Hess_;\n Vector& q = grad_obj_;\n\n Vector d = constr_step - A * p;\n Vector l = l_ - d;\n Vector u = u_ - d;\n\n // TODO: only l and u change, possible to update QP solver more efficiently\n run_solve_qp(P, q, A, l, u, p, lambda);\n }\n}\ntemplate \ntypename SQP::Scalar SQP::line_search(Problem& prob, const Vector& p) {\n // Note: using members obj_ and grad_obj_, which are updated in solve_qp().\n\n Scalar mu, phi_l1, Dp_phi_l1;\n const Scalar tau = settings_.tau; // line search step decrease, 0 < tau < settings.tau\n\n Scalar constr_l1 = constraint_norm(constr_, l_, u_);\n\n // get mu from merit function model using hessian of Lagrangian instead\n mu = (grad_obj_.dot(p) + 0.5 * p.dot(Hess_ * p)) / ((1 - settings_.rho) * constr_l1);\n\n phi_l1 = obj_ + mu * constr_l1;\n Dp_phi_l1 = grad_obj_.dot(p) - mu * constr_l1;\n\n Scalar alpha = 1.0;\n int i;\n for (i = 1; i < settings_.line_search_max_iter; i++) {\n Scalar obj_step;\n Vector x_step = x_ + alpha * p;\n prob.objective(x_step, obj_step);\n\n Scalar phi_l1_step = obj_step + mu * constraint_norm(x_step, prob);\n if (phi_l1_step <= phi_l1 + alpha * settings_.eta * Dp_phi_l1) {\n // accept step\n break;\n } else {\n alpha = tau * alpha;\n }\n }\n return alpha;\n}\n\ntemplate \ntypename SQP::Scalar SQP::constraint_norm(const Vector &constr, const Vector &l, const Vector &u) const {\n Scalar c_l1 = DIV_BY_ZERO_REGUL;\n\n // l <= c(x) <= u\n c_l1 += (l - constr).cwiseMax(0.0).sum();\n c_l1 += (constr - u).cwiseMax(0.0).sum();\n\n return c_l1;\n}\n\ntemplate \ntypename SQP::Scalar SQP::constraint_norm(const Vector& x, Problem& prob) {\n // Note: uses members constr_, l_ and u_ as temporary\n prob.constraint(x, constr_, l_, u_);\n\n return constraint_norm(constr_, l_, u_);\n}\n\ntemplate \ntypename SQP::Scalar SQP::max_constraint_violation(const Vector& x, Problem& prob) {\n // Note: uses members constr_, l_ and u_ as temporary\n\n Scalar c_max = 0;\n prob.constraint(x, constr_, l_, u_);\n\n // l <= c(x) <= u\n if (prob.num_constr > 0) {\n c_max = fmax(c_max, (l_ - constr_).maxCoeff());\n c_max = fmax(c_max, (constr_ - u_).maxCoeff());\n }\n\n return c_max;\n}\n\ntemplate class SQP;\ntemplate class SQP;\n\n} // namespace sqp\n", "meta": {"hexsha": "57e0bc11489f3ab79808b051e9cb3a628f3e4dae", "size": 9818, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/sqp.cpp", "max_stars_repo_name": "nuft/sqp_solver", "max_stars_repo_head_hexsha": "7d059a717bb649d63ab27e4d3ec967b42a8b071c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 40.0, "max_stars_repo_stars_event_min_datetime": "2019-10-16T08:05:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-08T04:51:20.000Z", "max_issues_repo_path": "src/sqp.cpp", "max_issues_repo_name": "likping/sqp_solver", "max_issues_repo_head_hexsha": "7d059a717bb649d63ab27e4d3ec967b42a8b071c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2019-12-19T19:12:42.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-16T09:18:04.000Z", "max_forks_repo_path": "src/sqp.cpp", "max_forks_repo_name": "likping/sqp_solver", "max_forks_repo_head_hexsha": "7d059a717bb649d63ab27e4d3ec967b42a8b071c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 10.0, "max_forks_repo_forks_event_min_datetime": "2019-10-18T17:47:05.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-28T07:07:22.000Z", "avg_line_length": 28.1318051576, "max_line_length": 111, "alphanum_fraction": 0.6067427175, "num_tokens": 2800, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.843895106480586, "lm_q2_score": 0.6513548646660543, "lm_q1q2_score": 0.5496751828740075}} {"text": "#define DEBUG 1\n/**\n * File : F.cpp\n * Author : Kazune Takahashi\n * Created : 2020/7/3 5:48:55\n * Powered by Visual Studio Code\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n// ----- boost -----\n#include \n#include \n#include \n// ----- using directives and manipulations -----\nusing namespace std;\nusing boost::rational;\nusing boost::integer::gcd; // for C++14 or for cpp_int\nusing boost::integer::lcm; // for C++14 or for cpp_int\nusing boost::multiprecision::cpp_int;\nusing ll = long long;\nusing ld = long double;\ntemplate \nusing max_heap = priority_queue;\ntemplate \nusing min_heap = priority_queue, greater>;\n// ----- constexpr for Mint and Combination -----\nconstexpr ll MOD{1'000'000'007LL};\n// constexpr ll MOD{998'244'353LL}; // be careful\nconstexpr ll MAX_SIZE{3'000'010LL};\n// constexpr ll MAX_SIZE{30'000'010LL}; // if 10^7 is needed\n// ----- ch_max and ch_min -----\ntemplate \nbool ch_max(T &left, T right)\n{\n if (left < right)\n {\n left = right;\n return true;\n }\n return false;\n}\ntemplate \nbool ch_min(T &left, T right)\n{\n if (left > right)\n {\n left = right;\n return true;\n }\n return false;\n}\n// ----- Mint -----\ntemplate \nclass Mint\n{\npublic:\n ll x;\n Mint() : x{0LL} {}\n Mint(ll x) : x{(x % MOD + MOD) % MOD} {}\n Mint operator-() const { return x ? MOD - x : 0; }\n Mint &operator+=(Mint const &a)\n {\n if ((x += a.x) >= MOD)\n {\n x -= MOD;\n }\n return *this;\n }\n Mint &operator-=(Mint const &a) { return *this += -a; }\n Mint &operator++() { return *this += 1; }\n Mint operator++(int)\n {\n Mint tmp{*this};\n ++*this;\n return tmp;\n }\n Mint &operator--() { return *this -= 1; }\n Mint operator--(int)\n {\n Mint tmp{*this};\n --*this;\n return tmp;\n }\n Mint &operator*=(Mint const &a)\n {\n (x *= a.x) %= MOD;\n return *this;\n }\n Mint &operator/=(Mint const &a)\n {\n Mint b{a};\n return *this *= b.power(MOD - 2);\n }\n Mint operator+(Mint const &a) const { return Mint(*this) += a; }\n Mint operator-(Mint const &a) const { return Mint(*this) -= a; }\n Mint operator*(Mint const &a) const { return Mint(*this) *= a; }\n Mint operator/(Mint const &a) const { return Mint(*this) /= a; }\n bool operator<(Mint const &a) const { return x < a.x; }\n bool operator<=(Mint const &a) const { return x <= a.x; }\n bool operator>(Mint const &a) const { return x > a.x; }\n bool operator>=(Mint const &a) const { return x >= a.x; }\n bool operator==(Mint const &a) const { return x == a.x; }\n bool operator!=(Mint const &a) const { return !(*this == a); }\n Mint power(ll N) const\n {\n if (N == 0)\n {\n return 1;\n }\n else if (N % 2 == 1)\n {\n return *this * power(N - 1);\n }\n else\n {\n Mint half = power(N / 2);\n return half * half;\n }\n }\n};\ntemplate \nMint operator+(ll lhs, Mint const &rhs) { return rhs + lhs; }\ntemplate \nMint operator-(ll lhs, Mint const &rhs) { return -rhs + lhs; }\ntemplate \nMint operator*(ll lhs, Mint const &rhs) { return rhs * lhs; }\ntemplate \nMint operator/(ll lhs, Mint const &rhs) { return Mint{lhs} / rhs; }\ntemplate \nistream &operator>>(istream &stream, Mint &a) { return stream >> a.x; }\ntemplate \nostream &operator<<(ostream &stream, Mint const &a) { return stream << a.x; }\n// ----- Combination -----\ntemplate \nclass Combination\n{\npublic:\n vector> inv, fact, factinv;\n Combination() : inv(MAX_SIZE), fact(MAX_SIZE), factinv(MAX_SIZE)\n {\n inv[1] = 1;\n for (auto i{2LL}; i < MAX_SIZE; i++)\n {\n inv[i] = (-inv[MOD % i]) * (MOD / i);\n }\n fact[0] = factinv[0] = 1;\n for (auto i{1LL}; i < MAX_SIZE; i++)\n {\n fact[i] = Mint(i) * fact[i - 1];\n factinv[i] = inv[i] * factinv[i - 1];\n }\n }\n Mint operator()(int n, int k)\n {\n if (n >= 0 && k >= 0 && n - k >= 0)\n {\n return fact[n] * factinv[k] * factinv[n - k];\n }\n return 0;\n }\n Mint catalan(int x, int y)\n {\n return (*this)(x + y, y) - (*this)(x + y, y - 1);\n }\n};\n// ----- for C++14 -----\nusing mint = Mint;\nusing combination = Combination;\n// ----- for C++17 -----\ntemplate ::value>::type * = nullptr>\nsize_t popcount(T x) { return bitset<64>(x).count(); }\nsize_t popcount(string const &S) { return bitset<200010>{S}.count(); }\n// ----- Infty -----\ntemplate \nconstexpr T Infty() { return numeric_limits::max(); }\ntemplate \nconstexpr T mInfty() { return numeric_limits::min(); }\n// ----- frequently used constexpr -----\n// constexpr double epsilon{1e-10};\n// constexpr ll infty{1'000'000'000'000'010LL}; // or\n// constexpr int infty{1'000'000'010};\n// ----- Yes() and No() -----\nvoid Yes()\n{\n cout << \"Yes\" << endl;\n exit(0);\n}\nvoid No()\n{\n cout << \"INF\" << endl;\n exit(0);\n}\n\n// ----- 2D, 3D, 4D vectors -----\n// Referring to ymatsux-san's source code: https://atcoder.jp/contests/abc138/submissions/7018300\n\ntemplate \nvector> Make2DVector(size_t d0, size_t d1, T v = T{})\n{\n return vector>(d0, vector(d1, v));\n}\n\ntemplate \nvector>> Make3DVector(size_t d0, size_t d1, size_t d2, T v = T{})\n{\n return vector>>(d0, Make2DVector(d1, d2, v));\n}\n\ntemplate \nvector>>> Make4DVector(size_t d0, size_t d1, size_t d2, size_t d3, T v = T{})\n{\n return vector>>>(d0, Make3DVector(d1, d2, d3, v));\n}\n\n// ----- Compressor -----\n// referring to ymatsux-san's code:\n// https://atcoder.jp/contests/abc168/submissions/13337691\n\ntemplate \nclass Compressor\n{\n vector raw;\n map index;\n\npublic:\n Compressor() {}\n\n template \n Compressor(Container const &V) { append(V); }\n\n template \n Compressor(Iter first, Iter last) { append(first, last); }\n\n template \n void append(Container const &V) { append(V.begin(), V.end()); }\n\n template \n void append(Iter first, Iter last)\n {\n set S(first, last);\n raw = vector(S.begin(), S.end());\n sort(raw.begin(), raw.end());\n for (auto i = size_t{0}; i < raw.size(); ++i)\n {\n index[raw[i]] = i;\n }\n }\n\n T to_raw(int i) { return raw[i]; }\n int to_index(T t) { return index[t]; }\n size_t size() { return raw.size(); }\n};\n\nconstexpr int dx[4] = {1, 0, -1, 0};\nconstexpr int dy[4] = {0, 1, 0, -1};\n\n// ----- Solve -----\n\nstruct Point\n{\n int x, y;\n};\n\nostream &operator<<(ostream &os, vector> v)\n{\n for (auto i{size_t{0}}; i < v.size(); ++i)\n {\n for (auto j{size_t{0}}; j < v[i].size(); ++j)\n {\n os << (v[i][j] ? '#' : '.');\n }\n os << endl;\n }\n return os;\n}\n\nclass Solve\n{\n int n, m;\n vector a, b, c, d, e, f;\n Compressor x, y;\n vector> visited;\n vector>> dir;\n int size_x, size_y;\n\npublic:\n Solve(int n, int m) : n{n}, m{m}, a(n), b(n), c(n), d(m), e(m), f(m)\n {\n for (auto i{0}; i < n; ++i)\n {\n cin >> a[i] >> b[i] >> c[i];\n }\n for (auto i{0}; i < m; ++i)\n {\n cin >> d[i] >> e[i] >> f[i];\n }\n vector xs{mInfty(), 0LL, Infty()}, ys{mInfty(), 0LL, Infty()};\n copy(a.begin(), a.end(), back_inserter(xs));\n copy(b.begin(), b.end(), back_inserter(xs));\n copy(c.begin(), c.end(), back_inserter(ys));\n copy(d.begin(), d.end(), back_inserter(xs));\n copy(e.begin(), e.end(), back_inserter(ys));\n copy(f.begin(), f.end(), back_inserter(ys));\n x.append(xs);\n y.append(ys);\n size_x = x.size() - 1;\n size_y = y.size() - 1;\n visited = Make2DVector(size_x, size_y, false);\n dir = Make3DVector(size_x, size_y, 4, true);\n set_segment();\n }\n\n void flush()\n {\n bfs();\n#if DEBUG == 1\n cerr << visited;\n#endif\n cout << answer() << endl;\n }\n\nprivate:\n void bfs()\n {\n queue q;\n {\n int i{x.to_index(0)};\n int j{y.to_index(0)};\n q.push(Point{i, j});\n }\n while (!q.empty())\n {\n auto p{q.front()};\n q.pop();\n for (auto k{0}; k < 4; ++k)\n {\n if (!dir[p.x][p.y][k])\n {\n continue;\n }\n auto nx{p.x + dx[k]};\n auto ny{p.y + dy[k]};\n if (!valid(nx, ny))\n {\n continue;\n }\n if (visited[nx][ny])\n {\n continue;\n }\n visited[nx][ny] = true;\n q.push(Point{nx, ny});\n }\n }\n }\n\n void set_segment()\n {\n for (auto i{0}; i < n; ++i)\n {\n set_segment_x(a[i], b[i], c[i]);\n }\n for (auto i{0}; i < m; ++i)\n {\n set_segment_y(d[i], e[i], f[i]);\n }\n }\n\n void set_segment_x(ll xa, ll xb, ll yc)\n {\n int ia = x.to_index(xa);\n int ib = x.to_index(xb);\n int jc = y.to_index(yc);\n for (auto i{ia}; i < ib; ++i)\n {\n dir.at(i).at(jc - 1).at(1) = false;\n dir.at(i).at(jc).at(3) = false;\n }\n }\n\n void set_segment_y(ll xd, ll ye, ll yf)\n {\n int id = x.to_index(xd);\n int je = y.to_index(ye);\n int jf = y.to_index(yf);\n for (auto j{je}; j < jf; ++j)\n {\n dir.at(id - 1).at(j).at(0) = false;\n dir.at(id).at(j).at(2) = false;\n }\n }\n\n bool valid(int i, int j)\n {\n return 0 <= i && i < size_x && 0 <= j && j < size_y;\n }\n\n ll area(int i, int j)\n {\n ll width{x.to_raw(i + 1) - x.to_raw(i)};\n ll height{y.to_raw(j + 1) - y.to_raw(j)};\n return height * width;\n }\n\n ll answer()\n {\n for (auto i{0}; i < size_x; ++i)\n {\n if (visited[i][0] || visited[i][size_y - 1])\n {\n No();\n }\n }\n for (auto j{0}; j < size_y; ++j)\n {\n if (visited[0][j] || visited[size_x - 1][j])\n {\n No();\n }\n }\n ll ans{0};\n for (auto i{1}; i < size_x - 1; ++i)\n {\n for (auto j{1}; j < size_y - 1; ++j)\n {\n if (visited[i][j])\n {\n ans += area(i, j);\n }\n }\n }\n return ans;\n }\n};\n\n// ----- main() -----\n\nint main()\n{\n int n, m;\n cin >> n >> m;\n Solve solve(n, m);\n solve.flush();\n}\n", "meta": {"hexsha": "87552983fe1f6483c33683fd419fe97737411aac", "size": 10721, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "2020/0703_ABC168/F.cpp", "max_stars_repo_name": "kazunetakahashi/atcoder", "max_stars_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2019-03-24T14:06:29.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-17T21:16:36.000Z", "max_issues_repo_path": "2020/0703_ABC168/F.cpp", "max_issues_repo_name": "kazunetakahashi/atcoder", "max_issues_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "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": "2020/0703_ABC168/F.cpp", "max_forks_repo_name": "kazunetakahashi/atcoder", "max_forks_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-07-22T17:27:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-22T17:27:09.000Z", "avg_line_length": 22.9081196581, "max_line_length": 101, "alphanum_fraction": 0.5485495756, "num_tokens": 3461, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8438950986284991, "lm_q2_score": 0.6513548646660543, "lm_q1q2_score": 0.5496751777595126}} {"text": "#include \"pso.h\"\n\n#include \n\n\n\ntemplate <\n typename Scalar, \n typename DerivedX,\n typename DerivedLB, \n typename DerivedUB>\nIGL_INLINE Scalar igl::pso(\n const std::function< Scalar (DerivedX &) > f,\n const Eigen::MatrixBase & LB,\n const Eigen::MatrixBase & UB,\n const int max_iters,\n const int population,\n DerivedX & X)\n{\n const Eigen::Array P =\n Eigen::Array::Zero(LB.size(),1);\n return igl::pso(f,LB,UB,P,max_iters,population,X);\n}\n\ntemplate <\n typename Scalar, \n typename DerivedX,\n typename DerivedLB, \n typename DerivedUB,\n typename DerivedP>\nIGL_INLINE Scalar igl::pso(\n const std::function< Scalar (DerivedX &) > f,\n const Eigen::MatrixBase & LB,\n const Eigen::MatrixBase & UB,\n const Eigen::DenseBase & P,\n const int max_iters,\n const int population,\n DerivedX & X)\n{\n const int dim = LB.size();\n assert(UB.size() == dim && \"UB should match LB size\");\n assert(P.size() == dim && \"P should match LB size\");\n typedef std::vector > VectorList;\n VectorList position(population);\n VectorList best_position(population);\n VectorList velocity(population);\n Eigen::Matrix best_f(population);\n // https://en.wikipedia.org/wiki/Particle_swarm_optimization#Algorithm\n //\n // g → X\n // p_i → best[i]\n // v_i → velocity[i]\n // x_i → position[i]\n Scalar min_f = std::numeric_limits::max();\n for(int p=0;p UB(d))\n {\n position[p](d) = UB(d);\n if(velocity[p](d) > 0.0) velocity[p](d) *= -1.0;\n }\n#else\n//#warning \"trying no bounds on periodic\"\n// // TODO: I'm not sure this is the right thing to do/enough. The\n// // velocities could be weird. Suppose the current \"best\" value is ε and\n// // the value is -ε and the \"periodic bounds\" [0,2π]. Moding will send\n// // the value to 2π-ε but the \"velocity\" term will now be huge pointing\n// // all the way from 2π-ε to ε.\n// //\n// // Q: Would it be enough to try (all combinations) of ±(UB-LB) before\n// // computing velocities to \"best\"s? In the example above, instead of\n// //\n// // v += best - p = ε - (2π-ε) = -2π+2ε\n// //\n// // you'd use\n// //\n// // v += / argmin |b - p| \\ - p = (ε+2π)-(2π-ε) = 2ε\n// // | |\n// // \\ b∈{best, best+2π, best-2π} /\n// //\n// // Though, for multivariate b,p,v this would seem to explode\n// // combinatorially.\n// //\n// // Maybe periodic things just shouldn't be bounded and we hope that the\n// // forces toward the current minima \"regularize\" them away from insane\n// // values.\n// if(P(d))\n// {\n// position[p](d) = std::fmod(position[p](d)-LB(d),UB(d)-LB(d))+LB(d);\n// }else\n// {\n// position[p](d) = std::max(LB(d),std::min(UB(d),position[p](d)));\n// }\n position[p](d) = std::max(LB(d),std::min(UB(d),position[p](d)));\n#endif\n }\n const Scalar fp = f(position[p]);\n if(fp=max_iters)\n {\n break;\n }\n }\n return min_f;\n}\n\n#ifdef IGL_STATIC_LIBRARY\ntemplate float igl::pso, Eigen::Matrix, Eigen::Matrix >(std::function&)>, Eigen::MatrixBase > const&, Eigen::MatrixBase > const&, int, int, Eigen::Matrix&);\n#endif\n", "meta": {"hexsha": "8b05ee642afa05ed983337f8477bd3376c0d4949", "size": 5490, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "External/libigl-2.1.0/include/igl/pso.cpp", "max_stars_repo_name": "RokKos/eol-cloth", "max_stars_repo_head_hexsha": "b9c6f55f25ba17f33532ea5eefa41fedd29c5206", "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": "External/libigl-2.1.0/include/igl/pso.cpp", "max_issues_repo_name": "RokKos/eol-cloth", "max_issues_repo_head_hexsha": "b9c6f55f25ba17f33532ea5eefa41fedd29c5206", "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/libigl-2.1.0/include/igl/pso.cpp", "max_forks_repo_name": "RokKos/eol-cloth", "max_forks_repo_head_hexsha": "b9c6f55f25ba17f33532ea5eefa41fedd29c5206", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.3714285714, "max_line_length": 394, "alphanum_fraction": 0.5468123862, "num_tokens": 1695, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8438951064805861, "lm_q2_score": 0.6513548511303338, "lm_q1q2_score": 0.5496751714512793}} {"text": "/* The Computer Language Benchmarks Game\n * http://benchmarksgame.alioth.debian.org/\n *\n * contributed by Marcin Zalewski & Jeremiah Willcock\n */\n\n\n#include \n#include \n#include \n#include \n#include \n\nusing namespace boost;\n\nclass Digits {\nprivate:\n unsigned int j;\n tuple nad;\n mpz_class tmp1, tmp2;\n\npublic:\n Digits() { j = 0; get<0>(nad) = 1; get<1>(nad) = 0; get<2>(nad) = 1; }\n\n inline char operator()() {\n ++j;\n next_term();\n\n if(get<0>(nad) > get<1>(nad)) return (*this)();\n\n mpz_mul_2exp(tmp1.get_mpz_t(), get<0>(nad).get_mpz_t(), 1);\n tmp1 += get<0>(nad);\n tmp1 += get<1>(nad);\n\n mpz_fdiv_qr(tmp1.get_mpz_t(), tmp2.get_mpz_t(), tmp1.get_mpz_t(), get<2>(nad).get_mpz_t());\n\n tmp2 += get<0>(nad);\n\n if(tmp2 >= get<2>(nad)) {\n return (*this)();\n } else {\n unsigned int d = tmp1.get_ui();\n eliminate_digit(d);\n return d + '0';\n }\n }\n\nprivate:\n\n inline void next_term() {\n unsigned int y = j * 2 + 1;\n mpz_mul_2exp(tmp1.get_mpz_t(), get<0>(nad).get_mpz_t(), 1);\n get<1>(nad) += tmp1;\n get<1>(nad) *= y;\n get<0>(nad) *= j;\n get<2>(nad) *= y;\n }\n\n inline void eliminate_digit(unsigned int d) {\n mpz_submul_ui(get<1>(nad).get_mpz_t(), get<2>(nad).get_mpz_t(), d);\n get<0>(nad) *= 10;\n get<1>(nad) *= 10;\n }\n\n};\n\nvoid pi(unsigned int n) {\n unsigned int i = 0;\n Digits digits;\n\n while((i += 10) <= n) {\n for(int count = 0; count < 10; ++count) {\n std::cout << digits();\n }\n std::cout << \"\\t:\" << i << '\\n';\n }\n \n i -= 10;\n if(n > i) {\n for(int count = 0; count < n - i; ++count) {\n std::cout << digits();\n }\n i += 10;\n for(int count = 0; count < i - n; ++count) {\n std::cout << ' ';\n }\n std::cout << \"\\t:\" << n << '\\n';\n }\n}\n\nint main(int argc, char** argv) {\n std::cout.sync_with_stdio(false);\n unsigned int count = (argc >= 2 ? boost::lexical_cast(argv[1]) : 10000);\n pi(count);\n return 0;\n}\n", "meta": {"hexsha": "c0434f43f173c003eda423db46406727fa384b94", "size": 2059, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "progs/pidigits/pidigits.cpp", "max_stars_repo_name": "qznc/d-shootout", "max_stars_repo_head_hexsha": "40164a864f1d0a08140cde63f7bd2d36010d5332", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2015-09-10T15:06:51.000Z", "max_stars_repo_stars_event_max_datetime": "2015-09-10T15:06:51.000Z", "max_issues_repo_path": "progs/pidigits/pidigits.cpp", "max_issues_repo_name": "qznc/d-shootout", "max_issues_repo_head_hexsha": "40164a864f1d0a08140cde63f7bd2d36010d5332", "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": "progs/pidigits/pidigits.cpp", "max_forks_repo_name": "qznc/d-shootout", "max_forks_repo_head_hexsha": "40164a864f1d0a08140cde63f7bd2d36010d5332", "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": 21.2268041237, "max_line_length": 95, "alphanum_fraction": 0.5536668286, "num_tokens": 703, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8438950868503681, "lm_q2_score": 0.6513548646660542, "lm_q1q2_score": 0.5496751700877696}} {"text": "// Copyright (c) 2019, Torsten Sattler\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions are met:\n//\n// * Redistributions of source code must retain the above copyright\n// notice, this list of conditions and the following disclaimer.\n//\n// * Redistributions in binary form must reproduce the above copyright\n// notice, this list of conditions and the following disclaimer in the\n// documentation and/or other materials provided with the distribution.\n//\n// * Neither the name of the copyright holder nor the\n// names of its contributors may be used to endorse or promote products\n// derived from this software without specific prior written permission.\n//\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n// ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY\n// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\n// author: Torsten Sattler, torsten.sattler.de@googlemail.com\n\n#include \n\n#include \n#include \n#include \n\n#include \"calibrated_absolute_pose_estimator.h\"\n\nnamespace ransac_lib {\n\nnamespace calibrated_absolute_pose {\n\nstruct NormalizedReprojectionError {\n NormalizedReprojectionError(double x, double y, double X, double Y, double Z,\n double fx, double fy)\n : point2D_x(x),\n point2D_y(y),\n point3D_X(X),\n point3D_Y(Y),\n point3D_Z(Z),\n f_x(fx),\n f_y(fy) {}\n\n template \n bool operator()(const T* const camera, T* residuals) const {\n // The last three entries are the camera position.\n T p[3];\n p[0] = point3D_X - camera[3];\n p[1] = point3D_Y - camera[4];\n p[2] = point3D_Z - camera[5];\n\n // The first three entries correspond to the rotation matrix stored in an\n // angle-axis representation.\n T p_rot[3];\n ceres::AngleAxisRotatePoint(camera, p, p_rot);\n\n T x_proj = static_cast(f_x) * p_rot[0] / p_rot[2];\n T y_proj = static_cast(f_y) * p_rot[1] / p_rot[2];\n\n residuals[0] = static_cast(point2D_x) - x_proj;\n residuals[1] = static_cast(point2D_y) - y_proj;\n\n return true;\n }\n\n // Factory function\n static ceres::CostFunction* CreateCost(const double x, const double y,\n const double X, const double Y,\n const double Z, const double fx,\n const double fy) {\n return (new ceres::AutoDiffCostFunction(\n new NormalizedReprojectionError(x, y, X, Y, Z, fx, fy)));\n }\n\n // Assumes that the measurement is centered around the principal point.\n // This camera model does not take any radial distortion into account. If\n // radial distortion is present, one should undistort the measurements first.\n double point2D_x;\n double point2D_y;\n // The 3D point position is fixed as we are only interested in refining the\n // camera parameters.\n double point3D_X;\n double point3D_Y;\n double point3D_Z;\n double f_x;\n double f_y;\n};\n\nCalibratedAbsolutePoseEstimator::CalibratedAbsolutePoseEstimator(\n const double f_x, const double f_y, const double squared_inlier_threshold,\n const Points2D& points2D, const ViewingRays& rays, const Points3D& points3D)\n : focal_x_(f_x),\n focal_y_(f_y),\n squared_inlier_threshold_(squared_inlier_threshold),\n points2D_(points2D),\n points3D_(points3D),\n adapter_(rays, points3D) {\n num_data_ = static_cast(points2D_.size());\n}\n\nint CalibratedAbsolutePoseEstimator::MinimalSolver(\n const std::vector& sample, CameraPoses* poses) const {\n poses->clear();\n CameraPoses p3p_poses = opengv::absolute_pose::p3p_kneip(adapter_, sample);\n if (p3p_poses.empty()) return 0;\n for (const CameraPose& pose : p3p_poses) {\n CameraPose P = pose;\n // OpenGV returns the transformation from the camera to the world coordinate\n // system. We store the rotation from the world to the local coordinate\n // system instead.\n P.topLeftCorner<3, 3>() = pose.topLeftCorner<3, 3>().transpose();\n const double kError = EvaluateModelOnPoint(P, sample[3]);\n if (kError < squared_inlier_threshold_) {\n // // Refine using all four points.\n // LeastSquares(sample, &P);\n poses->push_back(P);\n // At most one pose should be correct.\n break;\n }\n }\n\n return static_cast(poses->size());\n}\n\n// Returns 0 if no model could be estimated and 1 otherwise.\n// Implemented by a simple linear least squares solver.\nint CalibratedAbsolutePoseEstimator::NonMinimalSolver(\n const std::vector& sample, CameraPose* pose) const {\n // Alternative: Run minimal solver and polish.\n CameraPoses poses;\n if (MinimalSolver(sample, &poses) == 1) {\n *pose = poses[0];\n LeastSquares(sample, pose);\n return 1;\n } else {\n return 0;\n }\n \n// CameraPose P = opengv::absolute_pose::epnp(adapter_, sample);\n// // OpenGV returns the transformation from the camera to the world coordinate\n// // system. We store the rotation from the world to the local coordinate\n// // system instead.\n// *pose = P;\n// pose->topLeftCorner<3, 3>() = P.topLeftCorner<3, 3>().transpose();\n// return 1;\n}\n\n// Evaluates the pose on the i-th data point.\ndouble CalibratedAbsolutePoseEstimator::EvaluateModelOnPoint(\n const CameraPose& pose, int i) const {\n Eigen::Vector3d p_c =\n pose.topLeftCorner<3, 3>() * (points3D_[i] - pose.col(3));\n\n // Check whether point projects behind the camera.\n if (p_c[2] < 0.0) return std::numeric_limits::max();\n\n Eigen::Vector2d p_2d = p_c.head<2>() / p_c[2];\n p_2d[0] *= focal_x_;\n p_2d[1] *= focal_y_;\n\n return (p_2d - points2D_[i]).squaredNorm();\n}\n\n// Reference implementation using Ceres for refinement.\nvoid CalibratedAbsolutePoseEstimator::LeastSquares(\n const std::vector& sample, CameraPose* pose) const {\n Eigen::AngleAxisd aax(pose->topLeftCorner<3, 3>());\n Eigen::Vector3d aax_vec = aax.axis() * aax.angle();\n double camera[6];\n camera[0] = aax_vec[0];\n camera[1] = aax_vec[1];\n camera[2] = aax_vec[2];\n camera[3] = pose->col(3)[0];\n camera[4] = pose->col(3)[1];\n camera[5] = pose->col(3)[2];\n\n ceres::Problem refinement_problem;\n// ceres::LossFunction* cauchy_loss = new ceres::CauchyLoss(1.0);\n const int kSampleSize = static_cast(sample.size());\n for (int i = 0; i < kSampleSize; ++i) {\n const int kIdx = sample[i];\n const Eigen::Vector2d& p_img = points2D_[kIdx];\n const Eigen::Vector3d& p_3D = points3D_[kIdx];\n ceres::CostFunction* cost_function =\n NormalizedReprojectionError::CreateCost(\n p_img[0], p_img[1], p_3D[0], p_3D[1], p_3D[2], focal_x_, focal_y_);\n// double error_i = std::sqrt(EvaluateModelOnPoint(*pose, sample[i]));\n// error_i = std::max(0.00001, error_i);\n refinement_problem.AddResidualBlock(cost_function, nullptr, camera);\n// refinement_problem.AddResidualBlock(cost_function, cauchy_loss, camera);\n// refinement_problem.AddResidualBlock(cost_function,\n// new ceres::ScaledLoss(nullptr,\n// 1.0 / error_i,\n// ceres::DO_NOT_TAKE_OWNERSHIP),\n// camera);\n }\n\n ceres::Solver::Options options;\n options.linear_solver_type = ceres::DENSE_QR;\n options.minimizer_progress_to_stdout = false;\n // options.function_tolerance = 0.000001;\n ceres::Solver::Summary summary;\n ceres::Solve(options, &refinement_problem, &summary);\n\n // std::cout << summary.BriefReport() << std::endl;\n// delete cauchy_loss;\n// cauchy_loss = nullptr;\n\n if (summary.IsSolutionUsable()) {\n Eigen::Vector3d axis(camera[0], camera[1], camera[2]);\n double angle = axis.norm();\n axis.normalize();\n aax.axis() = axis;\n aax.angle() = angle;\n\n pose->topLeftCorner<3, 3>() = aax.toRotationMatrix();\n pose->col(3) = Eigen::Vector3d(camera[3], camera[4], camera[5]);\n }\n}\n\n//// Reference implementation using OpenGV's non-linear refinement.\n// void CalibratedAbsolutePoseEstimator::LeastSquares(\n// const std::vector& sample, CameraPose* pose) const {\n// // OpenGV returns the transformation from the camera to the world coordinate\n// // system. We store the rotation from the world to the local coordinate\n// // system instead.\n// Eigen::Matrix3d R = pose->topLeftCorner<3, 3>().transpose();\n// Eigen::Vector3d c = pose->col(3);\n// // At the moment, we need to copy data as we need to add the current pose\n// // estimate to the adapter, which would break the requirement that this\n// // function is constant.\n// const int kSampleSize = static_cast(sample.size());\n// opengv::bearingVectors_t bearing_vectors(kSampleSize);\n// opengv::points_t points(kSampleSize);\n// for (int i = 0; i < kSampleSize; ++i) {\n// const int kIdx = sample[i];\n// bearing_vectors[i] = adapter_.getBearingVector(kIdx);\n// points[i] = adapter_.getPoint(kIdx);\n// }\n//\n// opengv::absolute_pose::CentralAbsoluteAdapter lsq_adapter(bearing_vectors,\n// points, c, R);\n//\n// CameraPose P = opengv::absolute_pose::optimize_nonlinear(lsq_adapter);\n// *pose = P;\n// pose->topLeftCorner<3, 3>() = P.topLeftCorner<3, 3>().transpose();\n//}\n\nvoid CalibratedAbsolutePoseEstimator::PixelsToViewingRays(\n const double focal_x, const double focal_y, const Points2D& points2D,\n ViewingRays* rays) {\n const int kNumData = static_cast(points2D.size());\n\n // Creates the bearing vectors and points for the OpenGV adapter.\n rays->resize(kNumData);\n for (int i = 0; i < kNumData; ++i) {\n (*rays)[i] = points2D[i].homogeneous();\n (*rays)[i][0] /= focal_x;\n (*rays)[i][1] /= focal_y;\n (*rays)[i].normalize();\n }\n}\n} // namespace calibrated_absolute_pose\n\n} // namespace ransac_lib\n", "meta": {"hexsha": "4bd3a382d8a76dc274b1a024c987c9dd1f995971", "size": 10672, "ext": "cc", "lang": "C++", "max_stars_repo_path": "examples/calibrated_absolute_pose_estimator.cc", "max_stars_repo_name": "yocabon/RansacLib", "max_stars_repo_head_hexsha": "4669343cb682efdb0317d4608ea50c808558379d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 216.0, "max_stars_repo_stars_event_min_datetime": "2019-08-17T14:22:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T06:19:08.000Z", "max_issues_repo_path": "examples/calibrated_absolute_pose_estimator.cc", "max_issues_repo_name": "NamDinhRobotics/RansacLib", "max_issues_repo_head_hexsha": "b66c74b3b3ca3974651dd6343eeecb8ee1d04e56", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 11.0, "max_issues_repo_issues_event_min_datetime": "2019-09-27T07:26:19.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-04T16:41:41.000Z", "max_forks_repo_path": "examples/calibrated_absolute_pose_estimator.cc", "max_forks_repo_name": "NamDinhRobotics/RansacLib", "max_forks_repo_head_hexsha": "b66c74b3b3ca3974651dd6343eeecb8ee1d04e56", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 32.0, "max_forks_repo_forks_event_min_datetime": "2019-08-18T05:52:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T07:01:54.000Z", "avg_line_length": 38.6666666667, "max_line_length": 95, "alphanum_fraction": 0.6684782609, "num_tokens": 2828, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8438950907764119, "lm_q2_score": 0.6513548511303336, "lm_q1q2_score": 0.5496751612222892}} {"text": "#include \n\n#include \n\n#include \n\n#include \n\nnamespace rubbishrsa {\n private_key private_key::from_factors(const bigint& p, const bigint& q, bigint e) {\n // We can now start filling in our result\n private_key ret;\n ret.n = p * q;\n // This is automatically done\n ret.e = e;\n\n auto lambda_n = carmichael_semiprime(p, q);\n ret.d = modinv(ret.e, lambda_n); // $d \\equiv e^{-1} \\pmod{\\lambda(n)}$\n\n\n return ret;\n }\n\n private_key private_key::generate(uint_fast16_t bits) {\n // Apparently we should differ in lengths by a few digits\n // this will differ in length by log10(2^8) = ~3 digits\n auto p = generate_prime(bits / 2 + 4);\n auto q = generate_prime(bits / 2 - 3);\n\n RUBBISHRSA_LOG_INFO(std::cerr << \"(p, q) = (\" << p.str() << \", \" << q.str() << ')' << std::endl);\n\n // Now we have a good p and q, we can pass it along\n return private_key::from_factors(p, q);\n }\n\n void public_key::serialise(std::ostream& os) const {\n boost::property_tree::ptree data;\n data.put(\"e\", e);\n data.put(\"n\", n);\n boost::property_tree::write_json(os, data, false);\n }\n\n void private_key::serialise(std::ostream& os) const {\n boost::property_tree::ptree data;\n data.put(\"e\", e);\n data.put(\"d\", d);\n data.put(\"n\", n);\n boost::property_tree::write_json(os, data, false);\n }\n\n public_key public_key::deserialise(std::istream& is) {\n boost::property_tree::ptree data;\n boost::property_tree::read_json(is, data);\n public_key ret;\n\n ret.e = data.get(\"e\");\n ret.n = data.get(\"n\");\n\n return ret;\n }\n\n private_key private_key::deserialise(std::istream& is) {\n boost::property_tree::ptree data;\n boost::property_tree::read_json(is, data);\n private_key ret;\n\n ret.e = data.get(\"e\");\n ret.d = data.get(\"d\");\n ret.n = data.get(\"n\");\n\n return ret;\n }\n}\n", "meta": {"hexsha": "ce2e0a1d3429bfec9df7d5b111577e81084fd905", "size": 1994, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/keys.cpp", "max_stars_repo_name": "Cyclic3/rubbishrsa", "max_stars_repo_head_hexsha": "d1755b6ed464c84fa7a44e8665631f28766ee7fb", "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/keys.cpp", "max_issues_repo_name": "Cyclic3/rubbishrsa", "max_issues_repo_head_hexsha": "d1755b6ed464c84fa7a44e8665631f28766ee7fb", "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/keys.cpp", "max_forks_repo_name": "Cyclic3/rubbishrsa", "max_forks_repo_head_hexsha": "d1755b6ed464c84fa7a44e8665631f28766ee7fb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.9459459459, "max_line_length": 101, "alphanum_fraction": 0.6339017051, "num_tokens": 574, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577681049901037, "lm_q2_score": 0.640635868562172, "lm_q1q2_score": 0.5495170149652634}} {"text": "#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\n#include \"tbb/tick_count.h\"\n#include \"tbb/parallel_for.h\"\n#include \"tbb/task_scheduler_init.h\"\n\n#include \n#include \n\n#include \"green_cage_deformer.h\"\n\n\nconst MTypeId GreenCageDeformer::s_node_id(0xBBBB9255);\nconst MString GreenCageDeformer::s_node_name(\"green_cage_deformer\");\nMObject GreenCageDeformer::s_cage_mesh;\n\n\nnamespace {\n\tconst Eigen::Vector3d NULL_VECTOR(0.0, 0.0, 0);\n\tconstexpr auto TOLERANCE = 1e-6;\n}\n\n\nnamespace MathConstants {\n\tconstexpr auto PI = 3.14159265358979323846;\n\tconstexpr auto ONE_OVER_FOUR_PI = 0.07957747154594767;\n\tconstexpr auto SQRT8 = 2.828427124746190097603;\n};\n\n\nconst double GCTriInt(const Eigen::Vector3d& p, const Eigen::Vector3d& v1, const Eigen::Vector3d& v2)\n{\n\tconst auto v2_v1 = v2 - v1;\n\tconst auto p_v1 = p - v1;\n\tconst auto v1_p = v1 - p;\n\tconst auto v2_p = v2 - p;\n\n\tconst auto alpha = std::acos(std::min(std::max(((v2_v1).dot((p_v1))) / ((v2_v1).norm() * (p_v1).norm()), -1.0), 1.0));\n\tif (abs(alpha - MathConstants::PI) < TOLERANCE || abs(alpha) < TOLERANCE) {\n\t\treturn 0.0;\n\t}\n\n\tconst auto beta = std::acos(std::min(std::max((((v1_p).dot((v2_p)))) / ((v1_p).norm() * (v2_p).norm()), -1.0), 1.0));\n\tconst auto lambda = p_v1.squaredNorm() * std::sin(alpha) * std::sin(alpha);\n\tconst auto c = p.squaredNorm();\n\n\tconst auto sqrt_c = sqrt(c);\n\tconst auto sqrt_lambda = sqrt(lambda);\n\n\tconst std::array theta{ MathConstants::PI - alpha, MathConstants::PI - alpha - beta };\n\tstd::array I;\n\n\tfor (size_t i = 0; i < 2; ++i)\n\t{\n\t\tconst auto S = std::sin(theta[i]);\n\t\tconst auto C = std::cos(theta[i]);\n\t\tconst auto sign = S < 0 ? -1.0 : 1.0;\n\n\t\tconst auto SS = S*S;\n\t\tconst auto half_sign = (-sign * 0.5);\n\t\tconst auto tan_part = (2 * sqrt_c * std::atan2((sqrt_c * C), sqrt(lambda + (SS * c))));\n\t\tconst auto log_part = log(((2 * sqrt_lambda * SS) / std::pow(1.0 - C, 2)) * (1.0 - ((2 * c * C) / ((c*(1 + C) + lambda + sqrt((lambda * lambda) + (lambda * c * SS)))))));\n\n\t\tI[i] = half_sign * (tan_part + (sqrt_lambda * log_part));\n\t}\n\n\treturn -MathConstants::ONE_OVER_FOUR_PI * abs(I[0] - I[1] - sqrt_c * beta);\n}\n\n\nvoid GCDeformData::setup_cage() {\n\tMStatus stat;\n\tMFnMesh fn_mesh(m_cage_object);\n\tMIntArray m_tri_counts;\n\tfn_mesh.getTriangles(m_tri_counts, m_tri_verts);\n\n\tm_nr_of_tris = 0;\n\tfor (unsigned int i = 0; i < m_tri_counts.length(); ++i)\n\t{\n\t\tm_nr_of_tris += m_tri_counts[i];\n\t}\n\n\n\tMPointArray cage_points;\n\tfn_mesh.getPoints(cage_points);\n\tm_nr_of_verts = fn_mesh.numVertices();\n\tm_vertices.resize(m_nr_of_verts);\n\n\tfor (unsigned int i = 0; i < cage_points.length(); ++i) {\n\t\tconst auto point = cage_points[i];\n\t\tm_vertices[i] = Eigen::Vector3d(point.x, point.y, point.z);\n\t}\n\n\tm_scale_factor.resize(m_nr_of_tris);\n\tm_tri_areas.resize(m_nr_of_tris);\n\tm_tri_normals.resize(m_nr_of_tris);\n\tm_tri_points.resize(m_nr_of_tris);\n\tm_tri_edges.resize(m_nr_of_tris);\n\n\tfor (unsigned int j = 0; j < m_nr_of_tris; ++j) {\n\t\tconst auto tri_idx = j * 3;\n\t\tconst auto v0 = m_vertices[m_tri_verts[tri_idx + 0]];\n\t\tconst auto v1 = m_vertices[m_tri_verts[tri_idx + 1]];\n\t\tconst auto v2 = m_vertices[m_tri_verts[tri_idx + 2]];\n\t\tm_tri_points[j][0] = v0;\n\t\tm_tri_points[j][1] = v1;\n\t\tm_tri_points[j][2] = v2;\n\t\t// ccw order\n\t\tconst Eigen::Vector3d edge1{ v1 - v0 };\n\t\tconst Eigen::Vector3d edge2{ v2 - v1 };\n\t\tconst Eigen::Vector3d cross = edge1.cross(edge2);\n\t\tm_tri_areas[j] = cross.norm()*0.5;\n\t\tm_tri_normals[j] = cross.normalized();\n\t\tm_tri_edges[j] = std::make_pair(edge1, edge2);\n\t}\n\n}\n\n// variable names based on pseudocode\nvoid GCDeformData::calc_green_coords(MItGeometry& iter, const MMatrix& mat)\n{\n\tMPointArray target_vertices;\n\titer.allPositions(target_vertices);\n\tm_nr_of_targetverts = iter.exactCount();\n\tm_psi.resize(m_nr_of_tris*m_nr_of_targetverts, 0.0);\n\tm_phi.resize(m_nr_of_verts*m_nr_of_targetverts, 0.0);\n\n\ttbb::parallel_for(tbb::blocked_range(0, m_nr_of_targetverts), [&](const tbb::blocked_range& r) {\n\t\tfor (unsigned int idx = r.begin(); idx < r.end(); ++idx) {\n\t\t\tconst auto maya_vec = target_vertices[idx] * mat;\n\t\t\tconst Eigen::Vector3d pvec(maya_vec.x, maya_vec.y, maya_vec.z);\n\t\t\tEigen::Vector3d s;\n\t\t\tEigen::Vector3d I;\n\t\t\tstd::array II;\n\t\t\tstd::array N;\n\t\t\tfor (unsigned int i = 0; i < m_nr_of_tris; ++i) {\n\t\t\t\tconst auto nrm = m_tri_normals[i];\n\t\t\t\tstd::array vj;\n\t\t\t\tfor (size_t l = 0; l < 3; ++l) {\n\t\t\t\t\tvj[l] = m_tri_points[i][l] - pvec;\n\t\t\t\t}\n\t\t\t\tconst auto p = nrm * (vj[0].dot(nrm));\n\t\t\t\tfor (size_t k = 0; k < 3; ++k) {\n\t\t\t\t\tconst auto v0 = vj[k];\n\t\t\t\t\tconst auto v1 = vj[(k + 1) % 3];\n\t\t\t\t\tconst auto lg = ((v0 - p).cross((v1 - p))).dot(nrm);\n\t\t\t\t\ts[k] = lg < 0 ? -1.0 : 1.0;\n\t\t\t\t\t// eta always zero(?)\n\t\t\t\t\tI[k] = GCTriInt(p, v0, v1);\n\t\t\t\t\tII[k] = GCTriInt(NULL_VECTOR, v1, v0);\n\t\t\t\t\tN[k] = (v1.cross(v0)).normalized();\n\t\t\t\t}\n\n\t\t\t\tconst auto I_ = -abs(s.dot(I));\n\n\t\t\t\tm_psi[(idx*m_nr_of_tris) + i] = -I_;\n\n\t\t\t\tEigen::Vector3d w = I_ * nrm;\n\t\t\t\tfor (int k = 0; k < 3; k++)\n\t\t\t\t\tw += (II[k] * N[k]);\n\n\t\t\t\tif (w.norm() > DBL_EPSILON) {\n\t\t\t\t\tfor (unsigned int l = 0; l < 3; l++)\n\t\t\t\t\t{\n\t\t\t\t\t\tconst auto l1 = (l + 1) % 3;\n\t\t\t\t\t\tconst auto a1 = N[l1];\n\t\t\t\t\t\tconst auto a2 = w;\n\t\t\t\t\t\tconst auto a3 = vj[l];\n\t\t\t\t\t\tconst auto val = ((a1.dot(a2)) / (a1.dot(a3)));\n\t\t\t\t\t\tm_phi[m_nr_of_verts*idx + m_tri_verts[(i * 3) + l]] += val;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t});\n}\n\n\nconst MPoint GCDeformData::calc_pos(unsigned int idx) const\n{\n\tEigen::Vector3d pnt(0.0, 0.0, 0.0);\n\tconst auto current_tri = idx*m_nr_of_tris;\n\tconst auto current_vert = idx*m_nr_of_verts;\n\n\tfor (unsigned int i = 0; i < m_nr_of_verts; ++i) {\n\t\tpnt += m_phi[current_vert + i] * m_vertices[i];\n\t}\n\n\tfor (unsigned int i = 0; i < m_nr_of_tris; ++i) {\n\n\t\tpnt += m_psi[current_tri + i] * m_scale_factor[i] * m_tri_normals[i];\n\t}\n\n\treturn MPoint(pnt.x(), pnt.y(), pnt.z());\n}\n\n\nvoid GCDeformData::calc_scale_factor()\n{\n\n\tfor (unsigned int i = 0; i < m_nr_of_tris; ++i) {\n\t\tconst auto rest_edges = m_original_edges[i];\n\t\tconst auto current_edges = m_tri_edges[i];\n\n\t\tconst auto u0 = rest_edges.first;\n\t\tconst auto v0 = rest_edges.second;\n\n\t\tconst auto u1 = current_edges.first;\n\t\tconst auto v1 = current_edges.second;\n\n\t\tm_scale_factor[i] = sqrt((u1.squaredNorm()) * (v0.squaredNorm()) - 2.0 * (u1.dot(v1)) * (u0.dot(v0)) + (v1.squaredNorm()) * (u0.squaredNorm())) / (MathConstants::SQRT8 * m_original_areas[i]);\n\n\t}\n}\n\n\nvoid GCDeformData::save_original_cage_data()\n{\n\tm_original_areas.reserve(m_nr_of_tris);\n\tm_original_areas = m_tri_areas;\n\n\tm_original_edges.reserve(m_nr_of_tris);\n\tm_original_edges = m_tri_edges;\n}\n\n\nMStatus GreenCageDeformer::deform(MDataBlock& block, MItGeometry& iter, const MMatrix& mat, unsigned int multiIndex)\n{\n\tMStatus stat;\n\n\t// not yet supported\n\tif (multiIndex > 0)\n\t\treturn stat;\n\n\tif (!m_cage_connected)\n\t\treturn stat;\n\n\tconst auto envelope_val = block.inputValue(envelope).asDouble();\n\tif (envelope_val <= 0.0)\n\t\treturn stat;\n\n\tconst auto h_cage = block.inputValue(s_cage_mesh);\n\n\t// since we are getting the worldMesh lets not fiddle around with local to world transformations\n\tconst auto cage_object = h_cage.asMeshTransformed();\n\n\tp_cage_data->m_cage_object = cage_object;\n\tp_cage_data->setup_cage();\n\n\tif (!m_green_calculated) {\n\t\tMArrayDataHandle h_input_array = block.outputArrayValue(input, &stat);\n\t\t// atm multiIndex will be only 0\n\t\tstat = h_input_array.jumpToElement(multiIndex);\n\t\tp_cage_data->calc_green_coords(iter, mat);\n\t\tp_cage_data->save_original_cage_data();\n\t\tm_green_calculated = true;\n\t\t// TODO: write out green coords w/ original cage to be able to reload scene without calculating(also correctly) everytime we open it\n\t}\n\n\tp_cage_data->calc_scale_factor();\n\tMPointArray new_arr;\n\tnew_arr.setLength(p_cage_data->m_nr_of_targetverts);\n\n\tconst auto inverse_mat = mat.inverse();\n\ttbb::parallel_for(tbb::blocked_range(0, p_cage_data->m_nr_of_targetverts), [&](const tbb::blocked_range& r) {\n\t\tfor (unsigned int idx = r.begin(); idx < r.end(); ++idx) {\n\t\t\tnew_arr[idx] = p_cage_data->calc_pos(idx) * inverse_mat;\n\t\t}\n\t});\n\n\titer.setAllPositions(new_arr);\n\treturn stat;\n}\n\nvoid GreenCageDeformer::postConstructor()\n{\n\tm_cage_connected = false;\n\tm_green_calculated = false;\n}\n\nMStatus GreenCageDeformer::connectionMade(const MPlug & plug, const MPlug & otherPlug, bool asSrc)\n{\n\tif (!asSrc && plug == s_cage_mesh) {\t\t\n\t\tp_cage_data.reset(new GCDeformData());\n\t\tm_cage_connected = true;\n\t}\n\n\treturn MPxDeformerNode::connectionMade(plug, otherPlug, asSrc);\n}\n\nMStatus GreenCageDeformer::connectionBroken(const MPlug & plug, const MPlug & otherPlug, bool asSrc)\n{\n\tif (!asSrc && plug == s_cage_mesh) {\n\t\tp_cage_data.reset();\n\t\tm_cage_connected = false;\n\t\tm_green_calculated = false;\n\t}\n\n\treturn MPxDeformerNode::connectionBroken(plug, otherPlug, asSrc);\n}\n\n\nvoid* GreenCageDeformer::creator()\n{\n\treturn new GreenCageDeformer();\n}\n\n\nMStatus GreenCageDeformer::initialize()\n{\n\tMStatus stat;\n\tMFnTypedAttribute tAttr;\n\n\ts_cage_mesh = tAttr.create(\"cageMesh\", \"cm\", MFnData::kMesh, &stat);\n\tCHECK_MSTATUS_AND_RETURN_IT(stat);\n\tstat = addAttribute(s_cage_mesh);\n\tCHECK_MSTATUS_AND_RETURN_IT(stat);\n\tstat = attributeAffects(s_cage_mesh, outputGeom);\n\n\treturn stat;\n}\n\n\nMStatus initializePlugin(MObject obj)\n{\n\tMStatus stat;\n\n\tMFnPlugin plugin(obj, \"Balazs Pataki\", \"1.0\", \"Any\");\n\tstat = plugin.registerNode(GreenCageDeformer::s_node_name, GreenCageDeformer::s_node_id, &GreenCageDeformer::creator, &GreenCageDeformer::initialize, MPxNode::kDeformerNode);\n\tCHECK_MSTATUS_AND_RETURN_IT(stat);\n\n\treturn stat;\n}\n\n\nMStatus uninitializePlugin(MObject obj)\n{\n\tMStatus stat;\n\n\tMFnPlugin plugin(obj);\n\tstat = plugin.deregisterNode(GreenCageDeformer::s_node_id);\n\tCHECK_MSTATUS_AND_RETURN_IT(stat);\n\n\treturn stat;\n}\n", "meta": {"hexsha": "a771666c2f3c84da50e749997bd26011c1c1fab6", "size": 10069, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/green_cage_deformer.cc", "max_stars_repo_name": "blaisebundle/green_cage_deformer", "max_stars_repo_head_hexsha": "5a2b32624fb04042d058161b02f2c35d306cbdc1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10.0, "max_stars_repo_stars_event_min_datetime": "2018-06-18T19:01:17.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-25T12:22:42.000Z", "max_issues_repo_path": "src/green_cage_deformer.cc", "max_issues_repo_name": "RiggestOu/green_cage_deformer", "max_issues_repo_head_hexsha": "5a2b32624fb04042d058161b02f2c35d306cbdc1", "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/green_cage_deformer.cc", "max_forks_repo_name": "RiggestOu/green_cage_deformer", "max_forks_repo_head_hexsha": "5a2b32624fb04042d058161b02f2c35d306cbdc1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2018-02-12T22:53:47.000Z", "max_forks_repo_forks_event_max_datetime": "2018-12-29T08:41:22.000Z", "avg_line_length": 28.0473537604, "max_line_length": 193, "alphanum_fraction": 0.6853709405, "num_tokens": 3198, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767874818409, "lm_q2_score": 0.626124191181315, "lm_q1q2_score": 0.5494094438424463}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nconst int debug_level = 0;\n\n#define DEBUG(min_level, x) \\\n if (debug_level >= min_level) \\\n { \\\n std::cerr << x << std::endl; \\\n }\n\ntypedef boost::adjacency_list> Graph;\n\ntypedef CGAL::Exact_predicates_inexact_constructions_kernel K;\ntypedef CGAL::Delaunay_triangulation_2 Triangulation;\n\nbool testcase()\n{\n int n;\n std::cin >> n;\n if (n == 0)\n {\n return false;\n }\n assert(n >= 2 && n <= 6e4);\n\n DEBUG(1, \"\\ntest case; n = \" << n);\n\n std::vector infected_points;\n for (int i = 0; i < n; i++)\n {\n int x, y;\n std::cin >> x >> y;\n assert(abs(x) < (1 << 24) && abs(y) < (1 << 24));\n infected_points.emplace_back(x, y);\n }\n\n int m;\n std::cin >> m;\n assert(m >= 1 && m <= 4e4);\n\n std::vector> healthy_points;\n for (int i = 0; i < m; i++)\n {\n int x, y;\n long d;\n std::cin >> x >> y >> d;\n assert(abs(x) < (1 << 24) && abs(y) < (1 << 24));\n assert(d >= 0 && d < (long(1) << 49));\n healthy_points.push_back(std::make_pair(K::Point_2(x, y), d));\n }\n\n Triangulation triangulation;\n triangulation.insert(infected_points.begin(), infected_points.end());\n\n const int indexed_face_count = triangulation.number_of_faces() + 1;\n Graph mst_input_graph(indexed_face_count);\n auto mst_input_weights = boost::get(boost::edge_weight, mst_input_graph);\n std::map face_indices_by_handle;\n int next_free_face_index = 0;\n const int infinite_face_index = next_free_face_index++;\n auto index_from_face_handle = [&face_indices_by_handle, &next_free_face_index, &triangulation, indexed_face_count, infinite_face_index](Triangulation::Face_handle fh) {\n if (triangulation.is_infinite(fh))\n {\n DEBUG(4, \"infinite face\");\n return infinite_face_index;\n }\n\n int face_index;\n if (face_indices_by_handle.count(fh) == 1)\n {\n DEBUG(4, \"existing face\");\n face_index = face_indices_by_handle.at(fh);\n }\n else\n {\n DEBUG(4, \"new face\");\n assert(face_indices_by_handle.count(fh) == 0);\n face_index = next_free_face_index++;\n face_indices_by_handle.insert(std::make_pair(fh, face_index));\n }\n DEBUG(4, \"face_index \" << face_index << \" limit \" << indexed_face_count);\n assert(face_index >= 0 && face_index < indexed_face_count);\n return face_index;\n };\n for (auto it = triangulation.finite_edges_begin(); it != triangulation.finite_edges_end(); it++)\n {\n long weight = -CGAL::squared_distance(it->first->vertex((it->second + 1) % 3)->point(), it->first->vertex((it->second + 2) % 3)->point());\n int vertex_a = index_from_face_handle(it->first);\n int vertex_b = index_from_face_handle(it->first->neighbor(it->second));\n if (vertex_a > vertex_b)\n {\n std::swap(vertex_a, vertex_b);\n }\n assert(vertex_a < vertex_b);\n DEBUG(3, \"vertex_a \" << vertex_a << \" vertex_b \" << vertex_b << \" weight \" << weight);\n auto edge_result = boost::edge(vertex_a, vertex_b, mst_input_graph);\n if (edge_result.second)\n {\n long &saved_weight = mst_input_weights[edge_result.first];\n saved_weight = std::min(saved_weight, weight);\n }\n else\n {\n boost::add_edge(vertex_a, vertex_b, weight, mst_input_graph);\n }\n }\n\n Graph mst(indexed_face_count);\n auto add_mst_edge = [&mst, &mst_input_graph](Graph::edge_descriptor edge) {\n long weight = boost::get(boost::edge_weight_t(), mst_input_graph, edge);\n DEBUG(3, \"add_mst_edge \" << edge.m_source << \" \" << edge.m_target << \" \" << weight);\n boost::add_edge(edge.m_source, edge.m_target, weight, mst);\n };\n boost::kruskal_minimum_spanning_tree(mst_input_graph, boost::make_function_output_iterator(std::ref(add_mst_edge)));\n\n std::deque> bfs_queue{std::make_pair(infinite_face_index, std::numeric_limits::max())};\n std::vector largest_escape_by_face(indexed_face_count, 0);\n while (!bfs_queue.empty())\n {\n int prev_vertex = bfs_queue.front().first;\n long prev_largest_escape = bfs_queue.front().second;\n bfs_queue.pop_front();\n\n assert(largest_escape_by_face.at(prev_vertex) == 0);\n largest_escape_by_face.at(prev_vertex) = prev_largest_escape;\n DEBUG(3, \"prev_vertex \" << prev_vertex << \" prev_largest_escape \" << prev_largest_escape);\n\n for (auto its = boost::out_edges(prev_vertex, mst); its.first != its.second; its.first++)\n {\n int next_vertex = its.first->m_target;\n assert(next_vertex != prev_vertex);\n if (largest_escape_by_face.at(next_vertex) > 0)\n {\n continue;\n }\n DEBUG(3, \"next_vertex \" << next_vertex);\n\n long limit_of_this_edge = -boost::get(boost::edge_weight_t(), mst, *its.first);\n long next_largest_escape = std::min(prev_largest_escape, limit_of_this_edge);\n DEBUG(3, \"limit_of_this_edge \" << limit_of_this_edge << \" next_largest_escape \" << next_largest_escape)\n assert(next_largest_escape > 0);\n\n bfs_queue.push_back(std::make_pair(next_vertex, next_largest_escape));\n }\n }\n int min_largest_escape_by_triangle = *std::min_element(largest_escape_by_face.begin(), largest_escape_by_face.end());\n DEBUG(2, \"min_largest_escape_by_triangle \" << min_largest_escape_by_triangle);\n assert(min_largest_escape_by_triangle > 0);\n\n std::vector can_escape_by_index(m);\n for (int i = 0; i < m; i++)\n {\n auto &healthy_point = healthy_points.at(i);\n Triangulation::Face_handle face = triangulation.locate(healthy_point.first);\n int face_index = index_from_face_handle(face);\n DEBUG(2, \"face_index \" << face_index);\n long largest_escape = largest_escape_by_face.at(face_index);\n DEBUG(2, \"largest_escape (initial) \" << largest_escape);\n\n auto nearest = triangulation.nearest_vertex(healthy_point.first);\n DEBUG(3, \"limiting using point \" << nearest->point());\n largest_escape = std::min(largest_escape, 4 * long(CGAL::squared_distance(healthy_point.first, nearest->point())));\n\n DEBUG(2, \"largest_escape (adjusted) \" << largest_escape);\n can_escape_by_index.at(i) = 4 * healthy_point.second <= largest_escape;\n }\n\n for (bool v : can_escape_by_index)\n {\n std::cout << (v ? \"y\" : \"n\");\n }\n std::cout << \"\\n\";\n\n return true;\n}\n\nint main()\n{\n std::ios_base::sync_with_stdio(false);\n\n while (testcase())\n {\n }\n\n return 0;\n}", "meta": {"hexsha": "8e4355c27f861b9df9326121069c7ee1ac3e09bb", "size": 6774, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "week-08/h1n1/src/main.cpp", "max_stars_repo_name": "tehwalris/algolab", "max_stars_repo_head_hexsha": "489e0f6dd137336fa32b8002fc6eed8a7d35d87a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-01-17T08:21:32.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-17T08:21:32.000Z", "max_issues_repo_path": "week-08/h1n1/src/main.cpp", "max_issues_repo_name": "tehwalris/algolab", "max_issues_repo_head_hexsha": "489e0f6dd137336fa32b8002fc6eed8a7d35d87a", "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": "week-08/h1n1/src/main.cpp", "max_forks_repo_name": "tehwalris/algolab", "max_forks_repo_head_hexsha": "489e0f6dd137336fa32b8002fc6eed8a7d35d87a", "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.7384615385, "max_line_length": 170, "alphanum_fraction": 0.6737525834, "num_tokens": 1861, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8723473614033683, "lm_q2_score": 0.6297746213017459, "lm_q1q2_score": 0.5493822291713836}} {"text": "#define _USE_MATH_DEFINES\n\n#include \"mesh.hpp\"\n#include \"plane2d.hpp\"\n#include \"line_interval.hpp\"\n#include \"found_path.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nusing namespace Eigen;\nusing namespace std;\n\nMesh::Mesh(const int numVertices, const int numFaces, const int numCells){\n vertices.reserve(numVertices);\n faces.reserve(numFaces);\n tetrahedrons.reserve(numCells);\n}\n\nvoid Mesh::setVertices(const vector> & _vertices){\n\n for(unsigned long int i=0; i < _vertices.size(); ++i){\n\tVertex3d pt(_vertices[i]);\n\tvertices.push_back(pt);\n }\n\n}\n\n\nvoid Mesh::addTetrahedron(const int id, const array vertexIds, \n\tconst vector neighborIds, const double weight, const int label){\n\n vector> refs = {vertices[vertexIds[0]], vertices[vertexIds[1]], vertices[vertexIds[2]], vertices[vertexIds[3]]};\n\n Tetrahedron tet(id, refs, weight, label);\n\n unsigned long int current_size = tetrahedrons.size();\n\n for(unsigned long int i=0; i vertexIds, const int tetId){\n vector> refs = {vertices[vertexIds[0]], vertices[vertexIds[1]], vertices[vertexIds[2]]};\n\n Face face(refs, tetId);\n faces.push_back(face);\n}\n\nbool Mesh::setTarget(array _target){\n bool targetSet=false;\n for(unsigned long int i=0; i < tetrahedrons.size(); ++i){\n\tif (tetrahedrons[i].contains(_target)){\n\t Vector3d t(_target[0], _target[1], _target[2]);\n\t target = t;\n\t targetTetId=i;\n\t targetSet=true;\n\t break;\n\t}\n }\n return targetSet;\n}\n\nvector Mesh::sliceIndv(array rotation){\n vector planeLastChecked;\n planeLastChecked.reserve(tetrahedrons.size());\n for(unsigned long int i=0; i Mesh::findPaths(vector planes, double distBound){\n vector planeLastChecked;\n planeLastChecked.reserve(tetrahedrons.size());\n for(unsigned long int i=0; i::max();\n\n //vector> allCandidateIntervals;\n vector> allFoundPaths;\n\n for(int i=0; i planeSlice = slice(planes[i], planeLastChecked);\n\tPlane2d plane2d(planeSlice, planes[i]);\n\tvector planePaths=plane2d.FindPaths(distBound);\n\t//cout << \"plane paths size:\" << endl;\n\t//cout << planePaths.size() << endl;\n\tallFoundPaths.push_back(planePaths);\n\tif(plane2d.MinUpperBound() foundPaths;\n //cout << \"min upper bound:\" << endl;\n //cout << minUpperBound << endl;\n //cout << \"all found paths size:\" << endl;\n //cout << allFoundPaths.size() << endl;\n\n for(int i=0; i planePaths=allFoundPaths[i];\n\n\tfor(int j=0; j endPoints=foundPath.Points();\n\t\tVector3d pt0=planes[i].Get3dPoint(endPoints[0]);\n\t\tVector3d pt1=planes[i].Get3dPoint(endPoints[1]);\n\n\t\tFoundPath fp(planes[i].Id(), pt0, pt1, foundPath.LowerBound(), foundPath.UpperBound());\n\t\tfoundPaths.push_back(fp);\n\t }\n\t}\n }\n //cout << \"return paths size:\" << endl;\n //cout << foundPaths.size() << endl;\n return foundPaths;\n}\n\nvector Mesh::slice(Plane3d plane, vector &planeLastChecked){\n vector slice = computeSliceComponent(plane, planeLastChecked, targetTetId);\n\n for(unsigned long int i=0; i sliceComponent = computeSliceComponent(plane, planeLastChecked, faces[i].TetId());\n\t slice.insert(slice.end(), sliceComponent.begin(), sliceComponent.end());\n\t}\n }\n return slice;\n}\n\nvector Mesh::computeSliceComponent(Plane3d plane, vector &planeLastChecked, unsigned long int initTet){\n \n vector tetStack;\n tetStack.push_back(initTet);\n\n vector allPoints;\n\n while(tetStack.size() > 0){\n\tTetrahedron& tet = tetrahedrons[tetStack.back()];\n\ttetStack.pop_back();\n\t\n\tif(planeLastChecked[tet.Id()]!=plane.Id()){\n\n\t vector> intersectionPoints = tet.intersectsPlane(plane);\n\n\t if(intersectionPoints.size()>2){\n\t\tShape3d shape(tet.Id(), intersectionPoints, tet.Weight(), tet.Label());\n\t\tallPoints.push_back(shape);\n\t\tvector neighbors = tet.Neighbors();\n\n\t\tfor(int i=0; i Mesh::shortestPaths(const int epsilon, const int numThreads, double distBound){\n\n future> futures[numThreads];\n\n vector planes;\n //cout << numThreads << endl;\n\n for(int i=0; i(epsilon*epsilon)){\n\t end=epsilon*epsilon;\n\t}\n\n\tvector planeVector;\n\n\tfor(int idx=start; idx allFoundPaths;\n double minUpperBound=numeric_limits::max();\n for(unsigned long int i=0; i foundPaths=futures[i].get();\n\tfor(unsigned long int j=0; j foundPaths=futures[i].get();\n\t//allFoundPaths.push_back(foundPaths);\n }\n\n \n vector ret;\n for(unsigned long int i=0; i\nNTL_CLIENT\n\n\n#include \nG_mod_p::G_mod_p() {\n\t// TODO Auto-generated constructor stub\n\n}\n\n//Sets the generator to gen and the mod to p, checks if the generator has the right modular value p\nG_mod_p::G_mod_p(Mod_p gen, long p){\n\n\tgenerator = gen;\n\tmod = to_ZZ(p);\n\tif (gen.get_mod() != p)\n\t\tcout << \"The modular value of the generator and p are not equal\" << endl;\n}\n\n//Sets the generator to gen and the mod to p, checks if the generator has the right modular value p\nG_mod_p::G_mod_p(Mod_p gen, ZZ p){\n\n\tgenerator = gen;\n\tmod = p;\n\n\tif (gen.get_mod() != p)\n\t\tcout << \"The modular value of the generator and p are not equal\" << endl;\n\n}\n\n//Sets the generator to the value gen and the mod to p\nG_mod_p::G_mod_p(ZZ val, long p){\n\n\tgenerator = Mod_p(val, p);\n\tmod = to_ZZ(p);\n\n}\n\n//Sets the generator to the value gen and the mod to p\nG_mod_p::G_mod_p(ZZ val, ZZ p){\n\n\tgenerator = Mod_p(val, p);\n\tmod = p;\n\n}\n\n//Sets the generator to the value gen and the mod to p\nG_mod_p::G_mod_p(long val, long p){\n\n\tgenerator = Mod_p(val, p);\n\tmod = to_ZZ(p);\n\n}\n\n//Sets the generator to the value gen and the mod to p\nG_mod_p::G_mod_p(long val, ZZ p){\n\n\tgenerator = Mod_p(val, p);\n\tmod = p;\n\n}\n\n//Creates a group given the generator, mod is set to modular value if gen\nG_mod_p::G_mod_p(Mod_p gen){\n\n\tgenerator = gen;\n\tmod = gen.get_mod();\n}\n\n//Creates a group ZZ/p, the function sets the generator to the smallest possible one\nG_mod_p::G_mod_p(ZZ p){\n\n\tZZ i;\n\tmod = p;\n\tfor (i = to_ZZ(1); i < p; ++i)\n\t{\n\t\tif (is_generator(i))\n\t\t{\n\t\t\tgenerator = Mod_p(i,p);\n\t\t\tbreak;\n\t\t}\n\t}\n}\n\n//Creates a group ZZ/p, the function sets the generator to the smallest possible one\nG_mod_p::G_mod_p(long p){\n\n\tlong i;\n\tmod = p;\n\tfor (i = 1; i < p; ++i)\n\t{\n\t\tif (is_generator(i))\n\t\t{\n\t\t\tgenerator = Mod_p(i,p);\n\t\t\tbreak;\n\t\t}\n\t}\n}\n\n//Destructor\nG_mod_p::~G_mod_p() {\n\t// TODO Auto-generated destructor stub\n}\n\n//Returns the generator\nMod_p G_mod_p::get_gen()const{\n\n\treturn generator;\n}\n\n//Returns the modular value\nZZ G_mod_p::get_mod()const{\n\n\treturn mod;\n}\n\n//Checks if an element is a generator of the group\nbool G_mod_p::is_generator(const Mod_p& el){\n\tZZ pow;\n\tbool b;\n\tb=false;\n\tpow = PowerMod(el.get_val(),(mod-1)/2,mod);\n\tif(pow == (mod-1))\n\t{\n\t\tif(el.get_val()!=(mod-1))\n\t\t{b=true;\n\t\t}\n\t}\n\treturn b;\n}\n\n//Checks if an element with value x is a generator of the group\nbool G_mod_p::is_generator(const ZZ& x){\n\tZZ pow;\n\tbool b;\n\tb=false;\n\tpow = PowerMod(x,(mod-1)/2,mod);\n\n\n\tif(pow == (mod-1))\n\t{\n\t\tif(x!=(mod-1))\n\t\t{b=true;\n\t\t}\n\t}\n\n\treturn b;\n}\n\n//Checks if an element with value x is a generator of the group\nbool G_mod_p::is_generator(const long& x){\n\tZZ pow;\n\tbool b;\n\tpow = PowerMod(to_ZZ(x),(mod-1)/2, mod);\n\tif(pow == (mod-1))\n\t{\n\t\tif(x!=(mod-1))\n\t\t{b=true;\n\t\t}\n\t}\n\n\treturn b;\n}\n\n//Returns the identity of the group\nMod_p G_mod_p::identity(){\n\n\treturn Mod_p(1, mod);\n}\n\n//return a random element of the group\nMod_p G_mod_p::random_el(){\n\n\tZZ ran;\n\tSetSeed(to_ZZ(time(0)));\n\tran = RandomBnd(mod);\n\n\treturn Mod_p(ran,mod);\n\n}\n\n//Creates an element with the value v modular mod\nMod_p G_mod_p::element(ZZ v){\n\n\n\treturn Mod_p(v,mod);\n\n}\n\n//Creates an element with the value v modular mod\nMod_p G_mod_p::element(long v){\n\n\n\treturn Mod_p(v,mod);\n\n}\n\n//Returns a n-th root of unity of the group\nMod_p G_mod_p::rootofunity(long n){\n\n\tZZ i;\n\tZZ pow;\n\tif ((mod-1) % n == 0)\n\t{\tfor(i = to_ZZ(2); i\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\n#include \n#include \n#include \n#include \n#include \n\ntypedef CGAL::Simple_cartesian Kernel;\ntypedef CGAL::Polyhedron_items_with_id_3 Polyhedron_items;\ntypedef CGAL::Polyhedron_3 Polyhedron;\ntypedef CGAL::Triangulation_vertex_base_with_info_2 Vb;\ntypedef CGAL::Triangulation_face_base_2 Fb;\ntypedef CGAL::Triangulation_data_structure_2 Tds;\ntypedef CGAL::Delaunay_triangulation_2 Delaunay;\ntypedef Kernel::Point_3 Point_3;\ntypedef Kernel::Point_2 Point_2;\n\nPoint_3 sphericalToCart(Point_2 const &s) {\n using std::sin;\n using std::cos;\n return Point_3(sin(s[0]) * cos(s[1]), sin(s[0]) * sin(s[1]), -cos(s[0]));\n}\n\ninline Point_2 PhiN(Point_3 const &x) {\n return Point_2(x[0] / (1.0 - x[2]), x[1] / (1.0 - x[2]));\n}\n\nstd::vector>\ntriangulate(std::vector &points) {\n std::size_t vertexIndex = 0;\n auto const f = [&vertexIndex](auto const &p) {\n return std::make_pair(PhiN(p), vertexIndex++);\n };\n\n typedef boost::transform_iterator<\n decltype(f), std::vector::const_iterator> Iterator;\n\n // Delaunay dt(Iterator(points.cbegin(), f), Iterator(points.cend(), f));\n Delaunay dt;\n\n // ensure that no three points inserted to dt are collinear\n std::vector> pt(Iterator(points.cbegin(), f),\n Iterator(points.cend(), f));\n auto p0 = pt[0], p1 = pt[1];\n pt.erase(pt.begin());\n pt.erase(pt.begin());\n auto iter = pt.begin();\n while (!pt.empty()) {\n auto p2 = *iter;\n if (CGAL::collinear(p0.first, p1.first, p2.first)) {\n ++iter;\n continue;\n }\n dt.push_back(iter->first)->info() = iter->second;\n p0 = p1;\n p1 = p2;\n iter = pt.erase(iter);\n if (iter == pt.end()) iter = pt.begin();\n }\n\n std::size_t const N = points.size();\n std::vector> facets;\n facets.reserve(dt.number_of_faces());\n for (auto t = dt.all_faces_begin(); t != dt.all_faces_end(); ++t) {\n auto const v0 = t->vertex(0);\n auto const v1 = t->vertex(1);\n auto const v2 = t->vertex(2);\n auto const i0 = dt.is_infinite(v0) ? N : v0->info();\n auto const i1 = dt.is_infinite(v1) ? N : v1->info();\n auto const i2 = dt.is_infinite(v2) ? N : v2->info();\n facets.push_back({i0, i1, i2});\n }\n // The infinite point is the south pole\n points.emplace_back(0, 0, 1);\n\n return facets;\n}\n\nstd::vector genPoints(std::size_t const N,\n Point_2 offset = Point_2(0, 0)) {\n std::vector v;\n assert(N >= 2 && \"N must be at leat 2\");\n v.reserve(N * (N - 2) + 2);\n for (unsigned int i = 0; i <= N; ++i) {\n double const theta = offset[0] + M_PI * double(i) / double(N);\n for (unsigned int j = 0; j < N; ++j) {\n double const phi = offset[1] + 2.0 * M_PI * double(j) / double(N);\n Point_3 const pCart(sphericalToCart(Point_2(theta, phi)));\n v.push_back(pCart);\n if (i == 0 || i == N) break;\n }\n }\n return v;\n}\n\nPolyhedron constructPolyhedron() {\n typedef Polyhedron::HalfedgeDS HDS;\n auto v = genPoints(500);\n // remove north pole\n v.pop_back();\n auto const f = triangulate(v);\n\n struct Builder : public CGAL::Modifier_base {\n std::vector const &v_;\n std::vector> const &f_;\n Builder(std::vector const &vv,\n std::vector> const &ff)\n : v_(vv), f_(ff) {}\n void operator()(HDS &hds) {\n CGAL::Polyhedron_incremental_builder_3 b(hds, true);\n std::size_t vIdx = 0;\n b.begin_surface(v_.size(), f_.size());\n for (auto const &p : v_) { b.add_vertex(p)->id() = vIdx++; }\n for (auto const &t : f_) {\n b.begin_facet();\n b.add_vertex_to_facet(t[2]);\n b.add_vertex_to_facet(t[1]);\n b.add_vertex_to_facet(t[0]);\n b.end_facet();\n }\n b.end_surface();\n }\n } builder(v, f);\n Polyhedron p;\n p.delegate(builder);\n return p;\n}\n\nstatic std::size_t comparisonCount = 0;\n\ntemplate \nstruct CountingTraits\n : public TriPQ::CGALSphericalPolyhedronTraitsBase> {\n typedef TriPQ::CGALSphericalPolyhedronTraits

Base;\n typedef CountingTraits

Self;\n struct IsRightOf {\n template \n inline bool operator()(typename Self::Edge e, Point const &p) const {\n ++comparisonCount;\n return typename Base::IsRightOf()(e, p);\n }\n };\n};\n\nnamespace std {\n\ntemplate <>\nstruct hash::Edge>\n : public hash {\n size_t operator()(typename CountingTraits::Edge e) const {\n return hash()(static_cast(&*e));\n }\n};\n\n} // namespace std\n\ntemplate \nbool assertPointInTriangle(Edge e, Point const &x) {\n typedef TriPQ::CGALSphericalPolyhedronTraits T;\n\n if (typename T::IsRightOf()(e, x)) return false;\n if (typename T::IsRightOf()(e->next(), x)) return false;\n if (typename T::IsRightOf()(e->next()->next(), x)) return false;\n return true;\n}\n\ntemplate \nvoid runQuery(Query const &q, Points const &p) {\n comparisonCount = 0;\n using Clock = std::chrono::high_resolution_clock;\n using TimePoint = std::chrono::time_point;\n std::cout << \"\\tQuerying \" << p.size() << \" points...\" << std::flush;\n TimePoint const start = Clock::now();\n\n auto const edges = q(p);\n\n using ms = std::chrono::milliseconds;\n TimePoint const end = Clock::now();\n auto const timeDiff = end - start;\n std::cout << \"Done.\" << std::endl;\n std::cout << \"\\tTook \" << std::chrono::duration_cast(timeDiff).count()\n << \"ms\" << std::endl;\n std::cout << \"\\tOn average \" << double(comparisonCount) / double(p.size())\n << \" comparisons\" << std::endl;\n\n for (unsigned int i = 0; i < p.size(); ++i) {\n if (!assertPointInTriangle(edges[i], p[i])) {\n std::cerr << \"Point not in triangle\" << std::endl;\n std::cerr << \"Point \" << p[i] << std::endl;\n std::cerr << \"Edge: (\" << edges[i]->opposite()->vertex()->id() << \", \"\n << edges[i]->vertex()->id() << \")\" << std::endl;\n std::cerr << \"Triangle \" << edges[i]->vertex()->id() << \", \"\n << edges[i]->next()->vertex()->id() << \", \"\n << edges[i]->next()->next()->vertex()->id() << std::endl;\n exit(EXIT_FAILURE);\n }\n }\n}\n\nint main(int, char **) {\n std::random_device rd;\n std::mt19937 gen(rd());\n std::uniform_real_distribution theta(0, M_PI);\n std::uniform_real_distribution phi(0, 2.0 * M_PI);\n\n typedef TriPQ::PointQuery,\n TriPQ::StartFromFixedEdge,\n TriPQ::RandomEdgeSelect> QueryFixedRandom;\n typedef TriPQ::PointQuery,\n TriPQ::StartFromFixedEdge,\n TriPQ::SelectNearestEdge3> QueryFixedNearest;\n typedef TriPQ::PointQuery,\n TriPQ::StartFromLastEdge,\n TriPQ::RandomEdgeSelect> QueryLastRandom;\n typedef TriPQ::PointQuery,\n TriPQ::StartFromLastEdge,\n TriPQ::SelectNearestEdge3> QueryLastNearest;\n typedef TriPQ::PointQuery,\n TriPQ::StartFromMostLocatedEdge,\n TriPQ::RandomEdgeSelect> QueryMRRandom;\n typedef TriPQ::PointQuery,\n TriPQ::StartFromMostLocatedEdge,\n TriPQ::SelectNearestEdge3> QueryMRNearest;\n typedef TriPQ::PointQuery,\n TriPQ::StartFromMostLocatedEdgeUnordered,\n TriPQ::RandomEdgeSelect> QueryMRURandom;\n typedef TriPQ::PointQuery,\n TriPQ::StartFromMostLocatedEdgeUnordered,\n TriPQ::SelectNearestEdge3> QueryMRUNearest;\n\n std::size_t const N = 40000;\n // std::size_t const N = 4;\n\n // Generate polyhedron\n std::cout << \"Constructing triangulation... \" << std::flush;\n auto const p = constructPolyhedron();\n std::cout << \"done.\" << std::endl;\n\n std::vector randomPoints(N - 1);\n // generate query points\n for (unsigned int i = 0; i < N - 1; ++i) {\n randomPoints[i] = sphericalToCart(Point_2(theta(gen), phi(gen)));\n }\n\n auto const sequencialPoints =\n genPoints(std::sqrt(N), Point_2(theta(gen), phi(gen)));\n\n auto const e0 = p.halfedges_begin();\n\n std::cout << \"Triangulation dimensions:\" << std::endl;\n std::cout << \"\\t\" << p.size_of_vertices() << \" vertices\" << std::endl;\n std::cout << \"\\t\" << p.size_of_facets() << \" triangles\" << std::endl;\n std::cout << \"\\t\" << p.size_of_halfedges() / 2 << \" edges\" << std::endl;\n\n std::cout << \"Fixed starting edge, random edge select\" << std::endl;\n std::cout << \"Random points\" << std::endl;\n runQuery(QueryFixedRandom(e0), randomPoints);\n std::cout << \"Sequencial points\" << std::endl;\n runQuery(QueryFixedRandom(e0), sequencialPoints);\n\n std::cout << \"Fixed starting edge, nearest edge\" << std::endl;\n std::cout << \"Random points\" << std::endl;\n runQuery(QueryFixedNearest(e0), randomPoints);\n std::cout << \"Sequencial points\" << std::endl;\n runQuery(QueryFixedNearest(e0), sequencialPoints);\n\n std::cout << \"Last starting edge, random edge\" << std::endl;\n std::cout << \"Random points\" << std::endl;\n runQuery(QueryLastRandom(e0), randomPoints);\n std::cout << \"Sequencial points\" << std::endl;\n runQuery(QueryLastRandom(e0), sequencialPoints);\n\n std::cout << \"Last starting edge, nearest edge\" << std::endl;\n std::cout << \"Random points\" << std::endl;\n runQuery(QueryLastNearest(e0), randomPoints);\n std::cout << \"Sequencial points\" << std::endl;\n runQuery(QueryLastNearest(e0), sequencialPoints);\n\n std::cout << \"Most located starting edge, random edge\" << std::endl;\n std::cout << \"Random points\" << std::endl;\n runQuery(QueryMRRandom(e0), randomPoints);\n std::cout << \"Sequencial points\" << std::endl;\n runQuery(QueryMRRandom(e0), sequencialPoints);\n\n std::cout << \"Most located starting edge, nearest edge\" << std::endl;\n std::cout << \"Random points\" << std::endl;\n runQuery(QueryMRNearest(e0), randomPoints);\n std::cout << \"Sequencial points\" << std::endl;\n runQuery(QueryMRNearest(e0), sequencialPoints);\n\n std::cout << \"Most located starting edge (unordered map), random edge\"\n << std::endl;\n std::cout << \"Random points\" << std::endl;\n runQuery(QueryMRUNearest(e0), randomPoints);\n std::cout << \"Sequencial points\" << std::endl;\n runQuery(QueryMRURandom(e0), sequencialPoints);\n\n std::cout << \"Most located starting edge (unordered map), nearest edge\"\n << std::endl;\n std::cout << \"Random points\" << std::endl;\n runQuery(QueryMRUNearest(e0), randomPoints);\n std::cout << \"Sequencial points\" << std::endl;\n runQuery(QueryMRUNearest(e0), sequencialPoints);\n\n return EXIT_SUCCESS;\n}\n", "meta": {"hexsha": "596b246e2377720228c8051725a69cfb345eb286", "size": 11730, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/exampleSphericalTriangulation.cpp", "max_stars_repo_name": "ithron/TriPQ", "max_stars_repo_head_hexsha": "5559dab04bb6f4b632e516b70e7eb9a4eb211f65", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/exampleSphericalTriangulation.cpp", "max_issues_repo_name": "ithron/TriPQ", "max_issues_repo_head_hexsha": "5559dab04bb6f4b632e516b70e7eb9a4eb211f65", "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": "examples/exampleSphericalTriangulation.cpp", "max_forks_repo_name": "ithron/TriPQ", "max_forks_repo_head_hexsha": "5559dab04bb6f4b632e516b70e7eb9a4eb211f65", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.5420560748, "max_line_length": 79, "alphanum_fraction": 0.6332480818, "num_tokens": 3410, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677430095496, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5493119928024592}} {"text": "//---------------------------------------------------------------------------//\n// Copyright (c) 2020-2021 Mikhail Komarov \n// Copyright (c) 2020-2021 Nikita Kaskov \n//\n// MIT License\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n//---------------------------------------------------------------------------//\n\n#ifndef CRYPTO3_MATH_EVALUATE_HPP\n#define CRYPTO3_MATH_EVALUATE_HPP\n\n#include \n#include \n\n#include \n\nnamespace nil {\n namespace crypto3 {\n namespace math {\n /*!\n * @brief\n * Naive evaluation of a *single* polynomial, used for testing purposes.\n *\n * The inputs are:\n * - an integer m\n * - a vector coeff representing monomial P of size m\n * - a field element element t\n * The output is the polynomial P(x) evaluated at x = t.\n */\n template\n inline FieldValueType evaluate_polynomial(ContiguousIterator first, ContiguousIterator last,\n const FieldValueType &t, std::size_t m) {\n BOOST_ASSERT(std::distance(first, last) == m);\n\n return boost::math::tools::evaluate_polynomial(&*first, t, m);\n }\n\n template\n inline FieldValueType evaluate_polynomial(const ContiguousContainer &coeff, const FieldValueType &t,\n std::size_t m) {\n return evaluate_polynomial(coeff.begin(), coeff.end(), t, m);\n }\n\n /*!\n * @brief\n * Naive evaluation of a *single* Lagrange polynomial, used for testing purposes.\n *\n * The inputs are:\n * - an integer m\n * - a domain S = (a_{0},...,a_{m-1}) of size m\n * - a field element element t\n * - an index idx in {0,...,m-1}\n * The output is the polynomial L_{idx,S}(z) evaluated at z = t.\n */\n template\n inline FieldValueType evaluate_lagrange_polynomial(InputIterator first, InputIterator last,\n const FieldValueType &t, std::size_t m,\n std::size_t idx) {\n typedef typename std::iterator_traits::value_type value_type;\n\n BOOST_STATIC_ASSERT(std::is_same::value);\n\n if (m != std::distance(first, last)) {\n throw std::invalid_argument(\"expected m == domain.size()\");\n }\n if (idx >= m) {\n throw std::invalid_argument(\"expected idx < m\");\n }\n\n value_type num = value_type::one();\n value_type denom = value_type::one();\n\n for (std::size_t k = 0; k < m; ++k) {\n if (k == idx) {\n continue;\n }\n\n num *= t - *(first + k);\n denom *= *(first + idx) - *(first + k);\n }\n\n return num * denom.inversed();\n }\n\n template\n inline FieldValueType evaluate_lagrange_polynomial(const Range &domain, const FieldValueType &t,\n std::size_t m, std::size_t idx) {\n typedef FieldValueType value_type;\n BOOST_STATIC_ASSERT(std::is_same()))>::value_type>::value);\n\n return evaluate_lagrange_polynomial(domain.begin(), domain.end(), t, m, idx);\n }\n } // namespace math\n } // namespace crypto3\n} // namespace nil\n\n#endif // ALGEBRA_FFT_NAIVE_EVALUATE_HPP\n", "meta": {"hexsha": "92f8a89f92f9171ebd1d3cfce8e88cbf5bbf0db8", "size": 5269, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/nil/crypto3/math/polynomial/evaluate.hpp", "max_stars_repo_name": "NilFoundation/fft", "max_stars_repo_head_hexsha": "87609ea4b36eedf0426ddec69a34df2d1c990f7d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/nil/crypto3/math/polynomial/evaluate.hpp", "max_issues_repo_name": "NilFoundation/fft", "max_issues_repo_head_hexsha": "87609ea4b36eedf0426ddec69a34df2d1c990f7d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2021-12-19T23:19:42.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-04T20:10:27.000Z", "max_forks_repo_path": "include/nil/crypto3/math/polynomial/evaluate.hpp", "max_forks_repo_name": "NilFoundation/crypto3-math", "max_forks_repo_head_hexsha": "9351ff8c0f1a75022457e82475b0eba2447ceecc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.4224137931, "max_line_length": 112, "alphanum_fraction": 0.5496299108, "num_tokens": 1016, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673269042767, "lm_q2_score": 0.6757645944891558, "lm_q1q2_score": 0.5493069595389526}} {"text": "//////////////////////////////////////////////////////////////////////////////\n// random::poisson::devroye::crtp::parameters.hpp \t//\n// //\n// //\n// (C) Copyright 2010 Erwann Rogard //\n// Use, modification and distribution are subject to the //\n// Boost Software License, Version 1.0. (See accompanying file //\n// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //\n//////////////////////////////////////////////////////////////////////////////\n#ifndef BOOST_RANDOM_POISSON_EXT_DEVROYE_CRTP_PARAMETERS_HPP_ER_2010\n#define BOOST_RANDOM_POISSON_EXT_DEVROYE_CRTP_PARAMETERS_HPP_ER_2010\n#include \n\nnamespace boost{\nnamespace random{\nnamespace poisson{\nnamespace devroye{ \n \n // These are quantities that remain fixed throughout sampling and are only\n // modified if the poisson mean is changed.\n\ttemplate\n struct parameters{\n typedef IntT converter_;\n\n \tpublic:\n static const T pi;\n static const T one;\n static const T two;\n static const T eps;\n \n typedef Int result_type;\n typedef T input_type;\n \n parameters(){}\n \texplicit parameters(const Int& i_mean)\n {\n using namespace boost::math;\n\t\t\tthis->m1_ = converter_::convert( i_mean );\n\t\t\tthis->m2_ = converter_::convert( 2 * i_mean );\t\n\t\t\tT m8 = converter_::convert( 8 * i_mean );\n T m32 = converter_::convert( 32 * i_mean );\n this->c1_ = converter_::convert(1) / m8; // Equation (6)\t\t\t\n \n // Equation (10)\n this->delta_ = \tlog1p( m32 / pi, P() );\t\t\n this->delta_ = \tsqrt( this->delta() * this->m1() );\t\n\n\t\t\t// Below equation (7)\n\t\t\tthis->sd1_ = sqrt( this->m1() + this->delta() / two );\n this->shape2_ = this->delta() / ( this->m2() + this->delta() ); \n \n T a1, a2, a3, a;\n\t\t\t\n\t\t\ta1 = sqrt( pi * ( this->m2() + this->delta() ) ); \n a1 *= exp( this->c1() ); \t\t\t\t\n a2 = exp( -( this->delta() + one ) * this->shape2());\n a2 /= this->shape2(); \t\t\t\t\t\t\n a3 = one;\n a = a1 + a2 + a3;\n this->p1_ = a1 / a;\t\t\t\t\t\t\t\t\n this->p2_ = a2 / a;\t\t\t\t\t\t\t\t\t\t\t\t\n this->p3_ = a3 / a;\t\t\t\t\t\t\t\t\t\t\t\t\n\n\t\t\t// Reconciliation with Fortran code\n // RL\t\t\t\t\tm1\n // TWO\t\t\t\t\tm2\n\t\t\t// CON \t\t\t\t\tc1\n // D \t\t\t\t\tdelta\n // D2\t\t\t\t\tdelta + m2\n\t\t\t// D3 \t\t\t\t\t1 / shape2\n // STDDEV \t\t\t\tsd1\n // SUM \t\t\t\t\ta1 + a2 + a3\n // PBODY \t\t\t\tp3 = a3/(a+a2+a3) \n\t\t\t// PTAIL \t\t\t\tp2 + p3\n\n }\n\n\t\tstd::ostream& parameters_description(std::ostream& os)const{\n \treturn os \n << '('\n << \"m1 = \" \t\t<< this->m1()\n << ','\n << \" m2 = \"\t\t<< this->m2()\n << ','\n << \" delta = \" \t<< this->delta()\n << ','\n << \" loc1 = \"\t<< loc1()\n << ','\n << \" sd1 = \" \t<< this->sd1()\n << ','\n << \" shape2 = \"\t<< this->shape2()\n << ','\n << \" c1 = \"\t\t<< this->c1()\n << ','\n << \" p1 = \"\t\t<< this->p1()\n << ','\n << \" p2 = \"\t\t<< this->p2()\n << ','\n << \" p3 = \"\t\t<< this->p3()\n << ')';\n }\n\n\t\tconst T& m1()const{ return this->m1_; }\n\t\tconst T& m2()const{ return this->m2_; }\n\t\tconst T& delta()const{ return this->delta_; }\n\t\tstatic T loc1(){ return -one/two; }\n\t\tconst T& sd1()const{ return this->sd1_; }\n\t\tconst T& shape2()const{ return this->shape2_; }\n const T& c1()const{ return this->c1_; }\n\t\tconst T& p1()const{ return this->p1_; }\n\t\tconst T& p2()const{ return this->p2_; }\n\t\tconst T& p3()const{ return this->p3_; }\n\n\t\tprivate:\n T inv_m1_;\n\t\tT m1_;\n\t\tT m2_;\t\t\t\n T delta_;\t\t\n\t\tT sd1_;\t\t\n\t\tT shape2_;\t\t\n \n T c1_;\t\t\t\n T p1_;\t\t\t\n T p2_;\t\t\n\t\tT p3_;\n\n };\n\n template\n const T parameters::pi = boost::math::constants::pi();\n\n template\n const T parameters::one = IntT::convert( 1 );\n\n template\n const T parameters::two = IntT::convert( 2 );\n\n template\n const T parameters::eps \n = boost::numeric::bounds::smallest();\n\n}// devroye\n}// poisson\n}// random\n}// boost\n\n#endif\n", "meta": {"hexsha": "aceceaa2d3a4503df0c20addeec49f29ea4fc9ed", "size": 4930, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "random/boost/random/poisson_ext/devroye/crtp/parameters.hpp", "max_stars_repo_name": "rogard/boost_sandbox_statistics", "max_stars_repo_head_hexsha": "16aacbc716a31a9f7bb6c535b1c90dc343282a23", "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": "random/boost/random/poisson_ext/devroye/crtp/parameters.hpp", "max_issues_repo_name": "rogard/boost_sandbox_statistics", "max_issues_repo_head_hexsha": "16aacbc716a31a9f7bb6c535b1c90dc343282a23", "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": "random/boost/random/poisson_ext/devroye/crtp/parameters.hpp", "max_forks_repo_name": "rogard/boost_sandbox_statistics", "max_forks_repo_head_hexsha": "16aacbc716a31a9f7bb6c535b1c90dc343282a23", "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": 33.3108108108, "max_line_length": 78, "alphanum_fraction": 0.4468559838, "num_tokens": 1312, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.812867299704166, "lm_q2_score": 0.6757645879592642, "lm_q1q2_score": 0.5493069358501455}} {"text": "/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */\n\n/*\n Copyright (C) 2009 Jose Aparicio\n\n This file is part of QuantLib, a free-software/open-source library\n for financial quantitative analysts and developers - http://quantlib.org/\n\n QuantLib is free software: you can redistribute it and/or modify it\n under the terms of the QuantLib license. You should have received a\n copy of the license along with this program; if not, please email\n . The license is also available online at\n .\n\n This program is distributed in the hope that it will be useful, but WITHOUT\n ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n FOR A PARTICULAR PURPOSE. See the license for more details.\n*/\n\n#ifndef recursive_cdo_engine_hpp\n#define recursive_cdo_engine_hpp\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace QuantLib {\n\n /*! Recursive STCDO pricing for a heterogeneous pool of names. The pool\n names are heterogeneous in their default probabilities, notionals\n and recovery rates. Correlations are pairwise. The recursive pricing\n algorithm used here is described in Andersen, Sidenius and Basu;\n \"All your hedges in one basket\", Risk, November 2003, pages 67-72\n\n Notice that using copulas other than Gaussian it is only an\n approximation (see remark on p.68).\n */\n template \n class RecursiveCdoEngine : public CDOEngine {\n public:\n // Base constructors call default Handle constructor, the copula is to\n // be relinked by template partial specializations on the copula type\n\n //! Single correlation construction\n RecursiveCdoEngine(const Handle& correl,\n Size nbuckets = 1,\n Size quadOrder = 20)\n : correlQuote_(correl), copula_(), nBuckets_(nbuckets),\n integral_(quadOrder), wk_()\n {\n this->registerWith(correl);\n }\n\n //! Correlation name to name single factor construction\n RecursiveCdoEngine(const Handle& correl,\n const Matrix& correlMtrx,\n Size nbuckets = 1,\n Size quadOrder = 20)\n : correlQuote_(correl), copula_(), nBuckets_(nbuckets),\n integral_(quadOrder), wk_(),\n oneFactorCorrels_(factorReduction(correlMtrx))\n {\n // at least\n QL_REQUIRE(!oneFactorCorrels_.empty(),\n \"Invalid correlation parameter matrix.\");\n }\n protected:\n void initialize() const;\n private:\n //! Weights the conditional portfolio loss by the mkt factor\n // distribtion\n Real integratorLoss(const Date& date, Real mktFactor) const {\n return expectedConditionalLoss(date, mktFactor) *\n copula_->density(mktFactor);\n }\n //! Portfolio loss conditional to the market factor value\n Real expectedConditionalLoss(const Date& date,\n Real mktFactor) const;\n public:\n void update();\n\n /* Expected tranche Loss calculation.\n This is computed from the first equation on page 70 (not numbered)\n Notice that while we want to compute:\n \\f[\n EL(t) = \\sum_{l_k}l_k P(l;t) =\n \\sum_{l_k}l_k \\int P(l_k;t|\\omega) d\\omega q(\\omega)\n \\f]\n One can invert the sumation and the integral order to:\n \\f[\n EL(t) = \\int\\,q(\\omega)\\,d\\omega\\,\\sum_{l_k}\\,l_k\\,P(l_k;t|\\omega) =\n \\int\\,q(\\omega)\\,d\\omega\\,EL(t|\\omega)\n \\f]\n and this is the way it is integrated here. The recursion formula makes\n it easier this way.\n */\n Real expectedTrancheLoss(const Date& date) const {\n return\n integral_(boost::bind(\n &RecursiveCdoEngine::integratorLoss,\n this,\n date,\n _1)\n );\n }\n protected:\n const Handle correlQuote_;\n mutable RelinkableHandle copula_;\n private:\n // loss model descriptor members\n Size nBuckets_;\n const GaussHermiteIntegration integral_;\n mutable std::vector wk_;\n mutable Real loss_unit_;\n //! name to name factor loadings (betas). In the single factor copula:\n // correl = beta * beta\n // When constructing through a single correlation number the factor is\n // taken to be the positive swuare root of this number in the copula.\n mutable std::vector oneFactorCorrels_;\n };\n\n\n template \n void RecursiveCdoEngine::update() {\n oneFactorCorrels_.clear();\n CDOEngine::update();\n }\n\n\n template \n void RecursiveCdoEngine::initialize() const {\n wk_.clear();\n Date today = Settings::instance().evaluationDate();\n Date start = this->arguments_.schedule.startDate();\n boost::shared_ptr& basket = this->arguments_.basket;\n /*\n Remove defaulted names and adjust the subordination.\n */\n std::vector names =\n basket->remainingNames(start, today);\n std::vector notionals\n = basket->remainingNotionals(start, today);\n Real a = basket->remainingAttachmentRatio(start, today);\n Real d = basket->remainingDetachmentRatio(start, today);\n const boost::shared_ptr pool = basket->pool();\n this->remainingBasket_ =\n boost::shared_ptr(new Basket(names, notionals, pool,\n basket->remainingDefaultKeys(start, today),\n basket->remainingRecModels(start, today),\n a, d));\n\n this->results_.xMin = this->remainingBasket_->attachmentAmount();\n this->results_.xMax = this->remainingBasket_->detachmentAmount();\n this->results_.remainingNotional =\n this->results_.xMax - this->results_.xMin;\n //----------------------------------------------------------------\n if(oneFactorCorrels_.empty())\n oneFactorCorrels_ = std::vector(names.size(),\n correlQuote_->value());\n // check size of factors:\n QL_REQUIRE(oneFactorCorrels_.size() == names.size(),\n \"Size of matrix must match number of names in the basket.\");\n //\n std::vector lgdsTmp, lgds = this->remainingBasket_->LGDs();\n lgdsTmp = lgds;\n lgds.erase(std::remove(lgds.begin(), lgds.end(), 0.), lgds.end());\n loss_unit_ = *(std::min_element(lgds.begin(), lgds.end()))\n / nBuckets_;\n\n for(Size i = 0; i(pool->size(), oneFactorCorrels_[0]);\n else\n QL_REQUIRE(oneFactorCorrels_.size() == this->remainingBasket_->size(),\n \"Incompatible correl matrix, pool size.\");\n //----------------------------------------------------------------\n const std::vector& dates = this->arguments_.schedule.dates();\n for (Size i = 0; i < dates.size(); i++) {\n if (dates[i] <= today)\n this->results_.expectedTrancheLoss.push_back(0.0);\n else {\n Real L = expectedTrancheLoss(dates[i]);\n this->results_.expectedTrancheLoss.push_back(L);\n }\n }\n\n }\n\n\n //! Portfolio loss conditional to the market factor value\n template \n Real RecursiveCdoEngine::expectedConditionalLoss(\n const Date& date,\n Real mktFactor) const {\n const std::vector& names = this->remainingBasket_->names();\n\n // eq. 10 p.68\n // attainable losses distribution, recursive algorithm\n std::vector uncDefProb =\n this->remainingBasket_->probabilities(date);;\n std::map pIndepDistrib;\n // K=0\n pIndepDistrib.insert(std::make_pair(0., 1.));\n for(Size iName=0; iNamesetValue(oneFactorCorrels_[iName]);\n\n Probability pDef =\n copula_->conditionalProbability(uncDefProb[iName],\n mktFactor);\n // iterate on all possible losses in the distribution:\n std::map pDistTemp;\n std::map::iterator distIt =\n pIndepDistrib.begin();\n while(distIt != pIndepDistrib.end()) {\n // update prob if this name does not default\n std::map::iterator matchIt\n = pDistTemp.find(distIt->first);\n if(matchIt != pDistTemp.end()) {\n matchIt->second += distIt->second * (1.-pDef);\n }else{\n pDistTemp.insert(std::make_pair(distIt->first,\n distIt->second * (1.-pDef)));\n }\n // and if it does\n matchIt = pDistTemp.find(distIt->first + wk_[iName]);\n if(matchIt != pDistTemp.end()) {\n matchIt->second += distIt->second * pDef;\n }else{\n pDistTemp.insert(std::make_pair(\n distIt->first+wk_[iName], distIt->second * pDef));\n }\n distIt++;\n }\n // copy back\n pIndepDistrib = pDistTemp;\n }\n\n // get the expected value subject to the value of the market\n // factor.\n Real expLoss = 0.;\n //---------------------------------------------------------------\n /* This is the original (easy to read) loop which I have partially\n unroll below to take profit of the fact that once we go over\n the tranche top the loss amount is fixed:\n\n std::map::iterator distIt =\n pIndepDistrib.begin();\n while(distIt != pIndepDistrib.end()) {\n Real loss = distIt->first * loss_unit_\n ;\n loss = std::max(std::min(loss,\n results_.xMax)-results_.xMin, 0.);\n expLoss += loss * distIt->second;\n distIt++;\n }\n return expLoss ;\n */\n //---------------------------------------------------------------\n Real relativeMax = this->results_.xMax / loss_unit_;\n Real relativeMin = this->results_.xMin / loss_unit_;\n Size relativeMinIdx = std::floor(relativeMin);\n std::map::iterator\n distIt = pIndepDistrib.lower_bound(relativeMinIdx),\n itTop = pIndepDistrib.lower_bound(relativeMax);\n for(; distIt != itTop; distIt++)\n expLoss += std::max(std::min(distIt->first, relativeMax)\n -relativeMin, 0.) * distIt->second;\n Real sumProbs = 0.;\n for(;distIt != pIndepDistrib.end(); distIt++)\n sumProbs += distIt->second;\n return expLoss * loss_unit_ + this->results_.remainingNotional * sumProbs;\n }\n\n\n\n // Partial specializations on the copula type. Kind\n // of template virtual constructions. Allows to own the correlation\n // quote and the copula for each specific copula type. It only\n // needs to know its particular copula constructor.\n // These and the base correlation pricers use a unifactorial copula\n // which needs to be modified for different parameters of the\n // correlation per name to name if theres such an structure or\n // because the correlation parameter has got a time or/and loss\n // level surface.\n //\n // TO do: Correlation matrix constructors.\n\n //! Specialization for Gaussian copula, the integration still remains\n // to be defined by the user out of the available ones in\n // syntheticcdoengines.\n template \n class GaussianRecursiveCdoEngine : public\n RecursiveCdoEngine {\n public:\n //! quote constructor.\n GaussianRecursiveCdoEngine(\n const Handle& correlQuote,\n Size nbuckets = 1,\n Size quadOrder = 12,\n Real maxval = 5.,\n Size steps = 50)\n :\n RecursiveCdoEngine(correlQuote,\n nbuckets, quadOrder) {\n this->copula_.linkTo(boost::shared_ptr(\n new OneFactorGaussianCopula(correlQuote, maxval, steps)), true);\n }\n };\n\n template \n class StudentRecursiveCdoEngine : public\n RecursiveCdoEngine {\n public:\n //! quote constructor.\n StudentRecursiveCdoEngine(\n const Handle& correlQuote,\n Size nz,\n Size nm,\n Size nbuckets = 1,\n Size quadOrder = 12,\n Real maxval = 5.,\n Size steps = 50)\n :\n RecursiveCdoEngine(correlQuote,\n nbuckets, quadOrder) {\n this->copula_.linkTo(boost::shared_ptr(\n new OneFactorStudentCopula(correlQuote, nz, nm, maxval, steps)), true);\n }\n };\n\n\n\n typedef GaussianRecursiveCdoEngine GaussRecCDOEngine;\n typedef StudentRecursiveCdoEngine StudentRecCDOEngine;\n\n}\n\n#endif\n", "meta": {"hexsha": "876d33a2d437fd5e4c443b4fac10cef1df8d5641", "size": 14752, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "ql/experimental/credit/recursivecdoengine.hpp", "max_stars_repo_name": "quantosaurosProject/quantLib", "max_stars_repo_head_hexsha": "84b49913d3940cf80d6de8f70185867373f45e8d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ql/experimental/credit/recursivecdoengine.hpp", "max_issues_repo_name": "quantosaurosProject/quantLib", "max_issues_repo_head_hexsha": "84b49913d3940cf80d6de8f70185867373f45e8d", "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": "ql/experimental/credit/recursivecdoengine.hpp", "max_forks_repo_name": "quantosaurosProject/quantLib", "max_forks_repo_head_hexsha": "84b49913d3940cf80d6de8f70185867373f45e8d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-03-29T05:44:27.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T05:44:27.000Z", "avg_line_length": 41.9090909091, "max_line_length": 91, "alphanum_fraction": 0.5797180043, "num_tokens": 3250, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278788223264, "lm_q2_score": 0.6224593171945417, "lm_q1q2_score": 0.5492754549251732}} {"text": "#include \n#include \n\n\n#include \n#include \n#include \n\n#include \n#include \n\n#include \"NRGclasses.hpp\"\n#include \"NRGfunctions.hpp\"\n#include \"TwoChQS.hpp\"\n\n#ifndef pi\n#define pi 3.141592653589793238462643383279502884197169\n#endif\n\n\n\n\nint main (int argc, char* argv[]){\n\n //char ModelOption[]=\"Anderson\";\n //int ModelNo=0;\n\n // command-line model options\n#include\"ModelOpt.cpp\"\n\n CNRGarray Aeig(2);\n\n CNRGbasisarray AeigCut(2);\n\n CNRGbasisarray Abasis(2);\n\n CNRGbasisarray SingleSite(3);\n\n CNRGmatrix* MatArray;\n int NumNRGarrays=2;\n // MatArray 0 is nd\n // MatArray 1 is cd\n\n\n // Thermodynamics\n CNRGthermo Suscep;\n CNRGthermo Entropy;\n\n\n // STL vector\n\n CNRGmatrix Qm1fNQ[2];\n\n CNRGmatrix MQQp1;\n\n double U,ed,Gamma1,Gamma2;\n vector Params;\n double Lambda;\n double HalfLambdaFactor;\n double Dband=1.0;\n int calcdens;\n\n double DN=0.0;\n double TM=0.0;\n double betabar=0.727;\n double Temp=0.0;\n double Sus=0.0;\n //vector SuscepChain;\n char arqSus[32],arqname[32];\n\n\n\n double chi_m1,chi_N[2];\n double daux[4];\n\n int Nsites=0,Nsitesmax=2;\n\n int Ncutoff=700;\n int UpdateBefCut=0;\n int auxIn;\n\n // outstream\n ofstream OutFile;\n // instream\n ifstream InFile;\n\n\n int ii,jj,i1,i2;\n\n // STL iterator:\n\n vector::iterator diter;\n\n // Phonon\n // Test!! Remove later\n double Nph=1.0;\n double w0=0.2;\n double lambda=0.4;\n double alpha=0.4;\n double tp=0.2;\n\n\n /// ///\n /// Begin code ///\n /// ///\n U=0.5;\n ed=-0.5*U;\n Gamma1=0.0282691;\n Gamma2=0.0;\n Lambda=2.5;\n \n // Steps: Input parameters\n InFile.open(\"nrg_input_TwoCh.dat\");\n if (InFile.is_open())\n {\n InFile >> Nsitesmax;\n InFile >> Ncutoff;\n InFile >> U;\n InFile >> Gamma1;\n InFile >> Gamma2;\n InFile >> ed;\n InFile >> Lambda;\n InFile >> Dband;\n InFile >> auxIn;\n InFile >> UpdateBefCut;\n InFile >> calcdens;\n }\n else cout << \"can't open nrg_input_TwoCh.dat\" << endl;\n\n InFile.close();\n\n if (ModelNo==4)\n {\n InFile.open(\"Input_Phonon.dat\");\n if (InFile.is_open())\n\t{\n\t InFile >> Nph;\n\t InFile >> w0;\n\t InFile >> lambda;\n\t InFile >> tp;\n\t InFile >> alpha;\n\t}\n else cout << \"can't open Input_Phonon.dat\" << endl;\n InFile.close();\n Gamma1=pi*tp*tp;\n Gamma2=alpha*alpha*Gamma1;\n }\n // end if phonon\n\n\n ///////////////////////////\n ///////////////////////////\n\n // New stuff\n strcpy(Suscep.ArqName,\"SuscepImp2Ch_25_726.dat\");\n strcpy(Suscep.ChainArqName,\"SuscepChain2Ch.dat\");\n Suscep.Calc=CalcSuscep;\n \n strcpy(Entropy.ArqName,\"EntropyImp2Ch_25_726.dat\");\n strcpy(Entropy.ChainArqName,\"EntropyChain2Ch.dat\");\n Entropy.Calc=CalcEntropy;\n\n // Chain model\n if(ModelNo==3) calcdens=3;\n\n if (calcdens==2)\n {\n Suscep.CalcChain=false;\n Entropy.CalcChain=false;\n Suscep.Nsite0Chain=0; // Anderson chains\n Entropy.Nsite0Chain=0; // Anderson chains\n \n if ( (!FileExists(Suscep.ChainArqName))||\n\t (!FileExists(Entropy.ChainArqName)) )\n\t {\n\t cout << \" Can't find chain files: \" << endl \n\t\t<< \" \" << Suscep.ChainArqName << endl\n\t\t<< \" \" << Entropy.ChainArqName << endl;\n\t cout << \" Exiting... \" << endl;\n\t exit(0);\n\t }\n else\n\t cout << \" Found files \" \n\t << Suscep.ChainArqName << \", \" \n\t << Entropy.ChainArqName \n\t << endl;\n }\n if (calcdens==3)\n {\n //strcpy(arqSus,\"SuscepChain.dat\");\n Suscep.CalcChain=true;\n Entropy.CalcChain=true;\n if ( (FileExists(Suscep.ChainArqName))||\n\t (FileExists(Entropy.ChainArqName)) )\n\t {\n\t cout << \" Error: Chain files already exist: \" << endl\n\t\t<< \" \" << Suscep.ChainArqName << endl\n\t\t<< \" \" << Entropy.ChainArqName << endl;\n\t cout << \" Not rewriting. Exiting... \" << endl;\n\t exit(0);\n\t }\n U=0.0;ed=0.0;Gamma1=0.0;Gamma2=0.0;\n }\n\n ///////////////////////////\n ///////////////////////////\n\n HalfLambdaFactor=0.5*(1.0+(1.0/Lambda));\n chi_m1=sqrt(2.0*Gamma1/pi)/(sqrt(Lambda)*HalfLambdaFactor);\n\n double U_tilde=0.5*U/HalfLambdaFactor;\n double ed_tilde=ed/HalfLambdaFactor;\n double Gamma1_tilde=Gamma1*(2.0/pi)/(HalfLambdaFactor*HalfLambdaFactor);\n double Gamma2_tilde=Gamma2*(2.0/pi)/(HalfLambdaFactor*HalfLambdaFactor);\n\n\n OutFile.open(\"NRG_in.txt\");\n OutFile << \"Begin NRG 2-ch calculation\" << endl;\n OutFile << \" Model : \" << ModelOption << endl;\n OutFile << \" Nsitesmax = \" << Nsitesmax-1 << endl;\n OutFile << \" Ncutoff = \" << Ncutoff << endl;\n OutFile << \" U = \" << U << endl;\n OutFile << \" Gamma1 = \" << Gamma1 << endl;\n OutFile << \" Gamma2 = \" << Gamma2 << endl;\n OutFile << \" ed = \" << ed << endl;\n OutFile << \" Lambda = \" << Lambda << endl;\n OutFile << \" Dband = \" << Dband << endl;\n OutFile << \" UpdateBefCut = \" << UpdateBefCut << endl;\n OutFile << \" calcdens = \" << calcdens << endl;\n OutFile << \"=================================\" << endl;\n OutFile << \"U~ = \" << U_tilde << endl;\n OutFile << \"ed~ = \" << ed_tilde << endl;\n OutFile << \"Gamma1~ = \" << Gamma1_tilde<< endl;\n OutFile << \"Gamma2~ = \" << Gamma2_tilde<< endl;\n OutFile << \"=================================\" << endl;\n if (ModelNo==4)\n {\n OutFile << \"Nph = \" << Nph << endl;\n OutFile << \"w0 = \" << w0 << endl;\n OutFile << \"lambda = \" << lambda << endl;\n OutFile << \"tp = \" << tp << endl;\n OutFile << \"alpha = \" << alpha << endl;\n OutFile << \"chi_S_tilde = \" << sqrt(Gamma1_tilde) << endl;\n OutFile << \"chi_A_tilde = \" << alpha*sqrt(Gamma1_tilde) << endl;\n OutFile << \"=================================\" << endl;\n }\n OutFile.close();\n\n\n\n // Define H0 (impurity + 1s site)\n // Output:\n // Aeig,\n // fd_{1sigma} and fd_{2sigma} matrix elements\n //\n\n // Set single site (use pointers in the subroutines!!)\n\n TwoChQS_SetSingleSite(&SingleSite);\n\n Params.push_back(U_tilde/sqrt(Lambda));\n Params.push_back(ed_tilde/sqrt(Lambda));\n Params.push_back(sqrt(Gamma1_tilde/Lambda));\n Params.push_back(sqrt(Gamma2_tilde/Lambda));\n\n Nsites=0;\n DN=HalfLambdaFactor*pow(Lambda,(-(Nsites-1)/2.0) );\n TM=DN/betabar;\n cout << \"DN = \" << DN << \" TM = \" << TM << endl;\n\n\n\n switch (ModelNo)\n {\n case 0 :\n TwoChQS_SetH0Anderson(Params,&SingleSite,&Aeig,&Abasis);\n Suscep.dImpValue=1.0/8.0;\n Entropy.dImpValue=2.0*log(2.0);\n break;\n\n case 1 :\n cout << \" Testing 2ch Kondo model. \" << endl;\n Params.clear();\n Params.push_back(Gamma1);\n Params.push_back(Gamma2);\n TwoChQS_SetH0Kondo(Params,&SingleSite,&Aeig,&Abasis,MatArray);\n Suscep.dImpValue=1.0/4.0;\n Entropy.dImpValue=log(2.0);\n break;\n\n case 3 :\n TwoChQS_SetH0Chain(Params,&SingleSite,&Aeig,&Abasis);\n Suscep.dImpValue=0.0;\n Entropy.dImpValue=0.0; // Check this!!\n Suscep.CalcChain=true;\n Entropy.CalcChain=true;\n break;\n case 4 :\n Params.push_back(w0); //\n Params.push_back(lambda); //\n Params.push_back(alpha); //\n Params.push_back(Nph); //\n // Using the untransformed Hamiltonian\n //TwoChQS_SetH0CMphononwTransf(Params,&SingleSite,&Aeig,&Abasis,MatArray);\n TwoChQS_SetH0CMphonon(Params,&SingleSite,&Aeig,&Abasis,MatArray);\n // Qm1fQ needs special updates\n for (int ich=0;ich<=1;ich++)\n\t{\n\t Qm1fNQ[ich].NeedOld=false;\n\t Qm1fNQ[ich].CheckForMatEl=TwoChQS_cd_check;\n\t}\n\n Qm1fNQ[0].CalcMatEl=TwoChQS_cd_ich1_Phonon_MatEl;\n Qm1fNQ[1].CalcMatEl=TwoChQS_cd_ich2_Phonon_MatEl;\n /////////\n Suscep.dImpValue=0.0;\n Entropy.dImpValue=0.0; // Check this!!\n strcpy(Suscep.ArqName,\"SuscepImp2Ch_Phonon.dat\");\n strcpy(Entropy.ArqName,\"EntropyImp2Ch_Phonon.dat\");\n // Update with a new scheme\n cout << \" Updating! \" << endl;\n AeigCut.CNRGbasisarray::ClearAll();\n AeigCut=CutStates(&Aeig, Ncutoff);\n UpdateMatrices(&SingleSite,&AeigCut, \n\t\t &Abasis,&Qm1fNQ[0], 2);\n\n break;\n default :\n cout << \" Model not implemented. Exiting... \" << endl;\n exit(0);\n break;\n }\n //end switch models\n\n Aeig.PrintEn();\n\n if (ModelNo!=4){TwoChQS_UpdateQm1fQ(&SingleSite,&Aeig,&Abasis,Qm1fNQ);}\n\n cout << \" f0_ch1 : \" << endl;\n //Qm1fNQ[0].PrintAllBlocks();\n Qm1fNQ[0].PrintMatBlock(1,3);\n Qm1fNQ[0].PrintMatBlock(2,3);\n cout << \" f0_ch1 : \" << endl;\n //Qm1fNQ[1].PrintAllBlocks();\n Qm1fNQ[1].PrintMatBlock(1,3);\n Qm1fNQ[1].PrintMatBlock(2,3);\n\n\n // Calculate Susceptibility at Nsites=0!\n\n if ( (calcdens==2)||(calcdens==3) )\n {\n TM=DN/betabar;\n Params.clear();\n Params.push_back(betabar);\n\n Suscep.ReadNChainValue(Nsites,0);\n Suscep.AddValue(Params,&Aeig,1,true,TM);\n Suscep.SaveNValue(Nsites,0);\n \n Entropy.ReadNChainValue(Nsites,0);\n Entropy.AddValue(Params,&Aeig,1,true,TM);\n Entropy.SaveNValue(Nsites,0);\n\n }\n //end if calcdens=2 or 3\n\n //TwoChQS_UpdateQm1fQ(&SingleSite,&Aeig,&Abasis,Qm1fNQ);\n\n\n\n // Check Matrix\n// for (int ich=1;ich<=2;ich++)\n// {\n// cout << \" Printing Qm1fQ channel: \" << ich << endl;\n// for (int ibl=0; ibl1) )\n\t{\n\t cout << \"Updating matrices after cutting... \" << endl; \n\t TwoChQS_UpdateMatrixAfterCutting(&SingleSite,\n\t \t\t\t\t &AeigCut, &Abasis, Qm1fNQ, &MQQp1);\n\t cout << \"... done updating matrices. \" << endl;\n\t}\n\n // Spec density calculation, other similar things woudl go HERE\n\n // This is where the loop really begins...\n\n QS_BuildBasis(&AeigCut,&Abasis,&SingleSite,UpdateBefCut);\n\n\n cout << \"No blocks = \" << Abasis.NumBlocks() << endl;\n \n cout << \"No states = \" << Abasis.Nstates() << endl;\n\n //Abasis.PrintAll();\n\n\n // 2 - Build and diagonalize H_N+1\n\n Params.clear();\n Params.push_back(chi_N[0]);\n Params.push_back(chi_N[1]);\n Params.push_back(Lambda);\n\n cout << \"Diagonalizing HN... \" << endl; \n\n TwoChQS_DiagHN(Params,&Abasis,&SingleSite,Qm1fNQ,&Aeig);\n\n Aeig.PrintEn();\n\n cout << \"..done diagonalizing HN. \" << endl; \n\n // 3 - Update Qm1f1NQ, Qm1f2Q, Qm1cdQ, etc.\n\n if ( (UpdateBefCut==1)&&(Nsites> Temp >> daux[0] >> daux[0] >> Sus;\n// \t SuscepChain.push_back(Sus);\n// \t }\n// \t SuscepChain.pop_back();\n// \t if (SuscepChain.size()> daux[0] >> daux[0] >> daux[0] >> Sus0;\n// \t\t nlines++;\n// \t\t}\n// \t }\n// \t InFile.close();\n// \t}\n// else \n// \tSus-=1.0/8.0; // exclude dot site in the chain.\n// if (Nsites==0) OutFile.open(arqSus);\n// else OutFile.open(arqSus,ofstream::app);\n// OutFile.precision(20);\n// OutFile << scientific << TM << \" \" << Sus << \" \" << Sus0 << \" \" << Sus-Sus0 << endl;\n// OutFile.close();\n\n\n// \t Sus=CalcSuscep(Params,&Aeig,1,true);\n// \t double Sus0=0.0;\n// \t int nlines=0;\n// \t // Gets SuscepChain iteration by iteration\n// \t if (calcdens==2)\n// \t {\n// \t InFile.open(\"SuscepChain.dat\");\n// \t InFile.clear(); \n// \t InFile.seekg(0, ios::beg); // rewind\n// \t if (InFile.fail())\n// \t\t{\n// \t\t cout << \"Can't find \" << arqname << endl;\n// \t\t}\n// \t else\n// \t\t{\n// \t\t while ( (!InFile.eof())&&(nlines<=Nsites) ) \n// \t\t {\n// \t\t InFile >> daux[0] >> daux[0] >> daux[0] >> Sus0;\n// \t\t nlines++;\n// \t\t }\n// \t\t}\n// \t InFile.close();\n// \t }\n// \t //if (calcdens==2) Sus0=SuscepChain[Nsites];\n// \t else Sus-=1.0/8.0; // exclude dot site in the chain.\n\n// \t if (Nsites==0) OutFile.open(arqSus);\n// \t else OutFile.open(arqSus,ofstream::app);\n// \t OutFile.precision(20);\n// \t OutFile << scientific << TM << \" \" << Sus << \" \" << Sus0 << \" \" << Sus-Sus0 << endl;\n// \t OutFile.close();\n", "meta": {"hexsha": "483c1e908f24474e19bcbdf1c51bc2fac836c947", "size": 15134, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/TwoChQS/TwoChQS.cpp", "max_stars_repo_name": "lgds/NRG_USP", "max_stars_repo_head_hexsha": "ff66846e92498aa429cce6fc5793bec23ad03eb4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2015-09-21T20:58:45.000Z", "max_stars_repo_stars_event_max_datetime": "2019-03-20T01:21:41.000Z", "max_issues_repo_path": "src/TwoChQS/TwoChQS.cpp", "max_issues_repo_name": "lgds/NRG_USP", "max_issues_repo_head_hexsha": "ff66846e92498aa429cce6fc5793bec23ad03eb4", "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/TwoChQS/TwoChQS.cpp", "max_forks_repo_name": "lgds/NRG_USP", "max_forks_repo_head_hexsha": "ff66846e92498aa429cce6fc5793bec23ad03eb4", "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.0562913907, "max_line_length": 93, "alphanum_fraction": 0.5627064887, "num_tokens": 5036, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920020959544, "lm_q2_score": 0.6859494550081925, "lm_q1q2_score": 0.5492342424671384}} {"text": "// Copyright 2017 Nicolas Mellado\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//\n// Authors: Dror Aiger, Yoni Weill, Nicolas Mellado\n//\n// This file is part of the implementation of the 4-points Congruent Sets (4PCS)\n// algorithm presented in:\n//\n// 4-points Congruent Sets for Robust Surface Registration\n// Dror Aiger, Niloy J. Mitra, Daniel Cohen-Or\n// ACM SIGGRAPH 2008 and ACM Transaction of Graphics.\n//\n// Given two sets of points in 3-space, P and Q, the algorithm applies RANSAC\n// in roughly O(n^2) time instead of O(n^3) for standard RANSAC, using an\n// efficient method based on invariants, to find the set of all 4-points in Q\n// that can be matched by rigid transformation to a given set of 4-points in P\n// called a base. This avoids the need to examine all sets of 3-points in Q\n// against any base of 3-points in P as in standard RANSAC.\n// The algorithm can use colors and normals to speed-up the matching\n// and to improve the quality. It can be easily extended to affine/similarity\n// transformation but then the speed-up is smaller because of the large number\n// of congruent sets. The algorithm can also limit the range of transformations\n// when the application knows something on the initial pose but this is not\n// necessary in general (though can speed the runtime significantly).\n\n// Home page of the 4PCS project (containing the paper, presentations and a\n// demo): http://graphics.stanford.edu/~niloy/research/fpcs/fpcs_sig_08.html\n// Use google search on \"4-points congruent sets\" to see many related papers\n// and applications.\n\n#include \"super4pcs/algorithms/match4pcsBase.h\"\n#include \"super4pcs/shared4pcs.h\"\n#include \"super4pcs/sampling.h\"\n#include \"super4pcs/accelerators/kdtree.h\"\n\n#include \n#include \n\n#include \n#include \n\nconst double pi = std::acos(-1);\n\n\n\n// Compute the closest points between two 3D line segments and obtain the two\n// invariants corresponding to the closet points. This is the \"intersection\"\n// point that determines the invariants. Since the 4 points are not exactly\n// planar, we use the center of the line segment connecting the two closest\n// points as the \"intersection\".\ntemplate < typename VectorType, typename Scalar>\nstatic Scalar\ndistSegmentToSegment(const VectorType& p1, const VectorType& p2,\n const VectorType& q1, const VectorType& q2,\n Scalar& invariant1, Scalar& invariant2) {\n\n static const Scalar kSmallNumber = 0.0001;\n VectorType u = p2 - p1;\n VectorType v = q2 - q1;\n VectorType w = p1 - q1;\n Scalar a = u.dot(u);\n Scalar b = u.dot(v);\n Scalar c = v.dot(v);\n Scalar d = u.dot(w);\n Scalar e = v.dot(w);\n Scalar f = a * c - b * b;\n // s1,s2 and t1,t2 are the parametric representation of the intersection.\n // they will be the invariants at the end of this simple computation.\n Scalar s1 = 0.0;\n Scalar s2 = f;\n Scalar t1 = 0.0;\n Scalar t2 = f;\n\n if (f < kSmallNumber) {\n s1 = 0.0;\n s2 = 1.0;\n t1 = e;\n t2 = c;\n } else {\n s1 = (b * e - c * d);\n t1 = (a * e - b * d);\n if (s1 < 0.0) {\n s1 = 0.0;\n t1 = e;\n t2 = c;\n } else if (s1 > s2) {\n s1 = s2;\n t1 = e + b;\n t2 = c;\n }\n }\n\n if (t1 < 0.0) {\n t1 = 0.0;\n if (-d < 0.0)\n s1 = 0.0;\n else if (-d > a)\n s1 = s2;\n else {\n s1 = -d;\n s2 = a;\n }\n } else if (t1 > t2) {\n t1 = t2;\n if ((-d + b) < 0.0)\n s1 = 0;\n else if ((-d + b) > a)\n s1 = s2;\n else {\n s1 = (-d + b);\n s2 = a;\n }\n }\n invariant1 = (std::abs(s1) < kSmallNumber ? 0.0 : s1 / s2);\n invariant2 = (std::abs(t1) < kSmallNumber ? 0.0 : t1 / t2);\n\n return ( w + (invariant1 * u) - (invariant2 * v)).norm();\n}\n\n\nnamespace GlobalRegistration{\n\nMatch4PCSBase::Match4PCSBase( const Match4PCSOptions& options\n , const Utils::Logger& logger\n#ifdef SUPER4PCS_USE_OPENMP\n , const int omp_nthread_congruent\n#endif\n )\n :number_of_trials_(0)\n , max_base_diameter_(-1)\n , P_mean_distance_(1.0)\n , best_LCP_(0.0)\n , options_(options)\n , randomGenerator_(options.randomSeed)\n , logger_(logger)\n#ifdef SUPER4PCS_USE_OPENMP\n , omp_nthread_congruent_(omp_nthread_congruent)\n#endif\n{\n base_3D_.resize(4);\n}\n\nMatch4PCSBase::~Match4PCSBase(){}\n\nMatch4PCSBase::Scalar\nMatch4PCSBase::MeanDistance() {\n const Scalar kDiameterFraction = 0.2;\n using RangeQuery = GlobalRegistration::KdTree::RangeQuery<>;\n\n int number_of_samples = 0;\n Scalar distance = 0.0;\n\n for (size_t i = 0; i < sampled_P_3D_.size(); ++i) {\n\n RangeQuery query;\n query.sqdist = P_diameter_ * kDiameterFraction;\n query.queryPoint = sampled_P_3D_[i].pos().cast();\n\n GlobalRegistration::KdTree::Index resId =\n kd_tree_.doQueryRestrictedClosestIndex(query , i);\n\n if (resId != GlobalRegistration::KdTree::invalidIndex()) {\n distance += (sampled_P_3D_[i].pos() - sampled_P_3D_[resId].pos()).norm();\n number_of_samples++;\n }\n }\n\n return distance / number_of_samples;\n}\n\n\nbool Match4PCSBase::SelectRandomTriangle(int &base1, int &base2, int &base3) {\n int number_of_points = sampled_P_3D_.size();\n base1 = base2 = base3 = -1;\n\n // Pick the first point at random.\n int first_point = randomGenerator_() % number_of_points;\n\n const Scalar sq_max_base_diameter_ = max_base_diameter_*max_base_diameter_;\n\n // Try fixed number of times retaining the best other two.\n Scalar best_wide = 0.0;\n for (int i = 0; i < kNumberOfDiameterTrials; ++i) {\n // Pick and compute\n const int second_point = randomGenerator_() % number_of_points;\n const int third_point = randomGenerator_() % number_of_points;\n const VectorType u =\n sampled_P_3D_[second_point].pos() -\n sampled_P_3D_[first_point].pos();\n const VectorType w =\n sampled_P_3D_[third_point].pos() -\n sampled_P_3D_[first_point].pos();\n // We try to have wide triangles but still not too large.\n Scalar how_wide = (u.cross(w)).norm();\n if (how_wide > best_wide &&\n u.squaredNorm() < sq_max_base_diameter_ &&\n w.squaredNorm() < sq_max_base_diameter_) {\n best_wide = how_wide;\n base1 = first_point;\n base2 = second_point;\n base3 = third_point;\n }\n }\n return base1 != -1 && base2 != -1 && base3 != -1;\n}\n\n\n\n// Try the current base in P and obtain the best pairing, i.e. the one that\n// gives the smaller distance between the two closest points. The invariants\n// corresponding the the base pairing are computed.\nbool Match4PCSBase::TryQuadrilateral(Scalar &invariant1, Scalar &invariant2,\n int& id1, int& id2, int& id3, int& id4) {\n\n Scalar min_distance = std::numeric_limits::max();\n int best1, best2, best3, best4;\n best1 = best2 = best3 = best4 = -1;\n for (int i = 0; i < 4; ++i) {\n for (int j = 0; j < 4; ++j) {\n if (i == j) continue;\n int k = 0;\n while (k == i || k == j) k++;\n int l = 0;\n while (l == i || l == j || l == k) l++;\n double local_invariant1;\n double local_invariant2;\n // Compute the closest points on both segments, the corresponding\n // invariants and the distance between the closest points.\n Scalar segment_distance = distSegmentToSegment(\n base_3D_[i].pos(), base_3D_[j].pos(),\n base_3D_[k].pos(), base_3D_[l].pos(),\n local_invariant1, local_invariant2);\n // Retail the smallest distance and the best order so far.\n if (segment_distance < min_distance) {\n min_distance = segment_distance;\n best1 = i;\n best2 = j;\n best3 = k;\n best4 = l;\n invariant1 = local_invariant1;\n invariant2 = local_invariant2;\n }\n }\n }\n\n if(best1 < 0 || best2 < 0 || best3 < 0 || best4 < 0 ) return false;\n\n std::vector tmp = base_3D_;\n base_3D_[0] = tmp[best1];\n base_3D_[1] = tmp[best2];\n base_3D_[2] = tmp[best3];\n base_3D_[3] = tmp[best4];\n\n std::array tmpId = {id1, id2, id3, id4};\n id1 = tmpId[best1];\n id2 = tmpId[best2];\n id3 = tmpId[best3];\n id4 = tmpId[best4];\n\n return true;\n}\n\n\n// Selects a good base from P and computes its invariants. Returns false if\n// a good planar base cannot can be found.\nbool Match4PCSBase::SelectQuadrilateral(Scalar& invariant1, Scalar& invariant2,\n int& base1, int& base2, int& base3,\n int& base4) {\n\n const Scalar kBaseTooSmall (0.2);\n int current_trial = 0;\n\n // Try fix number of times.\n while (current_trial < kNumberOfDiameterTrials) {\n // Select a triangle if possible. otherwise fail.\n if (!SelectRandomTriangle(base1, base2, base3)){\n return false;\n }\n\n base_3D_[0] = sampled_P_3D_[base1];\n base_3D_[1] = sampled_P_3D_[base2];\n base_3D_[2] = sampled_P_3D_[base3];\n\n // The 4th point will be a one that is close to be planar to the other 3\n // while still not too close to them.\n const double x1 = base_3D_[0].x();\n const double y1 = base_3D_[0].y();\n const double z1 = base_3D_[0].z();\n const double x2 = base_3D_[1].x();\n const double y2 = base_3D_[1].y();\n const double z2 = base_3D_[1].z();\n const double x3 = base_3D_[2].x();\n const double y3 = base_3D_[2].y();\n const double z3 = base_3D_[2].z();\n\n // Fit a plan.\n Scalar denom = (-x3 * y2 * z1 + x2 * y3 * z1 + x3 * y1 * z2 - x1 * y3 * z2 -\n x2 * y1 * z3 + x1 * y2 * z3);\n\n if (denom != 0) {\n Scalar A =\n (-y2 * z1 + y3 * z1 + y1 * z2 - y3 * z2 - y1 * z3 + y2 * z3) / denom;\n Scalar B =\n (x2 * z1 - x3 * z1 - x1 * z2 + x3 * z2 + x1 * z3 - x2 * z3) / denom;\n Scalar C =\n (-x2 * y1 + x3 * y1 + x1 * y2 - x3 * y2 - x1 * y3 + x2 * y3) / denom;\n base4 = -1;\n Scalar best_distance = std::numeric_limits::max();\n // Go over all points in P.\n const Scalar too_small = std::pow(max_base_diameter_ * kBaseTooSmall, 2);\n for (unsigned int i = 0; i < sampled_P_3D_.size(); ++i) {\n if ((sampled_P_3D_[i].pos()- sampled_P_3D_[base1].pos()).squaredNorm() >= too_small &&\n (sampled_P_3D_[i].pos()- sampled_P_3D_[base2].pos()).squaredNorm() >= too_small &&\n (sampled_P_3D_[i].pos()- sampled_P_3D_[base3].pos()).squaredNorm() >= too_small) {\n // Not too close to any of the first 3.\n const Scalar distance =\n std::abs(A * sampled_P_3D_[i].x() + B * sampled_P_3D_[i].y() +\n C * sampled_P_3D_[i].z() - 1.0);\n // Search for the most planar.\n if (distance < best_distance) {\n best_distance = distance;\n base4 = int(i);\n }\n }\n }\n // If we have a good one we can quit.\n if (base4 != -1) {\n base_3D_[3] = sampled_P_3D_[base4];\n if(TryQuadrilateral(invariant1, invariant2, base1, base2, base3, base4))\n return true;\n }\n }\n current_trial++;\n }\n\n // We failed to find good enough base..\n return false;\n}\n\nvoid Match4PCSBase::initKdTree(){\n size_t number_of_points = sampled_P_3D_.size();\n\n // Build the kdtree.\n kd_tree_ = GlobalRegistration::KdTree(number_of_points);\n\n for (size_t i = 0; i < number_of_points; ++i) {\n kd_tree_.add(sampled_P_3D_[i].pos());\n }\n kd_tree_.finalize();\n}\n\nbool Match4PCSBase::ComputeRigidTransformation(\n const std::array& ref,\n const std::array& candidate,\n const Eigen::Matrix& centroid1,\n Eigen::Matrix centroid2,\n Scalar max_angle,\n Eigen::Ref transform,\n Scalar& rms_,\n bool computeScale ) const {\n\n rms_ = kLargeNumber;\n\n Scalar kSmallNumber = 1e-6;\n\n // We only use the first 3 pairs. This simplifies the process considerably\n // because it is the planar case.\n\n const VectorType& p0 = ref[0].pos();\n const VectorType& p1 = ref[1].pos();\n const VectorType& p2 = ref[2].pos();\n VectorType q0 = candidate[0].pos();\n VectorType q1 = candidate[1].pos();\n VectorType q2 = candidate[2].pos();\n\n Scalar scaleEst (1.);\n\n // Compute scale factor if needed\n if (computeScale){\n const VectorType& p3 = ref[3].pos();\n const VectorType& q3 = candidate[3].pos();\n\n const Scalar ratio1 = (p1 - p0).norm() / (q1 - q0).norm();\n const Scalar ratio2 = (p3 - p2).norm() / (q3 - q2).norm();\n\n const Scalar ratioDev = std::abs(ratio1/ratio2 - Scalar(1.)); // deviation between the two\n const Scalar ratioMean = (ratio1+ratio2)/Scalar(2.); // mean of the two\n\n if ( ratioDev > Scalar(0.1) )\n return kLargeNumber;\n\n\n //Log( ratio1, \" \", ratio2, \" \", ratioDev, \" \", ratioMean);\n scaleEst = ratioMean;\n\n // apply scale factor to q\n q0 = q0*scaleEst;\n q1 = q1*scaleEst;\n q2 = q2*scaleEst;\n centroid2 *= scaleEst;\n }\n\n VectorType vector_p1 = p1 - p0;\n if (vector_p1.squaredNorm() == 0) return kLargeNumber;\n vector_p1.normalize();\n VectorType vector_p2 = (p2 - p0) - ((p2 - p0).dot(vector_p1)) * vector_p1;\n if (vector_p2.squaredNorm() == 0) return kLargeNumber;\n vector_p2.normalize();\n VectorType vector_p3 = vector_p1.cross(vector_p2);\n\n VectorType vector_q1 = q1 - q0;\n if (vector_q1.squaredNorm() == 0) return kLargeNumber;\n vector_q1.normalize();\n VectorType vector_q2 = (q2 - q0) - ((q2 - q0).dot(vector_q1)) * vector_q1;\n if (vector_q2.squaredNorm() == 0) return kLargeNumber;\n vector_q2.normalize();\n VectorType vector_q3 = vector_q1.cross(vector_q2);\n\n //cv::Mat rotation = cv::Mat::eye(3, 3, CV_64F);\n Eigen::Matrix rotation = Eigen::Matrix::Identity();\n\n Eigen::Matrix rotate_p;\n rotate_p.row(0) = vector_p1;\n rotate_p.row(1) = vector_p2;\n rotate_p.row(2) = vector_p3;\n\n Eigen::Matrix rotate_q;\n rotate_q.row(0) = vector_q1;\n rotate_q.row(1) = vector_q2;\n rotate_q.row(2) = vector_q3;\n\n rotation = rotate_p.transpose() * rotate_q;\n\n\n // Discard singular solutions. The rotation should be orthogonal.\n if (((rotation * rotation).diagonal().array() - Scalar(1) > kSmallNumber).any())\n return false;\n\n //FIXME\n if (max_angle >= 0) {\n // Discard too large solutions (todo: lazy evaluation during boolean computation\n if (! (\n std::abs(std::atan2(rotation(2, 1), rotation(2, 2)))\n <= max_angle &&\n\n std::abs(std::atan2(-rotation(2, 0),\n std::sqrt(std::pow(rotation(2, 1),2) +\n std::pow(rotation(2, 2),2))))\n <= max_angle &&\n\n std::abs(atan2(rotation(1, 0), rotation(0, 0)))\n <= max_angle\n ))\n return false;\n }\n\n\n //FIXME\n // Compute rms and return it.\n rms_ = Scalar(0.0);\n {\n VectorType first, transformed;\n\n //cv::Mat first(3, 1, CV_64F), transformed;\n for (int i = 0; i < 3; ++i) {\n first = scaleEst*candidate[i].pos() - centroid2;\n transformed = rotation * first;\n rms_ += (transformed - ref[i].pos() + centroid1).norm();\n }\n }\n\n rms_ /= Scalar(ref.size());\n\n Eigen::Transform etrans (Eigen::Transform::Identity());\n transform = etrans\n .scale(scaleEst)\n .translate(centroid1)\n .rotate(rotation)\n .translate(-centroid2)\n .matrix();\n\n return true;\n}\n\n\n\n// Verify a given transformation by computing the number of points in P at\n// distance at most (normalized) delta from some point in Q. In the paper\n// we describe randomized verification. We apply deterministic one here with\n// early termination. It was found to be fast in practice.\nMatch4PCSBase::Scalar\nMatch4PCSBase::Verify(const Eigen::Ref &mat) const {\n using RangeQuery = GlobalRegistration::KdTree::RangeQuery<>;\n\n#ifdef TEST_GLOBAL_TIMINGS\n Timer t_verify (true);\n#endif\n\n // We allow factor 2 scaling in the normalization.\n const Scalar epsilon = options_.delta;\n std::atomic_uint good_points(0);\n const size_t number_of_points = sampled_Q_3D_.size();\n const size_t terminate_value = best_LCP_ * number_of_points;\n\n const Scalar sq_eps = epsilon*epsilon;\n\n for (size_t i = 0; i < number_of_points; ++i) {\n\n // Use the kdtree to get the nearest neighbor\n#ifdef TEST_GLOBAL_TIMINGS\n Timer t (true);\n#endif\n\n RangeQuery query;\n query.queryPoint = (mat * sampled_Q_3D_[i].pos().homogeneous()).head<3>();\n query.sqdist = sq_eps;\n\n GlobalRegistration::KdTree::Index resId =\n kd_tree_.doQueryRestrictedClosestIndex( query );\n\n#ifdef TEST_GLOBAL_TIMINGS\n kdTreeTime += Scalar(t.elapsed().count()) / Scalar(CLOCKS_PER_SEC);\n#endif\n\n if ( resId != GlobalRegistration::KdTree::invalidIndex() ) {\n// Point3D& q = sampled_P_3D_[near_neighbor_index[0]];\n// bool rgb_good =\n// (p.rgb()[0] >= 0 && q.rgb()[0] >= 0)\n// ? cv::norm(p.rgb() - q.rgb()) < options_.max_color_distance\n// : true;\n// bool norm_good = norm(p.normal()) > 0 && norm(q.normal()) > 0\n// ? fabs(p.normal().ddot(q.normal())) >= cos_dist\n// : true;\n// if (rgb_good && norm_good) {\n good_points++;\n// }\n }\n\n // We can terminate if there is no longer chance to get better than the\n // current best LCP.\n if (number_of_points - i + good_points < terminate_value) {\n break;\n }\n }\n\n#ifdef TEST_GLOBAL_TIMINGS\n verifyTime += Scalar(t_verify.elapsed().count()) / Scalar(CLOCKS_PER_SEC);\n#endif\n return Scalar(good_points) / Scalar(number_of_points);\n}\n\n} // namespace Super4PCS\n\n", "meta": {"hexsha": "ef104c2a18a953fc755941f1b3f1efc9083f6062", "size": 18600, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/super4pcs/algorithms/match4pcsBase.cc", "max_stars_repo_name": "zengzhen/Super4PCS", "max_stars_repo_head_hexsha": "736f31122532f52c31dbfd6b9077bc77be518d97", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2019-05-31T01:17:10.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-07T19:52:41.000Z", "max_issues_repo_path": "src/super4pcs/algorithms/match4pcsBase.cc", "max_issues_repo_name": "RioWong/Super4PCS", "max_issues_repo_head_hexsha": "7971c7fab0ffcbe9a2a4a517c0211edc37ba7af8", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2019-11-11T14:39:20.000Z", "max_issues_repo_issues_event_max_datetime": "2019-11-11T14:39:20.000Z", "max_forks_repo_path": "src/super4pcs/algorithms/match4pcsBase.cc", "max_forks_repo_name": "RioWong/Super4PCS", "max_forks_repo_head_hexsha": "7971c7fab0ffcbe9a2a4a517c0211edc37ba7af8", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2018-10-09T12:48:28.000Z", "max_forks_repo_forks_event_max_datetime": "2019-03-22T06:09:42.000Z", "avg_line_length": 32.8042328042, "max_line_length": 109, "alphanum_fraction": 0.6137634409, "num_tokens": 5425, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006919925839875, "lm_q2_score": 0.6859494550081926, "lm_q1q2_score": 0.54923423594241}} {"text": "/*\n# linalgCpp\nCollection of basic tools or examples for linear algebra in c++\nOriginal code from https://github.com/leopoldcambier/linalgCpp\n*/\n\n#ifndef MMIO_HPP\n#define MMIO_HPP\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\nnamespace mmio {\n\n /** Read a line real / cplx **/\n template\n V read_entry(std::istringstream& vals) {\n V v;\n vals >> v;\n return v;\n };\n template<>\n std::complex read_entry(std::istringstream& vals) {\n double v1, v2;\n vals >> v1 >> v2;\n return std::complex(v1, v2);\n };\n template<>\n std::complex read_entry(std::istringstream& vals) {\n float v1, v2;\n vals >> v1 >> v2;\n return std::complex(v1, v2);\n };\n\n /** Read a line real / cplx of coordinate values **/\n template\n Eigen::Triplet read_line(std::istringstream& vals) {\n I i, j;\n V v;\n vals >> i >> j >> v;\n return Eigen::Triplet(i-1,j-1,v);\n };\n template<>\n Eigen::Triplet,int> read_line(std::istringstream& vals) {\n int i, j; double v1, v2;\n vals >> i >> j >> v1 >> v2;\n return Eigen::Triplet,int>(i-1,j-1,std::complex(v1, v2));\n };\n template<>\n Eigen::Triplet,int> read_line(std::istringstream& vals) {\n int i, j; float v1, v2;\n vals >> i >> j >> v1 >> v2;\n return Eigen::Triplet,int>(i-1,j-1,std::complex(v1, v2));\n };\n\n /** Write a line real / cplx of coordinate values **/\n template\n std::string get_line(I i, I j, V v) {\n return std::to_string(i+1) + \" \" + std::to_string(j+1) + \" \" + std::to_string(v);\n };\n template<>\n std::string get_line(int i, int j, std::complex v) {\n return std::to_string(i+1) + \" \" + std::to_string(j+1) + \" \" + std::to_string(v.real()) + \" \" + std::to_string(v.imag());\n };\n template<>\n std::string get_line(int i, int j, std::complex v) {\n return std::to_string(i+1) + \" \" + std::to_string(j+1) + \" \" + std::to_string(v.real()) + \" \" + std::to_string(v.imag());\n };\n\n /** Symmetric (real) / hermitian (cplx) **/\n template\n Eigen::Triplet symmetric(Eigen::Triplet& a) {\n return Eigen::Triplet(a.col(), a.row(), a.value());\n }\n template<>\n Eigen::Triplet,int> symmetric(Eigen::Triplet,int>& a) {\n return Eigen::Triplet,int>(a.col(), a.row(), std::conj(a.value()));\n }\n template<>\n Eigen::Triplet,int> symmetric(Eigen::Triplet,int>& a) {\n return Eigen::Triplet,int>(a.col(), a.row(), std::conj(a.value()));\n }\n\n /** Skew-symmetric (real only, really) **/\n template\n Eigen::Triplet skew_symmetric(Eigen::Triplet& a) {\n return Eigen::Triplet(a.col(), a.row(), - a.value());\n }\n\n enum class format {coordinate, array};\n enum class type {real, integer, complex, pattern};\n enum class property {general, symmetric, hermitian, skew_symmetric};\n\n std::string prop2str(property p) {\n if(p == property::general) return \"general\";\n else if(p == property::symmetric) return \"symmetric\";\n else if(p == property::hermitian) return \"hermitian\";\n else return \"skew_symmetric\";\n }\n\n template\n struct V2str {\n static std::string value() {\n if (std::is_same>::value || std::is_same>::value) {\n return \"complex\";\n } else if (std::is_integral::value) {\n return \"integer\";\n } else {\n return \"real\";\n }\n }\n };\n\n struct Header {\n bool bannerOK;\n bool objectOK;\n format f;\n type t;\n property p;\n Header(std::istringstream& header) {\n std::string banner, object, format, type, properties;\n header >> banner >> object >> format >> type >> properties;\n std::transform(object.begin(), object.end(), object.begin(), ::tolower);\n std::transform(format.begin(), format.end(), format.begin(), ::tolower);\n std::transform(type.begin(), type.end(), type.begin(), ::tolower);\n std::transform(properties.begin(), properties.end(), properties.begin(), ::tolower);\n this->bannerOK = ! banner.compare(\"%%MatrixMarket\");\n this->objectOK = ! object.compare(\"matrix\");\n assert(this->bannerOK);\n assert(this->objectOK);\n if(! format.compare(\"coordinate\")) {\n this->f = format::coordinate;\n } else if(! format.compare(\"array\")) {\n this->f = format::array;\n } else {\n assert(false);\n }\n if (! type.compare(\"real\")) {\n this->t = type::real;\n } else if (! type.compare(\"integer\")) {\n this->t = type::integer;\n } else if (! type.compare(\"complex\")) {\n this->t = type::complex;\n } else if (! type.compare(\"pattern\")) {\n this->t = type::pattern;\n } else { \n assert(false);\n }\n if (! properties.compare(\"general\")) {\n this->p = property::general;\n } else if (! properties.compare(\"symmetric\")) {\n this->p = property::symmetric;\n } else if (! properties.compare(\"skew-symmetric\")) {\n this->p = property::skew_symmetric;\n } else if (! properties.compare(\"hermitian\")) {\n this->p = property::hermitian;\n } else { \n assert(false);\n }\n }\n };\n\n /**\n * Read a sparse matrix in MM format\n */\n template\n Eigen::SparseMatrix sp_mmread(std::string filename) {\n std::ifstream mfile(filename);\n if (mfile.is_open()) {\n std::string line;\n /** Header **/\n std::getline(mfile, line);\n std::istringstream header(line);\n Header h(header);\n assert(h.f == format::coordinate);\n // assert(h.t != type::pattern);\n /** Find M N K row **/\n while(std::getline(mfile, line)) {\n if(line.size() == 0 || line[0] == '%') continue;\n else break;\n }\n I M, N, K;\n std::istringstream MNK(line);\n MNK >> M >> N >> K;\n std::vector> data;\n if(h.p != property::general) {\n data.reserve(2*K);\n } else {\n data.reserve(K);\n }\n /** Read data **/\n int lineread = 0;\n while(std::getline(mfile, line)) {\n if(line.size() == 0 || line[0] == '%') continue;\n if (h.t == type::pattern) line = line + \" 1\";\n std::istringstream vals(line);\n Eigen::Triplet dataline = read_line(vals);\n data.push_back(dataline);\n if(dataline.row() != dataline.col() && (h.p == property::symmetric || h.p == property::hermitian)) {\n Eigen::Triplet dataline2 = symmetric(dataline);\n data.push_back(dataline2);\n }\n if(dataline.row() != dataline.col() && (h.p == property::skew_symmetric)) {\n Eigen::Triplet dataline2 = skew_symmetric(dataline);\n data.push_back(dataline2);\n }\n if(h.p == property::skew_symmetric && dataline.row() == dataline.col()) {\n assert(false);\n }\n if(h.p != property::general && dataline.row() < dataline.col()) {\n assert(false);\n }\n lineread ++;\n }\n assert(lineread == K);\n Eigen::SparseMatrix A(M, N);\n A.setFromTriplets(data.begin(), data.end());\n return std::move(A);\n } else {\n throw(\"Couldn't open file\");\n }\n }\n\n /**\n * Reads a dense matrix in MM format\n */\n template\n Eigen::Matrix dense_mmread(std::string filename) {\n std::ifstream mfile(filename);\n if (mfile.is_open()) {\n std::string line;\n /** Header **/\n std::getline(mfile, line);\n std::istringstream header(line);\n Header h(header);\n assert(h.p == property::general);\n assert(h.f == format::array);\n assert(h.t != type::pattern);\n /** Find M N row **/\n while(std::getline(mfile, line)) {\n if(line.size() == 0 || line[0] == '%') continue;\n else break;\n }\n int M, N;\n std::istringstream MNK(line);\n MNK >> M >> N;\n Eigen::Matrix A(M, N); \n /** Read data **/\n int lineread = 0;\n while(std::getline(mfile, line)) {\n if(line.size() == 0 || line[0] == '%') continue;\n std::istringstream vals(line);\n V v = read_entry(vals);\n int i = (lineread % M);\n int j = (lineread / M);\n A(i,j) = v;\n lineread ++;\n }\n assert(lineread == M*N);\n return std::move(A);\n } else {\n throw(\"Couldn't open file\");\n }\n }\n\n /**\n * Reads a dense vector in MM format\n */\n template\n Eigen::Matrix vector_mmread(std::string filename) {\n std::ifstream mfile(filename);\n if (mfile.is_open()) {\n std::string line;\n /** Header **/\n std::getline(mfile, line);\n std::istringstream header(line);\n Header h(header);\n assert(h.p == property::general);\n assert(h.f == format::array);\n assert(h.t != type::pattern);\n /** Find M N row **/\n while(std::getline(mfile, line)) {\n if(line.size() == 0 || line[0] == '%') continue;\n else break;\n }\n int M, N;\n std::istringstream MNK(line);\n MNK >> M >> N;\n assert(N ==1);\n Eigen::Matrix b(M); \n /** Read data **/\n int lineread = 0;\n while(std::getline(mfile, line)) {\n if(line.size() == 0 || line[0] == '%') continue;\n std::istringstream vals(line);\n V v = read_entry(vals);\n int i = (lineread % M);\n // int j = (lineread / M);\n // A(i,j) = v;\n b(i) = v;\n lineread ++;\n }\n assert(lineread == M*N);\n return std::move(b);\n } else {\n throw(\"Couldn't open file\");\n }\n }\n\n /**\n * Writes a sparse matrix in MM format, using the optional property p.\n * Wether the matrix satisfies or not p is not verified\n */\n template\n void sp_mmwrite(std::string filename, Eigen::SparseMatrix mat, property p = property::general) {\n std::ofstream mfile;\n mfile.open (filename);\n if (mfile.is_open()) {\n std::string type = V2str::value();\n std::string prop = prop2str(p);\n mfile << \"%%MatrixMarket matrix coordinate \" << type << \" \" << prop << \"\\n\";\n int NNZ = 0;\n for (int k = 0; k < mat.outerSize(); ++k) {\n for (typename Eigen::SparseMatrix::InnerIterator it(mat,k); it; ++it) {\n if( (p == property::symmetric || p == property::hermitian) && (it.row() < it.col()) ) continue;\n if( (p == property::skew_symmetric) && (it.row() <= it.col()) ) continue;\n NNZ ++;\n }\n }\n mfile << mat.rows() << \" \" << mat.cols() << \" \" << NNZ << \"\\n\";\n for (int k = 0; k < mat.outerSize(); ++k) {\n for (typename Eigen::SparseMatrix::InnerIterator it(mat,k); it; ++it) {\n if( (p == property::symmetric || p == property::hermitian) && (it.row() < it.col()) ) continue;\n if( (p == property::skew_symmetric) && (it.row() <= it.col()) ) continue;\n mfile << get_line(it.row(), it.col(), it.value()) << \"\\n\";\n }\n }\n } else {\n throw(\"Couldn't open file\");\n }\n }\n\n /**\n * Writes a dense matrix in MM format, using the optional property p.\n * Wether the matrix satisfies or not p is not verified\n */\n template\n void dense_mmwrite(std::string filename, Eigen::Matrix mat, property p = property::general) {\n std::ofstream mfile;\n mfile.open (filename);\n if (mfile.is_open()) {\n std::string type = V2str::value();\n std::string prop = prop2str(p);\n mfile << \"%%MatrixMarket matrix array \" << type << \" \" << prop << \"\\n\";\n mfile << mat.rows() << \" \" << mat.cols() << \"\\n\";\n for(int j = 0; j < mat.cols(); j++) {\n for(int i = 0; i < mat.rows(); i++) {\n if( (p == property::symmetric || p == property::hermitian) && (i < j) ) continue;\n if( (p == property::skew_symmetric) && (i <= j) ) continue;\n mfile << mat(i,j) << \"\\n\";\n }\n }\n } else {\n throw(\"Couldn't open file\");\n }\n }\n\n}\n\n#endif", "meta": {"hexsha": "82ac2aa591813818f0f724c3d7291093324b7889", "size": 14287, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/mmio.hpp", "max_stars_repo_name": "Abeynaya/spaQR_public", "max_stars_repo_head_hexsha": "4fd28b1a23c73feb914b40e4285d5a076ffc9058", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/mmio.hpp", "max_issues_repo_name": "Abeynaya/spaQR_public", "max_issues_repo_head_hexsha": "4fd28b1a23c73feb914b40e4285d5a076ffc9058", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/mmio.hpp", "max_forks_repo_name": "Abeynaya/spaQR_public", "max_forks_repo_head_hexsha": "4fd28b1a23c73feb914b40e4285d5a076ffc9058", "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": 37.7962962963, "max_line_length": 132, "alphanum_fraction": 0.4865262126, "num_tokens": 3465, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833841649232, "lm_q2_score": 0.7090191399336401, "lm_q1q2_score": 0.5491944448475022}} {"text": "// Boost.Geometry\n\n// Copyright (c) 2017 Oracle and/or its affiliates.\n\n// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle\n\n// Use, modification and distribution is subject to the Boost Software License,\n// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#ifndef BOOST_GEOMETRY_FORMULAS_ELLIPTIC_ARC_LENGTH_HPP\n#define BOOST_GEOMETRY_FORMULAS_ELLIPTIC_ARC_LENGTH_HPP\n\n#include \n\n#include \n#include \n\n#include \n#include \n#include \n\n#include \n\nnamespace boost { namespace geometry { namespace formula\n{\n\n/*!\n\\brief Compute the arc length of an ellipse.\n*/\n\ntemplate \nclass elliptic_arc_length\n{\n\npublic :\n\n struct result\n {\n result()\n : distance(0)\n , meridian(false)\n {}\n\n CT distance;\n bool meridian;\n };\n\n template \n static result apply(T lon1, T lat1, T lon2, T lat2, Spheroid const& spheroid)\n {\n result res;\n\n CT c0 = 0;\n CT pi = math::pi();\n CT half_pi = pi/CT(2);\n CT diff = geometry::math::longitude_distance_signed(lon1, lon2);\n\n if (lat1 > lat2)\n {\n std::swap(lat1, lat2);\n }\n\n if ( math::equals(diff, c0) ||\n (math::equals(lat2, half_pi) && math::equals(lat1, -half_pi)) )\n {\n // single meridian not crossing pole\n res.distance = apply(lat2, spheroid) - apply(lat1, spheroid);\n res.meridian = true;\n }\n\n if (math::equals(math::abs(diff), pi))\n {\n // meridian crosses pole\n CT lat_sign = 1;\n if (lat1+lat2 < c0)\n {\n lat_sign = CT(-1);\n }\n res.distance = math::abs(lat_sign * CT(2) * apply(half_pi, spheroid)\n - apply(lat1, spheroid) - apply(lat2, spheroid));\n res.meridian = true;\n }\n return res;\n }\n\n // Distance computation on meridians using series approximations\n // to elliptic integrals. Formula to compute distance from lattitude 0 to lat\n // https://en.wikipedia.org/wiki/Meridian_arc\n // latitudes are assumed to be in radians and in [-pi/2,pi/2]\n template \n static CT apply(T lat, Spheroid const& spheroid)\n {\n CT const a = get_radius<0>(spheroid);\n CT const f = formula::flattening(spheroid);\n CT n = f / (CT(2) - f);\n CT M = a/(1+n);\n CT C0 = 1;\n\n if (Order == 0)\n {\n return M * C0 * lat;\n }\n\n CT C2 = -1.5 * n;\n\n if (Order == 1)\n {\n return M * (C0 * lat + C2 * sin(2*lat));\n }\n\n CT n2 = n * n;\n C0 += .25 * n2;\n CT C4 = 0.9375 * n2;\n\n if (Order == 2)\n {\n return M * (C0 * lat + C2 * sin(2*lat) + C4 * sin(4*lat));\n }\n\n CT n3 = n2 * n;\n C2 += 0.1875 * n3;\n CT C6 = -0.729166667 * n3;\n\n if (Order == 3)\n {\n return M * (C0 * lat + C2 * sin(2*lat) + C4 * sin(4*lat)\n + C6 * sin(6*lat));\n }\n\n CT n4 = n2 * n2;\n C4 -= 0.234375 * n4;\n CT C8 = 0.615234375 * n4;\n\n if (Order == 4)\n {\n return M * (C0 * lat + C2 * sin(2*lat) + C4 * sin(4*lat)\n + C6 * sin(6*lat) + C8 * sin(8*lat));\n }\n\n CT n5 = n4 * n;\n C6 += 0.227864583 * n5;\n CT C10 = -0.54140625 * n5;\n\n // Order 5 or higher\n return M * (C0 * lat + C2 * sin(2*lat) + C4 * sin(4*lat)\n + C6 * sin(6*lat) + C8 * sin(8*lat) + C10 * sin(10*lat));\n\n }\n\n // Iterative method to elliptic arc length based on\n // http://www.codeguru.com/cpp/cpp/algorithms/article.php/c5115/\n // Geographic-Distance-and-Azimuth-Calculations.htm\n // latitudes are assumed to be in radians and in [-pi/2,pi/2]\n template \n CT interative_method(T1 lat1,\n T2 lat2,\n Spheroid const& spheroid)\n {\n CT result = 0;\n CT const zero = 0;\n CT const one = 1;\n CT const c1 = 2;\n CT const c2 = 0.5;\n CT const c3 = 4000;\n\n CT const a = get_radius<0>(spheroid);\n CT const f = formula::flattening(spheroid);\n\n // how many steps to use\n\n CT lat1_deg = lat1 * geometry::math::r2d();\n CT lat2_deg = lat2 * geometry::math::r2d();\n\n int steps = c1 + (c2 + (lat2_deg > lat1_deg) ? CT(lat2_deg - lat1_deg)\n : CT(lat1_deg - lat2_deg));\n steps = (steps > c3) ? c3 : steps;\n\n //std::cout << \"Steps=\" << steps << std::endl;\n\n CT snLat1 = sin(lat1);\n CT snLat2 = sin(lat2);\n CT twoF = 2 * f - f * f;\n\n // limits of integration\n CT x1 = a * cos(lat1) /\n sqrt(1 - twoF * snLat1 * snLat1);\n CT x2 = a * cos(lat2) /\n sqrt(1 - twoF * snLat2 * snLat2);\n\n CT dx = (x2 - x1) / (steps - one);\n CT x, y1, y2, dy, dydx;\n CT adx = (dx < zero) ? -dx : dx; // absolute value of dx\n\n CT a2 = a * a;\n CT oneF = 1 - f;\n\n // now loop through each step adding up all the little\n // hypotenuses\n for (int i = 0; i < (steps - 1); i++){\n x = x1 + dx * i;\n dydx = ((a * oneF * sqrt((one - ((x+dx)*(x+dx))/a2))) -\n (a * oneF * sqrt((one - (x*x)/a2)))) / dx;\n result += adx * sqrt(one + dydx*dydx);\n }\n\n return result;\n }\n};\n\n}}} // namespace boost::geometry::formula\n\n\n#endif // BOOST_GEOMETRY_FORMULAS_ELLIPTIC_ARC_LENGTH_HPP\n", "meta": {"hexsha": "75881f3d0d5a346f12260762100189ea12db6077", "size": 6094, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "tether/boost/geometry/formulas/elliptic_arc_length.hpp", "max_stars_repo_name": "fictheader/fcolorwheel", "max_stars_repo_head_hexsha": "ae78ae582c6132964b7ef838a74cda9c075e74dc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 918.0, "max_stars_repo_stars_event_min_datetime": "2016-12-22T02:53:08.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T06:21:35.000Z", "max_issues_repo_path": "tether/boost/geometry/formulas/elliptic_arc_length.hpp", "max_issues_repo_name": "fictheader/fcolorwheel", "max_issues_repo_head_hexsha": "ae78ae582c6132964b7ef838a74cda9c075e74dc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 203.0, "max_issues_repo_issues_event_min_datetime": "2016-12-27T12:09:03.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T20:46:55.000Z", "max_forks_repo_path": "tether/boost/geometry/formulas/elliptic_arc_length.hpp", "max_forks_repo_name": "fictheader/fcolorwheel", "max_forks_repo_head_hexsha": "ae78ae582c6132964b7ef838a74cda9c075e74dc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 122.0, "max_forks_repo_forks_event_min_datetime": "2016-12-22T17:38:09.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-22T14:25:49.000Z", "avg_line_length": 28.3441860465, "max_line_length": 90, "alphanum_fraction": 0.5182146373, "num_tokens": 1809, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833737577158, "lm_q2_score": 0.7090191337850932, "lm_q1q2_score": 0.5491944327060307}} {"text": "#include \"path_finding.h\"\n\n#include \"error_handling.h\"\n#include \"rover.h\"\n#include \"geometry.h\"\n#include \"robot_configuration.h\"\n\n#include \n\n#include \n#include \n\n#include \n#include \n#include \n\n// A* path finding algorithm\ntemplate\nboost::optional GenericAStar(rbt::pose const& poseStart, \n rbt::point const& ptEnd, \n FMinimalNodeCost MinimalNodeCost, \n FForEachNeighbor ForEachNeighbor,\n\tFIsGoal IsGoal\n) {\n auto GreaterDistance = [&](TNode const& lhs, TNode const& rhs) noexcept {\n return (lhs.Position() - ptEnd).Abs() + lhs.m_fCost > (rhs.Position() - ptEnd).Abs() + rhs.m_fCost;\n };\n\n std::priority_queue, decltype(GreaterDistance)> queue(GreaterDistance);\n \n TNode nodeStart(poseStart);\n queue.push(nodeStart);\n MinimalNodeCost(nodeStart) = nodeStart.m_fCost;\n\n while(!queue.empty()) {\n auto const nodeTop = queue.top();\n queue.pop();\n\n if(MinimalNodeCost(nodeTop) < nodeTop.m_fCost) continue;\n\n if(IsGoal(nodeTop, ptEnd)) return nodeTop;\n\n ForEachNeighbor(\n nodeTop, \n [&](TNode const& nodeNeighbor) {\n if(rbt::assign_min(MinimalNodeCost(nodeNeighbor), nodeNeighbor.m_fCost)) {\n queue.push(nodeNeighbor);\n }\n });\n }\n\n return boost::none;\n}\n\nstd::vector> FindPath(cv::Mat matn, rbt::pose const& posefStart, rbt::point const& ptfEnd) {\n cv::Mat matnEroded;\n auto const nMaxExtent = std::max(c_nRobotWidth/c_nScale, c_nRobotHeight/c_nScale);\n cv::erode(\n matn, \n matnEroded, \n cv::Mat::ones(nMaxExtent, nMaxExtent, CV_8U)\n );\n \n // Include costs of traveling close to an obstacle in calculation\n cv::Mat matnGauss;\n auto const nMaxExtentOdd = 2*nMaxExtent + 1;\n cv::GaussianBlur(matnEroded, matnGauss, cv::Size(nMaxExtentOdd, nMaxExtentOdd), 0, 0);\n\n float aanMinimalCost[c_nMapExtent][c_nMapExtent];\n std::fill_n(&aanMinimalCost[0][0], c_nMapExtent*c_nMapExtent, std::numeric_limits::max());\n\n struct node {\n node() {}\n node(rbt::pose const& pose) : m_pt(pose.m_pt), m_fCost(0) {}\n node(rbt::point const& pt, float fCost) : m_pt(pt), m_fCost(fCost) {}\n\n\t\trbt::point Position() const { return m_pt; }\n\n rbt::point m_pt; // in grid coordinates\n float m_fCost;\n };\n\n auto MinimalNodeCost = [&](node const& node) noexcept -> float& {\n return aanMinimalCost[node.m_pt.x][node.m_pt.y];\n };\n\n auto ForEachNeighbor = [&](node const& n, auto fn) noexcept {\n for(int x = -1; x <= 1; ++x) {\n for(int y = -1; y <= 1; ++y) {\n auto const ptNext = n.m_pt + rbt::size(x, y);\n if((0!=x || 0!=y)\n && 128(ptNext.y, ptNext.x)) {\n fn(node(\n ptNext,\n n.m_fCost + (0==x || 0==y ? 1.0f : M_SQRT2) * (1 + (255 - matnGauss.at(ptNext.y, ptNext.x))/10)\n ));\n }\n }\n }\n };\n\tauto IsGoal = [](node const& n, rbt::point const& ptnEnd) {\n\t\treturn n.m_pt == ptnEnd;\n\t};\n\n\tauto const posenStart = ToGridCoordinate(posefStart);\n\n std::vector> vecptfResult;\n if(auto onode = GenericAStar(posenStart, ToGridCoordinate(ptfEnd), MinimalNodeCost, ForEachNeighbor, IsGoal)) {\n vecptfResult.emplace_back(ptfEnd);\n auto const ptnStart = posenStart.m_pt;\n for(auto nodePrev = *onode; nodePrev.m_pt!=ptnStart; ) {\n float fMinCost = std::numeric_limits::max();\n node nodeMin;\n ForEachNeighbor(\n nodePrev,\n [&](node const& node) {\n if(rbt::assign_min(fMinCost, MinimalNodeCost(node))) {\n nodeMin = node;\n }\n }\n );\n\n nodePrev = nodeMin;\n vecptfResult.emplace_back(ToWorldCoordinate(rbt::point(nodeMin.m_pt)));\n }\n }\n return vecptfResult;\n}\n\n\nnamespace {\n struct config_space_node {\n\t\tconfig_space_node() {}\n config_space_node(rbt::pose const& pose) : m_pose(pose) {}\n \n\t\trbt::point Position() const { return m_pose.m_pt; }\n\t\t\n\t\tint RoundedYaw() const { return (int)std::round(m_pose.m_fYaw*100); }\n\t\trbt::point RoundedPosition() const { \n\t\t\treturn rbt::point((int)std::round(m_pose.m_pt.x), (int)std::round(m_pose.m_pt.y));\n\t\t}\n rbt::pose m_pose;\n\n\t\t// as used for robot commands, encoder ticks / s?\n int m_nSpeedLeft = 0;\n int m_nSpeedRight = 0;\n\n // path cost\n float m_fCost = 0;\n\n\t\tconfig_space_node const* m_pnodeParent = nullptr;\n\n friend bool operator==(config_space_node const& lhs, config_space_node const& rhs) {\n return lhs.RoundedPosition()==rhs.RoundedPosition()\n\t\t\t\t&& lhs.RoundedYaw()==rhs.RoundedYaw()\n && lhs.m_nSpeedLeft==rhs.m_nSpeedLeft\n && rhs.m_nSpeedRight==rhs.m_nSpeedRight;\n }\n };\n\n\tconstexpr int c_nSpeedStep = 100;\n\tconstexpr double c_fTimeStep = 0.2; // s\n\tconst float c_fHighTravelDistance = encoderTicksToCm(c_nMaxSpeed*0.8*c_fTimeStep);\n}\n\nnamespace std {\n\ttemplate <> struct hash {\n\t\tsize_t operator()(config_space_node const& node) const {\n\t\t\tstd::size_t seed = 0;\n\t\t\tauto pt = node.RoundedPosition();\n\t\t\tboost::hash_combine(seed, pt.x);\n\t\t\tboost::hash_combine(seed, pt.y);\n\t\t\tboost::hash_combine(seed, node.RoundedYaw());\n\t\t\tboost::hash_combine(seed, node.m_nSpeedLeft);\n\t\t\tboost::hash_combine(seed, node.m_nSpeedRight);\n\t\t\treturn seed;\n\t\t}\n\t};\n}\n\nstd::vector> PathConfigurationSpace(cv::Mat matn, rbt::pose const& posefStart, rbt::point const& ptfEnd) {\n auto const vecptf = FindPath(matn, posefStart, ptfEnd);\n\n\t// TODO: Share code?\n\tcv::Mat matnEroded;\n auto const nMaxExtent = std::max(c_nRobotWidth/c_nScale, c_nRobotHeight/c_nScale);\n cv::erode(\n matn, \n matnEroded, \n cv::Mat::ones(nMaxExtent, nMaxExtent, CV_8U)\n );\n \n cv::Mat matnGauss;\n auto const nMaxExtentOdd = 2*nMaxExtent + 1;\n cv::GaussianBlur(matnEroded, matnGauss, cv::Size(nMaxExtentOdd, nMaxExtentOdd), 0, 0);\n\n\tcv::Mat matnPath = cv::Mat::zeros(matn.size(), CV_8U);\n\trbt::point ptnPrev = ToGridCoordinate(vecptf.front());\n\tboost::for_each(vecptf, [&](rbt::point const& ptf) {\n\t\tauto const ptnGrid = ToGridCoordinate(ptf);\n cv::line(matnPath, ptnPrev, ptnGrid, cv::Scalar(255), 50/c_nScale);\n ptnPrev = ptnGrid;\n\t});\n\n\tint cExpanded = 0;\n\tstd::unordered_map mapnodefCosts;\n\tauto onode = GenericAStar(\n\t\tposefStart, \n\t\t// Calculating a longer path in configuration space takes too much time to compute due to large state space.\n\t\t*(vecptf.end() - 80), \n\t\t[&](config_space_node const& node) noexcept -> float& {\n\t\t\treturn mapnodefCosts.emplace(node, std::numeric_limits::max()).first->second;\n\t\t},\n\t\t[&](config_space_node const& node, auto fn) noexcept {\n\t\t\t++cExpanded;\n\n\t\t\tauto const pnodeParent = [&] {\n\t\t\t\tauto const itpair = mapnodefCosts.find(node);\n\t\t\t\tASSERT(itpair!=mapnodefCosts.end());\n\t\t\t\treturn &itpair->first;\n\t\t\t}();\n\n\t\t\tfor(int nStepLeft = -1; nStepLeft <= 1; ++nStepLeft) {\n\t\t\t\t// [decelerate both, left, right, no change, accelerate right, left, both]\n\t\t\t\tfor(int nStepRight = -1; nStepRight <= 1; ++nStepRight) {\n\t\t\t\t\t// -> Calculate new positions / angle \n\t\t\t\t\tauto nodeNeighbor = node;\n\t\t\t\t\tnodeNeighbor.m_pnodeParent = pnodeParent;\n\t\t\t\t\tnodeNeighbor.m_nSpeedLeft += nStepLeft * c_nSpeedStep;\n\t\t\t\t\tnodeNeighbor.m_nSpeedRight += nStepRight * c_nSpeedStep;\n\n\t\t\t\t\tif(std::abs(nodeNeighbor.m_nSpeedLeft)<=c_nMaxSpeed\n\t\t\t\t\t&& std::abs(nodeNeighbor.m_nSpeedRight)<=c_nMaxSpeed\n\t\t\t\t\t&& std::abs(nodeNeighbor.m_nSpeedRight-nodeNeighbor.m_nSpeedLeft)<=400) \n\t\t\t\t\t{\n\t\t\t\t\t\tnodeNeighbor.m_pose = UpdatePose(\n\t\t\t\t\t\t\tnode.m_pose, \n\t\t\t\t\t\t\tnodeNeighbor.m_nSpeedLeft*c_fTimeStep, \n\t\t\t\t\t\t\tnodeNeighbor.m_nSpeedRight*c_fTimeStep\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\tcv::LineIterator itpt(\n\t\t\t\t\t\t\tmatn, \n\t\t\t\t\t\t\tToGridCoordinate(node.Position()), \n\t\t\t\t\t\t\tToGridCoordinate(nodeNeighbor.Position())\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\tfloat fWeightedCost = 0;\n\t\t\t\t\t\tfor(int i = 0; i < itpt.count; ++i, ++itpt) { \t\n\t\t\t\t\t\t\tauto const pt = rbt::point(itpt.pos());\n\t\t\t\t\t\t\t// -> check if still in range of shortest path \n\t\t\t\t\t\t\tif(matnPath.at(pt.y, pt.x)<255) {\n\t\t\t\t\t\t\t\tgoto outside_range;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// integrate costs over node.m_pt -> nodeNeighbor.m_pt\n\t\t\t\t\t\t\tfWeightedCost += std::pow((255.0 - matnGauss.at(pt.y, pt.x))/30, 2);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tfWeightedCost = std::max(1.f, fWeightedCost/itpt.count);\n\t\t\t\t\t\t\tfloat const fDistance = (nodeNeighbor.Position()-node.Position()).Abs();\n\t\t\t\t\t\t\t// Penalize several short moves, i.e., slow moves\n\t\t\t\t\t\t\tnodeNeighbor.m_fCost += fDistance * std::max(1.0, std::pow(c_fHighTravelDistance/fDistance, 2)) * fWeightedCost;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tfn(nodeNeighbor);\n\noutside_range: \n\t\t\t\t\t\t;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[](config_space_node const& node, rbt::point const ptfEnd) {\n\t\t\treturn (node.m_pose.m_pt - ptfEnd).SqrAbs() < c_nScale*c_nScale;\n\t\t}\n\t);\n\n\tstd::cout << \"Discovered \" << mapnodefCosts.size() << \" states, \" << cExpanded << \" expanded.\" << std::endl;\n\tstd::vector> vecposef;\n\tif(onode) {\t\n\t\tauto const* pnodeNext = &*onode;\n\t\twhile(pnodeNext) {\n\t\t\tstd::cout << pnodeNext->m_pose << \n\t\t\t\" (\" << pnodeNext->m_nSpeedLeft << \", \" << pnodeNext->m_nSpeedRight << \") \" << std::endl;\n\n\t\t\tvecposef.emplace_back(pnodeNext->m_pose);\n\t\t\tpnodeNext = pnodeNext->m_pnodeParent;\n\t\t}\n\t\tboost::reverse(vecposef);\n\t} \n\treturn vecposef;\n}", "meta": {"hexsha": "8b879a6c3b4f05dc81185b24f6bcdfe4863d9ae0", "size": 10041, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "raspberry/path_finding.cpp", "max_stars_repo_name": "stheophil/MappingRover2", "max_stars_repo_head_hexsha": "25d968a4f27016a3eb61b70e48d3f137887d440c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2015-11-12T11:12:50.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-27T02:15:23.000Z", "max_issues_repo_path": "raspberry/path_finding.cpp", "max_issues_repo_name": "stheophil/MappingRover2", "max_issues_repo_head_hexsha": "25d968a4f27016a3eb61b70e48d3f137887d440c", "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": "raspberry/path_finding.cpp", "max_forks_repo_name": "stheophil/MappingRover2", "max_forks_repo_head_hexsha": "25d968a4f27016a3eb61b70e48d3f137887d440c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2015-11-12T03:10:28.000Z", "max_forks_repo_forks_event_max_datetime": "2018-12-02T21:38:21.000Z", "avg_line_length": 34.2696245734, "max_line_length": 140, "alphanum_fraction": 0.6282242805, "num_tokens": 2900, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8670357735451834, "lm_q2_score": 0.63341027751814, "lm_q1q2_score": 0.5491893699394098}} {"text": "// Copyright (C) 2013 The Regents of the University of California (Regents).\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions are\n// met:\n//\n// * Redistributions of source code must retain the above copyright\n// notice, this list of conditions and the following disclaimer.\n//\n// * Redistributions in binary form must reproduce the above\n// copyright notice, this list of conditions and the following\n// disclaimer in the documentation and/or other materials provided\n// with the distribution.\n//\n// * Neither the name of The Regents or University of California nor the\n// names of its contributors may be used to endorse or promote products\n// derived from this software without specific prior written permission.\n//\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE\n// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n// POSSIBILITY OF SUCH DAMAGE.\n//\n// Please contact the author of this library if you have any questions.\n// Author: Chris Sweeney (cmsweeney@cs.ucsb.edu)\n\n// These functions are largely based off the the Ceres solver polynomial\n// functions which are not available through the public interface. The license\n// is below:\n//\n// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2012 Google Inc. All rights reserved.\n// http://code.google.com/p/ceres-solver/\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions are met:\n//\n// * Redistributions of source code must retain the above copyright notice,\n// this list of conditions and the following disclaimer.\n// * Redistributions in binary form must reproduce the above copyright notice,\n// this list of conditions and the following disclaimer in the documentation\n// and/or other materials provided with the distribution.\n// * Neither the name of Google Inc. nor the names of its contributors may be\n// used to endorse or promote products derived from this software without\n// specific prior written permission.\n//\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n// POSSIBILITY OF SUCH DAMAGE.\n//\n// Author: moll.markus@arcor.de (Markus Moll)\n// sameeragarwal@google.com (Sameer Agarwal)\n\n#include \"theia/math/polynomial.h\"\n\n#include \n#include \n\n#include \n#include \n\n#include \"theia/math/find_polynomial_roots_companion_matrix.h\"\n\nnamespace theia {\n\nusing Eigen::MatrixXd;\nusing Eigen::VectorXd;\nusing Eigen::VectorXcd;\n\nbool FindPolynomialRoots(const VectorXd& polynomial,\n VectorXd* real,\n VectorXd* imaginary) {\n return FindPolynomialRootsCompanionMatrix(polynomial, real, imaginary);\n}\n\n// Remove leading terms with zero coefficients.\nVectorXd RemoveLeadingZeros(const VectorXd& polynomial_in) {\n int i = 0;\n while (i < (polynomial_in.size() - 1) && polynomial_in(i) == 0) {\n ++i;\n }\n return polynomial_in.tail(polynomial_in.size() - i);\n}\n\nVectorXd DifferentiatePolynomial(const VectorXd& polynomial) {\n const int degree = polynomial.rows() - 1;\n CHECK_GE(degree, 0);\n\n // Degree zero polynomials are constants, and their derivative does\n // not result in a smaller degree polynomial, just a degree zero\n // polynomial with value zero.\n if (degree == 0) {\n return VectorXd::Zero(1);\n }\n\n VectorXd derivative(degree);\n for (int i = 0; i < degree; ++i) {\n derivative(i) = (degree - i) * polynomial(i);\n }\n\n return derivative;\n}\n\nVectorXd MultiplyPolynomials(const VectorXd& poly1, const VectorXd& poly2) {\n VectorXd multiplied_poly = VectorXd::Zero(poly1.size() + poly2.size() - 1);;\n for (int i = 0; i < poly1.size(); i++) {\n for (int j = 0; j < poly2.size(); j++) {\n multiplied_poly.reverse().operator()(i + j) +=\n poly1.reverse()(i) * poly2.reverse()(j);\n }\n }\n return multiplied_poly;\n}\n\nvoid DividePolynomial(const VectorXd& polynomial,\n const VectorXd& divisor,\n VectorXd* quotient,\n VectorXd* remainder) {\n // If the divisor is higher degree than the polynomial then it cannot be\n // divided so we simply return the remainder.\n if (polynomial.size() < divisor.size()) {\n *quotient = VectorXd::Zero(1);\n *remainder = polynomial;\n return;\n }\n\n VectorXd numerator = RemoveLeadingZeros(polynomial);\n VectorXd denominator;\n *quotient = VectorXd::Zero(numerator.size() - divisor.size() + 1);\n while (numerator.size() >= divisor.size()) {\n denominator = VectorXd::Zero(numerator.size());\n denominator.head(divisor.size()) = divisor;\n\n const double quotient_scalar = numerator(0) / denominator(0);\n quotient->reverse().operator()(numerator.size() - divisor.size()) =\n quotient_scalar;\n denominator = denominator * quotient_scalar;\n numerator = numerator - denominator;\n // Sometimes there are floating point errors that result in a non-zero first\n // value.\n numerator(0) = 0;\n numerator = RemoveLeadingZeros(numerator);\n }\n *remainder = numerator;\n}\n\nVectorXd AddPolynomials(const VectorXd& poly1, const VectorXd& poly2) {\n if (poly1.size() > poly2.size()) {\n VectorXd sum = poly1;\n sum.tail(poly2.size()) += poly2;\n return sum;\n } else {\n VectorXd sum = poly2;\n sum.tail(poly1.size()) += poly1;\n return sum;\n }\n}\n\nvoid FindLinearPolynomialRoots(const VectorXd& polynomial,\n VectorXd* real,\n VectorXd* imaginary) {\n CHECK_EQ(polynomial.size(), 2);\n if (real != NULL) {\n real->resize(1);\n (*real)(0) = -polynomial(1) / polynomial(0);\n }\n\n if (imaginary != NULL) {\n imaginary->setZero(1);\n }\n}\n\nvoid FindQuadraticPolynomialRoots(const VectorXd& polynomial,\n VectorXd* real,\n VectorXd* imaginary) {\n CHECK_EQ(polynomial.size(), 3);\n const double a = polynomial(0);\n const double b = polynomial(1);\n const double c = polynomial(2);\n const double D = b * b - 4 * a * c;\n const double sqrt_D = sqrt(fabs(D));\n if (real != NULL) {\n real->setZero(2);\n }\n if (imaginary != NULL) {\n imaginary->setZero(2);\n }\n\n // Real roots.\n if (D >= 0) {\n if (real != NULL) {\n // Stable quadratic roots according to BKP Horn.\n // http://people.csail.mit.edu/bkph/articles/Quadratics.pdf\n if (b >= 0) {\n (*real)(0) = (-b - sqrt_D) / (2.0 * a);\n (*real)(1) = (2.0 * c) / (-b - sqrt_D);\n } else {\n (*real)(0) = (2.0 * c) / (-b + sqrt_D);\n (*real)(1) = (-b + sqrt_D) / (2.0 * a);\n }\n }\n return;\n }\n\n // Use the normal quadratic formula for the complex case.\n if (real != NULL) {\n (*real)(0) = -b / (2.0 * a);\n (*real)(1) = -b / (2.0 * a);\n }\n if (imaginary != NULL) {\n (*imaginary)(0) = sqrt_D / (2.0 * a);\n (*imaginary)(1) = -sqrt_D / (2.0 * a);\n }\n}\n\nvoid MinimizePolynomial(const VectorXd& polynomial,\n const double x_min,\n const double x_max,\n double* optimal_x,\n double* optimal_value) {\n // Find the minimum of the polynomial at the two ends.\n //\n // We start by inspecting the middle of the interval. Technically\n // this is not needed, but we do this to make this code as close to\n // the minFunc package as possible.\n *optimal_x = (x_min + x_max) / 2.0;\n *optimal_value = EvaluatePolynomial(polynomial, *optimal_x);\n\n const double x_min_value = EvaluatePolynomial(polynomial, x_min);\n if (x_min_value < *optimal_value) {\n *optimal_value = x_min_value;\n *optimal_x = x_min;\n }\n\n const double x_max_value = EvaluatePolynomial(polynomial, x_max);\n if (x_max_value < *optimal_value) {\n *optimal_value = x_max_value;\n *optimal_x = x_max;\n }\n\n // If the polynomial is linear or constant, we are done.\n if (polynomial.rows() <= 2) {\n return;\n }\n\n const VectorXd derivative = DifferentiatePolynomial(polynomial);\n VectorXd roots_real;\n if (!FindPolynomialRoots(derivative, &roots_real, NULL)) {\n LOG(WARNING) << \"Unable to find the critical points of \"\n << \"the interpolating polynomial.\";\n return;\n }\n\n // This is a bit of an overkill, as some of the roots may actually\n // have a complex part, but its simpler to just check these values.\n for (int i = 0; i < roots_real.rows(); ++i) {\n const double root = roots_real(i);\n if ((root < x_min) || (root > x_max)) {\n continue;\n }\n\n const double value = EvaluatePolynomial(polynomial, root);\n if (value < *optimal_value) {\n *optimal_value = value;\n *optimal_x = root;\n }\n }\n}\n\n// An iterative solver to find the closest root based on an initial guess. We\n// use Laguerre's method, which is a polynomial root finding method that\n// converges to a root with very high certainty. For multiple roots, the\n// convergence is linear, otherwise it is cubic.\ndouble FindRootIterativeLaguerre(const VectorXd& polynomial,\n const double x0,\n const double epsilon,\n const int max_iter) {\n const double kSmallestValue = 1e-10;\n\n // Constant symbolic derivitives.\n const VectorXd f_prime = DifferentiatePolynomial(polynomial);\n const VectorXd f_prime_prime = DifferentiatePolynomial(f_prime);\n const double k = static_cast(polynomial.size());\n\n double x = x0;\n\n for (int i = 0; i < max_iter; i++) {\n const double f_of_x = EvaluatePolynomial(polynomial, x);\n if (std::abs(f_of_x) < kSmallestValue) {\n break;\n }\n\n const double g = EvaluatePolynomial(f_prime, x) / f_of_x;\n const double h = g * g - EvaluatePolynomial(f_prime_prime, x) / f_of_x;\n const double denom_part = std::sqrt(std::abs((k - 1.0) * (k * h - g * g)));\n const double denom = (g < 0) ? g - denom_part : g + denom_part;\n const double delta = k / denom;\n if (std::abs(delta) < epsilon) {\n break;\n }\n\n x -= delta;\n }\n\n return x;\n}\n\ndouble FindRootIterativeNewton(const Eigen::VectorXd& polynomial,\n const double x0,\n const double epsilon,\n const int max_iterations) {\n double root = x0;\n const Eigen::VectorXd derivative = DifferentiatePolynomial(polynomial);\n double prev = std::numeric_limits::max();\n for (int i = 0; i < max_iterations && std::abs(prev - root) > epsilon; i++) {\n prev = root;\n root -= EvaluatePolynomial(polynomial, root) /\n EvaluatePolynomial(derivative, root);\n }\n return root;\n}\n\n} // namespace theia\n", "meta": {"hexsha": "f388dd84a16b9a0ba9fca9bb30f70d92e4a61acb", "size": 12105, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/theia/math/polynomial.cc", "max_stars_repo_name": "nuernber/TheiaSfM", "max_stars_repo_head_hexsha": "0475f6b7b021a36d1d5c0d4a30608a2f45a1decb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/theia/math/polynomial.cc", "max_issues_repo_name": "nuernber/TheiaSfM", "max_issues_repo_head_hexsha": "0475f6b7b021a36d1d5c0d4a30608a2f45a1decb", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/theia/math/polynomial.cc", "max_forks_repo_name": "nuernber/TheiaSfM", "max_forks_repo_head_hexsha": "0475f6b7b021a36d1d5c0d4a30608a2f45a1decb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-12-11T04:09:18.000Z", "max_forks_repo_forks_event_max_datetime": "2018-12-11T04:09:18.000Z", "avg_line_length": 35.6029411765, "max_line_length": 80, "alphanum_fraction": 0.6592317224, "num_tokens": 2951, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8670357666736773, "lm_q2_score": 0.6334102498375401, "lm_q1q2_score": 0.5491893415868571}} {"text": "\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \n\n#include \n\n#include \n#include \n#include \n\n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\nusing namespace dealii;\nclass ParallelKL\n{\npublic:\n ParallelKL();\n void run();\nprivate:\n void make_grid();\n void setup_system();\n void assemble_system();\n void solve();\n void create_random_field();\n void stats_for_random_field();\n void output_results() const;\n void output_results_parallel();\n\n MPI_Comm mpi_communicator;\n\n parallel::distributed::Triangulation<2> triangulation;\n\n FE_Q<2> fe;\n DoFHandler<2> dof_handler;\n\n IndexSet locally_owned_dofs;\n IndexSet locally_relevant_dofs;\n\n AffineConstraints constraints;\n\n SparsityPattern sparsity_pattern;\n\n PETScWrappers::MPI::SparseMatrix system_mass_matrix;\n PETScWrappers::MPI::SparseMatrix system_stiffness_matrix;\n\n PETScWrappers::MPI::Vector randomfield_vector;\n\n std::vector eigenvalues;\n std::vector eigenvectors;\n\n std::vector normalized_gaussian;\n std::default_random_engine generator;\n std::normal_distribution distribution;\n\n unsigned int this_mpi_process, n_mpi_processes;\n\n ConditionalOStream pcout;\n TimerOutput computing_timer;\n};\n\nParallelKL::ParallelKL()\n : mpi_communicator(MPI_COMM_WORLD)\n , triangulation(mpi_communicator,\n typename Triangulation<2>::MeshSmoothing(\n Triangulation<2>::smoothing_on_refinement |\n Triangulation<2>::smoothing_on_coarsening))\n , fe(1)\n , dof_handler(triangulation)\n , this_mpi_process(Utilities::MPI::this_mpi_process(mpi_communicator))\n , n_mpi_processes(Utilities::MPI::n_mpi_processes(mpi_communicator))\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\nvoid ParallelKL::make_grid()\n{\n GridGenerator::hyper_cube(triangulation, -1, 1);\n triangulation.refine_global(5);\n\n //parallel console output\n pcout << \"Number of active cells: \" << triangulation.n_active_cells()\n << std::endl;\n}\n\nvoid ParallelKL::setup_system()\n{\n TimerOutput::Scope t(computing_timer, \"setup\");\n\n dof_handler.distribute_dofs(fe);\n pcout << \"Number of degrees of freedom: \" << dof_handler.n_dofs()\n << std::endl;\n\n locally_owned_dofs = dof_handler.locally_owned_dofs();\n DoFTools::extract_locally_relevant_dofs(dof_handler, locally_relevant_dofs);\n\n DynamicSparsityPattern dsp(locally_relevant_dofs);\n DoFTools::make_sparsity_pattern(dof_handler, dsp);\n\n SparsityTools::distribute_sparsity_pattern(dsp,\n locally_owned_dofs,\n mpi_communicator,\n locally_relevant_dofs);\n\n system_stiffness_matrix.reinit(locally_owned_dofs,\n locally_owned_dofs,\n dsp,\n mpi_communicator);\n\n system_mass_matrix.reinit(locally_owned_dofs,\n locally_owned_dofs,\n dsp,\n mpi_communicator);\n\n randomfield_vector.reinit(locally_owned_dofs, mpi_communicator);\n\n constraints.clear();\n constraints.reinit(locally_relevant_dofs);\n constraints.close();\n}\n\nvoid ParallelKL::assemble_system()\n{\n TimerOutput::Scope t(computing_timer, \"assembly\");\n\n system_stiffness_matrix = 0.;\n system_mass_matrix = 0.;\n\n QGauss<2> quadrature_formula(fe.degree + 1);\n\n FEValues<2> fe_values(fe,\n quadrature_formula,\n update_values | update_gradients | update_JxW_values | update_quadrature_points);\n\n const unsigned int dofs_per_cell = fe.dofs_per_cell;\n\n FullMatrix cell_mass_matrix(dofs_per_cell, dofs_per_cell);\n FullMatrix cell_stiffness_matrix(dofs_per_cell, dofs_per_cell);\n\n std::vector local_dof_indices(dofs_per_cell);\n\n for (const auto &cell : dof_handler.active_cell_iterators())\n { if (cell->is_locally_owned())\n {\n fe_values.reinit(cell);\n cell_mass_matrix = 0.;\n cell_stiffness_matrix = 0.;\n\n for (const unsigned int q_index : fe_values.quadrature_point_indices())\n {\n Point<2> quad_pointq = fe_values.quadrature_point(q_index);\n for (const unsigned int i : fe_values.dof_indices())\n for (const unsigned int j : fe_values.dof_indices())\n cell_mass_matrix(i, j) +=\n (fe_values.shape_value(i, q_index) * // grad phi_i(x_q)\n fe_values.shape_value(j, q_index) * // grad phi_j(x_q)\n fe_values.JxW(q_index)); // dx\n\n for (const unsigned int l_index : fe_values.quadrature_point_indices())\n {\n Point<2> quad_pointl = fe_values.quadrature_point(l_index);\n const double point_distance = quad_pointl.distance(quad_pointq);\n\n for (const unsigned int i : fe_values.dof_indices())\n for (const unsigned int j : fe_values.dof_indices())\n cell_stiffness_matrix(i, j) +=\n (exp(-0.5*point_distance/(0.05*0.05))* // R(x,x')\n fe_values.shape_value(i, q_index) * // grad phi_i(x_q)\n fe_values.shape_value(j, l_index) * // grad phi_j(x_l)\n fe_values.JxW(q_index)*fe_values.JxW(l_index)); // dx\n }\n }\n cell->get_dof_indices(local_dof_indices);\n\n constraints.distribute_local_to_global(cell_stiffness_matrix,\n local_dof_indices,\n system_stiffness_matrix);\n\n constraints.distribute_local_to_global(cell_mass_matrix,\n local_dof_indices,\n system_mass_matrix);\n }\n }\n\nsystem_mass_matrix.compress(VectorOperation::add);\nsystem_stiffness_matrix.compress(VectorOperation::add);\n\n//system_mass_matrix.print(std::cout);\n//system_stiffness_matrix.print(std::cout);\n}\n\nvoid ParallelKL::solve()\n{\n const unsigned int num_eigenpairs_requested = 100;\n\n eigenvalues.resize(num_eigenpairs_requested);\n eigenvectors.resize(num_eigenpairs_requested);\n\n normalized_gaussian.resize(num_eigenpairs_requested);\n\n for (unsigned int i = 0; i < num_eigenpairs_requested; ++i)\n eigenvectors[i].reinit(locally_owned_dofs, locally_relevant_dofs, mpi_communicator);\n\n SolverControl eigen_solver_control (10000, 1e-10);\n\n SLEPcWrappers::SolverKrylovSchur eigensolver(eigen_solver_control, mpi_communicator);\n\n eigensolver.set_which_eigenpairs(EPS_LARGEST_REAL);\n\n eigensolver.set_problem_type(EPS_GHEP);\n\n pcout << \"Beginning Eigensolve...\" << std::endl;\n eigensolver.solve(system_stiffness_matrix,\n system_mass_matrix,\n eigenvalues,\n eigenvectors,\n num_eigenpairs_requested);\n\n for (unsigned int i = 0; i < num_eigenpairs_requested; i++)\n {\n double temporary_sample = 0.0;\n\n if (this_mpi_process == 0)\n temporary_sample = distribution(generator);\n\n double temporary_sum = 0.0;\n\n MPI_Allreduce (&temporary_sample, &temporary_sum, 1, MPI_DOUBLE, MPI_SUM, mpi_communicator);\n\n normalized_gaussian[i] = temporary_sum;\n\n }\n}\n\nvoid ParallelKL::create_random_field()\n{\n randomfield_vector = 0.0;\n\n PETScWrappers::MPI::Vector tmp_locally_owned_vector(locally_owned_dofs, mpi_communicator);\n\n for (unsigned int i = 0; i < eigenvalues.size(); i++)\n {\n const double multiplier = sqrt(eigenvalues[i])*normalized_gaussian[i];\n tmp_locally_owned_vector = eigenvectors[i];\n randomfield_vector.add(multiplier, tmp_locally_owned_vector);\n }\n}\n\nvoid ParallelKL::stats_for_random_field()\n{\n PETScWrappers::MPI::Vector relevent_randomfield_vector(locally_owned_dofs, locally_relevant_dofs, mpi_communicator);\n relevent_randomfield_vector = randomfield_vector;\n\n QGauss<2> quadrature_formula(fe.degree + 1);\n\n FEValues<2> fe_values(fe,\n quadrature_formula,\n update_values | update_JxW_values);\n\n double vol_on_current_processor = 0.;\n double random_field_volume_integral_on_current_processor = 0.;\n\n std::vector local_dof_values(fe.dofs_per_cell);\n std::vector current_function_values(quadrature_formula.size());\n\n const FEValuesExtractors::Scalar r_field(0);\n\n for (const auto &cell : dof_handler.active_cell_iterators())\n { if (cell->is_locally_owned())\n {\n fe_values.reinit(cell);\n cell->get_dof_values(relevent_randomfield_vector, local_dof_values.begin(), local_dof_values.end());\n fe_values[r_field].get_function_values_from_local_dof_values(local_dof_values, current_function_values);\n\n for (const unsigned int q_index : fe_values.quadrature_point_indices())\n {\n vol_on_current_processor += fe_values.JxW(q_index);\n random_field_volume_integral_on_current_processor += current_function_values[q_index]*fe_values.JxW(q_index);\n }\n }\n }\n\n double total_random_field_volume_integral = 0.0;\n double total_volume = 0.0;\n\n MPI_Allreduce (&random_field_volume_integral_on_current_processor, &total_random_field_volume_integral, 1, MPI_DOUBLE, MPI_SUM, mpi_communicator);\n MPI_Allreduce (&vol_on_current_processor, &total_volume, 1, MPI_DOUBLE, MPI_SUM, mpi_communicator);\n\n double volume_average_of_random_field = total_random_field_volume_integral/total_volume;\n\n pcout << \"Volume Average of Random Field = \" << volume_average_of_random_field << std::endl;\n pcout << \"Total Volume = \" << total_volume << std::endl;\n\n}\n\nvoid ParallelKL::output_results() const\n{\n DataOut<2> data_out;\n data_out.attach_dof_handler(dof_handler);\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 for (unsigned int i = 0; i < eigenvalues.size(); i++)\n {\n //std::cout << eigenvectors[i] << \"\\n\" << std::endl;\n std::string tmpname = \"solution\";\n tmpname += Utilities::int_to_string(i, 3);\n //std::cout << \"Eigen_val = \" << eigenvalues[i] << \" \" << \"Normalized_gaussian = \" << normalized_gaussian[i] << \"\\n\" << std::endl;\n data_out.add_data_vector(eigenvectors[i], tmpname);\n }\n\n data_out.build_patches();\n std::ofstream output(\"solution.vtk\");\n data_out.write_vtk(output);\n}\n\nvoid ParallelKL::output_results_parallel()\n{\n TimerOutput::Scope t(computing_timer, \"output parallel\");\n\n PETScWrappers::MPI::Vector relevent_randomfield_vector(locally_owned_dofs, locally_relevant_dofs, mpi_communicator);\n relevent_randomfield_vector = randomfield_vector;\n\n DataOut<2> data_out;\n\n // ############################################################\n // ####### OUTPUT #######\n // ############################################################\n\n data_out.add_data_vector(dof_handler, relevent_randomfield_vector,\n \"RandomField\");\n\n /*\n for (unsigned int i = 0; i < eigenvalues.size(); i++)\n {\n std::string tmpname = \"solution\";\n tmpname += Utilities::int_to_string(i, 3);\n data_out.add_data_vector(eigenvectors[i], tmpname);\n }\n */\n\n std::vector> buckling_eigenmodes_out;\n\n buckling_eigenmodes_out.resize(eigenvalues.size());\n for (unsigned int i = 0; i < eigenvalues.size(); ++i)\n {\n buckling_eigenmodes_out[i].reinit(dof_handler.n_dofs(), 0.0);\n buckling_eigenmodes_out[i] = eigenvectors[i];\n const std::string buckling_mode_string = std::string(\"EigenVector\") + Utilities::int_to_string(i, 2);\n\n data_out.add_data_vector(dof_handler, buckling_eigenmodes_out[i],\n buckling_mode_string);\n }\n\n // ############################################################\n // ####### WRITE VTU FILE #######\n // ############################################################\n data_out.build_patches ();\n const std::string filename = \"Solution.\" +\n Utilities::int_to_string (this_mpi_process, 2) + \".vtu\";\n\n std::ofstream output (filename.c_str());\n data_out.write_vtu (output);\n output.close();\n\n // ############################################################\n // ####### WRITE PVTU FILE #######\n // ############################################################\n if (this_mpi_process == 0)\n {\n std::vector filenames;\n for (unsigned int i=0; i < n_mpi_processes; ++i)\n filenames.push_back (\"Solution.\" +\n Utilities::int_to_string (i, 2) + \".vtu\");\n\n std::ofstream master_output (\"Solution.pvtu\");\n\n data_out.write_pvtu_record (master_output, filenames);\n }\n}\n\nvoid ParallelKL::run()\n{\n pcout << \"Running with \" << \"PETSc\" << \" on \" << Utilities::MPI::n_mpi_processes(mpi_communicator)\n << \" MPI rank(s)...\" << std::endl;\n\n make_grid();\n\n setup_system();\n\n pcout << \" Number of active cells: \"\n << triangulation.n_global_active_cells() << std::endl\n << \" Number of degrees of freedom: \" << dof_handler.n_dofs()\n << std::endl;\n\n assemble_system();\n solve();\n create_random_field();\n stats_for_random_field();\n\n if (Utilities::MPI::n_mpi_processes(mpi_communicator) <= 32)\n {\n TimerOutput::Scope t(computing_timer, \"output\");\n //output_results();\n output_results_parallel();\n\n }\n}\n\nint main(int argc, char* argv[])\n{\n Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);\n\n deallog.depth_console(0);\n\n ParallelKL klexpansion_2d;\n klexpansion_2d.run();\n return 0;\n}\n", "meta": {"hexsha": "3c74c3692a9d68a6fbba534ded62ba21275e4aaa", "size": 15461, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/klexpansion.cpp", "max_stars_repo_name": "gh2546/Project_APMA4302", "max_stars_repo_head_hexsha": "e7db5dc5b2bb2d2aa8e32eced6af070f3fda03e6", "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/klexpansion.cpp", "max_issues_repo_name": "gh2546/Project_APMA4302", "max_issues_repo_head_hexsha": "e7db5dc5b2bb2d2aa8e32eced6af070f3fda03e6", "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/klexpansion.cpp", "max_forks_repo_name": "gh2546/Project_APMA4302", "max_forks_repo_head_hexsha": "e7db5dc5b2bb2d2aa8e32eced6af070f3fda03e6", "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": 33.5379609544, "max_line_length": 148, "alphanum_fraction": 0.6447836492, "num_tokens": 3660, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8670357460591569, "lm_q2_score": 0.6334102567576901, "lm_q1q2_score": 0.549189334529426}} {"text": "#ifndef RASTERIZER_HPP\n#define RASTERIZER_HPP\n\n#include \n#include \n#include \n\nnamespace rasterize {\n\nnamespace bg = boost::geometry;\n\n/* rasterize a polygon implementation */\n\ntemplate \nstruct Edge {\n typedef bg::model::segment segment_t;\n float_t x, xNorm, yNorm;\n float_t minX, maxX;\n float_t slope;\n int_t yMax, yMin; // min-max of edge\n float_t dX, dY;\n segment_t line;\n Edge(const point_t &a, const point_t &b) : line{a, b} {\n auto &pMin = (bg::get<1>(a) < bg::get<1>(b) ? a : b);\n auto &pMax = (bg::get<1>(a) < bg::get<1>(b) ? b : a);\n\n yMax = bg::get<1>(pMax);\n yMin = bg::get<1>(pMin);\n\n x = bg::get<0>(pMin); // start x\n minX = std::min(bg::get<0>(a), bg::get<0>(b)); // start x\n maxX = std::max(bg::get<0>(a), bg::get<0>(b)); // start x\n\n dX = (bg::get<0>(pMax) - bg::get<0>(pMin));\n dY = (bg::get<1>(pMax) - bg::get<1>(pMin));\n slope = dY != 0 ? slope = dX / dY : 0;\n\n auto yOff = yMin - std::floor(yMin);\n auto xOff = x - std::floor(x);\n\n yNorm = std::round(yMin) + 0.5;\n xNorm = x + (yNorm - yMin) * slope;\n }\n\n friend std::ostream &operator<<(std::ostream &stream, const Edge &edge) {\n return std::cout << \"Edge bucket: \" << edge.yMin << \"=>\" << edge.yMax\n << \"dx=\" << edge.dX << \"; dy=\" << edge.dY\n << \"; x=\" << edge.x << \";\" << std::endl;\n }\n};\n\ntemplate struct Rasterizer {\n typedef bg::model::polygon polygon_t;\n typedef Edge edge_t;\n struct {\n bool operator()(const edge_t &a, const edge_t &b) const {\n return a.yMin < b.yMin;\n }\n } yMinCompare;\n\n enum { STEP_INTERSECT, STEP_RASTERIZE };\n std::list ET; // edge table\n std::list AL; // active list\n\n int scanline;\n\n std::pair custom_scanline;\n\n void set_scanline(int _scanline) {\n custom_scanline = std::make_pair(true, _scanline);\n }\n\n void clear_scanline() { custom_scanline = std::make_pair(false, 0); }\n\n void clear() {\n clear_scanline();\n ET.clear();\n AL.clear();\n }\n\n void init(const polygon_t &p) {\n clear();\n if (p.outer().size() < 3) // don't render invalid polygons\n return;\n // build edge table containing all edges n=>0, 0=>1, ...n-1=>n\n edge_t e = {p.outer().back(), p.outer()[0]};\n if (e.dY != 0)\n ET.push_back(e);\n for (size_t i = 0; i < p.outer().size() - 1; i++) {\n e = {p.outer()[i], p.outer()[i + 1]};\n if (e.dY != 0)\n ET.push_back(e);\n }\n // sort according to yMin\n ET.sort(yMinCompare);\n\n //\tstd::cout << bg::wkt(p) << std::endl;\n if (ET.empty())\n return;\n\n if (!custom_scanline.first) {\n scanline = ET.front().yMin;\n } else {\n auto _scanline = custom_scanline.second;\n if (ET.front().yMin != _scanline)\n //\t std::cout << \"Starting at different scanlines: \" <<\n // ET.front().yMin << \" vs.\" << scanline << std::endl;\n scanline = ET.front().yMin;\n //\t std::cout << \"silent step should now do \" << scanline << \"\n // until \" << _scanline << std::endl;\n while (scanline < _scanline) {\n //\t std::cout << \"silent step:\" << scanline << \" towards \" <<\n //_scanline << std::endl;\n step_intersect([](int x, int y) {});\n }\n }\n }\n\n bool done() { return (ET.empty() && AL.empty()); }\n template void step_intersect(func putpixel) {\n#ifdef DEBUG_LOG\n std::cout << \"scanline(\" << scanline << \"):\" << std::endl;\n#endif\n // all edges that start here are moved from ET to AL\n for (auto it = ET.begin(); it != ET.end();) {\n if (std::floor(it->yMin - 1) <= scanline) {\n AL.push_back(*it);\n#ifdef DEBUG_LOG\n std::cout << \"erase (\" << it->yMin << \") \";\n#endif\n it = ET.erase(it);\n } else\n it++;\n }\n#ifdef DEBUG_LOG\n std::cout << \"active(\" << AL.size() << \") \";\n#endif\n // all edges that end here, are removed from AL\n for (auto it = AL.begin(); it != AL.end();) {\n if (std::ceil(it->yMax + 1) < scanline) {\n it = AL.erase(it);\n } else\n it++;\n }\n\n // theoretic: for multipolygons, this could become empty. However, for\n // polygons it should always have at least two active edges\n if (AL.empty()) {\n scanline++;\n return;\n }\n\n // sort according to X coordinate\n AL.sort([](const edge_t &a, const edge_t &b) {\n // it is an iterator pointing to Edge\n // sort by x and slope\n return (a.x < b.x || (a.x == b.x && a.slope < b.slope));\n });\n#ifdef DEBUG_LOG\n std::cout << \"-> (\" << AL.size() << \"):\" << std::endl;\n for (auto &a : AL) {\n std::cout << \"{(\" << a.line.first.get<0>() << \",\" << a.line.first.get<1>()\n << \"),\"\n << \"(\" << a.line.second.get<0>() << \",\"\n << a.line.second.get<1>() << \")},\";\n }\n#endif\n\n // prepare scanline filling\n auto minX = std::floor(AL.front().minX - 1);\n auto maxX = std::ceil(AL.back().maxX);\n auto line = typename edge_t::segment_t(point_t(minX, scanline + 0.5),\n point_t(maxX, scanline + 0.5));\n\n std::vector output;\n for (auto &e : AL) {\n bg::intersection(line, e.line, output);\n#ifdef DEBUG_LOG\n std::cout << \"[\";\n for (auto i = output.begin(); i != output.end(); ++i)\n std::cout << \"(\" << bg::get<0>(*i) << ',' << bg::get<1>(*i) << \"),\";\n std::cout << \"], \";\n#endif\n }\n#ifdef DEBUG_LOG\n std::cout << \" | sum: \" << output.size() << std::endl;\n#endif\n // assert(output.size() % 2 == 0);\n std::sort(output.begin(), output.end(),\n ([](const point_t &a, const point_t &b) {\n // sort by x\n return bg::get<0>(a) < bg::get<0>(b);\n }));\n#ifdef BORDERS_ONLY\n // Just the borders\n auto index = 0;\n for (auto &i : output) {\n //\tfloat_t pixelX = bg::get<0>(i) - std::floor(bg::get<0>(i));\n\n int x = index % 2 == 0 ? std::round(bg::get<0>(i))\n : std::floor(bg::get<0>(i) - 0.5);\n\n putpixel(x, scanline);\n index++;\n }\n#else\n if (output.size() > 0) {\n\n for (auto i = 1; i < output.size(); i += 2) {\n auto xstart = std::round(bg::get<0>(output[i - 1]));\n auto xend = std::floor(bg::get<0>(output[i]) - 0.5);\n#ifdef DEBUG_LOG\n std::cout << \"xstart: \" << xstart << \" xend: \" << xend << std::endl;\n#endif\n for (auto x = xstart; x <= xend; x++)\n putpixel(x, scanline);\n }\n }\n#endif\n\n scanline++;\n return;\n }\n template void step_rasterize(func putpixel) {\n//#define DEBUG_LOG\n#ifdef DEBUG_LOG\n std::cout << \"scanline(\" << scanline << \"):\" << std::endl;\n#endif\n // all edges that start here are moved from ET to AL\n for (auto it = ET.begin(); it != ET.end();) {\n if (std::floor(it->yNorm) <= scanline) {\n AL.push_back(*it);\n#ifdef DEBUG_LOG\n std::cout << \"erase (\" << it->yMin << \") \";\n#endif\n it = ET.erase(it);\n } else\n it++;\n }\n#ifdef DEBUG_LOG\n std::cout << \"active(\" << AL.size() << \") \";\n#endif\n // all edges that end here, are removed from AL\n for (auto it = AL.begin(); it != AL.end();) {\n if (std::ceil(it->yMax - 1) < scanline) {\n it = AL.erase(it);\n } else\n it++;\n }\n\n // theoretic: for multipolygons, this could become empty. However, for\n // polygons it should always have at least two active edges\n if (AL.empty()) {\n scanline++;\n return;\n }\n\n // sort according to X coordinate\n AL.sort([](const edge_t &a, const edge_t &b) {\n // it is an iterator pointing to Edge\n // sort by x and slope\n return ((a.xNorm < b.xNorm) || (a.xNorm == b.xNorm && a.slope < b.slope));\n });\n#ifdef DEBUG_LOG\n std::cout << \"-> (\" << AL.size() << \"):\" << std::endl;\n for (auto &a : AL) {\n std::cout << \"{(\" << a.line.first.get<0>() << \",\" << a.line.first.get<1>()\n << \"),\"\n << \"(\" << a.line.second.get<0>() << \",\"\n << a.line.second.get<1>() << \")},\";\n }\n#endif\n\n // prepare scanline filling\n auto minX = std::floor(AL.front().minX - 2);\n auto maxX = std::ceil(AL.back().maxX);\n typename edge_t::segment_t line(point_t(minX, scanline + 0.5),\n point_t(maxX, scanline + 0.5));\n auto it = AL.begin();\n bool inside = false;\n#ifdef DEBUG_LOG\n std::cout << \"[\" << std::endl;\n#endif\n for (float_t x = minX; x <= maxX; x++) {\n auto go = true;\n while (go) {\n go = false;\n if (!inside) {\n if (x + 0.5 >= it->xNorm && it != AL.end()) {\n inside = !inside;\n it++;\n go = true;\n }\n } else {\n if ((x + 0.499999) > it->xNorm) {\n#ifdef DEBUG_LOG\n std::cout.precision(std::numeric_limits::max_digits10);\n std::cout << std::endl\n << \"(\" << x + 0.5 << \" > \" << it->xNorm << \")\"\n << std::endl;\n std::cout.precision(2);\n#endif\n inside = !inside;\n it++;\n go = true;\n }\n }\n if (it == AL.end())\n break;\n }\n#ifdef DEBUG_LOG\n std::cout << \"n:\" << it->xNorm << \"~\" << it->x << \" x:\" << x\n << \" in:\" << inside << \", \";\n#endif\n\n if (inside)\n putpixel(x, scanline);\n }\n#ifdef DEBUG_LOG\n std::cout << \"]\" << std::endl;\n#endif\n\n // increment all the X based on slope\n for (auto &e : AL) {\n if (e.dX != 0)\n e.xNorm += e.slope;\n }\n\n scanline++;\n return;\n }\n\n void rasterize(const polygon_t &p,\n std::function putpixel,\n int step_id = STEP_RASTERIZE, int steps = -1) {\n init(p);\n\n switch (step_id) {\n case STEP_INTERSECT:\n while (!done()) {\n step_intersect(putpixel);\n }\n break;\n case STEP_RASTERIZE:\n while (!done()) {\n step_rasterize(putpixel);\n }\n break;\n }\n // Process ET=>AL=>(void)\n }\n};\n\n} // namespace rasterize\n\n#endif\n", "meta": {"hexsha": "c4d37ea7d5047a10cf654be294422f517e62c5da", "size": 10310, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "experiments/src/rasterizer.hpp", "max_stars_repo_name": "mlaass/globimap", "max_stars_repo_head_hexsha": "6bbcbf33cc39ed343662e6b98871dc6dfbc4648f", "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": "experiments/src/rasterizer.hpp", "max_issues_repo_name": "mlaass/globimap", "max_issues_repo_head_hexsha": "6bbcbf33cc39ed343662e6b98871dc6dfbc4648f", "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": "experiments/src/rasterizer.hpp", "max_forks_repo_name": "mlaass/globimap", "max_forks_repo_head_hexsha": "6bbcbf33cc39ed343662e6b98871dc6dfbc4648f", "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": 28.8795518207, "max_line_length": 80, "alphanum_fraction": 0.5057225994, "num_tokens": 3059, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7853085708384736, "lm_q2_score": 0.6992544273261175, "lm_q1q2_score": 0.5491304949759487}} {"text": "//=======================================================================\n// Copyright 2002 Indiana University.\n// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek\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\n/*\n Adapted from the GIRTH program of the Stanford GraphBase.\n\n Sample output:\n\n This program explores the girth and diameter of Ramanujan graphs.\n The bipartite graphs have q^3-q vertices, and the non-bipartite\n graphs have half that number. Each vertex has degree p+1.\n Both p and q should be odd prime numbers;\n or you can try p = 2 with q = 17 or 43.\n\n Choose a branching factor, p: 2\n Ok, now choose the cube root of graph size, q: 17\n Starting at any given vertex, there are\n 3 vertices at distance 1,\n 6 vertices at distance 2,\n 12 vertices at distance 3,\n 24 vertices at distance 4,\n 46 vertices at distance 5,\n 90 vertices at distance 6,\n 169 vertices at distance 7,\n 290 vertices at distance 8,\n 497 vertices at distance 9,\n 634 vertices at distance 10,\n 521 vertices at distance 11,\n 138 vertices at distance 12,\n 13 vertices at distance 13,\n 3 vertices at distance 14,\n 1 vertices at distance 15.\n So the diameter is 15, and the girth is 9.\n \n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\ntypedef boost::graph_traits Traits;\ntypedef Traits::vertex_descriptor vertex_descriptor;\ntypedef Traits::edge_descriptor edge_descriptor;\ntypedef Traits::vertex_iterator vertex_iterator;\n\nstd::vector distance_list;\n\ntypedef boost::v_property dist_t;\nboost::property_map::type d_map;\n\ntypedef boost::u_property pred_t;\nboost::property_map::type p_map;\n\ntypedef boost::w_property color_t;\nboost::property_map::type c_map;\n\nclass diameter_and_girth_visitor : public boost::bfs_visitor<>\n{\npublic:\n diameter_and_girth_visitor(std::size_t& k_, std::size_t& girth_)\n : k(k_), girth(girth_) { }\n\n void tree_edge(edge_descriptor e, Graph* g) {\n vertex_descriptor u = source(e, g), v = target(e, g);\n k = d_map[u] + 1;\n d_map[v] = k;\n ++distance_list[k];\n p_map[v] = u;\n }\n void non_tree_edge(edge_descriptor e, Graph* g) {\n vertex_descriptor u = source(e, g), v = target(e, g);\n k = d_map[u] + 1;\n if (d_map[v] + k < girth && v != p_map[u])\n girth = d_map[v]+ k;\n }\nprivate:\n std::size_t& k;\n std::size_t& girth;\n};\n\n\nint\nmain()\n{\n std::cout <<\n \"This program explores the girth and diameter of Ramanujan graphs.\" \n << std::endl;\n std::cout <<\n \"The bipartite graphs have q^3-q vertices, and the non-bipartite\" \n << std::endl;\n std::cout << \n \"graphs have half that number. Each vertex has degree p+1.\" \n << std::endl;\n std::cout << \"Both p and q should be odd prime numbers;\" << std::endl;\n std::cout << \" or you can try p = 2 with q = 17 or 43.\" << std::endl;\n\n while (1) {\n\n std::cout << std::endl\n << \"Choose a branching factor, p: \";\n long p = 0, q = 0;\n std::cin >> p;\n if (p == 0)\n break;\n std::cout << \"Ok, now choose the cube root of graph size, q: \";\n std::cin >> q;\n if (q == 0)\n break;\n\n Graph* g;\n g = raman(p, q, 0L, 0L);\n if (g == 0) {\n std::cerr << \" Sorry, I couldn't make that graph (error code \"\n << panic_code << \")\" << std::endl;\n continue;\n }\n distance_list.clear();\n distance_list.resize(boost::num_vertices(g), 0);\n\n // obtain property maps\n d_map = get(dist_t(), g);\n p_map = get(pred_t(), g);\n c_map = get(color_t(), g);\n\n vertex_iterator i, end;\n for (boost::tie(i, end) = boost::vertices(g); i != end; ++i)\n d_map[*i] = 0;\n\n std::size_t k = 0;\n std::size_t girth = (std::numeric_limits::max)();\n diameter_and_girth_visitor vis(k, girth);\n\n vertex_descriptor s = *boost::vertices(g).first;\n\n boost::breadth_first_search(g, s, visitor(vis).color_map(c_map));\n\n std::cout << \"Starting at any given vertex, there are\" << std::endl;\n\n for (long d = 1; distance_list[d] != 0; ++d)\n std::cout << distance_list[d] << \" vertices at distance \" << d\n << (distance_list[d+1] != 0 ? \",\" : \".\") << std::endl;\n\n std::cout << \"So the diameter is \" << k - 1\n << \", and the girth is \" << girth\n << \".\" << std::endl;\n } // end while\n\n return 0;\n}\n", "meta": {"hexsha": "9c9cc23cc22fd1e9823737269052e2954794f06b", "size": 4760, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "boost/libs/graph/example/girth.cpp", "max_stars_repo_name": "randolphwong/mcsema", "max_stars_repo_head_hexsha": "eb5b376736e7f57ff0a61f7e4e5a436bbb874720", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 12278.0, "max_stars_repo_stars_event_min_datetime": "2015-01-29T17:11:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T21:12:00.000Z", "max_issues_repo_path": "boost/libs/graph/example/girth.cpp", "max_issues_repo_name": "randolphwong/mcsema", "max_issues_repo_head_hexsha": "eb5b376736e7f57ff0a61f7e4e5a436bbb874720", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 9469.0, "max_issues_repo_issues_event_min_datetime": "2015-01-30T05:33:07.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T16:17:21.000Z", "max_forks_repo_path": "boost/libs/graph/example/girth.cpp", "max_forks_repo_name": "randolphwong/mcsema", "max_forks_repo_head_hexsha": "eb5b376736e7f57ff0a61f7e4e5a436bbb874720", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 892.0, "max_forks_repo_forks_event_min_datetime": "2015-01-29T16:26:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-20T07:44:30.000Z", "avg_line_length": 29.5652173913, "max_line_length": 73, "alphanum_fraction": 0.6180672269, "num_tokens": 1354, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7853085708384736, "lm_q2_score": 0.6992544085240401, "lm_q1q2_score": 0.5491304802105161}} {"text": "#include \n#include \n#include \n#include \"NeuralNetwork.h\"\n\n\nint main(void)\n{\n NeuralNetwork nn;\n\n float loss;\n Matrix out;\n\n#if 1\n Matrix input[4];\n Matrix expect[4];\n Matrix W1(2,2);\n Matrix W2(2,1);\n\n input[0] << 0, 0; expect[0] << 0;\n input[1] << 0, 1; expect[1] << 1;\n input[2] << 1, 0; expect[2] << 1;\n input[3] << 1, 1; expect[3] << 0;\n\n W1 << -0.0032973, -0.02393722, -0.02107663, 0.01280219 ;\n W2 << -0.01024167, -0.01514217;\n\n nn.createNewLayer(2,2, false, &W1);\n nn.createNewLayer(2,1, true, &W2);\n\n loss = 100.f;\n nn.printnet();\n // while (loss > 0.001f)\n for(int j=0; j<10; j++)\n {\n loss = 0.f;\n for(int i=0; i<4; i++)\n {\n // std::cout << \"==== \" << i+1 << \" ====\" << std::endl;\n out = nn.forward( input[i] );\n loss += nn.backward(0.1f, expect[i]);\n nn.printnet();\n // std::cout << \" out = \" << out << std::endl;\n }\n loss /= 4;\n std::cout << \"loss = \" << loss << std::endl;\n nn.printnet();\n }\n\n for(int i=0; i<4; i++)\n {\n std::cout << \"Expect = \" << expect[i] << \" Input = \" << input[i] << std::endl;\n out = nn.forward( input[i] );\n std::cout << \"Output = \" << out << std::endl;\n }\n\n#else\n Matrix input;\n Matrix expect;\n\n input << 3, 3;\n expect << 0, 1;\n\n nn.createNewLayer(2, 5);\n nn.createNewLayer(5, 3);\n nn.createNewLayer(3, 2, true);\n\n std::cout << \"tmp input = \" << input << std::endl;\n std::cout << \"expect = \" << expect << std::endl;\n std::cout << \"input * expect = \" << input.array() * expect.array() << std::endl;\n\n std::cout << \"input = \" << input << std::endl;\n input = input.array() + 1;\n std::cout << \"input = \" << input << std::endl;\n \n\n out = nn.forward( input );\n std::cout << \"out.rows = \" << out.rows() << std::endl;\n std::cout << \"out.cols = \" << out.cols() << std::endl;\n std::cout << \"out = \" << out << std::endl;\n\n loss = 100.f;\n while (loss > 0.001f)\n {\n out = nn.forward( input );\n loss = nn.backward(0.1f, expect);\n std::cout << \"out = \" << out << std::endl;\n std::cout << \"loss = \" << loss << std::endl;\n }\n#endif\n\n return 0;\n}\n\n", "meta": {"hexsha": "4288f1922e82f5133402457bf04073344458e528", "size": 2309, "ext": "cxx", "lang": "C++", "max_stars_repo_path": "eigen_test/main.cxx", "max_stars_repo_name": "takayoshi-k/marubatsu", "max_stars_repo_head_hexsha": "cfda9544aa02cb23ead41c67b980a8af47d5d50c", "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": "eigen_test/main.cxx", "max_issues_repo_name": "takayoshi-k/marubatsu", "max_issues_repo_head_hexsha": "cfda9544aa02cb23ead41c67b980a8af47d5d50c", "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": "eigen_test/main.cxx", "max_forks_repo_name": "takayoshi-k/marubatsu", "max_forks_repo_head_hexsha": "cfda9544aa02cb23ead41c67b980a8af47d5d50c", "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.3052631579, "max_line_length": 85, "alphanum_fraction": 0.5028150715, "num_tokens": 823, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872045996818986, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.548984847010704}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\ndouble cos_rule_angle(double A, double B, double C) {\n if (fabs((A + B) - C) < 0.000001) {\n return M_PI;\n }\n if (!(A + B >= C)) {\n fprintf(stderr, \"Assertion Error: A + B >= C\\n\");\n exit(1);\n }\n return acos((A * A + B * B - C * C) / (2.0 * A * B));\n}\n\nbool concave(const arma::vec &l, const arma::vec &c, const arma::vec &r, double lrad, double crad, double rrad) {\n double dlcx = c(0) - l(0);\n double dlcy = c(1) - l(1);\n double drcx = c(0) - r(0);\n double drcy = c(1) - r(1);\n double lc = sqrt(dlcx * dlcx + dlcy * dlcy);\n double rc = sqrt(drcx * drcx + drcy * drcy);\n double theta1 = cos_rule_angle(lc, crad, lrad);\n double theta2 = cos_rule_angle(rc, crad, rrad);\n return ((theta1 + theta2) - M_PI) > -0.1;\n}\n\nbool within(const arma::vec &l, const arma::vec &c, const arma::vec &r, double lrad, double crad, double rrad) {\n if (crad == 0.0) {\n return true;\n }\n return concave(l, c, r, lrad, crad, rrad);\n}\n\nstd::vector get_filled_boundary(const std::vector &pts) {\n arma::vec X(pts.size());\n arma::vec Y(pts.size());\n for (int i = 0; i < pts.size(); i++) {\n X(i) = pts[i](0) * cos(pts[i](1));\n Y(i) = pts[i](0) * sin(pts[i](1));\n }\n int min_x = 0;\n int min_y = 0;\n int max_x = 0;\n int max_y = 0;\n int tx;\n int ty;\n for (int i = 0; i < pts.size(); i++) {\n tx = (int)floor(X(i));\n if (tx < min_x) {\n min_x = tx;\n }\n tx = (int)ceil(X(i));\n if (tx > max_x) {\n max_x = tx;\n }\n ty = (int)floor(Y(i));\n if (ty < min_y) {\n min_y = ty;\n }\n ty = (int)ceil(Y(i));\n if (ty > max_y) {\n max_y = ty;\n }\n }\n max_x++;\n max_y++;\n // create vmap\n arma::mat vmap = arma::zeros(max_y - min_y, max_x - min_x);\n std::vector colored;\n std::vector infection_queue = {{ 0.0, 0.0 }};\n vmap(-min_y, -min_x) = 1.0;\n int index = 0;\n while (infection_queue.size() > index) {\n double x = infection_queue[index](0);\n double y = infection_queue[index](1);\n\n double theta = atan2(y, x);\n if (theta < 0.0) {\n theta += 2.0 * M_PI;\n }\n double radius = sqrt(x * x + y * y);\n // binary search\n int left = 0;\n int right = pts.size() - 1;\n if (pts[right](1) <= theta || theta < pts[left](1)) {\n left = right;\n right = 0;\n } else {\n int mid = (left + right) / 2;\n while (left + 1 != right) {\n if (theta >= pts[mid](1)) {\n left = mid;\n } else {\n right = mid;\n }\n mid = (left + right) / 2;\n }\n }\n\n // bfs\n arma::vec l({X(left), Y(left)});\n arma::vec c({x, y});\n arma::vec r({X(right), Y(right)});\n int dx = x - min_x;\n int dy = y - min_y;\n if (within(l, c, r, pts[left](0), radius, pts[right](0))) {\n colored.push_back(c);\n if (y + 1 < max_y && vmap(dy + 1, dx) == 0.0) {\n infection_queue.push_back({x, y + 1});\n vmap(dy + 1, dx) = 1.0;\n }\n if (y - 1 >= min_y && vmap(dy - 1, dx) == 0.0) {\n infection_queue.push_back({x, y - 1});\n vmap(dy - 1, dx) = 1.0;\n }\n if (x + 1 < max_x && vmap(dy, dx + 1) == 0.0) {\n infection_queue.push_back({x + 1, y});\n vmap(dy, dx + 1) = 1.0;\n }\n if (x - 1 >= min_x && vmap(dy, dx - 1) == 0.0) {\n infection_queue.push_back({x - 1, y});\n vmap(dy, dx - 1) = 1.0;\n }\n }\n //infection_queue.erase(infection_queue.begin());\n index++;\n }\n return colored;\n}\n\nstd::vector lidar_read(void) {\n std::vector pts;\n double theta = 0.0;\n while (theta < 360.0) {\n theta += (double)rand() / (double)RAND_MAX + 2.0;\n if (theta > 360.0) {\n break;\n }\n double radius = (double)rand() / (double)RAND_MAX * 100.0 + 100.0;\n pts.push_back(arma::vec({radius, theta * M_PI / 180.0}));\n }\n return pts;\n}\n\nint main(int argc, char *argv[]) {\n arma::vec center = { 300.0, 300.0 };\n\n srand(getpid());\n SDL_Init(SDL_INIT_VIDEO);\n SDL_Window *window = SDL_CreateWindow(\"raycast\", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 640, SDL_WINDOW_SHOWN);\n SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);\n SDL_Surface *screen = SDL_CreateRGBSurface(0, 640, 640, 32, 0, 0, 0, 0);\n SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, screen);\n\n bool done = false;\n uint32_t color_black = SDL_MapRGB(screen->format, 0, 0, 0);\n uint32_t color_red = SDL_MapRGB(screen->format, 255, 0, 0);\n uint32_t color_green = SDL_MapRGB(screen->format, 0, 255, 0);\n uint32_t color_blue = SDL_MapRGB(screen->format, 0, 0, 255);\n while (true) {\n SDL_Event e;\n while (SDL_PollEvent(&e)) {\n if (e.type == SDL_QUIT) {\n done = true;\n break;\n }\n }\n if (done) {\n break;\n }\n \n std::vector data = lidar_read();\n printf(\"getting raycast area...\\n\");\n std::vector raycast_area = get_filled_boundary(data);\n\n SDL_FillRect(screen, NULL, color_black);\n for (arma::vec &pt : raycast_area) {\n int x = (int)(pt(0) + center(0));\n int y = (int)(-pt(1) + center(1));\n ((uint32_t *)screen->pixels)[y * 640 + x] = color_red;\n }\n for (arma::vec &pt : data) {\n int x = (int)(pt(0) * cos(pt(1)) + center(0));\n int y = (int)(-pt(0) * sin(pt(1)) + center(1));\n ((uint32_t *)screen->pixels)[y * 640 + x] = color_green;\n }\n ((uint32_t *)screen->pixels)[300 * 640 + 299] = color_blue;\n ((uint32_t *)screen->pixels)[300 * 640 + 300] = color_blue;\n ((uint32_t *)screen->pixels)[300 * 640 + 301] = color_blue;\n ((uint32_t *)screen->pixels)[299 * 640 + 300] = color_blue;\n ((uint32_t *)screen->pixels)[301 * 640 + 300] = color_blue;\n\n SDL_UpdateTexture(texture, NULL, screen->pixels, screen->pitch);\n SDL_RenderClear(renderer);\n SDL_RenderCopy(renderer, texture, NULL, NULL);\n SDL_RenderPresent(renderer);\n SDL_Delay(25);\n }\n SDL_DestroyTexture(texture);\n SDL_FreeSurface(screen);\n SDL_DestroyRenderer(renderer);\n SDL_DestroyWindow(window);\n SDL_Quit();\n return 0;\n}\n", "meta": {"hexsha": "b92347b97a14aa436636aea942bd814471ad607c", "size": 6252, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "slam/raycast/raycast.cpp", "max_stars_repo_name": "timrobot/Tachikoma-Project", "max_stars_repo_head_hexsha": "c7af70f2c58fe43f25331fd03589845480ae0f16", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2016-11-11T19:04:33.000Z", "max_stars_repo_stars_event_max_datetime": "2016-11-11T19:04:33.000Z", "max_issues_repo_path": "slam/raycast/raycast.cpp", "max_issues_repo_name": "TimothyYong/Tachikoma-Project", "max_issues_repo_head_hexsha": "c7af70f2c58fe43f25331fd03589845480ae0f16", "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": "slam/raycast/raycast.cpp", "max_forks_repo_name": "TimothyYong/Tachikoma-Project", "max_forks_repo_head_hexsha": "c7af70f2c58fe43f25331fd03589845480ae0f16", "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.3521126761, "max_line_length": 127, "alphanum_fraction": 0.5591810621, "num_tokens": 2148, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8519527869325345, "lm_q2_score": 0.6442251064863697, "lm_q1q2_score": 0.5488493748829715}} {"text": "/***********************************************************************\nThis file is part of the librjmcmc project source files.\n\nCopyright : Institut Geographique National (2008-2012)\nContributors : Mathieu Brédif, Olivier Tournaire, Didier Boldo\nemail : librjmcmc@ign.fr\n\nThis software is a generic C++ library for stochastic optimization.\n\nThis software is governed by the CeCILL license under French law and\nabiding by the rules of distribution of free software. You can use,\nmodify and/or redistribute the software under the terms of the CeCILL\nlicense as circulated by CEA, CNRS and INRIA at the following URL\n\"http://www.cecill.info\".\n\nAs a counterpart to the access to the source code and rights to copy,\nmodify and redistribute granted by the license, users are provided only\nwith a limited warranty and the software's author, the holder of the\neconomic rights, and the successive licensors have only limited liability.\n\nIn this respect, the user's attention is drawn to the risks associated\nwith loading, using, modifying and/or developing or reproducing the\nsoftware by the user in light of its specific status of free software,\nthat may mean that it is complicated to manipulate, and that also\ntherefore means that it is reserved for developers and experienced\nprofessionals having in-depth computer knowledge. Users are therefore\nencouraged to load and test the software's suitability as regards their\nrequirements in conditions enabling the security of their systems and/or\ndata to be ensured and, more generally, to use and operate it in the\nsame conditions as regards security.\n\nThe fact that you are presently reading this means that you have had\nknowledge of the CeCILL license and that you accept its terms.\n\n***********************************************************************/\n\n#ifndef GRADIENT_FUNCTOR_INC_HPP\n#define GRADIENT_FUNCTOR_INC_HPP\n\n#include \"gradient_functor.hpp\"\n\n#include \n#include \n#include \n#include \n\nnamespace internal {\n\n#if !defined(M_PI)\n const double M_PI = 4.0 * atan(1.0);\n#endif\n\n template\n void initKernelGaussian1D(Kernel1D& kernel, double m_sigma)\n {\n\t// Gaussian smoothing\n typedef\ttypename Kernel1D::value_type vt;\n const vt z = 1.0 / (std::sqrt(2 * M_PI) * m_sigma);\n const vt m_sigmasquared = m_sigma * m_sigma;\n vt x = -1.0 * kernel.center();\n typename Kernel1D::iterator i;\n vt sum = 0.;\n for (i=kernel.begin(); i!=kernel.end(); ++i, ++x)\n {\n *i = z * (std::exp(-0.5*(x*x/m_sigmasquared)));\n sum += *i;\n }\n for (i=kernel.begin(); i!=kernel.end(); ++i) *i /= sum;\n }\n\n template\n void initKernelGaussianDeriv1D(Kernel1D& kernel, double m_sigma)\n {\n\t// Gaussian derivative smoothing\n typedef\ttypename Kernel1D::value_type vt;\n const vt z = 1.0 / (std::sqrt(2 * M_PI) * m_sigma);\n const vt m_sigmasquared = m_sigma * m_sigma;\n vt x = -1.0 * kernel.center();\n typename Kernel1D::iterator i;\n vt sum = 0.;\n for (i=kernel.begin(); i!=kernel.end(); ++i, ++x)\n {\n *i = - (x/m_sigmasquared) * z * (std::exp(-0.5*(x*x/m_sigmasquared)));\n sum += *i * x;\n }\n for (i=kernel.begin(); i!=kernel.end(); ++i) *i /= sum;\n }\n\n}\n\ntemplate\ntypename gradient_functor::result_type gradient_functor::operator()(Image& g, const View& v) const\n{\n using namespace boost::gil;\n\n typedef typename Image::view_t g_view_t;\n typedef typename get_pixel_type::type g_pixel_t;\n typedef typename kth_element_type::type element_0_t;\n typedef typename kth_element_type::type element_1_t;\n typedef pixel g0_pixel_t;\n typedef pixel g1_pixel_t;\n\n g.recreate(v.dimensions());\n\n unsigned int half_size = (unsigned int) (3* m_sigma) ;\n const size_t kws = 2 * half_size + 1;\n kernel_1d ksmooth(kws, kws / 2);\n kernel_1d kderiv(kws, kws / 2);\n internal::initKernelGaussian1D(ksmooth, m_sigma);\n internal::initKernelGaussianDeriv1D(kderiv, m_sigma);\n\n convolve_cols (v, ksmooth, kth_channel_view<0> (view(g)), convolve_option_extend_constant);\n convolve_rows (kth_channel_view<0> (view(g)), kderiv, kth_channel_view<0> (view(g)), convolve_option_extend_constant);\n\n convolve_rows (v, ksmooth, kth_channel_view<1> (view(g)), convolve_option_extend_constant);\n convolve_cols (kth_channel_view<1> (view(g)), kderiv, kth_channel_view<1> (view(g)), convolve_option_extend_constant);\n}\n\n#endif // GRADIENT_FUNCTOR_INC_HPP\n", "meta": {"hexsha": "f81e9bab75b4214f21329cbc0b42b4e21afd2212", "size": 4858, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/rjmcmc/image/gradient_functor_inc.hpp", "max_stars_repo_name": "qc2105/librjmcmc", "max_stars_repo_head_hexsha": "6e031a9f6f3612394f8918c745700ae41d2aa586", "max_stars_repo_licenses": ["CECILL-B"], "max_stars_count": 17.0, "max_stars_repo_stars_event_min_datetime": "2015-02-17T17:07:31.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-02T16:49:02.000Z", "max_issues_repo_path": "include/rjmcmc/image/gradient_functor_inc.hpp", "max_issues_repo_name": "qc2105/librjmcmc", "max_issues_repo_head_hexsha": "6e031a9f6f3612394f8918c745700ae41d2aa586", "max_issues_repo_licenses": ["CECILL-B"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2015-09-24T09:39:33.000Z", "max_issues_repo_issues_event_max_datetime": "2016-01-03T13:22:49.000Z", "max_forks_repo_path": "include/rjmcmc/image/gradient_functor_inc.hpp", "max_forks_repo_name": "qc2105/librjmcmc", "max_forks_repo_head_hexsha": "6e031a9f6f3612394f8918c745700ae41d2aa586", "max_forks_repo_licenses": ["CECILL-B"], "max_forks_count": 15.0, "max_forks_repo_forks_event_min_datetime": "2015-03-18T17:32:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-04T21:38:16.000Z", "avg_line_length": 40.4833333333, "max_line_length": 134, "alphanum_fraction": 0.6930835735, "num_tokens": 1244, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382094310357, "lm_q2_score": 0.6370307806984444, "lm_q1q2_score": 0.5488263581553926}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"DatasetAR.h\"\n#include \"DatasetARX.h\"\n#include \"GaussSeq.h\"\n#include \"ARSeq.h\"\n#include \"ARPoly.h\"\n#include \"utils.h\"\nusing utils::my_float;\nusing boost::multiprecision::cpp_bin_float_50;\nusing boost::random::uniform_real_distribution;\n\n\nint main() {\n boost::random::mt19937 gen {};\n uniform_real_distribution u(-1, 1);\n\n // prepare \n std::map coeff {\n {3, 0.2},\n {20, 0.5},\n };\n std::map coeff_2 {\n {3, 0.75},\n {20, -0.9},\n };\n std::vector v_seed(20);\n\n // Stationary AR process\n for (auto type = 0; type < 5; type++) {\n for (auto samp = 0; samp < utils::N_SAMPLE; samp++) {\n // Seed differently\n for (auto i = 0; i < 20; i++) {\n v_seed[i] = u(gen);\n }\n ARSeq targ_seq(coeff, u(gen));\n targ_seq.seed_prev_vals(v_seed);\n\n DatasetAR dat(\"./ARStat/ARStat-\" + std::to_string(type) + \n \"/Sample-\" + std::to_string(samp), targ_seq, type);\n dat.write_csv();\n }\n }\n\n // Non-stationary AR process\n for (auto type = 0; type < 5; type++) {\n for (auto samp = 0; samp < utils::N_SAMPLE; samp++) {\n // Seed differently\n for (auto i = 0; i < 20; i++) {\n v_seed[i] = u(gen);\n }\n ARSeq targ_seq(coeff_2, u(gen));\n targ_seq.seed_prev_vals(v_seed);\n\n DatasetAR dat(\"./ARNStat/ARNStat-\" + std::to_string(type) + \n \"/Sample-\" + std::to_string(samp), targ_seq, type);\n dat.write_csv();\n }\n }\n\n // Non-stationary ARX process\n for (auto type = 1; type < 5; type++) {\n for (auto samp = 0; samp < utils::N_SAMPLE; samp++) {\n DatasetARX dat(\"./ARXNStat/ARXNStat-\" + std::to_string(type) + \n \"/Sample-\" + std::to_string(samp), type);\n dat.write_csv();\n }\n }\n return 0;\n}\n", "meta": {"hexsha": "0016046576d7fe16b4ac6e55a73c58130371609d", "size": 2217, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "gen-data/main/gen-train-1.cpp", "max_stars_repo_name": "kvathupo/Synthetic-Time-Series-Generator", "max_stars_repo_head_hexsha": "ac133d2b0beff7f93f686742ce59401bc3cd1b90", "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": "gen-data/main/gen-train-1.cpp", "max_issues_repo_name": "kvathupo/Synthetic-Time-Series-Generator", "max_issues_repo_head_hexsha": "ac133d2b0beff7f93f686742ce59401bc3cd1b90", "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": "gen-data/main/gen-train-1.cpp", "max_forks_repo_name": "kvathupo/Synthetic-Time-Series-Generator", "max_forks_repo_head_hexsha": "ac133d2b0beff7f93f686742ce59401bc3cd1b90", "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": 28.7922077922, "max_line_length": 75, "alphanum_fraction": 0.5444294091, "num_tokens": 612, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8080672135527632, "lm_q2_score": 0.6791787056691698, "lm_q1q2_score": 0.5488220441944583}} {"text": "/*BISHOPS - Bishops\n#math #big-numbers #ad-hoc-1\n\nYesterday was Sam's birthday. The most interesting gift was definitely the chessboard. Sam quickly learned the rules of chess and defeated his father, all his friends, his little sister, and now no one wants to play with him any more.\n\nSo he decided to play with another birthday gift – a Book of Math Problems for Young Mathematicians. He opened the book somewhere in the middle and read the following problem: \"How many knights can be placed on a chessboard without threatening each other?\" After a while he realized that this was trivial and moved on to the next problem: \"How many bishops can be placed on a chessboard without threatening each other?\". Sam is in trouble here. He is not able to solve this problem and needs your help.\n\nSam's chessboard has size N x N. A bishop can move to any distance in any of the four diagonal directions. A bishop threatens another bishop if it can move to the other bishop's position. Your task is to compute the maximum number of bishops that can be placed on a chessboard in such a way that no two bishops threaten each other.\nInput\n\nThe input file consists of several lines. The line number i contains a single positive integer N representing the size of the i-th chessboard. [1 <= N <= 10^100]\nOutput\n\nThe output file should contain the same number of lines as the input file. The i-th line should contain one number – the maximum number of bishops that can be placed on i-th chessboard without threatening each other.\nExample\n\nInput:\n2\n3\n\nOutput:\n2\n4\n\n*/\n\n#include \n#include \n\nint main()\n{\n using namespace boost::multiprecision;\n \n cpp_int num;\n \n while (std::cin >> num)\n {\n std::cout << (num <= 1 ? num : 2*num - 2) << std::endl;\n }\n \n return 0;\n}\n", "meta": {"hexsha": "da9b988a8be64c76035c95c751b0419bc4049570", "size": 1827, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "SPOJ/BISHOPS - Bishops.cpp", "max_stars_repo_name": "ravirathee/Competitive-Programming", "max_stars_repo_head_hexsha": "20a0bfda9f04ed186e2f475644e44f14f934b533", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2018-11-26T02:38:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-28T00:16:41.000Z", "max_issues_repo_path": "SPOJ/BISHOPS - Bishops.cpp", "max_issues_repo_name": "ravirathee/Competitive-Programming", "max_issues_repo_head_hexsha": "20a0bfda9f04ed186e2f475644e44f14f934b533", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-05-30T09:25:53.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-05T08:33:56.000Z", "max_forks_repo_path": "SPOJ/BISHOPS - Bishops.cpp", "max_forks_repo_name": "ravirathee/Competitive-Programming", "max_forks_repo_head_hexsha": "20a0bfda9f04ed186e2f475644e44f14f934b533", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2020-04-16T07:15:01.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-04T06:26:07.000Z", "avg_line_length": 42.488372093, "max_line_length": 502, "alphanum_fraction": 0.746031746, "num_tokens": 421, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178969328287, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.548743272650867}} {"text": "#pragma once\n\n#include \n#include \n\ntemplate \nclass Twist {\n using Vector3x = Eigen::Matrix;\n\n public:\n Twist() {}\n Twist(const Vector3x& rotation, const Vector3x& translation)\n : rotation_(rotation), translation_(translation) {}\n\n Twist(const Twist& twist)\n : rotation_(twist.rotation_), translation_(twist.translation_) {}\n\n const Vector3x& Translation() const { return translation_; }\n\n Vector3x& Translation() { return translation_; }\n\n const Vector3x& Rotation() const { return rotation_; }\n\n Vector3x& Rotation() { return rotation_; }\n\n private:\n Vector3x rotation_;\n Vector3x translation_;\n};\n\ntemplate \nTwist operator*(const Twist& twist, const float scale) {\n return Twist{twist.Rotation() * scale, twist.Translation() * scale};\n}\n\ntemplate \nTwist operator*(const float scale, const Twist& twist) {\n return Twist{twist.Rotation() * scale, twist.Translation() * scale};\n}\n\n/**\n * se3 -> SE3\n */\ntemplate \nEigen::Transform Exp(const Twist& T) {\n const auto& w = T.Rotation();\n const auto& v = T.Translation();\n\n const float t2 = w.dot(w);\n const float t = std::sqrt(t2);\n const bool is_small_angle = (t <= std::numeric_limits::epsilon());\n const Eigen::AngleAxis rotation(t, is_small_angle ? w : w / t);\n\n if (is_small_angle) {\n const Eigen::Matrix position = v + 0.5 * w.cross(v);\n return Eigen::Translation{position} * rotation;\n }\n\n const float ct = std::cos(t);\n const float st = std::sin(t);\n const float awxv = (1.0 - ct) / t2;\n const float av = (st / t);\n const float aw = (1.0 - av) / t2;\n\n const Eigen::Matrix position =\n av * v + aw * w.dot(v) * w + awxv * w.cross(v);\n\n return Eigen::Translation{position} * rotation;\n}\n\n/**\n * SE3 -> se3\n */\ntemplate \nTwist Log(const Eigen::Transform& T) {\n Twist out;\n\n // Extract components.\n const Eigen::AngleAxis axa{T.linear()};\n const Eigen::Matrix& w = axa.axis() * axa.angle();\n const Eigen::Matrix& p = T.translation();\n\n // Set intermediate values.\n const float t = axa.angle();\n const float t2 = t * t;\n const bool is_small_angle = (t <= std::numeric_limits::epsilon());\n\n if (is_small_angle) {\n const Eigen::Matrix& v = p + 0.5 * p.cross(w);\n return Twist{w, v};\n }\n\n const float st = std::sin(t);\n const float ct = std::cos(t);\n const float alpha = (t * st / (2.0 * (1.0 - ct)));\n const float beta = (1.0 / t2 - st / (2.0 * t * (1.0 - ct)));\n const Eigen::Matrix& v =\n (alpha * p - 0.5 * w.cross(p) + beta * w.dot(p) * w);\n return Twist{w, v};\n}\n", "meta": {"hexsha": "981da0ccb8fd6ec3ec3a349f4309c6b6a62d7a01", "size": 2880, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/raycaster/twist.hpp", "max_stars_repo_name": "yycho0108/PCLRayCaster", "max_stars_repo_head_hexsha": "b80fda4c5357a7777e4e9ea31f36fc09b6502312", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/raycaster/twist.hpp", "max_issues_repo_name": "yycho0108/PCLRayCaster", "max_issues_repo_head_hexsha": "b80fda4c5357a7777e4e9ea31f36fc09b6502312", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/raycaster/twist.hpp", "max_forks_repo_name": "yycho0108/PCLRayCaster", "max_forks_repo_head_hexsha": "b80fda4c5357a7777e4e9ea31f36fc09b6502312", "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": 28.5148514851, "max_line_length": 78, "alphanum_fraction": 0.6427083333, "num_tokens": 841, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998611746912, "lm_q2_score": 0.7057850340255387, "lm_q1q2_score": 0.5486066089672259}} {"text": "/*SLAMBOOK2里面，使用智能指针实现G2O的版本*/\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// 曲线模型的顶点，模板参数：优化变量维度和数据类型\nclass CurveFittingVertex : public g2o::BaseVertex<3, Eigen::Vector3d> {\npublic:\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n\n // 重置\n virtual void setToOriginImpl() override {\n _estimate << 0, 0, 0;\n }\n\n // 更新\n virtual void oplusImpl(const double *update) override {\n _estimate += Eigen::Vector3d(update);\n }\n\n // 存盘和读盘：留空\n virtual bool read(istream &in) {}\n\n virtual bool write(ostream &out) const {}\n};\n\n// 误差模型 模板参数：观测值维度，类型，连接顶点类型\nclass CurveFittingEdge : public g2o::BaseUnaryEdge<1, double, CurveFittingVertex> {\npublic:\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n\n CurveFittingEdge(double x) : BaseUnaryEdge(), _x(x) {}\n\n // 计算曲线模型误差\n virtual void computeError() override {\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\n // 计算雅可比矩阵\n virtual void linearizeOplus() override {\n const CurveFittingVertex *v = static_cast (_vertices[0]);\n const Eigen::Vector3d abc = v->estimate();\n double y = exp(abc[0] * _x * _x + abc[1] * _x + abc[2]);\n _jacobianOplusXi[0] = -_x * _x * y;\n _jacobianOplusXi[1] = -_x * y;\n _jacobianOplusXi[2] = -y;\n }\n\n virtual bool read(istream &in) {}\n\n virtual bool write(ostream &out) const {}\n\npublic:\n double _x; // x 值， y 值为 _measurement\n};\n\nint main(int argc, char **argv) {\n double ar = 1.0, br = 2.0, cr = 1.0; // 真实参数值\n double ae = 2.0, be = -1.0, ce = 5.0; // 估计参数值\n int N = 100; // 数据点\n double w_sigma = 1.0; // 噪声Sigma值\n double inv_sigma = 1.0 / w_sigma;\n cv::RNG rng; // OpenCV随机数产生器\n\n vector x_data, y_data; // 数据\n for (int i = 0; i < N; i++) {\n double x = i / 100.0;\n x_data.push_back(x);\n y_data.push_back(exp(ar * x * x + br * x + cr) + rng.gaussian(w_sigma * w_sigma));\n }\n\n // 构建图优化，先设定g2o\n typedef g2o::BlockSolver> BlockSolverType; // 每个误差项优化变量维度为3，误差值维度为1\n typedef g2o::LinearSolverDense LinearSolverType; // 线性求解器类型\n\n // 梯度下降方法，可以从GN, LM, DogLeg 中选\n auto solver = new g2o::OptimizationAlgorithmGaussNewton(\n g2o::make_unique(g2o::make_unique()));\n g2o::SparseOptimizer optimizer; // 图模型\n optimizer.setAlgorithm(solver); // 设置求解器\n optimizer.setVerbose(true); // 打开调试输出\n\n // 往图中增加顶点\n CurveFittingVertex *v = new CurveFittingVertex();\n v->setEstimate(Eigen::Vector3d(ae, be, ce));\n v->setId(0);\n optimizer.addVertex(v);\n\n // 往图中增加边\n for (int i = 0; i < N; i++) {\n CurveFittingEdge *edge = new CurveFittingEdge(x_data[i]);\n edge->setId(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\" << endl;\n chrono::steady_clock::time_point t1 = chrono::steady_clock::now();\n optimizer.initializeOptimization();\n optimizer.optimize(10);\n chrono::steady_clock::time_point t2 = chrono::steady_clock::now();\n chrono::duration time_used = chrono::duration_cast>(t2 - t1);\n cout << \"solve time cost = \" << time_used.count() << \" seconds. \" << endl;\n\n // 输出优化值\n Eigen::Vector3d abc_estimate = v->estimate();\n cout << \"estimated model: \" << abc_estimate.transpose() << endl;\n\n return 0;\n}", "meta": {"hexsha": "c8cfc726a323beea4f6a6d5227af485df8e1e536", "size": 4156, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ch6/g2o_curve_fitting/g2oCurveFitting.cpp", "max_stars_repo_name": "seanleecn/learn_SLAM14", "max_stars_repo_head_hexsha": "d86501efcad7a95d545b53968864f4d61f0a4b8c", "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": "ch6/g2o_curve_fitting/g2oCurveFitting.cpp", "max_issues_repo_name": "seanleecn/learn_SLAM14", "max_issues_repo_head_hexsha": "d86501efcad7a95d545b53968864f4d61f0a4b8c", "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": "ch6/g2o_curve_fitting/g2oCurveFitting.cpp", "max_forks_repo_name": "seanleecn/learn_SLAM14", "max_forks_repo_head_hexsha": "d86501efcad7a95d545b53968864f4d61f0a4b8c", "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.46875, "max_line_length": 108, "alphanum_fraction": 0.656641001, "num_tokens": 1476, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998611746912, "lm_q2_score": 0.7057850278370112, "lm_q1q2_score": 0.5486066041568844}} {"text": "// Software License for MTL\n// \n// Copyright (c) 2007 The Trustees of Indiana University.\n// 2008 Dresden University of Technology and the Trustees of Indiana University.\n// 2010 SimuNova UG (haftungsbeschränkt), www.simunova.com.\n// All rights reserved.\n// Authors: Peter Gottschling and Andrew Lumsdaine\n// \n// This file is part of the Matrix Template Library\n// \n// See also license.mtl.txt in the distribution.\n\n#ifndef ITL_CG_INCLUDE\n#define ITL_CG_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\nnamespace itl {\n\n/// Conjugate Gradients without preconditioning\ntemplate < typename LinearOperator, typename HilbertSpaceX, typename HilbertSpaceB, \n\t typename Iteration >\nint cg(const LinearOperator& A, HilbertSpaceX& x, const HilbertSpaceB& b, \n Iteration& iter)\n{\n mtl::vampir_trace<7001> tracer;\n using std::abs; using mtl::conj; using mtl::lazy;\n typedef HilbertSpaceX Vector;\n typedef typename mtl::Collection::value_type Scalar;\n typedef typename Iteration::real Real;\n\n Scalar rho(0), rho_1(0), alpha(0), alpha_1(0);\n Vector p(resource(x)), q(resource(x)), r(resource(x)), z(resource(x));\n \n r = b - A*x;\n rho = dot(r, r);\n while (! iter.finished(Real(sqrt(abs(rho))))) {\n\t++iter;\n\tif (iter.first())\n\t p = r;\n\telse \n\t p = r + (rho / rho_1) * p;\t \n\n\t// q = A * p; alpha = rho / dot(p, q);\n\t(lazy(q)= A * p) || (lazy(alpha_1)= lazy_dot(p, q));\n\talpha= rho / alpha_1;\n\t\n\tx += alpha * p;\n\trho_1 = rho;\n\t(lazy(r) -= alpha * q) || (lazy(rho) = lazy_unary_dot(r));\n }\n\n return iter;\n}\n\n/// Conjugate Gradients\ntemplate < typename LinearOperator, typename HilbertSpaceX, typename HilbertSpaceB, \n\t typename Preconditioner, typename Iteration >\nint cg(const LinearOperator& A, HilbertSpaceX& x, const HilbertSpaceB& b, \n const Preconditioner& L, Iteration& iter)\n{\n using pc::is_identity;\n if (is_identity(L))\n\treturn cg(A, x, b, iter);\n\n mtl::vampir_trace<7002> tracer;\n using std::abs; using mtl::conj; using mtl::lazy;\n typedef HilbertSpaceX Vector;\n typedef typename mtl::Collection::value_type Scalar;\n typedef typename Iteration::real Real;\n\n Scalar rho(0), rho_1(0), rr, alpha(0), alpha_1;\n Vector p(resource(x)), q(resource(x)), r(resource(x)), z(resource(x));\n \n r = b - A*x;\n rr = dot(r, r);\n while (! iter.finished(Real(sqrt(abs(rr))))) {\n\t++iter;\n\t(lazy(z)= solve(L, r)) || (lazy(rho)= lazy_dot(r, z));\n\n\tif (iter.first())\n\t p = z;\n\telse \n\t p = z + (rho / rho_1) * p;\n\t\n\t(lazy(q)= A * p) || (lazy(alpha_1)= lazy_dot(p, q));\n\talpha= rho / alpha_1;\n \n\tx += alpha * p;\n\trho_1 = rho;\n\t(lazy(r) -= alpha * q) || (lazy(rr) = lazy_unary_dot(r));\n }\n return iter;\n}\n\n/// Conjugate Gradients with ignored right preconditioner to unify interface\ntemplate < typename LinearOperator, typename HilbertSpaceX, typename HilbertSpaceB, \n\t typename Preconditioner, typename RightPreconditioner, typename Iteration >\nint cg(const LinearOperator& A, HilbertSpaceX& x, const HilbertSpaceB& b, \n const Preconditioner& L, const RightPreconditioner&, Iteration& iter)\n{\n return cg(A, x, b, L, iter);\n}\n\n/// Solver class for CG method; right preconditioner ignored (prints warning if not identity)\ntemplate < typename LinearOperator, typename Preconditioner, \n\t typename RightPreconditioner>\nclass cg_solver\n{\n public:\n /// Construct solver from a linear operator; generate (left) preconditioner from it\n explicit cg_solver(const LinearOperator& A) : A(A), L(A) \n {\n\tif (!pc::static_is_identity::value)\n\t std::cerr << \"Right Preconditioner ignored!\" << std::endl;\n }\n\n /// Construct solver from a linear operator and (left) preconditioner\n cg_solver(const LinearOperator& A, const Preconditioner& L) : A(A), L(L) \n {\n\tif (!pc::static_is_identity::value)\n\t std::cerr << \"Right Preconditioner ignored!\" << std::endl;\n }\n\n /// Solve linear system approximately as specified by \\p iter\n template < typename HilbertSpaceB, typename HilbertSpaceX, typename Iteration >\n int solve(const HilbertSpaceB& b, HilbertSpaceX& x, Iteration& iter) const\n {\n\treturn cg(A, x, b, L, iter);\n }\n\n /// Perform one CG iteration on linear system\n template < typename HilbertSpaceB, typename HilbertSpaceX >\n int solve(const HilbertSpaceB& b, HilbertSpaceX& x) const\n {\n\titl::basic_iteration iter(x, 1, 0, 0);\n\treturn solve(b, x, iter);\n }\n \n private:\n const LinearOperator& A;\n Preconditioner L;\n};\n\n\n} // namespace itl\n\n#endif // ITL_CG_INCLUDE\n", "meta": {"hexsha": "f1f2eeedbee8ecbaa8fe07b69b14c32d72d79019", "size": 5270, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "lib/mtl4/boost/numeric/itl/krylov/cg.hpp", "max_stars_repo_name": "spraetor/amdis2", "max_stars_repo_head_hexsha": "53c45c81a65752a8fafbb54f9ae6724a86639dcd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2018-07-04T16:44:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-03T07:26:27.000Z", "max_issues_repo_path": "lib/mtl4/boost/numeric/itl/krylov/cg.hpp", "max_issues_repo_name": "spraetor/amdis2", "max_issues_repo_head_hexsha": "53c45c81a65752a8fafbb54f9ae6724a86639dcd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/mtl4/boost/numeric/itl/krylov/cg.hpp", "max_forks_repo_name": "spraetor/amdis2", "max_forks_repo_head_hexsha": "53c45c81a65752a8fafbb54f9ae6724a86639dcd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.1341463415, "max_line_length": 94, "alphanum_fraction": 0.675142315, "num_tokens": 1471, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998508568416, "lm_q2_score": 0.7057850154599563, "lm_q1q2_score": 0.5486065872540177}} {"text": "/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */\n\n/*\n Copyright (C) 2015 Klaus Spanderen\n\n This file is part of QuantLib, a free-software/open-source library\n for financial quantitative analysts and developers - http://quantlib.org/\n\n QuantLib is free software: you can redistribute it and/or modify it\n under the terms of the QuantLib license. You should have received a\n copy of the license along with this program; if not, please email\n . The license is also available online at\n .\n\n This program is distributed in the hope that it will be useful, but WITHOUT\n ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n FOR A PARTICULAR PURPOSE. See the license for more details.\n*/\n\n/*! \\file analytichestonadengine.hpp\n \\brief analytic Heston-model engine\n*/\n\n#ifndef quantlib_analytic_heston_ad_engine_hpp\n#define quantlib_analytic_heston_ad_engine_hpp\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \n\nnamespace QuantLib {\n\n //! analytic Heston-model engine based on Fourier transform\n class AnalyticHestonADEngine\n : public GenericModelEngine {\n public:\n class Integration;\n enum ComplexLogFormula { Gatheral, BranchCorrection };\n\n // Constructor using Laguerre integration\n // and Gatheral's version of complex log.\n AnalyticHestonADEngine(const boost::shared_ptr& model,\n Size integrationOrder = 144);\n\n\n void calculate() const;\n Size numberOfEvaluations() const;\n\n static void doCalculation(Real riskFreeDiscount,\n Real dividendDiscount,\n Real spotPrice,\n Real strikePrice,\n Real term,\n Real kappa, Real theta, Real sigma, Real v0, Real rho,\n const TypePayoff& type,\n const Integration& integration,\n const ComplexLogFormula cpxLog,\n const AnalyticHestonADEngine* const enginePtr,\n VanillaOption::results& results,\n Size& evaluations);\n\n protected:\n\n private:\n class Fj_Helper;\n\n mutable Size evaluations_;\n const ComplexLogFormula cpxLog_;\n const boost::shared_ptr integration_;\n };\n\n\n class AnalyticHestonADEngine::Integration {\n public:\n // non adaptive integration algorithms based on Gaussian quadrature\n static Integration gaussLaguerre (Size integrationOrder = 128);\n static Integration gaussLegendre (Size integrationOrder = 128);\n static Integration gaussChebyshev (Size integrationOrder = 128);\n static Integration gaussChebyshev2nd(Size integrationOrder = 128);\n\n CppAD::AD calculate(\n \tconst boost::function(Real)>& f) const;\n\n Size numberOfEvaluations() const;\n\n private:\n enum Algorithm\n { GaussLaguerre, GaussLegendre,\n GaussChebyshev, GaussChebyshev2nd };\n\n Integration(Algorithm intAlgo,\n const boost::shared_ptr& quadrature);\n\n const Algorithm intAlgo_;\n const boost::shared_ptr gaussianQuadrature_;\n };\n}\n\n#endif\n", "meta": {"hexsha": "27a6e0852a2ed32a7cffc54adc661dedd1cb48e9", "size": 4035, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "ShineNgine/Volatility/analytichestonadengine.hpp", "max_stars_repo_name": "FinancialEngineerLab/fineQuantlib", "max_stars_repo_head_hexsha": "a07eb659a440964ded9e9f636de0fd379672f4c3", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ShineNgine/Volatility/analytichestonadengine.hpp", "max_issues_repo_name": "FinancialEngineerLab/fineQuantlib", "max_issues_repo_head_hexsha": "a07eb659a440964ded9e9f636de0fd379672f4c3", "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": "ShineNgine/Volatility/analytichestonadengine.hpp", "max_forks_repo_name": "FinancialEngineerLab/fineQuantlib", "max_forks_repo_head_hexsha": "a07eb659a440964ded9e9f636de0fd379672f4c3", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.0183486239, "max_line_length": 99, "alphanum_fraction": 0.6188351921, "num_tokens": 800, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619436290699, "lm_q2_score": 0.6654105521116443, "lm_q1q2_score": 0.5486056771052588}} {"text": "/** @file\n *****************************************************************************\n \n Arithmetic in the finite field Fp, for prime p of fixed length using\n NTL as the backend.\n\n *****************************************************************************\n * @author Samir Menon, Brennan Shacklett, and David J. Wu\n * @copyright MIT license (see LICENSE file)\n *****************************************************************************/\n\n#ifndef NTLFP_HPP_\n#define NTLFP_HPP_\n\n#include \n#include \n#include \n#include \n#include \n\nnamespace libsnark {\n\ntemplate\nclass NTLFp_model;\n\ntemplate\nstd::ostream& operator<<(std::ostream &, const NTLFp_model&);\n\ntemplate\nstd::istream& operator>>(std::istream &, NTLFp_model &);\n\ntemplate\nclass NTLFp_model {\nprivate:\n NTL::ZZ_p value;\npublic:\n static const constexpr unsigned long& mod = modulus;\n static size_t s; // log2(modulus) OR modulus = 2^s * t + 1\n static size_t t; // with t odd\n static NTLFp_model multiplicative_generator; // generator of Fp^*\n static NTLFp_model root_of_unity; // generator^((modulus-1)/2^s)m\n static size_t num_bits;\n\n NTLFp_model();\n NTLFp_model(long x);\n NTLFp_model(const NTLFp_model &other);\n NTLFp_model(const NTL::ZZ_p &value) : value(value) {}\n\n NTL::ZZ_p as_ZZ_p() const { return this->value; }\n static NTL::ZZ mod_zz() { return NTL::ZZ(modulus); }\n\n bool operator==(const NTLFp_model& other) const;\n bool operator!=(const NTLFp_model& other) const;\n bool is_zero() const;\n\n void print() const;\n\n NTLFp_model& operator+=(const NTLFp_model& other);\n NTLFp_model& operator-=(const NTLFp_model& other);\n NTLFp_model& operator*=(const NTLFp_model& other);\n NTLFp_model& operator/=(const NTLFp_model& other);\n NTLFp_model& operator^=(const NTLFp_model& other);\n NTLFp_model& operator^=(unsigned long pwr);\n NTLFp_model& operator^=(const libff::bigint<1>& pwr);\n\n NTLFp_model operator+(const NTLFp_model& other) const;\n NTLFp_model operator-(const NTLFp_model& other) const;\n NTLFp_model operator*(const NTLFp_model& other) const;\n NTLFp_model operator/(const NTLFp_model& other) const;\n NTLFp_model operator-() const;\n\n NTLFp_model squared() const;\n NTLFp_model& invert();\n NTLFp_model inverse() const;\n NTLFp_model sqrt() const;\n void get_s_and_t(unsigned long& s, unsigned long& t);\n\n NTLFp_model operator^(unsigned long pwr) const;\n NTLFp_model operator^(const libff::bigint<1>& pwr) const;\n NTLFp_model operator^(const NTLFp_model& other) const;\n \n\n static size_t size_in_bits() { return num_bits; }\n static size_t capacity() { return num_bits - 1; }\n static unsigned long field_char() { return modulus; }\n static NTLFp_model geometric_generator() { return NTLFp_model::multiplicative_generator; }\n static NTLFp_model arithmetic_generator() { return 1; }\n\n static NTLFp_model zero();\n static NTLFp_model one();\n static NTLFp_model random_element();\n\n friend std::ostream& operator<< (std::ostream &out, const NTLFp_model &p);\n friend std::istream& operator>> (std::istream &in, NTLFp_model &p);\n};\n\ntemplate\nsize_t NTLFp_model::num_bits;\n\ntemplate\nsize_t NTLFp_model::s;\n\ntemplate\nsize_t NTLFp_model::t;\n\ntemplate\nNTLFp_model NTLFp_model::multiplicative_generator;\n\ntemplate\nNTLFp_model NTLFp_model::root_of_unity;\n\n} // libsnark\n\n#include \"ntlfp.tcc\"\n\n#endif // NTLFP_HPP_\n", "meta": {"hexsha": "0d6593c35230717880d77e967f025e1dabcdac51", "size": 3913, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "lattice_snarg/algebra/fields/ntlfp.hpp", "max_stars_repo_name": "dwu4/lattice-snarg", "max_stars_repo_head_hexsha": "f5ef3e75d7200ee2b794d04b102fc7502b149628", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2017-11-19T16:49:42.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-02T03:16:15.000Z", "max_issues_repo_path": "lattice_snarg/algebra/fields/ntlfp.hpp", "max_issues_repo_name": "dwu4/lattice-snarg", "max_issues_repo_head_hexsha": "f5ef3e75d7200ee2b794d04b102fc7502b149628", "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": "lattice_snarg/algebra/fields/ntlfp.hpp", "max_forks_repo_name": "dwu4/lattice-snarg", "max_forks_repo_head_hexsha": "f5ef3e75d7200ee2b794d04b102fc7502b149628", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2019-09-12T07:11:48.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-16T18:20:57.000Z", "avg_line_length": 33.4444444444, "max_line_length": 112, "alphanum_fraction": 0.6815742397, "num_tokens": 1099, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619350028204, "lm_q2_score": 0.6654105521116445, "lm_q1q2_score": 0.5486056713652614}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"vlasovpp/field.h\"\n#include \"vlasovpp/weno.h\"\n#include \"vlasovpp/fft.h\"\n#include \"vlasovpp/array_view.h\"\n#include \"vlasovpp/poisson.h\"\n\n#ifndef SIGMA\n#define SIGMA (2.*std::sqrt(2.))\n#endif\n#define E_MAX (0.6)\n\n/*\ntemplate \nstruct phi\n{\n static std::complex\n operator () ( std::complex const & z ) {\n static std::valarray> coeff(i);\n coeff[0] = 1.;\n\n for ( unsigned int k=1 ; k(0.,0.) ))/(std::pow(z,i));\n }\n};\n*/\ntemplate \nstd::complex\nphi ( std::complex const & _z )\n{\n std::valarray> coeff(i);\n coeff[0] = 1.;\n\n std::complex z = _z;\n if ( _z == 0. ) { z = std::complex(1.,0.); }\n\n for ( unsigned int k=1 ; k>(std::cout,\" . \"));\n //std::cout << std::endl;\n\n if ( z != 0. ) {\n return (std::exp(z) - std::accumulate( std::begin(coeff) , std::end(coeff) , std::complex(0.,0.) ))/(std::pow(z,i)); \n }\n return coeff[i-1];\n}\n\nnamespace o2 {\n template < typename _T , std::size_t NumDimsV >\n auto\n trp_v ( field<_T,NumDimsV> const & u , ublas::vector<_T> const& E )\n {\n field<_T,NumDimsV> trp(tools::array_view(u.shape(),NumDimsV+1));\n\n { auto k=0, km1=trp.size(0)-1;\n for ( auto i=0 ; i & I = std::complex(0.,1.);\n\n#define SQ(X) ((X)*(X))\n#define Xi(i) (i*f.step.dx+f.range.x_min)\n#define Vk(k) (k*f.step.dv+f.range.v_min)\n\nint main(int,char**)\n{\n\tstd::size_t Nx = 135, Nv = 256 , Nb_iter=10;\n\tfield f(boost::extents[Nv][Nx]);\n\n\tf.range.v_min = -8.; f.range.v_max = 8.;\n\tf.step.dv = (f.range.v_max-f.range.v_min)/Nv;\n\n const double Kx = 0.3;\n f.range.x_min = 0.; f.range.x_max = 2./Kx*math::pi();\n\t//f.range.x_min = 0.; f.range.x_max = 20.*math::pi();\n //f.range.x_min = 0.; f.range.x_max = 4.0*math::pi();\n //f.range.x_min = -8.; f.range.x_max = 8.;\n\tf.step.dx = (f.range.x_max-f.range.x_min)/Nx;\n\n // SIGMA is the CFL number 0.45 is E_max in our test case\n\tconst double dt = 0.05;//SIGMA*f.step.dv/E_MAX; //1.606*f.step.dv/0.6; //0.005; //1.606*f.step.dv/0.6; //0.5*6.*math::pi()/(Nv*f.range.v_max);\n\n //field f_sol = f;\n //field f_ini = f;\n\t\n\tublas::vector v (Nv,0.);\n ublas::vector E (Nx,0.),rho(Nx);\n for ( std::size_t k=0 ; k kx(Nx);\n\t//for ( auto i=0 ; i()*i/l; }\n\t//for ( auto i=0 ; i<((Nx/2)) ; ++i ) { kx[i+Nx/2+1] = -kx[Nx/2-i]; }\n for ( auto i=0 ; i()*i/l; }\n for ( int i=-Nx/2 ; i<0 ; ++i ) { kx[Nx+i] = 2.*math::pi()*i/l; }\n\t\n\n double ui = 3.4;\n double alpha = 0.1;\n double Tc = 0.0001;\n\n //double np = 0.9 , nb = 0.2 , ui = 4.5;\n for (field::size_type k=0 ; k::size_type i=0 ; i()) + nb/std::sqrt(2.*math::pi())*std::exp(-0.5*SQ(Vk(k)-ui)/0.25) )*(1.+0.04*std::cos(0.5*Xi(i)));\n \n // Bump on Tail\n f[k][i] = ( std::exp(-0.5*SQ(Vk(k)))*np/std::sqrt(2.*math::pi()) + nb/std::sqrt(2.*math::pi())*std::exp(-0.5*SQ(Vk(k)-ui)/0.25) )*(1.+0.04*std::cos(0.3*Xi(i)));\n // Landau dumpping test\n //f[k][i] = (1./std::sqrt(2*math::pi()))*std::exp(-0.5*SQ(Vk(k)))*(1.+0.001*std::cos(0.5*Xi(i)));\n \n //f[k][i] = std::exp( -SQ(Xi(i)-6) );\n //f[k][i] = std::exp(-SQ(Xi(i)-3)/0.5 - SQ(Vk(k))/2.);\n //f_sol[k][i] = std::exp(-SQ(Xi(i)-3)/0.5 - SQ(Vk(k))/2.);\n //f[k][i] = SQ(v(k))*std::exp(-0.5*SQ(Vk(k)))/std::sqrt(2.*math::pi())*(1.+0.01*std::cos(0.5*Xi(i)));\n //f_ini[k][i] = f[k][i];\n //f_sol[k][i] = std::exp(-SQ(Xi(i)-3.-v[k]*Nb_iter*dt)/0.5 - SQ(Vk(k)-E[i]*Nb_iter*dt)/2.);\n\n // triple bump\n //f[k][i] = ( 0.5*alpha/std::sqrt(2.*math::pi())*std::exp(-0.5*SQ(Vk(k)-ui)) + 0.5*alpha/std::sqrt(2.*math::pi())*std::exp(-0.5*SQ(Vk(k)+ui)) )*(1.+0.04*std::cos(Kx*Xi(i))) + ((1-alpha)/(std::sqrt(2.*math::pi()*Tc))*std::exp(-0.5*SQ(Vk(k))/Tc));\n }\n }\n f.write(\"vphl/kin/init.dat\");\n\n poisson poisson_solver(Nx,l);\n rho = f.density();\n E = poisson_solver(rho);\n \n\n //double Tf = 60.;//2*math::pi();\n double Tf = 40.;\n int i_t=0;\n\n std::cout << \"Nx: \" << Nx << \"\\n\";\n std::cout << \"Nv: \" << Nv << \"\\n\";\n std::cout << \"v_min: \" << f.range.v_min << \"\\n\";\n std::cout << \"v_max: \" << f.range.v_max << \"\\n\";\n std::cout << \"x_min: \" << f.range.x_min << \"\\n\";\n std::cout << \"x_max: \" << f.range.x_max << \"\\n\";\n std::cout << \"dt: \" << dt << \"\\n\";\n std::cout << \"dx: \" << f.step.dx << \"\\n\";\n std::cout << \"dv: \" << f.step.dv << \"\\n\";\n std::cout << \"Tf: \" << Tf << \"\\n\";\n std::cout << \"f_0: \" << \"\\\"bot\\\"\" << \"\\n\";\n std::cout << std::endl;\n\n std::ofstream info(\"info.yaml\");\n\n info << \"Nx: \" << Nx << \"\\n\";\n info << \"Nv: \" << Nv << \"\\n\";\n info << \"v_min: \" << f.range.v_min << \"\\n\";\n info << \"v_max: \" << f.range.v_max << \"\\n\";\n info << \"x_min: \" << f.range.x_min << \"\\n\";\n info << \"x_max: \" << f.range.x_max << \"\\n\";\n info << \"dt: \" << dt << \"\\n\";\n info << \"dx: \" << f.step.dx << \"\\n\";\n info << \"dv: \" << f.step.dv << \"\\n\";\n info << \"Tf: \" << Tf << \"\\n\";\n info << \"f_0: \" << \"\\\"bot\\\"\" << \"\\n\";\n info << std::endl;\n info.close();\n\n ublas::vector ee(int(std::ceil(Tf/dt))+1,0.);\n ublas::vector Emax(int(std::ceil(Tf/dt))+1,0.);\n ublas::vector H(int(std::ceil(Tf/dt))+1,0.);\n //ublas::vector ee(Nb_iter);\n //ublas::vector Emax(Nb_iter);\n //ublas::vector H(Nb_iter);\n\n field f1(tools::array_view(f.shape(),2)),f2(tools::array_view(f.shape(),2)),f3(tools::array_view(f.shape(),2)),f4(tools::array_view(f.shape(),2)),f5(tools::array_view(f.shape(),2));\n fft::spectrum_ hf(Nx),hf1(Nx),hf2(Nx),hf3(Nx),hf4(Nx),hf5(Nx),hEdvf(Nx),hEdvf1(Nx),hEdvf2(Nx),hEdvf3(Nx),hEdvf4(Nx);\n\n\n rho = f.density();\n E = poisson_solver(rho);\n //for ( int i=0 ; i Edvf = o2::trp_v(f,E);\n for ( auto k=0 ; k(dt*L)*hEdvf[i];\n }\n hf1.ifft(&(f1[k][0]));\n }\n\n E = poisson_solver(f1.density());\n field Edvf1 = o2::trp_v(f1,E);\n for ( auto k=0 ; k(dt*L)-phi<2>(dt*L))*hEdvf[i] + phi<2>(dt*L)*hEdvf1[i] );\n }\n\n hf.ifft(&(f[k][0]));\n }\n\n **/\n /**\n // Cox-Matthews ===========================================================\n #define SCHEME \"CM\"\n // SIGMA = 0.450 (10^-2)\n E = poisson_solver( f.density() );\n field Edvf = o2::trp_v(f,E);\n for ( auto k=0 ; k(-0.5*L*dt)*hEdvf[i];\n }\n\n hf1.ifft(&(f1[k][0]));\n }\n\n E = poisson_solver( f1.density() );\n field Edvf1 = o2::trp_v(f1,E);\n for ( auto k=0 ; k(-0.5*L*dt)*hEdvf1[i];\n }\n \n hf2.ifft(&(f2[k][0]));\n }\n\n E = poisson_solver( f2.density() );\n field Edvf2 = o2::trp_v(f2,E);\n for ( auto k=0 ; k(-0.5*L*dt)*(std::exp(-0.5*L*dt)-1.)*hEdvf[i] + dt*phi<1>(-0.5*L*dt)*hEdvf2[i];\n }\n\n hf3.ifft(&(f3[k][0]));\n }\n\n E = poisson_solver( f3.density() );\n field Edvf3 = o2::trp_v(f3,E);\n for ( auto k=0 ; k(-L*dt)-3.*phi<2>(-L*dt)+4.*phi<3>(-L*dt))*hEdvf[i]\n + (2.*phi<2>(-L*dt)-4.*phi<3>(-L*dt))*(hEdvf1[i]+hEdvf2[i])\n + (-phi<2>(-L*dt)+4.*phi<3>(-L*dt))*hEdvf3[i] );\n }\n\n hf4.ifft(&(f[k][0]));\n }\n\n **/\n /**\n // Krogstad ===============================================================\n #define SCHEME \"K\"\n // SIGMA = 0.200 (10^-2)\n E = poisson_solver( f.density() );\n field Edvf = o2::trp_v(f,E);\n for ( auto k=0 ; k(-0.5*L*dt)*hEdvf[i];\n }\n\n hf1.ifft(&(f1[k][0]));\n }\n\n E = poisson_solver( f1.density() );\n field Edvf1 = o2::trp_v(f1,E);\n for ( auto k=0 ; k(-0.5*L*dt)-phi<2>(-0.5*L*dt))*hEdvf[i] + dt*phi<2>(-0.5*L*dt)*hEdvf1[i];\n }\n \n hf2.ifft(&(f2[k][0]));\n }\n\n E = poisson_solver( f2.density() );\n field Edvf2 = o2::trp_v(f2,E);\n for ( auto k=0 ; k(-L*dt)-2.*phi<2>(-0.5*L*dt))*hEdvf[i] + 2.*dt*phi<2>(-L*dt)*hEdvf2[i];\n }\n\n hf3.ifft(&(f3[k][0]));\n }\n\n E = poisson_solver( f3.density() );\n field Edvf3 = o2::trp_v(f3,E);\n for ( auto k=0 ; k(-L*dt)-3.*phi<2>(-L*dt)+4.*phi<3>(-L*dt))*hEdvf[i]\n + (2.*phi<2>(-L*dt)-4.*phi<3>(-L*dt))*(hEdvf1[i]+hEdvf2[i])\n + (-phi<2>(-L*dt)+4.*phi<3>(-L*dt))*hEdvf3[i] );\n }\n\n hf4.ifft(&(f[k][0]));\n }\n\n **/\n /**\n // Hochbruck-Ostermann ====================================================\n #define SCHEME \"HO\"\n // SIGMA = 0.501 (10^-2)\n E = poisson_solver( f.density() );\n field Edvf = o2::trp_v(f,E);\n for ( auto k=0 ; k(-0.5*L*dt)*hEdvf[i];\n }\n\n hf1.ifft(&(f1[k][0]));\n }\n\n E = poisson_solver( f1.density() );\n field Edvf1 = o2::trp_v(f1,E);\n for ( auto k=0 ; k(-0.5*L*dt)-phi<2>(-0.5*L*dt))*hEdvf[i] + dt*phi<2>(-0.5*L*dt)*hEdvf1[i];\n }\n \n hf2.ifft(&(f2[k][0]));\n }\n\n E = poisson_solver( f2.density() );\n field Edvf2 = o2::trp_v(f2,E);\n for ( auto k=0 ; k(-L*dt)-2.*phi<2>(-L*dt))*hEdvf[i] + dt*phi<2>(-L*dt)*hEdvf1[i] + dt*phi<2>(-L*dt)*hEdvf2[i];\n }\n\n hf3.ifft(&(f3[k][0]));\n }\n\n E = poisson_solver( f3.density() );\n field Edvf3 = o2::trp_v(f3,E);\n for ( auto k=0 ; k(-0.5*L*dt)-phi<3>(-L*dt)+0.25*phi<2>(-L*dt)-0.5*phi<3>(-0.5*L*dt))\n#define a54 (0.25*phi<2>(-0.5*L*dt)-a52)\n for ( auto i=0 ; i(-0.5*L*dt)-2.*a52-a54)*hEdvf[i] + dt*a52*(hEdvf1[i]+hEdvf2[i]) + dt*(0.25*phi<2>(-0.5*L*dt)-a52)*hEdvf3[i];\n }\n#undef a54\n#undef a52\n\n hf4.ifft(&(f4[k][0]));\n }\n\n E = poisson_solver( f4.density() );\n field Edvf4 = o2::trp_v(f4,E);\n for ( auto k=0 ; k(-L*dt)-3.*phi<2>(-L*dt)+4.*phi<3>(-L*dt))*hEdvf[i]\n + (-phi<2>(-L*dt)+4.*phi<3>(-L*dt))*hEdvf3[i]\n + (4.*phi<2>(-L*dt)-8.*phi<3>(-L*dt))*hEdvf4[i] );\n }\n\n hf5.ifft(&(f[k][0]));\n }\n **/\n /**\n // RK(3,2) best ===========================================================\n #define SCHEME \"RK32\"\n // SIGMA = 2. (y_max)\n // SIGMA = 1.344 (WENO)\n E = poisson_solver(f.density());\n field Edvf = o2::trp_v(f,E);\n for ( auto k=0 ; k Edvf = weno::trp_v(f,E);\n for ( auto k=0 ; k Edvf = weno::trp_v(f,E);\n for ( auto k=0 ; k Edvf = weno::trp_v(f,E);\n for ( auto k=0 ; k Edvf = weno::trp_v(f,E);\n for ( auto k=0 ; k Edvf = weno::trp_v(f,E);\n for ( auto k=0 ; k(of,\"\\n\") , dx_y );\n of.close();\n\n ss.str(std::string());\n //std::ofstream of;\n std::size_t count = 0;\n auto dt_y = [&,count=0](auto const& y) mutable { std::stringstream ss; ss<<(count++)*dt<<\" \"<(of,\"\\n\") , dt_y );\n of.close();\n\n\treturn 0;\n}\n", "meta": {"hexsha": "70fd7b20924f0338bd3bb06aa17f52208f748d75", "size": 35449, "ext": "cc", "lang": "C++", "max_stars_repo_path": "code/main.cc", "max_stars_repo_name": "kivvix/vlasovpp", "max_stars_repo_head_hexsha": "123072d42ddcceef9278e0cd3ac18d5b3fa4b3c0", "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": "code/main.cc", "max_issues_repo_name": "kivvix/vlasovpp", "max_issues_repo_head_hexsha": "123072d42ddcceef9278e0cd3ac18d5b3fa4b3c0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/main.cc", "max_forks_repo_name": "kivvix/vlasovpp", "max_forks_repo_head_hexsha": "123072d42ddcceef9278e0cd3ac18d5b3fa4b3c0", "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.2833655706, "max_line_length": 390, "alphanum_fraction": 0.4452029676, "num_tokens": 14213, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619091240701, "lm_q2_score": 0.665410572017153, "lm_q1q2_score": 0.5486056705566016}} {"text": "\n// (C) Copyright John Maddock 2006.\n// Use, modification and distribution are subject to the\n// Boost Software License, Version 1.0. (See accompanying file\n// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n\n#ifndef BOOST_MATH_SPECIAL_HERMITE_HPP\n#define BOOST_MATH_SPECIAL_HERMITE_HPP\n\n#ifdef _MSC_VER\n#pragma once\n#endif\n\n#include \n#include \n#include \n\nnamespace boost{\nnamespace math{\n\n// Recurrence relation for Hermite polynomials:\ntemplate \ninline typename tools::promote_args::type \n hermite_next(unsigned n, T1 x, T2 Hn, T3 Hnm1)\n{\n return (2 * x * Hn - 2 * n * Hnm1);\n}\n\nnamespace detail{\n\n// Implement Hermite polynomials via recurrence:\ntemplate \nT hermite_imp(unsigned n, T x)\n{\n T p0 = 1;\n T p1 = 2 * x;\n\n if(n == 0)\n return p0;\n\n unsigned c = 1;\n\n while(c < n)\n {\n std::swap(p0, p1);\n p1 = hermite_next(c, x, p0, p1);\n ++c;\n }\n return p1;\n}\n\n} // namespace detail\n\ntemplate \ninline typename tools::promote_args::type \n hermite(unsigned n, T x, const Policy&)\n{\n typedef typename tools::promote_args::type result_type;\n typedef typename policies::evaluation::type value_type;\n return policies::checked_narrowing_cast(detail::hermite_imp(n, static_cast(x)), \"boost::math::hermite<%1%>(unsigned, %1%)\");\n}\n\ntemplate \ninline typename tools::promote_args::type \n hermite(unsigned n, T x)\n{\n return boost::math::hermite(n, x, policies::policy<>());\n}\n\n} // namespace math\n} // namespace boost\n\n#endif // BOOST_MATH_SPECIAL_HERMITE_HPP\n\n\n\n", "meta": {"hexsha": "dcc352f55f279bbe7fc92af67b6f3b5b88d225e2", "size": 1778, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "ReactNativeFrontend/ios/Pods/boost/boost/math/special_functions/hermite.hpp", "max_stars_repo_name": "Harshitha91/Tmdb-react-native-node", "max_stars_repo_head_hexsha": "e06e3f25a7ee6946ef07a1f524fdf62e48424293", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 310.0, "max_stars_repo_stars_event_min_datetime": "2017-02-02T09:14:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-21T06:50:11.000Z", "max_issues_repo_path": "ReactNativeFrontend/ios/Pods/boost/boost/math/special_functions/hermite.hpp", "max_issues_repo_name": "Harshitha91/Tmdb-react-native-node", "max_issues_repo_head_hexsha": "e06e3f25a7ee6946ef07a1f524fdf62e48424293", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 626.0, "max_issues_repo_issues_event_min_datetime": "2015-02-05T18:12:27.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-20T13:19:18.000Z", "max_forks_repo_path": "ReactNativeFrontend/ios/Pods/boost/boost/math/special_functions/hermite.hpp", "max_forks_repo_name": "Harshitha91/Tmdb-react-native-node", "max_forks_repo_head_hexsha": "e06e3f25a7ee6946ef07a1f524fdf62e48424293", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 243.0, "max_forks_repo_forks_event_min_datetime": "2015-01-17T17:46:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-07T12:56:26.000Z", "avg_line_length": 23.0909090909, "max_line_length": 160, "alphanum_fraction": 0.6996625422, "num_tokens": 506, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619177503206, "lm_q2_score": 0.6654105521116443, "lm_q1q2_score": 0.548605659885266}} {"text": "// Copyright (C) 2021 Christian Brommer, Control of Networked Systems, University of Klagenfurt, Austria.\n//\n// All rights reserved.\n//\n// This software is licensed under the terms of the BSD-2-Clause-License with\n// no commercial use allowed, the full terms of which are made available\n// in the LICENSE file. No license in patents is granted.\n//\n// You can contact the author at \n\n#include \n#include \n\nnamespace mars\n{\nNearestCov::NearestCov(const Eigen::MatrixXd& covariance) : cov_mat_(covariance)\n{\n // Ensure the matrix is square\n assert(covariance.rows() == covariance.cols());\n}\n\nEigen::MatrixXd NearestCov::EigenCorrectionUsingCovariance(NearestCovMethod method)\n{\n Eigen::EigenSolver vd(cov_mat_);\n\n Eigen::EigenSolver::EigenvectorsType V(vd.eigenvectors());\n Eigen::EigenSolver::EigenvalueType D(vd.eigenvalues());\n\n if (!(V.imag().isZero() && D.imag().isZero()))\n {\n std::cout << \"Warning: Eigenvalue decomposition has imaginary components\" << std::endl;\n }\n\n Eigen::MatrixXd V_real(V.real());\n Eigen::VectorXd D_real(D.real());\n\n // determine if the matrix is already positive-semi-definite\n bool no_negative_eigenvalues = true;\n for (int k = 0; k < D_real.size(); k++)\n {\n if (D_real[k] < 0)\n {\n no_negative_eigenvalues = false;\n }\n }\n\n if (no_negative_eigenvalues)\n {\n return cov_mat_;\n }\n\n Eigen::VectorXd D_corrected(D_real);\n\n // Correct the covariance matrix\n switch (method)\n {\n case NearestCovMethod::abs:\n // replace negative Eigenvalues with their absolut value\n for (int k = 0; k < D_corrected.size(); k++)\n {\n if (D_corrected[k] < 0)\n {\n D_corrected[k] = std::abs(D_corrected[k]);\n }\n }\n break;\n\n case NearestCovMethod::zero:\n // replace negative Eigenvalues with zero\n for (int k = 0; k < D_corrected.size(); k++)\n {\n if (D_corrected[k] < 0)\n {\n D_corrected[k] = 0.0;\n }\n }\n break;\n\n case NearestCovMethod::delta:\n // replace negative Eigenvalues with a positive delta\n for (int k = 0; k < D_corrected.size(); k++)\n {\n if (D_corrected[k] < 0)\n {\n D_corrected[k] = delta_;\n }\n }\n break;\n\n default:\n std::cout << \"Warning: Unexpected method for nearest_cov\" << std::endl;\n break;\n }\n\n Eigen::MatrixXd result(V_real * D_corrected.asDiagonal() * V_real.inverse());\n return result;\n}\n\nEigen::MatrixXd NearestCov::EigenCorrectionUsingCorrelation(NearestCovMethod method)\n{\n // TODO\n return {};\n}\n}\n", "meta": {"hexsha": "2c46283fa053f86860d8a26ce12e108d7b28b0a3", "size": 2664, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "source/mars/source/nearest_cov.cpp", "max_stars_repo_name": "eallak/mars_lib", "max_stars_repo_head_hexsha": "9657fb669c48be39471e7504c3648319126c020b", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "source/mars/source/nearest_cov.cpp", "max_issues_repo_name": "eallak/mars_lib", "max_issues_repo_head_hexsha": "9657fb669c48be39471e7504c3648319126c020b", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "source/mars/source/nearest_cov.cpp", "max_forks_repo_name": "eallak/mars_lib", "max_forks_repo_head_hexsha": "9657fb669c48be39471e7504c3648319126c020b", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.3714285714, "max_line_length": 105, "alphanum_fraction": 0.643018018, "num_tokens": 711, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199633332891, "lm_q2_score": 0.6548947357776795, "lm_q1q2_score": 0.548552904569264}} {"text": "#include \"ExtendedKalmanFilter4d.h\"\n\n#include \n\nExtendedKalmanFilter4d::ExtendedKalmanFilter4d(const Eigen::Vector4d& state, const Eigen::Matrix2d& processNoiseStdSingleDimension, const Eigen::Matrix2d& measurementNoiseCovariances, const Eigen::Matrix2d& initialStateStdSingleDimension):\n x(state)\n{\n Eigen::Matrix2d q;\n q = processNoiseStdSingleDimension.cwiseProduct(processNoiseStdSingleDimension);\n\n // covariance matrix of process noise (values taken from old kalman filter)\n Q << q, Eigen::Matrix2d::Zero(), Eigen::Matrix2d::Zero(), q;\n\n // covariance matrix of measurement noise\n Eigen::Matrix2d r;\n R << measurementNoiseCovariances;\n\n // inital covariance matrix of current state (values taken from old kalman filter)\n //double p = 62500;\n Eigen::Matrix2d p;\n p = initialStateStdSingleDimension.cwiseProduct(initialStateStdSingleDimension);\n P << p, Eigen::Matrix2d::Zero(), Eigen::Matrix2d::Zero(), p;\n\n P_pre = P; // covariance matrix of predicted state\n P_corr = P; // covariance matrix of corrected state\n\n x_pre = x;\n x_corr = x;\n\n updateEllipses();\n}\n\nExtendedKalmanFilter4d::~ExtendedKalmanFilter4d()\n{\n\n}\n\nvoid ExtendedKalmanFilter4d::predict(const Eigen::Vector2d& u, double dt)\n{\n // adapt state transition matrix\n F << 1, dt, 0, 0,\n 0, 1, 0, 0,\n 0, 0, 1, dt,\n 0, 0, 0, 1;\n\n // adapt control matrix to dt\n B << dt*dt/2, 0,\n dt , 0,\n 0 , dt*dt/2,\n 0 , dt;\n\n // predict\n x_pre = F * x + B * u;\n P_pre = F * P * F.transpose() + Q;\n\n x = x_pre;\n P = P_pre;\n\n updateEllipses();\n}\n\nvoid ExtendedKalmanFilter4d::update(const Eigen::Vector2d& z, const Measurement_Function_H& h)\n{\n Eigen::Vector2d predicted_measurement;\n\n predicted_measurement = getStateInMeasurementSpace(h);\n\n // approximate H with central differential quotient\n H = approximateH(h);\n\n Eigen::Matrix2d temp1 = H * P_pre * H.transpose() + R;\n\n K = P_pre * H.transpose() * temp1.inverse();\n\n // just for debugging - begin\n x_pre = x;\n P_pre = P;\n // just for debugging - end\n\n x_corr = x_pre + K * (z - predicted_measurement);\n\n P_corr = (Eigen::Matrix4d::Identity()-K*H)*P_pre;\n\n x = x_corr;\n P = P_corr;\n\n updateEllipses();\n}\n\nEigen::Matrix ExtendedKalmanFilter4d::approximateH(const Measurement_Function_H &h) const {\n double e = 1e-4;\n Eigen::Vector2d dx1, dx2, dy1, dy2;\n\n dx1 = h(x(0)-e,x(2));\n dx2 = h(x(0)+e,x(2));\n\n dy1 = h(x(0),x(2)-e);\n dy2 = h(x(0),x(2)+e);\n\n Eigen::Vector2d dx = (dx2-dx1)/(2*e);\n Eigen::Vector2d dy = (dy2-dy1)/(2*e);\n\n Eigen::Matrix H_approx;\n H_approx << dx(0), 0, dy(0), 0,\n dx(1), 0, dy(1), 0;\n\n return H_approx;\n}\n\n//--- setter ---//\n\nvoid ExtendedKalmanFilter4d::setState(Eigen::Vector4d& state)\n{\n x = state;\n}\n\nvoid ExtendedKalmanFilter4d::setCovarianceOfProcessNoise(const Eigen::Matrix2d& q){\n Q << q, Eigen::Matrix2d::Zero(), Eigen::Matrix2d::Zero(), q;\n}\n\nvoid ExtendedKalmanFilter4d::setCovarianceOfState(const Eigen::Matrix4d& p){\n P << p;\n}\n\nvoid ExtendedKalmanFilter4d::setCovarianceOfMeasurementNoise(const Eigen::Matrix2d& r){\n R << r;\n}\n\n//--- getter ---//\nEigen::Matrix2d ExtendedKalmanFilter4d::getStateCovarianceInMeasurementSpace(const Measurement_Function_H& h) const // horizontal, vertical\n{\n Eigen::Matrix H_approx;\n\n H_approx = approximateH(h);\n\n return H_approx * P * H_approx.transpose();\n}\n\nvoid ExtendedKalmanFilter4d::updateEllipses()\n{\n Eigen::EigenSolver< Eigen::Matrix > es;\n\n // determine error ellipse for the location\n Eigen::Matrix2d loc_cov;\n\n loc_cov << P(0,0), P(0,2),\n P(2,0), P(2,2);\n\n es.compute(loc_cov,true);\n\n if(std::abs(es.eigenvalues()[0]) > std::abs(es.eigenvalues()[1]))\n {\n ellipse_location.minor = std::sqrt(5.99*std::abs(es.eigenvalues()[1]));\n ellipse_location.major = std::sqrt(5.99*std::abs(es.eigenvalues()[0]));\n ellipse_location.angle = std::atan2(es.eigenvectors()(1,1).real(),es.eigenvectors()(0,1).real());\n } else {\n ellipse_location.minor = std::sqrt(5.99*std::abs(es.eigenvalues()[0]));\n ellipse_location.major = std::sqrt(5.99*std::abs(es.eigenvalues()[1]));\n ellipse_location.angle = std::atan2(es.eigenvectors()(1,0).real(),es.eigenvectors()(0,0).real());\n }\n\n // determine error ellipse of the velocity\n Eigen::Matrix2d vol_cov;\n\n vol_cov << P(1,1), P(1,3),\n P(3,1), P(3,3);\n\n es.compute(vol_cov,true);\n\n if(std::abs(es.eigenvalues()[0]) > std::abs(es.eigenvalues()[1]))\n {\n ellipse_velocity.minor = std::sqrt(5.99*std::abs(es.eigenvalues()[1]));\n ellipse_velocity.major = std::sqrt(5.99*std::abs(es.eigenvalues()[0]));\n ellipse_velocity.angle = std::atan2(es.eigenvectors()(1,1).real(),es.eigenvectors()(0,1).real());\n } else {\n ellipse_velocity.minor = std::sqrt(5.99*std::abs(es.eigenvalues()[0]));\n ellipse_velocity.major = std::sqrt(5.99*std::abs(es.eigenvalues()[1]));\n ellipse_velocity.angle = std::atan2(es.eigenvectors()(1,0).real(),es.eigenvectors()(0,0).real());\n }\n}\n", "meta": {"hexsha": "1bfa817219cc65b695fa3b4e51648b0613ad83d8", "size": 5255, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "NaoTHSoccer/Source/Tools/Filters/KalmanFilter/ExtendedKalmanFilter4d.cpp", "max_stars_repo_name": "BerlinUnited/NaoTH", "max_stars_repo_head_hexsha": "02848ac10c16a5349f1735da8122a64d601a5c75", "max_stars_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_stars_count": 15.0, "max_stars_repo_stars_event_min_datetime": "2015-01-12T10:46:29.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T05:13:14.000Z", "max_issues_repo_path": "NaoTHSoccer/Source/Tools/Filters/KalmanFilter/ExtendedKalmanFilter4d.cpp", "max_issues_repo_name": "BerlinUnited/NaoTH", "max_issues_repo_head_hexsha": "02848ac10c16a5349f1735da8122a64d601a5c75", "max_issues_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2019-01-20T21:07:50.000Z", "max_issues_repo_issues_event_max_datetime": "2020-01-22T14:00:28.000Z", "max_forks_repo_path": "NaoTHSoccer/Source/Tools/Filters/KalmanFilter/ExtendedKalmanFilter4d.cpp", "max_forks_repo_name": "BerlinUnited/NaoTH", "max_forks_repo_head_hexsha": "02848ac10c16a5349f1735da8122a64d601a5c75", "max_forks_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2018-02-07T18:18:10.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-15T17:01:41.000Z", "avg_line_length": 29.0331491713, "max_line_length": 239, "alphanum_fraction": 0.6367269267, "num_tokens": 1595, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110511888302, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.5485421470012666}} {"text": "// MSVC has a bug where it chokes on complex Eigen expressions\n\n#ifdef _MSC_VER\n#define EIGEN_STRONG_INLINE inline\n#endif\n\n#include \"MidedgeAngleSinFormulation.h\"\n#include \"../GeometryDerivatives.h\"\n#include \"../MeshConnectivity.h\"\n#include \n#include \n#include \n\n\nstatic double edgeTheta(\n const MeshConnectivity& mesh,\n const Eigen::MatrixXd& curPos,\n int edge,\n Eigen::Matrix* derivative, // edgeVertex, then edgeOppositeVertex\n Eigen::Matrix* hessian)\n{\n if (derivative)\n derivative->setZero();\n if (hessian)\n hessian->setZero();\n int v0 = mesh.edgeVertex(edge, 0);\n int v1 = mesh.edgeVertex(edge, 1);\n int v2 = mesh.edgeOppositeVertex(edge, 0);\n int v3 = mesh.edgeOppositeVertex(edge, 1);\n if (v2 == -1 || v3 == -1)\n return 0; // boundary edge\n\n Eigen::Vector3d q0 = curPos.row(v0);\n Eigen::Vector3d q1 = curPos.row(v1);\n Eigen::Vector3d q2 = curPos.row(v2);\n Eigen::Vector3d q3 = curPos.row(v3);\n\n Eigen::Vector3d n0 = (q0 - q2).cross(q1 - q2);\n Eigen::Vector3d n1 = (q1 - q3).cross(q0 - q3);\n Eigen::Vector3d axis = q1 - q0;\n Eigen::Matrix angderiv;\n Eigen::Matrix anghess;\n\n double theta = angle(n0, n1, axis, (derivative || hessian) ? &angderiv : NULL, hessian ? &anghess : NULL);\n\n if (derivative)\n {\n derivative->block<1, 3>(0, 0) += angderiv.block<1, 3>(0, 0) * crossMatrix(q2 - q1);\n derivative->block<1, 3>(0, 3) += angderiv.block<1, 3>(0, 0) * crossMatrix(q0 - q2);\n derivative->block<1, 3>(0, 6) += angderiv.block<1, 3>(0, 0) * crossMatrix(q1 - q0);\n\n derivative->block<1, 3>(0, 0) += angderiv.block<1, 3>(0, 3) * crossMatrix(q1 - q3);\n derivative->block<1, 3>(0, 3) += angderiv.block<1, 3>(0, 3) * crossMatrix(q3 - q0);\n derivative->block<1, 3>(0, 9) += angderiv.block<1, 3>(0, 3) * crossMatrix(q0 - q1);\n }\n\n if (hessian)\n {\n Eigen::Matrix3d vqm[3];\n vqm[0] = crossMatrix(q0 - q2);\n vqm[1] = crossMatrix(q1 - q0);\n vqm[2] = crossMatrix(q2 - q1);\n Eigen::Matrix3d wqm[3];\n wqm[0] = crossMatrix(q0 - q1);\n wqm[1] = crossMatrix(q1 - q3);\n wqm[2] = crossMatrix(q3 - q0);\n\n int vindices[3] = { 3, 6, 0 };\n int windices[3] = { 9, 0, 3 };\n\n for (int i = 0; i < 3; i++)\n {\n for (int j = 0; j < 3; j++)\n {\n hessian->block<3, 3>(vindices[i], vindices[j]) += vqm[i].transpose() * anghess.block<3, 3>(0, 0) * vqm[j];\n hessian->block<3, 3>(vindices[i], windices[j]) += vqm[i].transpose() * anghess.block<3, 3>(0, 3) * wqm[j];\n hessian->block<3, 3>(windices[i], vindices[j]) += wqm[i].transpose() * anghess.block<3, 3>(3, 0) * vqm[j];\n hessian->block<3, 3>(windices[i], windices[j]) += wqm[i].transpose() * anghess.block<3, 3>(3, 3) * wqm[j];\n }\n\n hessian->block<3, 3>(vindices[i], 3) += vqm[i].transpose() * anghess.block<3, 3>(0, 6);\n hessian->block<3, 3>(3, vindices[i]) += anghess.block<3, 3>(6, 0) * vqm[i];\n hessian->block<3, 3>(vindices[i], 0) += -vqm[i].transpose() * anghess.block<3, 3>(0, 6);\n hessian->block<3, 3>(0, vindices[i]) += -anghess.block<3, 3>(6, 0) * vqm[i];\n\n hessian->block<3, 3>(windices[i], 3) += wqm[i].transpose() * anghess.block<3, 3>(3, 6);\n hessian->block<3, 3>(3, windices[i]) += anghess.block<3, 3>(6, 3) * wqm[i];\n hessian->block<3, 3>(windices[i], 0) += -wqm[i].transpose() * anghess.block<3, 3>(3, 6);\n hessian->block<3, 3>(0, windices[i]) += -anghess.block<3, 3>(6, 3) * wqm[i];\n\n }\n\n Eigen::Vector3d dang1 = angderiv.block<1, 3>(0, 0).transpose();\n Eigen::Vector3d dang2 = angderiv.block<1, 3>(0, 3).transpose();\n\n Eigen::Matrix3d dang1mat = crossMatrix(dang1);\n Eigen::Matrix3d dang2mat = crossMatrix(dang2);\n\n hessian->block<3, 3>(6, 3) += dang1mat;\n hessian->block<3, 3>(0, 3) -= dang1mat;\n hessian->block<3, 3>(0, 6) += dang1mat;\n hessian->block<3, 3>(3, 0) += dang1mat;\n hessian->block<3, 3>(3, 6) -= dang1mat;\n hessian->block<3, 3>(6, 0) -= dang1mat;\n\n hessian->block<3, 3>(9, 0) += dang2mat;\n hessian->block<3, 3>(3, 0) -= dang2mat;\n hessian->block<3, 3>(3, 9) += dang2mat;\n hessian->block<3, 3>(0, 3) += dang2mat;\n hessian->block<3, 3>(0, 9) -= dang2mat;\n hessian->block<3, 3>(9, 3) -= dang2mat;\n }\n\n return theta;\n}\n\nstatic Eigen::Vector3d secondFundamentalFormEntries(\n const MeshConnectivity& mesh,\n const Eigen::MatrixXd& curPos,\n const Eigen::VectorXd& edgeThetas,\n int face,\n Eigen::Matrix* derivative,\n std::vector >* hessian)\n{\n if (derivative)\n derivative->setZero();\n if (hessian)\n {\n hessian->resize(3);\n for (int i = 0; i < 3; i++)\n (*hessian)[i].setZero();\n }\n\n Eigen::Vector3d II;\n for (int i = 0; i < 3; i++)\n {\n Eigen::Matrix hderiv;\n Eigen::Matrix hhess;\n double altitude = triangleAltitude(mesh, curPos, face, i, (derivative || hessian) ? &hderiv : NULL, hessian ? &hhess : NULL);\n\n int edge = mesh.faceEdge(face, i);\n Eigen::Matrix thetaderiv;\n Eigen::Matrix thetahess;\n double theta = edgeTheta(mesh, curPos, edge, (derivative || hessian) ? &thetaderiv : NULL, hessian ? &thetahess : NULL);\n\n double orient = mesh.faceEdgeOrientation(face, i) == 0 ? 1.0 : -1.0;\n double alpha = 0.5 * theta + orient * edgeThetas[edge];\n\n double sinAlpha = sin(alpha);\n double cosAlpha = cos(alpha);\n\n II[i] = 2.0 * altitude * sinAlpha;\n\n if (derivative)\n {\n int hv0 = i;\n int hv1 = (i + 1) % 3;\n int hv2 = (i + 2) % 3;\n derivative->block<1, 3>(i, 3 * hv0) += 2.0 * sinAlpha * hderiv.block<1, 3>(0, 0);\n derivative->block<1, 3>(i, 3 * hv1) += 2.0 * sinAlpha * hderiv.block<1, 3>(0, 3);\n derivative->block<1, 3>(i, 3 * hv2) += 2.0 * sinAlpha * hderiv.block<1, 3>(0, 6);\n\n int av0, av1, av2, av3;\n if (mesh.faceEdgeOrientation(face, i) == 0)\n {\n av0 = (i + 1) % 3;\n av1 = (i + 2) % 3;\n av2 = i;\n av3 = 3 + i;\n }\n else\n {\n av0 = (i + 2) % 3;\n av1 = (i + 1) % 3;\n av2 = 3 + i;\n av3 = i;\n }\n derivative->block<1, 3>(i, 3 * av0) += altitude * cosAlpha * thetaderiv.block<1, 3>(0, 0);\n derivative->block<1, 3>(i, 3 * av1) += altitude * cosAlpha * thetaderiv.block<1, 3>(0, 3);\n derivative->block<1, 3>(i, 3 * av2) += altitude * cosAlpha * thetaderiv.block<1, 3>(0, 6);\n derivative->block<1, 3>(i, 3 * av3) += altitude * cosAlpha * thetaderiv.block<1, 3>(0, 9);\n (*derivative)(i, 18 + i) += 2.0 * altitude * cosAlpha * orient;\n }\n\n if (hessian)\n {\n int hv[3];\n hv[0] = i;\n hv[1] = (i + 1) % 3;\n hv[2] = (i + 2) % 3;\n for (int j = 0; j < 3; j++)\n {\n for (int k = 0; k < 3; k++)\n {\n (*hessian)[i].block<3, 3>(3 * hv[j], 3 * hv[k]) += 2.0 * sinAlpha * hhess.block<3, 3>(3 * j, 3 * k);\n }\n }\n\n int av[4];\n if (mesh.faceEdgeOrientation(face, i) == 0)\n {\n av[0] = (i + 1) % 3;\n av[1] = (i + 2) % 3;\n av[2] = i;\n av[3] = 3 + i;\n }\n else\n {\n av[0] = (i + 2) % 3;\n av[1] = (i + 1) % 3;\n av[2] = 3 + i;\n av[3] = i;\n }\n\n for (int k = 0; k < 3; k++)\n {\n for (int j = 0; j < 4; j++)\n {\n (*hessian)[i].block<3, 3>(3 * av[j], 3 * hv[k]) += cosAlpha * thetaderiv.block<1, 3>(0, 3 * j).transpose() * hderiv.block<1, 3>(0, 3 * k);\n (*hessian)[i].block<3, 3>(3 * hv[k], 3 * av[j]) += cosAlpha * hderiv.block<1, 3>(0, 3 * k).transpose() * thetaderiv.block<1, 3>(0, 3 * j);\n }\n (*hessian)[i].block<1, 3>(18 + i, 3 * hv[k]) += 2.0 * cosAlpha * orient * hderiv.block<1, 3>(0, 3 * k);\n (*hessian)[i].block<3, 1>(3 * hv[k], 18 + i) += 2.0 * cosAlpha * orient * hderiv.block<1, 3>(0, 3 * k).transpose();\n }\n\n for (int k = 0; k < 4; k++)\n {\n for (int j = 0; j < 4; j++)\n {\n (*hessian)[i].block<3, 3>(3 * av[j], 3 * av[k]) += altitude * cosAlpha * thetahess.block<3, 3>(3 * j, 3 * k);\n (*hessian)[i].block<3, 3>(3 * av[j], 3 * av[k]) += -0.5 * altitude * sinAlpha * thetaderiv.block<1, 3>(0, 3 * j).transpose() * thetaderiv.block<1, 3>(0, 3 * k);\n }\n (*hessian)[i].block<1, 3>(18 + i, 3 * av[k]) += -1.0 * altitude * sinAlpha * orient * thetaderiv.block<1, 3>(0, 3 * k);\n (*hessian)[i].block<3, 1>(3 * av[k], 18 + i) += -1.0 * altitude * sinAlpha * orient * thetaderiv.block<1, 3>(0, 3 * k).transpose();\n }\n\n (*hessian)[i](18 + i, 18 + i) += -2.0 * altitude * sinAlpha;\n }\n }\n\n return II;\n}\n\n\nEigen::Matrix2d MidedgeAngleSinFormulation::secondFundamentalForm(\n const MeshConnectivity &mesh,\n const Eigen::MatrixXd &curPos,\n const Eigen::VectorXd &extraDOFs,\n int face,\n Eigen::MatrixXd *derivative, \n std::vector *hessian) const\n{\n if (derivative)\n {\n derivative->resize(4, 21);\n derivative->setZero();\n }\n if (hessian)\n {\n hessian->resize(4);\n for (int i = 0; i < 4; i++)\n {\n (*hessian)[i].resize(21, 21);\n (*hessian)[i].setZero();\n }\n }\n\n\n Eigen::Matrix IIderiv;\n std::vector < Eigen::Matrix > IIhess;\n\n Eigen::Vector3d II = secondFundamentalFormEntries(mesh, curPos, extraDOFs, face, derivative ? &IIderiv : NULL, hessian ? &IIhess : NULL);\n\n Eigen::Matrix2d result;\n result << II[0] + II[1], II[0], II[0], II[0] + II[2];\n\n if (derivative)\n {\n derivative->row(0) += IIderiv.row(0);\n derivative->row(0) += IIderiv.row(1);\n\n derivative->row(1) += IIderiv.row(0);\n derivative->row(2) += IIderiv.row(0);\n\n derivative->row(3) += IIderiv.row(0);\n derivative->row(3) += IIderiv.row(2);\n }\n if (hessian)\n {\n (*hessian)[0] += IIhess[0];\n (*hessian)[0] += IIhess[1];\n\n (*hessian)[1] += IIhess[0];\n (*hessian)[2] += IIhess[0];\n\n (*hessian)[3] += IIhess[0];\n (*hessian)[3] += IIhess[2];\n }\n\n return result;\n}\n\nstatic void testSecondFundamentalFormEntries(const Eigen::MatrixXd &V, const Eigen::MatrixXi &F)\n{\n double eps = 1e-6;\n MeshConnectivity mesh(F);\n int nfaces = mesh.nFaces();\n int nedges = mesh.nEdges();\n Eigen::VectorXd thetas(nedges);\n thetas.setConstant(0.3);\n int ntests = 100;\n\n std::random_device rd;\n std::mt19937 rng(rd());\n std::uniform_int_distribution uni(0, nfaces);\n\n std::cout << \"Testing \" << ntests << \" random faces\" << std::endl;\n\n for(int i=0; i deriv;\n std::vector > hess;\n Eigen::Vector3d b = secondFundamentalFormEntries(mesh, V, thetas, face, &deriv, &hess);\n\n for(int j=0; j<3; j++)\n {\n for(int k=0; k<3; k++)\n {\n Eigen::MatrixXd Vpert(V);\n Vpert(mesh.faceVertex(face, j), k) += 1e-6;\n Eigen::Matrix derivpert;\n Eigen::Vector3d bpert = secondFundamentalFormEntries(mesh, Vpert, thetas, face, &derivpert, NULL);\n Eigen::Vector3d findiff = (bpert-b)/1e-6;\n Eigen::Vector3d exact = deriv.col(3*j+k);\n std::cout << \"q\" << j << \"[\" << k <<\"]: \" << exact.transpose() << \" / \" << findiff.transpose() << std::endl;\n\n Eigen::Matrix findiffhess = (derivpert-deriv)/1e-6;\n for(int l=0; l<3; l++)\n {\n std::cout << \" hess[\" << l << \"]: \" << hess[l].col(3*j+k).transpose() << \" / \" << findiffhess.row(l) << std::endl;;\n }\n }\n int edge = mesh.faceEdge(face, j);\n int ofaceidx = 0;\n if(mesh.edgeFace(edge, ofaceidx) == face)\n ofaceidx = 1;\n if(mesh.edgeFace(edge, ofaceidx) == -1)\n continue;\n int pidx = mesh.edgeOppositeVertex(edge, ofaceidx);\n for(int k=0; k<3; k++)\n {\n Eigen::MatrixXd Vpert(V);\n Vpert(pidx, k) += 1e-6;\n Eigen::Matrix derivpert;\n Eigen::Vector3d bpert = secondFundamentalFormEntries(mesh, Vpert, thetas, face, &derivpert, NULL);\n Eigen::Vector3d findiff = (bpert-b)/1e-6;\n Eigen::Vector3d exact = deriv.col(9 + 3*j+k);\n std::cout << \"p\" << j << \"[\" << k <<\"]: \" << exact.transpose() << \" / \" << findiff.transpose() << std::endl;\n\n Eigen::Matrix findiffhess = (derivpert-deriv)/1e-6;\n for(int l=0; l<3; l++)\n {\n std::cout << \" hess[\" << l << \"]: \" << hess[l].col(9 + 3*j+k).transpose() << \" / \" << findiffhess.row(l) << std::endl;;\n }\n }\n Eigen::VectorXd thetapert(thetas);\n thetapert[edge] += 1e-6;\n Eigen::Matrix derivpert;\n Eigen::Vector3d bpert = secondFundamentalFormEntries(mesh, V, thetapert, face, &derivpert, NULL);\n Eigen::Vector3d findiff = (bpert-b)/1e-6;\n Eigen::Vector3d exact = deriv.col(18+j);\n std::cout << \"theta[\" << j << \"]: \" << exact.transpose() << \" / \" << findiff.transpose() << std::endl; \n\n Eigen::Matrix findiffhess = (derivpert-deriv)/1e-6;\n for(int l=0; l<3; l++)\n {\n std::cout << \" hess[\" << l << \"]: \" << hess[l].col(18 + j).transpose() << \" / \" << findiffhess.row(l) << std::endl;;\n }\n }\n }\n}\n\nstatic void testThetas(const Eigen::MatrixXd &V, const Eigen::MatrixXi &F)\n{\n double eps = 1e-6;\n MeshConnectivity mesh(F);\n int nfaces = mesh.nFaces();\n int nedges = mesh.nEdges();\n int ntests = 100;\n\n std::random_device rd;\n std::mt19937 rng(rd());\n std::uniform_int_distribution uni(0, nedges);\n\n std::cout << \"Testing \" << ntests << \" random edges\" << std::endl;\n\n for (int i = 0; i < ntests; i++)\n {\n int edge = uni(rng);\n Eigen::Matrix deriv;\n Eigen::Matrix hess;\n double theta = edgeTheta(mesh, V, edge, &deriv, &hess);\n\n int v[2];\n v[0] = mesh.edgeVertex(edge, 0);\n v[1] = mesh.edgeVertex(edge, 1);\n\n int vo[2];\n vo[0] = mesh.edgeOppositeVertex(edge, 0);\n vo[1] = mesh.edgeOppositeVertex(edge, 1);\n\n for (int j = 0; j < 2; j++)\n {\n for (int k = 0; k < 3; k++)\n {\n Eigen::MatrixXd Vpert(V);\n Vpert(v[j], k) += 1e-6;\n Eigen::Matrix derivpert;\n double thetapert = edgeTheta(mesh, Vpert, edge, &derivpert, NULL);\n double findiff = (thetapert - theta) / 1e-6;\n double exact = deriv(0, 3 * j + k);\n std::cout << \"edgeVert\" << j << \"[\" << k << \"]: \" << exact << \" / \" << findiff << std::endl;\n\n Eigen::Matrix findiffhess = (derivpert-deriv)/1e-6;\n std::cout << \" hess: \" << hess.col(3 * j + k).transpose() << \" / \" << findiffhess << std::endl;\n }\n\n if (vo[j] != -1)\n {\n for (int k = 0; k < 3; k++)\n {\n Eigen::MatrixXd Vpert(V);\n Vpert(vo[j], k) += 1e-6;\n Eigen::Matrix derivpert;\n double thetapert = edgeTheta(mesh, Vpert, edge, &derivpert, NULL);\n double findiff = (thetapert - theta) / 1e-6;\n double exact = deriv(0, 6 + 3 * j + k);\n std::cout << \"edgeOppVert\" << j << \"[\" << k << \"]: \" << exact << \" / \" << findiff << std::endl;\n\n Eigen::Matrix findiffhess = (derivpert-deriv)/1e-6;\n std::cout << \" hess: \" << hess.col(6 + 3 * j + k).transpose() << \" / \" << findiffhess << std::endl;\n }\n }\n }\n }\n}\n\nint MidedgeAngleSinFormulation::numExtraDOFs() const\n{\n return 1;\n}\n\nvoid MidedgeAngleSinFormulation::initializeExtraDOFs(Eigen::VectorXd &extraDOFs, const MeshConnectivity &mesh, const Eigen::MatrixXd &curPos) const\n{\n extraDOFs.resize(mesh.nEdges());\n extraDOFs.setZero();\n}\n", "meta": {"hexsha": "6006c4d1c1f53f122d0b8d9cef4269cf22042b86", "size": 17410, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "SecondFundamentalForm/MidedgeAngleSinFormulation.cpp", "max_stars_repo_name": "csyzzkdcz/effective-garbanzo", "max_stars_repo_head_hexsha": "87223ecfc26371a9b251a70a0111ca4e0d95b594", "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": "SecondFundamentalForm/MidedgeAngleSinFormulation.cpp", "max_issues_repo_name": "csyzzkdcz/effective-garbanzo", "max_issues_repo_head_hexsha": "87223ecfc26371a9b251a70a0111ca4e0d95b594", "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": "SecondFundamentalForm/MidedgeAngleSinFormulation.cpp", "max_forks_repo_name": "csyzzkdcz/effective-garbanzo", "max_forks_repo_head_hexsha": "87223ecfc26371a9b251a70a0111ca4e0d95b594", "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": 37.9302832244, "max_line_length": 180, "alphanum_fraction": 0.4901780586, "num_tokens": 5797, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110396870287, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.5485421399266481}} {"text": "/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */\n\n/*\n Copyright (C) 2009 Andrea Odetti\n\n This file is part of QuantLib, a free-software/open-source library\n for financial quantitative analysts and developers - http://quantlib.org/\n\n QuantLib is free software: you can redistribute it and/or modify it\n under the terms of the QuantLib license. You should have received a\n copy of the license along with this program; if not, please email\n . The license is also available online at\n .\n\n This program is distributed in the hope that it will be useful, but WITHOUT\n ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n FOR A PARTICULAR PURPOSE. See the license for more details.\n*/\n\n#ifndef quantlib_longstaff_schwartz_multi_path_pricer_hpp\n#define quantlib_longstaff_schwartz_multi_path_pricer_hpp\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace QuantLib {\n\n //! Longstaff-Schwarz path pricer for early exercise options\n /*! References:\n\n Francis Longstaff, Eduardo Schwartz, 2001. Valuing American Options\n by Simulation: A Simple Least-Squares Approach, The Review of\n Financial Studies, Volume 14, No. 1, 113-147\n\n \\ingroup mcarlo\n\n \\test the correctness of the returned value is tested by\n reproducing results available in web/literature\n */\n class LongstaffSchwartzMultiPathPricer : public PathPricer {\n public:\n\n LongstaffSchwartzMultiPathPricer(\n const boost::shared_ptr& ,\n const std::vector &,\n const std::vector > &,\n const Array &,\n Size ,\n LsmBasisSystem::PolynomType );\n\n Real operator()(const MultiPath& multiPath) const;\n virtual void calibrate();\n\n protected:\n struct PathInfo {\n PathInfo(Size numberOfTimes);\n\n Size pathLength() const;\n\n Array payments;\n Array exercises;\n std::vector states;\n };\n\n PathInfo transformPath(const MultiPath& path) const;\n\n bool calibrationPhase_;\n\n const boost::shared_ptr payoff_;\n\n boost::scoped_array coeff_;\n boost::scoped_array lowerBounds_;\n\n const std::vector timePositions_;\n const std::vector > forwardTermStructures_;\n const Array dF_;\n\n mutable std::vector paths_;\n const std::vector > v_;\n };\n\n}\n\n\n#endif\n", "meta": {"hexsha": "9ced3e7e6abc12983e67584f83acb2d3217dc327", "size": 2991, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "ql/experimental/mcbasket/longstaffschwartzmultipathpricer.hpp", "max_stars_repo_name": "quantosaurosProject/quantLib", "max_stars_repo_head_hexsha": "84b49913d3940cf80d6de8f70185867373f45e8d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ql/experimental/mcbasket/longstaffschwartzmultipathpricer.hpp", "max_issues_repo_name": "quantosaurosProject/quantLib", "max_issues_repo_head_hexsha": "84b49913d3940cf80d6de8f70185867373f45e8d", "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": "ql/experimental/mcbasket/longstaffschwartzmultipathpricer.hpp", "max_forks_repo_name": "quantosaurosProject/quantLib", "max_forks_repo_head_hexsha": "84b49913d3940cf80d6de8f70185867373f45e8d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-03-29T05:44:27.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T05:44:27.000Z", "avg_line_length": 32.5108695652, "max_line_length": 79, "alphanum_fraction": 0.6833834838, "num_tokens": 682, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933535169629, "lm_q2_score": 0.6688802669716107, "lm_q1q2_score": 0.5484104851886754}} {"text": "#include \"plane.h\"\n#include \n#include \n#include \n\n#include \n\nusing namespace Eigen;\nusing namespace std;\n\nbool line3d::ClosestPoint(const line3d &L1, const line3d &L2, Vector3d &Result1, Vector3d &Result2)\n{\n\tVector3d NewDir = L1.D.cross(L2.D);\n\tfloat Length = NewDir.norm();\n\tif (Length == 0.0f) {\n\t\treturn false;\n\t}\n\n\tplane P1 = plane::fromPointVectors(L1.P0, NewDir, L1.D);\n\tplane P2 = plane::fromPointVectors(L2.P0, NewDir, L2.D);\n\n\tResult1 = P2.IntersectLine(L1);\n\tResult2 = P1.IntersectLine(L2);\n\treturn true;\n}\n\nfloat line3d::Dist(const line3d &L1, const line3d &L2)\n{\n\tVector3d Cross = L1.D.cross(L2.D);\n\tVector3d v = L2.P0 - L1.P0;\n\n\treturn abs(v.dot(Cross)) / Cross.norm();\n}\n\nfloat line3d::DistSq(const line3d &L1, const line3d &L2)\n{\n\tVector3d Cross = L1.D.cross(L2.D);\n\n\tVector3d v = L2.P0 - L1.P0;\n\tfloat Dot = v.dot(Cross);\n\treturn (Dot * Dot) / Cross.squaredNorm();\n}\n\nfloat line3d::DistToPoint(const Vector3d &P) const\n{\n\tfloat t0 = D.dot(P - P0) / D.dot(D);\n\n\tVector3d v = P0 + t0 * D;\n\n\t// TODO: Replace this with the eigen equivalent\n\tfloat x = P.x() + v.x();\n\tfloat y = P.y() + v.y();\n\tfloat z = P.z() + v.z();\n\n\tfloat distanceLine = sqrt(x*x + y*y + z*z);\n\treturn distanceLine;\n}\n\n//-----------------------------------------------------------------------------\n\nplane::plane()\n{\n\n}\n\nfloat plane::get_x(float y, float z)\n{\n\treturn -(b*y + c*z + d) / a;\n}\n\nfloat plane::get_y(float x, float z)\n{\n\treturn -(a*x + c*z + d) / b;\n}\n\nfloat plane::get_z(float x, float y)\n{\n\treturn -(a*x + b*y + d) / c;\n}\n\nplane::plane(const plane &P)\n{\n\ta = P.a;\n\tb = P.b;\n\tc = P.c;\n\td = P.d;\n}\n\nplane::plane(float _a, float _b, float _c, float _d)\n{\n\ta = _a;\n\tb = _b;\n\tc = _c;\n\td = _d;\n}\n\nplane::plane(const Vector3d &NormalizedNormal, float _d)\n{\n\ta = NormalizedNormal(0);\n\tb = NormalizedNormal(1);\n\tc = NormalizedNormal(2);\n\td = _d;\n}\n\nplane plane::fromPointNormal(const Vector3d &Pt, const Vector3d &Normal)\n{\n\tplane Result;\n\tVector3d NormalizedNormal = Normal;\n\tNormalizedNormal.normalize();\n\n\tResult.a = NormalizedNormal(0);\n\tResult.b = NormalizedNormal(1);\n\tResult.c = NormalizedNormal(2);\n\tResult.d = -Pt.dot(NormalizedNormal);\n\treturn Result;\n}\n\nplane plane::fromPointVectors(const Vector3d &Pt, const Vector3d &V1, const Vector3d &V2)\n{\n\tVector3d Normal = V1.cross(V2);\n\treturn fromPointNormal(Pt, Normal);\n}\n\nplane plane::Normalize()\n{\n\tplane Result;\n\tfloat Distance = sqrtf(a * a + b * b + c * c);\n\tResult.a = a / Distance;\n\tResult.b = b / Distance;\n\tResult.c = c / Distance;\n\tResult.d = d / Distance;\n\treturn Result;\n}\n\nplane plane::fromPoints(const Vector3d &V0, const Vector3d &V1, const Vector3d &V2)\n{\n\tVector3d t0 = V1 - V0;\n\tVector3d t1 = V2 - V0;\n\tVector3d Normal = t0.cross(t1);\n\tNormal.normalize();\n\treturn fromPointNormal(V0, Normal);\n}\n\nVector3d plane::IntersectLine(const line3d &Line) const\n{\n\treturn IntersectLine(Line.P0, Line.P0 + Line.D);\n}\n\nVector3d plane::IntersectLine(const Vector3d &V1, const Vector3d &V2) const\n{\n\tVector3d Diff = V1 - V2;\n\tfloat Denominator = a * Diff(0) + b * Diff(1) + c * Diff(2);\n\tif (Denominator == 0.0f) {\n\t\treturn (V1 + V2) * 0.5f;\n\t}\n\tfloat u = (a * V1(0) + b * V1(1) + c * V1(2) + d) / Denominator;\n\n\treturn (V1 + u * (V2 - V1));\n}\n\nVector3d plane::IntersectLine(const Vector3d &V1, const Vector3d &V2, bool &Hit) const\n{\n\tHit = true;\n\tVector3d Diff = V2 - V1;\n\tfloat denominator = a * Diff(0) + b * Diff(1) + c * Diff(2);\n\tif (denominator == 0) { Hit = false; return V1; }\n\tfloat u = (a * V1(0) + b * V1(1) + c * V1(2) + d) / denominator;\n\n\treturn (V1 + u * (V2 - V1));\n}\n\nfloat plane::IntersectLineRatio(const Vector3d &V1, const Vector3d &V2)\n{\n\tVector3d Diff = V2 - V1;\n\tfloat Denominator = a * Diff(0) + b * Diff(1) + c * Diff(2);\n\tif (Denominator == 0.0f) {\n\t\treturn 0.0f;\n\t}\n\treturn (a * V1(0) + b * V1(1) + c * V1(2) + d) / -Denominator;\n}\n\nfloat plane::signedDistance(const Vector3d &Pt) const\n{\n\treturn (a * Pt(0) + b * Pt(1) + c * Pt(2) + d);\n}\n\nfloat plane::unsignedDistance(const Vector3d &Pt) const\n{\n\treturn abs(a * Pt(0) + b * Pt(1) + c * Pt(2) + d);\n}\n\nVector3d plane::ClosestPoint(const Vector3d &Point)\n{\n\treturn (Point - Normal() * signedDistance(Point));\n}\n\nbool plane::planePlaneIntersection(const plane &P1, const plane &P2, line3d &L)\n{\n\tfloat Denominator = P1.a * P2.b - P1.b * P2.a;\n\tif (Denominator == 0.0f) {\n\t\t// this case should be handled by switching axes...\n\t\treturn false;\n\t}\n\tL.P0 = Vector3d((P2.d * P1.b - P1.d * P2.b) /\n\t\tDenominator, (P1.d * P2.a - P2.d * P1.a) /\n\t\tDenominator, 0.0f);\n\n\tL.D = P1.Normal().cross(P2.Normal());\n\tif (L.D.norm() == 0.0f) {\n\t\treturn false;\n\t}\n\tL.D.normalize();\n\n\treturn true;\n}\n\nfloat plane::Dot(const plane &P, const Vector4d &V)\n{\n\treturn P.a * V(0) + P.b * V(1) + P.c * V(2) + P.d * V(3);\n}\n\nfloat plane::DotCoord(const plane &P, const Vector3d &V)\n{\n\treturn P.a * V(0) + P.b * V(1) + P.c * V(2) + P.d;\n}\n\nfloat plane::DotNormal(const plane &P, const Vector3d &V)\n{\n\treturn P.a * V(0) + P.b * V(1) + P.c * V(2);\n}\n\n", "meta": {"hexsha": "ef2cb18f0bb4e10c5c0c35bfe63bfe38e19d07b4", "size": 4986, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/algebra/plane.cpp", "max_stars_repo_name": "earthrover/er_vision_pipeline", "max_stars_repo_head_hexsha": "bdc1cc9e90be4dfaef78253828288e96dbd95cb1", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/algebra/plane.cpp", "max_issues_repo_name": "earthrover/er_vision_pipeline", "max_issues_repo_head_hexsha": "bdc1cc9e90be4dfaef78253828288e96dbd95cb1", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/algebra/plane.cpp", "max_forks_repo_name": "earthrover/er_vision_pipeline", "max_forks_repo_head_hexsha": "bdc1cc9e90be4dfaef78253828288e96dbd95cb1", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2019-01-18T15:55:59.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-01T21:33:52.000Z", "avg_line_length": 21.4913793103, "max_line_length": 99, "alphanum_fraction": 0.6179302046, "num_tokens": 1744, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933271118221, "lm_q2_score": 0.6688802669716107, "lm_q1q2_score": 0.5484104675267977}} {"text": "/**\n * @file mtgp64-calc-poly.cpp\n *\n * @brief calculate characteristic polynomial for 64bit mtgp.\n *\n * @author Mutsuo Saito (Hiroshima University)\n * @author Makoto Matsumoto (Hiroshima University)\n *\n * Copyright (c) 2012 Mutsuo Saito, Makoto Matsumoto, Hiroshima\n * University and University of Tokyo. All rights reserved.\n *\n * The new BSD License is applied to this software, see LICENSE.txt\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"mtgp64-calc-poly.hpp\"\n#include \"mtgp-calc-jump.hpp\"\n#include \"mtgp64-fast.h\"\n\nusing namespace std;\nusing namespace NTL;\n\n/**\n * calculate the characteristic polynomial for given 64-bit MTGP.\n * MinPolySeq is defined in NTL.\n * @param[out] poly calculated characteristic polynomial.\n * @param[in] mtgp64 generator\n */\nvoid mtgp64_calc_characteristic(GF2X& poly, mtgp64_fast_t * mtgp64)\n{\n vec_GF2 seq;\n int mexp = mtgp64->params.mexp;\n seq.SetLength(2 * mexp);\n for (int i = 0; i < 2 * mexp; i++) {\n\tseq[i] = mtgp64_genrand_uint64(mtgp64) & 1;\n }\n MinPolySeq(poly, seq, mexp);\n}\n\n/**\n * calculate the characteristic polynomial for given 64-bit MTGP.\n * MinPolySeq is defined in NTL.\n * @param[out] str calculated characteristic polynomial in string format.\n * @param[in] mtgp64 generator\n */\nvoid mtgp64_calc_characteristic(string& str, mtgp64_fast_t * mtgp64)\n{\n GF2X poly;\n mtgp64_calc_characteristic(poly, mtgp64);\n polytostring(str, poly);\n}\n\n\n#if defined(MAIN)\n/**\n * main function for executable.\n * @param[in] argc number of arguments.\n * @param[in] argv an array of arguments.\n * @return 0 if normal, other abnormal.\n */\nint main(int argc, char *argv[]) {\n int mexp;\n int no;\n uint32_t seed = 1;\n mtgp64_params_fast_t *params;\n mtgp64_fast_t mtgp64;\n int rc;\n\n if (argc <= 2) {\n\tprintf(\"%s: mexp no.\\n\", argv[0]);\n\treturn 1;\n }\n mexp = strtol(argv[1], NULL, 10);\n if (errno) {\n\tprintf(\"%s: mexp no.\\n\", argv[0]);\n\treturn 2;\n }\n no = strtol(argv[2], NULL, 10);\n if (errno) {\n\tprintf(\"%s: mexp no.\\n\", argv[0]);\n\treturn 3;\n }\n switch (mexp) {\n case 23209:\n\tparams = mtgp64_params_fast_23209;\n\tbreak;\n case 44497:\n\tparams = mtgp64_params_fast_44497;\n\tbreak;\n case 110503:\n\tparams = mtgp64_params_fast_110503;\n\tbreak;\n default:\n\tprintf(\"%s: mexp no.\\n\", argv[0]);\n\tprintf(\"mexp shuould be 23209, 44497 or 110503\\n\");\n\treturn 4;\n }\n if (no >= 128 || no < 0) {\n\tprintf(\"%s: mexp no.\\n\", argv[0]);\n\tprintf(\"no must be between 0 and 127\\n\");\n\treturn 5;\n }\n params += no;\n rc = mtgp64_init(&mtgp64, params, seed);\n if (rc) {\n\tprintf(\"failure in mtgp64_init\\n\");\n\treturn -1;\n }\n mtgp64_print_idstring(&mtgp64, stdout);\n string s;\n mtgp64_calc_characteristic(s, &mtgp64);\n printf(\"%s\\n\", s.c_str());\n mtgp64_free(&mtgp64);\n return 0;\n}\n#endif\n", "meta": {"hexsha": "40aa9b7fc432b606bb53b75147952d2596ab7dd2", "size": 2969, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "mtgp64-calc-poly.cpp", "max_stars_repo_name": "mkt-matsumoto-lab/MTGP", "max_stars_repo_head_hexsha": "9cea3283dc67d9fc6cfc044b7ae38fe9ef32afb3", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 9.0, "max_stars_repo_stars_event_min_datetime": "2015-04-24T06:39:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-10T09:48:37.000Z", "max_issues_repo_path": "mtgp64-calc-poly.cpp", "max_issues_repo_name": "mkt-matsumoto-lab/MTGP", "max_issues_repo_head_hexsha": "9cea3283dc67d9fc6cfc044b7ae38fe9ef32afb3", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2022-01-10T07:15:53.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-10T07:15:53.000Z", "max_forks_repo_path": "mtgp64-calc-poly.cpp", "max_forks_repo_name": "mkt-matsumoto-lab/MTGP", "max_forks_repo_head_hexsha": "9cea3283dc67d9fc6cfc044b7ae38fe9ef32afb3", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2017-07-27T21:05:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-10T09:47:58.000Z", "avg_line_length": 23.9435483871, "max_line_length": 73, "alphanum_fraction": 0.6604917481, "num_tokens": 923, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.78793120560257, "lm_q2_score": 0.6959583187272712, "lm_q1q2_score": 0.5483672771239165}} {"text": "#include \n#include \n\n#include \n\nstatic double inertia_z = 6.55929728e-05;\nstatic double frequency =3.0;\n\n\nstatic double stiffness= inertia_z * pow(2*M_PI*frequency,2);\nstatic double angle_init = -0.2300258882727588;\n//static double angle_init = -0.8;\n\n\nextern \"C\" void externalForces(double t, double *f, unsigned int size_z, double *z)\n{\n f[0]=0;\n f[1]=0;\n f[2]=-10;\n}\nextern \"C\" void externalMoment(double t,double *m, unsigned int size_z, double *z)\n{\n m[0]=0;\n m[1]=0;\n m[2]=0;\n}\n\nextern \"C\" void internalForces(double t, double *q, double *v, double *f, unsigned int size_z,double *z)\n{\n // Simple spring in z direction.\n f[0]=0;\n f[1]=0;\n f[2]=0.;\n // printf(\"internalForcesB1 :\\n\");\n // printf(\"f[0] = %e\\t f[1] = %e\\t, f[2]=%e\\n\",f[0],f[1],f[2]);\n}\n\nextern \"C\" void internalForcesB1_Jacq(double t, double *q, double *v, double *jac, unsigned int size_z,double *z)\n{\n for(int i =0; i < 3; i++)\n {\n for(int j=0; j<7; j++)\n jac[i+j*3]=0.0;\n }\n jac[2+2*3]=1e4;\n // printf(\"internalForcesB1_Jacq :\\n\");\n // printf(\"jac[2+2*3] = %e\\n\", jac[2+2*3]);\n}\n\nextern \"C\" void internalMomentsBalanceWheel(double t, double *q, double *v, double *m, unsigned int size_z,double *z)\n{\n // printf(\"internalMomentsB1 :\\n\");\n // Simple torsional spring around z axis\n // printf(\"q[3] = %e\\n\", q[3]);\n // printf(\"q[4] = %e\\n\", q[4]);\n // printf(\"q[5] = %e\\n\", q[5]);\n // printf(\"q[6] = %e\\n\", q[6]);\n\n double angle = 2*asin(q[6]);\n //printf(\"angle = %e\\n\", angle);\n //printf(\"stiffness = %e \\n\", stiffness);\n m[0]=0.0;\n m[1]=0.;\n m[2]=stiffness * (angle-angle_init);\n //printf(\"m[0] = %e\\t m[1] = %e\\t, m[2]=%e\\n\",m[0],m[1],m[2]);\n}\n\nextern \"C\" void internalMomentsBalanceWheel_Jacq(double t, double *q, double *v, double *jac, unsigned int size_z,double *z)\n{\n //printf(\"internalMomentsB1_Jacq :\\n\");\n for(int i =0; i < 3; i++)\n {\n for(int j=0; j<7; j++)\n jac[i+j*3]=0.0;\n }\n // printf(\"q[3] = %e\\n\", q[3]);\n // printf(\"q[4] = %e\\n\", q[4]);\n // printf(\"q[5] = %e\\n\", q[5]);\n // printf(\"q[6] = %e\\n\", q[6]);\n\n //double angle = 2*asin(q[6]);\n // printf(\"angle = %e\\n\", angle);\n jac[2+6*3]=stiffness * 2.0 / sqrt(1 - q[6]*q[6]) ;\n // printf(\"jac[3+3*3] = %e\\n\", jac[3+3*3]);\n}\n\nextern \"C\" void externalMomentEscapeWheel(double t,double *m, unsigned int size_z, double *z)\n{\n m[0]=0;\n m[1]=0;\n m[2]=-0.001;\n}\n\n\nextern \"C\" void prescribedvelocityB1(double time, unsigned int sizeofprescribedvelocity, double *pv)\n{\n /* the plugin implements v(t) = C + A cos(omega *t) */\n\n double C = -150.0 ;\n // double omega = M_PI / 2.0;\n // double A = 10.0;\n\n //pv[0] = A * cos(omega * time*100.0);\n pv[0] = C;\n //printf(\"prescribed velocity = %e\\n\", pv[0]);\n}\n", "meta": {"hexsha": "29685318bcd3a16d70b4772e10a7ad8ea80e0ff1", "size": 2745, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/mechanics/MultiBodySystems/WatchEscapment/Plugin/WatchEscapementPlugin.cpp", "max_stars_repo_name": "vacary/siconos-tutorials", "max_stars_repo_head_hexsha": "93c0158321077a313692ed52fed69ff3c256ae32", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2017-01-12T23:09:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-20T17:03:58.000Z", "max_issues_repo_path": "examples/mechanics/MultiBodySystems/WatchEscapment/Plugin/WatchEscapementPlugin.cpp", "max_issues_repo_name": "vacary/siconos-tutorials", "max_issues_repo_head_hexsha": "93c0158321077a313692ed52fed69ff3c256ae32", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2019-01-14T13:44:51.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-17T13:57:27.000Z", "max_forks_repo_path": "examples/mechanics/MultiBodySystems/WatchEscapment/Plugin/WatchEscapementPlugin.cpp", "max_forks_repo_name": "vacary/siconos-tutorials", "max_forks_repo_head_hexsha": "93c0158321077a313692ed52fed69ff3c256ae32", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2019-10-22T13:30:39.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-06T10:19:57.000Z", "avg_line_length": 25.6542056075, "max_line_length": 124, "alphanum_fraction": 0.5785063752, "num_tokens": 1074, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8757869819218865, "lm_q2_score": 0.6261241772283034, "lm_q1q2_score": 0.5483514034831002}} {"text": "#ifndef STAN_MATH_FWD_SCAL_FUN_BINOMIAL_COEFFICIENT_LOG_HPP\n#define STAN_MATH_FWD_SCAL_FUN_BINOMIAL_COEFFICIENT_LOG_HPP\n\n#include \n#include \n\n#include \n#include \n\nnamespace stan {\nnamespace math {\n\ntemplate \ninline fvar binomial_coefficient_log(const fvar& x1, const fvar& x2) {\n using boost::math::digamma;\n using std::log;\n const double cutoff = 1000;\n if ((x1.val_ < cutoff) || (x1.val_ - x2.val_ < cutoff)) {\n return fvar(binomial_coefficient_log(x1.val_, x2.val_),\n x1.d_ * digamma(x1.val_ + 1) - x2.d_ * digamma(x2.val_ + 1)\n - (x1.d_ - x2.d_) * digamma(x1.val_ - x2.val_ + 1));\n } else {\n return fvar(\n binomial_coefficient_log(x1.val_, x2.val_),\n x2.d_ * log(x1.val_ - x2.val_)\n + x2.val_ * (x1.d_ - x2.d_) / (x1.val_ - x2.val_)\n + x1.d_ * log(x1.val_ / (x1.val_ - x2.val_))\n + (x1.val_ + 0.5) / (x1.val_ / (x1.val_ - x2.val_))\n * (x1.d_ * (x1.val_ - x2.val_) - (x1.d_ - x2.d_) * x1.val_)\n / ((x1.val_ - x2.val_) * (x1.val_ - x2.val_))\n - x1.d_ / (12.0 * x1.val_ * x1.val_) - x2.d_\n + (x1.d_ - x2.d_)\n / (12.0 * (x1.val_ - x2.val_) * (x1.val_ - x2.val_))\n - digamma(x2.val_ + 1) * x2.d_);\n }\n}\n\ntemplate \ninline fvar binomial_coefficient_log(const fvar& x1, double x2) {\n using boost::math::digamma;\n using std::log;\n const double cutoff = 1000;\n if ((x1.val_ < cutoff) || (x1.val_ - x2 < cutoff)) {\n return fvar(\n binomial_coefficient_log(x1.val_, x2),\n x1.d_ * digamma(x1.val_ + 1) - x1.d_ * digamma(x1.val_ - x2 + 1));\n } else {\n return fvar(binomial_coefficient_log(x1.val_, x2),\n x2 * x1.d_ / (x1.val_ - x2)\n + x1.d_ * log(x1.val_ / (x1.val_ - x2))\n + (x1.val_ + 0.5) / (x1.val_ / (x1.val_ - x2))\n * (x1.d_ * (x1.val_ - x2) - x1.d_ * x1.val_)\n / ((x1.val_ - x2) * (x1.val_ - x2))\n - x1.d_ / (12.0 * x1.val_ * x1.val_)\n + x1.d_ / (12.0 * (x1.val_ - x2) * (x1.val_ - x2)));\n }\n}\n\ntemplate \ninline fvar binomial_coefficient_log(double x1, const fvar& x2) {\n using boost::math::digamma;\n using std::log;\n const double cutoff = 1000;\n if ((x1 < cutoff) || (x1 - x2.val_ < cutoff)) {\n return fvar(\n binomial_coefficient_log(x1, x2.val_),\n -x2.d_ * digamma(x2.val_ + 1) - x2.d_ * digamma(x1 - x2.val_ + 1));\n } else {\n return fvar(binomial_coefficient_log(x1, x2.val_),\n x2.d_ * log(x1 - x2.val_) + x2.val_ * -x2.d_ / (x1 - x2.val_)\n - x2.d_\n - x2.d_ / (12.0 * (x1 - x2.val_) * (x1 - x2.val_))\n + x2.d_ * (x1 + 0.5) / (x1 - x2.val_)\n - digamma(x2.val_ + 1) * x2.d_);\n }\n}\n} // namespace math\n} // namespace stan\n#endif\n", "meta": {"hexsha": "40c6ea91b6ae84460d2ef24794c2a9be1bc6b4c1", "size": 3149, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "stan/math/fwd/scal/fun/binomial_coefficient_log.hpp", "max_stars_repo_name": "PhilClemson/math", "max_stars_repo_head_hexsha": "fffe604a7ead4525be2551eb81578c5f351e5c87", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-07-23T14:57:41.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-23T14:57:41.000Z", "max_issues_repo_path": "stan/math/fwd/scal/fun/binomial_coefficient_log.hpp", "max_issues_repo_name": "Capri2014/math", "max_issues_repo_head_hexsha": "d4042bdf8623bba5a1633b557227325a324e32e9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2019-09-23T19:58:36.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-24T12:03:41.000Z", "max_forks_repo_path": "stan/math/fwd/scal/fun/binomial_coefficient_log.hpp", "max_forks_repo_name": "riddell-stan/math", "max_forks_repo_head_hexsha": "d84ee0d991400d6cf4b08a07a4e8d86e0651baea", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.3625, "max_line_length": 80, "alphanum_fraction": 0.525563671, "num_tokens": 1121, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8757869981319863, "lm_q2_score": 0.6261241632752915, "lm_q1q2_score": 0.5483514014127693}} {"text": "// The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt\n/*\n *\n * This is an example illustrating the use the general purpose non-linear\n * optimization routines from the dlib C++ Library.\n *\n * The library provides implementations of many popular algorithms such as L-BFGS\n * and BOBYQA. These algorithms allow you to find the minimum or maximum of a\n * function of many input variables. This example walks though a few of the ways\n * you might put these routines to use.\n *\n */\n\n\n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n#include \"ViennaRNA/utils/basic.h\"\n#ifdef __cplusplus\n}\n#endif\n\n#include \"wrap_dlib.h\"\n\nusing namespace std;\nusing namespace dlib;\n\n// ----------------------------------------------------------------------------------------\n\n// In dlib, most of the general purpose solvers optimize functions that take a\n// column vector as input and return a double. So here we make a typedef for a\n// variable length column vector of doubles. This is the type we will use to\n// represent the input to our objective functions which we will be minimizing.\ntypedef matrix column_vector;\n\n/*\n * function to minimize to obtain equlibrium concentrations\n * of multistrand systems. We use the transformation\n *\n * L_a = lambda_a + ln Z_a\n *\n * such that h(L) reads\n *\n * h(L) = -\\sum_a (c_a L_a - exp(L_a)) + sum_k K_k exp(sum_b L_b A_{b,k}\n *\n * with total concentration c_a of strand a, equilibrium constant\n * K_k of strand k, and membership matrix A[b][k] denoting the number\n * of strands b in complex k\n *\n * Note, here we minimize h(L) due to implementation issues whereas\n * in our publication we've written h'(L) = -h(L) to effectively\n * maximize the function instead.\n */\nPRIVATE double\nh(const column_vector& L,\n const double *eq_constants,\n const double *concentration_strands_tot,\n const unsigned int **A,\n size_t strands,\n size_t complexes)\n{\n double h, hh, *K, maxK;\n\n K = (double *)vrna_alloc(sizeof(double) * complexes);\n h = 0.;\n maxK = (double)(-INF);\n\n for (size_t a = 0; a < strands; a++) {\n// printf(\"L[%u] = %g\\n\", a, L(a));\n maxK = (maxK < L(a)) ? L(a) : maxK;\n }\n\n for (size_t k = 0; k < complexes; k++) {\n K[k] = log(eq_constants[k]);\n\n for (size_t a = 0; a < strands; a++) {\n K[k] += L(a) *\n (double)A[a][k];\n }\n\n maxK = (maxK < K[k]) ? K[k] : maxK;\n }\n\n for (size_t a = 0; a < strands; a++)\n h -= concentration_strands_tot[a] *\n L(a);\n\n// printf(\"h = %g\\n\", h);\n hh = 0;\n\n for (size_t a = 0; a < strands; a++)\n hh += exp(L(a) - maxK);\n\n for (size_t k = 0; k < complexes; k++)\n hh += exp(K[k] - maxK);\n\n h += exp(maxK + log(hh));\n// printf(\"h = %g\\n\", h);\n\n free(K);\n\n return h;\n}\n\n\n/*\n * Get gradient of h(L)\n */\nPRIVATE const column_vector\nh_derivative(const column_vector& L,\n const double *eq_constants,\n const double *concentration_strands_tot,\n const unsigned int **A,\n size_t strands,\n size_t complexes)\n{\n double *K, *maxK;\n column_vector g(strands);\n\n K = (double *)vrna_alloc(sizeof(double) * complexes);\n maxK = (double *)vrna_alloc(sizeof(double) * strands);\n\n for (size_t a = 0; a < strands; a++)\n maxK[a] = L(a);\n\n for (size_t k = 0; k < complexes; k++) {\n K[k] = log(eq_constants[k]);\n for (size_t a = 0; a < strands; a++)\n K[k] += L(a) *\n (double)A[a][k];\n\n for (size_t a = 0; a < strands; a++)\n if (A[a][k] > 0)\n maxK[a] = (maxK[a] < K[k] + log((double)A[a][k])) ?\n K[k] + log((double)A[a][k]) :\n maxK[a];\n }\n\n for (size_t a = 0; a < strands; a++) {\n g(a) = -concentration_strands_tot[a];\n\n double hh = exp(L(a) - maxK[a]);\n for (size_t k = 0; k < complexes; k++)\n if (A[a][k] > 0)\n hh += exp(log((double)A[a][k]) +\n K[k] -\n maxK[a]);\n\n g(a) += exp(maxK[a] + log(hh));\n// printf(\"g(%u) = %g\\n\", a, g(a));\n }\n\n free(K);\n free(maxK);\n\n return g;\n}\n\n\n/*\n * Get Hessian of h(L)\n */\nPRIVATE matrix\nh_hessian(const column_vector& L,\n const double *eq_constants,\n const unsigned int **A,\n size_t strands,\n size_t complexes)\n{\n double *K, **xs;\n\n PRIVATE matrix H(strands, strands);\n\n K = (double *)vrna_alloc(sizeof(double) * complexes);\n xs = (double **)vrna_alloc(sizeof(double *) * strands);\n\n for (size_t a = 0; a < strands; a++) {\n xs[a] = (double *)vrna_alloc(sizeof(double) * strands);\n for (size_t b = 0; b < strands; b++)\n xs[a][b] = (a == b) ? L(a) : (double)(-INF);\n }\n\n for (size_t k = 0; k < complexes; k++) {\n K[k] = log(eq_constants[k]);\n for (size_t a = 0; a < strands; a++)\n K[k] += L(a) *\n (double)A[a][k];\n\n for (size_t a = 0; a < strands; a++)\n for (size_t b = 0; b < strands; b++) {\n if ((A[a][k] > 0) && (A[b][k] > 0))\n xs[a][b] = (xs[a][b] < K[k] + log((double)A[a][k]) + log((double)A[b][k])) ?\n K[k] + log((double)A[a][k]) + log((double)A[b][k]) :\n xs[a][b];\n }\n }\n\n for (size_t a = 0; a < strands; a++) {\n for (size_t b = 0; b < strands; b++) {\n double hh = (a == b) ? exp(L(a) - xs[a][b]) : 0.;\n\n for (size_t k = 0; k < complexes; k++)\n if ((A[a][k] > 0) && (A[b][k] > 0))\n hh += exp(log((double)A[a][k]) +\n log((double)A[b][k]) +\n K[k] -\n xs[a][b]);\n\n H(a,b) = exp(xs[a][b] + log(hh));\n// H(b,a) = H(a,b);\n// printf(\"H(%u,%u) = %g\\n\", a, b, H(a,b));\n }\n }\n\n free(K);\n for (size_t a = 0; a < strands; a++)\n free(xs[a]);\n free(xs);\n\n return H;\n}\n\n\nclass h_model\n{\n/*!\n * This object is a \"function model\" which can be used with the\n * find_min_trust_region() routine.\n * !*/\n\npublic:\ntypedef ::column_vector column_vector;\ntypedef matrix general_matrix;\n\nconst double *eq_constants;\nconst double *concentration_strands_tot;\nconst unsigned int **A;\nsize_t strands;\nsize_t complexes;\n\ndouble\noperator()(const column_vector& x) const\n{\n return h(x, eq_constants, concentration_strands_tot, A, strands, complexes);\n}\n\n\nvoid\ninit(const double *eq_constants,\n const double *concentration_strands_tot,\n const unsigned int **A,\n size_t strands,\n size_t complexes)\n{\n this->eq_constants = eq_constants;\n this->concentration_strands_tot = concentration_strands_tot;\n this->A = A;\n this->strands = strands;\n this->complexes = complexes;\n}\n\n\nvoid\nget_derivative_and_hessian(const column_vector& x,\n column_vector& der,\n general_matrix& hess) const\n{\n der = h_derivative(x, eq_constants, concentration_strands_tot, A, strands, complexes);\n hess = h_hessian(x, eq_constants, A, strands, complexes);\n}\n};\n\n\n/*\n * Get concentrations of single strands from\n * a given vector L (that minimizes h(L))\n */\nPRIVATE double *\nconc_single_strands(const column_vector& L,\n size_t strands)\n{\n double *c = (double *)vrna_alloc(sizeof(double) * strands);\n\n for (size_t a = 0; a < strands; a++)\n c[a] = exp(L(a));\n\n return c;\n}\n\n\n/*\n * Get concentrations of complexes from\n * a given vector L (that minimizes h(L))\n */\nPRIVATE double *\nconc_complexes(const column_vector& L,\n const double *eq_const,\n const unsigned int **A,\n size_t strands,\n size_t complexes)\n{\n double *c;\n\n c = (double *)vrna_alloc(sizeof(double) * complexes);\n\n for (size_t k = 0; k < complexes; k++) {\n c[k] = log(eq_const[k]);\n\n for (size_t a = 0; a < strands; a++)\n c[k] += (double)A[a][k] * L(a);\n\n c[k] = exp(c[k]);\n }\n\n return c;\n}\n\n\ndouble *\nvrna_equilibrium_conc(const double *eq_constants,\n double *concentration_strands,\n const unsigned int **A,\n size_t num_strands,\n size_t num_complexes)\n{\n double *r = NULL;\n\n column_vector starting_point;\n\n h_model h;\n\n h.init(eq_constants,\n concentration_strands,\n A,\n num_strands,\n num_complexes);\n\n starting_point.set_size(num_strands);\n\n for (size_t a = 0; a < num_strands; a++)\n starting_point(a) = 0.;\n\n find_min_trust_region(objective_delta_stop_strategy(1e-18),\n h,\n starting_point,\n 1 // initial trust region radius\n );\n\n double *conc_monomers = conc_single_strands(starting_point, num_strands);\n\n for (size_t a = 0; a < num_strands; a++)\n concentration_strands[a] = conc_monomers[a];\n\n r = conc_complexes(starting_point, eq_constants, A, num_strands, num_complexes);\n\n free(conc_monomers);\n\n return r;\n}\n", "meta": {"hexsha": "5ebd84365c2cc70e597c9b9d160b393162a8f483", "size": 9316, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/ViennaRNA/wrap_dlib.cpp", "max_stars_repo_name": "tsjzz/ViennaRNA", "max_stars_repo_head_hexsha": "f58f58ac6fb3e050f12e69cbbf7f0a95bc625d99", "max_stars_repo_licenses": ["Python-2.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-12-02T06:38:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-02T06:38:05.000Z", "max_issues_repo_path": "src/ViennaRNA/wrap_dlib.cpp", "max_issues_repo_name": "tsjzz/ViennaRNA", "max_issues_repo_head_hexsha": "f58f58ac6fb3e050f12e69cbbf7f0a95bc625d99", "max_issues_repo_licenses": ["Python-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/ViennaRNA/wrap_dlib.cpp", "max_forks_repo_name": "tsjzz/ViennaRNA", "max_forks_repo_head_hexsha": "f58f58ac6fb3e050f12e69cbbf7f0a95bc625d99", "max_forks_repo_licenses": ["Python-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": 25.5934065934, "max_line_length": 91, "alphanum_fraction": 0.5434735938, "num_tokens": 2613, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8558511469672594, "lm_q2_score": 0.640635854839898, "lm_q1q2_score": 0.5482889311530774}} {"text": "#include \n#include \n#include \n#include \n\nint main(int argc, char const *argv[])\n{\n Eigen::Matrix a = Eigen::Matrix::Zero();\n a(1,1) = 1;\n Eigen::Matrix, 2, 2> b, c;\n b << std::complex(), std::complex(1,1), std::complex(2,2), std::complex(3,3);\n c = a.cast>()*b;\n std::cout << \"a = \" << std::endl << a << std::endl;\n std::cout << \"b = \" << std::endl << b << std::endl;\n std::cout << \"c = \" << std::endl << c << std::endl;\n return EXIT_SUCCESS;\n}\n", "meta": {"hexsha": "efec933337593d7f5e80900ed252a90e2331d339", "size": 595, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "HelloEigen/main.cpp", "max_stars_repo_name": "reinhar2/SamplesWorld", "max_stars_repo_head_hexsha": "e765a2db8569b4cc538d82cb2140e8eb3abc39ec", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "HelloEigen/main.cpp", "max_issues_repo_name": "reinhar2/SamplesWorld", "max_issues_repo_head_hexsha": "e765a2db8569b4cc538d82cb2140e8eb3abc39ec", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "HelloEigen/main.cpp", "max_forks_repo_name": "reinhar2/SamplesWorld", "max_forks_repo_head_hexsha": "e765a2db8569b4cc538d82cb2140e8eb3abc39ec", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.0555555556, "max_line_length": 111, "alphanum_fraction": 0.5781512605, "num_tokens": 200, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8558511396138366, "lm_q2_score": 0.640635854839898, "lm_q1q2_score": 0.5482889264422112}} {"text": "// Copyright (c) 2020 Chris Richardson & Matthew Scroggs\n// FEniCS Project\n// SPDX-License-Identifier: MIT\n\n#include \"brezzi-douglas-marini.h\"\n#include \"core/dof-permutations.h\"\n#include \"core/element-families.h\"\n#include \"core/mappings.h\"\n#include \"core/moments.h\"\n#include \"core/polyset.h\"\n#include \"core/quadrature.h\"\n#include \"lagrange.h\"\n#include \"nedelec.h\"\n#include \n#include \n#include \n\nusing namespace basix;\n\n//----------------------------------------------------------------------------\nFiniteElement basix::create_bdm(cell::type celltype, int degree)\n{\n if (celltype != cell::type::triangle and celltype != cell::type::tetrahedron)\n throw std::runtime_error(\"Unsupported cell type\");\n\n const int tdim = cell::topological_dimension(celltype);\n\n const cell::type facettype\n = (tdim == 2) ? cell::type::interval : cell::type::triangle;\n\n // The number of order (degree) scalar polynomials\n const int npoly = polyset::dim(celltype, degree);\n const int ndofs = npoly * tdim;\n\n // Create coefficients for order (degree-1) vector polynomials\n Eigen::MatrixXd wcoeffs = Eigen::MatrixXd::Identity(ndofs, ndofs);\n\n // Dual space\n Eigen::MatrixXd dual = Eigen::MatrixXd::Zero(ndofs, ndofs);\n\n // quadrature degree\n int quad_deg = 5 * degree;\n\n // Add rows to dualmat for integral moments on facets\n const int facet_count = tdim + 1;\n const int facet_dofs = polyset::dim(facettype, degree);\n\n dual.block(0, 0, facet_count * facet_dofs, ndofs)\n = moments::make_normal_integral_moments(\n create_dlagrange(facettype, degree), celltype, tdim, degree,\n quad_deg);\n\n const int internal_dofs = ndofs - facet_count * facet_dofs;\n\n // Add rows to dualmat for integral moments on interior\n if (degree > 1)\n {\n // Interior integral moment\n dual.block(facet_count * facet_dofs, 0, internal_dofs, ndofs)\n = moments::make_dot_integral_moments(\n create_nedelec(celltype, degree - 1), celltype, tdim, degree,\n quad_deg);\n }\n\n const std::vector>> topology\n = cell::topology(celltype);\n\n int perm_count = 0;\n for (int i = 1; i < tdim; ++i)\n perm_count += topology[i].size() * i;\n\n std::vector base_permutations(\n perm_count, Eigen::MatrixXd::Identity(ndofs, ndofs));\n if (tdim == 2)\n {\n Eigen::ArrayXi edge_ref = dofperms::interval_reflection(degree + 1);\n Eigen::ArrayXXd edge_dir\n = dofperms::interval_reflection_tangent_directions(degree + 1);\n for (int edge = 0; edge < facet_count; ++edge)\n {\n const int start = edge_ref.size() * edge;\n for (int i = 0; i < edge_ref.size(); ++i)\n {\n base_permutations[edge](start + i, start + i) = 0;\n base_permutations[edge](start + i, start + edge_ref[i]) = 1;\n }\n Eigen::MatrixXd directions = Eigen::MatrixXd::Identity(ndofs, ndofs);\n directions.block(edge_dir.rows() * edge, edge_dir.cols() * edge,\n edge_dir.rows(), edge_dir.cols())\n = edge_dir;\n base_permutations[edge] *= directions;\n }\n }\n else if (tdim == 3)\n {\n Eigen::ArrayXi face_ref = dofperms::triangle_reflection(degree + 1);\n Eigen::ArrayXi face_rot = dofperms::triangle_rotation(degree + 1);\n\n for (int face = 0; face < facet_count; ++face)\n {\n const int start = face_ref.size() * face;\n for (int i = 0; i < face_rot.size(); ++i)\n {\n base_permutations[6 + 2 * face](start + i, start + i) = 0;\n base_permutations[6 + 2 * face](start + i, start + face_rot[i]) = 1;\n base_permutations[6 + 2 * face + 1](start + i, start + i) = 0;\n base_permutations[6 + 2 * face + 1](start + i, start + face_ref[i])\n = -1;\n }\n }\n }\n\n // BDM has facet_dofs dofs on each facet, and ndofs-facet_count*facet_dofs in\n // the interior\n std::vector> entity_dofs(topology.size());\n for (int i = 0; i < tdim - 1; ++i)\n entity_dofs[i].resize(topology[i].size(), 0);\n entity_dofs[tdim - 1].resize(topology[tdim - 1].size(), facet_dofs);\n entity_dofs[tdim] = {internal_dofs};\n\n Eigen::MatrixXd coeffs = compute_expansion_coefficients(wcoeffs, dual);\n\n return FiniteElement(element::family::BDM, celltype, degree, {tdim}, coeffs,\n entity_dofs, base_permutations, {}, {},\n mapping::type::contravariantPiola);\n}\n//-----------------------------------------------------------------------------\n", "meta": {"hexsha": "4561a66aa8a43770264c92d59f2120c201551679", "size": 4481, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "cpp/elements/brezzi-douglas-marini.cpp", "max_stars_repo_name": "draenog/basix", "max_stars_repo_head_hexsha": "172720a7ecf2caaf4619a4718fa3f3e1cbe0c1e4", "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": "cpp/elements/brezzi-douglas-marini.cpp", "max_issues_repo_name": "draenog/basix", "max_issues_repo_head_hexsha": "172720a7ecf2caaf4619a4718fa3f3e1cbe0c1e4", "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": "cpp/elements/brezzi-douglas-marini.cpp", "max_forks_repo_name": "draenog/basix", "max_forks_repo_head_hexsha": "172720a7ecf2caaf4619a4718fa3f3e1cbe0c1e4", "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": 35.0078125, "max_line_length": 79, "alphanum_fraction": 0.6244141933, "num_tokens": 1236, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972751232809, "lm_q2_score": 0.6297746143530797, "lm_q1q2_score": 0.5482800631976062}} {"text": "/*\n * LaplaceM2L.cpp\n *\n * Created on: Oct 12, 2016\n * Author: wyan\n */\n\n#include \"SVD_pvfmm.hpp\"\n\n#include \n\n#include \n#include \n#include \n#include \n\n#define DIRECTLAYER 2\n#define PI314 (static_cast(3.1415926535897932384626433))\n\nnamespace Laplace3D3D {\n\nusing EVec3 = Eigen::Vector3d;\nusing EVec4 = Eigen::Vector4d;\nconstexpr double eps = 1e-10;\n\n// real and wave sum of 2D Laplace kernel Ewald\n\ninline double freal(double xi, double r) { return std::erfc(xi * r) / r; }\n\ninline double frealp(double xi, double r) {\n return -(2. * exp(-r * r * (xi * xi)) * xi) / (sqrt(M_PI) * r) - std::erfc(r * xi) / (r * r);\n}\n\n// xm: target, xn: source\ninline double realSum(const double xi, const EVec3 &xn, const EVec3 &xm) {\n EVec3 rmn = xm - xn;\n double rnorm = rmn.norm();\n if (rnorm < eps) {\n return 0;\n }\n return freal(xi, rnorm);\n}\n\ninline double potEwald(const EVec3 &xm, const EVec3 &xn) {\n const double xi = 2; // recommend for box=1 to get machine precision\n EVec3 target = xm;\n EVec3 source = xn;\n target[0] = target[0] - floor(target[0]); // periodic BC\n target[1] = target[1] - floor(target[1]);\n target[2] = target[2] - floor(target[2]);\n source[0] = source[0] - floor(source[0]);\n source[1] = source[1] - floor(source[1]);\n source[2] = source[2] - floor(source[2]);\n\n // real sum\n int rLim = 4;\n double Kreal = 0;\n for (int i = -rLim; i <= rLim; i++) {\n for (int j = -rLim; j <= rLim; j++) {\n for (int k = -rLim; k <= rLim; k++) {\n Kreal += realSum(xi, target, source - EVec3(i, j, k));\n }\n }\n }\n\n // wave sum\n int wLim = 4;\n double Kwave = 0;\n EVec3 rmn = target - source;\n const double xi2 = xi * xi;\n const double rmnnorm = rmn.norm();\n for (int i = -wLim; i <= wLim; i++) {\n for (int j = -wLim; j <= wLim; j++) {\n for (int k = -wLim; k <= wLim; k++) {\n if (i == 0 && j == 0 && k == 0) {\n continue;\n }\n EVec3 kvec = EVec3(i, j, k) * (2 * PI314);\n double k2 = kvec.dot(kvec);\n Kwave += 4 * PI314 * cos(kvec.dot(rmn)) * exp(-k2 / (4 * xi2)) / k2;\n }\n }\n }\n\n double Kself = rmnnorm < 1e-10 ? -2 * xi / sqrt(PI314) : 0;\n\n return Kreal + Kwave + Kself - PI314 / xi2;\n}\n\ninline void realGradSum(double xi, const EVec3 &target, const EVec3 &source, EVec3 &v) {\n EVec3 rvec = target - source;\n double rnorm = rvec.norm();\n if (rnorm < eps) {\n v.setZero();\n } else {\n v = (frealp(xi, rnorm) / rnorm) * rvec;\n }\n}\n\ninline void gradkernel(const EVec3 &target, const EVec3 &source, EVec3 &answer) {\n EVec3 rst = target - source;\n double rnorm = rst.norm();\n if (rnorm < eps) {\n answer.setZero();\n return;\n }\n double rnorm3 = rnorm * rnorm * rnorm;\n answer = -rst / rnorm3;\n}\n\n// grad of Laplace potential, without 1/4pi prefactor, periodic of -r_k/r^3\ninline void gradEwald(const EVec3 &target_, const EVec3 &source_, EVec3 &answer) {\n EVec3 target = target_;\n EVec3 source = source_;\n target[0] = target[0] - floor(target[0]); // periodic BC\n target[1] = target[1] - floor(target[1]);\n target[2] = target[2] - floor(target[2]);\n source[0] = source[0] - floor(source[0]);\n source[1] = source[1] - floor(source[1]);\n source[2] = source[2] - floor(source[2]);\n\n double xi = 0.54;\n\n // real sum\n int rLim = 10;\n EVec3 Kreal = EVec3::Zero();\n for (int i = -rLim; i < rLim + 1; i++) {\n for (int j = -rLim; j < rLim + 1; j++) {\n for (int k = -rLim; k < rLim + 1; k++) {\n EVec3 v = EVec3::Zero();\n realGradSum(xi, target, source + EVec3(i, j, k), v);\n Kreal += v;\n }\n }\n }\n\n // wave sum\n int wLim = 10;\n EVec3 rmn = target - source;\n double xi2 = xi * xi;\n EVec3 Kwave(0., 0., 0.);\n for (int i = -wLim; i < wLim + 1; i++) {\n for (int j = -wLim; j < wLim + 1; j++) {\n for (int k = -wLim; k < wLim + 1; k++) {\n if (i == 0 && j == 0 && k == 0)\n continue;\n EVec3 kvec = EVec3(i, j, k) * (2 * M_PI);\n double k2 = kvec.dot(kvec);\n double knorm = kvec.norm();\n Kwave += -kvec * (sin(kvec.dot(rmn)) * exp(-k2 / (4 * xi2)) / k2);\n }\n }\n }\n\n answer = Kreal + Kwave;\n}\n\ninline double pot(const EVec3 &target, const EVec3 &source) {\n EVec3 rst = target - source;\n double rnorm = rst.norm();\n return rnorm < eps ? 0 : 1 / rnorm;\n}\n\ninline EVec4 gKernel(const EVec3 &target, const EVec3 &source) {\n EVec3 rst = target - source;\n EVec4 pgrad = EVec4::Zero();\n double rnorm = rst.norm();\n if (rnorm < eps) {\n pgrad.setZero();\n } else {\n pgrad[0] = 1 / rnorm;\n double rnorm3 = rnorm * rnorm * rnorm;\n pgrad.block<3, 1>(1, 0) = -rst / rnorm3;\n }\n return pgrad;\n}\n\ninline EVec4 gKernelEwald(const EVec3 &target, const EVec3 &source) {\n EVec4 pgrad = EVec4::Zero();\n pgrad[0] = potEwald(target, source);\n EVec3 grad;\n gradEwald(target, source, grad);\n pgrad[1] = grad[0];\n pgrad[2] = grad[1];\n pgrad[3] = grad[2];\n return pgrad;\n}\n\ninline EVec4 gKernelNF(const EVec3 &target, const EVec3 &source, int N = DIRECTLAYER) {\n EVec4 gNF = EVec4::Zero();\n for (int i = -N; i < N + 1; i++) {\n for (int j = -N; j < N + 1; j++) {\n for (int k = -N; k < N + 1; k++) {\n EVec4 gFree = gKernel(target, source + EVec3(i, j, k));\n gNF += gFree;\n }\n }\n }\n return gNF;\n}\n\n// Out of Direct Sum Layer, far field part\ninline EVec4 gKernelFF(const EVec3 &target, const EVec3 &source) {\n EVec4 fEwald = gKernelEwald(target, source);\n fEwald -= gKernelNF(target, source);\n return fEwald;\n}\n\ninline double potNF(const EVec3 &target, const EVec3 &source, int N = DIRECTLAYER) {\n double gNF = 0;\n for (int i = -N; i < N + 1; i++) {\n for (int j = -N; j < N + 1; j++) {\n for (int k = -N; k < N + 1; k++) {\n gNF += pot(target, source + EVec3(i, j, k));\n }\n }\n }\n return gNF;\n}\n\n// Out of Direct Sum Layer, far field part\ninline double potFF(const EVec3 &target, const EVec3 &source) {\n double fEwald = potEwald(target, source);\n fEwald -= potNF(target, source);\n return fEwald;\n}\n\n/**\n * \\brief Returns the coordinates of points on the surface of a cube.\n * \\param[in] p Number of points on an edge of the cube is (n+1)\n * \\param[in] c Coordinates to the centre of the cube (3D array).\n * \\param[in] alpha Scaling factor for the size of the cube.\n * \\param[in] depth Depth of the cube in the octree.\n * \\return Vector with coordinates of points on the surface of the cube in the\n * format [x0 y0 z0 x1 y1 z1 .... ].\n */\n\ntemplate \nstd::vector surface(int p, Real_t *c, Real_t alpha, int depth) {\n size_t n_ = (6 * (p - 1) * (p - 1) + 2); // Total number of points.\n\n std::vector coord(n_ * 3);\n coord[0] = coord[1] = coord[2] = -1.0;\n size_t cnt = 1;\n for (int i = 0; i < p - 1; i++)\n for (int j = 0; j < p - 1; j++) {\n coord[cnt * 3] = -1.0;\n coord[cnt * 3 + 1] = (2.0 * (i + 1) - p + 1) / (p - 1);\n coord[cnt * 3 + 2] = (2.0 * j - p + 1) / (p - 1);\n cnt++;\n }\n for (int i = 0; i < p - 1; i++)\n for (int j = 0; j < p - 1; j++) {\n coord[cnt * 3] = (2.0 * i - p + 1) / (p - 1);\n coord[cnt * 3 + 1] = -1.0;\n coord[cnt * 3 + 2] = (2.0 * (j + 1) - p + 1) / (p - 1);\n cnt++;\n }\n for (int i = 0; i < p - 1; i++)\n for (int j = 0; j < p - 1; j++) {\n coord[cnt * 3] = (2.0 * (i + 1) - p + 1) / (p - 1);\n coord[cnt * 3 + 1] = (2.0 * j - p + 1) / (p - 1);\n coord[cnt * 3 + 2] = -1.0;\n cnt++;\n }\n for (size_t i = 0; i < (n_ / 2) * 3; i++)\n coord[cnt * 3 + i] = -coord[i];\n\n Real_t r = 0.5 * pow(0.5, depth);\n Real_t b = alpha * r;\n for (size_t i = 0; i < n_; i++) {\n coord[i * 3 + 0] = (coord[i * 3 + 0] + 1.0) * b + c[0];\n coord[i * 3 + 1] = (coord[i * 3 + 1] + 1.0) * b + c[1];\n coord[i * 3 + 2] = (coord[i * 3 + 2] + 1.0) * b + c[2];\n }\n return coord;\n}\n\nint main(int argc, char **argv) {\n Eigen::initParallel();\n Eigen::setNbThreads(1);\n\n std::cout << std::scientific << std::setprecision(18);\n\n std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();\n const int pEquiv = atoi(argv[1]); // (8-1)^2*6 + 2 points\n const int pCheck = atoi(argv[1]);\n const double scaleEquiv = 1.05;\n const double scaleCheck = 2.95;\n const double pCenterEquiv[3] = {-(scaleEquiv - 1) / 2, -(scaleEquiv - 1) / 2, -(scaleEquiv - 1) / 2};\n const double pCenterCheck[3] = {-(scaleCheck - 1) / 2, -(scaleCheck - 1) / 2, -(scaleCheck - 1) / 2};\n\n const double scaleLEquiv = 1.05;\n const double scaleLCheck = 2.95;\n const double pCenterLEquiv[3] = {-(scaleLEquiv - 1) / 2, -(scaleLEquiv - 1) / 2, -(scaleLEquiv - 1) / 2};\n const double pCenterLCheck[3] = {-(scaleLCheck - 1) / 2, -(scaleLCheck - 1) / 2, -(scaleLCheck - 1) / 2};\n\n auto pointMEquiv = surface(pEquiv, (double *)&(pCenterEquiv[0]), scaleEquiv, 0);\n // center at 0.5,0.5,0.5, periodic box 1,1,1, scale 1.05, depth = 0\n auto pointMCheck = surface(pCheck, (double *)&(pCenterCheck[0]), scaleCheck, 0);\n // center at 0.5,0.5,0.5, periodic box 1,1,1, scale 1.05, depth = 0\n\n auto pointLEquiv = surface(pEquiv, (double *)&(pCenterLCheck[0]), scaleLCheck, 0);\n // center at 0.5,0.5,0.5, periodic box 1,1,1, scale 1.05, depth = 0\n auto pointLCheck = surface(pCheck, (double *)&(pCenterLEquiv[0]), scaleLEquiv, 0);\n // center at 0.5,0.5,0.5, periodic box 1,1,1, scale 1.05, depth = 0\n\n // calculate the operator M2L with least square\n const int equivN = pointMEquiv.size() / 3;\n const int checkN = pointLCheck.size() / 3;\n Eigen::MatrixXd M2L(equivN, equivN); // Laplace, 1->1\n\n // Aup for solving MEquiv\n Eigen::MatrixXd Aup(checkN, equivN);\n Eigen::MatrixXd AuppinvU(Aup.cols(), Aup.rows());\n Eigen::MatrixXd AuppinvVT(Aup.cols(), Aup.rows());\n for (int k = 0; k < checkN; k++) {\n Eigen::Vector3d Cpoint(pointMCheck[3 * k], pointMCheck[3 * k + 1], pointMCheck[3 * k + 2]);\n for (int l = 0; l < equivN; l++) {\n const Eigen::Vector3d Lpoint(pointMEquiv[3 * l], pointMEquiv[3 * l + 1], pointMEquiv[3 * l + 2]);\n Aup(k, l) = pot(Cpoint, Lpoint);\n }\n }\n pinv(Aup, AuppinvU, AuppinvVT);\n\n // condition number\n Eigen::JacobiSVD svd(Aup);\n double cond = svd.singularValues()(0) / svd.singularValues()(svd.singularValues().size() - 1);\n std::cout << cond << std::endl;\n std::cout << \"s:\" << svd.singularValues() << std::endl;\n\n // Adown for solving LEquiv\n Eigen::MatrixXd Adown(checkN, equivN);\n Eigen::MatrixXd AdownpinvU(Adown.cols(), Adown.rows());\n Eigen::MatrixXd AdownpinvVT(Adown.cols(), Adown.rows());\n for (int k = 0; k < checkN; k++) {\n Eigen::Vector3d Cpoint(pointLCheck[3 * k], pointLCheck[3 * k + 1], pointLCheck[3 * k + 2]);\n for (int l = 0; l < equivN; l++) {\n const Eigen::Vector3d Lpoint(pointLEquiv[3 * l], pointLEquiv[3 * l + 1], pointLEquiv[3 * l + 2]);\n Adown(k, l) = pot(Cpoint, Lpoint);\n }\n }\n pinv(Adown, AdownpinvU, AdownpinvVT);\n\n#pragma omp parallel for\n for (int i = 0; i < equivN; i++) {\n const Eigen::Vector3d Mpoint(pointMEquiv[3 * i], pointMEquiv[3 * i + 1], pointMEquiv[3 * i + 2]);\n const EVec3 Npoint(0.5, 0.5, 0.5);\n Eigen::VectorXd f(checkN);\n f.setZero();\n for (int k = 0; k < checkN; k++) {\n EVec3 Cpoint(pointLCheck[3 * k], pointLCheck[3 * k + 1], pointLCheck[3 * k + 2]);\n f[k] = potFF(Cpoint, Mpoint) - potFF(Cpoint, Npoint);\n }\n\n M2L.col(i) = (AdownpinvU.transpose() * (AdownpinvVT.transpose() * f));\n }\n std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();\n auto duration = std::chrono::duration_cast(t2 - t1).count();\n\n // dump M2L\n for (int i = 0; i < equivN; i++) {\n for (int j = 0; j < equivN; j++) {\n std::cout << i << \" \" << j << \" \" << std::scientific << std::setprecision(18) << M2L(i, j) << std::endl;\n }\n }\n\n std::cout << \"Precomputing time:\" << duration / 1e6 << std::endl;\n\n // Test\n EVec3 center(0.6, 0.5, 0.5);\n std::vector> chargePoint(2);\n std::vector chargeValue(2);\n chargePoint[0] = center + EVec3(0.1, 0, 0);\n chargeValue[0] = 1;\n chargePoint[1] = center + EVec3(-0.1, 0., 0.);\n chargeValue[1] = -1;\n // chargePoint[2] = center + EVec3(-0.2, 0., 0.);\n // chargeValue[2] = 1;\n\n // solve M\n Eigen::VectorXd f(checkN);\n for (int k = 0; k < checkN; k++) {\n double temp = 0;\n Eigen::Vector3d Cpoint(pointMCheck[3 * k], pointMCheck[3 * k + 1], pointMCheck[3 * k + 2]);\n for (size_t p = 0; p < chargePoint.size(); p++) {\n temp = temp + pot(Cpoint, chargePoint[p]) * (chargeValue[p]);\n }\n f[k] = temp;\n }\n Eigen::VectorXd Msource = (AuppinvU.transpose() * (AuppinvVT.transpose() * f));\n\n std::cout << \"Msource \" << Msource << std::endl;\n\n std::cout << \"backward error: \" << f - Aup * Msource << std::endl;\n\n // check dipole moment\n {\n EVec3 dipole = EVec3::Zero();\n for (int i = 0; i < chargePoint.size(); i++) {\n dipole += chargeValue[i] * chargePoint[i];\n }\n std::cout << \"charge dipole \" << dipole.transpose() << std::endl;\n }\n {\n EVec3 dipole = EVec3::Zero();\n for (int i = 0; i < equivN; i++) {\n Eigen::Vector3d Mpoint(pointMEquiv[3 * i], pointMEquiv[3 * i + 1], pointMEquiv[3 * i + 2]);\n dipole += Mpoint * Msource[i];\n }\n std::cout << \"Mequiv dipole \" << dipole.transpose() << std::endl;\n }\n\n Eigen::VectorXd M2Lsource = M2L * (Msource);\n\n for (int is = 0; is < 5; is++) {\n\n Eigen::Vector3d samplePoint = EVec3::Random() * 0.2 + EVec3(0.5, 0.5, 0.5);\n\n EVec4 UFFL2T = EVec4::Zero();\n EVec4 UFFS2T = EVec4::Zero();\n EVec4 UFFM2T = EVec4::Zero();\n\n#pragma omp sections\n {\n#pragma omp section\n for (int p = 0; p < chargePoint.size(); p++) {\n UFFS2T += gKernelFF(samplePoint, chargePoint[p]) * chargeValue[p];\n }\n\n#pragma omp section\n for (int p = 0; p < equivN; p++) {\n Eigen::Vector3d Lpoint(pointLEquiv[3 * p], pointLEquiv[3 * p + 1], pointLEquiv[3 * p + 2]);\n UFFL2T += gKernel(samplePoint, Lpoint) * M2Lsource[p];\n }\n\n#pragma omp section\n for (int p = 0; p < equivN; p++) {\n Eigen::Vector3d Mpoint(pointMEquiv[3 * p], pointMEquiv[3 * p + 1], pointMEquiv[3 * p + 2]);\n UFFM2T += gKernelFF(samplePoint, Mpoint) * Msource[p];\n }\n }\n std::cout << std::scientific << std::setprecision(10);\n std::cout << \"-----------------------------------------------\" << std::endl;\n std::cout << \"samplePoint:\" << samplePoint.transpose() << std::endl;\n std::cout << \"UFF S2T: \" << UFFS2T.transpose() << std::endl;\n std::cout << \"UFF M2T: \" << UFFM2T.transpose() << std::endl;\n std::cout << \"UFF L2T: \" << UFFL2T.transpose() << std::endl;\n std::cout << \"Error M2T: \" << (UFFM2T - UFFS2T).transpose() << std::endl;\n std::cout << \"Error L2T: \" << (UFFL2T - UFFS2T).transpose() << std::endl;\n }\n\n return 0;\n}\n\n} // namespace Laplace3D3D\n\n#undef DIRECTLAYER\n#undef PI314\n", "meta": {"hexsha": "c6c0bd55158b43e7f4bbc62f18e3821eeec82d86", "size": 16041, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "M2L/Laplace/Laplace3D3D.cpp", "max_stars_repo_name": "lamsoa729/STKFMM", "max_stars_repo_head_hexsha": "26d7d971c198e3bed68eb8373e5590a6eb72f764", "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": "M2L/Laplace/Laplace3D3D.cpp", "max_issues_repo_name": "lamsoa729/STKFMM", "max_issues_repo_head_hexsha": "26d7d971c198e3bed68eb8373e5590a6eb72f764", "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": "M2L/Laplace/Laplace3D3D.cpp", "max_forks_repo_name": "lamsoa729/STKFMM", "max_forks_repo_head_hexsha": "26d7d971c198e3bed68eb8373e5590a6eb72f764", "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": 34.8717391304, "max_line_length": 116, "alphanum_fraction": 0.5290817281, "num_tokens": 5583, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972684083608, "lm_q2_score": 0.6297746074044134, "lm_q1q2_score": 0.5482800529192301}} {"text": "/**\n * Some additional useful distributions (only bare operator()).\n */\n#ifndef SKYLARK_DISTRIBUTIONS_HPP\n#define SKYLARK_DISTRIBUTIONS_HPP\n\n#include \n\nnamespace skylark {\nnamespace utility {\n\n\n/**\n * Levy distribution\n */\ntemplate< typename ValueType >\nstruct standard_levy_distribution_t {\n\n // TODO not really sure this is the standard, or implemented correctly\n\n typedef ValueType result_type;\n\n standard_levy_distribution_t() {\n\n }\n\n template< typename URNG >\n ValueType operator()(URNG &prng) const {\n boost::random::gamma_distribution dist(0.5, 2);\n result_type y = static_cast(dist(prng));\n return (1.0 / y);\n }\n void reset() {}\n\n};\n\n/**\n * Radamachar distribution - +1 and -1 with equal probability.\n */\ntemplate< typename ValueType >\nstruct rademacher_distribution_t {\n\n typedef ValueType result_type;\n\n template< typename URNG >\n ValueType operator()(URNG &prng) const {\n double probabilities[] = { 0.5, 0.0, 0.5 };\n boost::random::discrete_distribution<> dist(probabilities);\n return static_cast(dist(prng)) - 1.0;\n }\n void reset() {}\n};\n\n/**\n * Uniform distribution\n */\ntemplate struct uniform_distribution_t {\n typedef ValueType result_type;\n};\n\n/**\n * Uniform distribution specialization for double's\n */\ntemplate <> struct uniform_distribution_t {\n\n typedef double result_type;\n\n boost::random::uniform_real_distribution distribution;\n\n uniform_distribution_t() {}\n\n uniform_distribution_t(double low, double high) :\n distribution(low, high) {}\n\n template< typename URNG >\n double operator()(URNG &urng) const {\n return distribution(urng);\n }\n void reset() {}\n};\n\n/**\n * Uniform distribution specialization for int's\n */\ntemplate <> struct uniform_distribution_t {\n\n typedef int result_type;\n\n boost::random::uniform_int_distribution distribution;\n\n uniform_distribution_t() {}\n\n uniform_distribution_t(int low, int high) :\n distribution(low, high) {}\n\n template< typename URNG >\n int operator()(URNG &urng) const {\n return distribution(urng);\n }\n void reset() {}\n};\n\n/**\n * Uniform distribution specialization for size_t\n */\ntemplate <> struct uniform_distribution_t {\n\n typedef int result_type;\n\n boost::random::uniform_int_distribution distribution;\n\n uniform_distribution_t() {}\n\n uniform_distribution_t(size_t low, size_t high) :\n distribution(low, high) {}\n\n template< typename URNG >\n int operator()(URNG &urng) const {\n return distribution(urng);\n }\n void reset() {}\n};\n\n\n/**\n * Uniform distribution specialization for bool's\n */\ntemplate <> struct uniform_distribution_t {\n\n typedef bool result_type;\n\n boost::random::uniform_int_distribution distribution;\n\n uniform_distribution_t() {}\n\n template< typename URNG >\n bool operator()(URNG &urng) const {\n return (1==distribution(urng));\n }\n void reset() {}\n};\n\n} // namespace utility\n} // namespace skylark\n\n#endif // SKYLARK_DISTRIBUTIONS_HPP\n", "meta": {"hexsha": "1d03f711e486341d62e28aa8e387c2c334aa4068", "size": 3166, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "utility/distributions.hpp", "max_stars_repo_name": "wangg12/libskylark", "max_stars_repo_head_hexsha": "e8836190be854d0284d38772c48e110b3c6d5e51", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 86.0, "max_stars_repo_stars_event_min_datetime": "2015-01-20T03:12:46.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-10T04:05:21.000Z", "max_issues_repo_path": "utility/distributions.hpp", "max_issues_repo_name": "cjiyer/libskylark", "max_issues_repo_head_hexsha": "e8836190be854d0284d38772c48e110b3c6d5e51", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 48.0, "max_issues_repo_issues_event_min_datetime": "2015-05-12T09:31:23.000Z", "max_issues_repo_issues_event_max_datetime": "2018-12-05T14:45:46.000Z", "max_forks_repo_path": "utility/distributions.hpp", "max_forks_repo_name": "cjiyer/libskylark", "max_forks_repo_head_hexsha": "e8836190be854d0284d38772c48e110b3c6d5e51", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 25.0, "max_forks_repo_forks_event_min_datetime": "2015-01-18T23:02:11.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-12T07:30:35.000Z", "avg_line_length": 21.537414966, "max_line_length": 74, "alphanum_fraction": 0.6803537587, "num_tokens": 697, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031737963569016, "lm_q2_score": 0.6825737279551494, "lm_q1q2_score": 0.5482253323752203}} {"text": "/* ---------------------------------------------------------------------\n *\n * Copyright (C) 2020 - 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 at\n * the top level of the deal.II distribution.\n *\n * ---------------------------------------------------------------------\n\n *\n * Author: Timo Heister and Jiaqi Zhang, Clemson University, 2020\n */\n\n// The first few files have already been covered in previous examples and will\n// thus not be further commented on:\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n// Here the discontinuous finite elements and FEInterfaceValues are defined.\n#include \n#include \n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\nnamespace Step74\n{\n using namespace dealii;\n\n // @sect3{Equation data}\n // Here we define two test cases: convergence_rate for a smooth function\n // and l_singularity for the Functions::LSingularityFunction.\n enum class TestCase\n {\n convergence_rate,\n l_singularity\n };\n\n\n\n // A smooth solution for the convergence test:\n template \n class SmoothSolution : public Function\n {\n public:\n SmoothSolution()\n : Function()\n {}\n\n virtual void value_list(const std::vector> &points,\n std::vector & values,\n const unsigned int component = 0) const override;\n\n virtual Tensor<1, dim>\n gradient(const Point & point,\n const unsigned int component = 0) const override;\n };\n\n\n\n template \n void SmoothSolution::value_list(const std::vector> &points,\n std::vector & values,\n const unsigned int /*component*/) const\n {\n using numbers::PI;\n for (unsigned int i = 0; i < values.size(); ++i)\n values[i] =\n std::sin(2. * PI * points[i][0]) * std::sin(2. * PI * points[i][1]);\n }\n\n\n\n template \n Tensor<1, dim>\n SmoothSolution::gradient(const Point &point,\n const unsigned int /*component*/) const\n {\n Tensor<1, dim> return_value;\n using numbers::PI;\n return_value[0] =\n 2. * PI * std::cos(2. * PI * point[0]) * std::sin(2. * PI * point[1]);\n return_value[1] =\n 2. * PI * std::sin(2. * PI * point[0]) * std::cos(2. * PI * point[1]);\n return return_value;\n }\n\n\n\n // The corresponding right-hand side of the smooth function:\n template \n class SmoothRightHandSide : public Function\n {\n public:\n SmoothRightHandSide()\n : Function()\n {}\n\n virtual void value_list(const std::vector> &points,\n std::vector & values,\n const unsigned int /*component*/) const override;\n };\n\n\n\n template \n void\n SmoothRightHandSide::value_list(const std::vector> &points,\n std::vector & values,\n const unsigned int /*component*/) const\n {\n using numbers::PI;\n for (unsigned int i = 0; i < values.size(); ++i)\n values[i] = 8. * PI * PI * std::sin(2. * PI * points[i][0]) *\n std::sin(2. * PI * points[i][1]);\n }\n\n\n\n // The right-hand side that corresponds to the function\n // Functions::LSingularityFunction, where we\n // assume that the diffusion coefficient $\\nu = 1$:\n template \n class SingularRightHandSide : public Function\n {\n public:\n SingularRightHandSide()\n : Function()\n {}\n\n virtual void value_list(const std::vector> &points,\n std::vector & values,\n const unsigned int /*component*/) const override;\n\n private:\n const Functions::LSingularityFunction ref;\n };\n\n\n\n template \n void\n SingularRightHandSide::value_list(const std::vector> &points,\n std::vector & values,\n const unsigned int /*component*/) const\n {\n for (unsigned int i = 0; i < values.size(); ++i)\n values[i] = -ref.laplacian(points[i]);\n }\n\n\n\n // @sect3{Auxiliary functions}\n // The following two auxiliary functions are used to compute\n // jump terms for $u_h$ and $\\nabla u_h$ on a face,\n // respectively.\n template \n void get_function_jump(const FEInterfaceValues &fe_iv,\n const Vector & solution,\n std::vector & jump)\n {\n const unsigned int n_q = fe_iv.n_quadrature_points;\n std::array, 2> face_values;\n jump.resize(n_q);\n for (unsigned int i = 0; i < 2; ++i)\n {\n face_values[i].resize(n_q);\n fe_iv.get_fe_face_values(i).get_function_values(solution,\n face_values[i]);\n }\n for (unsigned int q = 0; q < n_q; ++q)\n jump[q] = face_values[0][q] - face_values[1][q];\n }\n\n\n\n template \n void get_function_gradient_jump(const FEInterfaceValues &fe_iv,\n const Vector & solution,\n std::vector> & gradient_jump)\n {\n const unsigned int n_q = fe_iv.n_quadrature_points;\n std::vector> face_gradients[2];\n gradient_jump.resize(n_q);\n for (unsigned int i = 0; i < 2; ++i)\n {\n face_gradients[i].resize(n_q);\n fe_iv.get_fe_face_values(i).get_function_gradients(solution,\n face_gradients[i]);\n }\n for (unsigned int q = 0; q < n_q; ++q)\n gradient_jump[q] = face_gradients[0][q] - face_gradients[1][q];\n }\n\n // This function computes the penalty $\\sigma$.\n double get_penalty_factor(const unsigned int fe_degree,\n const double cell_extent_left,\n const double cell_extent_right)\n {\n const unsigned int degree = std::max(1U, fe_degree);\n return degree * (degree + 1.) * 0.5 *\n (1. / cell_extent_left + 1. / cell_extent_right);\n }\n\n\n // @sect3{The CopyData}\n // In the following, we define \"Copy\" objects for the MeshWorker::mesh_loop(),\n // which is essentially the same as step-12. Note that the\n // \"Scratch\" object is not defined here because we use\n // MeshWorker::ScratchData instead. (The use of \"Copy\" and \"Scratch\"\n // objects is extensively explained in the WorkStream namespace documentation.\n struct CopyDataFace\n {\n FullMatrix cell_matrix;\n std::vector joint_dof_indices;\n std::array values;\n std::array cell_indices;\n };\n\n\n\n struct CopyData\n {\n FullMatrix cell_matrix;\n Vector cell_rhs;\n std::vector local_dof_indices;\n std::vector face_data;\n double value;\n unsigned int cell_index;\n\n\n template \n void reinit(const Iterator &cell, const unsigned int dofs_per_cell)\n {\n cell_matrix.reinit(dofs_per_cell, dofs_per_cell);\n cell_rhs.reinit(dofs_per_cell);\n local_dof_indices.resize(dofs_per_cell);\n cell->get_dof_indices(local_dof_indices);\n }\n };\n\n\n\n // @sect3{The SIPGLaplace class}\n // After these preparations, we proceed with the main class of this program,\n // called `SIPGLaplace`. The overall structure of the class is as in many\n // of the other tutorial programs. Major differences will only come up in the\n // implementation of the assemble functions, since we use FEInterfaceValues to\n // assemble face terms.\n template \n class SIPGLaplace\n {\n public:\n SIPGLaplace(const TestCase &test_case);\n void run();\n\n private:\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 void compute_errors();\n void compute_error_estimate();\n double compute_energy_norm_error();\n\n Triangulation triangulation;\n const unsigned int degree;\n const QGauss quadrature;\n const QGauss face_quadrature;\n const QGauss quadrature_overintegration;\n const QGauss face_quadrature_overintegration;\n const MappingQ1 mapping;\n\n using ScratchData = MeshWorker::ScratchData;\n\n const FE_DGQ fe;\n DoFHandler dof_handler;\n\n SparsityPattern sparsity_pattern;\n SparseMatrix system_matrix;\n Vector solution;\n Vector system_rhs;\n\n // The remainder of the class's members are used for the following:\n // - Vectors to store error estimator square and energy norm square per\n // cell.\n // - Print convergence rate and errors on the screen.\n // - The fiffusion coefficient $\\nu$ is set to 1.\n // - Members that store information about the test case to be computed.\n Vector estimated_error_square_per_cell;\n Vector energy_norm_square_per_cell;\n\n ConvergenceTable convergence_table;\n\n const double diffusion_coefficient = 1.;\n\n const TestCase test_case;\n std::unique_ptr> exact_solution;\n std::unique_ptr> rhs_function;\n };\n\n // The constructor here takes the test case as input and then\n // determines the correct solution and right-hand side classes. The\n // remaining member variables are initialized in the obvious way.\n template \n SIPGLaplace::SIPGLaplace(const TestCase &test_case)\n : degree(3)\n , quadrature(degree + 1)\n , face_quadrature(degree + 1)\n , quadrature_overintegration(degree + 2)\n , face_quadrature_overintegration(degree + 2)\n , mapping()\n , fe(degree)\n , dof_handler(triangulation)\n , test_case(test_case)\n {\n if (test_case == TestCase::convergence_rate)\n {\n exact_solution = std::make_unique>();\n rhs_function = std::make_unique>();\n }\n\n else if (test_case == TestCase::l_singularity)\n {\n exact_solution =\n std::make_unique();\n rhs_function = std::make_unique>();\n }\n else\n AssertThrow(false, ExcNotImplemented());\n }\n\n\n\n template \n void SIPGLaplace::setup_system()\n {\n dof_handler.distribute_dofs(fe);\n DynamicSparsityPattern dsp(dof_handler.n_dofs());\n DoFTools::make_flux_sparsity_pattern(dof_handler, dsp);\n sparsity_pattern.copy_from(dsp);\n\n system_matrix.reinit(sparsity_pattern);\n solution.reinit(dof_handler.n_dofs());\n system_rhs.reinit(dof_handler.n_dofs());\n }\n\n\n\n // @sect3{The assemble_system function}\n // The assemble function here is similar to that in step-12 and step-47.\n // Different from assembling by hand, we just need to focus\n // on assembling on each cell, each boundary face, and each\n // interior face. The loops over cells and faces are handled\n // automatically by MeshWorker::mesh_loop().\n //\n // The function starts by defining a local (lambda) function that is\n // used to integrate the cell terms:\n template \n void SIPGLaplace::assemble_system()\n {\n const auto cell_worker =\n [&](const auto &cell, auto &scratch_data, auto ©_data) {\n const FEValues &fe_v = scratch_data.reinit(cell);\n const unsigned int dofs_per_cell = fe_v.dofs_per_cell;\n copy_data.reinit(cell, dofs_per_cell);\n\n const auto & q_points = scratch_data.get_quadrature_points();\n const unsigned int n_q_points = q_points.size();\n const std::vector &JxW = scratch_data.get_JxW_values();\n\n std::vector rhs(n_q_points);\n rhs_function->value_list(q_points, rhs);\n\n for (unsigned int point = 0; point < n_q_points; ++point)\n for (unsigned int i = 0; i < fe_v.dofs_per_cell; ++i)\n {\n for (unsigned int j = 0; j < fe_v.dofs_per_cell; ++j)\n copy_data.cell_matrix(i, j) +=\n diffusion_coefficient * // nu\n fe_v.shape_grad(i, point) * // grad v_h\n fe_v.shape_grad(j, point) * // grad u_h\n JxW[point]; // dx\n\n copy_data.cell_rhs(i) += fe_v.shape_value(i, point) * // v_h\n rhs[point] * // f\n JxW[point]; // dx\n }\n };\n\n // Next, we need a function that assembles face integrals on the boundary:\n const auto boundary_worker = [&](const auto & cell,\n const unsigned int &face_no,\n auto & scratch_data,\n auto & copy_data) {\n const FEFaceValuesBase &fe_fv = scratch_data.reinit(cell, face_no);\n\n const auto & q_points = scratch_data.get_quadrature_points();\n const unsigned int n_q_points = q_points.size();\n const unsigned int dofs_per_cell = fe_fv.dofs_per_cell;\n\n const std::vector & JxW = scratch_data.get_JxW_values();\n const std::vector> &normals =\n scratch_data.get_normal_vectors();\n\n std::vector g(n_q_points);\n exact_solution->value_list(q_points, g);\n\n const double extent1 = cell->measure() / cell->face(face_no)->measure();\n const double penalty = get_penalty_factor(degree, extent1, extent1);\n\n for (unsigned int point = 0; point < n_q_points; ++point)\n {\n for (unsigned int i = 0; i < dofs_per_cell; ++i)\n for (unsigned int j = 0; j < dofs_per_cell; ++j)\n copy_data.cell_matrix(i, j) +=\n (-diffusion_coefficient * // - nu\n fe_fv.shape_value(i, point) * // v_h\n (fe_fv.shape_grad(j, point) * // (grad u_h .\n normals[point]) // n)\n\n - diffusion_coefficient * // - nu\n (fe_fv.shape_grad(i, point) * // (grad v_h .\n normals[point]) * // n)\n fe_fv.shape_value(j, point) // u_h\n\n + diffusion_coefficient * penalty * // + nu sigma\n fe_fv.shape_value(i, point) * // v_h\n fe_fv.shape_value(j, point) // u_h\n\n ) *\n JxW[point]; // dx\n\n for (unsigned int i = 0; i < dofs_per_cell; ++i)\n copy_data.cell_rhs(i) +=\n (-diffusion_coefficient * // - nu\n (fe_fv.shape_grad(i, point) * // (grad v_h .\n normals[point]) * // n)\n g[point] // g\n\n\n + diffusion_coefficient * penalty * // + nu sigma\n fe_fv.shape_value(i, point) * g[point] // v_h g\n\n ) *\n JxW[point]; // dx\n }\n };\n\n // Finally, a function that assembles face integrals on interior\n // faces. To reinitialize FEInterfaceValues, we need to pass\n // cells, face and subface indices (for adaptive refinement) to\n // the reinit() function of FEInterfaceValues:\n const auto face_worker = [&](const auto & cell,\n const unsigned int &f,\n const unsigned int &sf,\n const auto & ncell,\n const unsigned int &nf,\n const unsigned int &nsf,\n auto & scratch_data,\n auto & copy_data) {\n const FEInterfaceValues &fe_iv =\n scratch_data.reinit(cell, f, sf, ncell, nf, nsf);\n\n const auto & q_points = fe_iv.get_quadrature_points();\n const unsigned int n_q_points = q_points.size();\n\n copy_data.face_data.emplace_back();\n CopyDataFace & copy_data_face = copy_data.face_data.back();\n const unsigned int n_dofs_face = fe_iv.n_current_interface_dofs();\n copy_data_face.joint_dof_indices = fe_iv.get_interface_dof_indices();\n copy_data_face.cell_matrix.reinit(n_dofs_face, n_dofs_face);\n\n const std::vector & JxW = fe_iv.get_JxW_values();\n const std::vector> &normals = fe_iv.get_normal_vectors();\n\n const double extent1 = cell->measure() / cell->face(f)->measure();\n const double extent2 = ncell->measure() / ncell->face(nf)->measure();\n const double penalty = get_penalty_factor(degree, extent1, extent2);\n\n for (unsigned int point = 0; point < n_q_points; ++point)\n {\n for (unsigned int i = 0; i < n_dofs_face; ++i)\n for (unsigned int j = 0; j < n_dofs_face; ++j)\n copy_data_face.cell_matrix(i, j) +=\n (-diffusion_coefficient * // - nu\n fe_iv.jump(i, point) * // [v_h]\n (fe_iv.average_gradient(j, point) * // ({grad u_h} .\n normals[point]) // n)\n\n - diffusion_coefficient * // - nu\n (fe_iv.average_gradient(i, point) * // (grad v_h .\n normals[point]) * // n)\n fe_iv.jump(j, point) // [u_h]\n\n + diffusion_coefficient * penalty * // + nu sigma\n fe_iv.jump(i, point) * // [v_h]\n fe_iv.jump(j, point) // [u_h]\n\n ) *\n JxW[point]; // dx\n }\n };\n\n // The following lambda function will then copy data into the\n // global matrix and right-hand side. Though there are no hanging\n // node constraints in DG discretization, we define an empty\n // AffineConstraints object that allows us to use the\n // AffineConstraints::distribute_local_to_global() functionality.\n AffineConstraints constraints;\n constraints.close();\n const auto copier = [&](const auto &c) {\n constraints.distribute_local_to_global(c.cell_matrix,\n c.cell_rhs,\n c.local_dof_indices,\n system_matrix,\n system_rhs);\n\n // Copy data from interior face assembly to the global matrix.\n for (auto &cdf : c.face_data)\n {\n constraints.distribute_local_to_global(cdf.cell_matrix,\n cdf.joint_dof_indices,\n system_matrix);\n }\n };\n\n\n // With the assembly functions defined, we can now create\n // ScratchData and CopyData objects, and pass them together with\n // the lambda functions above to MeshWorker::mesh_loop(). In\n // addition, we need to specify that we want to assemble on\n // interior faces exactly once.\n const UpdateFlags cell_flags = update_values | update_gradients |\n update_quadrature_points | update_JxW_values;\n const UpdateFlags face_flags = update_values | update_gradients |\n update_quadrature_points |\n update_normal_vectors | update_JxW_values;\n\n ScratchData scratch_data(\n mapping, fe, quadrature, cell_flags, face_quadrature, face_flags);\n CopyData copy_data;\n\n MeshWorker::mesh_loop(dof_handler.begin_active(),\n dof_handler.end(),\n cell_worker,\n copier,\n scratch_data,\n copy_data,\n MeshWorker::assemble_own_cells |\n MeshWorker::assemble_boundary_faces |\n MeshWorker::assemble_own_interior_faces_once,\n boundary_worker,\n face_worker);\n }\n\n\n\n // @sect3{The solve() and output_results() function}\n // The following two functions are entirely standard and without difficulty.\n template \n void SIPGLaplace::solve()\n {\n SparseDirectUMFPACK A_direct;\n A_direct.initialize(system_matrix);\n A_direct.vmult(solution, system_rhs);\n }\n\n\n\n template \n void SIPGLaplace::output_results(const unsigned int cycle) const\n {\n const std::string filename = \"sol_Q\" + Utilities::int_to_string(degree, 1) +\n \"-\" + Utilities::int_to_string(cycle, 2) +\n \".vtu\";\n std::ofstream output(filename);\n\n DataOut data_out;\n data_out.attach_dof_handler(dof_handler);\n data_out.add_data_vector(solution, \"u\", DataOut::type_dof_data);\n data_out.build_patches(mapping);\n data_out.write_vtu(output);\n }\n\n\n // @sect3{The compute_error_estimate() function}\n // The assembly of the error estimator here is quite similar to\n // that of the global matrix and right-had side and can be handled\n // by the MeshWorker::mesh_loop() framework. To understand what\n // each of the local (lambda) functions is doing, recall first that\n // the local cell residual is defined as\n // $h_K^2 \\left\\| f + \\nu \\Delta u_h \\right\\|_K^2$:\n template \n void SIPGLaplace::compute_error_estimate()\n {\n const auto cell_worker =\n [&](const auto &cell, auto &scratch_data, auto ©_data) {\n const FEValues &fe_v = scratch_data.reinit(cell);\n\n copy_data.cell_index = cell->active_cell_index();\n\n const auto & q_points = fe_v.get_quadrature_points();\n const unsigned int n_q_points = q_points.size();\n const std::vector &JxW = fe_v.get_JxW_values();\n\n std::vector> hessians(n_q_points);\n fe_v.get_function_hessians(solution, hessians);\n\n std::vector rhs(n_q_points);\n rhs_function->value_list(q_points, rhs);\n\n const double hk = cell->diameter();\n double residual_norm_square = 0;\n\n for (unsigned int point = 0; point < n_q_points; ++point)\n {\n const double residual =\n rhs[point] + diffusion_coefficient * trace(hessians[point]);\n residual_norm_square += residual * residual * JxW[point];\n }\n copy_data.value = hk * hk * residual_norm_square;\n };\n\n // Next compute boundary terms $\\sum_{f\\in \\partial K \\cap \\partial \\Omega}\n // \\sigma \\left\\| [ u_h-g_D ] \\right\\|_f^2 $:\n const auto boundary_worker = [&](const auto & cell,\n const unsigned int &face_no,\n auto & scratch_data,\n auto & copy_data) {\n const FEFaceValuesBase &fe_fv = scratch_data.reinit(cell, face_no);\n\n const auto & q_points = fe_fv.get_quadrature_points();\n const unsigned n_q_points = q_points.size();\n\n const std::vector &JxW = fe_fv.get_JxW_values();\n\n std::vector g(n_q_points);\n exact_solution->value_list(q_points, g);\n\n std::vector sol_u(n_q_points);\n fe_fv.get_function_values(solution, sol_u);\n\n const double extent1 = cell->measure() / cell->face(face_no)->measure();\n const double penalty = get_penalty_factor(degree, extent1, extent1);\n\n double difference_norm_square = 0.;\n for (unsigned int point = 0; point < q_points.size(); ++point)\n {\n const double diff = (g[point] - sol_u[point]);\n difference_norm_square += diff * diff * JxW[point];\n }\n copy_data.value += penalty * difference_norm_square;\n };\n\n // And finally interior face terms $\\sum_{f\\in \\partial K}\\lbrace \\sigma\n // \\left\\| [u_h] \\right\\|_f^2 + h_f \\left\\| [\\nu \\nabla u_h \\cdot\n // \\mathbf n ] \\right\\|_f^2 \\rbrace$:\n const auto face_worker = [&](const auto & cell,\n const unsigned int &f,\n const unsigned int &sf,\n const auto & ncell,\n const unsigned int &nf,\n const unsigned int &nsf,\n auto & scratch_data,\n auto & copy_data) {\n const FEInterfaceValues &fe_iv =\n scratch_data.reinit(cell, f, sf, ncell, nf, nsf);\n\n copy_data.face_data.emplace_back();\n CopyDataFace ©_data_face = copy_data.face_data.back();\n\n copy_data_face.cell_indices[0] = cell->active_cell_index();\n copy_data_face.cell_indices[1] = ncell->active_cell_index();\n\n const std::vector & JxW = fe_iv.get_JxW_values();\n const std::vector> &normals = fe_iv.get_normal_vectors();\n\n const auto & q_points = fe_iv.get_quadrature_points();\n const unsigned int n_q_points = q_points.size();\n\n std::vector jump(n_q_points);\n get_function_jump(fe_iv, solution, jump);\n\n std::vector> grad_jump(n_q_points);\n get_function_gradient_jump(fe_iv, solution, grad_jump);\n\n const double h = cell->face(f)->diameter();\n\n const double extent1 = cell->measure() / cell->face(f)->measure();\n const double extent2 = ncell->measure() / ncell->face(nf)->measure();\n const double penalty = get_penalty_factor(degree, extent1, extent2);\n\n double flux_jump_square = 0;\n double u_jump_square = 0;\n for (unsigned int point = 0; point < n_q_points; ++point)\n {\n u_jump_square += jump[point] * jump[point] * JxW[point];\n const double flux_jump = grad_jump[point] * normals[point];\n flux_jump_square +=\n diffusion_coefficient * flux_jump * flux_jump * JxW[point];\n }\n copy_data_face.values[0] =\n 0.5 * h * (flux_jump_square + penalty * u_jump_square);\n copy_data_face.values[1] = copy_data_face.values[0];\n };\n\n // Having computed local contributions for each cell, we still\n // need a way to copy these into the global vector that will hold\n // the error estimators for all cells:\n const auto copier = [&](const auto ©_data) {\n if (copy_data.cell_index != numbers::invalid_unsigned_int)\n estimated_error_square_per_cell[copy_data.cell_index] +=\n copy_data.value;\n for (auto &cdf : copy_data.face_data)\n for (unsigned int j = 0; j < 2; ++j)\n estimated_error_square_per_cell[cdf.cell_indices[j]] += cdf.values[j];\n };\n\n // After all of this set-up, let's do the actual work: We resize\n // the vector into which the results will be written, and then\n // drive the whole process using the MeshWorker::mesh_loop()\n // function.\n estimated_error_square_per_cell.reinit(triangulation.n_active_cells());\n\n const UpdateFlags cell_flags =\n update_hessians | update_quadrature_points | update_JxW_values;\n const UpdateFlags face_flags = update_values | update_gradients |\n update_quadrature_points |\n update_JxW_values | update_normal_vectors;\n\n ScratchData scratch_data(\n mapping, fe, quadrature, cell_flags, face_quadrature, face_flags);\n\n CopyData copy_data;\n MeshWorker::mesh_loop(dof_handler.begin_active(),\n dof_handler.end(),\n cell_worker,\n copier,\n scratch_data,\n copy_data,\n MeshWorker::assemble_own_cells |\n MeshWorker::assemble_own_interior_faces_once |\n MeshWorker::assemble_boundary_faces,\n boundary_worker,\n face_worker);\n }\n\n // @sect3{The compute_energy_norm_error() function}\n // Next, we evaluate the accuracy in terms of the energy norm.\n // This function is similar to the assembling of the error estimator above.\n // Here we compute the square of the energy norm defined by\n // @f[\n // \\|u \\|_{1,h}^2 = \\sum_{K \\in \\Gamma_h} \\nu\\|\\nabla u \\|_K^2 +\n // \\sum_{f \\in F_i} \\sigma \\| [ u ] \\|_f^2 +\n // \\sum_{f \\in F_b} \\sigma \\|u\\|_f^2.\n // @f]\n // Therefore the corresponding error is\n // @f[\n // \\|u -u_h \\|_{1,h}^2 = \\sum_{K \\in \\Gamma_h} \\nu\\|\\nabla (u_h - u) \\|_K^2\n // + \\sum_{f \\in F_i} \\sigma \\|[ u_h ] \\|_f^2 + \\sum_{f \\in F_b}\\sigma\n // \\|u_h-g_D\\|_f^2.\n // @f]\n template \n double SIPGLaplace::compute_energy_norm_error()\n {\n energy_norm_square_per_cell.reinit(triangulation.n_active_cells());\n\n // Assemble $\\sum_{K \\in \\Gamma_h} \\nu\\|\\nabla (u_h - u) \\|_K^2 $.\n const auto cell_worker =\n [&](const auto &cell, auto &scratch_data, auto ©_data) {\n const FEValues &fe_v = scratch_data.reinit(cell);\n\n copy_data.cell_index = cell->active_cell_index();\n\n const auto & q_points = fe_v.get_quadrature_points();\n const unsigned int n_q_points = q_points.size();\n const std::vector &JxW = fe_v.get_JxW_values();\n\n std::vector> grad_u(n_q_points);\n fe_v.get_function_gradients(solution, grad_u);\n\n std::vector> grad_exact(n_q_points);\n exact_solution->gradient_list(q_points, grad_exact);\n\n double norm_square = 0;\n for (unsigned int point = 0; point < n_q_points; ++point)\n {\n norm_square +=\n (grad_u[point] - grad_exact[point]).norm_square() * JxW[point];\n }\n copy_data.value = diffusion_coefficient * norm_square;\n };\n\n // Assemble $\\sum_{f \\in F_b}\\sigma \\|u_h-g_D\\|_f^2$.\n const auto boundary_worker = [&](const auto & cell,\n const unsigned int &face_no,\n auto & scratch_data,\n auto & copy_data) {\n const FEFaceValuesBase &fe_fv = scratch_data.reinit(cell, face_no);\n\n const auto & q_points = fe_fv.get_quadrature_points();\n const unsigned n_q_points = q_points.size();\n\n const std::vector &JxW = fe_fv.get_JxW_values();\n\n std::vector g(n_q_points);\n exact_solution->value_list(q_points, g);\n\n std::vector sol_u(n_q_points);\n fe_fv.get_function_values(solution, sol_u);\n\n const double extent1 = cell->measure() / cell->face(face_no)->measure();\n const double penalty = get_penalty_factor(degree, extent1, extent1);\n\n double difference_norm_square = 0.;\n for (unsigned int point = 0; point < q_points.size(); ++point)\n {\n const double diff = (g[point] - sol_u[point]);\n difference_norm_square += diff * diff * JxW[point];\n }\n copy_data.value += penalty * difference_norm_square;\n };\n\n // Assemble $\\sum_{f \\in F_i} \\sigma \\| [ u_h ] \\|_f^2$.\n const auto face_worker = [&](const auto & cell,\n const unsigned int &f,\n const unsigned int &sf,\n const auto & ncell,\n const unsigned int &nf,\n const unsigned int &nsf,\n auto & scratch_data,\n auto & copy_data) {\n const FEInterfaceValues &fe_iv =\n scratch_data.reinit(cell, f, sf, ncell, nf, nsf);\n\n copy_data.face_data.emplace_back();\n CopyDataFace ©_data_face = copy_data.face_data.back();\n\n copy_data_face.cell_indices[0] = cell->active_cell_index();\n copy_data_face.cell_indices[1] = ncell->active_cell_index();\n\n const std::vector &JxW = fe_iv.get_JxW_values();\n\n const auto & q_points = fe_iv.get_quadrature_points();\n const unsigned int n_q_points = q_points.size();\n\n std::vector jump(n_q_points);\n get_function_jump(fe_iv, solution, jump);\n\n const double extent1 = cell->measure() / cell->face(f)->measure();\n const double extent2 = ncell->measure() / ncell->face(nf)->measure();\n const double penalty = get_penalty_factor(degree, extent1, extent2);\n\n double u_jump_square = 0;\n for (unsigned int point = 0; point < n_q_points; ++point)\n {\n u_jump_square += jump[point] * jump[point] * JxW[point];\n }\n copy_data_face.values[0] = 0.5 * penalty * u_jump_square;\n copy_data_face.values[1] = copy_data_face.values[0];\n };\n\n const auto copier = [&](const auto ©_data) {\n if (copy_data.cell_index != numbers::invalid_unsigned_int)\n energy_norm_square_per_cell[copy_data.cell_index] += copy_data.value;\n for (auto &cdf : copy_data.face_data)\n for (unsigned int j = 0; j < 2; ++j)\n energy_norm_square_per_cell[cdf.cell_indices[j]] += cdf.values[j];\n };\n\n const UpdateFlags cell_flags =\n update_gradients | update_quadrature_points | update_JxW_values;\n UpdateFlags face_flags =\n update_values | update_quadrature_points | update_JxW_values;\n\n const ScratchData scratch_data(mapping,\n fe,\n quadrature_overintegration,\n cell_flags,\n face_quadrature_overintegration,\n face_flags);\n\n CopyData copy_data;\n MeshWorker::mesh_loop(dof_handler.begin_active(),\n dof_handler.end(),\n cell_worker,\n copier,\n scratch_data,\n copy_data,\n MeshWorker::assemble_own_cells |\n MeshWorker::assemble_own_interior_faces_once |\n MeshWorker::assemble_boundary_faces,\n boundary_worker,\n face_worker);\n const double energy_error =\n std::sqrt(energy_norm_square_per_cell.l1_norm());\n return energy_error;\n }\n\n\n\n // @sect3{The refine_grid() function}\n template \n void SIPGLaplace::refine_grid()\n {\n const double refinement_fraction = 0.1;\n\n GridRefinement::refine_and_coarsen_fixed_number(\n triangulation, estimated_error_square_per_cell, refinement_fraction, 0.);\n\n triangulation.execute_coarsening_and_refinement();\n }\n\n\n\n // @sect3{The compute_errors() function}\n // We compute three errors in the $L_2$ norm, $H_1$ seminorm, and\n // the energy norm, respectively. These are then printed to screen,\n // but also stored in a table that records how these errors decay\n // with mesh refinement and which can be output in one step at the\n // end of the program.\n template \n void SIPGLaplace::compute_errors()\n {\n double L2_error, H1_error, energy_error;\n\n {\n Vector difference_per_cell(triangulation.n_active_cells());\n VectorTools::integrate_difference(mapping,\n dof_handler,\n solution,\n *(exact_solution.get()),\n difference_per_cell,\n quadrature_overintegration,\n VectorTools::L2_norm);\n\n L2_error = VectorTools::compute_global_error(triangulation,\n difference_per_cell,\n VectorTools::L2_norm);\n convergence_table.add_value(\"L2\", L2_error);\n }\n\n {\n Vector difference_per_cell(triangulation.n_active_cells());\n VectorTools::integrate_difference(mapping,\n dof_handler,\n solution,\n *(exact_solution.get()),\n difference_per_cell,\n quadrature_overintegration,\n VectorTools::H1_seminorm);\n\n H1_error = VectorTools::compute_global_error(triangulation,\n difference_per_cell,\n VectorTools::H1_seminorm);\n convergence_table.add_value(\"H1\", H1_error);\n }\n\n {\n energy_error = compute_energy_norm_error();\n convergence_table.add_value(\"Energy\", energy_error);\n }\n\n std::cout << \" Error in the L2 norm : \" << L2_error << std::endl\n << \" Error in the H1 seminorm : \" << H1_error << std::endl\n << \" Error in the energy norm : \" << energy_error\n << std::endl;\n }\n\n\n\n // @sect3{The run() function}\n template \n void SIPGLaplace::run()\n {\n const unsigned int max_cycle =\n (test_case == TestCase::convergence_rate ? 6 : 20);\n for (unsigned int cycle = 0; cycle < max_cycle; ++cycle)\n {\n std::cout << \"Cycle \" << cycle << std::endl;\n\n switch (test_case)\n {\n case TestCase::convergence_rate:\n {\n if (cycle == 0)\n {\n GridGenerator::hyper_cube(triangulation);\n\n triangulation.refine_global(2);\n }\n else\n {\n triangulation.refine_global(1);\n }\n break;\n }\n\n case TestCase::l_singularity:\n {\n if (cycle == 0)\n {\n GridGenerator::hyper_L(triangulation);\n triangulation.refine_global(3);\n }\n else\n {\n refine_grid();\n }\n break;\n }\n\n default:\n {\n Assert(false, ExcNotImplemented());\n }\n }\n\n std::cout << \" Number of active cells : \"\n << triangulation.n_active_cells() << std::endl;\n setup_system();\n\n std::cout << \" Number of degrees of freedom : \" << dof_handler.n_dofs()\n << std::endl;\n\n assemble_system();\n solve();\n output_results(cycle);\n {\n convergence_table.add_value(\"cycle\", cycle);\n convergence_table.add_value(\"cells\", triangulation.n_active_cells());\n convergence_table.add_value(\"dofs\", dof_handler.n_dofs());\n }\n compute_errors();\n\n if (test_case == TestCase::l_singularity)\n {\n compute_error_estimate();\n std::cout << \" Estimated error : \"\n << std::sqrt(estimated_error_square_per_cell.l1_norm())\n << std::endl;\n\n convergence_table.add_value(\n \"Estimator\",\n std::sqrt(estimated_error_square_per_cell.l1_norm()));\n }\n std::cout << std::endl;\n }\n\n // Having run all of our computations, let us tell the convergence\n // table how to format its data and output it to screen:\n convergence_table.set_precision(\"L2\", 3);\n convergence_table.set_precision(\"H1\", 3);\n convergence_table.set_precision(\"Energy\", 3);\n\n convergence_table.set_scientific(\"L2\", true);\n convergence_table.set_scientific(\"H1\", true);\n convergence_table.set_scientific(\"Energy\", true);\n\n if (test_case == TestCase::convergence_rate)\n {\n convergence_table.evaluate_convergence_rates(\n \"L2\", ConvergenceTable::reduction_rate_log2);\n convergence_table.evaluate_convergence_rates(\n \"H1\", ConvergenceTable::reduction_rate_log2);\n }\n if (test_case == TestCase::l_singularity)\n {\n convergence_table.set_precision(\"Estimator\", 3);\n convergence_table.set_scientific(\"Estimator\", true);\n }\n\n std::cout << \"degree = \" << degree << std::endl;\n convergence_table.write_text(\n std::cout, TableHandler::TextOutputFormat::org_mode_table);\n }\n} // namespace Step74\n\n\n\n// @sect3{The main() function}\n// The following main function is similar to previous examples as\n// well, and need not be commented on.\nint main()\n{\n try\n {\n using namespace dealii;\n using namespace Step74;\n\n const TestCase test_case = TestCase::l_singularity;\n\n SIPGLaplace<2> problem(test_case);\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 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", "meta": {"hexsha": "e82c46259601ef4f221458859000bb363fbd3d6b", "size": 43455, "ext": "cc", "lang": "C++", "max_stars_repo_path": "Translator_file/examples/step-74/step-74.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-74/step-74.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-74/step-74.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": 37.7541268462, "max_line_length": 80, "alphanum_fraction": 0.5659187665, "num_tokens": 9829, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.803173791645582, "lm_q2_score": 0.6825737214979746, "lm_q1q2_score": 0.5482253239731637}} {"text": "#include \"interface.h\"\n\n#include \n\n#include \"total_unimodularity.hpp\"\n#include \"unimodularity.hpp\"\n\n#include \n\nextern \"C\"\nCMR_ERROR CMRinterfaceTU(CMR* cmr, CMR_CHRMAT* matrix, bool* pisTU, CMR_DEC** pdec, CMR_SUBMAT** psubmatrix)\n{\n assert(cmr);\n assert(matrix);\n assert(pisTU);\n assert(!psubmatrix || !*psubmatrix);\n\n tu::integer_matrix mat(matrix->numRows, matrix->numColumns, 0);\n for (size_t row = 0; row < (size_t)matrix->numRows; ++row)\n {\n size_t first = matrix->rowSlice[row];\n size_t beyond = matrix->rowSlice[row + 1];\n for (size_t i = first; i < beyond; ++i)\n {\n size_t column = matrix->entryColumns[i];\n mat(row,column) = matrix->entryValues[i];\n }\n }\n\n tu::submatrix_indices violator;\n if (psubmatrix)\n {\n *pisTU = tu::is_totally_unimodular(mat, violator);\n }\n else\n {\n *pisTU = tu::is_totally_unimodular(mat);\n }\n\n if (*pisTU && pdec)\n fprintf(stderr, \"Retrieval of decomposition is not implemented, yet.\");\n\n if (!violator.rows.empty())\n {\n CMR_CALL( CMRsubmatCreate(cmr, violator.rows.size(), violator.columns.size(), psubmatrix) );\n CMR_SUBMAT* submatrix = *psubmatrix;\n for (size_t row = 0; row < submatrix->numRows; ++row)\n submatrix->rows[row] = violator.rows[row];\n for (size_t column = 0; column < submatrix->numColumns; ++column)\n submatrix->columns[column] = violator.columns[column];\n }\n\n return CMR_OKAY;\n}\n\nCMR_ERROR CMRinterfaceKModular(CMR* cmr, CMR_CHRMAT* matrix, size_t* pk)\n{\n assert(cmr);\n assert(matrix);\n assert(pk);\n\n tu::integer_matrix mat(matrix->numRows, matrix->numColumns, 0);\n for (size_t row = 0; row < (size_t)matrix->numRows; ++row)\n {\n size_t first = matrix->rowSlice[row];\n size_t beyond = matrix->rowSlice[row + 1];\n for (size_t i = first; i < beyond; ++i)\n {\n size_t column = matrix->entryColumns[i];\n mat(row,column) = matrix->entryValues[i];\n }\n }\n\n size_t rank;\n unsigned int k;\n bool result = tu::is_k_modular(mat, rank, k);\n *pk = result ? k : 0;\n\n return CMR_OKAY;\n}\n", "meta": {"hexsha": "86e1520fcde4870519353d5ff775e54de85e0a4b", "size": 2076, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/cmr/interface.cpp", "max_stars_repo_name": "discopt/cmr", "max_stars_repo_head_hexsha": "669811a8c8cbaa12dabd2a1242f0c0ff1aea6e09", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2015-04-13T12:48:09.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-26T11:56:31.000Z", "max_issues_repo_path": "src/cmr/interface.cpp", "max_issues_repo_name": "xammy/unimodularity-test", "max_issues_repo_head_hexsha": "669811a8c8cbaa12dabd2a1242f0c0ff1aea6e09", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 11.0, "max_issues_repo_issues_event_min_datetime": "2021-08-19T09:06:05.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-27T23:18:47.000Z", "max_forks_repo_path": "src/cmr/interface.cpp", "max_forks_repo_name": "discopt/cmr", "max_forks_repo_head_hexsha": "669811a8c8cbaa12dabd2a1242f0c0ff1aea6e09", "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.6296296296, "max_line_length": 108, "alphanum_fraction": 0.6526974952, "num_tokens": 649, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.815232489352, "lm_q2_score": 0.6723316991792861, "lm_q1q2_score": 0.5481066447921894}} {"text": "#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\n#include \n\ntypedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;\ntypedef Kernel::Point_3 Point;\ntypedef std::pair Point_with_normal;\ntypedef std::vector Pwn_vector;\ntypedef CGAL::First_of_pair_property_map Point_map;\ntypedef CGAL::Second_of_pair_property_map Normal_map;\n\n// Efficient RANSAC types\ntypedef CGAL::Shape_detection::Efficient_RANSAC_traits\n Traits;\ntypedef CGAL::Shape_detection::Efficient_RANSAC Efficient_ransac;\ntypedef CGAL::Shape_detection::Plane Plane;\n\n// Point set structuring type\ntypedef CGAL::Point_set_with_structure Structure;\n\n// Advancing front types\ntypedef CGAL::Advancing_front_surface_reconstruction_vertex_base_3 LVb;\ntypedef CGAL::Advancing_front_surface_reconstruction_cell_base_3 LCb;\ntypedef CGAL::Triangulation_data_structure_3 Tds;\ntypedef CGAL::Delaunay_triangulation_3 Triangulation_3;\ntypedef Triangulation_3::Vertex_handle Vertex_handle;\n\ntypedef std::array Facet;\n\n\n// Functor to init the advancing front algorithm with indexed points\nstruct On_the_fly_pair{\n const Pwn_vector& points;\n typedef std::pair result_type;\n\n On_the_fly_pair(const Pwn_vector& points) : points(points) {}\n\n result_type\n operator()(std::size_t i) const\n {\n return result_type(points[i].first,i);\n }\n};\n\n// Specialized priority functor that favor structure coherence\ntemplate \nstruct Priority_with_structure_coherence {\n\n Structure& structure;\n double bound;\n\n Priority_with_structure_coherence(Structure& structure,\n double bound)\n : structure (structure), bound (bound)\n {}\n\n template \n double operator() (AdvancingFront& adv, Cell_handle& c,\n const int& index) const\n {\n // If perimeter > bound, return infinity so that facet is not used\n if (bound != 0)\n {\n double d = 0;\n d = sqrt(squared_distance(c->vertex((index+1)%4)->point(),\n c->vertex((index+2)%4)->point()));\n if(d>bound) return adv.infinity();\n d += sqrt(squared_distance(c->vertex((index+2)%4)->point(),\n c->vertex((index+3)%4)->point()));\n if(d>bound) return adv.infinity();\n d += sqrt(squared_distance(c->vertex((index+1)%4)->point(),\n c->vertex((index+3)%4)->point()));\n if(d>bound) return adv.infinity();\n }\n\n Facet f = {{ c->vertex ((index + 1) % 4)->info (),\n c->vertex ((index + 2) % 4)->info (),\n c->vertex ((index + 3) % 4)->info () }};\n\n // facet_coherence takes values between -1 and 3, 3 being the most\n // coherent and -1 being incoherent. Smaller weight means higher\n // priority.\n double weight = 100. * (5 - structure.facet_coherence (f));\n\n return weight * adv.smallest_radius_delaunay_sphere (c, index);\n }\n\n};\n\n// Advancing front type\ntypedef CGAL::Advancing_front_surface_reconstruction\n >\n Reconstruction;\n\n\nint main (int argc, char* argv[])\n{\n // Points with normals.\n Pwn_vector points;\n\n const char* fname = (argc>1) ? argv[1] : \"data/cube.pwn\";\n // Loading point set from a file.\n\n if (!CGAL::read_points(fname, std::back_inserter(points),\n CGAL::parameters::point_map(Point_map()).\n normal_map(Normal_map())))\n {\n std::cerr << \"Error: cannot read file\" << std::endl;\n return EXIT_FAILURE;\n }\n\n std::cerr << \"Shape detection... \";\n\n Efficient_ransac ransac;\n ransac.set_input(points);\n ransac.add_shape_factory(); // Only planes are useful for stucturing\n\n // Default RANSAC parameters\n Efficient_ransac::Parameters op;\n op.probability = 0.05;\n op.min_points = 100;\n op.epsilon = (argc>2 ? boost::lexical_cast(argv[2]) : 0.002);\n op.cluster_epsilon = (argc>3 ? boost::lexical_cast(argv[3]) : 0.02);\n op.normal_threshold = 0.7;\n\n ransac.detect(op); // Plane detection\n\n Efficient_ransac::Plane_range planes = ransac.planes();\n\n std::cerr << \"done\\nPoint set structuring... \";\n\n Pwn_vector structured_pts;\n Structure pss (points,\n planes,\n op.cluster_epsilon, // Same parameter as RANSAC\n CGAL::parameters::point_map (Point_map()).\n normal_map (Normal_map()).\n plane_map (CGAL::Shape_detection::Plane_map()).\n plane_index_map(CGAL::Shape_detection::Point_to_shape_index_map(points, planes)));\n\n\n for (std::size_t i = 0; i < pss.size(); ++ i)\n structured_pts.push_back (pss[i]);\n\n std::cerr << \"done\\nAdvancing front... \";\n\n std::vector point_indices(boost::counting_iterator(0),\n boost::counting_iterator(structured_pts.size()));\n\n Triangulation_3 dt (boost::make_transform_iterator(point_indices.begin(), On_the_fly_pair(structured_pts)),\n boost::make_transform_iterator(point_indices.end(), On_the_fly_pair(structured_pts)));\n\n\n Priority_with_structure_coherence priority (pss,\n 1000. * op.cluster_epsilon); // Avoid too large facets\n Reconstruction R(dt, priority);\n R.run ();\n\n std::cerr << \"done\\nWriting result... \";\n\n std::vector output;\n const Reconstruction::TDS_2& tds = R.triangulation_data_structure_2();\n\n for(Reconstruction::TDS_2::Face_iterator fit = tds.faces_begin(); fit != tds.faces_end(); ++fit)\n if(fit->is_on_surface())\n output.push_back (CGAL::make_array(fit->vertex(0)->vertex_3()->id(),\n fit->vertex(1)->vertex_3()->id(),\n fit->vertex(2)->vertex_3()->id()));\n\n std::ofstream f (\"out.off\");\n f << \"OFF\\n\" << structured_pts.size () << \" \" << output.size() << \" 0\\n\"; // Header\n for (std::size_t i = 0; i < structured_pts.size (); ++ i)\n f << structured_pts[i].first << std::endl;\n for (std::size_t i = 0; i < output.size (); ++ i)\n f << \"3 \"\n << output[i][0] << \" \"\n << output[i][1] << \" \"\n << output[i][2] << std::endl;\n std::cerr << \"all done\\n\" << std::endl;\n\n f.close();\n\n return 0;\n}\n", "meta": {"hexsha": "c0aedf6974b95f727851cd07ad889eb78d027a5a", "size": 7110, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Advancing_front_surface_reconstruction/examples/Advancing_front_surface_reconstruction/reconstruction_structured.cpp", "max_stars_repo_name": "yemaedahrav/cgal", "max_stars_repo_head_hexsha": "ef771049b173007f2c566375bbd85a691adcee17", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-04-08T23:06:26.000Z", "max_stars_repo_stars_event_max_datetime": "2019-04-08T23:06:26.000Z", "max_issues_repo_path": "Advancing_front_surface_reconstruction/examples/Advancing_front_surface_reconstruction/reconstruction_structured.cpp", "max_issues_repo_name": "yemaedahrav/cgal", "max_issues_repo_head_hexsha": "ef771049b173007f2c566375bbd85a691adcee17", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-03-12T14:38:20.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-12T14:38:20.000Z", "max_forks_repo_path": "Advancing_front_surface_reconstruction/examples/Advancing_front_surface_reconstruction/reconstruction_structured.cpp", "max_forks_repo_name": "szobov/cgal", "max_forks_repo_head_hexsha": "e7b91b92b8c6949e3b62023bdd1e9f3ad8472626", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-03-05T04:18:59.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-05T04:18:59.000Z", "avg_line_length": 35.9090909091, "max_line_length": 111, "alphanum_fraction": 0.6451476793, "num_tokens": 1798, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206712569267, "lm_q2_score": 0.6076631698328916, "lm_q1q2_score": 0.5480639740337934}} {"text": "//\n// Created by Hamza El-Kebir on 6/18/21.\n//\n\n#ifndef LODESTAR_BACKWARDDIFFERENCE_HPP\n#define LODESTAR_BACKWARDDIFFERENCE_HPP\n\n#include \n\nnamespace ls {\n namespace primitives {\n template\n class BackwardDifference {\n static_assert(TSamples > 1, \"Number of samples must be greater than one.\");\n\n static_assert(TOrder > 1, \"Differentiation order must be greater than one.\");\n\n static_assert(TSamples > TOrder, \"Number of samples must be greater than order.\");\n\n static_assert(\n // First order\n (TSamples == 2 && TOrder == 1) ||\n (TSamples == 3 && TOrder == 1) ||\n (TSamples == 4 && TOrder == 1) ||\n (TSamples == 5 && TOrder == 1) ||\n (TSamples == 6 && TOrder == 1) ||\n (TSamples == 7 && TOrder == 1) ||\n // Second order\n (TSamples == 3 && TOrder == 2) ||\n (TSamples == 4 && TOrder == 2) ||\n (TSamples == 5 && TOrder == 2) ||\n (TSamples == 6 && TOrder == 2) ||\n (TSamples == 7 && TOrder == 2) ||\n // Third order\n (TSamples == 4 && TOrder == 3) ||\n (TSamples == 5 && TOrder == 3) ||\n (TSamples == 6 && TOrder == 3) ||\n (TSamples == 7 && TOrder == 3), \"Combination of samples and order is not supported.\");\n };\n\n// ------- First derivative ---------\n\n /**\n * @brief Computes the first-order backward finite difference difference given two samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType compute(const TType &xNeg1, const TType &x0)\n {\n return x0 - xNeg1;\n }\n\n public:\n static TType compute(const TType &xNeg1, const TType &x0, TScalarType h)\n {\n return compute(xNeg1, x0) / h;\n }\n\n static const int kOrder = 1;\n static const int kErrorOrder = 1;\n };\n\n /**\n * @brief Computes the first-order backward finite difference difference given three samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType compute(const TType &xNeg2, const TType &xNeg1, const TType &x0)\n {\n return (3.0 / 2.0) * x0 - 2.0 * xNeg1 + (1.0 / 2.0) * xNeg2;\n }\n\n public:\n static TType compute(const TType &xNeg2, const TType &xNeg1, const TType &x0, TScalarType h)\n {\n return compute(xNeg2, xNeg1, x0) / h;\n }\n\n static const int kOrder = 1;\n static const int kErrorOrder = 2;\n };\n\n /**\n * @brief Computes the first-order backward finite difference difference given four samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType compute(const TType &xNeg3, const TType &xNeg2, const TType &xNeg1, const TType &x0)\n {\n return (11.0 / 6.0) * x0 - 3.0 * xNeg1 + (3.0 / 2.0) * xNeg2 - (1.0 / 3.0) * xNeg3;\n }\n\n public:\n static TType\n compute(const TType &xNeg3, const TType &xNeg2, const TType &xNeg1, const TType &x0, TScalarType h)\n {\n return compute(xNeg3, xNeg2, xNeg1, x0) / h;\n }\n\n static const int kOrder = 1;\n static const int kErrorOrder = 3;\n };\n\n /**\n * @brief Computes the first-order backward finite difference difference given five samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType\n compute(const TType &xNeg4, const TType &xNeg3, const TType &xNeg2, const TType &xNeg1, const TType &x0)\n {\n return (25.0 / 12.0) * x0 - 4.0 * xNeg1 + 3.0 * xNeg2 - (4.0 / 3.0) * xNeg3 + (1.0 / 4.0) * xNeg4;\n }\n\n public:\n static TType\n compute(const TType &xNeg4, const TType &xNeg3, const TType &xNeg2, const TType &xNeg1, const TType &x0,\n TScalarType h)\n {\n return compute(xNeg4, xNeg3, xNeg2, xNeg1, x0) / h;\n }\n\n static const int kOrder = 1;\n static const int kErrorOrder = 4;\n };\n\n /**\n * @brief Computes the first-order backward finite difference difference given six samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType\n compute(const TType &xNeg5, const TType &xNeg4, const TType &xNeg3, const TType &xNeg2, const TType &xNeg1,\n const TType &x0)\n {\n return (137.0 / 60.0) * x0 - 5.0 * xNeg1 + 5.0 * xNeg2 - (10.0 / 3.0) * xNeg3 + (5.0 / 4.0) * xNeg4 -\n (1.0 / 6.0) * xNeg5;\n }\n\n public:\n static TType\n compute(const TType &xNeg5, const TType &xNeg4, const TType &xNeg3, const TType &xNeg2, const TType &xNeg1,\n const TType &x0, TScalarType h)\n {\n return compute(xNeg5, xNeg4, xNeg3, xNeg2, xNeg1, x0) / h;\n }\n\n static const int kOrder = 1;\n static const int kErrorOrder = 5;\n };\n\n /**\n * @brief Computes the first-order backward finite difference difference given seven samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType\n compute(const TType &xNeg6, const TType &xNeg5, const TType &xNeg4, const TType &xNeg3, const TType &xNeg2,\n const TType &xNeg1, const TType &x0)\n {\n return (49.0 / 20.0) * x0 - 6.0 * xNeg1 + (15.0 / 2.0) * xNeg2 - (20.0 / 3.0) * xNeg3 +\n (15.0 / 4.0) * xNeg4 - (6.0 / 5.0) * xNeg5 + (1.0 / 6.0) * xNeg6;\n }\n\n public:\n static TType\n compute(const TType &xNeg6, const TType &xNeg5, const TType &xNeg4, const TType &xNeg3, const TType &xNeg2,\n const TType &xNeg1, const TType &x0, TScalarType h)\n {\n return compute(xNeg6, xNeg5, xNeg4, xNeg3, xNeg2, xNeg1, x0) / h;\n }\n\n static const int kOrder = 1;\n static const int kErrorOrder = 6;\n };\n\n// ------- Second derivative ---------\n\n /**\n * @brief Computes the second-order backward finite difference difference given three samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType compute(const TType &xNeg2, const TType &xNeg1, const TType &x0)\n {\n return x0 - 2 * xNeg1 + xNeg2;\n }\n\n public:\n static TType compute(const TType &xNeg2, const TType &xNeg1, const TType &x0, TScalarType h)\n {\n return compute(xNeg2, xNeg1, x0) / (h * h);\n }\n\n static const int kOrder = 2;\n static const int kErrorOrder = 1;\n };\n\n /**\n * @brief Computes the second-order backward finite difference difference given four samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType compute(const TType &xNeg3, const TType &xNeg2, const TType &xNeg1, const TType &x0)\n {\n return 2 * x0 - 5 * xNeg1 + 4 * xNeg2 - 1 * xNeg3;\n }\n\n public:\n static TType\n compute(const TType &xNeg3, const TType &xNeg2, const TType &xNeg1, const TType &x0, TScalarType h)\n {\n return compute(xNeg3, xNeg2, xNeg1, x0) / (h * h);\n }\n\n static const int kOrder = 2;\n static const int kErrorOrder = 2;\n };\n\n /**\n * @brief Computes the second-order backward finite difference difference given five samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType\n compute(const TType &xNeg4, const TType &xNeg3, const TType &xNeg2, const TType &xNeg1, const TType &x0)\n {\n return (35.0 / 12.0) * x0 - (26.0 / 3.0) * xNeg1 + (19.0 / 2.0) * xNeg2 - (14.0 / 3.0) * xNeg3 +\n (11.0 / 12.0) * xNeg4;\n }\n\n public:\n static TType\n compute(const TType &xNeg4, const TType &xNeg3, const TType &xNeg2, const TType &xNeg1, const TType &x0,\n TScalarType h)\n {\n return compute(xNeg4, xNeg3, xNeg2, xNeg1, x0) / (h * h);\n }\n\n static const int kOrder = 2;\n static const int kErrorOrder = 3;\n };\n\n /**\n * @brief Computes the second-order backward finite difference difference given six samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType\n compute(const TType &xNeg5, const TType &xNeg4, const TType &xNeg3, const TType &xNeg2, const TType &xNeg1,\n const TType &x0)\n {\n return (15.0 / 4.0) * x0 - (77.0 / 6.0) * xNeg1 + (107.0 / 6.0) * xNeg2 - 13.0 * xNeg3 +\n (61.0 / 12.0) * xNeg4 - (5.0 / 6.0) * xNeg5;\n }\n\n public:\n static TType\n compute(const TType &xNeg5, const TType &xNeg4, const TType &xNeg3, const TType &xNeg2, const TType &xNeg1,\n const TType &x0, TScalarType h)\n {\n return compute(xNeg5, xNeg4, xNeg3, xNeg2, xNeg1, x0) / (h * h);\n }\n\n static const int kOrder = 2;\n static const int kErrorOrder = 4;\n };\n\n /**\n * @brief Computes the second-order backward finite difference difference given seven samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType\n compute(const TType &xNeg6, const TType &xNeg5, const TType &xNeg4, const TType &xNeg3, const TType &xNeg2,\n const TType &xNeg1, const TType &x0)\n {\n return (203.0 / 45.0) * x0 - (87.0 / 5.0) * xNeg1 + (117.0 / 4.0) * xNeg2 - (254.0 / 9.0) * xNeg3 +\n (33.0 / 2.0) * xNeg4 - (27.0 / 5.0) * xNeg5 + (137.0 / 180.0) * xNeg6;\n }\n\n public:\n static TType\n compute(const TType &xNeg6, const TType &xNeg5, const TType &xNeg4, const TType &xNeg3, const TType &xNeg2,\n const TType &xNeg1, const TType &x0, TScalarType h)\n {\n return compute(xNeg6, xNeg5, xNeg4, xNeg3, xNeg2, xNeg1, x0) / (h * h);\n }\n\n static const int kOrder = 2;\n static const int kErrorOrder = 5;\n };\n\n// ------- Third derivative ---------\n\n /**\n * @brief Computes the third-order backward finite difference difference given four samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType compute(const TType &xNeg3, const TType &xNeg2, const TType &xNeg1, const TType &x0)\n {\n return 1.0 * x0 - 3.0 * xNeg1 + 3.0 * xNeg2 - 1.0 * xNeg3;\n }\n\n public:\n static TType\n compute(const TType &xNeg3, const TType &xNeg2, const TType &xNeg1, const TType &x0, TScalarType h)\n {\n return compute(xNeg3, xNeg2, xNeg1, x0) / (h * h * h);\n }\n\n static const int kOrder = 3;\n static const int kErrorOrder = 1;\n };\n\n /**\n * @brief Computes the third-order backward finite difference difference given five samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType\n compute(const TType &xNeg4, const TType &xNeg3, const TType &xNeg2, const TType &xNeg1, const TType &x0)\n {\n return (5.0 / 2.0) * x0 - 9.0 * xNeg1 + 12.0 * xNeg2 - 7.0 * xNeg3 + (3.0 / 2.0) * xNeg4;\n }\n\n public:\n static TType\n compute(const TType &xNeg4, const TType &xNeg3, const TType &xNeg2, const TType &xNeg1, const TType &x0,\n TScalarType h)\n {\n return compute(xNeg4, xNeg3, xNeg2, xNeg1, x0) / (h * h * h);\n }\n\n static const int kOrder = 3;\n static const int kErrorOrder = 2;\n };\n\n /**\n * @brief Computes the third-order backward finite difference difference given six samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType\n compute(const TType &xNeg5, const TType &xNeg4, const TType &xNeg3, const TType &xNeg2, const TType &xNeg1,\n const TType &x0)\n {\n return (17.0 / 4.0) * x0 - (71.0 / 4.0) * xNeg1 + (59.0 / 2.0) * xNeg2 - (49.0 / 2.0) * xNeg3 +\n (41.0 / 4.0) * xNeg4 - (7.0 / 4.0) * xNeg5;\n }\n\n public:\n static TType\n compute(const TType &xNeg5, const TType &xNeg4, const TType &xNeg3, const TType &xNeg2, const TType &xNeg1,\n const TType &x0, TScalarType h)\n {\n return compute(xNeg5, xNeg4, xNeg3, xNeg2, xNeg1, x0) / (h * h * h);\n }\n\n static const int kOrder = 3;\n static const int kErrorOrder = 3;\n };\n\n /**\n * @brief Computes the third-order backward finite difference difference given seven samples.\n *\n * @tparam TType State type.\n * @tparam TScalarType Spacing type.\n */\n template\n class BackwardDifference {\n protected:\n static TType\n compute(const TType &xNeg6, const TType &xNeg5, const TType &xNeg4, const TType &xNeg3, const TType &xNeg2,\n const TType &xNeg1, const TType &x0)\n {\n return (49.0 / 8.0) * x0 - 29.0 * xNeg1 + (461.0 / 8.0) * xNeg2 - 62.0 * xNeg3 + (307.0 / 8.0) * xNeg4 -\n 13.0 * xNeg5 + (15.0 / 8.0) * xNeg6;\n }\n\n public:\n static TType\n compute(const TType &xNeg6, const TType &xNeg5, const TType &xNeg4, const TType &xNeg3, const TType &xNeg2,\n const TType &xNeg1, const TType &x0, TScalarType h)\n {\n return compute(xNeg6, xNeg5, xNeg4, xNeg3, xNeg2, xNeg1, x0) / (h * h * h);\n }\n\n static const int kOrder = 3;\n static const int kErrorOrder = 4;\n };\n\n }\n}\n\n#endif //LODESTAR_BACKWARDDIFFERENCE_HPP\n", "meta": {"hexsha": "dfa253278b140ceee4b039bb775f21e180ab314c", "size": 17273, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "Lodestar/primitives/differentiators/BackwardDifference.hpp", "max_stars_repo_name": "helkebir/Lodestar", "max_stars_repo_head_hexsha": "6b325d3e7a388676ed31d44eac1146630ee4bb2c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2020-06-05T14:08:23.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-26T22:15:31.000Z", "max_issues_repo_path": "Lodestar/primitives/differentiators/BackwardDifference.hpp", "max_issues_repo_name": "helkebir/Lodestar", "max_issues_repo_head_hexsha": "6b325d3e7a388676ed31d44eac1146630ee4bb2c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2021-06-25T15:14:01.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-01T17:43:20.000Z", "max_forks_repo_path": "Lodestar/primitives/differentiators/BackwardDifference.hpp", "max_forks_repo_name": "helkebir/Lodestar", "max_forks_repo_head_hexsha": "6b325d3e7a388676ed31d44eac1146630ee4bb2c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-06-16T03:15:23.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-16T03:15:23.000Z", "avg_line_length": 38.0462555066, "max_line_length": 120, "alphanum_fraction": 0.517628669, "num_tokens": 4846, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.865224068675884, "lm_q2_score": 0.6334102636778401, "lm_q1q2_score": 0.5480418054804054}} {"text": "#include \n#include \"linop.h\"\n#include \"utils.h\"\n#include \"math.h\"\n#include \n\nusing namespace Rcpp;\nusing namespace RcppEigen;\n\nRcppExport SEXP gls(SEXP X, SEXP S, SEXP Y, SEXP maxit, SEXP tol)\n{\n using namespace Rcpp;\n using namespace RcppEigen;\n try {\n using Eigen::Map;\n using Eigen::MatrixXd;\n using Eigen::VectorXd;\n using Rcpp::List;\n \n typedef Map MapVecd;\n typedef Map MapMatd;\n \n const int maxiter(as(maxit));\n const double toler(as(tol));\n const Eigen::Map XX(as(X));\n const Eigen::Map SS(as(S));\n const Eigen::Map YY(as(Y));\n \n const int n(XX.rows());\n const int p(XX.cols());\n \n MatrixXd SX(MatrixXd(n, p));\n //MatrixXd XSX(MatrixXd(p, p));\n \n for (int i = 0; i < p; i++) {\n SX.col(i) = conjugate_gradient(SS, XX.col(i), maxiter, toler);\n }\n \n MatrixXd XSX((XX.adjoint()) * SX);\n VectorXd XSY((SX.adjoint()) * YY);\n \n VectorXd beta = conjugate_gradient(XSX, XSY, maxiter, toler);\n \n \n return List::create(Named(\"beta\") = beta);\n } catch (std::exception &ex) {\n forward_exception_to_r(ex);\n } catch (...) {\n ::Rf_error(\"C++ exception (unknown reason)\");\n }\n return R_NilValue; //-Wall\n}\n\nRcppExport SEXP gls_half_cg(SEXP X, SEXP S, SEXP Y, SEXP maxit, SEXP tol)\n{\n using namespace Rcpp;\n using namespace RcppEigen;\n try {\n using Eigen::Map;\n using Eigen::MatrixXd;\n using Eigen::VectorXd;\n \n using Rcpp::List;\n \n typedef Map MapVecd;\n typedef Map MapMatd;\n \n const int maxiter(as(maxit));\n const double toler(as(tol));\n const Eigen::Map XX(as(X));\n const Eigen::Map SS(as(S));\n const Eigen::Map YY(as(Y));\n \n const int n(XX.rows());\n const int p(XX.cols());\n \n MatrixXd SX(MatrixXd(n, p));\n \n SX = SS.llt().solve(XX);\n \n MatrixXd XSX((XX.adjoint()) * SX);\n VectorXd XSY((SX.adjoint()) * YY);\n \n VectorXd beta = conjugate_gradient(XSX, XSY, maxiter, toler);\n \n \n return List::create(Named(\"beta\") = beta);\n } catch (std::exception &ex) {\n forward_exception_to_r(ex);\n } catch (...) {\n ::Rf_error(\"C++ exception (unknown reason)\");\n }\n return R_NilValue; //-Wall\n}\n\n\nRcppExport SEXP gls_direct(SEXP X, SEXP S, SEXP Y, SEXP maxit, SEXP tol)\n{\n using namespace Rcpp;\n using namespace RcppEigen;\n try {\n using Eigen::Map;\n using Eigen::MatrixXd;\n using Eigen::VectorXd;\n \n using Rcpp::List;\n \n typedef Map MapVecd;\n typedef Map MapMatd;\n \n const int maxiter(as(maxit));\n const double toler(as(tol));\n const Eigen::Map XX(as(X));\n const Eigen::Map SS(as(S));\n const Eigen::Map YY(as(Y));\n \n const int n(XX.rows());\n const int p(XX.cols());\n \n MatrixXd SX(MatrixXd(n, p));\n \n SX = SS.llt().solve(XX);\n \n MatrixXd XSX((XX.adjoint()) * SX);\n VectorXd XSY((SX.adjoint()) * YY);\n \n VectorXd beta = XSX.ldlt().solve(XSY);\n \n \n return List::create(Named(\"beta\") = beta);\n } catch (std::exception &ex) {\n forward_exception_to_r(ex);\n } catch (...) {\n ::Rf_error(\"C++ exception (unknown reason)\");\n }\n return R_NilValue; //-Wall\n}\n\n", "meta": {"hexsha": "f46758aa37c062f77049302ee37871d4a00955d2", "size": 3452, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/gls.cpp", "max_stars_repo_name": "jaredhuling/rfunctions", "max_stars_repo_head_hexsha": "ee118166ce4b31b871e4c1d4e7fc35518098423a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 19.0, "max_stars_repo_stars_event_min_datetime": "2015-04-07T21:52:41.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-08T01:12:53.000Z", "max_issues_repo_path": "src/gls.cpp", "max_issues_repo_name": "jaredhuling/rfunctions", "max_issues_repo_head_hexsha": "ee118166ce4b31b871e4c1d4e7fc35518098423a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2016-02-24T20:48:15.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-06T05:08:23.000Z", "max_forks_repo_path": "src/gls.cpp", "max_forks_repo_name": "jaredhuling/rfunctions", "max_forks_repo_head_hexsha": "ee118166ce4b31b871e4c1d4e7fc35518098423a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2016-04-13T06:47:30.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-07T22:20:41.000Z", "avg_line_length": 24.8345323741, "max_line_length": 73, "alphanum_fraction": 0.6089223638, "num_tokens": 998, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424528443251, "lm_q2_score": 0.6477982179521105, "lm_q1q2_score": 0.5480000134425911}} {"text": "/*\n * Filename: markers.cpp\n *\n * Copyright 2020 Tecnalia\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#include \n\n#include \n#include \n\n#include \n#include \n\n#include \n\nnamespace manipulability_metrics\n{\nvisualization_msgs::Marker ellipsoidMarker(const Eigen::Matrix& half_jacobian,\n const Eigen::Isometry3d& transform, const std::string& root,\n const std::string& ns, const std_msgs::ColorRGBA& color)\n{\n auto svd = Eigen::JacobiSVD>{ half_jacobian, Eigen::ComputeFullU };\n auto base = svd.matrixU();\n auto len = static_cast(svd.singularValues().topRows<3>());\n if (base.determinant() < 0)\n {\n base.col(1).swap(base.col(2));\n len.row(1).swap(len.row(2));\n }\n\n auto ellipsoid_marker = visualization_msgs::Marker{};\n ellipsoid_marker.type = visualization_msgs::Marker::SPHERE;\n ellipsoid_marker.header.frame_id = root;\n ellipsoid_marker.ns = ns;\n ellipsoid_marker.color = color;\n tf::pointEigenToMsg(transform.translation(), ellipsoid_marker.pose.position);\n tf::quaternionEigenToMsg(static_cast(base), ellipsoid_marker.pose.orientation);\n tf::vectorEigenToMsg(len, ellipsoid_marker.scale);\n\n return ellipsoid_marker;\n}\n\nvisualization_msgs::MarkerArray ellipsoidMarkers(const Chain& chain, const std::vector& joint_positions,\n const std::string& ns_prefix)\n{\n return ellipsoidMarkers(chain, KDL::Frame{}, joint_positions, ns_prefix);\n}\n\nvisualization_msgs::MarkerArray ellipsoidMarkers(const Chain& chain, const KDL::JntArray& joint_positions,\n const std::string& ns_prefix)\n{\n return ellipsoidMarkers(chain, KDL::Frame{}, joint_positions, ns_prefix);\n}\n\nvisualization_msgs::MarkerArray ellipsoidMarkers(const Chain& chain, const KDL::Frame& tcp,\n const std::vector& joint_positions,\n const std::string& ns_prefix)\n{\n auto jnt_array = KDL::JntArray{ static_cast(joint_positions.size()) };\n jnt_array.data =\n Eigen::Map{ joint_positions.data(), static_cast(joint_positions.size()) };\n return ellipsoidMarkers(chain, tcp, jnt_array, ns_prefix);\n}\n\nvisualization_msgs::MarkerArray ellipsoidMarkers(const Chain& chain, const KDL::Frame& tcp,\n const KDL::JntArray& joint_positions, const std::string& ns_prefix)\n{\n auto frame = KDL::Frame{};\n auto jacobian = KDL::Jacobian{ static_cast(chain.n_joints) };\n if (!chain.transform(joint_positions, tcp, frame) || !chain.jacobian(joint_positions, tcp.p, jacobian))\n {\n return {};\n }\n\n const auto transform = [&] {\n auto transform = Eigen::Isometry3d{};\n tf::transformKDLToEigen(frame, transform);\n return transform;\n }();\n\n auto marker_array = visualization_msgs::MarkerArray{};\n marker_array.markers.reserve(2);\n {\n std_msgs::ColorRGBA transparent_green;\n transparent_green.g = 1.0;\n transparent_green.a = 0.5;\n marker_array.markers.push_back(ellipsoidMarker(jacobian.data.topRows<3>(), transform, chain.root,\n ns_prefix + \"translational_ellipsoid\", transparent_green));\n }\n {\n std_msgs::ColorRGBA transparent_red;\n transparent_red.r = 1.0;\n transparent_red.a = 0.5;\n marker_array.markers.push_back(ellipsoidMarker(jacobian.data.bottomRows<3>(), transform, chain.root,\n ns_prefix + \"rotational_ellipsoid\", transparent_red));\n }\n\n return marker_array;\n}\n\nvisualization_msgs::MarkerArray desiredEllipsoidMarkers(const Ellipsoid& desired_ellipsoid, const std::string& frame_id,\n const KDL::Frame& transform)\n{\n auto pseudoU = Eigen::Matrix{};\n auto pseudoS = Eigen::Matrix{ Eigen::Matrix::Zero() };\n for (std::size_t i = 0; i < 6; ++i)\n {\n pseudoU.col(i) = desired_ellipsoid[i].unit;\n pseudoS(i, i) = desired_ellipsoid[i].len;\n }\n const auto pseudojac = pseudoU * pseudoS;\n\n const auto eigen_transform = [&] {\n auto eigen_transform = Eigen::Isometry3d{};\n tf::transformKDLToEigen(transform, eigen_transform);\n return eigen_transform;\n }();\n\n auto markers = visualization_msgs::MarkerArray{};\n markers.markers.reserve(2);\n {\n std_msgs::ColorRGBA transparent_light_green;\n transparent_light_green.r = 0.2;\n transparent_light_green.b = 0.2;\n transparent_light_green.g = 1.0;\n transparent_light_green.a = 0.5;\n\n markers.markers.push_back(ellipsoidMarker(pseudojac.topRows<3>(), eigen_transform, frame_id,\n \"desired_translational_ellipsoid\", transparent_light_green));\n }\n {\n std_msgs::ColorRGBA transparent_light_red;\n transparent_light_red.r = 1.0;\n transparent_light_red.b = 0.2;\n transparent_light_red.g = 0.2;\n transparent_light_red.a = 0.5;\n\n markers.markers.push_back(ellipsoidMarker(pseudojac.bottomRows<3>(), eigen_transform, frame_id,\n \"desired_rotational_ellipsoid\", transparent_light_red));\n }\n return markers;\n}\n\n} // namespace manipulability_metrics\n", "meta": {"hexsha": "68acc1210c9281b0382c2222fd04f0e8b99a4399", "size": 6096, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "manipulability_metrics/src/markers.cpp", "max_stars_repo_name": "tecnalia-medical-robotics/manipulability_metrics", "max_stars_repo_head_hexsha": "0e1360376a49fdc623e761fc8ca769e99fa11ac9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2021-02-15T16:15:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-12T03:01:22.000Z", "max_issues_repo_path": "manipulability_metrics/src/markers.cpp", "max_issues_repo_name": "iLoveVenki/manipulability_metrics", "max_issues_repo_head_hexsha": "0e1360376a49fdc623e761fc8ca769e99fa11ac9", "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": "manipulability_metrics/src/markers.cpp", "max_forks_repo_name": "iLoveVenki/manipulability_metrics", "max_forks_repo_head_hexsha": "0e1360376a49fdc623e761fc8ca769e99fa11ac9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2021-04-06T08:18:19.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-18T12:43:57.000Z", "avg_line_length": 38.582278481, "max_line_length": 120, "alphanum_fraction": 0.6699475066, "num_tokens": 1421, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424373085146, "lm_q2_score": 0.647798211152541, "lm_q1q2_score": 0.5479999976264763}} {"text": "/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2017 Hidekazu Ikeno\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n///\n/// \\file fast_esprit.hpp\n///\n#ifndef MXPFIT_FAST_ESPRIT_HPP\n#define MXPFIT_FAST_ESPRIT_HPP\n\n#include \n#include \n\n#include \n#include \n\n#include \n#include \n#include \n\n// #include \n// #include \n#include \n\nnamespace mxpfit\n{\n///\n/// ### FastESPRIT\n///\n/// \\brief Fast ESPRIT method for finding parameters of exponential sum\n/// approximation from sampled data on uniform grid.\n///\n/// \\tparam T Scalar type of function values.\n///\n/// #### Description\n///\n/// For a given sequence \\f$ f_{k}=f(t_{k}) \\f$ sampled on a uniform grid\n/// \\f$t_{k}=t_{0}+hk\\, (k=0,1,\\dots,N-1)\\f$ and prescribed accuracy\n/// \\f$\\epsilon\\f$, this class finds exponential sum approximation of function\n/// \\f$ f(t) \\f$ such that,\n///\n/// \\f[\n/// \\left| f_{k}-\\sum_{j=1}^{M}c_{j}e^{-a_{j} t} \\right| < \\epsilon\n/// \\f]\n///\n/// with \\f$\\mathrm{Re}(a_{j}) > 0.\\f$ The problem is solved using the fast\n/// ESPRIT algorithm via partial Lanczos bidiagonalization which has been\n/// developed by Potts and Tasche (2015). The present algorithm was slightly\n/// modified from the original one.\n///\n/// #### References\n///\n/// 1. D. Potts and M. Tasche, \"Fast ESPRIT algorithms based on partial singular\n/// value decompositions\", Appl. Numer. Math. **88** (2015) 31-45.\n/// [DOI: https://doi.org/10.1016/j.apnum.2014.10.003]\n/// 2. D. Potts and M. Tasche,\"Parameter estimation for nonincreasing\n/// exponential sums by Prony-like methods\", Linear Algebra Appl. **439**\n/// (2013) 1024-1039.\n/// [DOI: https://doi.org/10.1016/j.laa.2012.10.036]\n/// 3. K. Browne, S. Qiao, and Y. Wei, \"A Lanczos bidiagonalization algorithm\n/// for Hankel matrices\", Linear Algebra Appl. **430** (2009) 1531-1543.\n/// [DOI: https://doi.org/10.1016/j.laa.2008.01.012]\n///\ntemplate \nclass FastESPRIT\n{\npublic:\n using Scalar = T;\n using RealScalar = typename Eigen::NumTraits::Real;\n using ComplexScalar = std::complex;\n using Index = Eigen::Index;\n\n using Vector = Eigen::Matrix;\n using RealVector = Eigen::Matrix;\n using ComplexVector = Eigen::Matrix;\n\n using Matrix = Eigen::Matrix;\n using RealMatrix =\n Eigen::Matrix;\n using ComplexMatrix =\n Eigen::Matrix;\n\n using ResultType =\n typename detail::gen_prony_like_method_result::ResultType;\n\nprivate:\n using HankelGEMV = MatrixFreeGEMV>;\n using VandermondeGEMV = MatrixFreeGEMV>;\n enum\n {\n IsComplex = Eigen::NumTraits::IsComplex,\n Alignment = Eigen::internal::traits::Alignment\n };\n\n using MappedMatrix = Eigen::Map;\n\n Index m_rows;\n Index m_cols;\n Index m_max_terms;\n Index m_extra_basis = 5;\n HankelMatrix m_matH;\n PartialLanczosBidiagonalization m_plbd;\n\npublic:\n ///\n /// Default constructor\n ///\n FastESPRIT() = default;\n\n ///\n /// Constructor with memory preallocation\n ///\n /// \\param[in] N Number of sampling points\n /// \\param[in] L Window size. This is equals to the number of rows of\n /// generalized Hankel matrix.\n /// \\param[in] M Maxumum number of terms used for the exponential sum.\n /// \\pre `N >= M >= 1` and `N - L + 1 >= M >= 1`.\n ///\n FastESPRIT(Index N, Index L, Index M)\n : m_rows(L),\n m_cols(N - L + 1),\n m_max_terms(M),\n m_extra_basis(5),\n m_matH(m_rows, m_cols),\n m_plbd(m_rows, m_cols,\n std::min({m_rows, m_cols, m_max_terms + m_extra_basis}))\n {\n assert(m_rows >= M && m_cols >= M && M >= 1);\n }\n\n /// Destructor\n ~FastESPRIT()\n {\n }\n\n ///\n /// Memory reallocation\n ///\n /// \\param[in] N Number of sampling points\n /// \\param[in] L Window size. This is equals to the number of rows of\n /// generalized Hankel matrix.\n /// \\param[in] M Maxumum number of terms used for the exponential sum.\n /// \\pre `N >= L >= N / 2 >= 1` and `N - L + 1 >= M >= 1`.\n ///\n void resize(Index N, Index L, Index M)\n {\n m_rows = L;\n m_cols = N - L + 1;\n assert(m_rows >= M && m_cols >= M && M >= 1);\n m_max_terms = M;\n m_matH.resize(m_rows, m_cols);\n // Internal matrices of `m_plbd` are resized automatically during\n // computation\n }\n\n ///\n /// \\return Number of sampling points.\n ///\n Index size() const\n {\n return m_matH.size();\n }\n\n ///\n /// Fit signals by a exponential sum\n ///\n /// \\param[in] f The array of signals sampled on the equispaced grid. The\n /// first `size()` elemnets of `f` are used as a sampled data. In case\n /// `f.size() < size()` then, last `size() - f.size()` elements are\n /// padded by zeros.\n /// \\param[in] eps Small positive number `(0 < eps < 1)` that\n /// controlls the accuracy of the fit.\n /// \\param[in] x0 Argument of first sampling point\n /// \\param[in] delta Spacing between neighboring sample points.\n ///\n template \n ResultType compute(const Eigen::MatrixBase& h, RealScalar x0,\n RealScalar delta, RealScalar eps);\n};\n\ntemplate \ntemplate \ntypename FastESPRIT::ResultType\nFastESPRIT::compute(const Eigen::MatrixBase& h, RealScalar x0,\n RealScalar delta, RealScalar eps)\n{\n using Eigen::numext::sqrt;\n assert(h.size() == size() && \"Number of data points mismatch.\");\n //\n // Form rectangular Hankel matrix and pre-compute for fast multiplication to\n // the vector.\n //\n m_matH.setCoeffs(h);\n const Index nr = m_matH.rows();\n const Index nc = m_matH.cols();\n\n //-------------------------------------------------------------------------\n // Compute roots of Prony polynomials\n //-------------------------------------------------------------------------\n //\n // Partial Lanczos bidiagonalization of Hankel matrix H = P B Q^H\n //\n HankelGEMV opH(m_matH);\n m_plbd.setTolerance(eps);\n m_plbd.compute(opH, std::min({nr, nc, m_max_terms + m_extra_basis}));\n const Index nterms = m_plbd.rank();\n\n if (nterms == 0)\n {\n return ResultType();\n }\n\n // {\n // Matrix denseH = m_matH.toDenseMatrix();\n // std::cout << \"Partial LBD error: ||H - P B Q*||_F = \"\n // << (denseH - m_plbd.reconstructedMatrix()).norm()\n // << std::endl;\n // std::cout << \"(alpha):\\n\"\n // << m_plbd.diagonalAlpha().head(nterms) << \"\\n(beta):\\n\"\n // << m_plbd.superdiagonalBeta().head(nterms - 1) <<\n // std::endl;\n // }\n\n // --- Form the views of matrix Q\n // Matrix Q excluding the last row\n auto Q0 = m_plbd.matrixQ().block(0, 0, nc - 1, nterms);\n // Matrix Q excluding the first row\n auto Q1 = m_plbd.matrixQ().block(1, 0, nc - 1, nterms);\n // adjoint of the last row of matrix Q\n auto nu = m_plbd.matrixQ().block(nc - 1, 0, 1, nterms).adjoint();\n //\n // Compute the spectral matrix G = pinv(Q0) * Q1, where pinv indicate\n // the Moore-Penrose pseudo-inverse. The computation of the\n // pseudo-inverse of Q0 can be avoided.\n //\n Matrix G(Q0.adjoint() * Q1);\n Vector phi(G.adjoint() * nu);\n auto scal = RealScalar(1) / (RealScalar(1) - nu.squaredNorm());\n G += scal * nu * phi.adjoint();\n //\n // Prony roots \\f$\\{z_i\\{\\}\\f$ are the eigenvalues of matrix G.\n // The exponents for approximation are obtained as \\f$ \\log z_i \\f$\n //\n ComplexVector tmp_roots(G.eigenvalues());\n // std::cout << \"\\n*** roots\\n\" << tmp_roots << std::endl;\n //\n // Find roots on unit disk \\f$z_{i} \\in \\mathbb{D}\\f$.\n // If Scalar is a real type, neagative real roots will also be discarded.\n //\n tmp_roots =\n detail::prony_roots_on_unit_disk::compute(tmp_roots, sqrt(eps));\n\n ComplexVector roots(std::min(tmp_roots.size(), m_max_terms));\n roots = tmp_roots.head(roots.size());\n\n //----------------------------------------------------------------------\n // Solve overdetermined Vandermonde system to obtain the weights\n //----------------------------------------------------------------------\n ComplexVector weights(roots.size());\n detail::solve_overdetermined_vandermonde(\n roots, h, weights, eps, std::max(Index(100), 5 * roots.size()));\n\n // Rescale the exponents and weights, and return the result\n ResultType ret(roots.size());\n ret.exponents() = -roots.array().log() / delta;\n if (x0 == RealScalar())\n {\n ret.weights() = weights.array(); // Don't forget to copy weights\n }\n else\n {\n ret.weights() = weights.array() * (-x0 * ret.exponents()).exp();\n }\n\n return ret;\n\n // return detail::gen_prony_like_method_result::create(\n // roots.array(), weights.array(), x0, delta);\n}\n\n} // namespace mxpfit\n\n#endif /* MXPFIT_FAST_ESPRIT_HPP */\n", "meta": {"hexsha": "23f9057715849b2ee0f606c5eaf2bb939fa95765", "size": 10676, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/mxpfit/fast_esprit.hpp", "max_stars_repo_name": "hydeik/mxpfit", "max_stars_repo_head_hexsha": "a18621b191e426f549374cff0af3374861e9f065", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2018-04-25T07:07:50.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T09:13:11.000Z", "max_issues_repo_path": "include/mxpfit/fast_esprit.hpp", "max_issues_repo_name": "hydeik/mxpfit", "max_issues_repo_head_hexsha": "a18621b191e426f549374cff0af3374861e9f065", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2018-07-04T08:42:03.000Z", "max_issues_repo_issues_event_max_datetime": "2019-08-15T02:57:05.000Z", "max_forks_repo_path": "include/mxpfit/fast_esprit.hpp", "max_forks_repo_name": "hydeik/mxpfit", "max_forks_repo_head_hexsha": "a18621b191e426f549374cff0af3374861e9f065", "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": 35.1184210526, "max_line_length": 80, "alphanum_fraction": 0.6085612589, "num_tokens": 2857, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7799928900257126, "lm_q2_score": 0.7025300698514777, "lm_q1q2_score": 0.5479684595134199}} {"text": "/*\r\n * dct.cpp\r\n *\r\n * Author: M. Karnutsch (mkarnut@cosy.sbg.ac.at), C. Rathgeb (crathgeb@cosy.sbg.ac.at), P. Wild (pwild@cosy.sbg.ac.at)\r\n *\r\n * Generates an iris code from iris texture using the Monro et al. algorithm\r\n *\r\n */\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\nusing namespace std;\r\nusing namespace cv;\r\n\r\n#define pi 3.1415926535897931\r\n#define M_PI 3.14159265358979323846\r\n#define pihalf 1.57079632679489661923\r\n\r\n/*\r\n * default options\r\n */\r\n#define DCT_CUTOFF 3\r\n#define DCT_DEGREE 65\r\n#define DCT_PATCHHEIGHT 8\r\n#define DCT_PATCHWIDTH 12\r\n#define DCT_PATCHES 85\r\n#define DCT_ROWS 12\r\n#define DCT_WNDHEIGHT 2\r\n#define DCT_WNDWIDTH 1\r\n#define DCT_COEFFSIZE 3\r\n\r\nstruct b_d{\r\n unsigned char **data;\r\n unsigned char **bits;\r\n int size;\r\n struct b_d *next;\r\n};\r\n\r\nstruct allshifts_and_bits{\r\n int size;\r\n struct b_d *bitsdata;\r\n};\r\n\r\nstruct window_functions\r\n{\r\n double *window_w;\r\n double *window_h;\r\n int sizew;\r\n int sizeh;\r\n};\r\n\r\n/** no globbing in win32 mode **/\r\nint _CRT_glob = 0;\r\n\r\n/** Program modes **/\r\nstatic const int MODE_MAIN = 1, MODE_HELP = 2;\r\n\r\n/*\r\n * Print command line usage for this program\r\n */\r\nvoid printUsage() {\r\n\tprintf(\"+-----------------------------------------------------------------------------+\\n\");\r\n\tprintf(\"| dct - Iris-code generation (feature extraction) using the Monro algorithm |\\n\");\r\n\tprintf(\"| |\\n\");\r\n\tprintf(\"| Monro D. M., Rakshit S., Zhang D.: DCT-based Iris Recognition, |\\n\");\r\n\tprintf(\"| IEEE Trans Pattern Anal Mach Intell. 2007 Apr;29(4):586-95. |\\n\");\r\n\tprintf(\"| |\\n\");\r\n\tprintf(\"| MODES |\\n\");\r\n\tprintf(\"| |\\n\");\r\n printf(\"| (# 1) DCT iris code extraction from iris textures |\\n\");\r\n printf(\"| (# 2) usage |\\n\");\r\n printf(\"| |\\n\");\r\n printf(\"| ARGUMENTS |\\n\");\r\n printf(\"| |\\n\");\r\n printf(\"+------+------------+---+---+-------------------------------------------------+\\n\");\r\n printf(\"| Name | Parameters | # | ? | Description |\\n\");\r\n printf(\"+------+------------+---+---+-------------------------------------------------+\\n\");\r\n printf(\"| -i | infile | 1 | N | input iris texture (use * as wildcard, all other|\\n\");\r\n printf(\"| | | | | file parameters may refer to n-th * with ?n) |\\n\");\r\n printf(\"| -o | outfile | 1 | N | output iris code image |\\n\");\r\n printf(\"| -q | | 1 | Y | quiet mode on (off) |\\n\");\r\n printf(\"| -t | | 1 | Y | time progress on (off) |\\n\");\r\n printf(\"| -h | | 2 | N | prints usage |\\n\");\r\n printf(\"+------+------------+---+---+-------------------------------------------------+\\n\");\r\n printf(\"| |\\n\");\r\n printf(\"| EXAMPLE USAGE |\\n\");\r\n printf(\"| |\\n\");\r\n printf(\"| -i s1.tiff -o s1.png |\\n\");\r\n printf(\"| -i *.tiff -o ?1.png -q -t |\\n\");\r\n printf(\"| |\\n\");\r\n printf(\"| AUTHORS |\\n\");\r\n printf(\"| |\\n\");\r\n printf(\"| Michael Karnutsch (mkarnut@cosy.sbg.ac.at) |\\n\");\r\n printf(\"| Christian Rathgeb (crathgeb@cosy.sbg.ac.at) |\\n\");\r\n printf(\"| Peter Wild (pwild@cosy.sbg.ac.at) |\\n\");\r\n printf(\"| |\\n\");\r\n printf(\"| COPYRIGHT |\\n\");\r\n printf(\"| |\\n\");\r\n printf(\"| (C) 2012 All rights reserved. Do not distribute without written permission. |\\n\");\r\n printf(\"+-----------------------------------------------------------------------------+\\n\");\r\n}\r\n\r\n/** ------------------------------- image processing functions ------------------------------- **/\r\n\r\nunsigned char **data, **left4, **left8, **left12, **right4, **right8, **right12;\r\n\r\nstruct allshifts_and_bits *ab = NULL;\r\nstruct window_functions *window = NULL;\r\n\r\nint h;\r\nint w;\r\nint rotateDCT[3] = {4,8,12};\r\nint degree0[64] = {0};\r\nint degree10[64] = {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15};\r\nint degree17[64] = {0, 0, 0, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 11, 11, 11, 12, 12, 12, 13, 13, 14, 14, 14, 15, 15, 15, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 20, 20, 20, 21, 21, 21, 22, 22, 23, 23, 23};\r\nint degree25[64] = {0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31};\r\nint degree32[64] = {0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 10, 11, 11, 12, 12, 13, 13, 14, 15, 16, 16, 17, 17, 18, 18, 19, 20, 21, 21, 22, 22, 23, 23, 24, 25, 26, 26, 27, 27, 28, 28, 29, 30, 31, 31, 32, 32, 33, 33, 34, 35, 36, 36, 37, 37, 38, 38, 39};\r\nint degree38[64] = {0, 1, 1, 2, 3, 4, 4, 5, 6, 7, 7, 8, 9, 10, 10, 11, 12, 13, 13, 14, 15, 16, 16, 17, 18, 19, 19, 20, 21, 22, 22, 23, 24, 25, 25, 26, 27, 28, 28, 29, 30, 31, 31, 32, 33, 34, 34, 35, 36, 37, 37, 38, 39, 40, 40, 41, 42, 43, 43, 44, 45, 46, 46, 47};\r\nint degree41[64] = {0, 1, 2, 3, 3, 4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 17, 18, 19, 20, 21, 22, 23, 24, 24, 25, 26, 27, 28, 29, 30, 31, 31, 32, 33, 34, 35, 36, 37, 38, 38, 39, 40, 41, 42, 43, 44, 45, 45, 46, 47, 48, 49, 50, 51, 52, 52, 53, 54, 55};\r\nint degree45[64] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63};\r\nint degree50[64] = {0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30, 32, 33, 34, 35, 36, 37, 38, 39, 41, 42, 43, 44, 45, 46, 47, 48, 50, 51, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 66, 68, 69, 70, 71};\r\nint degree55[64] = {0, 1, 3, 4, 5, 6, 8, 9, 10, 11, 13, 14, 15, 16, 18, 19, 20, 21, 23, 24, 25, 26, 28, 29, 30, 31, 33, 34, 35, 36, 38, 39, 40, 41, 43, 44, 45, 46, 48, 49, 50, 51, 53, 54, 55, 56, 58, 59, 60, 61, 63, 64, 65, 66, 68, 69, 70, 71, 73, 74, 75, 76, 78, 79};\r\nint degree60[64] = {0, 1, 3, 5, 7, 9, 11, 12, 13, 14, 16, 18, 20, 22, 24, 25, 26, 27, 29, 31, 33, 35, 37, 38, 39, 40, 42, 44, 46, 48, 50, 51, 52, 53, 55, 57, 59, 61, 63, 64, 65, 66, 67, 69, 71, 73, 75, 77, 78, 79, 81, 83, 85, 87, 89, 90, 91, 92, 93, 95, 97, 99, 101, 102};\r\nint degree65[64] = {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126};\r\nint degree70[64] = {0, 2, 5, 7, 10, 12, 15, 17, 18, 20, 23, 25, 28, 30, 33, 35, 36, 38, 41, 43, 45, 47, 50, 52, 53, 55, 58, 60, 63, 65, 68, 70, 71, 73, 76, 78, 81, 83, 85, 87, 88, 90, 93, 95, 98, 100, 103, 105, 106, 108, 111, 113, 116, 118, 121, 123, 124, 126, 129, 131, 134, 136, 139, 141};\r\nint degree75[64] = {0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99, 102, 105, 108, 111, 114, 117, 120, 123, 126, 129, 132, 135, 138, 141, 145, 148, 151, 154, 157, 160, 163, 166, 169, 172, 175, 178, 181, 184, 187, 190};\r\n\r\nvoid setBitTo1(uchar* code, int bitpos){\r\n\tcode[bitpos / 8] |= (1 << (bitpos % 8));\r\n}\r\n\r\nvoid setBitTo0(uchar* code, int bitpos){\r\n\tcode[bitpos / 8] &= (0xff ^ 1 << (bitpos % 8));\r\n}\r\n\r\nint signum(double i)\r\n{\r\n if(i > 0.0) return 1;\r\n else return -1;\r\n}\r\n\r\ndouble *mydct(double *i, int n)\r\n{\r\n long bin,k;\r\n double *d = (double*)malloc(sizeof(double) * n);\r\n double arg;\r\n double one = sqrt((float)n);\r\n one = 1/one;\r\n double two = 2/(float)n;\r\n two = sqrt(two);\r\n for (bin = 1; bin <= n; bin++)\r\n {\r\n d[bin - 1] = 0.;\r\n for (k = 1; k <= n; k++)\r\n {\r\n arg = (2*k - 1) * (bin - 1) / (float)n;\r\n arg = arg * pihalf;\r\n d[bin - 1] += i[k - 1] * cos(arg);\r\n }\r\n if(bin == 1)\r\n {\r\n d[bin - 1] = d[bin - 1] * one;\r\n }\r\n else\r\n {\r\n d[bin - 1] = d[bin - 1] * two;\r\n }\r\n }\r\n return d;\r\n}\r\n\r\n\r\nunsigned char **truncate_image(const Mat& texture)\r\n{\r\n h = (DCT_ROWS + 1)*(DCT_PATCHHEIGHT/2);\r\n w = (DCT_PATCHES + 9)*(DCT_PATCHWIDTH/2);\r\n unsigned char **image;\r\n image = (unsigned char**)malloc( h * sizeof(unsigned char*));\r\n int front = DCT_PATCHWIDTH;\r\n int i = (DCT_CUTOFF)*(texture.cols);\r\n int diff = w - texture.cols - front;\r\n uchar* textureData = texture.data;\r\n for(int q = 0; q < h; q++)\r\n {\r\n image[q] = (unsigned char*)malloc( w * sizeof(unsigned char));\r\n }\r\n\r\n if(diff > 0)\r\n {\r\n for(int r = 0; r < h*texture.cols; r++)\r\n {\r\n image[(r/512)][(r%512) + front] = textureData[r + i];\r\n }\r\n for(int q = 0; q < h; q++)\r\n {\r\n for(int e = 0; e < diff; e++)\r\n {\r\n image[q][texture.cols + e + front] = image[q][e + front];\r\n //printf(\"(%i,%i) = %d \\n\", q, img->w + e, image[q][e]);\r\n }\r\n for(int t = 0; t < front; t++)\r\n {\r\n image[q][t] = image[q][texture.cols + t];\r\n }\r\n }\r\n }\r\n else\r\n {\r\n for(int q = 0; q < h; q++)\r\n {\r\n for(int e = 0; e < w; e++)\r\n {\r\n image[q][e] = textureData[q*texture.cols + i + e];\r\n }\r\n }\r\n }\r\n return image;\r\n}\r\n\r\n\r\nunsigned char **shift_image(unsigned char **img)\r\n{\r\n int *shiftpointer;\r\n switch(DCT_DEGREE)\r\n {\r\n case 0:\r\n shiftpointer = degree0;\r\n break;\r\n case 10:\r\n shiftpointer = degree10;\r\n break;\r\n case 17:\r\n shiftpointer = degree17;\r\n break;\r\n case 25:\r\n shiftpointer = degree25;\r\n break;\r\n case 32:\r\n shiftpointer = degree32;\r\n break;\r\n case 38:\r\n shiftpointer = degree38;\r\n break;\r\n case 41:\r\n shiftpointer = degree41;\r\n break;\r\n case 45:\r\n shiftpointer = degree45;\r\n break;\r\n case 50:\r\n shiftpointer = degree50;\r\n break;\r\n case 55:\r\n shiftpointer = degree55;\r\n break;\r\n case 60:\r\n shiftpointer = degree60;\r\n break;\r\n case 65:\r\n shiftpointer = degree65;\r\n break;\r\n case 70:\r\n shiftpointer = degree70;\r\n break;\r\n case 75:\r\n shiftpointer = degree75;\r\n break;\r\n default:\r\n shiftpointer = degree45;\r\n printf(\"degree: %i not possible, 45 used instead\\n\" , DCT_DEGREE);\r\n break;\r\n }\r\n unsigned char **shifted = (unsigned char**)malloc( h * sizeof(unsigned char*));\r\n int y = 0;\r\n while(y < h)\r\n {\r\n shifted[y] = (unsigned char*)malloc( w * sizeof(unsigned char));\r\n int i;\r\n for(i = 0; i < w; i++)\r\n {\r\n shifted[y][(i + shiftpointer[y])%w] = img[y][i];\r\n }\r\n y++;\r\n }\r\n return shifted;\r\n}\r\n\r\nvoid rotate_image()\r\n{\r\n left4 = (unsigned char**)malloc( h * sizeof(unsigned char*));\r\n left8 = (unsigned char**)malloc( h * sizeof(unsigned char*));\r\n left12 = (unsigned char**)malloc( h * sizeof(unsigned char*));\r\n right4 = (unsigned char**)malloc( h * sizeof(unsigned char*));\r\n right8 = (unsigned char**)malloc( h * sizeof(unsigned char*));\r\n right12 = (unsigned char**)malloc( h * sizeof(unsigned char*));\r\n int y = 0;\r\n while(y < h)\r\n {\r\n left4[y] = (unsigned char*)malloc( w * sizeof(unsigned char));\r\n left8[y] = (unsigned char*)malloc( w * sizeof(unsigned char));\r\n left12[y] = (unsigned char*)malloc( w * sizeof(unsigned char));\r\n right4[y] = (unsigned char*)malloc( w * sizeof(unsigned char));\r\n right8[y] = (unsigned char*)malloc( w * sizeof(unsigned char));\r\n right12[y] = (unsigned char*)malloc( w * sizeof(unsigned char));\r\n int i;\r\n for(i = 0; i < w; i++)\r\n {\r\n left4[y][i] = data[y][(i + rotateDCT[0])%w];\r\n left8[y][i] = data[y][(i + rotateDCT[1])%w];\r\n left12[y][i] = data[y][(i + rotateDCT[2])%w];\r\n right4[y][i] = data[y][(i + w - rotateDCT[0])%w];\r\n right8[y][i] = data[y][(i + w - rotateDCT[1])%w];\r\n right12[y][i] = data[y][(i + w -rotateDCT[2])%w];\r\n }\r\n y++;\r\n }\r\n ab = (allshifts_and_bits*)malloc(sizeof(struct allshifts_and_bits ));\r\n ab->size = 7;\r\n struct b_d *left12bd = (b_d*)malloc(sizeof(struct b_d));\r\n struct b_d *left8bd = (b_d*)malloc(sizeof(struct b_d));\r\n struct b_d *left4bd = (b_d*)malloc(sizeof(struct b_d));\r\n struct b_d *origbd = (b_d*)malloc(sizeof(struct b_d));\r\n struct b_d *right4bd = (b_d*)malloc(sizeof(struct b_d));\r\n struct b_d *right8bd = (b_d*)malloc(sizeof(struct b_d));\r\n struct b_d *right12bd = (b_d*)malloc(sizeof(struct b_d));\r\n origbd->data = data;\r\n origbd->next = right4bd;\r\n right4bd->data = right4;\r\n right4bd->next = right8bd;\r\n right8bd->data = right8;\r\n right8bd->next = right12bd;\r\n right12bd->data = right12;\r\n right12bd->next = left4bd;\r\n left4bd->data = left4;\r\n left4bd->next = left8bd;\r\n left8bd->data = left8;\r\n left8bd->next = left12bd;\r\n left12bd->data = left12;\r\n left12bd->next = NULL;\r\n ab->bitsdata = origbd;\r\n}\r\n\r\ndouble *compute_dct(double *patch)\r\n{\r\n double *d, *all;\r\n d= (double*)malloc(DCT_COEFFSIZE * sizeof(double));\r\n all = mydct(patch, DCT_PATCHHEIGHT);\r\n for(int i = 0; i < DCT_COEFFSIZE; i++)\r\n {\r\n d[i] = all[i];\r\n }\r\n return d;\r\n}\r\n\r\nunsigned char *generate_codes()\r\n{\r\n struct b_d *actualstruct = ab->bitsdata;\r\n unsigned char **actualdata;\r\n double actualpatch[DCT_PATCHHEIGHT];\r\n double *actualcoeff;\r\n double dctvalues[DCT_COEFFSIZE][DCT_PATCHES + 2 + 3];\r\n double diffs[DCT_COEFFSIZE][DCT_PATCHES + 1 + 3];\r\n unsigned char **bits;\r\n int howmanybits = DCT_PATCHES * DCT_ROWS;\r\n int extrabits = 0;\r\n int size = howmanybits;\r\n if(howmanybits%8 > 0)\r\n {\r\n howmanybits = howmanybits + 8 - howmanybits%8;\r\n size = howmanybits;\r\n extrabits = 1;\r\n }\r\n int r, p, ah, aw, c, d, halfpatchsizeheight = DCT_PATCHHEIGHT/2, halfpatchsizewidth = DCT_PATCHWIDTH/2;\r\n while(actualstruct)\r\n {\r\n actualstruct->size = size;\r\n\t\r\n bits = (uchar**)malloc(sizeof(unsigned char*) * DCT_COEFFSIZE);\r\n int q;\r\n for(q = 0; q < DCT_COEFFSIZE; q++)\r\n {\r\n bits[q] = (unsigned char*)malloc(sizeof(unsigned char) * size);\r\n }\r\n actualdata = actualstruct->data;\r\n for(r = 0; r < DCT_ROWS; r++)\r\n {\r\n for(p = 0; p < DCT_PATCHES + 2 + 3; p++)\r\n {\r\n for(ah = 0; ah < DCT_PATCHHEIGHT; ah++)\r\n {\r\n actualpatch[ah] = 0.0;\r\n for(aw = 0; aw < DCT_PATCHWIDTH; aw++)\r\n {\r\n actualpatch[ah] += (window->window_w[aw] * actualdata[halfpatchsizeheight*r + ah][halfpatchsizewidth*p + aw]);\r\n }\r\n actualpatch[ah] = actualpatch[ah] * window->window_h[ah];\r\n }\r\n actualcoeff = compute_dct(actualpatch);\r\n for(c = 0; c < DCT_COEFFSIZE; c++)\r\n {\r\n dctvalues[c][p] = actualcoeff[c];\r\n }\r\n }\r\n for(c = 0; c < DCT_COEFFSIZE; c++)\r\n {\r\n for(d = 0; d < DCT_PATCHES + 1 + 3; d++)\r\n {\r\n diffs[c][d] = dctvalues[c][d + 1] - dctvalues[c][d];\r\n }\r\n for(d = 0; d < DCT_PATCHES; d++)\r\n {\r\n if(signum(diffs[c][d + 3])==signum(diffs[c][d + 4]))\r\n {\r\n bits[c][r*DCT_PATCHES + d] = 0;\r\n }\r\n else\r\n {\r\n bits[c][r*DCT_PATCHES + d] = 1;\r\n }\r\n }\r\n }\r\n }\r\n if(extrabits == 1)\r\n {\r\n for(c = 0; c < DCT_COEFFSIZE; c++)\r\n {\r\n for(int e = 0; e < size - DCT_PATCHES * DCT_ROWS; e++)\r\n {\r\n int randbit = rand()%10 + 1;\r\n if(randbit > 5)\r\n {\r\n bits[c][DCT_PATCHES * DCT_ROWS + e] = 1;\r\n }\r\n else\r\n {\r\n bits[c][DCT_PATCHES * DCT_ROWS + e] = 0;\r\n }\r\n }\r\n }\r\n }\r\n actualstruct->bits = bits;\r\n actualstruct = actualstruct->next;\r\n }\r\n \r\n int idx_1,i;\r\n unsigned char *code = (unsigned char*)malloc(512*21*2 * sizeof(unsigned char));\r\n int cnt = 0;\r\n actualstruct = ab->bitsdata;\r\n while(actualstruct)\r\n {\r\n for(i = 0; i < DCT_COEFFSIZE; i++)\r\n {\r\n for (idx_1 = 0; idx_1 < actualstruct->size; idx_1++)\r\n {\r\n code[cnt*DCT_COEFFSIZE*actualstruct->size+i*actualstruct->size + idx_1] = actualstruct->bits[i][idx_1];\r\n }\r\n }\r\n cnt++;\r\n actualstruct = actualstruct->next;\r\n }\r\n return code;\r\n}\r\n\r\ndouble *hann(int size, int add)\r\n{\r\n double *hh = (double*)malloc(sizeof(double) * size + 2*add);\r\n double *r = (double*)malloc(sizeof(double) * size);\r\n for(int j = 0; j < size; j++) r[j] = 0.0;\r\n\r\n int L = size + 2*add + 2;\r\n int N = L - 1;\r\n for(int i = 1; i <= size + 2*add ; i++)\r\n {\r\n hh[i-1] = (double)0.5 * (1.0 - cos(2.0*pi*(double)(i) / (double)N));\r\n }\r\n if(add >= 0)\r\n {\r\n for(int j = 0; j < size; j++)\r\n {\r\n r[j] = 0.0;\r\n r[j] = hh[j + add];\r\n }\r\n }\r\n else\r\n {\r\n for(int i = 0; i < size; i++)\r\n {\r\n r[i] = (double)0.0;\r\n }\r\n\r\n for(int k = -add; k < size + add; k++)\r\n {\r\n r[k] = hh[k + add];\r\n }\r\n }\r\n return r;\r\n}\r\n\r\nstruct window_functions *compute_window()\r\n{\r\n struct window_functions *we = (window_functions*)malloc(sizeof(struct window_functions));\r\n we->sizeh = DCT_PATCHHEIGHT + DCT_WNDHEIGHT;\r\n we->sizew = DCT_PATCHWIDTH + DCT_WNDWIDTH;\r\n we->window_h = hann(DCT_PATCHHEIGHT , DCT_WNDHEIGHT);\r\n we->window_w = hann(DCT_PATCHWIDTH , DCT_WNDWIDTH);\r\n return we;\r\n}\r\n\r\nvoid freeall()\r\n{\r\n struct b_d *actualstruct = ab->bitsdata, *next;\r\n unsigned char **actualdata;\r\n unsigned char **actualbits;\r\n while(actualstruct)\r\n {\r\n actualdata = actualstruct->data;\r\n actualbits = actualstruct->bits;\r\n next = actualstruct->next;\r\n free(actualdata);\r\n free(actualbits);\r\n free(actualstruct);\r\n actualstruct = next;\r\n }\r\n free(ab);\r\n free(window);\r\n}\r\n\r\n/*\r\n * The Monro feature extraction algorithm\r\n *\r\n * code: Code matrix\r\n * texture: texture matrix\r\n */\r\nvoid featureExtract(Mat& code, const Mat& texture)\r\n{\r\n /*truncate to size*/\r\n unsigned char **temp;\r\n uchar* features;\r\n uchar* iris_code = code.data;\r\n \r\n //imagei = img;\r\n temp = truncate_image(texture);\r\n /*shift image by degree x*/\r\n data = shift_image(temp);\r\n /*rotates the image to the left and to the right and store in struct*/\r\n rotate_image();\r\n /*compute windowfunction*/\r\n window = compute_window();\r\n \r\n /*generates the codes for the 7 shifted images*/\r\n features = generate_codes();\r\n \r\n for (int i=0; i < texture.cols*(texture.rows/3)*2; i++)\r\n {\r\n\t\tif (features[i] == 0) setBitTo0(iris_code,i);\r\n\t\telse setBitTo1(iris_code,i);\r\n }\r\n //freeall();\r\n}\r\n\r\n/** ------------------------------- commandline functions ------------------------------- **/\r\n\r\n/**\r\n * Parses a command line\r\n * This routine should be called for parsing command lines for executables.\r\n * Note, that all options require '-' as prefix and may contain an arbitrary\r\n * number of optional arguments.\r\n *\r\n * cmd: commandline representation\r\n * argc: number of parameters\r\n * argv: string array of argument values\r\n */\r\nvoid cmdRead(map >& cmd, int argc, char *argv[]){\r\n\tfor (int i=1; i< argc; i++){\r\n\t\tchar * argument = argv[i];\r\n\t\tif (strlen(argument) > 1 && argument[0] == '-' && (argument[1] < '0' || argument[1] > '9')){\r\n\t\t\tcmd[argument]; // insert\r\n\t\t\tchar * argument2;\r\n\t\t\twhile (i + 1 < argc && (strlen(argument2 = argv[i+1]) <= 1 || argument2[0] != '-' || (argument2[1] >= '0' && argument2[1] <= '9'))){\r\n\t\t\t\tcmd[argument].push_back(argument2);\r\n\t\t\t\ti++;\r\n\t\t\t}\r\n\t\t}\r\n\t\telse {\r\n\t\t\tCV_Error(CV_StsBadArg,\"Invalid command line format\");\r\n\t\t}\r\n\t}\r\n}\r\n\r\n/**\r\n * Checks, if each command line option is valid, i.e. exists in the options array\r\n *\r\n * cmd: commandline representation\r\n * validOptions: list of valid options separated by pipe (i.e. |) character\r\n */\r\nvoid cmdCheckOpts(map >& cmd, const string validOptions){\r\n\tvector tokens;\r\n\tconst string delimiters = \"|\";\r\n\tstring::size_type lastPos = validOptions.find_first_not_of(delimiters,0); // skip delimiters at beginning\r\n\tstring::size_type pos = validOptions.find_first_of(delimiters, lastPos); // find first non-delimiter\r\n\twhile (string::npos != pos || string::npos != lastPos){\r\n\t\ttokens.push_back(validOptions.substr(lastPos,pos - lastPos)); // add found token to vector\r\n\t\tlastPos = validOptions.find_first_not_of(delimiters,pos); // skip delimiters\r\n\t\tpos = validOptions.find_first_of(delimiters,lastPos); // find next non-delimiter\r\n\t}\r\n\tsort(tokens.begin(), tokens.end());\r\n\tfor (map >::iterator it = cmd.begin(); it != cmd.end(); it++){\r\n\t\tif (!binary_search(tokens.begin(),tokens.end(),it->first)){\r\n\t\t\tCV_Error(CV_StsBadArg,\"Command line parameter '\" + it->first + \"' not allowed.\");\r\n\t\t\ttokens.clear();\r\n\t\t\treturn;\r\n\t\t}\r\n\t}\r\n\ttokens.clear();\r\n}\r\n\r\n/*\r\n * Checks, if a specific required option exists in the command line\r\n *\r\n * cmd: commandline representation\r\n * option: option name\r\n */\r\nvoid cmdCheckOptExists(map >& cmd, const string option){\r\n\tmap >::iterator it = cmd.find(option);\r\n\tif (it == cmd.end()) CV_Error(CV_StsBadArg,\"Command line parameter '\" + option + \"' is required, but does not exist.\");\r\n}\r\n\r\n/*\r\n * Checks, if a specific option has the appropriate number of parameters\r\n *\r\n * cmd: commandline representation\r\n * option: option name\r\n * size: appropriate number of parameters for the option\r\n */\r\nvoid cmdCheckOptSize(map >& cmd, const string option, const unsigned int size = 1){\r\n\tmap >::iterator it = cmd.find(option);\r\n\tif (it->second.size() != size) CV_Error(CV_StsBadArg,\"Command line parameter '\" + option + \"' has unexpected size.\");\r\n}\r\n\r\n/*\r\n * Checks, if a specific option has the appropriate number of parameters\r\n *\r\n * cmd: commandline representation\r\n * option: option name\r\n * min: minimum appropriate number of parameters for the option\r\n * max: maximum appropriate number of parameters for the option\r\n */\r\nvoid cmdCheckOptRange(map >& cmd, string option, unsigned int min = 0, unsigned int max = 1){\r\n\tmap >::iterator it = cmd.find(option);\r\n\tunsigned int size = it->second.size();\r\n\tif (size < min || size > max) CV_Error(CV_StsBadArg,\"Command line parameter '\" + option + \"' is out of range.\");\r\n}\r\n\r\n/*\r\n * Returns the list of parameters for a given option\r\n *\r\n * cmd: commandline representation\r\n * option: name of the option\r\n */\r\nvector * cmdGetOpt(map >& cmd, const string option){\r\n\tmap >::iterator it = cmd.find(option);\r\n\treturn (it != cmd.end()) ? &(it->second) : 0;\r\n}\r\n\r\n/*\r\n * Returns number of parameters in an option\r\n *\r\n * cmd: commandline representation\r\n * option: name of the option\r\n */\r\nunsigned int cmdSizePars(map >& cmd, const string option){\r\n\tmap >::iterator it = cmd.find(option);\r\n\treturn (it != cmd.end()) ? it->second.size() : 0;\r\n}\r\n\r\n/*\r\n * Returns a specific parameter type (int) given an option and parameter index\r\n *\r\n * cmd: commandline representation\r\n * option: name of option\r\n * param: name of parameter\r\n */\r\nint cmdGetParInt(map >& cmd, string option, unsigned int param = 0){\r\n\tmap >::iterator it = cmd.find(option);\r\n\tif (it != cmd.end()) {\r\n\t\tif (param < it->second.size()) {\r\n\t\t\treturn atoi(it->second[param].c_str());\r\n\t\t}\r\n\t}\r\n\treturn 0;\r\n}\r\n\r\n/*\r\n * Returns a specific parameter type (float) given an option and parameter index\r\n *\r\n * cmd: commandline representation\r\n * option: name of option\r\n * param: name of parameter\r\n */\r\nfloat cmdGetParFloat(map >& cmd, const string option, const unsigned int param = 0){\r\n\tmap >::iterator it = cmd.find(option);\r\n\tif (it != cmd.end()) {\r\n\t\tif (param < it->second.size()) {\r\n\t\t\treturn atof(it->second[param].c_str());\r\n\t\t}\r\n\t}\r\n\treturn 0;\r\n}\r\n\r\n/*\r\n * Returns a specific parameter type (string) given an option and parameter index\r\n *\r\n * cmd: commandline representation\r\n * option: name of option\r\n * param: name of parameter\r\n */\r\nstring cmdGetPar(map >& cmd, const string option, const unsigned int param = 0){\r\n\tmap >::iterator it = cmd.find(option);\r\n\tif (it != cmd.end()) {\r\n\t\tif (param < it->second.size()) {\r\n\t\t\treturn it->second[param];\r\n\t\t}\r\n\t}\r\n\treturn 0;\r\n}\r\n\r\n/** ------------------------------- timing functions ------------------------------- **/\r\n\r\n/**\r\n * Class for handling timing progress information\r\n */\r\nclass Timing{\r\npublic:\r\n\t/** integer indicating progress with respect tot total **/\r\n\tint progress;\r\n\t/** total count for progress **/\r\n\tint total;\r\n\r\n\t/*\r\n\t * Default constructor for timing initializing time.\r\n\t * Automatically calls init()\r\n\t *\r\n\t * seconds: update interval in seconds\r\n\t * eraseMode: if true, outputs sends erase characters at each print command\r\n\t */\r\n\tTiming(long seconds, bool eraseMode){\r\n\t\tupdateInterval = seconds;\r\n\t\tprogress = 1;\r\n\t\ttotal = 100;\r\n\t\teraseCount=0;\r\n\t\terase = eraseMode;\r\n\t\tinit();\r\n\t}\r\n\r\n\t/*\r\n\t * Destructor\r\n\t */\r\n\t~Timing(){}\r\n\r\n\t/*\r\n\t * Initializes timing variables\r\n\t */\r\n\tvoid init(void){\r\n\t\tstart = boost::posix_time::microsec_clock::universal_time();\r\n\t\tlastPrint = start - boost::posix_time::seconds(updateInterval);\r\n\t}\r\n\r\n\t/*\r\n\t * Clears printing (for erase option only)\r\n\t */\r\n\tvoid clear(void){\r\n\t\tstring erase(eraseCount,'\\r');\r\n\t\terase.append(eraseCount,' ');\r\n\t\terase.append(eraseCount,'\\r');\r\n\t\tprintf(\"%s\",erase.c_str());\r\n\t\teraseCount = 0;\r\n\t}\r\n\r\n\t/*\r\n\t * Updates current time and returns true, if output should be printed\r\n\t */\r\n\tbool update(void){\r\n\t\tcurrent = boost::posix_time::microsec_clock::universal_time();\r\n\t\treturn ((current - lastPrint > boost::posix_time::seconds(updateInterval)) || (progress == total));\r\n\t}\r\n\r\n\t/*\r\n\t * Prints timing object to STDOUT\r\n\t */\r\n\tvoid print(void){\r\n\t\tlastPrint = current;\r\n\t\tfloat percent = 100.f * progress / total;\r\n\t\tboost::posix_time::time_duration passed = (current - start);\r\n\t\tboost::posix_time::time_duration togo = passed * (total - progress) / max(1,progress);\r\n\t\tif (erase) {\r\n\t\t\tstring erase(eraseCount,'\\r');\r\n\t\t\tprintf(\"%s\",erase.c_str());\r\n\t\t\tint newEraseCount = (progress != total) ? printf(\"Progress ... %3.2f%% (%i/%i Total %i:%02i:%02i.%03i Remaining ca. %i:%02i:%02i.%03i)\",percent,progress,total,passed.hours(),passed.minutes(),passed.seconds(),(int)(passed.total_milliseconds()%1000),togo.hours(),togo.minutes(),togo.seconds(),(int)(togo.total_milliseconds() % 1000)) : printf(\"Progress ... %3.2f%% (%i/%i Total %i:%02i:%02i.%03d)\",percent,progress,total,passed.hours(),passed.minutes(),passed.seconds(),(int)(passed.total_milliseconds()%1000));\r\n\t\t\tif (newEraseCount < eraseCount) {\r\n\t\t\t\tstring erase(newEraseCount-eraseCount,' ');\r\n\t\t\t\terase.append(newEraseCount-eraseCount,'\\r');\r\n\t\t\t\tprintf(\"%s\",erase.c_str());\r\n\t\t\t}\r\n\t\t\teraseCount = newEraseCount;\r\n\t\t}\r\n\t\telse {\r\n\t\t\teraseCount = (progress != total) ? printf(\"Progress ... %3.2f%% (%i/%i Total %i:%02i:%02i.%03i Remaining ca. %i:%02i:%02i.%03i)\\n\",percent,progress,total,passed.hours(),passed.minutes(),passed.seconds(),(int)(passed.total_milliseconds()%1000),togo.hours(),togo.minutes(),togo.seconds(),(int)(togo.total_milliseconds() % 1000)) : printf(\"Progress ... %3.2f%% (%i/%i Total %i:%02i:%02i.%03d)\\n\",percent,progress,total,passed.hours(),passed.minutes(),passed.seconds(),(int)(passed.total_milliseconds()%1000));\r\n\t\t}\r\n\t}\r\nprivate:\r\n\tlong updateInterval;\r\n\tboost::posix_time::ptime start;\r\n\tboost::posix_time::ptime current;\r\n\tboost::posix_time::ptime lastPrint;\r\n\tint eraseCount;\r\n\tbool erase;\r\n};\r\n\r\n/** ------------------------------- file pattern matching functions ------------------------------- **/\r\n\r\n\r\n/*\r\n * Formats a given string, such that it can be used as a regular expression\r\n * I.e. escapes special characters and uses * and ? as wildcards\r\n *\r\n * pattern: regular expression path pattern\r\n * pos: substring starting index\r\n * n: substring size\r\n *\r\n * returning: escaped substring\r\n */\r\nstring patternSubstrRegex(string& pattern, size_t pos, size_t n){\r\n\tstring result;\r\n\tfor (size_t i=pos, e=pos+n; i < e; i++ ) {\r\n\t\tchar c = pattern[i];\r\n\t\tif ( c == '\\\\' || c == '.' || c == '+' || c == '[' || c == '{' || c == '|' || c == '(' || c == ')' || c == '^' || c == '$' || c == '}' || c == ']') {\r\n\t\t\tresult.append(1,'\\\\');\r\n\t\t\tresult.append(1,c);\r\n\t\t}\r\n\t\telse if (c == '*'){\r\n\t\t\tresult.append(\"([^/\\\\\\\\]*)\");\r\n\t\t}\r\n\t\telse if (c == '?'){\r\n\t\t\tresult.append(\"([^/\\\\\\\\])\");\r\n\t\t}\r\n\t\telse {\r\n\t\t\tresult.append(1,c);\r\n\t\t}\r\n\t}\r\n\treturn result;\r\n}\r\n\r\n/*\r\n * Converts a regular expression path pattern into a list of files matching with this pattern by replacing wildcards\r\n * starting in position pos assuming that all prior wildcards have been resolved yielding intermediate directory path.\r\n * I.e. this function appends the files in the specified path according to yet unresolved pattern by recursive calling.\r\n *\r\n * pattern: regular expression path pattern\r\n * files: the list to which new files can be applied\r\n * pos: an index such that positions 0...pos-1 of pattern are already considered/matched yielding path\r\n * path: the current directory (or empty)\r\n */\r\nvoid patternToFiles(string& pattern, vector& files, const size_t& pos, const string& path){\r\n\tsize_t first_unknown = pattern.find_first_of(\"*?\",pos); // find unknown * in pattern\r\n\tif (first_unknown != string::npos){\r\n\t\tsize_t last_dirpath = pattern.find_last_of(\"/\\\\\",first_unknown);\r\n\t\tsize_t next_dirpath = pattern.find_first_of(\"/\\\\\",first_unknown);\r\n\t\tif (next_dirpath != string::npos){\r\n\t\t\tboost::regex expr((last_dirpath != string::npos && last_dirpath > pos) ? patternSubstrRegex(pattern,last_dirpath+1,next_dirpath-last_dirpath-1) : patternSubstrRegex(pattern,pos,next_dirpath-pos));\r\n\t\t\tboost::filesystem::directory_iterator end_itr; // default construction yields past-the-end\r\n\t\t\ttry {\r\n\t\t\t\tfor ( boost::filesystem::directory_iterator itr( ((path.length() > 0) ? path + pattern[pos-1] : (last_dirpath != string::npos && last_dirpath > pos) ? \"\" : \"./\") + ((last_dirpath != string::npos && last_dirpath > pos) ? pattern.substr(pos,last_dirpath-pos) : \"\")); itr != end_itr; ++itr )\r\n\t\t\t\t{\r\n\t\t\t\t\tif (boost::filesystem::is_directory(itr->path())){\r\n\t\t\t\t\t\tboost::filesystem::path p = itr->path().filename();\r\n\t\t\t\t\t\tstring s = p.string();\r\n\t\t\t\t\t\tif (boost::regex_match(s.c_str(), expr)){\r\n\t\t\t\t\t\t\tpatternToFiles(pattern,files,(int)(next_dirpath+1),((path.length() > 0) ? path + pattern[pos-1] : \"\") + ((last_dirpath != string::npos && last_dirpath > pos) ? pattern.substr(pos,last_dirpath-pos) + pattern[last_dirpath] : \"\") + s);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tcatch (boost::filesystem::filesystem_error &e){}\r\n\t\t}\r\n\t\telse {\r\n\t\t\tboost::regex expr((last_dirpath != string::npos && last_dirpath > pos) ? patternSubstrRegex(pattern,last_dirpath+1,pattern.length()-last_dirpath-1) : patternSubstrRegex(pattern,pos,pattern.length()-pos));\r\n\t\t\tboost::filesystem::directory_iterator end_itr; // default construction yields past-the-end\r\n\t\t\ttry {\r\n\t\t\t\tfor ( boost::filesystem::directory_iterator itr(((path.length() > 0) ? path + pattern[pos-1] : (last_dirpath != string::npos && last_dirpath > pos) ? \"\" : \"./\") + ((last_dirpath != string::npos && last_dirpath > pos) ? pattern.substr(pos,last_dirpath-pos) : \"\")); itr != end_itr; ++itr )\r\n\t\t\t\t{\r\n\t\t\t\t\tboost::filesystem::path p = itr->path().filename();\r\n\t\t\t\t\tstring s = p.string();\r\n\t\t\t\t\tif (boost::regex_match(s.c_str(), expr)){\r\n\t\t\t\t\t\tfiles.push_back(((path.length() > 0) ? path + pattern[pos-1] : \"\") + ((last_dirpath != string::npos && last_dirpath > pos) ? pattern.substr(pos,last_dirpath-pos) + pattern[last_dirpath] : \"\") + s);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tcatch (boost::filesystem::filesystem_error &e){}\r\n\t\t}\r\n\t}\r\n\telse { // no unknown symbols\r\n\t\tboost::filesystem::path file(((path.length() > 0) ? path + \"/\" : \"\") + pattern.substr(pos,pattern.length()-pos));\r\n\t\tif (boost::filesystem::exists(file)){\r\n\t\t\tfiles.push_back(file.string());\r\n\t\t}\r\n\t}\r\n}\r\n\r\n/**\r\n * Converts a regular expression path pattern into a list of files matching with this pattern\r\n *\r\n * pattern: regular expression path pattern\r\n * files: the list to which new files can be applied\r\n */\r\nvoid patternToFiles(string& pattern, vector& files){\r\n\tpatternToFiles(pattern,files,0,\"\");\r\n}\r\n\r\n/*\r\n * Renames a given filename corresponding to the actual file pattern using a renaming pattern.\r\n * Wildcards can be referred to as ?1, ?2, ... in the order they appeared in the file pattern.\r\n *\r\n * pattern: regular expression path pattern\r\n * renamePattern: renaming pattern using ?1, ?2, ... as placeholders for wildcards\r\n * infile: path of the file (matching with pattern) to be renamed\r\n * outfile: path of the renamed file\r\n * par: used parameter (default: '?')\r\n */\r\nvoid patternFileRename(string& pattern, const string& renamePattern, const string& infile, string& outfile, const char par = '?'){\r\n\tsize_t first_unknown = renamePattern.find_first_of(par,0); // find unknown ? in renamePattern\r\n\tif (first_unknown != string::npos){\r\n\t\tstring formatOut = \"\";\r\n\t\tfor (size_t i=0, e=renamePattern.length(); i < e; i++ ) {\r\n\t\t\tchar c = renamePattern[i];\r\n\t\t\tif ( c == par && i+1 < e) {\r\n\t\t\t\tc = renamePattern[i+1];\r\n\t\t\t\tif (c > '0' && c <= '9'){\r\n\t\t\t\t\tformatOut.append(1,'$');\r\n\t\t\t\t\tformatOut.append(1,c);\r\n\t\t\t\t}\r\n\t\t\t\telse {\r\n\t\t\t\t\tformatOut.append(1,par);\r\n\t\t\t\t\tformatOut.append(1,c);\r\n\t\t\t\t}\r\n\t\t\t\ti++;\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tformatOut.append(1,c);\r\n\t\t\t}\r\n\t\t}\r\n\t\tboost::regex patternOut(patternSubstrRegex(pattern,0,pattern.length()));\r\n\t\toutfile = boost::regex_replace(infile,patternOut,formatOut,boost::match_default | boost::format_perl);\r\n\t} else {\r\n\t\toutfile = renamePattern;\r\n\t}\r\n}\r\n\r\n/** ------------------------------- Program ------------------------------- **/\r\n\r\n/*\r\n * Main program\r\n */\r\nint main(int argc, char *argv[])\r\n{\r\n\tint mode = MODE_HELP;\r\n\tmap > cmd;\r\n\ttry {\r\n\t\tcmdRead(cmd,argc,argv);\r\n \tif (cmd.size() == 0 || cmdGetOpt(cmd,\"-h\") != 0) mode = MODE_HELP;\r\n \telse mode = MODE_MAIN;\r\n \tif (mode == MODE_MAIN){\r\n\t\t\t// validate command line\r\n\t\t\tcmdCheckOpts(cmd,\"-i|-o|-q|-t\");\r\n\t\t\tcmdCheckOptExists(cmd,\"-i\");\r\n\t\t\tcmdCheckOptSize(cmd,\"-i\",1);\r\n\t\t\tstring inFiles = cmdGetPar(cmd,\"-i\");\r\n\t\t\tcmdCheckOptExists(cmd,\"-o\");\r\n\t\t\tcmdCheckOptSize(cmd,\"-o\",1);\r\n\t\t\tstring outFiles = cmdGetPar(cmd,\"-o\");\r\n\t\t\tstring imaskFiles, omaskFiles;\r\n\t\t\tbool quiet = false;\r\n\t\t\tif (cmdGetOpt(cmd,\"-q\") != 0){\r\n\t\t\t\tcmdCheckOptSize(cmd,\"-q\",0);\r\n\t\t\t\tquiet = true;\r\n\t\t\t}\r\n\t\t\tbool time = false;\r\n\t\t\tif (cmdGetOpt(cmd,\"-t\") != 0){\r\n\t\t\t\tcmdCheckOptSize(cmd,\"-t\",0);\r\n\t\t\t\ttime = true;\r\n\t\t\t}\r\n\t\t\t// starting routine\r\n\t\t\tTiming timing(1,quiet);\r\n\t\t\tvector files;\r\n\t\t\tpatternToFiles(inFiles,files);\r\n\t\t\tCV_Assert(files.size() > 0);\r\n\t\t\ttiming.total = files.size();\r\n\t\t\tfor (vector::iterator inFile = files.begin(); inFile != files.end(); ++inFile, timing.progress++){\r\n\t\t\t\tif (!quiet) printf(\"Loading texture '%s' ...\\n\", (*inFile).c_str());;\r\n\t\t\t\tMat img = imread(*inFile, CV_LOAD_IMAGE_GRAYSCALE);\r\n\t\t\t\tCV_Assert(img.data != 0);\r\n\t\t\t\tMat out;\r\n\t\t\t\tint w = img.cols;\r\n\t\t\t\tint h = (img.rows/DCT_COEFFSIZE)*2;\r\n\t\t\t\tif (!quiet) printf(\"Creating %d x %d iris-code ...\\n\", w, h);\r\n\t\t\t\tMat code (1,(w*h)/8,CV_8UC1);\r\n\t\t\t\tcode.setTo(0);\r\n\t\t\t\tfeatureExtract(code, img);\r\n\t\t\t\tout = code;\r\n\t\t\t\tstring outfile;\r\n\t\t\t\tpatternFileRename(inFiles,outFiles,*inFile,outfile);\r\n\t\t\t\tif (!quiet) printf(\"Storing code '%s' ...\\n\", outfile.c_str());\r\n\t\t\t\tif (!imwrite(outfile,out)) CV_Error(CV_StsError,\"Could not save image '\" + outfile + \"'\");\r\n\t\t\t\tif (time && timing.update()) timing.print();\r\n\t\t\t}\r\n\t\t\tif (time && quiet) timing.clear();\r\n \t}\r\n \telse if (mode == MODE_HELP){\r\n\t\t\t// validate command line\r\n\t\t\tcmdCheckOpts(cmd,\"-h\");\r\n\t\t\tif (cmdGetOpt(cmd,\"-h\") != 0) cmdCheckOptSize(cmd,\"-h\",0);\r\n\t\t\t// starting routine\r\n\t\t\tprintUsage();\r\n \t}\r\n }\r\n\tcatch (...){\r\n\t \tprintf(\"Exit with errors.\\n\");\r\n\t \texit(EXIT_FAILURE);\r\n\t}\r\n return EXIT_SUCCESS;\r\n}\r\n", "meta": {"hexsha": "7fc25ad1da4de9c47babfaa666338479da64dbda", "size": 39378, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "TFM/USITv1.0.3/dct.cpp", "max_stars_repo_name": "jmanday/Master", "max_stars_repo_head_hexsha": "388ee71d04a3fb1f64ed4b2d1164f1b5ec45179f", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2017-03-21T17:57:22.000Z", "max_stars_repo_stars_event_max_datetime": "2017-03-21T17:57:22.000Z", "max_issues_repo_path": "TFM/USITv1.0.3/dct.cpp", "max_issues_repo_name": "jmanday/Master", "max_issues_repo_head_hexsha": "388ee71d04a3fb1f64ed4b2d1164f1b5ec45179f", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 28.0, "max_issues_repo_issues_event_min_datetime": "2016-10-16T19:42:37.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-14T21:29:48.000Z", "max_forks_repo_path": "TFM/USITv1.0.3/dct.cpp", "max_forks_repo_name": "jmanday/Master", "max_forks_repo_head_hexsha": "388ee71d04a3fb1f64ed4b2d1164f1b5ec45179f", "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": 37.7907869482, "max_line_length": 513, "alphanum_fraction": 0.5314642694, "num_tokens": 11752, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.779992900254107, "lm_q2_score": 0.7025300449389325, "lm_q1q2_score": 0.547968447267566}} {"text": "#ifndef KOOPMAN_OPERATOR_HPP\n#define KOOPMAN_OPERATOR_HPP\n\n#include \n#include \"../system.hpp\"\n#include \"basis_functions/basis_template.hpp\"\n#include \n\n\nclass KoopmanOperator : public System\n{\n\nprivate:\n arma::mat _A;\n arma::mat _G;\n arma::mat _Ktrans;\npublic:\n arma::mat _K;\n arma::mat _Kx;\n arma::mat _Ku;\n\n int _nK;\n int _nM;\n int _nX;\n int _nU;\n int _nKU;\n\n Basis* basis;\n\n KoopmanOperator(Basis* _basis) : System(_basis->_nX, _basis->_nU) {\n basis = _basis;\n _nK = basis->_nK;\n _nX = basis->_nX;\n _nU = basis->_nU;\n _nM = basis->_nM;\n _nKU = basis->_nKU;\n _A = arma::zeros(_nK, _nK);\n _G = arma::zeros(_nK, _nK);\n _K = arma::zeros(_nK, _nK);\n _Kx = 0.1*arma::ones(_nX, _nX);\n _Ku = 0.1*arma::ones(_nX, _nKU);\n\n _Ktrans = _K.t();\n }\n\n inline arma::vec f(const arma::vec& x, const arma::vec& u) {\n if (x.n_rows < _nX) {\n return _Kx * basis->fkx(x) + _Ku * basis->fku(x, u);\n } else {\n arma::vec fkx = basis->fkx(x.head_rows(_nM));\n arma::vec fku = basis->fku(x.head_rows(_nM), u);\n return _Kx * fkx + _Ku * fku;\n }\n }\n\n\n inline arma::mat fdx(const arma::vec& x, const arma::vec& u) {\n return _Kx;\n }\n inline arma::mat fdu(const arma::vec& x, const arma::vec& u) {\n return _Ku * basis->fkudu(x.head_rows(_nM), u);\n }\n\n void gradStep(const arma::vec& dataIn, const arma::vec& hdataIn, const arma::vec& dataOut, const arma::vec& hdataOut) {\n\n arma::vec phix = basis->fk(dataIn, hdataIn);\n arma::vec phixpo = basis->fk(dataOut, hdataOut);\n\n _G += phix * phix.t();\n _A += phix * phixpo.t();\n\n try {\n _K = arma::pinv(_G) * _A;\n _Ktrans = _K.t();\n _Kx = _Ktrans.submat(0, 0, _nX-1, _nX-1);\n _Ku = _Ktrans.submat(0, _nX, _nX-1, _nX + _nKU - 1);\n } catch (std::runtime_error& e) {\n std::cout << \"CAUGHT ERROR\" << std::endl;\n }\n\n }\n\n void computeOperator() {\n try {\n _K = arma::pinv(_G) * _A;\n _Ktrans = _K.t();\n _Kx = _Ktrans.submat(0, 0, _nX-1, _nX-1);\n _Ku = _Ktrans.submat(0, _nX, _nX-1, _nX + _nKU - 1);\n } catch (std::runtime_error& e) {\n std::cout << \"CAUGHT ERROR\" << std::endl;\n }\n }\n\n void saveOperator(std::string filePath) {\n _Ktrans.save(filePath + \".csv\", arma::raw_ascii);\n _Ktrans.save(filePath + \".bin\");\n }\n\n void loadOperator(std::string filePath) {\n _Ktrans.load(filePath);\n _K = _Ktrans.t();\n _Kx = _Ktrans.submat(0, 0 ,_nX-1, _nX-1);\n _Ku = _Ktrans.submat(0, _nX, _nX-1, _nX + _nKU-1);\n std::cout << \"Loaded Koopman Operator.\" << std::endl;\n }\n\n void showOperator() {\n std::cout << _K.t() << std::endl;\n }\n};\n\n\n#endif\n", "meta": {"hexsha": "abc64865c30cc1ab8f4a901406b87f219de31dfa", "size": 2979, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/model_based_shared_control/src/robotlib/dynamicalSystems/koopman/koopman_operator.hpp", "max_stars_repo_name": "argallab/model_based_shared_control", "max_stars_repo_head_hexsha": "ff42226b6345266f35a32021c7d0b44cc5948ec1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2019-05-08T19:47:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T06:43:31.000Z", "max_issues_repo_path": "src/model_based_shared_control/src/robotlib/dynamicalSystems/koopman/koopman_operator.hpp", "max_issues_repo_name": "argallab/model_based_shared_control", "max_issues_repo_head_hexsha": "ff42226b6345266f35a32021c7d0b44cc5948ec1", "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/model_based_shared_control/src/robotlib/dynamicalSystems/koopman/koopman_operator.hpp", "max_forks_repo_name": "argallab/model_based_shared_control", "max_forks_repo_head_hexsha": "ff42226b6345266f35a32021c7d0b44cc5948ec1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2019-05-08T19:47:12.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-07T10:10:17.000Z", "avg_line_length": 26.1315789474, "max_line_length": 123, "alphanum_fraction": 0.5280295401, "num_tokens": 1044, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513786759491, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.5479519364625052}} {"text": "#include \n#include \n#include \nusing Eigen::Matrix;\n\nfloat dt;\nfloat vicon_R;\nfloat accelerometer_R;\nfloat sigma_J;\nfloat sigma_bAcc;\n\nMatrix x_est;\nMatrix p_est;\nMatrix x_prd;\nMatrix p_prd;\nMatrix Q; \nMatrix R_vicon;\nMatrix R_acc;\nMatrix A;\nMatrix H_pos;\nMatrix H_v;\nMatrix H_acc; //Acceleration without bias\nMatrix H_accm; //Measured acceleration (bias added)\nMatrix S;\nMatrix B;\nMatrix K;\nMatrix y;\nMatrix v;\nMatrix a;\nMatrix bAcc;\nMatrix result;\nMatrix Gammak;\nMatrix Qk;\nMatrix I_12x12;\nMatrix I_3x3;\nMatrix Zero_3x3;\n\n\nvoid kalman_init()\n{\n\n\tdt = 0.010; // 100 Hz\n sigma_J = 20; // Jerk process noise\n sigma_bAcc = 0.01; // Accelerometer bias process noise\n\tvicon_R = 0.0001; // estimated vicon standard deviation\n accelerometer_R = 0.5; // estimated accelerometer standard deviation\n I_12x12 = Matrix::Identity();\n I_3x3 = Matrix::Identity();\n Zero_3x3 = Matrix::Zero(3, 3);\n \n Gammak << I_3x3 * (pow(dt, 3)/6), Zero_3x3,\n I_3x3 * (pow(dt, 2)/2), Zero_3x3,\n I_3x3 * dt, Zero_3x3,\n Zero_3x3, I_3x3*dt;\n Qk << pow(sigma_J, 2)*I_3x3, Zero_3x3, \n Zero_3x3, pow(sigma_bAcc, 2)*I_3x3; //Process noise covariance matrix\n Q = Gammak*Qk*Gammak.transpose();\n\n\tR_vicon = pow(vicon_R, 2) * I_3x3; // Vicon measurement covariance matrix\n R_acc = pow(accelerometer_R, 2) * I_3x3; // Accelerometer measurement covariance matrix\n\n A << I_3x3, dt*I_3x3, (pow(dt,2)/2)*I_3x3, Zero_3x3,\n Zero_3x3, I_3x3, dt*I_3x3, Zero_3x3,\n Zero_3x3, Zero_3x3, I_3x3, Zero_3x3,\n Zero_3x3, Zero_3x3, Zero_3x3, I_3x3;\n\n //Initial estimate: zeros\n x_est = Matrix::Zero();\n\n //Initial covariance: we assume we don't know initial position, but velocity and \n // acceleration are close to zero. Also, we don't know the accelerometer bias\n p_est << 10*I_3x3, Zero_3x3, Zero_3x3, Zero_3x3,\n Zero_3x3, 0.0001*I_3x3, Zero_3x3, Zero_3x3,\n Zero_3x3, Zero_3x3, 0.0001*I_3x3, Zero_3x3,\n Zero_3x3, Zero_3x3, Zero_3x3, 1000*I_3x3;\n\n H_pos << I_3x3, Zero_3x3, Zero_3x3, Zero_3x3;\n H_v << Zero_3x3, I_3x3, Zero_3x3, Zero_3x3;\n H_acc << Zero_3x3, Zero_3x3, I_3x3, Zero_3x3; //Acceleration we want to determine\n H_accm << Zero_3x3, Zero_3x3, I_3x3, I_3x3; //Measured acceleration (includes bias)\n\n\n}\n\nMatrix kalman_propagate()\n{\n // Predicting state and covariance\n\n x_prd = A * x_est;\n p_prd = A * p_est * A.transpose() + Q;\n\n y = H_pos * x_prd; // Position estimate\n v = H_v * x_prd; // Velocity estimate\n a = H_acc * x_prd; // Velocity estimate\n bAcc = (H_accm - H_acc)*x_prd; //Bias estimate\n\n result << y,\n v,\n a,\n bAcc;\n\n x_est = x_prd;\n p_est = p_prd;\n\n return result;\n\n}\n\nMatrix kalman_estimate_pos(Matrix z)\n{\n\n// Estimating state and covariance\n\n S = H_pos * p_prd.transpose() * H_pos.transpose() + R_vicon;\n B = H_pos * p_prd.transpose();\n K = (S.inverse() * B).transpose();\n\n x_est = x_prd + K * (z - H_pos * x_prd);\n p_est = (I_12x12 - K * H_pos) * p_prd * (I_12x12 - K * H_pos).transpose() + K * R_vicon * K.transpose(); // Joseph form \n\n// Computing measurements\n y = H_pos * x_est; // Position estimate\n v = H_v * x_est; // Velocity estimate\n a = H_acc * x_est; // Acc estimate\n bAcc = (H_accm - H_acc)*x_prd; //Bias estimate\n\n result << y,\n v,\n a,\n bAcc;\n\n //These are necessary if the acceleration is updated\n x_prd = x_est;\n p_prd = p_est;\n\n return result;\n}\n\n\nMatrix kalman_estimate_acc(Matrix z)\n{\n\n// Estimating state and covariance\n\n S = H_accm * p_prd.transpose() * H_accm.transpose() + R_acc;\n B = H_accm * p_prd.transpose();\n K = (S.inverse() * B).transpose();\n\n x_est = x_prd + K * (z - H_accm * x_prd);\n p_est = (I_12x12 - K * H_accm) * p_prd * (I_12x12 - K * H_accm).transpose() + K * R_acc * K.transpose(); // Joseph form \n\n// Computing measurements\n y = H_pos * x_est; // Position estimate\n v = H_v * x_est; // Velocity estimate\n a = H_acc * x_est;\n bAcc = (H_accm - H_acc)*x_prd; //Bias estimate\n\n result << y,\n v,\n a,\n bAcc;\n\n // std::cout << x_est << std::endl << std::endl;\n // std::cout << p_est << std::endl << std::endl;\n\n return result;\n}\n\n\n// int main()\n// {\n\n// \tkalman_init();\n\n// \tMatrixXd z(3,1); // measurement vector\n\n// \tz << 1,\n// \t 1,\n// \t 1;\n\n// \tstd::cout << kalman(z) << std::endl;\n\n// }", "meta": {"hexsha": "ce0b7434f0b19068661bc4ba8d6b9aeafdd2e7c0", "size": 5053, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "data/AGNC-Lab_Quad/multithreaded/kalman.cpp", "max_stars_repo_name": "khairulislam/phys", "max_stars_repo_head_hexsha": "fc702520fcd3b23022b9253e7d94f878978b4500", "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": "data/AGNC-Lab_Quad/multithreaded/kalman.cpp", "max_issues_repo_name": "khairulislam/phys", "max_issues_repo_head_hexsha": "fc702520fcd3b23022b9253e7d94f878978b4500", "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": "data/AGNC-Lab_Quad/multithreaded/kalman.cpp", "max_forks_repo_name": "khairulislam/phys", "max_forks_repo_head_hexsha": "fc702520fcd3b23022b9253e7d94f878978b4500", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.6120218579, "max_line_length": 124, "alphanum_fraction": 0.6024144073, "num_tokens": 1874, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513675912912, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.5479519296855452}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nconst int debug_level = 0;\n\n#define DEBUG(min_level, x) \\\n if (debug_level >= min_level) \\\n { \\\n std::cerr << x << std::endl; \\\n }\n\ntypedef CGAL::Exact_predicates_inexact_constructions_kernel K;\ntypedef CGAL::Triangulation_vertex_base_with_info_2 TVB;\ntypedef CGAL::Triangulation_face_base_2 TFB;\ntypedef CGAL::Triangulation_data_structure_2 TriangulationDataStructure;\ntypedef CGAL::Delaunay_triangulation_2 Triangulation;\ntypedef boost::adjacency_list Graph;\n\nK::Point_2 read_point()\n{\n int x, y;\n std::cin >> x >> y;\n assert(abs(x) < (1 << 24) && abs(y) < (1 << 24));\n return K::Point_2(x, y);\n}\n\ninline Triangulation::Vertex_handle vertex_from_edge(Triangulation::Edge &edge, int i)\n{\n assert(i == 0 || i == 1);\n return edge.first->vertex((edge.second + 1 + i) % 3);\n}\n\ninline Triangulation::Vertex_handle other_vertex_from_edge(Triangulation::Edge &edge, Triangulation::Vertex_handle &v)\n{\n auto vertex_a = vertex_from_edge(edge, 0);\n auto vertex_b = vertex_from_edge(edge, 1);\n if (vertex_a == v)\n {\n return vertex_b;\n }\n else if (vertex_b == v)\n {\n return vertex_a;\n }\n assert(false);\n __builtin_unreachable();\n}\n\nstruct NetworkAnalysis\n{\n NetworkAnalysis(int n) : valid(false), component_map(n, -1){};\n\n bool valid;\n std::vector component_map;\n};\n\nNetworkAnalysis analyze_network(std::vector> radio_stations, Triangulation &all_stations_triangulation, std::function is_close_enough)\n{\n const int n = radio_stations.size();\n NetworkAnalysis network_analysis(n);\n\n std::vector all_stations_triangulation_handles(n);\n for (auto it = all_stations_triangulation.finite_vertices_begin(); it != all_stations_triangulation.finite_vertices_end(); it++)\n {\n all_stations_triangulation_handles.at(it->info()) = it;\n }\n\n std::deque> queue;\n std::vector color_by_station(n, -1);\n int next_connected_component = 0;\n for (int queue_starter = 0; queue_starter < n; queue_starter++)\n {\n if (network_analysis.component_map.at(queue_starter) >= 0)\n {\n continue;\n }\n queue.push_back(std::make_pair(queue_starter, 0));\n const int this_connected_component = next_connected_component++;\n network_analysis.component_map.at(queue_starter) = this_connected_component;\n\n while (!queue.empty())\n {\n int prev_index = queue.front().first;\n int prev_color = queue.front().second;\n queue.pop_front();\n K::Point_2 &prev_point = radio_stations.at(prev_index).first;\n\n assert(color_by_station.at(prev_index) == -1);\n color_by_station.at(prev_index) = prev_color;\n\n auto &prev_vertex = all_stations_triangulation_handles.at(prev_index);\n Triangulation::Edge_circulator c = all_stations_triangulation.incident_edges(prev_vertex);\n do\n {\n if (all_stations_triangulation.is_infinite(c))\n {\n continue;\n }\n\n auto next_vertex = other_vertex_from_edge(*c, prev_vertex);\n int next_index = next_vertex->info();\n K::Point_2 &next_point = next_vertex->point();\n int next_color = 1 - prev_color;\n\n if (network_analysis.component_map.at(next_index) == -1 && is_close_enough(CGAL::squared_distance(prev_point, next_point)))\n {\n network_analysis.component_map.at(next_index) = this_connected_component;\n queue.push_front(std::make_pair(next_index, next_color));\n }\n } while (++c != all_stations_triangulation.incident_edges(prev_vertex));\n }\n }\n\n assert(*std::min_element(network_analysis.component_map.begin(), network_analysis.component_map.end()) >= 0);\n\n std::vector> point_vectors_by_color(2);\n for (int i = 0; i < n; i++)\n {\n int color = color_by_station.at(i);\n point_vectors_by_color.at(color).push_back(radio_stations.at(i).first);\n }\n\n for (auto &points_this_color : point_vectors_by_color)\n {\n Triangulation color_triangulation;\n color_triangulation.insert(points_this_color.begin(), points_this_color.end());\n for (auto it = color_triangulation.finite_edges_begin(); it != color_triangulation.finite_edges_end(); it++)\n {\n if (is_close_enough(color_triangulation.segment(it).squared_length()))\n {\n return network_analysis;\n }\n }\n }\n\n network_analysis.valid = true;\n return network_analysis;\n}\n\nvoid testcase()\n{\n int n, m, r;\n std::cin >> n >> m >> r;\n assert(n >= 1 && n <= 9e4 && m >= 1 && m <= 9e4 && r > 0 && r < (1 << 24));\n\n const double r_squared = pow(double(r), 2);\n const auto is_close_enough = [r_squared](double sqlen) { return sqlen <= r_squared; };\n\n std::vector> radio_stations;\n for (int i = 0; i < n; i++)\n {\n radio_stations.push_back(std::make_pair(read_point(), i));\n }\n\n std::vector> clues;\n for (int i = 0; i < m; i++)\n {\n auto p1 = read_point();\n auto p2 = read_point();\n clues.push_back(std::make_pair(p1, p2));\n }\n\n Triangulation all_stations_triangulation;\n all_stations_triangulation.insert(radio_stations.begin(), radio_stations.end());\n\n NetworkAnalysis network_analysis = analyze_network(radio_stations, all_stations_triangulation, is_close_enough);\n DEBUG(2, \"network_analysis.valid \" << network_analysis.valid);\n\n const auto network_component_from_radio_set = [&is_close_enough, &all_stations_triangulation, &network_analysis](K::Point_2 &radio_set) -> int {\n auto nearest_station = all_stations_triangulation.nearest_vertex(radio_set);\n double set_station_sq_dist = CGAL::squared_distance(radio_set, nearest_station->point());\n if (!is_close_enough(set_station_sq_dist))\n {\n return -1;\n }\n return network_analysis.component_map.at(nearest_station->info());\n };\n\n std::vector can_transmit_by_clue(m, false);\n if (network_analysis.valid)\n {\n for (int i = 0; i < m; i++)\n {\n DEBUG(3, \"clue \" << i);\n auto &clue = clues.at(i);\n if (is_close_enough(CGAL::squared_distance(clue.first, clue.second)))\n {\n can_transmit_by_clue.at(i) = true;\n }\n else\n {\n int first_component = network_component_from_radio_set(clue.first);\n if (first_component >= 0 && first_component == network_component_from_radio_set(clue.second))\n {\n can_transmit_by_clue.at(i) = true;\n }\n }\n }\n }\n\n for (bool can_transmit : can_transmit_by_clue)\n {\n std::cout << (can_transmit ? \"y\" : \"n\");\n }\n std::cout << \"\\n\";\n}\n\nint main()\n{\n std::ios_base::sync_with_stdio(false);\n\n int t;\n std::cin >> t;\n for (int i = 0; i < t; i++)\n {\n testcase();\n }\n\n return 0;\n}", "meta": {"hexsha": "24fc66112695247e83473c48ceb62a5b56f9c24c", "size": 7169, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "week-08/clues/src/main.cpp", "max_stars_repo_name": "tehwalris/algolab", "max_stars_repo_head_hexsha": "489e0f6dd137336fa32b8002fc6eed8a7d35d87a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-01-17T08:21:32.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-17T08:21:32.000Z", "max_issues_repo_path": "week-08/clues/src/main.cpp", "max_issues_repo_name": "tehwalris/algolab", "max_issues_repo_head_hexsha": "489e0f6dd137336fa32b8002fc6eed8a7d35d87a", "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": "week-08/clues/src/main.cpp", "max_forks_repo_name": "tehwalris/algolab", "max_forks_repo_head_hexsha": "489e0f6dd137336fa32b8002fc6eed8a7d35d87a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.4429824561, "max_line_length": 175, "alphanum_fraction": 0.6858697168, "num_tokens": 1935, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513648201266, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.5479519279913051}} {"text": "/*\n * Array can perform coefficient-wise operations, which might not have a linear algebraic meaning.\n * Refs:\n * https://eigen.tuxfamily.org/dox/group__TutorialArrayClass.html\n * */\n\n#include \n#include \n\n#define PRINT(x) std::cout << #x << \": \" << std::endl << (x) << std::endl << std::endl\n#define PRINT_SIZE(x) std::cout << #x << \" is of size \" << x.rows() << \"x\" << x.cols() << std::endl << std::endl\n#define SECTION(x) std::cout << \"======================== \" << x << \" =======================\" << std::endl << std::endl\n\nint main() {\n\n using namespace Eigen;\n\n SECTION(\"Initialisations\");\n ArrayXXf m1(2,2); // Array\n m1 = Array22f::Ones();\n PRINT(m1);\n Array22f m2;\n m2 << 1, 2, 3, 4;\n\n // https://eigen.tuxfamily.org/dox/group__TutorialAdvancedInitialization.html\n ArrayXXf table(10, 4);\n table.col(0) = ArrayXf::LinSpaced(10, 0, 90);\n table.col(1) = M_PI / 180 * table.col(0);\n table.col(2) = table.col(1).sin();\n table.col(3) = table.col(1).cos();\n std::cout << \"table: \" << std::endl;\n std::cout << \"\\tDegrees\\t\\tRadians\\t\\tSine\\t\\tCosine\\n\";\n std::cout << table << std::endl;\n\n SECTION(\"Operations\");\n PRINT(m1+5);\n PRINT(m1+m2);\n PRINT(m1*2);\n PRINT(m1*m2);\n\n SECTION(\"Reduction\");\n Array33f m3 = Array33f::Random();\n PRINT(m3);\n PRINT(m3.abs().sqrt());\n PRINT(m3.min(m3.abs().sqrt()));\n // more coefficient-wise & Array operators https://eigen.tuxfamily.org/dox/group__QuickRefPage.html\n // boolean https://eigen.tuxfamily.org/dox/group__TutorialReductionsVisitorsBroadcasting.html\n PRINT((m3 > 0).all());\n PRINT((m3 > 0).any());\n PRINT((m3 > 0).count());\n\n SECTION(\"Types converting\");\n // convert type\n MatrixXf m(2,2);\n MatrixXf n(2,2);\n MatrixXf result(2,2);\n m << 1,2,\n 3,4;\n n << 5,6,\n 7,8;\n PRINT(m);\n PRINT(n);\n result = m * n;\n std::cout << \"-- Matrix m*n: --\" << std::endl << result << std::endl << std::endl;\n result = m.array() * n.array();\n std::cout << \"-- Array m*n: --\" << std::endl << result << std::endl << std::endl;\n result = m.cwiseProduct(n);\n std::cout << \"-- With cwiseProduct: --\" << std::endl << result << std::endl << std::endl;\n result = m.array() + 4;\n std::cout << \"-- Array m + 4: --\" << std::endl << result << std::endl << std::endl;\n result = (m.array() + 4).matrix() * m;\n std::cout << \"-- Combination 1: --\" << std::endl << result << std::endl << std::endl;\n result = (m.array() * n.array()).matrix() * m;\n std::cout << \"-- Combination 2: --\" << std::endl << result << std::endl << std::endl;\n\n ArrayXXd arr_result = result.array().cast();\n PRINT(arr_result);\n}\n", "meta": {"hexsha": "aaaede405c3ba8bc0e622c9cdcec815df0956b63", "size": 2623, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/103_Array/main.cpp", "max_stars_repo_name": "GeneKao/Eigen-Cpp-Notes", "max_stars_repo_head_hexsha": "fbc558af3926cb2f033a44403923af621fee1e92", "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/103_Array/main.cpp", "max_issues_repo_name": "GeneKao/Eigen-Cpp-Notes", "max_issues_repo_head_hexsha": "fbc558af3926cb2f033a44403923af621fee1e92", "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/103_Array/main.cpp", "max_forks_repo_name": "GeneKao/Eigen-Cpp-Notes", "max_forks_repo_head_hexsha": "fbc558af3926cb2f033a44403923af621fee1e92", "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": 33.2025316456, "max_line_length": 120, "alphanum_fraction": 0.5829203202, "num_tokens": 855, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.712232184238947, "lm_q2_score": 0.7690802317779601, "lm_q1q2_score": 0.5477636933342122}} {"text": "#include \"normal_modes.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"id_map.h\"\n#include \"dump_reader.h\"\n\ntypedef std::vector > coord_block;\n\n\nvoid normal_mode_analysis( dump_reader &r, py_int N, void *eigenvalues,\n void *eigenvectors )\n{\n\tstd::list< coord_block > blocks;\n\tblock_data b;\n\t\n\twhile( r.next_block( b ) ){\n\t\tid_map im( b.ids, b.N );\n\t\tpy_int Nparticles = b.N;\n\t\t\n\t\tcoord_block block( Nparticles );\n\t\tfor( int i = 0; i < Nparticles; ++i ){\n\t\t\tint id = i + 1;\n\t\t\tint idx = im[id];\n\n\t\t\tblock[i][0] = b.x[i][0];\n\t\t\tblock[i][1] = b.x[i][1];\n\t\t\tblock[i][2] = b.x[i][2];\n\t\t}\n\n\t\tblocks.push_back( block );\n\t}\n\tstd::cerr << \"Done reading dump file...\\n\";\n\n\tget_normal_modes( blocks, N, eigenvalues, eigenvectors );\n\n}\n\n\nvoid read_blocks_from_pipe( const char *pname,\n std::list< coord_block > &bs )\n{\n\tstd::ifstream in(pname);\n\tstd::string line;\n\tstd::ofstream out(\"pipe_test2\");\n\t\n\t/*\n\t Expected format:\n\t First line: Number of particles\n\t N times 3 coordinates, ordered along id.\n\t*/\n\n\tint block_idx = 1;\n\t\n\t// Make sure you exhaust the pipe:\n\twhile( in ){\n\t\tstd::getline( in, line );\n\t\tint Nparticles = 0;\n\t\tstd::stringstream ss(line);\n\t\tss >> Nparticles;\n\n\t\tif( Nparticles <= 0 ) break;\n\t\t\n\t\tcoord_block block(Nparticles);\n\n\t\t\n\t\tfor( int i = 0; i < Nparticles; ++i ){\n\t\t\tstd::getline( in, line );\n\t\t\tss.str(\"\");\n\t\t\tss.clear();\n\t\t\tss << line;\n\t\t\tss >> block[i][0] >> block[i][1] >> block[i][2];\n\t\t}\n\t\tblock_idx++;\n\t\tbs.push_back( block );\n\t}\n\tstd::cerr << \"Grabbed \" << bs.size() << \" blocks in total.\\n\";\n}\n\n\nvoid average_positions( const std::list< coord_block > &block_data, py_int N,\n std::vector &X_avg )\n{\n\tint Nparticles = block_data.begin()->size();\n\tfor( int i = 0; i < N; ++i ) X_avg[i] = 0.0;\n\n\tstd::cerr << \"Averaging positions...\\n\";\n\tfor( const coord_block &b : block_data ){\n\t\tfor( int i = 0; i < Nparticles; ++i ){\n\t\t\tX_avg[3*i + 0] += b[i][0];\n\t\t\tX_avg[3*i + 1] += b[i][1];\n\t\t\tX_avg[3*i + 2] += b[i][2];\n\t\t}\n\t}\n}\n\n\nvoid get_normal_modes( const std::list< coord_block > &block_data, py_int N,\n void *eigenvalues, void *eigenvectors,\n std::vector *X_avg_ptr )\n{\n\t// Perform the normal mode analysis...\n\tint Nparticles = block_data.begin()->size();\n\tdouble c = 1.0 / static_cast( block_data.size() );\n\tif( 3*Nparticles != N ){\n\t\tstd::cerr << \"Something fishy is going on...\\n\";\n\t\tstd::cerr << \"Nparticles = \" << Nparticles << \", 3*Nparticles = \"\n\t\t << 3*Nparticles << \" != N = \" << N << \"!\\n\";\n\t\treturn;\n\t}\n\n\tstd::vector X_avg;\n\tstd::cerr << \"Averaging positions...\\n\";\n\tif( !X_avg_ptr ){\n\t\tX_avg.resize(N);\n\t\tX_avg_ptr = &X_avg;\n\t\taverage_positions( block_data, N, *X_avg_ptr );\n\t}else{\n\t\tX_avg = *X_avg_ptr;\n\t\taverage_positions( block_data, N, *X_avg_ptr );\n\t}\n\t\n\t// Extract covariance matrix:\n\tstd::cerr << \"Constructing covariance matrix...\\n\";\n\tarma::mat covar(N,N);\n\t\n\tfor( int i = 0; i < N; ++i ){\n\t\tfor( int j = 0; j < N; ++j ){\n\t\t\tcovar(i, j) = 0.0;\n\t\t}\n\t}\n\t\n\tfor( const coord_block &b : block_data ){\n\t\tfor( int i = 0; i < Nparticles; ++i ){\n\t\t\tdouble dxi = b[i][0] - X_avg[3*i];\n\t\t\tdouble dyi = b[i][1] - X_avg[3*i+1];\n\t\t\tdouble dzi = b[i][2] - X_avg[3*i+2];\n\n\t\t\tfor( int j = 0; j < Nparticles; ++j ){\n\t\t\t\tdouble dxj = b[j][0] - X_avg[3*j];\n\t\t\t\tdouble dyj = b[j][1] - X_avg[3*j+1];\n\t\t\t\tdouble dzj = b[j][2] - X_avg[3*j+2];\n\n\t\t\t\tcovar(3*i , 3*j ) += dxi*dxj*c;\n\t\t\t\tcovar(3*i , 3*j+1) += dxi*dyj*c;\n\t\t\t\tcovar(3*i , 3*j+2) += dxi*dzj*c;\n\n\t\t\t\tcovar(3*i+1, 3*j ) += dyi*dxj*c;\n\t\t\t\tcovar(3*i+1, 3*j+1) += dyi*dyj*c;\n\t\t\t\tcovar(3*i+1, 3*j+2) += dyi*dzj*c;\n\n\t\t\t\tcovar(3*i+2, 3*j ) += dzi*dxj*c;\n\t\t\t\tcovar(3*i+2, 3*j+1) += dzi*dyj*c;\n\t\t\t\tcovar(3*i+2, 3*j+2) += dzi*dzj*c;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Perform the decomposition:\n\tstd::cerr << \"Performing decomposition in normal modes...\\n\";\n\tconst char *method = \"std\";\n\tarma::vec eigval(N);\n\tarma::mat eigvec(N,N);\n\tarma::eig_sym( eigval, eigvec, covar, method );\n\t\n\tstd::cerr << \"Writing \" << N << \" eigenvalues to \" << eigenvalues\n\t << \" and eigenvectors to \" << eigenvectors << \"\\n\";\n\n\tdouble **eigenvecs = static_cast(eigenvectors);\n\tdouble *eigenvals = static_cast (eigenvalues);\n\n\tfor( int i = 0; i < N; ++i ){\n\t\teigenvals[i] = eigval(i);\n\t\tfor( int j = 0; j < N; ++j ){\n\t\t\teigenvecs[i][j] = eigvec(i,j);\n\t\t}\n\t}\n\tstd::cerr << \"Done!\\n\";\n\n}\n\n\nvoid normal_mode_analysis( const char *pname, void *eigenvalues,\n void *eigenvectors, py_int N )\n{\n\n\tstd::list< coord_block > block_data;\n\n\tread_blocks_from_pipe( pname, block_data );\n\t\n\tget_normal_modes( block_data, N, eigenvalues, eigenvectors );\n}\n\n", "meta": {"hexsha": "777295e9b5e02793b7e946452449712bdc76c63f", "size": 4809, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "c_lib/normal_modes.cpp", "max_stars_repo_name": "Pakketeretet2/lammps-tools", "max_stars_repo_head_hexsha": "1e2109018a7412c33c80bb3eceb1f97003495341", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2017-09-04T14:39:51.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-07T01:30:00.000Z", "max_issues_repo_path": "c_lib/normal_modes.cpp", "max_issues_repo_name": "Pakketeretet2/lammps-tools", "max_issues_repo_head_hexsha": "1e2109018a7412c33c80bb3eceb1f97003495341", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "c_lib/normal_modes.cpp", "max_forks_repo_name": "Pakketeretet2/lammps-tools", "max_forks_repo_head_hexsha": "1e2109018a7412c33c80bb3eceb1f97003495341", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.045, "max_line_length": 77, "alphanum_fraction": 0.5733000624, "num_tokens": 1616, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789178257654, "lm_q2_score": 0.6757646075489392, "lm_q1q2_score": 0.5476929678312173}} {"text": "#include \n\n#include \n#include \n#include \n\n#include \n\n#include \"caffe/blob.hpp\"\n#include \"caffe/common.hpp\"\n#include \"caffe/layers/random_affine_layer.hpp\"\n#include \"caffe/util/math_functions.hpp\"\n\n\nnamespace caffe {\n\n\ntemplate \nvoid RandomAffineLayer::LayerSetUp(const vector*>& bottom,\n const vector*>& top) {\n\t//do nothing\n}\n\ntemplate \nvoid RandomAffineLayer::Reshape(const vector*>& bottom,\n const vector*>& top) {\n\t//set in batch size\n\tuint32_t batchSize = this->layer_param_.random_affine_param().batch_size();\n\tvector shape_top(4);\n\tshape_top[0] = batchSize;\n\tshape_top[1] = 1;\n\tshape_top[2] = 2;\n\tshape_top[3] = 3;\n\ttop[0]->Reshape(shape_top);\n\n\t//check valid bottom\n\tif(bottom.size() == 1){\n\t\tCHECK_EQ(top[0]->shape(0), bottom[0]->shape(0)) << \"Bottom batch size not the same\";\n\t\tCHECK_EQ(top[0]->shape(1), bottom[0]->shape(1)) << \"Bottom should have 1 channel\";\n\t\tCHECK_EQ(top[0]->shape(2), bottom[0]->shape(2)) << \"Bottom not 2x3 affine\";\n\t\tCHECK_EQ(top[0]->shape(3), bottom[0]->shape(3)) << \"Bottom not 2x3 affine\";\n\t}\n\n\t//set working variables\n\tvector shape_transform(4);\n\tshape_transform[0] = batchSize;\n\tshape_transform[1] = 1;\n\tshape_transform[2] = 3;\n\tshape_transform[3] = 3;\n\n\tt1_.Reshape(shape_transform);\n\tt2_.Reshape(shape_transform);\n\tt3_.Reshape(shape_transform);\n\tbottomExpanded.Reshape(shape_transform);\n\tt4_.Reshape(shape_transform);\n\n\t//transform params\n\tvector shape_param(4);\n\tshape_param[0] = batchSize;\n\tshape_param[1] = 1;\n\tshape_param[2] = 1;\n\tshape_param[3] = 1;\n\n\ttranslation_x.Reshape(shape_param);\n\ttranslation_y.Reshape(shape_param);\n\trotation.Reshape(shape_param);\n\tscale.Reshape(shape_param);\n\tflipping_rand.Reshape(shape_param);\n}\n\ntemplate \nvoid RandomAffineLayer::Forward_cpu(const vector*>& bottom,\n const vector*>& top) {\n\t//read in transformation distributions\n\tDtype max_translation_x = this->layer_param_.random_affine_param().max_translation_x();\n\tDtype max_translation_y = this->layer_param_.random_affine_param().max_translation_y();\n\tDtype max_rotation = this->layer_param_.random_affine_param().max_rotation();\n\tDtype min_scale = this->layer_param_.random_affine_param().min_scale();\n\tDtype max_scale = this->layer_param_.random_affine_param().max_scale();\n\tbool horizontalFlipping = this->layer_param_.random_affine_param().horizontal_flipping();\n\n\t//helpers\n\tDtype* t1 = t1_.mutable_cpu_data();\n\tDtype* t2 = t2_.mutable_cpu_data();\n\tDtype* t3 = t3_.mutable_cpu_data();\n\tDtype* bottomExpandedData = bottomExpanded.mutable_cpu_data();\n\tDtype* t4 = t4_.mutable_cpu_data();\n\tDtype* top_data = top[0]->mutable_cpu_data();\n\n\tcaffe_set(t1_.count(), (Dtype)0, t1);\n\tcaffe_set(t2_.count(), (Dtype)0, t2);\n\tcaffe_set(t3_.count(), (Dtype)0, t3);\n\tcaffe_set(bottomExpanded.count(), (Dtype)0, bottomExpandedData);\n\tcaffe_set(t4_.count(), (Dtype)0, t4);\n\n\tint N = top[0]->shape(0);\n\n\t//generate transform params\n\tDtype* tx = translation_x.mutable_cpu_data();\n\tDtype* ty = translation_y.mutable_cpu_data();\n\tDtype* rot = rotation.mutable_cpu_data();\n\tDtype* scal = scale.mutable_cpu_data();\n\tDtype* flip = flipping_rand.mutable_cpu_data();\n\n\tcaffe_rng_uniform(N,-max_translation_x,max_translation_x,tx);\n\tcaffe_rng_uniform(N,-max_translation_y,max_translation_y,ty);\n\tcaffe_rng_uniform(N,-max_rotation,max_rotation,rot);\n\tcaffe_rng_uniform(N,min_scale,max_scale,scal);\n\tif(horizontalFlipping){\n\t\tcaffe_rng_uniform(N,(Dtype)0,(Dtype)1,flip);\n\t}\n\telse{\n\t\tcaffe_set(N, (Dtype)0, flip);\n\t}\n\n\tfor(int n=0;n 0.5){\n\t\t\tt2[9*n] = scaleFactor;\n\t\t\tt2[9*n + 4] = -scaleFactor;\n\t\t\tt2[9*n + 8] = 1;\n\t\t}\n\t\telse{\n\t\t\tt2[9*n] = scaleFactor;\n\t\t\tt2[9*n + 4] = scaleFactor;\n\t\t\tt2[9*n + 8] = 1;\n\t\t}\n\n\t\tcaffe_cpu_gemm(CblasNoTrans, CblasNoTrans, 3, 3, 3, (Dtype)1.0,\n\t\t &t1[9*n], &t2[9*n], (Dtype)0.0, &t3[9*n]);\n\n\t\t//transfer to top\n\t\tif(bottom.size() == 1){\n\t\t\tcaffe_copy(6, &(bottom[0]->mutable_cpu_data()[6*n]), &bottomExpandedData[9*n]);\n\t\t\tbottomExpandedData[9*n + 8] = 1;\n\n\t\t\tcaffe_cpu_gemm(CblasNoTrans, CblasNoTrans, 3, 3, 3, (Dtype)1.0,\n\t\t \t\t&t3[9*n], &bottomExpandedData[9*n], (Dtype)0.0, &t4[9*n]);\n\t\t\tcaffe_copy(6, &t4[9*n], &top_data[6*n]);\n\t\t}\n\t\telse{\n\t\t\tcaffe_copy(6, &t3[9*n], &top_data[6*n]);\n\t\t}\n\t}\n}\n\ntemplate \nvoid RandomAffineLayer::Backward_cpu(const vector*>& bottom,\n const vector& propagate_down, const vector*>& top) {\n\t//do nothing\n}\n\n\n#ifdef CPU_ONLY\nSTUB_GPU(RandomAffineLayer);\n#endif\n\nINSTANTIATE_CLASS(RandomAffineLayer);\nREGISTER_LAYER_CLASS(RandomAffine);\n\n} // namespace caffe\n", "meta": {"hexsha": "11f35ca71ebe2ff83595ab685942e4d84705a85c", "size": 5062, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/caffe/layers/random_affine_layer.cpp", "max_stars_repo_name": "bryanyzhu/GuidedNet", "max_stars_repo_head_hexsha": "4c87d392addc38700caf2856b450f2c74a79e122", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 26.0, "max_stars_repo_stars_event_min_datetime": "2017-06-05T19:19:56.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T14:36:37.000Z", "max_issues_repo_path": "src/caffe/layers/random_affine_layer.cpp", "max_issues_repo_name": "zmlshiwo/GuidedNet", "max_issues_repo_head_hexsha": "4c87d392addc38700caf2856b450f2c74a79e122", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2018-05-15T11:48:01.000Z", "max_issues_repo_issues_event_max_datetime": "2018-05-15T11:52:13.000Z", "max_forks_repo_path": "src/caffe/layers/random_affine_layer.cpp", "max_forks_repo_name": "zmlshiwo/GuidedNet", "max_forks_repo_head_hexsha": "4c87d392addc38700caf2856b450f2c74a79e122", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 12.0, "max_forks_repo_forks_event_min_datetime": "2017-06-12T16:59:35.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-16T18:31:17.000Z", "avg_line_length": 29.2601156069, "max_line_length": 90, "alphanum_fraction": 0.6985381272, "num_tokens": 1608, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104788995148791, "lm_q2_score": 0.6757646010190476, "lm_q1q2_score": 0.547692950165029}} {"text": "// [[Rcpp::depends(RcppArmadillo)]]\n#define ARMA_DONT_PRINT_ERRORS\n#include \n#include \n#include \n#include \n#include \n#include \n//' Get observation location in 2D space\n//'\n//' @param time time to return observer position\n//' @param strip_size size of strip in (x, y) dimensions\n//' @param buffer buffer size\n//' @param delta (dx, dt) vector\n//' @param transect_type 0 = line, 1 = point\n//' @param observer_speed speed of observer\n//'\n//' @return (x, y) location of observer at time t\n// [[Rcpp::export]]\narma::vec GetObserverPosition(const double time,\n const arma::vec strip_size,\n const double buffer,\n const arma::vec delta,\n const int transect_type,\n const double observer_speed) {\n arma::vec pos(2);\n pos(0) = 0.5 * strip_size(0);\n if (transect_type == 1) {\n // point transect assumed to be center of grid\n\t pos(1) = 0.5 * strip_size(1);\n } else {\n pos(1) = observer_speed * time + buffer;\n }\n return pos;\n}\n//' Calculates the sparse transition rate matrix\n//'\n//' @param num_cells vector with number of cells in (total space, x-direction,\n//' y-direction)\n//' @param sd vector of diffusive standard deviation for each behavioural state\n//' @param dx grid cell size in the space (c.f. delta(0))\n//'\n//' @return sparse transition rate matrix\n// [[Rcpp::export]]\narma::sp_mat CalcTrm(const arma::vec num_cells, const double sd, const double dx) {\n arma::sp_mat tpr = arma::zeros(num_cells(0), num_cells(0));\n double rate = sd * sd / (2 * dx * dx);\n int s;\n for (int i = 0; i < num_cells(1); ++i) {\n for (int j = 0; j < num_cells(2); ++j) {\n s = i + num_cells(1) * j;\n if (i < num_cells(1) - 1) {\n tpr(s, s + 1) = rate;\n }\n if (i > 0) {\n tpr(s, s - 1) = rate;\n }\n if (j < num_cells(2) - 1) {\n tpr(s, s + num_cells(1)) = rate;\n }\n if (j > 0) {\n tpr(s, s - num_cells(1)) = rate;\n }\n tpr(s, s) = -4 * rate;\n }\n }\n return tpr.t();\n}\n//' Diffuse probability distribution over space\n//'\n//' @description Calculate product of v with matrix exponential of a using\n//' the Arnoldi process. Thereby diffusing the probability distribution\n//' according to Brownian motion. Code is transcribed from Expokit package.\n//' \n//' @note NOTICE\n//' Permission to use, copy, modify, and distribute EXPOKIT and its\n//' supporting documentation for non-commercial purposes, is hereby\n//' granted without fee, provided that this permission message and\n//' copyright notice appear in all copies. Approval must be sought for\n//' commercial purposes as testimony of its usage in applications.\n//' \n//' Neither the Institution (University of Queensland) nor the Author\n//' make any representations about the suitability of this software for\n//' any purpose. This software is provided ``as is'' without express or\n//' implied warranty.\n//' \n//' The work resulting from EXPOKIT has been published in ACM-Transactions \n//' on Mathematical Software, 24(1):130-156, 1998.\n//' \n//' The bibtex record of the citation:\n//' \n//' ARTICLE{EXPOKIT,\n//' AUTHOR = {Sidje, R. B.},\n//' TITLE = {{Expokit.} {A} Software Package for\n//' Computing Matrix Exponentials},\n//' JOURNAL = {ACM Trans. Math. Softw.},\n//' VOLUME = {24},\n//' NUMBER = {1},\n//' PAGES = {130-156}\n//' YEAR = {1998}\n//' }\n//' \n//' Certain elements of the current software may include inadequacies\n//' that may be corrected at any time, as they are discovered. The Web \n//' always contains the latest updates.\n//' \n//' Original Author:\n//' Roger B. Sidje \n//' Department of Mathematics, University of Queensland \n//' Brisbane, QLD-4072, Australia, (c) 1996-2006 All Rights Reserved\n//'\n//' @param a transition rate matrix\n//' @param v vector to be multiplied\n//' @param t time to diffuse over\n//' @param num_cells vector with number of cells in (total space, x-direction,\n//' y-direction)\n//' @param krylov_dim dimension of the approximating Krylov space\n//' @param tol tolerance in error\n//'\n//' @return diffused probability distribution\n// [[Rcpp::export]]\narma::rowvec Diffuse(const arma::sp_mat a,\n const arma::rowvec v,\n const double t,\n const arma::vec num_cells,\n const int& krylov_dim = 30,\n const double& tol = 1e-10) {\n double m = fmin(a.n_rows, krylov_dim);\n double anorm = norm(a, \"Inf\");\n double mxrej = 10;\n double mx;\n double btol = 1e-7;\n double gamma = 0.9;\n double mb = m;\n int nstep = 0;\n double t_now = 0;\n double t_step;\n double delta = 1.2;\n double t_out = fabs(t);\n double s_error = 0;\n double rndoff = anorm * 1e-16;\n int k1 = 1;\n double xm = 1 / m;\n double normv = norm(v);\n double avnorm;\n double beta = normv;\n double fact = std::pow((m + 1) / std::exp(1), m + 1) * std::sqrt(2 * M_PI * (m + 1));\n double t_new = (1.0 / anorm) * std::pow((fact * tol) / (4 * beta * anorm), xm);\n double s = std::pow(10, std::floor(std::log10(t_new)) - 1);\n t_new = std::ceil(t_new / s) * s;\n double sgn = t > 0 ? 1 : -1;\n int ireject;\n double err_loc;\n double phi1;\n double phi2;\n arma::vec w = v.t();\n double hump = normv;\n arma::mat vmat = arma::zeros(a.n_rows, m + 1);\n arma::mat hmat = arma::zeros(m + 2, m + 2);\n arma::mat fmat;\n arma::vec p;\n while (t_now < t_out) {\n Rcpp::checkUserInterrupt();\n ++nstep;\n t_step = fmin(t_out - t_now, t_new);\n vmat.zeros();\n hmat.zeros();\n vmat.col(0) = (1 / beta) * w;\n for (int j = 0; j < m; ++j) {\n p = a * vmat.col(j);\n for (int i = 0; i <= j; ++i) {\n hmat(i, j) = dot(vmat.col(i), p);\n p -= hmat(i, j) * vmat.col(i);\n }\n s = norm(p);\n if (s < btol) {\n k1 = 0;\n mb = j;\n t_step = t_out - t_now;\n break;\n }\n hmat(j + 1, j) = s;\n vmat.col(j + 1) = (1 / s) * p;\n }\n if (k1 != 0) {\n hmat(m + 1, m) = 1;\n avnorm = norm(a * vmat.col(m));\n }\n ireject = 0;\n while (ireject <= mxrej) {\n mx = mb + k1;\n fmat = expmat(sgn * t_step * hmat.submat(0, 0, mx, mx));\n\n if (k1 == 0) {\n err_loc = btol;\n break;\n }\n else {\n phi1 = fabs(beta * fmat(m, 0));\n phi2 = fabs(beta * fmat(m + 1, 0) * avnorm);\n if (phi1 > 10 * phi2) {\n err_loc = phi2;\n xm = 1 / m;\n }\n else if (phi1 > phi2) {\n err_loc = (phi1 * phi2) / (phi1 - phi2);\n xm = 1 / m;\n }\n else {\n err_loc = phi1;\n xm = 1 / (m - 1);\n }\n }\n if (err_loc <= delta * t_step * tol) break;\n else {\n t_step = gamma * t_step * std::pow(t_step * tol / err_loc, xm);\n s = std::pow(10, std::floor(std::log10(t_step)) - 1);\n t_step = std::ceil(t_step / s) * s;\n if (ireject == mxrej) {\n Rcpp::Rcout << \"error: requested tolerance too high for Krylov approximation\" << std::endl;\n }\n ++ireject;\n }\n }\n mx = mb + fmax(0, k1 - 1);\n w = vmat.cols(0, mx) * beta * fmat.col(0).rows(0, mx);\n beta = norm(w);\n hump = fmax(hump, beta);\n\n t_now = t_now + t_step;\n t_new = gamma * t_step * std::pow(t_step * tol / err_loc, xm);\n s = std::pow(10, std::floor(std::log10(t_new) - 1));\n t_new = std::ceil(t_new / s) * s;\n\n err_loc = fmax(err_loc, rndoff);\n s_error += err_loc;\n }\n double err = s_error;\n hump = hump / normv;\n return w.t();\n}\n//' Calculates the initial distribution of animal locations.\n//' Assumes uniform distribution relative to transect.\n//'\n//' @param num_cells vector with number of cells in (total space, x-direction,\n//' y-direction)\n//' @param delta spatial and temporal increments (dx, dt)\n//' @param region_size size of survey region in (x,y) extents\n//'\n//' @return Row vector with i^th entry probability animal in i^th grid cell initially\n// [[Rcpp::export]]\narma::rowvec CalcInitialDistribution(const arma::vec num_cells,\n const arma::vec delta,\n const arma::vec region_size) {\n arma::rowvec initial_phi = arma::ones(num_cells(0));\n initial_phi *= delta(0) * delta(0);\n initial_phi /= prod(region_size);\n return(initial_phi);\n}\n//' Transform working parameters (for the optimiser) to natural parameters\n//' @param working_parameter working parameters \n//' @param hzfn hazard function type \n//' @return natural parameters \n// [[Rcpp::export]]\narma::vec Working2Natural(arma::vec working_parameter, int hzfn = 1) {\n arma::vec parameter = arma::exp(working_parameter);\n //parameter(1) += 2; \n return parameter;\n}\n//' Transform natural parameters to unconstrained working parameters\n//' @param parameter natural parameters \n//' @param hzfn hazard function type \n//' @return working parameters \n// [[Rcpp::export]]\narma::vec Natural2Working(arma::vec parameter, int hzfn = 1) {\n arma::vec working_parameter(parameter);\n //working_parameter(1) -= 2; \n working_parameter = arma::log(working_parameter);\n return working_parameter;\n}\n\n//' Calculates hazard of detection\n//'\n//' @param x relative x coordinate\n//' @param y relative y coordinate\n//' @param dt time increment\n//' @param observer_speed speed of the observer\n//' @param parameter vector of (detection shape, detection scale)\n//' @param type transect type (0 = line, 1 = point)\n//' @param hzfn hazard function code (see ?hazardfns)\n//'\n//' @return hazard of detection\n// [[Rcpp::export]]\ndouble CalcHazard(const double x,\n const double y,\n const double dt,\n const double observer_speed,\n const arma::vec parameter,\n const int type,\n const int hzfn) {\n double hazard = 0;\n double r0, r1, abeta, abeta2, y1;\n double s, sx, sy, d, c, k; \n switch(hzfn) {\n case 0:\n // Hayes and Buckland isotropic h(r) = (r/s)^(-2)\n // parameter = (s, d)\n s = parameter(0); \n d = 1; \n c = pow(s, d); \n r0 = x * x + y * y;\n if (type == 1) {\n hazard = dt * c / pow(r0, 0.5 * d);\n }\n else {\n // assume cannot detect behind observer\n if (y < 0) return 0;\n abeta = 0.5 * (d - 1.0);\n y1 = y - observer_speed * dt;\n if (y1 < 0) y1 = 0;\n r1 = x * x + y1 * y1;\n if (r1 < 1e-10) return arma::datum::inf;\n if (fabs(x) < 1e-10) {\n if (fabs(d - 1) < 1e-10) {\n hazard = log(sqrt(r1)) - log(sqrt(r0));\n hazard *= c;\n } else {\n hazard = 1.0 / pow(r1, abeta) - 1.0 / pow(r0, abeta);\n hazard *= c / (d - 1.0);\n }\n } else {\n hazard = R::pbeta(x * x / r1, abeta, 0.5, 1, 0) - R::pbeta(x * x / r0,\n abeta, 0.5, 1, 0);\n hazard *= R::beta(abeta, 0.5) * c / (2.0 * pow(fabs(x),\n d - 1.0));\n }\n }\n return hazard;\n break;\n \n case 1:\n // Hayes and Buckland isotropic h(r) = (r/s)^(-d)\n // parameter = (s, d)\n s = parameter(0); \n d = 1 + parameter(1); \n c = pow(s, d); \n r0 = x * x + y * y;\n if (type == 1) {\n hazard = dt * c / pow(r0, 0.5 * d);\n }\n else {\n // assume cannot detect behind observer\n if (y < 0) return 0;\n abeta = 0.5 * (d - 1.0);\n y1 = y - observer_speed * dt;\n if (y1 < 0) y1 = 0;\n r1 = x * x + y1 * y1;\n if (r1 < 1e-10) return arma::datum::inf;\n if (fabs(x) < 1e-10) {\n if (fabs(d - 1) < 1e-10) {\n hazard = log(sqrt(r0)) - log(sqrt(r1));\n hazard *= c;\n } else {\n hazard = 1.0 / pow(r1, abeta) - 1.0 / pow(r0, abeta);\n hazard *= c / (d - 1.0);\n }\n } else {\n hazard = R::pbeta(x * x / r1, abeta, 0.5, 1, 0) - R::pbeta(x * x / r0,\n abeta, 0.5, 1, 0);\n hazard *= R::beta(abeta, 0.5) * c / (2.0 * pow(fabs(x),\n d - 1.0)); \n }\n }\n return hazard;\n break;\n\n case 2:\n // Hayes and Buckland anisotropic h(r) = (x^2/sx^2 + y^2/sy^2)^(-d/2)\n // parameter = (sx, sy, d)\n sx = parameter(0);\n sy = parameter(1); \n d = 1 + parameter(2); \n r0 = (x * x) / (sx * sx) + (y * y) / (sy * sy);\n if (type == 1) {\n hazard = dt * pow(r0, -0.5 * d); \n }\n else {\n // assume cannot detect behind observer\n if (y < 0) return 0;\n abeta = 0.5 * (d - 1.0);\n y1 = y - observer_speed * dt;\n if (y1 < 0) y1 = 0;\n r1 = (x * x) / (sx * sx) + (y1 * y1) / (sy * sy);\n if (r1 < 1e-10) return arma::datum::inf;\n if (fabs(x) < 1e-10) {\n if (fabs(d - 1) < 1e-10) {\n hazard = log(sqrt(y)) - log(sqrt(y1));\n hazard *= pow(sy, d);\n } else {\n hazard = 1.0 / pow(y1, abeta) - 1.0 / pow(y, abeta);\n hazard *= pow(sy, d) / (d - 1.0);\n }\n } else {\n hazard = R::pbeta(x * x / (sx * sx * r1), abeta, 0.5, 1, 0) - R::pbeta(x * x / (sx * sx * r0),\n abeta, 0.5, 1, 0);\n hazard *= R::beta(abeta, 0.5) * pow(sx, d - 1) * sy / (2.0 * pow(fabs(x),\n d - 1.0));\n }\n }\n return hazard;\n break;\n \n case 3:\n // Hayes and Buckland shape-anisotropic h(r) = (x^2+(y+k)^2)^(-d/2)\n // parameter = (s, d, k)\n s = parameter(0); \n d = 1 + parameter(1); \n k = parameter(2); \n c = pow(s, d); \n r0 = x * x / (s * s) + (y / s + k) * (y / s + k); \n if (type == 1) {\n hazard = dt * c * (1 + k * y / sqrt(r0)) / pow(r0, 0.5 * d);\n }\n else {\n // assume cannot detect behind observer\n if (y < 0) return 0;\n abeta = 0.5 * (d - 1.0);\n y1 = y - observer_speed * dt;\n if (y1 < 0) y1 = 0;\n r1 = x * x / (s * s) + (y1 / s + k) * (y1 / s + k); \n if (r1 < 1e-10) return arma::datum::inf;\n if (fabs(x) < 1e-10) {\n if (fabs(d - 1) < 1e-10) {\n hazard = log(sqrt(y + s * k)) - log(sqrt(y1 + s * k));\n hazard *= c;\n } else {\n hazard = 1.0 / pow(y1 + s * k, abeta) - 1.0 / pow(y + s * k, abeta);\n hazard *= c / (d - 1.0);\n }\n } else {\n hazard = R::pbeta(x * x / (s * s * r1), abeta, 0.5, 1, 0) - R::pbeta(x * x / (s * s * r0),\n abeta, 0.5, 1, 0);\n hazard *= R::beta(abeta, 0.5) * c / (2.0 * pow(fabs(x), d - 1.0)); \n }\n }\n return hazard;\n break;\n \n case 4:\n // Hayes and Buckland anisotropic h(r) = (x^2/sx^2 + (y/sy + k)^2)^(-d/2)\n // parameter = (sx, sy, d, k)\n sx = parameter(0);\n sy = parameter(1); \n d = 1 + parameter(2);\n k = parameter(3); \n r0 = (x * x) / (sx * sx) + pow(y / sy + k, 2.0); \n if (type == 1) {\n hazard = dt * pow(r0, -0.5 * d); \n }\n else {\n // assume cannot detect behind observer\n if (y < 0) return 0;\n abeta = 0.5 * (d - 1.0);\n y1 = y - observer_speed * dt;\n if (y1 < 0) y1 = 0;\n r1 = (x * x) / (sx * sx) + pow(y1 / sy + k, 2.0); \n if (r1 < 1e-10) return arma::datum::inf;\n if (fabs(x) < 1e-10) {\n if (fabs(d - 1) < 1e-10) {\n hazard = log(sqrt(y)) - log(sqrt(y1));\n hazard *= pow(sy, d);\n } else {\n hazard = 1.0 / pow(y1, abeta) - 1.0 / pow(y, abeta);\n hazard *= pow(sy, d) / (d - 1.0);\n }\n } else {\n hazard = R::pbeta(x * x / (sx * sx * r1), abeta, 0.5, 1, 0) - R::pbeta(x * x / (sx * sx * r0),\n abeta, 0.5, 1, 0);\n hazard *= R::beta(abeta, 0.5) * pow(sx, d - 1) * sy / (2.0 * pow(fabs(x),\n d - 1.0));\n }\n }\n return hazard;\n break;\n\n default:\n Rcpp::Rcout << \"error: no hazard specified.\" << std::endl;\n return -arma::datum::inf;\n }\n}\n//' Computes the probability of survival for each spatial location\n//'\n//' @param t time step\n//' @param parameter (scale, shape, diffusion) parameter\n//' @param num_cells number of cells in (x, y, all) dimensions\n//' @param delta (dx, dt) vector\n//' @param strip_size size of strip in (x, y) dimensions\n//' @param buffer buffer size\n//' @param observer_speed speed of the observer\n//' @param type transect type\n//' @param hzfn hazard function code\n//' @param nint not used\n//'\n//' @return row vector of survival probabilities over space\n// [[Rcpp::export]]\narma::rowvec CalcSurvivalPr(const int t,\n const arma::vec parameter,\n const arma::vec num_cells,\n const arma::vec delta,\n const arma::vec strip_size,\n const double buffer,\n const double observer_speed,\n const int type,\n const int hzfn,\n const int nint = 4) {\n\n arma::rowvec pr_survive = arma::ones(num_cells(0));\n arma::vec observer_position(GetObserverPosition(t * delta(1), strip_size, buffer, delta, type,\n observer_speed));\n double x, ix;\n double y, iy;\n int s;\n int ymin = 0; \n if (type == 0) ymin = floor(observer_position(1) / delta(0)); \n for (int x_cell = 0; x_cell < num_cells(1); ++x_cell) {\n for (int y_cell = ymin; y_cell < num_cells(2); ++y_cell) {\n s = x_cell + num_cells(1) * y_cell;\n pr_survive(s) = 0; \n x = x_cell * delta(0) - observer_position(0);\n y = y_cell * delta(0) - observer_position(1); \n for (int i = 0; i < nint; ++i) {\n //for (int j = 0; j < nint; ++j) {\n ix = x + (i * delta(0)) / nint; \n //iy = y + (j * delta(0)) / nint; \n pr_survive(s) += CalcHazard(ix, y, delta(1), observer_speed, parameter, type, hzfn);\n // }\n }\n //pr_survive(s) /= 1.0*nint*nint; \n pr_survive(s) /= 1.0*nint; \n pr_survive(s) = exp(-pr_survive(s)); \n }\n }\n return pr_survive;\n}\n\n//' Thins probability distribution by the proportion detected in each grid cell\n//'\n//' @param t time step\n//' @param pr probability distribution over finite grid\n//' @param parameter (scale, shape, diffusion) parameter\n//' @param num_cells number of cells in (x, y, all) dimensions\n//' @param delta (dx, dt) vector\n//' @param strip_size size of strip in (x, y) dimensions\n//' @param buffer buffer width \n//' @param observer_speed speed of the observer\n//' @param type transect type\n//' @param hzfn hazard function code \n//' \n//' @return thinned probability distribution\n// [[Rcpp::export]]\narma::rowvec Detect(const int t,\n const arma::rowvec pr,\n const arma::vec parameter,\n const arma::vec num_cells,\n const arma::vec delta,\n const arma::vec strip_size,\n const double buffer,\n const double observer_speed,\n const int type,\n const int hzfn) {\n arma::rowvec pr_survive = CalcSurvivalPr(t, parameter, num_cells, delta,\n\t\t strip_size, buffer, observer_speed, type, hzfn);\n pr_survive %= pr;\n return(pr_survive);\n}\n\n//' Compute hazard of each detection within time-step\n//'\n//' @param data (x, y, t) data matrix\n//' @param dt time step\n//' @param transdat transect data matrix\n//' @param parameter (scale, shape, diffusion) parameters\n//' @param observer_speed speed of observer\n//' @param type 1 = point, 0 = line transect\n//' @param hzfn hazard function code (see ?hazardfns)\n//' @return PDF for within-timestep detection\n// [[Rcpp::export]]\ndouble CalcHazardDetected(const arma::mat data,\n double dt,\n arma::mat transdat,\n arma::vec parameter,\n double observer_speed,\n int type,\n const int hzfn) {\n arma::vec r2, cosang;\n arma::vec t_remaining = data.col(4) - floor((data.col(4)) / dt) * dt;\n double log_hazard = 0;\n for (int i = 0; i < data.n_rows; ++i) {\n log_hazard -= CalcHazard(data(i, 2), data(i, 3) + t_remaining(i) *\n\t\t observer_speed, t_remaining(i), observer_speed, parameter, type, hzfn);\n }\n\n double s, sx, sy, d, c, k; \n switch(hzfn) {\n case 0:\n s = parameter(0); \n d = 1; \n c = pow(s, d); \n r2 = sum(data.cols(2, 3) % data.cols(2, 3), 1);\n log_hazard += arma::accu(log(c) - 0.5 * d * log(r2));\n break;\n \n case 1:\n s = parameter(0); \n d = 1 + parameter(1); \n c = pow(s, d); \n r2 = sum(data.cols(2, 3) % data.cols(2, 3), 1);\n log_hazard += arma::accu(log(c) - 0.5 * d * log(r2));\n break;\n\n case 2:\n sx = parameter(0); \n sy = parameter(1); \n d = 1 + parameter(2);\n log_hazard += -0.5 * d * arma::accu(log(data.col(2) % data.col(2) / (sx * sx) + data.col(3) % data.col(3) / (sy * sy))); \n break;\n\n case 3:\n s = parameter(0); \n d = 1 + parameter(1);\n k = parameter(2); \n r2 = data.col(2) % data.col(2) / (s * s) + pow(data.col(3) / s + k, 2.0); \n log_hazard += arma::accu(- 0.5 * d * log(r2));\n break;\n \n case 4:\n sx = parameter(0); \n sy = parameter(1); \n d = 1 + parameter(2);\n k = parameter(3); \n r2 = data.col(2) % data.col(2) / (sx * sx) + pow(data.col(3) / sy + k, 2.0); \n log_hazard += arma::accu(- 0.5 * d * log(r2));\n break;\n \n default:\n Rcpp::Rcout << \"error: no hazard specified.\" << std::endl;\n return -arma::datum::inf;\n }\n return log_hazard;\n}\n//' Calculates movement model log-likelihood\n//'\n//' @param sd diffusion\n//' @param data Rcpp List where each component represent an individual path\n//' and continas a matrix where each row is an observed location (x,y,t)\n//'\n//' @return log-likelihood\n// [[Rcpp::export]]\ndouble CalcMovementLogLikelihood(const double sd, const Rcpp::List data) {\n double log_likelihood = 0;\n arma::vec xdiff, ydiff;\n int ntags = data.size();\n arma::mat tag;\n for (int i = 0; i < ntags; ++i) {\n tag = Rcpp::as(data(i));\n arma::vec xdiff = arma::diff(tag.col(0));\n arma::vec ydiff = arma::diff(tag.col(1));\n arma::vec tdiff = arma::diff(tag.col(2));\n log_likelihood -= tag.n_rows * log(2 * M_PI * sd * sd);\n log_likelihood -= accu(log(tdiff) + (xdiff % xdiff + ydiff % ydiff) / (2 * sd * sd * tdiff));\n }\n return log_likelihood;\n}\n//' Computes what grid cells are inside and outside transect\n//'\n//' @param num_cells number of cells in (total, x, y) direction \n//' @param strip_size size of strip in (x,y) directions\n//' @param dx grid cell size \n//' @param w for lines, half-width, for points radius \n//' @param ymax maximum forward distance for lines \n//' @param buffer distance\n//' @param type =0 for lines, =1 for points \n//'\n//' @return vector with 1 for each grid cell inside and 0 otherwise \n// [[Rcpp::export]]\narma::rowvec InTransect(const arma::vec num_cells,\n const arma::vec strip_size, \n const double dx, \n const double w,\n const double ymax, \n const double buffer, \n const int type) {\n arma::rowvec intrans = arma::zeros(num_cells(0)); \n double x, y, r; \n double top, bot, lenx, leny; \n if (type == 0) {\n for (int i = 0; i < num_cells(1); ++i) {\n x = i * dx - strip_size(0) * 0.5;\n top = fmin(x + dx, w);\n bot = fmax(x, -w);\n lenx = top - bot; \n if (lenx < 0) lenx = 0; \n for (int j = 0; j < num_cells(2); ++j) {\n y = j * dx - buffer;\n top = fmin(y + dx, ymax); \n bot = fmax(y, 0); \n leny = top - bot; \n if (leny < 0) leny = 0; \n intrans(i + j * num_cells(1)) = lenx * leny / (dx * dx);\n }\n }\n } else {\n for (int i = 0; i < num_cells(1); ++i) {\n x = i * dx - strip_size(0) * 0.5; \n for (int j = 0; j < num_cells(2); ++j) {\n y = j * dx - strip_size(1) * 0.5; \n r = x * x + y * y; \n if (r <= w*w) intrans(i + j * num_cells(1)) = 1; \n }\n }\n }\n return intrans; \n}\n\n\n//' Computes negative log-likelihood of moveDs model\n//'\n//' @param working_parameter unconstrained version of parameter vector containing\n//' (detection shape, detection scale, diffusion sd)\n//' @param start start value for parameters on natural scale \n//' @param data matrix with (trans id, grid cell,t) distance sampling survey data (assumed to be ordered by transect and time)\n//' @param transdat matrix with (stripsize(1), numcells in y, totaltimestep, number of observations)\n//' @param auxiliary_data vector containing (area x extent, area y extent, strip width, transect_type)\n//' @param delta vector of (dx, dt) spacetime increments\n//' @param num_cells number of cells in (total space, x-direction, y-direction)\n//' @param T total time of survey for longest transect\n//' @param ymax maximum length of a transect\n//' @param buffer buffer distance\n//' @param movement_data field object where each component represents an individual\n//' path and contains a matrix where each row is an observed location (x,y,t)\n//' @param fixed_sd if move_method = 2\n//' @param hzfn hazard function code (see ?hazardfns)\n//' @param move_method 0 = 2d CDS model, 1 = 2d MDS model (movement estimated),\n//' 2 = 2d MDS model (movement fixed)\n//' @param print if TRUE then print likelihood and parmeters after evaluation\n//' @param con parameters are constrained to be between 1/con * start value and \n//' con * start value \n//'\n//' @return negative log-likelihood\n// [[Rcpp::export]]\ndouble NegativeLogLikelihood(const arma::vec working_parameter,\n const arma::vec start, \n const arma::mat data,\n const arma::mat transdat,\n const arma::vec auxiliary_data,\n const arma::vec delta,\n const arma::vec num_cells,\n const int T,\n const double ymax,\n const double buffer,\n const Rcpp::List movement_data,\n const double fixed_sd = 0,\n const int hzfn = 1,\n const int move_method = 1,\n const bool print = false,\n const double con = 100) {\n // unpack auxiliary data\n arma::vec region_size(auxiliary_data.rows(0, 1));\n arma::vec strip_size(2);\n strip_size(0) = 2 * auxiliary_data(2) + 2 * buffer;\n strip_size(1) = ymax + 2 * buffer;\n double observer_speed = auxiliary_data(3);\n int num_transects = transdat.n_rows;\n int transect_type = auxiliary_data(4);\n double dx = delta(0);\n double dt = delta(1);\n // unpack parameters\n arma::vec parameter = Working2Natural(working_parameter, hzfn);\n int npar = parameter.n_elem;\n // constraints \n for (int p = 0; p < npar; ++p) {\n if (parameter(p) > con * start(p)) return arma::datum::inf; \n if (parameter(p) < start(p) / con) return arma::datum::inf; \n }\n double sd = 0;\n if (move_method == 1) sd = parameter(npar - 1);\n if (move_method == 2) sd = fixed_sd;\n // setup variables\n int curtrans = 0;\n int curobs = 0;\n double pr_survived;\n double pr_outside;\n double accu_hazard;\n double pdet; \n double llk = 0;\n // calculate initial probability in each grid cell\n arma::rowvec pr_t = CalcInitialDistribution(num_cells, delta, region_size);\n arma::rowvec old_pr_t(pr_t);\n // probability outside buffer region at t = 0\n pr_outside = 1.0 - arma::prod(strip_size) / arma::prod(region_size);\n // compute movement matrices for survey\n arma::sp_mat trm;\n arma::rowvec flux = arma::ones(num_cells(0));\n if (move_method > 0) {\n trm = CalcTrm(num_cells, sd, dx);\n flux = Diffuse(trm.t(), flux, dt, num_cells);\n flux = 1.0 - flux;\n }\n double num_boundary_states = floor(prod(region_size) / (dx * dx)) - num_cells(0);\n // intialise variables\n double curt = floor((data(curobs, 4)) / dt);\n if (curt < 0) curt = 0; \n if ((curt > T - 1) & (curt < T + 1)) curt = T - 1; \n int endtime = transdat(curtrans, 2);\n arma::rowvec intrans = InTransect(num_cells, strip_size, dx, auxiliary_data(2), ymax, buffer, transect_type); \n accu_hazard = 0;\n pdet = 0; \n double diff = 0; \n // compute HMM approximation\n for (int t = 0; t < T; ++t) {\n Rcpp::checkUserInterrupt();\n // add to pr_obs, the observations that occur during time interval t\n while (t == curt) {\n if (data(curobs, 1) > num_cells(0)) {\n Rcpp::Rcout << \"Warning: buffer region too small to include all detections.\" << std::endl;\n } else {\n llk += log(pr_t(data(curobs, 1))) + accu_hazard - log(dx * dx);\n }\n ++curobs;\n if (curobs > data.n_rows - 1) {\n curt = T + 1;\n } else {\n curt = floor((data(curobs, 4)) / dt);\n if (curt < 0) curt = 0;\n if ((curt > T - 1) & (curt < T + 1)) curt = T - 1; \n }\n }\n // thin pr_t by those that are detected\n diff = 0; \n diff += arma::accu(pr_t % intrans); \n pr_t = Detect(t, pr_t, parameter, num_cells, delta, strip_size, buffer, observer_speed, transect_type, hzfn);\n diff -= arma::accu(pr_t % intrans); \n pdet += diff * exp(accu_hazard); \n if (arma::accu(pr_t) < 1e-10) return(arma::datum::inf);\n // move animals \n if (move_method > 0) {\n old_pr_t = pr_t;\n //move animals that are inside strip\n try {\n pr_t = Diffuse(trm, pr_t, dt, num_cells);\n } catch(...) {\n return arma::datum::inf; \n }\n //move animals outside strip that come into strip\n pr_t += flux * pr_outside / num_boundary_states;\n //account for transversal of boundary\n pr_outside += accu(old_pr_t % flux) - accu(flux) * pr_outside / num_boundary_states;\n }\n // add contribution to accu_hazard\n pr_survived = accu(pr_t) + pr_outside;\n accu_hazard += log(pr_survived);\n // scale to avoid underflow\n pr_t /= pr_survived;\n pr_outside /= pr_survived;\n // if transect ends divide by conditional probability\n while (endtime == t) {\n llk -= transdat(curtrans, 1) * log(pdet);\n ++curtrans;\n if (curtrans > transdat.n_rows - 1) {\n endtime = T + 1;\n } else {\n endtime = transdat(curtrans, 2);\n }\n }\n }\n // add hazard of detections\n llk += CalcHazardDetected(data, dt, transdat, parameter, observer_speed, transect_type, hzfn);\n double movement_log_likelihood = 0;\n if (move_method == 1) movement_log_likelihood = CalcMovementLogLikelihood(sd, movement_data);\n double negative_log_likelihood = -llk - movement_log_likelihood;\n if (print) {\n int old_precision = Rcpp::Rcout.precision();\n Rcpp::Rcout.precision(4);\n Rcpp::Rcout << -negative_log_likelihood << \" \";\n for (int par = 0; par < npar; ++par) Rcpp::Rcout << parameter(par) << \" \";\n Rcpp::Rcout << std::endl;\n }\n return negative_log_likelihood;\n}\n//' Computes covered area for entire survey\n//'\n//' @param working_parameter unconstrained version of parameter vector containing\n//' (detection shape, detection scale, diffusion sd)\n//' @param transdat matrix with (stripsize(1), numcells in y, totaltimestep, number of observations)\n//' @param auxiliary_data vector containing (area x extent, area y extent, strip width, transect_type)\n//' @param delta vector of (dx, dt) spacetime increments\n//' @param num_cells number of cells in (total space, x-direction, y-direction)\n//' @param T total time of survey for longest transect\n//' @param ymax maximum length of a transect\n//' @param buffer buffer distance\n//' @param fixed_sd if move_method = 2\n//' @param hzfn hazard function code (see ?hazardfns)\n//' @param move_method 0 = 2d CDS model, 1 = 2d MDS model (movement estimated),\n//' 2 = 2d MDS model (movement fixed)\n//'\n//' @return negative log-likelihood\n//' @return covered area\n//' unpack auxiliary data\n// [[Rcpp::export]]\ndouble GetPenc(const arma::vec working_parameter,\n const arma::mat transdat,\n const arma::vec auxiliary_data,\n const arma::vec delta,\n const arma::vec num_cells,\n const int T,\n const double ymax,\n const double buffer,\n const double fixed_sd,\n const int hzfn,\n int move_method) {\n\n arma::vec region_size(auxiliary_data.rows(0, 1));\n arma::vec strip_size(2);\n strip_size(0) = 2 * auxiliary_data(2) + 2 * buffer;\n strip_size(1) = ymax + 2 * buffer;\n double observer_speed = auxiliary_data(3);\n int num_transects = transdat.n_rows;\n int transect_type = auxiliary_data(4);\n double dx = delta(0);\n double dt = delta(1);\n // unpack parameters\n arma::vec parameter = Working2Natural(working_parameter, hzfn);\n int npar = parameter.n_elem;\n double sd = 0;\n if (move_method == 1) sd = parameter(npar - 1);\n if (move_method == 2) sd = fixed_sd;\n // setup variables\n int curtrans = 0;\n int curobs = 0;\n double pr_survived;\n double pr_outside;\n double accu_hazard;\n double pdet; \n arma::vec penc(num_transects); penc.zeros();\n // calculate initial probability in each grid cell\n arma::rowvec pr_t = CalcInitialDistribution(num_cells, delta, region_size);\n arma::rowvec old_pr_t(pr_t);\n // probability outside buffer region at t = 0\n pr_outside = 1.0 - arma::prod(strip_size) / arma::prod(region_size);\n // compute movement matrices for survey\n arma::sp_mat trm;\n arma::rowvec flux = arma::ones(num_cells(0));\n if (move_method > 0) {\n trm = CalcTrm(num_cells, sd, dx);\n flux = Diffuse(trm.t(), flux, dt, num_cells);\n flux = 1.0 - flux;\n }\n double num_boundary_states = floor(prod(region_size) / (dx * dx)) - num_cells(0);\n // intialise variables\n int endtime = transdat(curtrans, 2);\n arma::rowvec intrans = InTransect(num_cells, strip_size, dx, auxiliary_data(2), ymax, buffer, transect_type); \n accu_hazard = 0;\n pdet = 0; \n double diff; \n // compute HMM approximation\n for (int t = 0; t < T; ++t) {\n Rcpp::checkUserInterrupt();\n // thin pr_t by those that are detected\n diff = 0; \n diff += arma::accu(pr_t % intrans); \n pr_t = Detect(t, pr_t, parameter, num_cells, delta, strip_size, buffer, observer_speed, transect_type, hzfn);\n diff -= arma::accu(pr_t % intrans); \n pdet += diff * exp(accu_hazard); \n // move animals\n if (move_method > 0) {\n old_pr_t = pr_t;\n // move animals that are inside strip\n pr_t = Diffuse(trm, pr_t, dt, num_cells);\n // move animals outside strip that come into strip\n pr_t += flux * pr_outside / num_boundary_states;\n // account for transversal of boundary\n pr_outside += accu(old_pr_t % flux) - accu(flux) * pr_outside / num_boundary_states;\n }\n // add contribution to accu_hazard\n pr_survived = accu(pr_t) + pr_outside;\n accu_hazard += log(pr_survived);\n // scale to avoid underflow\n pr_t /= pr_survived;\n pr_outside /= pr_survived;\n // if transect ends divide by conditional probability\n while (endtime == t) {\n penc(curtrans) = pdet;\n ++curtrans;\n if (curtrans > transdat.n_rows - 1) {\n endtime = T + 1;\n } else {\n endtime = transdat(curtrans, 2);\n }\n }\n }\n return arma::accu(penc);\n}\n//' Computes PDF of observed detections for each (x,y) cell around the observer.\n//'\n//' @param working_parameter unconstrained version of parameter vector containing\n//' (detection shape, detection scale, diffusion sd)\n//' @param range to compute out to in x and y directions \n//' @param transdat matrix with (stripsize(1), numcells in y, totaltimestep, number of observations)\n//' @param auxiliary_data vector containing (area x extent, area y extent, strip width, transect_type)\n//' @param delta vector of (dx, dt) spacetime increments\n//' @param num_cells number of cells in (total space, x-direction, y-direction)\n//' @param T total time of survey for longest transect\n//' @param ymax maximum length of a transect\n//' @param buffer buffer distance\n//' @param fixed_sd if move_method = 2\n//' @param hzfn hazard function code (see ?hazardfns)\n//' @param move_method 0 = 2d CDS model, 1 = 2d MDS model (movement estimated),\n//' 2 = 2d MDS model (movement fixed)\n//'\n//' @return matrix where (i,j) entry is cell i*dx perpendicular and j*dx forward of\n//' observer\n//' unpack auxiliary data\n// [[Rcpp::export]]\narma::mat GetHist(const arma::vec working_parameter,\n const arma::vec range,\n const arma::mat transdat,\n const arma::vec auxiliary_data,\n const arma::vec delta,\n const arma::vec num_cells,\n const int T,\n const double ymax,\n const double buffer,\n const double fixed_sd = 0,\n const int hzfn = 1,\n int move_method = 1) {\n\n arma::vec region_size(auxiliary_data.rows(0, 1));\n arma::vec strip_size(2);\n strip_size(0) = 2 * auxiliary_data(2) + 2 * buffer;\n strip_size(1) = ymax + 2 * buffer;\n double observer_speed = auxiliary_data(3);\n int num_transects = transdat.n_rows;\n int transect_type = auxiliary_data(4);\n double dx = delta(0);\n double dt = delta(1);\n // unpack parameters\n arma::vec parameter = Working2Natural(working_parameter, hzfn);\n int npar = parameter.n_elem;\n double sd = 0;\n if (move_method == 1) sd = parameter(npar - 1);\n if (move_method == 2) sd = fixed_sd;\n // setup variables\n int curtrans = 0;\n int curobs = 0;\n double pr_survived;\n double pr_outside;\n double accu_hazard;\n arma::vec obspos;\n int sobs;\n int smax;\n int Nperp = floor(2 * range(0) / dx);\n int Nforw = floor(range(1) / dx);\n arma::rowvec count(num_cells(1) * Nforw); count.zeros();\n arma::rowvec accum(num_cells(1) * Nforw); accum.zeros();\n // nalive is the number of transect still being surveyed in the meta-transect\n int nalive = num_transects;\n // calculate initial probability in each grid cell\n arma::rowvec pr_t = CalcInitialDistribution(num_cells, delta, region_size);\n arma::rowvec old_pr_t(pr_t);\n // probability outside buffer region at t = 0\n pr_outside = 1.0 - arma::prod(strip_size) / arma::prod(region_size);\n // compute movement matrices for survey\n arma::sp_mat trm;\n arma::rowvec flux = arma::ones(num_cells(0));\n if (move_method > 0) {\n trm = CalcTrm(num_cells, sd, dx);\n flux = Diffuse(trm.t(), flux, dt, num_cells);\n flux = 1.0 - flux;\n }\n double num_boundary_states = floor(prod(region_size) / (dx * dx)) - num_cells(0);\n arma::rowvec intrans = InTransect(num_cells, strip_size, dx, auxiliary_data(2), ymax, buffer, transect_type); \n // intialise variables\n int endtime = transdat(curtrans, 2);\n accu_hazard = 0;\n // compute HMM approximation\n for (int t = 0; t < T; ++t) {\n Rcpp::checkUserInterrupt();\n obspos = GetObserverPosition(t * dt, strip_size, buffer, delta, transect_type, observer_speed);\n // observer grid cell\n sobs = num_cells(1) * floor(obspos(1) / dx);\n // sum from that point to 2 * Nperp * Nforw state or max size\n smax = sobs + num_cells(1) * Nforw - 1;\n if (smax >= num_cells(0)) smax = num_cells(0) - 1;\n if (sobs >= num_cells(0)) sobs = num_cells(0) - 1;\n // add in all animals present in cell\n count.cols(0, smax - sobs) += exp(log(pr_t.cols(sobs, smax) % intrans.cols(sobs, smax)) + accu_hazard);\n // thin pr_t by those that are detected\n pr_t = Detect(t, pr_t, parameter, num_cells, delta, strip_size, buffer, observer_speed, transect_type, hzfn);\n // subtract those animals still present (failed to be detected)\n count.cols(0, smax - sobs) -= exp(log(pr_t.cols(sobs, smax) % intrans.cols(sobs, smax)) + accu_hazard);\n if (move_method > 0) {\n old_pr_t = pr_t;\n // move animals that are inside strip\n pr_t = Diffuse(trm, pr_t, dt, num_cells);\n // move animals outside strip that come into strip\n pr_t += flux * pr_outside / num_boundary_states;\n // account for transversal of boundary\n pr_outside += accu(old_pr_t % flux) - accu(flux) * pr_outside / num_boundary_states;\n }\n // add contribution to accu_hazard\n pr_survived = accu(pr_t) + pr_outside;\n accu_hazard += log(pr_survived);\n // scale to avoid underflow\n pr_t /= pr_survived;\n pr_outside /= pr_survived;\n // if transect ends divide by conditional probability\n while (endtime == t) {\n accum += count; \n --nalive;\n ++curtrans;\n if (curtrans > transdat.n_rows - 1) {\n endtime = T + 1;\n } else {\n endtime = transdat(curtrans, 2);\n }\n }\n }\n return accum;\n}\n", "meta": {"hexsha": "436cd11ff3f0bb55efe44f950287843a0f7340e2", "size": 41050, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/moveds.cc", "max_stars_repo_name": "r-glennie/moveds", "max_stars_repo_head_hexsha": "3fb04969cd0548e65b230ee4dcfb750ee1560b46", "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/moveds.cc", "max_issues_repo_name": "r-glennie/moveds", "max_issues_repo_head_hexsha": "3fb04969cd0548e65b230ee4dcfb750ee1560b46", "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/moveds.cc", "max_forks_repo_name": "r-glennie/moveds", "max_forks_repo_head_hexsha": "3fb04969cd0548e65b230ee4dcfb750ee1560b46", "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.3274336283, "max_line_length": 127, "alphanum_fraction": 0.570864799, "num_tokens": 12426, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789086703225, "lm_q2_score": 0.6757645879592642, "lm_q1q2_score": 0.5476929457672746}} {"text": "/* Copyright (c) 2010-2018, Delft University of Technology\n * All rigths reserved\n *\n * This file is part of the Tudat. Redistribution and use in source and\n * binary forms, with or without modification, are permitted exclusively\n * under the terms of the Modified BSD license. You should have received\n * a copy of the license with this file. If not, please or visit:\n * http://tudat.tudelft.nl/LICENSE.\n *\n * References\n * PyKEP toolbox, Dario Izzo, ESA Advanced Concepts Team.\n * Richard H. An Introduction to the Mathematics and Methods of Astrodynamics, Revised\n * Edition.\n * Battin, AIAA Education Series.\n *\n */\n\n#include \n\n#include // for asinh and acosh\n\n#include \"Tudat/Mathematics/BasicMathematics/mathematicalConstants.h\"\n\n#include \"Tudat/Astrodynamics/MissionSegments/multiRevolutionLambertTargeterIzzo.h\"\n#include \"Tudat/Mathematics/BasicMathematics/convergenceException.h\"\n\nnamespace tudat\n{\nnamespace mission_segments\n{\n\n//! Compute solution for N revolutions and branch.\nvoid MultiRevolutionLambertTargeterIzzo::computeForRevolutionsAndBranch(\n const int aNumberOfRevolutions, const bool aIsRightBranch )\n{\n // Adjust parameters for new solution\n numberOfRevolutions = aNumberOfRevolutions;\n isRightBranch = aIsRightBranch;\n\n // Check whether number of revolutions is possible\n sanityCheckNumberOfRevolutions( );\n\n // Execute problem solving for new solution\n execute( );\n}\n\n//! Get maximum number of revolutions calculated.\nint MultiRevolutionLambertTargeterIzzo::getMaximumNumberOfRevolutions( )\n{\n if ( !solved )\n {\n transformDimensions( );\n sanityCheckNumberOfRevolutions( );\n }\n\n return maximumNumberOfRevolutions;\n}\n\n//! Sanity check number of revolutions.\nvoid MultiRevolutionLambertTargeterIzzo::sanityCheckNumberOfRevolutions( )\n{\n // If not yet defined, calculate number of revolutions possible.\n if ( maximumNumberOfRevolutions == NO_MAXIMUM_REVOLUTIONS )\n {\n // Temporarily store specified number, as numberOfRevolutions is needed to calculate max\n // (this is a tricky way to work, but on the other hand this makes this approach decidedly\n // different from PyKEP routines and it also happens only once per object).\n int copyOfOriginalNumberOfRevolutions = numberOfRevolutions;\n\n // Calculate first guess of maximum, by dividing the time of flight of the minimum energy\n // ellipse by the normalized time of flight.\n numberOfRevolutions = static_cast< int >(\n normalizedTimeOfFlight / (\n mathematical_constants::PI / 2.0\n * std::sqrt( 2.0 * normalizedSemiPerimeter\n * normalizedSemiPerimeter\n * normalizedSemiPerimeter ) ) );\n\n // If the current guess for the maximum is non-zero, then additional analysis is required to\n // determine the correct maximum.\n if( numberOfRevolutions != 0)\n {\n // The following try-block is meant to check whether the solution converges or not. If\n // the current guess for the maximum number of revolutions is correct, then the problem\n // will converge. If it does not, an exception will be thrown stating that it did not\n // converge. Catching this exception allows to decrease the guess only when the\n // exception occurs, and not under other circumstances.\n try\n {\n // Compute root (no further information is required)\n computeRootTimeOfFlight();\n }\n catch( basic_mathematics::ConvergenceException )\n {\n // If the rootfinder did not converge, then the current guess is wrong and needs to\n // be decreased\n numberOfRevolutions--;\n }\n }\n // No further analysis is needed of the current guess is equal to zero.\n\n // Maximum is now found.\n maximumNumberOfRevolutions = numberOfRevolutions;\n\n // Reinstating original number of revolutions specified.\n numberOfRevolutions = copyOfOriginalNumberOfRevolutions;\n }\n\n // Default: compare maximum with specified number of revolutions.\n // If specified is larger than maximum, no solution is possible.\n if ( numberOfRevolutions > maximumNumberOfRevolutions )\n {\n // Throw exception.\n throw std::runtime_error( \"Number of revolutions specified in Lambert problem is larger than possible. Specified number of revolutions is \" +\n std::to_string( numberOfRevolutions ) + \" while the maximum is \" +\n std::to_string( maximumNumberOfRevolutions ) );\n }\n // Else, nothing wrong.\n}\n\n//! Execute solving procedure (for multiple revolutions).\nvoid MultiRevolutionLambertTargeterIzzo::execute( )\n{\n // Sanity checks.\n sanityCheckTimeOfFlight( );\n sanityCheckGravitationalParameter( );\n\n // Transform dimensions.\n transformDimensions( );\n\n /*// Sanity check for number of revolutions (must be after dimension removal).\n sanityCheckNumberOfRevolutions( );*/\n\n if ( numberOfRevolutions == 0 )\n {\n // call base class function that works on zero revolutions.\n ZeroRevolutionLambertTargeterIzzo::execute( );\n }\n else\n {\n // Solve multi-rev root.\n double multipleRevolutionXParameter = computeRootTimeOfFlight( );\n\n // Reconstruct velocities.\n computeVelocities( multipleRevolutionXParameter );\n }\n\n solved = true;\n}\n\n//! Compute time-of-flight using Lagrange's equation (for multiple revolutions).\ndouble MultiRevolutionLambertTargeterIzzo::computeTimeOfFlight( const double xParameter )\n{\n // Determine semi-major axis.\n const double semiMajorAxis = normalizedMinimumEnergySemiMajorAxis\n / ( 1.0 - xParameter * xParameter );\n\n // If x < 1, the solution is an ellipse.\n if ( xParameter < 1.0 )\n {\n // Alpha parameter in Lagrange's equation (no explanation available).\n const double alphaParameter = 2.0 * std::acos( xParameter );\n\n // Beta parameter in Lagrange's equation (no explanation available).\n double betaParameter;\n\n // If long transfer arc.\n if ( isLongway )\n {\n betaParameter = -2.0 * std::asin(\n std::sqrt( ( normalizedSemiPerimeter - normalizedChord )\n / ( 2.0 * semiMajorAxis ) ) );\n }\n // Otherwise short transfer arc.\n else\n {\n betaParameter = 2.0 * std::asin(\n std::sqrt( ( normalizedSemiPerimeter - normalizedChord )\n / ( 2.0 * semiMajorAxis ) ) );\n }\n\n // Time-of-flight according to Lagrange including multiple revolutions.\n const double timeOfFlight = semiMajorAxis * std::sqrt( semiMajorAxis ) *\n ( ( alphaParameter - std::sin( alphaParameter ) )\n - ( betaParameter - std::sin( betaParameter ) )\n + 2.0 * mathematical_constants::PI\n * numberOfRevolutions );\n\n return timeOfFlight;\n }\n // Otherwise it is a hyperbola.\n else\n {\n // Alpha parameter in Lagrange's equation (no explanation available).\n const double alphaParameter = 2.0 * boost::math::acosh( xParameter );\n\n // Beta parameter in Lagrange's equation (no explanation available).\n double betaParameter;\n\n // If long transfer arc.\n if ( isLongway )\n {\n betaParameter = -2.0 * boost::math::asinh( std::sqrt( ( normalizedSemiPerimeter\n - normalizedChord )\n / ( -2.0 * semiMajorAxis ) ) );\n }\n // Otherwise short transfer arc\n else\n {\n betaParameter = 2.0 * boost::math::asinh( std::sqrt( ( normalizedSemiPerimeter\n - normalizedChord )\n / ( -2.0 * semiMajorAxis ) ) );\n }\n\n // Time-of-flight according to Lagrange.\n const double timeOfFlightLagrange = -semiMajorAxis * std::sqrt( -semiMajorAxis ) *\n ( ( std::sinh( alphaParameter ) - alphaParameter )\n - ( std::sinh( betaParameter ) - betaParameter ) );\n\n return timeOfFlightLagrange;\n }\n}\n\n//! Solve the time of flight equation for x (for multiple revolutions).\ndouble MultiRevolutionLambertTargeterIzzo::computeRootTimeOfFlight( )\n{\n using mathematical_constants::PI;\n\n // Define initial guesses for abcissae (x) and ordinates (y).\n double x1, x2;\n\n if ( isRightBranch )\n { // right branch solution.\n x1 = std::tan( .7234 * PI / 2.0 );\n x2 = std::tan( .5234 * PI / 2.0 );\n }\n else\n { // left branch solution.\n x1 = std::tan( -.5234 * PI / 2.0 );\n x2 = std::tan( -.2234 * PI / 2.0 );\n }\n\n double y1 = computeTimeOfFlight( std::atan( x1 ) * 2.0 / PI ) - normalizedTimeOfFlight;\n\n double y2 = computeTimeOfFlight( std::atan( x2 ) * 2.0 / PI ) - normalizedTimeOfFlight;\n\n // Declare and initialize root-finding parameters.\n double rootFindingError = 1.0, xNew = 0.0, yNew = 0.0;\n int iterator = 0;\n\n // Root-finding loop.\n while ( ( rootFindingError > convergenceTolerance ) && ( y1 != y2 )\n && ( iterator < maximumNumberOfIterations ) )\n {\n // Update iterator.\n iterator++;\n\n // Compute new x-value.\n xNew = ( x1 * y2 - y1 * x2 ) / ( y2 - y1 );\n\n // Compute corresponding y-value.\n yNew = computeTimeOfFlight( std::atan( xNew ) * 2.0 / PI ) - normalizedTimeOfFlight;\n\n // Update abcissae and ordinates.\n x1 = x2;\n y1 = y2;\n x2 = xNew;\n y2 = yNew;\n\n // Compute root-finding error.\n rootFindingError = std::fabs( x1 - xNew );\n }\n\n // Verify that root-finder has converged.\n if ( iterator == maximumNumberOfIterations )\n {\n throw basic_mathematics::ConvergenceException(\n \"Multi-Revolution Lambert targeter failed to converge to a solution. Reached the maximum number of iterations: %d\"\n + std::to_string( maximumNumberOfIterations ) );;\n }\n\n // Revert to x parameter.\n double xParameter = std::atan( xNew ) * 2.0 / PI;\n return xParameter;\n}\n\n// Add compute maximum number of revolutions routine?\n\n} // namespace mission_segments\n} // namespace tudat\n", "meta": {"hexsha": "e797e6acf453b5dc104daabda60900ba63a1a0f4", "size": 10773, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Tudat/Astrodynamics/MissionSegments/multiRevolutionLambertTargeterIzzo.cpp", "max_stars_repo_name": "J-Westin/tudat", "max_stars_repo_head_hexsha": "82ebe9e6e2dd51d0688b77960e62e980e6b8bcb8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Tudat/Astrodynamics/MissionSegments/multiRevolutionLambertTargeterIzzo.cpp", "max_issues_repo_name": "J-Westin/tudat", "max_issues_repo_head_hexsha": "82ebe9e6e2dd51d0688b77960e62e980e6b8bcb8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Tudat/Astrodynamics/MissionSegments/multiRevolutionLambertTargeterIzzo.cpp", "max_forks_repo_name": "J-Westin/tudat", "max_forks_repo_head_hexsha": "82ebe9e6e2dd51d0688b77960e62e980e6b8bcb8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.0206185567, "max_line_length": 150, "alphanum_fraction": 0.6152418082, "num_tokens": 2426, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8596637469145054, "lm_q2_score": 0.6370308082623217, "lm_q1q2_score": 0.5476322915307634}} {"text": "#include \"MeshGeometry.h\"\n#include \"MeshConnectivity.h\"\n#include \n\nMeshGeometry::MeshGeometry()\n{\n \n}\n\nMeshGeometry::MeshGeometry(const Eigen::MatrixXd &V, MeshConnectivity &mesh)\n{\n // compute barycentric matrices and Js\n int nfaces = mesh.nFaces();\n Bs.resize(nfaces);\n Js.resize(2 * nfaces, 2);\n faceNormals.resize(nfaces, 3);\n\n averageEdgeLength = 0;\n for (int i = 0; i < nfaces; i++)\n {\n Eigen::Vector3d v0 = V.row(mesh.faces()(i, 0));\n Eigen::Vector3d v1 = V.row(mesh.faces()(i, 1));\n Eigen::Vector3d v2 = V.row(mesh.faces()(i, 2));\n Bs[i].col(0) = v1 - v0;\n Bs[i].col(1) = v2 - v0;\n\n averageEdgeLength += (v1 - v0).norm();\n averageEdgeLength += (v2 - v1).norm();\n averageEdgeLength += (v0 - v2).norm();\n\n Eigen::Vector3d n = (v1 - v0).cross(v2 - v0);\n n /= n.norm();\n faceNormals.row(i) = n.transpose();\n\n Eigen::Matrix2d BTB = Bs[i].transpose() * Bs[i];\n Eigen::Matrix ncrossB;\n ncrossB.col(0) = n.cross(v1 - v0);\n ncrossB.col(1) = n.cross(v2 - v0);\n Js.block<2, 2>(2 * i, 0) = BTB.inverse() * Bs[i].transpose() * ncrossB;\n }\n\n averageEdgeLength /= 3.0 * nfaces;\n\n // compute cDiffs and transition matrices\n int nedges = mesh.nEdges();\n cDiffs.resize(2 * nedges, 2);\n Ts.resize(2 * nedges, 4);\n for (int edgeidx = 0; edgeidx < nedges; edgeidx++)\n { \n //collect neighboring face indices\n int face1 = mesh.edgeFace(edgeidx, 0);\n int face2 = mesh.edgeFace(edgeidx, 1);\n\n if(face1 == -1 || face2 == -1)\n continue;\n\n int v1 = mesh.edgeVertex(edgeidx, 0);\n int v2 = mesh.edgeVertex(edgeidx, 1);\n\n Eigen::Vector3d n1 = faceNormals.row(face1).transpose();\n Eigen::Vector3d n2 = faceNormals.row(face2).transpose();\n // collect: (1) the midpoint of the common edge, (2) unit vector in direction of common edge,\n // (3) the face normals, (4) the centroid of neighboring faces\n\n Eigen::Vector3d midpt = 0.5 * (V.row(v1).transpose() + V.row(v2).transpose());\n Eigen::Vector3d commone = V.row(v2).transpose() - V.row(v1).transpose();\n commone /= commone.norm();\n Eigen::Vector3d centroids[2];\n centroids[0].setZero();\n centroids[1].setZero();\n\n for (int i = 0; i < 3; i++)\n {\n centroids[0] += V.row(mesh.faces()(face1, i)).transpose();\n centroids[1] += V.row(mesh.faces()(face2, i)).transpose();\n }\n\n centroids[0] /= 3.0;\n centroids[1] /= 3.0;\n\n //rotate each centroid into the plane of the opposite triangle and compute ci minus c\n\n Eigen::Vector3d t1 = n1.cross(commone);\n Eigen::Vector3d t2 = n2.cross(commone);\n Eigen::Vector3d diff2 = centroids[1] - midpt;\n double alpha = commone.dot(diff2);\n double beta = t2.dot(diff2);\n\n Eigen::Matrix2d BTB1 = Bs[face1].transpose() * Bs[face1];\n Eigen::Matrix2d BTB2 = Bs[face2].transpose() * Bs[face2];\n\n cDiffs.row(2 * edgeidx) = BTB1.inverse() * Bs[face1].transpose() * (midpt + alpha * commone + beta * t1 - centroids[0]);\n Eigen::Vector3d diff1 = centroids[0] - midpt;\n alpha = commone.dot(diff1);\n beta = t1.dot(diff1);\n cDiffs.row(2 * edgeidx + 1) = BTB2.inverse() * Bs[face2].transpose() * (midpt + alpha*commone + beta * t2 - centroids[1]);\n\n Eigen::Vector3d e1 = V.row(mesh.faces()(face1, 1)).transpose() - V.row(mesh.faces()(face1, 0)).transpose();\n Eigen::Vector3d e2 = V.row(mesh.faces()(face1, 2)).transpose() - V.row(mesh.faces()(face1, 0)).transpose();\n\n double alpha1 = commone.dot(e1);\n double beta1 = t1.dot(e1);\n Eigen::Vector3d newe1 = alpha1*commone + beta1 * t2;\n Ts.block<2, 1>(2 * edgeidx, 0) = BTB2.inverse() * Bs[face2].transpose() * newe1;\n\n double alpha2 = commone.dot(e2);\n double beta2 = t1.dot(e2);\n Eigen::Vector3d newe2 = alpha2*commone + beta2*t2;\n Ts.block<2, 1>(2 * edgeidx, 1) = BTB2.inverse() * Bs[face2].transpose() * newe2;\n\n e1 = V.row(mesh.faces()(face2, 1)).transpose() - V.row(mesh.faces()(face2, 0)).transpose();\n e2 = V.row(mesh.faces()(face2, 2)).transpose() - V.row(mesh.faces()(face2, 0)).transpose();\n\n alpha1 = commone.dot(e1);\n beta1 = t2.dot(e1);\n newe1 = alpha1 * commone + beta1 * t1;\n Ts.block<2, 1>(2 * edgeidx, 2) = BTB1.inverse() * Bs[face1].transpose() * newe1;\n\n alpha2 = commone.dot(e2);\n beta2 = t2.dot(e2);\n newe2 = alpha2*commone + beta2*t1;\n Ts.block<2, 1>(2 * edgeidx, 3) = BTB1.inverse() * Bs[face1].transpose() * newe2;\n }\n}\n", "meta": {"hexsha": "ca2ca5af8c6a752a769f7770540b8862961f6e98", "size": 4743, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "MeshGeometry.cpp", "max_stars_repo_name": "csyzzkdcz/effective-garbanzo", "max_stars_repo_head_hexsha": "87223ecfc26371a9b251a70a0111ca4e0d95b594", "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": "MeshGeometry.cpp", "max_issues_repo_name": "csyzzkdcz/effective-garbanzo", "max_issues_repo_head_hexsha": "87223ecfc26371a9b251a70a0111ca4e0d95b594", "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": "MeshGeometry.cpp", "max_forks_repo_name": "csyzzkdcz/effective-garbanzo", "max_forks_repo_head_hexsha": "87223ecfc26371a9b251a70a0111ca4e0d95b594", "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": 37.944, "max_line_length": 130, "alphanum_fraction": 0.5694707991, "num_tokens": 1491, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8596637505099168, "lm_q2_score": 0.6370307944803832, "lm_q1q2_score": 0.5476322819733183}} {"text": "#ifndef PR_TREE_POINT_HPP\n#define PR_TREE_POINT_HPP\n#include \n#include \n#include \n#include \n#include \n\nnamespace perior\n{\n\nnamespace meta\n{\ntemplate\nstruct and_{};\ntemplate\nstruct and_: std::integral_constant{};\ntemplate\nstruct and_: std::integral_constant::value : false)>{};\n} // meta\n\ntemplate\nstruct point\n{\n typedef T value_type;\n typedef value_type scalar_type;\n constexpr static std::size_t dim = N;\n\n point() noexcept = default;\n ~point() noexcept = default;\n\n template...>::value,\n std::nullptr_t>::type = nullptr>\n point(Ts&& ... xs) noexcept : v_{{std::forward(xs)...}}{}\n\n point(const point& rhs) noexcept = default;\n point(point&& rhs) noexcept = default;\n point& operator=(const point& rhs) noexcept = default;\n point& operator=(point&& rhs) noexcept = default;\n\n point& operator+=(const point& rhs) noexcept\n {\n for(std::size_t i=0; i v_;\n};\n\ntemplate\ninline bool\noperator==(const point& lhs, const point& rhs) noexcept\n{\n for(std::size_t i=0; i\ninline bool\noperator!=(const point& lhs, const point& rhs) noexcept\n{\n for(std::size_t i=0; i\ninline point\noperator+(const point& lhs, const point& rhs) noexcept\n{\n point p;\n for(std::size_t i=0; i\ninline point\noperator-(const point& lhs, const point& rhs) noexcept\n{\n point p;\n for(std::size_t i=0; i\ninline point\noperator*(const point& lhs, const T rhs) noexcept\n{\n point p;\n for(std::size_t i=0; i\ninline point\noperator*(const T lhs, const point& rhs) noexcept\n{\n point p;\n for(std::size_t i=0; i\ninline point\noperator/(const point& lhs, const T rhs) noexcept\n{\n point p;\n for(std::size_t i=0; i\ninline std::basic_ostream&\noperator<<(std::basic_ostream& os,\n const point& pos)\n{\n os << \"point<\" << boost::typeindex::type_id().pretty_name() << \", \" << N << \">(\";\n for(std::size_t i=0; i\ninline point\nabs(const point& lhs) noexcept\n{\n point p;\n for(std::size_t i=0; i\ninline T\ndot_product(const point& lhs, const point& rhs) noexcept\n{\n T retval = 0;\n for(std::size_t i=0; i\ninline point\ncross_product(const point& lhs, const point& rhs) noexcept\n{\n return point(lhs[1] * rhs[2] - lhs[2] * rhs[1],\n lhs[2] * rhs[0] - lhs[0] * rhs[2],\n lhs[0] * rhs[1] - lhs[1] * rhs[0]);\n}\n\ntemplate\ninline T\nlength_sq(const point& lhs) noexcept\n{\n return dot_product(lhs, lhs);\n}\n\ntemplate\ninline T\nlength(const point& lhs) noexcept\n{\n return std::sqrt(length_sq(lhs));\n}\n\n}// perior\n#endif//TEST_PERIOR_TREE_POINT_TRAITS_HPP\n", "meta": {"hexsha": "d2a2bb8f85349713e0aa10c81142b1044cefcacd", "size": 5332, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "experimental/point.hpp", "max_stars_repo_name": "lasergyro/periortree", "max_stars_repo_head_hexsha": "1ab9abb385228d0aef08fa0eabdf5adb6f71c0a8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2017-09-01T14:46:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-15T11:11:50.000Z", "max_issues_repo_path": "experimental/point.hpp", "max_issues_repo_name": "lasergyro/periortree", "max_issues_repo_head_hexsha": "1ab9abb385228d0aef08fa0eabdf5adb6f71c0a8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2018-02-14T03:37:38.000Z", "max_issues_repo_issues_event_max_datetime": "2018-02-14T12:16:29.000Z", "max_forks_repo_path": "experimental/point.hpp", "max_forks_repo_name": "lasergyro/periortree", "max_forks_repo_head_hexsha": "1ab9abb385228d0aef08fa0eabdf5adb6f71c0a8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2018-02-14T03:52:23.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-08T15:49:30.000Z", "avg_line_length": 23.3859649123, "max_line_length": 92, "alphanum_fraction": 0.5692048012, "num_tokens": 1613, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7310585903489891, "lm_q2_score": 0.7490872075132152, "lm_q1q2_score": 0.5476266379730718}} {"text": "/* =========================================================================\n Copyright (c) 2010-2014, Institute for Microelectronics,\n Institute for Analysis and Scientific Computing,\n TU Wien.\n Portions of this software are copyright by UChicago Argonne, LLC.\n\n -----------------\n ViennaCL - The Vienna Computing Library\n -----------------\n\n Project Head: Karl Rupp rupp@iue.tuwien.ac.at\n \n (A list of authors and contributors can be found in the PDF manual)\n\n License: MIT (X11), see file LICENSE in the base directory\n============================================================================= */\n\n/*\n*\n* Tutorial: Shows how to exchange data between ViennaCL and MTL4 (http://www.mtl4.org/) objects.\n* \n*/\n\n//\n// include necessary system headers\n//\n#include \n\n//\n// Include MTL4 headers\n//\n#include \n#include \n\n//\n// Must be set prior to any ViennaCL includes if you want to use ViennaCL algorithms on MTL4 objects\n//\n#define VIENNACL_WITH_MTL4 1\n\n//#define VIENNACL_BUILD_INFO\n//#define VIENNACL_DEBUG_ALL\n\n//\n// ViennaCL includes\n//\n#include \"viennacl/vector.hpp\"\n#include \"viennacl/matrix.hpp\"\n#include \"viennacl/linalg/vector_operations.hpp\"\n#include \"viennacl/compressed_matrix.hpp\"\n\n#include \"viennacl/linalg/ilu.hpp\"\n#include \"viennacl/linalg/cg.hpp\"\n#include \"viennacl/linalg/bicgstab.hpp\"\n#include \"viennacl/linalg/gmres.hpp\"\n\n\n// Some helper functions for this tutorial:\n#include \"Random.hpp\"\n#include \"vector-io.hpp\"\n#include \"../benchmarks/benchmark-utils.hpp\"\n\ntemplate\nvoid run_test()\n{\n typedef mtl::dense2D MTL4DenseMatrix;\n typedef mtl::compressed2D MTL4SparseMatrix;\n \n //\n // Create and fill dense matrices from the MTL4 library:\n //\n mtl::dense2D mtl4_densemat(5, 5);\n mtl::dense2D mtl4_densemat2(5, 5);\n mtl4_densemat(0,0) = 2.0; mtl4_densemat(0,1) = -1.0;\n mtl4_densemat(1,0) = -1.0; mtl4_densemat(1,1) = 2.0; mtl4_densemat(1,2) = -1.0;\n mtl4_densemat(2,1) = -1.0; mtl4_densemat(2,2) = -1.0; mtl4_densemat(2,3) = -1.0;\n mtl4_densemat(3,2) = -1.0; mtl4_densemat(3,3) = 2.0; mtl4_densemat(3,4) = -1.0;\n mtl4_densemat(4,4) = -1.0; mtl4_densemat(4,4) = -1.0;\n \n \n //\n // Create and fill sparse matrices from the MTL4 library:\n //\n MTL4SparseMatrix mtl4_sparsemat;\n set_to_zero(mtl4_sparsemat); \n mtl4_sparsemat.change_dim(5, 5);\n\n MTL4SparseMatrix mtl4_sparsemat2;\n set_to_zero(mtl4_sparsemat2); \n mtl4_sparsemat2.change_dim(5, 5);\n \n {\n mtl::matrix::inserter< MTL4SparseMatrix > ins(mtl4_sparsemat);\n typedef typename mtl::Collection::value_type ValueType;\n ins(0,0) << ValueType(2.0); ins(0,1) << ValueType(-1.0);\n ins(1,1) << ValueType(2.0); ins(1,2) << ValueType(-1.0);\n ins(2,2) << ValueType(-1.0); ins(2,3) << ValueType(-1.0);\n ins(3,3) << ValueType(2.0); ins(3,4) << ValueType(-1.0);\n ins(4,4) << ValueType(-1.0);\n }\n \n //\n // Create and fill a few vectors from the MTL4 library:\n //\n mtl::dense_vector mtl4_rhs(5, 0.0);\n mtl::dense_vector mtl4_result(5, 0.0);\n mtl::dense_vector mtl4_temp(5, 0.0);\n \n\n mtl4_rhs(0) = 10.0;\n mtl4_rhs(1) = 11.0;\n mtl4_rhs(2) = 12.0;\n mtl4_rhs(3) = 13.0;\n mtl4_rhs(4) = 14.0;\n \n //\n // Let us create the ViennaCL analogues:\n //\n viennacl::vector vcl_rhs(5);\n viennacl::vector vcl_result(5);\n viennacl::matrix vcl_densemat(5, 5);\n viennacl::compressed_matrix vcl_sparsemat(5, 5);\n\n //\n // Directly copy the MTL4 objects to ViennaCL objects\n //\n viennacl::copy(&(mtl4_rhs[0]), &(mtl4_rhs[0]) + 5, vcl_rhs.begin()); //method 1: via iterator interface (cf. std::copy())\n viennacl::copy(mtl4_rhs, vcl_rhs); //method 2: via built-in wrappers (convenience layer)\n \n viennacl::copy(mtl4_densemat, vcl_densemat);\n viennacl::copy(mtl4_sparsemat, vcl_sparsemat);\n \n // For completeness: Copy matrices from ViennaCL back to Eigen:\n viennacl::copy(vcl_densemat, mtl4_densemat2);\n viennacl::copy(vcl_sparsemat, mtl4_sparsemat2);\n \n //\n // Run matrix-vector products and compare results:\n //\n mtl4_result = mtl4_densemat * mtl4_rhs;\n vcl_result = viennacl::linalg::prod(vcl_densemat, vcl_rhs);\n viennacl::copy(vcl_result, mtl4_temp);\n mtl4_result -= mtl4_temp;\n std::cout << \"Difference for dense matrix-vector product: \" << mtl::two_norm(mtl4_result) << std::endl;\n mtl4_result = mtl4_densemat2 * mtl4_rhs - mtl4_temp;\n std::cout << \"Difference for dense matrix-vector product (MTL4->ViennaCL->MTL4): \"\n << mtl::two_norm(mtl4_result) << std::endl;\n \n //\n // Same for sparse matrix:\n // \n mtl4_result = mtl4_sparsemat * mtl4_rhs;\n vcl_result = viennacl::linalg::prod(vcl_sparsemat, vcl_rhs);\n viennacl::copy(vcl_result, mtl4_temp);\n mtl4_result -= mtl4_temp;\n std::cout << \"Difference for sparse matrix-vector product: \" << mtl::two_norm(mtl4_result) << std::endl;\n mtl4_result = mtl4_sparsemat2 * mtl4_rhs - mtl4_temp;\n std::cout << \"Difference for sparse matrix-vector product (MTL4->ViennaCL->MTL4): \"\n << mtl::two_norm(mtl4_result) << std::endl;\n \n //\n // Please have a look at the other tutorials on how to use the ViennaCL types\n //\n}\n\n\n\nint main(int, char *[])\n{\n std::cout << \"----------------------------------------------\" << std::endl;\n std::cout << \"## Single precision\" << std::endl;\n std::cout << \"----------------------------------------------\" << std::endl;\n run_test();\n \n#ifdef VIENNACL_HAVE_OPENCL \n if ( viennacl::ocl::current_device().double_support() )\n#endif\n {\n std::cout << \"----------------------------------------------\" << std::endl;\n std::cout << \"## Double precision\" << std::endl;\n std::cout << \"----------------------------------------------\" << std::endl;\n run_test();\n }\n \n std::cout << std::endl;\n std::cout << \"!!!! TUTORIAL COMPLETED SUCCESSFULLY !!!!\" << std::endl;\n std::cout << std::endl;\n}\n", "meta": {"hexsha": "745804a26ff2ee216a6d051a11ca8fd0611c95f2", "size": 6254, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/tutorial/mtl4-with-viennacl.cpp", "max_stars_repo_name": "denis14/ViennaCL-1.5.2", "max_stars_repo_head_hexsha": "fec808905cca30196e10126681611bdf8da5297a", "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": "examples/tutorial/mtl4-with-viennacl.cpp", "max_issues_repo_name": "denis14/ViennaCL-1.5.2", "max_issues_repo_head_hexsha": "fec808905cca30196e10126681611bdf8da5297a", "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": "examples/tutorial/mtl4-with-viennacl.cpp", "max_forks_repo_name": "denis14/ViennaCL-1.5.2", "max_forks_repo_head_hexsha": "fec808905cca30196e10126681611bdf8da5297a", "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": 33.2659574468, "max_line_length": 124, "alphanum_fraction": 0.6124080588, "num_tokens": 1951, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7490872131147276, "lm_q2_score": 0.7310585727705127, "lm_q1q2_score": 0.5476266289002936}} {"text": "#pragma once\n\n#include \"ArithmeticProgression.hpp\"\n#include \"Misc.hpp\"\n#include \"Sequences.hpp\"\n#include \"VectorHelpers.hpp\"\n#include \n\nnamespace discreture\n{\n\n////////////////////////////////////////////////////////////////////////////////////\n/// \\brief Class for iterating through all dyck (dyck) paths.\n/// \\param IntType must be a SIGNED integer type.\n///\n/// Dyck paths, also called Catalan Paths, are paths that go from \\f$(0,0)\\f$ to\n/// \\f$(0,2n)\\f$, which never go below the \\f$ y=0\\f$ line, in which each step\n/// is from \\f$(x,y)\\f$ to either \\f$(x+1,y+1)\\f$ or \\f$(x+1,y-1)\\f$ #Example\n/// Usage:\n///\n/// dyck_paths X(3)\n/// for (auto&& x : X)\n/// cout << x << endl;\n/// Prints out:\n/// [ 1 1 1 -1 -1 -1 ]\n/// [ 1 1 -1 1 -1 -1 ]\n/// [ 1 -1 1 1 -1 -1 ]\n/// [ 1 1 -1 -1 1 -1 ]\n/// [ 1 -1 1 -1 1 -1 ]\n///\n/// # Example: Parenthesis\n///\n/// dyck_paths X(3)\n/// for (auto&& x : X)\n/// cout << dyck_paths::to_string(x, \"()\") << endl;\n///\n/// Prints out:\n/// ((()))\n/// (()())\n/// ()(())\n/// (())()\n/// ()()()\n///\n/////////////////////////////////////////////////////////////////////////////////////\ntemplate >\nclass DyckPaths\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 dyck_path = value_type;\n using difference_type = std::ptrdiff_t;\n using size_type = difference_type;\n class iterator;\n using const_iterator = iterator;\n\n // **************** Begin static functions\n static void next_dyck_path(dyck_path& data)\n {\n size_t n_ = data.size()/2;\n\n if (n_ == 0)\n return;\n\n if (data[1] != -1)\n {\n size_t loc = 2;\n\n while (data[loc] != -1)\n ++loc;\n\n data[loc] = 1;\n data[loc - 1] = -1;\n\n return;\n }\n\n size_t verif = 0;\n size_t i = 1;\n\n while (i < n_ && verif == 0)\n {\n if (data[(2*i) + 1] == 1)\n verif = ((2*i) + 1);\n\n ++i;\n }\n\n // for(nuint i=1; i= 0\n ///\n ////////////////////////////////////////////////////////////\n explicit DyckPaths(IntType n) : n_(n) {}\n\n ////////////////////////////////////////////////////////////\n /// \\brief The total number of dyck_paths\n ///\n /// \\return binomial(2n,n)/(n+1)\n ///\n ////////////////////////////////////////////////////////////\n size_type size() const { return catalan(n_); }\n\n IntType get_n() const { return n_; }\n\n ////////////////////////////////////////////////////////////\n /// \\brief Forward iterator class.\n ////////////////////////////////////////////////////////////\n class iterator\n : public boost::iterator_facade\n {\n public:\n iterator() = default; // empty initializer\n explicit iterator(IntType n) : ID_(0), data_(2*n, 1)\n {\n for (size_t i = n; i < data_.size(); ++i)\n data_[i] = -1;\n }\n\n size_type ID() const { return ID_; }\n\n bool is_at_end(IntType n) const { return ID_ == catalan(n); }\n\n void reset(IntType n)\n {\n ID_ = 0;\n data_.resize(2*n);\n auto r = static_cast(n);\n for (size_t i = 0; i < r; ++i)\n data_[i] = 1;\n\n for (size_t i = r; i < data_.size(); ++i)\n data_[i] = -1;\n }\n\n static const 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\n next_dyck_path(data_);\n }\n\n const dyck_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 dyck_path data_{};\n\n friend class boost::iterator_core_access;\n }; // end class iterator\n\n iterator begin() const { return iterator(n_); }\n\n const iterator end() const\n {\n return iterator::make_invalid_with_id(size());\n }\n\nprivate:\n IntType n_;\n\n}; // end class DyckPaths\n\nusing boost::container::static_vector;\n\nusing dyck_paths = DyckPaths;\nusing dyck_paths_stack = DyckPaths>;\n\n} // namespace discreture\n", "meta": {"hexsha": "579d01a5f70e330597409c694d5288b3c230bfd8", "size": 5913, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/Discreture/DyckPaths.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/DyckPaths.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/DyckPaths.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": 24.9493670886, "max_line_length": 97, "alphanum_fraction": 0.4336208354, "num_tokens": 1494, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7490872131147275, "lm_q2_score": 0.7310585669110202, "lm_q1q2_score": 0.5476266245110226}} {"text": "//////////////////////////////////////////////////////////////////////////////\n//////////////////////////////////////////////////////////////////////////////\n// Observable functions for Kitaev Quantum Monte Carlo\n// written by: Tim Eschmann, June 2016\n// Modified version: February 2019\n//////////////////////////////////////////////////////////////////////////////\n//////////////////////////////////////////////////////////////////////////////\n \n#define _USE_MATH_DEFINES\n\n#include \n#include \n#include \n#include \n\nusing namespace arma;\n \n///////////////////////////////////////////////////////////////\n// Calculate free energy for a given Z2 configuration:\n///////////////////////////////////////////////////////////////\n\ndouble free_en(vec ev, double b)\n{\n int p; // running index\n double fe = 0; // free energy\n \n // Calculating:\n for (p = 0; p < size(ev)[0]/2; p++)\n {\n fe -= (1/b)*logl(2*coshl(b*ev[p]/2)); \n }\n\n return fe;\n \n}\n \n///////////////////////////////////////////////////////////////\n// Calculate internal energy of the Majorana fermion system:\n///////////////////////////////////////////////////////////////\n\ndouble en(vec ev, double b)\n{\n int q; // running index;\n double en = 0; // internal energy\n \n for (q = 0; q < size(ev)[0]/2; q++)\n {\n en += ev[q]/2 * tanhl(-b * ev[q]/2);\n }\n \n return en;\n}\n\n///////////////////////////////////////////////////////////////\n// Calculate derivative of E w.r.t. beta:\n///////////////////////////////////////////////////////////////\n\ndouble diffE(vec ev, double b)\n{\n int qq; // running index\n double drv = 0;\n for (qq = 0; qq < size(ev)[0]/2; qq++)\n {\n //drv += ev[qq]*ev[qq]/4. * (1 - tanh(-beta_ * ev[qq]/2)*tanh(-beta_ * ev[qq]/2));\n drv += powl(ev[qq], 2)/4. / powl((coshl(-b * ev[qq]/2)),2);\n }\n\n return drv;\n}\n \n///////////////////////////////////////////////////////////////\n// Calculate average flux per elementary plaquette:\n///////////////////////////////////////////////////////////////\n\nstd::complex flux(cx_mat ham, Mat plaq)\n{\n std::complex flux;\n std::complex av_flux = std::complex(0.0, 0.0);\n int N = size(ham)[0];\n int M1 = size(plaq)[0];\n int M2 = size(plaq)[1];\n int coord1, coord2;\n \n for (int i = 0; i < M1; i++)\n {\n flux = std::complex(1.0, 0.0);\n for (int j = 0; j < M2; j++)\n {\n coord1 = plaq(i,j) / N;\n coord2 = plaq(i,j) % N;\n \n // Plaquette operator: W_p = prod_ (-i*u_ij)\n flux *= (-ham(coord1, coord2)) / std::abs(ham(coord1, coord2));\n }\n av_flux += flux;\n }\n\n av_flux /= double(M1);\n\n return av_flux;\n \n}\n\n///////////////////////////////////////////////////////////////\n// Calculate flux disorder ratio p:\n///////////////////////////////////////////////////////////////\n\ndouble get_p(cx_mat ham, Mat plaq)\n{\n std::complex flux;\n double p;\n int N = size(ham)[0];\n int M1 = size(plaq)[0];\n int M2 = size(plaq)[1];\n int coord1, coord2;\n \n for (int i = 0; i < M1; i++)\n {\n flux = std::complex(1.0, 0.0);\n for (int j = 0; j < M2; j++)\n {\n coord1 = plaq(i,j) / N;\n coord2 = plaq(i,j) % N;\n \n // Plaquette operator: W_p = prod_ (-i*u_ij)\n flux *= (-ham(coord1, coord2)) / std::abs(ham(coord1, coord2));\n }\n if ((M2 % 4 == 0) && (flux == std::complex(-1, 0)))\n p += 1;\n else if ((M2 % 4 == 2) && (flux == std::complex(1, 0)))\n p += 1;\n else if ((M2 % 2 != 0) && (flux == std::complex(0, 1)))\n p += 1;\n }\n\n p /= double(M1);\n\n return p;\n \n}\n\n///////////////////////////////////////////////////////////////\n// Give flux configurations as output:\n///////////////////////////////////////////////////////////////\ncx_vec flux_confs(cx_mat ham, Mat plaq)\n{\n int M1 = size(plaq)[0];\n int M2 = size(plaq)[1];\n int N = size(ham)[0];\n int coord1, coord2;\n cx_vec confs(M1);\n std::complex flux;\n\n for (int i = 0; i < M1; i++)\n {\n flux = std::complex(1.0, 0.0);\n for (int j = 0; j < M2; j++)\n {\n coord1 = plaq(i,j) / N;\n coord2 = plaq(i,j) % N;\n \n // Plaquette operator: W_p = prod_ (-i*u_ij)\n flux *= (-ham(coord1, coord2)) / std::abs(ham(coord1, coord2));\n }\n\n confs[i] = flux;\n }\n\n return confs;\n\n} \n\n///////////////////////////////////////////////////////////////\n// Calculate spin-spin correlation:\n// Make sure only to include one subset of bonds\n///////////////////////////////////////////////////////////////\n\ndouble correlation(cx_mat ham, std::vector v_, double b)\n{\n double value = 0.;\n std::complex av;\n vec eigval;\n cx_mat eigvec;\n int N = size(ham)[0];\n int coord1, coord2;\n \n eig_sym(eigval, eigvec, ham);\n //eigvec = normalise(eigvec);\n\n for (int j = 0; j < v_.size(); j++)\n {\n coord1 = v_[j]/N;\n coord2 = v_[j]%N;\n \n for (int i = size(eigval)[0]/2; i < size(eigval)[0]; i++)\n {\n av = conj(eigvec(coord1,i))*((-ham(coord1, coord2)) / std::abs(ham(coord1, coord2)))*eigvec(coord2, i);\n av += conj(eigvec(coord2,i))*((-ham(coord2, coord1)) / std::abs(ham(coord2, coord1)))*eigvec(coord1, i);\n value -= real(av)*tanhl(b * eigval[i]/2.);\n }\n }\n\n value *= 2/double(N); \n return value;\n \n}\n\n/////////////////////////////////////////////////////////\n// Set up simulation temperatures (w. different options):\n///////////////////////////////////////////////////////// \n\ndouble calc_temp(double T_min, double T_max, int me, int np, std::string dist)\n{\n int i;\n double T;\n \n // a) Read temperature distribution from file:\n if (dist == \"external\")\n {\n double temperatures[np];\n std::ifstream tempfile(\"temp.saved\", std::ifstream::in);\n if(tempfile.good())\n {\n for (i = 0; i < np; i++)\n {\n tempfile >> temperatures[i];\n }\n }\n\n T = temperatures[me - 1];\n }\n\n // b) Linear temperature distribution:\n else if (dist == \"lin\")\n {\n T = T_min + (T_max - T_min)*(me - 1)/float(np);\n }\n // c) Logarithmic temperature distribution:*/ \n else if (dist == \"log\")\n {\n T = pow(10,log10(T_min)+((log10(T_max) - log10(T_min))*(me - 1)/double(np)));\n }\n // d) Double-logarithmic temperature distribution:\n else if (dist == \"double_log\")\n {\n T = pow(10,log10(T_min)+((log10(T_max) - log10(T_min))*pow(10, -(np - (me - 1))/double(np))));\n }\n\n return T;\n\n\n}\n\n\n\n//////////////////////////////////////////////////////////////////////////////\n//////////////////////////////////////////////////////////////////////////////\n// Ensemble optimization functions \n// -> check if MC replica has been at T_min or T_max latest and assign\n// \"+1\" or \"-1\" accordingly \n//////////////////////////////////////////////////////////////////////////////\n//////////////////////////////////////////////////////////////////////////////\n\n/////////////////////////////////////////////////////////////////////////////\n// Record if replica has been at lowest or highest T latest ... ////////\n/////////////////////////////////////////////////////////////////////////////\n\nint check_sign_i(int i, int np, int s_i, int s_i_plus_1)\n{\n int sign;\n \n if (i != 1 && (i+1 != (np - 1)))\n {\n if (s_i == 1 && s_i_plus_1 == 0) \n sign = 0;\n else if (s_i == 0 && s_i_plus_1 == 1)\n sign = 1;\n else if (s_i == 1 && s_i_plus_1 == -1)\n sign = -1;\n else if (s_i == -1 && s_i_plus_1 == 1)\n sign = 1;\n else if (s_i == 0 && s_i_plus_1 == -1)\n sign = -1;\n else if (s_i == -1 && s_i_plus_1 == 0)\n sign = 0; \n else if (s_i == 0 && s_i_plus_1 == 0)\n sign = 0;\n else if (s_i == 1 && s_i_plus_1 == 1)\n sign = 1;\n else if (s_i == -1 && s_i_plus_1 == -1)\n sign = -1;\n }\n else if (i == 1)\n sign = 1;\n else if (i+1 == np - 1)\n sign = -1;\n else\n sign = 0;\n\n return sign;\n\n}\n\nint check_sign_i_plus_1(int i, int np, int s_i, int s_i_plus_1)\n{\n int sign;\n \n if (i != 1 && (i+1 != (np - 1)))\n {\n if (s_i == 1 && s_i_plus_1 == 0) \n sign = 1;\n else if (s_i == 0 && s_i_plus_1 == 1)\n sign = 0;\n else if (s_i == 1 && s_i_plus_1 == -1)\n sign = 1;\n else if (s_i == -1 && s_i_plus_1 == 1)\n sign = -1;\n else if (s_i == 0 && s_i_plus_1 == -1)\n sign = 0;\n else if (s_i == -1 && s_i_plus_1 == 0)\n sign = -1; \n else if (s_i == 0 && s_i_plus_1 == 0)\n sign = 0;\n else if (s_i == 1 && s_i_plus_1 == 1)\n sign = 1;\n else if (s_i == -1 && s_i_plus_1 == -1)\n sign = -1; \n }\n else if (i == 1)\n sign = 1;\n else if (i+1 == np - 1)\n sign = -1;\n else \n sign = 0;\n\n return sign;\n}\n\n\n\n", "meta": {"hexsha": "c2fc698f1c8f22f6ac16d3cd204f377f0e63ff48", "size": 9427, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "functions.hpp", "max_stars_repo_name": "timeschmann/Kitaev_QMC", "max_stars_repo_head_hexsha": "eab9167571507bcbbad35a2c4ff1367b21604d59", "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": "functions.hpp", "max_issues_repo_name": "timeschmann/Kitaev_QMC", "max_issues_repo_head_hexsha": "eab9167571507bcbbad35a2c4ff1367b21604d59", "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": "functions.hpp", "max_forks_repo_name": "timeschmann/Kitaev_QMC", "max_forks_repo_head_hexsha": "eab9167571507bcbbad35a2c4ff1367b21604d59", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.6451612903, "max_line_length": 116, "alphanum_fraction": 0.3883526042, "num_tokens": 2510, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8499711680567799, "lm_q2_score": 0.6442251201477016, "lm_q1q2_score": 0.5475727778634613}} {"text": "#include \"reconstruction.h\"\n#include \"simulation.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n\nvoid reconstruct(Eigen::MatrixXd &V, Eigen::MatrixXi &F, const Eigen::MatrixXd &P, const Eigen::Vector3i &res,\n const Eigen::VectorXd &mass, const Eigen::VectorXd &density, double h, double isovalue) {\n auto W_k = 10. / (7. * igl::PI);\n auto P1 = [&](double r) {\n auto q = r;\n auto res = 0.0;\n if (q <= 1.0)\n res = (1 - 1.5 * q * q + 0.75 * q * q * q);\n else if (q < 2.0) {\n auto q2 = 2 - q;\n res = 0.25 * q2 * q2 * q2;\n }\n return res;\n };\n\n printf(\"P.rows() = %d\\n\", P.rows());\n using igl::copyleft::marching_cubes;\n // Eigen::Vector3d lower = Eigen::Vector3d::Zero() - Eigen::Vector3d::Constant(2 * h); // = P.colwise().minCoeff();\n // Eigen::Vector3d upper = Eigen::Vector3d::Ones() + Eigen::Vector3d::Constant(2 * h); // P.colwise().maxCoeff();\n Eigen::Vector3d lower = Eigen::Vector3d(P.colwise().minCoeff()) - Eigen::Vector3d::Constant(2 * h);\n Eigen::Vector3d upper = Eigen::Vector3d(P.colwise().maxCoeff()) + Eigen::Vector3d::Constant(2 * h);\n Eigen::Vector3d extent = upper - lower;\n Eigen::VectorXd S;\n Eigen::MatrixXd GV;\n S.resize(res.prod());\n GV.resize(res.prod(), 3);\n Eigen::Vector3d nn_cell_size(2 * h, 2 * h, 2 * h);\n Eigen::Vector3i nn_grid_size;\n nn_grid_size << extent[0] / nn_cell_size[0], extent[1] / nn_cell_size[1], extent[2] / nn_cell_size[2];\n Eigen::Vector3d grid_cell_size = extent.array() / (res - Eigen::Vector3i::Ones()).cast().array();\n for (int i = 0; i < res.prod(); i++) {\n int x = i % res[0];\n int y = (i % (res[0] * res[1])) / res[0];\n int z = i / (res[0] * res[1]);\n Eigen::Vector3d p = Eigen::Vector3d(Eigen::Array3d(x, y, z) * grid_cell_size.array()) + lower;\n GV.row(i) = p;\n }\n // std::cout << GV << std::endl;\n struct Cell {\n std::vector particles;\n };\n std::vector grid(nn_grid_size.prod());\n std::vector> G(P.rows());\n std::vector> neighbors(P.rows());\n Eigen::MatrixXd X;\n X.resizeLike(P);\n // auto get_cell_index = [&](const Eigen::Vector3d &x) -> Eigen::Vector3i {\n // Eigen::Vector3i ip =\n // Eigen::Vector3i(((x - lower).array() / extent.array() * res.array().cast()).cast());\n // for (int i = 0; i < 3; i++) {\n // ip[i] = std::min(res[i] - 1, std::max(ip[i], 0));\n // }\n // return ip;\n // };\n // auto get_linear_index = [&](const Eigen::Vector3i &ip) { return ip[0] + ip[1] * res[0] + ip[2] * res[0] * res[1];\n // };\n auto get_nn_cell_index = [&](const Eigen::Vector3d &x) -> Eigen::Vector3i {\n Eigen::Vector3i ip = Eigen::Vector3i(((x - lower).array() / nn_cell_size.array()).cast());\n for (int i = 0; i < 3; i++) {\n ip[i] = std::min(nn_grid_size[i] - 1, std::max(ip[i], 0));\n }\n return ip;\n };\n auto get_nn_linear_index = [&](const Eigen::Vector3i &ip) {\n return ip[0] + ip[1] * nn_grid_size[0] + ip[2] * nn_grid_size[0] * nn_grid_size[1];\n };\n for (int i = 0; i < P.rows(); i++) {\n Eigen::Vector3i ip = get_nn_cell_index(P.row(i));\n auto idx = get_nn_linear_index(ip);\n CHECK(idx < grid.size());\n // printf(\"%d\\n\", idx);\n grid[idx].particles.push_back(i);\n }\n for (int i = 0; i < P.rows(); i++) {\n\n Eigen::Vector3d p = P.row(i);\n Eigen::Vector3i ip = get_nn_cell_index(p);\n for (int dx = -1; dx <= 1; dx++) {\n for (int dy = -1; dy <= 1; dy++) {\n for (int dz = -1; dz <= 1; dz++) {\n Eigen::Vector3i cell_idx = ip + Eigen::Vector3i(dx, dy, dz);\n if ((cell_idx.array() >= Eigen::Array3i::Zero()).all() &&\n (cell_idx.array() < nn_grid_size.array()).all()) {\n auto &cell = grid[get_nn_linear_index(cell_idx)];\n for (auto &j : cell.particles) {\n if (i == j)\n continue;\n Eigen::Vector3d q = P.row(j);\n if ((p - q).norm() < 2 * h) {\n neighbors[i].push_back(j);\n }\n }\n }\n }\n }\n }\n }\n CHECK(neighbors.size() == P.rows());\n // for (int i = 0; i < P.rows(); i++) {\n tbb::parallel_for(0, P.rows(), [&](int i) {\n Eigen::Vector3d xi = P.row(i);\n Eigen::Vector3d xiw(0, 0, 0);\n Eigen::Matrix3d C;\n Eigen::Vector3d x_bar(0.0, 0.0, 0.0);\n const auto lambda = 0.92;\n C.setZero();\n if (!neighbors.empty()) {\n double sum_w = 0.0;\n\n for (auto &j : neighbors[i]) {\n CHECK(j < P.rows());\n Eigen::Vector3d xj = P.row(j);\n const auto r = 2 * h;\n auto w = 0.0;\n if ((xi - xj).norm() <= r && (xi - xj).norm() > 0.0) {\n w = 1.0 - std::pow((xi - xj).norm() / r, 3);\n }\n sum_w += w;\n xiw += w * xj;\n }\n xiw /= sum_w;\n x_bar = (1.0 - lambda) * xi + lambda * xiw;\n X.row(i) = x_bar;\n } else {\n X.row(i) = xi;\n xiw = xi;\n }\n {\n double sum_w = 0.0;\n for (auto &j : neighbors[i]) {\n Eigen::Vector3d xj = P.row(j);\n const auto r = 2 * h;\n auto w = 0.0;\n if ((xi - xj).norm() <= r && (xi - xj).norm() > 0.0) {\n w = 1.0 - std::pow((xi - xj).norm() / r, 3);\n }\n sum_w += w;\n C += w * (xj - xiw) * (xj - xiw).transpose();\n }\n // std::cout << C << std::endl;\n C /= sum_w;\n }\n Eigen::JacobiSVD svd(C, Eigen::ComputeFullU | Eigen::ComputeFullV);\n Eigen::Matrix3d R = svd.matrixU();\n Eigen::Vector3d sigmas = svd.singularValues();\n const auto kr = 4.0;\n const auto ks = 1400.0;\n const auto kn = 0.5;\n const int Ne = 25;\n double sigma1 = sigmas[0];\n for (int i = 0; i < 3; i++) {\n sigmas[i] = std::fmax(sigmas[i], sigma1 / kr);\n }\n auto N = (int)neighbors[i].size();\n // std::cout << \"N: \" << N << std::endl;\n Eigen::DiagonalMatrix Sigma;\n if (N < Ne) {\n Sigma = kn * Eigen::Vector3d::Ones().asDiagonal();\n } else {\n Sigma = ks * sigmas.asDiagonal();\n }\n G[i] = 1.0 / h * R * Sigma.inverse() * R.transpose();\n // G[i] = 1.0 / h * Eigen::Matrix3d::Identity();\n // std::cout << G[i] << std::endl;\n });\n for (auto &cell : grid) {\n cell.particles.clear();\n }\n for (int i = 0; i < P.rows(); i++) {\n Eigen::Vector3i ip = get_nn_cell_index(P.row(i));\n auto idx = get_nn_linear_index(ip);\n CHECK(idx < grid.size());\n grid[idx].particles.push_back(i);\n }\n neighbors.clear();\n neighbors.resize(GV.rows());\n // for (int i = 0; i < GV.rows(); i++) {\n tbb::parallel_for(0, GV.rows(), [&](int i) {\n // int x = i % res[0];\n // int y = (i % (res[0] * res[1])) / res[0];\n // int z = i / (res[0] * res[1]);\n // Eigen::Vector3i gv_p(x, y, z);\n Eigen::Vector3d p = GV.row(i);\n Eigen::Vector3i ip = get_nn_cell_index(p);\n for (int dx = -1; dx <= 1; dx++) {\n for (int dy = -1; dy <= 1; dy++) {\n for (int dz = -1; dz <= 1; dz++) {\n Eigen::Vector3i cell_idx = ip + Eigen::Vector3i(dx, dy, dz);\n if ((cell_idx.array() >= Eigen::Array3i::Zero()).all() &&\n (cell_idx.array() < nn_grid_size.array()).all()) {\n auto &cell = grid[get_nn_linear_index(cell_idx)];\n for (auto &j : cell.particles) {\n Eigen::Vector3d q = X.row(j);\n if ((p - q).norm() < 2 * h) {\n neighbors[i].push_back(j);\n }\n }\n }\n }\n }\n }\n });\n\n // for (int i = 0; i < GV.rows(); i++) {\n tbb::parallel_for(0, GV.rows(), [&](int i) {\n const double r = 2 * h;\n // Eigen::Vector3i ip;\n // {\n // int x = i % res[0];\n // int y = (i % (res[0] * res[1])) / res[0];\n // int z = i / (res[0] * res[1]);\n // ip = Eigen::Vector3i(x, y, z);\n // }\n Eigen::Vector3d x = GV.row(i);\n double s = 0.0;\n for (auto j : neighbors[i]) {\n Eigen::Vector3d xj = X.row(j);\n Eigen::Vector3d r = x - xj;\n auto W = W_k / (h * h) * G[j].norm() * P1((G[j] * r).norm());\n // std::cout << (G[j] * r).norm() << std::endl;\n // std::cout << (r.norm() / h) << std::endl;\n s += mass[j] / density[j] * W;\n }\n S[i] = s;\n\n // double s = 0.0;\n // for (auto j : neighbors[i]) {\n // Eigen::Vector3d xj = P.row(j);\n // Eigen::Vector3d r = x - xj;\n // auto W = W_k / (h * h * h) * P1(r.norm() / h);\n // s += mass[j] / density[j] * W;\n // }\n\n // S[i] = s;\n });\n // std::cout << S << std::endl;\n printf(\"S.mean() = %f\\n\", S.mean());\n\n marching_cubes(S, GV, res[0], res[1], res[2], isovalue, V, F);\n}", "meta": {"hexsha": "25a8f45ae296a60e10351481a1804fec32eb91a3", "size": 9900, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/reconstruction.cpp", "max_stars_repo_name": "shiinamiyuki/Accurate-Large-Scale-Ferrofluids", "max_stars_repo_head_hexsha": "b39565ee94043b6ae19f14318af20f7489bc9312", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 12.0, "max_stars_repo_stars_event_min_datetime": "2020-12-22T04:19:23.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-08T15:47:32.000Z", "max_issues_repo_path": "src/reconstruction.cpp", "max_issues_repo_name": "shiinamiyuki/Accurate-Large-Scale-Ferrofluids", "max_issues_repo_head_hexsha": "b39565ee94043b6ae19f14318af20f7489bc9312", "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/reconstruction.cpp", "max_forks_repo_name": "shiinamiyuki/Accurate-Large-Scale-Ferrofluids", "max_forks_repo_head_hexsha": "b39565ee94043b6ae19f14318af20f7489bc9312", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2020-12-22T03:39:31.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-03T04:42:16.000Z", "avg_line_length": 39.7590361446, "max_line_length": 120, "alphanum_fraction": 0.4441414141, "num_tokens": 2990, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8499711604559848, "lm_q2_score": 0.6442251201477016, "lm_q1q2_score": 0.5475727729668382}} {"text": "#include \n#include \n#include \n#include \n#include \n\n#include \"world_rep.h\"\n\n\nint main(int argc, const char **argv)\n{\n // Values for single neuron.\n int snn_id = 2;\n int n_inputs = 2;\n int n_lateral = 1;\n std::vector init_d({2, 4});\n std::vector init_w({4});\n double tau_m = 2;\n double u_rest = 0;\n double init_v = 20; // when testing math, make this large\n unsigned char t_rest = 2;\n double kappa_naugh = 3;\n double round_zero = 0.1;\n double u_max = 10;\n\n SpikeResponseModelNeuron single_neuron = SpikeResponseModelNeuron(\n snn_id, n_inputs, init_d, tau_m, u_rest,\n init_v, t_rest, kappa_naugh, round_zero, u_max);\n std::cout << \"Created individual neuron.\" << std::endl;\n\n std::vector> presynaptic_train = {\n {0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0},\n {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0}\n };\n\n\n std::ofstream exp_res;\n exp_res.open(\"experiment_results.log\");\n exp_res << \"[\";\n for(unsigned int epoch = 0; epoch < presynaptic_train.at(0).size(); epoch++)\n {\n exp_res << single_neuron.membrane_potential() << \", \";\n // load dendrites with current value\n single_neuron.dendrite.at(0) = DelayedSpike(0, presynaptic_train.at(0).at(epoch));\n single_neuron.dendrite.at(1) = DelayedSpike(0, presynaptic_train.at(1).at(epoch));\n\n // Move network forward\n single_neuron.t_pulse();\n \n }\n exp_res << \"]\" << std::endl;\n\n printf(\"Testing FSTNs\\n\");\n double alpha = 1;\n FirstSpikeTimeNeuron fstn = FirstSpikeTimeNeuron(0, alpha);\n fstn.dendrite = 2;\n fstn.encode();\n\n unsigned char total_pulses = 10;\n\n exp_res << \"First Spike Time Neuron spike after \" << total_pulses << \"pulses.\" << std::endl << \"[\";\n exp_res << fstn.axon.signal << \", \";\n for(unsigned char pulse= 0; pulse < total_pulses; pulse++)\n {\n fstn.t_pulse();\n exp_res << fstn.axon.signal << \", \";\n }\n exp_res << \"]\" << std::endl;\n\n exp_res.close();\n\n // Testing training algorthm\n unsigned int n_data = 2;\n tau_m = 0.8;\n u_rest = 0;\n init_v = 5;\n unsigned int t_reset = 3;\n double k_nought = 3;\n round_zero = 0.05;\n alpha = 1;\n // note that n_x * n_y = h_layer_size\n unsigned int n_x = 8;\n unsigned int n_y = 8;\n double delay_distance = 0.2;\n unsigned int distance_unit = 1;\n double sigma_neighbor = 1;\n double eta_d = 1.7;\n unsigned int t_max = 25;\n u_max = 10;\n\n printf(\"Create SNN\\n\");\n SNN model(n_data, tau_m, u_rest, init_v, \n t_reset, k_nought, round_zero, alpha, n_x, n_y, delay_distance,\n distance_unit, sigma_neighbor, eta_d, t_max, u_max);\n\n std::vector> data = {\n {0, 0, 0, 1, 2, 2, 3, 3, 3, 3, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0},\n {0, 1, 2, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 7, 6, 5, 4, 3, 2, 1, 0}\n };\n std::vector> data_2 = {\n {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},\n {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1},\n };\n\n printf(\"Create output file\\n\");\n\n // save delays into file:\n std::ofstream delay_file;\n delay_file.open(\"training_delays.txt\");\n \n // print out delays\n delay_file << \"Delays before training:\" << std::endl;\n for(unsigned int i = 0; i < model.snn->d_ji.size(); i++)\n {\n delay_file << \"[ \";\n for(unsigned int j = 0; j < model.snn->d_ji.at(i).size(); j++)\n {\n delay_file << model.snn->d_ji.at(i).at(j) << \", \";\n }\n delay_file << \"]\" << std::endl;\n }\n \n for(unsigned int p = 0; p < 1; p++)\n model.train(data);\n\n delay_file << std::endl << \"Delays after training:\"<< std::endl;\n for(unsigned int i = 0; i < model.snn->d_ji.size(); i++)\n {\n delay_file << \"[ \";\n for(unsigned int j = 0; j < model.snn->d_ji.at(i).size(); j++)\n {\n delay_file << model.snn->d_ji.at(i).at(j) << \", \";\n }\n delay_file << \"]\" << std::endl;\n }\n\n\n for(unsigned int p = 0; p < 8; p++, sigma_neighbor -= 0.1)\n {\n model = SNN(n_data, tau_m, u_rest, init_v, \n t_reset, k_nought, round_zero, alpha, n_x, n_y, delay_distance,\n distance_unit, sigma_neighbor, eta_d, t_max, u_max);\n \n model.train(data);\n\n delay_file << std::endl << \"Delays after training with sigma_neighbor = \" << sigma_neighbor << \": \\n\" << std::endl;\n for(unsigned int i = 0; i < model.snn->d_ji.size(); i++)\n {\n delay_file << \"[ \";\n for(unsigned int j = 0; j < model.snn->d_ji.at(i).size(); j++)\n {\n delay_file << model.snn->d_ji.at(i).at(j) << \", \";\n }\n delay_file << \"]\" << std::endl;\n }\n }\n\n printf(\"test world representation and planner.\\n\");\n\n\n sigma_neighbor = 0.3;\n\n std::ofstream planner_file;\n planner_file.open(\"world_representation.txt\");\n\n double prune_dist = 0.1;\n\n WorldRep planner = WorldRep(k_nought, tau_m, init_v, round_zero,\n n_x, n_y, delay_distance, sigma_neighbor, eta_d, t_max, u_max, \n prune_dist);\n\n planner.train(data);\n\n planner_file << std::endl << \"Delays after training:\"<< std::endl;\n for(unsigned int i = 0; i < planner.snn.snn->d_ji.size(); i++)\n {\n planner_file << \"[ \";\n for(unsigned int j = 0; j < planner.snn.snn->d_ji.at(i).size(); j++)\n {\n planner_file << planner.snn.snn->d_ji.at(i).at(j) << \", \";\n }\n planner_file << \"]\" << std::endl;\n }\n\n\n std::vector> world_rep = planner.get_map();\n \n planner_file << std::endl << \"Delays after training with sigma_neighbor = \" << sigma_neighbor << \" and prunning with value:\" << prune_dist << std::endl;\n\n for(unsigned int i = 0; i < world_rep.size(); i++)\n {\n planner_file << \"[ \";\n for(unsigned int j = 0; j < world_rep.at(i).size(); j++)\n {\n planner_file << world_rep.at(i).at(j) << \", \";\n }\n planner_file << \"]\" << std::endl;\n }\n\n planner.dijkstra(28, 409);\n std::vector src_coor, goal_coor;\n src_coor = std::vector({0, 0});\n goal_coor = std::vector({0, 7});\n std::vector> path = planner.get_path(WorldRep::PathAlgorithm::dijkstras, src_coor, goal_coor);\n printf(\"[\");\n for(unsigned int x = 0; x < path.at(0).size(); x++)\n {\n printf(\"[%f, %f], \", path.at(0).at(x), path.at(1).at(x));\n }\n printf(\"]\\n\");\n planner_file.close();\n}", "meta": {"hexsha": "0ed47f326ccb809cb5d4465dbf7f17fdc460c36a", "size": 7000, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "test_snn.cpp", "max_stars_repo_name": "aguilarjose11/world_rep_snn", "max_stars_repo_head_hexsha": "fa519f9cbe32b7ee61ff5514b361b2c73959d57c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-12-06T18:45:33.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-06T18:45:33.000Z", "max_issues_repo_path": "test_snn.cpp", "max_issues_repo_name": "aguilarjose11/world_rep_snn", "max_issues_repo_head_hexsha": "fa519f9cbe32b7ee61ff5514b361b2c73959d57c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-01-19T19:12:04.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-19T19:12:04.000Z", "max_forks_repo_path": "test_snn.cpp", "max_forks_repo_name": "aguilarjose11/world_rep_snn", "max_forks_repo_head_hexsha": "fa519f9cbe32b7ee61ff5514b361b2c73959d57c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-12-29T15:38:07.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-29T15:38:07.000Z", "avg_line_length": 33.0188679245, "max_line_length": 249, "alphanum_fraction": 0.5421428571, "num_tokens": 2497, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8499711756575749, "lm_q2_score": 0.6442251064863697, "lm_q1q2_score": 0.547572771148346}} {"text": "// Copyright © 2016-2021 Thomas Nagler and Thibault Vatter\n//\n// This file is part of the vinecopulib library and licensed under the terms of\n// the MIT license. For a copy, see the LICENSE file in the root directory of\n// vinecopulib or https://vinecopulib.github.io/vinecopulib/.\n\n#include \n#include \n\nnamespace vinecopulib {\ninline ClaytonBicop::ClaytonBicop()\n{\n family_ = BicopFamily::clayton;\n parameters_ = Eigen::VectorXd(1);\n parameters_lower_bounds_ = Eigen::VectorXd(1);\n parameters_upper_bounds_ = Eigen::VectorXd(1);\n parameters_ << 1e-10;\n parameters_lower_bounds_ << 1e-10;\n parameters_upper_bounds_ << 28;\n}\n\ninline double\nClaytonBicop::generator(const double& u)\n{\n double theta = double(this->parameters_(0));\n return (std::pow(u, -theta) - 1) / theta;\n}\n\ninline double\nClaytonBicop::generator_inv(const double& u)\n{\n double theta = double(this->parameters_(0));\n return std::pow(1 + theta * u, -1 / theta);\n}\n\ninline double\nClaytonBicop::generator_derivative(const double& u)\n{\n return (-1) * std::pow(u, -1 - this->parameters_(0));\n}\n\n// inline double ClaytonBicop::generator_derivative2(const double &u)\n//{\n// double theta = double(this->parameters_(0));\n// return (1 + theta) * std::pow(u, -2 - theta);\n//}\n\ninline Eigen::VectorXd\nClaytonBicop::pdf_raw(const Eigen::MatrixXd& u)\n{\n double theta = static_cast(parameters_(0));\n // avoid numerical issues when copula is too close to independence\n if (theta < 1e-10) {\n auto f = [](const double&, const double&) { return 1.0; };\n return tools_eigen::binaryExpr_or_nan(u, f);\n }\n\n auto f = [theta](const double& u1, const double& u2) {\n double temp = boost::math::log1p(theta) - (1.0 + theta) * std::log(u1 * u2);\n temp = temp - (2.0 + 1.0 / (theta)) *\n std::log(std::pow(u1, -theta) + std::pow(u2, -theta) - 1.0);\n return std::exp(temp);\n };\n return tools_eigen::binaryExpr_or_nan(u, f);\n}\n\ninline Eigen::VectorXd\nClaytonBicop::hinv1_raw(const Eigen::MatrixXd& u)\n{\n double theta = double(this->parameters_(0));\n Eigen::VectorXd hinv = u.col(0).array().pow(theta + 1.0);\n if (theta < 75) {\n hinv = u.col(1).cwiseProduct(hinv);\n hinv = hinv.array().pow(-theta / (theta + 1.0));\n Eigen::VectorXd x = u.col(0);\n x = x.array().pow(-theta);\n hinv = hinv - x + Eigen::VectorXd::Ones(x.size());\n hinv = hinv.array().pow(-1 / theta);\n } else {\n hinv = hinv1_num(u);\n }\n return hinv;\n}\n\ninline Eigen::MatrixXd\nClaytonBicop::tau_to_parameters(const double& tau)\n{\n Eigen::VectorXd parameters(1);\n parameters(0) = 2 * std::fabs(tau) / (1 - std::fabs(tau));\n return parameters.cwiseMax(parameters_lower_bounds_)\n .cwiseMin(parameters_upper_bounds_);\n}\n\ninline double\nClaytonBicop::parameters_to_tau(const Eigen::MatrixXd& parameters)\n{\n return parameters(0) / (2 + std::fabs(parameters(0)));\n}\n\ninline Eigen::VectorXd\nClaytonBicop::get_start_parameters(const double tau)\n{\n Eigen::VectorXd par = tau_to_parameters(tau);\n par = par.cwiseMax(parameters_lower_bounds_);\n par = par.cwiseMin(parameters_upper_bounds_);\n return par;\n}\n}\n", "meta": {"hexsha": "39135b15612fb78a748b3fce1e8507842d817674", "size": 3168, "ext": "ipp", "lang": "C++", "max_stars_repo_path": "include/vinecopulib/bicop/implementation/clayton.ipp", "max_stars_repo_name": "tvatter/vinecoplib", "max_stars_repo_head_hexsha": "ae34d56408437e6eeacec40a51a8fa8dac378672", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 28.0, "max_stars_repo_stars_event_min_datetime": "2017-05-05T13:27:58.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-15T23:40:01.000Z", "max_issues_repo_path": "include/vinecopulib/bicop/implementation/clayton.ipp", "max_issues_repo_name": "vinecopulib/vinecopulib", "max_issues_repo_head_hexsha": "ae34d56408437e6eeacec40a51a8fa8dac378672", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 264.0, "max_issues_repo_issues_event_min_datetime": "2017-03-28T10:07:13.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-23T10:04:39.000Z", "max_forks_repo_path": "include/vinecopulib/bicop/implementation/clayton.ipp", "max_forks_repo_name": "tvatter/vinecoplib", "max_forks_repo_head_hexsha": "ae34d56408437e6eeacec40a51a8fa8dac378672", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2017-04-24T13:54:47.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-22T16:56:17.000Z", "avg_line_length": 29.0642201835, "max_line_length": 80, "alphanum_fraction": 0.6824494949, "num_tokens": 950, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303285397348, "lm_q2_score": 0.6926419831347361, "lm_q1q2_score": 0.5475544944879164}} {"text": "// \n// Implements iLQR (on a traditional chain) for nonlinear dynamics and cost.\n//\n// Arun Venkatraman (arunvenk@cs.cmu.edu)\n// December 2016\n//\n\n#pragma once\n\n#include \n\n#include \n\n#include \n#include \n\nnamespace ilqr\n{\n\nclass iLQR\n{\npublic:\n // Stores linearization points x, u and the Taylor expansions of the dynamics and cost.\n using TaylorExpansion = std::tuple;\n\n iLQR(const DynamicsFunc &dynamics, const CostFunc &cost, \n const std::vector &Xs, \n const std::vector &Us);\n\n void backwards_pass();\n\n void forward_pass(std::vector &costs, \n std::vector &states,\n std::vector &controls, \n bool update_linearizations\n );\n\n std::vector states();\n std::vector controls();\n\nprivate:\n int state_dim_ = -1;\n int control_dim_ = -1;\n int T_ = -1; // time horizon\n\n DynamicsFunc true_dynamics_; \n CostFunc true_cost_; \n\n // Taylor series expansion points and expanded dynamics, cost.\n std::vector expansions_;\n\n // Feedback control gains.\n std::vector Ks_;\n std::vector ks_;\n};\n\n} // namespace lqr\n\n", "meta": {"hexsha": "ecb4d0ddf3a3320aadcb956f57a308469d92bc90", "size": 1395, "ext": "hh", "lang": "C++", "max_stars_repo_path": "src/ilqr/iLQR.hh", "max_stars_repo_name": "LAIRLAB/qr_trees", "max_stars_repo_head_hexsha": "66eb7310daa1d9978158198a508d02bf2128a377", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-06-16T08:42:33.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-16T08:42:33.000Z", "max_issues_repo_path": "src/ilqr/iLQR.hh", "max_issues_repo_name": "LAIRLAB/qr_trees", "max_issues_repo_head_hexsha": "66eb7310daa1d9978158198a508d02bf2128a377", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/ilqr/iLQR.hh", "max_forks_repo_name": "LAIRLAB/qr_trees", "max_forks_repo_head_hexsha": "66eb7310daa1d9978158198a508d02bf2128a377", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2017-07-10T03:25:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-22T15:58:44.000Z", "avg_line_length": 23.6440677966, "max_line_length": 101, "alphanum_fraction": 0.6630824373, "num_tokens": 361, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303285397349, "lm_q2_score": 0.6926419767901475, "lm_q1q2_score": 0.5475544894723268}} {"text": "/*\n# Copyright 2018 HyphaROS Workshop.\n# Developer: HaoChih, LIN (hypha.ros@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#include \"MPC_last.h\"\n//#include \n#include \n#include \n\n// The program use fragments of code from\n// https://github.com/udacity/CarND-MPC-Quizzes\n\nusing CppAD::AD;\n\n// =========================================\n// FG_eval class definition implementation.\n// =========================================\nclass FG_eval \n{\n public:\n // Fitted polynomial coefficients\n Eigen::VectorXd coeffs;\n\n double _dt, _ref_cte, _ref_etheta, _ref_vel; \n double _w_cte, _w_etheta, _w_vel, _w_angvel, _w_accel, _w_angvel_d, _w_accel_d;\n int _mpc_steps, _x_start, _y_start, _theta_start, _v_start, _cte_start, _etheta_start, _angvel_start, _a_start;\n\n AD cost_cte, cost_etheta, cost_vel;\n // Constructor\n FG_eval(Eigen::VectorXd coeffs) \n { \n this->coeffs = coeffs; \n\n // Set default value \n _dt = 0.1; // in sec\n _ref_cte = 0;\n _ref_etheta = 0;\n _ref_vel = 0.5; // m/s\n _w_cte = 100;\n _w_etheta = 100;\n _w_vel = 1;\n _w_angvel = 100;\n _w_accel = 50;\n _w_angvel_d = 0;\n _w_accel_d = 0;\n\n _mpc_steps = 40;\n _x_start = 0;\n _y_start = _x_start + _mpc_steps;\n _theta_start = _y_start + _mpc_steps;\n _v_start = _theta_start + _mpc_steps;\n _cte_start = _v_start + _mpc_steps;\n _etheta_start = _cte_start + _mpc_steps;\n _angvel_start = _etheta_start + _mpc_steps;\n _a_start = _angvel_start + _mpc_steps - 1;\n }\n\n // Load parameters for constraints\n void LoadParams(const std::map ¶ms)\n {\n _dt = params.find(\"DT\") != params.end() ? params.at(\"DT\") : _dt;\n _mpc_steps = params.find(\"STEPS\") != params.end() ? params.at(\"STEPS\") : _mpc_steps;\n _ref_cte = params.find(\"REF_CTE\") != params.end() ? params.at(\"REF_CTE\") : _ref_cte;\n _ref_etheta = params.find(\"REF_ETHETA\") != params.end() ? params.at(\"REF_ETHETA\") : _ref_etheta;\n _ref_vel = params.find(\"REF_V\") != params.end() ? params.at(\"REF_V\") : _ref_vel;\n \n _w_cte = params.find(\"W_CTE\") != params.end() ? params.at(\"W_CTE\") : _w_cte;\n _w_etheta = params.find(\"W_EPSI\") != params.end() ? params.at(\"W_EPSI\") : _w_etheta;\n _w_vel = params.find(\"W_V\") != params.end() ? params.at(\"W_V\") : _w_vel;\n _w_angvel = params.find(\"W_ANGVEL\") != params.end() ? params.at(\"W_ANGVEL\") : _w_angvel;\n _w_accel = params.find(\"W_A\") != params.end() ? params.at(\"W_A\") : _w_accel;\n _w_angvel_d = params.find(\"W_DANGVEL\") != params.end() ? params.at(\"W_DANGVEL\") : _w_angvel_d;\n _w_accel_d = params.find(\"W_DA\") != params.end() ? params.at(\"W_DA\") : _w_accel_d;\n\n _x_start = 0;\n _y_start = _x_start + _mpc_steps;\n _theta_start = _y_start + _mpc_steps;\n _v_start = _theta_start + _mpc_steps;\n _cte_start = _v_start + _mpc_steps;\n _etheta_start = _cte_start + _mpc_steps;\n _angvel_start = _etheta_start + _mpc_steps;\n _a_start = _angvel_start + _mpc_steps - 1;\n \n //cout << \"\\n!! FG_eval Obj parameters updated !! \" << _mpc_steps << endl; \n }\n\n // MPC implementation (cost func & constraints)\n typedef CPPAD_TESTVECTOR(AD) ADvector; \n // fg: function that evaluates the objective and constraints using the syntax \n void operator()(ADvector& fg, const ADvector& vars) \n {\n // fg[0] for cost function\n fg[0] = 0;\n cost_cte = 0;\n cost_etheta = 0;\n cost_vel = 0;\n\n /*\n for (int i = 0; i < _mpc_steps; i++) \n {\n cout << i << endl;\n cout << \"_x_start\" << vars[_x_start + i] < x1 = vars[_x_start + i + 1];\n AD y1 = vars[_y_start + i + 1];\n AD theta1 = vars[_theta_start + i + 1];\n AD v1 = vars[_v_start + i + 1];\n AD cte1 = vars[_cte_start + i + 1];\n AD etheta1 = vars[_etheta_start + i + 1];\n\n // The state at time t.\n AD x0 = vars[_x_start + i];\n AD y0 = vars[_y_start + i];\n AD theta0 = vars[_theta_start + i];\n AD v0 = vars[_v_start + i];\n AD cte0 = vars[_cte_start + i];\n AD etheta0 = vars[_etheta_start + i];\n\n // Only consider the actuation at time t.\n //AD angvel0 = vars[_angvel_start + i];\n AD w0 = vars[_angvel_start + i];\n AD a0 = vars[_a_start + i];\n\n\n //AD f0 = coeffs[0] + coeffs[1] * x0 + coeffs[2] * CppAD::pow(x0, 2) + coeffs[3] * CppAD::pow(x0, 3);\n AD f0 = 0.0;\n for (int i = 0; i < coeffs.size(); i++) \n {\n f0 += coeffs[i] * CppAD::pow(x0, i); //f(0) = y\n }\n\n //AD trj_grad0 = CppAD::atan(coeffs[1] + 2 * coeffs[2] * x0 + 3 * coeffs[3] * CppAD::pow(x0, 2));\n AD trj_grad0 = 0.0;\n for (int i = 1; i < coeffs.size(); i++) \n {\n trj_grad0 += i*coeffs[i] * CppAD::pow(x0, i-1); // f'(x0) = f(1)/1\n }\n trj_grad0 = CppAD::atan(trj_grad0);\n\n\n // Here's `x` to get you started.\n // The idea here is to constraint this value to be 0.\n //\n // NOTE: The use of `AD` and use of `CppAD`!\n // This is also CppAD can compute derivatives and pass\n // these to the solver.\n // TODO: Setup the rest of the model constraints\n fg[2 + _x_start + i] = x1 - (x0 + v0 * CppAD::cos(theta0) * _dt);\n fg[2 + _y_start + i] = y1 - (y0 + v0 * CppAD::sin(theta0) * _dt);\n fg[2 + _theta_start + i] = theta1 - (theta0 + w0 * _dt);\n fg[2 + _v_start + i] = v1 - (v0 + a0 * _dt);\n \n fg[2 + _cte_start + i] = cte1 - ((f0 - y0) + (v0 * CppAD::sin(etheta0) * _dt));\n //fg[2 + _etheta_start + i] = etheta1 - ((theta0 - trj_grad0) + w0 * _dt);//theta0-trj_grad0)->etheta : it can have more curvature prediction, but its gradient can be only adjust positive plan. \n fg[2 + _etheta_start + i] = etheta1 - (etheta0 + w0 * _dt);\n }\n }\n};\n\n// ====================================\n// MPC class definition implementation.\n// ====================================\nMPC::MPC() \n{\n // Set default value \n _mpc_steps = 20;\n _max_angvel = 3.0; // Maximal angvel radian (~30 deg)\n _max_throttle = 1.0; // Maximal throttle accel\n _bound_value = 1.0e3; // Bound value for other variables\n\n _x_start = 0;\n _y_start = _x_start + _mpc_steps;\n _theta_start = _y_start + _mpc_steps;\n _v_start = _theta_start + _mpc_steps;\n _cte_start = _v_start + _mpc_steps;\n _etheta_start = _cte_start + _mpc_steps;\n _angvel_start = _etheta_start + _mpc_steps;\n _a_start = _angvel_start + _mpc_steps - 1;\n\n}\n\nvoid MPC::LoadParams(const std::map ¶ms)\n{\n _params = params;\n //Init parameters for MPC object\n _mpc_steps = _params.find(\"STEPS\") != _params.end() ? _params.at(\"STEPS\") : _mpc_steps;\n _max_angvel = _params.find(\"ANGVEL\") != _params.end() ? _params.at(\"ANGVEL\") : _max_angvel;\n _max_throttle = _params.find(\"MAXTHR\") != _params.end() ? _params.at(\"MAXTHR\") : _max_throttle;\n _bound_value = _params.find(\"BOUND\") != _params.end() ? _params.at(\"BOUND\") : _bound_value;\n \n _x_start = 0;\n _y_start = _x_start + _mpc_steps;\n _theta_start = _y_start + _mpc_steps;\n _v_start = _theta_start + _mpc_steps;\n _cte_start = _v_start + _mpc_steps;\n _etheta_start = _cte_start + _mpc_steps;\n _angvel_start = _etheta_start + _mpc_steps;\n _a_start = _angvel_start + _mpc_steps - 1;\n\n cout << \"\\n!! MPC Obj parameters updated !! \" << endl; \n}\n\n\nvector MPC::Solve(Eigen::VectorXd state, Eigen::VectorXd coeffs) \n{\n bool ok = true;\n size_t i;\n typedef CPPAD_TESTVECTOR(double) Dvector;\n const double x = state[0];\n const double y = state[1];\n const double theta = state[2];\n const double v = state[3];\n const double cte = state[4];\n const double etheta = state[5];\n\n // Set the number of model variables (includes both states and inputs).\n // For example: If the state is a 4 element vector, the actuators is a 2\n // element vector and there are 10 timesteps. The number of variables is:\n // 4 * 10 + 2 * 9\n size_t n_vars = _mpc_steps * 6 + (_mpc_steps - 1) * 2;\n \n // Set the number of constraints\n size_t n_constraints = _mpc_steps * 6;\n\n // Initial value of the independent variables.\n // SHOULD BE 0 besides initial state.\n Dvector vars(n_vars);\n for (int i = 0; i < n_vars; i++) \n {\n vars[i] = 0;\n }\n\n // Set the initial variable values\n vars[_x_start] = x;\n vars[_y_start] = y;\n vars[_theta_start] = theta;\n vars[_v_start] = v;\n vars[_cte_start] = cte;\n vars[_etheta_start] = etheta;\n\n // Set lower and upper limits for variables.\n Dvector vars_lowerbound(n_vars);\n Dvector vars_upperbound(n_vars);\n \n // Set all non-actuators upper and lowerlimits\n // to the max negative and positive values.\n for (int i = 0; i < _angvel_start; i++) \n {\n vars_lowerbound[i] = -_bound_value;\n vars_upperbound[i] = _bound_value;\n }\n // The upper and lower limits of angvel are set to -25 and 25\n // degrees (values in radians).\n for (int i = _angvel_start; i < _a_start; i++) \n {\n vars_lowerbound[i] = -_max_angvel;\n vars_upperbound[i] = _max_angvel;\n }\n // Acceleration/decceleration upper and lower limits\n for (int i = _a_start; i < n_vars; i++) \n {\n vars_lowerbound[i] = -_max_throttle;\n vars_upperbound[i] = _max_throttle;\n }\n\n\n // Lower and upper limits for the constraints\n // Should be 0 besides initial state.\n Dvector constraints_lowerbound(n_constraints);\n Dvector constraints_upperbound(n_constraints);\n for (int i = 0; i < n_constraints; i++)\n {\n constraints_lowerbound[i] = 0;\n constraints_upperbound[i] = 0;\n }\n constraints_lowerbound[_x_start] = x;\n constraints_lowerbound[_y_start] = y;\n constraints_lowerbound[_theta_start] = theta;\n constraints_lowerbound[_v_start] = v;\n constraints_lowerbound[_cte_start] = cte;\n constraints_lowerbound[_etheta_start] = etheta;\n constraints_upperbound[_x_start] = x;\n constraints_upperbound[_y_start] = y;\n constraints_upperbound[_theta_start] = theta;\n constraints_upperbound[_v_start] = v;\n constraints_upperbound[_cte_start] = cte;\n constraints_upperbound[_etheta_start] = etheta;\n\n // object that computes objective and constraints\n FG_eval fg_eval(coeffs);\n fg_eval.LoadParams(_params);\n\n\n // options for IPOPT solver\n std::string options;\n // Uncomment this if you'd like more print information\n options += \"Integer print_level 0\\n\";\n // NOTE: Setting sparse to true allows the solver to take advantage\n // of sparse routines, this makes the computation MUCH FASTER. If you\n // can uncomment 1 of these and see if it makes a difference or not but\n // if you uncomment both the computation time should go up in orders of\n // magnitude.\n options += \"Sparse true forward\\n\";\n options += \"Sparse true reverse\\n\";\n // NOTE: Currently the solver has a maximum time limit of 0.5 seconds.\n // Change this as you see fit.\n options += \"Numeric max_cpu_time 0.5\\n\";\n\n // place to return solution\n CppAD::ipopt::solve_result solution;\n\n // solve the problem\n CppAD::ipopt::solve(\n options, vars, vars_lowerbound, vars_upperbound, constraints_lowerbound,\n constraints_upperbound, fg_eval, solution);\n\n // Check some of the solution values\n ok &= solution.status == CppAD::ipopt::solve_result::success;\n\n // Cost\n auto cost = solution.obj_value;\n std::cout << \"------------ Total Cost(solution): \" << cost << \"------------\" << std::endl;\n cout << \"-----------------------------------------------\" <mpc_x = {};\n this->mpc_y = {};\n this->mpc_theta = {};\n for (int i = 0; i < _mpc_steps; i++) \n {\n this->mpc_x.push_back(solution.x[_x_start + i]);\n this->mpc_y.push_back(solution.x[_y_start + i]);\n this->mpc_theta.push_back(solution.x[_theta_start + i]);\n }\n \n vector result;\n result.push_back(solution.x[_angvel_start]);\n result.push_back(solution.x[_a_start]);\n return result;\n}\n", "meta": {"hexsha": "b48fd3edb086b4de7ee5fc6b74c786141351af0b", "size": 16442, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/MPC_last.cpp", "max_stars_repo_name": "fangzheng81/mpc_ros", "max_stars_repo_head_hexsha": "3b438cff3a8ed03f3df9cabafa8b8fad88934811", "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/MPC_last.cpp", "max_issues_repo_name": "fangzheng81/mpc_ros", "max_issues_repo_head_hexsha": "3b438cff3a8ed03f3df9cabafa8b8fad88934811", "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/MPC_last.cpp", "max_forks_repo_name": "fangzheng81/mpc_ros", "max_forks_repo_head_hexsha": "3b438cff3a8ed03f3df9cabafa8b8fad88934811", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2019-10-05T12:30:19.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-30T13:13:40.000Z", "avg_line_length": 41.0024937656, "max_line_length": 212, "alphanum_fraction": 0.5578396789, "num_tokens": 4712, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303087996143, "lm_q2_score": 0.6926419894793246, "lm_q1q2_score": 0.5475544858306697}} {"text": "/***************************************************************************\n * Copyright (c) 2011 Konstantinos Poulios *\n * *\n * This file is part of the FreeCAD CAx development system. *\n * *\n * This library is free software; you can redistribute it and/or *\n * modify it under the terms of the GNU Library General Public *\n * License as published by the Free Software Foundation; either *\n * version 2 of the License, or (at your option) any later version. *\n * *\n * This library is distributed in the hope that it will be useful, *\n * but WITHOUT ANY WARRANTY; without even the implied warranty of *\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *\n * GNU Library General Public License for more details. *\n * *\n * You should have received a copy of the GNU Library General Public *\n * License along with this library; see the file COPYING.LIB. If not, *\n * write to the Free Software Foundation, Inc., 59 Temple Place, *\n * Suite 330, Boston, MA 02111-1307, USA *\n * *\n ***************************************************************************/\n\n#ifdef _MSC_VER\n#pragma warning(disable : 4244)\n#endif\n\n#include \n#include \n\nusing namespace Eigen;\n\n// minimizes ( 0.5 * x^T * H * x + g^T * x ) under the condition ( A*x + c = 0 )\n// it returns the solution in x, the row-space of A in Y, and the null space of A in Z\nint qp_eq(MatrixXd &H, VectorXd &g, MatrixXd &A, VectorXd &c,\n VectorXd &x, MatrixXd &Y, MatrixXd &Z)\n{\n FullPivHouseholderQR qrAT(A.transpose());\n MatrixXd Q = qrAT.matrixQ ();\n\n size_t params_num = qrAT.rows();\n size_t constr_num = qrAT.cols();\n size_t rank = qrAT.rank();\n\n if (rank != constr_num || constr_num > params_num)\n return -1;\n\n // A^T = Q*R*P^T = Q1*R1*P^T\n // Q = [Q1,Q2], R=[R1;0]\n // Y = Q1 * inv(R^T) * P^T\n // Z = Q2\n Y = qrAT.matrixQR().topRows(constr_num)\n .triangularView()\n .transpose()\n .solve(Q.leftCols(rank))\n * qrAT.colsPermutation().transpose();\n if (params_num == rank)\n x = - Y * c;\n else {\n Z = Q.rightCols(params_num-rank);\n\n MatrixXd ZTHZ = Z.transpose() * H * Z;\n VectorXd rhs = Z.transpose() * (H * Y * c - g);\n\n VectorXd y = ZTHZ.colPivHouseholderQr().solve(rhs);\n\n x = - Y * c + Z * y;\n }\n\n return 0;\n}\n", "meta": {"hexsha": "7eeb58fafc13e2c34f1743b6ee0b7686bd033269", "size": 2954, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "external/PlaneGCS/qp_eq.cpp", "max_stars_repo_name": "xzrunner/constraints2", "max_stars_repo_head_hexsha": "91a48120afdd06a21124a2fb79bcc9f6d05045c2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-08-14T06:34:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-14T06:34:14.000Z", "max_issues_repo_path": "external/PlaneGCS/qp_eq.cpp", "max_issues_repo_name": "xzrunner/constraints2", "max_issues_repo_head_hexsha": "91a48120afdd06a21124a2fb79bcc9f6d05045c2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-08-14T08:42:12.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-17T12:37:56.000Z", "max_forks_repo_path": "external/PlaneGCS/qp_eq.cpp", "max_forks_repo_name": "xzrunner/constraints2", "max_forks_repo_head_hexsha": "91a48120afdd06a21124a2fb79bcc9f6d05045c2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.6056338028, "max_line_length": 86, "alphanum_fraction": 0.4749492214, "num_tokens": 677, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867873410141, "lm_q2_score": 0.6859494614282923, "lm_q1q2_score": 0.5475157968957475}} {"text": "#include \n#include \n\n#include \n\nNTL_START_IMPL\n\n\n#if (NTL_BITS_PER_LONG >= NTL_DOUBLE_PRECISION)\n\n\nquad_float to_quad_float(long n)\n{\n double xhi, xlo;\n\n xhi = TrueDouble(n);\n\n // Because we are assuming 2's compliment integer\n // arithmetic, the following prevents long(xhi) from overflowing.\n\n if (n > 0)\n xlo = TrueDouble(n+long(-xhi));\n else\n xlo = TrueDouble(n-long(xhi));\n\n // renormalize...just to be safe\n\n quad_float z;\n quad_float_normalize(z, xhi, xlo);\n return z;\n}\n\nquad_float to_quad_float(unsigned long n)\n{\n double xhi, xlo, t;\n\n const double bnd = double(1L << (NTL_BITS_PER_LONG-2))*4.0;\n\n xhi = TrueDouble(n);\n \n if (xhi >= bnd)\n t = xhi - bnd;\n else\n t = xhi;\n\n // we use the \"to_long\" function here to be as portable as possible.\n long llo = to_long(n - (unsigned long)(t));\n xlo = TrueDouble(llo);\n\n quad_float z;\n quad_float_normalize(z, xhi, xlo);\n return z;\n}\n#endif\n\n\nNTL_CHEAP_THREAD_LOCAL\nlong quad_float::oprec = 10;\n\nvoid quad_float::SetOutputPrecision(long p)\n{\n if (p < 1) p = 1;\n\n if (NTL_OVERFLOW(p, 1, 0)) \n ResourceError(\"quad_float: output precision too big\");\n\n oprec = p;\n}\n\n\n\nvoid power(quad_float& z, const quad_float& a, long e)\n{\n quad_float res, u;\n unsigned long k;\n\n if (e < 0)\n k = -((unsigned long) e);\n else\n k = e;\n\n res = 1.0;\n u = a;\n\n while (k) {\n if (k & 1)\n res = res * u;\n\n k = k >> 1;\n if (k)\n u = u * u;\n }\n\n if (e < 0)\n z = 1.0/res;\n else\n z = res;\n}\n\n\nvoid power2(quad_float& z, long e)\n{\n z.hi = _ntl_ldexp(1.0, e);\n z.lo = 0;\n}\n\n\nlong to_long(const quad_float& x)\n{\n double fhi, flo;\n\n fhi = floor(x.hi);\n\n if (fhi == x.hi) \n flo = floor(x.lo);\n else\n flo = 0;\n\n // the following code helps to prevent unnecessary integer overflow,\n // and guarantees that to_long(to_quad_float(a)) == a, for all long a,\n // provided long's are not too wide.\n\n if (fhi > 0)\n return long(flo) - long(-fhi);\n else\n return long(fhi) + long(flo);\n}\n\n\n\n// This version of ZZ to quad_float coversion relies on the\n// precise rounding rules implemented by the ZZ to double conversion.\n\n\nvoid conv(quad_float& z, const ZZ& a)\n{\n double xhi, xlo;\n\n conv(xhi, a);\n\n if (!IsFinite(&xhi)) {\n z.hi = xhi;\n z.lo = 0;\n return;\n }\n\n NTL_ZZRegister(t);\n\n conv(t, xhi);\n sub(t, a, t);\n\n conv(xlo, t);\n\n quad_float_normalize(z, xhi, xlo);\n} \n\nvoid conv(ZZ& z, const quad_float& x)\n{ \n NTL_ZZRegister(t1);\n NTL_ZZRegister(t2);\n NTL_ZZRegister(t3);\n\n double fhi, flo;\n\n fhi = floor(x.hi);\n\n if (fhi == x.hi) {\n flo = floor(x.lo);\n\n conv(t1, fhi);\n conv(t2, flo);\n\n add(z, t1, t2);\n }\n else\n conv(z, fhi);\n}\n\n\n\nostream& operator<<(ostream& s, const quad_float& a)\n{\n quad_float aa = a;\n\n if (!IsFinite(&aa)) {\n s << \"NaN\";\n return s;\n }\n\n RRPush push;\n RROutputPush opush;\n\n RR::SetPrecision(long(3.33*quad_float::oprec) + 10);\n RR::SetOutputPrecision(quad_float::oprec);\n\n NTL_TLS_LOCAL(RR, t);\n\n conv(t, a);\n s << t;\n\n return s;\n}\n\nistream& operator>>(istream& s, quad_float& x)\n{\n RRPush push;\n RR::SetPrecision(4*NTL_DOUBLE_PRECISION);\n\n NTL_TLS_LOCAL(RR, t);\n NTL_INPUT_CHECK_RET(s, s >> t);\n conv(x, t);\n\n return s;\n}\n\nvoid random(quad_float& x)\n{\n RRPush push;\n RR::SetPrecision(4*NTL_DOUBLE_PRECISION);\n\n NTL_TLS_LOCAL(RR, t);\n random(t);\n conv(x, t);\n}\n\nquad_float random_quad_float()\n{\n quad_float x;\n random(x);\n return x;\n}\n \nlong IsFinite(quad_float *x)\n{\n return IsFinite(&x->hi) && IsFinite(&x->lo);\n}\n\n\nquad_float floor(const quad_float& x)\n{\n double fhi = floor(x.hi);\n\n if (fhi != x.hi)\n return quad_float(fhi, 0.0);\n else {\n double flo = floor(x.lo);\n quad_float z;\n quad_float_normalize(z, fhi, flo);\n return z;\n }\n}\n\n\nquad_float ceil(const quad_float& x) { \n return -floor(-x);\n}\n\nquad_float trunc(const quad_float& x) { \n if (x>=0.0) return floor(x); else return -floor(-x);\n}\n\n\n\nlong compare(const quad_float& x, const quad_float& y)\n{\n if (x.hi > y.hi) \n return 1;\n else if (x.hi < y.hi)\n return -1;\n else if (x.lo > y.lo)\n return 1;\n else if (x.lo < y.lo) \n return -1;\n else\n return 0;\n}\n\n\nquad_float fabs(const quad_float& x) \n{ if (x.hi>=0.0) return x; else return -x; }\n\n\nquad_float ldexp(const quad_float& x, long exp) { // x*2^exp\n double xhi, xlo;\n quad_float z;\n\n xhi = _ntl_ldexp(x.hi, exp);\n xlo = _ntl_ldexp(x.lo, exp);\n\n quad_float_normalize(z, xhi, xlo);\n return z;\n}\n\n\nquad_float exp(const quad_float& x) { // New version 97 Aug 05\n/*\n! Calculate a quadruple-precision exponential\n! Method:\n! x x.log2(e) nint[x.log2(e)] + frac[x.log2(e)]\n! e = 2 = 2\n!\n! iy fy\n! = 2 . 2\n! Then\n! fy y.loge(2)\n! 2 = e\n!\n! Now y.loge(2) will be less than 0.3466 in absolute value.\n! This is halved and a Pade aproximation is used to approximate e^x over\n! the region (-0.1733, +0.1733). This approximation is then squared.\n*/\n if (x.hiDBL_MAX_10_EXP*2.302585092994045684017991) {\n ResourceError(\"exp(quad_float): overflow\");\n }\n\n static const quad_float Log2 = to_quad_float(\"0.6931471805599453094172321214581765680755\");\n // GLOBAL (assumes C++11 thread-safe init)\n\n quad_float y,temp,ysq,sum1,sum2;\n long iy;\n y=x/Log2;\n temp = floor(y+0.5);\n iy = to_long(temp);\n y=(y-temp)*Log2;\n y=ldexp(y,-1L);\n ysq=y*y;\n sum1=y*((((ysq+3960.0)*ysq+2162160.0)*ysq+302702400.0)*ysq+8821612800.0);\n sum2=(((90.0*ysq+110880.0)*ysq+30270240.0)*ysq+2075673600.0)*ysq+17643225600.0;\n/*\n! sum2 + sum1 2.sum1\n! Now approximation = ----------- = 1 + ----------- = 1 + 2.temp\n! sum2 - sum1 sum2 - sum1\n!\n! Then (1 + 2.temp)^2 = 4.temp.(1 + temp) + 1\n*/\n temp=sum1/(sum2-sum1);\n y=temp*(temp+1);\n y=ldexp(y,2L);\n return ldexp(y+1,iy);\n}\n\nquad_float log(const quad_float& t) { // Newton method. See Bailey, MPFUN\n if (t.hi <= 0.0) {\n ArithmeticError(\"log(quad_float): argument must be positive\");\n }\n\n quad_float s = to_quad_float(log(t.hi));\n // NOTE: in case log yields excess precision, this assumes\n // that to_quad_float removes it\n\n quad_float e = exp(s);\n return s+(t-e)/e; // Newton step\n}\n\nquad_float sqrt(const quad_float& y)\n{\n if (y.hi < 0.0)\n ArithmeticError(\"quad_float: square root of negative number\");\n if (y.hi == 0.0) return quad_float(0.0,0.0);\n\n double c = TrueDouble(sqrt(y.hi));\n // NOTE: we call TrueDouble, just in case sqrt yields excess precision\n\n quad_float yy = y;\n quad_float_in_place_sqrt(yy, c);\n return yy;\n}\n\n\nlong operator> (const quad_float& x, const quad_float& y) {\n return (x.hi> y.hi) || (x.hi==y.hi && x.lo> y.lo); }\nlong operator>=(const quad_float& x, const quad_float& y) {\n return (x.hi>y.hi) || (x.hi==y.hi && x.lo>=y.lo); }\nlong operator< (const quad_float& x, const quad_float& y) {\n return (x.hi< y.hi) || (x.hi==y.hi && x.lo< y.lo); }\nlong operator<=(const quad_float& x, const quad_float& y) {\n return (x.hi\n\nnamespace edp\n{\nnamespace internal\n{\n\tinline uint32_t ipow(uint32_t base, uint32_t exp)\n\t{\n\t\tuint32_t result = 1U;\n\t\twhile (exp)\n\t\t{\n\t\t\tif (exp & 1U)\n\t\t\t\tresult *= base;\n\t\t\texp >>= 1U;\n\t\t\tbase *= base;\n\t\t}\n\n\t\treturn result;\n\t}\n}\n\ntemplate\nstruct TwoSiteTerm\n{\n\tstd::pair sites;\n\tEigen::SparseMatrix m;\n\n\tTwoSiteTerm(const std::pair& p1, const Eigen::SparseMatrix& p2)\n\t\t: sites(p1), m(p2)\n\t{\n\t}\n\tTwoSiteTerm(std::pair&& p1, Eigen::SparseMatrix&& p2)\n\t\t: sites(p1), m(p2)\n\t{\n\t}\n};\n\ntemplate\nstruct OneSiteTerm\n{\n\tuint32_t site;\n\tEigen::SparseMatrix m;\n\n\tOneSiteTerm(uint32_t p1, const Eigen::SparseMatrix& p2)\n\t\t: site(p1), m(p2)\n\t{\n\t}\n\n\tOneSiteTerm(uint32_t p1, Eigen::SparseMatrix&& p2)\n\t\t: site(p1), m(p2)\n\t{\n\t}\n};\n\ntemplate\nclass LocalHamiltonian\n{\nprivate:\n\tuint32_t numSites_;\n\tuint64_t d_; //local Hibert dimension\n\n\tstd::vector > twoSiteTerms_;\n\tstd::vector > oneSiteTerms_;\n\n\tuint32_t swapBaseD(uint32_t idx, uint32_t pos, uint32_t val) const\n\t{\n\t\tuint32_t b = internal::ipow(d_, pos);\n\t\tuint32_t upper = (idx / (b*d_))*d_ + val;\n\t\treturn upper*b + (idx % b);\n\t}\npublic:\n\tLocalHamiltonian(uint32_t numSites, uint32_t d)\n\t\t: numSites_{numSites}, d_{d}\n\t{\n\t}\n\tLocalHamiltonian(const LocalHamiltonian&) = default;\n\tLocalHamiltonian(LocalHamiltonian&&) = default;\n\n\tLocalHamiltonian& operator=(const LocalHamiltonian&) = default;\n\tLocalHamiltonian& operator=(LocalHamiltonian&&) = default;\n\n\tvoid clearTerms()\n\t{\n\t\tstd::vector >().swap(twoSiteTerms_);\n\t\tstd::vector >().swap(oneSiteTerms_);\n\t}\n\tuint32_t getNumSites() const\n\t{\n\t\treturn numSites_;\n\t}\n\n\tstd::map getCol(uint32_t n) const;\n\tinline std::map operator()(uint32_t n) const\n\t{\n\t\treturn getCol(n);\n\t}\n\n\tvoid addTwoSiteTerm(const std::pair& site, Eigen::SparseMatrix m)\n\t{\n\t\tm.makeCompressed();\n\t\ttwoSiteTerms_.emplace_back(site, std::move(m));\n\t}\n\tvoid addOneSiteTerm(uint32_t site, Eigen::SparseMatrix m)\n\t{\n\t\tm.makeCompressed();\n\t\toneSiteTerms_.emplace_back(site, std::move(m));\n\t}\n};\n\n}\n\ntemplate\nstd::map edp::LocalHamiltonian::getCol(uint32_t n) const\n{\n\tusing internal::ipow;\n\tusing Eigen::SparseMatrix;\n\n\tstd::map m;\n\n\tfor(auto& twoSiteTerm : twoSiteTerms_)\n\t{\n\t\tauto a = (n/ipow(d_,twoSiteTerm.sites.first))%d_;\n\t\tauto b = (n/ipow(d_,twoSiteTerm.sites.second))%d_;\n\t\t//auto col = twoSiteTerm.m.col(a*d_ + b);\n\t\tauto col = b*d_ + a;\n\t\tfor(typename SparseMatrix::InnerIterator it(twoSiteTerm.m, col); it; ++it)\n\t\t{\n\t\t\tuint32_t r = it.row();\n\t\t\tuint32_t t = n;\n\t\t\tt = swapBaseD(t, twoSiteTerm.sites.first, r%d_);\n\t\t\tt = swapBaseD(t, twoSiteTerm.sites.second, r/d_);\n\t\t\tm[t] += it.value();\n\t\t}\n\t}\n\tfor(auto& oneSiteTerm: oneSiteTerms_)\n\t{\n\t\tuint32_t a = (n/ipow(d_,oneSiteTerm.site))%d_;\n\t\t//auto col = oneSiteTerm.m.col(a);\n\t\tauto col = a;\n\n\t\tfor(typename SparseMatrix::InnerIterator it(oneSiteTerm.m, col); it; ++it)\n\t\t{\n\t\t\tuint32_t r = it.row();\n\t\t\tuint32_t t = n;\n\t\t\tt = swapBaseD(t, oneSiteTerm.site, r);\n\t\t\tm[t] += it.value();\n\t\t}\n\t}\n\treturn m;\n}\n", "meta": {"hexsha": "0f7cce9d791d3a7a7b0d6e529105e4ec767c472e", "size": 3219, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/edlib/EDP/LocalHamiltonian.hpp", "max_stars_repo_name": "chaeyeunpark/ExactDiagonalization", "max_stars_repo_head_hexsha": "c93754e724486cc68453399c5dda6a2dadf45cb8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-04-24T08:47:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-24T08:47:05.000Z", "max_issues_repo_path": "include/edlib/EDP/LocalHamiltonian.hpp", "max_issues_repo_name": "chaeyeunpark/ExactDiagonalization", "max_issues_repo_head_hexsha": "c93754e724486cc68453399c5dda6a2dadf45cb8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-09-28T19:02:14.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-28T19:02:14.000Z", "max_forks_repo_path": "include/edlib/EDP/LocalHamiltonian.hpp", "max_forks_repo_name": "chaeyeunpark/ExactDiagonalization", "max_forks_repo_head_hexsha": "c93754e724486cc68453399c5dda6a2dadf45cb8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-03-22T18:59:11.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-22T18:59:11.000Z", "avg_line_length": 21.1776315789, "max_line_length": 87, "alphanum_fraction": 0.6731904318, "num_tokens": 1070, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8740772351648678, "lm_q2_score": 0.6261241772283034, "lm_q1q2_score": 0.547280889701593}} {"text": "/* Copyright (c) 2010-2019, Delft University of Technology\n * All rigths reserved\n *\n * This file is part of the Tudat. Redistribution and use in source and\n * binary forms, with or without modification, are permitted exclusively\n * under the terms of the Modified BSD license. You should have received\n * a copy of the license with this file. If not, please or visit:\n * http://tudat.tudelft.nl/LICENSE.\n *\n * References\n * Montebruck O, Gill E. Satellite Orbits, Corrected Third Printing, Springer, 2005.\n * Bate R. Fundamentals of Astrodynamics, Courier Dover Publications, 1971.\n *\n */\n\n#include \n#include \n\n#include \"Tudat/Astrodynamics/BasicAstrodynamics/missionGeometry.h\"\n#include \"Tudat/Mathematics/BasicMathematics/mathematicalConstants.h\"\n#include \"Tudat/Astrodynamics/BasicAstrodynamics/stateVectorIndices.h\"\n\nnamespace tudat\n{\n\nnamespace mission_geometry\n{\n\n//! Compute whether an orbit is retrograde based on inclination.\nbool isOrbitRetrograde( const double inclination )\n{\n bool isRetrograde = false;\n\n // Check which range inclination is in and return value accordingly.\n if ( inclination < 0.0 || inclination > mathematical_constants::PI )\n {\n throw std::runtime_error(\n \"The inclination is in the wrong range when determining retrogradeness\" );\n }\n else if ( inclination <= mathematical_constants::PI / 2.0 )\n {\n isRetrograde = false;\n }\n else if ( inclination > mathematical_constants::PI / 2.0 )\n {\n isRetrograde = true;\n }\n\n return isRetrograde;\n}\n\n//! Compute whether an orbit is retrograde based on Keplerian state.\nbool isOrbitRetrograde( const Eigen::Vector6d& keplerElements )\n{\n // Get inclination from vector and call overloaded function.\n return isOrbitRetrograde(\n keplerElements(\n orbital_element_conversions::inclinationIndex ) );\n}\n\n//! Compute the shadow function.\ndouble computeShadowFunction( const Eigen::Vector3d& occultedBodyPosition,\n const double occultedBodyRadius,\n const Eigen::Vector3d& occultingBodyPosition,\n const double occultingBodyRadius,\n const Eigen::Vector3d& satellitePosition )\n{\n // Calculate coordinates of the spacecraft with respect to the occulting body.\n const Eigen::Vector3d satellitePositionRelativeToOccultingBody = satellitePosition\n - occultingBodyPosition;\n\n // Calculate apparent radius of occulted body.\n const double occultedBodyApparentRadius\n = std::asin( occultedBodyRadius\n / ( occultedBodyPosition - satellitePosition ).norm( ) );\n\n // Calculate apparent radius of occulting body.\n const double occultingBodyApparentRadius =\n std::asin( occultingBodyRadius / satellitePositionRelativeToOccultingBody.norm( ) );\n\n // Calculate apparent separation of the center of both bodies.\n const double apparentSeparationPartOne = -satellitePositionRelativeToOccultingBody.transpose( )\n * ( occultedBodyPosition - satellitePosition );\n const double apparentSeparationPartTwo = satellitePositionRelativeToOccultingBody.norm( )\n * ( occultedBodyPosition - satellitePosition ).norm( );\n const double apparentSeparation = std::acos( apparentSeparationPartOne\n / apparentSeparationPartTwo );\n\n // Set initial value for the shadow function.\n double shadowFunction = 1.0;\n\n // Check if partial occultation takes place\n if ( std::fabs( occultedBodyApparentRadius - occultingBodyApparentRadius ) < apparentSeparation\n && apparentSeparation < occultedBodyApparentRadius + occultingBodyApparentRadius )\n {\n // Pre-compute values for optimal computations.\n const double apparentSeparationSquared = apparentSeparation * apparentSeparation;\n const double occultedBodyApparentRadiusSquared = occultedBodyApparentRadius\n * occultedBodyApparentRadius;\n const double occultingBodyApparentRadiusSquared = occultingBodyApparentRadius\n * occultingBodyApparentRadius;\n\n // Partial occultation takes place, calculate the occulted area.\n const double occultedAreaPartOne\n = ( apparentSeparationSquared + occultedBodyApparentRadiusSquared\n - occultingBodyApparentRadiusSquared ) / ( 2.0 * apparentSeparation );\n const double occultedAreaPartTwo = std::sqrt( occultedBodyApparentRadiusSquared\n - occultedAreaPartOne * occultedAreaPartOne );\n const double occultedArea = occultedBodyApparentRadiusSquared\n * std::acos( occultedAreaPartOne / occultedBodyApparentRadius )\n + occultingBodyApparentRadiusSquared\n * std::acos( ( apparentSeparation - occultedAreaPartOne )\n / occultingBodyApparentRadius )\n - apparentSeparation * occultedAreaPartTwo;\n shadowFunction = 1.0 - occultedArea / ( mathematical_constants::PI *\n occultedBodyApparentRadiusSquared );\n }\n\n else\n {\n // Full or no occultation takes place.\n // Check for type of occultation.\n if ( apparentSeparation < occultingBodyApparentRadius - occultedBodyApparentRadius &&\n occultedBodyApparentRadius < occultingBodyApparentRadius )\n {\n // Total occultation.\n shadowFunction = 0.0;\n }\n\n else if ( apparentSeparation < occultedBodyApparentRadius - occultingBodyApparentRadius &&\n occultedBodyApparentRadius > occultingBodyApparentRadius )\n {\n // Maximum partial occultation.\n shadowFunction = 0.0;\n }\n\n else if ( occultedBodyApparentRadius + occultingBodyApparentRadius <= apparentSeparation )\n {\n // No occultation\n shadowFunction = 1.0;\n }\n }\n\n // Return the shadow function\n return shadowFunction;\n}\n\ndouble computeSphereOfInfluence( const double distanceToCentralBody,\n const double ratioOfOrbitingToCentralBodyMass )\n{\n // Return the radius of the sphere of influence.\n return distanceToCentralBody * std::pow( ratioOfOrbitingToCentralBodyMass, 0.4 );\n}\n\n//! Compute the sphere of influence.\ndouble computeSphereOfInfluence( const double distanceToCentralBody,\n const double massOrbitingBody,\n const double massCentralBody )\n{\n // Return the radius of the sphere of influence.\n return computeSphereOfInfluence( distanceToCentralBody, massOrbitingBody / massCentralBody );\n}\n\n} // namespace mission_geometry\n\n} // namespace tudat\n", "meta": {"hexsha": "d25202f8202e9b9868e96e46ed800ba7b1a267dd", "size": 6904, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Tudat/Astrodynamics/BasicAstrodynamics/missionGeometry.cpp", "max_stars_repo_name": "sebranchett/tudat", "max_stars_repo_head_hexsha": "24e5f3cc85c250fcbed0aac37f026c1dd7fd6c44", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Tudat/Astrodynamics/BasicAstrodynamics/missionGeometry.cpp", "max_issues_repo_name": "sebranchett/tudat", "max_issues_repo_head_hexsha": "24e5f3cc85c250fcbed0aac37f026c1dd7fd6c44", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Tudat/Astrodynamics/BasicAstrodynamics/missionGeometry.cpp", "max_forks_repo_name": "sebranchett/tudat", "max_forks_repo_head_hexsha": "24e5f3cc85c250fcbed0aac37f026c1dd7fd6c44", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.3413173653, "max_line_length": 100, "alphanum_fraction": 0.6720741599, "num_tokens": 1462, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.874077222043951, "lm_q2_score": 0.6261241702517976, "lm_q1q2_score": 0.5472808753882651}} {"text": "//=======================================================================\r\n// Copyright 2007 Aaron Windsor - Ben Sisson\r\n//\r\n// Distributed under the Boost Software License, Version 1.0. (See\r\n// accompanying file LICENSE_1_0.txt or copy at\r\n// http://www.boost.org/LICENSE_1_0.txt)\r\n//=======================================================================\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n\r\nusing namespace boost;\r\n\r\n\r\n//a class to hold the coordinates of the straight line embedding\r\nstruct coord_t{\r\n std::size_t x;\r\n std::size_t y;\r\n};\r\n\r\nint main(int argc, char** argv){\r\n\r\n typedef adjacency_list\r\n < vecS,\r\n vecS,\r\n undirectedS,\r\n property,\r\n property\r\n > \r\n graph;\r\n\r\n graph g(7);\r\n add_edge(0,1,g);\r\n add_edge(1,2,g);\r\n add_edge(2,3,g);\r\n add_edge(3,0,g);\r\n add_edge(0,4,g);\r\n add_edge(1,5,g);\r\n add_edge(2,6,g);\r\n add_edge(3,7,g);\r\n add_edge(4,5,g);\r\n add_edge(5,6,g);\r\n add_edge(6,7,g);\r\n add_edge(7,4,g);\r\n\r\n //Initialize the interior edge index\r\n property_map::type e_index = get(edge_index, g);\r\n graph_traits::edges_size_type edge_count = 0;\r\n graph_traits::edge_iterator ei, ei_end;\r\n for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)\r\n put(e_index, *ei, edge_count++);\r\n \r\n \r\n //Test for planarity; compute the planar embedding as a side-effect\r\n typedef std::vector< graph_traits::edge_descriptor > vec_t;\r\n std::vector embedding(num_vertices(g));\r\n boyer_myrvold_planarity_test(boyer_myrvold_params::graph = g,\r\n boyer_myrvold_params::embedding = \r\n &embedding[0]\r\n );\r\n \r\n make_biconnected_planar(g, &embedding[0]);\r\n\r\n // Re-initialize the edge index, since we just added a few edges\r\n edge_count = 0;\r\n for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)\r\n put(e_index, *ei, edge_count++);\r\n\r\n\r\n //Test for planarity again; compute the planar embedding as a side-effect\r\n boyer_myrvold_planarity_test(boyer_myrvold_params::graph = g,\r\n boyer_myrvold_params::embedding = \r\n &embedding[0]\r\n );\r\n\r\n make_maximal_planar(g, &embedding[0]);\r\n\r\n // Re-initialize the edge index, since we just added a few edges\r\n edge_count = 0;\r\n for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)\r\n put(e_index, *ei, edge_count++);\r\n\r\n boyer_myrvold_planarity_test(boyer_myrvold_params::graph = g,\r\n boyer_myrvold_params::embedding = \r\n &embedding[0]\r\n );\r\n\r\n // Find a canonical ordering\r\n std::vector::vertex_descriptor> ordering;\r\n planar_canonical_ordering(g, &embedding[0], std::back_inserter(ordering));\r\n\r\n\r\n //Set up a property map to hold the mapping from vertices to coord_t's\r\n typedef std::vector< coord_t > straight_line_drawing_storage_t;\r\n typedef boost::iterator_property_map\r\n < straight_line_drawing_storage_t::iterator, \r\n property_map::type \r\n >\r\n straight_line_drawing_t;\r\n\r\n straight_line_drawing_storage_t straight_line_drawing_storage\r\n (num_vertices(g));\r\n straight_line_drawing_t straight_line_drawing\r\n (straight_line_drawing_storage.begin(), \r\n get(vertex_index,g)\r\n );\r\n\r\n\r\n\r\n // Compute the straight line drawing\r\n chrobak_payne_straight_line_drawing(g, \r\n embedding, \r\n ordering.begin(),\r\n ordering.end(),\r\n straight_line_drawing\r\n );\r\n \r\n\r\n\r\n std::cout << \"The straight line drawing is: \" << std::endl;\r\n graph_traits::vertex_iterator vi, vi_end;\r\n for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)\r\n {\r\n coord_t coord(get(straight_line_drawing,*vi));\r\n std::cout << *vi << \" -> (\" << coord.x << \", \" << coord.y << \")\" \r\n << std::endl;\r\n }\r\n\r\n // Verify that the drawing is actually a plane drawing\r\n if (is_straight_line_drawing(g, straight_line_drawing))\r\n std::cout << \"Is a plane drawing.\" << std::endl;\r\n else\r\n std::cout << \"Is not a plane drawing.\" << std::endl;\r\n\r\n return 0;\r\n}", "meta": {"hexsha": "69438eb5d5210d74960bbe93929475555103ef39", "size": 5026, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "embed.cpp", "max_stars_repo_name": "benmsisson/chrobak_embedding", "max_stars_repo_head_hexsha": "391e601b5ec686b256e68d7bfb3a34e240dd1fb3", "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": "embed.cpp", "max_issues_repo_name": "benmsisson/chrobak_embedding", "max_issues_repo_head_hexsha": "391e601b5ec686b256e68d7bfb3a34e240dd1fb3", "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": "embed.cpp", "max_forks_repo_name": "benmsisson/chrobak_embedding", "max_forks_repo_head_hexsha": "391e601b5ec686b256e68d7bfb3a34e240dd1fb3", "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": 33.7315436242, "max_line_length": 77, "alphanum_fraction": 0.5955033824, "num_tokens": 1215, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.782662489091802, "lm_q2_score": 0.6992544210587585, "lm_q1q2_score": 0.5472802056942949}} {"text": "/** A simple cartesian space controller.\n It receives a destination, a duration and publishes the trajectory\n in cartesian space at 200Hz\n Note: the robot is required to be calibrated to the zero configuration\n as used in the kdl chain model.\n**/\n#include \"ros/ros.h\"\n#include \n#include \n#include \n#include \"bosch_arm_srvs/GetJointAngles.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace Eigen;\n\nclass BoschArmKinematicModel\n{\n public:\n double L0,L3,L4;\n Vector3f getTipPosition(Vector4f q)\n {\n Vector3f tip;\n double q1=q(0);\n double q2=q(1);\n double q3=q(2);\n double q4=q(3);\n tip(0)= - L4*(sin(q4)*(cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3)) + cos(q2)*cos(q4)*sin(q1)) - L3*cos(q2)*sin(q1);\n tip(1)= - L4*(cos(q4)*sin(q2) + cos(q2)*sin(q3)*sin(q4)) - L3*sin(q2);\n tip(2)=L0 - L4*(sin(q4)*(cos(q3)*sin(q1) + cos(q1)*sin(q2)*sin(q3)) - cos(q1)*cos(q2)*cos(q4)) + L3*cos(q1)*cos(q2);\n return tip;\n }\n Matrix3f getJacobianLockJoint3(Vector4f qlock)\n {\n Matrix3f jacob;\n double q1=qlock(0);\n double q2=qlock(1);\n double q3=qlock(2);\n double q4=qlock(3);\n jacob(0,0)=L4*(sin(q4)*(cos(q3)*sin(q1) + cos(q1)*sin(q2)*sin(q3)) - cos(q1)*cos(q2)*cos(q4)) - L3*cos(q1)*cos(q2);\n jacob(0,1)=L4*(cos(q4)*sin(q1)*sin(q2) + cos(q2)*sin(q1)*sin(q3)*sin(q4)) + L3*sin(q1)*sin(q2);\n jacob(0,2)=-L4*(cos(q4)*(cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3)) - cos(q2)*sin(q1)*sin(q4));\n jacob(1,0)=0;\n jacob(1,1)=-L4*(cos(q2)*cos(q4) - sin(q2)*sin(q3)*sin(q4)) - L3*cos(q2);\n jacob(1,2)=L4*(sin(q2)*sin(q4) - cos(q2)*cos(q4)*sin(q3));\n jacob(2,0)=- L4*(sin(q4)*(cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3)) + cos(q2)*cos(q4)*sin(q1)) - L3*cos(q2)*sin(q1);\n jacob(2,1)=- L4*(cos(q1)*cos(q4)*sin(q2) + cos(q1)*cos(q2)*sin(q3)*sin(q4)) - L3*cos(q1)*sin(q2);\n jacob(2,2)=-L4*(cos(q4)*(cos(q3)*sin(q1) + cos(q1)*sin(q2)*sin(q3)) + cos(q1)*cos(q2)*sin(q4));\n return jacob;\n }\n\n \n};\nint main ( int argc, char **argv )\n{\n ros::init ( argc, argv, \"traj_gen\" );\n ros::NodeHandle n;\n ros::Publisher traj_pub = n.advertise ( \"/traj_cmd\",1 );\n //boost::thread t2 = boost::thread::thread ( boost::bind ( &pubTrajectory ) );\n ros::ServiceClient client = n.serviceClient ( \"get_joint_angles\" );\n bosch_arm_srvs::GetJointAngles srv;\n client.call ( srv );\n\n //read destination and duration\n KDL::Vector des;\n for ( int i=0;i<3;i++ )\n des[i]=boost::lexical_cast ( argv[i+1] );\n double t=boost::lexical_cast ( argv[4] );\n\n\n //TODO convert destination to joint angles\n \n Segment seg0=Segment ( Joint ( Joint::None ),\n Frame ( Rotation::RPY ( M_PI/2,-M_PI/2,0 ),Vector ( 0,0,0.27 ) ) );\n Segment seg1=Segment ( Joint ( Joint::RotZ ),\n Frame ( Rotation::RPY ( M_PI/2,-M_PI/2,0 ) ) );\n Segment seg2=Segment ( Joint ( Joint::RotZ ),\n Frame ( Rotation::RPY ( M_PI/2,-M_PI/2,0 ) ) );\n Segment seg3=Segment ( Joint ( Joint::None ),\n Frame ( Rotation::RPY ( M_PI/2,-M_PI/2,0 ),Vector ( 0,0,0.50 ) ) );\n Segment seg4=Segment ( Joint ( Joint::RotZ ),\n Frame ( Vector ( 0.48,0,0 ) ) );\n Chain chain;\n chain.addSegment ( seg0 );\n chain.addSegment ( seg1 );\n chain.addSegment ( seg2 );\n chain.addSegment ( seg3 );\n chain.addSegment ( seg4 );\n ChainFkSolverPos_recursive fksolver = ChainFkSolverPos_recursive ( chain );\n\n //linear interpolation in joint space\n trajectory_msgs::JointTrajectory traj;\n traj.header.stamp=ros::Time::now();\n traj.header.frame_id=\"\";\n traj.header.seq=0;\n traj.points.resize ( npts+1 );\n traj.joint_names.resize ( 4 );\n traj.joint_names[0]=\"joint1\";\n traj.joint_names[1]=\"joint2\";\n traj.joint_names[2]=\"joint3\";\n traj.joint_names[3]=\"joint4\";\n traj.points[i].positions.resize ( 4 );\n\n int npts=ceil ( t*200 );\n KDL::JntArray jointpositions = JntArray (3);\n KDL::Frame cartpos;\n double q3;\n bool kinematics_status;\n \n for ( int i=0;i<=npts;i++ )\n {\n //get the current joint position\n client.call ( srv );\n //compute forward kinematics.\n \n jointpositions (0) =srv.response.joint_angles[0];\n jointpositions (1) =srv.response.joint_angles[1];\n q3 =srv.response.joint_angles[2];\n jointpositions (2) =srv.response.joint_angles[3]; \n kinematics_status = fksolver.JntToCart ( jointpositions,cartpos );\n if ( kinematics_status>=0 )\n {\n std::cout << cartpos.p <\r\n#include \r\n\r\n#include \r\n#include \r\n\r\n#include \"Tudat/Mathematics/BasicMathematics/legendrePolynomials.h\"\r\n#include \"Tudat/Mathematics/BasicMathematics/mathematicalConstants.h\"\r\n\r\nnamespace tudat\r\n{\r\nnamespace basic_mathematics\r\n{\r\n\r\n\r\n\r\n//! Default constructor, initializes cache object with 0 maximum degree and order.\r\nLegendreCache::LegendreCache( const bool useGeodesyNormalization )\r\n{\r\n useGeodesyNormalization_ = useGeodesyNormalization;\r\n\r\n if( useGeodesyNormalization_ )\r\n {\r\n legendrePolynomialFunction_ = geodesyNormalizedLegendrePolynomialFunction;\r\n }\r\n else\r\n {\r\n legendrePolynomialFunction_ = regularLegendrePolynomialFunction;\r\n }\r\n\r\n resetMaximumDegreeAndOrder( 0, 0 );\r\n\r\n}\r\n\r\n//! Constructor\r\nLegendreCache::LegendreCache( const int maximumDegree, const int maximumOrder, const bool useGeodesyNormalization )\r\n{\r\n useGeodesyNormalization_ = useGeodesyNormalization;\r\n\r\n if( useGeodesyNormalization_ )\r\n {\r\n legendrePolynomialFunction_ = geodesyNormalizedLegendrePolynomialFunction;\r\n }\r\n else\r\n {\r\n legendrePolynomialFunction_ = regularLegendrePolynomialFunction;\r\n }\r\n\r\n resetMaximumDegreeAndOrder( maximumDegree, maximumOrder );\r\n}\r\n\r\n//! Get Legendre polynomial from cache when possible, and from direct computation otherwise.\r\nvoid LegendreCache::update( const double polynomialParameter )\r\n{\r\n currentPolynomialParameter_ = polynomialParameter;\r\n currentPolynomialParameterComplement_ = std::sqrt( 1.0 - polynomialParameter * polynomialParameter ); // cosine of latitude is always positive!\r\n\r\n LegendreCache& thisReference = *this;\r\n for( int i = 0; i <= maximumDegree_; i++ )\r\n {\r\n for( int j = 0; ( ( j <= i ) && ( j <= maximumOrder_ ) ) ; j++ )\r\n {\r\n legendreValues_[ i * ( maximumOrder_ + 1 ) + j ] = legendrePolynomialFunction_( i, j, thisReference );\r\n }\r\n }\r\n}\r\n\r\n//! Update maximum degree and order of cache\r\nvoid LegendreCache::resetMaximumDegreeAndOrder( const int maximumDegree, const int maximumOrder )\r\n{\r\n maximumDegree_ = maximumDegree;\r\n maximumOrder_ = maximumOrder;\r\n legendreValues_.resize( ( maximumDegree_ + 1 ) * ( maximumOrder_ + 1 ) );\r\n\r\n currentPolynomialParameter_ = TUDAT_NAN;\r\n currentPolynomialParameterComplement_ = TUDAT_NAN;\r\n}\r\n\r\n\r\n//! Get Legendre polynomial value from the cache.\r\ndouble LegendreCache::getLegendrePolynomial(\r\n const int degree, const int order )\r\n{\r\n if( degree > maximumDegree_ || order > maximumOrder_ )\r\n {\r\n std::cerr<<\"Error when requesting legendre cache, maximum degree or order exceeded \"<<\r\n degree<<\" \"< degree )\r\n {\r\n return 0.0;\r\n }\r\n else\r\n {\r\n return legendreValues_[ degree * ( maximumOrder_ + 1 ) + order ];\r\n };\r\n}\r\n\r\n//! Compute unnormalized associated Legendre polynomial.\r\ndouble computeLegendrePolynomial( const int degree,\r\n const int order,\r\n LegendreCache& legendreCache )\r\n{\r\n if( legendreCache.getUseGeodesyNormalization( ) )\r\n {\r\n throw std::runtime_error( \"Error when computing Legendre polynomial, input uses normalization\" );\r\n }\r\n\r\n // If degree or order is negative...\r\n if ( degree < 0 || order < 0 )\r\n {\r\n // Set error message.\r\n std::stringstream errorMessage;\r\n errorMessage << \"Error: the Legendre polynomial of = \" << degree << \" and order = \"\r\n << order << \" is undefined.\" << std::endl;\r\n\r\n // Throw a run-time error.\r\n boost::throw_exception( boost::enable_error_info( std::runtime_error(\r\n errorMessage.str( ) ) ) );\r\n }\r\n\r\n // Else if order is greater than degree...\r\n else if ( order > degree && degree >= 0 )\r\n {\r\n // Return zero.\r\n return 0.0;\r\n }\r\n\r\n // Else if order and degree are lower than 2...\r\n else if ( degree <= 1 && order <= 1 )\r\n {\r\n // Compute polynomial explicitly.\r\n return computeLegendrePolynomialExplicit( degree, order, legendreCache.getCurrentPolynomialParameter( ) );\r\n }\r\n\r\n // Else if degree and order are sectoral...\r\n else if ( degree == order )\r\n {\r\n // Obtain polynomial of degree one and order one.\r\n const double degreeOneOrderOnePolynomial = legendreCache.getLegendrePolynomial(\r\n 1, 1 );\r\n\r\n // Obtain prior sectoral polynomial.\r\n const double priorSectoralPolynomial = legendreCache.getLegendrePolynomial(\r\n degree - 1, order - 1 );\r\n\r\n // Compute polynomial.\r\n return computeLegendrePolynomialDiagonal(\r\n degree, degreeOneOrderOnePolynomial, priorSectoralPolynomial );\r\n }\r\n\r\n // Else degree and order are zonal/tessoral...\r\n else\r\n {\r\n // Obtain prior degree polynomial.\r\n const double oneDegreePriorPolynomial = legendreCache.getLegendrePolynomial(\r\n degree - 1, order );\r\n\r\n // Obtain two degrees prior polynomial.\r\n const double twoDegreesPriorPolynomial = legendreCache.getLegendrePolynomial(\r\n degree - 2, order );\r\n\r\n // Compute polynomial.\r\n return computeLegendrePolynomialVertical( degree,\r\n order,\r\n legendreCache.getCurrentPolynomialParameter( ),\r\n oneDegreePriorPolynomial,\r\n twoDegreesPriorPolynomial );\r\n }\r\n}\r\n\r\n\r\ndouble computeLegendrePolynomial( const int degree,\r\n const int order,\r\n const double legendreParameter )\r\n{\r\n LegendreCache legendreCache( degree, order, 0 );\r\n legendreCache.update( legendreParameter );\r\n return computeLegendrePolynomial( degree, order, legendreCache );\r\n}\r\n\r\n\r\n//! Compute geodesy-normalized associated Legendre polynomial.\r\ndouble computeGeodesyLegendrePolynomial( const int degree,\r\n const int order,\r\n LegendreCache& geodesyLegendreCache )\r\n{\r\n\r\n if( !geodesyLegendreCache.getUseGeodesyNormalization( ) )\r\n {\r\n throw std::runtime_error( \"Error when computing Legendre polynomial, input uses no normalization\" );\r\n }\r\n\r\n // If degree or order is negative...\r\n if ( degree < 0 || order < 0 )\r\n {\r\n // Set error message.\r\n std::stringstream errorMessage;\r\n errorMessage << \"Error: the Legendre polynomial of = \" << degree << \" and order = \"\r\n << order << \" is undefined.\" << std::endl;\r\n\r\n // Throw a run-time error.\r\n boost::throw_exception( boost::enable_error_info( std::runtime_error(\r\n errorMessage.str( ) ) ) );\r\n }\r\n\r\n // Else if order is greater than degree...\r\n else if ( order > degree && degree >= 0 )\r\n {\r\n // Return zero.\r\n return 0.0;\r\n }\r\n\r\n // Else if order and degree are lower than 2...\r\n else if ( degree <= 1 && order <= 1 )\r\n {\r\n // Compute polynomial explicitly.\r\n return computeGeodesyLegendrePolynomialExplicit( degree, order, geodesyLegendreCache.getCurrentPolynomialParameter( ) );\r\n }\r\n\r\n // Else if degree and order are sectoral...\r\n else if ( degree == order )\r\n {\r\n // Obtain polynomial of degree one and order one.\r\n double degreeOneOrderOnePolynomial = geodesyLegendreCache.getLegendrePolynomial(\r\n 1, 1 );\r\n\r\n // Obtain prior sectoral polynomial.\r\n double priorSectoralPolynomial = geodesyLegendreCache.getLegendrePolynomial(\r\n degree - 1, order - 1 );\r\n\r\n // Compute polynomial.\r\n return computeGeodesyLegendrePolynomialDiagonal(\r\n degree, degreeOneOrderOnePolynomial, priorSectoralPolynomial );\r\n }\r\n\r\n // Else degree and order are zonal/tessoral...\r\n else\r\n {\r\n // Obtain prior degree polynomial.\r\n double oneDegreePriorPolynomial = geodesyLegendreCache.getLegendrePolynomial(\r\n degree - 1, order );\r\n\r\n // Obtain two degrees prior polynomial.\r\n double twoDegreesPriorPolynomial = geodesyLegendreCache.getLegendrePolynomial(\r\n degree - 2, order );\r\n\r\n // Compute polynomial.\r\n return computeGeodesyLegendrePolynomialVertical( degree,\r\n order,\r\n geodesyLegendreCache.getCurrentPolynomialParameter( ),\r\n oneDegreePriorPolynomial,\r\n twoDegreesPriorPolynomial );\r\n }\r\n}\r\n\r\ndouble computeGeodesyLegendrePolynomial( const int degree,\r\n const int order,\r\n const double legendreParameter )\r\n{\r\n LegendreCache legendreCache( degree, order, 1 );\r\n legendreCache.update( legendreParameter );\r\n return computeGeodesyLegendrePolynomial( degree, order, legendreCache );\r\n}\r\n\r\n//! Compute derivative of unnormalized Legendre polynomial.\r\ndouble computeLegendrePolynomialDerivative( const int order,\r\n const double polynomialParameter,\r\n const double currentLegendrePolynomial,\r\n const double incrementedLegendrePolynomial )\r\n{\r\n // Return polynomial derivative.\r\n return incrementedLegendrePolynomial\r\n / std::sqrt( 1.0 - polynomialParameter * polynomialParameter )\r\n - static_cast< double >( order ) * polynomialParameter\r\n / ( 1.0 - polynomialParameter * polynomialParameter )\r\n * currentLegendrePolynomial;\r\n}\r\n\r\n//! Compute derivative of geodesy-normalized Legendre polynomial.\r\ndouble computeGeodesyLegendrePolynomialDerivative( const int degree,\r\n const int order,\r\n const double polynomialParameter,\r\n const double currentLegendrePolynomial,\r\n const double incrementedLegendrePolynomial )\r\n{\r\n // Compute normalization correction factor.\r\n double normalizationCorrection = std::sqrt( ( static_cast< double >( degree )\r\n + static_cast< double >( order ) + 1.0 )\r\n * ( static_cast< double >( degree - order ) ) );\r\n\r\n // If order is zero apply multiplication factor.\r\n if ( order == 0 )\r\n {\r\n normalizationCorrection *= std::sqrt( 0.5 );\r\n }\r\n\r\n // Return polynomial derivative.\r\n return normalizationCorrection * incrementedLegendrePolynomial\r\n / std::sqrt( 1.0 - polynomialParameter * polynomialParameter )\r\n - static_cast< double >( order ) * polynomialParameter\r\n / ( 1.0 - polynomialParameter * polynomialParameter )\r\n * currentLegendrePolynomial;\r\n}\r\n\r\n//! Compute low degree/order unnormalized Legendre polynomial explicitly.\r\ndouble computeLegendrePolynomialExplicit( const int degree,\r\n const int order,\r\n const double polynomialParameter )\r\n{\r\n // Check which order is required for Legendre polynomial.\r\n switch( degree )\r\n {\r\n case 0:\r\n switch( order )\r\n {\r\n case 0:\r\n return 1.0;\r\n default:\r\n std::cerr << \"Error, explicit legendre polynomial not possible for \"\r\n << degree << \" \" << order << std::endl;\r\n }\r\n break;\r\n case 1:\r\n switch( order )\r\n {\r\n case 0:\r\n return polynomialParameter;\r\n case 1:\r\n return std::sqrt( 1 - polynomialParameter * polynomialParameter );\r\n default:\r\n std::cerr << \"Error, explicit legendre polynomial not possible for \"\r\n << degree << \" \" << order << std::endl;\r\n }\r\n break;\r\n case 2:\r\n switch( order )\r\n {\r\n case 0:\r\n return 0.5 * ( 3.0 * polynomialParameter * polynomialParameter - 1.0 );\r\n case 1:\r\n return 3.0 * polynomialParameter\r\n * std::sqrt( 1.0 - polynomialParameter * polynomialParameter );\r\n case 2:\r\n return 3.0 * ( 1.0 - polynomialParameter * polynomialParameter );\r\n default:\r\n std::cerr << \"Error, explicit legendre polynomial not possible for \"\r\n << degree << \" \" << order << std::endl;\r\n }\r\n break;\r\n case 3:\r\n switch( order )\r\n {\r\n case 0:\r\n return 0.5 * polynomialParameter\r\n * ( 5.0 * polynomialParameter * polynomialParameter - 3.0 );\r\n case 1:\r\n return 1.5 * ( 5.0 * polynomialParameter * polynomialParameter - 1.0 )\r\n * std::sqrt( 1.0 - polynomialParameter * polynomialParameter );\r\n case 2:\r\n return 15.0 * polynomialParameter * ( 1.0 - polynomialParameter * polynomialParameter );\r\n case 3:\r\n return 15.0 * ( 1.0 - polynomialParameter * polynomialParameter )\r\n * std::sqrt( 1.0 - polynomialParameter * polynomialParameter );\r\n default:\r\n std::cerr << \"Error, a explicit legendre polynomial not possible for \"\r\n << degree << \" \" << order << std::endl;\r\n }\r\n break;\r\n case 4:\r\n switch( order )\r\n {\r\n case 0:\r\n return ( 35.0 * polynomialParameter * polynomialParameter\r\n * polynomialParameter * polynomialParameter\r\n - 30.0 * polynomialParameter * polynomialParameter + 3.0 ) / 8.0;\r\n case 1:\r\n return -2.5 * ( 7.0 * polynomialParameter * polynomialParameter * polynomialParameter\r\n - 3.0 * polynomialParameter )\r\n * std::sqrt( 1.0 - polynomialParameter * polynomialParameter );\r\n case 2:\r\n return 15.0 / 2.0 * ( - 1.0 + 7.0 * polynomialParameter * polynomialParameter )\r\n * ( 1.0 - polynomialParameter * polynomialParameter );\r\n case 3:\r\n return -105.0 * polynomialParameter * ( 1.0 - polynomialParameter * polynomialParameter )\r\n * std::sqrt( 1.0 - polynomialParameter * polynomialParameter );\r\n case 4:\r\n return 105.0 * ( 1.0 - polynomialParameter * polynomialParameter )\r\n * ( 1.0 - polynomialParameter * polynomialParameter );\r\n\r\n default:\r\n std::cerr << \"Error, a explicit legendre polynomial not possible for \"\r\n << degree << \" \" << order << std::endl;\r\n }\r\n break;\r\n default:\r\n std::cerr << \"Error, explicit legendre polynomial not possible for \"\r\n << degree << \" \" << order << std::endl;\r\n }\r\n return TUDAT_NAN;\r\n}\r\n\r\n//! Compute low degree/order geodesy-normalized Legendre polynomials explicitly.\r\ndouble computeGeodesyLegendrePolynomialExplicit( const int degree,\r\n const int order,\r\n const double polynomialParameter )\r\n{\r\n // If 0,0 term is requested return Legendre polynomial value.\r\n if ( degree == 0 && order == 0 )\r\n {\r\n return 1.0;\r\n }\r\n\r\n // Else if 1,0 term is requested return polynomial value.\r\n else if ( degree == 1 && order == 0 )\r\n {\r\n return std::sqrt( 3.0 ) * polynomialParameter;\r\n }\r\n\r\n // Else if 1,1 term is requested return polynomial value.\r\n else if ( degree == 1 && order == 1 )\r\n {\r\n return std::sqrt( 3.0 - 3.0 * polynomialParameter * polynomialParameter );\r\n }\r\n\r\n // Else the requested term cannot be computed; throw a run-time error.\r\n else\r\n {\r\n // Set error message.\r\n std::stringstream errorMessage;\r\n errorMessage << \"Error: computation of Legendre polynomial of = \" << degree\r\n << \" and order = \" << order << \" is not supported.\" << std::endl;\r\n\r\n // Throw a run-time error.\r\n boost::throw_exception( boost::enable_error_info( std::runtime_error(\r\n errorMessage.str( ) ) ) );\r\n }\r\n}\r\n\r\n//! Compute unnormalized Legendre polynomial through sectoral recursion.\r\ndouble computeLegendrePolynomialDiagonal( const int degree,\r\n const double degreeOneOrderOnePolynomial,\r\n const double priorSectoralPolynomial )\r\n{\r\n // Return polynomial.\r\n return ( 2.0 * static_cast< double >( degree ) - 1.0 )\r\n * degreeOneOrderOnePolynomial * priorSectoralPolynomial;\r\n\r\n}\r\n\r\n//! Compute geodesy-normalized Legendre polynomial through sectoral recursion.\r\ndouble computeGeodesyLegendrePolynomialDiagonal( const int degree,\r\n const double degreeOneOrderOnePolynomial,\r\n const double priorSectoralPolynomial )\r\n{\r\n // Return polynomial.\r\n return std::sqrt( ( 2.0 * static_cast< double >( degree ) + 1.0 )\r\n / ( 6.0 * static_cast< double >( degree ) ) )\r\n * degreeOneOrderOnePolynomial * priorSectoralPolynomial;\r\n}\r\n\r\n//! Compute unnormalized Legendre polynomial through degree recursion.\r\ndouble computeLegendrePolynomialVertical( const int degree,\r\n const int order,\r\n const double polynomialParameter,\r\n const double oneDegreePriorPolynomial,\r\n const double twoDegreesPriorPolynomial )\r\n{\r\n // Return polynomial.\r\n return ( ( 2.0 * static_cast< double >( degree ) - 1.0 ) * polynomialParameter\r\n * oneDegreePriorPolynomial - ( static_cast< double >( degree + order ) - 1.0 )\r\n * twoDegreesPriorPolynomial ) / ( static_cast< double >( degree - order ) );\r\n}\r\n\r\n//! Compute geodesy-normalized Legendre polynomial through degree recursion.\r\ndouble computeGeodesyLegendrePolynomialVertical( const int degree,\r\n const int order,\r\n const double polynomialParameter,\r\n const double oneDegreePriorPolynomial,\r\n const double twoDegreesPriorPolynomial )\r\n{\r\n // Return polynomial.\r\n return std::sqrt( ( 2.0 * static_cast< double >( degree ) + 1.0 )\r\n / ( ( static_cast< double >( degree + order ) ) * ( static_cast< double >( degree - order ) ) ) )\r\n * ( std::sqrt( 2.0 * static_cast< double >( degree ) - 1.0 ) * polynomialParameter * oneDegreePriorPolynomial\r\n - std::sqrt( ( static_cast< double >( degree + order ) - 1.0 )\r\n * ( static_cast< double >( degree - order ) - 1.0 )\r\n / ( 2.0 * static_cast< double >( degree ) - 3.0 ) )\r\n * twoDegreesPriorPolynomial );\r\n}\r\n\r\n\r\n//! Function to calculate the normalization factor for Legendre polynomials to geodesy-normalized.\r\ndouble calculateLegendreGeodesyNormalizationFactor( const int degree, const int order )\r\n{\r\n\r\n double deltaFunction = 0.0;\r\n if( order == 0 )\r\n {\r\n deltaFunction = 1.0;\r\n }\r\n\r\n double factor = std::sqrt(\r\n boost::math::factorial< double >( static_cast< double >( degree + order ) )\r\n / ( ( 2.0 - deltaFunction ) * ( 2.0 * static_cast< double >( degree ) + 1.0 )\r\n * boost::math::factorial< double >( static_cast< double >( degree - order ) ) ) );\r\n return 1.0 / factor;\r\n}\r\n\r\n\r\n} // namespace basic_mathematics\r\n} // namespace tudat\r\n", "meta": {"hexsha": "237692aab7eba1bcff096c094e66eafce1e3fa37", "size": 22591, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Tudat/Mathematics/BasicMathematics/legendrePolynomials.cpp", "max_stars_repo_name": "JPelamatti/ThesisTUDAT", "max_stars_repo_head_hexsha": "b94ce35fb7c8fa44ae83238e296a979dfa3adfe8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Tudat/Mathematics/BasicMathematics/legendrePolynomials.cpp", "max_issues_repo_name": "JPelamatti/ThesisTUDAT", "max_issues_repo_head_hexsha": "b94ce35fb7c8fa44ae83238e296a979dfa3adfe8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Tudat/Mathematics/BasicMathematics/legendrePolynomials.cpp", "max_forks_repo_name": "JPelamatti/ThesisTUDAT", "max_forks_repo_head_hexsha": "b94ce35fb7c8fa44ae83238e296a979dfa3adfe8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-05-30T03:42:22.000Z", "max_forks_repo_forks_event_max_datetime": "2019-05-30T03:42:22.000Z", "avg_line_length": 41.0745454545, "max_line_length": 148, "alphanum_fraction": 0.5724403524, "num_tokens": 4591, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718435083355187, "lm_q2_score": 0.7090191337850932, "lm_q1q2_score": 0.5472518156976969}} {"text": "#include \"tasktorrent/tasktorrent.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\ntypedef array int2;\ntypedef array int3;\ntypedef array int4;\ntypedef array int5;\ntypedef array int6;\ntypedef array int7;\n\nstruct scoped_timer {\n private:\n std::atomic* time_us_;\n ttor::timer time_init_;\n public:\n scoped_timer(std::atomic* time_us) {\n time_us_ = time_us;\n time_init_= ttor::wctime();\n }\n ~scoped_timer() {\n ttor::timer time_end_ = ttor::wctime();\n *time_us_ += static_cast(1e6 * ttor::elapsed(time_init_, time_end_));\n }\n};\n\nttor::view make_view(Eigen::MatrixXd* A) {\n return ttor::view(A->data(), A->size());\n}\n\nEigen::MatrixXd make_from_view(ttor::view A, int nrows) {\n Eigen::MatrixXd Add = Eigen::MatrixXd::Zero(nrows, nrows);\n assert(nrows * nrows == A.size());\n memcpy(Add.data(), A.data(), sizeof(double) * A.size());\n return Add;\n}\n\nvoid copy_from_view(Eigen::MatrixXd* dest, const ttor::view A) {\n assert(dest->size() == A.size());\n memcpy(dest->data(), A.data(), sizeof(double) * A.size());\n}\n\nvoid accumulate(Eigen::MatrixXd* dest, const Eigen::MatrixXd* src) {\n assert(dest->size() == src->size());\n #pragma omp parallel for\n for(int k = 0; k < dest->size(); k++) {\n (*dest)(k) += (*src)(k);\n }\n}\n\nstd::string to_string(int2 ij) {\n return to_string(ij[0]) + \"_\" + to_string(ij[1]);\n}\n\nstd::string to_string(int3 ijk) {\n return to_string(ijk[0]) + \"_\" + to_string(ijk[1]) + \"_\" + to_string(ijk[2]);\n}\n\n/**\n * Matrix is of size N (global)\n * Each rank works on Nr x Nr\n * Each thread works on Nt x Nt\n * \n * There are n sub blocks on a given rank\n */\nvoid gemm(const int N, const int Nt, const int n_threads, std::string logfile, const int verb, const bool test)\n{\n const int rank = ttor::comm_rank();\n const int n_ranks = ttor::comm_size();\n const int n_ranks_1d = static_cast(round(pow(n_ranks, 1.0/3.0)));\n assert(n_ranks_1d * n_ranks_1d * n_ranks_1d == n_ranks);\n const int rank_i = rank % n_ranks_1d;\n const int rank_j = (rank / n_ranks_1d) % n_ranks_1d;\n const int rank_k = rank / (n_ranks_1d * n_ranks_1d);\n const int3 rank_ijk = {rank_i, rank_j, rank_k};\n const int Nr = N / n_ranks_1d;\n assert(Nr * n_ranks_1d == N);\n const int n = Nr / Nt;\n assert(Nt * n == Nr);\n printf(\"Hello rank %d with 3d-index (%d %d %d) / (%d %d %d) from host %s, N %d, Nr %d, Nt %d, n %d\\n\", rank, rank_i, rank_j, rank_k, n_ranks_1d, n_ranks_1d, n_ranks_1d, \n ttor::processor_name().c_str(), N, Nr, Nt, n);\n\n printf(\"rank,%d\\n\", rank);\n printf(\"rank_i,%d\\n\", rank_i);\n printf(\"rank_j,%d\\n\", rank_j);\n printf(\"rank_k,%d\\n\", rank_k);\n printf(\"ntot,%d\\n\", N);\n printf(\"nrank,%d\\n\", Nr);\n printf(\"ntile,%d\\n\", Nt);\n printf(\"nthreads,%d\\n\", n_threads);\n printf(\"logfile,%s\\n\", logfile.c_str());\n printf(\"verb,%d\\n\", verb);\n printf(\"test,%d\\n\", test);\n \n auto rank_ijk_to_rank = [n_ranks_1d](int rank_i, int rank_j, int rank_k) {\n return rank_k * n_ranks_1d * n_ranks_1d + rank_j * n_ranks_1d + rank_i;\n };\n assert(rank_ijk_to_rank(rank_i, rank_j, rank_k) == rank);\n\n /**\n * Record timings\n **/\n std::atomic send_copy_us_t(0);\n std::atomic send_am_us_t(0);\n std::atomic bcst_copy_us_t(0);\n std::atomic bcst_am_us_t(0);\n std::atomic gemm_us_t(0);\n std::atomic gemm_copy_us_t(0);\n std::atomic gemm_am_us_t(0);\n std::atomic accu_us_t(0);\n\n /**\n * Original and final matrices\n **/\n // n x n matrix of Nt x Nt matrices, so Nr x Nr total\n std::vector> A_ij(n, std::vector(n, Eigen::MatrixXd::Zero(Nt, Nt)));\n std::vector> C_ij(n, std::vector(n, Eigen::MatrixXd::Zero(Nt, Nt)));\n std::vector> B_ij(n, std::vector(n, Eigen::MatrixXd::Zero(Nt, Nt)));\n\n auto val_global = [](int i, int j) { return static_cast(1 + i + j); };\n if(rank_k == 0) {\n for(int i = 0; i < n; i++) {\n for(int j = 0; j < n; j++) {\n auto val = [&](int i_, int j_) { return val_global(rank_i * Nr + i * Nt + i_, rank_j * Nr + j * Nt + j_); };\n A_ij[i][j] = Eigen::MatrixXd::NullaryExpr(Nt, Nt, val);\n B_ij[i][j] = Eigen::MatrixXd::NullaryExpr(Nt, Nt, val);\n }\n }\n }\n\n /** \n * Workspace\n **/\n std::vector> A_ijk(n, std::vector(n, Eigen::MatrixXd::Zero(Nt, Nt)));\n std::vector> C_ijk(n, std::vector(n, Eigen::MatrixXd::Zero(Nt, Nt)));\n std::vector> B_ijk(n, std::vector(n, Eigen::MatrixXd::Zero(Nt, Nt)));\n std::vector>> C_ijk_counts(n * n);\n for(int i = 0; i < n*n; i++) {\n C_ijk_counts[i] = std::make_unique>();\n C_ijk_counts[i]->store(0);\n }\n \n // C_ijk_accu[sub_i][sub_j][from] stores the results for (sub_i, sub_j) to be accumulated, from rank from\n std::vector>> C_ijk_accu(\n n, std::vector>(\n n, std::vector(\n n_ranks_1d, Eigen::MatrixXd::Zero(Nt, Nt))));\n \n MPI_Barrier(MPI_COMM_WORLD);\n\n /**\n * Initialize the runtime structures\n **/\n ttor::Communicator comm(MPI_COMM_WORLD, verb);\n ttor::Threadpool tp(n_threads, &comm, verb, \"Wk_Gemm_\" + to_string(rank) + \"_\");\n\n // send is indexed by int2, which are the sub blocks\n ttor::Taskflow send_Aij(&tp, verb); // (i,j,0) sends A_ij to (i,j,j) for all i,j\n ttor::Taskflow send_Bij(&tp, verb); // (i,j,0) sends B_ij to (i,j,i) for all i,j\n // send is indexed by int2, which are the sub blocks\n ttor::Taskflow bcst_Aij(&tp, verb); // (i,j,j) sends A_ij along j to all (i,*,j) for all i,j\n ttor::Taskflow bcst_Bij(&tp, verb); // (i,j,i) sends B_ij along i to all (*,j,i) for all i,j\n // gemm is indexed by int3, which are the sub blocks\n ttor::Taskflow gemm_Cijk(&tp, verb); // (i,j,k) compute C_ijk = A_ik * B_kj, send for accumulation reduction on (i,j,0)\n ttor::Taskflow accu_Cij(&tp, verb); // accumulate (i,j,from) into (i,j)\n\n ttor::Logger log(1000000);\n if(logfile.size() > 0) {\n tp.set_logger(&log);\n comm.set_logger(&log);\n }\n\n /** \n * Send\n **/\n\n auto send_Aij_am = comm.make_active_msg([&](ttor::view& Aij, int& sub_i, int& sub_j) {\n scoped_timer t(&send_am_us_t);\n copy_from_view(&A_ijk[sub_i][sub_j], Aij);\n bcst_Aij.fulfill_promise({sub_i, sub_j});\n });\n\n auto send_Bij_am = comm.make_active_msg([&](ttor::view& Bij, int& sub_i, int& sub_j) {\n scoped_timer t(&send_am_us_t);\n copy_from_view(&B_ijk[sub_i][sub_j], Bij);\n bcst_Bij.fulfill_promise({sub_i, sub_j});\n });\n\n // (i,j,0) sends A_ij to (i,j,j) for all i,j\n send_Aij.set_task([&](int2 sub_ij){\n assert(rank_k == 0);\n scoped_timer t(&send_copy_us_t);\n int sub_i = sub_ij[0];\n int sub_j = sub_ij[1];\n ttor::view A_view = make_view(&A_ij[sub_i][sub_j]);\n int dest = rank_ijk_to_rank(rank_i, rank_j, rank_j);\n if(dest == rank) {\n A_ijk[sub_i][sub_j] = A_ij[sub_i][sub_j];\n bcst_Aij.fulfill_promise({sub_i, sub_j});\n } else {\n send_Aij_am->send(dest, A_view, sub_i, sub_j);\n }\n }).set_indegree([&](int2) {\n return 1;\n }).set_mapping([&](int2 sub_ij) {\n // return (sub_ij[0] + n * sub_ij[1]) % n_threads;\n // return 0;\n return sub_ij[0] % n_threads;\n }).set_priority([&](int2 sub_ij){\n return 1.0 * n + (n - sub_ij[1]);\n }).set_binding([&](int2 sub_ij){\n return false;\n // return true;\n }).set_name([&](int2 sub_ij) { return \"send_A_\" + to_string(sub_ij) + \"_\" + to_string(rank_ijk); });\n\n // (i,j,0) sends B_ij to (i,j,i) for all i,j\n send_Bij.set_task([&](int2 sub_ij){\n assert(rank_k == 0);\n scoped_timer t(&send_copy_us_t);\n int sub_i = sub_ij[0];\n int sub_j = sub_ij[1];\n ttor::view B_view = make_view(&B_ij[sub_i][sub_j]);\n int dest = rank_ijk_to_rank(rank_i, rank_j, rank_i);\n if(dest == rank) {\n B_ijk[sub_i][sub_j] = B_ij[sub_i][sub_j];\n bcst_Bij.fulfill_promise({sub_i, sub_j});\n } else {\n send_Bij_am->send(dest, B_view, sub_i, sub_j);\n }\n }).set_indegree([&](int2) {\n return 1;\n }).set_mapping([&](int2 sub_ij) {\n // return (sub_ij[0] + n * sub_ij[1]) % n_threads;\n // return 0;\n return (sub_ij[1] % n_threads);\n }).set_priority([&](int2 sub_ij){\n return 1.0 * n + (n - sub_ij[0]);\n }).set_binding([&](int2 sub_ij){\n return false;\n //return true;\n }).set_name([&](int2 sub_ij) { return \"send_B_\" + to_string(sub_ij) + \"_\" + to_string(rank_ijk); });\n\n /** \n * Broadcast\n **/\n\n auto bcst_Aij_am = comm.make_active_msg([&](ttor::view& Aij, int &sub_i, int &sub_j) {\n scoped_timer t(&bcst_am_us_t);\n copy_from_view(&A_ijk[sub_i][sub_j], Aij);\n for(int k = 0; k < n; k++)\n gemm_Cijk.fulfill_promise({sub_i, k, sub_j});\n });\n\n auto bcst_Bij_am = comm.make_active_msg([&](ttor::view& Bij, int &sub_i, int &sub_j) {\n scoped_timer t(&bcst_am_us_t);\n copy_from_view(&B_ijk[sub_i][sub_j], Bij);\n for(int k = 0; k < n; k++)\n gemm_Cijk.fulfill_promise({k, sub_j, sub_i});\n });\n\n // (i,j,j) sends A_ij along j to all (i,*,j) for all i,j\n bcst_Aij.set_task([&](int2 sub_ij){\n scoped_timer t(&bcst_copy_us_t);\n assert(rank_j == rank_k);\n int sub_i = sub_ij[0];\n int sub_j = sub_ij[1];\n ttor::view A_view = make_view(&A_ijk[sub_i][sub_j]);\n for(int k = 0; k < n_ranks_1d; k++) {\n int dest = rank_ijk_to_rank(rank_i, k, rank_j);\n if(dest == rank) {\n for(int l = 0; l < n; l++)\n gemm_Cijk.fulfill_promise({sub_i, l, sub_j});\n } else {\n bcst_Aij_am->send(dest, A_view, sub_i, sub_j);\n }\n }\n }).set_indegree([&](int2) {\n return 1;\n }).set_mapping([&](int2 sub_ij) {\n // return (sub_ij[0] + n * sub_ij[1]) % n_threads;\n // return 0;\n return (sub_ij[0] % n_threads);\n }).set_priority([&](int2 sub_ij){\n return 1.0 * n + (n - sub_ij[1]);\n }).set_binding([&](int2 sub_ij){\n return false;\n //return true;\n }).set_name([&](int2 sub_ij) { return \"bcast_A_\" + to_string(sub_ij) + \"_\" + to_string(rank_ijk); });\n\n // (i,j,i) sends B_ij along i to all (*,j,i) for all i,j\n bcst_Bij.set_task([&](int2 sub_ij){\n scoped_timer t(&bcst_copy_us_t);\n assert(rank_i == rank_k);\n int sub_i = sub_ij[0];\n int sub_j = sub_ij[1];\n ttor::view B_view = make_view(&B_ijk[sub_i][sub_j]);\n for(int k = 0; k < n_ranks_1d; k++) {\n int dest = rank_ijk_to_rank(k, rank_j, rank_i);\n if(dest == rank) {\n for(int l = 0; l < n; l++)\n gemm_Cijk.fulfill_promise({l, sub_j, sub_i});\n } else {\n bcst_Bij_am->send(dest, B_view, sub_i, sub_j);\n }\n }\n }).set_indegree([&](int2) {\n return 1;\n }).set_mapping([&](int2 sub_ij) {\n // return (sub_ij[0] + n * sub_ij[1]) % n_threads;\n // return 0;\n return (sub_ij[1] % n_threads);\n }).set_priority([&](int2 sub_ij){\n return 1.0 * n + (n - sub_ij[0]);\n }).set_binding([&](int2 sub_ij){\n return false;\n // return true;\n }).set_name([&](int2 sub_ij) { return \"bcast_B_\" + to_string(sub_ij) + \"_\" + to_string(rank_ijk); });\n\n /** \n * GEMM\n **/\n\n auto gemm_Cijk_am = comm.make_active_msg([&](ttor::view& Cijk, int &sub_i, int &sub_j, int& from) {\n scoped_timer t(&gemm_am_us_t);\n copy_from_view(&C_ijk_accu[sub_i][sub_j][from], Cijk);\n accu_Cij.fulfill_promise({sub_i, sub_j, from});\n });\n\n // (i,j,k) compute C_ijk = A_ik * B_kj\n gemm_Cijk.set_task([&](int3 sub_ijk){\n int sub_i = sub_ijk[0];\n int sub_j = sub_ijk[1];\n int sub_k = sub_ijk[2];\n {\n scoped_timer t(&gemm_us_t);\n C_ijk[sub_i][sub_j].noalias() += A_ijk[sub_i][sub_k] * B_ijk[sub_k][sub_j];\n }\n //(*(C_ijk_counts[sub_i * n + sub_j]))++;\n scoped_timer t(&gemm_copy_us_t);\n if(sub_ijk[2] < n-1) {\n gemm_Cijk.fulfill_promise({sub_i, sub_j, sub_k+1});\n } else {\n //if(C_ijk_counts[sub_i * n + sub_j]->load() == n) {\n auto C_ijk_view = make_view(&C_ijk[sub_i][sub_j]);\n int dest = rank_ijk_to_rank(rank_i, rank_j, 0);\n if(dest == rank) {\n C_ijk_accu[sub_i][sub_j][rank_k] = C_ijk[sub_i][sub_j];\n accu_Cij.fulfill_promise({sub_i, sub_j, rank_k});\n } else {\n int k = rank_k;\n gemm_Cijk_am->send(dest, C_ijk_view, sub_i, sub_j, k);\n }\n }\n }).set_indegree([&](int3 sub_ijk) {\n return sub_ijk[2] == 0 ? 2 : 3; // 2 A_ik and B_kj blocks, + previous gemm\n // return 2;\n }).set_mapping([&](int3 sub_ijk) {\n if(n_threads == 1) return 0;\n // else return max(1, (sub_ijk[0] + sub_ijk[1] * n) % n_threads);\n else return max(1, (sub_ijk[0] + sub_ijk[1] * n) % n_threads); // + sub_ijk[2] * n * n) % n_threads);\n // return (sub_ijk[0] + sub_ijk[1] * n + sub_ijk[2] * n * n) % n_threads;\n }).set_binding([&](int3 sub_ijk) {\n return false;\n }).set_priority([&](int3 sub_ijk){\n return 0.0 * n + (n - sub_ijk[2]);\n }).set_name([&](int3 sub_ijk) { return \"gemm_C_\" + to_string(sub_ijk) + \"_\" + to_string(rank_ijk); });\n\n // (i,j,k) compute C_ijk = A_ik * B_kj\n accu_Cij.set_task([&](int3 sub_ij_from){\n scoped_timer t(&accu_us_t);\n int sub_i = sub_ij_from[0];\n int sub_j = sub_ij_from[1];\n int from = sub_ij_from[2];\n C_ij[sub_i][sub_j] += C_ijk_accu[sub_i][sub_j][from];\n }).set_indegree([&](int3) {\n return 1;\n }).set_mapping([&](int3 sub_ij_from) {\n if(n_threads == 1) return 0;\n else return max(1, (sub_ij_from[0] + n * sub_ij_from[1]) % n_threads);\n // return (sub_ij_from[0] + n * sub_ij_from[1]) % n_threads;\n }).set_binding([&](int3) {\n return true;\n }).set_priority([&](int3){\n return 0.0;\n }).set_name([&](int3 sub_ij_from) { return \"accu_C_\" + to_string(sub_ij_from) + \"_\" + to_string(rank_ijk); });\n\n printf(\"Starting 3D Gemm...\\n\");\n ttor::timer t0 = ttor::wctime();\n if(rank_k == 0) {\n for(int i = 0; i < n; i++) {\n for(int j = 0; j < n; j++) {\n send_Aij.fulfill_promise({i,j});\n send_Bij.fulfill_promise({i,j});\n }\n }\n }\n tp.join();\n ttor::timer t1 = ttor::wctime();\n double total_time = ttor::elapsed(t0, t1);\n double gemm_time = gemm_us_t.load() * 1e-6;\n double gemm_time_per_thread = gemm_time / n_threads;\n printf(\"Done\\n\");\n printf(\"total_time,%e\\n\", ttor::elapsed(t0, t1));\n printf(\"send_copy_us_t,%e\\n\",send_copy_us_t.load() * 1e-6);\n printf(\"send_am_us_t,%e\\n\",send_am_us_t.load() * 1e-6);\n printf(\"bcst_copy_us_t,%e\\n\",bcst_copy_us_t.load() * 1e-6);\n printf(\"bcst_am_us_t,%e\\n\",bcst_am_us_t.load() * 1e-6);\n printf(\"gemm_us_t,%e\\n\",gemm_us_t.load() * 1e-6);\n printf(\"gemm_copy_us_t,%e\\n\",gemm_copy_us_t.load() * 1e-6);\n printf(\"gemm_am_us_t,%e\\n\",gemm_am_us_t.load() * 1e-6);\n printf(\"accu_us_t,%e\\n\",accu_us_t.load() * 1e-6);\n // For easy CSV parsing\n printf(\"[rank]>>>>Ntot,Nrank,Ntile,rank,n_ranks,nthreads,tot_time,gemm_time,gemm_time_per_thread\\n\");\n printf(\"[%d]>>>>%d,%d,%d,%d,%d,%d,%e,%e,%e\\n\",rank,N,Nr,Nt,rank,n_ranks,n_threads,total_time,gemm_time,gemm_time_per_thread);\n\n if(logfile.size() > 0) {\n std::ofstream logstream;\n std::string filename = logfile + \".log.\" + to_string(rank);\n printf(\"Saving log to %s\\n\", filename.c_str());\n logstream.open(filename);\n logstream << log;\n logstream.close();\n }\n\n MPI_Barrier(MPI_COMM_WORLD);\n if(test && rank_k == 0) {\n // Send all to 0\n int n_received = 0;\n int n_expected = (rank == 0 ? n * n * n_ranks_1d * n_ranks_1d : 0);\n Eigen::MatrixXd C_test = Eigen::MatrixXd::Zero(N, N);\n ttor::Communicator comm(MPI_COMM_WORLD, verb);\n auto am = comm.make_active_msg([&](ttor::view& A, int& rank_i_from, int& rank_j_from, int& sub_i, int& sub_j){\n C_test.block(rank_i_from * Nr + sub_i * Nt, rank_j_from * Nr + sub_j * Nt, Nt, Nt) = make_from_view(A, Nt);\n n_received++;\n });\n int rank_i_from = rank_i;\n int rank_j_from = rank_j;\n for(int sub_i = 0; sub_i < n; sub_i++) {\n for(int sub_j = 0; sub_j < n; sub_j++) {\n auto C_view = make_view(&C_ij[sub_i][sub_j]);\n am->send(0, C_view, rank_i_from, rank_j_from, sub_i, sub_j);\n }\n }\n while((!comm.is_done()) || (n_received < n_expected)) {\n comm.progress();\n }\n // Compute reference on 0\n if(rank == 0) {\n Eigen::MatrixXd A_ref = Eigen::MatrixXd::NullaryExpr(N, N, val_global);\n Eigen::MatrixXd B_ref = Eigen::MatrixXd::NullaryExpr(N, N, val_global);\n ttor::timer t0 = ttor::wctime();\n Eigen::MatrixXd C_ref = A_ref * B_ref;\n ttor::timer t1 = ttor::wctime();\n double error = (C_ref - C_test).norm() / C_ref.norm();\n printf(\"\\n==> GEMM error %e\\n\\n\", error);\n printf(\"Reference code took %e\\n\", ttor::elapsed(t0, t1));\n assert(error <= 1e-12);\n }\n }\n}\n\nint main(int argc, char **argv)\n{\n int req = MPI_THREAD_FUNNELED;\n int prov = -1;\n\n MPI_Init_thread(NULL, NULL, req, &prov);\n\n assert(prov == req);\n\n int N = 128;\n int Nt = 8;\n int n_threads = 1;\n int verb = 0;\n bool test = true;\n std::string logfile = \"\";\n\n if (argc >= 2)\n {\n N = atoi(argv[1]);\n assert(N > 0);\n }\n \n if (argc >= 3) {\n Nt = atoi(argv[2]);\n assert(Nt > 0);\n assert(Nt <= N);\n }\n\n if (argc >= 4) {\n n_threads = atoi(argv[3]);\n assert(n_threads > 0);\n }\n\n if (argc >= 5) {\n logfile = argv[4];\n }\n\n if (argc >= 6) {\n verb = atoi(argv[5]);\n assert(verb >= 0);\n }\n\n if (argc >= 7) {\n test = static_cast(atoi(argv[6]));\n }\n\n if(ttor::comm_rank() == 0) printf(\"Usage: ./3d_gemm N Nt n_threads logfile verb test\\n\");\n if(ttor::comm_rank() == 0) printf(\"Arguments: N (global matrix size) %d, Nt (smallest block size) %d, n_threads %d, logfile %s, verb %d, test %d\\n\", N, Nt, n_threads, logfile.c_str(), verb, test);\n\n gemm(N, Nt, n_threads, logfile, verb, test);\n\n MPI_Finalize();\n}\n", "meta": {"hexsha": "2c20bb095636d736bae432b0ccbc6a2c38948371", "size": 19673, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "miniapp/3d_gemm/3d_gemm.cpp", "max_stars_repo_name": "RCambier/tasktorrent", "max_stars_repo_head_hexsha": "1432e30517d5cb7cbeca0ceb1a3f3f426e5bfcfd", "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": "miniapp/3d_gemm/3d_gemm.cpp", "max_issues_repo_name": "RCambier/tasktorrent", "max_issues_repo_head_hexsha": "1432e30517d5cb7cbeca0ceb1a3f3f426e5bfcfd", "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": "miniapp/3d_gemm/3d_gemm.cpp", "max_forks_repo_name": "RCambier/tasktorrent", "max_forks_repo_head_hexsha": "1432e30517d5cb7cbeca0ceb1a3f3f426e5bfcfd", "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": 37.5438931298, "max_line_length": 200, "alphanum_fraction": 0.566512479, "num_tokens": 6278, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434978390746, "lm_q2_score": 0.7090191399336402, "lm_q1q2_score": 0.5472518130012332}} {"text": "///////////////////////////////////////////////////////////////////////////////\n// importance_sampling::find_scale_to_finite_sum.hpp //\n// //\n// Copyright 2009 Erwann Rogard. Distributed under the Boost //\n// Software License, Version 1.0. (See accompanying file //\n// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //\n///////////////////////////////////////////////////////////////////////////////\n#ifndef BOOST_STATISTICS_DETAIL_IMPORTANCE_SAMPLING_WEIGHTS_FIND_SCALE_TO_FINITE_SUM_HPP_ER_2009\n#define BOOST_STATISTICS_DETAIL_IMPORTANCE_SAMPLING_WEIGHTS_FIND_SCALE_TO_FINITE_SUM_HPP_ER_2009\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost{\nnamespace statistics{\nnamespace detail{\nnamespace importance_sampling{\n\n // Finds c such that the sum over sum{*i/c, i in [b,e)} < inf using the\n // bisection method.\n //\n // Warning: The value c is not insensitive to permutations of [b,e), due\n // to non-associativity in the fp system\n template\n typename iterator_value::type \n find_scale_to_finite_sum(\n InIt b,InIt e,\n typename iterator_value::type low_init,\n typename iterator_value::type high_init\n );\n \n // This version may be faster than that above with low = 1, high = highest\n template\n typename iterator_value::type \n find_scale_to_finite_sum(InIt b,InIt e);\n\n // Implementation //\n\n template\n typename iterator_value::type \n find_scale_to_finite_sum(\n InIt b,InIt e,\n typename iterator_value::type low_init,\n typename iterator_value::type high_init\n ){\n typedef typename iterator_value::type val_;\n static val_ zero = static_cast(0);\n static val_ two = static_cast(2);\n static val_ eps = boost::math::tools::epsilon();\n\n BOOST_ASSERT(low_init < high_init);\n BOOST_ASSERT(low_init > zero);\n BOOST_ASSERT(high_init > zero);\n val_ low = low_init;\n val_ high = high_init;\n val_ mid = (low + high)/two;\n val_ delta, acc;\n \n do{\n delta = high - low;\n acc =\n std::accumulate(b,e,zero, lambda::_1 + ( lambda::_2 / mid) );\n if(boost::math::isinf(acc)){\n low = mid;\n }else{\n high = mid;\n }\n mid = (low+high)/two;\n }while(\n delta - (high - low)>eps\n );\n static \n const char* str = \"%3% = find_scale_to_finite_sum(b,e,%1%,%2%) = inf\";\n if(\n boost::math::isinf(\n std::accumulate(b,e,zero, lambda::_1 + ( lambda::_2 / high) )\n )\n ){\n format f(str); f%low_init%high_init%high;\n throw std::runtime_error(f.str());\n }\n return high;\n }\n\n template\n typename iterator_value::type \n find_scale_to_finite_sum(InIt b,InIt e){\n typedef typename iterator_value::type val_;\n typedef numeric::bounds bounds_;\n typedef std::vector vec_;\n static val_ zero = static_cast(0);\n static val_ one = static_cast(1);\n static val_ two = static_cast(2);\n static val_ highest = bounds_::highest();\n vec_ vec;\n maximal_finite_sums(b,e,std::back_inserter(vec));\n val_ low = one;\n val_ high = highest;\n val_ mid = find_scale_to_finite_sum(\n boost::begin(vec),\n boost::end(vec),\n low,high\n );\n low = mid;\n high = mid;\n while( \n !boost::math::isinf(\n std::accumulate(b,e,zero, lambda::_1 + ( lambda::_2 / low) )\n )\n ){\n low /= two;\n if(low\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace stan {\n namespace math {\n\n /**\n * Return a pseudorandom Beta variate with the supplied success and failure\n * parameters and specified random number generator.\n *\n * @tparam RNG class of random number generator\n * @param alpha positive finite success parameter\n * @param beta positive finite failure parameter\n * @param rng random number generator\n * @return Beta random variate\n * @throw std::domain_error if alpha or beta is nonpositive\n */\n template \n inline double\n beta_rng(double alpha,\n double beta,\n RNG& rng) {\n using boost::variate_generator;\n using boost::random::gamma_distribution;\n using boost::random::uniform_real_distribution;\n using std::log;\n using std::exp;\n static const char* function(\"beta_rng\");\n check_positive_finite(function, \"First shape parameter\", alpha);\n check_positive_finite(function, \"Second shape parameter\", beta);\n\n // If alpha and beta are large, trust the usual ratio of gammas\n // method for generating beta random variables. If any parameter\n // is small, work in log space and use Marsaglia and Tsang's trick\n if (alpha > 1.0 && beta > 1.0) {\n variate_generator >\n rng_gamma_alpha(rng, gamma_distribution<>(alpha, 1.0));\n variate_generator >\n rng_gamma_beta(rng, gamma_distribution<>(beta, 1.0));\n double a = rng_gamma_alpha();\n double b = rng_gamma_beta();\n return a / (a + b);\n } else {\n variate_generator >\n uniform_rng(rng, uniform_real_distribution<>(0.0, 1.0));\n variate_generator >\n rng_gamma_alpha(rng, gamma_distribution<>(alpha + 1, 1.0));\n variate_generator >\n rng_gamma_beta(rng, gamma_distribution<>(beta + 1, 1.0));\n double log_a = log(uniform_rng()) / alpha + log(rng_gamma_alpha());\n double log_b = log(uniform_rng()) / beta + log(rng_gamma_beta());\n double log_sum = log_sum_exp(log_a, log_b);\n return exp(log_a - log_sum);\n }\n }\n\n }\n}\n#endif\n", "meta": {"hexsha": "c37df527b21aee90b6a8c3e888953c42132406d1", "size": 3373, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "cmdstan/stan/lib/stan_math/stan/math/prim/scal/prob/beta_rng.hpp", "max_stars_repo_name": "yizhang-cae/torsten", "max_stars_repo_head_hexsha": "dc82080ca032325040844cbabe81c9a2b5e046f9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cmdstan/stan/lib/stan_math/stan/math/prim/scal/prob/beta_rng.hpp", "max_issues_repo_name": "yizhang-cae/torsten", "max_issues_repo_head_hexsha": "dc82080ca032325040844cbabe81c9a2b5e046f9", "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": "cmdstan/stan/lib/stan_math/stan/math/prim/scal/prob/beta_rng.hpp", "max_forks_repo_name": "yizhang-cae/torsten", "max_forks_repo_head_hexsha": "dc82080ca032325040844cbabe81c9a2b5e046f9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.6419753086, "max_line_length": 79, "alphanum_fraction": 0.7008597688, "num_tokens": 825, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430645886584, "lm_q2_score": 0.658417500561683, "lm_q1q2_score": 0.5472391391956419}} {"text": "/* Sirikata\n * ExpIntegral.cpp\n *\n * Copyright (c) 2010, Daniel Reiter Horn\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in\n * the documentation and/or other materials provided with the\n * distribution.\n * * Neither the name of Sirikata nor the names of its contributors may\n * be used to endorse or promote products derived from this software\n * without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS\n * IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\n * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER\n * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\n * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n#include \n#include \"ExpIntegral.hpp\"\n\n#ifndef SIRIKATA_BAD_BOOST_ERF\n#include \n#endif\n\n#include \n#include \n\nstatic double square(double x) {\n return x*x;\n}\n\nstatic double expFunction(double k,double x, double y, double u, double v) {\n return exp(-k*(square(x-u)+square(y-v)));\n}\nstatic double myerf(double value) {\n#ifndef SIRIKATA_BAD_BOOST_ERF\n return boost::math::erf(value);\n#else\n return 0;\n#endif\n}\nstatic double integralExpFunction(double k, double xmin, double xmax, double ymin, double ymax, double umin, double umax, double vmin, double vmax) {\n double e=2.7182818284590451;\n double j=xmin;\n double l=xmax;\n double m=ymin;\n double n=ymax;\n double p=umin;\n double q=umax;\n double r=vmin;\n double s=vmax;\n double pi=3.1415926535897931;\n double sqrtloge=1;\n double loge=1;\n return (1./(4*k*log(e)))\n *pi*( ( j - p)*myerf(sqrt(k)*(j - p)*sqrtloge)\n + (-l + p)*myerf(sqrt(k)*(l - p)*sqrtloge)\n + (-j + q)*myerf(sqrt(k)*(j - q)*sqrtloge)\n + ( l - q)*myerf(sqrt(k)*(l - q)*sqrtloge)\n + (exp(-k*square(j - p))\n - exp(-k*square(j - q)))/(sqrt(k)*sqrt(pi)*sqrtloge) +\n (-exp(-k*square(l - p)) + exp(-k*square(l - q)))/(sqrt(k)*sqrt(pi)*sqrtloge))\n *( ( m - r)*myerf(sqrt(k)*(m - r)*sqrtloge)\n + (-n + r)*myerf(sqrt(k)*(n - r)*sqrtloge)\n + (-m + s)*myerf(sqrt(k)*(m - s)*sqrtloge)\n + ( n - s)*myerf(sqrt(k)*(n - s)*sqrtloge)\n + (exp(-k*square(m - r)) - exp(-k*square(m - s)))/(sqrt(k)*sqrt(pi)*sqrtloge)\n + (-exp(-k*square(n - r)) + exp(-k*square(n - s)))/(sqrt(k)*sqrt(pi)*sqrtloge));\n}\nnamespace Sirikata {\ndouble integralExpFunction(double k, const Vector3d& xymin, const Vector3d& xymax, const Vector3d& uvmin, const Vector3d& uvmax){\n return ::integralExpFunction(k,xymin.x,xymax.x,xymin.y,xymax.y,uvmin.x,uvmax.x,uvmin.y,uvmax.y);\n}\n}\nint maino (int argc, char**argv) {\n float k=atof(argv[1]);\n\n float xmin=-1;\n float xmax= 1;\n float ymin=-1;\n float ymax= 1;\n float arg=atof(argv[2]);\n float umin=-arg;\n float umax= arg;\n float vmin=-arg;\n float vmax= arg;\n\n std::cout << \" Function evaluated at hundred: \"<<\n expFunction(1,100,100,100,100)<<\n \" Integration of function over a lot \"<\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost { namespace simd\n{\n namespace detail\n {\n namespace bd = boost::dispatch;\n namespace bs = boost::simd;\n\n template < class A0 >\n struct invtrig_base\n {\n static BOOST_FORCEINLINE A0 asin(A0 const& a0)\n {\n A0 sgn, x;\n x = bs::abs(a0);\n sgn = bs::bitofsign(a0);\n const auto x_larger_05 = x > bs::Half();\n A0 z = if_else(x_larger_05, bs::Half()*bs::oneminus(x), bs::sqr(x));\n x = if_else(x_larger_05, sqrt(z), x);\n // Remez polynomial of degree 4 for (asin(rx)-rx)/(rx*rx*rx) in [0, 0.25]\n // 2120752146 values (99.53%) within 0.0 ULPs\n // 9954286 values (0.47%) within 0.5 ULPs\n // 4.0 cycles/element SSE4.2 g++-4.8\n A0 z1 = horn (z);\n z1 = bs::fma(z1, z*x, x);\n z = if_else(x_larger_05, bs::Pio_2()-(z1+z1), z1);\n return bs::bitwise_xor(z, sgn);\n }\n\n static BOOST_FORCEINLINE A0 acos(const A0& a0)\n {\n // 2130706432 values computed.\n // 1968272987 values (92.38%) within 0.0 ULPs\n // 162433445 values (7.62%) within 0.5 ULPs\n // 8.5 cycles/element SSE4.2 g++-4.8\n A0 x = bs::abs(a0);\n auto x_larger_05 = is_greater(x, bs::Half());\n x = if_else(x_larger_05, bs::sqrt(fma(bs::Mhalf(), x, bs::Half())), a0);\n x = asin(x);\n x = if_plus(x_larger_05, x, x);\n x = bs::if_else(a0 < bs::Mhalf(), bs::Pi()-x, x);\n return bs::if_else(x_larger_05, x, bs::Pio_2()-x);\n }\n\n static BOOST_FORCEINLINE A0 atan(const A0& a0)\n {\n A0 absa0 = bs::abs(a0);\n const A0 x = kernel_atan(absa0, bs::rec(absa0));\n return bs::bitwise_xor(x, bs::bitofsign(a0));\n }\n\n static BOOST_FORCEINLINE A0 acot(const A0& a0)\n {\n A0 absa0 = bs::abs(a0);\n const A0 x = kernel_atan(bs::rec(absa0), absa0);\n return bs::bitwise_xor(x, bs::bitofsign(a0));\n }\n\n static BOOST_FORCEINLINE A0 kernel_atan(const A0& x, const A0& recx)\n {\n //4278190076 values computed in range: [-3.40282e+38, 3.40282e+38]\n //4257598358 values (99.52%) within 0.0 ULPs\n // 20591718 values (0.48%) within 0.5 ULPs\n\n //here x is positive\n const auto flag1 = x < Tan_3pio_8();\n const auto flag2 = bs::logical_and(x >= Constant(), flag1);\n A0 yy = bs::if_zero_else(flag1, Pio_2());\n yy = bs::if_else(flag2, Pio_4(), yy);\n A0 xx = bs::if_else(flag1, x, -recx);\n xx = bs::if_else(flag2, (bs::dec(x)/bs::inc(x)),xx);\n const A0 z = bs::sqr(xx);\n A0 z1 = horn (z);\n z1 = bs::fma(xx, bs::multiplies( z1, z), xx);\n z1 = if_plus(flag2, z1, Pio_4lo());\n z1 = ifnot_plus(flag1, z1, Pio_2lo());\n return yy+z1;\n }\n };\n}\n} }\n#endif\n", "meta": {"hexsha": "8eed1b1439bc8378a291ceaf6b0492c2d9b0bec6", "size": 4958, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "third_party/boost/simd/arch/common/detail/simd/f_invtrig.hpp", "max_stars_repo_name": "SylvainCorlay/pythran", "max_stars_repo_head_hexsha": "908ec070d837baf77d828d01c3e35e2f4bfa2bfa", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2018-02-25T22:23:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-15T15:13:12.000Z", "max_issues_repo_path": "third_party/boost/simd/arch/common/detail/simd/f_invtrig.hpp", "max_issues_repo_name": "SylvainCorlay/pythran", "max_issues_repo_head_hexsha": "908ec070d837baf77d828d01c3e35e2f4bfa2bfa", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "third_party/boost/simd/arch/common/detail/simd/f_invtrig.hpp", "max_forks_repo_name": "SylvainCorlay/pythran", "max_forks_repo_head_hexsha": "908ec070d837baf77d828d01c3e35e2f4bfa2bfa", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2017-12-12T12:36:31.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-10T14:27:07.000Z", "avg_line_length": 35.6690647482, "max_line_length": 100, "alphanum_fraction": 0.6151674062, "num_tokens": 1669, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.879146761176671, "lm_q2_score": 0.6224593452091672, "lm_q1q2_score": 0.5472331173047907}} {"text": "#include \"vtkReferenceFrameFilter.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nvtkStandardNewMacro(vtkReferenceFrameFilter);\n\n// Creates a 2x2 matrix from 2 column vectors\nstatic Eigen::Matrix2d make_Matrix2d(const Eigen::Vector2d& c0, const Eigen::Vector2d& c1)\n{\n\tEigen::Matrix2d M;\n\tM << c0.x(), c1.x(), c0.y(), c1.y();\n\treturn M;\n}\n\n// Create a 2x2 matrix from row-wise components\nstatic Eigen::Matrix2d make_Matrix2d(const double& m00, const double& m01, const double& m10, const double& m11)\n{\n\tEigen::Matrix2d M;\n\tM << m00, m01, m10, m11;\n\treturn M;\n}\n\n// Returns value of Binomial Coefficient C(n, k) \nstatic int binomialCoeff(int n, int k)\n{\n\tint res = 1;\n\tif (k > n - k)\n\t\tk = n - k;\n\tfor (int i = 0; i < k; ++i) {\n\t\tres *= (n - i);\n\t\tres /= (i + 1);\n\t}\n\treturn res;\n}\n\nstatic int factorial(int n)\n{\n\tint ret = 1;\n\tfor (int i = 1; i <= n; ++i)\n\t\tret *= i;\n\treturn ret;\n}\n\nstatic void ComputeDisplacementSystemMatrixCoefficients(int i, int j, const Eigen::Vector2d& xx, const Eigen::Vector2d& vv, const Eigen::Matrix2d& J, Eigen::Matrix2d& f, Eigen::Matrix2d& g)\n{\n\tf = make_Matrix2d(0, 0, 0, 0), g = make_Matrix2d(0, 0, 0, 0);\n\tEigen::Matrix2d I = make_Matrix2d(1, 0, 0, 1);\n\tdouble x = xx.x(), y = xx.y(), u = vv.x(), v = vv.y();\n\n\tdouble x_i = pow(x, i), x_i1 = pow(x, i - 1);\n\tdouble y_j = pow(y, j), y_j1 = pow(y, j - 1);\n\n\tint fac_i = factorial(i), fac_i1 = factorial(i - 1);\n\tint fac_j = factorial(j), fac_j1 = factorial(j - 1);\n\n\tf -= x_i * y_j / (fac_i * fac_j) * J;\n\tif (i != 0)\n\t\tf += u * x_i1*y_j / (fac_i1 * fac_j) * I;\n\tif (j != 0)\n\t\tf += v * x_i*y_j1 / (fac_i * fac_j1) * I;\n\n\tg = x_i * y_j / (fac_i * fac_j) * I;\n}\n\nvtkReferenceFrameFilter::vtkReferenceFrameFilter() : NeighborhoodU(10), Invariance(AffineInvariance), UseSummedAreaTables(true), TaylorOrder(2),\nFieldNameV(NULL), FieldNameVx(NULL), FieldNameVy(NULL), FieldNameVt(NULL)\n{\n\tSetFieldNameV(\"v\");\n\tSetFieldNameVx(\"vx\");\n\tSetFieldNameVy(\"vy\");\n\tSetFieldNameVt(\"vt\");\n}\n\nint vtkReferenceFrameFilter::RequestData(vtkInformation *vtkNotUsed(request),\n\tvtkInformationVector **inputVector,\n\tvtkInformationVector *outputVector)\n{\n\tusing namespace Eigen;\n\n\t// Get the info objects\n\tvtkInformation *inInfo = inputVector[0]->GetInformationObject(0);\n\tvtkInformation *outInfo = outputVector->GetInformationObject(0);\n\n\t// Get the input and ouptut\n\tvtkImageData *input = vtkImageData::SafeDownCast(inInfo->Get(vtkDataObject::DATA_OBJECT()));\n\tvtkImageData *output = vtkImageData::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT()));\n\n\t// Get the information on the domain\n\tint* dims = input->GetDimensions();\n\tdouble* spacing = input->GetSpacing();\n\tdouble* boundsMin = input->GetOrigin();\n\n\t// select the system matrix size depending on the chosen invariance\n\tint systemSize = 6;\n\tswitch (Invariance) {\n\tdefault:\n\tcase Objectivity:\t\t\tsystemSize = 6;\t\tbreak;\n\tcase SimilarityInvariance:\tsystemSize = 8;\t\tbreak;\n\tcase AffineInvariance:\t\tsystemSize = 12;\tbreak;\n\tcase Displacement:\t\t\tsystemSize = 2 * TaylorOrder*TaylorOrder + TaylorOrder * 6 + 4; break;\n\t}\n\n\t// read the input data and abort if data is not present!\n\tfloat* input_v = NULL, *input_vx = NULL, *input_vy = NULL, *input_vt = NULL;\n\tif (vtkFloatArray::SafeDownCast(input->GetPointData()->GetArray(FieldNameV)) && input->GetPointData()->GetArray(FieldNameV)->GetNumberOfComponents() == 2)\n\t\tinput_v = vtkFloatArray::SafeDownCast(input->GetPointData()->GetArray(FieldNameV))->GetPointer(0);\n\telse { cout << \"Field \" << FieldNameV << \" was not found or does not have 2 components!\" << endl; return 0; }\n\n\tif (vtkFloatArray::SafeDownCast(input->GetPointData()->GetArray(FieldNameVx)) && input->GetPointData()->GetArray(FieldNameVx)->GetNumberOfComponents() == 2)\n\t\tinput_vx = vtkFloatArray::SafeDownCast(input->GetPointData()->GetArray(FieldNameVx))->GetPointer(0);\n\telse { cout << \"Field \" << FieldNameVx << \" was not found or does not have 2 components!\" << endl; return 0; }\n\n\tif (vtkFloatArray::SafeDownCast(input->GetPointData()->GetArray(FieldNameVy)) && input->GetPointData()->GetArray(FieldNameVy)->GetNumberOfComponents() == 2)\n\t\tinput_vy = vtkFloatArray::SafeDownCast(input->GetPointData()->GetArray(FieldNameVy))->GetPointer(0);\n\telse { cout << \"Field \" << FieldNameVy << \" was not found or does not have 2 components!\" << endl; return 0; }\n\n\tif (vtkFloatArray::SafeDownCast(input->GetPointData()->GetArray(FieldNameVt)) && input->GetPointData()->GetArray(FieldNameVt)->GetNumberOfComponents() == 2)\n\t\tinput_vt = vtkFloatArray::SafeDownCast(input->GetPointData()->GetArray(FieldNameVt))->GetPointer(0);\n\telse { cout << \"Field \" << FieldNameVt << \" was not found or does not have 2 components!\" << endl; return 0; }\n\n\t// Create an image to write the result to and copy the input into it (just for initialization)\n\tvtkSmartPointer image = vtkSmartPointer::New();\n\timage->DeepCopy(input);\n\n\tvtkDataArray* output_v = image->GetPointData()->GetArray(FieldNameV);\n\tvtkDataArray* output_vx = image->GetPointData()->GetArray(FieldNameVx);\n\tvtkDataArray* output_vy = image->GetPointData()->GetArray(FieldNameVy);\n\tvtkDataArray* output_vt = image->GetPointData()->GetArray(FieldNameVt);\n\n\t// Iterate the time steps (in parallel)\n#ifdef NDEBUG\n#pragma omp parallel for schedule(dynamic,16)\n#endif\n\tfor (int it = 0; it < dims[2]; it++)\n\t{\n\t\t// declare matrices for every voxel of a slice\n\t\tstd::vector > _M(dims[0] * dims[1]);\n\t\tstd::vector > _MTM(dims[0] * dims[1]);\n\t\tstd::vector > _MTb(dims[0] * dims[1]);\n\n\t\t// setup the system matrix M and right hand side.\n\t\tfor (int iy = 0; iy < dims[1]; iy++)\n\t\t{\n\t\t\tdouble y = boundsMin[1] + iy * spacing[1];\n\t\t\tfor (int ix = 0; ix < dims[0]; ix++)\n\t\t\t{\n\t\t\t\tdouble x = boundsMin[0] + ix * spacing[0];\n\t\t\t\tint tupleIdx = it * dims[0] * dims[1] + iy * dims[0] + ix;\n\n\t\t\t\t// position, velocity and derivatives at the voxel\n\t\t\t\tVector2d xx(x, y);\n\t\t\t\tVector2d vv(input_v[tupleIdx * 2 + 0], input_v[tupleIdx * 2 + 1]);\n\t\t\t\tVector2d dx(input_vx[tupleIdx * 2 + 0], input_vx[tupleIdx * 2 + 1]);\n\t\t\t\tVector2d dy(input_vy[tupleIdx * 2 + 0], input_vy[tupleIdx * 2 + 1]);\n\t\t\t\tVector2d dt(input_vt[tupleIdx * 2 + 0], input_vt[tupleIdx * 2 + 1]);\n\n\t\t\t\t// compute 90 degree rotated vectors, setup Jacobian and compute products\n\t\t\t\tVector2d Xp(-xx.y(), xx.x());\n\t\t\t\tVector2d Vp(-vv.y(), vv.x());\n\t\t\t\tMatrix2d J = make_Matrix2d(dx, dy);\n\t\t\t\tVector2d Jxpvp = -J * Xp + Vp;\n\t\t\t\tVector2d Jxv = -J * xx + vv;\n\n\t\t\t\t// setup matrix M\n\t\t\t\tMatrixXd M(2, systemSize);\n\t\t\t\tswitch (Invariance)\n\t\t\t\t{\n\t\t\t\tdefault:\n\t\t\t\tcase Objectivity:\n\t\t\t\t\tM(0, 0) = Jxpvp.x(); \t M(0, 1) = dx.x(); M(0, 2) = dy.x(); M(0, 3) = 1; M(0, 4) = 0; M(0, 5) = Xp.x();\n\t\t\t\t\tM(1, 0) = Jxpvp.y(); \t M(1, 1) = dx.y(); M(1, 2) = dy.y(); M(1, 3) = 0; M(1, 4) = 1; M(1, 5) = Xp.y();\n\t\t\t\t\tbreak;\n\t\t\t\tcase SimilarityInvariance:\n\t\t\t\t\tM(0, 0) = Jxpvp.x(); \t M(0, 1) = dx.x(); M(0, 2) = dy.x(); M(0, 3) = 1; M(0, 4) = 0; M(0, 5) = Xp.x(); M(0, 6) = Jxv.x(); M(0, 7) = xx.x();\n\t\t\t\t\tM(1, 0) = Jxpvp.y(); \t M(1, 1) = dx.y(); M(1, 2) = dy.y(); M(1, 3) = 0; M(1, 4) = 1; M(1, 5) = Xp.y(); M(1, 6) = Jxv.y();\tM(1, 7) = xx.y();\n\t\t\t\t\tbreak;\n\t\t\t\tcase AffineInvariance:\n\t\t\t\t\tM(0, 0) = vv.x() - xx.x() * J(0, 0);\tM(0, 1) = 0 - xx.x() * J(0, 1);\t/**/ M(0, 2) = vv.y() - xx.y() * J(0, 0); M(0, 3) = 0 - xx.y() * J(0, 1); /**/ M(0, 4) = J(0, 0); M(0, 5) = J(0, 1); /**/ M(0, 6) = 1; M(0, 7) = 0; /**/ M(0, 8) = xx.x(); M(0, 9) = 0; /**/ M(0, 10) = xx.y(); M(0, 11) = 0;\n\t\t\t\t\tM(1, 0) = 0 - xx.x() * J(1, 0);\tM(1, 1) = vv.x() - xx.x() * J(1, 1);\t/**/ M(1, 2) = 0 - xx.y() * J(1, 0); M(1, 3) = vv.y() - xx.y() * J(1, 1); /**/ M(1, 4) = J(1, 0); M(1, 5) = J(1, 1); /**/ M(1, 6) = 0;\tM(1, 7) = 1; /**/ M(1, 8) = 0; M(1, 9) = xx.x(); /**/ M(1, 10) = 0; M(1, 11) = xx.y();\n\t\t\t\t\tbreak;\n\t\t\t\tcase Displacement:\n\t\t\t\t{\n\t\t\t\t\tint index = 0;\n\t\t\t\t\tfor (int m = 0; m <= TaylorOrder; ++m)\n\t\t\t\t\t{\n\t\t\t\t\t\tfor (int i = m; i >= 0; --i)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tint j = m - i;\n\t\t\t\t\t\t\tMatrix2d f, g;\n\t\t\t\t\t\t\tComputeDisplacementSystemMatrixCoefficients(i, j, xx, vv, J, f, g);\n\t\t\t\t\t\t\tM(0, index * 4 + 0) = f(0, 0);\t\tM(1, index * 4 + 0) = f(1, 0);\n\t\t\t\t\t\t\tM(0, index * 4 + 1) = f(0, 1);\t\tM(1, index * 4 + 1) = f(1, 1);\n\n\t\t\t\t\t\t\tM(0, index * 4 + 2) = g(0, 0);\t\tM(1, index * 4 + 2) = g(1, 0);\n\t\t\t\t\t\t\tM(0, index * 4 + 3) = g(0, 1);\t\tM(1, index * 4 + 3) = g(1, 1);\n\t\t\t\t\t\t\tindex += 1;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// store MTM and MTb\n\t\t\t\tMatrixXd MT = M.transpose();\n\t\t\t\t_M[iy*dims[0] + ix] = M;\n\t\t\t\t_MTM[iy*dims[0] + ix] = MT * M;\n\t\t\t\t_MTb[iy*dims[0] + ix] = MT * dt * ((Invariance == Displacement) ? -1 : 1);\n\t\t\t}\n\t\t}\n\n\t\t// compute the prefix sum\n\t\tif (UseSummedAreaTables)\n\t\t{\n\t\t\tfor (int iy = 0; iy < dims[1]; iy++)\n\t\t\t\tfor (int ix = 0; ix < dims[0]; ix++)\n\t\t\t\t{\n\t\t\t\t\tif (ix > 0) {\n\t\t\t\t\t\t_MTM[iy*dims[0] + ix] += _MTM[iy*dims[0] + (ix - 1)];\n\t\t\t\t\t\t_MTb[iy*dims[0] + ix] += _MTb[iy*dims[0] + (ix - 1)];\n\t\t\t\t\t}\n\t\t\t\t\tif (iy > 0) {\n\t\t\t\t\t\t_MTM[iy*dims[0] + ix] += _MTM[(iy - 1)*dims[0] + ix];\n\t\t\t\t\t\t_MTb[iy*dims[0] + ix] += _MTb[(iy - 1)*dims[0] + ix];\n\t\t\t\t\t}\n\t\t\t\t\tif (ix > 0 && iy > 0) {\n\t\t\t\t\t\t_MTM[iy*dims[0] + ix] -= _MTM[(iy - 1)*dims[0] + (ix - 1)];\n\t\t\t\t\t\t_MTb[iy*dims[0] + ix] -= _MTb[(iy - 1)*dims[0] + (ix - 1)];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t}\n\n\t\t// solve the system for each pixel\n\t\tfor (int iy = 0; iy < dims[1]; iy++)\n\t\t{\n\t\t\tdouble y = boundsMin[1] + iy * spacing[1];\n\t\t\tfor (int ix = 0; ix < dims[0]; ix++)\n\t\t\t{\n\t\t\t\tdouble x = boundsMin[0] + ix * spacing[0];\n\t\t\t\tint tupleIdx = it * dims[0] * dims[1] + iy * dims[0] + ix;\n\n\t\t\t\t// corner indices of the neighborhood region\n\t\t\t\tint x1 = std::min(std::max(0, ix - NeighborhoodU - 1), dims[0] - 1);\n\t\t\t\tint y1 = std::min(std::max(0, iy - NeighborhoodU - 1), dims[1] - 1);\n\t\t\t\tint x2 = std::min(std::max(0, ix + NeighborhoodU), dims[0] - 1);\n\t\t\t\tint y2 = std::min(std::max(0, iy + NeighborhoodU), dims[1] - 1);\n\n\t\t\t\t// compute the sum of all matrices/vectors in neighborhood region\n\t\t\t\tMatrixXd MTM(systemSize, systemSize);\n\t\t\t\tMTM.setZero();\n\t\t\t\tVectorXd MTb(systemSize, 1);\n\t\t\t\tMTb.setZero();\n\n\t\t\t\tif (UseSummedAreaTables)\n\t\t\t\t{\n\t\t\t\t\tMTM = _MTM[y2*dims[0] + x2] + _MTM[y1*dims[0] + x1] - _MTM[y1*dims[0] + x2] - _MTM[y2*dims[0] + x1];\n\t\t\t\t\tMTb = _MTb[y2*dims[0] + x2] + _MTb[y1*dims[0] + x1] - _MTb[y1*dims[0] + x2] - _MTb[y2*dims[0] + x1];\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tfor (int wy = y1; wy <= y2; ++wy)\n\t\t\t\t\t\tfor (int wx = x1; wx <= x2; ++wx)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tMTM += _MTM[wy*dims[0] + wx];\n\t\t\t\t\t\t\tMTb += _MTb[wy*dims[0] + wx];\n\t\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// solve for reference frame parameters\n\t\t\t\tVectorXd uu = MTM.fullPivHouseholderQr().solve(MTb);\n\n\t\t\t\t// compute new vector field in optimal frame\n\t\t\t\tVector2d xx(x, y);\n\t\t\t\tVector2d vv(input_v[tupleIdx * 2 + 0], input_v[tupleIdx * 2 + 1]);\n\t\t\t\tVector2d dx(input_vx[tupleIdx * 2 + 0], input_vx[tupleIdx * 2 + 1]);\n\t\t\t\tVector2d dy(input_vy[tupleIdx * 2 + 0], input_vy[tupleIdx * 2 + 1]);\n\t\t\t\tVector2d dt(input_vt[tupleIdx * 2 + 0], input_vt[tupleIdx * 2 + 1]);\n\t\t\t\tMatrix2d J = make_Matrix2d(dx, dy);\n\t\t\t\tVector2d vnew(0, 0);\n\t\t\t\tMatrix2d Jnew = make_Matrix2d(0, 0, 0, 0);\n\t\t\t\tVector2d Xp(-xx.y(), xx.x());\n\t\t\t\tswitch (Invariance)\n\t\t\t\t{\n\t\t\t\tcase Objectivity:\n\t\t\t\t\tvnew = vv + Vector2d(uu(1), uu(2)) - uu(0) * Xp;\n\t\t\t\t\tJnew = J + make_Matrix2d(0, uu(0), -uu(0), 0);\n\t\t\t\t\tbreak;\n\t\t\t\tcase SimilarityInvariance:\n\t\t\t\t\tvnew = vv + Vector2d(uu(1), uu(2)) - uu(0) * Xp - uu(6) * xx;\n\t\t\t\t\tJnew = J + make_Matrix2d(0, uu(0), -uu(0), 0) - make_Matrix2d(uu(6), 0, 0, uu(6));\n\t\t\t\t\tbreak;\n\t\t\t\tcase AffineInvariance:\n\t\t\t\t{\n\t\t\t\t\tMatrix2d H1 = make_Matrix2d(-uu(0), -uu(2), -uu(1), -uu(3));\n\t\t\t\t\tVector2d k1(uu(4), uu(5));\n\t\t\t\t\tvnew = vv + H1 * xx + k1;\n\t\t\t\t\tJnew = J + H1;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tcase Displacement:\n\t\t\t\t{\n\t\t\t\t\t// construct velocity\n\t\t\t\t\t{\n\t\t\t\t\t\tVector2d Ft(0, 0);\n\t\t\t\t\t\tint fac_m = 1;\n\t\t\t\t\t\tfor (int m = 0; m <= TaylorOrder; ++m)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tif (m > 1)\n\t\t\t\t\t\t\t\tfac_m *= m;\n\n\t\t\t\t\t\t\tVector2d Ftpart(0, 0);\n\t\t\t\t\t\t\tfor (int i = 0; i <= m; ++i)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tint fu_i = i, fu_j = m - i;\n\t\t\t\t\t\t\t\t// general formular to get the linear index: (i+j)*(i+j+1) + 2*j\n\t\t\t\t\t\t\t\tint linear_fu = (fu_i + fu_j)*(fu_i + fu_j + 1) + 2 * fu_j;\n\t\t\t\t\t\t\t\tdouble fu = uu(2 * linear_fu + 0);\n\t\t\t\t\t\t\t\tdouble fv = uu(2 * linear_fu + 1);\n\n\t\t\t\t\t\t\t\tint binom = binomialCoeff(m, i);\n\t\t\t\t\t\t\t\tFtpart += binom * pow(xx.x(), i) * pow(xx.y(), m - i) * Vector2d(fu, fv);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tFt += Ftpart / fac_m;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tvnew = vv + Ft;\n\t\t\t\t\t}\n\t\t\t\t\t// construct Jacobian\n\t\t\t\t\t{\n\t\t\t\t\t\tMatrix2d nablaFt = make_Matrix2d(0, 0, 0, 0);\n\t\t\t\t\t\tint fac_m = 1;\n\t\t\t\t\t\tfor (int m = 1; m <= TaylorOrder; ++m)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tMatrix2d nablaFtpart = make_Matrix2d(0, 0, 0, 0);\n\t\t\t\t\t\t\tfor (int i = 0; i <= m - 1; ++i)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tint fx_i = i + 1, fx_j = m - 1 - i;\n\t\t\t\t\t\t\t\tint fy_i = i, fy_j = m - i;\n\t\t\t\t\t\t\t\t// general formular to get the linear index: (i+j)*(i+j+1) + 2*j\n\t\t\t\t\t\t\t\tint linear_fx = (fx_i + fx_j)*(fx_i + fx_j + 1) + 2 * fx_j;\n\t\t\t\t\t\t\t\tint linear_fy = (fy_i + fy_j)*(fy_i + fy_j + 1) + 2 * fy_j;\n\t\t\t\t\t\t\t\tdouble fxu = uu(2 * linear_fx + 0);\n\t\t\t\t\t\t\t\tdouble fxv = uu(2 * linear_fx + 1);\n\t\t\t\t\t\t\t\tdouble fyu = uu(2 * linear_fy + 0);\n\t\t\t\t\t\t\t\tdouble fyv = uu(2 * linear_fy + 1);\n\n\t\t\t\t\t\t\t\tint binom = binomialCoeff(m - 1, i);\n\t\t\t\t\t\t\t\tnablaFtpart += binom * pow(xx.x(), i) * pow(xx.y(), m - 1 - i) * make_Matrix2d(fxu, fyu, fxv, fyv);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tnablaFt += nablaFtpart / fac_m;\n\n\t\t\t\t\t\t\tif (m > 1)\n\t\t\t\t\t\t\t\tfac_m *= m;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tJnew = J + nablaFt;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tVector2d vtnew = dt - _M[iy * dims[0] + ix] * uu * ((Invariance == Displacement) ? -1 : 1);\n\n\t\t\t\t// store the result\n\t\t\t\toutput_v->SetTuple2(tupleIdx, vnew.x(), vnew.y());\n\t\t\t\toutput_vx->SetTuple2(tupleIdx, Jnew(0, 0), Jnew(1, 0));\n\t\t\t\toutput_vy->SetTuple2(tupleIdx, Jnew(0, 1), Jnew(1, 1));\n\t\t\t\toutput_vt->SetTuple2(tupleIdx, vtnew.x(), vtnew.y());\n\t\t\t}\n\t\t}\n\t}\n\n\t// Copy the computed image to the output\n\toutput->ShallowCopy(image);\n\n\t// Update the extent\n\tint extent[6];\n\tinput->GetExtent(extent);\n\toutput->SetExtent(extent);\n\toutInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT(), extent, 6);\n\toutInfo->Set(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT(), extent, 6);\n\treturn 1;\n}", "meta": {"hexsha": "f8f2793812ea9f12aef2f29153f0f5bc42e168ec", "size": 14570, "ext": "cxx", "lang": "C++", "max_stars_repo_path": "vtkReferenceFrameFilter.cxx", "max_stars_repo_name": "tobguent/optimal-frames", "max_stars_repo_head_hexsha": "87a2796024d2ade7e381187f564b0bc89ae72660", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2017-09-06T02:21:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-14T14:26:22.000Z", "max_issues_repo_path": "vtkReferenceFrameFilter.cxx", "max_issues_repo_name": "tobguent/optimal-frames", "max_issues_repo_head_hexsha": "87a2796024d2ade7e381187f564b0bc89ae72660", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2022-01-14T01:57:05.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-14T13:17:01.000Z", "max_forks_repo_path": "vtkReferenceFrameFilter.cxx", "max_forks_repo_name": "tobguent/optimal-frames", "max_forks_repo_head_hexsha": "87a2796024d2ade7e381187f564b0bc89ae72660", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2020-02-07T11:46:31.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-03T16:21:38.000Z", "avg_line_length": 37.1683673469, "max_line_length": 317, "alphanum_fraction": 0.5790665752, "num_tokens": 5535, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467580102418, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.5472331030193338}} {"text": "/* Copyright (c) 2010-2018, Delft University of Technology\n * All rigths reserved\n *\n * This file is part of the Tudat. Redistribution and use in source and\n * binary forms, with or without modification, are permitted exclusively\n * under the terms of the Modified BSD license. You should have received\n * a copy of the license with this file. If not, please or visit:\n * http://tudat.tudelft.nl/LICENSE.\n *\n * References\n * van der Ham, L. Interplanetary trajectory design using dynamical systems theory,\n * MSc thesis, Delft University of Technology, Delft, The Netherlands, 2012.\n * Mireles James, J.D. Celestial Mechanics Notes Set 4: The Circular Restricted Three Body\n * Problem, 2006, http://www.math.utexas.edu/users/jjames/hw4Notes.pdf,\n * last accessed: 18th May, 2012.\n *\n * Notes\n * WARNING: There seems to be a bug in the computation of the L3 location!\n *\n */\n\n#include \n#include \n\n#include \n\n#include \"Tudat/Astrodynamics/Gravitation/librationPoint.h\"\n#include \"Tudat/Mathematics/BasicMathematics/functionProxy.h\"\n\nnamespace tudat\n{\nnamespace gravitation\n{\nnamespace circular_restricted_three_body_problem\n{\n\nusing namespace root_finders;\nusing namespace basic_mathematics;\n\n//! Compute location of Lagrange libration point.\nvoid LibrationPoint::computeLocationOfLibrationPoint(\n LagrangeLibrationPoints lagrangeLibrationPoint )\n{\n using std::pow;\n using std::sqrt;\n\n // Set functions for Newton-Raphson based on collinear libration point passed as input\n // parameter, or computed locations directly of equilateral libration points.\n switch( lagrangeLibrationPoint )\n {\n case l1:\n {\n // Create an object containing the function of which we whish to obtain the root from.\n UnivariateProxyPointer rootFunction = std::make_shared< UnivariateProxy >(\n std::bind( &LibrationPoint::computeL1LocationFunction, this, std::placeholders::_1 ) );\n\n // Add the first derivative of the root function.\n rootFunction->addBinding( -1, std::bind( &LibrationPoint::\n computeL1FirstDerivativeLocationFunction, this, std::placeholders::_1 ) );\n\n // Set position vector of L1 in Cartesian elements based on result of Newton-Raphson\n // root-finding algorithm.\n positionOfLibrationPoint_ << rootFinder->execute( rootFunction, 1.0 ), 0.0, 0.0;\n }\n break;\n\n case l2:\n {\n // Create an object containing the function of which we whish to obtain the root from.\n UnivariateProxyPointer rootFunction = std::make_shared< UnivariateProxy >(\n std::bind( &LibrationPoint::computeL2LocationFunction, this, std::placeholders::_1 ) );\n\n // Add the first derivative of the root function.\n rootFunction->addBinding( -1, std::bind( &LibrationPoint::\n computeL2FirstDerivativeLocationFunction, this, std::placeholders::_1 ) );\n\n // Set position vector of L1 in Cartesian elements based on result of Newton-Raphson\n // root-finding algorithm.\n positionOfLibrationPoint_ << rootFinder->execute( rootFunction, 1.0 ), 0.0, 0.0;\n }\n break;\n\n case l3:\n {\n // Create an object containing the function of which we whish to obtain the root from.\n UnivariateProxyPointer rootFunction = std::make_shared< UnivariateProxy >(\n std::bind( &LibrationPoint::computeL3LocationFunction, this, std::placeholders::_1 ) );\n\n // Add the first derivative of the root function.\n rootFunction->addBinding( -1, std::bind( &LibrationPoint::\n computeL3FirstDerivativeLocationFunction, this, std::placeholders::_1 ) );\n\n // Set position vector of L1 in Cartesian elements based on result of Newton-Raphson\n // root-finding algorithm.\n positionOfLibrationPoint_ << rootFinder->execute( rootFunction, -1.0 ), 0.0, 0.0;\n }\n break;\n\n case l4:\n\n // Set position vector of L4 in Cartesian elements.\n positionOfLibrationPoint_.x( ) = 0.5 - massParameter;\n positionOfLibrationPoint_.y( ) = 0.5 * sqrt( 3.0 );\n positionOfLibrationPoint_.z( ) = 0.0;\n\n break;\n\n case l5:\n\n // Set position vector of L5 in Cartesian elements.\n positionOfLibrationPoint_.x( ) = 0.5 - massParameter;\n positionOfLibrationPoint_.y( ) = -0.5 * sqrt( 3.0 );\n positionOfLibrationPoint_.z( ) = 0.0;\n\n break;\n\n default:\n\n throw std::runtime_error(\n \"The Lagrange libration point requested does not exist.\" );\n };\n}\n\n} // namespace circular_restricted_three_body_problem\n} // namespace gravitation\n} // namespace tudat\n", "meta": {"hexsha": "4d653d638ad68e6dbe286e683fbb777e80bd09b4", "size": 4768, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Tudat/Astrodynamics/Gravitation/librationPoint.cpp", "max_stars_repo_name": "different91988/tudat", "max_stars_repo_head_hexsha": "97b287fe759979cf2028c9180f0abafa2487dde4", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Tudat/Astrodynamics/Gravitation/librationPoint.cpp", "max_issues_repo_name": "different91988/tudat", "max_issues_repo_head_hexsha": "97b287fe759979cf2028c9180f0abafa2487dde4", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Tudat/Astrodynamics/Gravitation/librationPoint.cpp", "max_forks_repo_name": "different91988/tudat", "max_forks_repo_head_hexsha": "97b287fe759979cf2028c9180f0abafa2487dde4", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.5433070866, "max_line_length": 107, "alphanum_fraction": 0.6753355705, "num_tokens": 1164, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467770088162, "lm_q2_score": 0.6224593171945417, "lm_q1q2_score": 0.5472331025306898}} {"text": "#include \n#include \n#include \n#include \nusing namespace std;\nusing namespace arma;\n\ndouble ** CreateMatrix(int m, int n){\n double ** mat;\n mat = new double*[m];\n for(int i=0;i\n#include \n#include \n#include \n\n\ntemplate \nstruct fn\n{\n T operator()(const T& x )\n {\n return (x-2.)*(x-5.) ; \n }\n};\n\ntemplate \nstruct tolerance\n{\n bool operator()(const T& min, const T& max )\n {\n return (max - min) < 0.001 ; \n }\n};\n\n\n\n\nint main()\n{\n\n fn f ; \n tolerance tol ; \n\n float min = 1 ; \n float max = 3 ; \n\n std::pair r = boost::math::tools::bisect(f, min, max, tol );\n\n std::cout \n << \" r \" << std::setw(15) << std::fixed << std::setprecision(4) << r.first\n << \" \" << r.second \n << std::endl \n ;\n\n\n return 0 ; \n}\n", "meta": {"hexsha": "bc006694782f955ac945d5cdc84aa6b35f4774b4", "size": 1421, "ext": "cc", "lang": "C++", "max_stars_repo_path": "boostrap/tests/BBisectTest.cc", "max_stars_repo_name": "hanswenzel/opticks", "max_stars_repo_head_hexsha": "b75b5929b6cf36a5eedeffb3031af2920f75f9f0", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2020-07-05T02:39:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-20T18:52:44.000Z", "max_issues_repo_path": "boostrap/tests/BBisectTest.cc", "max_issues_repo_name": "hanswenzel/opticks", "max_issues_repo_head_hexsha": "b75b5929b6cf36a5eedeffb3031af2920f75f9f0", "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": "boostrap/tests/BBisectTest.cc", "max_forks_repo_name": "hanswenzel/opticks", "max_forks_repo_head_hexsha": "b75b5929b6cf36a5eedeffb3031af2920f75f9f0", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2020-09-03T20:36:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-19T07:42:21.000Z", "avg_line_length": 21.2089552239, "max_line_length": 80, "alphanum_fraction": 0.6213933849, "num_tokens": 385, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.7549149758396752, "lm_q2_score": 0.72487026428967, "lm_q1q2_score": 0.5472154180531352}} {"text": "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \n#include \n\nnamespace vitamine\n{\n\ttemplate \n\tstruct Vector2XZ\n\t{\n\t\tusing ComponentType = T;\n\n\t\tT x, z;\n\n\t\tVector2XZ() noexcept = default;\n\t\tconstexpr Vector2XZ(T x, T z) noexcept : x(x), z(z) {}\n\n\t\t[[nodiscard]]\n\t\tbool withinOrdered(Vector2XZ from, Vector2XZ to) const\n\t\t{\n\t\t\tassert(from.x <= to.x);\n\t\t\tassert(from.z <= to.z);\n\t\t\treturn x >= from.x && x <= to.x\n\t\t\t && z >= from.z && z <= to.z;\n\t\t}\n\n\t\ttemplate \n\t\t[[nodiscard]]\n\t\tconstexpr T lengthSquared() const\n\t\t{\n\t\t\tauto x = static_cast(this->x);\n\t\t\tauto z = static_cast(this->z);\n\t\t\treturn x * x + z * z;\n\t\t}\n\n\t\ttemplate \n\t\t[[nodiscard]]\n\t\tF length() const\n\t\t{\n\t\t\tusing std::sqrt;\n\t\t\treturn sqrt(static_cast(lengthSquared()));\n\t\t}\n\t};\n\n\ttemplate \n\tstruct Vector3XYZ\n\t{\n\t\tusing ComponentType = T;\n\n\t\tT x, y, z;\n\n\t\tVector3XYZ() noexcept = default;\n\t\tconstexpr Vector3XYZ(T x, T y, T z) noexcept : x(x), y(y), z(z) {}\n\n\t\t[[nodiscard]]\n\t\tbool withinOrdered(Vector3XYZ from, Vector3XYZ to)\n\t\t{\n\t\t\tassert(from.x <= to.x);\n\t\t\tassert(from.y <= to.y);\n\t\t\tassert(from.z <= to.z);\n\t\t\treturn x >= from.x && x <= to.x\n\t\t\t && y >= from.y && y <= to.y\n\t\t\t && z >= from.z && z <= to.z;\n\t\t}\n\n\t\ttemplate \n\t\t[[nodiscard]]\n\t\tconstexpr T lengthSquared() const\n\t\t{\n\t\t\tauto x = static_cast(this->x);\n\t\t\tauto y = static_cast(this->y);\n\t\t\tauto z = static_cast(this->z);\n\t\t\treturn x * x + y * y + z * z;\n\t\t}\n\n\t\ttemplate \n\t\t[[nodiscard]]\n\t\tF length() const\n\t\t{\n\t\t\tusing std::sqrt;\n\t\t\treturn sqrt(static_cast(lengthSquared()));\n\t\t}\n\t};\n\n\tstatic_assert(std::is_trivial_v>);\n\tstatic_assert(std::is_trivial_v>);\n\n\tstatic_assert(sizeof(Vector2XZ ) == 2 * sizeof(Int));\n\tstatic_assert(sizeof(Vector3XYZ) == 3 * sizeof(Int));\n\n\ttemplate \n\tconstexpr bool operator==(Vector2XZ a, Vector2XZ b)\n\t{\n\t\treturn a.x == b.x && a.z == b.z;\n\t}\n\n\ttemplate \n\tconstexpr bool operator==(Vector3XYZ a, Vector3XYZ b)\n\t{\n\t\treturn a.x == b.x && a.y == b.y && a.z == b.z;\n\t}\n\n\ttemplate \n\tconstexpr bool operator!=(Vector2XZ a, Vector2XZ b)\n\t{\n\t\treturn !(a == b);\n\t}\n\n\ttemplate \n\tconstexpr bool operator!=(Vector3XYZ a, Vector3XYZ b)\n\t{\n\t\treturn !(a == b);\n\t}\n\n\ttemplate \n\tconstexpr Vector2XZ& operator+=(Vector2XZ& a, Vector2XZ b)\n\t{\n\t\ta.x += b.x;\n\t\ta.z += b.z;\n\t\treturn a;\n\t}\n\n\ttemplate \n\tconstexpr Vector3XYZ& operator+=(Vector3XYZ& a, Vector3XYZ b)\n\t{\n\t\ta.x += b.x;\n\t\ta.y += b.y;\n\t\ta.z += b.z;\n\t\treturn a;\n\t}\n\n\ttemplate \n\tconstexpr Vector2XZ& operator-=(Vector2XZ& a, Vector2XZ b)\n\t{\n\t\ta.x -= b.x;\n\t\ta.z -= b.z;\n\t\treturn a;\n\t}\n\n\ttemplate \n\tconstexpr Vector3XYZ& operator-=(Vector3XYZ& a, Vector3XYZ b)\n\t{\n\t\ta.x -= b.x;\n\t\ta.y -= b.y;\n\t\ta.z -= b.z;\n\t\treturn a;\n\t}\n\n\ttemplate \n\tconstexpr Vector2XZ operator+(Vector2XZ a, Vector2XZ b)\n\t{\n\t\treturn {a.x + b.x, a.z + b.z};\n\t}\n\n\ttemplate \n\tconstexpr Vector3XYZ operator+(Vector3XYZ a, Vector3XYZ b)\n\t{\n\t\treturn {a.x + b.x, a.y + b.y, a.z + b.z};\n\t}\n\n\ttemplate \n\tconstexpr Vector2XZ operator-(Vector2XZ a, Vector2XZ b)\n\t{\n\t\treturn {a.x - b.x, a.z - b.z};\n\t}\n\n\ttemplate \n\tconstexpr Vector3XYZ operator-(Vector3XYZ a, Vector3XYZ b)\n\t{\n\t\treturn {a.x - b.x, a.y - b.y, a.z - b.z};\n\t}\n\n\ttemplate \n\tconstexpr Vector2XZ operator*(Vector2XZ v, typename Identity::Type n)\n\t{\n\t\treturn {v.x * n, v.z * n};\n\t}\n\n\ttemplate \n\tconstexpr Vector3XYZ operator*(Vector3XYZ v, typename Identity::Type n)\n\t{\n\t\treturn {v.x * n, v.y * n, v.z * n};\n\t}\n\n\ttemplate \n\tconstexpr Vector2XZ operator*(typename Identity::Type n, Vector2XZ v)\n\t{\n\t\treturn {n * v.x, n * v.z};\n\t}\n\n\ttemplate \n\tconstexpr Vector3XYZ operator*(typename Identity::Type n, Vector3XYZ v)\n\t{\n\t\treturn {n * v.x, n * v.y, n * v.z};\n\t}\n\n\n\ttemplate \n\tconstexpr Vector2XZ operator/(Vector2XZ v, typename Identity::Type n)\n\t{\n\t\treturn {v.x / n, v.z / n};\n\t}\n\n\ttemplate \n\tconstexpr Vector3XYZ operator/(Vector3XYZ v, typename Identity::Type n)\n\t{\n\t\treturn {v.x / n, v.y / n, v.z / n};\n\t}\n\n\ttemplate \n\tconstexpr Vector2XZ operator/(typename Identity::Type n, Vector2XZ v)\n\t{\n\t\treturn {n / v.x, n / v.z};\n\t}\n\n\ttemplate \n\tconstexpr Vector3XYZ operator/(typename Identity::Type n, Vector3XYZ v)\n\t{\n\t\treturn {n / v.x, n / v.y, n / v.z};\n\t}\n\n\ttemplate \n\tstd::string toString(Vector2XZ v)\n\t{\n\t\treturn '(' + std::to_string(v.x) + ',' + ' ' + std::to_string(v.z) + ')';\n\t}\n\n\ttemplate \n\tstd::string toString(Vector3XYZ v)\n\t{\n\t\treturn '(' + std::to_string(v.x) + ',' + ' ' + std::to_string(v.y) + ',' + ' ' + std::to_string(v.z) + ')';\n\t}\n}\n\nnamespace std\n{\n\ttemplate \n\tstruct hash>\n\t{\n\t\tstd::size_t operator()(vitamine::Vector2XZ v) const noexcept\n\t\t{\n\t\t\treturn boost::hash_value(std::tie(v.x, v.z));\n\t\t}\n\t};\n\n\ttemplate \n\tstruct hash>\n\t{\n\t\tstd::size_t operator()(vitamine::Vector3XYZ v) const noexcept\n\t\t{\n\t\t\treturn boost::hash_value(std::tie(v.x, v.y, v.z));\n\t\t}\n\t};\n\n\ttemplate \n\tstruct less>\n\t{\n\t\tconstexpr bool operator()(vitamine::Vector2XZ a, vitamine::Vector2XZ b) const noexcept\n\t\t{\n\t\t\tif(a.x < b.x)\n\t\t\t\treturn true;\n\n\t\t\tif(a.x > b.x)\n\t\t\t\treturn false;\n\n\t\t\treturn a.z < b.z;\n\t\t}\n\t};\n\n\ttemplate \n\tstruct less>\n\t{\n\t\tconstexpr bool operator()(vitamine::Vector3XYZ a, vitamine::Vector3XYZ b) const noexcept\n\t\t{\n\t\t\tif(a.x < b.x)\n\t\t\t\treturn true;\n\n\t\t\tif(a.x > b.x)\n\t\t\t\treturn false;\n\n\t\t\tif(a.y < b.y)\n\t\t\t\treturn true;\n\n\t\t\tif(a.y > b.y)\n\t\t\t\treturn false;\n\n\t\t\treturn a.z < b.z;\n\t\t}\n\t};\n}\n", "meta": {"hexsha": "af7ac5f717bdf0d635afc5e6d3f4092c905f13c9", "size": 6885, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "source/common/vector.hpp", "max_stars_repo_name": "mgrech/vitamine", "max_stars_repo_head_hexsha": "d2fab653a0146b0ad9eb40d62213c968af2a100b", "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": "source/common/vector.hpp", "max_issues_repo_name": "mgrech/vitamine", "max_issues_repo_head_hexsha": "d2fab653a0146b0ad9eb40d62213c968af2a100b", "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": "source/common/vector.hpp", "max_forks_repo_name": "mgrech/vitamine", "max_forks_repo_head_hexsha": "d2fab653a0146b0ad9eb40d62213c968af2a100b", "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": 22.798013245, "max_line_length": 109, "alphanum_fraction": 0.6187363834, "num_tokens": 2230, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8056321889812553, "lm_q2_score": 0.679178692681616, "lm_q1q2_score": 0.5471682168945176}} {"text": "#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\ntypedef boost::adjacency_list_traits traits;\ntypedef boost::adjacency_list>>> graph;\n\ntypedef traits::vertex_descriptor vertex_desc;\ntypedef traits::edge_descriptor edge_desc;\ntypedef boost::adjacency_list > weighted_graph;\ntypedef boost::property_map::type weight_map;\n\n// Custom edge adder class, highly recommended\nclass edge_adder {\n graph &G;\n\n public:\n explicit edge_adder(graph &G) : G(G) {}\n\n void add_edge(int from, int to, long capacity) {\n auto c_map = boost::get(boost::edge_capacity, G);\n auto r_map = boost::get(boost::edge_reverse, G);\n const auto e = boost::add_edge(from, to, G).first;\n const auto rev_e = boost::add_edge(to, from, G).first;\n c_map[e] = capacity;\n c_map[rev_e] = 0; // reverse edge has no capacity!\n r_map[e] = rev_e;\n r_map[rev_e] = e;\n }\n};\n\nusing namespace std;\n\nstruct edge {\n int u;\n int v;\n int length;\n int width;\n};\n\n// Strategy:\n// - Find all edges that are part of some shortest path\n// - Run a max-flow algorithm on those edges\nvoid solve() {\n int n, m, s, f;\n cin >> n >> m >> s >> f;\n\n // Dijkstra Graph\n weighted_graph G(n);\n\n // Read neighbors\n vector edges;\n edges.reserve(m);\n int u, v, length, width;\n for (int i = 0; i < m; ++i) {\n cin >> u >> v >> width >> length;\n boost::add_edge(u, v, length, G);\n edges.push_back({u, v, length, width});\n }\n\n // Run dijkstra\n std::vector d(n);\n boost::dijkstra_shortest_paths(G, s, boost::distance_map(boost::make_iterator_property_map( d.begin(), boost::get(boost::vertex_index, G))));\n\n // Flow graph\n graph gFlow(n);\n edge_adder adder(gFlow);\n\n\n // Find edges on a shortest path\n vector shortestPathEdges;\n for (auto e : edges) {\n int diff = d[e.v] - d[e.u];\n if (e.length == diff) {\n adder.add_edge(e.u, e.v, e.width);\n }\n else if (e.length == -diff) {\n adder.add_edge(e.v, e.u, e.width);\n }\n }\n\n // Compute flow\n long flow = boost::push_relabel_max_flow(gFlow, s, f);\n cout << flow << endl;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n int t; cin >> t;\n while (t--)\n {\n solve();\n }\n return 0;\n}", "meta": {"hexsha": "78717488868197856f00716acf0d39ce09277e21", "size": 2797, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/marathon.cpp", "max_stars_repo_name": "dsparber/algolab", "max_stars_repo_head_hexsha": "9781eb5c7444236f796f167f1f39fc9d913e5c53", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 13.0, "max_stars_repo_stars_event_min_datetime": "2021-01-01T17:19:24.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-09T12:27:57.000Z", "max_issues_repo_path": "src/marathon.cpp", "max_issues_repo_name": "dsparber/algolab", "max_issues_repo_head_hexsha": "9781eb5c7444236f796f167f1f39fc9d913e5c53", "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/marathon.cpp", "max_forks_repo_name": "dsparber/algolab", "max_forks_repo_head_hexsha": "9781eb5c7444236f796f167f1f39fc9d913e5c53", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-01-28T10:55:25.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-28T10:55:25.000Z", "avg_line_length": 26.6380952381, "max_line_length": 143, "alphanum_fraction": 0.6628530568, "num_tokens": 797, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8688267728417088, "lm_q2_score": 0.6297746074044134, "lm_q1q2_score": 0.5471650397688306}} {"text": "/*\n * 这是 TJU Robomasters 上位机源码，未经管理层允许严禁传播给其他人（包括队内以及队外）\n *\n * 该文件包含各种预测模型，并封装到了以抽象类Predictor类为基类的类中\n */\n\n#pragma once\n\n#include \n#include \n#include \"util.hpp\"\n#include \n#include \"KalmanFilter.hpp\"\nusing namespace cv;\n\ntypedef struct _prd_path_pt{\n\n Point3f worldPosition;\n Point2f targetPTZAngle;\n Point2f selfWorldPosition;\n double duration;\n\n _prd_path_pt(Point3d _worldp,Point2f _tgtAngle,Point2f _sfworldp,float _dur)\n {\n worldPosition = _worldp;\n targetPTZAngle = _tgtAngle;\n selfWorldPosition = _sfworldp;\n duration = _dur;\n }\n\n _prd_path_pt()\n { }\n\n}PredictionPathPoint;\n\n\nclass Predictor\n{\npublic:\n // 添加一个轨迹点，该函数应该能够自主甄别轨迹点是否与之前追踪的目标一样，如果不是\n // 预测器自动清空历史数据重新开始预测\n virtual void AddPredictPoint(PredictionPathPoint ppp) = 0;\n\n // 预测一段时间之后目标的位置\n virtual void Predict(double prdTime) = 0;\n \n // 主动清除历史记录\n virtual void ClearHistory() = 0;\n};\n// 线性预测器，由历史数据给出线性的预测（假设目标匀速直线运动）\nclass KFCPredictor : public Predictor\n{\npublic:\n static const int HistorySize = 6;\n Mat P, Q, H, R, F, K, x_;\n int xstate = 0;\n PredictionPathPoint present;\n PredictionPathPoint lastpoint;\n \n KFCPredictor()\n {\n Mat P_in = Mat::eye(6,6,CV_32FC1);\n Mat Q_in = Mat::eye(6,6,CV_32FC1);\n Mat H_in = Mat::eye(6,6,CV_32FC1);\n Mat R_in = Mat::eye(6,6,CV_32FC1);\n P = P_in;\n Q = Q_in;\n H = H_in;\n R = R_in;\n lastpoint.targetPTZAngle=Point2f(0,0);\n }\n \n KFCPredictor(Mat P_in, Mat Q_in, Mat H_in, Mat R_in)\n {\n P = P_in;\n Q = Q_in;\n H = H_in;\n R = R_in;\n lastpoint.targetPTZAngle=Point2f(0,0);\n }\n \n void AddPredictPoint(PredictionPathPoint ppp)\n {\n if (Length(ppp.targetPTZAngle - lastpoint.targetPTZAngle) > 10)\n ClearHistory();\n present = ppp;\n }\n \n void ClearHistory()\n {\n xstate = 0;\n P = Mat::eye(6,6,CV_32FC1);\n };\n\n void FirstFind()\n {\n p_tx_old = present.worldPosition.x;\n p_ty_old = present.worldPosition.y;\n p_tz_old = present.worldPosition.z;\n lastpoint = present;\n }\n\n void FirstSetFilter()\n {\n //将视觉根据图像计算出的装甲板在相机坐标系下的位置传给预测类中的worldposition \n //以当前的计算作为根据上一次计算进行预测的观测值\n double t = present.duration;\n float v_tx_now = (present.worldPosition.x - p_tx_old)/t;\n float v_ty_now =(present.worldPosition.y - p_ty_old)/t;\n float v_tz_now = (present.worldPosition.z - p_tz_old)/t;\n x_ = (Mat_(6,1) <<\n present.worldPosition.x, present.worldPosition.y, present.worldPosition.z,\n v_tx_now, v_ty_now, v_tz_now\n );\n xstate = 1;\n p_tx_old = present.worldPosition.x;\n p_ty_old = present.worldPosition.y;\n p_tz_old = present.worldPosition.z;\n lastpoint = present;\n }\n void ContinueSetFilter()\n {\n double t = present.duration;\n float v_tx_now = (present.worldPosition.x - p_tx_old)/t;\n float v_ty_now = (present.worldPosition.y - p_ty_old)/t;\n float v_tz_now = (present.worldPosition.z - p_tz_old)/t;\n\n Mat z = (Mat_(6,1) <<\n present.worldPosition.x, present.worldPosition.y, present.worldPosition.z,\n v_tx_now, v_ty_now, v_tz_now\n );\n\n Predict(t);\n update(z);\n\n p_tx_old = x_.at(0, 0);\n p_ty_old = x_.at(1, 0);\n p_tz_old = x_.at(2, 0);\n lastpoint = present;\n }\n\n void Predict(double prdTime)\n {\n double t = prdTime;\n F = (Mat_(6,6) <<\n 1.0, 0.0, 0.0, t, 0.0, 0.0,\n 0.0, 1.0, 0.0, 0.0, t, 0.0,\n 0.0, 0.0, 1.0, 0.0, 0.0, t,\n 0.0, 0.0, 0.0, 1.0, 0.0, 0.0,\n 0.0, 0.0, 0.0, 0.0, 1.0,0.0,\n 0.0, 0.0, 0.0, 0.0, 0.0, 1.0\n );\n //起\n x_ = F * x_;\n // return Point3f(x_.at(0,0),x_.at(0,1),x_.at(0,2));\n }\n\n void update(Mat z)\n {\n //按\n P = F*P*F.t() + Q;\n //顿\n Mat S = H*P*H.t() + R; \n K = P*H.t()*S.inv();\n //挫\n Mat y = z - H*x_;\n x_ = x_ + (K*y);\n //下笔风雷\n Mat I = Mat::eye(6,6,CV_32FC1);\n P = (I - K*H)*P;\n }\nprotected:\n float p_tx_old; //位置保留量\n float p_ty_old;\n float p_tz_old;\n};\n\nclass AnglePredictor : public Predictor\n{\npublic:\n \n Mat P, Q, H, R, F, K, x_;\n int xstate = 0;\n PredictionPathPoint present;\n PredictionPathPoint lastpoint;\n \n AnglePredictor()\n {\n Mat P_in = Mat::eye(4,4,CV_32FC1);\n Mat Q_in = (Mat_(4,4) <<\n 5,0,0,0,\n 0,1,0,0,\n 0,0,5,0,\n 0,0,0,1\n );\n Mat H_in = (Mat_(2,4) <<\n 1,0,0,0,\n 0,1,0,0\n );\n Mat R_in = (Mat_(2,2) <<\n 200,0,\n 0,200\n );\n P = P_in;\n Q = Q_in;\n H = H_in;\n R = R_in;\n lastpoint.targetPTZAngle=Point2f(0,0);\n }\n \n AnglePredictor(Mat P_in, Mat Q_in, Mat H_in, Mat R_in)\n {\n P = P_in;\n Q = Q_in;\n H = H_in;\n R = R_in;\n lastpoint.targetPTZAngle=Point2f(0,0);\n }\n \n void AddPredictPoint(PredictionPathPoint ppp)\n {\n if (Length(ppp.targetPTZAngle - lastpoint.targetPTZAngle) > 10)\n ClearHistory();\n present = ppp;\n }\n \n void ClearHistory()\n {\n xstate = 0;\n P = Mat::eye(4,4,CV_32FC1);\n };\n\n void FirstFind()\n {\n \n lastpoint = present;\n }\n\n void FirstSetFilter()\n {\n double t = present.duration;\n float vx = (present.targetPTZAngle.x - lastpoint.targetPTZAngle.x)/t;\n float vy =(present.targetPTZAngle.y - lastpoint.targetPTZAngle.y)/t;\n \n x_ = (Mat_(4,1) <<\n present.targetPTZAngle.x, present.targetPTZAngle.y,\n vx, vy\n );\n xstate = 1;\n \n lastpoint = present;\n }\n void ContinueSetFilter()\n {\n double t = present.duration;\n float vx = (present.targetPTZAngle.x - lastpoint.targetPTZAngle.x)/t;\n float vy =(present.targetPTZAngle.y - lastpoint.targetPTZAngle.y)/t;\n Mat z = (Mat_(2,1) <<\n present.targetPTZAngle.x, present.targetPTZAngle.y\n );\n\n Predict(t);\n update(z);\n // cout << \"presemtangle: \" << present.targetPTZAngle << \" lastangle: \" << lastpoint.targetPTZAngle << endl;\n // cout << \"speedx: \" << (present.targetPTZAngle.x-lastpoint.targetPTZAngle.x)/present.duration << endl;\n // cout << \"speedy: \" << (present.targetPTZAngle.y-lastpoint.targetPTZAngle.y)/present.duration << endl;\n lastpoint = present;\n }\n\n void Predict(double prdTime)\n {\n double t = prdTime;\n F = (Mat_(4,4) <<\n 1.0, 0.0, t, 0.0, \n 0.0, 1.0, 0.0, t, \n 0.0, 0.0, 1.0, 0.0, \n 0.0, 0.0, 0.0, 1.0\n );\n //起\n x_ = F * x_;\n \n //return Point2f(myx_.at(0,0),myx_.at(0,1));\n }\n Point2f PredictReal(double prdTime)\n {\n double t = prdTime;\n F = (Mat_(4,4) <<\n 1.0, 0.0, t, 0.0, \n 0.0, 1.0, 0.0, t, \n 0.0, 0.0, 1.0, 0.0, \n 0.0, 0.0, 0.0, 1.0\n );\n //起\n \n Mat myx_ = F * x_;\n return Point2f(myx_.at(0,0),myx_.at(0,1));\n }\n\n void update(Mat z)\n {\n //按\n P = F*P*F.t() + Q;\n //顿\n Mat S = H*P*H.t() + R; \n K = P*H.t()*S.inv();\n //挫\n Mat y = z - H*x_;\n x_ = x_ + (K*y);\n //下笔风雷\n Mat I = Mat::eye(4,4,CV_32FC1);\n P = (I - K*H)*P;\n }\n};\n\nclass KalmanPredictor{\npublic:\nKalmanPredictor(){\n\n\tEigen::MatrixXd A(stateSize, stateSize);\n\tA << 1, 0, 1, 0,\n\t\t0, 1, 0, 1,\n\t\t0, 0, 1, 0,\n\t\t0, 0, 0, 1 ;\n\n\tEigen::MatrixXd H(measureSize, stateSize);\n\tH << 2, 0, 0, 0,\n\t\t0, 2, 0, 0,\n\t\t0, 0, 1, 0,\n\t\t0, 0, 0, 1;\n\n\tEigen::MatrixXd P(stateSize, stateSize);\n\tP << 1, 0, 0, 0,\n\t\t0, 1, 0, 0,\n\t\t0, 0, 1, 0,\n\t\t0, 0, 0, 1;\n\n\tEigen::MatrixXd Q(stateSize, stateSize);\n\tQ << 1, 0, 0, 0,\n\t\t0, 1, 0, 0,\n\t\t0, 0, 1, 0,\n\t\t0, 0, 0, 1;\n\n\tEigen::MatrixXd R(measureSize, measureSize);\n\tR << 900, 0, 0, 0,\n\t\t0, 900, 0, 0,\n\t\t0, 0, 700, 0,\n\t\t0, 0, 0, 700;\n\n\tKF.init(stateSize, measureSize, A, P, R, Q, H);\n\n\tx.resize(stateSize);\n\tx << 0, 0, 0, 0;\n}\npublic:\n\tEigen::MatrixXd F;\n\tEigen::VectorXd x;\n cv::Point2f predict(float yaw, float pitch,float distance, float deltatime,int bulletSpeed) {\t\n\t return kalmanPredict(yaw, pitch, (double)deltatime,distance/bulletSpeed * 0.001);\n\t}\n\n\tcv::Point2f kalmanPredict(float yaw, float pitch, double deltatime,float time){\n\tif (abs(x(0) - yaw) > 200) {\n\t\tx(0) = (double)yaw;\n\t\tyawSpeed = 0;\n\t\tx(2) = yawSpeed;\n\t}\n\tif (abs(x(2) - pitch) > 200) {\n\t\tx(1) = (double)pitch;\n\t\tpitchSpeed = 0;\n\t\tx(3) = pitchSpeed;\n\t}\n\n\tyawSpeed = (yaw - lastYaw) / deltatime;\n\tpitchSpeed = (pitch - lastPitch) / deltatime;\n\tif(abs(yawSpeed) > 50){\n\t\tyawSpeed = 0;\n\t}\n\tif(abs(pitchSpeed > 20)){\n\t\tpitchSpeed = 0;\n\t}\n\tEigen::VectorXd z(measureSize);\n\tEigen::VectorXd output;\n\tF = Eigen::MatrixXd(4, 4);\n\tcout << \"hello3\"< shootSpeed;//发射速度 单位;米/秒\n};\n", "meta": {"hexsha": "494f21d64d85d49eae9ff15edfeb290601c2a772", "size": 10351, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "misc/predictor.hpp", "max_stars_repo_name": "LeonGoretzkatju/TJU_RM_VISION", "max_stars_repo_head_hexsha": "70c70c52de918f3e19bff01321c3fd64af590bec", "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": "misc/predictor.hpp", "max_issues_repo_name": "LeonGoretzkatju/TJU_RM_VISION", "max_issues_repo_head_hexsha": "70c70c52de918f3e19bff01321c3fd64af590bec", "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": "misc/predictor.hpp", "max_forks_repo_name": "LeonGoretzkatju/TJU_RM_VISION", "max_forks_repo_head_hexsha": "70c70c52de918f3e19bff01321c3fd64af590bec", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-11-22T11:33:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-22T11:33:35.000Z", "avg_line_length": 25.1849148418, "max_line_length": 116, "alphanum_fraction": 0.5195633272, "num_tokens": 3708, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891392358015, "lm_q2_score": 0.6654105653819835, "lm_q1q2_score": 0.547093339989821}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace g2o;\n\nclass hello_vertex: public BaseVertex<1, Eigen::Matrix> {//数据类型要以Eigen::Matrix给出,因为需要转置操作\n /**\n * update the position of the node from the parameters in v.\n * Implement in your class!\n */\n\t//optimizable_graph.h \n virtual void oplusImpl(const double* v) {\n\t\tcout << \"v: \" << *v << endl;\n\t\t_estimate(0,0) += *v;\t\t\t\t//_estimate的类型即为继承模板时传入的类型\n\t\tcout << \"_estimate: \" << _estimate(0,0) << endl;\n\t}\n\t\n //! sets the node to the origin (used in the multilevel stuff)\n //optimizable_graph.h\n virtual void setToOriginImpl() {\n\t\tcout << \"setToOriginImpl \" << _estimate(0,0) << endl;\n\t\t_estimate(0,0) = 0;\n\t}\n\t\n\t//! read the vertex from a stream, i.e., the internal state of the vertex\n virtual bool read(std::istream& is) {}\n //! write the vertex to a stream\n virtual bool write(std::ostream& os) const {}\n};\n\nclass hello_edge: public BaseUnaryEdge<1, double, hello_vertex> {\n\t// computes the error of the edge and stores it in an internal structure\n\t//optimizable_graph.h\n virtual void computeError() {\n\t\tconst hello_vertex* v = static_cast (_vertices[0]);\n\t\tconst Eigen::Matrix est = v->estimate();\n\t\t//typedef Eigen::Matrix ErrorVector;\n\t\t//_error = est - (Eigen::Matrix )(10);\n\t\tcout << \"computeError: \" ;\n\t\t//_error(0,0) = _measurement - est(0,0);\n\t\t//此处误差的定义影响后续解析求导时Jacob矩阵前边是否添加负号\n\t\t_error(0,0) = -_measurement + (est(0,0) + 1)*(est(0,0) + 1);\n\t\tcout << _error(0,0) << endl;\n\t}\n\t\n\tvirtual void linearizeOplus() {\n\t\tconst hello_vertex* v = static_cast (_vertices[0]);\n\t\tconst Eigen::Matrix est = v->estimate();\n\t\t//需要提供负梯度,与Ceres相同\n\t\t//之所以是负梯度,因为err = _measurement - f(_estimate)\n\t\t//因此为负的\n\t\t_jacobianOplusXi(0,0) = 2 * (est(0,0) + 1);\n\t\tcout << \"_jacobianOplusXi: \" << _jacobianOplusXi << endl;\n\t}\n\t\n\t//! read the vertex from a stream, i.e., the internal state of the vertex\n virtual bool read(std::istream& is) {}\n //! write the vertex to a stream\n virtual bool write(std::ostream& os) const {}\n};\n/*\n * default_random_engine generator; \n * normal_distribution distribution(0.0,0.5);\n * distribution(generator);\n */\n\n\n\nint main(int argc, char** argv)\n{\n\n\t// 构建图优化，先设定g2o\n\ttypedef g2o::BlockSolver< g2o::BlockSolverTraits<1,1> > Block; // 每个误差项优化变量维度为3，误差值维度为1\n\tBlock::LinearSolverType* linearSolver = new g2o::LinearSolverDense(); // 线性方程求解器\n\tBlock* solver_ptr = new Block( linearSolver ); // 矩阵块求解器\n\t// 梯度下降方法，从GN, LM, DogLeg 中选\n\tg2o::OptimizationAlgorithmLevenberg* solver = new g2o::OptimizationAlgorithmLevenberg( solver_ptr );\n\t// g2o::OptimizationAlgorithmGaussNewton* solver = new g2o::OptimizationAlgorithmGaussNewton( solver_ptr );\n\t// g2o::OptimizationAlgorithmDogleg* solver = new g2o::OptimizationAlgorithmDogleg( solver_ptr );\n\tg2o::SparseOptimizer optimizer; // 图模型\n\toptimizer.setAlgorithm( solver ); // 设置求解器\n\toptimizer.setVerbose( true ); // 打开调试输出\n\n\t// 往图中增加顶点\n\thello_vertex* v = new hello_vertex();\n\tv->setEstimate((Eigen::Matrix) 100);\n\tv->setId(0);\n\toptimizer.addVertex( v );\n\n\t//加边\n\thello_edge* edge = new hello_edge;\n\tedge->setId(0);\n\tedge->setVertex( 0, v ); // 设置连接的顶点\n\tedge->setMeasurement(66.6); // 观测数值\n\tedge->setInformation(Eigen::Matrix::Identity()*0.25); // 信息矩阵：协方差矩阵之逆\n\toptimizer.addEdge( edge );\n\n\t// 执行优化\n\tcout<<\"start optimization\"< time_used = chrono::duration_cast>( t2-t1 );\n\tcout<<\"solve time cost = \"< abc_estimate = v->estimate();\n\tcout<<\"estimated value: \"<\n// #include \n\n// clang-format off\n// Eigen::initParallel(); //TODO try this\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nint main() {\n double t1 = omp_get_wtime();\n\n auto const n = 10000; // number of nodes\n auto const n_el = 20; // number of elements\n\n Eigen::MatrixXd Kdense = Eigen::MatrixXd::Zero(n, n); // global stiffness matrix\n Eigen::MatrixXd Ke = Eigen::MatrixXd::Ones(n_el, n_el); // elemental stiffness\n#pragma omp declare reduction(+ : Eigen::MatrixXd : omp_out = omp_out + omp_in) \\\n initializer(omp_priv=Eigen::MatrixXd::Zero(n,n))\n\n#pragma omp parallel for reduction(+ : Kdense)\n for (int i = 0; i < n - n_el + 1; i++) {\n Kdense.block(i, i, n_el, n_el) += Ke;\n }\n\n double t2 = omp_get_wtime();\n std::cout << Kdense.block(n - n_el, n - n_el, n_el, n_el) << std::endl;\n std::cout << \"/* message */\" << t2 - t1 << '\\n';\n\n using namespace tbb;\n std::vector a(20);\n tbb::parallel_for( size_t(0), 10,1, [&]( size_t i ) {\n a.at(i)=i; return;\n } );\n\n\n}\n\n// Eigen::SparseMatrix K(n, n);\n// K.coeffs() = 0.0;\n// auto Ke = Eigen::MatrixXd::Ones(n_el, n_el);\n\n// #pragma omp critical\n// {\n// for (auto b = 0; b < dofs.size(); b++) {\n// for (auto a = 0; a < dofs.size(); a++) {\n// #pragma omp critical\n// K.coeffRef(int(dofs[a]), int(dofs[b])) += Ke(a, b);\n// }\n// }\n// }\n", "meta": {"hexsha": "e702e793b38ce6741c09f1aaaa8f83cf899143b7", "size": 1644, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "cpp/stifness_assembly.cpp", "max_stars_repo_name": "shadialameddin/numerical_tools_and_friends", "max_stars_repo_head_hexsha": "cc9f10f58886ee286ed89080e38ebd303d3c72a5", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cpp/stifness_assembly.cpp", "max_issues_repo_name": "shadialameddin/numerical_tools_and_friends", "max_issues_repo_head_hexsha": "cc9f10f58886ee286ed89080e38ebd303d3c72a5", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cpp/stifness_assembly.cpp", "max_forks_repo_name": "shadialameddin/numerical_tools_and_friends", "max_forks_repo_head_hexsha": "cc9f10f58886ee286ed89080e38ebd303d3c72a5", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.8644067797, "max_line_length": 82, "alphanum_fraction": 0.5857664234, "num_tokens": 524, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891305219503, "lm_q2_score": 0.6654105521116443, "lm_q1q2_score": 0.5470933232808037}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nclass Radix {\nprivate:\n const char* s;\n int a[128];\npublic:\n Radix(const char* s = \"0123456789ABCDEF\") : s(s) {\n int i;\n for(i = 0; s[i]; ++i)\n a[(int)s[i]] = i;\n }\n std::string to(long long p, int q) {\n int i;\n if(!p)\n return \"0\";\n char t[64] = { };\n for(i = 62; p; --i) {\n t[i] = s[p % q];\n p /= q;\n }\n return std::string(t + i + 1);\n }\n std::string to(const std::string& t, int p, int q) {\n return to(to(t, p), q);\n }\n long long to(const std::string& t, int p) {\n int i;\n long long sm = a[(int)t[0]];\n for(i = 1; i < (int)t.length(); ++i)\n sm = sm * p + a[(int)t[i]];\n return sm;\n }\n};\nint main() {\n int k; cin >> k;\n string a, b; cin >> a >> b;\n Radix r;\n boost::multiprecision::cpp_int x = boost::lexical_cast(r.to(a, k));\n boost::multiprecision::cpp_int y = boost::lexical_cast(r.to(b, k));\n cout << x * y << endl;\n}\n\n\n", "meta": {"hexsha": "e6d984376381db236bc507d248b3c25e4eb1343e", "size": 1277, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "AtCoder/abc220/b/main.cpp", "max_stars_repo_name": "H-Tatsuhiro/Com_Pro-Cpp", "max_stars_repo_head_hexsha": "fd79f7821a76b11f4a6f83bbb26a034db577a877", "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": "AtCoder/abc220/b/main.cpp", "max_issues_repo_name": "H-Tatsuhiro/Com_Pro-Cpp", "max_issues_repo_head_hexsha": "fd79f7821a76b11f4a6f83bbb26a034db577a877", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-10-19T08:47:23.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-07T05:23:56.000Z", "max_forks_repo_path": "AtCoder/abc220/b/main.cpp", "max_forks_repo_name": "H-Tatsuhiro/Com_Pro-Cpp", "max_forks_repo_head_hexsha": "fd79f7821a76b11f4a6f83bbb26a034db577a877", "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.5576923077, "max_line_length": 103, "alphanum_fraction": 0.5050900548, "num_tokens": 386, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392848011833, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.5470262120958792}} {"text": "//Code developed and used to produce the results of \n//\n// Rhoads, D., Solé-Ribalta, A., González, M. C., & Borge-Holthoefer, J. (2020). \n// Planning for sustainable Open Streets in pandemic cities. \n// arXiv preprint arXiv:2009.12548.\n//\n//Please cite the above paper in any works using or derived\n//from this software\n\n\n#define TRUE 1\n#define FALSE 0\n#define DEBUG 0\n#include \"mex.h\"\n#define MAX_COLA 65001\n#define MAX_NODES 65000\ntypedef unsigned long int node_id_type;\n#include \"predQueueCircStatic.h\"\n#include \n#include \n#include \"matrix.h\"\n#include \n\nchar outputString[150];\n\n//returns the value of a half-normal PDF with sigma=855 at x\ndouble halfNormalPDF(double x){\n\n //855 is the sigma that corresponds to a situation where\n //95% of trips fall within a distance of 1667 meters\n\n return (sqrt(2)/(855*(sqrt(M_PI)))) * exp(-pow(x,2)/(2*pow(855,2)));\n\n}\n\n//returns one row of the estimated OD matrix, \n//corresponding to the number of trips from s \n//to all other nodes j\nvoid getOdRow(\n node_id_type s, \n double * vStores, \n double * vPop, \n double * vCoords, \n node_id_type sizeSupra, \n double * attraction_vectPr, \n double * OD_rowPr\n){\n\n double xi, yi, xj, yj, dist, mass, rowSum;\n\n memset( attraction_vectPr, 0, sizeof(double)*sizeSupra ); \n memset( OD_rowPr, 0, sizeof(double)*sizeSupra ); \n\n //x and y coordinates of node s\n xi = vCoords[s];\n yi = vCoords[sizeSupra + s];\n\n //keep track of a sum of the row, to normalize later\n rowSum = 0;\n //for all nodes j in the network...\n for (node_id_type j=0; j n2.distance;\n }\n};\n\n\n//prhs[0] -> Adjacency Matrix in time\n//prhs[1] -> N nodes\n//prhs[2] -> N layers = 1\n//prhs[3] -> vector s of services per node\n//prhs[4] -> vector p of population per node\n//prhs[5] -> vector c of node coordinates x,y\n\n//plhs[0] -> Node betweenness\n//plhs[1] -> Directed edge betweenness\n//plhs[2] -> Num at start node CHECK\n//plhs[3] -> Num at end node CHECK\n\n\nvoid mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ){\n\n\n //output matrices\n double tolerance = 0.000000001;\n node_id_type numNodes = 0, numLayers = 0;\n node_id_type sizeSupra = 0;\n mwSignedIndex dimsP[3];\n mxArray *rhs[1], *lhs[1];\n \n // get and check inputs\n if (nrhs != 6) mexErrMsgTxt( \"Only 6 input arguments allowed.\" );\n if (nlhs > 2) mexErrMsgTxt( \"Only 2 output argument allowed.\" );\n sizeSupra = mxGetN( prhs[0] );\n if (mxGetM( prhs[0] ) != sizeSupra) mexErrMsgTxt( \"Input matrix G needs to be square.\" );\n if(mxIsSparse(prhs[0])==0) mexErrMsgTxt( \"Input matrix must be sparse\" );\n\n numNodes = mxGetPr(prhs[1])[0];\n numLayers = mxGetPr(prhs[2])[0]; \n\n double * vStores = mxGetPr(prhs[3]);\n double * vPop = mxGetPr(prhs[4]);\n double * vCoords = mxGetPr(prhs[5]); \n\n mxArray * attraction_vect = mxCreateDoubleMatrix( sizeSupra, 1, mxREAL );\n mxArray * OD_row = mxCreateDoubleMatrix( sizeSupra, 1, mxREAL );\n double * attraction_vectPr = mxGetPr(attraction_vect);\n double * OD_rowPr = mxGetPr(OD_row); \n \n if(numLayers != 1){\n mexErrMsgTxt(\"This code is not prepared to work in multiplex networks\" );\n }\n if((numNodes*numLayers)!=sizeSupra) mexErrMsgTxt( \"Incorrect size of the input matrix\" );\n\n\n\n rhs[0] = mxDuplicateArray(prhs[0]); \n mexCallMATLAB(1, lhs, 1, rhs, \"'\");\n mxDestroyArray(rhs[0]);\n\n \n double *Gpr = mxGetPr(lhs[0]);\n size_t *Gir = mxGetIr(lhs[0]);\n size_t *Gjc = mxGetJc(lhs[0]); \n\n double edgeWeight = 0;\n double min_dist = -1;\n \n long int sIndEdges;\n long int eIndEdges; \n long int nInd;\n node_id_type v,s,w,min_v;\n double numPacketReachDest; \n double * C_B = 0;\n double * spEBW = 0;\n staticQueue * P = NULL; \n double * sigma = 0;\n double * sigmaOrig = 0; \n double * d = 0;\n double * delta = 0;\n double * visited = 0;\n staticQueue S; \n \n //to store the nodes and the distance to them\n boost::heap::fibonacci_heap< dk_Node, boost::heap::compare > dk_heap; \n boost::heap::fibonacci_heap< dk_Node, boost::heap::compare >::handle_type heapHandles[MAX_NODES];\n \n \n plhs[0] = mxCreateDoubleMatrix( sizeSupra, 1, mxREAL );\n C_B = mxGetPr(plhs[0]); \n plhs[1] = mxCreateDoubleMatrix( numLayers*numNodes, numLayers*numNodes, mxREAL );\n spEBW = mxGetPr(plhs[1]); \n\n visited = (double *)mxMalloc(sizeof(double)*sizeSupra); \n sigma = (double *)mxMalloc(sizeof(double)*sizeSupra); \n sigmaOrig = (double *)mxMalloc(sizeof(double)*sizeSupra); \n d = (double *)mxMalloc(sizeof(double)*sizeSupra); \n P = (staticQueue *)mxMalloc(sizeof(staticQueue)*sizeSupra);\n delta = (double *)mxMalloc(sizeof(double)*sizeSupra); \n \n memset( C_B, 0, sizeof(double)*sizeSupra ); \n memset( spEBW, 0, sizeof(double)*sizeSupra ); \n \n for( s = 0 ; s d[v] + edgeWeight){ // new path to the vertex\n d[w] = d[v] + edgeWeight;\n \n (*heapHandles[w]).distance = d[w]; dk_heap.decrease(heapHandles[w]); \n\n sigma[w] = sigma[v];\n create(&P[w]);\n add(&P[w],v);\n \n if(DEBUG){ \n sprintf(outputString,\"fprintf('\\\\t\\\\tnew path to vertex %lu with dist = %f\\\\n');\",w+1, d[w]);\n mexEvalString(outputString); \n }\n }else if( fabs(d[w] - d[v] - edgeWeight) < tolerance){ // the current path is of equal length\n sigma[w] = sigma[w] + sigma[v];\n add(&P[w],v); \n \n if(DEBUG){ \n sprintf(outputString,\"fprintf('\\\\t\\\\tpath to equal length to %lu , path difference =%f\\\\n');\",w+1, fabs(d[w] - d[v] - edgeWeight));\n mexEvalString(outputString); \n sprintf(outputString,\"fprintf('\\\\t\\\\told length = %f, dist to %lu = %f and edgeweight = %f\\\\n');\",d[w],v+1,d[v],edgeWeight);\n mexEvalString(outputString); \n }\n } \n }\n //end if;\n }\n //end loop;\n\n\n if(!dk_heap.empty()){\n min_v = dk_heap.top().nodeId;\n min_dist = dk_heap.top().distance;\n dk_heap.pop(); \n }else{\n min_v = -1;\n min_dist = mxGetInf(); \n }\n } \n \n //keep an original copy of the sigma\n //memcpy(sigmaOrig,sigma,sizeof(double)*sizeSupra); \n for( w = 0 ; w Aquí la OD matrix\n\n\n numPacketReachDest = OD_rowPr[w];\n \n\n delta[v] = delta[v] + (sigma[v]/sigma[w])*(numPacketReachDest + delta[w]); \n\n if(v != s){\n\n spEBW[v + sizeSupra*w] = spEBW[v + sizeSupra*w] + (sigma[v]/sigma[w])*(numPacketReachDest + delta[w]);\n\n } \n if(v == s){\n\n spEBW[v + sizeSupra*w] = spEBW[v + sizeSupra*w] + (sigma[v]/sigma[w])*(numPacketReachDest + delta[w]); \n \n } \n\n\n \n }\n\n\n \n if(w!=s){\n\n C_B[w] = C_B[w] + delta[w]; /// aqui la delta d'ha de normalizar no es poden sumar les betweenness\n // de les differents capes simplement\n \n if(DEBUG){\n sprintf(outputString,\"fprintf('\\\\t\\\\tBetweenness[w(%lu)]=%f\\\\n');\",w,C_B[w]);\n mexEvalString(outputString); \n } \n \n }\n\n }\n\n \n }\n\n\n\n mxFree(sigma);\n mxFree(sigmaOrig);\n mxFree(d);\n mxFree(P);\n mxFree(delta);\n mxFree(visited);\n}\n\n\nvoid printMatrix(double * P, int rows, int cols){\n int rowIndex = 0, columnIndex = 0;\n \n //print the matrix\n for(rowIndex = 0 ; rowIndex < rows; rowIndex++){\n for(columnIndex = 0 ; columnIndex < cols; columnIndex++){ \n mexPrintf(\"%1.4f \",P[rowIndex*cols + columnIndex]); \n } \n mexPrintf(\"\\n\"); \n } \n}\n\nvoid printMatrixInverted(double * P, int rows, int cols){\n int rowIndex = 0, columnIndex = 0;\n \n //print the matrix\n for(rowIndex = 0 ; rowIndex < rows; rowIndex++){\n for(columnIndex = 0 ; columnIndex < cols; columnIndex++){ \n mexPrintf(\"%1.4f \",P[columnIndex*rows + rowIndex]); \n } \n mexPrintf(\"\\n\"); \n } \n}\n\nvoid printSparseMatrix(int n, double * pr, size_t * ir, size_t * jc){\n size_t nrow;\n\n mexPrintf(\"This is from the .cpp\");\n\n for (int y=0; y\n *\n * Copyright 2012 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_DETAIL_FLOAT_HPP\n#define DCS_MATH_DETAIL_FLOAT_HPP\n\n\n#include \n#include \n#include \n//#include \n#include \n\n\nnamespace dcs { namespace math { namespace detail {\n\n/// See also:\n/// - http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm\n/// - http://www.petebecker.com/js/js200012.html\n/// - http://code.google.com/p/googletest/source/browse/trunk/include/gtest/internal/gtest-internal.h\n/// - http://www.parashift.com/c++-faq-lite/newbie.html#faq-29.16\n/// - http://adtmag.com/articles/2000/03/16/comparing-floats-how-to-determine-if-floating-quantities-are-close-enough-once-a-tolerance-has-been.aspx\n/// - http://www.boost.org/doc/libs/1_47_0/libs/test/doc/html/utf/testing-tools/floating_point_comparison.html\n/// - http://learningcppisfun.blogspot.com/2010/04/comparing-floating-point-numbers.html\n/// - http://floating-point-gui.de/errors/comparison/\n/// - https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/\n/// .\n\n\n/**\n * \\brief x is approximately equal to y.\n *\n * Inspired by [1]:\n * \\f[\n * $x \\approx y\\,\\text{ if and only if } |y-x|\\le\\epsilon\\max(|x|,|y|)\n * \\f]\n *\n * References:\n * -# Knuth, \"The Art of Computer Programming: Vol.2\" 3rd Ed, 1998, Sec. 4.2.2.\n * .\n */\ntemplate \ninline\ntypename ::boost::enable_if<\n\t::boost::is_floating_point,\n\tbool\n>::type approximately_equal(T x, T y, T tol)\n{\n\t// Try first with standard comparison (handles the case when both x and y are zero)\n\tif (x == y)\n\t{\n\t\treturn true;\n\t}\n\n\t// Handle degenerate cases\n\tif (::std::isnan(x) || ::std::isnan(y))\n\t{\n\t\t// According to IEEE, NaN are different even by itself\n\t\treturn false;\n\t}\n\tif (::std::isinf(x) && ::std::isinf(y))\n\t{\n\t\t// According to IEEE, Infinite operands of the same sign shall compare equal\n\t\treturn true;\n\t}\n\tif ((::std::isinf(x) && ::std::isfinite(y)) || (::std::isfinite(x) && ::std::isinf(y)))\n\t{\n\t\t// Infinity vs non-infinite operands are different\n\t\treturn false;\n\t}\n\n\treturn ::std::abs(x-y) <= (::std::max(::std::abs(x), ::std::abs(y))*tol);\n}\n\n\n/**\n * \\brief x is definitely equal to y.\n *\n * Inspired by [1]:\n * \\f[\n * $x \\sim y\\,\\text{ if and only if } |y-x|\\le\\epsilon\\min(|x|,|y|)\n * \\f]\n *\n * References:\n * -# Knuth, \"The Art of Computer Programming: Vol.2\" 3rd Ed, 1998, Sec. 4.2.2.\n * .\n */\ntemplate \ninline\ntypename ::boost::enable_if<\n\t::boost::is_floating_point,\n\tbool\n>::type essentially_equal(T x, T y, T tol)\n{\n\t// Try first with standard comparison (handles the case when both x and y are zero)\n\tif (x == y)\n\t{\n\t\treturn true;\n\t}\n\t// Handle degenerate cases\n\tif (::std::isnan(x) || ::std::isnan(y))\n\t{\n\t\t// According to IEEE, NaN are different even by itself\n\t\treturn false;\n\t}\n\tif (::std::isinf(x) && ::std::isinf(y))\n\t{\n\t\t// According to IEEE, Infinite operands of the same sign shall compare equal\n\t\treturn true;\n\t}\n\tif ((::std::isinf(x) && ::std::isfinite(y)) || (::std::isfinite(x) && ::std::isinf(y)))\n\t{\n\t\t// Infinity vs non-infinite operands are different\n\t\treturn false;\n\t}\n\n\treturn ::std::abs(x-y) <= (::std::min(::std::abs(x), ::std::abs(y))*tol);\n}\n\n\n/**\n * \\brief x is definitely greater than y.\n *\n * Inspired by [1]:\n * \\f[\n * $x \\succ y\\,\\text{ if and only if } x-y > \\epsilon\\max(|x|,|y|)\n * \\f]\n *\n * References:\n * -# Knuth, \"The Art of Computer Programming: Vol.2\" 3rd Ed, 1998, Sec. 4.2.2.\n * .\n */\ntemplate \ninline\ntypename ::boost::enable_if<\n\t::boost::is_floating_point,\n\tbool\n>::type definitely_greater(T x, T y, T tol)\n{\n\t// Try first with standard comparison\n\tif (x <= y)\n\t{\n\t\treturn false;\n\t}\n\n\t// Handle degenerate cases\n\tif (::std::isnan(x) || ::std::isnan(y))\n\t{\n\t\t// According to IEEE, NaN are different even by itself\n\t\treturn false;\n\t}\n\tif (::std::isinf(x) && ::std::isfinite(y))\n\t{\n\t\treturn true;\n\t}\n\tif (::std::isfinite(x) && ::std::isinf(y))\n\t{\n\t\treturn false;\n\t}\n\n\treturn (x-y) > (::std::max(::std::abs(x), ::std::abs(y))*tol);\n}\n\n\n/**\n * \\brief x is definitely less than y.\n *\n * Inspired by [1]:\n * \\f[\n * $x \\prec y\\,\\text{ if and only if } y-x > \\epsilon\\max(|x|,|y|)\n * \\f]\n *\n * References:\n * -# Knuth, \"The Art of Computer Programming: Vol.2\" 3rd Ed, 1998, Sec. 4.2.2.\n * .\n */\ntemplate \ninline\ntypename ::boost::enable_if<\n\t::boost::is_floating_point,\n\tbool\n>::type definitely_less(T x, T y, T tol)\n{\n\t// Try first with standard comparison\n\tif (x >= y)\n\t{\n\t\treturn false;\n\t}\n\n\t// Handle degenerate cases\n\tif (::std::isnan(x) || ::std::isnan(y))\n\t{\n\t\t// According to IEEE, NaN are different even by itself\n\t\treturn false;\n\t}\n\tif (::std::isinf(x) && ::std::isfinite(y))\n\t{\n\t\treturn false;\n\t}\n\tif (::std::isfinite(x) && ::std::isinf(y))\n\t{\n\t\treturn true;\n\t}\n\n\treturn (y-x) > (::std::max(::std::abs(x), ::std::abs(y))*tol);\n}\n\n}}} // Namespace dcs::math::detail\n\n\n#endif // DCS_MATH_DETAIL_FLOAT_HPP\n", "meta": {"hexsha": "7e84b0926cd92f7b60b41c86c04d84ff445dcf7a", "size": 5697, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/dcs/math/detail/float.hpp", "max_stars_repo_name": "sguazt/fog-gt", "max_stars_repo_head_hexsha": "92a01de4f3d71bf89741c7e4af1bebb965c64d28", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-03-26T19:03:40.000Z", "max_stars_repo_stars_event_max_datetime": "2019-03-26T19:03:40.000Z", "max_issues_repo_path": "include/dcs/math/detail/float.hpp", "max_issues_repo_name": "sguazt/fog-gt", "max_issues_repo_head_hexsha": "92a01de4f3d71bf89741c7e4af1bebb965c64d28", "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/dcs/math/detail/float.hpp", "max_forks_repo_name": "sguazt/fog-gt", "max_forks_repo_head_hexsha": "92a01de4f3d71bf89741c7e4af1bebb965c64d28", "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": 24.4506437768, "max_line_length": 148, "alphanum_fraction": 0.6456029489, "num_tokens": 1723, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7577943712746407, "lm_q2_score": 0.7217432003123989, "lm_q1q2_score": 0.5469329347024814}} {"text": "#include \n#include \n\nusing namespace Eigen;\n\nint main() {\n MatrixXd m(2, 2);\n m(0, 0) = 3;\n m(1, 0) = 2.5;\n m(0, 1) = -1;\n m(1, 1) = m(1, 0) + m(0, 1);\n std::cout << \"Here is the matrix m:\\n\" << m << std::endl;\n VectorXd v(2);\n v(0) = 4;\n v(1) = v(0) - 1;\n std::cout << \"Here is the vector v:\\n\" << v << std::endl;\n}\n", "meta": {"hexsha": "8b2fc59ced3149a5b008d99ca2a2153e93b4024e", "size": 350, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "include/Eigen-3.3/doc/examples/tut_matrix_coefficient_accessors.cpp", "max_stars_repo_name": "chen0510566/CarND-Path-Planning-Project", "max_stars_repo_head_hexsha": "4652e5c459980252e4ab72a0fd687341f3245466", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/Eigen-3.3/doc/examples/tut_matrix_coefficient_accessors.cpp", "max_issues_repo_name": "chen0510566/CarND-Path-Planning-Project", "max_issues_repo_head_hexsha": "4652e5c459980252e4ab72a0fd687341f3245466", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/Eigen-3.3/doc/examples/tut_matrix_coefficient_accessors.cpp", "max_forks_repo_name": "chen0510566/CarND-Path-Planning-Project", "max_forks_repo_head_hexsha": "4652e5c459980252e4ab72a0fd687341f3245466", "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": 19.4444444444, "max_line_length": 59, "alphanum_fraction": 0.4942857143, "num_tokens": 163, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7577943712746406, "lm_q2_score": 0.721743200312399, "lm_q1q2_score": 0.5469329347024814}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"dbscan.h\"\n\nnamespace clustering {\nDBSCAN::ClusterData DBSCAN::gen_cluster_data( size_t features_num, size_t elements_num )\n{\n DBSCAN::ClusterData cl_d( elements_num, features_num );\n\n for ( size_t i = 0; i < elements_num; ++i ) {\n for ( size_t j = 0; j < features_num; ++j ) {\n cl_d( i, j ) = ( -1.0 + rand() * ( 2.0 ) / RAND_MAX );\n }\n }\n\n return cl_d;\n}\n\nDBSCAN::FeaturesWeights DBSCAN::std_weights( size_t s )\n{\n // num cols\n DBSCAN::FeaturesWeights ws( s );\n\n for ( size_t i = 0; i < s; ++i ) {\n ws( i ) = 1.0;\n }\n\n return ws;\n}\n\nDBSCAN::DBSCAN()\n{\n}\n\nstatic int num_threads_or_default( int nt )\n{\n if ( !nt ) {\n return omp_get_max_threads();\n }\n return nt;\n}\n\nvoid DBSCAN::init( double eps, size_t min_elems, int num_threads )\n{\n m_eps = eps;\n m_min_elems = min_elems;\n m_num_threads = num_threads_or_default( num_threads );\n}\n\nDBSCAN::DBSCAN( double eps, size_t min_elems, int num_threads )\n : m_eps( eps )\n , m_min_elems( min_elems )\n , m_num_threads( num_threads_or_default( num_threads ) )\n , m_dmin( 0.0 )\n , m_dmax( 0.0 )\n{\n reset();\n}\n\nDBSCAN::~DBSCAN()\n{\n}\n\nvoid DBSCAN::reset()\n{\n m_labels.clear();\n}\n\nvoid DBSCAN::prepare_labels( size_t s )\n{\n m_labels.resize( s );\n\n for ( auto& l : m_labels ) {\n l = -1;\n }\n}\n\nconst DBSCAN::DistanceMatrix DBSCAN::calc_dist_matrix( const DBSCAN::ClusterData& C, const DBSCAN::FeaturesWeights& W )\n{\n DBSCAN::ClusterData cl_d = C;\n\n omp_set_dynamic( 0 );\n omp_set_num_threads( m_num_threads );\n#pragma omp parallel for\n for ( size_t i = 0; i < cl_d.size2(); ++i ) {\n ublas::matrix_column< DBSCAN::ClusterData > col( cl_d, i );\n\n const auto r = minmax_element( col.begin(), col.end() );\n\n double data_min = *r.first;\n double data_range = *r.second - *r.first;\n\n if ( data_range == 0.0 ) {\n data_range = 1.0;\n }\n\n const double scale = 1 / data_range;\n const double min = -1.0 * data_min * scale;\n\n col *= scale;\n col.plus_assign( ublas::scalar_vector< typename ublas::matrix_column< DBSCAN::ClusterData >::value_type >( col.size(), min ) );\n }\n\n // rows x rows\n DBSCAN::DistanceMatrix d_m( cl_d.size1(), cl_d.size1() );\n ublas::vector< double > d_max( cl_d.size1() );\n ublas::vector< double > d_min( cl_d.size1() );\n\n omp_set_dynamic( 0 );\n omp_set_num_threads( m_num_threads );\n#pragma omp parallel for\n for ( size_t i = 0; i < cl_d.size1(); ++i ) {\n for ( size_t j = i; j < cl_d.size1(); ++j ) {\n d_m( i, j ) = 0.0;\n\n if ( i != j ) {\n ublas::matrix_row< DBSCAN::ClusterData > U( cl_d, i );\n ublas::matrix_row< DBSCAN::ClusterData > V( cl_d, j );\n\n int k = 0;\n for ( const auto e : ( U - V ) ) {\n d_m( i, j ) += fabs( e ) * W[k++];\n }\n\n d_m( j, i ) = d_m( i, j );\n }\n }\n\n const auto cur_row = ublas::matrix_row< DBSCAN::DistanceMatrix >( d_m, i );\n const auto mm = minmax_element( cur_row.begin(), cur_row.end() );\n\n d_max( i ) = *mm.second;\n d_min( i ) = *mm.first;\n }\n\n m_dmin = *( min_element( d_min.begin(), d_min.end() ) );\n m_dmax = *( max_element( d_max.begin(), d_max.end() ) );\n\n m_eps = ( m_dmax - m_dmin ) * m_eps + m_dmin;\n\n return d_m;\n}\n\nDBSCAN::Neighbors DBSCAN::find_neighbors( const DBSCAN::DistanceMatrix& D, uint32_t pid )\n{\n Neighbors ne;\n\n for ( uint32_t j = 0; j < D.size1(); ++j ) {\n if ( D( pid, j ) <= m_eps ) {\n ne.push_back( j );\n }\n }\n return ne;\n}\n\nvoid DBSCAN::dbscan( const DBSCAN::DistanceMatrix& dm )\n{\n std::vector< uint8_t > visited( dm.size1() );\n\n uint32_t cluster_id = 0;\n\n for ( uint32_t pid = 0; pid < dm.size1(); ++pid ) {\n if ( !visited[pid] ) {\n visited[pid] = 1;\n\n Neighbors ne = find_neighbors( dm, pid );\n\n if ( ne.size() >= m_min_elems ) {\n m_labels[pid] = cluster_id;\n\n for ( uint32_t i = 0; i < ne.size(); ++i ) {\n uint32_t nPid = ne[i];\n\n if ( !visited[nPid] ) {\n visited[nPid] = 1;\n\n Neighbors ne1 = find_neighbors( dm, nPid );\n\n if ( ne1.size() >= m_min_elems ) {\n for ( const auto& n1 : ne1 ) {\n ne.push_back( n1 );\n }\n }\n }\n\n if ( m_labels[nPid] == -1 ) {\n m_labels[nPid] = cluster_id;\n }\n }\n\n ++cluster_id;\n }\n }\n }\n}\n\nvoid DBSCAN::fit( const DBSCAN::ClusterData& C )\n{\n const DBSCAN::FeaturesWeights W = DBSCAN::std_weights( C.size2() );\n wfit( C, W );\n}\nvoid DBSCAN::fit_precomputed( const DBSCAN::DistanceMatrix& D )\n{\n prepare_labels( D.size1() );\n dbscan( D );\n}\n\nvoid DBSCAN::wfit( const DBSCAN::ClusterData& C, const DBSCAN::FeaturesWeights& W )\n{\n prepare_labels( C.size1() );\n const DBSCAN::DistanceMatrix D = calc_dist_matrix( C, W );\n dbscan( D );\n}\n\nconst DBSCAN::Labels& DBSCAN::get_labels() const\n{\n return m_labels;\n}\n\nstd::ostream& operator<<( std::ostream& o, DBSCAN& d )\n{\n o << \"[ \";\n for ( const auto& l : d.get_labels() ) {\n o << \" \" << l;\n }\n o << \" ] \" << std::endl;\n\n return o;\n}\n}\n", "meta": {"hexsha": "8dfcd312e428a37c8ed54ecb79a4068f641c36c2", "size": 5786, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "dbscan.cpp", "max_stars_repo_name": "houwenbo87/DBSCAN", "max_stars_repo_head_hexsha": "3452d32186f2b59f2f1e515cebdf0ce15cb3e2f7", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-09-18T22:40:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-18T22:40:39.000Z", "max_issues_repo_path": "dbscan.cpp", "max_issues_repo_name": "conanhung/DBSCAN", "max_issues_repo_head_hexsha": "0bf4e6a83d61b83858f270dc5fbf78cd05ca3153", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "dbscan.cpp", "max_forks_repo_name": "conanhung/DBSCAN", "max_forks_repo_head_hexsha": "0bf4e6a83d61b83858f270dc5fbf78cd05ca3153", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-10-09T08:24:35.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-09T08:24:35.000Z", "avg_line_length": 24.4135021097, "max_line_length": 135, "alphanum_fraction": 0.5279986174, "num_tokens": 1646, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.863391617003942, "lm_q2_score": 0.6334102705979902, "lm_q1q2_score": 0.5468811177585031}} {"text": "#include \n#include \"ArchivoTrain.h\"\n#include \"Imagen.h\"\n#include \"Trabajador.h\"\n#include \"config.h\"\n#include \"ArchivoNeighbors.h\"\n#include \n#include \"ActiveSet.h\"\n#include \n#include \n#include \n#include \n/**\n * Necesito que el archivo venga en \n * \"exactamente\" el mismo formato que \n * el train de kaggle, se detecta la\n * cantidad de dimensiones\n * */\n//weinberger 09 - páginas 33 a 35\nusing namespace std;\n\nvoid filtrarNegativos(Matriz& m){\n\tfor(int i = 0; i < m.rows(); i++){\n\t\tif(m(i,i)<0){\n\t\t\tm(i,i)=0;\n\t\t}\n\t}\n}\n\nvoid obtenerSalieron(\tConjuntoActiveSets& salieron,\n\t\t\t\t\t\tConjuntoActiveSets& activos, \n\t\t\t\t\t\tConjuntoActiveSets& anterior){\n\t//salieron = anterior - activos\n\tset_difference(\tanterior.begin(),anterior.end(),\n\t\t\t\t\tactivos.begin(),activos.end(), \n\t\t\t\t\tinserter(salieron,salieron.end()),\n\t\t\t\t\tCompararActiveSet()\n\t);\n}\nvoid obtenerEntraron(\tConjuntoActiveSets& entraron,\n\t\t\t\t\t\tConjuntoActiveSets& activos, \n\t\t\t\t\t\tConjuntoActiveSets& anterior){\n\t//entraron = activos - anterior\n\tset_difference(\tactivos.begin(),activos.end(),\n\t\t\t\t\tanterior.begin(),anterior.end(), \n\t\t\t\t\tinserter(entraron,entraron.end()),\n\t\t\t\t\tCompararActiveSet()\n\t);\n\t//notese que los argumentos están invertidos\n}\n\nint main(int argc, char* argv[]){\n\tif(argc==1){\n\t\tcout<<\"Y los argumentos?\"< solver(m_def);\n\t\t\t\tMatriz delta = solver.pseudoEigenvalueMatrix();\n\t\t\t\tMatriz v = solver.pseudoEigenvectors();\n\t\t\t\tfiltrarNegativos(delta);//proyección sobre semidefinidas positivas\n\t\t\t\tm=v*delta*v.transpose();//take gradient step\n\t\t\t\t\n\t\t\t}\n\t\t\t\n\t\t\toff<\n#include \n\nnamespace abo::error_metrics {\n\n boost::multiprecision::cpp_dec_float_100 average_value(const std::vector &f) {\n\n boost::multiprecision::uint256_t sum = 0;\n const boost::multiprecision::uint256_t one = 1;\n\n int max_support_size = 0;\n for (const auto &bdd : f) {\n max_support_size = std::max(max_support_size, bdd.SupportSize());\n }\n\n for (unsigned int i = 0;i &f) {\n\n boost::multiprecision::uint256_t sum = 0;\n const boost::multiprecision::uint256_t one = 1;\n\n int max_support_size = 0;\n for (const auto &bdd : f) {\n max_support_size = std::max(max_support_size, bdd.SupportSize());\n }\n\n for (unsigned int i = 0;i &f, const std::vector &f_hat,\n const util::NumberRepresentation num_rep) {\n\n std::vector absolute_difference = abo::util::bdd_absolute_difference(mgr, f, f_hat, num_rep);\n return average_value(absolute_difference);\n }\n\n boost::multiprecision::cpp_dec_float_100 mean_squared_error(const Cudd &mgr, const std::vector &f, const std::vector &f_hat,\n const util::NumberRepresentation num_rep) {\n\n std::vector absolute_difference = abo::util::bdd_absolute_difference(mgr, f, f_hat, num_rep);\n return mean_squared_value(absolute_difference);\n }\n\n\n boost::multiprecision::cpp_dec_float_100 average_case_error_add(const Cudd &mgr, const std::vector &f, const std::vector &f_hat,\n const NumberRepresentation num_rep) {\n\n ADD diff = abo::util::absolute_difference_add(mgr, f, f_hat, num_rep);\n std::vector> terminal_values = abo::util::add_terminal_values(diff);\n\n boost::multiprecision::uint256_t sum = 0;\n boost::multiprecision::uint256_t path_sum = 0;\n for (auto p : terminal_values) {\n sum += boost::multiprecision::uint256_t(p.first) * p.second;\n path_sum += p.second;\n }\n return boost::multiprecision::cpp_dec_float_100(sum) /\n boost::multiprecision::cpp_dec_float_100(path_sum);\n }\n\n boost::multiprecision::cpp_dec_float_100 mean_squared_error_add(const Cudd &mgr, const std::vector &f, const std::vector &f_hat,\n const NumberRepresentation num_rep) {\n\n ADD diff = abo::util::absolute_difference_add(mgr, f, f_hat, num_rep);\n std::vector> terminal_values = abo::util::add_terminal_values(diff);\n\n boost::multiprecision::uint256_t sum = 0;\n boost::multiprecision::uint256_t path_sum = 0;\n for (auto p : terminal_values) {\n boost::multiprecision::uint256_t value(p.first);\n sum += value * value * p.second;\n path_sum += p.second;\n }\n return boost::multiprecision::cpp_dec_float_100(sum) /\n boost::multiprecision::cpp_dec_float_100(path_sum);\n }\n\n}\n", "meta": {"hexsha": "d97e2a401766eb70dd1696d7c7fef5f3efda5915", "size": 4572, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/error_metrics/average_case_error.cpp", "max_stars_repo_name": "andreaswendler/abo", "max_stars_repo_head_hexsha": "d5d31e0714365960fb9c02a6a5b240c07ac3a738", "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/error_metrics/average_case_error.cpp", "max_issues_repo_name": "andreaswendler/abo", "max_issues_repo_head_hexsha": "d5d31e0714365960fb9c02a6a5b240c07ac3a738", "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/error_metrics/average_case_error.cpp", "max_forks_repo_name": "andreaswendler/abo", "max_forks_repo_head_hexsha": "d5d31e0714365960fb9c02a6a5b240c07ac3a738", "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": 44.8235294118, "max_line_length": 142, "alphanum_fraction": 0.6084864392, "num_tokens": 1078, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8633916099737806, "lm_q2_score": 0.6334102636778401, "lm_q1q2_score": 0.5468811073307273}} {"text": "#include \"Gamma.h\"\n#include \n\nBaseDistributionGamma::BaseDistributionGamma(const Options& iOptions, const Data& iData) : BaseDistribution(iOptions, iData) {\n\n}\nfloat BaseDistributionGamma::getCdf(float iX, const std::vector& iMoments) const {\n assert(iMoments.size() == 2);\n float mean = iMoments[0];\n float variance = iMoments[1];\n if(variance == 0) {\n return Global::MV;\n }\n float scale = getScale(mean, variance);\n float shape = getShape(mean, variance);\n boost::math::gamma_distribution<> dist(shape, scale);\n return boost::math::cdf(dist, iX);\n}\nfloat BaseDistributionGamma::getPdf(float iX, const std::vector& iMoments) const {\n assert(iMoments.size() == 2);\n float mean = iMoments[0];\n float variance = iMoments[1];\n if(variance == 0) {\n return Global::MV;\n }\n float scale = getScale(mean, variance);\n float shape = getShape(mean, variance);\n //std::cout << \"Scale, shape = \" << scale << \" \" << shape << std::endl;\n boost::math::gamma_distribution<> dist(shape, scale);\n //std::cout << scale << \" \" << shape << std::endl;\n return boost::math::pdf(dist, iX);\n}\nfloat BaseDistributionGamma::getInv(float iCdf, const std::vector& iMoments) const {\n assert(iMoments.size() == 2);\n float mean = iMoments[0];\n float variance = iMoments[1];\n if(variance == 0) {\n return Global::MV;\n }\n float scale = getScale(mean, variance);\n float shape = getShape(mean, variance);\n boost::math::gamma_distribution<> dist(shape, scale);\n return boost::math::quantile(dist, iCdf);\n}\nint BaseDistributionGamma::getNumMoments() const {\n return 2;\n}\nfloat BaseDistributionGamma::getShape(float iMean, float iVariance) {\n // alpha (wiki: k)\n return iMean*iMean / iVariance;\n}\nfloat BaseDistributionGamma::getScale(float iMean, float iVariance) {\n // beta (wiki: theta)\n return iVariance / iMean;\n}\n", "meta": {"hexsha": "183766d5d945587f16a23541ee4a10905504e3e5", "size": 1948, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/BaseDistributions/Gamma.cpp", "max_stars_repo_name": "dsiuta/Comps", "max_stars_repo_head_hexsha": "2071279280d33946e975de25deedc60f1881eda0", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/BaseDistributions/Gamma.cpp", "max_issues_repo_name": "dsiuta/Comps", "max_issues_repo_head_hexsha": "2071279280d33946e975de25deedc60f1881eda0", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/BaseDistributions/Gamma.cpp", "max_forks_repo_name": "dsiuta/Comps", "max_forks_repo_head_hexsha": "2071279280d33946e975de25deedc60f1881eda0", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.7857142857, "max_line_length": 126, "alphanum_fraction": 0.6647843943, "num_tokens": 538, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.863391624034103, "lm_q2_score": 0.6334102498375401, "lm_q1q2_score": 0.5468811042870807}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n// Includes\n// ========\n#include \n// BGL includes\n#include \n#include \n#include \n#include \n#include \n\n// Graph Type with nested interior edge properties for Cost Flow Algorithms\ntypedef boost::adjacency_list_traits traits;\ntypedef boost::adjacency_list > > > > graph; // new! weightmap corresponds to costs\n\ntypedef boost::graph_traits::edge_descriptor edge_desc;\ntypedef boost::graph_traits::out_edge_iterator out_edge_it; // Iterator\n\n// Custom edge adder class\nclass edge_adder {\n graph &G;\n\n public:\n explicit edge_adder(graph &G) : G(G) {}\n void add_edge(int from, int to, long capacity, long cost) {\n auto c_map = boost::get(boost::edge_capacity, G);\n auto r_map = boost::get(boost::edge_reverse, G);\n auto w_map = boost::get(boost::edge_weight, G); // new!\n const edge_desc e = boost::add_edge(from, to, G).first;\n const edge_desc rev_e = boost::add_edge(to, from, G).first;\n c_map[e] = capacity;\n c_map[rev_e] = 0; // reverse edge has no capacity!\n r_map[e] = rev_e;\n r_map[rev_e] = e;\n w_map[e] = cost; // new assign cost\n w_map[rev_e] = -cost; // new negative cost\n }\n};\n\n\nint ind(int i, int j, int n) {\n return i * n + j;\n}\n\nvoid testcase() {\n int n; std::cin >> n;\n int nn = n * n;\n int sum_a = 0;\n std::vector> a(n, std::vector(n));\n for(int i = 0; i < n; i++) {\n for(int j = 0; j < n; j++) {\n std::cin >> a[i][j];\n sum_a += a[i][j];\n }\n }\n\n graph G(2 * nn);\n edge_adder adder(G);\n int max_a = 100;\n const int v_source = nn;\n const int v_sink = nn - 1;\n for(int i = 0; i < n; i++) {\n for(int j = 0; j < n; j++) {\n if(i < n - 1) adder.add_edge(nn + ind(i,j,n), ind(i+1,j,n), 1, 0);\n if(j < n - 1) adder.add_edge(nn + ind(i,j,n), ind(i,j+1,n), 1, 0);\n if(!( (i == 0 && j == 0) || (i == n - 1 && j == n - 1))) {\n adder.add_edge(ind(i,j,n), nn + ind(i,j,n), 1, -a[i][j] + max_a);\n }\n }\n }\n \n boost::successive_shortest_path_nonnegative_weights(G, v_source, v_sink);\n int cost1 = boost::find_flow_cost(G);\n // std::cerr << cost1 << \" \" << (4 * n - 6) * max_a << std::endl;\n std::cout << (4 * n - 6) * max_a - cost1 + a[0][0] + a[n-1][n-1] << std::endl;\n return;\n}\n\nint main() {\n std::ios_base::sync_with_stdio(false);\n\n int t;\n std::cin >> t;\n for (int i = 0; i < t; ++i)\n testcase();\n}\n", "meta": {"hexsha": "4a39549d14dce970fca62cb228c092d5940b400c", "size": 3178, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "problems/week12-bonus_level/src/algorithm.cpp", "max_stars_repo_name": "haeggee/algolab", "max_stars_repo_head_hexsha": "176a7d4efbbfb2842f46e93250be00d3b59e0ec3", "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": "problems/week12-bonus_level/src/algorithm.cpp", "max_issues_repo_name": "haeggee/algolab", "max_issues_repo_head_hexsha": "176a7d4efbbfb2842f46e93250be00d3b59e0ec3", "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": "problems/week12-bonus_level/src/algorithm.cpp", "max_forks_repo_name": "haeggee/algolab", "max_forks_repo_head_hexsha": "176a7d4efbbfb2842f46e93250be00d3b59e0ec3", "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.7628865979, "max_line_length": 114, "alphanum_fraction": 0.5918816866, "num_tokens": 959, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.863391602943619, "lm_q2_score": 0.6334102636778401, "lm_q1q2_score": 0.5468811028777508}} {"text": "// smooth: Lie Theory for Robotics\n// https://github.com/pettni/smooth\n//\n// Licensed under the MIT License .\n//\n// Copyright (c) 2021 Petter Nilsson\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\n#ifndef SMOOTH__INTERNAL__LMPAR_HPP_\n#define SMOOTH__INTERNAL__LMPAR_HPP_\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"utils.hpp\"\n\nnamespace smooth::detail {\n\n/**\n * @brief Solve structured least-squares probelm\n *\n * min_x \\| [J ; D] x + [r; 0] \\|^2\n *\n * Where a is a size N vector and J is M x N\n * and it must hold that J^T J + D^T D is positive semi-definite\n * where D = diag(d) is a diagonal matrix\n *\n * Let J P = Q R0 be a QR decomposition of J where P is a permutation matrix\n *\n * @param[in, out] R top left NxN corner of R0 (NxN upper triangular) (dense or sparse supported)\n * @param[in] Qt_r N-vector containing product Q' * r\n * @param[in] P NxN permutation matrix in QR decomposition\n * @param[in] d N-vector representing diagonal of D\n *\n * The function modifies R to be an upper triangular matrix Rt in the QR decomposition\n * of [R; P' D P] which satisfies\n *\n * Rt' Rt = P' (J' J + D' D) P\n *\n * NOTE For systems with M < N, R and Qt_r should be filled with zeros at the bottom\n *\n * NOTE To maximize performance in the sparse case R should be Row-Major\n */\ntemplate\nEigen::Matrix solve_ls(MatrixType & R,\n const Eigen::Matrix & Qt_r,\n const Eigen::PermutationMatrix & P,\n const Eigen::Matrix & d)\n{\n // true if R is sparse\n static constexpr bool is_sparse =\n std::is_base_of_v, MatrixType>;\n\n const auto n = R.cols();\n Eigen::Matrix a = Qt_r;\n\n // We operate on B and b row-wise, so just need to allocate one row\n Eigen::Matrix Bj(n);\n double bj;\n\n // QR decomposition of [R; P' D P] with Givens rotations;\n // where it is known that A is upper triangular and B is diagonal\n // algorithm:\n // R = A, Q = I\n // for each nonzero in B part:\n // find rotation G that eliminates nonzero without introducing new zeros\n // Q = Q G\n // R = G' R\n Eigen::JacobiRotation G;\n for (auto j = 0u; j != n; ++j) { // for each diagonal element\n // find permuted diagonal index\n const auto permidx = P.indices()(j);\n // initialize row j of B and b\n Bj.tail(n - 1 - j).setZero();\n Bj(j) = d(permidx); // Bj(k) represents B(j, k)\n bj = 0; // bj represents b(j)\n\n for (auto col = j; col != n; ++col) { // for each column right of diagonal\n if (R.coeff(col, col) >= 0 && Bj(col) == 0) { continue; }\n\n double r;\n G.makeGivens(R.coeff(col, col), Bj(col), &r); // eliminates B(j, col)\n\n // perform matrix multiplication R = G' R\n // affects row 'col' of R and row 'j' of B\n R.coeffRef(col, col) = r;\n for (auto k = col + 1; k != n; ++k) {\n const double tmp = G.c() * R.coeff(col, k) - G.s() * Bj(k);\n Bj(k) = G.s() * R.coeff(col, k) + G.c() * Bj(k);\n if constexpr (is_sparse) {\n if (R.coeff(col, k) != 0 || tmp != 0) { R.coeffRef(col, k) = tmp; }\n } else {\n R.coeffRef(col, k) = tmp;\n }\n }\n\n // At the end we need Q matrix to multiply rhs as\n // Q' * rhs = (I * G0 * ... * Gk)' * rhs = Gk' * ... * G0' * rhs\n //\n // We can therefore do it as we go, here we set\n // rhs = G * rhs\n const double tmp = G.c() * a(col) - G.s() * bj;\n bj = G.s() * a(col) + G.c() * bj;\n a(col) = tmp;\n }\n }\n\n // solve triangular system R z = a to obtain z = R^-1 z\n // first check rank of upper-diagonal R (may happen if d not full-rank)\n int rank = 0;\n for (; rank != n && R.coeff(rank, rank) >= Eigen::NumTraits::dummy_precision(); ++rank) {}\n\n Eigen::Matrix sol(n);\n sol.tail(n - rank).setZero();\n sol.head(rank) =\n R.topLeftCorner(rank, rank).template triangularView().solve(a.head(rank));\n\n // solution is now equal to -P z\n return -(P * sol);\n}\n\n/**\n * @brief Solve structured least-squares probelm\n *\n * min_x \\| [J ; D] x + [r; 0] \\|^2\n *\n * Where a is a size N vector and J is M x N\n * and it must hold that J^T J + D^T D is positive semi-definite\n * where D = diag(d) is a diagonal matrix\n *\n * @param J_qr QR decomposition J P = Q R of J with column pivoting\n * @param d vector of length N representing diagonal matrix\n * @param r vector with same number of elements as there are rows in J\n */\ntemplate\nEigen::Matrix solve_ls(\n const QrType & J_qr, const Eigen::Matrix & d, const Eigen::Matrix & r)\n{\n // true if it's a sparse decomposition\n static constexpr bool is_sparse =\n std::is_base_of_v,\n typename QrType::MatrixType>;\n\n // figure type to use for A matrix\n using AType = std::conditional_t,\n Eigen::Matrix>;\n\n static constexpr int NM_min = std::min(N, M);\n static constexpr int NM_rest = NM_min == -1 ? -1 : N - NM_min;\n\n // dynamic sizes\n const auto n = J_qr.cols();\n const auto m = J_qr.rows();\n const auto nm_min = std::min(n, m);\n const auto nm_rest = n - nm_min;\n\n AType R(n, n);\n if constexpr (is_sparse) {\n // allocate upper triangular pattern\n Eigen::Matrix pattern(n);\n for (auto i = 0u; i != n; ++i) { pattern(i) = i + 1; }\n R.reserve(pattern);\n } else {\n R.template bottomRows(nm_rest).setZero();\n }\n R.template topRows(nm_min) = J_qr.matrixR().template topRows(nm_min);\n\n Eigen::Matrix Qt_r(n);\n Qt_r.template head(nm_min) =\n (J_qr.matrixQ().transpose() * r).template head(nm_min);\n Qt_r.template bottomRows(nm_rest).setZero();\n\n return solve_ls(R, Qt_r, J_qr.colsPermutation(), d);\n}\n\n/**\n * @brief Approximate a Levenberg-Marquardt parameter lambda s.t. if x solves\n *\n * \\| [J; sqrt(lambda) * diag(d)] x + [r ; 0] \\|^2\n *\n * then either\n * * lambda = 0 AND \\|diag(d) * x\\| <= 1.1 Delta\n * OR\n * * lambda > 0 AND 0.9 Delta <= \\|diag(d) * x\\| <= 1.1 Delta\n *\n * @param J matrix MxN (static/dynamic/sparse sizes supported)\n * @param d vector size Nx1 (static/dynamic sizes supported)\n * @param r vector size Mx1 (static/dynamic sizes supported)\n * @param Delta scalar\n * @return pair(lambda, x) where x solves the least-squares problem for lambda\n *\n * @note The sparse QR decomposition is numerically unstable for ill-conditioned matrices.\n * Consider using lmpar_sparse instead.\n */\ntemplate\nstd::pair> lmpar(const MatrixT & J,\n const Eigen::Matrix & d,\n const Eigen::Matrix & r,\n double Delta)\n{\n static constexpr bool is_sparse = std::is_base_of_v, MatrixT>;\n\n static constexpr int NM_min = std::min(N, M);\n static constexpr int NM_rest = NM_min == -1 ? -1 : N - NM_min;\n\n // dynamic sizes\n const auto m = J.rows();\n const auto n = J.cols();\n const auto nm_min = std::min(n, m);\n const auto nm_rest = n - nm_min;\n\n // calculate qr decomposition of J\n std::conditional_t>,\n Eigen::ColPivHouseholderQR> J_qr;\n\n if constexpr (is_sparse) {\n // sparse solver is not very good for close-to-singular matrices\n // J_qr.setPivotThreshold(1e-1);\n }\n\n J_qr.compute(J);\n\n // calculate size n Qt_r\n Eigen::Matrix Qt_r(n);\n Qt_r.template head(nm_min) =\n (J_qr.matrixQ().transpose() * r).template head(nm_min);\n Qt_r.template bottomRows(nm_rest).setZero();\n\n // calculate phi(0) by solving J x = -r as x = P R^-1 (-Q' r)\n Eigen::Matrix x(n);\n int rank = J_qr.rank();\n x.head(rank) = J_qr.matrixR()\n .topLeftCorner(rank, rank)\n .template triangularView()\n .solve(-Qt_r.head(rank));\n x.tail(n - rank).setZero();\n x.applyOnTheLeft(J_qr.colsPermutation());\n\n Eigen::Matrix D_x_iter = d.cwiseProduct(x);\n double D_x_iter_norm = D_x_iter.stableNorm();\n\n double alpha = 0;\n double phi = D_x_iter_norm - Delta;\n double dphi;\n\n if (phi <= 0.1 * Delta) {\n // alpha = 0 solution fulfills condition\n return std::make_pair(alpha, std::move(x));\n }\n\n // lower bound\n double l = 0;\n if (J_qr.rank() == n) {\n // full rank means we can calculate dphi(0)\n // as - \\| D x \\| * \\| Rinv (P' D' D x) / \\| Dx \\| \\|^2\n Eigen::Matrix y =\n J_qr.colsPermutation().inverse() * (d.cwiseProduct(D_x_iter) / D_x_iter_norm);\n J_qr.matrixR()\n .template topLeftCorner(n, n)\n .template triangularView()\n .transpose()\n .solveInPlace(y);\n dphi = -D_x_iter_norm * y.squaredNorm();\n l = std::max(l, -phi / dphi);\n }\n\n // upper bound\n double u = (d.cwiseInverse().cwiseProduct(J.transpose() * r)).stableNorm() / Delta;\n\n // it typically converges in 2 or 3 iterations\n for (auto i = 0u; i != 20; ++i) {\n // ensure alpha stays within bounds (and not equal to zero)\n if (!(l < alpha && alpha < u)) { alpha = std::max(0.001 * u, sqrt(l * u)); }\n\n // solve least-squares problem\n using RType = std::conditional_t,\n Eigen::Matrix>;\n RType R(n, n);\n R.template topRows(nm_min) = J_qr.matrixR().template topRows(nm_min);\n if constexpr (!is_sparse) { R.template bottomRows(nm_rest).setZero(); }\n x = solve_ls(R, Qt_r, J_qr.colsPermutation(), sqrt(alpha) * d);\n if constexpr (is_sparse) { R.makeCompressed(); }\n\n // calculate phi\n D_x_iter = d.cwiseProduct(x);\n D_x_iter_norm = D_x_iter.stableNorm();\n phi = D_x_iter_norm - Delta;\n\n if (std::abs(phi) <= 0.1 * Delta) {\n break; // condition fulfilled\n }\n\n // calculate derivative of phi wrt alpha\n Eigen::Matrix y =\n J_qr.colsPermutation().inverse() * (d.cwiseProduct(D_x_iter) / D_x_iter_norm);\n R.template triangularView().transpose().solveInPlace(y);\n dphi = -D_x_iter_norm * y.squaredNorm();\n\n // update bounds\n l = std::max(l, alpha - phi / dphi);\n if (phi < 0) { u = alpha; }\n\n // update alpha\n alpha = alpha - ((phi + Delta) / Delta) * (phi / dphi);\n }\n\n return std::make_pair(alpha, std::move(x));\n}\n\n} // namespace smooth::detail\n\n#endif // SMOOTH__INTERNAL__LMPAR_HPP_\n", "meta": {"hexsha": "36952309e3a143d6f8d89b31a3bd0fc16b1d5135", "size": 11950, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/smooth/internal/lmpar.hpp", "max_stars_repo_name": "NamDinhRobotics/smooth", "max_stars_repo_head_hexsha": "137008de5d68af459db2c7802e05cdabd166c424", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-11-29T10:28:18.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-29T10:28:18.000Z", "max_issues_repo_path": "include/smooth/internal/lmpar.hpp", "max_issues_repo_name": "NamDinhRobotics/smooth", "max_issues_repo_head_hexsha": "137008de5d68af459db2c7802e05cdabd166c424", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/smooth/internal/lmpar.hpp", "max_forks_repo_name": "NamDinhRobotics/smooth", "max_forks_repo_head_hexsha": "137008de5d68af459db2c7802e05cdabd166c424", "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": 35.5654761905, "max_line_length": 100, "alphanum_fraction": 0.6328870293, "num_tokens": 3528, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744939732855, "lm_q2_score": 0.6688802603710086, "lm_q1q2_score": 0.5468594404015468}} {"text": "// Original source code from:\n// https://github.com/stegua/MyBlogEntries/tree/master/Dijkstra\n\n/// My typedefs\n#include \n#include \n#include \n\ntypedef int32_t node_t;\ntypedef int32_t edge_t;\ntypedef int64_t cost_t;\n\n/// From STL library\n#include \n\n#include \nusing std::vector;\n\n#include \n\nusing std::make_pair;\nusing std::pair;\n\n/// Lemon Graph Library\n#include \nusing lemon::SmartDigraph;\n\n#include \n#include \n#include \n#include \ntypedef SmartDigraph::Arc Arc;\ntypedef SmartDigraph::Node Node;\ntypedef SmartDigraph::ArcMap LengthMap;\n\n#include \ntypedef SmartDigraph::NodeMap NodeMap;\ntypedef lemon::FibHeap FibonacciHeap;\n\n/// Boost Timer\n#include \nusing boost::timer;\n\nusing namespace boost;\n\n/// Read input data, build graph, and run Dijkstra\ncost_t runDijkstra(char *argv[]) {\n /// Read instance from the OR-lib\n std::ifstream infile(argv[1]);\n if (!infile)\n exit(EXIT_FAILURE);\n\n int n; /// Number of variables\n int m; /// Number of constraints\n\n // reads file of the form\n // #nodes #edges\n // e_1 = v_i v_j cost[e_m]\n // ..\n // e_m = v_i v_j cost[e_m]\n\n /// Read the first line\n infile >> n >> m;\n fprintf(stdout, \"n %d, m %d\\t\", n, m);\n /// Build the graph\n SmartDigraph G;\n G.reserveNode(n);\n G.reserveArc(m);\n vector vs;\n vs.reserve(n);\n for (int i = 0; i < n; ++i)\n vs.push_back(G.addNode());\n\n int v, w;\n cost_t c;\n cost_t T_dist;\n LengthMap C(G);\n for (int i = 0; i < m; i++) {\n infile >> v >> w >> c;\n Arc a;\n a = G.addArc(vs[v - 1], vs[w - 1]);\n C[a] = c;\n }\n\n timer TIMER;\n for (int i = 0; i < 50; ++i) {\n double t0 = TIMER.elapsed();\n Node S = vs[i];\n Node T = vs[n - 1 - i];\n // NodeMap heap_cross_ref(G);\n // FibonacciHeap heap(heap_cross_ref);\n // lemon::Dijkstra::SetHeap::Create spp(G, C); spp.heap( heap, heap_cross_ref );\n lemon::Dijkstra spp(G, C);\n spp.run(S, T);\n T_dist = spp.dist(T);\n fprintf(stdout, \"Time %.4f Cost %\" PRId64 \"\\n\", TIMER.elapsed() - t0,\n T_dist);\n }\n fprintf(stdout, \"Tot %.4f\\n\", TIMER.elapsed());\n\n return T_dist;\n}\n\n/// Main function\nint main(int argc, char **argv) {\n if (argc != 2) {\n fprintf(stdout, \"usage: ./dijkstra \\n\");\n exit(EXIT_FAILURE);\n }\n /// Measure overall time\n timer TIMER;\n /// Invoke the different Dijkstra algorithm implementations\n cost_t T_dist = runDijkstra(argv);\n /// Print basic figures\n fprintf(stdout, \"Cost %\" PRId64 \" - Time %.3f\\n\", T_dist, TIMER.elapsed());\n\n return 0;\n}\n", "meta": {"hexsha": "b0fc965290265515b5637edb6334615954f33bac", "size": 2800, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/dijkstra_lemon.cc", "max_stars_repo_name": "torressa/cpp_graph_benchmarks", "max_stars_repo_head_hexsha": "f1a39024afb09a476e431e019bdbcac1ea4aa76d", "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/dijkstra_lemon.cc", "max_issues_repo_name": "torressa/cpp_graph_benchmarks", "max_issues_repo_head_hexsha": "f1a39024afb09a476e431e019bdbcac1ea4aa76d", "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/dijkstra_lemon.cc", "max_forks_repo_name": "torressa/cpp_graph_benchmarks", "max_forks_repo_head_hexsha": "f1a39024afb09a476e431e019bdbcac1ea4aa76d", "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": 23.3333333333, "max_line_length": 77, "alphanum_fraction": 0.6460714286, "num_tokens": 829, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744673038222, "lm_q2_score": 0.6688802735722128, "lm_q1q2_score": 0.5468594333558368}} {"text": "/*\n * Filename: ellipsoid.cpp\n *\n * Copyright 2020 Tecnalia\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#include \"ellipsoid.h\"\n\n#include \n\nnamespace manipulability_metrics\n{\nEllipsoid ellipsoidFromJacobian(const Eigen::Matrix& jacobian)\n{\n auto jac_svd = Eigen::JacobiSVD>{ jacobian, Eigen::ComputeFullU };\n\n return { { { jac_svd.matrixU().col(0), jac_svd.singularValues()(0) },\n { jac_svd.matrixU().col(1), jac_svd.singularValues()(1) },\n { jac_svd.matrixU().col(2), jac_svd.singularValues()(2) },\n { jac_svd.matrixU().col(3), jac_svd.singularValues()(3) },\n { jac_svd.matrixU().col(4), jac_svd.singularValues()(4) },\n { jac_svd.matrixU().col(5), jac_svd.singularValues()(5) } } };\n}\n} // namespace manipulability_metrics\n", "meta": {"hexsha": "2cf4a850f618ec66845ea43aa75f3054a9ab4ddc", "size": 1384, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "KDLUtils/ellipsoid.cpp", "max_stars_repo_name": "hyu-ryeol/RTControlDualArm", "max_stars_repo_head_hexsha": "30467a95863c5e33c355ec494d9a705ce84f98cd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2021-02-06T09:55:20.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-05T12:29:16.000Z", "max_issues_repo_path": "KDLUtils/ellipsoid.cpp", "max_issues_repo_name": "hyu-ryeol/RTControlDualArm", "max_issues_repo_head_hexsha": "30467a95863c5e33c355ec494d9a705ce84f98cd", "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": "KDLUtils/ellipsoid.cpp", "max_forks_repo_name": "hyu-ryeol/RTControlDualArm", "max_forks_repo_head_hexsha": "30467a95863c5e33c355ec494d9a705ce84f98cd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2021-07-27T06:12:58.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-24T13:54:46.000Z", "avg_line_length": 37.4054054054, "max_line_length": 109, "alphanum_fraction": 0.686416185, "num_tokens": 363, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744673038222, "lm_q2_score": 0.6688802735722128, "lm_q1q2_score": 0.5468594333558368}} {"text": "#define DEBUG 1\n/**\n * File : F.cpp\n * Author : Kazune Takahashi\n * Created : 5/19/2020, 3:57:45 PM\n * Powered by Visual Studio Code\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n// ----- boost -----\n#include \n#include \n// ----- using directives and manipulations -----\nusing namespace std;\nusing boost::rational;\nusing boost::multiprecision::cpp_int;\nusing ll = long long;\ntemplate \nusing max_heap = priority_queue;\ntemplate \nusing min_heap = priority_queue, greater>;\n// ----- constexpr for Mint and Combination -----\nconstexpr ll MOD{1000000007LL};\n// constexpr ll MOD{998244353LL}; // be careful\nconstexpr ll MAX_SIZE{3000010LL};\n// constexpr ll MAX_SIZE{30000010LL}; // if 10^7 is needed\n// ----- ch_max and ch_min -----\ntemplate \nvoid ch_max(T &left, T right)\n{\n if (left < right)\n {\n left = right;\n }\n}\ntemplate \nvoid ch_min(T &left, T right)\n{\n if (left > right)\n {\n left = right;\n }\n}\n// ----- Mint -----\ntemplate \nclass Mint\n{\npublic:\n ll x;\n Mint() : x{0LL} {}\n Mint(ll x) : x{(x % MOD + MOD) % MOD} {}\n Mint operator-() const { return x ? MOD - x : 0; }\n Mint &operator+=(const Mint &a)\n {\n if ((x += a.x) >= MOD)\n {\n x -= MOD;\n }\n return *this;\n }\n Mint &operator-=(const Mint &a) { return *this += -a; }\n Mint &operator++() { return *this += 1; }\n Mint operator++(int)\n {\n Mint tmp{*this};\n ++*this;\n return tmp;\n }\n Mint &operator--() { return *this -= 1; }\n Mint operator--(int)\n {\n Mint tmp{*this};\n --*this;\n return tmp;\n }\n Mint &operator*=(const Mint &a)\n {\n (x *= a.x) %= MOD;\n return *this;\n }\n Mint &operator/=(const Mint &a)\n {\n Mint b{a};\n return *this *= b.power(MOD - 2);\n }\n Mint operator+(const Mint &a) const { return Mint(*this) += a; }\n Mint operator-(const Mint &a) const { return Mint(*this) -= a; }\n Mint operator*(const Mint &a) const { return Mint(*this) *= a; }\n Mint operator/(const Mint &a) const { return Mint(*this) /= a; }\n bool operator<(const Mint &a) const { return x < a.x; }\n bool operator<=(const Mint &a) const { return x <= a.x; }\n bool operator>(const Mint &a) const { return x > a.x; }\n bool operator>=(const Mint &a) const { return x >= a.x; }\n bool operator==(const Mint &a) const { return x == a.x; }\n bool operator!=(const Mint &a) const { return !(*this == a); }\n const Mint power(ll N)\n {\n if (N == 0)\n {\n return 1;\n }\n else if (N % 2 == 1)\n {\n return *this * power(N - 1);\n }\n else\n {\n Mint half = power(N / 2);\n return half * half;\n }\n }\n};\ntemplate \nMint operator+(ll lhs, const Mint &rhs)\n{\n return rhs + lhs;\n}\ntemplate \nMint operator-(ll lhs, const Mint &rhs)\n{\n return -rhs + lhs;\n}\ntemplate \nMint operator*(ll lhs, const Mint &rhs)\n{\n return rhs * lhs;\n}\ntemplate \nMint operator/(ll lhs, const Mint &rhs)\n{\n return Mint{lhs} / rhs;\n}\ntemplate \nistream &operator>>(istream &stream, Mint &a)\n{\n return stream >> a.x;\n}\ntemplate \nostream &operator<<(ostream &stream, const Mint &a)\n{\n return stream << a.x;\n}\n// ----- Combination -----\ntemplate \nclass Combination\n{\npublic:\n vector> inv, fact, factinv;\n Combination() : inv(MAX_SIZE), fact(MAX_SIZE), factinv(MAX_SIZE)\n {\n inv[1] = 1;\n for (auto i = 2LL; i < MAX_SIZE; i++)\n {\n inv[i] = (-inv[MOD % i]) * (MOD / i);\n }\n fact[0] = factinv[0] = 1;\n for (auto i = 1LL; i < MAX_SIZE; i++)\n {\n fact[i] = Mint(i) * fact[i - 1];\n factinv[i] = inv[i] * factinv[i - 1];\n }\n }\n Mint operator()(int n, int k)\n {\n if (n >= 0 && k >= 0 && n - k >= 0)\n {\n return fact[n] * factinv[k] * factinv[n - k];\n }\n return 0;\n }\n Mint catalan(int x, int y)\n {\n return (*this)(x + y, y) - (*this)(x + y, y - 1);\n }\n};\n// ----- for C++14 -----\nusing mint = Mint;\nusing combination = Combination;\ntemplate \nT gcd(T x, T y) { return y ? gcd(y, x % y) : x; }\ntemplate \nT lcm(T x, T y) { return x / gcd(x, y) * y; }\n// ----- for C++17 -----\ntemplate \nint popcount(T x) // C++20\n{\n int ans{0};\n while (x != 0)\n {\n ans += x & 1;\n x >>= 1;\n }\n return ans;\n}\n// ----- frequently used constexpr -----\n// constexpr double epsilon{1e-10};\n// constexpr ll infty{1000000000000000LL}; // or\n// constexpr int infty{1'000'000'010};\n// constexpr int dx[4] = {1, 0, -1, 0};\n// constexpr int dy[4] = {0, 1, 0, -1};\n// ----- Yes() and No() -----\nvoid Yes()\n{\n cout << \"Yes\" << endl;\n exit(0);\n}\nvoid No()\n{\n cout << \"No\" << endl;\n exit(0);\n}\n\n// ----- LCA -----\n\nclass LCA\n{\n // helper classes\n struct Edge\n {\n // Initialized by initializer list. Take care fore the order of the field.\n int src, dst;\n ll cost;\n };\n\n struct Vertex\n {\n int depth;\n ll length;\n };\n\n // fields\n int N, root, L;\n vector> E;\n vector V;\n vector> ancestors;\n\n // methods\npublic:\n LCA(int N, int root = 0);\n void add_edge(int a, int b, ll c = 0);\n void init();\n void init(int root); // after adding all edges.\n\n // LCA\n int operator()(int a, int b);\n\n int depth(int a, int b) { return V[a].depth + V[b].depth - 2 * V[(*this)(a, b)].depth; }\n int depth(int v) { return depth(v, root); }\n ll length(int a, int b) { return V[a].length + V[b].length - 2 * V[(*this)(a, b)].length; }\n ll length(int v) { return length(v, root); }\n int parent(int v) { return ancestors[v][0]; }\n\nprivate:\n void dfs(int v, int d = 0, ll l = 0, int p = -1);\n};\n\n// LCA: implement\n\nLCA::LCA(int N, int root) : N{N}, root{root}, L{0}, E(N), V(N)\n{\n while ((1 << L) < N)\n {\n ++L;\n }\n ancestors = vector>(N + 1, vector(L, N));\n}\n\nvoid LCA::add_edge(int a, int b, ll c)\n{\n E[a].push_back(LCA::Edge{a, b, c});\n E[b].push_back(LCA::Edge{b, a, c});\n}\n\nvoid LCA::init(int root)\n{\n LCA::root = root;\n init();\n}\n\nvoid LCA::init()\n{\n dfs(root);\n for (auto i = 0; i < L - 1; i++)\n {\n for (auto v = 0; v < N; v++)\n {\n if (ancestors[v][i] != -1)\n {\n ancestors[v][i + 1] = ancestors[ancestors[v][i]][i];\n }\n }\n }\n}\n\nint LCA::operator()(int a, int b)\n{\n if (V[a].depth > V[b].depth)\n {\n swap(a, b);\n }\n int gap = V[b].depth - V[a].depth;\n for (auto i = L - 1; i >= 0; i--)\n {\n int len{1 << i};\n if (gap >= len)\n {\n gap -= len;\n b = ancestors[b][i];\n }\n }\n if (a == b)\n {\n return a;\n }\n for (auto i = L - 1; i >= 0; i--)\n {\n int na{ancestors[a][i]};\n int nb{ancestors[b][i]};\n if (na != nb)\n {\n a = na;\n b = nb;\n }\n }\n return ancestors[a][0];\n}\n\nvoid LCA::dfs(int v, int d, ll l, int p)\n{\n if (p != -1)\n {\n ancestors[v][0] = p;\n }\n V[v].depth = d;\n V[v].length = l;\n for (auto const &e : E[v])\n {\n int u{e.dst};\n if (u == p)\n {\n continue;\n }\n dfs(u, d + 1, l + e.cost, v);\n }\n}\n\n// ----- main() -----\n\nstruct Query\n{\n int id, color, y, coefficient;\n};\n\nstruct Edge\n{\n int src, dst, color, cost;\n};\n\nclass Solve\n{\n int N, Q;\n vector> V;\n vector> W;\n LCA lca;\n vector ans;\n vector sum, cnt;\n\npublic:\n Solve(int N, int Q) : N{N}, Q{Q}, V(N), W(N), lca{N}, ans(Q), sum(N - 1, 0), cnt(N - 1, 0)\n {\n for (auto i = 0; i < N - 1; ++i)\n {\n int a, b, c, d;\n cin >> a >> b >> c >> d;\n --a;\n --b;\n --c;\n V[a].push_back({a, b, c, d});\n V[b].push_back({b, a, c, d});\n lca.add_edge(a, b, d);\n }\n lca.init(0);\n for (auto i = 0; i < Q; ++i)\n {\n int x, y, u, v;\n cin >> x >> y >> u >> v;\n --x;\n --u;\n --v;\n W[u].push_back({i, x, y, 1});\n W[v].push_back({i, x, y, 1});\n W[lca(u, v)].push_back({i, x, y, -2});\n ans[i] = lca.length(u, v);\n }\n }\n\n void flush()\n {\n dfs();\n for (auto i = 0; i < Q; ++i)\n {\n cout << ans[i] << endl;\n }\n }\n\nprivate:\n void dfs(int u = 0, int p = -1)\n {\n#if DEBUG == 1\n cerr << \"u = \" << u << \", p = \" << p << endl;\n#endif\n for (auto const &q : W[u])\n {\n ans[q.id] += q.coefficient * (-sum[q.color] + cnt[q.color] * q.y);\n#if DEBUG == 1\n cerr << \"ans[\" << q.id << \"] += \" << q.coefficient << \" * (-\" << sum[q.color] << \" + \" << cnt[q.color] << \" * \" << q.y << \")\" << endl;\n#endif\n }\n for (auto const &e : V[u])\n {\n if (e.dst == p)\n {\n continue;\n }\n sum[e.color] += e.cost;\n cnt[e.color]++;\n dfs(e.dst, u);\n sum[e.color] -= e.cost;\n cnt[e.color]--;\n }\n }\n};\n\nint main()\n{\n int N, Q;\n cin >> N >> Q;\n Solve solve(N, Q);\n solve.flush();\n}\n", "meta": {"hexsha": "a76fd43bce619951cfbd5c059aa5f864d42b4e39", "size": 9217, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "2019/0707_ABC133/F.cpp", "max_stars_repo_name": "kazunetakahashi/atcoder", "max_stars_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2019-03-24T14:06:29.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-17T21:16:36.000Z", "max_issues_repo_path": "2019/0707_ABC133/F.cpp", "max_issues_repo_name": "kazunetakahashi/atcoder", "max_issues_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "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": "2019/0707_ABC133/F.cpp", "max_forks_repo_name": "kazunetakahashi/atcoder", "max_forks_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-07-22T17:27:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-22T17:27:09.000Z", "avg_line_length": 19.9502164502, "max_line_length": 140, "alphanum_fraction": 0.5205598351, "num_tokens": 3130, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744761936438, "lm_q2_score": 0.6688802603710086, "lm_q1q2_score": 0.5468594285090954}} {"text": "#include \n// [[Rcpp::plugins(cpp11)]]\n\n// [[Rcpp::depends(BH)]]\n#include \n#include \n\nusing namespace boost::numeric::odeint;\n\nunsigned int n;\nRcpp::NumericMatrix g_a;\nRcpp::NumericVector g_r;\nstd::vector out_t;\nstd::vector< std::vector > out_x;\n\n// the model\nvoid LV (const std::vector &x,\n std::vector &dxdt,\n double t) {\n for (int row = 0; row < g_a.nrow(); ++row) {\n double c = 0;\n for (int col = 0; col < g_a.ncol(); ++col) {\n // Rcpp::numericMatrix is indexed like this\n // matrixName(row, column)\n c = c + g_a(row, col) * x[col];\n }\n dxdt[row] = x[row] * (g_r[row] - c);\n }\n}\n\n// the observer\nvoid write_LV (const std::vector &x , const double t) {\n // debugging output\n // for (unsigned int i = 0; i < x.size(); ++i) {\n // std::cout << x[i] << \" \";\n // }\n // std::cout << std::endl;\n \n out_t.push_back(t);\n \n for (unsigned int i = 0; i < x.size(); ++i) {\n out_x[i].push_back(x[i]);\n }\n}\n\n// creates the output object\nRcpp::List createOutput() {\n \n Rcpp::List out;\n out(\"Time\") = Rcpp::wrap(out_t);\n for (unsigned int i = 0; i != n; ++i)\n {\n auto cnam = std::string(\"X\") + std::to_string(i + 1);\n out(cnam) = Rcpp::wrap(out_x[i]);\n }\n out.attr(\"class\") = \"data.frame\";\n int rows_out = out_t.size();\n auto rn = Rcpp::IntegerVector::create(NA_INTEGER, -rows_out);\n out.attr(\"row.names\") = rn;\n return out;\n}\n \n// function that will be called from R\n// [[Rcpp::export]]\nRcpp::List integrateModel(Rcpp::NumericVector init,\n Rcpp::NumericVector r,\n Rcpp::NumericMatrix a,\n double t0,\n double t1,\n double dt) {\n n = r.size();\n \n // initialize out_x\n out_x = std::vector< std::vector >(n);\n for (unsigned int i = 0; i < n; ++i) {\n out_x[i] = std::vector();\n }\n \n // initialize/reset out_t\n out_t = std::vector();\n \n // assign global variables, needed for function LV\n g_a = a;\n g_r = r;\n \n // init must be casted to std::vector for integrate function\n std::vector v_init = Rcpp::as< std::vector >(init);\n \n \n // for debugging: is the order of row/col iteration right?\n // for (int i = 0; i < n; ++i) {\n // std::cout << r[i] << \" \";\n // }\n // std::cout << std::endl;\n // \n // for (int row = 0; row < a.nrow(); ++row) {\n // for (int col = 0; col < a.ncol(); ++col) {\n // std::cout << a(row, col) << \" \";\n // } \n // }\n // std::cout << std::endl;\n \n \n // this is the integration step\n // the function LV does the work\n // the observer function write_LV catches the state of the\n // stepper and pushes it to the global output variables\n integrate(LV, v_init, t0, t1, dt, write_LV);\n \n return createOutput();\n}\n", "meta": {"hexsha": "c39d880d65c4b3e729bbeecdc193cf2ba7f63919", "size": 2936, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "lib/LV_model_wrapped.cpp", "max_stars_repo_name": "LoicChr/TransferTraitDemo", "max_stars_repo_head_hexsha": "d25be80ae3d9e39e5bf388666b7a430c1d630951", "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": "lib/LV_model_wrapped.cpp", "max_issues_repo_name": "LoicChr/TransferTraitDemo", "max_issues_repo_head_hexsha": "d25be80ae3d9e39e5bf388666b7a430c1d630951", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/LV_model_wrapped.cpp", "max_forks_repo_name": "LoicChr/TransferTraitDemo", "max_forks_repo_head_hexsha": "d25be80ae3d9e39e5bf388666b7a430c1d630951", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.2142857143, "max_line_length": 69, "alphanum_fraction": 0.5463215259, "num_tokens": 898, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.793105951184112, "lm_q2_score": 0.6893056040203135, "lm_q1q2_score": 0.5466923767330696}} {"text": "\n#include \n#include \n\nNTL_START_IMPL\n\n\n\n\n// ==========================================\n\n\n\n\n#define PAR_THRESH (40000.0)\n\nstatic double\nzz_pE_SizeInWords()\n{\n return deg(zz_pE::modulus());\n}\n\n\nstatic\nvoid mul_aux(Mat& X, const Mat& A, const Mat& B) \n{ \n long n = A.NumRows(); \n long l = A.NumCols(); \n long m = B.NumCols(); \n \n if (l != B.NumRows()) \n LogicError(\"matrix mul: dimension mismatch\"); \n \n X.SetDims(n, m); \n\n\n zz_pContext zz_p_context;\n zz_p_context.save();\n zz_pEContext zz_pE_context;\n zz_pE_context.save();\n double sz = zz_pE_SizeInWords();\n\n bool seq = (double(n)*double(l)*double(m)*sz*sz < PAR_THRESH);\n\n NTL_GEXEC_RANGE(seq, m, first, last)\n NTL_IMPORT(n)\n NTL_IMPORT(l)\n NTL_IMPORT(m)\n\n zz_p_context.restore();\n zz_pE_context.restore();\n\n long i, j, k; \n zz_pX acc, tmp; \n\n Vec B_col;\n B_col.SetLength(l);\n\n for (j = first; j < last; j++) {\n for (k = 0; k < l; k++) B_col[k] = B[k][j];\n\n for (i = 0; i < n; i++) {\n clear(acc);\n for (k = 0; k < l; k++) {\n mul(tmp, rep(A[i][k]), rep(B_col[k]));\n add(acc, acc, tmp);\n }\n conv(X[i][j], acc);\n }\n }\n\n NTL_GEXEC_RANGE_END\n} \n\n\nvoid mul(mat_zz_pE& X, const mat_zz_pE& A, const mat_zz_pE& B) \n{ \n if (&X == &A || &X == &B) { \n mat_zz_pE tmp; \n mul_aux(tmp, A, B); \n X = tmp; \n } \n else \n mul_aux(X, A, B); \n} \n \n\nvoid inv(zz_pE& d, Mat& X, const Mat& A)\n{\n long n = A.NumRows();\n\n if (A.NumCols() != n)\n LogicError(\"inv: nonsquare matrix\");\n\n if (n == 0) {\n set(d);\n X.SetDims(0, 0);\n return;\n }\n\n const zz_pXModulus& G = zz_pE::modulus();\n\n zz_pX t1, t2;\n zz_pX pivot;\n zz_pX pivot_inv;\n\n Vec< Vec > M;\n // scratch space\n\n M.SetLength(n);\n for (long i = 0; i < n; i++) {\n M[i].SetLength(n);\n for (long j = 0; j < n; j++) {\n M[i][j].SetMaxLength(2*deg(G)-1);\n M[i][j] = rep(A[i][j]);\n }\n }\n\n zz_pX det;\n det = 1;\n\n\n Vec P;\n P.SetLength(n);\n for (long k = 0; k < n; k++) P[k] = k;\n // records swap operations\n \n\n zz_pContext zz_p_context;\n zz_p_context.save();\n double sz = zz_pE_SizeInWords();\n\n bool seq = double(n)*double(n)*sz*sz < PAR_THRESH;\n\n bool pivoting = false;\n\n for (long k = 0; k < n; k++) {\n\n long pos = -1;\n\n for (long i = k; i < n; i++) {\n rem(pivot, M[i][k], G);\n if (pivot != 0) {\n InvMod(pivot_inv, pivot, G);\n pos = i;\n break;\n }\n }\n\n if (pos != -1) {\n if (k != pos) {\n swap(M[pos], M[k]);\n negate(det, det); \n P[k] = pos;\n pivoting = true;\n }\n\n MulMod(det, det, pivot, G);\n\n {\n // multiply row k by pivot_inv\n zz_pX *y = &M[k][0];\n for (long j = 0; j < n; j++) {\n rem(t2, y[j], G);\n MulMod(y[j], t2, pivot_inv, G);\n }\n y[k] = pivot_inv;\n }\n\n\n NTL_GEXEC_RANGE(seq, n, first, last) \n NTL_IMPORT(n)\n NTL_IMPORT(k)\n\n zz_p_context.restore();\n\n zz_pX *y = &M[k][0]; \n zz_pX t1, t2;\n\n for (long i = first; i < last; i++) {\n if (i == k) continue; // skip row k\n\n zz_pX *x = &M[i][0]; \n rem(t1, x[k], G);\n negate(t1, t1); \n x[k] = 0;\n if (t1 == 0) continue;\n\n // add t1 * row k to row i\n for (long j = 0; j < n; j++) {\n mul(t2, y[j], t1);\n add(x[j], x[j], t2);\n }\n }\n NTL_GEXEC_RANGE_END\n }\n else {\n clear(d);\n return;\n }\n }\n\n if (pivoting) {\n // pivot colums, using reverse swap sequence\n\n for (long i = 0; i < n; i++) {\n zz_pX *x = &M[i][0]; \n\n for (long k = n-1; k >= 0; k--) {\n long pos = P[k];\n if (pos != k) swap(x[pos], x[k]);\n }\n }\n }\n\n X.SetDims(n, n);\n for (long i = 0; i < n; i++)\n for (long j = 0; j < n; j++)\n conv(X[i][j], M[i][j]);\n\n conv(d, det);\n}\n\nstatic\nvoid solve_impl(zz_pE& d, Vec& X, \n const Mat& A, const Vec& b, bool trans)\n\n{\n long n = A.NumRows();\n if (A.NumCols() != n)\n LogicError(\"solve: nonsquare matrix\");\n\n if (b.length() != n)\n LogicError(\"solve: dimension mismatch\");\n\n if (n == 0) {\n set(d);\n X.SetLength(0);\n return;\n }\n\n zz_pX t1, t2;\n\n const zz_pXModulus& G = zz_pE::modulus();\n\n Vec< Vec > M;\n\n M.SetLength(n);\n\n for (long i = 0; i < n; i++) {\n M[i].SetLength(n+1);\n for (long j = 0; j < n; j++) M[i][j].SetMaxLength(2*deg(G)-1);\n\n if (trans) \n for (long j = 0; j < n; j++) M[i][j] = rep(A[j][i]);\n else\n for (long j = 0; j < n; j++) M[i][j] = rep(A[i][j]);\n\n M[i][n] = rep(b[i]);\n }\n\n zz_pX det;\n set(det);\n\n zz_pContext zz_p_context;\n zz_p_context.save();\n double sz = zz_pE_SizeInWords();\n\n for (long k = 0; k < n; k++) {\n long pos = -1;\n for (long i = k; i < n; i++) {\n rem(t1, M[i][k], G);\n M[i][k] = t1;\n if (pos == -1 && !IsZero(t1)) {\n pos = i;\n }\n }\n\n if (pos != -1) {\n if (k != pos) {\n swap(M[pos], M[k]);\n negate(det, det); \n }\n\n MulMod(det, det, M[k][k], G);\n\n // make M[k, k] == -1 mod G, and make row k reduced\n\n InvMod(t1, M[k][k], G);\n negate(t1, t1); \n for (long j = k+1; j <= n; j++) {\n rem(t2, M[k][j], G);\n MulMod(M[k][j], t2, t1, G);\n }\n\n bool seq =\n double(n-(k+1))*(n-(k+1))*sz*sz < PAR_THRESH;\n\n NTL_GEXEC_RANGE(seq, n-(k+1), first, last)\n NTL_IMPORT(n)\n NTL_IMPORT(k)\n\n zz_p_context.restore();\n\n zz_pX t1, t2;\n\n for (long ii = first; ii < last; ii++) {\n long i = ii + k+1;\n\n // M[i] = M[i] + M[k]*M[i,k]\n\n t1 = M[i][k]; // this is already reduced\n\n zz_pX *x = M[i].elts() + (k+1);\n zz_pX *y = M[k].elts() + (k+1);\n\n for (long j = k+1; j <= n; j++, x++, y++) {\n // *x = *x + (*y)*t1\n\n mul(t2, *y, t1);\n add(*x, *x, t2);\n }\n }\n\n NTL_GEXEC_RANGE_END\n\n }\n else {\n clear(d);\n return;\n }\n }\n\n X.SetLength(n);\n for (long i = n-1; i >= 0; i--) {\n clear(t1);\n for (long j = i+1; j < n; j++) {\n mul(t2, rep(X[j]), M[i][j]);\n add(t1, t1, t2);\n }\n sub(t1, t1, M[i][n]);\n conv(X[i], t1);\n }\n\n conv(d, det);\n}\n\n\nvoid solve(zz_pE& d, Vec& x, \n const Mat& A, const Vec& b)\n{\n solve_impl(d, x, A, b, true);\n}\n\nvoid solve(zz_pE& d, const Mat& A, \n Vec& x, const Vec& b)\n{\n solve_impl(d, x, A, b, false);\n}\n\n\n\nlong gauss(Mat& M_in, long w)\n{\n zz_pX t1, t2;\n zz_pX piv;\n\n long n = M_in.NumRows();\n long m = M_in.NumCols();\n\n if (w < 0 || w > m)\n LogicError(\"gauss: bad args\");\n\n const zz_pXModulus& G = zz_pE::modulus();\n\n Vec< Vec > M;\n\n M.SetLength(n);\n for (long i = 0; i < n; i++) {\n M[i].SetLength(m);\n for (long j = 0; j < m; j++) {\n M[i][j].SetLength(2*deg(G)-1);\n M[i][j] = rep(M_in[i][j]);\n }\n }\n\n zz_pContext zz_p_context;\n zz_p_context.save();\n double sz = zz_pE_SizeInWords();\n\n long l = 0;\n for (long k = 0; k < w && l < n; k++) {\n\n long pos = -1;\n for (long i = l; i < n; i++) {\n rem(t1, M[i][k], G);\n M[i][k] = t1;\n if (pos == -1 && !IsZero(t1)) {\n pos = i;\n }\n }\n\n if (pos != -1) {\n swap(M[pos], M[l]);\n\n InvMod(piv, M[l][k], G);\n negate(piv, piv);\n\n for (long j = k+1; j < m; j++) {\n rem(M[l][j], M[l][j], G);\n }\n\n bool seq =\n double(n-(l+1))*double(m-(k+1))*sz*sz < PAR_THRESH;\n\n NTL_GEXEC_RANGE(seq, n-(l+1), first, last)\n NTL_IMPORT(m)\n NTL_IMPORT(k)\n NTL_IMPORT(l)\n\n zz_p_context.restore();\n\n zz_pX t1, t2;\n\n\n for (long ii = first; ii < last; ii++) {\n long i = ii + l+1;\n\n // M[i] = M[i] + M[l]*M[i,k]*piv\n\n MulMod(t1, M[i][k], piv, G);\n\n clear(M[i][k]);\n\n zz_pX *x = M[i].elts() + (k+1);\n zz_pX *y = M[l].elts() + (k+1);\n\n for (long j = k+1; j < m; j++, x++, y++) {\n // *x = *x + (*y)*t1\n\n mul(t2, *y, t1);\n add(t2, t2, *x);\n *x = t2;\n }\n }\n\n NTL_GEXEC_RANGE_END\n\n l++;\n }\n }\n \n for (long i = 0; i < n; i++)\n for (long j = 0; j < m; j++)\n conv(M_in[i][j], M[i][j]);\n\n return l;\n}\n\n\nlong gauss(Mat& M)\n{\n return gauss(M, M.NumCols());\n}\n\nvoid image(Mat& X, const Mat& A)\n{\n Mat M;\n M = A;\n long r = gauss(M);\n M.SetDims(r, M.NumCols());\n X = M;\n}\n\n\n\nvoid kernel(Mat& X, const Mat& A)\n{\n long m = A.NumRows();\n long n = A.NumCols();\n\n const zz_pXModulus& G = zz_pE::modulus();\n\n Mat M;\n\n transpose(M, A);\n long r = gauss(M);\n\n if (r == 0) {\n ident(X, m);\n return;\n }\n\n X.SetDims(m-r, m);\n\n if (m-r == 0 || m == 0) return;\n\n\n Vec D;\n D.SetLength(m);\n for (long j = 0; j < m; j++) D[j] = -1;\n\n Vec inverses;\n inverses.SetLength(m);\n\n for (long i = 0, j = -1; i < r; i++) {\n do {\n j++;\n } while (IsZero(M[i][j]));\n\n D[j] = i;\n inv(inverses[j], M[i][j]); \n }\n\n zz_pEContext zz_pE_context;\n zz_pE_context.save();\n zz_pContext zz_p_context;\n zz_p_context.save();\n double sz = zz_pE_SizeInWords();\n\n bool seq = \n double(m-r)*double(r)*double(r)*sz*sz < PAR_THRESH;\n\n NTL_GEXEC_RANGE(seq, m-r, first, last)\n NTL_IMPORT(m)\n NTL_IMPORT(r)\n\n zz_p_context.restore();\n zz_pE_context.restore();\n\n zz_pX t1, t2;\n zz_pE T3;\n\n for (long k = first; k < last; k++) {\n Vec& v = X[k];\n long pos = 0;\n for (long j = m-1; j >= 0; j--) {\n if (D[j] == -1) {\n if (pos == k)\n set(v[j]);\n else\n clear(v[j]);\n pos++;\n }\n else {\n long i = D[j];\n\n clear(t1);\n\n for (long s = j+1; s < m; s++) {\n mul(t2, rep(v[s]), rep(M[i][s]));\n add(t1, t1, t2);\n }\n\n conv(T3, t1);\n mul(T3, T3, inverses[j]);\n negate(v[j], T3); \n }\n }\n }\n\n NTL_GEXEC_RANGE_END\n}\n\n\n\n\n\nvoid determinant(zz_pE& d, const Mat& M_in)\n{\n zz_pX t1, t2;\n\n const zz_pXModulus& G = zz_pE::modulus();\n\n long n = M_in.NumRows();\n\n if (M_in.NumCols() != n)\n LogicError(\"determinant: nonsquare matrix\");\n\n if (n == 0) {\n set(d);\n return;\n }\n\n Vec< Vec > M;\n\n M.SetLength(n);\n for (long i = 0; i < n; i++) {\n M[i].SetLength(n);\n for (long j = 0; j < n; j++) { \n M[i][j].SetMaxLength(2*deg(G)-1);\n M[i][j] = rep(M_in[i][j]);\n }\n }\n\n zz_pX det;\n set(det);\n\n zz_pContext zz_p_context;\n zz_p_context.save();\n double sz = zz_pE_SizeInWords();\n\n for (long k = 0; k < n; k++) {\n long pos = -1;\n for (long i = k; i < n; i++) {\n rem(t1, M[i][k], G);\n M[i][k] = t1;\n if (pos == -1 && !IsZero(t1))\n pos = i;\n }\n\n if (pos != -1) {\n if (k != pos) {\n swap(M[pos], M[k]);\n negate(det, det);\n }\n\n MulMod(det, det, M[k][k], G);\n\n // make M[k, k] == -1 mod G, and make row k reduced\n\n InvMod(t1, M[k][k], G);\n negate(t1, t1);\n for (long j = k+1; j < n; j++) {\n rem(t2, M[k][j], G);\n MulMod(M[k][j], t2, t1, G);\n }\n\n\n bool seq =\n double(n-(k+1))*(n-(k+1))*sz*sz < PAR_THRESH;\n\n NTL_GEXEC_RANGE(seq, n-(k+1), first, last)\n NTL_IMPORT(n)\n NTL_IMPORT(k)\n\n zz_p_context.restore();\n\n zz_pX t1, t2;\n\n for (long ii = first; ii < last; ii++) {\n long i = ii + k+1;\n\n // M[i] = M[i] + M[k]*M[i,k]\n\n t1 = M[i][k]; // this is already reduced\n\n zz_pX *x = M[i].elts() + (k+1);\n zz_pX *y = M[k].elts() + (k+1);\n\n for (long j = k+1; j < n; j++, x++, y++) {\n // *x = *x + (*y)*t1\n\n mul(t2, *y, t1);\n add(*x, *x, t2);\n }\n }\n\n NTL_GEXEC_RANGE_END\n\n }\n else {\n clear(d);\n return;\n }\n }\n\n conv(d, det);\n}\n\n\n// ==========================================\n\n\n\n\n \nvoid add(mat_zz_pE& X, const mat_zz_pE& A, const mat_zz_pE& B) \n{ \n long n = A.NumRows(); \n long m = A.NumCols(); \n \n if (B.NumRows() != n || B.NumCols() != m) \n LogicError(\"matrix add: dimension mismatch\"); \n \n X.SetDims(n, m); \n \n long i, j; \n for (i = 1; i <= n; i++) \n for (j = 1; j <= m; j++) \n add(X(i,j), A(i,j), B(i,j)); \n} \n \nvoid sub(mat_zz_pE& X, const mat_zz_pE& A, const mat_zz_pE& B) \n{ \n long n = A.NumRows(); \n long m = A.NumCols(); \n \n if (B.NumRows() != n || B.NumCols() != m) \n LogicError(\"matrix sub: dimension mismatch\"); \n \n X.SetDims(n, m); \n \n long i, j; \n for (i = 1; i <= n; i++) \n for (j = 1; j <= m; j++) \n sub(X(i,j), A(i,j), B(i,j)); \n} \n\nvoid negate(mat_zz_pE& X, const mat_zz_pE& A) \n{ \n long n = A.NumRows(); \n long m = A.NumCols(); \n \n \n X.SetDims(n, m); \n \n long i, j; \n for (i = 1; i <= n; i++) \n for (j = 1; j <= m; j++) \n negate(X(i,j), A(i,j)); \n} \n\n\n \nstatic\nvoid mul_aux(vec_zz_pE& x, const mat_zz_pE& A, const vec_zz_pE& b) \n{ \n long n = A.NumRows(); \n long l = A.NumCols(); \n \n if (l != b.length()) \n LogicError(\"matrix mul: dimension mismatch\"); \n \n x.SetLength(n); \n \n long i, k; \n zz_pX acc, tmp; \n \n for (i = 1; i <= n; i++) { \n clear(acc); \n for (k = 1; k <= l; k++) { \n mul(tmp, rep(A(i,k)), rep(b(k))); \n add(acc, acc, tmp); \n } \n conv(x(i), acc); \n } \n} \n \n \nvoid mul(vec_zz_pE& x, const mat_zz_pE& A, const vec_zz_pE& b) \n{ \n if (&b == &x || A.alias(x)) {\n vec_zz_pE tmp;\n mul_aux(tmp, A, b);\n x = tmp;\n }\n else\n mul_aux(x, A, b);\n} \n\nstatic\nvoid mul_aux(vec_zz_pE& x, const vec_zz_pE& a, const mat_zz_pE& B) \n{ \n long n = B.NumRows(); \n long l = B.NumCols(); \n \n if (n != a.length()) \n LogicError(\"matrix mul: dimension mismatch\"); \n \n x.SetLength(l); \n \n long i, k; \n zz_pX acc, tmp; \n \n for (i = 1; i <= l; i++) { \n clear(acc); \n for (k = 1; k <= n; k++) { \n mul(tmp, rep(a(k)), rep(B(k,i)));\n add(acc, acc, tmp); \n } \n conv(x(i), acc); \n } \n} \n\nvoid mul(vec_zz_pE& x, const vec_zz_pE& a, const mat_zz_pE& B)\n{\n if (&a == &x) {\n vec_zz_pE tmp;\n mul_aux(tmp, a, B);\n x = tmp;\n }\n else\n mul_aux(x, a, B);\n\n}\n\n \n \nvoid ident(mat_zz_pE& X, long n) \n{ \n X.SetDims(n, n); \n long i, j; \n \n for (i = 1; i <= n; i++) \n for (j = 1; j <= n; j++) \n if (i == j) \n set(X(i, j)); \n else \n clear(X(i, j)); \n} \n\n\n\nlong IsIdent(const mat_zz_pE& A, long n)\n{\n if (A.NumRows() != n || A.NumCols() != n)\n return 0;\n\n long i, j;\n\n for (i = 1; i <= n; i++)\n for (j = 1; j <= n; j++)\n if (i != j) {\n if (!IsZero(A(i, j))) return 0;\n }\n else {\n if (!IsOne(A(i, j))) return 0;\n }\n\n return 1;\n}\n \n\nvoid transpose(mat_zz_pE& X, const mat_zz_pE& A)\n{\n long n = A.NumRows();\n long m = A.NumCols();\n\n long i, j;\n\n if (&X == & A) {\n if (n == m)\n for (i = 1; i <= n; i++)\n for (j = i+1; j <= n; j++)\n swap(X(i, j), X(j, i));\n else {\n mat_zz_pE tmp;\n tmp.SetDims(m, n);\n for (i = 1; i <= n; i++)\n for (j = 1; j <= m; j++)\n tmp(j, i) = A(i, j);\n X.kill();\n X = tmp;\n }\n }\n else {\n X.SetDims(m, n);\n for (i = 1; i <= n; i++)\n for (j = 1; j <= m; j++)\n X(j, i) = A(i, j);\n }\n}\n \n\n \nvoid mul(mat_zz_pE& X, const mat_zz_pE& A, const zz_pE& b_in)\n{\n zz_pE b = b_in;\n long n = A.NumRows();\n long m = A.NumCols();\n\n X.SetDims(n, m);\n\n long i, j;\n for (i = 0; i < n; i++)\n for (j = 0; j < m; j++)\n mul(X[i][j], A[i][j], b);\n}\n\nvoid mul(mat_zz_pE& X, const mat_zz_pE& A, const zz_p& b_in)\n{\n NTL_zz_pRegister(b);\n b = b_in;\n long n = A.NumRows();\n long m = A.NumCols();\n\n X.SetDims(n, m);\n\n long i, j;\n for (i = 0; i < n; i++)\n for (j = 0; j < m; j++)\n mul(X[i][j], A[i][j], b);\n}\n\nvoid mul(mat_zz_pE& X, const mat_zz_pE& A, long b_in)\n{\n NTL_zz_pRegister(b);\n b = b_in;\n long n = A.NumRows();\n long m = A.NumCols();\n\n X.SetDims(n, m);\n\n long i, j;\n for (i = 0; i < n; i++)\n for (j = 0; j < m; j++)\n mul(X[i][j], A[i][j], b);\n}\n\nvoid diag(mat_zz_pE& X, long n, const zz_pE& d_in) \n{ \n zz_pE d = d_in;\n X.SetDims(n, n); \n long i, j; \n \n for (i = 1; i <= n; i++) \n for (j = 1; j <= n; j++) \n if (i == j) \n X(i, j) = d; \n else \n clear(X(i, j)); \n} \n\nlong IsDiag(const mat_zz_pE& A, long n, const zz_pE& d)\n{\n if (A.NumRows() != n || A.NumCols() != n)\n return 0;\n\n long i, j;\n\n for (i = 1; i <= n; i++)\n for (j = 1; j <= n; j++)\n if (i != j) {\n if (!IsZero(A(i, j))) return 0;\n }\n else {\n if (A(i, j) != d) return 0;\n }\n\n return 1;\n}\n\n\nlong IsZero(const mat_zz_pE& a)\n{\n long n = a.NumRows();\n long i;\n\n for (i = 0; i < n; i++)\n if (!IsZero(a[i]))\n return 0;\n\n return 1;\n}\n\nvoid clear(mat_zz_pE& x)\n{\n long n = x.NumRows();\n long i;\n for (i = 0; i < n; i++)\n clear(x[i]);\n}\n\n\nmat_zz_pE operator+(const mat_zz_pE& a, const mat_zz_pE& b)\n{\n mat_zz_pE res;\n add(res, a, b);\n NTL_OPT_RETURN(mat_zz_pE, res);\n}\n\nmat_zz_pE operator*(const mat_zz_pE& a, const mat_zz_pE& b)\n{\n mat_zz_pE res;\n mul_aux(res, a, b);\n NTL_OPT_RETURN(mat_zz_pE, res);\n}\n\nmat_zz_pE operator-(const mat_zz_pE& a, const mat_zz_pE& b)\n{\n mat_zz_pE res;\n sub(res, a, b);\n NTL_OPT_RETURN(mat_zz_pE, res);\n}\n\n\nmat_zz_pE operator-(const mat_zz_pE& a)\n{\n mat_zz_pE res;\n negate(res, a);\n NTL_OPT_RETURN(mat_zz_pE, res);\n}\n\n\nvec_zz_pE operator*(const mat_zz_pE& a, const vec_zz_pE& b)\n{\n vec_zz_pE res;\n mul_aux(res, a, b);\n NTL_OPT_RETURN(vec_zz_pE, res);\n}\n\nvec_zz_pE operator*(const vec_zz_pE& a, const mat_zz_pE& b)\n{\n vec_zz_pE res;\n mul_aux(res, a, b);\n NTL_OPT_RETURN(vec_zz_pE, res);\n}\n\nvoid inv(mat_zz_pE& X, const mat_zz_pE& A)\n{\n zz_pE d;\n inv(d, X, A);\n if (d == 0) ArithmeticError(\"inv: non-invertible matrix\");\n}\n\nvoid power(mat_zz_pE& X, const mat_zz_pE& A, const ZZ& e)\n{\n if (A.NumRows() != A.NumCols()) LogicError(\"power: non-square matrix\");\n\n if (e == 0) {\n ident(X, A.NumRows());\n return;\n }\n\n mat_zz_pE T1, T2;\n long i, k;\n\n k = NumBits(e);\n T1 = A;\n\n for (i = k-2; i >= 0; i--) {\n sqr(T2, T1);\n if (bit(e, i))\n mul(T1, T2, A);\n else\n T1 = T2;\n }\n\n if (e < 0)\n inv(X, T1);\n else\n X = T1;\n}\n\nvoid random(mat_zz_pE& x, long n, long m)\n{\n x.SetDims(n, m);\n for (long i = 0; i < n; i++) random(x[i], m);\n}\n\nNTL_END_IMPL\n", "meta": {"hexsha": "29fa07f38e290b4e6763a428189a6eb4f17b639a", "size": 19976, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "homomorphic_evaluation/ntl-11.3.2/src/mat_lzz_pE.cpp", "max_stars_repo_name": "dklee0501/PLDI_20_242_artifact_publication", "max_stars_repo_head_hexsha": "f2b73df9165c76e8b521d8ebd639d68321e3862b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 160.0, "max_stars_repo_stars_event_min_datetime": "2016-05-11T09:45:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-06T09:32:19.000Z", "max_issues_repo_path": "homomorphic_evaluation/ntl-11.3.2/src/mat_lzz_pE.cpp", "max_issues_repo_name": "dklee0501/Lobster", "max_issues_repo_head_hexsha": "f2b73df9165c76e8b521d8ebd639d68321e3862b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 57.0, "max_issues_repo_issues_event_min_datetime": "2016-12-26T07:02:12.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-06T16:34:31.000Z", "max_forks_repo_path": "LibSource/ExtendedNTL/src/mat_lzz_pE.cpp", "max_forks_repo_name": "ekzyis/CrypTool-2", "max_forks_repo_head_hexsha": "1af234b4f74486fbfeb3b3c49228cc36533a8c89", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 67.0, "max_forks_repo_forks_event_min_datetime": "2016-10-10T17:56:22.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-15T22:56:39.000Z", "avg_line_length": 18.9705603039, "max_line_length": 74, "alphanum_fraction": 0.4308169804, "num_tokens": 7039, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833945721304, "lm_q2_score": 0.7057850278370111, "lm_q1q2_score": 0.5466893627001777}} {"text": "//=======================================================================\n// Copyright (c) 2014 Andrzej Pacuk, Piotr Wygocki\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/**\n * @file lsh_functions.hpp\n * @brief\n * @author Andrzej Pacuk, Piotr Wygocki\n * @version 1.0\n * @date 2014-10-07\n */\n#ifndef PAAL_LSH_FUNCTIONS_HPP\n#define PAAL_LSH_FUNCTIONS_HPP\n\n#include \"paal/data_structures/ublas_traits.hpp\"\n#include \"paal/utils/functors.hpp\"\n#include \"paal/utils/type_functions.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#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace paal {\n\nnamespace lsh {\n\n/**\n * @brief simple hash function\n */\ntemplate \nclass projection_hash_function {\n IntType m_chosen_position;\n\npublic:\n ///serialize\n template\n void serialize(Archive & ar, const unsigned int version) {\n ar & m_chosen_position;\n }\n\n ///default constructor\n projection_hash_function() = default;\n\n /**\n * @brief constructor\n *\n * @param chosen_position\n *\n */\n projection_hash_function(IntType chosen_position) :\n m_chosen_position(chosen_position) {\n }\n\n ///operator==\n bool operator==(projection_hash_function const & other) const {\n return m_chosen_position == other.m_chosen_position;\n }\n\n /**\n * @brief operator()\n *\n * @tparam Range\n * @param range\n *\n * @return\n */\n template \n //TODO change to decltype(auto), when it starts working\n auto operator()(Range &&range) const ->\n range_to_elem_t {\n //TODO takes to long, use boost assert\n //assert(m_chosen_position < boost::size(range));\n return range[m_chosen_position];\n }\n};\n\n/**\n * @brief Factory class for projection_hash_function\n */\ntemplate \nclass random_projection_hash_function_generator {\n mutable RandomEngine m_generator;\n using distribution_t = std::uniform_int_distribution;\n mutable distribution_t m_distribution;\n\n static IntType convert_to_inclusive(IntType upper_bound) {\n assert(upper_bound > 0);\n return upper_bound - 1;\n }\n\npublic:\n /**\n * @brief constructor\n *\n * @param range_size\n * @param random_engine\n */\n random_projection_hash_function_generator(IntType range_size,\n RandomEngine random_engine = RandomEngine{}) :\n m_generator(std::move(random_engine)),\n m_distribution(0, convert_to_inclusive(range_size)) {\n }\n\n /**\n * @brief operator()\n *\n * @return new projection_hash_function\n */\n //TODO change to auto, when it starts working\n projection_hash_function operator()() const {\n return projection_hash_function(m_distribution(m_generator));\n }\n};\n\nusing hamming_hash_function_generator =\n random_projection_hash_function_generator<>;\n\n/**\n */\n/// hash_function for l_p distance for p in range (0,2]\ntemplate \nclass l_p_hash_function {\npublic:\n using r_param_t = boost::numeric::ublas::vector;\n\nprivate:\n r_param_t m_r;\n FloatType m_b;\n FloatType m_w;\n\npublic:\n\n ///serialize\n template\n void serialize(Archive & ar, const unsigned int version) {\n ar & m_r;\n ar & m_b;\n ar & m_w;\n }\n\n /**\n * @brief constructor\n *\n * @param r r elements has to be generated by p-stable distribution\n * @param b b is a random value from [0, w)\n * @param w w should be much greater than expected points neighborhood\n * radius\n */\n l_p_hash_function(r_param_t r,\n FloatType b, FloatType w) :\n m_r(std::move(r)), m_b(b), m_w(w) {\n }\n\n ///default constructor\n l_p_hash_function() = default;\n\n ///operator==\n bool operator==(l_p_hash_function const & other) const {\n return boost::equal(m_r, other.m_r) &&\n m_b == other.m_b &&\n m_w == other.m_w;\n }\n\n /**\n * @brief operator()\n *\n * @tparam Range\n * @param range Range modeling boost uBLAS VectorExpression concept\n *\n * @return\n */\n template \n auto operator()(Range &&range) const {\n //TODO use concept check with VectorExpressionConcept,\n //when it works\n\n //TODO takes to long, use boost assert\n //assert(boost::size(m_r) == boost::size(range));\n\n using boost::numeric::ublas::inner_prod;\n auto inner_product = inner_prod(m_r, range);\n return std::floor((m_b + inner_product) / m_w);\n }\n\n};\n\n/**\n * @brief Factory class for l_p_hash_function\n */\ntemplate >\nclass l_p_hash_function_generator {\n std::size_t m_range_size;\n FloatType m_w;\n mutable RandomEngine m_generator;\n mutable Distribution m_r_distribution;\n mutable std::uniform_real_distribution m_b_distribution;\n\npublic:\n /**\n * @brief constructor\n *\n * @param range_size\n * @param w\n * @param random_engine\n */\n l_p_hash_function_generator(std::size_t range_size,\n FloatType w,\n RandomEngine random_engine = RandomEngine{}) :\n m_range_size(range_size),\n m_w(w),\n m_generator(std::move(random_engine)),\n m_b_distribution(FloatType{}, w) {\n }\n\n /**\n * @brief operator()\n *\n * @return new l_p_hash_function\n */\n l_p_hash_function operator()() const {\n typename l_p_hash_function::r_param_t r(m_range_size);\n boost::generate(r, [&]() {\n return m_r_distribution(m_generator);\n });\n\n FloatType b = m_b_distribution(m_generator);\n return l_p_hash_function(std::move(r), b, m_w);\n }\n};\n\n/// Cauchy distribution is 1-stable\ntemplate \nusing l_1_hash_function_generator =\n l_p_hash_function_generator>;\n\n/// Gaussian distribution is 2-stable\ntemplate \nusing l_2_hash_function_generator =\n l_p_hash_function_generator;\n\n///min-wise independent permutations locality sensitive hashing (Jaccard)\nclass min_hash_function {\n //permutation\n std::vector m_perm;\n\npublic:\n\n ///serialize\n template\n void serialize(Archive & ar, const unsigned int version) {\n ar & m_perm;\n }\n\n ///constructor\n template \n min_hash_function(std::size_t set_element_upper_bound, RandomEngine && rng)\n : m_perm(set_element_upper_bound) {\n boost::iota(m_perm, 0);\n std::shuffle(m_perm.begin(), m_perm.end(), rng);\n }\n\n ///default constructor\n min_hash_function() = default;\n\n ///operator==\n bool operator==(min_hash_function const & other) const {\n return boost::equal(m_perm, other.m_perm);\n }\n\n /**\n * @brief operator()\n *\n * @tparam Range\n * @param range forward range modeling boost uBLAS sparse VectorExpression concept,\n * set is represented as set of indexes of range elements\n *\n * @return\n */\n template \n auto operator()(Range &&range) const {\n static_assert(data_structures::is_sparse_row::value, \"vector must be sparse\");\n using iter_t = typename boost::range_iterator::type;\n\n auto perm_function = [&](iter_t it) {\n auto set_elem = it.index();\n assert(set_elem < m_perm.size());\n return m_perm[set_elem];\n };\n auto perm_range =\n boost::counting_range(range)\n | boost::adaptors::transformed(utils::make_assignable_functor(perm_function));\n\n assert(!boost::empty(perm_range));\n return *boost::min_element(perm_range);\n }\n};\n\n///Factory class for min_hash_function\ntemplate \nclass min_hash_function_generator {\n std::size_t m_range_size;\n mutable RandomEngine m_generator;\n\npublic:\n ///constructor\n min_hash_function_generator(std::size_t range_size,\n RandomEngine random_engine = RandomEngine{}) :\n m_range_size(range_size),\n m_generator(std::move(random_engine)) { }\n\n ///operator()\n min_hash_function operator()() const {\n return min_hash_function(m_range_size, m_generator);\n }\n};\nusing jaccard_hash_function_generator =\n min_hash_function_generator<>;\n\n} //! lsh\n\n} //! paal\n\n#endif // PAAL_LSH_FUNCTIONS_HPP\n\n", "meta": {"hexsha": "8e6dd83952648c5e6a28a929dda05c0fecfa72ea", "size": 9839, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/paal/regression/lsh_functions.hpp", "max_stars_repo_name": "Kommeren/AA", "max_stars_repo_head_hexsha": "e537b58d50e93d4a72709821b9ea413008970c6b", "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": "include/paal/regression/lsh_functions.hpp", "max_issues_repo_name": "Kommeren/AA", "max_issues_repo_head_hexsha": "e537b58d50e93d4a72709821b9ea413008970c6b", "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": "include/paal/regression/lsh_functions.hpp", "max_forks_repo_name": "Kommeren/AA", "max_forks_repo_head_hexsha": "e537b58d50e93d4a72709821b9ea413008970c6b", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-02-24T06:23:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-24T06:23:56.000Z", "avg_line_length": 28.0313390313, "max_line_length": 94, "alphanum_fraction": 0.6458989735, "num_tokens": 2208, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833841649233, "lm_q2_score": 0.7057850340255387, "lm_q1q2_score": 0.5466893601484574}} {"text": "//==================================================================================================\n/*!\n @file\n @copyright 2015 NumScale SAS\n @copyright 2015 J.T. Lapreste\n\n Distributed under the Boost Software License, Version 1.0.\n (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)\n*/\n//==================================================================================================\n#ifndef BOOST_SIMD_ARCH_COMMON_FUNCTION_SCALAR_STIRLING_HPP_INCLUDED\n#define BOOST_SIMD_ARCH_COMMON_FUNCTION_SCALAR_STIRLING_HPP_INCLUDED\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#ifndef BOOST_SIMD_NO_INVALIDS\n#include \n#endif\n\nnamespace boost { namespace simd { namespace ext\n{\n namespace bd = boost::dispatch;\n namespace bs = boost::simd;\n BOOST_DISPATCH_OVERLOAD ( stirling_\n , (typename A0)\n , bd::cpu_\n , bd::scalar_< bd::floating_ >\n )\n {\n BOOST_FORCEINLINE A0 operator() (A0 a0) const BOOST_NOEXCEPT\n {\n const A0 Stirlinglargelim = Real();// 172, 35.0399895f\n const A0 Stirlingsplitlim = Real();// 143.01608, 26.77f\n #ifndef BOOST_SIMD_NO_INVALIDS\n if (is_nan(a0)) return a0;\n #endif\n if (a0 > Stirlinglargelim) return Inf();\n A0 w = rec(a0);\n w = fma(w,detail::stirling_kernel::stirling1(w), One());\n A0 y = exp(-a0);\n if(is_eqz(y)) return Inf();\n A0 z = a0 - Half();\n if( a0 >= Stirlingsplitlim )\n { /* Avoid overflow in pow() */\n const A0 v = pow(a0,z*Half());\n y *= v;\n y *= v;\n }\n else\n {\n y *= pow( a0, z );\n }\n y *= Sqrt_2pi()*w;\n return y;\n }\n };\n} } }\n\n\n#endif\n", "meta": {"hexsha": "052c95b52093685682e08a580540018720919ff6", "size": 2431, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/boost/simd/arch/common/scalar/function/stirling.hpp", "max_stars_repo_name": "yaeldarmon/boost.simd", "max_stars_repo_head_hexsha": "561316cc54bdc6353ca78f3b6d7e9120acd11144", "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": "include/boost/simd/arch/common/scalar/function/stirling.hpp", "max_issues_repo_name": "yaeldarmon/boost.simd", "max_issues_repo_head_hexsha": "561316cc54bdc6353ca78f3b6d7e9120acd11144", "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": "include/boost/simd/arch/common/scalar/function/stirling.hpp", "max_forks_repo_name": "yaeldarmon/boost.simd", "max_forks_repo_head_hexsha": "561316cc54bdc6353ca78f3b6d7e9120acd11144", "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": 33.7638888889, "max_line_length": 102, "alphanum_fraction": 0.5939942411, "num_tokens": 657, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8438950947024555, "lm_q2_score": 0.6477982315512488, "lm_q1q2_score": 0.5466737499630243}} {"text": "//==================================================================================================\n/*!\n @file\n @copyright 2016 NumScale SAS\n\n Distributed under the Boost Software License, Version 1.0.\n (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)\n*/\n//==================================================================================================\n#ifndef BOOST_SIMD_FUNCTION_ERF_HPP_INCLUDED\n#define BOOST_SIMD_FUNCTION_ERF_HPP_INCLUDED\n\n#if defined(DOXYGEN_ONLY)\nnamespace boost { namespace simd\n{\n\n /*!\n @ingroup group-euler\n Function object implementing erf capabilities\n\n Computes the error function:\n \\f$\\displaystyle \\frac{2}{\\sqrt\\pi}\\int_0^{x} e^{-t^2}\\mbox{d}t\\f$\n\n @par Semantic:\n\n For every parameter of floating type T\n\n @code\n T r = erf(x);\n @endcode\n\n @par Decorators\n\n std_ for floating entries provides access to @c std::erf\n\n @see erfc, erfcx\n\n **/\n Value erf(Value const & v0);\n} }\n#endif\n\n#include \n#include \n\n#endif\n", "meta": {"hexsha": "3df73c797e5bf3def802444a26e3a0fa47cc9d22", "size": 1085, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "third_party/boost/simd/function/erf.hpp", "max_stars_repo_name": "xmar/pythran", "max_stars_repo_head_hexsha": "dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2018-02-20T11:21:12.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-12T13:45:09.000Z", "max_issues_repo_path": "third_party/boost/simd/function/erf.hpp", "max_issues_repo_name": "xmar/pythran", "max_issues_repo_head_hexsha": "dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "third_party/boost/simd/function/erf.hpp", "max_forks_repo_name": "xmar/pythran", "max_forks_repo_head_hexsha": "dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2017-12-12T12:29:52.000Z", "max_forks_repo_forks_event_max_datetime": "2019-04-08T15:55:25.000Z", "avg_line_length": 23.085106383, "max_line_length": 100, "alphanum_fraction": 0.5732718894, "num_tokens": 254, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8438950947024555, "lm_q2_score": 0.6477982247516797, "lm_q1q2_score": 0.5466737442249013}} {"text": "\n// (C) Copyright John Maddock 2006.\n// Use, modification and distribution are subject to the\n// Boost Software License, Version 1.0. (See accompanying file\n// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n\n#ifndef BOOST_MATH_SPECIAL_LAGUERRE_HPP\n#define BOOST_MATH_SPECIAL_LAGUERRE_HPP\n\n#ifdef _MSC_VER\n#pragma once\n#endif\n\n#include \n#include \n#include \n\nnamespace boost{\nnamespace math{\n\n// Recurrance relation for Laguerre polynomials:\ntemplate \ninline typename tools::promote_args::type\n laguerre_next(unsigned n, T1 x, T2 Ln, T3 Lnm1)\n{\n typedef typename tools::promote_args::type result_type;\n return ((2 * n + 1 - result_type(x)) * result_type(Ln) - n * result_type(Lnm1)) / (n + 1);\n}\n\nnamespace detail{\n\n// Implement Laguerre polynomials via recurrance:\ntemplate \nT laguerre_imp(unsigned n, T x)\n{\n T p0 = 1;\n T p1 = 1 - x;\n\n if(n == 0)\n return p0;\n\n unsigned c = 1;\n\n while(c < n)\n {\n std::swap(p0, p1);\n p1 = laguerre_next(c, x, p0, p1);\n ++c;\n }\n return p1;\n}\n\ntemplate \ninline typename tools::promote_args::type\nlaguerre(unsigned n, T x, const Policy&, const mpl::true_&)\n{\n typedef typename tools::promote_args::type result_type;\n typedef typename policies::evaluation::type value_type;\n return policies::checked_narrowing_cast(detail::laguerre_imp(n, static_cast(x)), \"boost::math::laguerre<%1%>(unsigned, %1%)\");\n}\n\ntemplate \ninline typename tools::promote_args::type\n laguerre(unsigned n, unsigned m, T x, const mpl::false_&)\n{\n return boost::math::laguerre(n, m, x, policies::policy<>());\n}\n\n} // namespace detail\n\ntemplate \ninline typename tools::promote_args::type\n laguerre(unsigned n, T x)\n{\n return laguerre(n, x, policies::policy<>());\n}\n\n// Recurrence for associated polynomials:\ntemplate \ninline typename tools::promote_args::type\n laguerre_next(unsigned n, unsigned l, T1 x, T2 Pl, T3 Plm1)\n{\n typedef typename tools::promote_args::type result_type;\n return ((2 * n + l + 1 - result_type(x)) * result_type(Pl) - (n + l) * result_type(Plm1)) / (n+1);\n}\n\nnamespace detail{\n// Laguerre Associated Polynomial:\ntemplate \nT laguerre_imp(unsigned n, unsigned m, T x, const Policy& pol)\n{\n // Special cases:\n if(m == 0)\n return boost::math::laguerre(n, x, pol);\n\n T p0 = 1;\n\n if(n == 0)\n return p0;\n\n T p1 = m + 1 - x;\n\n unsigned c = 1;\n\n while(c < n)\n {\n std::swap(p0, p1);\n p1 = laguerre_next(c, m, x, p0, p1);\n ++c;\n }\n return p1;\n}\n\n}\n\ntemplate \ninline typename tools::promote_args::type\n laguerre(unsigned n, unsigned m, T x, const Policy& pol)\n{\n typedef typename tools::promote_args::type result_type;\n typedef typename policies::evaluation::type value_type;\n return policies::checked_narrowing_cast(detail::laguerre_imp(n, m, static_cast(x), pol), \"boost::math::laguerre<%1%>(unsigned, unsigned, %1%)\");\n}\n\ntemplate \ninline typename laguerre_result::type\n laguerre(unsigned n, T1 m, T2 x)\n{\n typedef typename policies::is_policy::type tag_type;\n return detail::laguerre(n, m, x, tag_type());\n}\n\n} // namespace math\n} // namespace boost\n\n#endif // BOOST_MATH_SPECIAL_LAGUERRE_HPP\n", "meta": {"hexsha": "44211f6a8392751a293d3419823d631f7fc97bd1", "size": 3624, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "deps/src/boost_1_65_1/boost/math/special_functions/laguerre.hpp", "max_stars_repo_name": "shreyasvj25/turicreate", "max_stars_repo_head_hexsha": "32e84ca16aef8d04aff3d49ae9984bd49326bffd", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 11356.0, "max_stars_repo_stars_event_min_datetime": "2017-12-08T19:42:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T16:55:25.000Z", "max_issues_repo_path": "deps/src/boost_1_65_1/boost/math/special_functions/laguerre.hpp", "max_issues_repo_name": "shreyasvj25/turicreate", "max_issues_repo_head_hexsha": "32e84ca16aef8d04aff3d49ae9984bd49326bffd", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2402.0, "max_issues_repo_issues_event_min_datetime": "2017-12-08T22:31:01.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-28T19:25:52.000Z", "max_forks_repo_path": "deps/src/boost_1_65_1/boost/math/special_functions/laguerre.hpp", "max_forks_repo_name": "shreyasvj25/turicreate", "max_forks_repo_head_hexsha": "32e84ca16aef8d04aff3d49ae9984bd49326bffd", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1343.0, "max_forks_repo_forks_event_min_datetime": "2017-12-08T19:47:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-26T11:31:36.000Z", "avg_line_length": 26.4525547445, "max_line_length": 180, "alphanum_fraction": 0.6854304636, "num_tokens": 1101, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7853085909370422, "lm_q2_score": 0.6959583313396339, "lm_q1q2_score": 0.546542056535223}} {"text": "// cfiles, an analysis frontend for the Chemfiles library\n// Copyright (C) Guillaume Fraux and contributors -- BSD license\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \"Elastic.hpp\"\n#include \"Errors.hpp\"\n\nusing namespace chemfiles;\n\nusing Matrix6 = Eigen::Matrix;\n\nstatic size_t CARTESIAN_TO_VOIGT[][2] = {\n {0, 0}, {1, 1}, {2, 2}, {1, 2}, {0, 2}, {0, 1},\n};\n\nstatic const std::string OPTIONS =\nR\"(Compute the elastic tensor of a system from the unit cell fluctuations during\na NPT simulation.\n\nThe values given here are highly dependent on having good statistic during the\nsimulation: both in term of having a long enough simulation time to get to the\nequilibrium, and using a good barostat that does produce isobaric-isothermal\nensemble fluctuations (not just average). The theory behind this code is\ndescribed in https://dx.doi.org/10.1080/08927022.2017.1313418.\n\nUsage:\n cfiles elastic [options] \n cfiles elastic (-h | --help)\n\nExamples:\n cfiles elastic -t 328 -o elastic.dat trajectory.pdb\n\nOptions:\n -h --help show this help\n --format= force the input file format to be \n -t , --temperature= temperature of the simulation, in kelvin\n -o , --output= write result to . This default to the\n trajectory file name with the `.angles.dat`\n extension.\n --steps= steps to use from the input. format\n is :[:] with ,\n and optional. The used steps\n goes from to (excluded) by\n steps of . The default values are 0\n for , the number of steps for \n and 1 for .\n)\";\n\n\nstatic Elastic::Options parse_options(int argc, const char* argv[]) {\n auto options_str = command_header(\"elastic\", Elastic().description());\n options_str += \"Guillaume Fraux \\n\\n\";\n options_str += std::string(OPTIONS);\n auto args = docopt::docopt(options_str, {argv, argv + argc}, true, \"\");\n\n Elastic::Options options;\n options.trajectory = args.at(\"\").asString();\n\n if (args[\"--temperature\"]) {\n options.temperature = string2double(args.at(\"--temperature\").asString());\n } else {\n throw CFilesError(\"missing --temperature argument\");\n }\n\n if (args.at(\"--steps\")) {\n options.steps = steps_range::parse(args.at(\"--steps\").asString());\n }\n\n if (args[\"--output\"]) {\n options.outfile = args.at(\"--output\").asString();\n } else {\n options.outfile = options.trajectory + \".elastic.dat\";\n }\n\n return options;\n}\n\nstd::string Elastic::description() const {\n return \"compute elastic constants from unit cell fluctuations in NPT\";\n}\n\nint Elastic::run(int argc, const char* argv[]) {\n auto options = parse_options(argc, argv);\n auto cells = std::vector();\n\n auto trajectory = Trajectory(options.trajectory, 'r', options.format);\n for (auto step: options.steps) {\n if (step >= trajectory.nsteps()) {\n break;\n }\n auto frame = trajectory.read_step(step);\n cells.emplace_back(frame.cell().matrix());\n }\n\n // Use the avrerage as the reference state\n auto reference = Matrix3D::zero();\n for (auto& cell: cells) {\n reference += cell.invert();\n }\n reference /= cells.size();\n auto reference_t = reference.transpose();\n\n auto epsilons = std::vector();\n epsilons.reserve(cells.size());\n for (auto& cell: cells) {\n epsilons.emplace_back(0.5 * (reference_t * cell.transpose() * cell * reference - Matrix3D::unit()));\n }\n\n // in GPa A^2 / K\n auto BOLTZMANN = 1.38065e-2;\n auto volume_inv = reference.determinant();\n auto v_kt = 1.0 / (volume_inv * BOLTZMANN * options.temperature);\n auto compute = [&](size_t ij[2], size_t kl[2]) {\n auto i = ij[0];\n auto j = ij[1];\n auto k = kl[0];\n auto l = kl[1];\n\n // Multiplicative factors for cross terms yz xz xy\n double factor = 1.0;\n if (i != j) {\n factor *= 2;\n }\n if (k != l) {\n factor *= 2;\n }\n\n double eij = 0;\n double ekl = 0;\n double eij_ekl = 0;\n for (auto& epsilon: epsilons) {\n eij += epsilon[i][j];\n ekl += epsilon[k][l];\n eij_ekl += epsilon[i][j] * epsilon[k][l];\n }\n eij /= epsilons.size();\n ekl /= epsilons.size();\n eij_ekl /= epsilons.size();\n\n return factor * v_kt * (eij_ekl - eij * ekl);\n };\n\n auto SVoigt = Matrix6();\n for (size_t i=0; i<6; i++) {\n for (size_t j=0; j<=i; j++) {\n SVoigt(i, j) = compute(CARTESIAN_TO_VOIGT[i], CARTESIAN_TO_VOIGT[j]);\n }\n }\n // Make the matrix symetric\n for (size_t i=0; i<6; i++) {\n for (size_t j=i+1; j<6; j++) {\n SVoigt(i, j) = SVoigt(j, i);\n }\n }\n\n if (std::abs(SVoigt.determinant()) < 100 * DBL_EPSILON) {\n throw CFilesError(\"the compliance matrix is not invertible\");\n }\n\n auto CVoigt = SVoigt.inverse();\n std::ofstream outfile(options.outfile, std::ios::out);\n if (!outfile.is_open()) {\n throw CFilesError(\"Could not open the '\" + options.outfile + \"' file.\");\n }\n\n fmt::print(outfile, \"# stiffness tensor in GPa from {}\\n\", options.trajectory);\n for (size_t i=0; i<6; i++) {\n for (size_t j=0; j<6; j++) {\n if (j != 0) {\n fmt::print(outfile, \" \");\n }\n if (j >= i) {\n fmt::print(outfile, \"{:12.5f}\", CVoigt(i, j));\n } else {\n fmt::print(outfile, \" \");\n }\n }\n fmt::print(outfile, \"\\n\");\n }\n\n auto eigenvalues = CVoigt.eigenvalues();\n auto sorter = [](std::complex i, std::complex j) {\n return std::abs(i) < std::abs(j);\n };\n std::sort(eigenvalues.data(), eigenvalues.data() + eigenvalues.size(), sorter);\n fmt::print(outfile, \"# eigen values of the stiffness tensor (GPa)\\n\");\n for (size_t i=0; i<6; i++) {\n auto& value = eigenvalues(i);\n if (value.imag() == 0) {\n fmt::print(outfile, \"{:12.5f}\\n\", value.real());\n } else {\n fmt::print(outfile, \"{:12.5f} + {:12.5f}i\\n\", value.real(), value.imag());\n }\n }\n\n double A = (CVoigt(0, 0) + CVoigt(1, 1) + CVoigt(2, 2)) / 3.0;\n double B = (CVoigt(1, 2) + CVoigt(0, 2) + CVoigt(0, 1)) / 3.0;\n double C = (CVoigt(3, 3) + CVoigt(4, 4) + CVoigt(5, 5)) / 3.0;\n\n double a = (SVoigt(0, 0) + SVoigt(1, 1) + SVoigt(2, 2)) / 3.0;\n double b = (SVoigt(1, 2) + SVoigt(0, 2) + SVoigt(0, 1)) / 3.0;\n double c = (SVoigt(3, 3) + SVoigt(4, 4) + SVoigt(5, 5)) / 3.0;\n\n double KV = (A + 2.0 * B) / 3.0;\n double GV = (A - B + 3.0 * C) / 5.0;\n double YV = 1.0 / (1.0 / (3.0 * GV) + 1.0 / (9.0 * KV));\n double PV = (1.0 - 3.0 * GV / (3.0 * KV + GV)) / 2.0;\n\n double KR = 1.0 / (3.0 * a + 6.0 * b);\n double GR = 5.0 / (4.0 * a - 4.0 * b + 3.0 * c);\n double YR = 1.0 / (1.0 / (3.0 * GR) + 1.0 / (9.0 * KR));\n double PR = (1.0 - 3.0 * GR / (3.0 * KR + GR)) / 2.0;\n\n double KH = (KV + KR) / 2.0;\n double GH = (GV + GR) / 2.0;\n double YH = 1.0 / (1.0 / (3.0 * GH) + 1.0 / (9.0 * KH));\n double PH = (1.0 - 3.0 * GH / (3.0 * KH + GH)) / 2.0;\n\n fmt::print(outfile, \"# Bulk modulus (GPa) | Young's modulus (GPa) | Shear modulus (GPa) | Poisson's ratio\\n\");\n fmt::print(outfile, \"# Voigt averaging\\n\");\n fmt::print(outfile, \"{:12.5f} {:12.5f} {:12.5f} {:12.5f}\\n\", KV, YV, GV, PV);\n fmt::print(outfile, \"# Reuss averaging\\n\");\n fmt::print(outfile, \"{:12.5f} {:12.5f} {:12.5f} {:12.5f}\\n\", KR, YR, GR, PR);\n fmt::print(outfile, \"# Hill averaging\\n\");\n fmt::print(outfile, \"{:12.5f} {:12.5f} {:12.5f} {:12.5f}\\n\", KH, YH, GH, PH);\n\n return 0;\n}\n", "meta": {"hexsha": "84c12d15470fcfa71bd6554f2c1fb2b7f043ccad", "size": 8263, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/commands/Elastic.cpp", "max_stars_repo_name": "Luthaf/chrp", "max_stars_repo_head_hexsha": "73c4aa76bc8e7154001fad819a2ad5a0b2663a60", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 9.0, "max_stars_repo_stars_event_min_datetime": "2015-12-03T20:32:41.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-16T16:32:49.000Z", "max_issues_repo_path": "src/commands/Elastic.cpp", "max_issues_repo_name": "Luthaf/chrp", "max_issues_repo_head_hexsha": "73c4aa76bc8e7154001fad819a2ad5a0b2663a60", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 39.0, "max_issues_repo_issues_event_min_datetime": "2016-03-04T14:25:16.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-22T16:48:42.000Z", "max_forks_repo_path": "src/commands/Elastic.cpp", "max_forks_repo_name": "Luthaf/chrp", "max_forks_repo_head_hexsha": "73c4aa76bc8e7154001fad819a2ad5a0b2663a60", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2016-03-07T20:42:35.000Z", "max_forks_repo_forks_event_max_datetime": "2019-01-23T06:50:40.000Z", "avg_line_length": 35.0127118644, "max_line_length": 114, "alphanum_fraction": 0.5425390294, "num_tokens": 2539, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.785308580887758, "lm_q2_score": 0.6959583313396339, "lm_q1q2_score": 0.54654204954134}} {"text": "// smooth: Lie Theory for Robotics\n// https://github.com/pettni/smooth\n//\n// Licensed under the MIT License .\n//\n// Copyright (c) 2021 Petter Nilsson\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\n#ifndef INTERP__BSPLINE_HPP_\n#define INTERP__BSPLINE_HPP_\n\n/**\n * @file\n * @brief B-splines on Lie groups.\n */\n\n#include \n\n#include \n\n#include \"smooth/concepts.hpp\"\n#include \"smooth/internal/utils.hpp\"\n#include \"smooth/manifold_vector.hpp\"\n#include \"smooth/optim.hpp\"\n\n#include \"common.hpp\"\n\nnamespace smooth {\n\n/**\n * @brief Cardinal Bspline on a Lie group\n *\n * The curve is defined by\n * \\f[\n * g(t) = g_0 * \\exp(\\tilde B_1(t) v_1) * ... \\exp(\\tilde B_N(t) v_N)\n * \\f]\n * where \\f$\\tilde B_i(t)\\f$ are cumulative Bspline basis functions and\n * \\f$v_i = g_i \\ominus g_{i-1}\\f$ are the control point differences.\n * The control points - knot time correspondence is as follows\n *\n \\verbatim\n KNOT -K -K+1 -K+2 ... 0 1 ... N-K\n CTRL 0 1 2 ... K K+1 N\n ^ ^\n t_min t_max\n \\endverbatim\n *\n * The first K ctrl_pts are exterior points and are outside\n * the support of the spline, which means that the spline is defined on\n * \\f$ [t_{min}, t_{max}] = [t0, (N-K)*dt] \\f$.\n *\n * For interpolation purposes use an odd spline degree and set\n \\verbatim\n t0 = (timestamp of first control point) + dt*(K-1)/2\n \\endverbatim\n * which aligns control points with the maximum of the corresponding\n * basis function.\n */\ntemplate\nclass BSpline\n{\npublic:\n /**\n * @brief Construct a constant bspline defined on [0, 1) equal to identity.\n */\n BSpline() : t0_(0), dt_(1), ctrl_pts_(K + 1, G::Identity()) {}\n\n /**\n * @brief Create a BSpline\n * @param t0 start of spline\n * @param dt distance between spline knots\n * @param ctrl_pts spline control points\n */\n BSpline(double t0, double dt, std::vector> && ctrl_pts)\n : t0_(t0), dt_(dt), ctrl_pts_(std::move(ctrl_pts))\n {}\n\n /**\n * @brief Create a BSpline\n * @tparam R range type\n * @param t0 start of spline\n * @param dt distance between spline knots\n * @param ctrl_pts spline control points\n */\n template\n BSpline(double t0, double dt, const R & ctrl_pts)\n : t0_(t0), dt_(dt), ctrl_pts_(std::ranges::begin(ctrl_pts), std::ranges::end(ctrl_pts))\n {}\n\n /// @brief Copy constructor\n BSpline(const BSpline &) = default;\n /// @brief Move constructor\n BSpline(BSpline &&) = default;\n /// @brief Copy assignment\n BSpline & operator=(const BSpline &) = default;\n /// @brief Move assignment\n BSpline & operator=(BSpline &&) = default;\n /// @brief Descructor\n ~BSpline() = default;\n\n /**\n * @brief Distance between knots\n */\n double dt() const { return dt_; }\n\n /**\n * @brief Minimal time for which spline is defined.\n */\n double t_min() const { return t0_; }\n\n /**\n * @brief Maximal time for which spline is defined.\n */\n double t_max() const { return t0_ + (ctrl_pts_.size() - K) * dt_; }\n\n /**\n * @brief Access spline control points.\n */\n const std::vector> & ctrl_pts() const { return ctrl_pts_; }\n\n /**\n * @brief Evaluate Bspline.\n *\n * @param[in] t time point to evaluate at\n * @param[out] vel output body velocity at evaluation time\n * @param[out] acc output body acceleration at evaluation time\n * @return spline value at time t\n *\n * @note Input \\p t is clamped to spline interval of definition\n */\n G eval(double t, detail::OptTangent vel = {}, detail::OptTangent acc = {}) const\n {\n // index of relevant interval\n int64_t istar = static_cast((t - t0_) / dt_);\n\n double u;\n // clamp to end of range if necessary\n if (istar < 0) {\n istar = 0;\n u = 0;\n } else if (istar + K + 1 > ctrl_pts_.size()) {\n istar = ctrl_pts_.size() - K - 1;\n u = 1;\n } else {\n u = (t - t0_ - istar * dt_) / dt_;\n }\n\n constexpr auto Mstatic = detail::cum_coefmat().transpose();\n Eigen::Map> M(Mstatic[0].data());\n\n G g = cspline_eval(\n ctrl_pts_ | std::views::drop(istar) | std::views::take(K + 1), M, u, vel, acc);\n\n if (vel.has_value()) { vel.value() /= dt_; }\n if (acc.has_value()) { acc.value() /= (dt_ * dt_); }\n\n return g;\n }\n\nprivate:\n double t0_, dt_;\n std::vector> ctrl_pts_;\n};\n\n/**\n * @brief Fit a bpsline to data points \\f$(t_i, g_i)\\f$\n * by solving the optimization problem\n *\n * \\f[\n * \\min_{p} \\left\\| p(t_i) - g_i \\right\\|^2\n * \\f]\n *\n * @tparam K bspline degree\n * @tparam Rt, Rg input range types\n * @param tt time values t_i (doubles, non-decreasing)\n * @param gg data values t_i\n * @param dt distance between spline control points\n */\ntemplate\nBSpline> fit_bspline(const Rt & tt, const Rg & gg, double dt)\n{\n static_assert(LieGroup>, \"Rg value type is LieGroup\");\n static_assert(std::is_same_v, double>, \"Rt value type is double\");\n\n using G = std::ranges::range_value_t;\n\n auto [tmin_ptr, tmax_ptr] = std::minmax_element(std::ranges::begin(tt), std::ranges::end(tt));\n\n const double t0 = *tmin_ptr;\n const double t1 = *tmax_ptr;\n\n const std::size_t NumData = std::min(std::ranges::size(tt), std::ranges::size(gg));\n const std::size_t NumPts = K + static_cast((t1 - t0 + dt) / dt);\n\n constexpr auto Mstatic = detail::cum_coefmat().transpose();\n Eigen::Map> M(Mstatic[0].data());\n\n auto f = [&](const auto & var) {\n Eigen::VectorXd ret(G::Dof * NumData);\n\n Eigen::SparseMatrix Jac;\n Jac.resize(G::Dof * NumData, G::Dof * NumPts);\n Jac.reserve(Eigen::Matrix::Constant(G::Dof * NumData, G::Dof * (K + 1)));\n\n auto t_iter = std::ranges::begin(tt);\n auto g_iter = std::ranges::begin(gg);\n\n for (auto i = 0u; i != NumData; ++t_iter, ++g_iter, ++i) {\n const int64_t istar = static_cast((*t_iter - t0) / dt);\n const double u = (*t_iter - t0 - istar * dt) / dt;\n\n Eigen::Matrix d_vali_pts;\n auto g_spline = cspline_eval(\n var | std::views::drop(istar) | std::views::take(K + 1), M, u, {}, {}, d_vali_pts);\n\n const typename G::Tangent resi = g_spline - *g_iter;\n\n ret.segment(i * G::Dof) = resi;\n\n const Eigen::Matrix d_resi_vali = G::dr_expinv(resi);\n const Eigen::Matrix d_resi_pts = d_resi_vali * d_vali_pts;\n\n for (auto r = 0u; r != G::Dof; ++r) {\n for (auto c = 0u; c != G::Dof * (K + 1); ++c) {\n Jac.insert(i * G::Dof + r, istar * G::Dof + c) = d_resi_pts(r, c);\n }\n }\n }\n\n Jac.makeCompressed();\n\n return std::make_pair(std::move(ret), Eigen::MatrixXd(Jac));\n };\n\n // create optimization variable\n ManifoldVector ctrl_pts(NumPts);\n\n // create initial guess\n auto t_iter = std::ranges::begin(tt);\n auto g_iter = std::ranges::begin(gg);\n for (auto i = 0u; i != NumPts; ++i) {\n const double t_target = t0 + (i - static_cast(K - 1) / 2) * dt;\n while (t_iter + 1 < std::ranges::end(tt)\n && std::abs(t_target - *(t_iter + 1)) < std::abs(t_target - *t_iter)) {\n ++t_iter;\n ++g_iter;\n }\n ctrl_pts[i] = *g_iter;\n }\n\n // fit to data with loose convergence criteria\n MinimizeOptions opts;\n opts.ftol = 1e-3;\n opts.ptol = 1e-3;\n opts.max_iter = 10;\n minimize(f, smooth::wrt(ctrl_pts), opts);\n\n return BSpline(t0, dt, std::move(ctrl_pts));\n}\n\n} // namespace smooth\n\n#endif // INTERP__BSPLINE_HPP_\n", "meta": {"hexsha": "e3db6a5745fb69e6cb87024ea302da1e518464e2", "size": 9131, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/smooth/spline/bspline.hpp", "max_stars_repo_name": "NamDinhRobotics/smooth", "max_stars_repo_head_hexsha": "137008de5d68af459db2c7802e05cdabd166c424", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-11-29T10:28:18.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-29T10:28:18.000Z", "max_issues_repo_path": "include/smooth/spline/bspline.hpp", "max_issues_repo_name": "NamDinhRobotics/smooth", "max_issues_repo_head_hexsha": "137008de5d68af459db2c7802e05cdabd166c424", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/smooth/spline/bspline.hpp", "max_forks_repo_name": "NamDinhRobotics/smooth", "max_forks_repo_head_hexsha": "137008de5d68af459db2c7802e05cdabd166c424", "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.4946619217, "max_line_length": 99, "alphanum_fraction": 0.6316942285, "num_tokens": 2730, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920116079209, "lm_q2_score": 0.6825737408694988, "lm_q1q2_score": 0.5465313416475428}} {"text": "/** \\file cmr_time_stamp.h\n \\brief Implement functionalities to handle cardiac time stamps\n \\author Hui Xue\n*/\n\n#include \"cmr_time_stamp.h\"\n#include \"hoNDArray_reductions.h\"\n#include \"hoNDArray_elemwise.h\"\n#include \n\nnamespace Gadgetron { \n\n template \n void simple_line_fit(const std::vector& x, const std::vector& y, T& a, T& b)\n {\n try\n {\n size_t num = x.size();\n\n if(num<2)\n {\n a = 0;\n b = 0;\n return;\n }\n\n T sx(0), sy(0);\n\n size_t n;\n for (n=0; n 0 ? syy : boost::math::sign(syy)*FLT_EPSILON);\n b /= syy;\n a = (sy - sx*b) / (T)(num);\n }\n catch(...)\n {\n GADGET_THROW(\"Exceptions happened in simple_line_fit ... \");\n }\n }\n\n void correct_time_stamp_with_fitting(hoNDArray& time_stamp, size_t startE1, size_t endE1)\n {\n try\n {\n size_t E1 = time_stamp.get_size(0);\n size_t N = time_stamp.get_size(1);\n size_t rE1 = endE1 - startE1 + 1;\n\n size_t e1, n;\n\n size_t num_acq_read_outs = 0;\n for ( n=0; n 0 )\n {\n num_acq_read_outs++;\n }\n }\n }\n\n GDEBUG_STREAM(\" Number of acquired lines : \" << num_acq_read_outs);\n\n float a, b; // y = a + b*x\n {\n std::vector x(num_acq_read_outs), y(num_acq_read_outs);\n\n size_t ind = 0;\n for ( n=0; n 0 )\n {\n x[ind] = (float)(e1-startE1 + n*rE1);\n y[ind] = acq_time;\n ind++;\n }\n }\n }\n\n Gadgetron::simple_line_fit(x, y, a, b);\n }\n\n for ( n=0; n& cpt_time_stamp, hoNDArray& ind_hb, \n std::vector& start_e1_hb, std::vector& end_e1_hb, \n std::vector& start_n_hb, std::vector& end_n_hb )\n {\n try\n {\n size_t E1 = cpt_time_stamp.get_size(0);\n size_t N = cpt_time_stamp.get_size(1);\n\n size_t e1, n, ind, ii;\n\n size_t num_acq_read_outs = 0;\n for ( n=0; n= 0 )\n {\n num_acq_read_outs++;\n }\n }\n }\n\n ind_hb.create(E1, N);\n Gadgetron::clear(ind_hb);\n\n // --------------------------------------------------------\n // cpt time stamps\n // --------------------------------------------------------\n\n std::vector acquired_cpt(num_acq_read_outs);\n std::vector ind_acquired_cpt(num_acq_read_outs);\n\n ind = 0;\n for ( n=0; n -1 )\n {\n acquired_cpt[ind] = cpt_time_stamp(e1, n);\n ind_acquired_cpt[ind] = e1 + n*E1;\n ind++;\n }\n }\n }\n\n // --------------------------------------------------------\n // find the number of heart beats\n // --------------------------------------------------------\n size_t numOfHB = 0;\n\n // store the line indexes for every heart beat\n std::vector ind_HB_start, ind_HB_end;\n ind_HB_start.push_back(0);\n\n for ( ind=1; ind start, end;\n for ( ii=0; ii& cpt_time_stamp, hoNDArray& ind_hb, size_t startE1, size_t endE1, \n const std::vector& start_e1_hb, const std::vector& end_e1_hb, \n const std::vector& start_n_hb, const std::vector& end_n_hb )\n {\n try\n {\n size_t E1 = cpt_time_stamp.get_size(0);\n size_t N = cpt_time_stamp.get_size(1);\n size_t rE1 = endE1-startE1+1;\n\n size_t e1, n, ind, ii;\n\n size_t num_acq_read_outs = 0;\n for ( n=0; n= 0 )\n {\n num_acq_read_outs++;\n }\n }\n }\n\n size_t numOfHB = start_e1_hb.size();\n\n std::vector ind_HB_start(numOfHB);\n std::vector ind_HB_end(numOfHB);\n\n for ( ind=0; ind A(numOfHB, 0.0f), B(numOfHB, 0.0f);\n for ( ind=0; ind x, y;\n\n size_t cpt;\n for ( cpt=ind_HB_start[ind]; cpt<=ind_HB_end[ind]; cpt++ )\n {\n size_t n = cpt / E1;\n size_t e1 = cpt - n*E1;\n\n if(e1>=startE1 && e1<=endE1)\n {\n if ( cpt_time_stamp[cpt] > -1 )\n {\n size_t x_ind = (e1-startE1) + n*rE1;\n x.push_back( (float)x_ind );\n y.push_back(cpt_time_stamp[cpt]);\n }\n }\n }\n\n if ( !x.empty() )\n {\n Gadgetron::simple_line_fit(x, y, a, b);\n A[ind] = a;\n B[ind] = b;\n }\n }\n\n // --------------------------------------------------------\n // compute cpt time stamp for every line\n // --------------------------------------------------------\n size_t num = cpt_time_stamp.get_number_of_elements();\n for ( ind=0; ind=startE1 && e1<=endE1)\n {\n // find to which heart beat this line belongs\n bool foundHB = false;\n for ( ii=0; ii=endHB )\n {\n foundHB = true;\n break;\n }\n\n if ( ind>=startHB && ind<=endHB )\n {\n foundHB = true;\n break;\n }\n }\n\n // if cannot find a heart beat, this kspace line will not be used\n if ( foundHB && (std::abs(B[ii])>0) )\n {\n ind_hb(e1, n) = ii;\n\n size_t x_ind = (e1-startE1) + n*rE1;\n cpt_time_stamp(e1, n) = (float)(A[ii] + B[ii]*x_ind);\n }\n else\n {\n ind_hb(e1, n) = -1;\n }\n }\n else\n {\n cpt_time_stamp(e1, n) = -1;\n ind_hb(e1, n) = -1;\n }\n }\n }\n catch(...)\n {\n GADGET_THROW(\"Exceptions happened in correct_heart_beat_time_stamp_with_fitting(...) ... \");\n }\n }\n\n void compute_phase_time_stamp(const hoNDArray& time_stamp, const hoNDArray& cpt_time_stamp, size_t startE1, size_t endE1, \n hoNDArray& phs_time_stamp, hoNDArray& phs_cpt_time_stamp)\n {\n try\n {\n size_t E1 = time_stamp.get_size(0);\n size_t N = time_stamp.get_size(1);\n size_t rE1 = endE1 - startE1 + 1;\n\n size_t e1, n;\n\n for ( n=0; n0)\n {\n tt += time_stamp(e1, n);\n num++;\n }\n }\n phs_time_stamp(n, 0) = tt/((num>0) ? num : 1);\n\n //// phase cpt time as the median of all acquired lines\n //std::vector cpt_buf(rE1, 0);\n //for ( e1=startE1; e1<=endE1; e1++ )\n //{\n // if(cpt_time_stamp(e1, n)>=0)\n // cpt_buf[e1-startE1] = cpt_time_stamp(e1, n);\n //}\n\n //std::sort(cpt_buf.begin(), cpt_buf.end());\n //phs_cpt_time_stamp(n, 0) = cpt_buf[E1/2-startE1];\n\n // phase cpt time as the cpt time of center line\n phs_cpt_time_stamp(n, 0) = cpt_time_stamp(E1/2, n);\n }\n }\n catch(...)\n {\n GADGET_THROW(\"Exceptions happened in compute_phase_time_stamp(...) ... \");\n }\n }\n\n template \n void resample_cardiac_phase_cmr_array(const hoNDArray& data, size_t output_N, hoNDArray& res, size_t spline_degree)\n {\n try\n {\n std::vector dims;\n data.get_dimensions(dims);\n\n size_t num_of_dims = dims.size();\n\n GADGET_CHECK_THROW(num_of_dims >=2);\n\n size_t N = dims[num_of_dims -1];\n\n GADGET_CHECK_THROW(N>2);\n\n std::vector dims_res(dims);\n dims_res[num_of_dims - 1] = output_N;\n\n res.create(dims_res);\n Gadgetron::clear(res);\n\n long long num = data.get_number_of_elements()/N;\n\n long long n;\n\n#pragma omp parallel default(none) shared(N, output_N, num, data, res, spline_degree, num_of_dims) private (n)\n {\n hoNDArray data_in(N);\n hoNDArray data_res(output_N);\n hoNDArray coeff(N);\n hoNDBSpline< T, 1 > interp;\n\n float dx = (float(N)-1)/(float(output_N)-1);\n\n std::vector ind;\n\n #pragma omp for \n for (n=0; n& data, size_t output_N, hoNDArray& res, size_t spline_degree);\n template EXPORTCMR void resample_cardiac_phase_cmr_array(const hoNDArray& data, size_t output_N, hoNDArray& res, size_t spline_degree);\n template EXPORTCMR void resample_cardiac_phase_cmr_array(const hoNDArray< std::complex >& data, size_t output_N, hoNDArray< std::complex >& res, size_t spline_degree);\n template EXPORTCMR void resample_cardiac_phase_cmr_array(const hoNDArray< std::complex >& data, size_t output_N, hoNDArray< std::complex >& res, size_t spline_degree);\n}\n", "meta": {"hexsha": "d6eeabce53039948d87f540feecc554058b9d036", "size": 16593, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "toolboxes/cmr/cmr_time_stamp.cpp", "max_stars_repo_name": "roopchansinghv/gadgetron", "max_stars_repo_head_hexsha": "fb6c56b643911152c27834a754a7b6ee2dd912da", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2022-02-22T21:06:36.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-22T21:06:36.000Z", "max_issues_repo_path": "toolboxes/cmr/cmr_time_stamp.cpp", "max_issues_repo_name": "apd47/gadgetron", "max_issues_repo_head_hexsha": "073e84dabe77d2dae3b3dd9aa4bf9edbf1f890f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "toolboxes/cmr/cmr_time_stamp.cpp", "max_forks_repo_name": "apd47/gadgetron", "max_forks_repo_head_hexsha": "073e84dabe77d2dae3b3dd9aa4bf9edbf1f890f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.8632653061, "max_line_length": 187, "alphanum_fraction": 0.3993250166, "num_tokens": 3843, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673359709796, "lm_q2_score": 0.6723317123102955, "lm_q1q2_score": 0.546516487874477}} {"text": "#ifndef VERTEX_COVERING\r\n#define VERTEX_COVERING 1\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n\r\n/**\r\n * Primal-dual algorithm for minimum vertex cover problem\r\n */\r\ntemplate \r\nT min_vc_pd(const leda::graph& G, const leda::node_array& weight,\r\n leda::list& S)\r\n{\r\n leda::edge_array is_covered(G, false);\r\n leda::node_array is_vc(G, false);\r\n leda::node_array gap(weight);\r\n\r\n T total_primal_cost = 0;\r\n T total_dual_cost = 0;\r\n\r\n leda::edge e;\r\n forall_edges(e, G)\r\n {\r\n if (is_covered[e])\r\n continue;\r\n\r\n leda::node s = G.source(e);\r\n leda::node t = G.target(e);\r\n if (gap[t] < gap[s])\r\n std::swap(s, t);\r\n is_vc[s] = true;\r\n S.append(s);\r\n gap[t] -= gap[s];\r\n assert(gap[t] >= T(0));\r\n // gap[s] = T(0);\r\n leda::edge e2;\r\n forall_adj_edges(e2, s)\r\n {\r\n is_covered[e2] = true;\r\n }\r\n total_primal_cost += weight[s];\r\n total_dual_cost += gap[s];\r\n }\r\n\r\n leda::list_item it;\r\n forall_items(it, S)\r\n {\r\n leda::node v = S.inf(it);\r\n leda::node w;\r\n bool found = false;\r\n forall_adj_nodes(w, v)\r\n {\r\n if (!is_vc[w])\r\n {\r\n found = true;\r\n break;\r\n }\r\n }\r\n if (!found)\r\n {\r\n S.del_item(it);\r\n total_primal_cost -= weight[v];\r\n is_vc[v] = false;\r\n }\r\n }\r\n\r\n assert(total_primal_cost >= total_dual_cost);\r\n return total_primal_cost;\r\n}\r\n\r\n/**\r\n * Primal-dual algorithm for graph bipartization problem\r\n */\r\ntemplate \r\nT min_bipartization_pd(const leda::graph& G, const leda::node_array& weight,\r\n leda::list& S)\r\n{\r\n leda::face_map is_covered(G);\r\n leda::node_array is_vc(G, false);\r\n leda::node_array gap(weight);\r\n\r\n std::queue Q;\r\n\r\n T total_primal_cost = 0;\r\n T total_dual_cost = 0;\r\n\r\n leda::face f;\r\n forall_faces(f, G)\r\n {\r\n size_t deg = 0;\r\n leda::edge e;\r\n forall_face_edges(e, f)++ deg;\r\n if ((deg & 1) == 1)\r\n { // odd\r\n Q.push(f);\r\n is_covered[f] = false;\r\n }\r\n else\r\n { // even\r\n is_covered[f] = true;\r\n }\r\n }\r\n\r\n while (!Q.empty())\r\n {\r\n leda::face f = Q.top();\r\n Q.pop();\r\n if (is_covered[f])\r\n continue;\r\n\r\n leda::edge e = G.first_face_edge(f);\r\n leda::node s = G.source(e);\r\n T min_gap = gap[s];\r\n forall_face_edges(e, f)\r\n {\r\n leda::node v = G.source(e);\r\n if (min_gap > gap[v])\r\n {\r\n s = v;\r\n min_gap = gap[v];\r\n }\r\n }\r\n\r\n is_vc[s] = true;\r\n S.append(s);\r\n forall_face_edges(e, f)\r\n {\r\n leda::node v = G.source(e);\r\n gap[v] -= min_gap;\r\n }\r\n assert(gap[s] == 0);\r\n\r\n leda::face f2;\r\n forall_adj_faces(f2, s)\r\n { // ???\r\n is_covered[f2] = true;\r\n }\r\n\r\n // add new odd-cycle face ???\r\n\r\n total_primal_cost += weight[s];\r\n total_dual_cost += min_gap;\r\n }\r\n\r\n leda::list_item it;\r\n forall_items(it, S)\r\n {\r\n leda::node v = S.inf(it);\r\n leda::node w;\r\n bool found = false;\r\n forall_adj_nodes(w, v)\r\n {\r\n if (!is_vc[w])\r\n {\r\n found = true;\r\n break;\r\n }\r\n }\r\n if (!found)\r\n {\r\n S.del_item(it);\r\n total_primal_cost -= weight[v];\r\n is_vc[v] = false;\r\n }\r\n }\r\n\r\n assert(total_primal_cost >= total_dual_cost);\r\n return total_primal_cost;\r\n}\r\n\r\n#include \r\n\r\ntemplate \r\nclass vc_order // for boost::heap\r\n{\r\n public:\r\n vc_order(const leda::node_array& W, const leda::node_array& D)\r\n : _W(&W)\r\n , _D(&D)\r\n {\r\n }\r\n ~vc_order() { }\r\n\r\n bool operator()(leda::node v, leda::node w) const\r\n {\r\n return (*_W)[v] * (*_D)[w] > (*_W)[w] * (*_D)[v];\r\n // return (*_W)[v] > (*_W)[w];\r\n // return (*_D)[w] > (*_D)[v];\r\n }\r\n\r\n private:\r\n const leda::node_array* _W;\r\n const leda::node_array* _D;\r\n};\r\n\r\n/**\r\n * Greedy algorithm for minimun vertex cover problem\r\n */\r\ntemplate \r\nT min_vc_greedy(const leda::graph& G, const leda::node_array& weight,\r\n leda::list& S)\r\n{\r\n typedef typename boost::heap::binomial_heap>>\r\n bpq_t;\r\n typedef typename bpq_t::handle_type bh_t;\r\n\r\n leda::node_array D(G); // number of uncovered edges\r\n\r\n leda::node v;\r\n forall_nodes(v, G) D[v] = G.degree(v);\r\n\r\n bpq_t Bpq(vc_order(weight, D));\r\n leda::node_array bh_handlers(G);\r\n forall_nodes(v, G)\r\n {\r\n bh_t bh = Bpq.push(v);\r\n bh_handlers[v] = bh;\r\n }\r\n\r\n leda::edge_array is_covered(G, false);\r\n leda::node_array is_vc(G, false);\r\n\r\n T total_cost = 0;\r\n size_t num_edges = G.number_of_edges();\r\n\r\n while (num_edges > 0 && !Bpq.empty())\r\n {\r\n leda::node s = Bpq.top();\r\n Bpq.pop();\r\n is_vc[s] = true;\r\n S.append(s);\r\n total_cost += weight[s];\r\n\r\n leda::edge e2;\r\n forall_adj_edges(e2, s)\r\n {\r\n if (is_covered[e2])\r\n continue;\r\n is_covered[e2] = true;\r\n leda::node t = G.opposite(e2, s);\r\n D[t] -= 1;\r\n Bpq.update(bh_handlers[t]);\r\n --num_edges;\r\n }\r\n }\r\n\r\n leda::list_item it;\r\n forall_items(it, S)\r\n {\r\n leda::node v = S.inf(it);\r\n leda::node w;\r\n bool found = false;\r\n forall_adj_nodes(w, v)\r\n {\r\n if (!is_vc[w])\r\n {\r\n found = true;\r\n break;\r\n }\r\n }\r\n if (!found)\r\n {\r\n S.del_item(it);\r\n total_cost -= weight[v];\r\n is_vc[v] = false;\r\n }\r\n }\r\n\r\n return total_cost;\r\n}\r\n\r\n#endif\r\n", "meta": {"hexsha": "6a882270b06cea293f32123de6e8f957cb7aec39", "size": 6362, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "lib/include/vertex_cover.hpp", "max_stars_repo_name": "luk036/netoptimcpp", "max_stars_repo_head_hexsha": "29b24cea62f5bf70ffc04777ecf92da187110845", "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": "lib/include/vertex_cover.hpp", "max_issues_repo_name": "luk036/netoptimcpp", "max_issues_repo_head_hexsha": "29b24cea62f5bf70ffc04777ecf92da187110845", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/include/vertex_cover.hpp", "max_forks_repo_name": "luk036/netoptimcpp", "max_forks_repo_head_hexsha": "29b24cea62f5bf70ffc04777ecf92da187110845", "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": 22.9675090253, "max_line_length": 80, "alphanum_fraction": 0.4657340459, "num_tokens": 1697, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673269042767, "lm_q2_score": 0.6723316860482762, "lm_q1q2_score": 0.5465164604311076}} {"text": "//==================================================================================================\n/*!\n @file\n\n @copyright 2016 NumScale SAS\n\n Distributed under the Boost Software License, Version 1.0.\n (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)\n*/\n//==================================================================================================\n#ifndef BOOST_SIMD_FUNCTION_FMA_HPP_INCLUDED\n#define BOOST_SIMD_FUNCTION_FMA_HPP_INCLUDED\n\n#if defined(DOXYGEN_ONLY)\nnamespace boost { namespace simd\n{\n /*!\n\n @ingroup group-arithmetic\n This function object computes the (fused) multiply add of these three parameters.\n\n\n @par Header \n\n @par Notes\n The call `fma(x, y, z)` is similar to `x*y+z`\n\n But really conformant fused multiply/add also implies\n\n - only one rounding\n\n - no \"intermediate\" overflow\n\n fma provides this for all integral types and also each time it is reasonable\n in terms of performance for floating ones (i.e. if the system has the hard\n wired capability).\n\n If you need pedantic fma capabilities in all circumstances in your own\n code you can use the pedantic_ or std_ decorator\n (although both can be very expensive).\n\n @par Decorators\n\n - std_ for floating entries to call directly std::fma. This generally implies pedantic\n fma behaviour, but in no way improved performances.\n - pedantic_ ensures the fma properties and allows SIMD acceleration if available.\n\n @see fms, fnma, fnms\n\n @par Example:\n\n @snippet fma.cpp fma\n\n @par Possible output:\n\n @snippet fma.txt fma\n **/\n Value fma(Value const& x, Value const& y, Value const& z);\n} }\n#endif\n\n#include \n#include \n\n#endif\n", "meta": {"hexsha": "120657fd1bd7228a4378dd99e5d7156a411bb1cc", "size": 1819, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "third_party/boost/simd/function/fma.hpp", "max_stars_repo_name": "SylvainCorlay/pythran", "max_stars_repo_head_hexsha": "908ec070d837baf77d828d01c3e35e2f4bfa2bfa", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2018-02-25T22:23:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-15T15:13:12.000Z", "max_issues_repo_path": "third_party/boost/simd/function/fma.hpp", "max_issues_repo_name": "SylvainCorlay/pythran", "max_issues_repo_head_hexsha": "908ec070d837baf77d828d01c3e35e2f4bfa2bfa", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "third_party/boost/simd/function/fma.hpp", "max_forks_repo_name": "SylvainCorlay/pythran", "max_forks_repo_head_hexsha": "908ec070d837baf77d828d01c3e35e2f4bfa2bfa", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2017-12-12T12:36:31.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-10T14:27:07.000Z", "avg_line_length": 27.5606060606, "max_line_length": 100, "alphanum_fraction": 0.6382627817, "num_tokens": 410, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673178375735, "lm_q2_score": 0.6723316926137812, "lm_q1q2_score": 0.5465164596721602}} {"text": "/*\n * COPYRIGHT AND PERMISSION NOTICE\n * Penn Software MSCKF_VIO\n * Copyright (C) 2017 The Trustees of the University of Pennsylvania\n * All rights reserved.\n */\n\n// The original file belongs to MSCKF_VIO (https://github.com/KumarRobotics/msckf_vio/)\n// Several changes have been made to use it in orcvio\n\n#ifndef FEATURE_HPP\n#define FEATURE_HPP\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \n#include \n\nnamespace orcvio\n{\n\n /*\n * @brief Feature Salient part of an image. Please refer\n * to the Appendix of \"A Multi-State Constraint Kalman\n * Filter for Vision-aided Inertial Navigation\" for how\n * the 3d position of a feature is initialized.\n */\n struct Feature\n {\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n\n /*\n * @brief OptimizationConfig Configuration parameters\n * for 3d feature position optimization.\n */\n struct OptimizationConfig\n {\n double translation_threshold;\n double huber_epsilon;\n double estimation_precision;\n double initial_damping;\n int outer_loop_max_iteration;\n int inner_loop_max_iteration;\n double cost_threshold;\n double init_final_dist_threshold;\n\n OptimizationConfig() : translation_threshold(0.2),\n huber_epsilon(0.01),\n estimation_precision(5e-7),\n initial_damping(1e-3),\n outer_loop_max_iteration(10),\n inner_loop_max_iteration(10),\n cost_threshold(4.7673e-04),\n init_final_dist_threshold(5)\n {\n return;\n }\n };\n\n // Constructors for the struct.\n Feature() : id(0), position(Eigen::Vector3d::Zero()),\n is_initialized(false), best_cost(99999.9),\n id_anchor(-1), invParam(Eigen::Vector3d::Zero()),\n in_state(false), totalObsNum(0), ekf_feature(false) {}\n\n Feature(const FeatureIDType &new_id) : id(new_id),\n position(Eigen::Vector3d::Zero()),\n is_initialized(false), best_cost(99999.9),\n id_anchor(-1), invParam(Eigen::Vector3d::Zero()),\n in_state(false), totalObsNum(0), ekf_feature(false) {}\n\n /*\n * @brief triangulate feature position based on initial guess and LM\n * @param cam_poses: all the camera poses \n * @param measurements: measurements \n * @param final_position: to hold the initial position \n * @param final_position: to hold the position after LM \n * @param T_c_w_last: to hold the pose of last camera \n * @return a flag indicating whether this feature is valid \n */\n inline bool triangulate_position(std::vector> &cam_poses,\n const std::vector> &measurements,\n Eigen::Vector3d &solution, Eigen::Vector3d &final_position, Eigen::Isometry3d &T_c_w_last);\n\n /*\n * @brief cost Compute the cost of the camera observations\n * @param T_c0_c1 A rigid body transformation takes\n * a vector in c0 frame to ci frame.\n * @param x The current estimation.\n * @param z The ith measurement of the feature j in ci frame.\n * @return e The cost of this observation.\n */\n inline void cost(const Eigen::Isometry3d &T_c0_ci,\n const Eigen::Vector3d &x, const Eigen::Vector2d &z,\n double &e) const;\n\n /*\n * @brief jacobian Compute the Jacobian of the camera observation\n * @param T_c0_c1 A rigid body transformation takes\n * a vector in c0 frame to ci frame.\n * @param x The current estimation.\n * @param z The actual measurement of the feature in ci frame.\n * @return J The computed Jacobian.\n * @return r The computed residual.\n * @return w Weight induced by huber kernel.\n */\n inline void jacobian(const Eigen::Isometry3d &T_c0_ci,\n const Eigen::Vector3d &x, const Eigen::Vector2d &z,\n Eigen::Matrix &J, Eigen::Vector2d &r,\n double &w) const;\n\n /*\n * @brief generateInitialGuess Compute the initial guess of\n * the feature's 3d position using only two views.\n * @param T_c1_c2: A rigid body transformation taking\n * a vector from c2 frame to c1 frame.\n * @param z1: feature observation in c1 frame.\n * @param z2: feature observation in c2 frame.\n * @return p: Computed feature position in c1 frame.\n */\n inline void generateInitialGuess(\n const Eigen::Isometry3d &T_c1_c2, const Eigen::Vector2d &z1,\n const Eigen::Vector2d &z2, Eigen::Vector3d &p) const;\n\n /*\n * @brief checkMotion Check the input camera poses to ensure\n * there is enough translation to triangulate the feature\n * positon.\n * @param imu_states : input to aquire camera poses.\n × @param if_tracked : if feature be tracked now.\n * @return True if the translation between the input camera\n * poses is sufficient.\n */\n inline bool checkMotion(\n const IMUStateServer &imu_states, bool if_tracked) const;\n\n /*\n * @brief InitializePosition Intialize the feature position\n * based on all current available measurements.\n * @param imu_states: A map containing the camera poses with its\n * ID as the associated key value.\n * @param curr_id: current camera id.\n * @return The computed 3d position is used to set the position\n * member variable. Note the resulted position is in world\n * frame.\n * @return True if the estimated 3d position of the feature\n * is valid.\n */\n inline bool initializePosition(\n const IMUStateServer &imu_states, const StateIDType &curr_id);\n\n /*\n * @brief initializePosition_AssignAnchor Intialize the feature position\n * based on all current available measurements. Current camera would\n * be the anchor\n * @param imu_states: A map containing the camera poses with its\n * ID as the associated key value.\n * @param anchor_id: Assigned anchor camera id.\n * @return The computed 3d position is used to set the position\n * member variable. Note the resulted position is in world\n * frame.\n * @return True if the estimated 3d position of the feature\n * is valid.\n */\n inline bool initializePosition_AssignAnchor(\n const IMUStateServer &imu_states);\n\n /*\n * @brief initializeInvParamPosition Intialize the feature position\n * based on all current available measurements. Result in \n * inverse depth parameterization in anchor frame.\n * @param imu_states: A map containing the camera poses with its\n * ID as the associated key value.\n * @param curr_id: current camera id.\n * @return The computed 3d position is used to set the position\n * member variable. Note the resulted position is in world\n * frame.\n * @return The computed inverse depth parameterizations is used to \n * set the invParam variable. Note the resulted inverse depth\n * parameterization is in the anchor frame, which is the newest \n * frame observing this feature except for current frame.\n * @return True if the estimated 3d position of the feature\n * is valid.\n */\n inline bool initializeInvParamPosition(\n const IMUStateServer &imu_states, const StateIDType &curr_id);\n\n // An unique identifier for the feature.\n // In case of long time running, the variable\n // type of id is set to FeatureIDType in order\n // to avoid duplication.\n FeatureIDType id;\n\n // id for next feature\n static FeatureIDType next_id;\n\n // Store the observations of the features in the\n // state_id(key)-image_coordinates(value) manner.\n std::map,\n Eigen::aligned_allocator<\n std::pair>>\n observations;\n\n // Store the observations of the features velocity in the\n // state_id(key)-features_velocity(value) manner.\n std::map,\n Eigen::aligned_allocator<\n std::pair>>\n observations_vel;\n\n // 3d postion of the feature in the world frame.\n Eigen::Vector3d position;\n\n // First estimate 3d position in world frame\n Eigen::Vector3d position_FEJ;\n\n // Best normalized cost, added by QXC\n double best_cost;\n\n // First observed camera pose, added by QXC\n Eigen::Isometry3d firstCamPose;\n\n // If failed because of nagtive depth of big reprojection error\n bool failed_by_neg_dpth;\n bool failed_by_big_proj;\n\n // [x/z, y/z] under first observed camera coordinate, added by QXC\n Eigen::Vector2d solutionInFirstCam;\n\n // A indicator to show if the 3d postion of the feature\n // has been initialized or not.\n bool is_initialized;\n\n // Optimization configuration for solving the 3d position.\n static OptimizationConfig optimization_config;\n\n // QXC debug log\n inline double getMaxObsDiff();\n inline double getTotalObsChange();\n\n // Anchor camera id\n StateIDType id_anchor;\n\n // 3d inverse depth parameter position in anchor camera frame.\n Eigen::Vector3d invParam;\n\n // 1d inverse depth parameter position in anchor camera frame.\n double invDepth;\n // Corrected observation in anchor camera frame.\n Eigen::Vector3d obs_anchor;\n\n // If this feature is in filter state\n bool in_state;\n\n // Record total observation number\n int totalObsNum;\n\n // If this is a potential ekf feature\n bool ekf_feature;\n };\n\n typedef std::map,\n Eigen::aligned_allocator<\n std::pair>>\n MapServer;\n\n void Feature::cost(const Eigen::Isometry3d &T_c0_ci,\n const Eigen::Vector3d &x, const Eigen::Vector2d &z,\n double &e) const\n {\n // Compute hi1, hi2, and hi3 as Equation (37).\n const double &alpha = x(0);\n const double &beta = x(1);\n const double &rho = x(2);\n\n Eigen::Vector3d h = T_c0_ci.linear() *\n Eigen::Vector3d(alpha, beta, 1.0) +\n rho * T_c0_ci.translation();\n double &h1 = h(0);\n double &h2 = h(1);\n double &h3 = h(2);\n\n // Predict the feature observation in ci frame.\n Eigen::Vector2d z_hat(h1 / h3, h2 / h3);\n\n // Compute the residual.\n e = (z_hat - z).squaredNorm();\n return;\n }\n\n void Feature::jacobian(const Eigen::Isometry3d &T_c0_ci,\n const Eigen::Vector3d &x, const Eigen::Vector2d &z,\n Eigen::Matrix &J, Eigen::Vector2d &r,\n double &w) const\n {\n\n // Compute hi1, hi2, and hi3 as Equation (37).\n const double &alpha = x(0);\n const double &beta = x(1);\n const double &rho = x(2);\n\n Eigen::Vector3d h = T_c0_ci.linear() *\n Eigen::Vector3d(alpha, beta, 1.0) +\n rho * T_c0_ci.translation();\n double &h1 = h(0);\n double &h2 = h(1);\n double &h3 = h(2);\n\n // Compute the Jacobian.\n Eigen::Matrix3d W;\n W.leftCols<2>() = T_c0_ci.linear().leftCols<2>();\n W.rightCols<1>() = T_c0_ci.translation();\n\n J.row(0) = 1 / h3 * W.row(0) - h1 / (h3 * h3) * W.row(2);\n J.row(1) = 1 / h3 * W.row(1) - h2 / (h3 * h3) * W.row(2);\n\n // Compute the residual.\n Eigen::Vector2d z_hat(h1 / h3, h2 / h3);\n r = z_hat - z;\n\n // Compute the weight based on the residual.\n double e = r.norm();\n if (e <= optimization_config.huber_epsilon)\n w = 1.0;\n else\n w = std::sqrt(2.0 * optimization_config.huber_epsilon / e);\n\n return;\n }\n\n void Feature::generateInitialGuess(\n const Eigen::Isometry3d &T_c1_c2, const Eigen::Vector2d &z1,\n const Eigen::Vector2d &z2, Eigen::Vector3d &p) const\n {\n // Construct a least square problem to solve the depth.\n Eigen::Vector3d m = T_c1_c2.linear() * Eigen::Vector3d(z1(0), z1(1), 1.0);\n\n Eigen::Vector2d A(0.0, 0.0);\n A(0) = m(0) - z2(0) * m(2);\n A(1) = m(1) - z2(1) * m(2);\n\n Eigen::Vector2d b(0.0, 0.0);\n b(0) = z2(0) * T_c1_c2.translation()(2) - T_c1_c2.translation()(0);\n b(1) = z2(1) * T_c1_c2.translation()(2) - T_c1_c2.translation()(1);\n\n // Solve for the depth.\n double depth = (A.transpose() * A).inverse() * A.transpose() * b;\n p(0) = z1(0) * depth;\n p(1) = z1(1) * depth;\n p(2) = depth;\n return;\n }\n\n bool Feature::checkMotion(\n const IMUStateServer &imu_states, bool if_tracked) const\n {\n\n StateIDType first_cam_id = observations.begin()->first;\n StateIDType last_cam_id;\n if (if_tracked)\n last_cam_id = (--(--observations.end()))->first;\n else\n last_cam_id = (--observations.end())->first;\n\n Eigen::Isometry3d first_cam_pose;\n first_cam_pose.linear() = imu_states.find(first_cam_id)->second.orientation_cam;\n first_cam_pose.translation() =\n imu_states.find(first_cam_id)->second.position_cam;\n\n Eigen::Isometry3d last_cam_pose;\n last_cam_pose.linear() = imu_states.find(last_cam_id)->second.orientation_cam;\n last_cam_pose.translation() =\n imu_states.find(last_cam_id)->second.position_cam;\n\n // Get the direction of the feature when it is first observed.\n // This direction is represented in the world frame.\n Eigen::Vector3d feature_direction(\n observations.begin()->second(0),\n observations.begin()->second(1), 1.0);\n feature_direction = feature_direction / feature_direction.norm();\n feature_direction = first_cam_pose.linear() * feature_direction;\n\n // Compute the translation between the first frame\n // and the last frame. We assume the first frame and\n // the last frame will provide the largest motion to\n // speed up the checking process.\n Eigen::Vector3d translation = last_cam_pose.translation() -\n first_cam_pose.translation();\n double parallel_translation =\n translation.transpose() * feature_direction;\n Eigen::Vector3d orthogonal_translation = translation -\n parallel_translation * feature_direction;\n\n if (orthogonal_translation.norm() >\n optimization_config.translation_threshold)\n return true;\n else\n return false;\n }\n\n bool Feature::initializePosition(\n const IMUStateServer &imu_states, const StateIDType &curr_id)\n {\n // Organize camera poses and feature observations properly.\n std::vector>\n cam_poses(0);\n std::vector>\n measurements(0);\n\n std::vector cam_ids(0);\n for (auto &m : observations)\n {\n // TODO: This should be handled properly. Normally, the\n // required camera states should all be available in\n // the input imu_states buffer.\n auto state_iter = imu_states.find(m.first);\n if (state_iter == imu_states.end())\n continue;\n\n if (curr_id == state_iter->first)\n continue;\n\n // Add the measurement.\n measurements.push_back(m.second.head<2>());\n\n // This camera pose will take a vector from this camera frame\n // to the world frame.\n Eigen::Isometry3d cam_pose;\n cam_pose.linear() = state_iter->second.orientation_cam;\n cam_pose.translation() = state_iter->second.position_cam;\n\n cam_poses.push_back(cam_pose);\n\n cam_ids.push_back(state_iter->first);\n }\n\n Eigen::Vector3d solution, final_position;\n Eigen::Isometry3d T_c_w_last;\n bool is_valid_solution = triangulate_position(cam_poses, measurements, solution, final_position, T_c_w_last);\n\n if (is_valid_solution)\n {\n if (!is_initialized)\n position_FEJ = position;\n is_initialized = true;\n position = T_c_w_last.linear() * final_position + T_c_w_last.translation();\n invParam = solution;\n id_anchor = cam_ids[cam_ids.size() - 1];\n invDepth = 1 / final_position(2);\n obs_anchor = Eigen::Vector3d(final_position(0) * invDepth, // correct observation\n final_position(1) * invDepth, 1);\n // obs_anchor = Eigen::Vector3d(measurements[cam_ids.size()-1](0), // do not correct observation\n // measurements[cam_ids.size()-1](1), 1);\n }\n\n return is_valid_solution;\n }\n\n bool Feature::initializePosition_AssignAnchor(\n const IMUStateServer &imu_states)\n {\n // Organize camera poses and feature observations properly.\n std::vector>\n cam_poses(0);\n std::vector>\n measurements(0);\n\n std::vector cam_ids(0);\n for (auto &m : observations)\n {\n // TODO: This should be handled properly. Normally, the\n // required camera states should all be available in\n // the input imu_states buffer.\n auto state_iter = imu_states.find(m.first);\n if (state_iter == imu_states.end())\n continue;\n\n // Add the measurement.\n measurements.push_back(m.second.head<2>());\n\n // This camera pose will take a vector from this camera frame\n // to the world frame.\n Eigen::Isometry3d cam_pose;\n cam_pose.linear() = state_iter->second.orientation_cam;\n cam_pose.translation() = state_iter->second.position_cam;\n\n cam_poses.push_back(cam_pose);\n\n cam_ids.push_back(state_iter->first);\n }\n\n Eigen::Vector3d solution, final_position;\n Eigen::Isometry3d T_c_w_last;\n bool is_valid_solution = triangulate_position(cam_poses, measurements, solution, final_position, T_c_w_last);\n\n if (is_valid_solution)\n {\n if (!is_initialized)\n position_FEJ = position;\n is_initialized = true;\n position = T_c_w_last.linear() * final_position + T_c_w_last.translation();\n invParam = solution;\n id_anchor = cam_ids[cam_ids.size() - 1];\n invDepth = 1 / final_position(2);\n obs_anchor = Eigen::Vector3d(final_position(0) * invDepth, // correct observation\n final_position(1) * invDepth, 1);\n // obs_anchor = Eigen::Vector3d(measurements[cam_ids.size()-1](0), // do not correct observation\n // measurements[cam_ids.size()-1](1), 1);\n }\n\n return is_valid_solution;\n }\n\n bool Feature::initializeInvParamPosition(\n const IMUStateServer &imu_states, const StateIDType &curr_id)\n {\n // Organize camera poses and feature observations properly.\n std::vector>\n cam_poses(0);\n std::vector>\n measurements(0);\n\n std::vector cam_ids(0);\n for (auto &m : observations)\n {\n // TODO: This should be handled properly. Normally, the\n // required camera states should all be available in\n // the input imu_states buffer.\n auto state_iter = imu_states.find(m.first);\n if (state_iter == imu_states.end())\n continue;\n\n if (curr_id == state_iter->first)\n continue;\n\n // Add the measurement.\n measurements.push_back(m.second.head<2>());\n\n // This camera pose will take a vector from this camera frame\n // to the world frame.\n Eigen::Isometry3d cam_pose;\n cam_pose.linear() = state_iter->second.orientation_cam;\n cam_pose.translation() = state_iter->second.position_cam;\n\n cam_poses.push_back(cam_pose);\n\n cam_ids.push_back(state_iter->first);\n }\n\n Eigen::Vector3d solution, final_position;\n Eigen::Isometry3d T_c_w_last;\n bool is_valid_solution = triangulate_position(cam_poses, measurements, solution, final_position, T_c_w_last);\n\n if (is_valid_solution)\n {\n if (!is_initialized)\n position_FEJ = position;\n ekf_feature = true;\n is_initialized = true;\n position = T_c_w_last.linear() * final_position + T_c_w_last.translation();\n invParam = solution;\n id_anchor = cam_ids[cam_ids.size() - 1];\n invDepth = 1 / final_position(2);\n obs_anchor = Eigen::Vector3d(final_position(0) * invDepth, // correct observation\n final_position(1) * invDepth, 1);\n // obs_anchor = Eigen::Vector3d(measurements[cam_ids.size()-1](0), // do not correct observation\n // measurements[cam_ids.size()-1](1), 1);\n }\n\n return is_valid_solution;\n }\n\n double Feature::getMaxObsDiff()\n {\n Eigen::Vector2d p0(observations.begin()->second(0),\n observations.begin()->second(1));\n Eigen::Vector2d p1((--observations.end())->second(0),\n (--observations.end())->second(1));\n\n return (p0 - p1).norm();\n }\n\n double Feature::getTotalObsChange()\n {\n\n std::vector>\n p(0);\n for (const auto &obs : observations)\n p.push_back(Eigen::Vector2d(obs.second(0), obs.second(1)));\n\n double diff = 0.0;\n for (int i = 1; i < p.size(); i++)\n {\n diff += (p[i] - p[i - 1]).norm();\n }\n return diff;\n }\n\n bool Feature::triangulate_position(std::vector> &cam_poses,\n const std::vector> &measurements,\n Eigen::Vector3d &solution, Eigen::Vector3d &final_position, Eigen::Isometry3d &T_c_w_last)\n {\n\n // All camera poses should be modified such that it takes a\n // vector from the last camera frame in the buffer to this\n // camera frame.\n T_c_w_last = cam_poses[cam_poses.size() - 1];\n for (auto &pose : cam_poses)\n pose = pose.inverse() * T_c_w_last;\n\n // Generate initial guess\n Eigen::Vector3d initial_position(0.0, 0.0, 0.0);\n if (!is_initialized)\n generateInitialGuess(cam_poses[0], measurements[cam_poses.size() - 1],\n measurements[0], initial_position);\n else\n initial_position = T_c_w_last.inverse() * position;\n\n solution << initial_position(0) / initial_position(2),\n initial_position(1) / initial_position(2),\n 1.0 / initial_position(2);\n\n // Apply Levenberg-Marquart method to solve for the 3d position.\n double lambda = optimization_config.initial_damping;\n int inner_loop_cntr = 0;\n int outer_loop_cntr = 0;\n bool is_cost_reduced = false;\n double delta_norm = 0;\n\n // Compute the initial cost.\n double total_cost = 0.0;\n for (int i = 0; i < cam_poses.size(); ++i)\n {\n double this_cost = 0.0;\n cost(cam_poses[i], solution, measurements[i], this_cost);\n total_cost += this_cost;\n }\n\n // Outer loop.\n do\n {\n Eigen::Matrix3d A = Eigen::Matrix3d::Zero();\n Eigen::Vector3d b = Eigen::Vector3d::Zero();\n\n for (int i = 0; i < cam_poses.size(); ++i)\n {\n Eigen::Matrix J;\n Eigen::Vector2d r;\n double w;\n\n jacobian(cam_poses[i], solution, measurements[i], J, r, w);\n\n if (w == 1)\n {\n A += J.transpose() * J;\n b += J.transpose() * r;\n }\n else\n {\n double w_square = w * w;\n A += w_square * J.transpose() * J;\n b += w_square * J.transpose() * r;\n }\n }\n\n // Inner loop.\n // Solve for the delta that can reduce the total cost.\n do\n {\n Eigen::Matrix3d damper = lambda * Eigen::Matrix3d::Identity();\n Eigen::Vector3d delta = (A + damper).ldlt().solve(b);\n Eigen::Vector3d new_solution = solution - delta;\n delta_norm = delta.norm();\n\n double new_cost = 0.0;\n for (int i = 0; i < cam_poses.size(); ++i)\n {\n double this_cost = 0.0;\n cost(cam_poses[i], new_solution, measurements[i], this_cost);\n new_cost += this_cost;\n }\n\n if (new_cost < total_cost)\n {\n is_cost_reduced = true;\n solution = new_solution;\n total_cost = new_cost;\n lambda = lambda / 10 > 1e-10 ? lambda / 10 : 1e-10;\n }\n else\n {\n is_cost_reduced = false;\n lambda = lambda * 10 < 1e12 ? lambda * 10 : 1e12;\n }\n\n } while (inner_loop_cntr++ <\n optimization_config.inner_loop_max_iteration &&\n !is_cost_reduced);\n\n inner_loop_cntr = 0;\n\n } while (outer_loop_cntr++ <\n optimization_config.outer_loop_max_iteration &&\n delta_norm > optimization_config.estimation_precision);\n\n // Covert the feature position from inverse depth\n // representation to its 3d coordinate.\n // Eigen::Vector3d final_position(solution(0)/solution(2),\n // solution(1)/solution(2), 1.0/solution(2));\n final_position << solution(0) / solution(2),\n solution(1) / solution(2), 1.0 / solution(2);\n\n // Check if the solution is valid. Make sure the feature\n // is in front of every camera frame observing it.\n bool is_valid_solution = true;\n failed_by_neg_dpth = false;\n for (const auto &pose : cam_poses)\n {\n Eigen::Vector3d pos =\n pose.linear() * final_position + pose.translation();\n if (pos(2) <= 0)\n {\n is_valid_solution = false;\n failed_by_neg_dpth = true;\n break;\n }\n }\n\n // check total_cost\n double normalized_cost =\n total_cost / (2 * cam_poses.size() * cam_poses.size());\n double uv_cost =\n sqrt(total_cost / cam_poses.size());\n failed_by_big_proj = false;\n\n if ((final_position - initial_position).norm() > optimization_config.init_final_dist_threshold)\n {\n is_valid_solution = false;\n failed_by_big_proj = true;\n }\n\n if (normalized_cost > optimization_config.cost_threshold)\n {\n is_valid_solution = false;\n failed_by_big_proj = true;\n }\n\n return is_valid_solution;\n }\n\n} // namespace orcvio\n\n#endif // FEATURE_HPP", "meta": {"hexsha": "2146be5f3e68148d91e7abac779bd249525d695f", "size": 26690, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/orcvio/feat/feature.hpp", "max_stars_repo_name": "shanmo/OrcVIO-Object-Mapping", "max_stars_repo_head_hexsha": "e5337a56da72b23ebf5c9d9f87534fe2edc9c54c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-10-14T03:31:16.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-14T03:31:16.000Z", "max_issues_repo_path": "include/orcvio/feat/feature.hpp", "max_issues_repo_name": "shanmo/OrcVIO-Object-Mapping", "max_issues_repo_head_hexsha": "e5337a56da72b23ebf5c9d9f87534fe2edc9c54c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/orcvio/feat/feature.hpp", "max_forks_repo_name": "shanmo/OrcVIO-Object-Mapping", "max_forks_repo_head_hexsha": "e5337a56da72b23ebf5c9d9f87534fe2edc9c54c", "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.7526041667, "max_line_length": 129, "alphanum_fraction": 0.6271637317, "num_tokens": 6645, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673178375734, "lm_q2_score": 0.6723316926137812, "lm_q1q2_score": 0.5465164596721602}} {"text": "#define DEBUG 1\n/**\n * File : F.cpp\n * Author : Kazune Takahashi\n * Created : 5/30/2021, 4:50:13 PM\n * Powered by Visual Studio Code\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n// using namespace atcoder;\nusing boost::rational;\nusing boost::integer::gcd; // for C++14 or for cpp_int\nusing boost::integer::lcm; // for C++14 or for cpp_int\nusing boost::multiprecision::cpp_int;\nusing ll = long long;\nusing ld = long double;\n/***************************************************\n Fundermental Tools\n ***************************************************/\n// ----- max_heap and min_heap -----\ntemplate \nusing max_heap = priority_queue;\ntemplate \nusing min_heap = priority_queue, greater>;\n// ----- ch_max and ch_min -----\ntemplate \nbool ch_max(T &left, T right)\n{\n if (left < right)\n {\n left = right;\n return true;\n }\n return false;\n}\ntemplate \nbool ch_min(T &left, T right)\n{\n if (left > right)\n {\n left = right;\n return true;\n }\n return false;\n}\n// ----- mint -----\nusing mint = atcoder::modint1000000007;\n// using mint = atcoder::modint998244353;\n// using mint = atcoder::modint; // atcoder::modint::set_mod(xxx);\n// using mint = atcoder::static_modint<1000000009>;\n// using mint0 = dynamic_modint;\n// using mint1 = dynamic_modint;\nistream &operator>>(istream &is, mint &x)\n{\n ll t;\n is >> t;\n x = t;\n return is;\n}\nostream &operator<<(ostream &os, mint const &x)\n{\n return os << x.val();\n}\n// ----- Combination -----\ntemplate \nclass Combination\n{\npublic:\n constexpr static ll MAX_SIZE{4'000'010LL};\n // constexpr static ll MAX_SIZE{30'000'010LL}; // if 10^7 is needed\n\n vector inv, fact, factinv;\n\n Combination() : inv(MAX_SIZE), fact(MAX_SIZE), factinv(MAX_SIZE)\n {\n inv[1] = 1;\n for (auto i{2LL}; i < MAX_SIZE; i++)\n {\n inv[i] = (-inv[Mint::mod() % i]) * (Mint::mod() / i);\n }\n fact[0] = factinv[0] = 1;\n for (auto i{1LL}; i < MAX_SIZE; i++)\n {\n fact[i] = Mint(i) * fact[i - 1];\n factinv[i] = inv[i] * factinv[i - 1];\n }\n }\n\n Mint operator()(int n, int k)\n {\n if (n >= 0 && k >= 0 && n - k >= 0)\n {\n return fact[n] * factinv[k] * factinv[n - k];\n }\n return 0;\n }\n\n Mint catalan(int x, int y)\n {\n return (*this)(x + y, y) - (*this)(x + y, y - 1);\n }\n};\n// ----- for C++14 -----\nusing combination = Combination;\n// ----- for C++17 -----\ntemplate ::value>::type * = nullptr>\nsize_t popcount(T x) { return bitset<64>(x).count(); }\nsize_t popcount(string const &S) { return bitset<200010>{S}.count(); }\n// ----- Infty -----\ntemplate \nconstexpr T Infty() { return numeric_limits::max(); }\ntemplate \nconstexpr T mInfty() { return numeric_limits::min(); }\n/***************************************************\n AtCoder Library / Data Structures\n ***************************************************/\n// ----- FenwickTree -----\ntemplate \nclass FenwickTree : public atcoder::fenwick_tree\n{\npublic:\n using atcoder::fenwick_tree::fenwick_tree;\n\n FenwickTree(vector const &v) : FenwickTree(static_cast(v.size()))\n {\n for (auto i{size_t{0}}; i < v.size(); ++i)\n {\n atcoder::fenwick_tree::add(i, v[i]);\n }\n }\n\n T operator[](int i)\n {\n return atcoder::fenwick_tree::sum(i, i + 1);\n }\n};\n/***************************************************\n AtCoder Library / Math\n ***************************************************/\n// ----- Math -----\nusing atcoder::convolution;\nusing atcoder::convolution_ll;\nusing atcoder::floor_sum;\n/***************************************************\n AtCoder Library / Graphs\n ***************************************************/\n// ----- UnionFind -----\nusing UnionFind = atcoder::dsu;\n// ----- MaxFlow -----\ntemplate \nclass MaxFlow : public atcoder::mf_graph\n{\npublic:\n using atcoder::mf_graph::mf_graph;\n\n int add_edge(int from, int to)\n {\n return atcoder::mf_graph::add_edge(from, to, Cap{1});\n }\n};\nostream &operator<<(ostream &os, typename atcoder::mf_graph::edge const &edge)\n{\n return os << \"from: \" << edge.from << \", to: \" << edge.to << \", cap: \" << edge.cap << \", flow: \" << edge.flow;\n}\n// ----- MinCostFlow -----\ntemplate \nclass MinCostFlow : public atcoder::mcf_graph\n{\nprivate:\n Cost infty;\n\npublic:\n using atcoder::mcf_graph::mcf_graph;\n\n MinCostFlow(int n, Cost infty = Cost{0}) : atcoder::mcf_graph::mcf_graph(n), infty{infty} {}\n\n int add_edge(int from, int to, Cap cap)\n {\n return atcoder::mcf_graph::add_edge(from, to, cap, Cost{0});\n }\n\n int add_edge(int from, int to, Cap cap, Cost cost)\n {\n return atcoder::mcf_graph::add_edge(from, to, cap, cost + infty);\n }\n\n pair flow(int s, int t)\n {\n return flow(s, t, std::numeric_limits::max());\n }\n\n pair flow(int s, int t, Cap flow_limit)\n {\n return slope(s, t, flow_limit).back();\n }\n\n vector> slope(int s, int t)\n {\n return slope(s, t, numeric_limits::max());\n }\n\n vector> slope(int s, int t, Cap flow_limit)\n {\n auto res{atcoder::mcf_graph::slope(s, t, flow_limit)};\n for (auto &[cap, cost] : res)\n {\n cost -= cap * infty;\n }\n return res;\n }\n\n typename atcoder::mcf_graph::edge get_edge(int i)\n {\n auto res{atcoder::mcf_graph::get_edge(i)};\n res.cost -= infty;\n return res;\n }\n\n vector::edge> edges()\n {\n auto res{atcoder::mcf_graph::edges()};\n for (auto &e : res)\n {\n e.cost -= infty;\n }\n return res;\n }\n};\nostream &operator<<(ostream &os, typename atcoder::mcf_graph::edge const &edge)\n{\n return os << \"from: \" << edge.from << \", to: \" << edge.to << \", cap: \" << edge.cap << \", flow: \" << edge.flow << \", cost: \" << edge.cost;\n}\n// ----- StronglyConnectedComponents -----\nusing StronglyConnectedComponents = atcoder::scc_graph;\n// ----- TwoSat -----\nusing TwoSat = atcoder::two_sat;\n/***************************************************\n My Library / DP-Typical\n ***************************************************/\n// ----- LongestIncreasingSubsequence -----\ntemplate \nclass LongestIncreasingSubsequence\n{\n struct Cache_LIS\n {\n typename vector::iterator it;\n T value;\n };\n\n int n; // fixed\n T infty;\n vector dp;\n stack st;\n\npublic:\n LongestIncreasingSubsequence() {}\n LongestIncreasingSubsequence(int n, T infty = numeric_limits::max()) : n{n}, infty{infty}, dp(n, infty) {}\n\n int query(T a)\n {\n auto it{lower_bound(dp.begin(), dp.end(), a)};\n auto value{*it};\n st.push(Cache_LIS{it, value});\n *it = a;\n return lower_bound(dp.begin(), dp.end(), infty) - dp.begin();\n }\n\n bool rollback()\n {\n if (st.empty())\n {\n return false;\n }\n auto const &c{st.top()};\n *c.it = c.value;\n st.pop();\n return true;\n }\n\nprivate:\n};\n/***************************************************\n My Library / Graphs\n ***************************************************/\n// ----- LowestCommonAncestor -----\nclass LowestCommonAncestor\n{\n // helper classes\n struct Edge\n {\n // Initialized by initializer list. Take care for the order of the field.\n int src, dst;\n ll cost;\n };\n\n struct Vertex\n {\n int depth;\n ll length;\n };\n\n // fields\n int N, root, L;\n vector> E;\n vector V;\n vector> ancestors;\n\n // methods\npublic:\n LowestCommonAncestor(int N, int root = 0);\n void add_edge(int a, int b, ll c = 0);\n void init();\n void init(int root); // after adding all edges.\n\n // LowestCommonAncestor\n int operator()(int a, int b);\n\n int depth(int a, int b) { return V[a].depth + V[b].depth - 2 * V[(*this)(a, b)].depth; }\n int depth(int v) { return depth(v, root); }\n ll length(int a, int b) { return V[a].length + V[b].length - 2 * V[(*this)(a, b)].length; }\n ll length(int v) { return length(v, root); }\n int parent(int v) { return ancestors[v][0]; }\n\nprivate:\n void dfs(int v, int d = 0, ll l = 0, int p = -1);\n};\n// LowestCommonAncestor: implement\nLowestCommonAncestor::LowestCommonAncestor(int N, int root) : N{N}, root{root}, L{0}, E(N), V(N)\n{\n while ((1 << L) < N)\n {\n ++L;\n }\n ancestors = vector>(N + 1, vector(L, N));\n}\nvoid LowestCommonAncestor::add_edge(int a, int b, ll c)\n{\n E[a].push_back(LowestCommonAncestor::Edge{a, b, c});\n E[b].push_back(LowestCommonAncestor::Edge{b, a, c});\n}\nvoid LowestCommonAncestor::init(int root)\n{\n LowestCommonAncestor::root = root;\n init();\n}\nvoid LowestCommonAncestor::init()\n{\n dfs(root);\n for (auto i = 0; i < L - 1; i++)\n {\n for (auto v = 0; v < N; v++)\n {\n if (ancestors[v][i] != -1)\n {\n ancestors[v][i + 1] = ancestors[ancestors[v][i]][i];\n }\n }\n }\n}\nint LowestCommonAncestor::operator()(int a, int b)\n{\n if (V[a].depth > V[b].depth)\n {\n swap(a, b);\n }\n int gap = V[b].depth - V[a].depth;\n for (auto i = L - 1; i >= 0; i--)\n {\n int len{1 << i};\n if (gap >= len)\n {\n gap -= len;\n b = ancestors[b][i];\n }\n }\n if (a == b)\n {\n return a;\n }\n for (auto i = L - 1; i >= 0; i--)\n {\n int na{ancestors[a][i]};\n int nb{ancestors[b][i]};\n if (na != nb)\n {\n a = na;\n b = nb;\n }\n }\n return ancestors[a][0];\n}\nvoid LowestCommonAncestor::dfs(int v, int d, ll l, int p)\n{\n if (p != -1)\n {\n ancestors[v][0] = p;\n }\n V[v].depth = d;\n V[v].length = l;\n for (auto const &e : E[v])\n {\n int u{e.dst};\n if (u == p)\n {\n continue;\n }\n dfs(u, d + 1, l + e.cost, v);\n }\n}\n// ----- WarshallFloyd -----\ntemplate \nvoid WarshallFloyd(vector> &V, T infinity = numeric_limits::max())\n{\n // It is valid to apply this method for\n // - a directed/undirected graph,\n // - a graph whose edge may be negative.\n // - Negative cycle can be detected by V[i][i] < 0 if we initialize V[i][i] = 0.\n auto N{static_cast(V.size())};\n for (auto k{0}; k < N; ++k)\n {\n for (auto i{0}; i < N; ++i)\n {\n for (auto j{0}; j < N; ++j)\n {\n if (V[i][k] == infinity || V[k][j] == infinity)\n {\n continue;\n }\n ch_min(V[i][j], V[i][k] + V[k][j]);\n }\n }\n }\n}\n/***************************************************\n My Library / Math\n ***************************************************/\n// ----- Permutation -----\nstruct Permutation\n{\n vector V;\n\n Permutation() {}\n Permutation(vector const &V) : V{V} {}\n\n static Permutation unit(size_t N)\n {\n vector X(N);\n for (auto i = 0; i < static_cast(N); ++i)\n {\n X[i] = i;\n }\n return Permutation{X};\n }\n\n size_t size() const { return V.size(); }\n int operator[](size_t i) const { return V[i]; }\n\n Permutation inverse() const\n {\n vector Q(size());\n for (auto i = 0; i < static_cast(size()); ++i)\n {\n Q[(*this)[i]] = i;\n }\n return Permutation{Q};\n }\n\n Permutation operator*(Permutation const &Q) const\n {\n assert(size() == Q.size());\n vector R(size());\n for (auto i = 0; i < static_cast(size()); ++i)\n {\n R[i] = (*this)[Q[i]];\n }\n return Permutation{R};\n }\n\n Permutation &operator*=(Permutation const &Q)\n {\n return *this = *this * Q;\n }\n\n Permutation pow(int n)\n {\n if (n == 0)\n {\n return unit(size());\n }\n if (n & 1)\n {\n auto W{pow(n / 2)};\n return W * W;\n }\n return *this * pow(n - 1);\n }\n};\n// ----- Mat (matrix) and Vec -----\ntemplate \nusing Vec = vector;\ntemplate \nusing Mat = Vec>;\n// operators of Vec / Mat\ntemplate \nVec operator+(Vec const &A)\n{\n return A;\n}\ntemplate \nVec &operator+=(Vec &A, Vec const &B)\n{\n assert(A.size() == B.size());\n for (auto i = size_t{0}; i < A.size(); i++)\n {\n A[i] += B[i];\n }\n return A;\n}\ntemplate \nVec &operator+=(Vec &A, T K)\n{\n for (auto i = size_t{0}; i < A.size(); i++)\n {\n A[i] += K;\n }\n return A;\n}\ntemplate \nVec operator+(Vec const &A, Vec const &B)\n{\n auto C{A};\n C += B;\n return C;\n}\ntemplate \nVec operator+(Vec const &A, T K)\n{\n auto C{A};\n C += K;\n return C;\n}\ntemplate \nVec operator+(T K, Vec const &A)\n{\n return A + K;\n}\ntemplate \nVec operator-(Vec const &A)\n{\n Vec C(A.size());\n for (auto i = size_t{0}; i < A.size(); i++)\n {\n C[i] = -A[i];\n }\n return C;\n}\ntemplate \nVec &operator-=(Vec &A, Vec const &B)\n{\n return A += (-B);\n}\ntemplate \nVec &operator-=(Vec &A, T K)\n{\n return A += (-K);\n}\ntemplate \nVec operator-(Vec const &A, Vec const &B)\n{\n return A + (-B);\n}\ntemplate \nVec operator-(Vec const &A, T K)\n{\n return A + (-K);\n}\ntemplate \nVec operator-(T K, Vec const &A)\n{\n return K + (-A);\n}\ntemplate \nVec &operator*=(Vec &A, T K)\n{\n for (auto i = size_t{0}; i < A.size(); i++)\n {\n A[i] *= K;\n }\n return A;\n}\ntemplate \nVec operator*(T K, Vec const &A)\n{\n auto C{A};\n C *= K;\n return C;\n}\ntemplate \nVec operator*(Vec const &A, T K)\n{\n return K * A;\n}\ntemplate \nVec &operator/=(Vec &A, T K)\n{\n return A *= (1 / K);\n}\ntemplate \nVec operator/(Vec const &A, T K)\n{\n return A * (1 / K);\n}\ntemplate \nVec &operator++(Vec &A)\n{\n for (auto i = size_t{0}; i < A.size(); i++)\n {\n ++A[i];\n }\n return A;\n}\ntemplate \nVec operator++(Vec &A, int)\n{\n auto C{A};\n ++A;\n return C;\n}\ntemplate \nVec &operator--(Vec &A)\n{\n for (auto i = size_t{0}; i < A.size(); i++)\n {\n --A[i];\n }\n return A;\n}\ntemplate \nVec operator--(Vec &A, int)\n{\n auto C{A};\n --A;\n return C;\n}\n// generator of unit matrix\n// call example: Mat A{unit_matrix(s)};\ntemplate \nMat UnitMatrix(size_t s)\n{\n Mat res(s, Vec(s, T{0}));\n for (auto i = size_t{0}; i < s; ++i)\n {\n res[i][i] = T{1};\n }\n return res;\n}\n// multiply operators\ntemplate \nMat operator*(Mat const &A, Mat const &B)\n{\n assert(A.front().size() == B.size());\n Mat C(A.size(), Vec(B.front().size()));\n for (auto i = size_t{0}; i < A.size(); i++)\n {\n for (auto j = size_t{0}; j < B.front().size(); j++)\n {\n for (auto k = size_t{0}; k < A.front().size(); k++)\n {\n C[i][j] += A[i][k] * B[k][j];\n }\n }\n }\n return C;\n}\ntemplate \nMat &operator*=(Mat &A, Mat const &B)\n{\n auto C{A * B};\n return A = C;\n}\ntemplate \nVec operator*(Mat const &A, Vec const &V)\n{\n assert(A.front().size() == V.size());\n Vec W(A.size());\n for (auto i = size_t{0}; i < A.size(); i++)\n {\n for (auto j = size_t{0}; j < A.front().size(); j++)\n {\n W[i] += A[i][j] * V[j];\n }\n }\n return W;\n}\ntemplate \nMat Power(Mat const &A, ll n)\n{\n assert(A.size() == A.front().size());\n if (n == 0)\n {\n return UnitMatrix(A.size());\n }\n if (n & 1)\n {\n return A * pow(A, n - 1);\n }\n auto B{pow(A, n / 2)};\n return B * B;\n}\n// Transpose\ntemplate \nMat Transpose(Mat const &A)\n{\n Mat C(A.front().size(), Vec(A.size()));\n for (auto i = size_t{0}; i < A.size(); i++)\n {\n for (auto j = size_t{0}; j < A.front().size(); j++)\n {\n C[j][i] = A[i][j];\n }\n }\n return C;\n}\n/***************************************************\n My Library / Numbers\n ***************************************************/\n// ----- Sieve -----\nclass Sieve\n{\n static constexpr ll MAX_SIZE{1000010LL};\n ll N;\n vector f;\n vector prime_nums;\n\npublic:\n Sieve(ll N = MAX_SIZE) : N{N}, f(N, 0), prime_nums{}\n {\n f[0] = f[1] = -1;\n for (auto i = 2; i < N; i++)\n {\n if (f[i])\n {\n continue;\n }\n prime_nums.push_back(i);\n f[i] = i;\n for (auto j = 2 * i; j < N; j += i)\n {\n if (!f[j])\n {\n f[j] = i;\n }\n }\n }\n }\n\n bool is_prime(ll x) const\n { // 2 \\leq x \\leq MAX_SIZE^2\n if (x < N)\n {\n return f[x] == x;\n }\n for (auto e : prime_nums)\n {\n if (x % e == 0)\n {\n return false;\n }\n }\n return true;\n }\n\n vector const &primes() const\n {\n return prime_nums;\n }\n\n vector factor_list(ll x) const\n {\n if (x < 2)\n {\n return {};\n }\n vector res;\n auto it{prime_nums.begin()};\n if (x < N)\n {\n while (x != 1)\n {\n res.push_back(f[x]);\n x /= f[x];\n }\n }\n else\n {\n while (x != 1 && it != prime_nums.end())\n {\n if (x % *it == 0)\n {\n res.push_back(*it);\n x /= *it;\n }\n else\n {\n ++it;\n }\n }\n if (x != 1)\n {\n res.push_back(x);\n }\n }\n return res;\n }\n\n vector> factor(ll x) const\n {\n if (x < 2)\n {\n return {};\n }\n auto factors{factor_list(x)};\n vector> res{make_tuple(factors[0], 0)};\n for (auto x : factors)\n {\n if (x == get<0>(res.back()))\n {\n get<1>(res.back())++;\n }\n else\n {\n res.emplace_back(x, 1);\n }\n }\n return res;\n }\n};\n// ----- EulerNums -----\nclass EulerNums\n{\n static constexpr ll MAX_SIZE{1000010LL};\n ll N;\n vector table;\n\npublic:\n EulerNums(ll N = MAX_SIZE) : N{N}\n {\n table.resize(N);\n for (auto i = 0; i < N; i++)\n {\n table[i] = i;\n }\n for (auto i = 2; i < N; i++)\n {\n if (table[i] == i)\n {\n for (auto j = i; j < N; j += i)\n {\n table[j] = table[j] / i * (i - 1);\n }\n }\n }\n }\n\n ll euler(ll n)\n {\n if (n < N)\n {\n return table[N];\n }\n else\n {\n ll res{n};\n for (auto i = 2LL; i * i <= n; i++)\n {\n if (n % i == 0)\n {\n res = res / i * (i - 1);\n }\n for (; n % i == 0; n /= i)\n {\n }\n }\n if (n != 1)\n {\n res = res / n * (n - 1);\n }\n return res;\n }\n }\n};\nclass LinearMod\n{\n vector A, B, M;\n\npublic:\n LinearMod() {}\n\n void add(ll a, ll b, ll m)\n {\n A.push_back(a);\n B.push_back(b);\n M.push_back(m);\n }\n\n tuple get()\n {\n assert(A.size() == B.size() && B.size() == M.size());\n ll x{0}, m{1};\n for (auto i = size_t{0}; i < A.size(); i++)\n {\n ll a{A[i] * m};\n ll b{B[i] - A[i] * x};\n ll d{gcd(M[i], a)};\n if (b % d != 0)\n {\n return make_tuple(0, -1);\n }\n ll t{b / d * mod_inverse(a / d, M[i] / d) % (M[i] / d)};\n x = x + m * t;\n m *= M[i] / d;\n }\n return make_tuple(x % m, m);\n }\n\nprivate:\n static ll extra_gcd(ll a, ll b, ll &x, ll &y)\n {\n ll d{a};\n if (b != 0)\n {\n d = extra_gcd(b, a % b, y, x);\n y -= (a / b) * x;\n }\n else\n {\n x = 1;\n y = 0;\n }\n return d;\n }\n\n static ll mod_inverse(ll a, ll m)\n {\n ll x, y;\n extra_gcd(a, m, x, y);\n return (m + x % m) % m;\n }\n};\n/***************************************************\n My Library / Tools\n ***************************************************/\n// ----- Compressor -----\ntemplate \nclass Compressor\n{\n vector raw;\n map index;\n\npublic:\n Compressor() {}\n\n template \n Compressor(Container const &V) { append(V); }\n\n template \n Compressor(Iter first, Iter last) { append(first, last); }\n\n template \n void append(Container const &V) { append(V.begin(), V.end()); }\n\n template \n void append(Iter first, Iter last)\n {\n set S(first, last);\n raw = vector(S.begin(), S.end());\n sort(raw.begin(), raw.end());\n for (auto i = size_t{0}; i < raw.size(); ++i)\n {\n index[raw[i]] = i;\n }\n }\n\n T to_raw(int i) { return raw[i]; }\n int to_index(T t) { return index[t]; }\n};\n// ----- RunLengthCompress -----\ntemplate \nauto RunLengthCompress(T const &S) -> vector>, int>>\n{\n using U = remove_const_t>;\n vector> res;\n U c{S[0]};\n int x{0};\n for (auto e : S)\n {\n if (c == e)\n {\n ++x;\n }\n else\n {\n res.emplace_back(c, x);\n c = e;\n x = 1;\n }\n }\n res.emplace_back(c, x);\n return res;\n}\n// ----- Make 2D, 3D, 4D Vectors -----\ntemplate \nvector> Make2DVector(size_t d0, size_t d1, T v = T{})\n{\n return vector>(d0, vector(d1, v));\n}\ntemplate \nvector>> Make3DVector(size_t d0, size_t d1, size_t d2, T v = T{})\n{\n return vector>>(d0, Make2DVector(d1, d2, v));\n}\ntemplate \nvector>>> Make4DVector(size_t d0, size_t d1, size_t d2, size_t d3, T v = T{})\n{\n return vector>>>(d0, Make3DVector(d1, d2, d3, v));\n}\n// ----- vector istream and ostream -----\ntemplate \nistream &operator>>(istream &is, vector &v)\n{\n for (auto it{v.begin()}; it != v.end(); ++it)\n {\n is >> *it;\n }\n return is;\n}\ntemplate \nistream &operator>>(istream &is, vector *> &&v)\n{\n for (auto it{v.begin()}; it + 1 != v.end(); ++it)\n {\n assert((*it)->size() == (*(it + 1))->size());\n }\n auto s{(*v.begin())->size()};\n for (auto i{size_t{0}}; i < s; ++i)\n {\n for (auto it{v.begin()}; it != v.end(); ++it)\n {\n cin >> (**it)[i];\n }\n }\n return is;\n}\ntemplate \nostream &FlushVector(vector const &v, U const &s = \"\\n\", ostream &os = cout)\n{\n for (auto it{v.begin()}; it != v.end(); ++it)\n {\n os << *it;\n if (it + 1 != v.end())\n {\n os << s;\n }\n }\n return os;\n}\ntemplate \nostream &operator<<(ostream &os, vector const &v)\n{\n return FlushVector(v, \"\\n\", os);\n}\n/***************************************************\n Frequently Used Structures\n ***************************************************/\n// ----- Constants -----\n// constexpr double epsilon{1e-10};\n// constexpr ll infty{1'000'000'000'000'010LL}; // or\n// constexpr int infty{1'000'000'010};\n// constexpr int dx[4] = {1, 0, -1, 0};\n// constexpr int dy[4] = {0, 1, 0, -1};\n// ----- Yes() and No() -----\nvoid Yes()\n{\n cout << \"Yes\" << endl;\n exit(0);\n}\nvoid No()\n{\n cout << \"No\" << endl;\n exit(0);\n}\n/***************************************************\n Solutions\n ***************************************************/\n\n// ----- Solve -----\n\nclass Solve\n{\n ll N, K, M;\n Combination C;\n\npublic:\n Solve()\n {\n cin >> N >> K;\n M = 2 * N + 1;\n }\n\n void flush()\n {\n auto p{prob()};\n cout << 1 - p / 2 << endl;\n }\n\nprivate:\n mint prob()\n {\n mint ans{0};\n for (auto a{0}; M - 2 * a - 1 > 0; ++a)\n {\n for (auto b{0}; b <= M; ++b)\n {\n if (b % 2 != 0)\n {\n continue;\n }\n ll one{(M - 2 * a - 1 - b) / 2};\n if (one <= 0)\n {\n break;\n }\n mint m_one{one};\n auto p{m_one / (m_one + b) * (2 * a + 1) / (2 * a + 1 + b + 1)};\n auto q{C(one + b, K)};\n auto c{C(M, one) - C(M, one - 1)};\n#if DEBUG == 1\n if (N == 1)\n {\n cerr << \"a = \" << a << \", b = \" << b << endl;\n cerr << \"p = \" << p << \", q = \" << q << \", c = \" << c << endl;\n }\n#endif\n ans += p * q * c;\n }\n }\n for (auto a{0}; M - 2 * a > 0; ++a)\n {\n for (auto b{0}; b <= M; ++b)\n {\n if (b % 2 != 1)\n {\n continue;\n }\n ll one{(M - 2 * a - b) / 2};\n if (one <= 0)\n {\n break;\n }\n mint m_one{one};\n auto p{m_one / (m_one + b) * (2 * a + 1) / (2 * a + b + 1)};\n auto q{C(one + b, K)};\n auto c{C(M, one) - C(M, one - 1)};\n#if DEBUG == 1\n if (N == 1)\n {\n cerr << \"a = \" << a << \", b = \" << b << endl;\n cerr << \"p = \" << p << \", q = \" << q << \", c = \" << c << endl;\n }\n#endif\n ans += p * q * c;\n }\n }\n return ans / C(M, K) / mint{2}.pow(M - K);\n }\n};\n\n// ----- main() -----\n\nint main()\n{\n Solve solve;\n solve.flush();\n}\n", "meta": {"hexsha": "582c576fd5bf55b12892be4e066f6fb619f6c703", "size": 25287, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "2021/0530_AGC053/F.cpp", "max_stars_repo_name": "kazunetakahashi/atcoder", "max_stars_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2019-03-24T14:06:29.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-17T21:16:36.000Z", "max_issues_repo_path": "2021/0530_AGC053/F.cpp", "max_issues_repo_name": "kazunetakahashi/atcoder", "max_issues_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "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": "2021/0530_AGC053/F.cpp", "max_forks_repo_name": "kazunetakahashi/atcoder", "max_forks_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-07-22T17:27:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-22T17:27:09.000Z", "avg_line_length": 20.8466611707, "max_line_length": 139, "alphanum_fraction": 0.4959069878, "num_tokens": 7995, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577681158979306, "lm_q2_score": 0.6370307944803831, "lm_q1q2_score": 0.5464247043504}} {"text": "// Copyright (c) 2020 Chris Richardson & Matthew Scroggs\n// FEniCS Project\n// SPDX-License-Identifier: MIT\n\n#include \"nedelec.h\"\n#include \"dof-permutations.h\"\n#include \"lagrange.h\"\n#include \"moments.h\"\n#include \"polyset.h\"\n#include \"quadrature.h\"\n#include \"raviart-thomas.h\"\n#include \n#include \n#include \n\nusing namespace libtab;\n\nnamespace\n{\n//-----------------------------------------------------------------------------\nEigen::MatrixXd create_nedelec_2d_space(int degree)\n{\n // Number of order (degree) vector polynomials\n const int nv = degree * (degree + 1) / 2;\n\n // Number of order (degree-1) vector polynomials\n const int ns0 = (degree - 1) * degree / 2;\n\n // Number of additional polynomials in Nedelec set\n const int ns = degree;\n\n // Tabulate polynomial set at quadrature points\n auto [Qpts, Qwts]\n = quadrature::make_quadrature(cell::type::triangle, 2 * degree);\n Eigen::ArrayXXd Pkp1_at_Qpts\n = polyset::tabulate(cell::type::triangle, degree, 0, Qpts)[0];\n\n const int psize = Pkp1_at_Qpts.cols();\n\n // Create coefficients for order (degree-1) vector polynomials\n Eigen::MatrixXd wcoeffs = Eigen::MatrixXd::Zero(nv * 2 + ns, psize * 2);\n wcoeffs.block(0, 0, nv, nv) = Eigen::MatrixXd::Identity(nv, nv);\n wcoeffs.block(nv, psize, nv, nv) = Eigen::MatrixXd::Identity(nv, nv);\n\n // Create coefficients for the additional Nedelec polynomials\n for (int i = 0; i < ns; ++i)\n {\n for (int k = 0; k < psize; ++k)\n {\n wcoeffs(2 * nv + i, k) = (Qwts * Pkp1_at_Qpts.col(ns0 + i) * Qpts.col(1)\n * Pkp1_at_Qpts.col(k))\n .sum();\n wcoeffs(2 * nv + i, k + psize) = (-Qwts * Pkp1_at_Qpts.col(ns0 + i)\n * Qpts.col(0) * Pkp1_at_Qpts.col(k))\n .sum();\n }\n }\n\n return wcoeffs;\n}\n//-----------------------------------------------------------------------------\nEigen::MatrixXd create_nedelec_2d_dual(int degree)\n{\n // Number of dofs and size of polynomial set P(k+1)\n const int ndofs = 3 * degree + degree * (degree - 1);\n const int psize = (degree + 1) * (degree + 2) / 2;\n\n // Dual space\n Eigen::MatrixXd dual = Eigen::MatrixXd::Zero(ndofs, psize * 2);\n\n // dof counter\n const int quad_deg = 5 * degree;\n\n // Integral representation for the boundary (edge) dofs\n dual.block(0, 0, 3 * degree, psize * 2)\n = moments::make_tangent_integral_moments(\n create_dlagrange(cell::type::interval, degree - 1),\n cell::type::triangle, 2, degree, quad_deg);\n\n if (degree > 1)\n {\n // Interior integral moment\n dual.block(3 * degree, 0, degree * (degree - 1), psize * 2)\n = moments::make_integral_moments(\n create_dlagrange(cell::type::triangle, degree - 2),\n cell::type::triangle, 2, degree, quad_deg);\n }\n\n return dual;\n}\n//-----------------------------------------------------------------------------\nstd::vector create_nedelec_2d_base_perms(int degree)\n{\n const int ndofs = degree * (degree + 2);\n std::vector base_permutations(\n 3, Eigen::MatrixXd::Identity(ndofs, ndofs));\n\n Eigen::ArrayXi edge_ref = dofperms::interval_reflection(degree);\n for (int edge = 0; edge < 3; ++edge)\n {\n const int start = edge_ref.size() * edge;\n for (int i = 0; i < edge_ref.size(); ++i)\n {\n base_permutations[edge](start + i, start + i) = 0;\n base_permutations[edge](start + i, start + edge_ref[i]) = 1;\n }\n }\n\n Eigen::ArrayXXd edge_dir\n = dofperms::interval_reflection_tangent_directions(degree);\n for (int edge = 0; edge < 3; ++edge)\n {\n Eigen::MatrixXd directions = Eigen::MatrixXd::Identity(ndofs, ndofs);\n directions.block(edge_dir.rows() * edge, edge_dir.cols() * edge,\n edge_dir.rows(), edge_dir.cols())\n = edge_dir;\n base_permutations[edge] *= directions;\n }\n\n return base_permutations;\n}\n//-----------------------------------------------------------------------------\nEigen::MatrixXd create_nedelec_3d_space(int degree)\n{\n // Reference tetrahedron\n const int tdim = 3;\n\n // Number of order (degree) vector polynomials\n const int nv = degree * (degree + 1) * (degree + 2) / 6;\n\n // Number of order (degree-1) vector polynomials\n const int ns0 = (degree - 1) * degree * (degree + 1) / 6;\n // Number of additional Nedelec polynomials that could be added\n const int ns = degree * (degree + 1) / 2;\n // Number of polynomials that would be included that are not independent so\n // are removed\n const int ns_remove = degree * (degree - 1) / 2;\n\n // Number of dofs in the space, ie size of polynomial set\n const int ndofs = 6 * degree + 4 * degree * (degree - 1)\n + (degree - 2) * (degree - 1) * degree / 2;\n\n // Tabulate polynomial basis at quadrature points\n auto [Qpts, Qwts]\n = quadrature::make_quadrature(cell::type::tetrahedron, 2 * degree);\n Eigen::ArrayXXd Pkp1_at_Qpts\n = polyset::tabulate(cell::type::tetrahedron, degree, 0, Qpts)[0];\n const int psize = Pkp1_at_Qpts.cols();\n\n // Create coefficients for order (degree-1) polynomials\n Eigen::MatrixXd wcoeffs = Eigen::MatrixXd::Zero(ndofs, psize * tdim);\n for (int i = 0; i < tdim; ++i)\n {\n wcoeffs.block(nv * i, psize * i, nv, nv)\n = Eigen::MatrixXd::Identity(nv, nv);\n }\n\n // Create coefficients for additional Nedelec polynomials\n for (int i = 0; i < ns; ++i)\n {\n for (int k = 0; k < psize; ++k)\n {\n const double w = (Qwts * Pkp1_at_Qpts.col(ns0 + i) * Qpts.col(2)\n * Pkp1_at_Qpts.col(k))\n .sum();\n // Don't include polynomials (*, *, 0) that are dependant\n if (i >= ns_remove)\n wcoeffs(tdim * nv + i - ns_remove, psize + k) = -w;\n wcoeffs(tdim * nv + i + ns - ns_remove, k) = w;\n }\n }\n\n for (int i = 0; i < ns; ++i)\n {\n for (int k = 0; k < psize; ++k)\n {\n const double w = (Qwts * Pkp1_at_Qpts.col(ns0 + i) * Qpts.col(1)\n * Pkp1_at_Qpts.col(k))\n .sum();\n wcoeffs(tdim * nv + i + ns * 2 - ns_remove, k) = -w;\n // Don't include polynomials (*, *, 0) that are dependant\n if (i >= ns_remove)\n wcoeffs(tdim * nv + i - ns_remove, psize * 2 + k) = w;\n }\n }\n\n for (int i = 0; i < ns; ++i)\n {\n for (int k = 0; k < psize; ++k)\n {\n const double w = (Qwts * Pkp1_at_Qpts.col(ns0 + i) * Qpts.col(0)\n * Pkp1_at_Qpts.col(k))\n .sum();\n wcoeffs(tdim * nv + i + ns - ns_remove, psize * 2 + k) = -w;\n wcoeffs(tdim * nv + i + ns * 2 - ns_remove, psize + k) = w;\n }\n }\n\n return wcoeffs;\n}\n//-----------------------------------------------------------------------------\nEigen::MatrixXd create_nedelec_3d_dual(int degree)\n{\n const int tdim = 3;\n\n // Size of polynomial set P(k+1)\n const int psize = (degree + 1) * (degree + 2) * (degree + 3) / 6;\n\n // Work out number of dofs\n const int ndofs = 6 * degree + 4 * degree * (degree - 1)\n + (degree - 2) * (degree - 1) * degree / 2;\n Eigen::MatrixXd dual = Eigen::MatrixXd::Zero(ndofs, psize * tdim);\n\n // Create quadrature scheme on the edge\n const int quad_deg = 5 * degree;\n\n // Integral representation for the boundary (edge) dofs\n dual.block(0, 0, 6 * degree, psize * 3)\n = moments::make_tangent_integral_moments(\n create_dlagrange(cell::type::interval, degree - 1),\n cell::type::tetrahedron, 3, degree, quad_deg);\n\n if (degree > 1)\n {\n // Integral moments on faces\n dual.block(6 * degree, 0, 4 * (degree - 1) * degree, psize * 3)\n = moments::make_integral_moments(\n create_dlagrange(cell::type::triangle, degree - 2),\n cell::type::tetrahedron, 3, degree, quad_deg);\n }\n\n if (degree > 2)\n {\n // Interior integral moment\n dual.block(6 * degree + 4 * degree * (degree - 1), 0,\n (degree - 2) * (degree - 1) * degree / 2, psize * 3)\n = moments::make_integral_moments(\n create_dlagrange(cell::type::tetrahedron, degree - 3),\n cell::type::tetrahedron, 3, degree, quad_deg);\n }\n\n return dual;\n}\n//-----------------------------------------------------------------------------\nstd::vector create_nedelec_3d_base_perms(int degree)\n{\n const int ndofs = 6 * degree + 4 * degree * (degree - 1)\n + (degree - 2) * (degree - 1) * degree / 2;\n std::vector base_permutations(\n 14, Eigen::MatrixXd::Identity(ndofs, ndofs));\n\n Eigen::ArrayXi edge_ref = dofperms::interval_reflection(degree);\n for (int edge = 0; edge < 6; ++edge)\n {\n const int start = edge_ref.size() * edge;\n for (int i = 0; i < edge_ref.size(); ++i)\n {\n base_permutations[edge](start + i, start + i) = 0;\n base_permutations[edge](start + i, start + edge_ref[i]) = 1;\n }\n }\n Eigen::ArrayXi face_rot = dofperms::triangle_rotation(degree - 1);\n Eigen::ArrayXi face_ref = dofperms::triangle_reflection(degree - 1);\n for (int face = 0; face < 4; ++face)\n {\n const int start = edge_ref.size() * 6 + face_ref.size() * 2 * face;\n for (int i = 0; i < face_rot.size(); ++i)\n {\n for (int b = 0; b < 2; ++b)\n {\n const int p = 6 + 2 * face;\n const int p1 = start + 2 * i + b;\n base_permutations[p](p1, start + i * 2 + b) = 0;\n base_permutations[p](p1, start + face_rot[i] * 2 + b) = 1;\n base_permutations[p + 1](p1, start + i * 2 + b) = 0;\n base_permutations[p + 1](p1, start + face_ref[i] * 2 + b) = 1;\n }\n }\n }\n\n Eigen::ArrayXXd edge_dir\n = dofperms::interval_reflection_tangent_directions(degree);\n for (int edge = 0; edge < 6; ++edge)\n {\n Eigen::MatrixXd directions = Eigen::MatrixXd::Identity(ndofs, ndofs);\n directions.block(edge_dir.rows() * edge, edge_dir.cols() * edge,\n edge_dir.rows(), edge_dir.cols())\n = edge_dir;\n base_permutations[edge] *= directions;\n }\n\n // Faces\n Eigen::ArrayXXd face_dir_ref\n = dofperms::triangle_reflection_tangent_directions(degree - 1);\n Eigen::ArrayXXd face_dir_rot\n = dofperms::triangle_rotation_tangent_directions(degree - 1);\n for (int face = 0; face < 4; ++face)\n {\n // Rotate face\n Eigen::MatrixXd rotation = Eigen::MatrixXd::Identity(ndofs, ndofs);\n rotation.block(edge_dir.rows() * 6 + face_dir_rot.rows() * face,\n edge_dir.cols() * 6 + face_dir_rot.rows() * face,\n face_dir_rot.rows(), face_dir_rot.cols())\n = face_dir_rot;\n base_permutations[6 + 2 * face] *= rotation;\n\n // Reflect face\n Eigen::MatrixXd reflection = Eigen::MatrixXd::Identity(ndofs, ndofs);\n reflection.block(edge_dir.rows() * 6 + face_dir_ref.rows() * face,\n edge_dir.cols() * 6 + face_dir_ref.rows() * face,\n face_dir_ref.rows(), face_dir_ref.cols())\n = face_dir_ref;\n base_permutations[6 + 2 * face + 1] *= reflection;\n }\n\n return base_permutations;\n}\n\n//-----------------------------------------------------------------------------\nEigen::MatrixXd create_nedelec2_2d_dual(int degree)\n{\n // Number of dofs and size of polynomial set P(k+1)\n const int ndofs = (degree + 1) * (degree + 2);\n const int psize = (degree + 1) * (degree + 2) / 2;\n\n // Dual space\n Eigen::MatrixXd dual = Eigen::MatrixXd::Zero(ndofs, psize * 2);\n\n // dof counter\n int quad_deg = 5 * degree;\n\n // Integral representation for the boundary (edge) dofs\n dual.block(0, 0, 3 * (degree + 1), psize * 2)\n = moments::make_tangent_integral_moments(\n create_dlagrange(cell::type::interval, degree), cell::type::triangle,\n 2, degree, quad_deg);\n\n if (degree > 1)\n {\n // Interior integral moment\n dual.block(3 * (degree + 1), 0, (degree - 1) * (degree + 1), psize * 2)\n = moments::make_dot_integral_moments(\n create_rt(cell::type::triangle, degree - 1), cell::type::triangle,\n 2, degree, quad_deg);\n }\n\n return dual;\n}\n//-----------------------------------------------------------------------------\nEigen::MatrixXd create_nedelec2_3d_dual(int degree)\n{\n const int tdim = 3;\n\n // Size of polynomial set P(k+1)\n const int psize = (degree + 1) * (degree + 2) * (degree + 3) / 6;\n\n // Work out number of dofs\n const int ndofs = (degree + 1) * (degree + 2) * (degree + 3) / 2;\n\n Eigen::MatrixXd dual = Eigen::MatrixXd::Zero(ndofs, psize * tdim);\n\n // Create quadrature scheme on the edge\n int quad_deg = 5 * degree;\n\n // Integral representation for the boundary (edge) dofs\n dual.block(0, 0, 6 * (degree + 1), psize * 3)\n = moments::make_tangent_integral_moments(\n create_dlagrange(cell::type::interval, degree),\n cell::type::tetrahedron, 3, degree, quad_deg);\n\n if (degree > 1)\n {\n // Integral moments on faces\n dual.block(6 * (degree + 1), 0, 4 * (degree - 1) * (degree + 1), psize * 3)\n = moments::make_dot_integral_moments(\n create_rt(cell::type::triangle, degree - 1),\n cell::type::tetrahedron, 3, degree, quad_deg);\n }\n\n if (degree > 2)\n {\n // Interior integral moment\n dual.block((6 + 4 * (degree - 1)) * (degree + 1), 0,\n (degree - 1) * (degree - 2) * (degree + 1) / 2, psize * 3)\n = moments::make_integral_moments(\n create_dlagrange(cell::type::tetrahedron, degree - 2),\n cell::type::tetrahedron, 3, degree, quad_deg);\n }\n\n return dual;\n}\n\n} // namespace\n\n//-----------------------------------------------------------------------------\nFiniteElement libtab::create_nedelec(cell::type celltype, int degree,\n const std::string& name)\n{\n Eigen::MatrixXd wcoeffs;\n Eigen::MatrixXd dual;\n std::vector perms;\n std::vector directions;\n if (celltype == cell::type::triangle)\n {\n wcoeffs = create_nedelec_2d_space(degree);\n dual = create_nedelec_2d_dual(degree);\n perms = create_nedelec_2d_base_perms(degree);\n }\n else if (celltype == cell::type::tetrahedron)\n {\n wcoeffs = create_nedelec_3d_space(degree);\n dual = create_nedelec_3d_dual(degree);\n perms = create_nedelec_3d_base_perms(degree);\n }\n else\n throw std::runtime_error(\"Invalid celltype in Nedelec\");\n\n // Nedelec has d dofs on each edge, d(d-1) on each face\n // and d(d-1)(d-2)/2 on the interior in 3D\n const std::vector>> topology\n = cell::topology(celltype);\n std::vector> entity_dofs(topology.size());\n entity_dofs[0].resize(topology[0].size(), 0);\n entity_dofs[1].resize(topology[1].size(), degree);\n entity_dofs[2].resize(topology[2].size(), degree * (degree - 1));\n const int tdim = cell::topological_dimension(celltype);\n if (tdim > 2)\n entity_dofs[3] = {degree * (degree - 1) * (degree - 2) / 2};\n\n const Eigen::MatrixXd coeffs = compute_expansion_coefficients(wcoeffs, dual);\n return FiniteElement(name, celltype, degree, {tdim}, coeffs, entity_dofs,\n perms);\n}\n//-----------------------------------------------------------------------------\nFiniteElement libtab::create_nedelec2(cell::type celltype, int degree,\n const std::string& name)\n{\n const int tdim = cell::topological_dimension(celltype);\n const int psize = polyset::dim(celltype, degree);\n Eigen::MatrixXd wcoeffs\n = Eigen::MatrixXd::Identity(tdim * psize, tdim * psize);\n\n Eigen::MatrixXd dual;\n if (celltype == cell::type::triangle)\n dual = create_nedelec2_2d_dual(degree);\n else if (celltype == cell::type::tetrahedron)\n dual = create_nedelec2_3d_dual(degree);\n else\n throw std::runtime_error(\"Invalid celltype in Nedelec\");\n\n // TODO: Implement base permutations\n const std::vector>> topology\n = cell::topology(celltype);\n const int ndofs = dual.rows();\n int perm_count = 0;\n for (int i = 1; i < tdim; ++i)\n perm_count += topology[i].size() * i;\n std::vector base_permutations(\n perm_count, Eigen::MatrixXd::Identity(ndofs, ndofs));\n\n const Eigen::MatrixXd coeffs = compute_expansion_coefficients(wcoeffs, dual);\n\n // Nedelec(2nd kind) has (d+1) dofs on each edge, (d+1)(d-1) on each face\n // and (d-2)(d-1)(d+1)/2 on the interior in 3D\n std::vector> entity_dofs(topology.size());\n entity_dofs[0].resize(topology[0].size(), 0);\n entity_dofs[1].resize(topology[1].size(), degree + 1);\n entity_dofs[2].resize(topology[2].size(), (degree + 1) * (degree - 1));\n if (tdim > 2)\n entity_dofs[3] = {(degree - 2) * (degree - 1) * (degree + 1) / 2};\n\n return FiniteElement(name, celltype, degree, {tdim}, coeffs, entity_dofs,\n base_permutations);\n}\n//-----------------------------------------------------------------------------\n", "meta": {"hexsha": "a918c7c20aea12152163d550c6126d97d2157558", "size": 16879, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "cpp/nedelec.cpp", "max_stars_repo_name": "chrisrichardson/libtab", "max_stars_repo_head_hexsha": "1f6593409bf51427bd6d8d1036bb885f5fbb7a8c", "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": "cpp/nedelec.cpp", "max_issues_repo_name": "chrisrichardson/libtab", "max_issues_repo_head_hexsha": "1f6593409bf51427bd6d8d1036bb885f5fbb7a8c", "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": "cpp/nedelec.cpp", "max_forks_repo_name": "chrisrichardson/libtab", "max_forks_repo_head_hexsha": "1f6593409bf51427bd6d8d1036bb885f5fbb7a8c", "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": 35.4600840336, "max_line_length": 79, "alphanum_fraction": 0.5761004799, "num_tokens": 4999, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677583778258, "lm_q2_score": 0.6442251133170357, "lm_q1q2_score": 0.5462821252301475}} {"text": "#pragma once\n\n#include \n#include \n#include \n\n#include \"FiniteFields.hpp\"\n#include \"FastFourierTransform.hpp\"\n\nnamespace ligero {\ntemplate \nclass \t\tSecretSharing {\n\tpublic:\n\t\t/* Constructors allowing some flexibility in the choice of domains */\n\t\tSecretSharing(size_t lSecretLength, size_t kDegree, size_t nShares) : lSecretLength_(lSecretLength), kDegree_(kDegree), nNumberShares_(nShares) {\n\t\t\t// In this implementation, we use an evaluation domain that is twice the size of the number of shares, and we discard\n\t\t\tthis->dCompositeDomainSize_ = nShares;\n\t\t};\n\n\t\tint share(FieldT *secret);\n\t\tint reconstruct(FieldT *eval, bool expanded = false);\n\n\t\tint padMany(FieldT *secrets, size_t lrows);\n\t\tint padIntrablocRandomnessMany(FieldT *secret, size_t lrows);\n\t\tint shareMany(FieldT *secrets, size_t lrows);\n\t\tint reconstructMany(FieldT *secrets, size_t lrows);\n\n\t\tbool degreeTest(FieldT *eval);\n\t\tbool zeroTest(FieldT *eval, bool expanded = false);\n\t\tbool zeroSumTest(FieldT *eval);\n\n\tprotected:\n\t\tint padSecret(FieldT *secret);\n\t\tint padPolynominal(FieldT *secret);\n\t\tint padShares(FieldT *secret);\n\t\tint padIntrablocRandomness(FieldT *secret);\n\n\t\tsize_t\tlSecretLength_;\n\t\tsize_t\tkDegree_;\n\t\tsize_t\tnNumberShares_;\n\t\tsize_t\tdCompositeDomainSize_;\n\t\tstd::vector rootsOfUnity_;\n};\n\ntemplate \nint SecretSharing::padSecret(FieldT *secret) {\n\tFieldT::randomVector(secret + this->lSecretLength_, this->kDegree_ - this->lSecretLength_, true);\n\treturn 0;\n}\n\ntemplate \nint SecretSharing::padIntrablocRandomness(FieldT *secret) {\n\tfor (size_t i = this->lSecretLength_; i < kDegree_ ;i++) {\n\t\tsecret[i] = FieldT(0); \n\t}\n\n\treturn 0;\n}\n\ntemplate \nint SecretSharing::padPolynominal(FieldT *secret) {\n\tfor (size_t i = this->kDegree_; i < nNumberShares_;i++) {\n\t\tsecret[i] = FieldT(0);\n\t}\n\n\treturn 0;\n}\n\ntemplate \nint SecretSharing::padShares(FieldT *secret) {\n\tfor (size_t i = this->nNumberShares_; i < dCompositeDomainSize_ ;i++) {\n\t\tsecret[i] = FieldT(0);\n\t}\n\n\treturn 0;\n}\n\ntemplate \nint SecretSharing::padMany(FieldT *secret, size_t lrows) {\n\n\t// Add randomness for padding\n\tfor (size_t i = 0; i < lrows; i++) {\n\t\tthis->padSecret(secret + i * this->nNumberShares_);\n\t}\n\n\treturn 0;\n}\n\ntemplate \nint SecretSharing::padIntrablocRandomnessMany(FieldT *secret, size_t lrows) {\n\n\t// Add randomness for padding\n\tfor (size_t i = 0; i < lrows; i++) {\n\t\tthis->padIntrablocRandomness(secret + i * this->nNumberShares_);\n\t}\n\n\treturn 0;\n}\n\ntemplate \nint SecretSharing::share(FieldT *secret) {\n\n\t// Interpolate a polynomial of degree k for the secret\n iFFT(secret, kDegree_, rootsOfUnity_);\n\n\t// Evaluate the polynomial on a coset within the composite domain (size numberShares)\n\tthis->padPolynominal(secret);\n\tFFT(secret, nNumberShares_, FieldT(FieldT::getOmega(nNumberShares_)), rootsOfUnity_);\n\n\treturn 0;\n}\n\ntemplate \ninline int SecretSharing::reconstruct(FieldT *eval, bool expandedDegree) {\n\tsize_t degree = kDegree_;\n\tiFFT(eval, nNumberShares_, FieldT(FieldT::getOmega(nNumberShares_)), rootsOfUnity_);\n\n\tif (expandedDegree) {\n\t\tfor (size_t i = 0; i < kDegree_; i++) {eval[i] = eval[i] + eval[i + kDegree_];}\n\t}\n\n FFT(eval, degree, rootsOfUnity_);\n\n\treturn 0;\n}\n\ntemplate \nbool SecretSharing::degreeTest(FieldT *eval) {\n\n\tstd::vector localCopy(eval, eval + this->nNumberShares_);\n\tiFFT(&localCopy[0], nNumberShares_, FieldT::getOmega(nNumberShares_), rootsOfUnity_);\n\n\tfor (size_t i = kDegree_; i < nNumberShares_; i++) {\n\t\tif (!(localCopy[i] == FieldT(0))) {\n\t\t\tDBG(\"val:\"<< localCopy[i].getValue() << \",degree>\" << i);\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n\ntemplate \nbool SecretSharing::zeroTest(FieldT *eval, bool largerDegree) {\n\n\tstd::vector localCopy(eval, eval + this->nNumberShares_);\n\treconstruct(&localCopy[0], largerDegree);\n\n\tfor (size_t i = 0; i < this->lSecretLength_; i++) {\n\t\tif (!(localCopy[i] == FieldT(0))) return false;\n\t}\n\n\treturn true;\n}\n\ntemplate \nbool SecretSharing::zeroSumTest(FieldT *eval) {\n\t\n\tstd::vector localCopy(eval, eval+ this->nNumberShares_);\n\treconstruct(&localCopy[0], true);\n\n\tFieldT sum = FieldT(0);\n\tfor (size_t i = 0; i < this->lSecretLength_; i++) {\n\t\tsum += localCopy[i];\n\t}\n\n\tif (sum == FieldT(0)) return true;\n\telse return false;\n}\n\ntemplate \nint SecretSharing::shareMany(FieldT *secret, size_t lrows) {\n\n\t// std::cout << \"Performing FFTs: \" << lrows << std::endl; \n\tfor (size_t i = 0; i < lrows; i++) {\n\t\tshare(secret + i * this->nNumberShares_);\n\t}\n\n\treturn 0;\n}\n\ntemplate \nint SecretSharing::reconstructMany(FieldT *secret, size_t lrows) {\n\n\tfor (size_t i = 0; i < lrows; i++) {\n\t\treconstruct(secret + i * this->nNumberShares_);\n\t}\n\n\treturn 0;\n}\n\n\n}\n", "meta": {"hexsha": "1dc354885cdde57a61ee44b55946c5a371235652", "size": 5049, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/SecretSharing.hpp", "max_stars_repo_name": "Eleven-Z/LigeroRSA", "max_stars_repo_head_hexsha": "17d8b3d00604da1e0272035e871fac3add8d7551", "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/SecretSharing.hpp", "max_issues_repo_name": "Eleven-Z/LigeroRSA", "max_issues_repo_head_hexsha": "17d8b3d00604da1e0272035e871fac3add8d7551", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-08-09T05:48:09.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-09T05:48:09.000Z", "max_forks_repo_path": "include/SecretSharing.hpp", "max_forks_repo_name": "Eleven-Z/LigeroRSA", "max_forks_repo_head_hexsha": "17d8b3d00604da1e0272035e871fac3add8d7551", "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.0257731959, "max_line_length": 147, "alphanum_fraction": 0.7130124777, "num_tokens": 1448, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677737461006, "lm_q2_score": 0.6442250996557036, "lm_q1q2_score": 0.5462821235464068}} {"text": "// error_policies_example.cpp\r\n\r\n// Copyright Paul A. Bristow 2007.\r\n// Copyright John Maddock 2007.\r\n\r\n// Use, modification and distribution are subject to the\r\n// Boost Software License, Version 1.0.\r\n// (See accompanying file LICENSE_1_0.txt\r\n// or copy at http://www.boost.org/LICENSE_1_0.txt)\r\n\r\n#include \r\n using boost::math::normal_distribution;\r\n\r\n#include \r\n using boost::math::students_t; // Probability of students_t(df, t).\r\n using boost::math::students_t_distribution;\r\n\r\n// using namespace boost::math;\r\n//.\\error_policy_normal.cpp(30) : error C2872: 'policy' : ambiguous symbol\r\n// could be 'I:\\Boost-sandbox\\math_toolkit\\boost/math/policies/policy.hpp(392) : boost::math::policies::policy'\r\n// or 'boost::math::policies'\r\n\r\n // So can't use this using namespace command.\r\n// Suppose we want a statistical distribution to return infinities,\r\n// rather than throw exceptions (the default policy), then we can use:\r\n\r\n// std\r\n#include \r\n using std::cout;\r\n using std::endl;\r\n\r\nusing boost::math::policies::policy;\r\n// Possible errors\r\nusing boost::math::policies::overflow_error;\r\nusing boost::math::policies::underflow_error;\r\nusing boost::math::policies::domain_error;\r\nusing boost::math::policies::pole_error;\r\nusing boost::math::policies::denorm_error;\r\nusing boost::math::policies::evaluation_error;\r\n\r\nusing boost::math::policies::ignore_error;\r\n\r\n// Define a custom policy to ignore just overflow:\r\ntypedef policy<\r\noverflow_error\r\n > my_policy;\r\n\r\n// Define another custom policy (perhaps ill-advised?)\r\n// to ignore all errors: domain, pole, overflow, underflow, denorm & evaluation:\r\ntypedef policy<\r\ndomain_error,\r\npole_error,\r\noverflow_error,\r\nunderflow_error,\r\ndenorm_error,\r\nevaluation_error\r\n > my_ignoreall_policy;\r\n\r\n// Define a new distribution with a custom policy to ignore_error\r\n// (& thus perhaps return infinity for some arguments):\r\ntypedef boost::math::normal_distribution my_normal;\r\n// Note: uses default parameters zero mean and unit standard deviation.\r\n\r\n// We could also do the same for another distribution, for example:\r\nusing boost::math::students_t_distribution;\r\ntypedef students_t_distribution my_students_t;\r\n\r\nint main()\r\n{\r\n cout << \"quantile(my_normal(), 0.05); = \" << quantile(my_normal(), 0.05) << endl; // 0.05 is argument within normal range.\r\n cout << \"quantile(my_normal(), 0.); = \" << quantile(my_normal(), 0.) << endl; // argument zero, so expect infinity.\r\n cout << \"quantile(my_normal(), 0.); = \" << quantile(my_normal(), 0.F) << endl; // argument zero, so expect infinity.\r\n\r\n cout << \"quantile(my_students_t(), 0.); = \" << quantile(my_students_t(-1), 0.F) << endl; // 'bad' argument negative, so expect NaN.\r\n\r\n#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS\r\n // Construct a (0, 1) normal distribution that ignores all errors,\r\n // returning NaN, infinity, zero, or best guess,\r\n // and NOT setting errno.\r\n normal_distribution my_normal2(0.L, 1.L); // explicit parameters for distribution.\r\n cout << \"quantile(my_normal2(), 0.); = \" << quantile(my_normal2, 0.01) << endl; // argument 0.01, so result finite.\r\n cout << \"quantile(my_normal2(), 0.); = \" << quantile(my_normal2, 0.) << endl; // argument zero, so expect infinity.\r\n#endif\r\n\r\n return 0;\r\n}\r\n\r\n/*\r\n\r\nOutput:\r\n\r\nquantile(my_normal(), 0.05); = -1.64485\r\nquantile(my_normal(), 0.); = -1.#INF\r\nquantile(my_normal(), 0.); = -1.#INF\r\nquantile(my_students_t(), 0.); = 1.#QNAN\r\nquantile(my_normal2(), 0.); = -2.32635\r\nquantile(my_normal2(), 0.); = -1.#INF\r\n\r\n*/\r\n", "meta": {"hexsha": "28fd8ff50074b589d05f2c7d3d53117cbd2d445a", "size": 3800, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libs/math/example/error_policies_example.cpp", "max_stars_repo_name": "zyiacas/boost-doc-zh", "max_stars_repo_head_hexsha": "689e5a3a0a4dbead1a960f7b039e3decda54aa2c", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2015-07-12T13:04:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-30T23:23:46.000Z", "max_issues_repo_path": "libs/math/example/error_policies_example.cpp", "max_issues_repo_name": "sdfict/boost-doc-zh", "max_issues_repo_head_hexsha": "689e5a3a0a4dbead1a960f7b039e3decda54aa2c", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "libs/math/example/error_policies_example.cpp", "max_forks_repo_name": "sdfict/boost-doc-zh", "max_forks_repo_head_hexsha": "689e5a3a0a4dbead1a960f7b039e3decda54aa2c", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2015-12-23T01:51:57.000Z", "max_forks_repo_forks_event_max_datetime": "2019-08-25T04:58:32.000Z", "avg_line_length": 38.0, "max_line_length": 134, "alphanum_fraction": 0.7044736842, "num_tokens": 986, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7634837743174788, "lm_q2_score": 0.7154239957834733, "lm_q1q2_score": 0.5462146125380583}} {"text": "/*\n * This is part of the fl library, a C++ Bayesian filtering library\n * (https://github.com/filtering-library)\n *\n * Copyright (c) 2015 Max Planck Society,\n * \t\t\t\t Autonomous Motion Department,\n * \t\t\t Institute for Intelligent Systems\n *\n * This Source Code Form is subject to the terms of the MIT License (MIT).\n * A copy of the license can be found in the LICENSE file distributed with this\n * source code.\n */\n\n/**\n * \\file sigma_point_additive_update_policy.hpp\n * \\date July 2015\n * \\author Jan Issac (jan.issac@gmail.com)\n */\n\n#pragma once\n\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n\nnamespace fl\n{\n\n// Forward declarations\ntemplate class SigmaPointUpdatePolicy;\n\ntemplate <\n typename SigmaPointQuadrature,\n typename AdditiveSensorFunction\n>\nclass SigmaPointUpdatePolicy<\n SigmaPointQuadrature,\n Additive>\n : public Descriptor\n{\npublic:\n typedef typename AdditiveSensorFunction::State State;\n typedef typename AdditiveSensorFunction::Obsrv Obsrv;\n\n enum : signed int\n {\n NumberOfPoints =\n SigmaPointQuadrature::number_of_points(SizeOf::Value)\n };\n\n typedef PointSet StatePointSet;\n typedef PointSet ObsrvPointSet;\n\n template <\n typename Belief\n >\n void operator()(const AdditiveSensorFunction& obsrv_function,\n const SigmaPointQuadrature& quadrature,\n const Belief& prior_belief,\n const Obsrv& obsrv,\n Belief& posterior_belief)\n {\n auto&& h = [&](const State& x)\n {\n return obsrv_function.expected_observation(x);\n };\n\n quadrature.propergate_gaussian(h, prior_belief, X, Z);\n\n auto&& prediction = Z.center();\n auto&& Z_c = Z.points();\n auto&& W = X.covariance_weights_vector();\n auto&& X_c = X.centered_points();\n\n auto innovation = (obsrv - prediction).eval();\n auto cov_xx = (X_c * W.asDiagonal() * X_c.transpose()).eval();\n auto cov_yy = (Z_c * W.asDiagonal() * Z_c.transpose()\n + obsrv_function.noise_covariance()).eval();\n auto cov_xy = (X_c * W.asDiagonal() * Z_c.transpose()).eval();\n auto K = (cov_xy * cov_yy.inverse()).eval();\n\n posterior_belief.dimension(prior_belief.dimension());\n posterior_belief.mean(X.mean() + K * innovation);\n posterior_belief.covariance(cov_xx - K * cov_yy * K.transpose());\n }\n\n virtual std::string name() const\n {\n return \"SigmaPointUpdatePolicy<\"\n + this->list_arguments(\n \"SigmaPointQuadrature\",\n \"Additive\")\n + \">\";\n }\n\n virtual std::string description() const\n {\n return \"Sigma Point based filter update policy for observation model\"\n \" with additive noise\";\n }\n\nprotected:\n StatePointSet X;\n ObsrvPointSet Z;\n};\n\n}\n\n\n\n", "meta": {"hexsha": "3a4c5ec1cd9183d90f192c7d2f8f188c455167c5", "size": 3219, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/fl/filter/gaussian/update_policy/sigma_point_additive_update_policy.hpp", "max_stars_repo_name": "aeolusbot-tommyliu/fl", "max_stars_repo_head_hexsha": "a50d0c9620a8f86e0cd14a5e22ee0f022d00bd02", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 17.0, "max_stars_repo_stars_event_min_datetime": "2015-07-03T06:53:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-15T20:55:12.000Z", "max_issues_repo_path": "include/fl/filter/gaussian/update_policy/sigma_point_additive_update_policy.hpp", "max_issues_repo_name": "aeolusbot-tommyliu/fl", "max_issues_repo_head_hexsha": "a50d0c9620a8f86e0cd14a5e22ee0f022d00bd02", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2015-02-20T12:48:17.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-18T08:45:13.000Z", "max_forks_repo_path": "include/fl/filter/gaussian/update_policy/sigma_point_additive_update_policy.hpp", "max_forks_repo_name": "aeolusbot-tommyliu/fl", "max_forks_repo_head_hexsha": "a50d0c9620a8f86e0cd14a5e22ee0f022d00bd02", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 15.0, "max_forks_repo_forks_event_min_datetime": "2015-02-20T11:34:14.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-15T20:55:13.000Z", "avg_line_length": 27.75, "max_line_length": 79, "alphanum_fraction": 0.6352904629, "num_tokens": 735, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767810736692, "lm_q2_score": 0.6224593452091672, "lm_q1q2_score": 0.5461936225833639}} {"text": "#include \n#include \n#include \n#include \n\nint atom(int ao_index)\n{\n int orbitals_per_atom=4;\n return ao_index / orbitals_per_atom;\n}\n\nint indexOf(std::vector my_list, std::string element)\n{\n for(size_t i=0;i my_list, std::string element)\n{\n bool found = 0;\n for(size_t i=0;i orbital_types)\n{\n int orbitals_per_atom=4;\n int orb_index = ao_index % orbitals_per_atom;\n return orbital_types[orb_index];\n}\n\nint ao_index(int atom_p, std::string orb_p, std::vector orbital_types)\n{\n int orbitals_per_atom=4;\n int p = atom_p * orbitals_per_atom;\n p += indexOf(orbital_types,orb_p);\n return p;\n}\n\nfloat chi_on_atom(std::string o1, std::string o2, std::string o3, std::vector p_orbitals,double dipole)\n{\n if(o1 == o2 && o3 == \"s\")\n return 1.0;\n bool o3_in_p_orbitals = list_contains(p_orbitals,o3);\n if((o1 == o3 && o3_in_p_orbitals) && (o2 == \"s\"))\n return dipole;\n if ((o2 == o3 && o3_in_p_orbitals) && (o1 == \"s\"))\n return dipole;\n return 0.0;\n}\n\nEigen::MatrixXd fast_fock_matrix(Eigen::MatrixXd hamiltonian, Eigen::MatrixXd interaction, Eigen::MatrixXd rho,double dipole)\n{\n std::vector orbital_types ={\"s\",\"px\", \"py\", \"pz\"};\n std::vector p_orbitals = {\"px\", \"py\", \"pz\"};\n size_t ndof = hamiltonian.rows();\n Eigen::MatrixXd fock_mat = hamiltonian;\n //Hartree potential term\n for(size_t p=0;p\n#include \nusing namespace std;\nusing namespace boost::multiprecision;\n\ncpp_int dp[55][4004];\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n int n, k, x;\n while (cin >> k >> n >> x) {\n cpp_int nom = 0;\n if (x <= k * n && x >= n) {\n for (int i = 0; i <= 50; i++)\n for (int j = 0; j <= 4000; j++)\n dp[i][j] = 0;\n\n dp[0][0] = 1;\n\n for (int i = 1; i <= k; i++)\n dp[1][i] = 1;\n\n for (int i = 2; i <= n; i++) {\n cpp_int ps = 0;\n for (int j = i; j <= k * i; j++) {\n ps += dp[i - 1][j - 1];\n if (j - i >= k)ps -= dp[i - 1][j - k - 1];\n dp[i][j] = ps;\n }\n }\n nom = dp[n][x];\n }\n\n cpp_int denom = 1;\n for (int i = 1; i <= n; i++)denom *= k;\n\n cout << nom << \"/\" << denom << endl;\n }\n\n return 0;\n}\n", "meta": {"hexsha": "bc683f478d5606d9add17bf5090271b6afe5577b", "size": 1039, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Mathematics/Probability Theory/Standard/Throw the Dice.cpp", "max_stars_repo_name": "satvik007/uva", "max_stars_repo_head_hexsha": "72a763f7ed46a34abfcf23891300d68581adeb44", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2017-08-12T06:09:39.000Z", "max_stars_repo_stars_event_max_datetime": "2018-09-16T02:31:27.000Z", "max_issues_repo_path": "Mathematics/Probability Theory/Standard/Throw the Dice.cpp", "max_issues_repo_name": "satvik007/uva", "max_issues_repo_head_hexsha": "72a763f7ed46a34abfcf23891300d68581adeb44", "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": "Mathematics/Probability Theory/Standard/Throw the Dice.cpp", "max_forks_repo_name": "satvik007/uva", "max_forks_repo_head_hexsha": "72a763f7ed46a34abfcf23891300d68581adeb44", "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.1627906977, "max_line_length": 62, "alphanum_fraction": 0.3580365736, "num_tokens": 323, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767874818409, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.5461936142810986}} {"text": "#include \n#define _USE_MATH_DEFINES\n#include \n#include \n#include \n#include \n#include \n\n\ninline uint8_t scale8u(uint8_t value, uint8_t scale) {\n\treturn (value * scale + value) >> 8;\n}\n\n\nvoid cos(boost::filesystem::path outputPath) {\n\tstd::ofstream f((outputPath / \"cos8u10.h\").string());\n\tf << \"#pragma once\" << std::endl;\n\n\t// unsigned cosine with 8 bit output and 10 bit input, shifted to positive values\n\tf << \"uint16_t FLASH cos8Table[] = {\" << std::endl;\n\tfor (int j = 0; j < 64; ++j) {\n\t\tf << \"\\t\";\n\t\tfor (int i = 0; i < 16; ++i) {\n\t\t\tdouble x = double(i + 16*j) / 512.0 * M_PI;\n\t\t\t//int y = (i | j) == 0 ? 255 : 0;\n\t\t\tint y = int(round((cos(x) + 1.0) * 127.5));\n\t\t\tf << y << \", \";\n\t\t}\n\t\tf << std::endl;\n\t}\t\n\tf << \"};\" << std::endl;\n\tf << \"inline uint8_t cos8u10(uint16_t x) {return cos8Table[x];}\" << std::endl;\n}\n\nvoid exp(boost::filesystem::path outputPath) {\n\t{\n\t\t// write exp table with 5 bit input and 16 bit output\n\t\tstd::ofstream f((outputPath / \"exp16u5.h\").string());\n\t\tf << \"#pragma once\" << std::endl;\n\t\tf << \"uint16_t FLASH exp16u5Table[] = {\" << std::endl;\n\t\tf << \"\\t0\";\n\t\tfor (int i = 1; i < 32; ++i) {\n\t\t\t// x^31 = 65535 -> x = 65535^(1/31)\n\t\t\tint y = int(round(pow(65535.0, i / 31.0)));\n\t\t\tf << \", \" << y;\n\t\t}\n\t\tf << std::endl;\n\t\tf << \"};\" << std::endl;\n\t\tf << \"inline uint16_t exp16u5(uint8_t x) {return exp16u5Table[x];}\" << std::endl;\n\t}\n\t{\n\t\t// write exp table with 8 bit input and 16 bit output\n\t\tstd::ofstream f((outputPath / \"exp16u8.h\").string());\n\t\tf << \"#pragma once\" << std::endl;\n\t\tf << \"uint16_t FLASH exp16u8Table[] = {\" << std::endl;\n\t\tf << \"\\t0\";\n\t\tfor (int i = 1; i < 256; ++i) {\n\t\t\t// x^255 = 65535 -> x = 65535^(1/255)\n\t\t\tint y = int(round(pow(65535.0, i / 255.0)));\n\t\t\tf << \", \" << y;\n\t\t}\n\t\tf << std::endl;\n\t\tf << \"};\" << std::endl;\n\t\tf << \"inline uint16_t exp16u8(uint8_t x) {return exp16u8Table[x];}\" << std::endl;\n\t}\n}\n\nvoid permute(boost::filesystem::path outputPath) {\n\t// generate permute table\n\tsrand(1337);\n\tint permute[256];\n\tfor (int i = 0; i < 256; ++i) {\n\t\tpermute[i] = i;\n\t}\n\tfor (int i = 0; i < 10000; ++i) {\n\t\tint x = rand() & 0xff;\n\t\tint y = rand() & 0xff;\n\t\tstd::swap(permute[x], permute[y]);\n\t}\n\n\t// write permutation table and function\n\tstd::ofstream f((outputPath / \"permute8.h\").string());\n\tf << \"#pragma once\" << std::endl;\n\tf << \"uint8_t FLASH permute8Table[] = {\" << std::endl;\n\tf << \"\\t\";\n\tfor (int i = 0; i < 256; ++i) {\n\t\tif (i != 0)\n\t\t\tf << \", \";\n\t\tf << permute[i];\n\t}\n\tf << std::endl;\n\tf << \"};\" << std::endl;\n\tf << \"inline uint8_t permute8(uint8_t x) {return permute8Table[x];}\" << std::endl;\n}\n\nvoid ledSerial(boost::filesystem::path outputPath) {\n\t// generate pattern to send via serial port to led strip of WS2812b etc.\n\n\t// 8 bit are transferred like this (shown inverted) where first and last bit of each block are start and stop bit:\n\t// 1xx001xx00 1xx001xx00 1xx001xx00 1xx001xx00\n\n\t// write lookup table\n\tstd::ofstream f((outputPath / \"ledSerial.h\").string());\n\tf << \"#pragma once\" << std::endl;\n\tf << \"uint32_t FLASH ledSerialTable[] = {\" << std::endl;\n\tf << \"\\t\";\n\tfor (int v = 0; v < 256; ++v) {\n\t\tif (v != 0)\n\t\t\tf << \", \";\n\t\t\n\t\t// square the value to emulate gamma of 2\n\t\tint value = scale8u(v, v);\n\t\t\n\t\t// all ones in the middle of each block, omitting start bits (inverted)\n\t\tuint32_t pattern = ~0x08080808;\n\t\tfor (int i = 0; i < 8; ++i) {\n\t\t\tif (value & (1 << i)) {\n\t\t\t\t// offsets of the \"xx\" are 1, 6, 9, 14, 17, 22, 25, 30\n\t\t\t\tint offset = 1 + 4 * i + (i & 1 ? 1 : 0);\n\t\t\t\tpattern &= ~(3 << offset);\n\t\t\t}\n\t\t}\n\t\t\n\t\tf << pattern;\n\t}\n\tf << std::endl;\n\tf << \"};\" << std::endl;\n}\n\n\n\nstruct IndexColor {\n\tint index;\n\t\n\tint red;\n\tint green;\n\tint blue;\n\n\tIndexColor() = default;\n\tIndexColor(int index, uint8_t red, uint8_t green, uint8_t blue)\n\t\t: index(index), red(red), green(green), blue(blue) {}\n};\n\ninline int toInt(std::string const & s) {\n\tint base = 10;\n\tint i = 0;\n\tif (boost::starts_with(s, \"0x\")) {\n\t\tbase = 16;\n\t\ti = 2;\n\t}\n\t\n\tint value = 0;\n\tfor (; i < s.length(); ++i) {\n\t\tvalue *= base;\n\t\tchar ch = s[i];\n\t\t\n\t\tif (ch >= '0' && ch <= '9') {\n\t\t\tvalue += ch - '0';\n\t\t} else if (base == 16) {\n\t\t\tif (ch >= 'A' && ch <= 'F')\n\t\t\t\tvalue += ch - 'A' + 10;\n\t\t\telse if (ch >= 'a' && ch <= 'f')\n\t\t\t\tvalue += ch - 'a' + 10;\n\t\t}\n\t}\n\treturn value;\n}\n\n\nvoid interpolate(std::ofstream & f, const std::string &indent, int index1, int index2, int value1, int value2) {\n\tf << value1;\n\tif (value2 != value1) {\n\t\tf << (value2 > value1 ? \" + \" : \" - \");\n\t\tf << '(';\n\t\tif ((index1 & 0xff) == 0)\n\t\t\tf << \"(uint8_t)x\";\n\t\telse\n\t\t\tf << \"(uint8_t)(x - \" << index1 << \")\";\n\t\tf << \" * \" << std::abs(value2 - value1);\n\t\tint d = index2 - index1;\n\t\tint shift = 0;\n\t\twhile (d > 1) {\n\t\t\t++shift;\n\t\t\td >>= 1;\n\t\t}\n\t\tf << \" >> \" << shift;\n\t\tf << ')';\n\t}\n}\n\nvoid subdivide(std::ofstream & os, const std::string& indent, std::vector const & palette, int begin, int end) {\n\tif (end - begin > 1) {\n\t\tint mid = (begin + end) / 2;\n\t\t\n\t\tos << indent << \"if (x < 0x\" << std::hex << palette[mid].index << std::dec << \") {\" << std::endl;\n\t\tsubdivide(os, indent + '\\t', palette, begin, mid);\n\t\tos << indent << \"} else {\" << std::endl;\n\t\tsubdivide(os, indent + '\\t', palette, mid, end);\n\t\tos << indent << \"}\" << std::endl;\n\t} else {\n\t\t// add index as comment\n\t\tos << indent << \"// 0x\" << std::hex << palette[begin].index << std::dec << std::endl;\n\n\t\t// interpolate colors\n\t\tIndexColor color1 = palette[begin];\n\t\tIndexColor color2 = palette[begin + 1];\n\t\tos << indent << \"color.red = \"; interpolate(os, indent, color1.index, color2.index, color1.red, color2.red); os << \";\" << std::endl;\n\t\tos << indent << \"color.green = \"; interpolate(os, indent, color1.index, color2.index, color1.green, color2.green); os << \";\" << std::endl;\n\t\tos << indent << \"color.blue = \"; interpolate(os, indent, color1.index, color2.index, color1.blue, color2.blue); os << \";\" << std::endl;\n\t}\n}\n\nvoid palette(boost::filesystem::path path, boost::filesystem::path outputPath) {\n\tstd::vector palette;\n\n\t// read palette\n\tstd::ifstream is(path.string());\n\tstd::string line;\n\twhile (std::getline(is, line)) {\n\t\t// remove comment\n\t\tsize_t pos = line.find(\"//\");\n\t\tif (pos != std::string::npos)\n\t\t\tline = line.substr(0, pos);\n\t\t\n\t\t// trim\n\t\tboost::algorithm::trim(line);\n\t\t\n\t\t// split\n\t\tstd::vector elements;\n\t\tboost::split(elements, line, boost::algorithm::is_any_of(\"\\t \"), boost::token_compress_on);\n\t\t\n\t\tif (elements.size() >= 2) {\n\t\t\n\t\t\tint index = toInt(elements[0]);\n\t\t\n\t\t\tif (elements.size() == 2) {\n\t\t\t\tif (elements[1] == \"loop\") {\n\t\t\t\t\tIndexColor ic = palette.front();\n\t\t\t\t\tic.index = index;\n\t\t\t\t\tpalette.push_back(ic);\n\t\t\t\t}\n\t\t\t} else if (elements.size() == 4) {\n\t\t\t\tint r = toInt(elements[1]);\n\t\t\t\tint g = toInt(elements[2]);\n\t\t\t\tint b = toInt(elements[3]);\n\t\t\t\t\n\t\t\t\tpalette.push_back(IndexColor(index, r, g, b));\n\t\t\t}\n\t\t}\n\t}\n\n\tstd::string name = path.stem().string();\n\tstd::ofstream os((outputPath / (name + \".h\")).string());\n\tos << \"#pragma once\" << std::endl;\n\tos << \"inline RGB \" << name << \"(uint16_t x) {\" << std::endl;\n\t\n\t//os << \"\\tuint8_t r, g, b;\" << std::endl;\n\tos << \"\\tRGB color;\" << std::endl;\n\n\tsubdivide(os, \"\\t\", palette, 0, palette.size()-1);\n\t\n\t//os << \"\\tRGB color;\" << std::endl;\n\t//os << \"\\tcolor.red = r;\" << std::endl;\n\t//os << \"\\tcolor.green = g;\" << std::endl;\n\t//os << \"\\tcolor.blue = b;\" << std::endl;\n\tos << \"\\treturn color;\" << std::endl;\n\n\tos << \"}\" << std::endl;\n\tos.close();\n}\n\n\n\nint main(int argc, const char **argv) {\n\tboost::filesystem::path outputPath = \"generated\";\n\tboost::filesystem::create_directory(outputPath);\n\t\n\t// generate tables\n\tcos(outputPath);\n\texp(outputPath);\n\tpermute(outputPath);\n\tledSerial(outputPath);\n\t\n\t// convert palettes in current directory\n\tboost::filesystem::path p = \".\";\n\tfor (auto & entry : boost::make_iterator_range(boost::filesystem::directory_iterator(p), {})) {\n\t\tboost::filesystem::path path = entry.path();\n\t\tstd::string ext = path.extension().string();\n\t\tif (ext == \".palette\") {\n\t\t\tpalette(path, outputPath);\n\t\t}\n\t}\n\n\treturn 0;\n}\n", "meta": {"hexsha": "bd4161981c709ac23257c36404e1f4a39e0d57b4", "size": 8090, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Generator/main.cpp", "max_stars_repo_name": "Jochen0x90h/LedControl", "max_stars_repo_head_hexsha": "2e19bf3f3db0fb4b471e95ea234534a94caa3227", "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": "Generator/main.cpp", "max_issues_repo_name": "Jochen0x90h/LedControl", "max_issues_repo_head_hexsha": "2e19bf3f3db0fb4b471e95ea234534a94caa3227", "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": "Generator/main.cpp", "max_forks_repo_name": "Jochen0x90h/LedControl", "max_forks_repo_head_hexsha": "2e19bf3f3db0fb4b471e95ea234534a94caa3227", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.3310810811, "max_line_length": 140, "alphanum_fraction": 0.5688504326, "num_tokens": 2727, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8080672135527632, "lm_q2_score": 0.6757646010190476, "lm_q1q2_score": 0.5460632181630566}} {"text": "/**\n * @file mtgp32-calc-poly.cpp\n *\n * @brief calculate characteristic polynomial for 32bit mtgp.\n *\n * @author Mutsuo Saito (Hiroshima University)\n * @author Makoto Matsumoto (Hiroshima University)\n *\n * Copyright (c) 2012 Mutsuo Saito, Makoto Matsumoto, Hiroshima\n * University and University of Tokyo. All rights reserved.\n *\n * The new BSD License is applied to this software, see LICENSE.txt\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"mtgp32-calc-poly.hpp\"\n#include \"mtgp-calc-jump.hpp\"\n#include \"mtgp32-fast.h\"\n\nusing namespace std;\nusing namespace NTL;\n\n/**\n * calculate the characteristic polynomial for given 32-bit MTGP.\n * MinPolySeq is defined in NTL.\n * @param[out] poly calculated characteristic polynomial.\n * @param[in] mtgp64 generator\n */\nvoid calc_characteristic(GF2X& poly, mtgp32_fast_t * mtgp32)\n{\n vec_GF2 seq;\n int mexp = mtgp32->params.mexp;\n seq.SetLength(2 * mexp);\n for (int i = 0; i < 2 * mexp; i++) {\n\tseq[i] = mtgp32_genrand_uint32(mtgp32) & 1;\n }\n MinPolySeq(poly, seq, mexp);\n}\n\n/**\n * calculate the characteristic polynomial for given 32-bit MTGP.\n * MinPolySeq is defined in NTL.\n * @param[out] str calculated characteristic polynomial in string format.\n * @param[in] mtgp64 generator\n */\nvoid calc_characteristic(string& str, mtgp32_fast_t * mtgp32)\n{\n GF2X poly;\n calc_characteristic(poly, mtgp32);\n polytostring(str, poly);\n}\n\nvoid calc_characteristic(uint32_t array[], int size, mtgp32_fast_t * mtgp32)\n{\n GF2X poly;\n calc_characteristic(poly, mtgp32);\n polytoarray(array, size, poly);\n}\n\n\n#if defined(MAIN)\n/**\n * main function for executable.\n * @param[in] argc number of arguments.\n * @param[in] argv an array of arguments.\n * @return 0 if normal, other abnormal.\n */\nint main(int argc, char *argv[]) {\n int mexp;\n int no;\n uint32_t seed = 1;\n mtgp32_params_fast_t *params;\n mtgp32_fast_t mtgp32;\n int rc;\n\n if (argc <= 2) {\n\tprintf(\"%s: mexp no.\\n\", argv[0]);\n\treturn 1;\n }\n mexp = strtol(argv[1], NULL, 10);\n if (errno) {\n\tprintf(\"%s: mexp no.\\n\", argv[0]);\n\treturn 2;\n }\n no = strtol(argv[2], NULL, 10);\n if (errno) {\n\tprintf(\"%s: mexp no.\\n\", argv[0]);\n\treturn 3;\n }\n switch (mexp) {\n case 11213:\n\tparams = mtgp32_params_fast_11213;\n\tbreak;\n case 23209:\n\tparams = mtgp32_params_fast_23209;\n\tbreak;\n case 44497:\n\tparams = mtgp32_params_fast_44497;\n\tbreak;\n default:\n\tprintf(\"%s: mexp no.\\n\", argv[0]);\n\tprintf(\"mexp shuould be 11213, 23209 or 44497\\n\");\n\treturn 4;\n }\n if (no >= 128 || no < 0) {\n\tprintf(\"%s: mexp no.\\n\", argv[0]);\n\tprintf(\"no must be between 0 and 127\\n\");\n\treturn 5;\n }\n params += no;\n rc = mtgp32_init(&mtgp32, params, seed);\n if (rc) {\n\tprintf(\"failure in mtgp32_init\\n\");\n\treturn -1;\n }\n mtgp32_print_idstring(&mtgp32, stdout);\n#if 0\n string s;\n calc_characteristic(s, &mtgp32);\n printf(\"%s\\n\", s.c_str());\n#else\n#endif\n mtgp32_free(&mtgp32);\n return 0;\n}\n#endif\n", "meta": {"hexsha": "c24bfe60b102de88eb065604011903ff3e1f1d4c", "size": 3129, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "mtgp32-calc-poly.cpp", "max_stars_repo_name": "mkt-matsumoto-lab/MTGP", "max_stars_repo_head_hexsha": "9cea3283dc67d9fc6cfc044b7ae38fe9ef32afb3", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 9.0, "max_stars_repo_stars_event_min_datetime": "2015-04-24T06:39:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-10T09:48:37.000Z", "max_issues_repo_path": "mtgp32-calc-poly.cpp", "max_issues_repo_name": "mkt-matsumoto-lab/MTGP", "max_issues_repo_head_hexsha": "9cea3283dc67d9fc6cfc044b7ae38fe9ef32afb3", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2022-01-10T07:15:53.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-10T07:15:53.000Z", "max_forks_repo_path": "mtgp32-calc-poly.cpp", "max_forks_repo_name": "mkt-matsumoto-lab/MTGP", "max_forks_repo_head_hexsha": "9cea3283dc67d9fc6cfc044b7ae38fe9ef32afb3", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2017-07-27T21:05:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-10T09:47:58.000Z", "avg_line_length": 23.3507462687, "max_line_length": 76, "alphanum_fraction": 0.6599552573, "num_tokens": 969, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8080672135527632, "lm_q2_score": 0.6757645879592641, "lm_q1q2_score": 0.5460632076098737}} {"text": "//\n// Created by eliezer on 07.11.16.\n//\n\n\n#include \n#include \"BatchPoissonPure.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#ifndef M_PIl\n/** The constant Pi in high precision */\n#define M_PIl 3.1415926535897932384626433832795029L\n#endif\n#ifndef M_GAMMAl\n/** Euler's constant in high precision */\n#define M_GAMMAl 0.5772156649015328606065120900824024L\n#endif\n#ifndef M_LN2l\n/** the natural logarithm of 2 in high precision */\n#define M_LN2l 0.6931471805599453094172321214581766L\n#endif\n\n\ndouble gamma_term(double a, double b, double a_latent, double b_latent, double e_latent, double elog_latent) {\n return lgamma(a_latent)-lgamma(a)+a*log(b)+a_latent*(1-log(b_latent))-b*e_latent+(a-a_latent)*elog_latent;\n}\n\nvoid compute_gama_expected(Arrayf& a_x, Arrayf& b_x, Arrayf& e_x,\n Arrayf& elog_x) {\n for ( long i=0; i< a_x.rows();i++ ){\n for( long k=0; k< a_x.cols();k++){\n e_x(i,k) = a_x(i,k)/b_x(k);\n //elog_x(i,k) = (double)(digammal(a_x(i,k))-log(b_x(k))); // using standalone implementation\n elog_x(i, k) = boost::math::digamma(a_x(i, k)) - log(b_x(k)); // using boost implementation\n\n }\n }\n}\n\nsize_t sizes_var(vars v,size_t n_ratings, size_t n_wd_entries, size_t n_users, size_t n_items,size_t k_feat, size_t n_words, size_t n_max_neighbors){\n size_t result=0;\n switch(v){\n case vars::a_beta:\n case vars::e_beta:\n case vars::elog_beta:\n result= k_feat*n_words;\n break;\n\n case vars::a_epsilon:\n case vars::e_epsilon:\n case vars::elog_epsilon:\n case vars::a_theta:\n case vars::e_theta:\n case vars::elog_theta:\n result= k_feat*n_items;\n break;\n\n case vars::e_eta:\n case vars::elog_eta:\n case vars::a_eta:\n result= k_feat*n_users;\n break;\n\n case vars::e_tau:\n case vars::elog_tau:\n case vars::a_tau:\n result= n_max_neighbors*n_users;\n break;\n\n case vars::phi:\n result=k_feat*n_wd_entries;\n break;\n case vars::xi_M:\n case vars::xi_N:\n result= k_feat*n_ratings;\n break;\n case vars::xi_S:\n result= n_max_neighbors*n_ratings;\n break;\n\n case vars::b_theta:\n case vars::b_eta:\n case vars::b_epsilon:\n case vars::b_beta:\n result= k_feat;\n break;\n\n case vars::b_tau:\n result= n_max_neighbors;\n break;\n }\n //std::cout << EnumStrings[(int)v]<<\"= \"<(2*total_memory(n_ratings,n_wd_entries, n_users, n_items,k_feat, n_words,n_max_neighbors))),\n _n_users(n_users), _n_items(n_items), _k_feat(k_feat),\n _n_words(n_words), _n_ratings(n_ratings),\n _n_wd_entries(n_wd_entries), _n_max_neighbors(n_max_neighbors),\n a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h), k(k), l(l),\n beta(arrman,n_words,k_feat,a,b),\n theta(arrman,n_items,k_feat,c,d),\n epsilon(arrman,n_items,k_feat,g,h),\n eta(arrman,n_users,k_feat,e,f),\n tau(arrman,n_users,n_max_neighbors,k,l),\n phi(arrman->makeArray(n_wd_entries,k_feat)),\n xi_M(arrman->makeArray(n_ratings,k_feat)),\n xi_N(arrman->makeArray(n_ratings,k_feat)),\n xi_S(arrman->makeArray(n_ratings,n_max_neighbors)),\n user_items_map(pairmap(n_ratings)),\n user_items_index(vector< pair>(n_users)),\n user_items_neighboors(vector< list < pair > >(n_ratings))\n{\n\n mem_use= total_memory(n_ratings,n_wd_entries, n_users, n_items,k_feat, n_words,n_max_neighbors);\n std::cout << \"total = \" << mem_use <<\"\\n\";\n std::cout << \"n_users = \" << n_users <<\"\\n\";\n std::cout << \"n_items = \" << n_items <<\"\\n\";\n std::cout << \"n_words = \" << n_words <<\"\\n\";\n std::cout << \"n_max_neighbors = \" << n_max_neighbors <<\"\\n\";\n std::cout << \"n_ratings = \" << n_ratings <<\"\\n\";\n std::cout << \"n_wd_entries = \" << n_wd_entries <<\"\\n\";\n std::cout << \"k_feat = \" << k_feat <<\"\\n\";\n\n\n\n}\n\nvoid BatchPoissonNewArray::train(size_t n_iter, double tol) {\n try {\n std::cout << \"n_iter = \" << n_iter <<\"\\n\";\n std::cout << \"tol = \" << tol <<\"\\n\";\n init_aux_latent();\n double old_elbo=-std::numeric_limits::infinity();\n double elbo=0;\n\n for(auto i=0;i(std::cout, \" , \"));\n } catch (const std::bad_alloc& e) {\n std::cout << \"Allocation failed: \" << e.what() << '\\n';\n exit(-1);\n }\n}\n\n\n\n void BatchPoissonNewArray::init_train(vector> r_entries,\n vector> w_entries,\n vector< vector > user_neighboors) {\n this->r_entries=r_entries;\n this->w_entries=w_entries;\n this->user_neighboors=user_neighboors;\n cout << \"init_train \" << endl;\n std::cout << \"r_entries.size = \" << r_entries.size() <<\"\\n\";\n std::cout << \"w_entries.size = \" << w_entries.size() <<\"\\n\";\n std::cout << \"user_neighboors.size = \" << user_neighboors.size() <<\"\\n\";\n\n\n pair temp=make_pair(0,0);\n\n size_t ud;\n for(ud=0; ud< _n_ratings;ud++) {\n auto user_u = std::get<0>(r_entries[ud]);\n auto item_i = std::get<1>(r_entries[ud]);\n temp.first=user_u;\n temp.second=item_i;\n user_items_map[temp]= ud;\n\n }\n temp=make_pair(0,0);\n size_t current_user=0;\n for(ud = 0; ud < _n_ratings; ud++) {\n auto user_u = std::get<0>(r_entries[ud]);\n auto item_i = std::get<1>(r_entries[ud]);\n tau.b_latent(user_u)+=std::get<2>(r_entries[ud]); // b_tau_user_i = l + \\sum_d r_{user_i,d}\n\n if(current_user!=user_u){\n // generate a index with beginning index and end index for item rated by user in the user_item_rating matrix\n //\n temp.second=ud;\n user_items_index[current_user]=temp;\n temp=make_pair(ud,0);\n current_user=user_u;\n //cout << \"(\"<(r_entries[ud])<<\"),\";\n\n }\n size_t neigh_ord=0;\n for(auto user_i : this->user_neighboors[user_u]){\n // test which neighboor of user_u has item_i rated and point to the index on the rating matrix\n pairmap::iterator ifind = user_items_map.find(make_pair(user_i,item_i));\n if ( ifind != user_items_map.end() ){\n // fill vector< list < pair > > user_items_neighboors;\n // list<>\n user_items_neighboors[ud].push_back(make_pair(user_i,ifind->second));\n\n }\n neigh_ord++;\n }\n }\n temp.second=_n_ratings;\n user_items_index[current_user]=temp;\n //cout << \"###########\" <(r_entries[ud]);\n auto item_i = std::get<1>(r_entries[ud]);\n auto r_ud= std::get<2>(r_entries[ud]);\n\n for(size_t k=0; k< _k_feat;k++){\n auto rudk_M=r_ud*xi_M(ud,k);\n auto rudk_N=r_ud*xi_N(ud,k);\n epsilon.a_latent(item_i,k)+=rudk_N;\n theta.a_latent(item_i,k)+=rudk_M;\n eta.a_latent(user_u,k)+=rudk_M+rudk_N;\n }\n\n for(auto neighb : user_items_neighboors[ud]) {\n tau.a_latent(user_u,neighb.first)+=r_ud*xi_S(ud,neighb.first);\n }\n }\n double temp_w;\n for(size_t dv=0; dv< _n_wd_entries;dv++){\n\n auto word_w = std::get<1>(w_entries[dv]);\n auto item_i = std::get<0>(w_entries[dv]);\n auto wdv= std::get<2>(w_entries[dv]);\n for(size_t k=0; k< _k_feat;k++) {\n temp_w=wdv*phi(dv,k);\n beta.a_latent(word_w,k)+=temp_w;\n theta.a_latent(item_i,k)+=temp_w;\n\n }\n }\n\n\n beta.init_b_latent();\n eta.init_b_latent();\n for(size_t k=0; k< _k_feat;k++) {\n double sum_d_epsilon = epsilon.e_expected.col_sum(k);\n double sum_d_theta = theta.e_expected.col_sum(k);\n beta.b_latent(k)+= sum_d_theta;\n eta.b_latent(k) += sum_d_theta + sum_d_epsilon;\n }\n beta.update_expected();\n eta.update_expected();\n\n\n theta.init_b_latent();\n epsilon.init_b_latent();\n for(size_t k=0; k< _k_feat;k++) {\n double sum_u_eta = eta.e_expected.col_sum(k);\n double sum_v_beta = beta.e_expected.col_sum(k);\n epsilon.b_latent(k) += sum_u_eta;\n theta.b_latent(k) += sum_u_eta + sum_v_beta;\n }\n theta.update_expected();\n epsilon.update_expected();\n tau.update_expected();\n\n //cout << \"END#theta\" << theta <(r_entries[ud]);\n auto item_i = std::get<1>(r_entries[ud]);\n for (auto k = 0; k < _k_feat; k++) {\n // self.xi_M = np.exp(self.Elogeta[:, np.newaxis, :] + self.Elogtheta[:, :, np.newaxis])\n xi_M(ud, k) = exp(eta.elog_expected(user_u, k) + theta.elog_expected(item_i, k));\n\n // self.xi_N = np.exp(self.Elogeta[:, np.newaxis, :] + self.Elogepsilon[:, :, np.newaxis])\n xi_N(ud, k) = exp(eta.elog_expected(user_u, k) + epsilon.elog_expected(item_i, k));\n sum_k += xi_M(ud,k) + xi_N(ud,k);\n }\n xi_S.row(ud) = 0;\n for (auto neighb : user_items_neighboors[ud]) {\n // user_items_neighboors[ud].push_back(make_pair(user_i,ifind->second));\n xi_S(ud,neighb.first) = std::get<2>(r_entries[neighb.second])\n * exp(tau.elog_expected(user_u,neighb.first));\n sum_k += xi_S(ud,neighb.first);\n\n }\n {\n xi_M.row(ud) /= sum_k;\n }\n {\n xi_N.row(ud) /= sum_k;\n }\n {\n xi_S.row(ud) /= sum_k;\n }\n }\n cout << endl;\n\n for(auto dv=0; dv< _n_wd_entries;dv++){\n sum_k=0;\n auto word_w = std::get<1>(w_entries[dv]);\n auto item_i = std::get<0>(w_entries[dv]);\n for(auto k=0; k< _k_feat;k++){\n // self.phi = np.exp(self.Elogbeta[:, np.newaxis, :] + self.Elogtheta[:, :, np.newaxis])\n phi(dv,k)=exp(beta.elog_expected(word_w,k)+theta.elog_expected(item_i,k));\n sum_k += phi(dv,k);\n }\n {\n phi.row(dv)/=sum_k;\n }\n\n }\n cout << \"#END UPDATE_AUX\" << endl;\n cout << \"#xi_M\" << xi_M.row(11685) << endl;\n cout << \"#xi_N\" << xi_N.row(11685) << endl;\n //cout << \"#xi_S\" << xi_S.row(11685) << endl;\n //cout << \"#xi_N\" << xi_N << endl;\n //cout << \"#xi_S\" << xi_S << endl;\n cout << \"#phi\" << phi.row(0) << endl;\n\n}\n\n\ndouble BatchPoissonNewArray::compute_elbo() {\n double total_sum;\n total_sum = 0.0;\n double log_sum=0;\n // poisson termo of the ELBO for user-document ratings\n // sum_u,d,k{ Eq[log p(r_ud|*) ] }\n cout << r_entries.size() << \" nrat \" << _n_ratings;\n for(size_t ud=0; ud< _n_ratings;ud++) {\n size_t user_u = std::get<0>(r_entries[ud]);\n size_t item_i = std::get<1>(r_entries[ud]);\n size_t r_ud = std::get<2>(r_entries[ud]);\n log_sum=0;\n for (size_t k = 0; k < _k_feat; k++) {\n if(xi_M(ud,k) > 0)\n log_sum += xi_M(ud,k)*(eta.elog_expected(user_u,k)+theta.elog_expected(item_i,k)-log(xi_M(ud,k)));\n if(xi_N(ud,k) > 0)\n log_sum += xi_N(ud,k)*(eta.elog_expected(user_u,k)+epsilon.elog_expected(item_i,k)-log(xi_N(ud,k)));\n if(log_sum!=log_sum)\n {\n cout << \"(NAN-logsum: ud=\"< neighb : user_items_neighboors[ud]) {\n //neighb is user_i in N(user_u), neighb.first is its index in the trust tau variable\n // user_items_neighboors[ud].push_back(make_pair(user_i,ifind->second));\n size_t r_id = std::get<2>(r_entries[neighb.second]);\n if(xi_S(ud,neighb.first) > 0)\n log_sum += xi_S(ud,neighb.first)*(tau.elog_expected(user_u,neighb.first)+log(r_id )\n -log(xi_S(ud,neighb.first)));\n }\n if(ud==0)\n cout << \"logsum = \" << log_sum << \" \";\n total_sum+=r_ud*log_sum-boost::math::lgamma(r_ud+1);\n if(boost::math::isnan( total_sum))\n cout << \"##LOG_SUM ud=\"<(r_entries[0]) << \" \" << std::get<1>(r_entries[0]) << \" \" << boost::math::lgamma(std::get<2>(r_entries[0])+1) << \" \" <(w_entries[dv]);\n size_t item_i = std::get<0>(w_entries[dv]);\n size_t w_dv = std::get<2>(w_entries[dv]);\n log_sum=0;\n for(size_t k=0; k< _k_feat;k++){\n log_sum += phi(dv,k)*(beta.elog_expected(word_w,k)+theta.elog_expected(item_i,k)- log(phi(dv,k)));\n if(boost::math::isnan( log_sum))\n cout << \"##LOG_SUM dv=\"<= 1){\n try {\n double x=boost::math::lgamma(w_dv+1);\n //cout << \"boot lgamma =\" << x << \" wdv=\" << w_dv << endl ;\n if(boost::math::isnan( log_sum))\n cout << \"##LOG_SUM dv=\"<({&beta}));\n if(boost::math::isnan( total_sum ))\n cout << \"##TOTAL_SUM theta*beta\";\n // -sum_k,d,u E[theta_dk]*E[eta_uk]+E[epsilon_dk]*E[eta_uk]\n total_sum+=eta.elbo_term_prod_linear_expectations(vector({&theta,&epsilon}));\n if(boost::math::isnan( total_sum ))\n cout << \"##TOTAL_SUM theta*eta+epsilon*eta\";\n total_sum+=tau_elbo_expected_linear_term();\n if(boost::math::isnan( total_sum ))\n cout << \"##TOTAL_SUM tau\";\n\n\n // Gamma terms for the latent variables\n total_sum+=beta.elbo_term();\n if(boost::math::isnan( total_sum ))\n cout << \"##TOTAL_SUM gamma beta\";\n total_sum+=theta.elbo_term();\n if(boost::math::isnan( total_sum ))\n cout << \"##TOTAL_SUM gamma theta\";\n total_sum+=epsilon.elbo_term();\n if(boost::math::isnan( total_sum ))\n cout << \"##TOTAL_SUM gamma epsilon\";\n total_sum+=eta.elbo_term();\n if(boost::math::isnan( total_sum ))\n cout << \"##TOTAL_SUM gamma eta\";\n total_sum+=tau.elbo_term();\n if(boost::math::isnan( total_sum ))\n cout << \"##TOTAL_SUM gamma tau\";\n return total_sum;\n}\n/*\n * TODO:\n * - Change everything about tau variable. There is two options:\n * 1) kdim of tau variable is = n_users;\n * 2) kdim of tau variable is = n_users_that_are_neighbors.\n * In beginning to think that option 1) is better, but it will need some changing in other places\n *\n * UPDATE: implemented option 1\n */\n\ndouble BatchPoissonNewArray::tau_elbo_expected_linear_term() {\n double total_sum=0;\n for(size_t u=0;u < _n_users ;u++) {\n for(size_t i : user_neighboors[u]) {\n for(size_t d=user_items_index[i].first; d(r_entries[d]);\n total_sum+=tau.e_expected(u,i)*r_id;\n }\n }\n }\n return -total_sum;\n}\n\n\nvector> BatchPoissonNewArray::estimate() {\n cout << \"begin estimate\" <> ret(_n_users);\n for(size_t user_u=0;user_u < _n_users; user_u++){\n for(size_t item_i=0;item_i < _n_items ; item_i++){\n double r_ui = 0;\n for(size_t k=0;k<_k_feat;k++){\n r_ui += eta.e_expected(user_u,k)*(epsilon.e_expected(item_i,k)+theta.e_expected(item_i,k));\n }\n for(size_t user_i : user_neighboors[user_u]){\n pairmap::iterator ifind = user_items_map.find(make_pair(user_i,item_i));\n if ( ifind != user_items_map.end() )\n r_ui += tau.e_expected(user_u,user_i)*ifind->second;\n }\n ret[user_u].push_back(r_ui);\n }\n }\n cout << \"end estimate\" < &left, const std::pair &right)\n {\n return left.first < right.first;\n }\n};\n\nvector> BatchPoissonNewArray::recommend(size_t m) {\n cout << \"begin recommend\" <> ret= estimate();\n vector> rec;\n ;\n\n for(size_t user_u=0;user_u < _n_users; user_u++)\n {\n vector> scores;\n for(size_t item_i=0;item_i < _n_items ; item_i++){\n // recommend only items that are not already rated by the user\n if(user_items_map.count(make_pair(user_u,item_i))<=0)\n scores.push_back(make_pair(ret[user_u][item_i],item_i));\n }\n std::sort(scores.begin(),scores.end());\n std::reverse(scores.begin(),scores.end());\n vector temp;\n for(size_t i=0; i < m ; i++)\n {\n //cout << \"(\" <> ret= estimate();\n\n for(size_t user_u=0;user_u < _n_users; user_u++)\n {\n vector> scores;\n for(size_t item_i=0;item_i < _n_items ; item_i++){\n // recommend only items that are not already rated by the user\n if(user_items_map.count(make_pair(user_u,item_i))<=0)\n scores.push_back(make_pair(ret[user_u][item_i],item_i));\n }\n std::sort(scores.begin(),scores.end());\n std::reverse(scores.begin(),scores.end());\n vector temp;\n for(size_t i=0; i < m ; i++)\n {\n //cout << \"(\" <(output, \"\\t\"));\n output << endl;\n }\n}\n\nBatchPoissonNewArray::~BatchPoissonNewArray() {\n arrman->~ArrayManager();\n}\n\n\nvars operator++(vars &x) { return x = (vars)(((int)(x) + 1)); }\n\n\n\nvoid gamma_latent::update_expected() {\n for ( size_t i=0; i< a_latent.rows();i++ ){\n for( size_t k=0; k< a_latent.cols();k++){\n e_expected(i,k) = a_latent(i,k)/b_latent(k);\n if(i==k && i==0)\n {\n if(boost::math::isnan( e_expected(i,k)))\n cout << \"NAN-EXP \"< vars) {\n double total_sum=0;\n for( size_t d=0;da,var->b,var->a_latent(d,k),var->b_latent(k),var->e_expected(d,k),var->elog_expected(d,k));\n }\n }\n }\n return total_sum;\n}\n\n\n\n\ngamma_latent::gamma_latent(const Arrayf &a_latent, const Arrayf &b_latent, const Arrayf &e_expected,\n const Arrayf &elog_expected, double a, double b) :\n a_latent(a_latent), b_latent(b_latent),\n e_expected(e_expected),\n elog_expected(elog_expected), a(a), b(b),\n nvars(a_latent.nrow),kdim(a_latent.ncol){}\n\nvoid gamma_latent::init_b_latent() {\n b_latent=b;\n}\n\nvoid gamma_latent::init_a_latent() {\n a_latent=a;\n\n}\n\ndouble gamma_latent::elbo_term_prod_linear_expectations(vector vars) {\n double total_sum=0;\n\n\n for(gamma_latent* var : vars)\n {\n if(var)\n {\n\n for( size_t j=0;j<(var->nvars);j++)\n {\n for (int k = 0; k < kdim; ++k)\n {\n auto expjk=var->e_expected(j,k);\n for( size_t i=0;i* arrman, size_t nrows, size_t ncols, double a, double b):\n a(a), b(b), a_latent(arrman->makeArray(nrows,ncols,a)),b_latent(arrman->makeArray(ncols,b)),\n e_expected(arrman->makeArray(nrows,ncols)),elog_expected(arrman->makeArray(nrows,ncols)),\n nvars(nrows),kdim(ncols)\n{\n\n}\n\n\n\n\n\n\n", "meta": {"hexsha": "5900dd8d25d98687fb3140f02ad4ca88e4e079a9", "size": 26752, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "BatchPoissonPure.cpp", "max_stars_repo_name": "zehsilva/poissonmf_cs", "max_stars_repo_head_hexsha": "5e870a6616ce8940d7de6aa108e005893edf184c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 9.0, "max_stars_repo_stars_event_min_datetime": "2017-09-05T12:29:12.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-15T12:44:55.000Z", "max_issues_repo_path": "BatchPoissonPure.cpp", "max_issues_repo_name": "zehsilva/poissonmf_cs", "max_issues_repo_head_hexsha": "5e870a6616ce8940d7de6aa108e005893edf184c", "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": "BatchPoissonPure.cpp", "max_forks_repo_name": "zehsilva/poissonmf_cs", "max_forks_repo_head_hexsha": "5e870a6616ce8940d7de6aa108e005893edf184c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6.0, "max_forks_repo_forks_event_min_datetime": "2017-11-30T02:19:25.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-11T05:58:39.000Z", "avg_line_length": 35.2463768116, "max_line_length": 164, "alphanum_fraction": 0.5599955144, "num_tokens": 7472, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8670357666736772, "lm_q2_score": 0.6297746074044135, "lm_q1q2_score": 0.5460371095624997}} {"text": "/*\n * world = K [R | t]\n */\n#include \n#include \n#include \n\nstruct rgbpoint\n{\n\trgbpoint(): r(0),g(0),b(0) {}\n\tchar r,g,b;\n} __attribute__((packed));\n\n// [sx 0 cx]\n// [0 sy cy]\n// [0 0 1]\n//\n// to 4x4\nvoid intrinsics2m44(Eigen::Matrix4d & out, Eigen::Matrix3d & in)\n{\n\tout.setZero();\n\tout.block<3,3>(0,0) = in;\n\tout(3,3) = 1;\n\n//\tout << in(0,0),in(0,1),0,in(0,2) ,in(1,0),in(1,1),0,in (1,2), 0,0,1,0, 0,0,0,1;\n}\n\nvoid composerotot(Eigen::Matrix4d& out, const Eigen::Matrix3d & R, const Eigen::Vector3d & T)\n{\n\t\tout.setZero();\n\t\tout.block<3,3>(0,0) = R;\n\t\tout.block<3,1>(0,3) = T;\n\t\tout(3,3) = 1;\n\n}\n\n#ifdef __MINGW32__\n#define DE __declspec(dllexport)\n#else\n#define DE\n\n#endif\n\nextern \"C\"\n{\n\tvoid DE initlibanyregistration(){}\n\t/// output is color computed as depth in sizes \n\tvoid DE register2color(char * outrgb, int cw, int ch, const char * rgb, int dw, int dh, const uint16_t * depth, const double depthK[9], const double colorK[9], const double inrotation[9], const double position[3])\n\t{\t\n\t\tstatic_assert(sizeof(rgbpoint) == 3,\"rgpoint should be 3 bytes\");\n\n\t\tfloat maxdistance_mm = 10000;\n\n\n\t\tEigen::Matrix3d rotation = Eigen::Matrix::Map(inrotation);\n\t\tEigen::Vector3d translation = Eigen::Vector3d::Map(position);\n\t\tEigen::Matrix3d depth_matrix = Eigen::Matrix::Map(depthK);\n\t\tEigen::Matrix3d rgb_matrix = Eigen::Matrix::Map(colorK);\n\n\t\tstd::cout << \"Rotation is\\n \" << rotation << std::endl;\n\t\tstd::cout << \"Kdepth is\\n\" << depth_matrix << std::endl;\n\n\t\tEigen::Matrix4d rototranslationD2R;\n\t\tEigen::Matrix4d odepth_matrix;\n\t\tEigen::Matrix4d orgb_matrix;\n\t\t\n\t\tintrinsics2m44(odepth_matrix,depth_matrix);\n\t\tintrinsics2m44(orgb_matrix,rgb_matrix);\n\t\tcomposerotot(rototranslationD2R,rotation,translation);\n\n\t\tstd::cout << \"Kdepth4 is\\n\" << odepth_matrix << std::endl;\n\n\t\tstd::cout << \"rototraslation(W->D)\\n\" << rototranslationD2R << std::endl;\n\n\t\tEigen::Matrix4d depth2rgb4 = orgb_matrix * rototranslationD2R * odepth_matrix.inverse();\n//\t\tEigen::Matrix4d depth2rgb4 = orgb_matrix * (odepth_matrix*rototranslationD2R).inverse();\n\n\t\tstd::cout << \"depth2rgb4\\n\" << depth2rgb4 << std::endl;\n\n\t\tconst uint16_t * inputdepth_mm = depth;\n\t\trgbpoint * out = (rgbpoint*)outrgb;\n\t\tconst rgbpoint * inputcolor = (rgbpoint*)rgb;\n\n\t\tmemset(out,0,dw*dh*3);\n\n\t\tfor(int y = 0; y < dh; ++y)\n\t\t{\t\n\t\t\tfor(size_t x = 0; x < dw; ++x, inputdepth_mm++,out++)\n\t\t\t{\n\t\t\t\tif(!*inputdepth_mm)\n\t\t\t\t\tcontinue;\n\n\t\t\t\t// Check for invalid measurements\n\t\t\t\tif(*inputdepth_mm >= maxdistance_mm)\n\t\t\t\t\tcontinue;\n\n\t\t\t\tconst float depth_value = *inputdepth_mm / 1000.0f;\n\n\n\t\t\t\t//Eigen::Vector4d psd(x, y, 1.0, 1.0/depth_value);\n\t\t\t\t//Eigen::Vector4d psddiv = psd * depth_value;\n\t\t\t\t//Eigen::Vector4d pworld = depth2world * psddiv;\n\t\t\t\t//Eigen::Vector4d rgb_img_homo = world2rgb * pworld;\n\n\t\t\t\tEigen::Vector4d psd(x, y, 1.0, 1.0/depth_value);\n\t\t\t\tEigen::Vector4d rgb_img_homo = depth2rgb4 * (psd * depth_value);\n\t\t\t\tEigen::Vector4d rgb_img = rgb_img_homo / rgb_img_homo.z();\n\n\n\t\t\t\tint ix = rgb_img.x();\n\t\t\t\tint iy = rgb_img.y();\n\n\t\t\t\tif(ix >= 0 && ix < cw && iy >= 0 && iy < ch)\n\t\t\t\t{\t\n\t\t\t\t\t*out = inputcolor[iy*cw+ix];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// NOT WORKING DUE TO FILLING\n\t/// output is depth computed as color in size\n\tvoid DE register2depth(uint16_t * outdepth, int cw, int ch, const char * rgb, int dw, int dh, const uint16_t * depth, const double depthK[9], const double colorK[9], const double inrotation[9], const double position[3])\n\t{\t\n\t\tfloat maxdistance = 10;\n\n\t\tEigen::Matrix3d rotation = Eigen::Matrix::Map(inrotation);\n\t\tEigen::Vector3d translation = Eigen::Vector3d::Map(position);\n\t\tEigen::Matrix3d depth_matrix = Eigen::Matrix::Map(depthK);\n\t\tEigen::Matrix3d rgb_matrix = Eigen::Matrix::Map(colorK);\n\n\t\tEigen::Matrix4d rototranslationD2R;\n\t\tEigen::Matrix4d orgb_matrix,odepth_matrix;\n\n\t\tintrinsics2m44(odepth_matrix,depth_matrix);\n\t\tintrinsics2m44(orgb_matrix,rgb_matrix);\n\t\tcomposerotot(rototranslationD2R,rotation,-translation);\n\n\n\t\t//odepth_matrix.block<3,3>(0,0) = depth_matrix;\n\t\t//odepth_matrix(3,3) = 1;\n\n\t\t//orgb_matrix.block<3,3>(0,0) = rgb_matrix;\n\t\t//orgb_matrix(3,3) = 1;\n\n\t\tstd::cout << rototranslationD2R << std::endl;\n\n\t\tEigen::Matrix4d depth2rgb4 = orgb_matrix * rototranslationD2R * odepth_matrix.inverse();\n\t\tEigen::Matrix3d rgb2depth = depth2rgb4.block<3,3>(0,0).inverse();\n\n\n\t\tmemset(outdepth,0,cw*ch*2); // cleanup output (max value)\n\t\tauto po = outdepth;\n\n\t\tfor(int y = 0; y < ch; ++y)\n\t\t{\t\n\t\t\tfor(size_t x = 0; x < cw; ++x,++po)\n\t\t\t{\n\n\t\t\t\tEigen::Vector3d rgb_i(x,y,1); // 2D homo\n\t\t\t\tEigen::Vector3d depth_sub_i = rgb2depth * rgb_i; // to 2D homo\n\t\t\t\tint ix = depth_sub_i.x();\n\t\t\t\tint iy = depth_sub_i.y();\n\n\t\t\t\t// if inside, and valid and nearer than the current\n\t\t\t\tif(ix >= 0 && ix < dw && iy >= 0 && iy < dh )\n\t\t\t\t{\n\t\t\t\t\t int off = iy*dw+ix;\n\t\t\t\t\t uint16_t current = depth[off];\n\t\t\t\t\t *po = current;\n\t\t\t\t\t //uint16_t *target = outdepth + off; // target output\n\t\t\t\t\t //if(current > 0 && (*target == 0 || *target > current))\n\t\t\t\t\t //*target = current;\n\t\t\t\t}\n\n\t\t\t\t/*\n\t\t\t\t\tTo obtain world coords\n\t\t\t\t\tEigen::Vector4d psd(depth_sub_i.x(),depth_sub_i.y(), 1.0, 1.0/newdepth);\n\t\t\t\t\tEigen::Vector4d psddiv = psd * newdepth; // (x*newdepth,y*newdepth,newdepth,1)\n\t\t\t\t\tEigen::Vector4d pworld = depth2world * psddiv;\n\t\t\t\t*/\n\t\t\t}\n\t\t}\n\t}\n}", "meta": {"hexsha": "2219e583d6cb6afb47f818df57dc5297cf567691", "size": 5460, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "extern/anyregistration/anyregistration.cpp", "max_stars_repo_name": "iiharu/pyoni", "max_stars_repo_head_hexsha": "3e62cedc1ed7dc726e421858ff143f7b7a713403", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2016-06-16T15:26:38.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-29T17:40:52.000Z", "max_issues_repo_path": "extern/anyregistration/anyregistration.cpp", "max_issues_repo_name": "iiharu/pyoni", "max_issues_repo_head_hexsha": "3e62cedc1ed7dc726e421858ff143f7b7a713403", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2016-06-16T15:39:17.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-19T16:14:53.000Z", "max_forks_repo_path": "extern/anyregistration/anyregistration.cpp", "max_forks_repo_name": "iiharu/pyoni", "max_forks_repo_head_hexsha": "3e62cedc1ed7dc726e421858ff143f7b7a713403", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2017-12-13T08:27:50.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-16T10:25:07.000Z", "avg_line_length": 29.5135135135, "max_line_length": 220, "alphanum_fraction": 0.6505494505, "num_tokens": 1914, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278664544912, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.5460290979523703}} {"text": "#include \n\nusing namespace std;\nusing namespace arma;\n\nnamespace enjambre {\n\nclass Individuo {\npublic:\n Individuo(const vector>& limites);\n\n vec getPosicion() const { return posicion; }\n void setPosicion(const vec& value);\n\n vec getVelocidad() const { return velocidad; }\n void setVelocidad(const vec& value);\n\n vec getMejorLocal() const { return mejorLocal; }\n void setMejorLocal(const vec& value);\n\n double aptitudMejorLocal;\n\n Individuo& operator=(const Individuo& other);\n\nprivate:\n const vector> m_limites;\n vec posicion;\n vec velocidad;\n vec mejorLocal;\n};\n\nIndividuo::Individuo(const vector>& limites)\n : aptitudMejorLocal{-numeric_limits::max()}\n , m_limites{limites}\n{\n const unsigned int nVariables = m_limites.size();\n\n posicion = randu(nVariables);\n\n if (m_limites.size() != nVariables)\n throw runtime_error(\"Número de límites no concuerda con la cantidad de variables\");\n\n for (unsigned int i = 0; i < posicion.n_elem; ++i) {\n double rangoVariable = m_limites.at(i).second - m_limites.at(i).first;\n\n posicion(i) = posicion(i) * rangoVariable + m_limites.at(i).first;\n }\n\n velocidad = zeros(nVariables);\n mejorLocal = posicion;\n}\n\nvoid Individuo::setPosicion(const vec& value)\n{\n if (value.n_elem != this->posicion.n_elem)\n throw runtime_error(\"La dimensión del vector es incorrecta\");\n\n for (unsigned int i = 0; i < m_limites.size(); ++i) {\n if (value.at(i) > m_limites.at(i).second)\n posicion.at(i) = m_limites.at(i).second; // Nos pasamos de largo por derecha\n else if (value.at(i) < m_limites.at(i).first)\n posicion.at(i) = m_limites.at(i).first; // Nos pasamos de largo por izquierda\n else\n posicion.at(i) = value.at(i); // No nos pasamos de largo\n }\n}\n\nvoid Individuo::setVelocidad(const vec& value)\n{\n if (value.n_elem != this->velocidad.n_elem)\n throw runtime_error(\"La dimensión del vector es incorrecta\");\n\n velocidad = value;\n}\n\nvoid Individuo::setMejorLocal(const vec& value)\n{\n if (value.n_elem != this->posicion.n_elem)\n throw runtime_error(\"La dimensión del vector es incorrecta\");\n\n mejorLocal = value;\n}\n\nIndividuo& Individuo::operator=(const Individuo& other)\n{\n if (other.m_limites != this->m_limites)\n throw runtime_error(\"Los individuos tienen distintos limites en las variables\");\n\n this->posicion = other.posicion;\n this->velocidad = other.velocidad;\n this->mejorLocal = other.mejorLocal;\n this->aptitudMejorLocal = other.aptitudMejorLocal;\n\n return *this;\n}\n\nclass Enjambre {\npublic:\n Enjambre(function fitness,\n const vector>& limites,\n const double c1,\n const double c2,\n unsigned int nIndividuos,\n int umbral);\n\n bool evaluarPoblacion();\n void epoca();\n const vector& individuos() const { return m_individuos; }\n const Individuo& mejorGlobal() const { return m_mejorGlobal; }\n double fitnessPromedio() const { return m_fitnessPromedio; }\n bool termino() const { return m_termino; }\n\nprivate:\n vector m_individuos;\n Individuo m_mejorGlobal;\n double m_mejorAptitud;\n double m_fitnessPromedio;\n function m_fitness;\n const double m_c1, m_c2;\n int m_umbral;\n int m_epocasSinMejora;\n bool m_termino;\n};\n\nEnjambre::Enjambre(function fitness,\n const vector>& limites,\n const double c1,\n const double c2,\n unsigned int nIndividuos,\n int umbral)\n : m_mejorGlobal{limites}\n , m_mejorAptitud{-numeric_limits::max()}\n , m_fitness{fitness}\n , m_c1{c1}\n , m_c2{c2}\n , m_umbral{umbral}\n , m_epocasSinMejora{0}\n , m_termino{false}\n{\n for (unsigned int i = 0; i < nIndividuos; ++i) {\n m_individuos.push_back(Individuo{limites});\n\n evaluarPoblacion();\n }\n}\n\nbool Enjambre::evaluarPoblacion()\n{\n bool mejoro = false;\n double sumaFitness = 0;\n\n for (Individuo& ind : m_individuos) {\n double aptitud = m_fitness(ind);\n sumaFitness += aptitud;\n\n if (aptitud > ind.aptitudMejorLocal) {\n ind.setMejorLocal(ind.getPosicion());\n ind.aptitudMejorLocal = aptitud;\n\n if (aptitud > m_mejorAptitud) {\n m_mejorGlobal = ind;\n m_mejorAptitud = aptitud;\n mejoro = true;\n }\n }\n }\n\n m_fitnessPromedio = sumaFitness / m_individuos.size();\n\n return mejoro;\n}\n\nvoid Enjambre::epoca()\n{\n const int nVariables = m_individuos.front().getPosicion().n_elem;\n\n for (Individuo& ind : m_individuos) {\n // Cálculo de la nueva velocidad\n // Componente cognitiva\n const vec r1 = randu(nVariables);\n const vec distanciaMejorLocal = ind.getMejorLocal() - ind.getPosicion();\n\n const vec compCognitiva = m_c1 * r1 % distanciaMejorLocal;\n\n // Componente social\n const vec r2 = randu(nVariables);\n const vec distanciaMejorGlobal = m_mejorGlobal.getPosicion() - ind.getPosicion();\n\n const vec compSocial = m_c2 * r2 % distanciaMejorGlobal;\n\n // Actualización\n ind.setVelocidad(ind.getVelocidad() + compCognitiva + compSocial);\n ind.setPosicion(ind.getPosicion() + ind.getVelocidad());\n }\n\n if (evaluarPoblacion())\n m_epocasSinMejora = 0;\n else {\n if (m_epocasSinMejora == m_umbral)\n m_termino = true;\n\n ++m_epocasSinMejora;\n }\n}\n} // namespace enjambre\n", "meta": {"hexsha": "34dacb3401113be1c2d36794c3603b80a5897cf2", "size": 5763, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "guia4/enjambre.cpp", "max_stars_repo_name": "junrrein/ic2017", "max_stars_repo_head_hexsha": "e7ab09257093a56751c58a4633a049f7746f00e3", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "guia4/enjambre.cpp", "max_issues_repo_name": "junrrein/ic2017", "max_issues_repo_head_hexsha": "e7ab09257093a56751c58a4633a049f7746f00e3", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "guia4/enjambre.cpp", "max_forks_repo_name": "junrrein/ic2017", "max_forks_repo_head_hexsha": "e7ab09257093a56751c58a4633a049f7746f00e3", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.9757281553, "max_line_length": 91, "alphanum_fraction": 0.6411591185, "num_tokens": 1585, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8519527944504227, "lm_q2_score": 0.640635854839898, "lm_q1q2_score": 0.5457915067559865}} {"text": "/** \\file cmr_t2_mapping.cpp\n \\brief Implement CMR T1 mapping for 2D acquisition\n \\author Hui Xue\n*/\n\n#include \"cmr_t2_mapping.h\"\n#include \"log.h\"\n\n#include \"hoNDArray_reductions.h\"\n#include \"hoNDArray_elemwise.h\"\n#include \"hoNDArray_math.h\"\n#include \"hoNDArray_linalg.h\"\n\n#include \"simplexLagariaSolver.h\"\n#include \"twoParaExpDecayOperator.h\"\n#include \"curveFittingCostFunction.h\"\n\n#include \n\nnamespace Gadgetron { \n\ntemplate \nCmrT2Mapping::CmrT2Mapping() : BaseClass()\n{\n max_iter_ = 150;\n max_fun_eval_ = 1000;\n thres_fun_ = 1e-4;\n\n max_map_value_ = 2500;\n}\n\ntemplate \nCmrT2Mapping::~CmrT2Mapping()\n{\n}\n\ntemplate \nvoid CmrT2Mapping::get_initial_guess(const VectorType& ti, const VectorType& yi, VectorType& guess)\n{\n if (guess.size() != this->get_num_of_paras())\n {\n guess.resize(this->get_num_of_paras(), 0);\n }\n\n // do a log linear fit\n size_t numpts = yi.size();\n GADGET_CHECK_THROW(numpts>0);\n\n T default_A = *std::max_element(yi.begin(), yi.end());\n T default_T2 = ti[ti.size() / 2];;\n\n try\n {\n size_t i;\n for (i = 0; i < numpts; i++)\n {\n if(yi[i]<=0)\n {\n guess[0] = default_A;\n guess[1] = default_T2;\n return;\n }\n }\n\n hoNDArray log_yi(numpts), bi_est(2);\n hoNDArray xi(numpts);\n for (size_t i = 0; i < numpts; i++)\n {\n xi[i] = ti[i];\n log_yi[i] = std::log(yi[i]);\n }\n\n T a, b;\n Gadgetron::linFit(xi, log_yi, a, b);\n\n guess[0] = std::exp(b);\n guess[1] = -1.0 / a;\n }\n catch(...)\n {\n guess[0] = default_A;\n guess[1] = default_T2;\n }\n\n if(guess[1]<0)\n {\n guess[0] = default_A;\n guess[1] = default_T2;\n }\n}\n\ntemplate \nvoid CmrT2Mapping::compute_map(const VectorType& ti, const VectorType& yi, const VectorType& guess, VectorType& bi, T& map_v)\n{\n try\n {\n bi = guess;\n map_v = 0;\n\n typedef Gadgetron::twoParaExpDecayOperator< std::vector > SignalType;\n typedef Gadgetron::leastSquareErrorCostFunction< std::vector > CostType;\n\n // define solver\n Gadgetron::simplexLagariaSolver< VectorType, SignalType, CostType > solver;\n\n // define signal model\n SignalType t2;\n\n // define cost function\n CostType lse;\n\n solver.signal_model_ = &t2;\n solver.cf_ = &lse;\n\n solver.max_iter_ = max_iter_;\n solver.max_fun_eval_ = max_fun_eval_;\n solver.thres_fun_ = thres_fun_;\n\n solver.x_ = ti;\n solver.y_ = yi;\n\n solver.solve(bi, guess);\n\n if (bi[0] > 0 && bi[1] > 0)\n {\n map_v = bi[1];\n if (map_v >= max_map_value_) map_v = hole_marking_value_;\n if (map_v <= min_map_value_) map_v = hole_marking_value_;\n }\n }\n catch (...)\n {\n GADGET_THROW(\"Exceptions happened in CmrT2Mapping::compute_map(...) ... \");\n }\n}\n\ntemplate \nvoid CmrT2Mapping::compute_sd(const VectorType& ti, const VectorType& yi, const VectorType& bi, VectorType& sd, T& map_sd)\n{\n try\n {\n sd.clear();\n sd.resize(bi.size(), 0);\n\n map_sd = 0;\n\n typedef Gadgetron::twoParaExpDecayOperator< std::vector > SignalType;\n SignalType t2;\n\n // compute fitting values\n VectorType y;\n t2.magnitude(ti, bi, y);\n\n // compute residual\n VectorType res(y), abs_res(y);\n\n size_t num = ti.size();\n size_t N = this->get_num_of_paras();\n\n size_t n;\n for (n = 0; n < num; n++)\n {\n res[n] = y[n] - yi[n];\n abs_res[n] = std::abs(res[n]);\n }\n\n hoNDArray grad;\n grad.create(N, num);\n Gadgetron::clear(grad);\n\n VectorType gradVec(N);\n for (n = 0; n < num; n++)\n {\n t2.gradient(ti[n], bi, gradVec);\n memcpy(grad.begin() + n*N, &gradVec[0], sizeof(T)*N);\n }\n\n GADGET_CATCH_THROW(this->compute_sd_impl(ti, yi, bi, abs_res, grad, sd));\n\n map_sd = sd[1];\n if (map_sd > max_map_value_) map_sd = this->hole_marking_value_;\n }\n catch (...)\n {\n GADGET_THROW(\"Exceptions happened in CmrT2Mapping::compute_map(...) ... \");\n }\n}\n\ntemplate \nsize_t CmrT2Mapping::get_num_of_paras() const\n{\n return 2; // A and T2\n}\n\n// ------------------------------------------------------------\n// Instantiation\n// ------------------------------------------------------------\n\ntemplate class EXPORTCMR CmrT2Mapping< float >;\n\n}\n", "meta": {"hexsha": "dadf3582449201e9d2eb274255a1b462efbf09d4", "size": 4735, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "toolboxes/cmr/cmr_t2_mapping.cpp", "max_stars_repo_name": "roopchansinghv/gadgetron", "max_stars_repo_head_hexsha": "fb6c56b643911152c27834a754a7b6ee2dd912da", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2022-02-22T21:06:36.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-22T21:06:36.000Z", "max_issues_repo_path": "toolboxes/cmr/cmr_t2_mapping.cpp", "max_issues_repo_name": "apd47/gadgetron", "max_issues_repo_head_hexsha": "073e84dabe77d2dae3b3dd9aa4bf9edbf1f890f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "toolboxes/cmr/cmr_t2_mapping.cpp", "max_forks_repo_name": "apd47/gadgetron", "max_forks_repo_head_hexsha": "073e84dabe77d2dae3b3dd9aa4bf9edbf1f890f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.4405940594, "max_line_length": 128, "alphanum_fraction": 0.5472016895, "num_tokens": 1339, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8289387956435734, "lm_q2_score": 0.6584175139669997, "lm_q1q2_score": 0.5457878210584404}} {"text": "// Software License for MTL\n// \n// Copyright (c) 2007 The Trustees of Indiana University.\n// 2008 Dresden University of Technology and the Trustees of Indiana University.\n// 2010 SimuNova UG (haftungsbeschränkt), www.simunova.com.\n// All rights reserved.\n// Authors: Peter Gottschling and Andrew Lumsdaine\n// \n// This file is part of the Matrix Template Library\n// \n// See also license.mtl.txt in the distribution.\n\n#ifndef MTL_ORTH_INCLUDE\n#define MTL_ORTH_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#include \n\nnamespace mtl { namespace vec {\n\n namespace impl {\n\n\ttemplate \n\tinline void orth(VVector& v, typename mtl::Collection::size_type j, tag::vector)\n\t{\n\t\tvampir_trace<2018> tracer;\n\t using mtl::two_norm; using mtl::size1D;\n\t MTL_DEBUG_THROW_IF(is_negative(j) || j >= size1D(v), index_out_of_range());\n\n\t typedef typename mtl::Collection::size_type Size;\n\t for (Size i= 0; i < j; ++i)\n\t\tentry1D(v, j)-= dot(entry1D(v, i), entry1D(v, j)) * entry1D(v, i);\n\t entry1D(v, j)/= two_norm(entry1D(v, j));\n\t}\n\n\ttemplate \n\tinline void orth(VVector& v, tag::vector)\n\t{\n\t typedef typename mtl::Collection::size_type Size;\n\t using mtl::size1D;\n\t for (Size j= 0; j < size1D(v); ++j)\n\t\torth(v, j, tag::vector());\n\t}\n\n\n\ttemplate \n\tmtl::mat::dense2D::value_type\n\t\t >::value_type, mat::parameters<> >\n\tinline orthogonalize_factors(VVector& v, tag::vector)\n\t{\t\n\t vampir_trace<2019> tracer;\n\t using ::mtl::two_norm; using math::zero; using mtl::size1D;\n\t typedef typename mtl::Collection::size_type Size;\n\t typedef typename mtl::Collection::value_type Vector;\n\t typedef typename mtl::Collection::value_type Scalar;\n\n\t mtl::mat::dense2D > tau(size1D(v), size1D(v));\n\t tau= zero(Scalar());\n\n\t if (size1D(v) == 0)\n\t\treturn tau;\n\n\t tau[0][0]= dot(entry1D(v, 0), entry1D(v, 0));\n\n\t for (Size j= 1; j < size1D(v); ++j) {\n#ifdef MTL_WITH_FUSED_ORTHOGONALIZATION\n\t\tScalar t= dot(entry1D(v, 0), entry1D(v, j)) / tau[0][0], t2;\n\t\ttau[0][j]= t;\n\t\tfor (Size i= 1; i < j; ++i) {\n\t\t (lazy(entry1D(v, j))-= t * entry1D(v, i-1)) || (lazy(t2)= lazy_dot(entry1D(v, i), entry1D(v, j)));\n\t\t t= tau[i][j]= t2 / tau[i][i];\n\t\t}\n\t\tentry1D(v, j)-= t * entry1D(v, j-1);\n#else\n\t\tfor (Size i= 0; i < j; ++i) {\n\t\t Scalar t= dot(entry1D(v, i), entry1D(v, j)) / tau[i][i];\n\t\t tau[i][j]= t;\n\t\t entry1D(v, j)-= t * entry1D(v, i);\n\t\t}\n#endif\n\t\ttau[j][j]= dot(entry1D(v, j), entry1D(v, j));\n\t }\n\t return tau;\n\t}\n\n } // impl\n\n\n\n/*! Orthonormalize a vector of vectors.\n\n The outer type must be a random access collection and\n the vector type must provide a dot function. \n For instance dense_vector > or\n std::vector > > are eligible.\n It is planned to implement the function for matrices as well\n where the columns will be ortho-normalized.\n**/\ntemplate \ninline void orth(Value& value)\n{\n impl::orth(value, typename traits::category::type());\n}\n\n/*! Orthonormalize the i-th entry of a vector of vectors.\n\n The i-th vector is orthogonalized w.r.t. to the preceeding ones and\n consecutively normalized.\n The outer type must be a random access collection and\n the vector type must provide a dot function. \n For instance dense_vector > or\n std::vector > > are eligible.\n It is planned to implement the function for matrices as well\n where the columns will be ortho-normalized.\n**/\ntemplate \ninline void orth(Value& value, typename mtl::Collection::size_type i)\n{\n impl::orth(value, i, typename traits::category::type());\n}\n\n\n/*! Orthogonalize a vector of vectors.\n\n Opposed to orth the vectors are not normalized. \n An upper matrix with the factors used in the orthogonalization is returned.\n The diagonal contains dot(v[i], v[i]).\n The returned factors are for instance used in bicgstab_ell.\n The outer type must be a random access collection and\n the vector type must provide a dot function. \n For instance dense_vector > or\n std::vector > > are eligible.\n**/\ntemplate \nmtl::mat::dense2D::value_type\n\t >::value_type, mat::parameters<> >\ninline orthogonalize_factors(Value& v)\n{\n return impl::orthogonalize_factors(v, typename traits::category::type());\n}\n\n} // namespace vector\n\nnamespace mat {\n\n // If other matrix types will be supported within a template function, it needs reimplementation!!!\n template \n inline void orth(multi_vector& A)\n {\n\tmtl::vec::impl::orth(A, mtl::tag::vector());\n }\n}\n\nusing vec::orth;\nusing vec::orthogonalize_factors;\n\n} // namespace mtl\n\n#endif // MTL_ORTH_INCLUDE\n", "meta": {"hexsha": "48a83e58da58d49fe2928ea418487ae0aa001bc6", "size": 5673, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "boost/numeric/mtl/operation/orth.hpp", "max_stars_repo_name": "lit-uriy/mtl4-mirror", "max_stars_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_stars_repo_licenses": ["MTLL"], "max_stars_count": 24.0, "max_stars_repo_stars_event_min_datetime": "2019-03-26T15:25:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T10:00:45.000Z", "max_issues_repo_path": "boost/numeric/mtl/operation/orth.hpp", "max_issues_repo_name": "lit-uriy/mtl4-mirror", "max_issues_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_issues_repo_licenses": ["MTLL"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2020-04-17T12:35:32.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-03T15:46:25.000Z", "max_forks_repo_path": "boost/numeric/mtl/operation/orth.hpp", "max_forks_repo_name": "lit-uriy/mtl4-mirror", "max_forks_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_forks_repo_licenses": ["MTLL"], "max_forks_count": 10.0, "max_forks_repo_forks_event_min_datetime": "2019-12-01T13:40:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-14T08:39:54.000Z", "avg_line_length": 32.7919075145, "max_line_length": 104, "alphanum_fraction": 0.6885245902, "num_tokens": 1601, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8289388083214155, "lm_q2_score": 0.6584174871563662, "lm_q1q2_score": 0.5457878071813791}} {"text": "#define DEBUG 1\n/**\n * File : E.cpp\n * Author : Kazune Takahashi\n * Created : 4/23/2020, 7:08:47 PM\n * Powered by Visual Studio Code\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n// ----- boost -----\n#include \n#include \n// ----- using directives and manipulations -----\nusing namespace std;\nusing boost::rational;\nusing boost::multiprecision::cpp_int;\nusing ll = long long;\ntemplate \nusing max_heap = priority_queue;\ntemplate \nusing min_heap = priority_queue, greater>;\n// ----- constexpr for Mint and Combination -----\nconstexpr ll MOD{1000000007LL};\n// constexpr ll MOD{998244353LL}; // be careful\nconstexpr ll MAX_SIZE{3000010LL};\n// constexpr ll MAX_SIZE{30000010LL}; // if 10^7 is needed\n// ----- ch_max and ch_min -----\ntemplate \nvoid ch_max(T &left, T right)\n{\n if (left < right)\n {\n left = right;\n }\n}\ntemplate \nvoid ch_min(T &left, T right)\n{\n if (left > right)\n {\n left = right;\n }\n}\n// ----- Mint -----\ntemplate \nclass Mint\n{\npublic:\n ll x;\n Mint() : x{0LL} {}\n Mint(ll x) : x{(x % MOD + MOD) % MOD} {}\n Mint operator-() const { return x ? MOD - x : 0; }\n Mint &operator+=(const Mint &a)\n {\n if ((x += a.x) >= MOD)\n {\n x -= MOD;\n }\n return *this;\n }\n Mint &operator-=(const Mint &a) { return *this += -a; }\n Mint &operator++() { return *this += 1; }\n Mint &operator++(int)\n {\n Mint tmp{*this};\n ++*this;\n return tmp;\n }\n Mint &operator--() { return *this -= 1; }\n Mint &operator--(int)\n {\n Mint tmp{*this};\n --*this;\n return tmp;\n }\n Mint &operator*=(const Mint &a)\n {\n (x *= a.x) %= MOD;\n return *this;\n }\n Mint &operator/=(const Mint &a)\n {\n Mint b{a};\n return *this *= b.power(MOD - 2);\n }\n Mint operator+(const Mint &a) const { return Mint(*this) += a; }\n Mint operator-(const Mint &a) const { return Mint(*this) -= a; }\n Mint operator*(const Mint &a) const { return Mint(*this) *= a; }\n Mint operator/(const Mint &a) const { return Mint(*this) /= a; }\n bool operator<(const Mint &a) const { return x < a.x; }\n bool operator<=(const Mint &a) const { return x <= a.x; }\n bool operator>(const Mint &a) const { return x > a.x; }\n bool operator>=(const Mint &a) const { return x >= a.x; }\n bool operator==(const Mint &a) const { return x == a.x; }\n bool operator!=(const Mint &a) const { return !(*this == a); }\n const Mint power(ll N)\n {\n if (N == 0)\n {\n return 1;\n }\n else if (N % 2 == 1)\n {\n return *this * power(N - 1);\n }\n else\n {\n Mint half = power(N / 2);\n return half * half;\n }\n }\n};\ntemplate \nMint operator+(ll lhs, const Mint &rhs)\n{\n return rhs + lhs;\n}\ntemplate \nMint operator-(ll lhs, const Mint &rhs)\n{\n return -rhs + lhs;\n}\ntemplate \nMint operator*(ll lhs, const Mint &rhs)\n{\n return rhs * lhs;\n}\ntemplate \nMint operator/(ll lhs, const Mint &rhs)\n{\n return Mint{lhs} / rhs;\n}\ntemplate \nistream &operator>>(istream &stream, Mint &a)\n{\n return stream >> a.x;\n}\ntemplate \nostream &operator<<(ostream &stream, const Mint &a)\n{\n return stream << a.x;\n}\n// ----- Combination -----\ntemplate \nclass Combination\n{\npublic:\n vector> inv, fact, factinv;\n Combination() : inv(MAX_SIZE), fact(MAX_SIZE), factinv(MAX_SIZE)\n {\n inv[1] = 1;\n for (auto i = 2LL; i < MAX_SIZE; i++)\n {\n inv[i] = (-inv[MOD % i]) * (MOD / i);\n }\n fact[0] = factinv[0] = 1;\n for (auto i = 1LL; i < MAX_SIZE; i++)\n {\n fact[i] = Mint(i) * fact[i - 1];\n factinv[i] = inv[i] * factinv[i - 1];\n }\n }\n Mint operator()(int n, int k)\n {\n if (n >= 0 && k >= 0 && n - k >= 0)\n {\n return fact[n] * factinv[k] * factinv[n - k];\n }\n return 0;\n }\n Mint catalan(int x, int y)\n {\n return (*this)(x + y, y) - (*this)(x + y, y - 1);\n }\n};\n// ----- for C++14 -----\nusing mint = Mint;\nusing combination = Combination;\ntemplate \nT gcd(T x, T y) { return y ? gcd(y, x % y) : x; }\ntemplate \nT lcm(T x, T y) { return x / gcd(x, y) * y; }\n// ----- for C++17 -----\ntemplate \nint popcount(T x) // C++20\n{\n int ans{0};\n while (x != 0)\n {\n ans += x & 1;\n x >>= 1;\n }\n return ans;\n}\n// ----- frequently used constexpr -----\n// constexpr double epsilon{1e-10};\n// constexpr ll infty{1000000000000000LL}; // or\n// constexpr int infty{1'000'000'010};\n// constexpr int dx[4] = {1, 0, -1, 0};\n// constexpr int dy[4] = {0, 1, 0, -1};\n// ----- Yes() and No() -----\nvoid Yes()\n{\n cout << \"Yes\" << endl;\n exit(0);\n}\nvoid No()\n{\n cout << \"No\" << endl;\n exit(0);\n}\n\n// ----- Point -----\n\nusing Point = tuple;\n\nostream &operator<<(ostream &os, Point const &pt)\n{\n return os << get<0>(pt) << \" \" << get<1>(pt);\n}\n\n// ----- Cycle -----\n\nclass Cycle\n{\n int num;\n bool pos;\n\npublic:\n Cycle(int num, bool pos) : num{num}, pos{pos} {}\n\n vector path() const\n {\n vector ans;\n for (auto i = 0; i <= num; ++i)\n {\n ans.push_back(Point(i, 0));\n }\n if (pos)\n {\n ans.push_back(Point(num + 1, 0));\n ans.push_back(Point(num + 1, 1));\n ans.push_back(Point(num, 1));\n }\n else\n {\n ans.push_back(Point(num, 1));\n ans.push_back(Point(num + 1, 1));\n ans.push_back(Point(num + 1, 0));\n }\n for (auto i = num; i >= 1; --i)\n {\n ans.push_back(Point(i, 0));\n }\n return ans;\n }\n\n Cycle inv() const\n {\n return Cycle(num, !pos);\n }\n};\n\nclass Chain\n{\n vector V;\n\npublic:\n Chain() {}\n Chain(Cycle c) : V{c} {}\n Chain(vector V) : V(V) {}\n\n Chain(int mask)\n {\n int cnt{0};\n while ((mask >> cnt) != 0)\n {\n if ((mask >> cnt) & 1)\n {\n merge(cnt);\n }\n ++cnt;\n }\n }\n\n vector path() const\n {\n vector ans;\n for (auto const &e : V)\n {\n auto tmp{e.path()};\n copy(tmp.begin(), tmp.end(), back_inserter(ans));\n }\n return ans;\n }\n\n vector const &seq() const\n {\n return V;\n }\n\n void operator+=(Chain const &other)\n {\n copy(other.seq().begin(), other.seq().end(), back_inserter(V));\n }\n\nprivate:\n void merge(int n)\n {\n if (V.empty())\n {\n V.push_back(Cycle{n, true});\n }\n else\n {\n auto inverse{inv()};\n *this += Chain{Cycle{n, true}};\n *this += inverse;\n *this += Chain{Cycle{n, false}};\n }\n }\n\n Chain inv() const\n {\n vector W;\n for (auto it = V.rbegin(); it != V.rend(); ++it)\n {\n W.push_back(it->inv());\n }\n return Chain(W);\n }\n};\n\n// ----- Solve -----\n\nclass Solve\n{\n int N;\n vector V;\n Chain C;\n bool possible;\n\npublic:\n Solve(int N, string A) : N{N}, V(1 << N), possible{true}\n {\n for (auto i = 0; i < 1 << N; ++i)\n {\n V[i] = (A[i] == '1');\n }\n }\n\n void answer()\n {\n if (check())\n {\n construct();\n }\n else\n {\n possible = false;\n }\n flush();\n }\n\nprivate:\n bool check() const\n {\n if (!V[0])\n {\n return false;\n }\n for (auto i = 0; i < 1 << N; ++i)\n {\n for (auto j = 0; j < 1 << N; ++j)\n {\n if (i != j && (i & j) == j)\n {\n if (!V[j] && V[i])\n {\n return false;\n }\n }\n }\n }\n return true;\n }\n\n void construct()\n {\n for (auto i = 0; i < 1 << N; ++i)\n {\n if (V[i])\n {\n continue;\n }\n bool create{true};\n for (auto j = 0; j < 1 << N; ++j)\n {\n if (i != j && (i & j) == j && !V[j])\n {\n create = false;\n break;\n }\n }\n if (create)\n {\n C += Chain{i};\n }\n }\n }\n\n void flush() const\n {\n if (possible)\n {\n cout << \"Possible\" << endl;\n }\n else\n {\n cout << \"Impossible\" << endl;\n return;\n }\n auto tmp{C.path()};\n cout << tmp.size() << endl;\n tmp.push_back(Point(0, 0));\n for (auto const &e : tmp)\n {\n cout << e << endl;\n }\n }\n};\n\n// ----- main() -----\n\nint main()\n{\n int N;\n cin >> N;\n string A;\n cin >> A;\n Solve solve(N, A);\n solve.answer();\n}\n", "meta": {"hexsha": "0e8bdd83b60cc69bd4141b0561f943a25dd1a70d", "size": 8668, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "2020/0321_AGC043/E.cpp", "max_stars_repo_name": "kazunetakahashi/atcoder", "max_stars_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2019-03-24T14:06:29.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-17T21:16:36.000Z", "max_issues_repo_path": "2020/0321_AGC043/E.cpp", "max_issues_repo_name": "kazunetakahashi/atcoder", "max_issues_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "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": "2020/0321_AGC043/E.cpp", "max_forks_repo_name": "kazunetakahashi/atcoder", "max_forks_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-07-22T17:27:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-22T17:27:09.000Z", "avg_line_length": 18.6408602151, "max_line_length": 67, "alphanum_fraction": 0.5154591601, "num_tokens": 2751, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8289387914176258, "lm_q2_score": 0.6584174938590246, "lm_q1q2_score": 0.5457878016077219}} {"text": "\n// inverting A\n// using getrf() & getri() \n\n//#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"utils.h\"\n\nnamespace ublas = boost::numeric::ublas;\nnamespace blas = boost::numeric::bindings::blas;\nnamespace lapack = boost::numeric::bindings::lapack;\n\nusing std::size_t; \nusing std::cout;\nusing std::endl; \n\ntypedef std::complex cmpx; \n\n#ifndef F_ROW_MAJOR\ntypedef ublas::matrix m_t;\ntypedef ublas::matrix cm_t;\n#else\ntypedef ublas::matrix m_t;\ntypedef ublas::matrix cm_t;\n#endif\n\nint main() {\n\n cout << endl; \n cout << \"real matrix:\" << endl << endl; \n\n size_t n = 5; \n m_t a (n, n);\n init_symm (a); \n // [n n-1 n-2 ... 1]\n // [n-1 n n-1 ... 2]\n // a = [n-2 n-1 n ... 3]\n // [ ... ]\n // [1 2 ... n-1 n]\n print_m (a, \"A\"); \n cout << endl; \n\n m_t aa (a); // copy of a, for later use\n\n std::vector ipiv (n); // pivot vector \n lapack::getrf (a, ipiv); // no lu_factor() alias for getrf() available\n lapack::getri (a, ipiv); // no lu_invert() alias for getrf() available\n\n m_t i1 (n, n), i2 (n, n); \n blas::gemm (1.0, a, aa, 0.0, i1); // i1 should be (almost) identity matrix\n blas::gemm (1.0, aa, a, 0.0, i2); // i2 should be (almost) identity matrix\n\n print_m (i1, \"I = A^(-1) * A\"); \n cout << endl; \n print_m (i2, \"I = A * A^(-1)\"); \n cout << endl; \n \n cout << endl; \n\n //////////////////////////////////////////////////////\n\n cout << \"complex matrix:\" << endl << endl; \n cm_t ca (3, 3); \n\n ca (0, 0) = cmpx (3, 0);\n ca (0, 1) = cmpx (4, 2);\n ca (0, 2) = cmpx (-7, 5);\n ca (1, 0) = cmpx (4, -2);\n ca (1, 1) = cmpx (-5, 0);\n ca (1, 2) = cmpx (0, -3);\n ca (2, 0) = cmpx (-7, -5);\n ca (2, 1) = cmpx (0, 3);\n ca (2, 2) = cmpx (2, 0);\n print_m (ca, \"CA\"); \n cout << endl; \n\n cm_t caa (ca); \n \n std::vector ipiv2 (3); \n \n int ierr = lapack::getrf (ca, ipiv2);\n if (ierr == 0) {\n lapack::getri (ca, ipiv2); \n cm_t ii (3, 3); \n blas::gemm (1.0, ca, caa, 0.0, ii);\n print_m (ii, \"I = CA^(-1) * CA\"); \n cout << endl; \n blas::gemm (1.0, caa, ca, 0.0, ii);\n print_m (ii, \"I = CA * CA^(-1)\"); \n cout << endl; \n }\n else\n cout << \"matrix is singular\" << endl; \n \n cout << endl; \n\n}\n\n", "meta": {"hexsha": "dfb781348b293366d088695e9b5b4698376af147", "size": 2663, "ext": "cc", "lang": "C++", "max_stars_repo_path": "externals/numeric_bindings/libs/numeric/bindings/atlas/ublas_getri.cc", "max_stars_repo_name": "ljktest/siconos", "max_stars_repo_head_hexsha": "85b60e62beca46e6bf06bfbd65670089e86607c7", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 137.0, "max_stars_repo_stars_event_min_datetime": "2015-06-16T15:55:28.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T06:01:59.000Z", "max_issues_repo_path": "externals/numeric_bindings/libs/numeric/bindings/atlas/ublas_getri.cc", "max_issues_repo_name": "ljktest/siconos", "max_issues_repo_head_hexsha": "85b60e62beca46e6bf06bfbd65670089e86607c7", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 381.0, "max_issues_repo_issues_event_min_datetime": "2015-09-22T15:31:08.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-14T09:05:23.000Z", "max_forks_repo_path": "externals/numeric_bindings/libs/numeric/bindings/atlas/ublas_getri.cc", "max_forks_repo_name": "ljktest/siconos", "max_forks_repo_head_hexsha": "85b60e62beca46e6bf06bfbd65670089e86607c7", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 30.0, "max_forks_repo_forks_event_min_datetime": "2015-08-06T22:57:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-02T20:30:20.000Z", "avg_line_length": 24.8878504673, "max_line_length": 78, "alphanum_fraction": 0.5527600451, "num_tokens": 1008, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956581000631542, "lm_q2_score": 0.6859494485880927, "lm_q1q2_score": 0.54578123500297}} {"text": "\n// BLAS level 3\n\n//#define F_USE_STD_VECTOR\n\n//#define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS \n//#define BOOST_NO_FUNCTION_TEMPLATE_ORDERING\n\n#include \n#include \n#include \n#include \n#ifdef F_USE_STD_VECTOR\n#include \n#include \n#endif \n#include \"utils.h\"\n\nnamespace ublas = boost::numeric::ublas;\nnamespace atlas = boost::numeric::bindings::atlas;\n\nusing std::cout;\nusing std::endl; \n\n#ifndef F_USE_STD_VECTOR\ntypedef ublas::matrix m_t;\n#else\ntypedef ublas::matrix > m_t;\n#endif \n\nint main() {\n\n cout << endl; \n\n m_t a (4, 4);\n init_m (a, kpp (1)); \n print_m (a, \"a\"); \n cout << endl; \n\n m_t b (4, 6);\n init_m (b, cls1()); \n print_m (b, \"b\"); \n cout << endl; \n \n m_t c (4, 6);\n\n // c = a b\n atlas::gemm (a, b, c); \n print_m (c, \"c = a b\"); \n cout << endl; \n atlas::gemm (CblasNoTrans, CblasNoTrans, 1.0, a, b, 0.0, c); \n print_m (c, \"c = a b\"); \n cout << endl; \n\n init_m (c, const_val (1)); \n print_m (c, \"c\"); \n cout << endl; \n // c = 2 a b + 0.5 c\n atlas::gemm (2.0, a, b, 0.05, c);\n print_m (c, \"c = 2 a b + 0.05 c\"); \n cout << endl; \n\n m_t d (6, 4);\n\n // d = b^T a^T\n atlas::gemm (CblasTrans, CblasTrans, 1.0, b, a, 0.0, d);\n print_m (d, \"d = b^T a^T\"); \n cout << endl; \n\n // c = a^T b \n atlas::gemm (CblasTrans, CblasNoTrans, 1.0, a, b, 0.0, c); \n print_m (c, \"c = a^T b\"); \n cout << endl; \n\n // d = b^T a\n atlas::gemm (CblasTrans, CblasNoTrans, 1.0, b, a, 0.0, d);\n print_m (d, \"d = b^T a\"); \n cout << endl; \n\n init_m (d, const_val (0)); \n ublas::matrix_range br (b, ublas::range (0, 4), ublas::range (0, 4)); \n ublas::matrix_range dr (d, ublas::range (1, 5), ublas::range (0, 4)); \n\n // d[1..5][0..4] = a b[0..4][0..4] \n atlas::gemm (a, br, dr); \n print_m (d, \"d[1..5][0..4] = a b[0..4][0..4]\"); \n cout << endl; \n \n // d[1..5][0..4] = b[0..4][0..4] a\n atlas::gemm (br, a, dr); \n print_m (d, \"d[1..5][0..4] = b[0..4][0..4] a\"); \n cout << endl; \n \n // d[1..5][0..4] = b[0..4][0..4] a^T\n atlas::gemm (CblasNoTrans, CblasTrans, 1.0, br, a, 0.0, dr);\n print_m (d, \"d[1..5][0..4] = b[0..4][0..4] a^T\"); \n cout << endl; \n\n // d[1..5][0..4] = a b[0..4][0..4]^T\n atlas::gemm (CblasNoTrans, CblasTrans, 1.0, a, br, 0.0, dr);\n print_m (d, \"d[1..5][0..4] = a b[0..4][0..4]^T\"); \n cout << endl; \n\n}\n", "meta": {"hexsha": "b552b4d4023c3ceaa54b706e50c37df4f988b14c", "size": 2546, "ext": "cc", "lang": "C++", "max_stars_repo_path": "PROX/3RDPARTY/BOOST_BINDINGS/boost_bindings/libs/numeric/bindings/atlas/ublas_matr3.cc", "max_stars_repo_name": "diku-dk/PROX", "max_stars_repo_head_hexsha": "c6be72cc253ff75589a1cac28e4e91e788376900", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-01-14T19:18:21.000Z", "max_stars_repo_stars_event_max_datetime": "2019-01-14T19:18:21.000Z", "max_issues_repo_path": "PROX/3RDPARTY/BOOST_BINDINGS/boost_bindings/libs/numeric/bindings/atlas/ublas_matr3.cc", "max_issues_repo_name": "diku-dk/PROX", "max_issues_repo_head_hexsha": "c6be72cc253ff75589a1cac28e4e91e788376900", "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": "PROX/3RDPARTY/BOOST_BINDINGS/boost_bindings/libs/numeric/bindings/atlas/ublas_matr3.cc", "max_forks_repo_name": "diku-dk/PROX", "max_forks_repo_head_hexsha": "c6be72cc253ff75589a1cac28e4e91e788376900", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-11-23T09:56:06.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-23T09:56:06.000Z", "avg_line_length": 24.2476190476, "max_line_length": 77, "alphanum_fraction": 0.5604870385, "num_tokens": 1096, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311956428947, "lm_q2_score": 0.6926419958239132, "lm_q1q2_score": 0.5457542359220168}} {"text": "#include \n#include \n#include \n#include \n#include \"chrono.h\"\n\ndouble dot1(const Eigen::VectorXd &vec1, const Eigen::VectorXd &vec2) {\n assert(vec1.size() == vec2.size() && \"Vectors must have the same size\");\n double result = 0.0f;\n for (size_t i = 0; i < vec1.size(); ++i) {\n result += vec1[i] * vec2[i];\n }\n return result;\n}\n\nEigen::MatrixXd matProduct(const Eigen::MatrixXd& mat1, const Eigen::MatrixXd& mat2) {\n assert(mat1.size() == mat2.size() && \"Matrices must have the same size\");\n Eigen::MatrixXd result = Eigen::MatrixXd::Zero(mat1.rows(), mat1.cols());\n \n for (size_t i = 0; i < result.rows(); i++) {\n for (size_t j = 0; j < result.cols(); j++) {\n for (size_t k = 0; k < mat1.cols(); k++) {\n result(i, j) += mat1(i, k) * mat2(k, j);\n }\n }\n }\n \n return result;\n}\n\nint main() {\n const size_t dimension = 500;\n TP_CPP_IMAC2::Chrono chrono;\n\n Eigen::MatrixXd A = Eigen::MatrixXd::Random(dimension, dimension);\n Eigen::MatrixXd B = Eigen::MatrixXd::Random(dimension, dimension);\n\n chrono.start();\n Eigen::MatrixXd eingenResult = A * B;\n std::cout << \"Eignen mean : \" << chrono.timeSpan() << std::endl;\n chrono.stop();\n\n chrono.start();\n Eigen::MatrixXd myResult = matProduct(A, B);\n std::cout << \"My mean : \" << chrono.timeSpan() << std::endl;\n chrono.stop();\n\n std::cout << (eingenResult - myResult).norm() << std::endl;\n\n /*\n\n chrono.start();\n std::cout << \"mean : \" << chrono.timeSpan() << std::endl;\n chrono.stop();\n \n Eigen::VectorXd vec1 = Eigen::VectorXd::Random(dimension);\n Eigen::VectorXd vec2 = Eigen::VectorXd::Random(dimension);\n\n std::cout << \"My dot1 : \" << dot1(vec1, vec2) << std::endl;\n std::cout << \"My dot2 : \" << dot2(vec1, vec2) << std::endl;\n std::cout << \"Eignen dot : \" << vec1.dot(vec2) << std::endl;\n */\n\n /*\n Eigen::VectorXd v1(5);\n v1 << 1, 2, 3, 4, 5;\n std::cout << \"v1 : \" << v1.transpose() << std::endl\n << std::endl;\n\n Eigen::Vector4f v2 = Eigen::Vector4f::Zero();\n std::cout << \"v2 : \" << v2.transpose() << std::endl\n << std::endl;\n\n v2 = Eigen::Vector4f::Ones();\n std::cout << \"v2 : \" << v2.transpose() << std::endl\n << std::endl;\n\n Eigen::Vector4f v3 = Eigen::Vector4f::Random();\n std::cout << \"v3 : \" << v3.transpose() << std::endl\n << std::endl;\n v3 = v3 + v2;\n std::cout << \"v3 : \" << v3.transpose() << std::endl\n << std::endl;\n\n Eigen::MatrixXd A = Eigen::MatrixXd::Random(3, 4);\n std::cout << \"A :\\n\"\n << A << std::endl\n << std::endl;\n\n Eigen::Matrix4d B = Eigen::Matrix4d::Random(4, 4);\n std::cout << \"B :\\n\"\n << B << std::endl\n << std::endl;\n\n Eigen::MatrixXd C(3, 4);\n\n clock_t begin = clock();\n C = A * B;\n clock_t end = clock();\n double tempsCalc = double(end - begin) / CLOCKS_PER_SEC;\n\n std::cout << \"temps calcul du produit matriciel: \" << tempsCalc << \"s \" << std::endl;\n std::cout << \"A + 2*A :\\n\"\n << A + 2 * A << std::endl\n << std::endl;\n std::cout << \"A * B :\\n\"\n << A * B << std::endl\n << std::endl;\n\n */\n\n return 0;\n}\n", "meta": {"hexsha": "34aed21e12c49421c92cf098da262c9ebe4162ee", "size": 3341, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/semestre-3/maths-2/ex1/eigensample.cpp", "max_stars_repo_name": "guillaume-haerinck/imac-c", "max_stars_repo_head_hexsha": "2d88de90acdb546479c4e310528e786358e66bd7", "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/semestre-3/maths-2/ex1/eigensample.cpp", "max_issues_repo_name": "guillaume-haerinck/imac-c", "max_issues_repo_head_hexsha": "2d88de90acdb546479c4e310528e786358e66bd7", "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/semestre-3/maths-2/ex1/eigensample.cpp", "max_forks_repo_name": "guillaume-haerinck/imac-c", "max_forks_repo_head_hexsha": "2d88de90acdb546479c4e310528e786358e66bd7", "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.3070175439, "max_line_length": 89, "alphanum_fraction": 0.5160131697, "num_tokens": 1005, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311956428947, "lm_q2_score": 0.6926419958239132, "lm_q1q2_score": 0.5457542359220168}} {"text": "#if HAVE_CONFIG_H\n# include \n#endif\n\n#include \"HigherStat.h\"\n#include \"PowerSpectrum.h\"\n#include \"LinearPS.h\"\n#include \"Quadrature.h\"\n#include \"SpecialFunctions.h\"\n#include \"array.h\"\n#include \"Spline.h\"\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 \nusing boost::cref;\n\nconst real KMIN_e = 0.0001;\nconst real KMAX_e = 30.;\n\n// Load Linear PS\nHigherStat::HigherStat(const Cosmology& C, const PowerSpectrum& P_l, real epsrel_)\n: C(C), P_l(P_l),kintegral(*this)\n{\nMonteCarloIntegral::Range domain[5] = {\n { KMIN_e, KMAX_e },\n { KMIN_e, KMAX_e },\n { KMIN_e, KMAX_e },\n { -0.999999, 0.999999 },\n { -0.999999, 0.999999 },\n};\nkintegral.SetDomain(domain);\nepsrel = epsrel_;\n}\nHigherStat::~HigherStat() {\n}\n\n\n//Filters\ninline double w_filter(double k, int a){\n switch (a) {\n case 1:\n return 3./k*SphericalBesselJ1(k); //TOPHAT\n break;\n case 2:\n\t return exp(-pow2(k)/2.); //GAUSSIAN\n break;\n case 3:\n\t return 1.; // NO FILTER\n break;\n default:\n warning(\"Filter: invalid indices\");\n return 0;\n }\n}\n\n\n/*Gamma 1 and Gamma 2 (logarithmic derivatives of variance) */\n\n// Create splines functions of sigma^2\nSpline sig2_spline;\nvoid HigherStat::sigsqr_init(int a) const{\n int loop_N = 1000;\n double RMAX =250;\n double RMIN = 1.;\n double Rval, sigval, vars[4];\n vector Rval_tab, sigval_tab;\nfor(int i = 0; i< loop_N; i++){\n Rval = RMIN + i*(RMAX-RMIN)/(loop_N-1);//RMIN * exp(i*log(RMAX/RMIN)/(loop_N-1));\n sigval = sig_sqr(Rval,a,1,vars);\n Rval_tab.push_back(Rval);\n sigval_tab.push_back(sigval);\n }\n sig2_spline = LinearSpline(Rval_tab,sigval_tab);\n}\n\n//function for derivative\n\nstatic double mysigsqr(double R,void * params){\n (void)(params);\n return sig2_spline(R);\n}\n\nstatic double gam1(double R, void * params1){\n (void)(params1);\ngsl_function F;\ndouble result, abserr;\n F.params = 0;\n F.function = &mysigsqr;\n gsl_deriv_central(&F, R, 1e-3, &result, &abserr);\nreturn R*result/sig2_spline(R);\n}\n\nstatic double gam2(double R){\ngsl_function F;\ndouble result, abserr;\n F.params = 0;\n F.function = &gam1;\n gsl_deriv_central(&F, R, 1e-4, &result, &abserr);\nreturn R*result;\n}\n\n\n\n// b selects analytic (1) or numerical (2)\n// a selects window function form\n\n/* Variance */\nstatic double var_integranda(const PowerSpectrum& P_l, double R, int a,double k){\n\treturn pow2(k*w_filter(k*R,a)*D_spt/dnorm_spt)*P_l(k);\n}\n\nstatic double gam1_test(double R, const PowerSpectrum& P_l){\ndouble step = 0.00001;\ndouble top = Integrate(bind(var_integranda, cref(P_l), R + step, 1, _1), KMIN_e , KMAX_e, 1e-4)/(2.*pow2(M_PI));\ndouble bot = Integrate(bind(var_integranda, cref(P_l), R - step, 1, _1), KMIN_e , KMAX_e, 1e-4)/(2.*pow2(M_PI));\ndouble mid = Integrate(bind(var_integranda, cref(P_l), R, 1, _1), KMIN_e , KMAX_e, 1e-4)/(2.*pow2(M_PI));\nreturn R*(top-bot)/(2.*step)/mid;\n}\n\nstatic double gam2_test(double R, double step, const PowerSpectrum& P_l){\ndouble top = gam1_test(R+step, cref(P_l));\ndouble bot = gam1_test(R-step, cref(P_l));\ndouble mid = gam1_test(R, cref(P_l));\nreturn R*(top-bot)/(2.*step)/mid;\n}\n\n\n\n\nstatic double var_integrandn(const PowerSpectrum& P_l, double R, int a, double vars[], double k){\n IOW iow;\n iow.initn_lin(0, vars[4], k, vars[0], vars[1], vars[2], vars[3]);\n\treturn pow2(k*w_filter(k*R,a)*F1_nk/dnorm_spt)*P_l(k);\n}\n\n// vars is for numerical skewness only : vars[0]=omega0, vars[1-3] = MG params and vars[4]=scale factor\n// a chooses filter, b chooses analytic or numerical (1 or 2 resp)\ndouble HigherStat::sig_sqr(double R, int a, int b, double vars[]) const{\n switch (b) {\n case 1:\n return Integrate(bind(var_integranda, cref(P_l), R, a, _1), KMIN_e , KMAX_e, epsrel)/(2.*pow2(M_PI));\n break;\n case 2:\n return Integrate(bind(var_integrandn, cref(P_l), R, a, vars, _1), KMIN_e , KMAX_e, epsrel)/(2.*pow2(M_PI));\n break;\n }\n\n}\n\n/* Skewness */\n// analytic (GR AND nDGP)\nstatic double s3_num_integranda(const PowerSpectrum& P_l, double R, int a, double k1, double k2, double x){\n double k1s = pow2(k1);\n double k2s = pow2(k2);\n\treturn k1s*k2s*w_filter(k1*R,a)*w_filter(k2*R,a)*w_filter(sqrt(k1s+k2s+2.*k1*k2*x)*R,a)*(pow2(D_spt)*F2eds(k1,k2,x) + F_spt*(1.-x*x))*pow2(D_spt)/pow4(dnorm_spt)*P_l(k1)*P_l(k2);\n}\n// numerical\nstatic double s3_num_integrandn(const PowerSpectrum& P_l, double R, int a, double vars[], double k1, double k2, double x){\n double kargs[4],kv[3],xv[3], p22,p13,d;\n double k1s = pow2(k1);\n double k2s = pow2(k2);\n IOW iow;\n kv[0] = k1;\n kv[1] = k2;\n kv[2] = kv[1];\n xv[0] = -0.99999999;\n xv[1] = x;\n xv[2] = -x;\n kargs[0] = sqrt(kv[1]*kv[1]+kv[0]*kv[0]-2.*kv[1]*kv[0]*xv[1]);\n kargs[2] = sqrt(kv[1]*kv[1]+2.*kv[1]*kv[2]*xv[0]+kv[2]*kv[2]);\n kargs[1] = sqrt(kv[2]*kv[2]+2.*kv[2]*kv[0]*xv[2]+kv[0]*kv[0]);\n kargs[3] = sqrt(kv[0]*kv[0]+2.*kv[0]*kv[1]*xv[1]+kv[1]*kv[1]);\n iow.initn2(vars[4],kv,xv,kargs,vars[0],vars[1],vars[2],vars[3]);\n\treturn k1s*k2s*w_filter(k1*R,a)*w_filter(k2*R,a)*w_filter(sqrt(k1s+k2s+2.*k1*k2*x)*R,a)*F2A_nk[0]*F1p_nk[0]*F1_nk/pow4(dnorm_spt)*P_l(k1)*P_l(k2);\n}\n\n// vars is for numerical skewness only : vars[0]=omega0, vars[1-3] = MG params and vars[4]=scale factor\n// a chooses window functions (see w_filter)\n// b chooses (1) analytic (2) numerical (3) gamma1 approx for top-hat filter\ndouble HigherStat::skewness(double R, int a, int b, double vars[]) const{\n double c[3] = {KMIN_e,KMIN_e,-0.99999999};\n double d[3] = {KMAX_e,KMAX_e,0.99999999};\n void * params;\n\n switch (b) {\n case 1:\n\t return 3./4./pow4(M_PI) * Integrate<3>(bind(s3_num_integranda, cref(P_l), R, a, _1, _2, _3), c,d, epsrel);\n break;\n case 2:\n return 3./4./pow4(M_PI) * Integrate<3>(bind(s3_num_integrandn, cref(P_l), R, a, vars, _1, _2, _3), c,d, epsrel);\n break;\n case 3:\n return (34./7. + gam1(R,params)) * pow2(sig2_spline(R));\n break;\n }\n}\n\n/* Analytic Kurtosis */\n\nstatic double s4_num_integranda1(const PowerSpectrum& P_l, double R, int a, double args[], double k[], double x12, double x23, double x13){\n double k1 = k[0];\n double k2 = k[1];\n double k3 = k[2];\n double k1s = args[0];\n double k2s = args[1];\n double k3s = args[2];\n double filt1 = args[3];\n double filt2 = args[4];\n double filt3 = args[5];\n double k12 = sqrt(k1s+k2s+2.*k1*k2*x12);\n double k23 = sqrt(k2s+k3s-2.*k2*k3*x23);\n double k13 = sqrt(k1s+k3s+2.*k1*k3*x13);\n double filt12 = w_filter(k12*R,a);\n double filt23 = w_filter(k23*R,a);\n double term1, term2;\n\n term1 = F2eds(k1,k2,x12)*F2eds(k2,k3,-x23)*filt23*filt12*filt1*filt3;\n term2 = 0.;\n if (a>=2) {\n double k123 = sqrt(k1s + k2s + k3s + 2.*k1*k2*x12 + 2.*k2*k3*x23 + 2.*k1*k3*x13);\n double filt123 = w_filter(k123*R,a);\n term2 = 0.5*filt1*filt2*filt3*F3edsb(k1,k2,k3,k23,k12,k13,x23,x12,x13)*filt123;\n }\n\treturn term1 + term2;\n}\n\nstatic double s4_num_integranda2(const PowerSpectrum& P_l, double R, int a, double k1, double k2, double k3){\n double c[3] = {-1.,-1.,-1.};\n double d[3] = {1.,1.,1.};\n double k[3];\n k[0] = k1;\n k[1] = k2;\n k[2] = k3;\n double args[6];\n args[0]= pow2(k1);\n args[1]= pow2(k2);\n args[2]= pow2(k3);\n args[3]= w_filter(k1*R,a);\n args[4]= w_filter(k2*R,a);\n args[5]= w_filter(k3*R,a);\n\treturn args[0]*args[1]*args[2]*P_l(k1)*P_l(k2)*P_l(k3)*Integrate<3>(bind(s4_num_integranda1, cref(P_l), R, a,args,k, _1, _2, _3), c,d, 1e-4);\n}\n\n// vars is for numerical kurtosis only : vars[0]=omega0, vars[1-3] = MG params and vars[4]=scale factor\n// a chooses window functions (see w_filter)\n// b chooses (1) analytic (2) numerical (3) gamma1 + gamma2 approx for top-hat filter\n\n\nHigherStat::kurtosis_integral::kurtosis_integral(const HigherStat& hs_)\n : MonteCarloIntegral(5), hs(hs_)\n{\n maxeval = 10000000;\n}\n\nvoid HigherStat::kurtosis_integral::Integrand(const double x[], double* f, double* param) const {\n double R = *param;\n double k1 = x[0];\n double k2 = x[1];\n double k3 = x[2];\n double x12 = x[3];\n double x23 = x[4];\n double k1s= pow2(k1);\n double k2s = pow2(k2);\n double k3s = pow2(k3);\n double filt1 = w_filter(k1*R,1);\n double filt3 = w_filter(k3*R,1);\n double k12 = sqrt(k1s+k2s+2.*k1*k2*x12);\n double k23 = sqrt(k2s+k3s+2.*k2*k3*x23);\n double filt12 = w_filter(k12*R,1);\n double filt23 = w_filter(k23*R,1);\n double term1 = F2eds(k1,k2,x12)*F2eds(k2,k3,x23)*filt23*filt12*filt1;\n f[0] = 2.*k1s*k2s*k3s*hs.P_l(k1)*hs.P_l(k2)*hs.P_l(k3)*filt3*(term1);\n}\n\n\n/* kbar definition (EQ. A.25 OF 9312026)*/\nstatic double kbar_integrand(const PowerSpectrum& P_l, double R, double k){\n\treturn pow2(pow2(k)*w_filter(k*R,1)*D_spt/dnorm_spt)*P_l(k);\n}\n\ndouble HigherStat::kurtosis(double R, int a, int b, double vars[]) const{\n double c[3] = {KMIN_e,KMIN_e,KMIN_e};\n double d[3] = {KMAX_e,KMAX_e,KMAX_e};\n double term4 = 0.;\n double kbar;\n double sigsqr = sig_sqr(R, 1, 1, vars);\n if (b==1 && a ==1) {\n kbar = Integrate(bind(kbar_integrand, cref(P_l), R, _1), KMIN_e , KMAX_e, epsrel)/(2.*pow2(M_PI)*sigsqr);\n term4 = 2./189.*pow3(sigsqr)*(1364. + 9.*gam1_test(R,cref(P_l)) * (60. + 7. * gam1_test(R,cref(P_l))) - 126. * kbar);\n }\n switch (b) {\n case 1:\n return term4;//0.75 * pow6(D_spt/(M_PI*dnorm_spt)) * Integrate<3>(bind(s4_num_integranda2, cref(P_l), R, a, _1, _2, _3), c,d, epsrel); //+ term4;\n case 2:\n return (60712./1323. + 62./3.*gam1_test(R,cref(P_l)) + 7./3.*pow2(gam1_test(R,cref(P_l))) + 2./3.*gam2_test(R,epsrel,cref(P_l))) * pow3(sigsqr);\n case 3:\n return 0.75 * pow6(D_spt/(M_PI*dnorm_spt)) * Integrate<3>(bind(s4_num_integranda2, cref(P_l), R, a, _1, _2, _3), c,d, epsrel);\n }\n}\n", "meta": {"hexsha": "22f80792d4c7242fe02f837683035c2e73d018c5", "size": 9862, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "reactions/src/extra_libraries/HigherStat.cpp", "max_stars_repo_name": "PedroCarrilho/ReACT", "max_stars_repo_head_hexsha": "507866e9462ecf10c298fcd3e2c81249f32e7d50", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2020-07-07T11:34:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-15T12:48:05.000Z", "max_issues_repo_path": "reactions/src/extra_libraries/HigherStat.cpp", "max_issues_repo_name": "PedroCarrilho/ReACT", "max_issues_repo_head_hexsha": "507866e9462ecf10c298fcd3e2c81249f32e7d50", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 11.0, "max_issues_repo_issues_event_min_datetime": "2020-05-29T16:26:06.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-07T08:59:52.000Z", "max_forks_repo_path": "reactions/src/extra_libraries/HigherStat.cpp", "max_forks_repo_name": "PedroCarrilho/ReACT", "max_forks_repo_head_hexsha": "507866e9462ecf10c298fcd3e2c81249f32e7d50", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-08-31T15:35:28.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-31T15:35:28.000Z", "avg_line_length": 31.8129032258, "max_line_length": 179, "alphanum_fraction": 0.6410464409, "num_tokens": 3746, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311856832191, "lm_q2_score": 0.6926419958239132, "lm_q1q2_score": 0.5457542290235272}} {"text": "//==============================================================================\n// Copyright 2003 - 2012 LASMEA UMR 6602 CNRS/Univ. Clermont II\n// Copyright 2009 - 2012 LRI UMR 8623 CNRS/Univ Paris Sud XI\n//\n// Distributed under the Boost Software License, Version 1.0.\n// See accompanying file LICENSE.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt\n//==============================================================================\n#ifndef NT2_LINALG_FUNCTIONS_MNORM_HPP_INCLUDED\n#define NT2_LINALG_FUNCTIONS_MNORM_HPP_INCLUDED\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace nt2 { namespace tag\n {\n /*!\n @brief globalnorm generic tag\n\n Represents the mnorm function in generic contexts.\n\n @par Models:\n Hierarchy\n **/\n struct mnorm_ : ext::abstract_\n {\n /// INTERNAL ONLY\n typedef ext::abstract_ parent;\n template\n static BOOST_FORCEINLINE BOOST_AUTO_DECLTYPE dispatch(Args&&... args)\n BOOST_AUTO_DECLTYPE_BODY( dispatching_mnorm_( ext::adl_helper(), static_cast(args)... ) )\n };\n }\n namespace ext\n {\n template\n BOOST_FORCEINLINE generic_dispatcher dispatching_mnorm_(adl_helper, boost::dispatch::meta::unknown_, ...)\n {\n return generic_dispatcher();\n }\n template\n struct impl_mnorm_;\n }\n\n /*!\n @brief Matricial norm\n\n Computes the matricial norms of a matrix expression with static or dynamic choice from\n by the optional second parameter\n that can be 1, nt2::tag::one_ 2, nt2::two_, , nt2::inf_ or , nt2::fro_\n or the template parameter\n that can be 1, nt2::tag::one_ 2, nt2::tag::two_, , nt2::tag::inf_ or , nt2::tag::fro_\n\n Call protocols to mnorm are summarized in the following table. We advise to use static\n calls whenever possible as it prevents cascaded run-time if clauses and goes directly\n to the right call at execution.\n\n @code\n |-------------------|-------------------|------------------------------|-------------------|\n | mnorm(a0, p) |\n |-------------------|-------------------|------------------------------|-------------------|\n | static p | dynamic p | formula (pseudo-code) | equivalent to |\n |-------------------|-------------------|------------------------------|-------------------|\n | nt2::one_ | 1 | max(sum(abs(x))) | mnorm1(x) |\n | nt2::two_ | 2 | max(svd(x)) | mnorm2(x) |\n | nt2::inf_ | nt2::Inf() | max(sum(abs(ctrans(x)))) | mnorminf(x) |\n | nt2::fro_ | -1 | sqrt(sum(diag(ctrans(x)*x))) | mnormfro(x) |\n |-------------------|-------------------|------------------------------|-------------------|\n | mnorm

(a0) |\n |-------------------|-------------------|------------------------------|-------------------|\n | static p | | matrix | |\n |-------------------|-------------------|------------------------------|-------------------|\n | nt2::tag::one_ | - | max(sum(abs(x))) | mnorm1(x) |\n | nt2::tag::two_ | - | max(svd(x)) | mnorm2(x) |\n | nt2::tag::inf_ | - | max(sum(abs(ctrans(x)))) | mnorminf(x) |\n | nt2::tag::fro_ | - | sqrt(sum(diag(ctrans(x)*x))) | mnormfro(x) |\n |-------------------|-------------------|------------------------------|-------------------|\n @endcode\n\n @par Semantic:\n 1, 2 and inf can be given dynamically or statically as template parameter ie:\n\n For any expression @c a0 of type @c A0, the following call:\n\n @code\n as_real::type x = mnorm(a0);\n @endcode\n\n is equivalent to:\n\n @code\n as_real::type x = svd(a0)(1);\n @endcode\n\n For any expression @c a0 of type @c A0 and any value x in {one_, two_, inf_, fro_}\n following call:\n\n @code\n as_real::type r = mnorm(a0,nt2::x);\n @endcode\n\n or\n\n @code\n as_real::type r = mnorm(a0);\n @endcode\n is equivalent to:\n\n @code\n as_real::type r = mnormx(a0);\n @endcode\n\n @param a0 Expression to compute the norm of\n @param a1 Type of norm to compute\n **/\n\n\n\n BOOST_DISPATCH_FUNCTION_IMPLEMENTATION(tag::mnorm_, mnorm, 1)\n\n /// @overload\n BOOST_DISPATCH_FUNCTION_IMPLEMENTATION(tag::mnorm_, mnorm, 2)\n\n /// @overload\n BOOST_DISPATCH_FUNCTION_IMPLEMENTATION(tag::mnorm_, mnorm2, 1)\n\n /// @overload\n template < class T, class A>\n BOOST_FORCEINLINE\n typename meta::as_real::type\n mnorm(const A& a)\n {\n return mnorm(a, nt2::meta::as_());\n }\n /// @overload\n template < int Value, typename A>\n BOOST_FORCEINLINE\n typename meta::as_real::type\n mnorm(const A& a)\n {\n return mnorm(a, boost::mpl::int_());\n }\n}\n\n\n#endif\n", "meta": {"hexsha": "42c2dedd2a780e30b644eea42018e632da9a7589", "size": 5523, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "modules/core/linalg/include/nt2/linalg/functions/mnorm.hpp", "max_stars_repo_name": "feelpp/nt2", "max_stars_repo_head_hexsha": "4d121e2c7450f24b735d6cff03720f07b4b2146c", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 34.0, "max_stars_repo_stars_event_min_datetime": "2017-05-19T18:10:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-04T02:18:13.000Z", "max_issues_repo_path": "modules/core/linalg/include/nt2/linalg/functions/mnorm.hpp", "max_issues_repo_name": "feelpp/nt2", "max_issues_repo_head_hexsha": "4d121e2c7450f24b735d6cff03720f07b4b2146c", "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/linalg/include/nt2/linalg/functions/mnorm.hpp", "max_forks_repo_name": "feelpp/nt2", "max_forks_repo_head_hexsha": "4d121e2c7450f24b735d6cff03720f07b4b2146c", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2017-12-02T12:59:17.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-31T12:46:14.000Z", "avg_line_length": 36.82, "max_line_length": 134, "alphanum_fraction": 0.4823465508, "num_tokens": 1411, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311956428947, "lm_q2_score": 0.6926419831347361, "lm_q1q2_score": 0.5457542259238184}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"Algebra.h\"\n#include \"params.h\"\n#include \"FFT.h\"\n#include \"Random.h\"\n\nusing namespace std;\nusing namespace NTL;\n\n\nZZX FastMod(const ZZX& f)\n{\n return (trunc(f,N0) - (f>>N0));\n}\n\nZZX Cyclo()\n{\n ZZX phi0;\n phi0.SetLength(N0+1);\n phi0[0] = 1;\n phi0[N0] = 1;\n return phi0;\n}\n\nconst ZZX phi = Cyclo();\n\n\n//==============================================================================\n//Computes the squared norm of a polynomial f \n//==============================================================================\nZZ SquaredNorm(const ZZX& f, const unsigned int degree)\n{\n unsigned int i;\n ZZ somme;\n for(i=0; i<=degree; i++)\n {\n somme += sqr(f[i]);\n }\n return somme;\n}\n\n\n//==============================================================================\n//Verifies that for a parameter N, polynomials f, g are a valid semi-basis for building a NTRU lattice.\n//If PGCD!=1, then (f,g) isn't a valid pair\n//==============================================================================\nvoid ValidPair(ZZ& PGCD, ZZ& Alpha, ZZ& Beta, ZZX& rho_f, ZZX& rho_g, const ZZX& f, const ZZX& g)\n{\n ZZX Res_fx, Res_gx, iphi;\n ZZ Res_f, Res_g; \n\n XGCD(Res_f, rho_f, iphi, f, phi, 0);\n if(GCD(Res_f, q1)!=1)\n {\n PGCD = 0;\n }\n else\n { XGCD(Res_g, rho_g, iphi, g, phi, 0);\n XGCD(PGCD, Alpha, Beta, Res_f, Res_g);\n }\n}\n\n\n//==============================================================================\n//Computes f(1/x) mod (x^N + 1)\n//If f = a0 + a1*x + ... + a_{N-1}*x^{N-1}, then\n//Reverse(f) = a0 + a_{N-1}*x + ... + a1*x^{N-1}\n//==============================================================================\nZZX Reverse(const ZZX& f)\n{\n assert(deg(f)>=0);\n assert(deg(f)=N0)\n {\n cout << \"df = \" << dfu << endl;\n cout << \"f = \" << f << endl;\n }\n assert(dfu(Res_f));\n assert(Res_f_1*conv(Res_f) == 1);\n\n return ( Res_f_1 * conv(rho_f) );\n}\n\n\n//==============================================================================\n//Computes h = g/f (mod phi) (mod q)\n//==============================================================================\nZZ_pX Quotient(const ZZX& f, const ZZX& g)\n{\n ZZ_pX f_1, g0, h0, phi0;\n f_1 = Inverse(f);\n g0 = conv(g);\n phi0 = conv(phi);\n h0 = (f_1*g0)%phi0;\n return h0;\n}\n\n\n\n//==============================================================================\n//Computes the Gram-Schmidt norm of the basis B generated from f,g\n//==============================================================================\nvoid GS_Norm(const ZZX fx, const ZZX gx, int& flag)\n{\n unsigned int i;\n\n double acc, acc3, Fred[N0], Gred[N0];\n CC_t f[N0], g[N0], F[N0], G[N0];\n\n acc = 0;\n for(i=0; i(fx[i]*fx[i] + gx[i]*gx[i]);\n }\n acc = sqrt(acc);\n\n ZZXToFFT(f, fx);\n ZZXToFFT(g, gx);\n\n for(i=0; i=0)\n {\n i++;\n\n F = FastMod(F - k*f);\n G = FastMod(G - k*g);\n\n fb = Reverse(f);\n gb = Reverse(g);\n\n num = FastMod(fb*F + gb*G);\n mb = MaxBits(num);\n\n\n k = ReductionCoefficient(f, g, F, G, mb);\n k.normalize();\n }\n\n aux = FastMod(f*G - g*F);\n\n assert(aux[0]==q1);\n assert(deg(aux)==0);\n aux.SetLength(N0);\n}\n\n\nRR_t DotProduct(const RR_t * x1, const RR_t * x2)\n{\n unsigned int i;\n RR_t rep = 0;\n for(i=0; i<2*N0; i++)\n {\n rep += x1[i]*x2[i];\n }\n return rep;\n}\n\n\nvoid Rotate(RR_t * const dest, RR_t const * const src)\n{\n unsigned int i;\n for(i=0; i/ r(v)\n aux = C_k/D_k;\n Bst[k][0] = -Bst[k-1][N0-1] + aux*v[N0-1];\n Bst[k][N0] = -Bst[k-1][2*N0-1] + aux*v[2*N0-1];\n for(j=1; j/ r(v)\n aux = C_k/D_k;\n Bst[k][0] = -Bst[k-1][N0-1] + aux*v[N0-1];\n Bst[k][N0] = -Bst[k-1][2*N0-1] + aux*v[2*N0-1];\n for(j=1; j\n#include \n#include \n#include \n\n#include \n#include \n\n#include \n#include \n\nusing namespace std;\nusing namespace boost::numeric::odeint;\n\n\n/* Set parameters */\nconst double alpha = 0.0025, //priming rate\n delta = 0.019; // death rate immune cells\n\nconst double hI = 571, // Michaelis constant\n hT = 571; // Michaelis constant\n\n double xi = 0.005, // default killing rate immune cells\n R = 2; // growth rate tumor\n\n int STOCHASTIC_KILLING = 0, // default flag stochastic killing (= off)\n STOCHASTIC_GROWTH = 0; // default flag stochastic growth (= off)\n\n double DIAGNOSIS_THRESHOLD = 65*1e8,\n DIAGNOSED_AT = numeric_limits::infinity(),\n RAISE_KILLING = 1.0, // multiplication factor of killing rate by imm. therapy\n TREATMENT_DURATION = numeric_limits::infinity();\n\n double DRIFT_XI = 0, // drift terms\n DRIFT_R = 0;\n\n double t_max = 1825.0; // simulation duration\n\n double seed = time(0)+getpid();\n\ntypedef boost::array< double , 4 > state_type;\n\n\n/* Make interpolation function */\nvector f(500);\nvector g(500);\nboost::math::cubic_b_spline spline_f, spline_g;\n\n// Function to generate time-dep. killing rate\ndouble xi_t( double t ){\n return ( xi * ( 1 + DRIFT_XI * ( t / t_max ) ) * spline_f(t)); // / ((t + 365) / 365);\n}\n\n// Function for time-depedent growth rate\ndouble R_t( double t ){\n return (R * (1 + DRIFT_R * (t / t_max ) ) * spline_g(t)); // / ((t + 365) / 365);\n}\n\n/* TUMOR MODEL */\nvoid tumormodel( const state_type &x , state_type &dxdt , double t )\n{\n const double T = x[0], N = x[3], S = x[2], I = x[1];\n\n const double t_cell_activation = alpha * ( T / (1e7 + T) ) * N;\n\n double killing, growth;\n\n // Set time of diagnosis\n if( T > DIAGNOSIS_THRESHOLD ){\n if( t < DIAGNOSED_AT )\n DIAGNOSED_AT = t;\n }\n\n\n if( STOCHASTIC_KILLING )\n killing = xi_t(t) * I * T / (1 + I/hI + T / hT); // time-dependent killing\n else\n killing = xi * I * T / (1 + I/hI + T / hT); // time-independent killing\n\n\n if( STOCHASTIC_GROWTH )\n growth = R_t(t); // time-dependent growth\n else\n growth = R;\n\n // Start immunotherapy if: one day after diagnosis, a treatment effect is set (RAISE_KILLING),\n // and time is within treatment duration\n if( (t > (DIAGNOSED_AT+1)) && (RAISE_KILLING != 1.0) && (t <= (DIAGNOSED_AT + TREATMENT_DURATION)) )\n killing *= RAISE_KILLING;\n\n\n if ( T < 1 )\n dxdt[0] = -T; // tumor cells\n else\n dxdt[0] = growth * pow( T , 4./5. ) - killing; // tumor cells\n\n dxdt[1] = S - delta*I; // TILs\n dxdt[2] = t_cell_activation; // specific T cells\n dxdt[3] = - t_cell_activation; // naive T cells\n}\n\n\n/* Print output */\nvoid write_solution( const state_type &x , const double t)\n{\n if( STOCHASTIC_GROWTH ){\n cout << t << \"\\t\"<< R_t(t);\n } else {\n cout << t << \"\\t\" << R;\n }\n if( STOCHASTIC_KILLING )\n cout << \"\\t\" << xi_t(t);\n else\n cout << \"\\t\" << xi;\n for( int i = 0 ; i < 4 ; i ++ )\n cout << \"\\t\" << x[i];\n cout << endl;\n}\n\n\n#define XI_OPT 1000\n#define R_OPT 1001\n#define STOCHASTIC_KILLING_OPT 1002\n#define RAISE_KILLING_OPT 1003\n#define TREATMENT_DURATION_OPT 1004\n#define STOCHASTIC_GROWTH_OPT 1005\n#define DRIFT_XI_OPT 1006\n#define DRIFT_R_OPT 1007\n#define SEED_OPT 1008\n\n\nstatic struct option command_line_options[] =\n{\n {\"xi\", required_argument, NULL, XI_OPT},\n {\"R\", required_argument, NULL, R_OPT},\n {\"stochastic-killing\", required_argument, NULL, STOCHASTIC_KILLING_OPT},\n {\"raise-killing\", required_argument, NULL, RAISE_KILLING_OPT},\n {\"treatment-duration\", required_argument, NULL, TREATMENT_DURATION_OPT},\n {\"stochastic-growth\", required_argument, NULL, STOCHASTIC_GROWTH_OPT},\n {\"drift-xi\", required_argument, NULL, DRIFT_XI_OPT},\n {\"drift-R\", required_argument, NULL, DRIFT_R_OPT},\n {\"seed\", required_argument, NULL, SEED_OPT}\n};\n\n\nint main(int argc, char **argv)\n{\n // Parse command line options\n int c;\n double KILLING_SD = 0;\n double GROWTH_SD = 0;\n while ((c = getopt_long(argc, argv, \"\", command_line_options, NULL)) != -1){\n switch(c){\n case XI_OPT:\n xi = atof(optarg);\n break;\n case R_OPT:\n R = atof(optarg);\n break;\n case STOCHASTIC_KILLING_OPT:\n STOCHASTIC_KILLING = 1;\n KILLING_SD = atof(optarg);\n break;\n case STOCHASTIC_GROWTH_OPT:\n STOCHASTIC_GROWTH = 1;\n GROWTH_SD = atof(optarg);\n break;\n case RAISE_KILLING_OPT:\n RAISE_KILLING = atof(optarg);\n break;\n case TREATMENT_DURATION_OPT:\n TREATMENT_DURATION = atof(optarg);\n break;\n case DRIFT_XI_OPT:\n DRIFT_XI = atof(optarg);\n break;\n case DRIFT_R_OPT:\n DRIFT_R = atof(optarg);\n break;\n case SEED_OPT:\n if(atof(optarg) != 0){\n seed = atof(optarg);\n }\n break;\n }\n }\n\n /*Function to generate a random number*/\n boost::mt19937 rng(seed);\n boost::normal_distribution<> nd(0.0, 1.0);\n boost::variate_generator > rnorm(rng, nd);\n \n // Fill vector f with i, returns a vector (size=500) with scaled random numbers\n for (auto& i: f)\n i = 1 + rnorm()*KILLING_SD;\n f[0] = 1;\n \n // Create object cubic_b_spline (constructor);\n spline_f = boost::math::cubic_b_spline(f.begin(), f.end(), 0.0, 30.5);\n\n\n for (auto& i: g)\n i = 1 + rnorm()*GROWTH_SD;\n g[0] = 1;\n \n spline_g = boost::math::cubic_b_spline(g.begin(), g.end(), 0.0, 30.5);\n\n state_type x = {{ 1.0, 0., 0., 1e6 }};\n //integrate(tumormodel, x, 0.0, 2500.0, 1.0, write_solution );\n controlled_runge_kutta> stepper;\n\n integrate_const( stepper, tumormodel, x, 0.0, t_max, 1.0, write_solution );\n}\n", "meta": {"hexsha": "14b74561958ffd27577597441b0e832efc341319", "size": 6549, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "model.cpp", "max_stars_repo_name": "jeroencreemers/tipping-point-cancer-immune-dynamics", "max_stars_repo_head_hexsha": "73b05ae578f6b868b09f2b1dba4688dd4933dc91", "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": "model.cpp", "max_issues_repo_name": "jeroencreemers/tipping-point-cancer-immune-dynamics", "max_issues_repo_head_hexsha": "73b05ae578f6b868b09f2b1dba4688dd4933dc91", "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": "model.cpp", "max_forks_repo_name": "jeroencreemers/tipping-point-cancer-immune-dynamics", "max_forks_repo_head_hexsha": "73b05ae578f6b868b09f2b1dba4688dd4933dc91", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.4604651163, "max_line_length": 104, "alphanum_fraction": 0.5748969308, "num_tokens": 1871, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8333245953120233, "lm_q2_score": 0.6548947290421275, "lm_q1q2_score": 0.5457398850510081}} {"text": "/**\n * linalg.cpp\n *\n * 2021 Gabriel Moreira\n *\n * https://github.com/gabmoreira/maks\n *\n * This software and the related documents are provided as is, with no express\n * or implied warranties, other than those that are expressly stated in the\n * License.\n *\n * Copyright © 2021 Gabriel Moreira. All rights reserved.\n */\n\n#include \n#include \n#include \n#include \n\n#include \n\n#include \"err.hpp\"\n#include \"linalg.hpp\"\n\nusing std::min;\nusing std::max;\nusing std::iota;\nusing std::fill;\nusing std::sort;\nusing std::vector;\nusing std::string;\nusing std::accumulate;\n\nusing Eigen::Ref;\nusing Eigen::VectorXd;\nusing Eigen::MatrixXd;\nusing Eigen::Matrix3d;\nusing Eigen::VectorXd;\nusing Eigen::VectorXi;\n\ntypedef Eigen::Triplet Triplet;\ntypedef Eigen::SparseMatrix Sparse;\ntypedef Eigen::PardisoLDLT PardisoLDLT;\n\n/* Parameters for the Krylov-Schur eigensolver */\n#define KRYLOV_MAXITER 300\n#define KRYLOV_TOL 1e-15\n#define KRYLOV_RES_TOL 2.22e-16\n#define KRYLOV_SUBSPACE_MAX_SIZE 20\n\nnamespace alg {\n\n\n/**\n * Converts two vectors i and j to matrix indices (in-place).\n *\n * @param ei (input) Eigen::VectorXi - row indices.\n * @param ej (input) Eigen::VectorXi - column indices.\n * @param num_nodes (output) int - number of nodes.\n */\nvoid convertToIdx(Ref ei, Ref ej, int& num_nodes) {\n \n int num_edges = (int) ei.rows();\n \n // Obtain node list from edges\n vector nodes;\n \n nodes.insert(nodes.end(), ei.data(), ei.data() + num_edges);\n nodes.insert(nodes.end(), ej.data(), ej.data() + num_edges);\n \n sort(nodes.begin(), nodes.end());\n auto last = unique(nodes.begin(), nodes.end());\n \n num_nodes = (int) (last - nodes.begin());\n \n // Build edge map\n vector idx_map(num_nodes);\n \n for (int i = 0; i < num_nodes ; ++i)\n idx_map[nodes[i]] = i;\n \n // Store matrix indices\n for (int i = 0; i < num_edges; ++i) {\n ei(i) = idx_map[ei(i)];\n ej(i) = idx_map[ej(i)];\n };\n};\n\n\n/**\n * Builds sparse graph adjacency matrix.\n *\n * @param ei (input) Eigen::VectorXi - row indices.\n * @param ej (input) Eigen::VectorXi - column indices.\n * @param num_edges (input) int - number of edges.\n * @param sym (input) bool - whether to make the matrix symmetric.\n * @param dst (output) Eigen::SparseMatrix - output adjacency matrix.\n */\nvoid adjacency(const Ref ei, const Ref ej, int num_edges, bool sym, Sparse& dst) {\n \n int buffer_size = num_edges;\n \n if (sym)\n buffer_size *= 2;\n \n // Allocate buffer\n vector buffer(buffer_size);\n \n // Fill in the data\n for (int i = 0; i < num_edges; ++i)\n buffer[i] = Triplet( ei(i), ej(i), 1.0f );\n\n // Duplicate entries if symmetric flag is true\n if (sym)\n for (int i = 0; i < num_edges; ++i)\n buffer[num_edges + i] = Triplet( ej(i), ei(i), 1.0f );\n\n dst.setFromTriplets(buffer.begin(), buffer.end());\n};\n\n\n/**\n * Builds sparse block matrix.\n *\n * @param ei (input) Eigen::VectorXi - row indices.\n * @param ej (input) Eigen::VectorXi - column indices.\n * @param blocks (input) Eigen::MatrixXd - row block matrix containing contiguous blocks.\n * @param block_height (input) int - block height.\n * @param block_width (input) int - block width.\n * @param num_blocks (input) int - number of contiguous blocks.\n * @param sym (input) bool - whether to make the matrix symmetric.\n * @param dst (output) Eigen::SparseMatrix - output adjacency matrix.\n */\nvoid sparseBlocks(const Ref ei,\n const Ref ej,\n const Ref blocks,\n int block_height,\n int block_width,\n int num_blocks,\n bool sym,\n Sparse& dst) {\n \n int buffer_size = num_blocks * block_height * block_width;\n \n if (sym)\n buffer_size *= 2;\n \n // Allocate buffer\n vector buffer(buffer_size);\n\n // Fill in the data\n int k = 0;\n for (int i = 0; i < num_blocks; ++i) {\n for (int jj = 0; jj < block_width; ++jj) {\n for (int ii = 0; ii < block_height; ++ii) {\n buffer[k] = Triplet( ei(i)*block_height + ii, ej(i)*block_width + jj, blocks(ii, i*block_width + jj) );\n k++;\n };\n };\n };\n\n // Duplicate entries if symmetric flag is true\n if (sym)\n for (int i = 0; i < num_blocks; ++i) {\n for (int jj = 0; jj < block_width; ++jj) {\n for (int ii = 0; ii < block_height; ++ii) {\n buffer[k] = Triplet( ej(i)*block_width + jj, ei(i)*block_height + ii, blocks(ii, i*block_width + jj) );\n k++;\n };\n };\n };\n \n dst.setFromTriplets(buffer.begin(), buffer.end());\n};\n\n\n/**\n * Solves the orthogonal Procrustes problem in SO(3) (in-place).\n *\n * @param mat (input/output) Eigen::MatrixXd - 3x3 matrix\n */\nvoid orthoProcrustesSO3(Ref mat) {\n Eigen::JacobiSVD svd(mat, Eigen::ComputeFullU | Eigen::ComputeFullV);\n Matrix3d U = svd.matrixU();\n Matrix3d R = U * svd.matrixV().transpose();\n U.col(2) *= R.determinant();\n mat = U * svd.matrixV().transpose();\n};\n\n\n/**\n * Solves the orthogonal Procrustes problem in O(3) (in-place).\n *\n * @param mat (input/output) Eigen::MatrixXd - 3x3 matrix.\n */\nvoid orthoProcrustesO3(Ref mat) {\n Eigen::JacobiSVD svd(mat, Eigen::ComputeFullU | Eigen::ComputeFullV);\n mat = svd.matrixU() * svd.matrixV().transpose();\n};\n\n\n/**\n * Finds the projection of a vector on a subpace spanned by the columns of a matrix\n *\n * @param subspace_basis (input) Eigen::MatrixXd - Dense matrix whose columns span a subspace where we want to project the vector v.\n * @param idx (input) unsigned int - Sub-selects of the first idx columns of A only.\n * @param v (input) Eigen::VectorXd - Vector to project.\n * @return Eigen::VectorXd - The component of the vector in the subspace spanned by the first\n * idx columns of the input matrix A\n */\nVectorXd projectionOnto(const Ref subspace_basis, unsigned int idx, const Ref v) {\n VectorXd w = subspace_basis.leftCols(idx).transpose() * v;\n VectorXd proj = subspace_basis.leftCols(idx) * w;\n return proj;\n};\n\n\n/**\n * Projects a vector onto a subpace spanned by the columns of a matrix (in-place)\n *\n * @param subspace_basis (input) Eigen::MatrixXd - Dense matrix whose columns span a subspace where we want to project the vector v.\n * @param idx (input) unsigned int - Sub-selects of the first idx columns of A only.\n * @param v (input/output) Eigen::VectorXd - Vector to project.\n */\nvoid projectOnto(const Ref subspace_basis, unsigned int idx, Ref v) {\n VectorXd w = subspace_basis.leftCols(idx).transpose() * v;\n v -= subspace_basis.leftCols(idx) * w;\n};\n\n\n/**\n * Symmetric sparse solver via LDLT decomposition.\n *\n * Solves sparse system Ax = b via LDLt decomposition.\n *\n * @param solver (input) Eigen::PardisoLDLT - LDLt Intel PARDISO solver\n * @param mat (input) Eigen::MatrixXd - matrix to factorize.\n * @param rhs (input) Eigen::VectorXd - right hand side.\n * @param x (output) Eigen::VectorXd - solution of the system.\n */\nvoid sparseSolverLDL(PardisoLDLT* solver, const Sparse& mat, const Ref rhs, Ref x) {\n solver->factorize(mat);\n x = solver->solve(rhs);\n};\n\n\n/**\n * Robust reorthogonalization function. For an input matrix V and an input\n * vector r, tries to iteratively orthogonalize r against the j first columns\n * of V. This prevents numerical errors and ensures orthogonality. If, by any\n * chance, and after multiple iterations of subtracting projections, the vector\n * has a norm smaller than 1/sqrt(2) of its starting norm, it cannot be\n * reorthogonalized. This method then attempts to find another orthogonal vector\n * through random restarts. The flag stop is activate if everything fails.\n * (See G. W. Stewart 2001)\n *\n * @param V Dense matrix of doubles whose columns contain orthogonal basis vectors\n * @param r Vector to orthogonalize\n * @param residual_norm Residual norm or r after it has been orthogonalized against the first j columns of V.\n * @param idx Index specifying the number of columns of V used in the orthogonalization.\n * @param stop Stop the algorithm flag. Indicates that it is impossible to find, to machine precision, a vector r orthogonal to the first j cols of V.\n */\nvoid reorthogonalize(const Ref V, Ref r, double& residual_norm, unsigned int idx, int& stop) {\n stop = 0;\n double normr0 = r.norm();\n \n projectOnto(V, idx, r);\n \n residual_norm = r.norm();\n\n // Iteratively tries to reorthogonalize r against the columns of V\n unsigned int num_reorths = 1;\n while((residual_norm <= (1.0 / sqrt(2)) * normr0) && num_reorths < 5) {\n projectOnto(V, idx, r);\n normr0 = residual_norm;\n residual_norm = r.norm();\n num_reorths++;\n };\n \n /* Cannot reorthogonalize: Invariant subspace found. Restart with\n * a new random vector and try another 3 times */\n if (residual_norm <= (1.0 / sqrt(2)) * normr0) {\n residual_norm = 0;\n stop = 1;\n // Try another 3 times with random restarts\n for (int j = 0; j < 3; ++j) {\n r = VectorXd::Random(r.rows(),1);\n projectOnto(V, idx, r);\n r.normalize();\n \n // Reorthogonalize if necessary\n for (unsigned int k = 0; k < 5; ++k) {\n VectorXd Mr = r;\n VectorXd proj = projectionOnto(V, idx, Mr);\n double rMr = sqrt(abs(r.transpose() * Mr));\n \n if (abs(rMr - 1.0f) <= 1e-10) {\n stop = 0;\n break;\n };\n \n // Reorthogonalize\n r -= proj;\n r.normalize();\n };\n if (!stop)\n break;\n };\n } else {\n r /= residual_norm;\n };\n};\n\n\n/**\n * Symmetric Krylov-Schur LDLt eigensolver.\n *\n * For a real sparse symmetric matrix A, this function computes k real eigenvalues\n * near a real target sigma using the Krylov-Schur method (G. W. Stewart 2001).\n *\n * @param solver (input) Eigen::PardisoLDLT - LDLt Intel PARDISO solver.\n * @param mat (input) Eigen::SparseMatrix - sparse matrix to compute eigenvalues and eigenvectors.\n * @param eigenvalues (output) Eigen::VectorXd - k x 1 matrix to store the computed eigenvalues.\n * @param eigenvectors (output) Eigen::MatrixXd - n x k matrix to store normalized eigenvectors.\n * @param k (input) int - number of eigenvalues and eigenvectors to be computed.\n * @param sigma (input) double - spectral shift / eigenvalue target.\n*/\nvoid symKrylovSchurLDL(PardisoLDLT* solver,\n const Sparse& mat,\n Ref eigenvalues,\n Ref eigenvectors,\n unsigned int k,\n double sigma) {\n \n long n = mat.rows();\n \n // Sparse identity matrix\n Sparse speye(n,n);\n speye.setIdentity();\n \n Sparse shiftInvert = mat;\n shiftInvert -= sigma * speye;\n \n // Get LDLt factorization of A - sigma I\n solver->factorize(shiftInvert);\n \n MKS_ASSERT(solver->info()==Eigen::Success, mksGetStatusString(mksEigenPardisoLDLErr));\n \n // Matrix to hold the orthogonal Krylov basis\n MatrixXd krylov_basis = MatrixXd::Zero(n, KRYLOV_SUBSPACE_MAX_SIZE);\n \n // Size of the V matrix (not actual size but size in use)\n unsigned int size_krylov_basis = 0;\n \n // Stop the algorithm flag (reorthogonalization gone bad)\n int stop = 0;\n \n // Number of selected eigenvalues\n unsigned int k0 = k;\n\n // Store projection data\n vector Alpha;\n Alpha.reserve(KRYLOV_SUBSPACE_MAX_SIZE);\n \n // Store projection data\n vector Beta;\n Beta.reserve(KRYLOV_SUBSPACE_MAX_SIZE);\n \n MatrixXd c;\n\n double residual_norm = 0;\n bool restarted = false;\n unsigned int nconv = 0;\n vector converged(k0);\n\n MatrixXd ritz_vectors;\n MatrixXd ritz_values;\n\n // Used to compute argsorts\n vector idx_vec(KRYLOV_SUBSPACE_MAX_SIZE);\n\n // H matrix\n MatrixXd H(KRYLOV_SUBSPACE_MAX_SIZE, KRYLOV_SUBSPACE_MAX_SIZE);\n\n // Starting vector for the Krylov iterations\n VectorXd v0 = VectorXd::Random(n,1);\n v0.normalize();\n \n // One step of the power iteration\n VectorXd v = solver->solve(v0);\n v.normalize();\n \n // Main loop of the Krylov-Schur method\n for (unsigned int i = 0; i < KRYLOV_MAXITER; ++i) {\n // Loop to build the invariant subspace in V, H\n for (unsigned int j = size_krylov_basis; j < KRYLOV_SUBSPACE_MAX_SIZE; ++j) {\n \n // Store the Krylov vector v from the previous iteration in the Krylov matrix V\n krylov_basis.col(j) = v;\n // Compute Krylov power using Cholesky solver: r = (A-sigma I)^-1 * v\n VectorXd r = solver->solve(v);\n // Component of the new vector r in the direction of the previous vector v\n double alpha = v.transpose() * r;\n\n // Orthogonalization\n if (j == 0) {\n // 1st iteration: just subtract the projection on the previous vector\n r.noalias() -= alpha * v;\n } else if (restarted) {\n VectorXd w = krylov_basis.leftCols(j+1).transpose() * r;\n r.noalias() -= krylov_basis.leftCols(j+1) * w;\n restarted = false;\n } else {\n // Subtract projection on the previous vector and residuals before that\n r.noalias() -= alpha * v;\n r.noalias() -= residual_norm * krylov_basis.col(j-1);\n };\n\n /* Robust reorthogonalization of r against the columns of V.\n * This helps prevent numerical errors */\n reorthogonalize(krylov_basis, r, residual_norm, j+1, stop);\n\n /* Check if it was possible to reorthogonalize. If not, we cannot find the\n * invariant subspace and must exit the program */\n MKS_ASSERT(!stop, mksGetStatusString(mksKrylovReorthogonalizationErr));\n \n // Save projection of r on the the previous vector v (alpha)\n Alpha.push_back(alpha);\n // Save projection of r on the previous previous vector (beta)\n Beta.push_back(residual_norm);\n // Set the current vector v as the orthogonalized vector r\n v = r;\n };\n\n // Build matrix H\n Eigen::Map Alpha_vec(Alpha.data(), Alpha.size());\n Eigen::Map Beta_vec(Beta.data(), Beta.size()-1);\n\n MatrixXd H1 = MatrixXd::Zero(Alpha.size(), Alpha.size());\n H1.diagonal(-1).array() += Beta_vec.array();\n H1.diagonal(0).array() += Alpha_vec.array();\n H1.diagonal(1).array() += Beta_vec.array();\n \n // H matrix\n H = MatrixXd::Zero(KRYLOV_SUBSPACE_MAX_SIZE, KRYLOV_SUBSPACE_MAX_SIZE);\n H.bottomRightCorner(H1.rows(), H1.cols()) += H1;\n\n if (ritz_values.rows() > 0)\n H.topLeftCorner(ritz_values.rows(),ritz_values.rows()) += ritz_values.asDiagonal();\n\n if (ritz_values.rows() > 0) {\n for (unsigned int l = 0; l < k; ++l) {\n H(l,k) = c(0,l);\n H(k,l) = c(0,l);\n };\n };\n\n Alpha.resize(0);\n Beta.resize(0);\n\n // Compute Ritz pairs (eigenpairs of the H matrix)\n Eigen::SelfAdjointEigenSolver eig(H);\n ritz_vectors = eig.eigenvectors();\n ritz_values = eig.eigenvalues();\n\n // Compute residuals to find out what has converged\n vector res(ritz_vectors.cols());\n for (unsigned int l = 0; l < ritz_vectors.cols(); ++l)\n res[l] = abs(residual_norm * ritz_vectors(ritz_vectors.rows()-1, l));\n\n // Argsort eigenvalues descending order\n iota(idx_vec.begin(), idx_vec.end(), 0);\n sort(idx_vec.begin(), idx_vec.end(), [&](size_t a, size_t b) { return abs(ritz_values(a)) > abs(ritz_values(b)); });\n\n // Check which ones have converged\n for (unsigned int l = 0; l < k0; ++l)\n converged[l] = (int) ( res[idx_vec[l]] < KRYLOV_TOL * max(KRYLOV_RES_TOL, abs(ritz_values(idx_vec[l]))) );\n\n // Number of eigenvalues which have converged\n nconv = accumulate(converged.begin(), converged.end(), 0);\n \n // More than k0 eigenvalues converged: We're good to go\n if (nconv >= k0) {\n break;\n } else {\n // Adjust k to prevent stagnation\n k = k0 + min( (float) nconv, (float) floor(((float) (KRYLOV_SUBSPACE_MAX_SIZE-k0)) / 2.0f) );\n if (k == 1)\n k = floor(KRYLOV_SUBSPACE_MAX_SIZE / 2.0f);\n };\n\n // Use previous eigenvalue argsort to sort eigenvalues and eigenvectors\n MatrixXd ritz_vectors_ = MatrixXd::Zero(KRYLOV_SUBSPACE_MAX_SIZE, k);\n VectorXd ritz_values_ = VectorXd::Zero(KRYLOV_SUBSPACE_MAX_SIZE, 1);\n \n for (unsigned int i = 0; i < k; ++i) {\n ritz_vectors_.col(i) += ritz_vectors.col(idx_vec[i]);\n ritz_values_(i) += ritz_values(idx_vec[i]);\n };\n \n ritz_vectors = ritz_vectors_;\n ritz_values = ritz_values_;\n\n // Store variables for the next iteration\n krylov_basis.leftCols(k) = krylov_basis * ritz_vectors;\n c = residual_norm * ritz_vectors.bottomRows<1>();\n\n restarted = true;\n size_krylov_basis = k;\n };\n \n MatrixXd ritz_vectors_ = MatrixXd::Zero(ritz_vectors.rows(), k0);\n eigenvalues = VectorXd::Zero(k0);\n\n for (unsigned int i = 0; i < k0; ++i) {\n eigenvalues(i) += ritz_values(idx_vec[i]);\n ritz_vectors_.col(i) += ritz_vectors.col(idx_vec[i]);\n };\n\n c = residual_norm * ritz_vectors_.bottomRows<1>();\n\n eigenvectors = krylov_basis * ritz_vectors_;\n eigenvectors = eigenvectors.array().rowwise() * eigenvalues.transpose().array();\n eigenvectors.noalias() += v * c;\n\n // Eigenvector normalization\n VectorXd norms = eigenvectors.colwise().norm();\n eigenvectors.array().rowwise() /= norms.array().transpose();\n\n // Eigenvalue reverse the shift and invert\n eigenvalues.array() = 1.0f / eigenvalues.array() + sigma;\n};\n\n};\n\n", "meta": {"hexsha": "eb0a10499bcc6485479d63b38393c5a4a9a8a60e", "size": 18668, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/linalg.cpp", "max_stars_repo_name": "rjanvier/maks", "max_stars_repo_head_hexsha": "30808dd29cc29ba447bd23823259eca4695579aa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 50.0, "max_stars_repo_stars_event_min_datetime": "2020-12-15T10:15:13.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T03:19:07.000Z", "max_issues_repo_path": "src/linalg.cpp", "max_issues_repo_name": "rjanvier/maks", "max_issues_repo_head_hexsha": "30808dd29cc29ba447bd23823259eca4695579aa", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T12:24:14.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T12:47:43.000Z", "max_forks_repo_path": "src/linalg.cpp", "max_forks_repo_name": "rjanvier/maks", "max_forks_repo_head_hexsha": "30808dd29cc29ba447bd23823259eca4695579aa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-11-06T07:22:07.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-18T09:31:30.000Z", "avg_line_length": 34.828358209, "max_line_length": 150, "alphanum_fraction": 0.6128669381, "num_tokens": 4861, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8333246035907932, "lm_q2_score": 0.6548947223065754, "lm_q1q2_score": 0.5457398848598295}} {"text": "/****************************************************************************\n**\n** This file is part of the LibreCAD project, a 2D CAD program\n**\n** Copyright (C) 2010 R. van Twisk (librecad@rvt.dds.nl)\n** Copyright (C) 2001-2003 RibbonSoft. All rights reserved.\n**\n**\n** This file may be distributed and/or modified under the terms of the\n** GNU General Public License version 2 as published by the Free Software\n** Foundation and appearing in the file gpl-2.0.txt included in the\n** packaging of this file.\n**\n** This program is distributed in the hope that it will be useful,\n** but WITHOUT ANY WARRANTY; without even the implied warranty of\n** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n** GNU General Public License for more details.\n**\n** You should have received a copy of the GNU General Public License\n** along with this program; if not, write to the Free Software\n** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n**\n** This copyright notice MUST APPEAR in all copies of the script!\n**\n**********************************************************************/\n#include \n#include \n#include \n#include \n\n#include \n//#include \n#include \n#include \n\n#include \"rs_settings.h\"\n#include \"rs_units.h\"\n#include \"rs_math.h\"\n#include \"rs_vector.h\"\n#include \"rs_debug.h\"\n\nnamespace {\nconstexpr double m_piX2 = M_PI*2; //2*PI\n}\n\n/**\n * Rounds the given double to the closest int.\n */\nint RS_Math::round(double v) {\n return (int) lrint(v);\n}\n\n/**\n * Save pow function\n */\ndouble RS_Math::pow(double x, double y) {\n errno = 0;\n double ret = ::pow(x, y);\n if (errno==EDOM) {\n RS_DEBUG->print(RS_Debug::D_ERROR,\n \"RS_Math::pow: EDOM in pow\");\n ret = 0.0;\n }\n else if (errno==ERANGE) {\n RS_DEBUG->print(RS_Debug::D_WARNING,\n \"RS_Math::pow: ERANGE in pow\");\n ret = 0.0;\n }\n return ret;\n}\n\n/* pow of vector components */\nRS_Vector RS_Math::pow(RS_Vector vp, double y) {\n return RS_Vector(pow(vp.x,y),pow(vp.y,y));\n}\n\n/**\n * Save equal function for real types\n */\nbool RS_Math::equal(const double d1, const double d2)\n{\n return fabs(d1 - d2) < RS_TOLERANCE;\n}\n\n/**\n * Converts radians to degrees.\n */\ndouble RS_Math::rad2deg(double a) {\n\treturn 180./M_PI*a;\n}\n\n/**\n * Converts degrees to radians.\n */\ndouble RS_Math::deg2rad(double a) {\n\treturn M_PI/180.0*a;\n}\n\n/**\n * Converts radians to gradians.\n */\ndouble RS_Math::rad2gra(double a) {\n\treturn 200./M_PI*a;\n}\n\ndouble RS_Math::gra2rad(double a) {\n\treturn M_PI/200.*a;\n}\n\n\n/**\n * Finds greatest common divider using Euclid's algorithm.\n */\nunsigned RS_Math::findGCD(unsigned a, unsigned b) {\n\n\twhile (b) {\n\t\tunsigned rem = a % b;\n a = b;\n b = rem;\n }\n\n return a;\n}\n\n\n\n/**\n * Tests if angle a is between a1 and a2. a, a1 and a2 must be in the\n * range between 0 and 2*PI.\n * All angles in rad.\n *\n * @param reversed true for clockwise testing. false for ccw testing.\n * @return true if the angle a is between a1 and a2.\n */\nbool RS_Math::isAngleBetween(double a,\n double a1, double a2,\n bool reversed) {\n\n\tif (reversed) std::swap(a1,a2);\n\tif(getAngleDifferenceU(a2, a1 ) < RS_TOLERANCE_ANGLE) return true;\n\tconst double tol=0.5*RS_TOLERANCE_ANGLE;\n\tconst double diff0=correctAngle(a2 -a1) + tol;\n\n\treturn diff0 >= correctAngle(a - a1) || diff0 >= correctAngle(a2 - a);\n}\n\n/**\n * Corrects the given angle to the range of 0 to +PI*2.0.\n */\ndouble RS_Math::correctAngle(double a) {\n return fmod(M_PI + remainder(a - M_PI, m_piX2), m_piX2);\n}\n\n/**\n * Corrects the given angle to the range of -PI to +PI.\n */\ndouble RS_Math::correctAngle2(double a) {\n return remainder(a, m_piX2);\n}\n\n/**\n * Returns the given angle as an Unsigned Angle in the range of 0 to +PI.\n */\ndouble RS_Math::correctAngleU(double a) {\n return fabs(remainder(a, m_piX2));\n}\n\n\n/**\n * @return The angle that needs to be added to a1 to reach a2.\n * Always positive and less than 2*pi.\n */\ndouble RS_Math::getAngleDifference(double a1, double a2, bool reversed) {\n\tif(reversed) std::swap(a1, a2);\n\treturn correctAngle(a2 - a1);\n}\n\ndouble RS_Math::getAngleDifferenceU(double a1, double a2)\n{\n\treturn correctAngleU(a1 - a2);\n}\n\n\n/**\n* Makes a text constructed with the given angle readable. Used\n* for dimension texts and for mirroring texts.\n*\n* @param readable true: make angle readable, false: unreadable\n* @param corrected Will point to true if the given angle was\n* corrected, false otherwise.\n*\n * @return The given angle or the given angle+PI, depending which on\n * is readable from the bottom or right.\n */\ndouble RS_Math::makeAngleReadable(double angle, bool readable,\n bool* corrected) {\n\n double ret=correctAngle(angle);\n\n bool cor = isAngleReadable(ret) ^ readable;\n\n // quadrant 1 & 4\n if (cor) {\n // ret = angle;\n // }\n // quadrant 2 & 3\n // else {\n ret = correctAngle(angle+M_PI);\n }\n\n if (corrected) {\n *corrected = cor;\n }\n\n return ret;\n}\n\n\n/**\n * @return true: if the given angle is in a range that is readable\n * for texts created with that angle.\n */\nbool RS_Math::isAngleReadable(double angle) {\n\tconst double tolerance=0.001;\n if (angle>M_PI_2)\n return fabs(remainder(angle, m_piX2)) < (M_PI_2 - tolerance);\n else\n return fabs(remainder(angle, m_piX2)) < (M_PI_2 + tolerance);\n}\n\n/**\n * @param tol Tolerance in rad.\n * @retval true The two angles point in the same direction.\n */\nbool RS_Math::isSameDirection(double dir1, double dir2, double tol) {\n\treturn getAngleDifferenceU(dir1, dir2) < tol;\n}\n\n/**\n * Evaluates a mathematical expression and returns the result.\n * If an error occurred, the given default value 'def' will be returned.\n */\n//double RS_Math::eval(const QString& expr, double def) {\n//\n// bool ok;\n// double res = RS_Math::eval(expr, &ok);\n//\n// if (!ok) {\n// //std::cerr << \"RS_Math::evaluate: Parse error at col \"\n// //<< ret << \": \" << fp.ErrorMsg() << \"\\n\";\n// return def;\n// }\n//\n// return res;\n//}\n\n/**\n * generic replaceAll will allow substitution of one string for another\n * as many times as it exists within a given string.\n */\nvoid RS_Math::replaceAll(QString& str, const std::string& from, const std::string& to) {\n\n QString qfrom = QString::fromStdString(from);\n QString qto = QString::fromStdString(to);\n if(qfrom.isEmpty())\n return;\n int start_pos = 0;\n while((start_pos = str.indexOf(qfrom, start_pos)) != -1) {\n str.replace(start_pos, qfrom.length(), qto);\n start_pos += qto.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'\n }\n}\n\n/**\n * Translate imperial shortform to inch equivalent math statements\n * this only holds true for simple +,- operators *,/ require manual braces..\n * which is probably a good thing.\n */\nvoid RS_Math::imperialTranslate(QString& str) {\n\n if (str.isEmpty())\n return;\n // put brackets around everything first\n str = \"(\" + str + \")\";\n replaceAll(str,\"+\",\")+(\");\n replaceAll(str,\"-\",\")-(\");\n // convert foot shortform\n replaceAll(str,\"\\'\",\"*12+\");\n // convert inch shortform\n replaceAll(str,\"\\\"\",\"+\");\n // fix for inch with no fraction component\n replaceAll(str,\"+)\",\")\"); // -- cleanup\n}\n\n/**\n * Evaluates a mathematical expression and returns the result.\n * If an error occurred, ok will be set to false (if ok isn't NULL).\n */\n//double RS_Math::eval(const QString& expr, bool* ok) {\n// bool okTmp(false);\n//\tif(!ok) ok=&okTmp;\n// if (expr.isEmpty()) {\n// *ok = false;\n// return 0.0;\n// }\n// double ret(0.);\n// // create a local copy of expr\n// QString expr_copy = expr;\n// // main drawing unit:\n// int insunits = RS_Units::stringToUnit(RS_SETTINGS->readEntry(\"/Unit\", \"None\"));\n// // only apply imperial shorthand conversion if current units are 'inch'\n// if (insunits==RS2::Inch) {\n// // translate imperial shorthand before you eval\n// imperialTranslate(expr_copy);\n// }\n// try{\n// mu::Parser p;\n// //p.DefineConst(\"pi\",M_PI);\n// //p.SetExpr(expr_copy.toStdString());\n// ret=p.Eval();\n// *ok=true;\n// }\n// catch (mu::Parser::exception_type &e)\n// {\n// //std::cout << e.GetMsg() << std::endl;\n// *ok=false;\n// }\n// return ret;\n//}\n\n\n/**\n * Converts a double into a string which is as short as possible\n *\n * @param value The double value\n * @param prec Precision e.g. a precision of 1 would mean that a\n * value of 2.12030 will be converted to \"2.1\". 2.000 is always just \"2\").\n */\nQString RS_Math::doubleToString(double value, double prec) {\n if (prec< RS_TOLERANCE ) {\n\t\tRS_DEBUG->print(RS_Debug::D_ERROR,\n\t\t\t\t\t\t\"RS_Math::doubleToString: invalid precision\");\n\t\treturn QString().setNum(value, prec);\n }\n\n\tdouble const num = RS_Math::round(value / prec)*prec;\n\n\tQString exaStr = RS_Math::doubleToString(1./prec, 10);\n\tint const dotPos = exaStr.indexOf('.');\n\n if (dotPos==-1) {\n\t\t//big numbers for the precision\n\t\treturn QString().setNum(RS_Math::round(num));\n } else {\n\t\t//number of digits after the point\n\t\tint digits = dotPos - 1;\n\t\treturn RS_Math::doubleToString(num, digits);\n }\n}\n\n/**\n * Converts a double into a string which is as short as possible.\n *\n * @param value The double value\n * @param prec Precision\n */\nQString RS_Math::doubleToString(double value, int prec) {\n QString valStr;\n\n valStr.setNum(value, 'f', prec);\n\n if(valStr.contains('.')) {\n // Remove tailing point and zeros:\n// valStr.replace(QRegExp(\"0*$\"), \"\");\n// valStr.replace(QRegExp(R\"(\\.$)\"), \"\");\n// while (valStr.at(valStr.length()-1)=='0') {\n// valStr.truncate(valStr.length()-1);\n// }\n\n if(valStr.at(valStr.length()-1)=='.') {\n valStr.truncate(valStr.length()-1);\n }\n\n }\n\n return valStr;\n}\n\n\n\n/**\n * Performs some testing for the math class.\n */\nvoid RS_Math::test() {\n\t{\n\t\tstd::cout<<\"testing quadratic solver\"<> const eqns{\n\t\t\t{-1., -1.},\n\t\t\t{-101., -1.},\n\t\t\t{-1., -100.},\n\t\t\t{2., 1.},\n\t\t\t{-2., 1.}\n\t\t};\n\t\t//expected roots\n\t\tstd::vector> roots{\n\t\t\t{-0.6180339887498948, 1.6180339887498948},\n\t\t\t{-0.0099000196991084878, 101.009900019699108},\n\t\t\t{-9.5124921972503929, 10.5124921972503929},\n\t\t\t{-1.},\n\t\t\t{1.}\n\t\t};\n\n\t\tfor(size_t i=0; i < eqns.size(); i++) {\n\t\t\tstd::cout<<\"Test quadratic solver, test case: x^2 + (\"\n\t\t\t\t\t< sol.back())\n\t\t\t\tstd::swap(sol[0], sol[1]);\n\t\t\tauto expected=roots[i];\n\t\t\tif (expected.front() > expected.back())\n\t\t\t\tstd::swap(expected[0], expected[1]);\n\t\t\tfor (size_t j=0; j < sol.size(); j++) {\n\t\t\t\tdouble x0 = sol[j];\n\t\t\t\tdouble x1 = expected[j];\n\t\t\t\tdouble const prec = (x0 - x1)/(fabs(x0 + x1) + RS_TOLERANCE2);\n\t\t\t\tstd::cout<<\"root \"<\nstd::vector RS_Math::quadraticSolver(const std::vector& ce)\n//quadratic solver for\n// x^2 + ce[0] x + ce[1] =0\n{\n std::vector ans(0,0.);\n\tif (ce.size() != 2) return ans;\n\tusing LDouble = long double;\n\tLDouble const b = -0.5L * ce[0];\n\tLDouble const c = ce[1];\n\t// x^2 -2 b x + c=0\n\t// (x - b)^2 = b^2 - c\n\t// b^2 >= fabs(c)\n\t// x = b \\pm b sqrt(1. - c/(b^2))\n\tLDouble const b2= b * b;\n\tLDouble const discriminant= b2 - c;\n\tLDouble const fc = std::abs(c);\n\n\t//TODO, fine tune to tolerance level\n\tLDouble const TOL = 1e-24L;\n\n\tif (discriminant < 0.L)\n\t\t//negative discriminant, no real root\n\t\treturn ans;\n\n\t//find the radical\n\tLDouble r;\n\n\t// given |p| >= |q|\n\t// sqrt(p^2 \\pm q^2) = p sqrt(1 \\pm q^2/p^2)\n\tif (b2 >= fc)\n\t\tr = std::abs(b) * std::sqrt(1.L - c/b2);\n\telse\n\t\t// c is negative, because b2 - c is non-negative\n\t\tr = std::sqrt(fc) * std::sqrt(1.L + b2/fc);\n\n\tif (r >= TOL*std::abs(b)) {\n\t\t//two roots\n\t\tif (b >= 0.L)\n\t\t\t//since both (b,r)>=0, avoid (b - r) loss of significance\n\t\t\tans.push_back(b + r);\n\t\telse\n\t\t\t//since b<0, r>=0, avoid (b + r) loss of significance\n\t\t\tans.push_back(b - r);\n\n\t\t//Vieta's formulas for the second root\n\t\tans.push_back(c/ans.front());\n\t} else\n\t\t//multiple roots\n\t\tans.push_back(b);\n\treturn ans;\n}\n\n\nstd::vector RS_Math::cubicSolver(const std::vector& ce)\n//cubic equation solver\n// x^3 + ce[0] x^2 + ce[1] x + ce[2] = 0\n{\n// std::cout<<\"x^3 + (\"< ans(0,0.);\n\tif (ce.size() != 3) return ans;\n // depressed cubic, Tschirnhaus transformation, x= t - b/(3a)\n // t^3 + p t +q =0\n double shift=(1./3)*ce[0];\n double p=ce[1] -shift*ce[0];\n double q=ce[0]*( (2./27)*ce[0]*ce[0]-(1./3)*ce[1])+ce[2];\n //Cardano's method,\n //\tt=u+v\n //\tu^3 + v^3 + ( 3 uv + p ) (u+v) + q =0\n //\tselect 3uv + p =0, then,\n //\tu^3 + v^3 = -q\n //\tu^3 v^3 = - p^3/27\n //\tso, u^3 and v^3 are roots of equation,\n //\tz^2 + q z - p^3/27 = 0\n //\tand u^3,v^3 are,\n //\t\t-q/2 \\pm sqrt(q^2/4 + p^3/27)\n //\tdiscriminant= q^2/4 + p^3/27\n //std::cout<<\"p=\"<0)?-pow(q,(1./3)):pow(-q,(1./3)));\n ans[0] -= shift;\n// DEBUG_HEADER\n// std::cout<<\"cubic: one root: \"<0) {\n std::vector ce2(2,0.);\n ce2[0]=q;\n ce2[1]=-1./27*p*p*p;\n\t\tauto r=quadraticSolver(ce2);\n if ( r.size()==0 ) { //should not happen\n\t\t\tstd::cerr<<__FILE__<<\" : \"<<__func__<<\" : line\"<<__LINE__<<\" :cubicSolver()::Error cubicSolver(\"< u(q,0),rt[3];\n\t\tu=std::pow(-0.5*u-sqrt(0.25*u*u+p*p*p/27),1./3);\n\t\trt[0]=u-p/(3.*u)-shift;\n\t\tstd::complex w(-0.5,sqrt(3.)/2);\n\t\trt[1]=u*w-p/(3.*u*w)-shift;\n\t\trt[2]=u/w-p*w/(3.*u)-shift;\n\t\t// DEBUG_HEADER\n\t\t// std::cout<<\"Roots:\\n\";\n\t\t// std::cout<fabs(f)+RS_TOLERANCE){\n\t\t\t\tdx=f/df;\n\t\t\t\tx0 -= dx;\n\t\t\t}else\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n return ans;\n}\n\n/** quartic solver\n* x^4 + ce[0] x^3 + ce[1] x^2 + ce[2] x + ce[3] = 0\n@ce, a vector of size 4 contains the coefficient in order\n@return, a vector contains real roots\n**/\nstd::vector RS_Math::quarticSolver(const std::vector& ce)\n{\n std::vector ans(0,0.);\n if(RS_DEBUG->getLevel()>=RS_Debug::D_INFORMATIONAL){\n\t\tDEBUG_HEADER\n std::cout<<\"expected array size=4, got \"<getLevel()>=RS_Debug::D_INFORMATIONAL){\n std::cout<<\"x^4+(\"<getLevel()>=RS_Debug::D_INFORMATIONAL){\n\t\tDEBUG_HEADER\n std::cout<<\"x^4+(\"<= 0.) { // two real roots\n ans.push_back(sqrt(t2[1])-shift);\n ans.push_back(-sqrt(t2[1])-shift);\n }\n if ( t2[0] >= 0. ) {// four real roots\n ans.push_back(sqrt(t2[0])-shift);\n ans.push_back(-sqrt(t2[0])-shift);\n }\n// DEBUG_HEADER\n// for(int i=0;i cubic(3,0.);\n cubic[1]=p;\n cubic[2]=q;\n ans.push_back(0.);\n\t\tauto r=cubicSolver(cubic);\n\t\tstd::copy(r.begin(),r.end(), std::back_inserter(ans));\n for(size_t i=0; i cubic(3,0.);\n cubic[0]=2.*p;\n cubic[1]=p*p-4.*r;\n cubic[2]=-q*q;\n\tauto r3= cubicSolver(cubic);\n //std::cout<<\"quartic_solver:: real roots from cubic: \"< ce2(2,0.);\n ce2[0]=\t-sqrtz0;\n ce2[1]=0.5*(p+r3[0])+0.5*q/sqrtz0;\n auto r1=quadraticSolver(ce2);\n if (r1.size()==0 ) {\n ce2[0]=\tsqrtz0;\n ce2[1]=0.5*(p+r3[0])-0.5*q/sqrtz0;\n r1=quadraticSolver(ce2);\n }\n\t\tfor(auto& x: r1){\n\t\t\tx -= shift;\n\t\t}\n return r1;\n }\n if ( r3[0]> 0. && r3[1] > 0. ) {\n double sqrtz0=sqrt(r3[0]);\n std::vector ce2(2,0.);\n ce2[0]=\t-sqrtz0;\n ce2[1]=0.5*(p+r3[0])+0.5*q/sqrtz0;\n ans=quadraticSolver(ce2);\n ce2[0]=\tsqrtz0;\n ce2[1]=0.5*(p+r3[0])-0.5*q/sqrtz0;\n\t\tauto r1=quadraticSolver(ce2);\n\t\tstd::copy(r1.begin(),r1.end(),std::back_inserter(ans));\n\t\tfor(auto& x: ans){\n\t\t\tx -= shift;\n\t\t}\n }\n\t// newton-raphson\n\tfor(double& x0: ans){\n\t\tdouble dx=0.;\n\t\tfor(size_t i=0; i<20; ++i){\n\t\t\tdouble f=(( (x0 + ce[0])*x0 + ce[1])*x0 +ce[2])*x0 + ce[3] ;\n\t\t\tdouble df=((4.*x0+3.*ce[0])*x0 +2.*ce[1])*x0+ce[2];\n//\t\t\tDEBUG_HEADER\n//\t\t\tqDebug()<<\"i=\"<RS_TOLERANCE2){\n\t\t\t\tdx=f/df;\n\t\t\t\tx0 -= dx;\n\t\t\t}else\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n return ans;\n}\n\n/** quartic solver\n* ce[4] x^4 + ce[3] x^3 + ce[2] x^2 + ce[1] x + ce[0] = 0\n@ce, a vector of size 5 contains the coefficient in order\n@return, a vector contains real roots\n*ToDo, need a robust algorithm to locate zero terms, better handling of tolerances\n**/\nstd::vector RS_Math::quarticSolverFull(const std::vector& ce)\n{\n if(RS_DEBUG->getLevel()>=RS_Debug::D_INFORMATIONAL){\n\t\tDEBUG_HEADER\n std::cout< roots(0,0.);\n if(ce.size()!=5) return roots;\n std::vector ce2(4,0.);\n\n if ( fabs(ce[4]) < 1.0e-14) { // this should not happen\n if ( fabs(ce[3]) < 1.0e-14) { // this should not happen\n if ( fabs(ce[2]) < 1.0e-14) { // this should not happen\n if( fabs(ce[1]) > 1.0e-14) {\n roots.push_back(-ce[0]/ce[1]);\n } else { // can not determine y. this means overlapped, but overlap should have been detected before, therefore return empty set\n return roots;\n }\n } else {\n ce2.resize(2);\n ce2[0]=ce[1]/ce[2];\n ce2[1]=ce[0]/ce[2];\n //std::cout<<\"ce2[2]={ \"<getLevel()>=RS_Debug::D_INFORMATIONAL){\n\t\t\tDEBUG_HEADER\n std::cout<<\"ce2[4]={ \"< >& mt, std::vector& sn){\n //verify the matrix size\n\tsize_t mSize(mt.size()); //rows\n\tsize_t aSize(mSize+1); //columns of augmented matrix\n\tif(std::any_of(mt.begin(), mt.end(), [&aSize](const std::vector& v)->bool{\n\t\t\t\t return v.size() != aSize;\n}))\n\t\treturn false;\n sn.resize(mSize);//to hold the solution\n#if false\n boost::numeric::ublas::matrix bm (mSize, mSize);\n boost::numeric::ublas::vector bs(mSize);\n\n for(int i=0;i >(bm) ) {\n\t\tstd::cout<<__FILE__<<\" : \"<<__func__<<\" : line \"<<__LINE__<print(RS_Debug::D_WARNING, \"linear solver failed\");\n return false;\n }\n\n boost::numeric::ublas:: triangular_matrix\n lm = boost::numeric::ublas::triangular_adaptor< boost::numeric::ublas::matrix, boost::numeric::ublas::unit_lower>(bm);\n boost::numeric::ublas:: triangular_matrix\n um = boost::numeric::ublas::triangular_adaptor< boost::numeric::ublas::matrix, boost::numeric::ublas::upper>(bm);\n ;\n boost::numeric::ublas::inplace_solve(lm,bs, boost::numeric::ublas::lower_tag());\n boost::numeric::ublas::inplace_solve(um,bs, boost::numeric::ublas::upper_tag());\n for(int i=0;i > mt0(mt); //copy the matrix;\n\tfor(size_t i=0;i cmax ) {\n imax=j;\n cmax=fabs(mt0[j][i]);\n }\n }\n if(cmax0.) {\n return boost::math::ellint_2(k,a);\n } else {\n return - boost::math::ellint_2(k,fabs(a));\n }\n}\n\n/** solver quadratic simultaneous equations of set two **/\n/* solve the following quadratic simultaneous equations,\n * ma000 x^2 + ma011 y^2 - 1 =0\n * ma100 x^2 + 2 ma101 xy + ma111 y^2 + mb10 x + mb11 y +mc1 =0\n *\n *@m, a vector of size 8 contains coefficients in the strict order of:\n ma000 ma011 ma100 ma101 ma111 mb10 mb11 mc1\n * m[0] m[1] must be positive\n *@return a vector contains real roots\n */\nRS_VectorSolutions RS_Math::simultaneousQuadraticSolver(const std::vector& m)\n{\n RS_VectorSolutions ret(0);\n if(m.size() != 8 ) return ret; // valid m should contain exact 8 elements\n std::vector< double> c1(0,0.);\n std::vector< std::vector > m1(0,c1);\n c1.resize(6);\n c1[0]=m[0];\n c1[1]=0.;\n c1[2]=m[1];\n c1[3]=0.;\n c1[4]=0.;\n c1[5]=-1.;\n m1.push_back(c1);\n c1[0]=m[2];\n c1[1]=2.*m[3];\n c1[2]=m[4];\n c1[3]=m[5];\n c1[4]=m[6];\n c1[5]=m[7];\n m1.push_back(c1);\n\n return simultaneousQuadraticSolverFull(m1);\n}\n\n/** solver quadratic simultaneous equations of a set of two **/\n/* solve the following quadratic simultaneous equations,\n * ma000 x^2 + ma001 xy + ma011 y^2 + mb00 x + mb01 y + mc0 =0\n * ma100 x^2 + ma101 xy + ma111 y^2 + mb10 x + mb11 y + mc1 =0\n *\n *@m, a vector of size 2 each contains a vector of size 6 coefficients in the strict order of:\n ma000 ma001 ma011 mb00 mb01 mc0\n ma100 ma101 ma111 mb10 mb11 mc1\n *@return a RS_VectorSolutions contains real roots (x,y)\n */\nRS_VectorSolutions RS_Math::simultaneousQuadraticSolverFull(const std::vector >& m)\n{\n RS_VectorSolutions ret;\n if(m.size()!=2) return ret;\n if( m[0].size() ==3 || m[1].size()==3 ){\n return simultaneousQuadraticSolverMixed(m);\n }\n if(m[0].size()!=6 || m[1].size()!=6) return ret;\n /** eliminate x, quartic equation of y **/\n auto& a=m[0][0];\n auto& b=m[0][1];\n auto& c=m[0][2];\n auto& d=m[0][3];\n auto& e=m[0][4];\n auto& f=m[0][5];\n\n auto& g=m[1][0];\n auto& h=m[1][1];\n auto& i=m[1][2];\n auto& j=m[1][3];\n auto& k=m[1][4];\n auto& l=m[1][5];\n /**\n Collect[Eliminate[{ a*x^2 + b*x*y+c*y^2+d*x+e*y+f==0,g*x^2+h*x*y+i*y^2+j*x+k*y+l==0},x],y]\n **/\n /*\n f^2 g^2 - d f g j + a f j^2 - 2 a f g l + (2 e f g^2 - d f g h - b f g j + 2 a f h j - 2 a f g k) y + (2 c f g^2 - b f g h + a f h^2 - 2 a f g i) y^2\n ==\n -(d^2 g l) + a d j l - a^2 l^2\n+\n (d e g j - a e j^2 - d^2 g k + a d j k - 2 b d g l + 2 a e g l + a d h l + a b j l - 2 a^2 k l) y\n+\n (-(e^2 g^2) + d e g h - d^2 g i + c d g j + b e g j - 2 a e h j + a d i j - a c j^2 - 2 b d g k + 2 a e g k + a d h k + a b j k - a^2 k^2 - b^2 g l + 2 a c g l + a b h l - 2 a^2 i l) y^2\n +\n(-2 c e g^2 + c d g h + b e g h - a e h^2 - 2 b d g i + 2 a e g i + a d h i + b c g j - 2 a c h j + a b i j - b^2 g k + 2 a c g k + a b h k - 2 a^2 i k) y^3\n+\n (-(c^2 g^2) + b c g h - a c h^2 - b^2 g i + 2 a c g i + a b h i - a^2 i^2) y^4\n\n\n */\n double a2=a*a;\n double b2=b*b;\n double c2=c*c;\n double d2=d*d;\n double e2=e*e;\n double f2=f*f;\n\n double g2=g*g;\n double h2=h*h;\n double i2=i*i;\n double j2=j*j;\n double k2=k*k;\n double l2=l*l;\n std::vector qy(5,0.);\n //y^4\n qy[4]=-c2*g2 + b*c*g*h - a*c*h2 - b2*g*i + 2.*a*c*g*i + a*b*h*i - a2*i2;\n //y^3\n qy[3]=-2.*c*e*g2 + c*d*g*h + b*e*g*h - a*e*h2 - 2.*b*d*g*i + 2.*a*e*g*i + a*d*h*i +\n b*c*g*j - 2.*a*c*h*j + a*b*i*j - b2*g*k + 2.*a*c*g*k + a*b*h*k - 2.*a2*i*k;\n //y^2\n qy[2]=(-e2*g2 + d*e*g*h - d2*g*i + c*d*g*j + b*e*g*j - 2.*a*e*h*j + a*d*i*j - a*c*j2 -\n 2.*b*d*g*k + 2.*a*e*g*k + a*d*h*k + a*b*j*k - a2*k2 - b2*g*l + 2.*a*c*g*l + a*b*h*l - 2.*a2*i*l)\n - (2.*c*f*g2 - b*f*g*h + a*f*h2 - 2.*a*f*g*i);\n //y\n qy[1]=(d*e*g*j - a*e*j2 - d2*g*k + a*d*j*k - 2.*b*d*g*l + 2.*a*e*g*l + a*d*h*l + a*b*j*l - 2.*a2*k*l)\n -(2.*e*f*g2 - d*f*g*h - b*f*g*j + 2.*a*f*h*j - 2.*a*f*g*k);\n //y^0\n qy[0]=-d2*g*l + a*d*j*l - a2*l2\n - ( f2*g2 - d*f*g*j + a*f*j2 - 2.*a*f*g*l);\n\tif(RS_DEBUG->getLevel()>=RS_Debug::D_INFORMATIONAL){\n\t\tDEBUG_HEADER\n std::cout<getLevel()>=RS_Debug::D_INFORMATIONAL){\n std::cout<<\"roots.size()= \"< ce(0,0.);\n\n for(size_t i0=0;i0getLevel()>=RS_Debug::D_INFORMATIONAL){\n\t\t\tDEBUG_HEADER\n std::cout<<\"y=\"<1e-75){\n std::vector ce2(2,0.);\n ce2[0]=ce[1]/ce[0];\n ce2[1]=ce[2]/ce[0];\n// DEBUG_HEADER\n// std::cout<<\"x^2 +(\"<getLevel()>=RS_Debug::D_INFORMATIONAL){\n\t\tDEBUG_HEADER\n std::cout<<\"ret=\"< >& m)\n{\n RS_VectorSolutions ret;\n auto p0=& (m[0]);\n auto p1=& (m[1]);\n if(p1->size()==3){\n std::swap(p0,p1);\n }\n if(p1->size()==3) {\n //linear\n\t\t\tstd::vector sn(2,0.);\n\t\t\tstd::vector > ce;\n\t\t\tce.push_back(m[0]);\n\t\t\tce.push_back(m[1]);\n ce[0][2]=-ce[0][2];\n ce[1][2]=-ce[1][2];\n if( RS_Math::linearSolver(ce,sn)) ret.push_back(RS_Vector(sn[0],sn[1]));\n return ret;\n }\n// DEBUG_HEADER\n// std::cout<<\"p0: size=\"<size()<<\"\\n Solve[{(\"<< p0->at(0)<<\")*x + (\"<at(1)<<\")*y + (\"<at(2)<<\")==0,\";\n// std::cout<<\"(\"<< p1->at(0)<<\")*x^2 + (\"<at(1)<<\")*x*y + (\"<at(2)<<\")*y^2 + (\"<at(3)<<\")*x +(\"<at(4)<<\")*y+(\"\n// <at(5)<<\")==0},{x,y}]\"<at(0);\n const double& b=p0->at(1);\n const double& c=p0->at(2);\n const double& d=p1->at(0);\n const double& e=p1->at(1);\n const double& f=p1->at(2);\n const double& g=p1->at(3);\n const double& h=p1->at(4);\n const double& i=p1->at(5);\n /**\n y (2 b c d-a c e)-a c g+c^2 d = y^2 (a^2 (-f)+a b e-b^2 d)+y (a b g-a^2 h)+a^2 (-i)\n */\n std::vector ce(3,0.);\n\tconst double& a2=a*a;\n\tconst double& b2=b*b;\n\tconst double& c2=c*c;\n ce[0]= -f*a2+a*b*e-b2*d;\n ce[1]=a*b*g-a2*h- (2*b*c*d-a*c*e);\n ce[2]=a*c*g-c2*d-a2*i;\n// DEBUG_HEADER\n// std::cout<<\"(\"< roots(0,0.);\n if( fabs(ce[1])>RS_TOLERANCE15 && fabs(ce[0]/ce[1]) ce2(2,0.);\n ce2[0]=ce[1]/ce[0];\n ce2[1]=ce[2]/ce[0];\n roots=quadraticSolver(ce2);\n }\n// for(size_t i=0;i >& m, RS_Vector& v)\n{\n\tRS_Vector v0=v;\n\tauto& a=m[0][0];\n\tauto& b=m[0][1];\n\tauto& c=m[0][2];\n\tauto& d=m[0][3];\n\tauto& e=m[0][4];\n\tauto& f=m[0][5];\n\n\tauto& g=m[1][0];\n\tauto& h=m[1][1];\n\tauto& i=m[1][2];\n\tauto& j=m[1][3];\n\tauto& k=m[1][4];\n\tauto& l=m[1][5];\n /**\n * tolerance test for bug#3606099\n * verifying the equations to floating point tolerance by terms\n */\n\tdouble sum0=0., sum1=0.;\n\tdouble f00=0.,f01=0.;\n\tdouble amax0, amax1;\n\tfor(size_t i0=0; i0<20; ++i0){\n\t\tdouble& x=v.x;\n\t\tdouble& y=v.y;\n\t\tdouble x2=x*x;\n\t\tdouble y2=y*y;\n\t\tdouble const terms0[12]={ a*x2, b*x*y, c*y2, d*x, e*y, f, g*x2, h*x*y, i*y2, j*x, k*y, l};\n\t\tamax0=fabs(terms0[0]), amax1=fabs(terms0[6]);\n\t\tdouble px=2.*a*x+b*y+d;\n\t\tdouble py=b*x+2.*c*y+e;\n\t\tsum0=0.;\n\t\tfor(int i=0; i<6; i++) {\n\t\t\tif(amax0> nrCe;\n\t\tnrCe.push_back(std::vector{px, py, sum0});\n\t\tpx=2.*g*x+h*y+j;\n\t\tpy=h*x+2.*i*y+k;\n\t\tsum1=0.;\n\t\tfor(int i=6; i<12; i++) {\n\t\t\tif(amax1{px, py, sum1});\n\t\tstd::vector dn;\n\t\tbool ret=linearSolver(nrCe, dn);\n//\t\tDEBUG_HEADER\n//\t\tqDebug()<<\"i0=\"< fabs(f00) && fabs(sum1)>fabs(f01)){\n\t\tv=v0;\n\t\tsum0=f00;\n\t\tsum1=f01;\n\t}\n\n// DEBUG_HEADER\n// std::cout<<\"verifying: x=\"<\n#include \n#include \n\n#include \n\n\nusing namespace boost::multiprecision::literals;\nusing boost::multiprecision::number;\nusing boost::multiprecision::backends::cpp_int_backend;\nusing boost::multiprecision::cpp_integer_type;\nusing boost::multiprecision::cpp_int_check_type;\n\nusing std::cout;\n\n#define BLS12_381_MODULUS_LEN 255\n#define GRAIN_LFSR_STATE_LEN 80\n\n\nBOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(BLS12_381_MODULUS_LEN);\nBOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(GRAIN_LFSR_STATE_LEN);\n\n\ntemplate\nstruct round_constants_generator {\n constexpr static std::size_t modulus_bits = BLS12_381_MODULUS_LEN;\n constexpr static std::size_t state_bits = GRAIN_LFSR_STATE_LEN;\n\n typedef number>\n integral_type;\n typedef number>\n state_type;\n\n constexpr static integral_type mod = 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001_cppui255;\n\n\n constexpr void generate_round_constants() {\n integral_type constant = 0x0_cppui255;\n state_type lfsr_state = get_lfsr_init_state();\n\n for (std::size_t i = 0; i < (full_rounds + part_rounds) * t; i++) {\n while (true) {\n constant = 0x0_cppui255;\n for (std::size_t i = 0; i < modulus_bits; i++) {\n lfsr_state = update_state(lfsr_state);\n constant = set_new_bit(constant, get_state_bit(lfsr_state, state_bits - 1));\n }\n if (constant < 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001_cppui255) {\n constants[i] = constant;\n break;\n }\n }\n }\n }\n\n constexpr void generate_round_constants_unfolded() {\n integral_type constant = 0x0_cppui255;\n bool new_bit = false;\n state_type lfsr_state = get_lfsr_init_state();\n\n for (std::size_t i = 0; i < (full_rounds + part_rounds) * t; i++) {\n while (true) {\n constant = 0x0_cppui255;\n for (std::size_t i = 0; i < modulus_bits; i++) {\n while (true) {\n new_bit = ((lfsr_state & (0x1_cppui80 << (state_bits - 1))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 13))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 23))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 38))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 51))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 62))) != 0);\n lfsr_state = (lfsr_state << 1) | (new_bit ? 1 : 0);\n if (new_bit)\n break;\n else {\n new_bit = ((lfsr_state & (0x1_cppui80 << (state_bits - 1))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 13))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 23))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 38))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 51))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 62))) != 0);\n lfsr_state = (lfsr_state << 1) | (new_bit ? 1 : 0);\n }\n }\n new_bit = ((lfsr_state & (0x1_cppui80 << (state_bits - 1))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 13))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 23))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 38))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 51))) != 0) !=\n ((lfsr_state & (0x1_cppui80 << (state_bits - 1 - 62))) != 0);\n lfsr_state = (lfsr_state << 1) | (new_bit ? 1 : 0);\n constant = (constant << 1) | (lfsr_state & 1);\n }\n if (constant < 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001_cppui255) {\n constants[i] = constant;\n break;\n }\n }\n }\n }\n\n constexpr static integral_type get_round_constant(std::size_t constant_number) {\n integral_type constant = 0x0_cppui255;\n\n state_type lfsr_state = get_lfsr_init_state();\n\n // previous constants\n for (std::size_t i = 0; i < constant_number; i++) {\n constant = 0x0_cppui255;\n while (true) {\n constant = 0x0_cppui255;\n for (std::size_t i = 0; i < modulus_bits; i++) {\n lfsr_state = update_state(lfsr_state);\n constant = set_new_bit(constant, get_state_bit(lfsr_state, state_bits - 1));\n }\n if (constant < 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001_cppui255)\n break;\n }\n }\n\n // requested constant\n while (true) {\n constant = 0x0_cppui255;\n for (std::size_t i = 0; i < modulus_bits; i++) {\n lfsr_state = update_state(lfsr_state);\n constant = set_new_bit(constant, get_state_bit(lfsr_state, state_bits - 1));\n }\n if (constant < 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001_cppui255)\n break;\n }\n\n return constant;\n }\n\n constexpr static state_type get_lfsr_init_state() {\n state_type state = 0x0_cppui80;\n int i = 0;\n for (i = 1; i >= 0; i--)\n state = set_new_bit(state, (1 >> i) & 1); // field - as in filecoin\n for (i = 3; i >= 0; i--)\n state = set_new_bit(state, (1 >> i) & 1); // s-box - as in filecoin\n for (i = 11; i >= 0; i--)\n state = set_new_bit(state, (modulus_bits >> i) & 1);\n for (i = 11; i >= 0; i--)\n state = set_new_bit(state, (t >> i) & 1);\n for (i = 9; i >= 0; i--)\n state = set_new_bit(state, (full_rounds >> i) & 1);\n for (i = 9; i >= 0; i--)\n state = set_new_bit(state, (part_rounds >> i) & 1);\n for (i = 29; i >= 0; i--)\n state = set_new_bit(state, 1);\n // idling\n for (i = 0; i < 160; i++)\n state = update_state_raw(state);\n return state;\n }\n\n constexpr static state_type update_state(state_type state) {\n while (true) {\n state = update_state_raw(state);\n if (get_state_bit(state, state_bits - 1))\n break;\n else\n state = update_state_raw(state);\n }\n return update_state_raw(state);\n }\n\n constexpr static state_type update_state_raw(state_type state) {\n bool new_bit = get_state_bit(state, 0) != get_state_bit(state, 13) != get_state_bit(state, 23) !=\n get_state_bit(state, 38) != get_state_bit(state, 51) != get_state_bit(state, 62);\n return set_new_bit(state, new_bit);\n }\n\n constexpr static bool get_state_bit(state_type state, std::size_t pos) {\n state_type bit_getter = 0x1_cppui80;\n bit_getter <<= (state_bits - 1 - pos);\n return (state & bit_getter) ? true : false;\n }\n\n template\n constexpr static T set_new_bit(T var, bool new_bit) {\n return (var << 1) | (new_bit ? 1 : 0);\n }\n\n constexpr round_constants_generator() : constants() {\n // generate_round_constants();\n generate_round_constants_unfolded();\n \n }\n\n integral_type constants[(full_rounds + part_rounds) * t];\n\n};\n\n\nint main() {\n constexpr std::size_t width = 4;\n constexpr std::size_t full_rounds = 8;\n constexpr std::size_t part_rounds = 56;\n typedef round_constants_generator rcg;\n \n // Add option -fconstexpr-ops-limit=4294967296 to compiler\n constexpr rcg gen;\n for (std::size_t i = 0; i < (8 + 56) * 4; i++)\n cout << gen.constants[i] << '\\n';\n\n return 0;\n}\n", "meta": {"hexsha": "cbdab3963f9230727bca73aa3caefaa793b2a6ae", "size": 8782, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "test/tmp_poseidon_constexpr_generation.cpp", "max_stars_repo_name": "JasonCoombs/crypto3-hash", "max_stars_repo_head_hexsha": "a4f330d14029b0b0330a5697ef24e825137ffded", "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": "test/tmp_poseidon_constexpr_generation.cpp", "max_issues_repo_name": "JasonCoombs/crypto3-hash", "max_issues_repo_head_hexsha": "a4f330d14029b0b0330a5697ef24e825137ffded", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 46.0, "max_issues_repo_issues_event_min_datetime": "2019-06-07T23:11:49.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-12T00:09:30.000Z", "max_forks_repo_path": "test/tmp_poseidon_constexpr_generation.cpp", "max_forks_repo_name": "JasonCoombs/crypto3-hash", "max_forks_repo_head_hexsha": "a4f330d14029b0b0330a5697ef24e825137ffded", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-01-11T15:35:55.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-11T15:35:55.000Z", "avg_line_length": 41.6208530806, "max_line_length": 138, "alphanum_fraction": 0.5413345479, "num_tokens": 2425, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872045937171069, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.5457087709534584}} {"text": "#include \"average_case_error.hpp\"\n\n#include \n#include \n\nusing abo::util::NumberRepresentation;\nusing boost::multiprecision::cpp_dec_float_100;\nusing boost::multiprecision::uint256_t;\n\nnamespace abo::error_metrics {\n\ncpp_dec_float_100 average_value(const std::vector& f)\n{\n\n uint256_t sum = 0;\n const uint256_t one = 1;\n\n int max_support_size = 0;\n for (const auto& bdd : f)\n {\n max_support_size = std::max(max_support_size, bdd.SupportSize());\n }\n\n for (unsigned int i = 0; i < f.size(); i++)\n {\n // TODO: CountMinterms returns a double, might loose precision\n double minterms = f[i].CountMinterm(max_support_size);\n sum += (one << i) * uint256_t(minterms);\n }\n\n return cpp_dec_float_100(sum) /\n cpp_dec_float_100(one << max_support_size);\n}\n\ncpp_dec_float_100 mean_squared_value(const std::vector& f)\n{\n\n uint256_t sum = 0;\n const uint256_t one = 1;\n\n int max_support_size = 0;\n for (const auto& bdd : f)\n {\n max_support_size = std::max(max_support_size, bdd.SupportSize());\n }\n\n for (unsigned int i = 0; i < f.size(); i++)\n {\n for (unsigned int b = i; b < f.size(); b++)\n {\n // cudd handles the case i = b efficiently\n BDD both = f[i] & f[b];\n double minterms = both.CountMinterm(max_support_size);\n // most terms (except for i == b), appear twice when factoring the square\n uint256_t doubling_factor = i == b ? 1 : 2;\n sum += (one << i) * (one << b) * uint256_t(minterms) *\n doubling_factor;\n }\n }\n\n return cpp_dec_float_100(sum) /\n cpp_dec_float_100(one << max_support_size);\n}\n\ncpp_dec_float_100\naverage_case_error(const Cudd& mgr, const std::vector& f,\n const std::vector& f_hat,\n const util::NumberRepresentation num_rep)\n{\n\n std::vector absolute_difference =\n abo::util::bdd_absolute_difference(mgr, f, f_hat, num_rep);\n return average_value(absolute_difference);\n}\n\ncpp_dec_float_100\nmean_squared_error(const Cudd& mgr, const std::vector& f,\n const std::vector& f_hat,\n const util::NumberRepresentation num_rep)\n{\n\n std::vector absolute_difference =\n abo::util::bdd_absolute_difference(mgr, f, f_hat, num_rep);\n return mean_squared_value(absolute_difference);\n}\n\ncpp_dec_float_100 average_case_error_add(const Cudd& mgr,\n const std::vector& f,\n const std::vector& f_hat,\n const NumberRepresentation num_rep)\n{\n\n ADD diff = abo::util::absolute_difference_add(mgr, f, f_hat, num_rep);\n std::vector> terminal_values =\n abo::util::add_terminal_values(diff);\n\n uint256_t sum = 0;\n uint256_t path_sum = 0;\n for (auto p : terminal_values)\n {\n sum += uint256_t(p.first) * p.second;\n path_sum += p.second;\n }\n return cpp_dec_float_100(sum) /\n cpp_dec_float_100(path_sum);\n}\n\ncpp_dec_float_100 mean_squared_error_add(const Cudd& mgr,\n const std::vector& f,\n const std::vector& f_hat,\n const NumberRepresentation num_rep)\n{\n\n ADD diff = abo::util::absolute_difference_add(mgr, f, f_hat, num_rep);\n std::vector> terminal_values =\n abo::util::add_terminal_values(diff);\n\n uint256_t sum = 0;\n uint256_t path_sum = 0;\n for (auto p : terminal_values)\n {\n uint256_t value(p.first);\n sum += value * value * p.second;\n path_sum += p.second;\n }\n return cpp_dec_float_100(sum) /\n cpp_dec_float_100(path_sum);\n}\n\n} // namespace abo::error_metrics\n", "meta": {"hexsha": "a6dd013c162ec7e86f2d02de7c5be46f5110451a", "size": 3981, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/error_metrics/average_case_error.cpp", "max_stars_repo_name": "keszocze/abo", "max_stars_repo_head_hexsha": "2d59ac20832b308ef5f90744fc98752797a4f4ba", "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/error_metrics/average_case_error.cpp", "max_issues_repo_name": "keszocze/abo", "max_issues_repo_head_hexsha": "2d59ac20832b308ef5f90744fc98752797a4f4ba", "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/error_metrics/average_case_error.cpp", "max_forks_repo_name": "keszocze/abo", "max_forks_repo_head_hexsha": "2d59ac20832b308ef5f90744fc98752797a4f4ba", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-03-11T14:50:31.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-11T14:50:31.000Z", "avg_line_length": 30.3893129771, "max_line_length": 85, "alphanum_fraction": 0.6028636021, "num_tokens": 988, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382094310357, "lm_q2_score": 0.6334102636778401, "lm_q1q2_score": 0.5457071444042465}} {"text": "/*\r\n * Copyright (c) 2007-2010 Tao Wang \r\n * See the file \"LICENSE.txt\" for usage and redistribution license requirements\r\n *\r\n *\t$Id$\r\n */\r\n#pragma once\r\n#ifndef _OPENCLAS_K_SHORTEST_PATH_HPP_\r\n#define _OPENCLAS_K_SHORTEST_PATH_HPP_\r\n\r\n//\tworkaround for remove VC min(a,b) macro function definition,\r\n//\twhich is make std::min() not working.\r\n#if defined(_MSC_VER) && defined(min)\r\n#undef min\r\n#endif\t//\tmin\r\n\r\n#include \"common.hpp\"\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\nnamespace openclas {\r\n\r\n\tusing namespace boost;\r\n\r\n\tstruct path_type {\r\n\t\tdouble weight;\r\n\t\tstd::vector nodelist;\r\n\t\tpath_type()\r\n\t\t\t: weight(0), nodelist()\r\n\t\t{}\r\n\t};\r\n\r\n\tinline bool operator < (const path_type& left, const path_type& right)\r\n\t{\r\n\t\treturn left.weight < right.weight;\r\n\t}\r\n\r\n\t//\tFind all paths of given pair of node in a DAG. (DFS-like algorithm)\r\n\ttemplate \r\n\tvoid dag_all_paths(IncidenceGraph& g, \r\n\t\ttypename graph_traits::vertex_descriptor begin, \r\n\t\ttypename graph_traits::vertex_descriptor end,\r\n\t\tstd::vector& result_paths,\r\n\t\tpath_type current_path = path_type())\r\n\t{\r\n\t\tfunction_requires >();\r\n\r\n\t\tif (num_vertices(g) == 0)\r\n\t\t\treturn;\t//\treturn if g is empty\r\n\r\n\t\tcurrent_path.nodelist.push_back(begin);\r\n\t\tif (begin == end) {\r\n\t\t\tresult_paths.push_back(current_path);\r\n\t\t} else {\r\n\t\t\ttypename graph_traits::out_edge_iterator ei, ei_end;\r\n\t\t\ttypename property_map::type\r\n\t\t\t\tw_map = get(edge_weight, g);\r\n\t\t\tdouble original_weight = current_path.weight;\r\n\t\t\tfor (tie(ei, ei_end) = out_edges(begin, g); ei != ei_end; ++ei) {\r\n\t\t\t\ttypename graph_traits::vertex_descriptor v = target(*ei, g);\r\n\t\t\t\tcurrent_path.weight = original_weight + w_map[edge(begin, v, g).first];\r\n\t\t\t\tdag_all_paths(g, v, end, result_paths, current_path);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t//\tFind k-shortest-path in DAG.\r\n\ttemplate \r\n\tvoid dag_k_shortest_paths(IncidenceGraph& g, \r\n\t\ttypename graph_traits::vertex_descriptor begin, \r\n\t\ttypename graph_traits::vertex_descriptor end,\r\n\t\tstd::vector& result_paths,\r\n\t\tint k)\r\n\t{\r\n\t\tif (num_vertices(g) == 0)\r\n\t\t\treturn;\t//\treturn if g is empty\r\n\r\n\t\tif (k == 1) {\r\n\t\t\tpath_type shortest_path;\r\n\t\t\tdag_shortest_path(g, begin, end, shortest_path);\r\n\t\t\tresult_paths.push_back(shortest_path);\r\n\t\t}else{\r\n\t\t\tstd::vector candidate_paths;\r\n\t\t\tdag_all_paths(g, begin, end, candidate_paths);\r\n\r\n\t\t\tk = std::min(k, static_cast(candidate_paths.size()));\r\n\t\t\tstd::partial_sort(candidate_paths.begin(), candidate_paths.begin() + k, candidate_paths.end());\r\n\t\t\tresult_paths.assign(candidate_paths.begin(), candidate_paths.begin() + k);\r\n\t\t}\r\n\t}\r\n\r\n\t//\tFind shortest-path in DAG. O(n+m)\r\n\ttemplate \r\n\tvoid dag_shortest_path(Graph& g, \r\n\t\ttypename graph_traits::vertex_descriptor begin, \r\n\t\ttypename graph_traits::vertex_descriptor end,\r\n\t\tpath_type& result_path)\r\n\t{\r\n\t\tif (num_vertices(g) == 0)\r\n\t\t\treturn;\t//\treturn if g is empty\r\n\r\n\t\ttypename property_map::type\r\n\t\t\td_map = get(vertex_distance, g);\r\n\t\ttypename property_map::type\r\n\t\t\tp_map = get(vertex_predecessor, g);\r\n\r\n\t\tif (begin == end) {\r\n\t\t\tresult_path.nodelist.push_back(begin);\r\n\t\t} else {\r\n\t\t\tdag_shortest_paths(g, begin, distance_map(d_map).predecessor_map(p_map));\r\n\r\n\t\t\tif (end == p_map[end])\t//\t[begin] is not connected with [end]\r\n\t\t\t\treturn;\r\n\r\n\t\t\tresult_path.weight = d_map[end];\r\n\t\t\tresult_path.nodelist.push_back(end);\r\n\r\n\t\t\tsize_t current = end;\r\n\t\t\twhile(current != begin)\r\n\t\t\t{\r\n\t\t\t\tcurrent = p_map[current];\r\n\t\t\t\tresult_path.nodelist.push_back(current);\r\n\t\t\t}\r\n\t\t\tstd::reverse(result_path.nodelist.begin(), result_path.nodelist.end());\r\n\t\t}\r\n\t}\r\n}\r\n\r\n//\t_OPENCLAS_K_SHORTEST_PATH_HPP_\r\n#endif\r\n", "meta": {"hexsha": "4ac5ed1386680404e16c8f0c2d1adb8decc8fdb5", "size": 4070, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "cpp/include/openclas/k_shortest_path.hpp", "max_stars_repo_name": "dancefire/openclas", "max_stars_repo_head_hexsha": "af15aad1891cb7e597dfe9dbc92dbd91093d613e", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cpp/include/openclas/k_shortest_path.hpp", "max_issues_repo_name": "dancefire/openclas", "max_issues_repo_head_hexsha": "af15aad1891cb7e597dfe9dbc92dbd91093d613e", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cpp/include/openclas/k_shortest_path.hpp", "max_forks_repo_name": "dancefire/openclas", "max_forks_repo_head_hexsha": "af15aad1891cb7e597dfe9dbc92dbd91093d613e", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.1481481481, "max_line_length": 99, "alphanum_fraction": 0.6992628993, "num_tokens": 1049, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7401743505760728, "lm_q2_score": 0.7371581626286834, "lm_q1q2_score": 0.5456255642955368}} {"text": "#include \n#include \n\nvoid random(NTL::mat_GF2 &L, int n1, int n2)\n{\n\tL.SetDims(n1,n2);\n\tint hw;\n\tfor (int i = 0; i < n1; i++)\n\t{\n\t\tdo\n\t \t{\n\t \t\thw = 0;\n\t\t\t\tfor (int j = 0; j < n2; j++)\n\t\t\t\t{\n\t\t\t\t\tL[i][j] = NTL::random_GF2();\n\t\t\t\t\tif (L[i][j] == 1)\n\t\t\t hw += 1;\n\t\t\t\t}\n\t\t\t} while (hw == 1);\n\t}\n}\nint initMatrixFromBit(NTL::mat_GF2 &M, long *data) {\n long i,j,n,m;\n\tfor(i=0, n=M.NumRows(); i=0; j--){\n\t\t\tM.put(i,j,t%2);\n\t\t\tt >>= 1;\n\t\t}\n\t\tdata++;\n\t}\n\n\treturn 0;\n}\n\nint initVecFromBit(NTL::vec_GF2 &M, long data, int len) {\n\tM.SetLength(len);\n long i,j,n,m;\n\tfor(i=len-1; i>=0; i--){\n\t\tM.put(i, data%2);\n\t\tdata >>=1;\n\t}\n\treturn 0;\n}\nint genRandomAffineAugmentedMatrix(NTL::mat_GF2 &X, NTL::mat_GF2 &Y, int n) {\n\tNTL::mat_GF2 L;\n\trandom(L, n, n);\n\twhile(determinant(L)==0) {\n\t\trandom(L, n, n);\n\t}\n\tNTL::mat_GF2 LINV = inv(L);\n\tNTL::vec_GF2 tran;\n\t// tran.SetLength(m);\n\trandom(tran, n);\n\tNTL::mat_GF2 AugmentedMatrix;\n\n\tX.SetDims(n+1, n+1);\n\tint i,j;\n\tfor (i=0; i=0; i--) {\n\t\td.put(i, s%2);\n\t\ts>>=1;\n\t}\n\treturn 0;\n}\n\nint getAugmentedVecFrom32(NTL::vec_GF2 &d, uint32_t s) {\n\td.SetLength(33);\n\tint i;\n\tfor (i=31; i>=0; i--) {\n\t\td.put(i, s%2);\n\t\ts>>=1;\n\t}\n\td.put(32, 1);\n\treturn 0;\n}\n\nint combineDiagMat(NTL::mat_GF2 &d, NTL::mat_GF2 &s1, NTL::mat_GF2 &s2) {\n\tlong n1 = s1.NumCols();\n\tlong n2 = s2.NumCols();\n\td.SetDims(n1+n2, n1+n2);\n\tint i,j;\n\tfor (i=0; i\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\nusing namespace Simulator;\r\n\r\nstd::string Simulator::AlgorithmToStr(const Algorithms algorithm)\r\n{\r\n\tswitch (algorithm) {\r\n\tcase Algorithms::Metropolis:\r\n\t\treturn { \"Metropolis method\" };\r\n\tcase Algorithms::Glauber:\r\n\t\treturn { \"Glauber dynamics\" };\r\n\tcase Algorithms::SCA:\r\n\t\treturn { \"Stochastic cellular automata\" };\r\n\tcase Algorithms::fcSCA:\r\n\t\treturn { \"Flip-Constrained Stochastic Cellular Automata\" };\r\n\tcase Algorithms::MA:\r\n\t\treturn { \"Momentum annealing\" };\r\n\tcase Algorithms::MMA:\r\n\t\treturn { \"Modified momentum annealing\" };\r\n\tcase Algorithms::HillClimbing:\r\n\t\treturn { \"Hill climbing\" };\r\n\tdefault:\r\n\t\treturn { \"Warning: Unknown type.\" };\r\n\t}\r\n}\r\n\r\n// quadraticのキーのペア (i, j) は順番が i < j となっていなければならない。\r\nIsingModel::IsingModel(const LinearBiases linear, const QuadraticBiases quadratic)\r\n\t: rand(std::make_unique())\r\n\t, temperature(0.e0)\r\n\t, pinningParameter(0.e0)\r\n\t, flipTrialRate(0.e0)\r\n\t, algorithm(Algorithms::Metropolis)\r\n{\r\n\t// spinsの添字と頂点の名前との対応表を作成。\r\n\tstd::set nodes;\r\n\tfor (auto iter = linear.begin(); iter != linear.end(); iter++)\r\n\t\tnodes.insert(iter->first);\r\n\tfor (auto iter = quadratic.begin(); iter != quadratic.end(); iter++) {\r\n\t\tnodes.insert(iter->first.first);\r\n\t\tnodes.insert(iter->first.second);\r\n\t}\r\n\tstd::size_t index = 0;\r\n\tfor (const auto& key : nodes)\r\n\t\tnodeIndices[key] = index++;\r\n\r\n\t// Hamiltonianの定数と変数を初期化。\r\n\tauto maxNodes = nodeIndices.size();\r\n\tspins.setConstant(maxNodes, Spin::Up);\r\n\tpreviousSpins = spins;\r\n\texternalMagneticField.resize(maxNodes);\r\n\tfor (const auto& node : nodeIndices) {\r\n\t\tauto iter = linear.find(node.first);\r\n\t\tif (iter != linear.end())\r\n\t\t\texternalMagneticField(node.second) = iter->second;\r\n\t\telse\r\n\t\t\texternalMagneticField(node.second) = 0.e0;\r\n\t}\r\n\tcouplingCoefficients = Eigen::MatrixXd::Zero(maxNodes, maxNodes);\r\n\tfor (const auto& row : nodeIndices) {\r\n\t\tfor (const auto& column : nodeIndices) {\r\n\t\t\tif (row.first > column.first)\r\n\t\t\t\tcontinue;\r\n\t\t\tauto iter = quadratic.find(std::make_pair(row.first, column.first));\r\n\t\t\tif (iter != quadratic.end())\r\n\t\t\t\tcouplingCoefficients(row.second, column.second) = couplingCoefficients(column.second, row.second) = iter->second;\r\n\t\t\telse\r\n\t\t\t\tcouplingCoefficients(row.second, column.second) = couplingCoefficients(column.second, row.second) = 0.e0;\r\n\t\t}\r\n\t}\r\n}\r\n\r\n// 行列 (-J_{x, y})_{x, y} の最大固有値を計算する。\r\ndouble IsingModel::CalcLargestEigenvalue() const\r\n{\r\n\tEigen::SelfAdjointEigenSolver solver(-couplingCoefficients);\r\n\treturn solver.eigenvalues().reverse()(0);\r\n}\r\n\r\ndouble IsingModel::GetEnergy() const\r\n{\r\n\t// Remove double-counting duplicates by multiplying the sum by 1/2.\r\n\treturn -spins.cast().transpose() * (0.5e0 * couplingCoefficients * spins.cast() + externalMagneticField);\r\n}\r\n\r\ndouble IsingModel::GetEnergyOnBipartiteGraph() const\r\n{\r\n\treturn -0.5e0 * spins.cast().transpose() * couplingCoefficients * spins.cast()\r\n\t\t- 0.5e0 * externalMagneticField.dot(spins.cast() + previousSpins.cast())\r\n\t\t+ 0.5e0 * pinningParameter * (spins.size() - spins.cast().dot(previousSpins.cast()));\r\n}\r\n\r\nvoid IsingModel::GiveSpins(const ConfigurationsType configurationType)\r\n{\r\n\tswitch (configurationType) {\r\n\tcase ConfigurationsType::AllDown:\r\n\t\tspins.fill(Spin::Down);\r\n\t\tbreak;\r\n\tcase ConfigurationsType::AllUp:\r\n\t\tspins.fill(Spin::Up);\r\n\t\tbreak;\r\n\tcase ConfigurationsType::Uniform:\r\n\t\tfor (auto i = 0; i < spins.size(); i++)\r\n\t\t\tspins(i) = rand->Bernoulli(0.5e0) ? Spin::Down : Spin::Up;\r\n\t\tbreak;\r\n\tdefault:\r\n\t\tbreak;\r\n\t}\r\n\tpreviousSpins = spins;\r\n}\r\n\r\nvoid IsingModel::Update()\r\n{\r\n\tauto metropolisMethod = [this]() {\r\n\t\tunsigned int updatedNodeIndex = (*rand)(spins.size());\r\n\t\tdouble energyDifference = 2.e0 * static_cast(spins(updatedNodeIndex)) * calcLocalMagneticField(updatedNodeIndex);\r\n\t\tif (energyDifference < 0.e0)\r\n\t\t\tspins(updatedNodeIndex) = flip(spins(updatedNodeIndex));\r\n\t\telse if (rand->Bernoulli(std::exp(-energyDifference / temperature)))\r\n\t\t\tspins(updatedNodeIndex) = flip(spins(updatedNodeIndex));\r\n\t};\r\n\r\n\tauto glauberDynamics = [this]() {\r\n\t\tunsigned int updatedNodeIndex = (*rand)(spins.size());\r\n\t\tif (rand->Bernoulli(1.e0 / (1.e0 + std::exp(-2.e0 * calcLocalMagneticField(updatedNodeIndex) / temperature))))\r\n\t\t\tspins(updatedNodeIndex) = Spin::Up;\r\n\t\telse\r\n\t\t\tspins(updatedNodeIndex) = Spin::Down;\r\n\t};\r\n\r\n\tauto stochasticCellularAutomata = [this]() {\r\n\t\tpreviousSpins = spins;\r\n\t\tspins = (\r\n\t\t\tcalcLocalMagneticField(spins) + pinningParameter * spins.cast()\r\n\t\t\t- temperature * Eigen::VectorXd::NullaryExpr(spins.size(), [this]() -> double { return rand->Logistic(); })\r\n\t\t).array().sign().cast(); // 実質起こらないが、符号関数に渡しているため、スピンが0になる場合がある。\r\n\t};\r\n\r\n\tauto flipConstrainedStochasticCellularAutomata = [this]() {\r\n\t\tpreviousSpins = spins;\r\n\t\t//auto bernoulli = Eigen::VectorXd::NullaryExpr(spins.size(), [this]() -> bool { return rand->Bernoulli(flipTrialRate) ; }); // = true w.p. flipTrialRate and = false w.p. 1 - flipTrialRate.\r\n\t\tspins = (\r\n\t\t\tcalcLocalMagneticField(spins) + pinningParameter * spins.cast()\r\n\t\t\t- temperature * Eigen::VectorXd::NullaryExpr(spins.size(), [this]() -> double { return rand->Logistic(); })\r\n\t\t\t+ Eigen::VectorXd::NullaryExpr(spins.size(), [this]() -> double {\r\n\t\t\t\treturn rand->Bernoulli(flipTrialRate) ? 0.e0 : std::numeric_limits::infinity();\r\n\t\t\t}).cwiseProduct(spins.cast())\r\n\t\t\t//+ bernoulli.unaryExpr([](bool b) -> double { return b ? 0.e0 : std::numeric_limits::infinity(); }).cwiseProduct(spins.cast())\r\n\t\t).array().sign().cast(); // 実質起こらないが、符号関数に渡しているため、スピンが0になる場合がある。\r\n\t};\r\n\r\n\t// 温度を下げなければ ``annealing'' ではないが、論文では区別していないので、ここでもこの名称を用いる。\r\n\tauto momentumAnnealing = [this]() {\r\n\t\tConfiguration temp = (\r\n\t\t\tcalcLocalMagneticField(spins) + pinningParameter * spins.cast()\r\n\t\t\t- temperature * Eigen::VectorXd::NullaryExpr(spins.size(), [this]() -> double { return rand->Exponential(); }).cwiseProduct(previousSpins.cast())\r\n\t\t).array().sign().cast(); // 実質起こらないが、符号関数に渡しているため、スピンが0になる場合がある。\r\n\t\tpreviousSpins = spins;\r\n\t\tspins = temp;\r\n\t};\r\n\r\n\tauto modifiedMomentumAnnealing = [this]() {\r\n\t\tpreviousSpins = spins;\r\n\t\tspins = (\r\n\t\t\tcalcLocalMagneticField(spins) + pinningParameter * spins.cast()\r\n\t\t\t- temperature * Eigen::VectorXd::NullaryExpr(spins.size(), [this]() -> double { return rand->Exponential(); }).cwiseProduct(spins.cast())\r\n\t\t).array().sign().cast(); // 実質起こらないが、符号関数に渡しているため、スピンが0になる場合がある。\r\n\t};\r\n\r\n\tauto hillClimbing = [this]() {\r\n\t\tConfiguration currentConfiguration = spins;\r\n\t\twhile (true) {\r\n\t\t\t//double nextEval = std::numeric_limits::infinity();\r\n\t\t\tdouble energyDifference = 0.e0;\r\n\t\t\tConfiguration nextConfiguration = currentConfiguration;\r\n\t\t\tfor (auto i = 0; i < spins.size(); i++) {\r\n\t\t\t\tdouble beforeEnergy = -1.e0 * static_cast(currentConfiguration(i)) * calcLocalMagneticField(i);\r\n\t\t\t\tdouble afterEnergy = -1.e0 * static_cast(flip(currentConfiguration(i))) * calcLocalMagneticField(i);\r\n\t\t\t\tif (energyDifference > afterEnergy - beforeEnergy) {\r\n\t\t\t\t\tenergyDifference = afterEnergy - beforeEnergy;\r\n\t\t\t\t\tnextConfiguration(i) = flip(nextConfiguration(i));\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (energyDifference >= 0.e0)\r\n\t\t\t\tbreak;\r\n\t\t\tcurrentConfiguration = nextConfiguration;\r\n\t\t}\r\n\t\tspins = currentConfiguration;\r\n\t};\r\n\r\n\tswitch (algorithm) {\r\n\tcase Algorithms::Metropolis:\r\n\t\tmetropolisMethod();\r\n\t\tbreak;\r\n\tcase Algorithms::Glauber:\r\n\t\tglauberDynamics();\r\n\t\tbreak;\r\n\tcase Algorithms::SCA:\r\n\t\tstochasticCellularAutomata();\r\n\t\tbreak;\r\n\tcase Algorithms::fcSCA:\r\n\t\tflipConstrainedStochasticCellularAutomata();\r\n\t\tbreak;\r\n\tcase Algorithms::MA:\r\n\t\tmomentumAnnealing();\r\n\t\tbreak;\r\n\tcase Algorithms::MMA:\r\n\t\tmodifiedMomentumAnnealing();\r\n\t\tbreak;\r\n\tcase Algorithms::HillClimbing:\r\n\t\thillClimbing();\r\n\t\tbreak;\r\n\tdefault:\r\n\t\tbreak;\r\n\t}\r\n}\r\n\r\nvoid IsingModel::Write() const\r\n{\r\n\tstd::cout << \"Current spin configuration:\" << std::endl;\r\n\tfor (auto i = 0; i < spins.size(); i++)\r\n\t\tstd::cout << std::setw(2) << static_cast(spins(i));\r\n\tstd::cout << \"External magnetic field:\" << std::endl;\r\n\tstd::cout << externalMagneticField.transpose() << std::endl;\r\n\tstd::cout << \"Coupling coefficinets:\" << std::endl;\r\n\tstd::cout << couplingCoefficients << std::endl;\r\n\tstd::cout << \"Algorithm: \" << AlgorithmToStr(algorithm) << std::endl;\r\n\tstd::cout << \"Temperature: \" << temperature << std::endl;\r\n\tstd::cout << \"Pinning parameter: \" << pinningParameter << std::endl;\r\n\tstd::cout << \"Flip trial rate: \" << flipTrialRate << std::endl;\r\n}\r\n", "meta": {"hexsha": "9821891cdecfc2d7b77417987a170a82b4048f0a", "size": 8701, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "cpp/simulator.cpp", "max_stars_repo_name": "Wandao123/ising_model", "max_stars_repo_head_hexsha": "36c1beafaffb4dd03cb7658d951a9e049532fc74", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2019-10-24T07:25:30.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-14T10:42:02.000Z", "max_issues_repo_path": "cpp/simulator.cpp", "max_issues_repo_name": "Wandao123/ising_model", "max_issues_repo_head_hexsha": "36c1beafaffb4dd03cb7658d951a9e049532fc74", "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": "cpp/simulator.cpp", "max_forks_repo_name": "Wandao123/ising_model", "max_forks_repo_head_hexsha": "36c1beafaffb4dd03cb7658d951a9e049532fc74", "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.5588235294, "max_line_length": 194, "alphanum_fraction": 0.6822204344, "num_tokens": 2513, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.837619947119304, "lm_q2_score": 0.651354857898194, "lm_q1q2_score": 0.5455878216285871}} {"text": "/* User code: This file will not be overwritten by TASTE. */\n\n#include \"printer.h\"\n#include \n#include \n#include \"base_support/Base-samples-RigidBodyStateConvert.hpp\"\n#include \"base_support/OpaqueConversion.hpp\"\n#include \n#include \n\nvoid printer_startup()\n{\n /* Write your initialization code here,\n but do not make any call to a required interface. */\n}\n\n// EIGEN HELPER METHODS\nvoid to4d(Eigen::Matrix3d r, Eigen::Vector3d t, Eigen::Matrix4d & h){\n\t\n h<< r(0,0), r(0,1), r(0,2), t[0],\n r(1,0), r(1,1), r(1,2), t[1],\n r(2,0), r(2,1), r(2,2), t[2],\n 0, 0, 0, 1;\n}\n\nvoid printer_PI_update_amp(const asn1SccBase_samples_RigidBodyState *IN_pose)\n{\n base::Vector3d t;\n base::Quaterniond q;\n Eigen::Matrix3d r;\n\n static int i = 0;\n\n // extract orientation / translation\n asn1Scc_Vector3d_fromAsn1(t, IN_pose->position);\n asn1Scc_Quaterniond_fromAsn1(q, IN_pose->orientation);\n // convert quaternion to rotation mat\n r = q.normalized().toRotationMatrix();\n\n Eigen::Matrix4d p;\n\n to4d(r,t,p);\n \n std::ifstream f(\"marker.csv\");\n bool good = f.good();\n \n std::ofstream myfile;\n if (good) myfile.open (\"marker.csv\", std::ios::app);\n else myfile.open (\"marker.csv\", std::ios::out);\n\n myfile << \"\\n\" << std::floor(((p(0,3)) * 100000) + .5) / 100000 \n\t << \",\" << std::floor(((p(1,3)) * 100000) + .5) / 100000 \n\t << \",\" << std::floor(((p(2,3)) * 100000) + .5) / 100000; \n\n myfile.close();\n\n i++;\n\n std::cout << \"got marker position:\\n\" << p << std::endl;\n}\n\nvoid printer_PI_update_arp(const asn1SccBase_samples_RigidBodyState *IN_pose)\n{\n base::Vector3d t;\n base::Quaterniond q;\n Eigen::Matrix3d r;\n // extract orientation / translation\n asn1Scc_Vector3d_fromAsn1(t, IN_pose->position);\n asn1Scc_Quaterniond_fromAsn1(q, IN_pose->orientation);\n // convert quaternion to rotation mat\n r = q.normalized().toRotationMatrix();\n\n Eigen::Matrix4d p;\n\n to4d(r,t,p);\n\n std::ifstream f(\"marker.csv\");\n bool good = f.good();\n \n std::ofstream myfile;\n if (good) myfile.open (\"marker.csv\", std::ios::app);\n else myfile.open (\"marker.csv\", std::ios::out);\n\n myfile << \"\\n\" << std::floor(((p(0,3)) * 100000) + .5) / 100000 \n\t << \",\" << std::floor(((p(1,3)) * 100000) + .5) / 100000 \n\t << \",\" << std::floor(((p(2,3)) * 100000) + .5) / 100000; \n\n myfile.close();\n std::cout << \"got robot position:\\n\" << p << std::endl;\n}\n\n", "meta": {"hexsha": "e4eaae4820b7c25164e2d5243a3af4ce080c317b", "size": 2421, "ext": "cc", "lang": "C++", "max_stars_repo_path": "printer/printer.cc", "max_stars_repo_name": "ESROCOS/plex-transformer_test", "max_stars_repo_head_hexsha": "22631794cffaa29858de5bc4307d9124f2d26f1d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "printer/printer.cc", "max_issues_repo_name": "ESROCOS/plex-transformer_test", "max_issues_repo_head_hexsha": "22631794cffaa29858de5bc4307d9124f2d26f1d", "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": "printer/printer.cc", "max_forks_repo_name": "ESROCOS/plex-transformer_test", "max_forks_repo_head_hexsha": "22631794cffaa29858de5bc4307d9124f2d26f1d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.3152173913, "max_line_length": 77, "alphanum_fraction": 0.6253614209, "num_tokens": 803, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.837619947119304, "lm_q2_score": 0.6513548511303338, "lm_q1q2_score": 0.5455878159596923}} {"text": "#include \"wx/wxprec.h\"\n#include \"wx/wx.h\"\n#include \"sample.xpm\"\n#include \n\nusing namespace Eigen;\n\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n//wxAppHeat\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n\nclass wxAppHeat : public wxApp\n{\npublic:\n virtual bool OnInit();\n};\n\nwxIMPLEMENT_APP(wxAppHeat);\n\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n//wxFrameHeat\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n\nclass wxFrameHeat : public wxFrame\n{\npublic:\n wxFrameHeat(const wxString& title);\n void OnQuit(wxCommandEvent& event);\n void OnAbout(wxCommandEvent& event);\n virtual void OnPaint(wxPaintEvent& event);\n wxColour to_color(float N);\n\n ~wxFrameHeat()\n {\n delete[] T_fvm;\n delete[] T_fdm_1;\n delete[] Tn_fdm_1;\n delete[] T_fdm_2;\n delete[] Tn_fdm_2;\n }\n\nprivate:\n void init_constants();\n void solve_fvm();\n void solve_fdm_1();\n void solve_fdm_2();\n void draw_cell(wxDC* dc, float N, wxCoord x, wxCoord y, wxCoord width, wxCoord height);\n\n //temperature at the left hand side of the bar(deg C)\n float T_A;\n\n //temperature at the left hand side of the bar(deg C)\n float T_B;\n\n //thermal conductivity k, [W/mK]\n float k;\n\n //heat source per unit volume (W/m3)\n float S;\n\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n //FVM\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n //number of cells for FVM\n Index m_nbr_fvm;\n\n //temperature (solution)\n float* T_fvm;\n\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n //FDM\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n //number of cells for FVM\n int m_nbr_fdm;\n\n //temperature (solution)\n float* T_fdm_1;\n float* Tn_fdm_1;\n\n //temperature (solution)\n float* T_fdm_2;\n float* Tn_fdm_2;\n\nprivate:\n wxDECLARE_EVENT_TABLE();\n};\n\nwxBEGIN_EVENT_TABLE(wxFrameHeat, wxFrame)\nEVT_MENU(wxID_EXIT, wxFrameHeat::OnQuit)\nEVT_MENU(wxID_ABOUT, wxFrameHeat::OnAbout)\nEVT_PAINT(wxFrameHeat::OnPaint)\nwxEND_EVENT_TABLE()\n\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n//wxAppHeat::OnInit()\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n\nbool wxAppHeat::OnInit()\n{\n if (!wxApp::OnInit())\n {\n return false;\n }\n wxFrameHeat* frame = new wxFrameHeat(\"Heat\");\n frame->Maximize(true);\n frame->Show(true);\n return true;\n}\n\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n//wxFrameHeat::wxFrameHeat\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n\nwxFrameHeat::wxFrameHeat(const wxString& title)\n : wxFrame(NULL, wxID_ANY, title)\n{\n SetIcon(wxICON(sample));\n wxMenu* menu_file = new wxMenu;\n menu_file->Append(wxID_EXIT, \"E&xit\\tAlt-X\", \"Quit this program\");\n wxMenu* menu_help = new wxMenu;\n menu_help->Append(wxID_ABOUT, \"&About\\tF1\", \"Show about dialog\");\n wxMenuBar* menu_bar = new wxMenuBar();\n menu_bar->Append(menu_file, \"&File\");\n menu_bar->Append(menu_help, \"&Help\");\n SetMenuBar(menu_bar);\n CreateStatusBar(2);\n SetStatusText(\"Ready\");\n init_constants();\n solve_fvm();\n solve_fdm_1();\n solve_fdm_2();\n}\n\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n//wxFrameHeat::OnQuit\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n\nvoid wxFrameHeat::OnQuit(wxCommandEvent& WXUNUSED(event))\n{\n Close(true);\n}\n\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n//wxFrameHeat::OnAbout\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n\nvoid wxFrameHeat::OnAbout(wxCommandEvent& WXUNUSED(event))\n{\n}\n\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n//wxFrameHeat::to_color\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n\nwxColour wxFrameHeat::to_color(float N)\n{\n wxColour C;\n if (N < 130) C = wxColour(187, 206, 255);\n else if (N < 160) C = wxColour(132, 166, 250);\n else if (N < 190) C = wxColour(66, 108, 218);\n else if (N < 200) C = wxColour(50, 72, 141);\n else C = wxColour(34, 47, 87);\n return C;\n}\n\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n//wxFrameHeat::draw_cell\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n\nvoid wxFrameHeat::draw_cell(wxDC* dc, float N, wxCoord x, wxCoord y, wxCoord width, wxCoord height)\n{\n dc->SetBrush(wxBrush(wxColour(to_color(N))));\n dc->DrawRectangle(x, y - height / 2, width, height);\n wxString str = wxString::Format(wxT(\"%.1f\"), N);\n dc->DrawText(str, x + width / 2, y);\n}\n\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n//wxFrameHeat::OnDraw\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n\nvoid wxFrameHeat::OnPaint(wxPaintEvent&)\n{\n wxPaintDC dc(this);\n wxFont font(wxFontInfo(8).FaceName(\"Courier\"));\n dc.SetFont(font);\n wxCoord width = 100;\n wxCoord height = 50;\n wxCoord x = 0, y = height / 2;\n\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n //FVM\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n //boundary\n draw_cell(&dc, T_A, x, y, width, height);\n x += width;\n //interior\n for (int idx = 0; idx < m_nbr_fvm; idx++)\n {\n draw_cell(&dc, T_fvm[idx], x, y, width, height);\n x += width;\n }\n //boundary\n draw_cell(&dc, T_B, x, y, width, height);\n\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n //FDM_1\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n x = 0; y += 100;\n for (int idx = 0; idx < m_nbr_fdm; idx++)\n {\n draw_cell(&dc, T_fdm_1[idx], x, y, width, height);\n x += width;\n }\n\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n //FDM_2\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n x = 0; y += 100;\n for (int idx = 0; idx < m_nbr_fdm; idx++)\n {\n draw_cell(&dc, T_fdm_2[idx], x, y, width, height);\n x += width;\n }\n}\n\n////////////////////////////////////////////////////////////////////////////////////////////////////\n//wxFrameHeat::init_constants\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n\nvoid wxFrameHeat::init_constants()\n{\n //temperature at the left hand side of the bar(deg C)\n T_A = 100;\n\n //temperature at the left hand side of the bar(deg C)\n T_B = 200;\n\n //thermal conductivity k, [W/mK]\n k = 100;\n\n //heat source per unit volume (W/m3)\n S = 1000.0f;;\n}\n\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n//wxFrameHeat::solve_fvm\n//Finite Volume Method\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n\nvoid wxFrameHeat::solve_fvm()\n{\n //number of cells\n m_nbr_fvm = 5;\n\n ////////////////////////////////////////////////////////////////////////////////////////////////////\n //allocate solution vectors\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n //FVM\n T_fvm = new float[m_nbr_fvm];\n\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n //geometry\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n //length of the bar(m)\n const float length = 5;\n\n //coordinates of the cell faces\n float* x_faces = new float[m_nbr_fvm + 1];\n x_faces[0] = 0;\n for (int idx = 1; idx < m_nbr_fvm + 1; idx++)\n {\n x_faces[idx] = x_faces[idx - 1] + length / m_nbr_fvm;\n wxLogDebug(\"x_faces [%d]=%f\", idx, x_faces[idx]);\n }\n\n //coordinates of the cell centroids\n float* x_center = new float[m_nbr_fvm];\n for (int idx = 0; idx < m_nbr_fvm; idx++)\n {\n x_center[idx] = 0.5f * (x_faces[idx + 1] + x_faces[idx]);\n wxLogDebug(\"x_center [%d]=%f\", idx, x_center[idx]);\n }\n\n //length of each cell\n float* cell_length = new float[m_nbr_fvm];\n for (int idx = 0; idx < m_nbr_fvm; idx++)\n {\n cell_length[idx] = x_faces[idx + 1] - x_faces[idx];\n wxLogDebug(\"cell_length [%d]=%f\", idx, cell_length[idx]);\n }\n\n //distance between cell centroids\n float* dist_centroids = new float[m_nbr_fvm + 1];\n for (int idx = 0; idx < m_nbr_fvm - 1; idx++)\n {\n dist_centroids[idx] = x_center[idx + 1] - x_center[idx];\n wxLogDebug(\"dist_centroids [%d]=%f\", idx, dist_centroids[idx]);\n }\n\n //for the boundary cell on the left, the distance is double the distance\n //from the cell centroid to the boundary face\n float dist_left = 2 * (x_center[0] - x_faces[0]);\n\n //for the boundary cell on the right, the distance is double the distance from\n //the cell centroid to the boundary cell face\n float dist_right = 2 * (x_faces[m_nbr_fvm] - x_center[m_nbr_fvm - 1]);\n\n for (int idx = 0; idx < m_nbr_fvm; idx++)\n {\n dist_centroids[idx + 1] = dist_centroids[idx];\n }\n dist_centroids[0] = dist_left;\n dist_centroids[m_nbr_fvm] = dist_right;\n for (int idx = 0; idx < m_nbr_fvm + 1; idx++)\n {\n wxLogDebug(\"dist_centroids [%d]=%f\", idx, dist_centroids[idx]);\n }\n\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n //constants\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n //cross-sectional area A, [m2]\n const float Area = 0.1f;\n\n //cell volume\n float* cell_volume = new float[m_nbr_fvm];\n for (int idx = 0; idx < m_nbr_fvm; idx++)\n {\n cell_volume[idx] = cell_length[idx] * Area;\n wxLogDebug(\"cell_volume [%d]=%f\", idx, cell_volume[idx]);\n }\n\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n //create the matrices\n //zero initially\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n MatrixXf A = MatrixXf::Zero(m_nbr_fvm, m_nbr_fvm);\n VectorXf B = VectorXf::Zero(m_nbr_fvm);\n\n for (Index n = 0; n < m_nbr_fvm; n++)\n {\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n //left boundary cell\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n if (n == 0)\n {\n //left coefficient aP, T at n\n float aP = k * Area / dist_centroids[n] + k * Area / dist_centroids[n] * 2.0;\n wxLogDebug(\"left A[%lld,%lld]=%f\", n, n, aP);\n A(n, n) = aP;\n\n //right coefficient aR, T at n+1\n float aR = k * Area / dist_centroids[n];\n wxLogDebug(\"left A[%lld,%lld]=%f\", n, n + 1, -1.0 * aR);\n A(n, n + 1) = -1.0 * aR;\n\n //source\n float source = S * cell_volume[n];\n //additional boundary source, temperature A\n source += T_A * Area * k / dist_centroids[n] * 2.0;\n wxLogDebug(\"B[%lld]=%f\", n, source);\n B(n) = source;\n }\n\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n //right boundary cell\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n else if (n == m_nbr_fvm - 1)\n {\n //left coefficient aL, T at n-1\n float aL = k * Area / dist_centroids[n];;\n wxLogDebug(\"right A[%lld,%lld]=%f\", n, n - 1, -1.0 * aL);\n A(n, n - 1) = -1.0 * aL;\n\n //right coefficient aP, T at n\n float aP = k * Area / dist_centroids[n] + k * Area / dist_centroids[n] * 2.0;\n wxLogDebug(\"right A[%lld,%lld]=%f\", n, n, aP);\n A(n, n) = aP;\n\n //source\n float source = S * cell_volume[n];\n //additional boundary source, temperature B\n source += T_B * Area * k / dist_centroids[n] * 2.0;\n wxLogDebug(\"B[%lld]=%f\", n, source);\n B(n) = source;\n }\n\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n //interior cells\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n else\n {\n //left coefficient aL, T at n-1\n float aL = k * Area / dist_centroids[n];\n wxLogDebug(\"A[%lld,%lld]=%f\", n, n - 1, -1.0 * aL);\n A(n, n - 1) = -1.0 * aL;\n\n //right coefficient aR, T at n+1\n float aR = k * Area / dist_centroids[n];\n wxLogDebug(\"A[%lld,%lld]=%f\", n, n + 1, -1.0 * aR);\n A(n, n + 1) = -1.0 * aR;\n\n //middle coefficient aP, T at n\n float aP = aR + aL;\n wxLogDebug(\"A[%lld,%lld]=%f\", n, n, aP);\n A(n, n) = aP;\n\n //source\n float source = S * cell_volume[n];\n wxLogDebug(\"B[%lld]=%f\", n, source);\n B(n) = source;\n }\n }\n\n //solve \n VectorXf T_vec = A.colPivHouseholderQr().solve(B);\n float* t = T_vec.data();\n for (int idx = 0; idx < m_nbr_fvm; idx++)\n {\n T_fvm[idx] = t[idx];\n wxLogDebug(\"%.1f\", t[idx]);\n }\n\n delete[] x_faces;\n delete[] x_center;\n delete[] cell_length;\n delete[] dist_centroids;\n delete[] cell_volume;\n}\n\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n//wxFrameHeat::solve_fdm_1\n//Finite Differences Method\n//diffusion only\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n\nvoid wxFrameHeat::solve_fdm_1()\n{\n //number of cells\n m_nbr_fdm = 7;\n\n ////////////////////////////////////////////////////////////////////////////////////////////////////\n //allocate solution vectors\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n //FDM\n T_fdm_1 = new float[m_nbr_fdm];\n Tn_fdm_1 = new float[m_nbr_fdm];\n\n //time step\n float dt = 0.005f;\n float dx = 1.0f;\n\n //initial and boundary values\n for (int i = 0; i < m_nbr_fdm; i++)\n {\n T_fdm_1[i] = 0;\n }\n T_fdm_1[0] = T_A;\n T_fdm_1[m_nbr_fdm - 1] = T_B;\n\n for (int i = 0; i < m_nbr_fdm; i++)\n {\n wxLogDebug(\"T[%d]=%.1f\", i, T_fdm_1[i]);\n }\n\n //F must be <= 0.5\n float F = k * dt / (dx * dx);\n wxLogDebug(\"F=%.4f\", F);\n for (int n = 0; n < 100; n++)\n {\n for (int i = 1; i < m_nbr_fdm - 1; i++)\n {\n Tn_fdm_1[i] = T_fdm_1[i] + F * (T_fdm_1[i - 1] - 2 * T_fdm_1[i] + T_fdm_1[i + 1]) + dt * S;\n }\n for (int i = 1; i < m_nbr_fdm - 1; i++)\n {\n T_fdm_1[i] = Tn_fdm_1[i];\n }\n for (int i = 0; i < m_nbr_fdm; i++)\n {\n wxLogDebug(\"T[%d]=%.1f\", i, T_fdm_1[i]);\n }\n }\n}\n\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n//wxFrameHeat::solve_fdm_2\n//Finite Differences Method\n//advection only\n/////////////////////////////////////////////////////////////////////////////////////////////////////\n\nvoid wxFrameHeat::solve_fdm_2()\n{\n //number of cells\n m_nbr_fdm = 7;\n\n ////////////////////////////////////////////////////////////////////////////////////////////////////\n //allocate solution vectors\n /////////////////////////////////////////////////////////////////////////////////////////////////////\n\n //FDM\n T_fdm_2 = new float[m_nbr_fdm];\n Tn_fdm_2 = new float[m_nbr_fdm];\n\n //time step\n float dt = 0.5f;\n float dx = 1.0f;\n\n //initial and boundary values\n for (int i = 0; i < m_nbr_fdm; i++)\n {\n T_fdm_2[i] = 0;\n }\n T_fdm_2[0] = T_A;\n T_fdm_2[m_nbr_fdm - 1] = T_B;\n\n for (int i = 0; i < m_nbr_fdm; i++)\n {\n wxLogDebug(\"T[%d]=%.1f\", i, T_fdm_2[i]);\n }\n\n int iter = 500;\n float time = dt * (float)iter;\n float U = 1.0f; //velocity\n float C = U * dt / dx; //courant number <= 1\n wxLogDebug(\"time=%.1f F=%.4f\", time, C);\n for (int n = 0; n < iter; n++)\n {\n for (int i = 1; i < m_nbr_fdm - 1; i++)\n {\n Tn_fdm_2[i] = T_fdm_2[i] - C * (T_fdm_2[i] - T_fdm_2[i - 1]);\n }\n for (int i = 1; i < m_nbr_fdm - 1; i++)\n {\n T_fdm_2[i] = Tn_fdm_2[i];\n }\n for (int i = 0; i < m_nbr_fdm; i++)\n {\n wxLogDebug(\"T[%d]=%.1f\", i, T_fdm_2[i]);\n }\n }\n}\n\n", "meta": {"hexsha": "9e32eff9e88131c07a972a1c14b3b247a812768a", "size": 16744, "ext": "cc", "lang": "C++", "max_stars_repo_path": "transport.cc", "max_stars_repo_name": "pedro-vicente/transport", "max_stars_repo_head_hexsha": "a12a7aa9085ba2cfc0b835473c0e45518c887cab", "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": "transport.cc", "max_issues_repo_name": "pedro-vicente/transport", "max_issues_repo_head_hexsha": "a12a7aa9085ba2cfc0b835473c0e45518c887cab", "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": "transport.cc", "max_forks_repo_name": "pedro-vicente/transport", "max_forks_repo_head_hexsha": "a12a7aa9085ba2cfc0b835473c0e45518c887cab", "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": 30.0071684588, "max_line_length": 105, "alphanum_fraction": 0.4025322504, "num_tokens": 4171, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.734119526900183, "lm_q2_score": 0.7431680029241321, "lm_q1q2_score": 0.5455741427140177}} {"text": "#pragma once\n\n#include \n\nnamespace hacky_toolkit {\n\n//! \\brief A Plane (or hyperplane) is a susbspace of which its dimension is one\n//! less than of its ambient space. The template argument of the dimension of\n//! the plane equals that of its ambient space. I.e., a Plane is a\n//! line in a 2d space. A plane is represented by a vector of Dim + 1 parameters\n//! that can be used to obtain the general form of the plane equation:\n//! a.dot((x, 1)) + d = 0\ntemplate \nclass Plane {\n static_assert(Dim_ > 0, \"DYNAMIC_DIMENSION_NOT_SUPPORTED\");\n\n public:\n inline Plane() = default;\n\n template \n inline Plane(Eigen::MatrixBase const& p) : a_(p) {}\n\n template \n inline Plane(Eigen::MatrixBase const& normal, Scalar_ d) {\n a_.template head() = normal;\n a_(Dim_) = d;\n }\n\n //! \\brief Creates a normalized plane using two points. The spatial dimension\n //! of the Plane must equal 2 when using this constructor. Input points can be\n //! of dimension 2 or 3.\n template \n inline Plane(\n Eigen::MatrixBase const& x,\n Eigen::MatrixBase const& y) {\n static_assert(Dim_ == 2);\n static_assert(\n Derived0::SizeAtCompileTime == Dim_ ||\n Derived0::SizeAtCompileTime == Dim_ + 1);\n static_assert(Derived0::SizeAtCompileTime == Derived1::SizeAtCompileTime);\n if constexpr (Derived0::SizeAtCompileTime == Dim_) {\n a_ = x.homogeneous().cross(y.homogeneous());\n } else {\n a_ = x.cross(y);\n }\n Normalize();\n }\n\n //! \\brief Creates a normalized plane using three points. The spatial\n //! dimension of the Plane must equal 3 when using this constructor. Input\n //! points can be of dimension 3 or 4.\n template \n inline Plane(\n Eigen::MatrixBase const& x,\n Eigen::MatrixBase const& y,\n Eigen::MatrixBase const& z) {\n static_assert(Dim_ == 3);\n static_assert(\n Derived0::SizeAtCompileTime == Dim_ ||\n Derived0::SizeAtCompileTime == Dim_ + 1);\n static_assert(\n Derived0::SizeAtCompileTime == Derived1::SizeAtCompileTime &&\n Derived1::SizeAtCompileTime == Derived2::SizeAtCompileTime);\n if constexpr (Derived0::SizeAtCompileTime == Dim_) {\n a_.template head<3>() = (y - x).cross(z - x);\n a_(Dim_) = -x.dot(a_.template head<3>());\n } else {\n auto xn = x.hnormalized().eval();\n a_.template head<3>() =\n (y.hnormalized() - xn).cross(z.hnormalized() - xn);\n a_(Dim_) = -xn.dot(a_.template head<3>());\n }\n Normalize();\n }\n\n template \n inline Scalar_ SignedDistance(Eigen::MatrixBase const& x) const {\n static_assert(\n Derived::SizeAtCompileTime == Dim_ ||\n Derived::SizeAtCompileTime == Dim_ + 1);\n if constexpr (Derived::SizeAtCompileTime == Dim_) {\n return a_.dot(x.homogeneous());\n } else {\n return a_.dot(x);\n }\n }\n\n template \n inline Scalar_ Distance(Eigen::MatrixBase const& x) const {\n return std::abs(SignedDistance(x));\n }\n\n template \n inline bool Positive(Eigen::MatrixBase const& x) const {\n return SignedDistance(x) > Scalar_(0.0);\n }\n\n template \n inline bool Negative(Eigen::MatrixBase const& x) const {\n return SignedDistance(x) < Scalar_(0.0);\n }\n\n //! \\brief Tests is a point is considered to lie on the plane.\n //! \\returns true if \\p x is on the plane.\n template \n inline bool Test(\n Eigen::MatrixBase const& x,\n Scalar_ threshold = Eigen::NumTraits::dummy_precision()) const {\n return Distance(x) < threshold;\n }\n\n //! \\brief Normalizes the plane such that the length of the normal (the first\n //! Dim parameters of a()) equals 1.\n inline void Normalize() { a_ /= a_.template head().norm(); }\n\n //! \\brief Point on the plane closest to the origin.\n inline Eigen::Matrix Origin() const {\n return normal() * -d();\n }\n\n //! \\brief Generates a random point on the unit hypersphere of the subspace\n //! defined by this plane at a distance of \\p distance from the point returned\n //! by the Origin() method. The plane does not have to be normalized.\n //! \\returns A random point on the plane.\n inline Eigen::Matrix RandomPoint(\n Scalar_ distance = Scalar_(1.0)) const {\n // Perturb the normal with some noise.\n // What are the odds that the added noise equals 0?\n Eigen::Matrix v =\n normal() + Eigen::Matrix::Random();\n // Apply Gram-Schmidt process to get an orthogonal vector. Ie, subtract the\n // projection of v on the normal from v.\n return (v - normal() * normal().dot(v) / normal().squaredNorm())\n .normalized() *\n distance +\n Origin();\n }\n\n //! \\brief The orientation of the plane is defined by its normal. Not\n //! guaranteed to be normalized.\n //! \\returns The plane normal.\n inline auto normal() const {\n // Eigen::VectorBlock\n return a_.template head();\n }\n\n //! \\brief The negative of the distance from the origin to the plane in the\n //! direction of the normal. That is, the closest point on the plane to the\n //! origin equals:\n //! \\code\n //! plane.normal() * -plane.d()\n //! \\endcode\n //! \\returns Negative distance from the origin to the plane.\n Scalar_ const& d() const { return a_(Dim_); }\n\n //! \\brief The parameters of the plane. They describe the General form of the\n //! plane equation: a.dot((x, 1)) = 0\n auto const& a() const { return a_; }\n\n //! \\brief Generates a Plane with a random normal at a distance somewhere in\n //! the range of [-max_distance:max_distance].\n static Plane Random(Scalar_ max_distance = Scalar_(1.0)) {\n return {\n Eigen::Matrix::Random().normalized(),\n Eigen::Matrix::Random()(0) * max_distance};\n }\n\n private:\n Eigen::Matrix a_;\n};\n\nusing Plane2d = Plane;\nusing Plane3d = Plane;\n\nusing Plane2f = Plane;\nusing Plane3f = Plane;\n\n} // namespace hacky_toolkit\n", "meta": {"hexsha": "795e0c24861b020b7682613b98335a7711bffd62", "size": 6375, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "examples/hacky_toolkit/hacky_toolkit/plane.hpp", "max_stars_repo_name": "Jaybro/hacky_sac", "max_stars_repo_head_hexsha": "9eea07eb4d5af8e5847d8afdd377d06f0a5740dc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-10-04T13:42:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-04T13:42:15.000Z", "max_issues_repo_path": "examples/hacky_toolkit/hacky_toolkit/plane.hpp", "max_issues_repo_name": "Jaybro/hacky_sac", "max_issues_repo_head_hexsha": "9eea07eb4d5af8e5847d8afdd377d06f0a5740dc", "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": "examples/hacky_toolkit/hacky_toolkit/plane.hpp", "max_forks_repo_name": "Jaybro/hacky_sac", "max_forks_repo_head_hexsha": "9eea07eb4d5af8e5847d8afdd377d06f0a5740dc", "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": 35.6145251397, "max_line_length": 80, "alphanum_fraction": 0.6600784314, "num_tokens": 1681, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.819893335913536, "lm_q2_score": 0.665410572017153, "lm_q1q2_score": 0.5455656936432778}} {"text": "#pragma once\n\n#include \n#include \n#include \n\n#include \"base/numbers.hpp\"\n#include \"enum/enum.hpp\"\n#include \"quadrature/qmidpoint.hpp\"\n#include \"quadrature/quad_handler1d.hpp\"\n#include \"quadrature/tensor_product_quadrature.hpp\"\n#include \"spectral/basis/spectral_elem_accessor.hpp\"\n#include \"spectral/basis/toolbox/spectral_basis.hpp\"\n\n\nnamespace boltzmann {\nclass Momentum\n{\n private:\n typedef Eigen::Vector2d value_t;\n\n public:\n Momentum() {}\n\n template \n Momentum(const SPECTRAL_BASIS& spectral_basis)\n {\n init(spectral_basis);\n }\n\n template \n void init(const SPECTRAL_BASIS& spectral_basis);\n\n /**\n * @brief compute momentum,\n *\n * @param dst\n * @param src\n * @param count #physical dofs\n */\n template \n void compute(NUMERIC_T* dstx, NUMERIC_T* dsty, const NUMERIC_T* src, int count) const;\n\n template \n void compute(VEC_OUT& dstx,\n VEC_OUT& dsty,\n const VEC_IN& src,\n const dealii::IndexSet& relevant_dofs,\n const INDEXER& indexer) const;\n\n template \n value_t compute(const NUMERIC_T* src) const;\n\n private:\n typedef std::pair entry_t;\n\n private:\n unsigned int n_velo_dofs;\n std::vector contributions;\n\n public:\n const std::vector& entries() const { return contributions; }\n};\n\n// ------------------------------------------------------------\ntemplate \nvoid\nMomentum::init(const SPECTRAL_BASIS& spectral_basis)\n{\n n_velo_dofs = spectral_basis.n_dofs();\n\n typedef typename std::tuple_element<1, typename SPECTRAL_BASIS::elem_t::container_t>::type\n radial_elem_t;\n\n typedef typename std::tuple_element<0, typename SPECTRAL_BASIS::elem_t::container_t>::type\n angular_elem_t;\n\n auto& QR_handler = QuadHandler::GetInstance();\n typedef QuadAdaptor qr_adapt;\n\n unsigned int nqR = spectral::get_max_k(spectral_basis) + 2;\n Eigen::VectorXd pts_qR(nqR);\n Eigen::VectorXd wts_qR(nqR);\n\n qr_adapt::apply(pts_qR.data(), wts_qR.data(), QR_handler.get(nqR), 0.5);\n\n typedef typename SPECTRAL_BASIS::elem_t elem_t;\n for (auto it = spectral_basis.begin(); it != spectral_basis.end(); ++it) {\n typename elem_t::Acc::template get getter;\n typename elem_t::Acc::template get geta;\n\n const auto& rr = getter(*it);\n\n if (geta(*it).get_id().l != 1) continue;\n\n // make sure we are using the right basis\n const double w = rr.w();\n if (abs(0.5 - w) > 1e-10) throw std::runtime_error(\"Error: wrong weight in Momentum::init\");\n\n value_t sum;\n sum[0] = 0.0;\n sum[1] = 0.0;\n if (geta(*it).get_id().t == TRIG::SIN) {\n // sin\n for (unsigned int q = 0; q < pts_qR.size(); ++q) {\n const double r = pts_qR[q];\n sum[TRIG::SIN] += rr.evaluate(r) * r * wts_qR[q];\n }\n } else if (geta(*it).get_id().t == TRIG::COS) {\n for (unsigned int q = 0; q < pts_qR.size(); ++q) {\n const double r = pts_qR[q];\n sum[TRIG::COS] += rr.evaluate(r) * r * wts_qR[q];\n }\n }\n\n const unsigned int i = it - spectral_basis.begin();\n contributions.push_back(std::make_pair(i, numbers::PI * sum));\n }\n}\n\n// // ------------------------------------------------------------\ntemplate \nvoid\nMomentum::compute(NUMERIC_T* dstx, NUMERIC_T* dsty, const NUMERIC_T* src, int count) const\n{\n#pragma omp parallel for\n for (int i = 0; i < count; ++i) {\n const NUMERIC_T* local_src = src + i * n_velo_dofs;\n value_t sum;\n sum[0] = 0;\n sum[1] = 0;\n for (unsigned int j = 0; j < contributions.size(); ++j) {\n sum += contributions[j].second * local_src[contributions[j].first];\n }\n dstx[i] = sum[0];\n dsty[i] = sum[1];\n }\n}\n\n// ------------------------------------------------------------\ntemplate \nMomentum::value_t\nMomentum::compute(const NUMERIC_T* src) const\n{\n value_t sum;\n sum[0] = 0;\n sum[1] = 0;\n for (unsigned int j = 0; j < contributions.size(); ++j) {\n sum += contributions[j].second * src[contributions[j].first];\n }\n return sum;\n}\n\n// // ------------------------------------------------------------\ntemplate \nvoid\nMomentum::compute(VEC_OUT& dstx,\n VEC_OUT& dsty,\n const VEC_IN& src,\n const dealii::IndexSet& relevant_dofs,\n const INDEXER& indexer) const\n{\n#pragma omp parallel for\n for (unsigned int ix = 0; ix < relevant_dofs.size(); ++ix) {\n if (relevant_dofs.is_element(ix)) {\n value_t sum;\n sum[0] = 0;\n sum[1] = 0;\n for (unsigned int j = 0; j < contributions.size(); ++j) {\n unsigned int jx = contributions[j].first;\n sum += contributions[j].second * src[indexer.to_global(ix, jx)];\n }\n dstx[ix] = sum[0];\n dsty[ix] = sum[1];\n }\n }\n}\n\n} // end namespace boltzmann\n", "meta": {"hexsha": "173b280926a364ed58e24130dd138a7f143fc349", "size": 5096, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/post_processing/momentum.hpp", "max_stars_repo_name": "simonpintarelli/2dBoltzmann", "max_stars_repo_head_hexsha": "bc6b7bbeffa242ce80937947444383b416ba3fc9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/post_processing/momentum.hpp", "max_issues_repo_name": "simonpintarelli/2dBoltzmann", "max_issues_repo_head_hexsha": "bc6b7bbeffa242ce80937947444383b416ba3fc9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/post_processing/momentum.hpp", "max_forks_repo_name": "simonpintarelli/2dBoltzmann", "max_forks_repo_head_hexsha": "bc6b7bbeffa242ce80937947444383b416ba3fc9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.3111111111, "max_line_length": 96, "alphanum_fraction": 0.6165620094, "num_tokens": 1453, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933359135361, "lm_q2_score": 0.665410558746814, "lm_q1q2_score": 0.5455656827630153}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std; \nusing namespace g2o;\n//Vertex数量n,这n个Vertex存储的数据类型\nclass powell_vertex: public BaseVertex<4, Eigen::Matrix> {\n\tvirtual void oplusImpl(const double* v) {\n\t\t//base_vertex.h: EstimateType _estimate;\n\t\t//cout << \"oplus: \" << endl;\n\t\t//cout << Eigen::Matrix(v) << endl;\n\t\t_estimate += Eigen::Matrix(v);\n\t\t//cout << \"_estimate: \" << _estimate << endl;\n\t}\n virtual void setToOriginImpl() {\n\t\t//cout << \"initial _estimate\" << endl;\n\t\t_estimate << 0.5,1.5,2.5,3.5;\n\t}\n\t\n\tvirtual bool read(std::istream& is) {}\n virtual bool write(std::ostream& os) const {}\t//const 不能忽略\n};\n//e(xi)的维度、类型; vertex的类型\nclass powell_edge: public BaseUnaryEdge<4, Eigen::Matrix, powell_vertex> {\n\tvirtual void computeError() {\n\t\t//vertex* vtx = new vertex;\n\t\tconst powell_vertex* v = static_cast (_vertices[0]);\n\t\tEigen::Matrix est = v->estimate();\n\t\t//cout << \"est: \" << est(0,0) << \"---\" << est(0,1) <<\"---\" << est(0,2) << \"---\"<< est(0,3) << endl;\n// \t\t_error(0,0) = (&_measurement)[0] - (est(0,0) + 10*est(0,1));\n// \t\t_error(0,1) = (&_measurement)[1] - sqrt(5)*(est(0,2) - est(0,3));\n// \t\t_error(0,2) = (&_measurement)[2] - (est(0,1) - 2*est(0,2))*(est(0,1) - 2*est(0,2));\n// \t\t_error(0,3) = (&_measurement)[3] - sqrt(10)*(est(0,0) - est(0,2))*(est(0,0) - est(0,2));\n\t\t_error(0,0) = _measurement(0,0)- (est(0,0) + 10*est(0,1));\n\t\t_error(1,0) = _measurement(0,1) - sqrt(5)*(est(0,2) - est(0,3));\n\t\t_error(2,0) = _measurement(0,2) - (est(0,1) - 2*est(0,2))*(est(0,1) - 2*est(0,2));\n\t\t_error(3,0) = _measurement(0,3) - sqrt(10)*(est(0,0) - est(0,2))*(est(0,0) - est(0,2));\n\t\tcout << \"_error: \" << _error.transpose() << endl;\n\t}\n\t\n\tvirtual bool read(std::istream& is) {}\n virtual bool write(std::ostream& os) const {}\t//const 不能忽略\n};\n\nint main(int argc, char **argv) { \n\t// 构建图优化，先设定g2o\n\t//注意维度对应--边--顶点---\n\ttypedef g2o::BlockSolver< g2o::BlockSolverTraits<4,4> > Block; // int _PoseDim, int _LandmarkDim\n\tBlock::LinearSolverType* linearSolver = new g2o::LinearSolverDense(); // 线性方程求解器\n\tBlock* solver_ptr = new Block( linearSolver ); // 矩阵块求解器\n\t// 梯度下降方法，从GN, LM, DogLeg 中选\n\tcout << \"config blocksolver\" << endl;\n\tg2o::OptimizationAlgorithmLevenberg* solver = new g2o::OptimizationAlgorithmLevenberg( solver_ptr );\n\t// g2o::OptimizationAlgorithmGaussNewton* solver = new g2o::OptimizationAlgorithmGaussNewton( solver_ptr );\n\t// g2o::OptimizationAlgorithmDogleg* solver = new g2o::OptimizationAlgorithmDogleg( solver_ptr );\n\tg2o::SparseOptimizer optimizer; // 图模型\n\toptimizer.setAlgorithm( solver ); // 设置求解器\n\toptimizer.setVerbose( true ); // 打开调试输出\n\tcout << \"add Vertex\" << endl;\n\t// 往图中增加顶点\n\tpowell_vertex* v = new powell_vertex;\n\tEigen::Matrix estimate_initial;\n\testimate_initial <<0.5,1.5,2.5,3.5;\n\tv->setEstimate(estimate_initial);\n\tv->setId(0);\n\toptimizer.addVertex( v );\n\tcout << \"add Edge\" << endl;\n\t//加边\n\tpowell_edge* eg = new powell_edge;\n\t//double measurement_initial[4] = {21,-sqrt(5),16,9*sqrt(10)};\n\t//for (int i=0;i<4;i++) {\n\t\teg->setId(0);\n\t\teg->setVertex( 0, v ); // 设置连接的顶点\n\t\tEigen::Matrix measurement_initial;\n\t\tmeasurement_initial << 21,-sqrt(5),16,9*sqrt(10);\n\t\teg->setMeasurement(measurement_initial); // 观测数值\n\t\t//这个'4'对应于powell_edge第一个参数\n\t\teg->setInformation(Eigen::Matrix::Identity()*1/0.25); // 信息矩阵：协方差矩阵之逆\n\t\toptimizer.addEdge( eg );\n\t//}\n\t// 执行优化\n\tcout<<\"start optimization\"< time_used = chrono::duration_cast>( t2-t1 );\n\tcout<<\"solve time cost = \"< abc_estimate = v->estimate();\n\tcout<<\"estimated value: \"<\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 \"pointevaluationrhs.h\"\n\nint main() {\n auto mesh_p = lf::mesh::test_utils::GenerateHybrid2DTestMesh(1, 1.0);\n\n // Start of numerical experiment\n std::vector dof_a{};\n std::vector l2_a{};\n std::vector h1_a{};\n Eigen::VectorXd sol_vec;\n\n // Runs with initial mesh\n lf::assemble::UniformFEDofHandler dofh_initial(\n mesh_p, {{lf::base::RefEl::kPoint(), 1}});\n auto result = PointEvaluationRhs::normsSolutionPointLoadDirichletBVP(\n dofh_initial, Eigen::Vector2d(1.3, 1.7), sol_vec);\n unsigned N_dofs = dofh_initial.NumDofs();\n dof_a.push_back(N_dofs);\n l2_a.push_back(result.first);\n h1_a.push_back(result.second);\n\n // Necessary for regular refinement\n std::unique_ptr mesh_factory2 =\n std::make_unique(2);\n lf::refinement::MeshHierarchy my_hierarchy(mesh_p, std::move(mesh_factory2));\n\n for (int k = 1; k < 7; k++) {\n my_hierarchy.RefineRegular();\n\n mesh_p = my_hierarchy.getMesh(k);\n lf::assemble::UniformFEDofHandler dofh(mesh_p,\n {{lf::base::RefEl::kPoint(), 1}});\n unsigned N_dofs = dofh.NumDofs();\n dof_a.push_back(N_dofs);\n sol_vec.resize(N_dofs);\n\n result = PointEvaluationRhs::normsSolutionPointLoadDirichletBVP(\n dofh, Eigen::Vector2d(1.3, 1.7), sol_vec);\n l2_a.push_back(result.first);\n h1_a.push_back(result.second);\n // Write vtk file\n std::stringstream filename;\n filename << \"rhseval\" << k << \".vtk\";\n lf::io::VtkWriter vtk_writer(mesh_p, filename.str());\n // need the newest pointer\n auto mds = lf::mesh::utils::make_CodimMeshDataSet(mesh_p, 2);\n for (auto *node : mesh_p->Entities(2)) {\n mds->operator()(*node) = sol_vec(dofh.GlobalDofIndices(*node)[0]);\n }\n vtk_writer.WritePointData(\"solution_data\", *mds);\n }\n\n // Print to std output\n std::cout << \" dof l2 h1 \" << std::endl;\n for (int i = 0; i < dof_a.size(); i++) {\n std::cout << std::setw(5) << dof_a.at(i) << \" \" << std::setw(5)\n << l2_a.at(i) << \" \" << std::setw(5) << h1_a.at(i) << std::endl;\n }\n}\n", "meta": {"hexsha": "60f72de4675acf7ac8c89092b060f487c0d5544c", "size": 2751, "ext": "cc", "lang": "C++", "max_stars_repo_path": "homeworks/PointEvaluationRhs/templates/pointevaluationrhs_main.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": "homeworks/PointEvaluationRhs/templates/pointevaluationrhs_main.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": "homeworks/PointEvaluationRhs/templates/pointevaluationrhs_main.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": 33.1445783133, "max_line_length": 80, "alphanum_fraction": 0.657215558, "num_tokens": 824, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461389817407016, "lm_q2_score": 0.7310585903489891, "lm_q1q2_score": 0.5454713121957875}} {"text": "// Boost pow.hpp header file\n// Computes a power with exponent known at compile-time\n\n// (C) Copyright Bruno Lalande 2008.\n// Distributed under the Boost Software License, Version 1.0.\n// (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// See http://www.boost.org for updates, documentation, and revision history.\n\n\n#ifndef BOOST_MATH_POW_HPP\n#define BOOST_MATH_POW_HPP\n\n\n#include \n#include \n#include \n#include \n#include \n\n\nnamespace boost {\nnamespace math {\n\n#ifdef BOOST_MSVC\n#pragma warning(push)\n#pragma warning(disable:4702) // Unreachable code, only triggered in release mode and /W4\n#endif\n\nnamespace detail {\n\n\ntemplate \nstruct positive_power\n{\n template \n static T result(T base)\n {\n T power = positive_power::result(base);\n return power * power;\n }\n};\n\ntemplate \nstruct positive_power\n{\n template \n static T result(T base)\n {\n T power = positive_power::result(base);\n return base * power * power;\n }\n};\n\ntemplate <>\nstruct positive_power<1, 1>\n{\n template \n static T result(T base){ return base; }\n};\n\n\ntemplate \nstruct power_if_positive\n{\n template \n static T result(T base, const Policy&)\n { return positive_power::result(base); }\n};\n\ntemplate \nstruct power_if_positive\n{\n template \n static T result(T base, const Policy& policy)\n {\n if (base == 0)\n {\n return policies::raise_overflow_error(\n \"boost::math::pow(%1%)\",\n \"Attempted to compute a negative power of 0\",\n policy\n );\n }\n\n return T(1) / positive_power<-N>::result(base);\n }\n};\n\ntemplate <>\nstruct power_if_positive<0, true>\n{\n template \n static T result(T base, const Policy& policy)\n {\n if (base == 0)\n {\n return policies::raise_indeterminate_result_error(\n \"boost::math::pow(%1%)\",\n \"The result of pow<0>(%1%) is undetermined\",\n base,\n T(1),\n policy\n );\n }\n\n return T(1);\n }\n};\n\n\ntemplate \nstruct select_power_if_positive\n{\n typedef typename mpl::greater_equal<\n boost::integral_constant,\n boost::integral_constant\n >::type is_positive;\n\n typedef power_if_positive type;\n};\n\n\n} // namespace detail\n\n\ntemplate \ninline typename tools::promote_args::type pow(T base, const Policy& policy)\n{ \n typedef typename tools::promote_args::type result_type;\n return detail::select_power_if_positive::type::result(static_cast(base), policy); \n}\n\n\ntemplate \ninline typename tools::promote_args::type pow(T base)\n{ return pow(base, policies::policy<>()); }\n\n#ifdef BOOST_MSVC\n#pragma warning(pop)\n#endif\n\n} // namespace math\n} // namespace boost\n\n\n#endif\n", "meta": {"hexsha": "9c92116acd02166e89401ece825321ba06161dc7", "size": 3426, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "boost/lib/include/boost/math/special_functions/pow.hpp", "max_stars_repo_name": "mamil/demo", "max_stars_repo_head_hexsha": "32240d95b80175549e6a1904699363ce672a1591", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 101.0, "max_stars_repo_stars_event_min_datetime": "2019-02-12T12:53:18.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T14:14:38.000Z", "max_issues_repo_path": "3rdparty/boost_1_73_0/boost/math/special_functions/pow.hpp", "max_issues_repo_name": "qingkouwei/mediaones", "max_issues_repo_head_hexsha": "cec475e1bfd5807b5351cc7e38d244ac5298ca16", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 157.0, "max_issues_repo_issues_event_min_datetime": "2019-02-06T05:04:20.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T21:50:28.000Z", "max_forks_repo_path": "3rdparty/boost_1_73_0/boost/math/special_functions/pow.hpp", "max_forks_repo_name": "qingkouwei/mediaones", "max_forks_repo_head_hexsha": "cec475e1bfd5807b5351cc7e38d244ac5298ca16", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 28.0, "max_forks_repo_forks_event_min_datetime": "2020-02-27T14:07:00.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-10T07:53:36.000Z", "avg_line_length": 22.9932885906, "max_line_length": 101, "alphanum_fraction": 0.619089317, "num_tokens": 793, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256631249077, "lm_q2_score": 0.6477982315512489, "lm_q1q2_score": 0.5453331758467727}} {"text": "#include \n#include \n#include \n#include \"MPIProvider.hpp\"\n#include \"BayesOptVQEBackend.hpp\"\n#include \n\nnamespace xacc {\nnamespace vqe {\n\nconst VQETaskResult BayesOptVQEBackend::minimize(Eigen::VectorXd parameters) {\n\n\tVQETaskResult r;\n\tconst int dim = parameters.size();\n\tauto pi = boost::math::constants::pi();\n\tauto computeTask = std::make_shared(program);\n\tbayesopt::Parameters par;\n\tpar = initialize_parameters_to_default();\n\tpar.n_iterations = xacc::optionExists(\"bo-n-iter\") ? std::stoi(xacc::getOption(\"bo-n-iter\")) : par.n_iterations;\n\tpar.noise = xacc::optionExists(\"bo-noise\") ? std::stod(xacc::getOption(\"bo-noise\")) : par.noise;\n\tpar.l_type = xacc::optionExists(\"bo-learn-type\") ? str2learn(xacc::getOption(\"bo-learn-type\").c_str()) : par.l_type;\n\tpar.n_init_samples = xacc::optionExists(\"bo-n-init-iter\") ? std::stoi(xacc::getOption(\"bo-n-init-iter\")) : par.n_init_samples;\n\tpar.verbose_level = xacc::optionExists(\"bo-verbose-level\") ? std::stoi(xacc::getOption(\"bo-verbose-level\")) : par.verbose_level;\n\tpar.epsilon = xacc::optionExists(\"bo-epsilon\") ? std::stod(xacc::getOption(\"bo-epsilon\")) : par.epsilon;\n\tpar.crit_name = xacc::optionExists(\"bo-crit-name\") ? std::string(xacc::getOption(\"bo-crit-name\")) : par.crit_name;\n\tpar.kernel.name = xacc::optionExists(\"bo-kernel-name\") ? std::string(xacc::getOption(\"bo-kernel-name\")) : par.kernel.name;\n\tpar.sc_type = xacc::optionExists(\"bo-score-type\") ? str2score(xacc::getOption(\"bo-score-type\").c_str()) : par.sc_type;\n\tpar.surr_name = xacc::optionExists(\"bo-surrogate-name\") ? std::string(xacc::getOption(\"bo-surrogate-name\")) : par.surr_name;\n\tpar.mean.name = xacc::optionExists(\"bo-mean-name\") ? std::string(xacc::getOption(\"bo-mean-name\")) : par.mean.name;\n\t//par.kernel.hp_mean = xacc::optionExists(\"bo-kernel-mean\") ? std::stod(xacc::getOption(\"bo-kernel-mean\")) : par.kernel.hp_mean;\n\t//par.kernel.hp_std = xacc::optionExists(\"bo-kernel-std\") ? std::stod(xacc::getOption(\"bo-kernel-std\")) : par.kernel.hp_std;\n\tVQEBayesOptFunction f(par, computeTask, dim);\n\n\t// Map parameters to boost vector\n\n\tboost::numeric::ublas::vector result(dim);\n\tdouble* p = parameters.data();\n\tstd::copy(result.begin(), result.end(), p);\n\n\tboost::numeric::ublas::vector lowerBound(dim);\n\tboost::numeric::ublas::vector upperBound(dim);\n\tfor (int i = 0; i < dim; i++) {lowerBound[i] = -1*pi;upperBound[i] = pi;}\n\n\tf.setBoundingBox(lowerBound,upperBound);\n\n\tf.optimize(result);\n\n\tr.energy = f.getValueAtMinimum();\n\tauto resultAngles = f.getFinalResult();\n\tconst double * data = &(resultAngles.data()[0]);\n r.angles = Eigen::Map(data, parameters.size());\n\n\treturn r;\n\n}\n\n}\n}\n", "meta": {"hexsha": "47d79b94f9bb35badc68f88d7f631350ceb62530", "size": 2782, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "backend/BayesOptVQEBackend.cpp", "max_stars_repo_name": "zpparks314/xacc-vqe-bayesopt", "max_stars_repo_head_hexsha": "0c01904350f2e79f654d4f8edcc04f3908b916e9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "backend/BayesOptVQEBackend.cpp", "max_issues_repo_name": "zpparks314/xacc-vqe-bayesopt", "max_issues_repo_head_hexsha": "0c01904350f2e79f654d4f8edcc04f3908b916e9", "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": "backend/BayesOptVQEBackend.cpp", "max_forks_repo_name": "zpparks314/xacc-vqe-bayesopt", "max_forks_repo_head_hexsha": "0c01904350f2e79f654d4f8edcc04f3908b916e9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.1525423729, "max_line_length": 129, "alphanum_fraction": 0.7156721783, "num_tokens": 780, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256472515683, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5453331541159477}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"print.hpp\"\n#include \"random.hpp\"\n\nnamespace ublas=boost::numeric::ublas;\nnamespace blas=boost::numeric::bindings::blas;\n\nint main(int argc, char *argv[]) {\n {\n typedef ublas::vector vector;\n typedef ublas::matrix matrix;\n typedef vector::size_type size_type;\n rand_normal::reset();\n size_type m=6, n=8;\n matrix A(m, n);\n for (size_type j=0; j::get();\n vector x(m);\n for (size_type i=0; i::get();\n vector y(n);\n for (size_type i=0; i::get();\n double alpha(rand_normal::get());\n matrix A1(alpha*ublas::outer_prod(x, y)+A);\n matrix A2(A);\n blas::gerh(alpha, x, y, A2);\n std::cout << print_mat(A1) << '\\n'\n \t << print_mat(A2) << '\\n';\n }\n {\n typedef std::complex complex;\n typedef ublas::vector vector;\n typedef ublas::matrix matrix;\n typedef vector::size_type size_type;\n rand_normal::reset();\n size_type m=6, n=8;\n matrix A(m, n);\n for (size_type j=0; j::get();\n vector x(m);\n for (size_type i=0; i::get();\n vector y(n);\n for (size_type i=0; i::get();\n complex alpha(rand_normal::get());\n matrix A1(alpha*ublas::outer_prod(x, ublas::conj(y))+A);\n matrix A2(A);\n blas::gerh(alpha, x, y, A2);\n std::cout << print_mat(A1) << '\\n'\n\t << print_mat(A2) << '\\n';\n }\n return EXIT_SUCCESS;\n}\n", "meta": {"hexsha": "821b15613178608e90f40518ce919e8a6e113d38", "size": 2151, "ext": "cc", "lang": "C++", "max_stars_repo_path": "examples/blas/gerh.cc", "max_stars_repo_name": "rabauke/numeric_bindings", "max_stars_repo_head_hexsha": "f4de93bd7a01a8b31c9367fad35c81d086768f99", "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": "examples/blas/gerh.cc", "max_issues_repo_name": "rabauke/numeric_bindings", "max_issues_repo_head_hexsha": "f4de93bd7a01a8b31c9367fad35c81d086768f99", "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": "examples/blas/gerh.cc", "max_forks_repo_name": "rabauke/numeric_bindings", "max_forks_repo_head_hexsha": "f4de93bd7a01a8b31c9367fad35c81d086768f99", "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": 31.6323529412, "max_line_length": 63, "alphanum_fraction": 0.6317991632, "num_tokens": 651, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256393148981, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.545333148974587}} {"text": "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#define PF_RAD(deg) ((double)deg * M_PI / 180.)\n#define PF_DEG(rad) ((double)rad * 180. / M_PI)\n#define PF_ISNAN(v) (!((v) == (v)))\n\nNAMESPACE_BEGIN(polyfit)\nNAMESPACE_BEGIN(AngleUtils)\n\n/*\n\tReturns true if both points are in the same quadrant. The test is inclusive\n\tif any of the two points lie exactly along one of the axis.\n*/\nPV_INLINE bool lie_in_the_same_quadrant(\n\tconst vec2& p0,\n\tconst vec2& p1\n);\n\nPV_INLINE double deviation_from_horizontal(const vec2& d);\nPV_INLINE double deviation_from_horizontal(double angle);\n\nPV_INLINE double deviation_from_vertical(const vec2& d);\nPV_INLINE double deviation_from_vertical(double angle);\n\nPV_INLINE double spanned_shortest(const vec2 & p0, const vec2 & p1, const vec2 & p2);\n\nPV_INLINE double spanned_shortest_between(const vec2 & d0, const vec2 & d1);\n\nPV_INLINE double spanned_clockwise_between(const vec2& d0, const vec2& d1);\n\nPV_INLINE bool have_opposite_convexity(const vec2 & p0, const vec2 & p1, const vec2 & p2, const vec2 & p3);\n\nPV_INLINE bool have_opposite_convexity_with_tol(const vec2 & p0, const vec2 & p1, const vec2 & p2, const vec2 & p3);\n\nPV_INLINE int count_inflections(const mat2x & points, bool circular = true);\n\nPV_INLINE bool is_flat(const vec2 pp, const vec2 p, const vec2 pn);\n\nPV_INLINE int convexity(const vec2 pp, const vec2 p, const vec2 pn, int orientation);\n\nPV_INLINE int number_of_neighbors_with_different_convexity(const Eigen::Matrix2Xd& polygon, int corner);\n\n// convexity should be writable for 1 + 2 * neighborhood_size elements\n// the polygon should contain enough elements before and after the first/last neighboring corners to be able to compute the convexity\nPV_INLINE void neighborhood_convexity(const Eigen::Matrix2Xd& P, const int corner, const int neighborhood_size, int* convexity);\n\n/*\n\tReturns the number of edges in P which overlap 1-pixel axis-aligned steps in B.\n\n\tB is assumed to be the raster boundary which P is approximating, though there are \n\tno requirements on the points except that they should have the same ordering.\n*/\nPV_INLINE int count_visually_degenerate_edges(\n\tconst mat2x& B, \n\tconst vecXi& P, \n\tconst bool circular = false\n);\n\nPV_INLINE int count_visually_inconsistent_edges(const mat2x & P, bool circular = false);\n\n#include \"angle.inl\"\n\nNAMESPACE_END(AngleUtils)\nNAMESPACE_END(polyfit)", "meta": {"hexsha": "27ec7a6451b2e4881e8f000b9556d65336562d86", "size": 2529, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/polyvec/geometry/angle.hpp", "max_stars_repo_name": "ShnitzelKiller/polyfit", "max_stars_repo_head_hexsha": "51ddc6365a794db1678459140658211cb78f65b1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 27.0, "max_stars_repo_stars_event_min_datetime": "2020-08-17T17:25:59.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T05:49:12.000Z", "max_issues_repo_path": "include/polyvec/geometry/angle.hpp", "max_issues_repo_name": "ShnitzelKiller/polyfit", "max_issues_repo_head_hexsha": "51ddc6365a794db1678459140658211cb78f65b1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4.0, "max_issues_repo_issues_event_min_datetime": "2020-08-26T13:54:59.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-21T07:19:22.000Z", "max_forks_repo_path": "include/polyvec/geometry/angle.hpp", "max_forks_repo_name": "ShnitzelKiller/polyfit", "max_forks_repo_head_hexsha": "51ddc6365a794db1678459140658211cb78f65b1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2020-08-26T23:26:48.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-04T09:06:07.000Z", "avg_line_length": 35.125, "max_line_length": 133, "alphanum_fraction": 0.7765915382, "num_tokens": 639, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.749087201911703, "lm_q2_score": 0.7279754489059774, "lm_q1q2_score": 0.5453170920813946}} {"text": "/******************************************************************************\n * Author: Laurent Kneip *\n * Contact: kneip.laurent@gmail.com *\n * License: Copyright (c) 2013 Laurent Kneip, ANU. All rights reserved. *\n * *\n * Redistribution and use in source and binary forms, with or without *\n * modification, are permitted provided that the following conditions *\n * are met: *\n * * Redistributions of source code must retain the above copyright *\n * notice, this list of conditions and the following disclaimer. *\n * * Redistributions in binary form must reproduce the above copyright *\n * notice, this list of conditions and the following disclaimer in the *\n * documentation and/or other materials provided with the distribution. *\n * * Neither the name of ANU nor the names of its contributors may be *\n * used to endorse or promote products derived from this software without *\n * specific prior written permission. *\n * *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"*\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE *\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE *\n * ARE DISCLAIMED. IN NO EVENT SHALL ANU OR THE CONTRIBUTORS BE LIABLE *\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL *\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR *\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER *\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT *\n * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY *\n * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF *\n * SUCH DAMAGE. *\n ******************************************************************************/\n\n/**\n * \\file arun.hpp\n * \\brief Arun's method for computing the rotation between two point sets.\n */\n\n#ifndef OPENGV_ARUN_HPP_\n#define OPENGV_ARUN_HPP_\n\n#include \n#include \n#include \n\n/**\n * \\brief The namespace of this library.\n */\nnamespace opengv\n{\n/**\n * \\brief The namespace of the math tools.\n */\nnamespace math\n{\n\n/**\n * \\brief Arun's method for computing the rotation between two point sets.\n * Core function [13].\n *\n * \\param[in] Hcross The summation over the exterior products between the\n * normalized points.\n * \\return The rotation matrix that aligns the points.\n */\nrotation_t arun( const Eigen::MatrixXd & Hcross );\n\n/**\n * \\brief Arun's method for complete point cloud alignment [13]. The method\n * actually does the same than threept_arun, but has a different\n * interface.\n *\n * \\param[in] p1 The points expressed in the first frame.\n * \\param[in] p2 The points expressed in the second frame.\n * \\return The Transformation from frame 2 to frame 1 (\n * \\f$ \\mathbf{T} = \\left(\\begin{array}{cc} \\mathbf{R} & \\mathbf{t} \\end{array}\\right) \\f$,\n * with \\f$ \\mathbf{t} \\f$ being the position of frame 2 seen from\n * frame 1, and \\f$ \\mathbf{R} \\f$ being the rotation from\n * frame 2 to frame 1).\n */\ntransformation_t arun_complete( const points_t & p1, const points_t & p2 );\n\n}\n}\n\n#endif /* OPENGV_ARUN_HPP_ */\n", "meta": {"hexsha": "b85a033586f1bf1e1c203e2e9b1174e69c0863b6", "size": 3753, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/opengv/math/arun.hpp", "max_stars_repo_name": "PXLVision/opengv", "max_stars_repo_head_hexsha": "e48f77da4db7b8cee36ec677ed4ff5c5354571bb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/opengv/math/arun.hpp", "max_issues_repo_name": "PXLVision/opengv", "max_issues_repo_head_hexsha": "e48f77da4db7b8cee36ec677ed4ff5c5354571bb", "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": "include/opengv/math/arun.hpp", "max_forks_repo_name": "PXLVision/opengv", "max_forks_repo_head_hexsha": "e48f77da4db7b8cee36ec677ed4ff5c5354571bb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.2168674699, "max_line_length": 99, "alphanum_fraction": 0.5835331735, "num_tokens": 757, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8152324938410784, "lm_q2_score": 0.6688802669716107, "lm_q1q2_score": 0.5452929281243526}} {"text": "/*!\n* Copyright 2007 Technical University of Catalonia\n*\n* Use, modification and distribution is subject to the Boost Software\n* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n* http://www.boost.org/LICENSE_1_0.txt)\n*\n* Authors: Dmitry Bufistov\n* Andrey Parfenov\n*/\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\nusing namespace boost;\ntypedef adjacency_list >, \n property > > > grap_real_t;\n\ntemplate \nvoid gen_rand_graph(TGraph& g, size_t nV, size_t nE)\n{\n g.clear();\n boost::mt19937 rng;\n boost::generate_random_graph(g, nV, nE, rng, true, true);\n boost::uniform_real<> ur(-1,10); \n boost::variate_generator > ew1rg(rng, ur);\n randomize_property(g, ew1rg);\n boost::uniform_int<> uint(1,5); \n boost::variate_generator > ew2rg(rng, uint);\n randomize_property(g, ew2rg);\n}\n\nint main(int argc, char* argv[])\n{\n const double epsilon = 0.000000001;\n double min_cr, max_cr; ///Minimum and maximum cycle ratio\n typedef std::vector::edge_descriptor> ccReal_t; \n ccReal_t cc; ///For storing critical edges\n \n \n grap_real_t tgr;\n property_map::type vim = get(vertex_index, tgr);\n property_map::type ew1m = get(edge_weight, tgr);\n property_map::type ew2m = ew2m;\n \n gen_rand_graph(tgr, 1000, 300000);\n std::cout << \"Vertices number: \" << num_vertices(tgr) << '\\n';\n std::cout << \"Edges number: \" << num_edges(tgr) << '\\n';\n int i = 0;\n BGL_FORALL_VERTICES(vd, tgr, grap_real_t) put(vertex_index, tgr, vd, i++); ///Initialize vertex index property\n boost::posix_time::ptime st = boost::posix_time::microsec_clock::local_time();\n max_cr = maximum_cycle_ratio(tgr, get(vertex_index, tgr), get(edge_weight, tgr), get(edge_weight2, tgr));\n std::cout << \"Maximum cycle ratio is \" << max_cr << '\\n';\n std::cout << \"Run time of the maximum_cycle_ratio() is \" << to_simple_string(boost::posix_time::microsec_clock::local_time() - st) << '\\n';\n\n \n ///One way to get the \"good\" value of the plus_infinity parameter\n double pl_infnt = double(*std::max_element(get_property_iter_range(tgr, edge_weight).first, get_property_iter_range(tgr, edge_weight).second)) / \n *std::min_element(get_property_iter_range(tgr, edge_weight2).first, get_property_iter_range(tgr, edge_weight2).second);\n std::cout << \"Set infinity for minimum_cycle_ratio() call to \" << pl_infnt << '\\n';\n i = 0;\n BGL_FORALL_EDGES(ed, tgr, grap_real_t) put(edge_index, tgr, ed, i++); ///Initialize edge index property\n min_cr = minimum_cycle_ratio(tgr, get(vertex_index, tgr), get(edge_weight, tgr), get(edge_weight2, tgr), get(edge_index, tgr), &cc, pl_infnt);\n std::cout << \"Minimal cycle ratio is \" << min_cr << '\\n';\n std::pair cr(.0,.0);\n std::cout << \"\\nCritical cycle is:\\n\";\n for (ccReal_t::iterator itr = cc.begin(); itr != cc.end(); ++itr) \n {\n cr.first += get(edge_weight, tgr, *itr); cr.second += get(edge_weight2, tgr, *itr);\n std::cout << \"(\" << get(vertex_index, tgr, source(*itr, tgr)) << \",\" << get(vertex_index, tgr, target(*itr, tgr)) << \") \";\n }\n std::cout << '\\n';\n assert(std::abs(cr.first / cr.second - min_cr) < epsilon);\n \n return 0;\n}\n\n", "meta": {"hexsha": "4f543079a55c5f8ad35fd4f03008d4f91f059937", "size": 4227, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libs/graph/example/cycle_ratio_example.cpp", "max_stars_repo_name": "mike-code/boost_1_38_0", "max_stars_repo_head_hexsha": "7ff8b2069344ea6b0b757aa1f0778dfb8526df3c", "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": "libs/graph/example/cycle_ratio_example.cpp", "max_issues_repo_name": "mike-code/boost_1_38_0", "max_issues_repo_head_hexsha": "7ff8b2069344ea6b0b757aa1f0778dfb8526df3c", "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": "libs/graph/example/cycle_ratio_example.cpp", "max_forks_repo_name": "mike-code/boost_1_38_0", "max_forks_repo_head_hexsha": "7ff8b2069344ea6b0b757aa1f0778dfb8526df3c", "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": 49.7294117647, "max_line_length": 153, "alphanum_fraction": 0.6531819257, "num_tokens": 1141, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8152324983301568, "lm_q2_score": 0.6688802537704063, "lm_q1q2_score": 0.5452929203649576}} {"text": "/*!\n * Distance.h\n *\n * Created on: 2012/12/29\n * \\author Hiroki Sudo\n *\n */\n\n#ifndef DISTANCE_H_\n#define DISTANCE_H_\n\n#include \n#include \n#include \n#include \n#include \"Element.h\"\n\n/*!\n *\n */\nnamespace {\n/*!\n * Distance\n */\nnamespace Distance {\n\n/*!\n * ElementクラスのVectorインスタンスを引数に2つ取り、それぞれの編集距離(Levenstein距離)を計算します。\n * 返値は引数に渡されるVectorインスタンスの要素数で割られるため、0~1の値を取ります。\n * 値が大きければ距離は離れていて、小さければ距離が近いと言う意味になります。計算量はO((n*m)^(1/2))\n */\ntemplate\ndouble levenstein(std::vector ex1, std::vector ex2) {\n \n\tboost::numeric::ublas::matrix matrix(0, 0);\n\tint col_size, row_size;\n\tint cost_delta, cost1, cost2, cost3, cost;\n\n\tif (ex1.size() == 0 && ex2.size() != 0)\n\t\treturn ex2.size();\n\tif (ex1.size() != 0 && ex2.size() == 0)\n\t\treturn ex1.size();\n\tif (ex1.size() == 0 && ex2.size() == 0)\n\t\treturn 0;\n\n\trow_size = ex1.size() + 1;\n\tcol_size = ex2.size() + 1;\n\n\tmatrix.resize(row_size, col_size);\n\n\tfor (int j = 0; j < col_size; j++) {\n\t\tmatrix(0, j) = j;\n\t}\n\tfor (int i = 0; i < row_size; i++) {\n\t\tmatrix(i, 0) = i;\n\t}\n\n\tfor (int index_ex1 = 0; index_ex1 < ex1.size(); index_ex1++) {\n\t\tfor (int index_ex2 = 0; index_ex2 < ex2.size(); index_ex2++) {\n\n\t\t\tif (ex1[index_ex1].is_sym() && ex2[index_ex2].is_sym()) {\n\t\t\t\tcost_delta = ex1[index_ex1] == ex2[index_ex2] ? 0 : 1;\n\t\t\t} else if (ex1[index_ex1].is_cat() && ex2[index_ex2].is_cat()) {\n\t\t\t\tcost_delta = ex1[index_ex1].obj == ex2[index_ex2].obj ? 0 : 1;\n\t\t\t} else {\n\t\t\t\tcost_delta = 1;\n\t\t\t}\n\n\t\t\tint x, y;\n\t\t\ty = index_ex1 + 1;\n\t\t\tx = index_ex2 + 1;\n\t\t\tcost1 = matrix(y - 1, x) + 1;\n\t\t\tcost2 = matrix(y, x - 1) + 1;\n\t\t\tcost3 = matrix(y - 1, x - 1) + cost_delta;\n\n\t\t\tcost = cost1;\n\t\t\tcost = cost2 < cost ? cost2 : cost;\n\t\t\tcost = cost3 < cost ? cost3 : cost;\n\n\t\t\tmatrix(y, x) = cost;\n\t\t}\n\t}\n\n\tint len;\n\tif (row_size > col_size)\n\t\tlen = row_size;\n\telse\n\t\tlen = col_size;\n\n\treturn (matrix(matrix.size1() - 1, matrix.size2() - 1))\n\t\t\t/ (static_cast(len));\n}\n\n/*!\n * Vectorインスタンスの要素数で割らないため，値は0~無限となるLevenstein距離\n */\ntemplate\ndouble levenstein2(std::vector ex1, std::vector ex2) {\n \n\tboost::numeric::ublas::matrix matrix(0, 0);\n\tint col_size, row_size;\n\tint cost_delta, cost1, cost2, cost3, cost;\n\n\tif (ex1.size() == 0 && ex2.size() != 0)\n\t\treturn ex2.size();\n\tif (ex1.size() != 0 && ex2.size() == 0)\n\t\treturn ex1.size();\n\tif (ex1.size() == 0 && ex2.size() == 0)\n\t\treturn 0;\n\n\trow_size = ex1.size() + 1;\n\tcol_size = ex2.size() + 1;\n\n\tmatrix.resize(row_size, col_size);\n\n\tfor (int j = 0; j < col_size; j++) {\n\t\tmatrix(0, j) = j;\n\t}\n\tfor (int i = 0; i < row_size; i++) {\n\t\tmatrix(i, 0) = i;\n\t}\n\n\tfor (int index_ex1 = 0; index_ex1 < ex1.size(); index_ex1++) {\n\t\tfor (int index_ex2 = 0; index_ex2 < ex2.size(); index_ex2++) {\n\n\t\t\tif (ex1[index_ex1].is_sym() && ex2[index_ex2].is_sym()) {\n\t\t\t\tcost_delta = ex1[index_ex1] == ex2[index_ex2] ? 0 : 1;\n\t\t\t} else if (ex1[index_ex1].is_cat() && ex2[index_ex2].is_cat()) {\n\t\t\t\tcost_delta = ex1[index_ex1].obj == ex2[index_ex2].obj ? 0 : 1;\n\t\t\t} else {\n\t\t\t\tcost_delta = 1;\n\t\t\t}\n\n\t\t\tint x, y;\n\t\t\ty = index_ex1 + 1;\n\t\t\tx = index_ex2 + 1;\n\t\t\tcost1 = matrix(y - 1, x) + 1;\n\t\t\tcost2 = matrix(y, x - 1) + 1;\n\t\t\tcost3 = matrix(y - 1, x - 1) + cost_delta;\n\n\t\t\tcost = cost1;\n\t\t\tcost = cost2 < cost ? cost2 : cost;\n\t\t\tcost = cost3 < cost ? cost3 : cost;\n\n\t\t\tmatrix(y, x) = cost;\n\t\t}\n\t}\n\n\tint len;\n\tif (row_size > col_size)\n\t\tlen = row_size;\n\telse\n\t\tlen = col_size;\n\n\treturn (matrix(matrix.size1() - 1, matrix.size2() - 1));\n}\n\n\ntemplate \nint snake(int k, int y, std::vector& ary1, std::vector& ary2, int m, int n) {\n\tint x;\n\tx = y - k;\n\twhile (x < m && y < n && ary1[x] == ary2[y]) {\n\t\tx++;\n\t\ty++;\n\t}\n\n\treturn y;\n}\n/*!\n * O(np)法の実装\n */\ntemplate\ndouble onp_lv(std::vector& ary1, std::vector& ary2, double limit = -1) {\n\tstd::vector temp;\n\tstd::vector fp;\n\tint size = 0;\n\tint delta = 0;\n\tint offset = 0;\n\tint n = 0;\n\tint m = 0;\n\tint p;\n\tint k;\n\tint i;\n\n\tif (ary1.size() > ary2.size()) {\n\t\ttemp = ary1;\n\t\tary1 = ary2;\n\t\tary2 = temp;\n\t}\n\n\tm = ary1.size();\n\tn = ary2.size();\n\n\toffset = m + 1;\n\tdelta = n - m;\n\tsize = m + n + 3;\n\n\tif (limit == -1) {\n\t\tlimit = 2 * m + delta;\n\t}\n\n\tfp = std::vector(size, -1);\n\tp = -1;\n\tk = 0;\n\n\twhile (fp[delta + offset] < n) {\n\t\tp++;\n\n\t\tif (2 * p + delta >= (limit) * ary2.size() ) {\n\t\t\t//std::cerr << \"Cutted\" << std::endl;\n\t\t\treturn 1.0;\n\t\t}\n\n\t\tk = -p;\n\t\twhile (k < delta) {\n\t\t\tfp[k + offset] = fp[k - 1 + offset] + 1 > fp[k + 1 + offset] ?\n\t\t\t\tsnake(k, fp[k - 1 + offset] + 1, ary1, ary2, m, n) :\n\t\t\t\tsnake(k, fp[k + 1 + offset], ary1, ary2, m, n);\n\t\t\tk++;\n\t\t}\n\n\t\tk = delta + p;\n\t\twhile (k > delta) {\n\t\t\tfp[k + offset] = fp[k - 1 + offset] + 1 > fp[k + 1 + offset] ?\n\t\t\t\tsnake(k, fp[k - 1 + offset] + 1, ary1, ary2, m, n) :\n\t\t\t\tsnake(k, fp[k + 1 + offset], ary1, ary2, m, n);\n\t\t\tk--;\n\t\t}\n\n\t\tfp[delta + offset] = fp[delta - 1 + offset] + 1 > fp[delta + 1 + offset] ?\n\t\t\t\tsnake(delta, fp[delta - 1 + offset] + 1, ary1, ary2, m,\tn) :\n\t\t\t\tsnake(delta, fp[delta + 1 + offset], ary1, ary2, m, n);\n\t}\n\n\treturn (delta + 2 * p)/(static_cast(ary2.size()));\n}\n\ntemplate \ndouble hamming(std::vector ex1, std::vector ex2){\n \n if(ex1.size()!=ex2.size()){\n std::cerr << \"Happened error on hamming distance method.\" << std::endl;\n std::exit(0);\n }\n typename std::vector::iterator ex1_it;\n\n ex1_it = ex1.begin();\n int cnt = 0;\n double ham_sum=0;\n for(; ex1_it != ex1.end(); ex1_it++) {\n \n if((*ex1_it)!=ex2[cnt])\n ham_sum+=1;\n \n cnt+=1;\n }\n return (ham_sum/(double)cnt);\n}\n\n} /*Distance*/\n}\n#endif /* DISTANCE_H_ */\n", "meta": {"hexsha": "23b224aee56f1d451ec94bf4ecc7149e43c94e5e", "size": 5689, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "SOURCE/Distance.hpp", "max_stars_repo_name": "asciian/MSILM", "max_stars_repo_head_hexsha": "bfaea503888574d9d78ffb0b55f583f251ac6ea8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2018-04-17T08:43:28.000Z", "max_stars_repo_stars_event_max_datetime": "2018-04-17T08:43:28.000Z", "max_issues_repo_path": "SOURCE/Distance.hpp", "max_issues_repo_name": "asciian/MSILM", "max_issues_repo_head_hexsha": "bfaea503888574d9d78ffb0b55f583f251ac6ea8", "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": "SOURCE/Distance.hpp", "max_forks_repo_name": "asciian/MSILM", "max_forks_repo_head_hexsha": "bfaea503888574d9d78ffb0b55f583f251ac6ea8", "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": 21.5492424242, "max_line_length": 85, "alphanum_fraction": 0.5579187906, "num_tokens": 2226, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.815232489352, "lm_q2_score": 0.6688802537704063, "lm_q1q2_score": 0.5452929143596458}} {"text": "//\n// Copyright © 2017 Arm Ltd. All rights reserved.\n// SPDX-License-Identifier: MIT\n//\n\n#include \"Resize.hpp\"\n\n#include \"TensorBufferArrayView.hpp\"\n\n#include \n\n#include \n#include \n\nusing namespace armnnUtils;\n\nnamespace armnn\n{\n\nnamespace\n{\n\ninline float Lerp(float a, float b, float w)\n{\n return w * b + (1.f - w) * a;\n}\n\ninline double EuclideanDistance(float Xa, float Ya, const unsigned int Xb, const unsigned int Yb)\n{\n return std::sqrt(pow(Xa - boost::numeric_cast(Xb), 2) + pow(Ya - boost::numeric_cast(Yb), 2));\n}\n\n}// anonymous namespace\n\nvoid Resize(Decoder& in,\n const TensorInfo& inputInfo,\n Encoder& out,\n const TensorInfo& outputInfo,\n DataLayoutIndexed dataLayout,\n armnn::ResizeMethod resizeMethod,\n bool alignCorners)\n{\n // We follow the definition of TensorFlow and AndroidNN: the top-left corner of a texel in the output\n // image is projected into the input image to figure out the interpolants and weights. Note that this\n // will yield different results than if projecting the centre of output texels.\n\n const unsigned int batchSize = inputInfo.GetShape()[0];\n const unsigned int channelCount = inputInfo.GetShape()[dataLayout.GetChannelsIndex()];\n\n const unsigned int inputHeight = inputInfo.GetShape()[dataLayout.GetHeightIndex()];\n const unsigned int inputWidth = inputInfo.GetShape()[dataLayout.GetWidthIndex()];\n const unsigned int outputHeight = outputInfo.GetShape()[dataLayout.GetHeightIndex()];\n const unsigned int outputWidth = outputInfo.GetShape()[dataLayout.GetWidthIndex()];\n\n const unsigned int sizeOffset = resizeMethod == armnn::ResizeMethod::Bilinear && alignCorners ? 1 : 0;\n\n // How much to scale pixel coordinates in the output image, to get the corresponding pixel coordinates\n // in the input image.\n const float scaleY = boost::numeric_cast(inputHeight - sizeOffset)\n / boost::numeric_cast(outputHeight - sizeOffset);\n const float scaleX = boost::numeric_cast(inputWidth - sizeOffset)\n / boost::numeric_cast(outputWidth - sizeOffset);\n\n TensorShape inputShape = inputInfo.GetShape();\n TensorShape outputShape = outputInfo.GetShape();\n\n for (unsigned int n = 0; n < batchSize; ++n)\n {\n for (unsigned int c = 0; c < channelCount; ++c)\n {\n for (unsigned int y = 0; y < outputHeight; ++y)\n {\n // Corresponding real-valued height coordinate in input image.\n const float iy = boost::numeric_cast(y) * scaleY;\n\n // Discrete height coordinate of top-left texel (in the 2x2 texel area used for interpolation).\n const float fiy = floorf(iy);\n const unsigned int y0 = boost::numeric_cast(fiy);\n\n // Interpolation weight (range [0,1]).\n const float yw = iy - fiy;\n\n for (unsigned int x = 0; x < outputWidth; ++x)\n {\n // Real-valued and discrete width coordinates in input image.\n const float ix = boost::numeric_cast(x) * scaleX;\n const float fix = floorf(ix);\n const unsigned int x0 = boost::numeric_cast(fix);\n\n // Interpolation weight (range [0,1]).\n const float xw = ix - fix;\n\n // Discrete width/height coordinates of texels below and to the right of (x0, y0).\n const unsigned int x1 = std::min(x0 + 1, inputWidth - 1u);\n const unsigned int y1 = std::min(y0 + 1, inputHeight - 1u);\n\n float interpolatedValue;\n switch (resizeMethod)\n {\n case armnn::ResizeMethod::Bilinear:\n {\n in[dataLayout.GetIndex(inputShape, n, c, y0, x0)];\n float input1 = in.Get();\n in[dataLayout.GetIndex(inputShape, n, c, y0, x1)];\n float input2 = in.Get();\n in[dataLayout.GetIndex(inputShape, n, c, y1, x0)];\n float input3 = in.Get();\n in[dataLayout.GetIndex(inputShape, n, c, y1, x1)];\n float input4 = in.Get();\n\n const float ly0 = Lerp(input1, input2, xw); // lerp along row y0.\n const float ly1 = Lerp(input3, input4, xw); // lerp along row y1.\n interpolatedValue = Lerp(ly0, ly1, yw);\n break;\n }\n case armnn::ResizeMethod::NearestNeighbor:\n {\n // calculate euclidean distance to the 4 neighbours\n auto distance00 = EuclideanDistance(fix, fiy, x0, y0);\n auto distance01 = EuclideanDistance(fix, fiy, x0, y1);\n auto distance10 = EuclideanDistance(fix, fiy, x1, y0);\n auto distance11 = EuclideanDistance(fix, fiy, x1, y1);\n\n auto minimum = std::min( { distance00, distance01, distance10, distance11 } );\n\n unsigned int xNearest = 0;\n unsigned int yNearest = 0;\n\n if (minimum == distance00)\n {\n xNearest = x0;\n yNearest = y0;\n }\n else if (minimum == distance01)\n {\n xNearest = x0;\n yNearest = y1;\n }\n else if (minimum == distance10)\n {\n xNearest = x1;\n yNearest = y0;\n }\n else if (minimum == distance11)\n {\n xNearest = x1;\n yNearest = y1;\n }\n else\n {\n throw armnn::InvalidArgumentException(\"Resize Nearest Neighbor failure\");\n }\n\n in[dataLayout.GetIndex(inputShape, n, c, yNearest, xNearest)];\n interpolatedValue = in.Get();\n break;\n }\n default:\n throw armnn::InvalidArgumentException(\"Unknown resize method: \" +\n std::to_string(static_cast(resizeMethod)));\n }\n out[dataLayout.GetIndex(outputShape, n, c, y, x)];\n out.Set(interpolatedValue);\n }\n }\n }\n }\n}\n\n} //namespace armnn\n", "meta": {"hexsha": "a26e34a1ff5d641228b3b79ac90826121ee61df0", "size": 7271, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/backends/reference/workloads/Resize.cpp", "max_stars_repo_name": "muthukumaravel7/armnn", "max_stars_repo_head_hexsha": "879ec231203df5b0a94462c0b247dc7d8d8a7a44", "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/backends/reference/workloads/Resize.cpp", "max_issues_repo_name": "muthukumaravel7/armnn", "max_issues_repo_head_hexsha": "879ec231203df5b0a94462c0b247dc7d8d8a7a44", "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/backends/reference/workloads/Resize.cpp", "max_forks_repo_name": "muthukumaravel7/armnn", "max_forks_repo_head_hexsha": "879ec231203df5b0a94462c0b247dc7d8d8a7a44", "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": 42.5204678363, "max_line_length": 114, "alphanum_fraction": 0.4980057764, "num_tokens": 1452, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8558511396138365, "lm_q2_score": 0.6370308013713525, "lm_q1q2_score": 0.5452035373227876}} {"text": "#include \n#include \n\n#include \n#include \n\nusing MatrixXd = Eigen::MatrixXd;\nusing VectorXd = Eigen::VectorXd;\nusing Vector2d = Eigen::Vector2d;\nusing Vector4d = Eigen::Vector4d;\nusing Vector6d = Eigen::Matrix;\nusing Vector8d = Eigen::Matrix;\nusing Matrix8d = Eigen::Matrix;\nusing TimeStamp = double;\nusing TimeDuration = double;\n\nconstexpr double dt = 1.;\n\nstruct RocketState {\n // Using a single dt is a better option.\n // But it make index handling a little bit more complex.\n enum StateIndex : int16_t {\n i_position_x = 0,\n i_position_y,\n i_velocity_x,\n i_velocity_y,\n STATE_SIZE\n };\n\n explicit RocketState(const double px,\n const double py,\n const double vel_x,\n const double vel_y)\n {\n variables << px, py, vel_x, vel_y;\n }\n\n RocketState() = default;\n\n static int variable_size()\n {\n return STATE_SIZE;\n }\n\n static int lcn_state_size()\n {\n return 2;\n }\n\n static int control_state_size()\n {\n // i_turning_rate,\n // i_acceleration,\n return 2;\n }\n\n Eigen::Map lcn_state()\n {\n return Eigen::Map(variables.data());\n }\n\n Eigen::Map cntl_state()\n {\n return Eigen::Map(variables.data() + 2);\n }\n\n Vector2d lcn_state() const\n {\n return variables.block<2, 1>(0, 0);\n }\n\n Vector2d cntl_state() const\n {\n return variables.block<2, 1>(2, 0);\n }\n\n Eigen::Map position()\n {\n return Eigen::Map(variables.data() + i_position_x);\n }\n\n Eigen::Map velocity()\n {\n return Eigen::Map(variables.data() + i_velocity_x);\n }\n\n Vector2d velocity() const\n {\n return { variables(i_velocity_x), variables(i_velocity_y) };\n }\n\n Vector4d variables = Vector4d::Zero();\n};\n\nstruct RocketMotionModel {\n RocketState motion(const RocketState& state_in) const\n {\n auto state = state_in;\n // TODO: non-const getter\n RocketState next_state = state;\n\n next_state.velocity() = state.velocity();\n\n next_state.position()[0] = state.position()[0] + sin(state.velocity()[0]);\n next_state.position()[1] = state.position()[1] + state.velocity()[1];\n\n return next_state;\n }\n\n MatrixXd jacobian_wrt_state(const RocketState& state_in) const\n {\n using S = RocketState;\n const int residual_size = RocketState::STATE_SIZE;\n MatrixXd jacobi_wrt_s = MatrixXd::Identity(residual_size, residual_size);\n\n jacobi_wrt_s(S::i_position_x, S::i_velocity_x) = cos(state_in.velocity()[0]);\n jacobi_wrt_s(S::i_position_y, S::i_velocity_y) = 1.;\n\n return jacobi_wrt_s;\n }\n};\n\n#define PRINT_NAME_VAR(var) std::cout << #var << \" :\" << var << std::endl\n\nusing State = Vector2d;\nusing Control = Vector2d;\n\nstruct RocketLandingProblem {\n // Variables\n std::vector states = std::vector(11);\n\n // support data\n RocketState start_state = RocketState(0.1, 0.1, 0, 0);\n RocketState end_state = RocketState(2, 2, 0, 0);\n};\n\nstruct QuadraticCost {\n QuadraticCost() = default;\n\n QuadraticCost(const VectorXd& meanIn, const MatrixXd& weightIn)\n : mean(meanIn)\n , weight(weightIn)\n {\n }\n\n double eval(const VectorXd& x) const\n {\n return (x - mean).transpose() * weight * (x - mean);\n }\n\n VectorXd mean;\n MatrixXd weight;\n};\n\n// du = K1 * dx + k2\nstruct FeedbackLaw {\n FeedbackLaw() = default;\n\n FeedbackLaw(MatrixXd K1, VectorXd k2)\n : K1(K1)\n , k2(k2)\n {\n }\n\n VectorXd apply(const VectorXd& x) const\n {\n return K1 * x + k2;\n }\n\n MatrixXd K1;\n VectorXd k2;\n};\n\n// The definition of states and controls is differient from previous section.\nstruct DDPStates {\n State last_state()\n {\n return states.at(num_states - 1);\n }\n\n int num_states = 0;\n std::vector controls;\n std::vector states;\n std::vector feedbacks;\n\n State init_state;\n State target_state;\n};\n\ninline RocketState ddp_vars_to_rocket_state(const State& x, const Control& u)\n{\n RocketState rstate;\n rstate.cntl_state() = u;\n rstate.lcn_state() = x;\n return rstate;\n}\n\nclass DifferentialDynamicProgramming {\npublic:\n void solve(RocketLandingProblem& problem)\n {\n DDPStates ddp_states = initialize_ddp_state(problem);\n for (int iteration = 0; iteration < 10; ++iteration) {\n forward_pass(ddp_states);\n backward_pass(ddp_states);\n apply_control_law(ddp_states);\n }\n\n update_output(ddp_states, problem);\n }\n\nprivate:\n DDPStates initialize_ddp_state(const RocketLandingProblem& problem)\n {\n DDPStates ddp_states;\n ddp_states.num_states = problem.states.size();\n num_states_ = ddp_states.num_states;\n ddp_states.init_state = problem.start_state.lcn_state();\n ddp_states.target_state = problem.end_state.lcn_state();\n\n PRINT_NAME_VAR(ddp_states.num_states);\n PRINT_NAME_VAR(ddp_states.init_state);\n PRINT_NAME_VAR(ddp_states.target_state);\n\n ddp_states.states.resize(ddp_states.num_states);\n ddp_states.controls.resize(ddp_states.num_states - 1);\n ddp_states.feedbacks.resize(ddp_states.num_states - 1);\n\n for (int i = 0; i < ddp_states.num_states; ++i) {\n ddp_states.states.at(i) = problem.states.at(i).lcn_state();\n }\n\n for (int i = 0; i < ddp_states.num_states - 1; ++i) {\n ddp_states.controls.at(i) = problem.states.at(i).cntl_state();\n }\n\n return ddp_states;\n }\n\n void update_output(const DDPStates& ddp_states, RocketLandingProblem& problem)\n {\n for (int i = 0; i < ddp_states.num_states; ++i) {\n problem.states.at(i).lcn_state() = ddp_states.states.at(i);\n }\n\n for (int i = 0; i < ddp_states.num_states - 1; ++i) {\n problem.states.at(i).cntl_state() = ddp_states.controls.at(i);\n }\n }\n\n void forward_pass(DDPStates& ddp_states)\n {\n ddp_states.states.resize(ddp_states.num_states);\n ddp_states.controls.resize(ddp_states.num_states - 1);\n\n ddp_states.states[0] = ddp_states.init_state;\n\n RocketMotionModel motion_model;\n for (int i = 0; i < ddp_states.num_states - 1; ++i) {\n RocketState current_full_state = ddp_vars_to_rocket_state(\n ddp_states.states.at(i), ddp_states.controls.at(i));\n\n RocketState next_full_state = motion_model.motion(current_full_state);\n ddp_states.states.at(i + 1) = next_full_state.lcn_state();\n\n std::cout << \"idx forward iter: \" << i << std::endl;\n std::cout << \"control: \" << ddp_states.controls.at(i).transpose() << std::endl;\n std::cout << \"state: \" << ddp_states.states.at(i).transpose() << std::endl;\n std::cout << \"next state: \" << ddp_states.states.at(i + 1).transpose() << std::endl;\n }\n }\n\n void backward_pass(DDPStates& ddp_states)\n {\n QuadraticCost marginal_cost = target_cost(ddp_states.target_state);\n\n current_best_cost_ = std::min(current_best_cost_, marginal_cost.eval(ddp_states.last_state()));\n std::cout << \"target cost :\" << marginal_cost.eval(ddp_states.last_state()) << std::endl;\n\n for (int i = ddp_states.num_states - 2; i >= 0; --i) {\n const State cur_state = ddp_states.states.at(i);\n const Control cur_control = ddp_states.controls.at(i);\n\n solve_backward_subproblem(cur_state, cur_control, marginal_cost, ddp_states.feedbacks[i]);\n }\n }\n\n void solve_backward_subproblem(const State& cur_state,\n const Control& cur_control,\n QuadraticCost& marginal_cost,\n FeedbackLaw& feedback_law)\n {\n const int state_size = 2;\n const int control_size = 2;\n\n MatrixXd lhs;\n VectorXd rhs;\n compute_backward_subproblem_normal_equation(marginal_cost, cur_state, cur_control, lhs, rhs);\n\n MatrixXd A1 = lhs.block(0, 0, state_size, state_size);\n MatrixXd A2 = lhs.block(0, state_size, state_size, control_size);\n MatrixXd A3 = lhs.block(state_size, 0, control_size, state_size);\n MatrixXd A4 = lhs.block(state_size, state_size, control_size, control_size);\n\n VectorXd b1 = rhs.block(0, 0, state_size, 1);\n VectorXd b2 = rhs.block(state_size, 0, control_size, 1);\n\n MatrixXd A4_inv = A4.inverse();\n\n // eliminate du\n MatrixXd lhs_xi = A1 - A2 * A4_inv * A3;\n VectorXd rhs_xi = b1 - A2 * A4_inv * b2;\n\n // solve PSD system by Cholesky\n VectorXd xi_star = lhs_xi.llt().solve(rhs_xi);\n\n marginal_cost = QuadraticCost(cur_state + xi_star, lhs_xi);\n // std::cout << \"marginal_cost \\n mean:\" << marginal_cost.mean.transpose()\n // << \"\\n weight:\" << marginal_cost.weight << std::endl;\n feedback_law = FeedbackLaw(-A4_inv * A3, A4_inv * b2);\n }\n\n void compute_backward_subproblem_normal_equation(const QuadraticCost& marginal_cost,\n const State& cur_state,\n const Control& cur_control,\n MatrixXd& lhs,\n VectorXd& rhs)\n {\n const int state_size = 2;\n const int control_size = 2;\n const int total_size = state_size + control_size;\n\n RocketMotionModel motion_model;\n const RocketState rstate = ddp_vars_to_rocket_state(cur_state, cur_control);\n\n const MatrixXd jacobi_wrt_augment_state = motion_model.jacobian_wrt_state(rstate);\n MatrixXd jacobian_marginal_cost = jacobi_wrt_augment_state.block(0, 0, state_size, total_size);\n\n const RocketState predict_state = motion_model.motion(rstate);\n\n std::cout << \"rstate.var: \" << rstate.variables << std::endl;\n std::cout << \"predict_state.var:\" << predict_state.variables << std::endl;\n std::cout << \"jacobian_marginal_cost: \" << jacobian_marginal_cost << std::endl;\n\n const VectorXd residual = predict_state.lcn_state() - marginal_cost.mean;\n\n lhs = jacobian_marginal_cost.transpose() * marginal_cost.weight * jacobian_marginal_cost;\n rhs = -jacobian_marginal_cost.transpose() * marginal_cost.weight * residual;\n\n // current cost (just regularizations for this problem)\n const double time_regularization = 1e-3 / num_states_;\n lhs(RocketState::i_velocity_x, RocketState::i_velocity_x) += 2 * time_regularization;\n rhs(RocketState::i_velocity_x) += -2 * time_regularization * cur_control(RocketState::i_velocity_x - 2);\n\n lhs(RocketState::i_velocity_y, RocketState::i_velocity_y) += 2 * time_regularization;\n rhs(RocketState::i_velocity_y) += -2 * time_regularization * cur_control(RocketState::i_velocity_y - 2);\n }\n\n QuadraticCost target_cost(const Vector2d& target_state)\n {\n QuadraticCost qcost;\n qcost.mean = target_state;\n MatrixXd jacobi = MatrixXd::Identity(2, 2);\n\n MatrixXd weight = MatrixXd::Identity(2, 2);\n Vector2d weight_diag;\n // dt, x, y, vel_x, vel_y, heading\n weight_diag << 1e0, 1e0;\n weight.diagonal() = weight_diag;\n\n qcost.weight = jacobi.transpose() * weight * jacobi;\n\n return qcost;\n }\n\n void apply_control_law(DDPStates& ddp_states)\n {\n std::vector new_controls = ddp_states.controls;\n std::vector new_states = ddp_states.states;\n RocketMotionModel motion_model;\n\n double shooting_cost = std::numeric_limits::max();\n\n PRINT_NAME_VAR(shooting_cost);\n PRINT_NAME_VAR(current_best_cost_);\n\n // DDP is HARD to converge!\n double step = 0.5;\n // for (; current_best_cost_ < shooting_cost && step > 1e-4; step *= 0.5) {\n for (int i = 0; i < ddp_states.num_states - 1; ++i) {\n const FeedbackLaw& feedback = ddp_states.feedbacks.at(i);\n Vector2d delta_state = new_states.at(i) - ddp_states.states.at(i);\n if (i == 0)\n assert(delta_state.sum() == 0);\n\n Vector2d delta_control = feedback.apply(delta_state);\n\n std::cout << \"=== idex: \" << i << std::endl;\n std::cout << \"delta_state: \" << delta_state.transpose() << std::endl;\n std::cout << \"delta_control: \" << delta_control.transpose() << std::endl;\n\n new_controls.at(i) = ddp_states.controls.at(i) + step * delta_control;\n\n const RocketState new_rstate = ddp_vars_to_rocket_state(new_states.at(i), new_controls.at(i));\n new_states.at(i + 1) = motion_model.motion(new_rstate).lcn_state();\n\n std::cout << \"new_control: \" << new_controls.at(i).transpose() << std::endl;\n std::cout << \"cur_state: \" << new_states.at(i).transpose() << std::endl;\n std::cout << \"new_state: \" << new_states.at(i + 1).transpose() << std::endl;\n }\n\n QuadraticCost marginal_cost = target_cost(ddp_states.target_state);\n double cur_cost = marginal_cost.eval(new_states.back());\n shooting_cost = std::min(shooting_cost, cur_cost);\n // }\n\n current_best_cost_ = std::min(current_best_cost_, shooting_cost);\n\n std::cout << \"ddp backtracking step:\" << step << std::endl;\n std::cout << \"current_best_cost_:\" << current_best_cost_ << std::endl;\n std::cout << \"cur_cost:\" << cur_cost << std::endl;\n\n ddp_states.states = new_states;\n ddp_states.controls = new_controls;\n }\n\n // current minmum target cost. Should use total cost.\n double current_best_cost_ = std::numeric_limits::max();\n\n double num_states_ = -1;\n};\n\n// yimu@yimu-mate:~/Desktop/blog$ /usr/bin/python3 /home/yimu/Desktop/blog/yimu-blog/least_squares/ddp/ddp_optimization.py\n// initial_state: [0.1 0.1]\n// target_state: [2. 2.]\n// num_states: 11\n// final_state_end_cost: [[0.22966875]]\n// final_state_end_cost: [[0.00102592]]\n// final_state_end_cost: [[0.00737957]]\n// final_state_end_cost: [[0.00287627]]\n// final_state_end_cost: [[0.00056493]]\n// final_state_end_cost: [[6.04254466e-05]]\n// final_state_end_cost: [[1.60630207e-06]]\n// final_state_end_cost: [[8.4323494e-07]]\n// final_state_end_cost: [[1.20808104e-06]]\n// final_state_end_cost: [[6.61618857e-07]]\n// ----------------------------------\n// new_controls:\n// [array([0.19102753, 0.18981443]), array([0.19110838, 0.18991752]), array([0.19117968, 0.19001093]), array([0.19123781, 0.19009055]), array([0.19127743, 0.19015008]), array([0.19129027, 0.19017957]), array([0.19126273, 0.19016206]), array([0.19117054, 0.19006576]), array([0.19096421, 0.18982076]), array([0.19051605, 0.18921421])]\n// new_states:\n// [array([0.1, 0.1]), array([0.28986784, 0.28981443]), array([0.47981505, 0.47973195]), array([0.66983226, 0.66974288]), array([0.85990655, 0.85983343]), array([1.05001973, 1.04998351]), array([1.24014552, 1.24016308]), array([1.43024427, 1.43032515]), array([1.62025251, 1.6203909 ]), array([1.81005818, 1.81021167]), array([1.9994238 , 1.99942588])]\n\n// ./test_ddp | grep cur_cost\n// cur_cost:0.229777\n// cur_cost:0.00101972\n// cur_cost:0.00736767\n// cur_cost:0.00287048\n// cur_cost:0.000562644\n// cur_cost:5.97038e-05\n// cur_cost:1.5031e-06\n// cur_cost:9.30061e-07\n// cur_cost:1.31691e-06\n// cur_cost:7.43505e-07\n//\n// new_control: 0.190882 0.189625\n// cur_state: 0.1 0.1\n// --\n// new_control: 0.191034 0.189811\n// cur_state: 0.289725 0.289625\n// --\n// new_control: 0.191173 0.189985\n// cur_state: 0.479599 0.479436\n// --\n// new_control: 0.191293 0.190141\n// cur_state: 0.66961 0.669421\n// --\n// new_control: 0.191385 0.190269\n// cur_state: 0.859738 0.859562\n// --\n// new_control: 0.191435 0.190352\n// cur_state: 1.04996 1.04983\n// --\n// new_control: 0.191417 0.190362\n// cur_state: 1.24023 1.24018\n// --\n// new_control: 0.19128 0.190237\n// cur_state: 1.43048 1.43055\n// --\n// new_control: 0.19091 0.189834\n// cur_state: 1.62059 1.62078\n// --\n// new_control: 0.189926 0.188637\n// cur_state: 1.81034 1.81062\n// --\n// new_control: 0.191024 0.189811\n// cur_state: 0.1 0.1\n// --\n// new_control: 0.191105 0.189914\n// cur_state: 0.289864 0.289811\n// --\n// new_control: 0.191176 0.190007\n// cur_state: 0.479808 0.479725\n// --\n// new_control: 0.191234 0.190087\n// cur_state: 0.669822 0.669733\n// --\n// new_control: 0.191274 0.190147\n// cur_state: 0.859892 0.85982\n// --\n// new_control: 0.191287 0.190176\n// cur_state: 1.05 1.04997\n// --\n// new_control: 0.191259 0.190159\n// cur_state: 1.24012 1.24014\n// --\n// new_control: 0.191167 0.190062\n// cur_state: 1.43022 1.4303\n// --\n// new_control: 0.190961 0.189817\n// cur_state: 1.62022 1.62036\n// --\n// new_control: 0.190513 0.189211\n// cur_state: 1.81003 1.81018\n\nint main(int argc, char* argv[])\n{\n RocketLandingProblem p;\n\n DifferentialDynamicProgramming solver;\n solver.solve(p);\n\n return 1;\n}", "meta": {"hexsha": "3efdbff254aec3242c6a360321df81cb1467a9db", "size": 17063, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "least_squares/land_rocket/test_ddp.cpp", "max_stars_repo_name": "yimuw/yimu-blog", "max_stars_repo_head_hexsha": "280ab2eca1fa48602d1695d69366842ea40debda", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8.0, "max_stars_repo_stars_event_min_datetime": "2021-06-11T05:50:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T02:41:05.000Z", "max_issues_repo_path": "least_squares/land_rocket/test_ddp.cpp", "max_issues_repo_name": "yimuw/yimu-blog", "max_issues_repo_head_hexsha": "280ab2eca1fa48602d1695d69366842ea40debda", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 7.0, "max_issues_repo_issues_event_min_datetime": "2020-06-28T13:58:26.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-09T22:30:54.000Z", "max_forks_repo_path": "least_squares/land_rocket/test_ddp.cpp", "max_forks_repo_name": "yimuw/yimu-blog", "max_forks_repo_head_hexsha": "280ab2eca1fa48602d1695d69366842ea40debda", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2021-07-07T04:00:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T03:42:54.000Z", "avg_line_length": 32.0131332083, "max_line_length": 353, "alphanum_fraction": 0.6365234718, "num_tokens": 4899, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8558511469672594, "lm_q2_score": 0.6370307875894138, "lm_q1q2_score": 0.5452035302118564}} {"text": "/*\nMIT License\n\nCopyright (c) 2019 Xiaohong Chen\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n*/\n\n#ifndef BOOST_UBLAS_PRECONDITIONER_HPP\n#define BOOST_UBLAS_PRECONDITIONER_HPP\n\n#include \n#include \n#include \n\nnamespace boost { namespace numeric { namespace ublas {\n\ntemplate \nclass identity_precond {\npublic:\n identity_precond() {}\n identity_precond(const M&) {}\n\n template\n const vector_expression& operator()(const vector_expression& ve) const {\n return ve;\n }\n};\n\ntemplate \nclass jacobi_precond {\npublic:\n typedef typename M::value_type value_type;\n typedef typename M::size_type size_type;\n jacobi_precond(const M& A)\n : diag_(A.size1()) {\n size_type size = A.size1();\n for (size_type i = 0; i < size; ++i) {\n diag_(i) = A(i, i);\n }\n }\n\n jacobi_precond(const jacobi_precond&) = default;\n jacobi_precond(jacobi_precond&&) = default;\n jacobi_precond& operator=(const jacobi_precond&) = default;\n jacobi_precond& operator=(jacobi_precond&&) = default;\n\n template\n decltype(auto) operator()(const vector_expression& ve) const {\n return element_prod(ve, diag_);\n }\n\nprivate:\n vector diag_;\n};\n\n} // end namespace linear\n} // end namespace solver\n} // end namespace math\n\n\n#endif\n", "meta": {"hexsha": "e0d062578b436c6f319d5c8e6948b395ade2e4af", "size": 2423, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/preconditioner.hpp", "max_stars_repo_name": "xiaohongchen1991/krylov-solvers", "max_stars_repo_head_hexsha": "148d7bb4107a80c9e1771d77a0d589afb74d5744", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2020-12-29T20:51:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-16T02:46:55.000Z", "max_issues_repo_path": "include/preconditioner.hpp", "max_issues_repo_name": "xiaohongchen1991/krylov-solvers", "max_issues_repo_head_hexsha": "148d7bb4107a80c9e1771d77a0d589afb74d5744", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/preconditioner.hpp", "max_forks_repo_name": "xiaohongchen1991/krylov-solvers", "max_forks_repo_head_hexsha": "148d7bb4107a80c9e1771d77a0d589afb74d5744", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.6708860759, "max_line_length": 82, "alphanum_fraction": 0.733801073, "num_tokens": 563, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.72487026428967, "lm_q2_score": 0.7520125793176222, "lm_q1q2_score": 0.5451115571191213}} {"text": "#include \n#include \n#include \n//#include \n\nusing namespace arma;\n\nconstexpr int training_size = 4000; //m\nconstexpr int input_layer_size = 784; //k\nconstexpr int hidden_layer_size = 500; //n\nconstexpr int num_labels = 10;\n\nconstexpr double lambda = 0.1;\nconstexpr int max_iterations = 1000;\n\n\nint main () {\n//\tstd::cout << \"Starting program with \" << mkl_get_max_threads() << \" threads...\" << std::endl;\n\n\t//mkl_set_num_threads(4);\n\n mat predictions(training_size,1,fill::zeros);\n \n mat x_train(training_size,input_layer_size,fill::zeros);\n //x_train.load(\"c:\\\\train_x_4000.csv\");\n x_train.load(\"./mnist_data/train_x_4000.csv\");\n \n mat y_train(training_size,1,fill::randu);\n //y_train.load(\"c:\\\\train_y_4000.csv\");\n y_train.load(\"./mnist_data/train_y_4000.csv\");\n \n \n mat s(10000,10000,fill::randu);\n mat t(10000,10000,fill::randu);\n mat u(10000,10000,fill::zeros);\n \n \n\twall_clock timer;\n\ttimer.tic(); \n u = s * t;\n double n = timer.toc();\n\tstd::cout << \"10k x 10k matrix multiplication completed in: \" << n << \" seconds.\" << endl;\n pause();\n \n \n ////calculate mean of the training data\n //double x_mean = sum(sum(x_train));\n //x_mean /= x_train.n_elem; //33.5026 TODO: check this\n //\n ////calculate standard devication of the training data\n //mat x_train_mean(training_size,input_layer_size);\n //x_train_mean = x_train;\n //x_train_mean.transform( [x_mean](double val){return (val - x_mean);} );\n //double x_std = sum(sum(x_train_mean));\n //x_std /= (x_train_mean.n_elem);\n //x_std = std::sqrt(x_std); //7.23942e-06 TODO: check this\n\n\tx_train = x_train / 255.0;\n\t//x_train.transform([](double val){return (val/255.0); });\n\t//std::cout << x_train.row(0) << endl;\n\n \n\tmat initial_theta1(hidden_layer_size, input_layer_size + 1, fill::ones); //784 26 n k+1\n\t//initial_theta1.load(\"c:\\\\theta1.csv\");\n\tinitial_theta1.load(\"./mnist_data/theta1.csv\");\n\tmat initial_theta2(num_labels, hidden_layer_size + 1, fill::ones); //25 11 numlabels n+1\n\t//initial_theta2.load(\"c:\\\\theta2.csv\");\n\tinitial_theta2.load(\"./mnist_data/theta2.csv\");\n\n\tinitial_theta1.reshape(hidden_layer_size*(input_layer_size + 1),1);\n\tinitial_theta2.reshape(num_labels*(hidden_layer_size + 1),1);\n \n mat combined_theta = join_cols(initial_theta1,initial_theta2);\n //std::cout << \"combined_theta rows: \" << combined_theta.n_rows << \", cols: \" << combined_theta.n_cols << endl;\n \n\t//test section----------------------\n\tmat gradient1 = combined_theta;\n\tdouble cost=0.0;\n\t\n\n\t //costfunction(cost, gradient1, combined_theta, input_layer_size, hidden_layer_size, num_labels, x_train, y_train, lambda);\n\t fmincg(cost, max_iterations,combined_theta,input_layer_size,hidden_layer_size,num_labels,x_train,y_train,lambda);\n\n //----------------------------------\n\t\n\n\tstd::cout << \"Final cost: \" << cost << endl;\n \n initial_theta1 = combined_theta.submat(0, 0, initial_theta1.n_cols-1, 0);\n\tinitial_theta1.reshape(hidden_layer_size, input_layer_size + 1);\n //std::cout << \"initial_theta1 rows: \" << initial_theta1.n_rows << \", cols: \" << initial_theta1.n_cols << endl;\n \n initial_theta2 = combined_theta.submat(initial_theta1.n_cols, 0,initial_theta1.n_cols+initial_theta2.n_cols-1, 0);\n\tinitial_theta2.reshape(num_labels, hidden_layer_size + 1);\n //std::cout << \"initial_theta2 rows: \" << initial_theta2.n_rows << \", cols: \" << initial_theta2.n_cols << endl;\n \n predict(initial_theta1,initial_theta2,x_train,predictions);\n \n //std::cout << \"predictions: \" << predictions.row(0) << endl;\n\n\n\n\t//pauseJNS();\n \n return 0;\n}\n\n\n\n\n// real function costandgradient(gradient, nn_params,input_layer_size,hidden_layer_size,num_labels, inputdata, y, lambda)\n\n// real, allocatable :: inputdata(:,:), X(:,:), y(:,:), y_representative(:,:), gradient(:,:), ones(:,:)\n// real, allocatable :: a_1(:,:),z_2(:,:),a_2(:,:),z_3(:,:),a_3(:,:),hofx(:,:)\n// real, allocatable :: delta_2(:,:), temp_delta_2(:,:), delta_3(:,:), gradient_1(:,:), gradient_2(:,:)\n// real, allocatable :: Theta1_grad(:,:), Theta2_grad(:,:)\n// integer :: input_layer_size,hidden_layer_size,num_labels,m,l,K,i\n// integer :: a1,a2,b1,b2,c1,c2\n// real :: lambda, temp, J\n// real, allocatable :: nn_params(:,:), Theta1(:,:), Theta2(:,:), temptheta1(:,:),temptheta2(:,:)\n// real, allocatable :: a_2_ones(:,:), summation(:,:), summation2(:,:), summation3(:,:),z_2_ones(:,:), sigmoid_z_2(:,:)\n \n// real :: timer1, timer2, holder1, holder2\n// double precision :: average1 = 0.0\n// double precision :: average2 = 0.0\n// double precision :: average3 = 0.0\n// double precision :: counter = 0.0\n \n \n \n// m = size(inputdata,1)\n// l = size(y,1)\n// K = num_labels\n\n// allocate(Theta1(1:hidden_layer_size,1:(input_layer_size+1)))\n// allocate(Theta2(1:num_labels,1:(hidden_layer_size+1)))\n// allocate(ones(m,1))\n// allocate(X(size(inputdata,1),(size(inputdata,2)+1))) \n// allocate(y_representative(l,num_labels)) \n// allocate(z_2(m,hidden_layer_size))\n// allocate(a_1(size(X,1),size(X,2)))\n// allocate(a_2(size(z_2,1),size(z_2,2))) \n// allocate(a_2_ones(size(a_2,1),(size(a_2,2)+1))) \n// allocate(z_3(size(a_2_ones,1),size(Theta2,1))) !a_2 * Theta2' \n// allocate(temptheta2(size(Theta2,2),size(Theta2,1))) \n// allocate(a_3(size(z_3,1),size(z_3,2))) \n// allocate(summation(size(z_3,1),size(z_3,2)))\n// allocate(summation2(size(z_3,1),size(z_3,2)))\n// allocate(summation3(size(z_3,1),size(z_3,2)))\n// allocate(delta_3(size(a_3,1),size(a_3,2))) \n// allocate(z_2_ones(size(z_2,1),(size(z_2,2)+1))) \n// allocate(sigmoid_z_2(size(z_2_ones,1),size(z_2_ones,2))) \n// allocate(temp_delta_2(size(delta_3,1),size(Theta2,2))) \n// allocate(delta_2(size(temp_delta_2,1),size(sigmoid_z_2,2)))\n// allocate(gradient_2(size(delta_3,2),size(a_2_ones,2))) \n// allocate(gradient_1(size(delta_2,2)-1,size(a_1,2)))\n// allocate(Theta2_grad(1:size(gradient_2),1))\n// allocate(Theta1_grad(1:size(gradient_1),1)) \n \n// allocate(temptheta1(size(Theta1,2),size(Theta1,1))) \n \n\n// Theta1 = reshape(nn_params(1:hidden_layer_size*(input_layer_size + 1),1), (/ hidden_layer_size, (input_layer_size + 1) /))\n// Theta2 = reshape(nn_params((1+hidden_layer_size*(input_layer_size + 1)):,1), (/ num_labels, (hidden_layer_size + 1) /))\n \n// !print *,shape(Theta1) !500 x 785\n// !print *,shape(Theta2) !10 x 501\n \n \n// ones = 1.0\n\n\n\n \n// !timer1=secnds(0.0)\n\n\n// do i=1,m\n// temp = y(i,1)\n// do j=1,K\n// if(temp == j)then\n// y_representative(i,j) = 1\n// else\n// y_representative(i,j) = 0\n// end if\n// end do\n// end do\n\n// X(:,1:1) = ones\n// X(:,2:) = inputdata \n// a_1 = X\n\n// z_2 = 0.0\n \n// call matrix_multiply(a_1,0,Theta1,1,z_2)\n\n\n// a_2 = 0.0\n// call sigmoid(z_2,a_2)\n\n \n// a_2_ones(:,1:1) = ones\n// a_2_ones(:,2:) = a_2\n \n// z_3 = 0.0\n// call matrix_multiply(a_2_ones,0,Theta2,1,z_3)\n \n// call sigmoid(z_3,a_3)\n\n// summation = 0.0\n// summation = -y_representative * log(a_3) - (1 - y_representative) * log(1 - a_3)\n \n// J = sum(summation)\n// J = J / m\n \n \n\n \n// !do concurrent (i = 1:size(delta_3,1))\n// ! delta_3(i,:) = a_3(i,:) - y(1,:)\n// !end do\n \n// delta_3 = a_3 - y_representative\n\n// z_2_ones(:,1:1) = ones\n// z_2_ones(:,2:) = z_2 \n \n\n// sigmoid_z_2 = 0.0\n \n \n// call sigmoidgradient(z_2_ones,sigmoid_z_2) \n\n\n// !temp_delta_2 = matmul(delta_3,Theta2)\n\n// !timer1=secnds(0.0) \n// !a1 = size(delta_3,1)\n// !a2 = size(delta_3,2)\n// !b1 = size(Theta2,1)\n// !b2 = size(Theta2,2)\n// !call sGEMM('N','N',a1,b2,b1,1.0,delta_3,a1,Theta2,b1,0.0,temp_delta_2,a1)\n// call matrix_multiply(delta_3,0,Theta2,0,temp_delta_2)\n// !timer2=secnds(timer1)\n// !average1 = average1 + timer2\n// !counter = counter + 1\n// !print '(a, f8.4)','matrix_multiply timer: ', average1/counter \n \n// delta_2 =0.0\n// !delta_2 = temp_delta_2 * sigmoid_z_2 !elemental multiplication\n// call vsMul( size(temp_delta_2), temp_delta_2, sigmoid_z_2, delta_2 ) !elemental multiplication \n\n \n// gradient_2 = 0.0\n// gradient_1 = 0.0\n \n// call matrix_multiply(delta_3,1,a_2_ones,0,gradient_2)\n \n// call matrix_multiply(delta_2(:,2:),1,a_1,0,gradient_1) \n \n// gradient_2 = gradient_2 / m\n// gradient_1 = gradient_1 / m\n \n// gradient_2(:,2:) = gradient_2(:,2:) + Theta2(:,2:) * (lambda / m)\n// gradient_1(:,2:) = gradient_1(:,2:) + Theta1(:,2:) * (lambda / m)\n\n\n// Theta2_grad = reshape(gradient_2, (/size(gradient_2),1/))\n// Theta1_grad = reshape(gradient_1, (/size(gradient_1),1/))\n\n// gradient(1:size(Theta1_grad),1:1) = Theta1_grad\n// gradient((size(Theta1_grad)+1):,1:1) = Theta2_grad\n \n// costandgradient = J\n \n \n// !print '(f8.4, a, f8.4)',average1/counter,' ',average2/counter\n// !timer2=secnds(timer1)\n// !average = average*0.9 + timer2*0.1\n// !print '(a, f8.4)','costandgradient timer: ', timer2\n// end function costandgradient", "meta": {"hexsha": "5b6d92345a8562e38e88fbf10727d9652f6c56fb", "size": 10062, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/main.cpp", "max_stars_repo_name": "jshahbazi/mnist-cpp", "max_stars_repo_head_hexsha": "d757d07c03b2c24df94af4c0762b99db21c21538", "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/main.cpp", "max_issues_repo_name": "jshahbazi/mnist-cpp", "max_issues_repo_head_hexsha": "d757d07c03b2c24df94af4c0762b99db21c21538", "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/main.cpp", "max_forks_repo_name": "jshahbazi/mnist-cpp", "max_forks_repo_head_hexsha": "d757d07c03b2c24df94af4c0762b99db21c21538", "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": 35.8078291815, "max_line_length": 133, "alphanum_fraction": 0.5699662095, "num_tokens": 3040, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972751232809, "lm_q2_score": 0.6261241842048093, "lm_q1q2_score": 0.5451020086574941}} {"text": "#ifndef UTILITIES\n#define UTILITIES\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"gsl/gsl_sf_gamma.h\"\n#include \"gsl/gsl_sf_result.h\"\n#include \"gsl/gsl_complex_math.h\"\n\nnamespace utilities {\n using namespace boost::numeric::ublas;\n\n const double PI = 3.14159265359;\n const double C = 299792458;//m/s\n const double EMASSC2 = 510.9989461;//keV\n const double PMASSC2 = 938272.046;//keV\n const double NMASSC2 = 939565.4133;//keV\n const double ALPHAMASSC2 = 3727379.508;//keV\n const double FINESTRUCTURE = 0.0072973525664;\n const double E = 2.718281828459045;\n const double HBAR = 6.58211889e-16;//ev*s\n const double a_CORR = -1.0;\n\n const std::string atoms[] = {\"H\", \"He\", \"Li\", \"Be\", \"B\", \"C\", \"N\", \"O\", \"F\", \"Ne\", \"Na\", \"Mg\", \"Al\", \"Si\", \"P\", \"S\", \"Cl\", \"Ar\", \"K\", \"Ca\", \"Sc\", \"Ti\", \"V\", \"Cr\", \"Mn\", \"Fe\", \"Co\", \"Ni\", \"Cu\", \"Zn\", \"Ga\", \"Ge\", \"As\", \"Se\", \"Br\", \"Kr\", \"Rb\", \"Sr\", \"Y\", \"Zr\", \"Nb\", \"Mo\", \"Tc\", \"Ru\", \"Rh\", \"Pd\", \"Ag\", \"Cd\", \"In\", \"Sn\", \"Sb\", \"Te\", \"I\", \"Xe\", \"Cs\", \"Ba\", \"La\", \"Ce\", \"Pr\", \"Nd\", \"Pm\", \"Sm\", \"Eu\", \"Gd\", \"Tb\", \"Dy\", \"Ho\", \"Er\", \"Tm\", \"Yb\", \"Lu\", \"Hf\", \"Ta\", \"W\", \"Re\", \"Os\", \"Ir\", \"Pt\", \"Au\", \"Hg\", \"Tl\", \"Pb\", \"Bi\", \"Po\", \"At\", \"Rn\", \"Fr\", \"Ra\", \"Ac\", \"Th\", \"Pa\", \"U\", \"Np\", \"Pu\", \"Am\", \"Cm\", \"Bk\", \"Cf\", \"Es\", \"Fm\", \"Md\", \"No\", \"Lr\", \"Rf\", \"Db\", \"Sg\", \"Bh\", \"Hs\", \"Mt\"};\n\n inline vector RandomDirection () {\n double z, phi;\n vector v(3);\n\n z = rand() / (double)RAND_MAX * 2. - 1.;\n phi = rand() / (double)RAND_MAX * 2. * PI;\n\n v(0) = std::sqrt(1.-z*z)*std::cos(phi);\n v(1) = std::sqrt(1.-z*z)*std::sin(phi);\n v(2) = z;\n\n return v;\n };\n\n inline double Random(double begin, double end) { return rand() / (double)RAND_MAX * (end - begin) + begin; };\n\n inline double RandomFromDistribution(std::vector >& pd) {\n double begin = pd[0][0];\n double end = pd[pd.size()-1][0];\n double stepSize = pd[1][0] - pd[0][0];\n double max = 0.;\n\n for (std::vector >::size_type i = 0; i != pd.size(); i++) {\n if (pd[i][1] > max) {\n max = pd[i][1];\n }\n }\n\n double r = 0.;\n double q = 0.;\n do {\n r = rand() / (double)RAND_MAX;\n q = rand() / (double)RAND_MAX * max;\n } while (q > pd[r*pd.size()][1]);\n return r*(end - begin) + begin;\n }\n\n inline double GetSpeed(double energy, double massc2) {\n double gamma = energy/massc2 + 1.;\n return std::sqrt(1.-1./(gamma*gamma))*C;\n }\n\n inline double GetNorm(const vector& v) {\n double sum = 0.;\n for (vector::size_type i = 0; i != v.size(); i++) {\n sum+=v[i]*v[i];\n }\n return std::sqrt(sum);\n }\n\n inline double FourDimDot(vector& a, vector& b) {\n //Mostly minus convention\n return a[0]*b[0]-(a[1]*b[1]+a[2]*b[2]+a[3]*b[3]);\n }\n\n inline double CalculateXiBetaDecay(double& cs, double& ct, double& cv, double& ca, double& mf, double& mgt) {\n return mf*mf*(2.*cs*cs+2.*cv*cv)+mgt*mgt*(2.*ct*ct+2.*ca*ca);\n }\n\n inline double CalculateBetaNeutrinoAsymmetry(double cs, double ct, double cv, double ca, double mf, double mgt) {\n return (mf*mf*(-2.*cs*cs+2.*cv*cv)+mgt*mgt/3.*(2.*ct*ct-2.*ca*ca))/CalculateXiBetaDecay(cs, ct, cv, ca, mf, mgt);\n }\n\n inline vector NormaliseVector(const vector& v) {\n vector newV (v);\n double norm = GetNorm(v);\n if (norm != 0) {\n return newV/norm;\n }\n return v;\n }\n\n inline double LambdaKinematic(double x, double y, double z) {\n return x*x+y*y+z*z-2*x*y-2*y*z-2*x*z;\n }\n\n inline double PhaseSpace(double W, double W0) {\n return std::sqrt(W*W-1.)*W*std::pow(W0-W, 2.);\n }\n\n inline double SimpleFermiFunction(double Z, double v) {\n double nu = Z*FINESTRUCTURE/v*C;\n return 2.*PI*nu/(1.-std::pow(E, -2.*PI*nu));\n }\n\n inline double FermiFunction(double Z, double W, double R) {\n double gamma = std::sqrt(1.-(FINESTRUCTURE*Z)*(FINESTRUCTURE*Z));\n double p = std::sqrt(W*W-1);\n double first = 2*(gamma+1);\n //the second term will be incorporated in the fifth\n //double second = 1/pow(gsl_sf_gamma(2*gamma+1),2);\n double third = std::pow(2*p*R,2*(gamma-1));\n double fourth = std::exp(M_PI*FINESTRUCTURE*Z*W/p);\n\n //the fifth is a bit tricky\n //we use the complex gamma function from GSL\n gsl_sf_result magn;\n gsl_sf_result phase;\n gsl_sf_lngamma_complex_e(gamma, FINESTRUCTURE*Z*W/p,&magn,&phase);\n //now we have what we want in magn.val\n\n //but we incorporate the second term here as well\n double fifth = std::exp(2*(magn.val-gsl_sf_lngamma(2*gamma+1)));\n\n return first*third*fourth*fifth;\n }\n\n inline double ApproximateRadius(double A) {\n return (1.15+1.8*std::pow(A, -2./3.)-1.2*std::pow(A, -4./3.))*EMASSC2*1000./HBAR/C*std::pow(A, 1./3.);\n }\n\n inline double GetSpectrumHeight(double Z, double A, double Q, double E, bool advancedFermi) {\n double W = E/EMASSC2+1.;\n double W0 = Q/EMASSC2+1.;\n double R = ApproximateRadius(A);\n if (advancedFermi) {\n return PhaseSpace(W, W0)*FermiFunction(Z, W, R);\n }\n else {\n return PhaseSpace(W, W0)*SimpleFermiFunction(Z, GetSpeed(E, EMASSC2));\n }\n }\n\n inline std::vector >* GenerateBetaSpectrum(double Z, double A, double Q, bool advancedFermi) {\n std::vector >* dist = new std::vector >();\n double stepSize = 1.0;\n\n double currentEnergy = stepSize;\n while(currentEnergy <= Q) {\n double s = GetSpectrumHeight(Z, A, Q, currentEnergy, advancedFermi);\n std::vector pair;\n pair.push_back(currentEnergy);\n pair.push_back(s);\n dist->push_back(pair);\n currentEnergy+=stepSize;\n }\n return dist;\n }\n\n inline vector CrossProduct(vector first, vector second) {\n vector v (3);\n\n v(0) = first(1)*second(2) - first(2)*second(1);\n v(1) = first(2)*second(0) - first(0)*second(2);\n v(2) = first(0)*second(1) - first(1)*second(0);\n\n return v;\n }\n\n inline vector RotateAroundVector(vector& initial, vector& axis, double angle) {\n vector vect(3);\n double u = axis[0];\n double v = axis[1];\n double w = axis[2];\n double x = initial[0];\n double y = initial[1];\n double z = initial[2];\n\n double c = std::cos(angle);\n double s = std::sin(angle);\n\n vect(0) = u*(u*x+v*y+w*z)*(1.-c)+x*c+(-w*y+v*z)*s;\n vect(1) = v*(u*x+v*y+w*z)*(1.-c)+y*c+(w*x-u*z)*s;\n vect(2) = w*(u*x+v*y+w*z)*(1.-c)+z*c+(-v*x+u*y)*s;\n\n return vect;\n }\n\n inline vector GetParticleDirection(vector& dir2, std::vector& A) {\n dir2 = NormaliseVector(dir2);\n\n std::vector > dist;\n double stepSize = PI/180;\n double currentAngle = 0.;\n\n while (currentAngle <= PI) {\n std::vector pair;\n pair.push_back(currentAngle);\n double W = 0.;\n for (std::vector::size_type i = 0; i != A.size(); i++) {\n W+=A[i]*boost::math::legendre_p(i, std::cos(currentAngle));\n }\n pair.push_back(W);\n dist.push_back(pair);\n currentAngle+=stepSize;\n }\n\n double theta = 1.-RandomFromDistribution(dist)/PI;\n theta = std::acos(2*theta-1.);\n //std::cout << theta;\n vector perp = CrossProduct(dir2, RandomDirection());\n vector dir = RotateAroundVector(dir2, perp, theta);\n return dir;\n }\n\n inline vector GetParticleDirection(std::vector >& dirs, std::vector >& A) {\n vector dir (3);\n //TODO\n return dir;\n }\n\n inline vector LorentzBoost(vector& velocity, vector& v) {\n double speed = GetNorm(velocity);\n double beta = speed;\n double gamma = 1./std::sqrt(1.-std::pow(speed, 2.));\n\n vector dir = NormaliseVector(velocity);\n\n symmetric_matrix boost(4,4);\n boost(0, 0) = gamma;\n boost(0, 1) = -gamma*beta*dir[0];\n boost(0, 2) = -gamma*beta*dir[1];\n boost(0, 3) = -gamma*beta*dir[2];\n boost(1, 1) = 1.+(gamma-1.)*dir[0]*dir[0];\n boost(1, 2) = (gamma-1.)*dir[0]*dir[1];\n boost(1, 3) = (gamma-1.)*dir[0]*dir[2];\n boost(2, 2) = 1.+(gamma-1.)*dir[1]*dir[1];\n boost(2, 3) = (gamma-1.)*dir[1]*dir[2];\n boost(3, 3) = 1.+(gamma-1.)*dir[2]*dir[2];\n\n return prod(boost, v);\n }\n\n inline double GetApproximateMass(int Z, int A) {\n double b = 15.5*A-16.8*std::pow(A, 2.0/3.0)- 0.72*Z*(Z-1)*std::pow(A, -1.0/3.0) - 23.*std::pow(A-2*Z, 2.)/A;\n if (A%2 == 0) {\n double asym = 34.*std::pow(A, -3.0/4.0);\n if (Z%2 == 0) {\n b+=asym;\n }\n else {\n b-=asym;\n }\n }\n return Z*PMASSC2+(A-Z)*NMASSC2-b;\n }\n\n inline std::vector > ReadDistribution(const char * filename) {\n std::ifstream distReader(filename, std::ifstream::in);\n\n if (!distReader.is_open()) {\n std::cout << \"Error: Could not find file \" << filename << std::endl;\n }\n std::vector > dist;\n\n double x, y;\n while (distReader >> x >> y) {\n std::vector pair;\n pair.push_back(x);\n pair.push_back(y);\n dist.push_back(pair);\n }\n return dist;\n }\n}\n#endif\n", "meta": {"hexsha": "5dc45430aeee85d60feef3c2ae4f1933957f90dc", "size": 9584, "ext": "hh", "lang": "C++", "max_stars_repo_path": "source/include/Utilities.hh", "max_stars_repo_name": "leenderthayen/CRADLE", "max_stars_repo_head_hexsha": "8b7979a201c6d95abbc00cf44159b8fa577a17f5", "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": "source/include/Utilities.hh", "max_issues_repo_name": "leenderthayen/CRADLE", "max_issues_repo_head_hexsha": "8b7979a201c6d95abbc00cf44159b8fa577a17f5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2019-04-22T13:07:52.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-13T04:49:09.000Z", "max_forks_repo_path": "source/include/Utilities.hh", "max_forks_repo_name": "leenderthayen/CRADLE", "max_forks_repo_head_hexsha": "8b7979a201c6d95abbc00cf44159b8fa577a17f5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-06-13T19:03:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-13T19:03:55.000Z", "avg_line_length": 32.4881355932, "max_line_length": 671, "alphanum_fraction": 0.5914023372, "num_tokens": 3305, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970654616712, "lm_q2_score": 0.6187804478040617, "lm_q1q2_score": 0.5450200025908764}} {"text": "// TRENTO: Reduced Thickness Event-by-event Nuclear Topology\n// Copyright 2015 Jonah E. Bernhard, J. Scott Moreland\n// MIT License\n\n#include \"event.h\"\n\n#include \n#include \n#include \n\n#include \n\n#include \"nucleus.h\"\n\nnamespace trento {\n\nnamespace {\n\ntypedef std::complex complex_t;\n\nconstexpr double TINY = 1e-12;\n\n// Generalized mean for p > 0.\n// M_p(a, b) = (1/2*(a^p + b^p))^(1/p)\ninline double positive_pmean(double p, double a, double b) {\n return std::pow(.5*(std::pow(a, p) + std::pow(b, p)), 1./p);\n}\n\n// Generalized mean for p < 0.\n// Same as the positive version, except prevents division by zero.\ninline double negative_pmean(double p, double a, double b) {\n if (a < TINY || b < TINY)\n return 0.;\n return positive_pmean(p, a, b);\n}\n\n// Generalized mean for p == 0.\ninline double geometric_mean(double a, double b) {\n return std::sqrt(a*b);\n}\n\ninline int get_max_eccentricity_m(const std::vector& quantities) {\n int max_m = -1;\n bool foundmn = false;\n\n for (auto qty : quantities) {\n if (EventQuantity_GetClass(qty) == EventEpsilon_mn ||\n EventQuantity_GetClass(qty) == EventEpsilonArg_mn)\n {\n int m = EventQuantity_GetSubscript1(qty);\n int n = EventQuantity_GetSubscript2(qty);\n\n max_m = std::max(max_m, m);\n foundmn = (foundmn || (m != n));\n }\n }\n\n return (foundmn ? max_m : -1);\n}\n\ninline int get_max_eccentricity_n(const std::vector& quantities) {\n int max_n = -1;\n\n for (auto qty : quantities) {\n if (EventQuantity_GetClass(qty) == EventEpsilon_mn ||\n EventQuantity_GetClass(qty) == EventEpsilonArg_mn)\n {\n int n = EventQuantity_GetSubscript2(qty);\n max_n = std::max(max_n, n);\n }\n }\n\n return max_n;\n}\n\n} // unnamed namespace\n\nEvent::Event(const VarMap& var_map) // this constructor assumes that only quantities being displayed need to\n : Event(var_map, var_map[\"columns\"].as().values) // be computed; retained for code compatibility but should not be used\n{ }\n\n// Determine the grid parameters like so:\n// 1. Read and set step size from the configuration.\n// 2. Read grid max from the config, then set the number of steps as\n// nsteps = ceil(2*max/step).\n// 3. Set the actual grid max as max = nsteps*step/2. Hence if the step size\n// does not evenly divide the config max, the actual max will be marginally\n// larger (by at most one step size).\nEvent::Event(\n const VarMap& var_map,\n const std::vector& required_quantities)\n : norm_(var_map[\"normalization\"].as()),\n dxy_(var_map[\"grid-step\"].as()),\n nsteps_(std::ceil(2.*var_map[\"grid-max\"].as()/dxy_)),\n xymax_(.5*nsteps_*dxy_),\n TA_(boost::extents[nsteps_][nsteps_]),\n TB_(boost::extents[nsteps_][nsteps_]),\n TR_(boost::extents[nsteps_][nsteps_]),\n max_eccentricity_m_(get_max_eccentricity_m(required_quantities)),\n max_eccentricity_n_(get_max_eccentricity_n(required_quantities)) {\n // Choose which version of the generalized mean to use based on the\n // configuration. The possibilities are defined above. See the header for\n // more information.\n auto p = var_map[\"reduced-thickness\"].as();\n\n if (std::fabs(p) < TINY) {\n compute_reduced_thickness_ = [this]() {\n compute_reduced_thickness(geometric_mean);\n };\n } else if (p > 0.) {\n compute_reduced_thickness_ = [this, p]() {\n compute_reduced_thickness(\n [p](double a, double b) { return positive_pmean(p, a, b); });\n };\n } else {\n compute_reduced_thickness_ = [this, p]() {\n compute_reduced_thickness(\n [p](double a, double b) { return negative_pmean(p, a, b); });\n };\n }\n}\n\nvoid Event::compute(const Nucleus& nucleusA, const Nucleus& nucleusB,\n const NucleonCommon& nucleon_common) {\n // Reset npart; compute_nuclear_thickness() increments it.\n npart_ = 0;\n compute_nuclear_thickness(nucleusA, nucleon_common, TA_);\n compute_nuclear_thickness(nucleusB, nucleon_common, TB_);\n compute_reduced_thickness_();\n compute_observables();\n\n failuresA_ = nucleusA.failures();\n failuresB_ = nucleusB.failures();\n}\n\nnamespace {\n\n// Limit a value to a range.\n// Used below to constrain grid indices.\ntemplate \ninline const T& clip(const T& value, const T& min, const T& max) {\n if (value < min)\n return min;\n if (value > max)\n return max;\n return value;\n}\n\n} // unnamed namespace\n\nvoid Event::compute_nuclear_thickness(\n const Nucleus& nucleus, const NucleonCommon& nucleon_common, Grid& TX) {\n // Construct the thickness grid by looping over participants and adding each\n // to a small subgrid within its radius. Compared to the other possibility\n // (grid cells as the outer loop and participants as the inner loop), this\n // reduces the number of required distance-squared calculations by a factor of\n // ~20 (depending on the nucleon size). The Event unit test verifies that the\n // two methods agree.\n\n // Wipe grid with zeros.\n std::fill(TX.origin(), TX.origin() + TX.num_elements(), 0.);\n\n // Deposit each participant onto the grid.\n for (const auto& nucleon : nucleus) {\n if (!nucleon.is_participant())\n continue;\n\n ++npart_;\n\n // Get nucleon subgrid boundary {xmin, xmax, ymin, ymax}.\n const auto boundary = nucleon_common.boundary(nucleon);\n\n // Determine min & max indices of nucleon subgrid.\n int ixmin = clip(static_cast((boundary[0]+xymax_)/dxy_), 0, nsteps_-1);\n int ixmax = clip(static_cast((boundary[1]+xymax_)/dxy_), 0, nsteps_-1);\n int iymin = clip(static_cast((boundary[2]+xymax_)/dxy_), 0, nsteps_-1);\n int iymax = clip(static_cast((boundary[3]+xymax_)/dxy_), 0, nsteps_-1);\n\n // Add profile to grid.\n for (auto iy = iymin; iy <= iymax; ++iy) {\n for (auto ix = ixmin; ix <= ixmax; ++ix) {\n TX[iy][ix] += nucleon_common.thickness(\n nucleon, (ix+.5)*dxy_ - xymax_, (iy+.5)*dxy_ - xymax_\n );\n }\n }\n }\n}\n\ntemplate \nvoid Event::compute_reduced_thickness(GenMean gen_mean) {\n double sum = 0.;\n double ixcm = 0.;\n double iycm = 0.;\n\n for (int iy = 0; iy < nsteps_; ++iy) {\n for (int ix = 0; ix < nsteps_; ++ix) {\n auto t = norm_ * gen_mean(TA_[iy][ix], TB_[iy][ix]);\n TR_[iy][ix] = t;\n sum += t;\n // Center of mass grid indices.\n // No need to multiply by dxy since it would be canceled later.\n ixcm += t * static_cast(ix);\n iycm += t * static_cast(iy);\n }\n }\n\n multiplicity_ = dxy_ * dxy_ * sum;\n ixcm_ = ixcm / sum;\n iycm_ = iycm / sum;\n}\n\nvoid Event::compute_en(int max_n) {\n // Compute eccentricity.\n if (max_n < MinEccentricityHarmonic || max_n > MaxEccentricityHarmonic)\n throw std::invalid_argument{\"max_n\"};\n\n // Simple helper class for use in the following loop.\n struct EccentricityAccumulator {\n complex_t z = 0.;\n double wt = 0.; // weight\n double finish() const // compute final eccentricity\n { return std::abs(z) / std::fmax(wt, TINY); }\n double arg() const\n { return std::arg(z); }\n } en[NumEccentricityHarmonics];\n\n for (int iy = 0; iy < nsteps_; ++iy) {\n auto y = static_cast(iy) - iycm_;\n auto y2 = y*y;\n\n for (int ix = 0; ix < nsteps_; ++ix) {\n const auto& t = TR_[iy][ix];\n if (t < TINY)\n continue;\n\n // Compute `r` relative to the CM.\n auto x = static_cast(ix) - ixcm_;\n auto r = std::sqrt(x*x + y2);\n\n // The eccentricity harmonics are weighted averages of r^n*exp(i*n*phi)\n // over the entropy profile (reduced thickness). Note that:\n //\n // r^n * exp(i*n*phi) = r^n * exp(i*phi)^n\n // = (r*exp(i*phi))^n\n // = (x + i*y)^n\n //\n // The Event unit test verifies that this method agrees with the\n // trigonometric function method.\n auto z = complex_t{x, y};\n auto enz = t * z;\n auto enwt = t * r;\n\n for (int i = MinEccentricityHarmonic; i <= max_n; ++i) {\n en[i - MinEccentricityHarmonic].z += (enz *= z);\n en[i - MinEccentricityHarmonic].wt += (enwt *= r);\n }\n }\n }\n\n for (int n = MinEccentricityHarmonic; n <= max_n; ++n) {\n eccentricity_[n] = eccentricity_mn_[std::make_pair(n,n)] = en[n - MinEccentricityHarmonic].finish();\n eccentricity_mn_arg_[std::make_pair(n,n)] = en[n - MinEccentricityHarmonic].arg();\n }\n}\n\nvoid Event::compute_emn(int max_m, int max_n) {\n // Compute eccentricity.\n if (max_m < MinEccentricityHarmonic || max_m > MaxEccentricityHarmonic)\n throw std::invalid_argument{\"max_m\"};\n\n if (max_n < MinEccentricityHarmonic || max_n > MaxEccentricityHarmonic)\n throw std::invalid_argument{\"max_n\"};\n\n // Simple helper class for use in the following loop.\n complex_t emn[NumEccentricityHarmonics][NumEccentricityHarmonics] = { }; // important: initializes to zeroes\n double weights[NumEccentricityHarmonics] = { };\n\n for (int iy = 0; iy < nsteps_; ++iy) {\n auto y = static_cast(iy) - iycm_;\n auto y2 = y*y;\n\n for (int ix = 0; ix < nsteps_; ++ix) {\n const auto& t = TR_[iy][ix];\n if (t < TINY)\n continue;\n\n // Compute `r` relative to the CM.\n auto x = static_cast(ix) - ixcm_;\n auto r = std::sqrt(x*x + y2);\n\n auto wt = t * r; // initialize to `(t * r)` and multiply `r` again at top of `m` loop, since `m` starts at 2\n for (int m = MinEccentricityHarmonic; m <= max_m; ++m) // (note: `MinEccentricityHarmonic = 2` assumed)\n weights[m - MinEccentricityHarmonic] += (wt *= r);\n\n // The eccentricity harmonics are weighted averages of `r^m*exp(i*n*phi)`\n // over the entropy profile (reduced thickness). Note that:\n //\n // r^m * exp(i*n*phi) = r^m * exp(i*phi)^n\n // = r^(m-n) * (r*exp(i*phi))^n\n // = r^(m-n) * (x + i*y)^n\n //\n auto z = complex_t{x, y};\n auto zfactor = t * z; // initialize to `(t * z)` and multiply `z` again at top of `n` loop, since `n` starts at 2\n\n for (int n = MinEccentricityHarmonic; n <= MaxEccentricityHarmonic; n++) { // (note: `MinEccentricityHarmonic = 2` assumed)\n zfactor *= z;\n\n double rfactor;\n\n if (r > TINY) { // ignore this pixel if `r ~ 0` here; it would be nugatory in an integral but causes problems for our sum\n rfactor = 1.; // initialize to 1 and divide `r` at top of `m` loop, since `(m - n)` starts at -1 and counts down\n\n for (int m = n - 1; m >= MinEccentricityHarmonic; --m) {\n rfactor /= r;\n emn[m - MinEccentricityHarmonic][n - MinEccentricityHarmonic] += rfactor * zfactor;\n }\n\n rfactor = 1.; // now initialize to 1 and multiply `r` at bottom of `m` loop, since `(m - n)` now starts at 0 and counts up\n\n for (int m = n; m <= MaxEccentricityHarmonic; ++m) {\n emn[m - MinEccentricityHarmonic][n - MinEccentricityHarmonic] += rfactor * zfactor;\n rfactor *= r;\n }\n }\n }\n }\n }\n\n for (int m = MinEccentricityHarmonic; m <= max_m; ++m) {\n double wt = std::fmax(weights[m - MinEccentricityHarmonic], TINY);\n\n for (int n = MinEccentricityHarmonic; n <= max_n; ++n) {\n eccentricity_mn_[std::make_pair(m,n)] = std::abs(emn[m - MinEccentricityHarmonic][n - MinEccentricityHarmonic]) / wt;\n eccentricity_mn_arg_[std::make_pair(m,n)] = std::arg(emn[m - MinEccentricityHarmonic][n - MinEccentricityHarmonic]);\n }\n\n if (m <= max_n) // also update `eccentricity_` for `m == n` if applicable\n eccentricity_[m] = std::abs(emn[m - MinEccentricityHarmonic][m - MinEccentricityHarmonic]) / wt;\n }\n}\n\nvoid Event::compute_observables() {\n if (max_eccentricity_n_ >= 0) {\n if (max_eccentricity_m_ >= 0)\n compute_emn(max_eccentricity_m_, max_eccentricity_n_);\n else compute_en(max_eccentricity_n_);\n }\n}\n\n} // namespace trento\n", "meta": {"hexsha": "d9ebcfb762a1f311dad9cc0f5ee3e082fef536e1", "size": 12090, "ext": "cxx", "lang": "C++", "max_stars_repo_path": "src/event.cxx", "max_stars_repo_name": "dereksoeder/trento", "max_stars_repo_head_hexsha": "4645d2cd5ee68c0e7c103e43f148bd0053622839", "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/event.cxx", "max_issues_repo_name": "dereksoeder/trento", "max_issues_repo_head_hexsha": "4645d2cd5ee68c0e7c103e43f148bd0053622839", "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/event.cxx", "max_forks_repo_name": "dereksoeder/trento", "max_forks_repo_head_hexsha": "4645d2cd5ee68c0e7c103e43f148bd0053622839", "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.3465909091, "max_line_length": 143, "alphanum_fraction": 0.629611249, "num_tokens": 3625, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970654616712, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.5450199902066832}} {"text": "//\n// Expansion Hunter\n// Copyright 2016-2019 Illumina, Inc.\n// All rights reserved.\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\n#include \"genotyping/AlleleChecker.hh\"\n\n#include \n#include \n#include \n\n#include \n\nnamespace ehunter\n{\n\nnamespace\n{\ndouble poissonLogPmf(double lambda, double count)\n{\n return count * log(lambda) - lambda - boost::math::lgamma(count + 1);\n}\n\ndouble logBeta(int a, int b) { return boost::math::lgamma(a) + boost::math::lgamma(b) - boost::math::lgamma(a + b); }\n\ndouble logBinomCoef(int n, int k) { return -boost::math::log1p(n) - logBeta(n - k + 1, k + 1); }\n\ndouble binomLogPmf(int n, double p, int count)\n{\n return logBinomCoef(n, count) + count * log(p) + (n - count) * boost::math::log1p(-p);\n}\n\n}\n\nAlleleCheckSummary AlleleChecker::check(double haplotypeDepth, int targetAlleleCount, int otherAlleleCount) const\n{\n if (haplotypeDepth <= 0)\n {\n throw std::runtime_error(\"Haplotype depth must be positive\");\n }\n\n if (targetAlleleCount < 0 || otherAlleleCount < 0)\n {\n throw std::runtime_error(\"Negative read counts are not allowed\");\n }\n\n const int totalReadCount = targetAlleleCount + otherAlleleCount;\n const double ll0 = (totalReadCount > 0) ? binomLogPmf(totalReadCount, errorRate_, targetAlleleCount) : 0;\n const double ll1 = poissonLogPmf(haplotypeDepth, targetAlleleCount);\n\n AlleleStatus status = AlleleStatus::kUncertain;\n double logLikelihoodRatio = (ll1 - ll0) / log(10);\n if (logLikelihoodRatio < -log10(likelihoodRatioThreshold_))\n {\n status = AlleleStatus::kAbsent;\n }\n else if (logLikelihoodRatio > log10(likelihoodRatioThreshold_))\n {\n status = AlleleStatus::kPresent;\n }\n\n return AlleleCheckSummary(status, logLikelihoodRatio);\n}\n\nstd::ostream& operator<<(std::ostream& out, AlleleStatus status)\n{\n switch (status)\n {\n case AlleleStatus::kAbsent:\n out << \"Absent\";\n break;\n case AlleleStatus::kPresent:\n out << \"Present\";\n break;\n case AlleleStatus::kUncertain:\n out << \"Uncertain\";\n break;\n }\n\n return out;\n}\n\n}\n", "meta": {"hexsha": "cbebc3d40bb7e6b9c9568b642a68e529abf28cc1", "size": 2765, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ehunter/genotyping/AlleleChecker.cpp", "max_stars_repo_name": "bw2/ExpansionHunter", "max_stars_repo_head_hexsha": "6a6005a4bae2c49f56ec8997a301b70a75b042b6", "max_stars_repo_licenses": ["BSL-1.0", "Apache-2.0"], "max_stars_count": 122.0, "max_stars_repo_stars_event_min_datetime": "2017-01-06T16:19:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-08T00:05:50.000Z", "max_issues_repo_path": "ehunter/genotyping/AlleleChecker.cpp", "max_issues_repo_name": "bw2/ExpansionHunter", "max_issues_repo_head_hexsha": "6a6005a4bae2c49f56ec8997a301b70a75b042b6", "max_issues_repo_licenses": ["BSL-1.0", "Apache-2.0"], "max_issues_count": 90.0, "max_issues_repo_issues_event_min_datetime": "2017-01-04T00:23:34.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-27T12:55:52.000Z", "max_forks_repo_path": "ehunter/genotyping/AlleleChecker.cpp", "max_forks_repo_name": "bw2/ExpansionHunter", "max_forks_repo_head_hexsha": "6a6005a4bae2c49f56ec8997a301b70a75b042b6", "max_forks_repo_licenses": ["BSL-1.0", "Apache-2.0"], "max_forks_count": 35.0, "max_forks_repo_forks_event_min_datetime": "2017-03-02T13:39:58.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T17:34:11.000Z", "avg_line_length": 28.2142857143, "max_line_length": 117, "alphanum_fraction": 0.6886075949, "num_tokens": 737, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765257642905, "lm_q2_score": 0.5964331462646254, "lm_q1q2_score": 0.5449469649297278}} {"text": "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"aux/filtered_range.hpp\"\n#include \"aux/hash_specializations.hpp\"\n#include \"aux/simple_sparse_matrix.hpp\"\n#include \"matrix/assembly/velocity_angular_integrator.hpp\"\n#include \"matrix/assembly/velocity_radial_integrator.hpp\"\n#include \"matrix/assembly/weight.hpp\"\n#include \"spectral/basis/spectral_basis_dimension_accessor.hpp\"\n\n\nnamespace boltzmann {\nnamespace local_ {\n/**\n * @brief Compute and cache overlap integrals in radial direction\n */\nstruct radial_entry_computer_t\n{\n // -----------------------------------------------------------------\n radial_entry_computer_t(int nqpts_ = 90)\n : nqpts(nqpts_)\n {\n /* empty */\n }\n\n /**\n * @brief I = \\f$\\int_\\bbR b_1(r) k(r), b_2(r) r \\ud r \\f$\n *\n * @tparam E spectral element\n * @param k additional function argument\n * @param b1 1st basis function\n * @param b2 2nd basis function\n * @return I integral\n */\n template \n double compute(const std::function& k,\n const E& b1,\n const E& b2,\n const double a = 0 /* inner product weight exp(-a r**2) */)\n {\n const double FUZZY = 1e7;\n const double nu = a + b1.w() + b2.w();\n const long int key = FUZZY * nu;\n if (quad_cache.find(key) == quad_cache.end()) quad_cache[key] = ptr_t(new QMaxwell(nu, nqpts));\n const auto& quad = *(quad_cache[key]);\n\n double sum = 0;\n for (unsigned int q = 0; q < quad.size(); ++q) {\n sum += b1.evaluate(quad.pts(q)) * b2.evaluate(quad.pts(q)) * k(quad.pts(q)) * quad.wts(q);\n }\n\n return sum;\n }\n\n private:\n const int nqpts;\n typedef std::shared_ptr ptr_t;\n std::map quad_cache;\n};\n} // end namespace local_\n\ntemplate \nclass VelocityVarForm\n{ };\n\n/**\n * @brief Storage for velocity domain matrix entries\n *\n */\ntemplate <>\nclass VelocityVarForm<2>\n{\n private:\n static const int DIM = 2;\n typedef unsigned int index_t;\n typedef dealii::Tensor<1, DIM, double> t1_t;\n typedef dealii::Tensor<2, DIM, double> t2_t;\n\n typedef SimpleSparseMatrix s0_entries_t;\n typedef SimpleSparseMatrix t1_entries_t;\n typedef SimpleSparseMatrix t2_entries_t;\n\n public:\n template \n void init(const BASIS& test_basis, const BASIS& trial_basis, const double beta = 2);\n\n template \n void init(const BASIS& trial_basis, const double beta = 2);\n\n private:\n s0_entries_t s0_;\n t1_entries_t t1_;\n t2_entries_t t2_;\n\n /// helpers\n VelocityAngularIntegrator<2> vai;\n\n constexpr const static double TOL = 1e-11; // magic number\n\n public:\n auto get_s0() const -> decltype(s0_.get_vec()) { return s0_.get_vec(); }\n auto get_s1() const -> decltype(t1_.get_vec()) { return t1_.get_vec(); }\n auto get_t1() const -> decltype(t1_.get_vec()) { return t1_.get_vec(); }\n auto get_t2() const -> decltype(t2_.get_vec()) { return t2_.get_vec(); }\n\n const SimpleSparseMatrix& get_s0m() const { return s0_; }\n const SimpleSparseMatrix& get_s1m() const { return t1_; }\n const SimpleSparseMatrix& get_t1m() const { return t1_; }\n const SimpleSparseMatrix& get_t2m() const { return t2_; }\n\n /**\n * @brief \\f$\\langle \\psi_1, \\psi_2\\rangle\\f$\n *\n * Detailed description\n *\n * @return Returns a vector [(entry_t...)] which contains the non-zero\n * entries of the sparse matrix arising from the overlap integral above.\n * entry_t has members row, col and val. row and col correspond to the\n * enumeration of DoFs in the spectral basis.\n\n */\n auto s0() const -> const decltype(s0_) & { return s0_; }\n\n /**\n * @brief \\f$\\langle v_i \\psi_1, \\psi_2\\rangle\\f$\n *\n * Detailed description\n *\n * @return Returns a vector [(entry_t...)] which contains the non-zero\n * entries of the sparse matrix arising from the overlap integral above.\n * entry_t has members row, col and val. row and col correspond to the\n * enumeration of DoFs in the spectral basis.\n */\n auto s1() const -> const decltype(t1_) & { return t1_; }\n\n /**\n * @brief same as s1\n */\n auto t1() const -> const decltype(t1_) & { return t1_; }\n\n /**\n * @brief \\f$\\langle v_i v_j \\psi_1, \\psi_2 \\rangle\\f$\n *\n * Detailed description\n *\n * @return Returns a vector [(entry_t...)] which contains the non-zero\n * entries of the sparse matrix arising from the overlap integral above.\n * entry_t has members row, col and val. row and col correspond to the\n * enumeration of DoFs in the spectral basis.\n */\n auto t2() const -> const decltype(t2_) & { return t2_; }\n\n const VelocityAngularIntegrator<2>& get_vai() const { return vai; }\n\n void print_info() const;\n};\n\n// --------------------------------------------------------------------------------\ntemplate \nvoid\nVelocityVarForm<2>::init(const BASIS& test_basis, const BASIS& trial_basis, const double beta)\n{\n typedef typename BASIS::elem_t elem_t;\n\n // angular basis\n typedef typename std::tuple_element<0, typename BASIS::elem_t::container_t>::type angular_elem_t;\n // radial basis\n typedef typename std::tuple_element<1, typename BASIS::elem_t::container_t>::type radial_elem_t;\n /// vector of basis functions in dim1\n typedef typename BASIS::DimAcc::template get_vec a1_t;\n typedef typename BASIS::DimAcc::template get_vec a2_t;\n\n typedef typename radial_elem_t::id_t rid_t;\n typedef typename radial_elem_t::numeric_t numeric_t;\n\n // element accessors for radial and angular parts\n typename elem_t::Acc::template get acc_rad;\n typename elem_t::Acc::template get acc_ang;\n\n /// they correspond to rows and columns in R1\n const auto& test_angular_basis = a1_t()(test_basis);\n // const auto& test_radial_basis = a2_t()(test_basis);\n\n const auto& trial_angular_basis = a1_t()(trial_basis);\n // const auto& trial_radial_basis = a2_t()(trial_basis);\n\n // matrix assembly\n vai.init(trial_angular_basis);\n // regular L2-inner product\n L2Weight weight(beta);\n\n // ------------------------------\n // Compute Radial Entries\n local_::radial_entry_computer_t radial_entry_computer;\n // create a cache for the radial entries\n std::unordered_map, numeric_t> cache;\n\n typedef std::pair index_pair_t;\n\n // ----------------------------------------------------------------------\n // S0\n s0_.reinit(trial_basis.n_dofs());\n cache.clear();\n auto k0 = [](double r __attribute__((unused))) { return 1; };\n // iterate over nonzero entries in s0\n const auto& s0A = vai.get_s0();\n for (auto itA = s0A.begin(); itA != s0A.end(); ++itA) {\n // get ids from anuglar basis\n unsigned int iA1 = itA->first.first;\n unsigned int iA2 = itA->first.second;\n const auto& idA1 = test_angular_basis[iA1].get_id();\n const auto& idA2 = trial_angular_basis[iA2].get_id();\n\n std::function pred1 = [&](const elem_t& e) {\n return acc_ang(e).get_id() == idA1;\n };\n\n std::function pred2 = [&](const elem_t& e) {\n return acc_ang(e).get_id() == idA2;\n };\n\n auto test_range_rad = filtered_range(test_basis.begin(), test_basis.end(), pred1);\n auto trial_range_rad = filtered_range(trial_basis.begin(), trial_basis.end(), pred2);\n\n // iterate over test functions\n for (auto itR1 = std::get<0>(test_range_rad); itR1 != std::get<1>(test_range_rad); ++itR1) {\n const auto& br1 = acc_rad(*itR1); // extract radial part\n const auto& id1 = br1.get_id();\n\n // iterate over trial functions\n for (auto itR2 = std::get<0>(trial_range_rad); itR2 != std::get<1>(trial_range_rad); ++itR2) {\n const auto& br2 = acc_rad(*itR2); // extract radial part\n const auto& id2 = br2.get_id();\n // create key\n auto key = std::make_tuple(id1, id2);\n // lookup\n auto cit = cache.find(key);\n // found?\n double vr;\n if (cit != cache.end()) {\n vr = cit->second;\n } else {\n vr = radial_entry_computer.compute(k0, br1, br2, 1 - 2.0 / beta);\n cache[key] = vr;\n }\n\n // insert value into entries structure\n if (std::abs(vr) > TOL) {\n unsigned int gidx1 = test_basis.get_dof_index(itR1->get_id());\n unsigned int gidx2 = trial_basis.get_dof_index(itR2->get_id());\n s0_.insert(gidx1, gidx2, (itA->second) * vr);\n }\n }\n }\n }\n s0_.compress();\n\n // ----------------------------------------------------------------------\n // T1\n t1_.reinit(trial_basis.n_dofs());\n cache.clear();\n auto k1 = [](double r) { return r; };\n // iterate over nonzero entries in t1\n const auto& t1A = vai.get_t1();\n for (auto itA = t1A.begin(); itA != t1A.end(); ++itA) {\n // get ids from anuglar basis\n unsigned int iA1 = itA->first.first;\n unsigned int iA2 = itA->first.second;\n const auto& idA1 = test_angular_basis[iA1].get_id();\n const auto& idA2 = trial_angular_basis[iA2].get_id();\n\n std::function pred1 = [&](const elem_t& e) {\n return acc_ang(e).get_id() == idA1;\n };\n std::function pred2 = [&](const elem_t& e) {\n return acc_ang(e).get_id() == idA2;\n };\n\n auto test_range_rad = filtered_range(test_basis.begin(), test_basis.end(), pred1);\n auto trial_range_rad = filtered_range(trial_basis.begin(), trial_basis.end(), pred2);\n\n // iterate over test functions\n for (auto itR1 = std::get<0>(test_range_rad); itR1 != std::get<1>(test_range_rad); ++itR1) {\n const auto& br1 = acc_rad(*itR1); // extract radial part\n const auto& id1 = br1.get_id();\n\n // iterate over trial functions\n for (auto itR2 = std::get<0>(trial_range_rad); itR2 != std::get<1>(trial_range_rad); ++itR2) {\n const auto& br2 = acc_rad(*itR2); // extract radial part\n const auto& id2 = br2.get_id();\n // create key\n auto key = std::make_tuple(id1, id2);\n // lookup\n auto cit = cache.find(key);\n // found?\n double vr;\n if (cit != cache.end()) {\n vr = cit->second;\n } else {\n vr = radial_entry_computer.compute(k1, br1, br2, 1 - 2.0 / beta);\n cache[key] = vr;\n }\n\n // insert value into entries structure\n if (std::abs(vr) > TOL) {\n unsigned int gidx1 = test_basis.get_dof_index(itR1->get_id());\n unsigned int gidx2 = trial_basis.get_dof_index(itR2->get_id());\n t1_.insert(gidx1, gidx2, (itA->second) * vr);\n }\n }\n }\n }\n t1_.compress();\n\n // ----------------------------------------------------------------------\n // T2\n t2_.reinit(trial_basis.n_dofs());\n cache.clear();\n auto k2 = [](double r) { return r * r; };\n const auto& t2A = vai.get_t2();\n for (auto itA = t2A.begin(); itA != t2A.end(); ++itA) {\n // get ids from anuglar basis\n unsigned int iA1 = itA->first.first;\n unsigned int iA2 = itA->first.second;\n const auto& idA1 = test_angular_basis[iA1].get_id();\n const auto& idA2 = trial_angular_basis[iA2].get_id();\n\n std::function pred1 = [&](const elem_t& e) {\n return acc_ang(e).get_id() == idA1;\n };\n std::function pred2 = [&](const elem_t& e) {\n return acc_ang(e).get_id() == idA2;\n };\n\n auto test_range_rad = filtered_range(test_basis.begin(), test_basis.end(), pred1);\n auto trial_range_rad = filtered_range(trial_basis.begin(), trial_basis.end(), pred2);\n\n // iterate over test functions\n for (auto itR1 = std::get<0>(test_range_rad); itR1 != std::get<1>(test_range_rad); ++itR1) {\n const auto& br1 = acc_rad(*itR1); // extract radial part\n const auto& id1 = br1.get_id();\n\n // iterate over trial functions\n for (auto itR2 = std::get<0>(trial_range_rad); itR2 != std::get<1>(trial_range_rad); ++itR2) {\n const auto& br2 = acc_rad(*itR2); // extract radial part\n const auto& id2 = br2.get_id();\n // create key\n auto key = std::make_tuple(id1, id2);\n // lookup\n auto cit = cache.find(key);\n // found?\n double vr;\n if (cit != cache.end()) {\n vr = cit->second;\n } else {\n vr = radial_entry_computer.compute(k2, br1, br2, 1 - 2.0 / beta);\n cache[key] = vr;\n }\n\n // insert value into entries structure\n if (std::abs(vr) > TOL) {\n unsigned int gidx1 = test_basis.get_dof_index(itR1->get_id());\n unsigned int gidx2 = trial_basis.get_dof_index(itR2->get_id());\n t2_.insert(gidx1, gidx2, (itA->second) * vr);\n }\n }\n }\n }\n t2_.compress();\n}\n\n// ------------------------------------------------------------\ntemplate \nvoid\nVelocityVarForm<2>::init(const BASIS& trial_basis, const double beta)\n{\n this->init(trial_basis, trial_basis, beta);\n}\n\n// -------------------------------------------------------------\ninline void\nVelocityVarForm<2>::print_info() const\n{\n std::cout << \"s0_.size()\"\n << \"\\t\" << s0_.size() << std::endl\n << \"t1_.size()\"\n << \"\\t\" << t1_.size() << std::endl\n << \"t2_.size()\"\n << \"\\t\" << t2_.size() << std::endl;\n}\n\n} // end namespace boltzmann\n", "meta": {"hexsha": "90a1e36b4ad198b09f64bb984032446eafbf8b12", "size": 13425, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/matrix/assembly/velocity_var_form.hpp", "max_stars_repo_name": "simonpintarelli/2dBoltzmann", "max_stars_repo_head_hexsha": "bc6b7bbeffa242ce80937947444383b416ba3fc9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/matrix/assembly/velocity_var_form.hpp", "max_issues_repo_name": "simonpintarelli/2dBoltzmann", "max_issues_repo_head_hexsha": "bc6b7bbeffa242ce80937947444383b416ba3fc9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/matrix/assembly/velocity_var_form.hpp", "max_forks_repo_name": "simonpintarelli/2dBoltzmann", "max_forks_repo_head_hexsha": "bc6b7bbeffa242ce80937947444383b416ba3fc9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.5625, "max_line_length": 100, "alphanum_fraction": 0.6078957169, "num_tokens": 3776, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303186696748, "lm_q2_score": 0.6893056231680121, "lm_q1q2_score": 0.5449169939438074}} {"text": "// Boost common_factor.hpp header file -------------------------------------//\n\n// (C) Copyright Daryle Walker, Stephen Cleary, Paul Moore 2001. Permission\n// to copy, use, modify, sell and distribute this software is granted provided\n// this copyright notice appears in all copies. This software is provided \"as\n// is\" without express or implied warranty, and with no claim as to its\n// suitability for any purpose. \n\n// See http://www.boost.org for updates, documentation, and revision history. \n\n#ifndef BOOST_MATH_COMMON_FACTOR_HPP\n#define BOOST_MATH_COMMON_FACTOR_HPP\n\n#include // self include\n\n#include // for BOOST_STATIC_CONSTANT, etc.\n#include // for std::numeric_limits\n\n\nnamespace boost\n{\nnamespace math\n{\n\n\n// Forward declarations for function templates -----------------------------//\n\ntemplate < typename IntegerType >\n IntegerType gcd( IntegerType const &a, IntegerType const &b );\n\ntemplate < typename IntegerType >\n IntegerType lcm( IntegerType const &a, IntegerType const &b );\n\n\n// Greatest common divisor evaluator class declaration ---------------------//\n\ntemplate < typename IntegerType >\nclass gcd_evaluator\n{\npublic:\n // Types\n typedef IntegerType result_type, first_argument_type, second_argument_type;\n\n // Function object interface\n result_type operator ()( first_argument_type const &a,\n second_argument_type const &b ) const;\n\n}; // boost::math::gcd_evaluator\n\n\n// Least common multiple evaluator class declaration -----------------------//\n\ntemplate < typename IntegerType >\nclass lcm_evaluator\n{\npublic:\n // Types\n typedef IntegerType result_type, first_argument_type, second_argument_type;\n\n // Function object interface\n result_type operator ()( first_argument_type const &a,\n second_argument_type const &b ) const;\n\n}; // boost::math::lcm_evaluator\n\n\n// Implementation details --------------------------------------------------//\n\nnamespace detail\n{\n#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION\n // Build GCD with Euclid's recursive algorithm\n template < unsigned long Value1, unsigned long Value2 >\n struct static_gcd_helper_t\n {\n private:\n BOOST_STATIC_CONSTANT( unsigned long, new_value1 = Value2 );\n BOOST_STATIC_CONSTANT( unsigned long, new_value2 = Value1 % Value2 );\n\n #ifndef __BORLANDC__\n #define BOOST_DETAIL_GCD_HELPER_VAL(Value) Value\n #else\n typedef static_gcd_helper_t self_type;\n #define BOOST_DETAIL_GCD_HELPER_VAL(Value) (self_type:: Value )\n #endif\n\n typedef static_gcd_helper_t< BOOST_DETAIL_GCD_HELPER_VAL(new_value1),\n BOOST_DETAIL_GCD_HELPER_VAL(new_value2) > next_step_type;\n\n #undef BOOST_DETAIL_GCD_HELPER_VAL\n\n public:\n BOOST_STATIC_CONSTANT( unsigned long, value = next_step_type::value );\n };\n\n // Non-recursive case\n template < unsigned long Value1 >\n struct static_gcd_helper_t< Value1, 0UL >\n {\n BOOST_STATIC_CONSTANT( unsigned long, value = Value1 );\n };\n#else\n // Use inner class template workaround from Peter Dimov\n template < unsigned long Value1 >\n struct static_gcd_helper2_t\n {\n template < unsigned long Value2 >\n struct helper\n {\n BOOST_STATIC_CONSTANT( unsigned long, value\n = static_gcd_helper2_t::helper::value );\n };\n\n template < >\n struct helper< 0UL >\n {\n BOOST_STATIC_CONSTANT( unsigned long, value = Value1 );\n };\n };\n\n // Special case\n template < >\n struct static_gcd_helper2_t< 0UL >\n {\n template < unsigned long Value2 >\n struct helper\n {\n BOOST_STATIC_CONSTANT( unsigned long, value = Value2 );\n };\n };\n\n // Build the GCD from the above template(s)\n template < unsigned long Value1, unsigned long Value2 >\n struct static_gcd_helper_t\n {\n BOOST_STATIC_CONSTANT( unsigned long, value\n = static_gcd_helper2_t::BOOST_NESTED_TEMPLATE\n helper::value );\n };\n#endif\n\n#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION\n // Build the LCM from the GCD\n template < unsigned long Value1, unsigned long Value2 >\n struct static_lcm_helper_t\n {\n typedef static_gcd_helper_t gcd_type;\n\n BOOST_STATIC_CONSTANT( unsigned long, value = Value1 / gcd_type::value\n * Value2 );\n };\n\n // Special case for zero-GCD values\n template < >\n struct static_lcm_helper_t< 0UL, 0UL >\n {\n BOOST_STATIC_CONSTANT( unsigned long, value = 0UL );\n };\n#else\n // Adapt GCD's inner class template workaround for LCM\n template < unsigned long Value1 >\n struct static_lcm_helper2_t\n {\n template < unsigned long Value2 >\n struct helper\n {\n typedef static_gcd_helper_t gcd_type;\n\n BOOST_STATIC_CONSTANT( unsigned long, value = Value1\n / gcd_type::value * Value2 );\n };\n\n template < >\n struct helper< 0UL >\n {\n BOOST_STATIC_CONSTANT( unsigned long, value = 0UL );\n };\n };\n\n // Special case\n template < >\n struct static_lcm_helper2_t< 0UL >\n {\n template < unsigned long Value2 >\n struct helper\n {\n BOOST_STATIC_CONSTANT( unsigned long, value = 0UL );\n };\n };\n\n // Build the LCM from the above template(s)\n template < unsigned long Value1, unsigned long Value2 >\n struct static_lcm_helper_t\n {\n BOOST_STATIC_CONSTANT( unsigned long, value\n = static_lcm_helper2_t::BOOST_NESTED_TEMPLATE\n helper::value );\n };\n#endif\n\n // Greatest common divisor for rings (including unsigned integers)\n template < typename RingType >\n RingType\n gcd_euclidean\n (\n RingType a,\n RingType b\n )\n {\n // Avoid repeated construction\n #ifndef __BORLANDC__\n RingType const zero = static_cast( 0 );\n #else\n RingType zero = static_cast( 0 );\n #endif\n\n // Reduce by GCD-remainder property [GCD(a,b) == GCD(b,a MOD b)]\n while ( true )\n {\n if ( a == zero )\n return b;\n b %= a;\n\n if ( b == zero )\n return a;\n a %= b;\n }\n }\n\n // Greatest common divisor for (signed) integers\n template < typename IntegerType >\n inline\n IntegerType\n gcd_integer\n (\n IntegerType const & a,\n IntegerType const & b\n )\n {\n // Avoid repeated construction\n IntegerType const zero = static_cast( 0 );\n IntegerType const result = gcd_euclidean( a, b );\n\n return ( result < zero ) ? -result : result;\n }\n\n // Least common multiple for rings (including unsigned integers)\n template < typename RingType >\n inline\n RingType\n lcm_euclidean\n (\n RingType const & a,\n RingType const & b\n )\n {\n RingType const zero = static_cast( 0 );\n RingType const temp = gcd_euclidean( a, b );\n\n return ( temp != zero ) ? ( a / temp * b ) : zero;\n }\n\n // Least common multiple for (signed) integers\n template < typename IntegerType >\n inline\n IntegerType\n lcm_integer\n (\n IntegerType const & a,\n IntegerType const & b\n )\n {\n // Avoid repeated construction\n IntegerType const zero = static_cast( 0 );\n IntegerType const result = lcm_euclidean( a, b );\n\n return ( result < zero ) ? -result : result;\n }\n\n // Function objects to find the best way of computing GCD or LCM\n#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS\n#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION\n template < typename T, bool IsSpecialized, bool IsSigned >\n struct gcd_optimal_evaluator_helper_t\n {\n T operator ()( T const &a, T const &b )\n {\n return gcd_euclidean( a, b );\n }\n };\n\n template < typename T >\n struct gcd_optimal_evaluator_helper_t< T, true, true >\n {\n T operator ()( T const &a, T const &b )\n {\n return gcd_integer( a, b );\n }\n };\n#else\n template < bool IsSpecialized, bool IsSigned >\n struct gcd_optimal_evaluator_helper2_t\n {\n template < typename T >\n struct helper\n {\n T operator ()( T const &a, T const &b )\n {\n return gcd_euclidean( a, b );\n }\n };\n };\n\n template < >\n struct gcd_optimal_evaluator_helper2_t< true, true >\n {\n template < typename T >\n struct helper\n {\n T operator ()( T const &a, T const &b )\n {\n return gcd_integer( a, b );\n }\n };\n };\n\n template < typename T, bool IsSpecialized, bool IsSigned >\n struct gcd_optimal_evaluator_helper_t\n : gcd_optimal_evaluator_helper2_t\n ::BOOST_NESTED_TEMPLATE helper\n {\n };\n#endif\n\n template < typename T >\n struct gcd_optimal_evaluator\n {\n T operator ()( T const &a, T const &b )\n {\n typedef ::std::numeric_limits limits_type;\n\n typedef gcd_optimal_evaluator_helper_t helper_type;\n\n helper_type solver;\n\n return solver( a, b );\n }\n };\n#else // BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS\n template < typename T >\n struct gcd_optimal_evaluator\n {\n T operator ()( T const &a, T const &b )\n {\n return gcd_integer( a, b );\n }\n };\n#endif\n\n#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS\n#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION\n template < typename T, bool IsSpecialized, bool IsSigned >\n struct lcm_optimal_evaluator_helper_t\n {\n T operator ()( T const &a, T const &b )\n {\n return lcm_euclidean( a, b );\n }\n };\n\n template < typename T >\n struct lcm_optimal_evaluator_helper_t< T, true, true >\n {\n T operator ()( T const &a, T const &b )\n {\n return lcm_integer( a, b );\n }\n };\n#else\n template < bool IsSpecialized, bool IsSigned >\n struct lcm_optimal_evaluator_helper2_t\n {\n template < typename T >\n struct helper\n {\n T operator ()( T const &a, T const &b )\n {\n return lcm_euclidean( a, b );\n }\n };\n };\n\n template < >\n struct lcm_optimal_evaluator_helper2_t< true, true >\n {\n template < typename T >\n struct helper\n {\n T operator ()( T const &a, T const &b )\n {\n return lcm_integer( a, b );\n }\n };\n };\n\n template < typename T, bool IsSpecialized, bool IsSigned >\n struct lcm_optimal_evaluator_helper_t\n : lcm_optimal_evaluator_helper2_t\n ::BOOST_NESTED_TEMPLATE helper\n {\n };\n#endif\n\n template < typename T >\n struct lcm_optimal_evaluator\n {\n T operator ()( T const &a, T const &b )\n {\n typedef ::std::numeric_limits limits_type;\n\n typedef lcm_optimal_evaluator_helper_t helper_type;\n\n helper_type solver;\n\n return solver( a, b );\n }\n };\n#else // BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS\n template < typename T >\n struct lcm_optimal_evaluator\n {\n T operator ()( T const &a, T const &b )\n {\n return lcm_integer( a, b );\n }\n };\n#endif\n\n // Functions to find the GCD or LCM in the best way\n template < typename T >\n inline\n T\n gcd_optimal\n (\n T const & a,\n T const & b\n )\n {\n gcd_optimal_evaluator solver;\n\n return solver( a, b );\n }\n\n template < typename T >\n inline\n T\n lcm_optimal\n (\n T const & a,\n T const & b\n )\n {\n lcm_optimal_evaluator solver;\n\n return solver( a, b );\n }\n\n} // namespace detail\n\n\n// Compile-time greatest common divisor evaluator class declaration --------//\n\ntemplate < unsigned long Value1, unsigned long Value2 >\nstruct static_gcd\n{\n BOOST_STATIC_CONSTANT( unsigned long, value\n = (detail::static_gcd_helper_t::value) );\n\n}; // boost::math::static_gcd\n\n\n// Compile-time least common multiple evaluator class declaration ----------//\n\ntemplate < unsigned long Value1, unsigned long Value2 >\nstruct static_lcm\n{\n BOOST_STATIC_CONSTANT( unsigned long, value\n = (detail::static_lcm_helper_t::value) );\n\n}; // boost::math::static_lcm\n\n\n// Greatest common divisor evaluator member function definition ------------//\n\ntemplate < typename IntegerType >\ninline\ntypename gcd_evaluator::result_type\ngcd_evaluator::operator ()\n(\n first_argument_type const & a,\n second_argument_type const & b\n) const\n{\n return detail::gcd_optimal( a, b );\n}\n\n\n// Least common multiple evaluator member function definition --------------//\n\ntemplate < typename IntegerType >\ninline\ntypename lcm_evaluator::result_type\nlcm_evaluator::operator ()\n(\n first_argument_type const & a,\n second_argument_type const & b\n) const\n{\n return detail::lcm_optimal( a, b );\n}\n\n\n// Greatest common divisor and least common multiple function definitions --//\n\ntemplate < typename IntegerType >\ninline\nIntegerType\ngcd\n(\n IntegerType const & a,\n IntegerType const & b\n)\n{\n gcd_evaluator solver;\n\n return solver( a, b );\n}\n\ntemplate < typename IntegerType >\ninline\nIntegerType\nlcm\n(\n IntegerType const & a,\n IntegerType const & b\n)\n{\n lcm_evaluator solver;\n\n return solver( a, b );\n}\n\n\n} // namespace math\n} // namespace boost\n\n\n#endif // BOOST_MATH_COMMON_FACTOR_HPP\n", "meta": {"hexsha": "10196fee64ab8e4822a0bacc6ccfae05e12ac420", "size": 14165, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "vegastrike/boost/1_28/boost/math/common_factor.hpp", "max_stars_repo_name": "Ezeer/VegaStrike_win32FR", "max_stars_repo_head_hexsha": "75891b9ccbdb95e48e15d3b4a9cd977955b97d1f", "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": "vegastrike/boost/1_28/boost/math/common_factor.hpp", "max_issues_repo_name": "Ezeer/VegaStrike_win32FR", "max_issues_repo_head_hexsha": "75891b9ccbdb95e48e15d3b4a9cd977955b97d1f", "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": "vegastrike/boost/1_28/boost/math/common_factor.hpp", "max_forks_repo_name": "Ezeer/VegaStrike_win32FR", "max_forks_repo_head_hexsha": "75891b9ccbdb95e48e15d3b4a9cd977955b97d1f", "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.2495543672, "max_line_length": 80, "alphanum_fraction": 0.6089657607, "num_tokens": 3343, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303186696747, "lm_q2_score": 0.6893056231680121, "lm_q1q2_score": 0.5449169939438073}} {"text": "#ifndef INCLUDED_scheme_numeric_euler_angles_HH\n#define INCLUDED_scheme_numeric_euler_angles_HH\n\n#include \n#include \n\nnamespace scheme { namespace numeric {\n\n\n\ttemplate typename M::Scalar const & xx( M const & m ) { return m(0,0); }\n\ttemplate typename M::Scalar const & xy( M const & m ) { return m(0,1); }\n\ttemplate typename M::Scalar const & xz( M const & m ) { return m(0,2); }\n\ttemplate typename M::Scalar const & yx( M const & m ) { return m(1,0); }\n\ttemplate typename M::Scalar const & yy( M const & m ) { return m(1,1); }\n\ttemplate typename M::Scalar const & yz( M const & m ) { return m(1,2); }\n\ttemplate typename M::Scalar const & zx( M const & m ) { return m(2,0); }\n\ttemplate typename M::Scalar const & zy( M const & m ) { return m(2,1); }\n\ttemplate typename M::Scalar const & zz( M const & m ) { return m(2,2); }\n\ttemplate typename M::Scalar & xx( M & m ) { return m(0,0); }\n\ttemplate typename M::Scalar & xy( M & m ) { return m(0,1); }\n\ttemplate typename M::Scalar & xz( M & m ) { return m(0,2); }\n\ttemplate typename M::Scalar & yx( M & m ) { return m(1,0); }\n\ttemplate typename M::Scalar & yy( M & m ) { return m(1,1); }\n\ttemplate typename M::Scalar & yz( M & m ) { return m(1,2); }\n\ttemplate typename M::Scalar & zx( M & m ) { return m(2,0); }\n\ttemplate typename M::Scalar & zy( M & m ) { return m(2,1); }\n\ttemplate typename M::Scalar & zz( M & m ) { return m(2,2); }\n\n\ttemplate struct get_scalar { typedef typename M::Scalar type; };\n\n\ttemplate T sin_cos_range(T const & t) { return t; }\n\n\t/// @brief COPIED FROM ROSETTA\n\t/// Return the three euler angles (in radians) that describe this HomogeneousTransform as the series\n\t/// of a Z axis rotation by the angle phi (returned in position 1 of the output vector), followed by\n\t/// an X axis rotation by the angle theta (returned in position 3 of the output vector), followed by another\n\t/// Z axis rotation by the angle psi (returned in position 2 of the output vector).\n\t/// This code is a modified version of Alex Z's code from r++.\n\t///\n\t/// @details\n\t/// The range of phi is [ -pi, pi ];\n\t/// The range of psi is [ -pi, pi ];\n\t/// The range of theta is [ 0, pi ];\n\t///\n\t/// The function pretends that this HomogeneousTransform is the result of these three transformations;\n\t/// if it were, then the rotation matrix would be\n\t///\n\t/// FIGURE 1:\n\t/// R = [\n\t/// cos(psi)cos(phi)-cos(theta)sin(phi)sin(psi) cos(psi)sin(phi)+cos(theta)cos(phi)sin(psi) sin(psi)sin(theta)\n\t/// -sin(psi)cos(phi)-cos(theta)sin(phi)cos(psi) -sin(psi)sin(phi)+cos(theta)cos(phi)cos(psi) cos(psi)sin(theta)\n\t/// sin(theta)sin(phi) -sin(theta)cos(phi) cos(theta)\n\t/// ]\n\t///\n\t/// where each axis above is represented as a ROW VECTOR (to be distinguished from the\n\t/// HomogeneousTransform's representation of axes as COLUMN VECTORS).\n\t///\n\t/// The zz_ coordinate gives away theta.\n\t/// Theta may be computed as acos( zz_ ), or, as Alex does it, asin( sqrt( 1 - zz^2))\n\t/// Since there is redundancy in theta, this function chooses a theta with a positive\n\t/// sin(theta): i.e. quadrants I and II. Assuming we have a positive sin theta\n\t/// pushes phi and psi into conforming angles.\n\t///\n\t/// NOTE on theta: asin returns a value in the range [ -pi/2, pi/2 ], and we have artificially\n\t/// created a positive sin(theta), so we will get a asin( pos_sin_theta ), we have a value\n\t/// in the range [ 0, pi/2 ]. To convert this into the actual angle theta, we examine the zz sign.\n\t/// If zz is negative, we chose the quadrant II theta.\n\t/// That is, asin( pos_sin_theta) returned an angle, call it theta'. Now, if cos( theta ) is negative,\n\t/// then we want to choose the positive x-axis rotation that's equivalent to -theta'. To do so,\n\t/// we reflect q through the y axis (See figure 2 below) to get p and then measure theta as pi - theta'.\n\t///\n\t/// FIGURE 2:\n\t///\n\t/// II | I\n\t/// |\n\t/// p. | .q (cos(-theta'), abs(sin(theta')))\n\t/// . | .\n\t/// theta'( . | . ) theta' = asin( abs(sin(theta))\n\t/// -----------------------\n\t/// |\n\t/// |\n\t/// |\n\t/// III | IV\n\t/// |\n\t/// The angle between the positive x axis and p is pi - theta'.\n\t///\n\t///\n\t///\n\t/// Since zx and zy contain only phi terms and a constant sin( theta ) term,\n\t/// phi is given by atan2( sin_phi, cos_phi ) = atan2( c*sin_phi, c*cos_phi ) = atan2( zx, -zy )\n\t/// for c positive and non-zero. If sin_theta is zero, or very close to zero, we're at gimbal lock.\n\t///\n\t/// Moreover, since xz and yz contain only psi terms, psi may also be deduced using atan2.\n\t///\n\t/// There are 2 degenerate cases (gimbal lock)\n\t/// 1. theta close to 0 (North Pole singularity), or\n\t/// 2. theta close to pi (South Pole singularity)\n\t/// For these, we take: phi=acos(xx), theta = 0 (resp. Pi/2), psi = 0\n\ttemplate void\n\teuler_angles(M const & m, E & euler){\n\n\t\ttypedef typename get_scalar::type T;\n\t\tstatic T const pi = boost::math::constants::pi();\n\t\tstatic T const pi_2 = boost::math::constants::pi() * (T)2;\n\t\tstatic T const epsilon = (T)10*std::numeric_limits::epsilon();\n\t\tstatic T const FLOAT_PRECISION = std::sqrt(epsilon);\n\t\tif ( zz(m) >= (T)1 - FLOAT_PRECISION ){\n\t\t\teuler[0] = std::atan2( sin_cos_range( yx(m) ), sin_cos_range( xx(m) ) );\n\t\t\teuler[1] = 0.0;\n\t\t\teuler[2] = 0.0;\n\t\t} else if ( zz(m) <= (T)-1 + FLOAT_PRECISION ){\n\t\t\teuler[0] = std::atan2( sin_cos_range( yx(m) ), sin_cos_range( xx(m) ) );\n\t\t\teuler[1] = 0.0;\n\t\t\teuler[2] = M_PI;\n\t\t} else {\n\t\t\tT pos_sin_theta = std::sqrt( (T)1 - zz(m)*zz(m) ); // sin2theta = 1 - cos2theta.\n\t\t\teuler[2] = std::asin( pos_sin_theta );\n\t\t\tif ( zz(m) < 0 ) {\n\t\t\t\teuler[2] = pi - euler[2];\n\t\t\t}\n\t\t\teuler[0] = std::atan2( xz(m), -yz(m) );\n\t\t\teuler[1] = std::atan2( zx(m), zy(m) );\n\t\t}\n\t\teuler[0] += euler[0]<0.0 ? pi_2 : 0.0;\n\t\teuler[1] += euler[1]<0.0 ? pi_2 : 0.0;\n\n\t\teuler[0] = std::min( std::max( 0.0, euler[0] ), pi_2-epsilon );\n\t\teuler[1] = std::min( std::max( 0.0, euler[1] ), pi_2-epsilon );\n\t\teuler[2] = std::min( std::max( 0.0, euler[2] ), pi -epsilon );\n\n\t\tassert( 0 <= euler[0] ); assert( euler[0] < pi_2 );\n\t\tassert( 0 <= euler[1] ); assert( euler[1] < pi_2 );\n\t\tassert( 0 <= euler[2] ); assert( euler[2] <= pi );\n\t}\n\n\t///@brief euler to matrix\n\ttemplate void\n\tfrom_euler_angles( E const & euler, M & m ){\n\t\ttypedef typename get_scalar::type T;\n\t\tT const ce1( std::cos( euler[0] ) ), se1( std::sin( euler[0] ) );\n\t\tT const ce2( std::cos( euler[1] ) ), se2( std::sin( euler[1] ) );\n\t\tT const ce3( std::cos( euler[2] ) ), se3( std::sin( euler[2] ) );\n\t\txx(m) = ce2 * ce1 - ce3 * se1 * se2; yx(m) = ce2 * se1 + ce3 * ce1 * se2; zx(m) = se2 * se3;\n\t\txy(m) = -se2 * ce1 - ce3 * se1 * ce2; yy(m) = -se2 * se1 + ce3 * ce1 * ce2; zy(m) = ce2 * se3;\n\t\txz(m) = se3 * se1; yz(m) = -se3 * ce1; zz(m) = ce3;\n\t}\n\n\ttemplate void\n\teuler_angles_deg(M const & m, E & euler) {\n\t\ttypedef typename get_scalar::type T;\n\t\tstatic T const rad_to_deg = 180.0 / boost::math::constants::pi();\n\t\teuler_angles(m,euler);\n\t\teuler[0] = euler[0] * rad_to_deg;\n\t\teuler[1] = euler[1] * rad_to_deg;\n\t\teuler[2] = euler[2] * rad_to_deg;\t\t\t\t\n\t}\n\ttemplate void\n\tfrom_euler_angles_deg(E const & erad, M & m) {\n\t\ttypedef typename get_scalar::type T;\n\t\tstatic T const deg_to_rad = boost::math::constants::pi() / 180.0;\n\t\tE euler; euler[0];\n\t\teuler[0] = erad[0] * deg_to_rad;\n\t\teuler[1] = erad[1] * deg_to_rad;\n\t\teuler[2] = erad[2] * deg_to_rad;\t\t\t\t\n\t\teuler_angles(m,euler);\n\t}\n\n}}\n\n#endif\n", "meta": {"hexsha": "c2e4f8d26d794657f9e311011cbe90611dbb57be", "size": 8021, "ext": "hh", "lang": "C++", "max_stars_repo_path": "schemelib/scheme/numeric/euler_angles.hh", "max_stars_repo_name": "YaoYinYing/rifdock", "max_stars_repo_head_hexsha": "cbde6bbeefd29a066273bdf2937cf36b0d2e6335", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 25.0, "max_stars_repo_stars_event_min_datetime": "2019-07-23T01:03:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T04:16:08.000Z", "max_issues_repo_path": "schemelib/scheme/numeric/euler_angles.hh", "max_issues_repo_name": "YaoYinYing/rifdock", "max_issues_repo_head_hexsha": "cbde6bbeefd29a066273bdf2937cf36b0d2e6335", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 13.0, "max_issues_repo_issues_event_min_datetime": "2018-01-30T17:45:57.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-28T11:02:44.000Z", "max_forks_repo_path": "schemelib/scheme/numeric/euler_angles.hh", "max_forks_repo_name": "YaoYinYing/rifdock", "max_forks_repo_head_hexsha": "cbde6bbeefd29a066273bdf2937cf36b0d2e6335", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2018-02-08T01:42:28.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T12:56:17.000Z", "avg_line_length": 46.9064327485, "max_line_length": 129, "alphanum_fraction": 0.5921954868, "num_tokens": 2618, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303186696748, "lm_q2_score": 0.689305616785446, "lm_q1q2_score": 0.5449169888981954}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n\n\nusing namespace std;\nusing namespace Eigen;\n\n// 文件路径\nstring left_file = \"./left.png\";\nstring right_file = \"./right.png\";\n\n\nvoid showPointCloud(\n const vector> &pointcloud);\n\nint main(int argc, char **argv) {\n double fx = 718.856, fy = 718.856, cx = 607.1928, cy = 185.2157;\n double b=0.573;\n\n cv::Mat left=cv::imread(left_file);\n cv::Mat right=cv::imread(right_file);\n cv::Ptr sgbm = cv::StereoSGBM::create(0, 96, 9, 8 * 9 * 9, 32 * 9 * 9, 1, 63, 10, 100, 32);\n cv::Mat disparity_sgbm, disparity;\n sgbm->compute(left,right,disparity_sgbm);\n disparity_sgbm.convertTo(disparity,CV_32F,1.0/16.0f);//signed short 2byte -> float 4byte \n \n \n vector> pointcloud;\n\n cout<(10,0)<<\" \"<< disparity.at(10,0)<(v,u)<=0||disparity.at(v,u)>=96.0) continue;\n\n Vector4d point(0,0,0,left.at(v,u)/255.0);\n\n double depth=b*fx/(disparity.at(v,u));//disparity in pixel\n double x=depth*(u-cx)/fx;\n double y=depth*(v-cy)/fy;\n \n point[0]=x;\n point[1]=y;\n point[2]=depth;\n \n \n pointcloud.push_back(point);\n //cout<<(int)left.at>(v,u)[0]<<\" \"<<(int)left.at>(v,u)[1]<<\" \"<<(int)left.at>(v,u)[2]<<\" \"<> &pointcloud) {\n\n if (pointcloud.empty()) {\n cerr << \"Point cloud is empty!\" << endl;\n return;\n }\n\n pangolin::CreateWindowAndBind(\"Point Cloud Viewer\", 1024, 768);\n glEnable(GL_DEPTH_TEST);\n glEnable(GL_BLEND);\n glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\n\n pangolin::OpenGlRenderState s_cam(\n pangolin::ProjectionMatrix(1024, 768, 500, 500, 512, 389, 0.1, 1000),\n pangolin::ModelViewLookAt(0, -0.1, -1.8, 0, 0, 0, 0.0, -1.0, 0.0)\n );\n\n pangolin::View &d_cam = pangolin::CreateDisplay()\n .SetBounds(0.0, 1.0, pangolin::Attach::Pix(175), 1.0, -1024.0f / 768.0f)\n .SetHandler(new pangolin::Handler3D(s_cam));\n\n while (pangolin::ShouldQuit() == false) {\n glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);\n\n d_cam.Activate(s_cam);\n glClearColor(1.0f, 1.0f, 1.0f, 1.0f);\n\n glPointSize(2);\n glBegin(GL_POINTS);\n for (auto &p: pointcloud) {\n glColor3f(p[3], p[3], p[3]);\n glVertex3d(p[0], p[1], p[2]);\n }\n glEnd();\n pangolin::FinishFrame();\n usleep(5000); // sleep 5 ms\n }\n return;\n}", "meta": {"hexsha": "8bf0238f7e783643b13081eaabe5a21f5f036ced", "size": 4271, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ch5/stereo/stereoVision.cpp", "max_stars_repo_name": "yejun1204/slambook2", "max_stars_repo_head_hexsha": "ed1c72226b16b1c4f159f2c030394f0eeaec5ed3", "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": "ch5/stereo/stereoVision.cpp", "max_issues_repo_name": "yejun1204/slambook2", "max_issues_repo_head_hexsha": "ed1c72226b16b1c4f159f2c030394f0eeaec5ed3", "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": "ch5/stereo/stereoVision.cpp", "max_forks_repo_name": "yejun1204/slambook2", "max_forks_repo_head_hexsha": "ed1c72226b16b1c4f159f2c030394f0eeaec5ed3", "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.168, "max_line_length": 184, "alphanum_fraction": 0.5340669632, "num_tokens": 1468, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303087996143, "lm_q2_score": 0.6893056167854461, "lm_q1q2_score": 0.5449169820947073}} {"text": "/* Copyright (c) 2010-2015, Delft University of Technology\r\n * All rights reserved.\r\n *\r\n * Redistribution and use in source and binary forms, with or without modification, are\r\n * permitted provided that the following conditions are met:\r\n * - Redistributions of source code must retain the above copyright notice, this list of\r\n * conditions and the following disclaimer.\r\n * - Redistributions in binary form must reproduce the above copyright notice, this list of\r\n * conditions and the following disclaimer in the documentation and/or other materials\r\n * provided with the distribution.\r\n * - Neither the name of the Delft University of Technology nor the names of its contributors\r\n * may be used to endorse or promote products derived from this software without specific\r\n * prior written permission.\r\n *\r\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS\r\n * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\r\n * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE\r\n * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\r\n * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE\r\n * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED\r\n * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\r\n * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED\r\n * OF THE POSSIBILITY OF SUCH DAMAGE.\r\n *\r\n * Changelog\r\n * YYMMDD Author Comment\r\n * 100903 K. Kumar File created.\r\n * 100916 L. Abdulkadir File checked.\r\n * 100929 K. Kumar Checked code by D. Dirkx added.\r\n * 101110 K. Kumar Added raiseToExponentPower( ) function.\r\n * 102410 D. Dirkx Minor comment changes as code check.\r\n * 101213 K. Kumar Bugfix raiseToIntegerExponent( ); renamed raiseToIntegerPower( ).\r\n * Added computeAbsoluteValue( ) functions.\r\n * 110202 K. Kumar Added overload for State* for computeLinearInterpolation( ).\r\n * 110111 J. Melman Added computeModulo( ) function.\r\n * 110411 K. Kumar Added convertCartesianToSpherical( ) function.\r\n * 110606 J. Melman Removed possible singularity from\r\n * convertCartesianToSpherical.\r\n * 110707 K. Kumar Added computeSampleMean( ), computeSampleVariance( ) functions.\r\n * 110905 S. Billemont Reorganized includes.\r\n * Moved (con/de)structors and getter/setters to header.\r\n * 120202 K. Kumar Moved linear interpolation functions into new Interpolators\r\n * sub-directory.\r\n * 120716 D. Dirkx Updated with interpolator architecture.\r\n *\r\n * References\r\n * Press W.H., et al. Numerical Recipes in C++: The Art of Scientific Computing. Cambridge\r\n * University Press, February 2002.\r\n *\r\n * Notes\r\n *\r\n */\r\n\r\n#include \r\n\r\n#include \"Tudat/Mathematics/Interpolators/linearInterpolator.h\"\r\n\r\nnamespace tudat\r\n{\r\nnamespace interpolators\r\n{\r\n\r\n//! Compute linear interpolation.\r\ndouble computeLinearInterpolation( const Eigen::VectorXd& sortedIndependentVariables,\r\n const Eigen::VectorXd& associatedDependentVariables,\r\n const double targetIndependentVariableValue )\r\n{\r\n // Declare local variables.\r\n // Declare nearest neighbor.\r\n int nearestNeighbor;\r\n double locationTargetIndependentVariableValueInInterval;\r\n\r\n // Compute nearest neighbor in sorted vector of independent variables.\r\n // Result is always to the left of the target independent variable value.\r\n nearestNeighbor = basic_mathematics::computeNearestLeftNeighborUsingBinarySearch(\r\n sortedIndependentVariables, targetIndependentVariableValue );\r\n\r\n // Compute location of target independent variable value in interval\r\n // between nearest neighbors.\r\n locationTargetIndependentVariableValueInInterval\r\n = ( targetIndependentVariableValue\r\n - sortedIndependentVariables[ nearestNeighbor ] )\r\n / ( sortedIndependentVariables[ nearestNeighbor + 1 ]\r\n - sortedIndependentVariables[ nearestNeighbor ] );\r\n\r\n // Return the computed value of the dependent variable.\r\n return ( associatedDependentVariables[ nearestNeighbor ]\r\n * ( 1 - locationTargetIndependentVariableValueInInterval )\r\n + associatedDependentVariables[ nearestNeighbor + 1 ]\r\n * locationTargetIndependentVariableValueInInterval );\r\n}\r\n\r\n//! Compute linear interpolation.\r\nEigen::VectorXd computeLinearInterpolation(\r\n const std::map < double, Eigen::VectorXd >& sortedIndepedentAndDependentVariables,\r\n const double targetIndependentVariableValue )\r\n{\r\n // Declare local variables.\r\n // Declare nearest neighbor.\r\n int nearestLeftNeighbor;\r\n\r\n // Declare location of target independent variable value in interval.\r\n double locationTargetIndependentVariableValueInInterval;\r\n\r\n // Declare map iterators\r\n std::map< double, Eigen::VectorXd >::const_iterator mapIteratorIntervalLeft;\r\n std::map< double, Eigen::VectorXd >::const_iterator mapIteratorIntervalRight;\r\n\r\n // Compute nearest neighbor in map of data.\r\n // Result is always to the left of the target independent variable value.\r\n nearestLeftNeighbor = basic_mathematics::computeNearestLeftNeighborUsingBinarySearch(\r\n sortedIndepedentAndDependentVariables, targetIndependentVariableValue );\r\n\r\n // Compute location of target independent variable value in interval\r\n // between nearest neighbors.\r\n mapIteratorIntervalLeft = sortedIndepedentAndDependentVariables.begin( );\r\n advance( mapIteratorIntervalLeft, nearestLeftNeighbor );\r\n mapIteratorIntervalRight = sortedIndepedentAndDependentVariables.begin( );\r\n advance( mapIteratorIntervalRight, nearestLeftNeighbor + 1 );\r\n locationTargetIndependentVariableValueInInterval\r\n = ( targetIndependentVariableValue\r\n - mapIteratorIntervalLeft->first )\r\n / ( mapIteratorIntervalRight->first\r\n - mapIteratorIntervalLeft->first );\r\n\r\n // Return the computed value of the dependent variable.\r\n return ( mapIteratorIntervalLeft->second\r\n * ( 1 - locationTargetIndependentVariableValueInInterval )\r\n + mapIteratorIntervalRight->second\r\n * locationTargetIndependentVariableValueInInterval );\r\n}\r\n\r\n} // namespace interpolators\r\n} // mamespace tudat\r\n", "meta": {"hexsha": "fbd1cbc903ad197b6e3aa403d5f3d08f4d6d4a0b", "size": 6983, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Tudat/Mathematics/Interpolators/linearInterpolator.cpp", "max_stars_repo_name": "JPelamatti/ThesisTUDAT", "max_stars_repo_head_hexsha": "b94ce35fb7c8fa44ae83238e296a979dfa3adfe8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Tudat/Mathematics/Interpolators/linearInterpolator.cpp", "max_issues_repo_name": "JPelamatti/ThesisTUDAT", "max_issues_repo_head_hexsha": "b94ce35fb7c8fa44ae83238e296a979dfa3adfe8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Tudat/Mathematics/Interpolators/linearInterpolator.cpp", "max_forks_repo_name": "JPelamatti/ThesisTUDAT", "max_forks_repo_head_hexsha": "b94ce35fb7c8fa44ae83238e296a979dfa3adfe8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-05-30T03:42:22.000Z", "max_forks_repo_forks_event_max_datetime": "2019-05-30T03:42:22.000Z", "avg_line_length": 51.7259259259, "max_line_length": 102, "alphanum_fraction": 0.6830874982, "num_tokens": 1366, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7217432182679956, "lm_q2_score": 0.7549149813536518, "lm_q1q2_score": 0.5448547681609085}} {"text": "// Copyright (c) 2006 Xiaogang Zhang\n// Use, modification and distribution are subject to the\n// Boost Software License, Version 1.0. (See accompanying file\n// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n//\n// History:\n// XZ wrote the original of this file as part of the Google\n// Summer of Code 2006. JM modified it slightly to fit into the\n// Boost.Math conceptual framework better.\n\n#ifndef BOOST_MATH_ELLINT_RD_HPP\n#define BOOST_MATH_ELLINT_RD_HPP\n\n#ifdef _MSC_VER\n#pragma once\n#endif\n\n#include \n#include \n#include \n\n// Carlson's elliptic integral of the second kind\n// R_D(x, y, z) = R_J(x, y, z, z) = 1.5 * \\int_{0}^{\\infty} [(t+x)(t+y)]^{-1/2} (t+z)^{-3/2} dt\n// Carlson, Numerische Mathematik, vol 33, 1 (1979)\n\nnamespace boost { namespace math { namespace detail{\n\ntemplate \nT ellint_rd_imp(T x, T y, T z, const Policy& pol)\n{\n T value, u, lambda, sigma, factor, tolerance;\n T X, Y, Z, EA, EB, EC, ED, EE, S1, S2;\n unsigned long k;\n\n BOOST_MATH_STD_USING\n using namespace boost::math::tools;\n\n static const char* function = \"boost::math::ellint_rd<%1%>(%1%,%1%,%1%)\";\n\n if (x < 0)\n {\n return policies::raise_domain_error(function,\n \"Argument x must be >= 0, but got %1%\", x, pol);\n }\n if (y < 0)\n {\n return policies::raise_domain_error(function,\n \"Argument y must be >= 0, but got %1%\", y, pol);\n }\n if (z <= 0)\n {\n return policies::raise_domain_error(function,\n \"Argument z must be > 0, but got %1%\", z, pol);\n }\n if (x + y == 0)\n {\n return policies::raise_domain_error(function,\n \"At most one argument can be zero, but got, x + y = %1%\", x+y, pol);\n }\n\n // error scales as the 6th power of tolerance\n tolerance = pow(tools::epsilon() / 3, T(1)/6);\n\n // duplication\n sigma = 0;\n factor = 1;\n k = 1;\n do\n {\n u = (x + y + z + z + z) / 5;\n X = (u - x) / u;\n Y = (u - y) / u;\n Z = (u - z) / u;\n if ((tools::max)(abs(X), abs(Y), abs(Z)) < tolerance) \n break;\n T sx = sqrt(x);\n T sy = sqrt(y);\n T sz = sqrt(z);\n lambda = sy * (sx + sz) + sz * sx; //sqrt(x * y) + sqrt(y * z) + sqrt(z * x);\n sigma += factor / (sz * (z + lambda));\n factor /= 4;\n x = (x + lambda) / 4;\n y = (y + lambda) / 4;\n z = (z + lambda) / 4;\n ++k;\n }\n while(k < policies::get_max_series_iterations());\n\n // Check to see if we gave up too soon:\n policies::check_series_iterations(function, k, pol);\n\n // Taylor series expansion to the 5th order\n EA = X * Y;\n EB = Z * Z;\n EC = EA - EB;\n ED = EA - 6 * EB;\n EE = ED + EC + EC;\n S1 = ED * (ED * T(9) / 88 - Z * EE * T(9) / 52 - T(3) / 14);\n S2 = Z * (EE / 6 + Z * (-EC * T(9) / 22 + Z * EA * T(3) / 26));\n value = 3 * sigma + factor * (1 + S1 + S2) / (u * sqrt(u));\n\n return value;\n}\n\n} // namespace detail\n\ntemplate \ninline typename tools::promote_args::type \n ellint_rd(T1 x, T2 y, T3 z, const Policy& pol)\n{\n typedef typename tools::promote_args::type result_type;\n typedef typename policies::evaluation::type value_type;\n return policies::checked_narrowing_cast(\n detail::ellint_rd_imp(\n static_cast(x),\n static_cast(y),\n static_cast(z), pol), \"boost::math::ellint_rd<%1%>(%1%,%1%,%1%)\");\n}\n\ntemplate \ninline typename tools::promote_args::type \n ellint_rd(T1 x, T2 y, T3 z)\n{\n return ellint_rd(x, y, z, policies::policy<>());\n}\n\n}} // namespaces\n\n#endif // BOOST_MATH_ELLINT_RD_HPP\n\n", "meta": {"hexsha": "61014d386608a749687a4d2fec9388f5d1fb149a", "size": 3938, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "boost/boost/math/special_functions/ellint_rd.hpp", "max_stars_repo_name": "randolphwong/mcsema", "max_stars_repo_head_hexsha": "eb5b376736e7f57ff0a61f7e4e5a436bbb874720", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 133.0, "max_stars_repo_stars_event_min_datetime": "2018-04-20T14:09:40.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-15T11:51:25.000Z", "max_issues_repo_path": "boost/boost/math/special_functions/ellint_rd.hpp", "max_issues_repo_name": "randolphwong/mcsema", "max_issues_repo_head_hexsha": "eb5b376736e7f57ff0a61f7e4e5a436bbb874720", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 61.0, "max_issues_repo_issues_event_min_datetime": "2015-05-27T11:20:11.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-20T15:06:21.000Z", "max_forks_repo_path": "boost/boost/math/special_functions/ellint_rd.hpp", "max_forks_repo_name": "randolphwong/mcsema", "max_forks_repo_head_hexsha": "eb5b376736e7f57ff0a61f7e4e5a436bbb874720", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 83.0, "max_forks_repo_forks_event_min_datetime": "2018-04-27T03:58:02.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-11T09:23:40.000Z", "avg_line_length": 30.0610687023, "max_line_length": 95, "alphanum_fraction": 0.5771965465, "num_tokens": 1262, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7549149868676283, "lm_q2_score": 0.7217432062975979, "lm_q1q2_score": 0.5448547631039511}} {"text": "// Boost.Geometry (aka GGL, Generic Geometry Library)\n// QuickBook Example\n\n// Copyright (c) 2011-2012 Barend Gehrels, Amsterdam, the Netherlands.\n\n// This file was modified by Oracle on 2018.\n// Modifications copyright (c) 2018 Oracle and/or its affiliates.\n// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle\n\n// Use, modification and distribution is subject to the Boost Software License,\n// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n//[area_with_strategy\n//` Calculate the area of a polygon\n\n#include \n\n#include \n#include \n#include \n\nnamespace bg = boost::geometry; /*< Convenient namespace alias >*/\n\nint main()\n{\n // Create spherical polygon\n bg::model::polygon > > sph_poly;\n bg::read_wkt(\"POLYGON((0 0,0 1,1 0,0 0))\", sph_poly);\n\n // Create spherical strategy with mean Earth radius in meters\n bg::strategy::area::spherical<> sph_strategy(6371008.8);\n\n // Calculate the area of a spherical polygon\n double area = bg::area(sph_poly, sph_strategy);\n std::cout << \"Area: \" << area << std::endl;\n\n // Create geographic polygon\n bg::model::polygon > > geo_poly;\n bg::read_wkt(\"POLYGON((0 0,0 1,1 0,0 0))\", geo_poly);\n\n // Create geographic strategy with WGS84 spheroid\n bg::srs::spheroid spheroid(6378137.0, 6356752.3142451793);\n bg::strategy::area::geographic<> geo_strategy(spheroid);\n\n // Calculate the area of a geographic polygon\n area = bg::area(geo_poly, geo_strategy);\n std::cout << \"Area: \" << area << std::endl;\n\n return 0;\n}\n\n//]\n\n\n//[area_with_strategy_output\n/*`\nOutput:\n[pre\nArea: 6.18249e+09\nArea: 6.15479e+09\n]\n*/\n//]\n", "meta": {"hexsha": "8d7803d8bf3337d17e9c43a497a7da4f38ded9fc", "size": 1918, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "doc/src/examples/algorithms/area_with_strategy.cpp", "max_stars_repo_name": "jkerkela/geometry", "max_stars_repo_head_hexsha": "4034ac88b214da0eab8943172eff0f1200b0a6cc", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 1155.0, "max_stars_repo_stars_event_min_datetime": "2015-01-10T19:04:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T12:30:30.000Z", "max_issues_repo_path": "doc/src/examples/algorithms/area_with_strategy.cpp", "max_issues_repo_name": "jkerkela/geometry", "max_issues_repo_head_hexsha": "4034ac88b214da0eab8943172eff0f1200b0a6cc", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 623.0, "max_issues_repo_issues_event_min_datetime": "2015-01-02T23:45:23.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-09T11:15:23.000Z", "max_forks_repo_path": "doc/src/examples/algorithms/area_with_strategy.cpp", "max_forks_repo_name": "jkerkela/geometry", "max_forks_repo_head_hexsha": "4034ac88b214da0eab8943172eff0f1200b0a6cc", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 228.0, "max_forks_repo_forks_event_min_datetime": "2015-01-13T12:55:42.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T11:11:05.000Z", "avg_line_length": 29.5076923077, "max_line_length": 105, "alphanum_fraction": 0.697080292, "num_tokens": 556, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867873410141, "lm_q2_score": 0.6825737408694988, "lm_q1q2_score": 0.5448213413479631}} {"text": "/// @file embed_cmp_with_tau.cpp\n/// @brief Implements kernel methods based on Kendall's tau.\n\n#include \n#include \n#include \n\nusing std::min;\nusing std::max;\nusing std::vector;\nusing Eigen::Index;\nusing Eigen::MatrixXd;\nusing Eigen::SparseMatrix;\nusing Eigen::VectorXd;\nusing OGT_NAMESPACE::linalg::kernelForFeatures;\n\ntypedef Eigen::Triplet sptriple;\ntypedef Eigen::SparseMatrix SpMat;\n\nnamespace OGT_NAMESPACE {\nnamespace embed {\n\n/// Finds the index of the specified object pair.\nIndex pair(size_t a, size_t b, size_t nObj) {\n\tIndex i = min(a, b), j = max(a, b);\n\treturn (nObj * (nObj-1) / 2)\n\t\t- ((nObj - i) * (nObj - i - 1) / 2)\n\t\t+ (j - i - 1);\n}\n\n/// Computes a kernel matrix from a sparse feature matrix.\n/// Computes the k1 kernel matrix from the paper cited for embedCmpWithTauForK()\nMatrixXd embedCmpWithTauK1(const vector& cons, size_t nObj) {\n\tvector triplets;\n\ttriplets.reserve(cons.size());\n\tVectorXd norm = VectorXd::Zero(nObj);\n\tIndex nPairs = nObj * (nObj - 1) / 2;\n\tfor (const auto& con : cons) {\n\t\tassert(con.a < nObj && con.b < nObj && con.c < nObj);\n\t\tIndex pr = pair(con.b, con.c, nObj);\n\t\ttriplets.emplace_back(con.a, pr, (con.b < con.c) ? +1 : -1);\n\t\tnorm(con.a)++;\n\t}\n\tSpMat phi(nObj, nPairs);\n\tphi.setFromTriplets(triplets.begin(), triplets.end());\n\tfor (size_t obj = 0; obj < nObj; obj++) {\n\t\tif (norm(obj) > 0) {\n\t\t\tphi.row(obj) /= sqrt(norm(obj));\n\t\t}\n\t}\n\treturn kernelForFeatures(phi);\n}\n\n/// Computes the k2 kernel matrix from the paper cited for embedCmpWithTauForK()\nMatrixXd embedCmpWithTauK2(const vector& cons, size_t nObj) {\n\tvector triplets;\n\ttriplets.reserve(2 * cons.size());\n\tVectorXd norm = VectorXd::Zero(nObj);\n\tIndex nPairs = nObj * (nObj - 1) / 2;\n\tfor (const auto& con : cons) {\n\t\tassert(con.a < nObj && con.b < nObj && con.c < nObj);\n\t\tIndex pr = pair(con.a, con.c, nObj);\n\t\ttriplets.emplace_back(con.b, pr, +1);\n\t\tnorm(con.b)++;\n\n\t\tpr = pair(con.a, con.b, nObj);\n\t\tif (pr >= nPairs) {\n\t\t\tstd::cerr << \"pair \" << pr << \" > \" << nPairs << std::endl;\n\t\t}\n\t\ttriplets.emplace_back(con.c, pr, -1);\n\t\tnorm(con.c)++;\n\t}\n\tSpMat phi(nObj, nPairs);\n\tphi.setFromTriplets(triplets.begin(), triplets.end());\n\tfor (size_t obj = 0; obj < nObj; obj++) {\n\t\tif (norm(obj) > 0) {\n\t\t\tphi.row(obj) /= sqrt(norm(obj));\n\t\t}\n\t}\n\treturn kernelForFeatures(phi);\n}\n\n/// Compute a kernel matrix where K_ij is derived by how similarly points i and\n/// j are ranked by the provided comparisons.\nEmbedResult embedCmpWithTauForK(vector cons, double k1,\n\tdouble k2) {\n\tsize_t nObj = 0;\n\tfor (const auto& con : cons) {\n\t\tnObj = max({nObj, con.a, con.b, con.c});\n\t}\n\tnObj++;\n\tEmbedResult result;\n\tresult.K = MatrixXd::Zero(nObj, nObj);\n\tif (k1 > 0) {\n\t\tresult.K += k1 * embedCmpWithTauK1(cons, nObj);\n\t}\n\tif (k2 > 0) {\n\t\tresult.K += k2 * embedCmpWithTauK2(cons, nObj);\n\t}\n\treturn result;\n}\n\n} // end namespace embed\n} // end namespace OGT_NAMESPACE\n", "meta": {"hexsha": "b3613cdda8f0882016b562f71bdd0b718d752321", "size": 3018, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/lib/embed/embed_cmp_with_tau.cpp", "max_stars_repo_name": "jesand/lloe", "max_stars_repo_head_hexsha": "66235b16fb8cfbb39f72a289c320e701bde94159", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2019-08-11T21:31:22.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-30T09:23:04.000Z", "max_issues_repo_path": "src/lib/embed/embed_cmp_with_tau.cpp", "max_issues_repo_name": "jesand/lloe", "max_issues_repo_head_hexsha": "66235b16fb8cfbb39f72a289c320e701bde94159", "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/lib/embed/embed_cmp_with_tau.cpp", "max_forks_repo_name": "jesand/lloe", "max_forks_repo_head_hexsha": "66235b16fb8cfbb39f72a289c320e701bde94159", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2019-08-11T21:31:33.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-27T20:57:26.000Z", "avg_line_length": 28.7428571429, "max_line_length": 80, "alphanum_fraction": 0.6613651425, "num_tokens": 967, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867873410141, "lm_q2_score": 0.6825737408694988, "lm_q1q2_score": 0.5448213413479631}} {"text": "/**\n * @file Triangulator.hpp\n * @author bwu\n * @brief Triangulator algrithom for triangulation\n * @version 0.1\n * @date 2022-02-22\n */\n#ifndef GENERIC_GEOMETRY_TRI_TRIANGULATOR_HPP\n#define GENERIC_GEOMETRY_TRI_TRIANGULATOR_HPP\n#include \n#include \n#include \"TriangulationOperator.hpp\"\n#include \n#include \n#include \nnamespace generic {\nnamespace geometry {\nnamespace tri {\nusing generic::common::float_type;\n\ntemplate \nclass RuppertRefinement2D;\n\ntemplate \nclass ChewSecondRefinement2D;\n\n/**\n * @brief represents a class that make points and edges to trangulation\n * @tparam num_type support integer and floating points number type\n */\ntemplate \nclass Triangulator2D\n{\npublic:\n using Depth = unsigned short;\n using Point = Point2D;\n using Box = Box2D;\n using Edge = IndexEdge;\n using Vertex = IndexVertex;\n using Triangle = IndexTriangle;\n\n using EdgeSet = typename Triangulation::EdgeSet;\n using TriIdxMap = std::unordered_map;\n\n Triangulation & tri;\n TriangulationOperator op;\n ///@brief constructs a Triangulator2D that manipulating the triangulation data\n Triangulator2D(Triangulation & t) : tri(t), op(t) {}\n \n /**\n * @brief inserts vertices and construct delaunay triangulation\n * \n * @tparam VertexIterator iterator of the sequence of vertices\n * @tparam CoorXGetter functioner type to get coordiante x of input vertex\n * @tparam CoorYGetter functioner type to get coordinate y of input vertex\n * @param begin iterator to the beginning of the vertices sequence\n * @param end iterator to the ending of the vertices sequence\n * @param xGetter functioner object to get coordiante x of input vertex\n * @param yGetter functioner object to get coordiante y of input vertex\n */\n template \n void InsertVertices(VertexIterator begin, VertexIterator end, CoorXGetter xGetter, CoorYGetter yGetter);\n\n /**\n * @brief inserts edges and construct constrained delaunay triangulation\n * \n * @tparam EdgeIterator iterator of the sequence of edges\n * @tparam sVerIdxGetter functioner type to get start vertex index of edge \n * @tparam eVerIdxGetter functioner type to get end vertex index of edge\n * @param begin iterator to the beginning of the edges sequence\n * @param end iterator to the ending of the edges sequence\n * @param sGetter functioner object to get start vertex index of edge\n * @param eGetter functioner object to get end vertex index of edge\n */\n template \n void InsertEdges(EdgeIterator begin, EdgeIterator end, sVerIdxGetter sGetter, eVerIdxGetter eGetter);\n\n ///@brief removes super triangle and produce a convex-hull \n void EraseSuperTriangle();\n ///@brief removes all outer triangles until a boundary defined by constrained edges\n void EraseOuterTriangles();\n /**\n * @brief removes outer triangles and automatically detected holes.\n * Starts from super-triangle and traverses triangles until outer boundary.\n * Triangles outside outer boundary will be removed.\n * Then traversal continues until next boundary.\n * hTriangles between two boundaries will be kept.\n * Traversal to next boundary continues (this time removing triangles).\n * Stops when all triangles are traversed.\n */\n void EraseOuterTrianglesAndHoles();\n\n ///@brief clears all data in triangulation\n void Clear();\nprivate:\n template \n Box Extent(VertexIterator begin, VertexIterator end, CoorXGetter xGetter, CoorYGetter yGetter);\n\n void AddSuperTriangle(const Box & box);\n \n void InsertOneEdge(const Edge & edge);\n void InsertOneVertex(const Point & pos);\n \n VerIdx InsertPointInTriangle(const Point & pos, TriIdx i0, std::stack & out);\n VerIdx InsertPointOnSharedEdge(const Point & pos, TriIdx i1, TriIdx i2, std::stack & out);\n VerIdx InsertPointOnBoundaryEdge(const Point & pos, TriIdx it, const Edge & e, std::stack & out);\n\n void Delaunay(std::stack & triangls, VerIdx iv);\n bool isNeedFlip(VerIdx iv, TriIdx it, TriIdx itOp) const;\n bool isInCircumCircle(const Point & pos, const Point & v1, const Point & v2, const Point & v3) const;\n\n std::tuple IntersectedTriangle(VerIdx iA,\n const TriIdxSet & candidates,\n const Point & a, const Point & b) const; \n void RemoveSuperTriangleVertices();\n template \n void RemoveTriangles(TriIdxIterator begin, TriIdxIterator end);\n\n TriIdx TriangulatePseudoPolygon(VerIdx ia, VerIdx ib, const std::vector & points);\n TriIdx PesudoPolyOuterTriangle(VerIdx ia, VerIdx ib) const;\n VerIdx FindDelaunayPoint(VerIdx ia, VerIdx ib, const std::vector & points) const;\n std::pair, std::vector >\n SplitPsedoPolygon(VerIdx vi, const std::vector & points);\n\n TriIdxSet Grow2Boundary(std::stack & seeds) const;\n std::vector CalculateTriangleDepths(const std::vector & vertices,\n const TriangleVec & triangles,\n const EdgeSet & fixedEdges);\n TriIdxSet PeelLayer(std::stack seeds,\n const TriangleVec & triangles,\n const EdgeSet & fixedEdges,\n Depth depth,\n std::vector & triDepths);\n \n void RebuildRTree();\n};\n\ntemplate \ntemplate \ninline void Triangulator2D::InsertVertices(VertexIterator begin, VertexIterator end, CoorXGetter xGetter, CoorYGetter yGetter)\n{\n if(tri.vertices.empty()){\n auto bounds = Extent(begin, end, xGetter, yGetter);\n AddSuperTriangle(bounds);\n }\n \n tri.vertices.reserve(tri.vertices.size() + std::distance(begin, end));\n for(auto iter = begin; iter != end; ++iter){\n InsertOneVertex(Point(xGetter(*iter), yGetter(*iter)));\n }\n}\n\ntemplate \ntemplate \ninline void Triangulator2D::InsertEdges(EdgeIterator begin, EdgeIterator end, sVerIdxGetter sGetter, eVerIdxGetter eGetter)\n{\n for(auto iter = begin; iter != end; ++iter){\n InsertOneEdge(Edge(sGetter(*iter) + 3, eGetter(*iter) + 3));\n }\n op.ReallocateTriangulation();\n}\n\ntemplate \ninline void Triangulator2D::EraseSuperTriangle()\n{\n TriIdxVec toErase;\n for(TriIdx it = 0; it < tri.triangles.size(); ++it){\n auto & t = tri.triangles[it];\n if(t.vertices[0] < 3 || t.vertices[1] < 3 || t.vertices[2] < 3)\n toErase.push_back(it);\n }\n RemoveTriangles(toErase.begin(), toErase.end());\n RemoveSuperTriangleVertices();\n}\n\ntemplate \ninline void Triangulator2D::EraseOuterTriangles()\n{\n std::stack seed(std::deque(1, *(tri.vertices[0].triangles.begin())));\n TriIdxSet toErase = Grow2Boundary(seed);\n RemoveTriangles(toErase.begin(), toErase.end());\n RemoveSuperTriangleVertices();\n}\n\ntemplate \ninline void Triangulator2D::EraseOuterTrianglesAndHoles()\n{\n auto triDepths = CalculateTriangleDepths(tri.vertices, tri.triangles, tri.fixedEdges);\n\n TriIdxVec toErase;\n toErase.reserve(tri.triangles.size());\n for(size_t it = 0; it != tri.triangles.size(); ++it){\n if(triDepths[it] % 2 == 0)\n toErase.push_back(it);\n }\n RemoveTriangles(toErase.begin(), toErase.end());\n RemoveSuperTriangleVertices();\n}\n\ntemplate \ntemplate \ninline Box2D Triangulator2D::Extent(VertexIterator begin, VertexIterator end, CoorXGetter xGetter, CoorYGetter yGetter)\n{\n Box box;\n for(auto iter = begin; iter != end; ++iter)\n box |= Point(xGetter(*iter), yGetter(*iter));\n return box;\n}\n\ntemplate \ninline void Triangulator2D::AddSuperTriangle(const Box & box)\n{\n auto center = box.Center();\n auto l = box.Length();\n auto w = box.Width();\n l *= l; w *= w;\n auto r = 0.5 * 1.1 * std::sqrt(float_type(l + w));\n auto sx = r * std::sqrt(3);\n VerIdx iv1 = op.AddOneVertex(Point(center[0] - sx, center[1] - r), {0});\n VerIdx iv2 = op.AddOneVertex(Point(center[0] + sx, center[1] - r), {0});\n VerIdx iv3 = op.AddOneVertex(Point(center[0], center[1] + 2 * r), {0});\n Triangle super{{iv1, iv2, iv3}, {noNeighbor, noNeighbor, noNeighbor}};\n op.AddOneTriangle(super);\n}\n\ntemplate \ninline void Triangulator2D::InsertOneVertex(const Point & pos)\n{\n VerIdx iv;\n std::stack tris;\n auto [it1, it2] = op.TraversalTriangleAt(pos);\n if(noNeighbor == it2) iv = op.InsertPointInTriangle(pos, it1, tris);\n else iv = op.InsertPointOnSharedEdge(pos, it1, it2, tris);\n Delaunay(tris, iv);\n}\n\ntemplate \ninline void Triangulator2D::InsertOneEdge(const Edge & edge)\n{\n auto is = edge.v1();\n auto ie = edge.v2();\n if(is == ie) return;\n\n const Vertex & vs = tri.vertices[is];\n const Vertex & ve = tri.vertices[ie];\n\n if(Vertex::isShareEdge(vs, ve)){\n tri.fixedEdges.insert(Edge(is, ie));\n return;\n }\n\n TriIdx it;\n VerIdx ivLeft, ivRight;\n std::tie(it, ivLeft, ivRight) = IntersectedTriangle(is, vs.triangles, tri.VertexPoint(vs), tri.VertexPoint(ve));\n if(it == noNeighbor){\n tri.fixedEdges.insert(Edge(is, ivLeft));\n return InsertOneEdge(Edge(ivLeft, ie));\n }\n\n std::vector intersected(1, it);\n std::vector ptsLeft(1, ivLeft);\n std::vector ptsRight(1, ivRight);\n VerIdx iv = is;\n Triangle t = tri.triangles[it];\n const auto & vrts = t.vertices;\n while(std::find(vrts.begin(), vrts.end(), ie) == vrts.end()){\n \n auto itOp = t.VeOpTn(iv);\n const Triangle & tOp = tri.triangles[itOp];\n auto ivOp = tOp.TnOpVe(it);\n auto vOp = tri.vertices[ivOp];\n\n intersected.push_back(itOp);\n it = itOp;\n t = tri.triangles[it];\n\n PointLineLocation loc = GetPointLineLocation(tri.VertexPoint(vOp), tri.VertexPoint(vs), tri.VertexPoint(ve));\n if(loc == PointLineLocation::Left){\n ptsLeft.push_back(ivOp);\n iv = ivLeft;\n ivLeft = ivOp;\n }\n else if(loc == PointLineLocation::Right){\n ptsRight.push_back(ivOp);\n iv = ivRight;\n ivRight = ivOp;\n }\n else { ie = ivOp; }\n }\n\n auto iter = intersected.begin();\n for(; iter != intersected.end(); ++iter)\n op.RemoveOneTriangle(*iter);\n \n auto itLeft = TriangulatePseudoPolygon(is, ie, ptsLeft);\n std::reverse(ptsRight.begin(), ptsRight.end());\n auto itRight = TriangulatePseudoPolygon(ie, is, ptsRight);\n \n tri.ChangeNeighbor(itLeft, noNeighbor, itRight);\n tri.ChangeNeighbor(itRight, noNeighbor, itLeft);\n\n tri.fixedEdges.insert(Edge(is, ie));\n if(ie != edge.v2())\n return InsertOneEdge(Edge(ie, edge.v2()));\n}\n\ntemplate \ninline void Triangulator2D::Delaunay(std::stack & triangles, VerIdx iv)\n{\n while(!triangles.empty()){\n TriIdx it = triangles.top();\n triangles.pop();\n\n const auto & triangle = tri.triangles[it];\n TriIdx itOp = triangle.VeOpTn(iv);\n if(itOp == noNeighbor) continue;\n if(isNeedFlip(iv, it, itOp)){\n tri.FlipEdge(it, itOp);\n triangles.push(it);\n triangles.push(itOp);\n }\n }\n}\n\ntemplate \ninline bool Triangulator2D::isNeedFlip(VerIdx iv, TriIdx it, TriIdx itOp) const\n{\n const Triangle & triOp = tri.triangles[itOp];\n size_t i = triOp.TnOpiVe(it);\n VerIdx ivOp = triOp.vertices[i];\n if(iv < 3 && ivOp < 3) return false;\n\n VerIdx ivCw = triOp.vertices[Triangle:: cw(i)];\n VerIdx ivCcw = triOp.vertices[Triangle::ccw(i)];\n const Point & p0 = tri.VerIdxPoint(iv);\n const Point & p1 = tri.VerIdxPoint(ivCw);\n const Point & p2 = tri.VerIdxPoint(ivOp);\n const Point & p3 = tri.VerIdxPoint(ivCcw);\n if(ivCw < 3) return GetPointLineLocation(p1, p2, p3) == GetPointLineLocation(p0, p2, p3);\n else if(ivCcw < 3) return GetPointLineLocation(p3, p1, p2) == GetPointLineLocation(p0, p1, p2);\n else return isInCircumCircle(p0, p1, p2, p3);\n}\n\ntemplate \ninline bool Triangulator2D::isInCircumCircle(const Point & p, const Point & p1, const Point & p2, const Point & p3) const\n{\n return geometry::isInCircumCircle(p1, p2, p3, p, false);\n}\n\ntemplate \ninline std::tuple\nTriangulator2D::IntersectedTriangle(VerIdx iA,\n const TriIdxSet & candidates,\n const Point & a, const Point & b) const\n{\n for(TriIdx it : candidates){\n const Triangle & triangle = tri.triangles[it];\n auto i = triangle.iVe(iA);\n auto iv1 = triangle.vertices[Triangle::cw(i)];\n auto iv2 = triangle.vertices[Triangle::ccw(i)];\n auto locP1 = GetPointLineLocation(tri.VerIdxPoint(iv1), a, b);\n auto locP2 = GetPointLineLocation(tri.VerIdxPoint(iv2), a, b);\n if(locP2 == PointLineLocation::Right){\n if(locP1 == PointLineLocation::OnLine)\n return std::make_tuple(noNeighbor, iv1, iv2);\n else if(locP1 == PointLineLocation::Left)\n return std::make_tuple(it, iv1, iv2);\n }\n }\n throw std::runtime_error(\"Could not find vertex triangle intersected by \"\n \"edge. Note: can be caused by duplicate points.\");\n}\n\ntemplate \ninline void Triangulator2D::RemoveSuperTriangleVertices()\n{\n for(VerIdx iv = 0; iv < 3; ++iv)\n op.RemoveOneVertex(iv);\n op.ReallocateTriangulation();\n}\n\ntemplate \ntemplate \nvoid Triangulator2D::RemoveTriangles(TriIdxIterator begin, TriIdxIterator end)\n{\n for(auto iter = begin; iter != end; ++iter)\n op.RemoveOneTriangle(*iter);\n op.ReallocateTriangulation();\n}\n\ntemplate \ninline TriIdx Triangulator2D::TriangulatePseudoPolygon(VerIdx ia, VerIdx ib, const std::vector & points)\n{\n if(points.empty())\n return PesudoPolyOuterTriangle(ia, ib);\n \n VerIdx ic = FindDelaunayPoint(ia, ib, points);\n auto split = SplitPsedoPolygon(ic, points);\n auto it2 = TriangulatePseudoPolygon(ic, ib, split.second);\n auto it1 = TriangulatePseudoPolygon(ia, ic, split.first);\n Triangle t = {{ia, ib, ic}, {noNeighbor, it2, it1}};\n TriIdx it = op.AddOneTriangle(t);\n if(it1 != noNeighbor){\n if(split.first.empty())\n tri.ChangeNeighbor(it1, ia, ic, it);\n else\n tri.triangles[it1].neighbors[0] = it;\n }\n if(it2 != noNeighbor){\n if(split.second.empty())\n tri.ChangeNeighbor(it2, ic, ib, it);\n else\n tri.triangles[it2].neighbors[0] = it;\n }\n tri.AddAdjacentTriangle(ia, it);\n tri.AddAdjacentTriangle(ib, it);\n tri.AddAdjacentTriangle(ic, it);\n return it;\n}\n\ntemplate \ninline TriIdx Triangulator2D::PesudoPolyOuterTriangle(VerIdx ia, VerIdx ib) const\n{\n const auto & aTris = tri.vertices[ia].triangles;\n const auto & bTris = tri.vertices[ib].triangles;\n for(auto iter = aTris.begin(); iter != aTris.end(); ++iter){\n if(std::find(bTris.begin(), bTris.end(), *iter) != bTris.end())\n return *iter;\n }\n return noNeighbor;\n}\n\ntemplate \ninline VerIdx Triangulator2D::FindDelaunayPoint(VerIdx ia, VerIdx ib, const std::vector & vs) const\n{\n assert(!vs.empty());\n const auto & a = tri.VerIdxPoint(ia);\n const auto & b = tri.VerIdxPoint(ib);\n VerIdx ic = vs.front();\n auto c = tri.VerIdxPoint(ic);\n for(auto iter = vs.begin(); iter != vs.end(); ++iter){\n const auto & v = tri.VerIdxPoint(*iter);\n if(!isInCircumCircle(v, a, b, c)) continue;\n ic = *iter;\n c = tri.VerIdxPoint(ic);\n }\n return ic;\n}\n\ntemplate \ninline std::pair, std::vector >\nTriangulator2D::SplitPsedoPolygon(VerIdx vi, const std::vector & points)\n{\n std::pair, std::vector > out;\n auto iter = points.begin();\n for(; vi != *iter; ++iter)\n out.first.push_back(*iter);\n for(++iter; iter != points.end(); ++iter)\n out.second.push_back(*iter);\n return out;\n}\n\ntemplate \ninline TriIdxSet Triangulator2D::Grow2Boundary(std::stack & seeds) const\n{\n TriIdxSet traversed;\n while(!seeds.empty()){\n auto it = seeds.top();\n seeds.pop();\n traversed.insert(it);\n const auto & triange = tri.triangles[it];\n for(auto i = 0; i < 3; ++i){\n Edge opEdge = Edge(\n triange.vertices[Triangle::ccw(i)],\n triange.vertices[Triangle::cw(i)]);\n if(tri.fixedEdges.count(opEdge)) continue;\n TriIdx in = triange.neighbors[Triangle::iVeOpiTn(i)];\n if(in != noNeighbor && !traversed.count(in))\n seeds.push(in);\n }\n }\n return traversed;\n}\n\ntemplate \ninline std::vector::Depth>\nTriangulator2D::CalculateTriangleDepths(const std::vector & vertices,\n const TriangleVec & triangles,\n const EdgeSet & fixedEdges)\n{\n std::vector triDepths(triangles.size(), std::numeric_limits::max());\n\n using TriDeque = std::deque;\n using TriStack = std::stack;\n TriStack seeds(TriDeque(1, *(tri.vertices[0].triangles.begin())));\n Depth layerDepth = 0;\n do{\n auto newSeeds = PeelLayer(seeds, triangles, fixedEdges, layerDepth++, triDepths);\n seeds = TriStack(TriDeque(newSeeds.begin(), newSeeds.end()));\n } while(!seeds.empty());\n\n return triDepths;\n}\n\ntemplate \ninline TriIdxSet Triangulator2D::PeelLayer(std::stack seeds,\n const TriangleVec & triangles,\n const EdgeSet & fixedEdges,\n Depth depth,\n std::vector & triDepths)\n{\n TriIdxSet behindBoundary;\n while(!seeds.empty()){\n auto it = seeds.top();\n seeds.pop();\n triDepths[it] = depth;\n behindBoundary.erase(it);\n const auto & triangle = triangles[it];\n for(auto i = 0; i < 3; ++i){\n Edge opEdge(triangle.vertices[Triangle::ccw(i)],\n triangle.vertices[Triangle:: cw(i)]);\n TriIdx in = triangle.neighbors[Triangle::iVeOpiTn(i)];\n if(in == noNeighbor || triDepths[in] <= depth) continue;\n if(fixedEdges.count(opEdge)){\n behindBoundary.insert(in);\n continue;\n }\n seeds.push(in);\n }\n }\n return behindBoundary;\n}\n\ntemplate \ninline void Triangulator2D::Clear()\n{\n op.Clear();\n}\n\ntemplate \nclass ConvexTriangulator2D\n{\n struct DoublyLinkedIndex { VerIdx prev, curr, next; };\npublic:\n using float_t = float_type;\n using Point = Point2D;\n using Edge = IndexEdge;\n using Vertex = IndexVertex;\n using Triangle = IndexTriangle;\n using Utility = TriangulationUtility;\n using EdgeSet = typename Triangulation::EdgeSet;\n using TriIdxMap = std::unordered_map;\n \n\n Triangulation & tri;\n TriangulationOperator op;\n ConvexTriangulator2D(Triangulation & t) : tri(t), op(t) { op.Clear(); }\n\n template \n void Triangulate(VertexIterator begin, VertexIterator end, CoorXGetter xGetter, CoorYGetter yGetter)\n {\n const size_t size = std::distance(begin, end);\n assert(size >= 3);\n \n size_t i = 0;\n std::vector vertices(size);\n for(auto iter = begin; iter != end; ++iter){\n vertices[i++].curr = op.AddOneVertex(Point(xGetter(*iter), yGetter(*iter)));\n }\n\n for(size_t i = 0; i < size; ++i){\n vertices[i].prev = vertices[(i + size - 1) % size].curr;\n vertices[i].next = vertices[(i + 1) % size].curr;\n }\n \n for(size_t i = size - 1; i > 3; --i){\n vertices[i - 1].next = vertices[i].next;\n }\n\n TriIdx it = AddTriangle(vertices[0].curr, vertices[1].curr, vertices[2].curr);\n for(size_t i = 3; i < size; ++i)\n ConvexInsertVertex(vertices[i].curr, Edge(vertices[i].prev, vertices[i].next));\n \n op.ReallocateTriangulation();\n\n }\n\nprivate:\n\n TriIdx AddTriangle(VerIdx iv1, VerIdx iv2, VerIdx iv3)\n {\n return op.AddOneTriangle(iv1, iv2, iv3);\n }\n\n void ConvexInsertVertex(VerIdx iv, const Edge & e)\n {\n TriIdx it;\n std::tie(it, std::ignore) = tri.GetTriangles(e);\n VerIdx iu = e.v1(), iw = e.v2();\n if(noNeighbor == it){\n AddTriangle(iv, iu, iw);\n return;\n }\n VerIdx ix = tri.triangles[it].EgOpVe(e);\n if(Utility::isInCircumCircle(tri, it, tri.VerIdxPoint(iv))){\n op.RemoveOneTriangle(it);\n ConvexInsertVertex(iv, Edge(iu, ix));\n ConvexInsertVertex(iv, Edge(ix, iw));\n }\n else AddTriangle(iv, iu, iw);\n }\n};\n\nstruct DuplicatesInfo\n{\n std::vector mapping;\n std::unordered_set duplicates;\n};\n\n/**\n * @brief utility functions to find duplicated points within given tolerance\n * @param[in] points point collection\n * @param[in] tolerance treat points distance less than tolerance as duplicated \n * @return DuplicatesInfo duplicate results\n */\ntemplate \ninline DuplicatesInfo FindDuplicates(const std::vector > & points, num_type tolerance)\n{\n using Grid = std::pair;\n struct GridHash\n {\n size_t operator() (const Grid & grid) const noexcept\n {\n size_t seed(0);\n boost::hash_combine(seed, grid.first);\n boost::hash_combine(seed, grid.second);\n return seed;\n }\n };\n\n struct GridCmp\n {\n bool operator() (const Grid & g1, const Grid & g2) const noexcept\n {\n return g1 == g2;\n }\n };\n\n using GridIdxMap = std::unordered_map;\n const size_t shift = std::numeric_limits::max() / 2;\n auto toGrid = [tolerance, shift](const Point2D & p)\n {\n size_t x = static_cast(p[0] / tolerance + shift);\n size_t y = static_cast(p[1] / tolerance + shift);\n return std::make_pair(x, y);\n };\n\n GridIdxMap gridIdxMap;\n DuplicatesInfo dup { std::vector(points.size()), std::unordered_set() };\n for(size_t iIn = 0, iOut = iIn; iIn < points.size(); ++iIn){\n bool isUnique;\n typename GridIdxMap::const_iterator iter;\n std::tie(iter, isUnique) = gridIdxMap.insert(std::make_pair(toGrid(points[iIn]), iOut));\n if(isUnique){\n dup.mapping[iIn] = iOut++;\n continue;\n }\n dup.mapping[iIn] = iter->second;\n dup.duplicates.insert(iIn);\n }\n return dup;\n}\n\n/**\n * @brief remaps edges with duplicated functions\n * @param[in, out] edges input edges\n * @param[in] mapping duplicated info, point n is duplicated with mapping[n]\n */\ninline void RemapEdges(std::list & edges, const std::vector & mapping)\n{\n for(auto iter = edges.begin(); iter != edges.end();){\n iter->SetVertices(mapping[iter->v1()], mapping[iter->v2()]);\n if(iter->v1() == iter->v2())\n iter = edges.erase(iter);\n else ++iter;\n }\n}\n\n/**\n * @brief removes duplicate points of a point collection\n * @param[in, out] points the given point collection \n * @param duplicates duplicated info, point n is duplicated with mapping[n]\n */\ntemplate \ninline void RemoveDuplicates(std::vector > & points, const std::unordered_set & duplicates)\n{\n for(size_t i = 0, iNew = i; i < points.size(); ++i){\n if(duplicates.count(i)) continue;\n points[iNew] = points[i];\n iNew++;\n }\n points.erase(points.end() - duplicates.size(), points.end());\n}\n\n/**\n * @brief removes duplicate points and remap edges\n * @param[in, out] points the given point collection \n * @param[in, out] edges the given edge collection \n * @param[in] tolerance merge tolerance\n * @return DuplicatesInfo duplicate results\n */\ntemplate \ninline DuplicatesInfo RemoveDuplicatesAndRemapEdges(std::vector > & points, std::list & edges, num_type tolerance)\n{\n DuplicatesInfo dup = FindDuplicates(points, tolerance);\n RemoveDuplicates(points, dup.duplicates);\n RemapEdges(edges, dup.mapping);\n return dup;\n}\n\n}//namespace tri\n}//namespace geometry\n}//namespace generic\n#endif//GENERIC_GEOMETRY_TRI_TRIANGULATOR_HPP\n", "meta": {"hexsha": "3d940983f184f5fbe5db7897fb2d5efa37821ac3", "size": 26358, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "geometry/Triangulator.hpp", "max_stars_repo_name": "Draaaaaaven/generic", "max_stars_repo_head_hexsha": "f72a1896058486ef865cb2a0a722d70b2398a7af", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2022-01-05T02:34:04.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-19T13:51:50.000Z", "max_issues_repo_path": "geometry/Triangulator.hpp", "max_issues_repo_name": "Draaaaaaven/generic", "max_issues_repo_head_hexsha": "f72a1896058486ef865cb2a0a722d70b2398a7af", "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": "geometry/Triangulator.hpp", "max_forks_repo_name": "Draaaaaaven/generic", "max_forks_repo_head_hexsha": "f72a1896058486ef865cb2a0a722d70b2398a7af", "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": 35.9590723056, "max_line_length": 143, "alphanum_fraction": 0.6407542302, "num_tokens": 6776, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867873410141, "lm_q2_score": 0.6825737408694988, "lm_q1q2_score": 0.5448213413479631}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace boost::numeric::ublas;\nusing namespace boost::random;\nusing namespace boost::program_options;\n\nint main (int argc, char* argv[]) {\n int scale = 2, depth = 2;\n\n try {\n options_description opts(\"options\");\n opts.add_options()\n (\"help,h\", \"help message\")\n (\"scale,S\", value()->implicit_value(2), \"2^scale motif verticies\")\n (\"depth,D\", value()->implicit_value(2), \"recursive depth\");\n \n variables_map vm;\n store(parse_command_line(argc, argv, opts), vm);\n notify(vm);\n\n if (vm.count(\"help\")) {\n cout << opts << endl;\n return 0;\n }\n \n if (vm.count(\"scale\")) scale = vm[\"scale\"].as();\n if (vm.count(\"depth\")) depth = vm[\"depth\"].as();\n } catch(exception& e) {\n cout << e.what() << endl;\n cout << \"use '-h' to get help.\" << endl;\n return -1;\n }\n\n unsigned motif_size = 1 << scale;\n unsigned result_size = 1 << (scale * (depth + 1));\n unsigned motif_mask = motif_size - 1;\n\n cout << result_size << endl;\n\n boost::mt19937 rng(time(0));\n boost::uniform_int<> binary(0, 1);\n\n matrix motif(motif_size, motif_size);\n\n for (unsigned i = 0; i < motif_size; ++ i)\n for (unsigned j = 0; j < motif_size; ++ j)\n motif(i, j) = (j < i) ? binary(rng) : 0;\n\n motif += trans(motif);\n\n cout << motif << endl;\n\n auto kronecker_cell = [=](unsigned i, unsigned j) {\n int cell = 1;\n unsigned motif_i = i, motif_j = j;\n for (unsigned d = 0; d < depth + 1; ++ d) {\n cell *= motif(motif_i & motif_mask, motif_j & motif_mask);\n motif_i >>= scale;\n motif_j >>= scale;\n }\n return cell;\n };\n\n for (unsigned i = 0; i < result_size; ++ i ) {\n for (unsigned j = 0; j < result_size; ++ j)\n cout << kronecker_cell(i, j) << ' ';\n cout << endl;\n }\n\n return 0;\n}\n", "meta": {"hexsha": "7caaeb6c8720cdebe511760f52a19755b2b5ff94", "size": 2180, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "practice/matrix4.cpp", "max_stars_repo_name": "ShiZhan/graph-study", "max_stars_repo_head_hexsha": "a983bdad09397b07885f75509baeefd5b9b7464f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2017-03-14T07:27:34.000Z", "max_stars_repo_stars_event_max_datetime": "2017-03-15T03:11:31.000Z", "max_issues_repo_path": "practice/matrix4.cpp", "max_issues_repo_name": "Zhan2012/graph-study", "max_issues_repo_head_hexsha": "a983bdad09397b07885f75509baeefd5b9b7464f", "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": "practice/matrix4.cpp", "max_forks_repo_name": "Zhan2012/graph-study", "max_forks_repo_head_hexsha": "a983bdad09397b07885f75509baeefd5b9b7464f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.9487179487, "max_line_length": 83, "alphanum_fraction": 0.5417431193, "num_tokens": 586, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867777396211, "lm_q2_score": 0.6825737473266735, "lm_q1q2_score": 0.5448213399483358}} {"text": "#include \"advent.hpp\"\n#include \"intersect.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\n#include \n#include \n\nusing std::vector;\nusing std::pair;\nusing std::string;\nusing std::ifstream;\nusing std::ranges::stable_sort;\n\nstruct def {\n static constexpr i64 nd{3}; // number of dimensions\n static constexpr i64 ncommon{12}; // number of beacons in common\n};\n\nusing point = std::tuple;\n\nstruct scanner {\n i64 id;\n std::optional position; // scanner position\n Eigen::MatrixXd beacons; // beacon positions\n Eigen::Matrix distances; // distance matrix between beacons\n Eigen::Matrix sorted_distances; // distance matrix between beacons\n\n explicit scanner(i64 i, Eigen::MatrixXd b)\n : id(i)\n , position(std::nullopt)\n , beacons(std::move(b))\n , distances(compute_distance_matrix(beacons))\n , sorted_distances(distances)\n {\n // sort the values so we can use intersection count\n for (auto col : sorted_distances.colwise()) {\n stable_sort(col);\n }\n }\n\n static auto compute_distance_matrix(auto const& m) -> Eigen::Matrix\n {\n Eigen::Matrix d = decltype(d)::Zero(m.cols(), m.cols());\n for (auto i = 0L; i < m.cols()-1; ++i) {\n for (auto j = i+1; j < m.cols(); ++j) {\n d(i, j) = d(j, i) = static_cast((m.col(i) - m.col(j)).matrix().squaredNorm());\n }\n }\n return d;\n }\n\n [[nodiscard]] auto find_common_beacons(scanner const& s) const\n {\n vector> map;\n for (auto i = 0L; i < distances.cols(); ++i) {\n auto ci = sorted_distances.col(i);\n for (auto j = 0L; j < s.distances.cols(); ++j) {\n auto cj = s.sorted_distances.col(j);\n auto count = detail::count_intersect(ci.data(), ci.size(), cj.data(), cj.size());\n if(count == def::ncommon) {\n vector chosen(s.distances.cols(), 0);\n for (auto k = 0L; k < distances.cols(); ++k) {\n for (auto l = 0L; l < s.distances.cols(); ++l) {\n if (!chosen[l] && distances(k, i) == s.distances(l, j)) {\n chosen[l] = 1;\n map.emplace_back(l, k);\n }\n }\n }\n return map;\n }\n }\n }\n return map;\n }\n\n auto translate(scanner const& dest, vector> const& map) -> void\n {\n vector idx; idx.reserve(map.size());\n vector dest_idx; dest_idx.reserve(map.size());\n for(auto [i, j] : map) {\n idx.push_back(j);\n dest_idx.push_back(i);\n }\n Eigen::MatrixXd tr = Eigen::umeyama(beacons(Eigen::all, idx), dest.beacons(Eigen::all, dest_idx)).array().round();\n auto t = tr.col(tr.cols()-1).template cast();\n position = {t(0), t(1), t(2)};\n beacons = (tr * beacons.colwise().homogeneous()).block(0, 0, beacons.rows(), beacons.cols());\n }\n\n friend auto operator<<(std::ostream& os, scanner const& s) -> std::ostream&;\n};\n\nauto operator<<(std::ostream& os, scanner const& s) -> std::ostream&\n{\n os << \"scanner \" << s.id << \" position: \";\n if (s.position) { \n auto [x, y, z] = *s.position;\n os << \"(\" << x << \",\" << y << \",\" << z << \")\\n\";\n }\n else { os << \"(?,?,?)\\n\"; }\n os << \"beacons:\\n\";\n os << s.beacons << \"\\n\";\n return os;\n}\n\nauto read_input(int argc, char** argv) {\n // read input\n if (argc < 2) {\n throw std::runtime_error(\"Error: no input.\");\n }\n\n ifstream infile(argv[1]);\n string line;\n\n vector scanners;\n\n vector> values;\n i64 id{0};\n while (std::getline(infile, line)) {\n if (line[0] == '-' && line[1] == '-') { continue; }\n if (line.empty()) {\n Eigen::MatrixXd beacons(def::nd, values.size());\n for (auto i = 0L; i < std::ssize(values); ++i) {\n beacons.col(i) = Eigen::Map>(values[i].data(), std::ssize(values[i]));\n }\n scanners.emplace_back(id++, std::move(beacons));\n values.clear();\n continue;\n }\n values.emplace_back();\n scn::scan_list(line, values.back(), ',');\n }\n scanners[0].position = {0, 0, 0};\n\n return scanners;\n}\n\nauto day19(int argc, char** argv) -> int\n{\n auto scanners = read_input(argc, argv);\n vector known{scanners[0]};\n\n while (known.size() < scanners.size()) {\n auto sz = std::ssize(known); \n for (auto i = 0L; i < sz; ++i) {\n auto const& s = known[i];\n for (auto& p : scanners) {\n if (p.position) { continue; }\n if (auto map = p.find_common_beacons(s); std::ssize(map) == def::ncommon) {\n p.translate(s, map);\n known.push_back(p);\n break;\n }\n }\n }\n }\n\n std::set unique_beacons;\n auto manhattan = 0L;\n for (auto const& s : scanners) {\n for (auto col : s.beacons.colwise()) {\n auto t = col.template cast();\n unique_beacons.insert({t(0), t(1), t(2)});\n }\n auto [x1, y1, z1] = *s.position;\n Eigen::Array v{x1, y1, z1};\n for (auto const& p : scanners) {\n auto [x2, y2, z2] = *p.position;\n Eigen::Array u{x2, y2, z2}; \n manhattan = std::max(manhattan, (u - v).abs().sum());\n }\n }\n fmt::print(\"part 1: {}\\n\", unique_beacons.size());\n fmt::print(\"part 2: {}\\n\", manhattan);\n\n return 0;\n}\n", "meta": {"hexsha": "68935f2e95bd6f43de931fd8d6048f4b52e3d666", "size": 6029, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "source/day19.cpp", "max_stars_repo_name": "foolnotion/aoc2021", "max_stars_repo_head_hexsha": "e2bbcd8cab2a1a7b9922694daff7d289a905c133", "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": "source/day19.cpp", "max_issues_repo_name": "foolnotion/aoc2021", "max_issues_repo_head_hexsha": "e2bbcd8cab2a1a7b9922694daff7d289a905c133", "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": "source/day19.cpp", "max_forks_repo_name": "foolnotion/aoc2021", "max_forks_repo_head_hexsha": "e2bbcd8cab2a1a7b9922694daff7d289a905c133", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-12-29T23:05:48.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-29T23:05:48.000Z", "avg_line_length": 31.7315789474, "max_line_length": 122, "alphanum_fraction": 0.5090396417, "num_tokens": 1620, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107914029486, "lm_q2_score": 0.5813030906443134, "lm_q1q2_score": 0.5448035296277369}} {"text": "/*\n This file is part of utils-lib.\n\n Copyright (c) 2020, 2021, 2022 Bernardo Fichera \n\n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included in all\n copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n SOFTWARE.\n*/\n\n#ifndef utils_lib_GRADIENT_CHECKER_HPP\n#define utils_lib_GRADIENT_CHECKER_HPP\n\n#include \n#include \n\nnamespace utils_lib {\n template \n class DerivativeChecker {\n public:\n DerivativeChecker(const size_t& dim = 1, const size_t& res = 51) : _dim(dim), _res(res) {}\n\n DerivativeChecker& setResolution(const size_t& res)\n {\n _res = res;\n return *this;\n }\n\n DerivativeChecker& setDimension(const size_t& dim)\n {\n _dim = dim;\n return *this;\n }\n\n Eigen::Matrix numericalGradient()\n {\n Eigen::Matrix M(_t.rows(), 2);\n M << _t, _G;\n\n return M;\n }\n\n Eigen::Matrix numericalHessian()\n {\n Eigen::Matrix M(_t.rows(), 2);\n M << _t, _H;\n\n return M;\n }\n\n template \n bool checkGradient(Function f, Gradient g, const Eigen::VectorXd& x, const Eigen::VectorXd& v)\n {\n // Init G\n _G.setZero(_res);\n\n // Generate log spaced perturbation intensities\n _t = Eigen::Matrix::LinSpaced(_res, -8, 0);\n for (size_t i = 0; i < _t.rows(); i++)\n _t(i) = std::pow(10, _t(i));\n\n // Calculate first order Taylor expansion\n for (size_t i = 0; i < _t.rows(); i++)\n _G(i) = std::abs(f(x + _t(i) * v) - f(x) - _t(i) * g(x).dot(v));\n\n // Transform to log space\n _t = _t.array().log();\n _G = _G.array().log();\n\n // Calculate mean slope for central values\n Precision mean_slope = 0, num_points = 0;\n\n for (size_t i = 20; i < _res - 20; i++) {\n mean_slope = mean_slope + (_G(i + 1) - _G(i)) / (_t(i + 1) - _t(i));\n num_points++;\n }\n\n mean_slope /= num_points;\n\n std::cout << \"First order Taylor expansion slope: \" << mean_slope << \" - It should be approximately equal to 2.0\" << std::endl;\n\n return (std::abs(mean_slope - 2.0) <= 1e-3) ? true : false;\n }\n\n template \n bool checkGradient(Function f, Gradient g)\n {\n // Generate random test point and perturbation direction\n Eigen::VectorXd x = Eigen::VectorXd::Random(_dim), v = Eigen::VectorXd::Random(_dim);\n\n // Init G\n _G.setZero(_res);\n\n // Generate log spaced perturbation intensities\n _t = Eigen::Matrix::LinSpaced(_res, -8, 0);\n for (size_t i = 0; i < _t.rows(); i++)\n _t(i) = std::pow(10, _t(i));\n\n // Calculate first order Taylor expansion\n for (size_t i = 0; i < _t.rows(); i++)\n _G(i) = std::abs(f(x + _t(i) * v) - f(x) - _t(i) * g(x).dot(v));\n\n // Transform to log space\n _t = _t.array().log();\n _G = _G.array().log();\n\n // Calculate mean slope for central values\n Precision mean_slope = 0, num_points = 0;\n\n for (size_t i = 20; i < _res - 20; i++) {\n mean_slope = mean_slope + (_G(i + 1) - _G(i)) / (_t(i + 1) - _t(i));\n num_points++;\n }\n\n mean_slope /= num_points;\n\n std::cout << \"First order Taylor expansion slope: \" << mean_slope << \" - It should be approximately equal to 2.0\" << std::endl;\n\n return (std::abs(mean_slope - 2.0) <= 1e-3) ? true : false;\n }\n\n template \n bool checkHessian(Function f, Gradient g, Hessian h, const Eigen::VectorXd& x, const Eigen::VectorXd& v)\n {\n // Init H\n _H.setZero(_res);\n\n // Generate log spaced perturbation intensities\n _t = Eigen::Matrix::LinSpaced(_res, -8, 0);\n for (size_t i = 0; i < _t.rows(); i++)\n _t(i) = std::pow(10, _t(i));\n\n // Calculate second order Taylor expansion\n for (size_t i = 0; i < _t.rows(); i++)\n _H(i) = std::abs(f(x + _t(i) * v) - f(x) - _t(i) * g(x).dot(v) - 0.5 * std::pow(_t(i), 2) * h(x, v).dot(v));\n\n // Transform to log space\n _t = _t.array().log();\n _H = _H.array().log();\n\n // Calculate mean slope for central values\n Precision mean_slope = 0, num_points = 0;\n\n for (size_t i = 30; i < _res - 10; i++) {\n mean_slope = mean_slope + (_H(i + 1) - _H(i)) / (_t(i + 1) - _t(i));\n num_points++;\n }\n\n mean_slope /= num_points;\n\n std::cout << \"Second order Taylor expansion slope: \" << mean_slope << \" - It should be approximately equal to 3.0\" << std::endl;\n\n return (std::abs(mean_slope - 3.0) <= 1e-3) ? true : false;\n }\n\n template \n bool checkHessian(Function f, Gradient g, Hessian h)\n {\n // Generate random test point and perturbation direction\n Eigen::VectorXd x = Eigen::VectorXd::Random(_dim), v = Eigen::VectorXd::Random(_dim);\n\n // Init H\n _H.setZero(_res);\n\n // Generate log spaced perturbation intensities\n _t = Eigen::Matrix::LinSpaced(_res, -8, 0);\n for (size_t i = 0; i < _t.rows(); i++)\n _t(i) = std::pow(10, _t(i));\n\n // Calculate second order Taylor expansion\n for (size_t i = 0; i < _t.rows(); i++)\n _H(i) = std::abs(f(x + _t(i) * v) - f(x) - _t(i) * g(x).dot(v) - 0.5 * std::pow(_t(i), 2) * h(x, v).dot(v));\n\n // Transform to log space\n _t = _t.array().log();\n _H = _H.array().log();\n\n // Calculate mean slope for central values\n Precision mean_slope = 0, num_points = 0;\n\n for (size_t i = 30; i < _res - 10; i++) {\n mean_slope = mean_slope + (_H(i + 1) - _H(i)) / (_t(i + 1) - _t(i));\n num_points++;\n }\n\n mean_slope /= num_points;\n\n std::cout << \"Second order Taylor expansion slope: \" << mean_slope << \" - It should be approximately equal to 3.0\" << std::endl;\n\n return (std::abs(mean_slope - 3.0) <= 1e-3) ? true : false;\n }\n\n protected:\n size_t _dim, _res;\n\n Eigen::Matrix _t, _G, _H;\n };\n} // namespace utils_lib\n\n#endif // utils_lib_GRADIENT_CHECKER_HPP", "meta": {"hexsha": "a16df4d9f1f3289549ca6dc6d9fabb0ffd32978e", "size": 8110, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/utils_lib/DerivativeChecker.hpp", "max_stars_repo_name": "nash169/utils-lib", "max_stars_repo_head_hexsha": "a734c63fb66b9b5e2f4dba2d2e210b05364ecb88", "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/utils_lib/DerivativeChecker.hpp", "max_issues_repo_name": "nash169/utils-lib", "max_issues_repo_head_hexsha": "a734c63fb66b9b5e2f4dba2d2e210b05364ecb88", "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/utils_lib/DerivativeChecker.hpp", "max_forks_repo_name": "nash169/utils-lib", "max_forks_repo_head_hexsha": "a734c63fb66b9b5e2f4dba2d2e210b05364ecb88", "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": 37.8971962617, "max_line_length": 140, "alphanum_fraction": 0.5488286067, "num_tokens": 2120, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718435083355188, "lm_q2_score": 0.7057850278370112, "lm_q1q2_score": 0.5447555920164006}} {"text": "#pragma once\n#include \n#include \n#include \n#include \n\nnamespace superpixel_mesh {\n\ntypedef ceres::Grid2D Grid;\ntypedef ceres::BiCubicInterpolator Interpolator;\n\ntemplate class Homography {\npublic:\n typedef Eigen::Matrix MatX;\n typedef Eigen::Matrix MatB;\n typedef Eigen::Matrix MatH;\n typedef Eigen::Matrix Mat8;\n typedef Eigen::Matrix Vec8;\n\n static void ComputeHomography(const MatX &x1, const MatX &x2, Vec8 *H) {\n Mat8 L = Mat8::Zero();\n Vec8 b = Vec8::Zero();\n /**\n *\n * Add 2 rows for each point. Parametrization uses h9 = 1\n *\n * 0 0 0 -x1 -y1 -1 x1*y2 y1*y2 hi = -y2\n * -x1 -y1 -1 0 0 0 x1*x2 y1*x2 hi+1 = -x2\n */\n\n for (int i = 0; i < 4; ++i) {\n int r = i * 2;\n L(r, 3) = x1(0, i);\n L(r, 4) = x1(1, i);\n L(r, 5) = T(1.0);\n L(r, 6) = -x1(0, i) * x2(1, i);\n L(r, 7) = -x1(1, i) * x2(1, i);\n b(r) = x2(1, i);\n\n L(r + 1, 0) = x1(0, i);\n L(r + 1, 1) = x1(1, i);\n L(r + 1, 2) = T(1.0);\n L(r + 1, 6) = -x1(0, i) * x2(0, i);\n L(r + 1, 7) = -x1(1, i) * x2(0, i);\n b(r + 1) = x2(0, i);\n }\n // Solve Ax=B\n Eigen::PartialPivLU dec(L);\n (*H) = dec.solve(b);\n }\n};\n\ntemplate struct PixelDissimilarityCost {\n\n PixelDissimilarityCost(const Interpolator &inteporlator)\n : interpolator(inteporlator) {}\n\n template \n bool operator()(const T *const v1, const T *const v2, const T *const v3,\n const T *const v4, T *residuals) const {\n\n // Compute the homography\n typename Homography::MatX x1, x2;\n x1 << T(-PADDING), T(SIZE + PADDING), T(SIZE + PADDING), T(-PADDING),\n T(-PADDING), T(-PADDING), T(SIZE + PADDING), T(SIZE + PADDING);\n x2 << v1[0], v2[0], v3[0], v4[0], v1[1], v2[1], v3[1], v4[1];\n\n typename Homography::Vec8 h;\n Homography::ComputeHomography(x1, x2, &h);\n\n T intensities[SIZE * SIZE];\n T mean = T(0);\n int intensity_index = 0;\n for (int row = 0; row < SIZE; row++) {\n for (int col = 0; col < SIZE; col++, intensity_index++) {\n T x, y, s;\n x = T(col);\n y = T(row);\n s = T(1.0) / (h(6) * x + h(7) * y + T(1.0));\n interpolator.Evaluate(s * (h(3) * x + h(4) * y + h(5)),\n s * (h(0) * x + h(1) * y + h(2)),\n &intensities[intensity_index]);\n mean += intensities[intensity_index];\n }\n }\n const T normalization = T(1.0 / double(SIZE * SIZE));\n mean *= normalization;\n for (int intensity_index = 0; intensity_index < SIZE * SIZE;\n intensity_index++) {\n residuals[intensity_index] = intensities[intensity_index] - mean;\n }\n\n return true;\n }\n\n const Interpolator &interpolator;\n};\n\nstruct AreaRegularizationCost {\n\n AreaRegularizationCost(const double target_area) : target_area(target_area) {}\n\n template \n T TriangleArea(const T *const v1, const T *const v2,\n const T *const v3) const {\n /**\n * Shoelace formula:\n * (1/2) | x1y2 + x2y3 + x3y1 - x2y1 - x3y2 - x1y3 |\n */\n const auto &x1 = v1[0];\n const auto &y1 = v1[1];\n const auto &x2 = v2[0];\n const auto &y2 = v2[1];\n const auto &x3 = v3[0];\n const auto &y3 = v3[1];\n\n return 0.5 * ceres::abs(x1 * y2 + x2 * y3 + x3 * y1 - x2 * y1 - x3 * y2 -\n x1 * y3);\n }\n\n template \n bool operator()(const T *const v1, const T *const v2, const T *const v3,\n const T *const v4, T *residuals) const {\n T triangle_areas[4];\n triangle_areas[0] = TriangleArea(v4, v3, v2);\n triangle_areas[1] = TriangleArea(v3, v2, v1);\n triangle_areas[2] = TriangleArea(v2, v1, v4);\n triangle_areas[3] = TriangleArea(v1, v4, v3);\n\n const T target_triangle_area = T(0.5 * target_area);\n for (int triangle_index = 0; triangle_index < 4; triangle_index++)\n residuals[triangle_index] =\n target_triangle_area - triangle_areas[triangle_index];\n\n return true;\n }\n\n const double target_area;\n};\n\n} // namespace superpixel_mesh\n", "meta": {"hexsha": "21e7a8a99df5f6aa664d8d314c37c57487e7a409", "size": 4307, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "lib/superpixel_mesh/meshing_cost.hpp", "max_stars_repo_name": "manlito/superpixel-mesh", "max_stars_repo_head_hexsha": "34a1dd3a80054787e4e020f8ccfdabc17ca8051d", "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": "lib/superpixel_mesh/meshing_cost.hpp", "max_issues_repo_name": "manlito/superpixel-mesh", "max_issues_repo_head_hexsha": "34a1dd3a80054787e4e020f8ccfdabc17ca8051d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/superpixel_mesh/meshing_cost.hpp", "max_forks_repo_name": "manlito/superpixel-mesh", "max_forks_repo_head_hexsha": "34a1dd3a80054787e4e020f8ccfdabc17ca8051d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.3309859155, "max_line_length": 80, "alphanum_fraction": 0.5479452055, "num_tokens": 1524, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314677809303, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.5447411602949187}} {"text": "// Copyright Abel Sinkovics (abel@sinkovics.hu) 2011.\n// Distributed under the Boost Software License, Version 1.0.\n// (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#include \n\n#if BOOST_METAPARSE_STD < 2011\n#include \n\nint main()\n{\n std::cout << \"Please use a compiler that supports constexpr\" << std::endl;\n}\n#else\n\n#define BOOST_MPL_LIMIT_STRING_SIZE 64\n#define BOOST_METAPARSE_LIMIT_STRING_SIZE BOOST_MPL_LIMIT_STRING_SIZE\n\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#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing boost::metaparse::build_parser;\nusing boost::metaparse::entire_input;\nusing boost::metaparse::token;\nusing boost::metaparse::grammar;\n\nusing boost::metaparse::util::digit_to_int;\n\nusing boost::mpl::apply_wrap1;\nusing boost::mpl::fold;\nusing boost::mpl::front;\nusing boost::mpl::back;\nusing boost::mpl::plus;\nusing boost::mpl::minus;\nusing boost::mpl::times;\nusing boost::mpl::divides;\nusing boost::mpl::eval_if;\nusing boost::mpl::equal_to;\nusing boost::mpl::_1;\nusing boost::mpl::_2;\nusing boost::mpl::char_;\nusing boost::mpl::lambda;\nusing boost::mpl::int_;\n\n#ifdef _STR\n #error _STR already defined\n#endif\n#define _STR BOOST_METAPARSE_STRING\n\ntemplate \nstruct lazy_plus : plus {};\n\ntemplate \nstruct lazy_minus : minus {};\n\ntemplate \nstruct lazy_times : times {};\n\ntemplate \nstruct lazy_divides : divides {};\n\ntemplate \nstruct lazy_eval_if : eval_if {};\n\ntemplate \nstruct lazy_equal_to : equal_to {};\n\ntemplate \nstruct lazy_fold :\n fold\n{};\n\ntypedef\n lazy_fold<\n back<_1>,\n front<_1>,\n lambda<\n lazy_eval_if<\n lazy_equal_to, char_<'*'>>,\n lazy_times<_1, back<_2>>,\n lazy_divides<_1, back<_2>>\n >\n >::type\n >\n prod_action;\n\ntypedef\n lazy_fold<\n back<_1>,\n front<_1>,\n lambda<\n lazy_eval_if<\n lazy_equal_to, char_<'+'>>,\n lazy_plus<_1, back<_2>>,\n lazy_minus<_1, back<_2>>\n >\n >::type\n >\n plus_action;\n\ntypedef\n lambda<\n lazy_fold<\n _1,\n int_<0>,\n lambda<\n lazy_plus>, apply_wrap1, _2>>\n >::type\n >\n >::type\n int_action;\n\ntypedef\n grammar<_STR(\"plus_exp\")>\n\n ::rule<_STR(\"int ::= ('0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9')+\"), int_action>::type\n ::rule<_STR(\"ws ::= (' ' | '\\n' | '\\r' | '\\t')*\")>::type\n ::rule<_STR(\"int_token ::= int ws\"), front<_1>>::type\n ::rule<_STR(\"plus_token ::= '+' ws\"), front<_1>>::type\n ::rule<_STR(\"minus_token ::= '-' ws\"), front<_1>>::type\n ::rule<_STR(\"mult_token ::= '*' ws\"), front<_1>>::type\n ::rule<_STR(\"div_token ::= '/' ws\"), front<_1>>::type\n ::rule<_STR(\"plus_token ::= '+' ws\")>::type\n ::rule<_STR(\"plus_exp ::= prod_exp ((plus_token | minus_token) prod_exp)*\"), plus_action>::type\n ::rule<_STR(\"prod_exp ::= int_token ((mult_token | div_token) int_token)*\"), prod_action>::type\n expression;\n\ntypedef build_parser> calculator_parser;\n\nint main()\n{\n using std::cout;\n using std::endl;\n\n cout\n << apply_wrap1::type::value << endl\n << apply_wrap1::type::value << endl\n ;\n}\n#endif\n", "meta": {"hexsha": "97ce161710f094000f81aca8004a8c43a6bfef16", "size": 4268, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/external/boost/boost_1_68_0/libs/metaparse/example/grammar_calculator/main.cpp", "max_stars_repo_name": "Bpowers4/turicreate", "max_stars_repo_head_hexsha": "73dad213cc1c4f74337b905baea2b3a1e5a0266c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 11356.0, "max_stars_repo_stars_event_min_datetime": "2017-12-08T19:42:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T16:55:25.000Z", "max_issues_repo_path": "src/external/boost/boost_1_68_0/libs/metaparse/example/grammar_calculator/main.cpp", "max_issues_repo_name": "Bpowers4/turicreate", "max_issues_repo_head_hexsha": "73dad213cc1c4f74337b905baea2b3a1e5a0266c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2402.0, "max_issues_repo_issues_event_min_datetime": "2017-12-08T22:31:01.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-28T19:25:52.000Z", "max_forks_repo_path": "src/external/boost/boost_1_68_0/libs/metaparse/example/grammar_calculator/main.cpp", "max_forks_repo_name": "Bpowers4/turicreate", "max_forks_repo_head_hexsha": "73dad213cc1c4f74337b905baea2b3a1e5a0266c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1343.0, "max_forks_repo_forks_event_min_datetime": "2017-12-08T19:47:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-26T11:31:36.000Z", "avg_line_length": 26.675, "max_line_length": 99, "alphanum_fraction": 0.6715089035, "num_tokens": 1220, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.782662489091802, "lm_q2_score": 0.6959583313396339, "lm_q1q2_score": 0.544700479910455}} {"text": "\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"FileSystemTools.h\"\n#include \"YamlFileIO.h\"\n\n// fitness threshold\ndouble min_fitness_thresh = 0.05;\n\nstruct RegistrationResult{\n // transform matrix\n Eigen::Matrix4d T;\n // fitness score\n double fitness;\n // inlier rms\n double inlier_rms;\n};\n\n// create init extrinsic file\nvoid createMultiLidarExtFile(const std::string& filename)\n{\n // new backpack structural value\n Eigen::Matrix4d T_l0_l1_gt = Eigen::Matrix4d::Identity();\n Eigen::AngleAxisd l0_l1_vec1(-30 * M_PI / 180.0, Eigen::Vector3d(0, 0, 1));\n Eigen::AngleAxisd l0_l1_vec2(-73.5 * M_PI / 180.0, Eigen::Vector3d(0, 1, 0));\n Eigen::Matrix3d l0_l1_vec = l0_l1_vec1.matrix() * l0_l1_vec2.matrix();\n Eigen::Vector3d t_l0_l1(-0.31405, 0, -0.39803);\n T_l0_l1_gt.block<3, 3>(0, 0) = l0_l1_vec;\n T_l0_l1_gt.block<3, 1>(0, 3) = l0_l1_vec1.matrix() * t_l0_l1;\n std::cout << \"T_l0_l1_gt:\\n\" << T_l0_l1_gt << \"\\n\";\n\n common::saveExtFileOpencv(filename, T_l0_l1_gt); \n}\n\nbool alignTwoPointClouds(const std::string &src_pcl_file, const std::string &target_pcl_file, const Eigen::Matrix4d &T_init, \n RegistrationResult &result){\n std::string path, file_name;\n common::splitPathAndFilename(src_pcl_file, &path, &file_name);\n\n auto src_pcd_ptr = open3d::io::CreatePointCloudFromFile(src_pcl_file);\n auto target_pcd_ptr = open3d::io::CreatePointCloudFromFile(target_pcl_file);\n\n if( src_pcd_ptr == nullptr || src_pcd_ptr == nullptr){\n LOG(ERROR) << \"Fail to load src and target pointcloud file!\";\n return false;\n }\n\n auto src_pcd_down_ptr = src_pcd_ptr->VoxelDownSample(0.05);\n src_pcd_ptr->EstimateNormals(open3d::geometry::KDTreeSearchParamHybrid(0.1, 30));\n\n auto target_pcd_down_ptr = target_pcd_ptr->VoxelDownSample(0.05);\n target_pcd_ptr->EstimateNormals(open3d::geometry::KDTreeSearchParamHybrid(0.1, 30));\n\n src_pcd_ptr->Transform(T_init);\n src_pcd_down_ptr->Transform(T_init);\n\n open3d::registration::RegistrationResult icp_result;\n\n const double max_corresp_dis = 0.03; // meter\n open3d::registration::ICPConvergenceCriteria icp_criteria(1e-6, 1e-6, 100);\n // icp_result = open3d::registration::RegistrationICP(*src_pcd_ptr, *target_pcd_ptr, max_corresp_dis, Eigen::Matrix4d::Identity(),\n // open3d::registration::TransformationEstimationPointToPlane(), icp_criteria);\n icp_result = open3d::registration::RegistrationICP(*src_pcd_ptr, *target_pcd_ptr, max_corresp_dis, Eigen::Matrix4d::Identity(),\n open3d::registration::TransformationEstimationPointToPoint(false), icp_criteria);\n\n // transform source pointcloud with icp_transformation\n Eigen::Matrix4d T_icp = icp_result.transformation_;\n\n LOG(INFO) << \"#############\" << path << \" ################\";\n result.fitness = icp_result.fitness_;\n LOG(INFO) << \"icp_result.fitness: \" << icp_result.fitness_;\n result.inlier_rms = icp_result.inlier_rmse_;\n LOG(INFO) << \"icp_result.inlier_rmse_ : \" << icp_result.inlier_rmse_;\n\n if(result.fitness < min_fitness_thresh){\n LOG(ERROR) << \"fitness score < \" << min_fitness_thresh;\n return false;\n }\n\n // final transformation between source pointcloud and target pointcloud\n result.T = T_icp * T_init;\n std::cout << \"Final transformation:\\n\"\n << result.T << \"\\n\";\n\n src_pcd_down_ptr->Transform(T_icp);\n \n std::string save_file_path;\n\n save_file_path = common::concatenateFolderAndFileName(path, \"transformed_source_pointcloud.ply\");\n open3d::io::WritePointCloudToPLY(save_file_path, *src_pcd_down_ptr, true);\n std::shared_ptr merge_points(new open3d::geometry::PointCloud);\n *merge_points = *src_pcd_down_ptr + *target_pcd_down_ptr;\n \n save_file_path = common::concatenateFolderAndFileName(path, \"merged_pointcloud.ply\");\n open3d::io::WritePointCloudToPLY(save_file_path, *merge_points, true);\n \n return true;\n}\n\nvoid evaluateExtrinsics(const std::vector & v_results, const Eigen::Matrix4d &T_baseline){\n assert(v_results.size() > 1);\n\n std::vector v_inlier_rms = {v_results[0].inlier_rms};\n // rotation sigma\n std::vector v_sigma_r;\n // translation sigma\n std::vector v_sigma_t;\n\n int T_num = v_results.size();\n for(int i = 0; i < T_num; ++i){\n Eigen::Matrix4d T = v_results[i].T;\n Eigen::Matrix4d T_inv = T.inverse();\n \n Eigen::Matrix4d T_delt = T_inv * T_baseline;\n Eigen::AngleAxisd rot_vec(T_delt.block<3, 3>(0, 0));\n double delt_r = rot_vec.angle() * 180.0 / M_PI;\n Eigen::Vector3d t_delt = T_delt.block<3, 1>(0, 3);\n double delt_t = t_delt.norm() * 100;\n LOG(INFO) << \"T_baseline and T_\" << i << \" Rotation delta: \"\n << delt_r << \" °\\n\";\n LOG(INFO) << \"T_baseline and T_\" << i << \" Translation delta: \" << delt_t\n << \" cm\\n\";\n\n v_sigma_r.push_back(delt_r * delt_r);\n v_sigma_t.push_back(delt_t * delt_t);\n v_inlier_rms.push_back(v_results[i].inlier_rms);\n }\n\n double sigma_r = std::accumulate(v_sigma_r.begin(), v_sigma_r.end(), 0.0) / T_num;\n double sigma_t = std::accumulate(v_sigma_t.begin(), v_sigma_t.end(), 0.0) / T_num;\n LOG(INFO) << \"Avg rotation sigma: \" << sigma_r << \", Avg trans sigma: \" << sigma_t;\n LOG(INFO) << \"Final sigma_r\" << std::sqrt(sigma_r) << \", sigma_t: \" << std::sqrt(sigma_t);\n // LOG(INFO) << \"Avg inlier rms: \" << std::accumulate(v_inlier_rms.begin(), v_inlier_rms.end(), 0.0) / v_inlier_rms.size();\n\n}\n\n\n\nint main(int argc, char **argv){\n if (argc < 3){\n LOG(FATAL) << \"Usage: test_lidar2lidar_calibration [T_l0_l1_init.yaml] [input_dataset_folder] [output_folder] [lidar0_id] [lidar1_id]\";\n return -1;\n }\n\n std::string init_ext_filepath(argv[1]);\n // dataset folder e.g. /path/data0/lidar_lidar\n std::string dataset_folder(argv[2]);\n std::string output_folder(argv[3]);\n int lidar0_id = 0, lidar1_id = 1;\n if (argc == 6){\n lidar0_id = std::stoi (argv[4]);\n lidar1_id = std::stoi (argv[5]);\n }\n\n // if initial extrinsic isn't here, create it\n if(!common::fileExists(init_ext_filepath)){\n createMultiLidarExtFile(init_ext_filepath);\n }\n if(!common::pathExists(dataset_folder)){\n LOG(FATAL) << \"Input folder doesnot exist!\";\n return -1;\n }\n if(!common::pathExists(output_folder)){\n if(!common::createPath(output_folder)){\n LOG(FATAL) << \"Fail to create \" << output_folder;\n return -1;\n }\n }\n\n // Eigen::Matrix4d T_base_l0 = horizontal_lidar_ptr->extrinsics();\n // Eigen::Matrix4d T_base_l1 = vertical_lidar_ptr->extrinsics();\n // initial extrinsic between two lidar\n Eigen::Matrix4d T_l0_l1_init = Eigen::Matrix4d::Identity();\n if (!common::loadExtFileOpencv(init_ext_filepath, T_l0_l1_init)){\n LOG(FATAL) << \"Fail to load \" << init_ext_filepath;\n return -1;\n }\n\n std::vector v_extrinsics;\n\n // for (const auto & entry : boost::filesystem::directory_iterator(dataset_folder)){\n // if(!boost::filesystem::is_directory(entry))\n // continue;\n\n // std::string scan_folder_path = entry.path().string() + \"/lidar_lidar\";\n std::string lidar0_scan_folder = common::concatenateFolderAndFileName(dataset_folder, \"lidar0\");\n std::string lidar1_scan_folder = common::concatenateFolderAndFileName(dataset_folder, \"lidar1\");\n std::vector v_lidar0_pcl_paths, v_lidar1_pcl_paths;\n std::vector paths = {lidar0_scan_folder};\n common::getFileLists(paths, true, \"ply\", &v_lidar0_pcl_paths);\n paths = {lidar1_scan_folder};\n common::getFileLists(paths, true, \"ply\", &v_lidar1_pcl_paths);\n\n if (v_lidar0_pcl_paths.empty() || v_lidar1_pcl_paths.empty()){\n LOG(ERROR) << \"lidar scan folder is empty!\\n\";\n return -1;\n }\n // only choose 1 scan pair for calibration\n std::string src_pcl_file_path, target_pcl_file_path;\n {\n std::string file_path = v_lidar0_pcl_paths[0];\n std::string path, file_name;\n common::splitPathAndFilename(file_path, &path, &file_name);\n if(std::atoi(&file_name[0]) == lidar0_id)\n target_pcl_file_path = file_path;\n }\n {\n std::string file_path = v_lidar1_pcl_paths[0];\n std::string path, file_name;\n common::splitPathAndFilename(file_path, &path, &file_name);\n if(std::atoi(&file_name[0]) == lidar1_id)\n src_pcl_file_path = file_path;\n }\n\n RegistrationResult regist_result;\n bool sts = alignTwoPointClouds(src_pcl_file_path, target_pcl_file_path, T_l0_l1_init, regist_result);\n if(!sts){\n return -1;\n }\n\n std::string save_file_path = common::concatenateFolderAndFileName(output_folder, \"lidar0_to_lidar1.yml\");\n common::saveExtFileOpencv(save_file_path, regist_result.T);\n v_extrinsics.emplace_back(regist_result);\n // }\n\n // sort result by fitness\n // std::sort(v_extrinsics.begin(), v_extrinsics.end(), [&](RegistrationResult &res_a, RegistrationResult &res_b){\n // return res_a.fitness > res_b.fitness;\n // });\n\n // evaluateExtrinsics(v_extrinsics, v_extrinsics[0].T);\n\n\n\n return 0;\n}", "meta": {"hexsha": "1b6846e6d0b451dcec7591836eb84a8b3eca25ac", "size": 9716, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "test/test_lidar2lidar_calibration.cpp", "max_stars_repo_name": "alibaba/multiple-cameras-and-3D-LiDARs-extrinsic-calibration", "max_stars_repo_head_hexsha": "349bc8b954506721583b3571568fb8e23c2f1e83", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 47.0, "max_stars_repo_stars_event_min_datetime": "2021-09-06T02:25:28.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T12:03:13.000Z", "max_issues_repo_path": "test/test_lidar2lidar_calibration.cpp", "max_issues_repo_name": "alibaba/multiple-cameras-and-3D-LiDARs-extrinsic-calibration", "max_issues_repo_head_hexsha": "349bc8b954506721583b3571568fb8e23c2f1e83", "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": "test/test_lidar2lidar_calibration.cpp", "max_forks_repo_name": "alibaba/multiple-cameras-and-3D-LiDARs-extrinsic-calibration", "max_forks_repo_head_hexsha": "349bc8b954506721583b3571568fb8e23c2f1e83", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11.0, "max_forks_repo_forks_event_min_datetime": "2021-09-15T22:30:04.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-11T07:43:24.000Z", "avg_line_length": 40.1487603306, "max_line_length": 143, "alphanum_fraction": 0.6539728283, "num_tokens": 2723, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8499711832583695, "lm_q2_score": 0.640635854839898, "lm_q1q2_score": 0.5445220155760052}} {"text": "/**\n * \\file CachedCosinusGeneratorFilter.cpp\n */\n\n#include \"CachedCosinusGeneratorFilter.h\"\n\n#include \n#include \n#include \n\n#include \n\nnamespace ATK\n{\n template\n CachedCosinusGeneratorFilter::CachedCosinusGeneratorFilter(int periods, int seconds)\n :Parent(0, 1), indice(1), periods(periods), seconds(seconds), volume(1), offset(0)\n {\n }\n \n template\n CachedCosinusGeneratorFilter::~CachedCosinusGeneratorFilter()\n {\n }\n \n template\n void CachedCosinusGeneratorFilter::set_frequency(int periods, int seconds)\n {\n this->periods = periods;\n this->seconds = seconds;\n setup();\n }\n \n template\n std::pair CachedCosinusGeneratorFilter::get_frequency() const\n {\n return std::make_pair(periods, seconds);\n }\n\n template\n void CachedCosinusGeneratorFilter::set_volume(DataType_ volume)\n {\n this->volume = volume;\n }\n \n template\n DataType_ CachedCosinusGeneratorFilter::get_volume() const\n {\n return volume;\n }\n \n template\n void CachedCosinusGeneratorFilter::set_offset(DataType_ offset)\n {\n this->offset = offset;\n }\n \n template\n DataType_ CachedCosinusGeneratorFilter::get_offset() const\n {\n return offset;\n }\n\n template\n void CachedCosinusGeneratorFilter::setup()\n {\n indice = 0;\n cache.resize(output_sampling_rate * seconds);\n for(int i = 0; i < cache.size(); ++i)\n {\n cache[i] = static_cast(std::cos(2 * boost::math::constants::pi() * (i+1) * periods / seconds / output_sampling_rate));\n }\n }\n\n template\n void CachedCosinusGeneratorFilter::process_impl(int64_t size) const\n {\n DataType* ATK_RESTRICT output = outputs[0];\n int64_t processed = 0;\n while(processed < size)\n {\n int64_t to_copy = std::min(size - processed, int64_t(cache.size()) - indice);\n memcpy(reinterpret_cast(output + processed), reinterpret_cast(cache.data() + indice), to_copy * sizeof(DataType_));\n indice += to_copy;\n processed += to_copy;\n if(indice >= static_cast(cache.size()))\n {\n indice = 0;\n }\n }\n for(int64_t i = 0; i < size; ++i)\n {\n output[i] = static_cast(offset + volume * output[i]);\n }\n }\n \n template class CachedCosinusGeneratorFilter;\n template class CachedCosinusGeneratorFilter;\n}\n", "meta": {"hexsha": "d9d0147d310081167db5317ec9de35e4316d48e1", "size": 2680, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ATK/Tools/CachedCosinusGeneratorFilter.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/CachedCosinusGeneratorFilter.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/CachedCosinusGeneratorFilter.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": 26.8, "max_line_length": 142, "alphanum_fraction": 0.6973880597, "num_tokens": 663, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8499711604559848, "lm_q2_score": 0.640635868562172, "lm_q1q2_score": 0.5445220126315171}} {"text": "/**\n * @file calc-characteristic.cpp\n *\n * @brief calculate characteristic polynomial.\n *\n * @author Mutsuo Saito (Hiroshima University)\n * @author Makoto Matsumoto (The University of Tokyo)\n *\n * Copyright (C) 2012 Mutsuo Saito, Makoto Matsumoto,\n * Hiroshima University and The University of Tokyo.\n * All rights reserved.\n *\n * The 3-clause BSD License is applied to this software, see\n * LICENSE.txt\n */\n#include \n#include \n#include \n#include \n#include \"dSFMText.hpp\"\n#include \"dSFMT-calc-jump.hpp\"\n#include \n#include \n#include \n\nusing namespace dsfmt;\nusing namespace NTL;\nusing namespace std;\n\nvoid calc_minimal(GF2X& minimal, int maxdegree, w128_t outseq[], int pos)\n{\n uint64_t mask = 0;\n vec_GF2 seq;\n seq.SetLength(2 * maxdegree);\n int idx = 0;\n\n if (pos >= 104 || pos < 0) {\n\tcerr << \"pos error:\" << dec << pos << endl;\n\texit(1);\n } else if (pos >= 52) {\n\tidx = 1;\n\tmask = UINT64_C(1) << (pos - 52);\n } else {\n\tidx = 0;\n\tmask = UINT64_C(1) << pos;\n }\n if (idx < 0 || idx >= 2) {\n\tcerr << \"idx error:\" << dec << idx << endl;\n\texit(1);\n }\n for (int i = 0; i < 2 * maxdegree; i++) {\n\tif ((outseq[i].u[idx] & mask) != 0) {\n\t seq[i] = 1;\n\t} else {\n\t seq[i] = 0;\n\t}\n }\n MinPolySeq(minimal, seq, maxdegree);\n#if defined(DEBUG)\n cout << \"deg(minimal) = \" << dec << deg(minimal) << endl;\n#endif\n}\n\nvoid LCM(GF2X& lcm, const GF2X& x, const GF2X& y) {\n GF2X gcd;\n mul(lcm, x, y);\n GCD(gcd, x, y);\n//void DivRem(GF2X& q, GF2X& r, const GF2X& a, const GF2X& b);\n// q = a/b, r = a%b\n GF2X r;\n DivRem(lcm, r, lcm, gcd);\n if (deg(r) != -1) {\n\tcerr << \"LCM error: deg(r) = \" << dec << deg(r);\n\tcerr << \"r:\" << r << endl;\n\texit(1);\n }\n}\n\nstatic void get_lcm_sub(GF2X& lcmpoly, dSFMText& dsfmt) {\n GF2X tmp(1,1);\n int maxdegree = dsfmt.get_maxdegree();\n w128_t out_seq[2 * maxdegree];\n\n for (int i = 0; i < 2 * maxdegree; i++) {\n\tout_seq[i] = dsfmt.next();\n }\n GF2X minimal;\n GF2X t1;\n SetCoeff(t1, 0, 1);\n SetCoeff(t1, 1, 1);\n for (int pos = 0; pos < 104; pos++) {\n\tcalc_minimal(minimal, maxdegree, out_seq, pos);\n\tLCM(tmp, lcmpoly, minimal);\n\tlcmpoly = tmp;\n\tif (divide(lcmpoly, t1)) {\n\t return;\n\t}\n }\n#if defined(DEBUG)\n cout << \"deg(lcmpoly) = \" << dec << deg(lcmpoly) << endl;\n#endif\n}\n\nvoid get_lcm(GF2X& lcmpoly, dSFMText& dsfmt) {\n int maxdegree = dsfmt.get_maxdegree();\n GF2X t1;\n SetCoeff(t1, 0, 1);\n SetCoeff(t1, 1, 1);\n\n //uint32_t time = (uint32_t)clock();\n dsfmt.seeding(1234);\n get_lcm_sub(lcmpoly, dsfmt);\n if (deg(lcmpoly) >= maxdegree) {\n\treturn;\n }\n if (divide(lcmpoly, t1)) {\n\treturn;\n }\n for(int i = 0; i < maxdegree; i++) {\n\tdsfmt.init_basis(i);\n\tget_lcm_sub(lcmpoly, dsfmt);\n\tif (deg(lcmpoly) >= maxdegree) {\n\t return;\n\t}\n\tif (divide(lcmpoly, t1)) {\n\t return;\n\t}\n }\n}\n\n\nstatic int has_large_irreducible(GF2X& fpoly, int degree) {\n static const GF2X t2(2, 1);\n static const GF2X t1(1, 1);\n GF2X t2m;\n GF2X t;\n GF2X alpha;\n int m;\n\n t2m = t2;\n if (deg(fpoly) < degree) {\n\treturn 0;\n }\n t = t1;\n t += t2m;\n\n for (m = 1; deg(fpoly) > degree; m++) {\n\tfor(;;) {\n\t GCD(alpha, fpoly, t);\n\t if (IsOne(alpha)) {\n\t\tbreak;\n\t }\n\t fpoly /= alpha;\n\t if (deg(fpoly) < degree) {\n\t\treturn 0;\n\t }\n\t}\n\tt2m *= t2m;\n\tt2m %= fpoly;\n\tadd(t, t2m, t1);\n }\n if (deg(fpoly) != degree) {\n\treturn 0;\n }\n return IterIrredTest(fpoly);\n}\n\nvoid check_fix(dSFMText & fix)\n{\n fix.setup_high();\n cout << \"before:\";\n fix.print(cout);\n fix.next();\n cout << \"after 1 step:\";\n fix.print(cout);\n fix.next();\n cout << \"after 2 step:\";\n fix.print(cout);\n fix.next();\n cout << \"after 3 step:\";\n fix.print(cout);\n}\n\nvoid check_fix2(dSFMText & fix)\n{\n cout << \"before:\";\n fix.print(cout);\n fix.next_add();\n cout << \"after 1 step:\";\n fix.print(cout);\n fix.next_add();\n cout << \"after 2 step:\";\n fix.print(cout);\n fix.next_add();\n cout << \"after 3 step:\";\n fix.print(cout);\n}\n\nvoid calc_fix(GF2X& inv, int mexp, int pos1, int sl1,\n\t uint64_t mask1, uint64_t mask2)\n{\n dSFMText fix(mexp, pos1, sl1, mask1, mask2);\n //fix.setup_high();\n //fix.next();\n //cout << \"setup0:\";\n //fix.print(cout);\n fix.setup_constants();\n#if defined(DEBUG)\n cout << \"setup:\";\n fix.print(cout);\n#endif\n dSFMText work(mexp, pos1, sl1, mask1, mask2);\n#if defined(DEBUG)\n cout << \"zero:\";\n work.print(cout);\n#endif\n for (long i = 0; i <= deg(inv); i++) {\n\tif (IsOne(coeff(inv, i))) {\n\t work.add(fix);\n#if defined(DEBUG) && 0\n cout << \"work:\";\n work.print(cout);\n#endif\n\t}\n\tfix.next();\n }\n cout << \"fix:\";\n work.print(cout);\n check_fix(work);\n}\n\nvoid check_const(GF2X& lcm, int mexp, int pos1, int sl1,\n\t uint64_t mask1, uint64_t mask2)\n{\n dSFMText normal(mexp, pos1, sl1, mask1, mask2);\n dSFMText add(mexp, pos1, sl1, mask1, mask2);\n normal.seeding(123);\n add.seeding(123);\n\n normal.setup_high();\n normal.next();\n add.next_add();\n cout << \"normal:\";\n normal.print(cout);\n cout << \"add:\";\n add.print(cout);\n for (int i = 0; i < 5; i++) {\n\tnormal.next();\n\tadd.next_add();\n }\n cout << \"normal:\";\n normal.print(cout);\n cout << \"add:\";\n add.print(cout);\n}\n\nvoid check_gcd(GF2X& d, GF2X& s, GF2X& inv, GF2X& work, GF2X& t1)\n{\n// XGCD(d, s, inv, work, t1);\n// check_gcd(d, s, inv, work, t1);\n//void XGCD(GF2X& d, GF2X& s, GF2X& t, const GF2X& a, const GF2X& b);\n// d = gcd(a,b), a s + b t = d\n if (deg(d) != 0) {\n\tcout << \"check_gcd d != 1:\" << dec << deg(d) << endl;\n\treturn;\n }\n GF2X p;\n GF2X q;\n mul(p, s, work);\n mul(q, inv, t1);\n p += q;\n if (p != d) {\n\tcout << \"check_gcd p != d, p = \" << p << endl;\n\tcout << \"check_gcd p != d, d = \" << d << endl;\n } else {\n\tcout << \"check_gcd OK d:\" << d << endl;\n }\n}\nint main(int argc, char *argv[]) {\n if (argc < 6) {\n\tcout << argv[0] << \" mexp pos1 sl1 mask1 mask2\" << endl;\n\treturn -1;\n }\n int mexp = strtol(argv[1], NULL, 10);\n int pos1 = strtol(argv[2], NULL, 10);\n int sl1 = strtol(argv[3], NULL, 10);\n uint64_t mask[2];\n mask[0] = strtoull(argv[4], NULL, 16);\n mask[1] = strtoull(argv[5], NULL, 16);\n#if defined(DEBUG)\n cout << \"mexp:\" << dec << mexp << endl;\n cout << \"pos1:\" << dec << pos1 << endl;\n cout << \"sl1:\" << dec << sl1 << endl;\n cout << \"mask1:\" << hex<< mask[0] << endl;\n cout << \"mask2:\" << hex << mask[1] << endl;\n#endif\n dSFMText dsfmt(mexp, pos1, sl1, mask[0], mask[1]);\n GF2X characteristic(0,1);\n get_lcm(characteristic, dsfmt);\n#if defined(DEBUG)\n cout << \"degree:\" << dec << deg(characteristic) << endl;\n cout << \"maxdegree = \" << dec << dsfmt.get_mamaxdegree() << endl;\n cout << characteristic << endl;\n#endif\n GF2X work;\n work = characteristic;\n#if defined(DEBUG)\n cout << \"degree:\" << deg(characteristic) << endl;\n cout << characteristic << endl;\n#endif\n if (!has_large_irreducible(characteristic, mexp)) {\n cout << \"error?\" << endl;\n return -1;\n }\n#if 0\n GF2X remain = work / characteristic;\n vec_pair_GF2X_long factors;\n CanZass(factors, remain);\n cout << \"degree of work:\" << dec << deg(work) << endl;\n cout << \"degree of remain:\" << dec << deg(remain) << endl;\n cout << \"=== factor of remain ===\" << endl;\n for (int i = 0; i < factors.length(); i++) {\n\tcout << factors[i].a;\n\tcout << \":\";\n\tcout << dec << deg(factors[i].a);\n\tcout << \":\";\n\tcout << dec << factors[i].b << endl;\n }\n#endif\n GF2X d, s, inv;\n GF2X t1;\n SetCoeff(t1, 0, 1);\n SetCoeff(t1, 1, 1);\n XGCD(d, s, inv, work, t1);\n check_gcd(d, s, inv, work, t1);\n// d = gcd(a,b), a s + b t = d\n// MulMod(s, inv, t1, work);\n#if defined(DEBUG)\n cout << \"deg work:\" << dec << deg(work) << endl;\n cout << \"deg inv:\" << dec << deg(inv) << endl;\n#endif\n string x;\n// cout << \"# deg = \" << dec << deg(work) << endl;\n polytostring(x, work);\n cout << \"#\" << dec << mexp;\n cout << \",\" << dec << pos1;\n cout << \",\" << dec << sl1;\n cout << \",\" << hex << mask[0];\n cout << \",\" << hex << mask[1];\n cout << dec << endl;\n cout << x << endl;\n cout << dec << flush;\n if (deg(d) != 0) {\n\tcout << \"doesn't have fixpoint.\" << endl;\n\treturn 0;\n }\n#if 0\n string y;\n polytostring(y, inv);\n if (deg(d) == 0) {\n\tcout << y << endl;\n } else {\n\tcout << \"can't finf inv d=\" << d << endl;\n }\n#endif\n calc_fix(inv, mexp, pos1, sl1, mask[0], mask[1]);\n //check_const(inv, mexp, pos1, sl1, mask[0], mask[1]);\n}\n", "meta": {"hexsha": "b55c59d0e412b2b337c60ad30dd401863e70d54a", "size": 8670, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "jump/calc-characteristic.cpp", "max_stars_repo_name": "mkt-matsumoto-lab/dSFMT", "max_stars_repo_head_hexsha": "6929b76f2ab07e6302f8daece28045d5bec6ff5c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 33.0, "max_stars_repo_stars_event_min_datetime": "2015-04-24T06:39:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-09T14:18:47.000Z", "max_issues_repo_path": "jump/calc-characteristic.cpp", "max_issues_repo_name": "mkt-matsumoto-lab/dSFMT", "max_issues_repo_head_hexsha": "6929b76f2ab07e6302f8daece28045d5bec6ff5c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4.0, "max_issues_repo_issues_event_min_datetime": "2020-09-02T02:08:20.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-19T06:15:28.000Z", "max_forks_repo_path": "jump/calc-characteristic.cpp", "max_forks_repo_name": "MersenneTwister-Lab/dSFMT", "max_forks_repo_head_hexsha": "6929b76f2ab07e6302f8daece28045d5bec6ff5c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 10.0, "max_forks_repo_forks_event_min_datetime": "2016-03-09T10:59:38.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-31T20:36:09.000Z", "avg_line_length": 23.4959349593, "max_line_length": 73, "alphanum_fraction": 0.5439446367, "num_tokens": 3006, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8596637469145053, "lm_q2_score": 0.6334102636778401, "lm_q1q2_score": 0.5445198406073969}} {"text": "#define DEBUG 1\n/**\n * File : A.cpp\n * Author : Kazune Takahashi\n * Created : 2020/1/25 11:32:12\n * Powered by Visual Studio Code\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n// ----- boost -----\n#include \n#include \n// ----- using directives and manipulations -----\nusing namespace std;\nusing boost::rational;\nusing boost::multiprecision::cpp_int;\nusing ll = long long;\ntemplate \nusing max_heap = priority_queue;\ntemplate \nusing min_heap = priority_queue, greater>;\n// ----- constexpr for Mint and Combination -----\nconstexpr ll MOD{1000000007LL};\n// constexpr ll MOD{998244353LL}; // be careful\nconstexpr ll MAX_SIZE{3000010LL};\n// constexpr ll MAX_SIZE{30000010LL}; // if 10^7 is needed\n// ----- ch_max and ch_min -----\ntemplate \nvoid ch_max(T &left, T right)\n{\n if (left < right)\n {\n left = right;\n }\n}\ntemplate \nvoid ch_min(T &left, T right)\n{\n if (left > right)\n {\n left = right;\n }\n}\n// ----- Mint -----\ntemplate \nclass Mint\n{\npublic:\n ll x;\n Mint() : x{0LL} {}\n Mint(ll x) : x{(x % MOD + MOD) % MOD} {}\n Mint operator-() const { return x ? MOD - x : 0; }\n Mint &operator+=(const Mint &a)\n {\n if ((x += a.x) >= MOD)\n {\n x -= MOD;\n }\n return *this;\n }\n Mint &operator-=(const Mint &a) { return *this += -a; }\n Mint &operator*=(const Mint &a)\n {\n (x *= a.x) %= MOD;\n return *this;\n }\n Mint &operator/=(const Mint &a)\n {\n Mint b{a};\n return *this *= b.power(MOD - 2);\n }\n Mint operator+(const Mint &a) const { return Mint(*this) += a; }\n Mint operator-(const Mint &a) const { return Mint(*this) -= a; }\n Mint operator*(const Mint &a) const { return Mint(*this) *= a; }\n Mint operator/(const Mint &a) const { return Mint(*this) /= a; }\n bool operator<(const Mint &a) const { return x < a.x; }\n bool operator<=(const Mint &a) const { return x <= a.x; }\n bool operator>(const Mint &a) const { return x > a.x; }\n bool operator>=(const Mint &a) const { return x >= a.x; }\n bool operator==(const Mint &a) const { return x == a.x; }\n bool operator!=(const Mint &a) const { return !(*this == a); }\n const Mint power(ll N)\n {\n if (N == 0)\n {\n return 1;\n }\n else if (N % 2 == 1)\n {\n return *this * power(N - 1);\n }\n else\n {\n Mint half = power(N / 2);\n return half * half;\n }\n }\n};\ntemplate \nMint operator+(ll lhs, const Mint &rhs)\n{\n return rhs + lhs;\n}\ntemplate \nMint operator-(ll lhs, const Mint &rhs)\n{\n return -rhs + lhs;\n}\ntemplate \nMint operator*(ll lhs, const Mint &rhs)\n{\n return rhs * lhs;\n}\ntemplate \nMint operator/(ll lhs, const Mint &rhs)\n{\n return Mint{lhs} / rhs;\n}\ntemplate \nistream &operator>>(istream &stream, Mint &a)\n{\n return stream >> a.x;\n}\ntemplate \nostream &operator<<(ostream &stream, const Mint &a)\n{\n return stream << a.x;\n}\n// ----- Combination -----\ntemplate \nclass Combination\n{\npublic:\n vector> inv, fact, factinv;\n Combination() : inv(MAX_SIZE), fact(MAX_SIZE), factinv(MAX_SIZE)\n {\n inv[1] = 1;\n for (auto i = 2LL; i < MAX_SIZE; i++)\n {\n inv[i] = (-inv[MOD % i]) * (MOD / i);\n }\n fact[0] = factinv[0] = 1;\n for (auto i = 1LL; i < MAX_SIZE; i++)\n {\n fact[i] = Mint(i) * fact[i - 1];\n factinv[i] = inv[i] * factinv[i - 1];\n }\n }\n Mint operator()(int n, int k)\n {\n if (n >= 0 && k >= 0 && n - k >= 0)\n {\n return fact[n] * factinv[k] * factinv[n - k];\n }\n return 0;\n }\n Mint catalan(int x, int y)\n {\n return (*this)(x + y, y) - (*this)(x + y, y - 1);\n }\n};\n// ----- for C++14 -----\nusing mint = Mint;\nusing combination = Combination;\ntemplate \nT gcd(T x, T y) { return y ? gcd(y, x % y) : x; }\ntemplate \nT lcm(T x, T y) { return x / gcd(x, y) * y; }\ntemplate \nint popcount(T x) // C++20\n{\n int ans{0};\n while (x != 0)\n {\n ans += x & 1;\n x >>= 1;\n }\n return ans;\n}\n// ----- frequently used constexpr -----\n// constexpr double epsilon{1e-10};\n// constexpr ll infty{1000000000000000LL};\n// constexpr int dx[4] = {1, 0, -1, 0};\n// constexpr int dy[4] = {0, 1, 0, -1};\n// ----- Yes() and No() -----\nvoid Yes()\n{\n cout << \"Yes\" << endl;\n exit(0);\n}\nvoid No()\n{\n cout << \"No\" << endl;\n exit(0);\n}\n\nclass Sieve\n{\n static constexpr ll MAX_SIZE{10000010LL};\n ll N;\n vector f;\n vector prime_nums;\n\npublic:\n Sieve(ll N = MAX_SIZE) : N{N}, f(N, 0), prime_nums{}\n {\n f[0] = f[1] = -1;\n for (auto i = 2; i < N; i++)\n {\n if (f[i])\n {\n continue;\n }\n prime_nums.push_back(i);\n f[i] = i;\n for (auto j = 2 * i; j < N; j += i)\n {\n if (!f[j])\n {\n f[j] = i;\n }\n }\n }\n }\n\n bool is_prime(ll x) const\n { // 2 \\leq x \\leq MAX_SIZE^2\n if (x < N)\n {\n return f[x];\n }\n for (auto e : prime_nums)\n {\n if (x % e == 0)\n {\n return false;\n }\n }\n return true;\n }\n\n vector const &primes() const\n {\n return prime_nums;\n }\n\n vector factor_list(ll x) const\n {\n if (x < 2)\n {\n return {};\n }\n vector res;\n auto it{prime_nums.begin()};\n if (x < N)\n {\n while (x != 1)\n {\n res.push_back(f[x]);\n x /= f[x];\n }\n }\n else\n {\n while (x != 1 && it != prime_nums.end())\n {\n if (x % *it == 0)\n {\n res.push_back(*it);\n x /= *it;\n }\n else\n {\n ++it;\n }\n }\n if (x != 1)\n {\n res.push_back(x);\n }\n }\n return res;\n }\n\n vector> factor(ll x) const\n {\n if (x < 2)\n {\n return {};\n }\n auto factors{factor_list(x)};\n vector> res{make_tuple(factors[0], 0)};\n for (auto x : factors)\n {\n if (x == get<0>(res.back()))\n {\n get<1>(res.back())++;\n }\n else\n {\n res.emplace_back(x, 1);\n }\n }\n return res;\n }\n};\n\n// ----- main() -----\n\nusing ld = long double;\nusing point = complex;\nconstexpr ld PI{3.14159265358979323846};\n\nclass Solve\n{\n ld La, Lb, Lc, Na, Nb, Nc, Ne, Ma, Mb, Mc, Tc;\n int alpha;\n Sieve sieve;\n ld Ta = 0;\n ld Tb;\n point Oa{0, 900}, Ob{900, 0}, Oc{900, 900}, Oe{90, 50};\n point Aa{1, 0}, Ab{0, 1}, Ac{-1, 0};\n ld S{500}, A{3000}, D{60};\n\npublic:\n Solve(ld La, ld Lb, ld Lc, ld Na, ld Nb, ld Nc, ld Ne, ld Ma, ld Mb, ld Mc, ld Tc) : La{La}, Lb{Lb}, Lc{Lc}, Na{Na}, Nb{Nb}, Nc{Nc}, Ne{Ne}, Ma{Ma}, Mb{Mb}, Mc{Mc}, Tc{Tc} {}\n\n void flush()\n {\n for (auto i = 0; i < 20; ++i)\n {\n ld now{0};\n ld W{Ma};\n if (now + Ma * Na > 100)\n {\n W = 500;\n }\n flush_A(W);\n now += Na * W;\n W = Mb;\n if (now + Mb * Nb > 100)\n {\n W = 500;\n }\n flush_B(W);\n now += Nb * W;\n W = Mc;\n if (now + Mc * Nc > 100)\n {\n W = 500;\n }\n flush_C(W);\n now += Nc * W;\n flush_E(now / Ne);\n }\n }\n\nprivate:\n void update_Tb()\n {\n if (alpha == 0)\n {\n Tb = 0;\n }\n else\n {\n ll p{sieve.primes()[alpha + 1]};\n ll r{p % 180};\n Tb = (r <= 90 ? r : 180 - r);\n }\n }\n\n point arg(ld theta) { return theta / 180 * PI * point(0, 1); }\n point Pa() { return exp(-arg(Ta)) * La + Oa; }\n point Pb() { return exp(arg(Tb)) * Lb + Ob; }\n point Pc() { return exp(arg(Tc)) * Lc + Oc; }\n\n void flush_simple(ld X, ld Sx, ld Ax, ld Dx, ld Y, ld Sy, ld Ay, ld Dy, ld Ta, ld Wa, ld Wb, ld Wc, ld We)\n {\n cout << fixed << setprecision(0) << X << \", \" << Sx << \", \" << Ax << \", \" << Dx << \", \" << Y << \", \" << Sy << \", \" << Ay << \", \" << Dy << \", \" << Ta << \", \" << Wa << \", \" << Wb << \", \" << Wc << \", \" << We << endl;\n }\n\n void flush_A(ld W)\n {\n flush_simple(Pa().real(), S, A, D, Pa().imag(), S, A, D, Ta, W, 0, 0, 0);\n alpha += W;\n }\n\n void flush_B(ld W)\n {\n flush_simple(Pb().real(), S, A, D, Pb().imag(), S, A, D, Ta, 0, W, 0, 0);\n }\n\n void flush_C(ld W)\n {\n flush_simple(Pc().real(), S, A, D, Pc().imag(), S, A, D, Ta, 0, 0, W, 0);\n }\n\n void flush_E(ld W)\n {\n flush_simple(Oe.real(), S, A, D, Oe.imag(), S, A, D, Ta, 0, 0, 0, W);\n }\n};\n\nint main()\n{\n ld La, Lb, Lc, Na, Nb, Nc, Ne, Ma, Mb, Mc, Tc;\n cin >> La >> Lb >> Lc >> Na >> Nb >> Nc >> Ne >> Ma >> Mb >> Mc >> Tc;\n Solve solve(La, Lb, Lc, Na / 1000, Nb / 1000, Nc / 1000, Ne / 1000, Ma, Mb, Mc, Tc);\n solve.flush();\n}\n", "meta": {"hexsha": "c1d8c9b1a9b00818d5ae083fa70c5fabe91ba6eb", "size": 9016, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "2020/0125_ddcc2020-machine/A.cpp", "max_stars_repo_name": "kazunetakahashi/atcoder", "max_stars_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2019-03-24T14:06:29.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-17T21:16:36.000Z", "max_issues_repo_path": "2020/0125_ddcc2020-machine/A.cpp", "max_issues_repo_name": "kazunetakahashi/atcoder", "max_issues_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "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": "2020/0125_ddcc2020-machine/A.cpp", "max_forks_repo_name": "kazunetakahashi/atcoder", "max_forks_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-07-22T17:27:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-22T17:27:09.000Z", "avg_line_length": 20.8221709007, "max_line_length": 217, "alphanum_fraction": 0.5043256433, "num_tokens": 3093, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8267117855317474, "lm_q2_score": 0.6584175005616829, "lm_q1q2_score": 0.5443215075146992}} {"text": "#include \n#include \n#include \n#include \ntypedef boost::adjacency_list_traits traits;\ntypedef boost::adjacency_list>>>\n graph;\n\ntypedef traits::vertex_descriptor vertex_desc;\ntypedef traits::edge_descriptor edge_desc;\n\nclass edge_adder\n{\n graph &G;\n\npublic:\n explicit edge_adder(graph &G) : G(G) {}\n\n void add_edge(int from, int to, long capacity)\n {\n auto c_map = boost::get(boost::edge_capacity, G);\n auto r_map = boost::get(boost::edge_reverse, G);\n const auto e = boost::add_edge(from, to, G).first;\n const auto rev_e = boost::add_edge(to, from, G).first;\n c_map[e] = capacity;\n c_map[rev_e] = 0; // reverse edge has no capacity!\n r_map[e] = rev_e;\n r_map[rev_e] = e;\n }\n};\n\nusing namespace std;\n\nvoid solve()\n{\n int n, m;\n cin >> n >> m;\n\n graph G(n);\n edge_adder adder(G);\n\n int u, v, c;\n for (int i = 0; i < m; ++i) {\n cin >> u >> v >> c;\n adder.add_edge(u, v, c);\n }\n\n long minCut = numeric_limits::max();\n\n int source = 0;\n for (int target = 1; target < n; ++target) {\n long maxFlow = boost::push_relabel_max_flow(G, source, target);\n minCut = min(minCut, maxFlow);\n maxFlow = boost::push_relabel_max_flow(G, target, source);\n minCut = min(minCut, maxFlow);\n }\n cout << minCut << endl;\n}\n\nint main()\n{\n ios_base::sync_with_stdio(false);\n int t;\n cin >> t;\n for (int i = 0; i < t; ++i)\n {\n solve();\n }\n return 0;\n}\n", "meta": {"hexsha": "d03364006b396f39c96512eb1c38dc80887cff2e", "size": 2008, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/algocoon.cpp", "max_stars_repo_name": "dsparber/algolab", "max_stars_repo_head_hexsha": "9781eb5c7444236f796f167f1f39fc9d913e5c53", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 13.0, "max_stars_repo_stars_event_min_datetime": "2021-01-01T17:19:24.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-09T12:27:57.000Z", "max_issues_repo_path": "src/algocoon.cpp", "max_issues_repo_name": "dsparber/algolab", "max_issues_repo_head_hexsha": "9781eb5c7444236f796f167f1f39fc9d913e5c53", "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/algocoon.cpp", "max_forks_repo_name": "dsparber/algolab", "max_forks_repo_head_hexsha": "9781eb5c7444236f796f167f1f39fc9d913e5c53", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-01-28T10:55:25.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-28T10:55:25.000Z", "avg_line_length": 27.1351351351, "max_line_length": 128, "alphanum_fraction": 0.5761952191, "num_tokens": 532, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430478583169, "lm_q2_score": 0.6548947357776795, "lm_q1q2_score": 0.5443112067206277}} {"text": "\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \"CompositeMinimization.h\"\n\nnamespace Grante {\n\ndouble CompositeMinimization::FISTAMinimize(\n\tCompositeMinimizationProblem& prob, std::vector& x_opt,\n\tdouble conv_tol, unsigned int max_iter, bool verbose) {\n\tdouble Lub = 0.25;\t// Lipschitz upper bound estimate for the gradient\n\tdouble eta = 2.0;\t// Lipschitz bound scale factor\n\n\t// Initialize iterates\n\tunsigned int dim = prob.Dimensions();\n\tx_opt.resize(dim);\n\tprob.ProvideStartingPoint(x_opt);\n\tstd::vector xprev(x_opt);\n\tstd::vector x_fgrad_dummy;\n\tstd::vector y(x_opt);\n\tstd::vector y_fgrad(dim, 0.0);\n\tstd::vector u(dim, 0.0);\n\n\t// Convergence criterion\n\tdouble conv = std::numeric_limits::infinity();\n\tdouble t = 1.0;\n\n\t// Objective F(x)=f(x)+g(x)\n\tdouble Fval = std::numeric_limits::signaling_NaN();\n\tboost::timer total_timer;\n\tunsigned int lip_iter = 0;\n\tfor (unsigned int iter = 0; max_iter == 0 || iter < max_iter; ++iter) {\n\t\tdouble y_fval = prob.EvalF(y, y_fgrad);\n\t\tdouble obj = y_fval + prob.EvalG(y, x_fgrad_dummy);\n\n\t\t// Verbose output\n\t\tif (verbose && (iter % 20 == 0)) {\n\t\t\tstd::cout << std::endl;\n\t\t\tstd::cout << \" iter time objective conv lipiter\"\n\t\t\t\t<< std::endl;\n\t\t}\n\t\tif (verbose) {\n\t\t\tstd::ios_base::fmtflags original_format = std::cout.flags();\n\t\t\tstd::streamsize original_prec = std::cout.precision();\n\n\t\t\t// Iteration\n\t\t\tstd::cout << std::setiosflags(std::ios::left)\n\t\t\t\t<< std::setiosflags(std::ios::adjustfield)\n\t\t\t\t<< std::setw(6) << iter << \" \";\n\t\t\t// Total runtime\n\t\t\tstd::cout << std::setiosflags(std::ios::left)\n\t\t\t\t<< std::resetiosflags(std::ios::scientific)\n\t\t\t\t<< std::setiosflags(std::ios::fixed)\n\t\t\t\t<< std::setiosflags(std::ios::adjustfield)\n\t\t\t\t<< std::setprecision(1)\n\t\t\t\t<< std::setw(6) << total_timer.elapsed() << \"s \";\n\t\t\tstd::cout << std::resetiosflags(std::ios::fixed);\n\n\t\t\t// Objective function\n\t\t\tstd::cout << std::setiosflags(std::ios::scientific)\n\t\t\t\t<< std::setprecision(5)\n\t\t\t\t<< std::setiosflags(std::ios::left)\n\t\t\t\t<< std::setiosflags(std::ios::showpos)\n\t\t\t\t<< std::setw(7) << obj << \" \";\n\t\t\t// Convergence criterion\n\t\t\tstd::cout << std::setiosflags(std::ios::scientific)\n\t\t\t\t<< std::setprecision(2)\n\t\t\t\t<< std::resetiosflags(std::ios::showpos)\n\t\t\t\t<< std::setiosflags(std::ios::left) << conv << \" \";\n\t\t\t// Lipschitz iterations\n\t\t\tstd::cout << std::setiosflags(std::ios::left)\n\t\t\t\t<< std::setiosflags(std::ios::adjustfield)\n\t\t\t\t<< std::setw(6) << lip_iter;\n\n\t\t\tstd::cout << std::endl;\n\n\t\t\tstd::cout.precision(original_prec);\n\t\t\tstd::cout.flags(original_format);\n\t\t}\n\n\t\t// Backtracking\n\t\tlip_iter = 0;\n\t\tdo {\n\t\t\tlip_iter += 1;\n\n\t\t\t// Solve (2.6) in Beck and Teboulle\n\t\t\tstd::transform(y.begin(), y.end(), y_fgrad.begin(), u.begin(),\n\t\t\t\t[Lub](double y_e, double y_fgrad_e) -> double {\n\t\t\t\t\treturn (y_e - y_fgrad_e/Lub); });\n\t\t\t// update x_opt\n\t\t\tprob.EvalGProximalOperator(u, Lub, x_opt);\n\n\t\t\t// Evaluate F(x)\n\t\t\tFval = prob.EvalF(x_opt, x_fgrad_dummy);\n\t\t\tFval += prob.EvalG(x_opt, x_fgrad_dummy);\n\n\t\t\t// Evaluate Q_L(x,y)\n\t\t\tdouble Qval = y_fval + prob.EvalG(x_opt, x_fgrad_dummy);\n\t\t\tfor (unsigned int di = 0; di < dim; ++di) {\n\t\t\t\tdouble xsuby = x_opt[di] - y[di];\n\t\t\t\tQval += xsuby*y_fgrad[di];\n\t\t\t\tQval += 0.5*Lub*xsuby*xsuby;\n\t\t\t}\n\n\t\t\t// Sufficient upper bound on the Lipschitz constant?\n\t\t\tif (Fval <= Qval)\n\t\t\t\tbreak;\n\n\t\t\tLub *= eta;\t// Increase upper bound estimate\n\t\t} while (true);\n\n\t\t// Update t sequence\n\t\tdouble tprev = t;\n\t\tt = 0.5*(1.0 + std::sqrt(1.0 + 4.0*tprev*tprev));\n\n\t\t// Perform averaged step: update y\n\t\tstd::transform(x_opt.begin(), x_opt.end(), xprev.begin(),\n\t\t\ty.begin(), [t,tprev](double xe, double xle) -> double {\n\t\t\t\treturn (xe + ((tprev-1.0)/t)*(xe-xle)); });\n\t\t// conv=norm(x_opt-xprev)\n\t\tconv = 0.0;\n\t\tfor (unsigned int di = 0; di < dim; ++di)\n\t\t\tconv += (x_opt[di]-xprev[di]) * (x_opt[di]-xprev[di]);\n\t\tconv = std::sqrt(conv);\n\t\tif (conv <= conv_tol) {\n\t\t\tif (verbose) {\n\t\t\t\tstd::cout << \"Converged with tolerance \" << conv\n\t\t\t\t\t<< \" (<= \" << conv_tol << \").\" << std::endl;\n\t\t\t}\n\t\t\treturn (Fval);\n\t\t}\n\n\t\tstd::copy(x_opt.begin(), x_opt.end(), xprev.begin());\n\t}\n\treturn (Fval);\t// objective of x_opt\n}\n\n}\n\n", "meta": {"hexsha": "47e40e86dac0aa2f2ab135e3222fecb362965d0f", "size": 4290, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "grante/CompositeMinimization.cpp", "max_stars_repo_name": "pantonante/grante-bazel", "max_stars_repo_head_hexsha": "e3f22ec111463a7ae0686494422ab09f86b4d39a", "max_stars_repo_licenses": ["DOC"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "grante/CompositeMinimization.cpp", "max_issues_repo_name": "pantonante/grante-bazel", "max_issues_repo_head_hexsha": "e3f22ec111463a7ae0686494422ab09f86b4d39a", "max_issues_repo_licenses": ["DOC"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "grante/CompositeMinimization.cpp", "max_forks_repo_name": "pantonante/grante-bazel", "max_forks_repo_head_hexsha": "e3f22ec111463a7ae0686494422ab09f86b4d39a", "max_forks_repo_licenses": ["DOC"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.1836734694, "max_line_length": 72, "alphanum_fraction": 0.6256410256, "num_tokens": 1384, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430478583168, "lm_q2_score": 0.6548947155710234, "lm_q1q2_score": 0.5443111899260059}} {"text": "#include \n#include \n\nEigen::VectorXd dipoleval(const Eigen::VectorXd & x, const Eigen::VectorXd & t, const Eigen::VectorXd & y){\n\tint x_size= x.size();\n\tint w=1;\n\tint n= t.size();\n\tEigen::VectorXd p=y;\n\tEigen::VectorXd dP=Eigen::MatrixXd::Zero(1,n);\n\tfor (int i=1; i0;j--){//i0\n\t\t\t//% compute dp(i)'s\n dP(j) = p(j+1) + (x(w)-t(j))*dP(j+1) - p(j) - (x(w)-t(i))*dP(j);\n dP(j) = dP(j) / ( t(i) - t(j) );\n //% compute p(i)'s\n p(j) = (x(w)-t(j)*p(j+1) - (x(w)-t(i))*p(j));\n p(j) = p(j) / ( t(i) - t(j) );\n }\n\t\t\tstd::cout <<\"test\\n\";\n\n\t}\n\treturn p.row(0);\n} \n\nint main(){\n\tint n=6;\n\tEigen::VectorXd x=Eigen::MatrixXd::Random(n,1);\n\tEigen::VectorXd y=Eigen::MatrixXd::Random(n,1);\n\tEigen::VectorXd t=Eigen::MatrixXd::Random(n,1);\n\t\n\tEigen::VectorXd v;\n\tv=dipoleval(x,t,y);\n\tstd::cout << v << std::endl;\n}\n\n", "meta": {"hexsha": "d678abff9133445f54272f57f9b97192f845f805", "size": 924, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Nummerical Methods for CSE/PS6/dipoleval.cpp", "max_stars_repo_name": "valentinjacot/backupETHZ", "max_stars_repo_head_hexsha": "36605c4f532eb65efb4a391ed0f17a07102f7d5b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-12-25T10:21:30.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-25T10:21:30.000Z", "max_issues_repo_path": "Nummerical Methods for CSE/PS6/dipoleval.cpp", "max_issues_repo_name": "valentinjacot/backupETHZ", "max_issues_repo_head_hexsha": "36605c4f532eb65efb4a391ed0f17a07102f7d5b", "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": "Nummerical Methods for CSE/PS6/dipoleval.cpp", "max_forks_repo_name": "valentinjacot/backupETHZ", "max_forks_repo_head_hexsha": "36605c4f532eb65efb4a391ed0f17a07102f7d5b", "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.6666666667, "max_line_length": 107, "alphanum_fraction": 0.512987013, "num_tokens": 339, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942261220292, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.5443098407788755}} {"text": "/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */\n/* */\n/* This file is part of the library KASKADE 7 */\n/* see http://www.zib.de/projects/kaskade7-finite-element-toolbox */\n/* */\n/* Copyright (C) 2002-2011 Zuse Institute Berlin */\n/* */\n/* KASKADE 7 is distributed under the terms of the ZIB Academic License. */\n/* see $KASKADE/academic.txt */\n/* */\n/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */\n\n#ifndef NORMS_HH\n#define NORMS_HH\n\n/**\n * @file\n * @brief Some norms for FunctionSpaceElement s or FunctionViews\n * @author Anton Schiela\n */\n\n#include \n#include \n#include \n\nnamespace Kaskade\n{\n/// L_2-norms\nstruct L2Norm\n{\n/// Evaluation of square norm\n template \n double square(Function const& f) const\n {\n Integral integral;\n FunctionViews::AbsSquare asf(f);\n return integral(asf);\n }\n\n/// Evaluation of norm\n template \n double operator()(Function const& f) const\n {\n return std::sqrt(square(f));\n }\n};\n\n/// L_2-norms\n// struct L2ScalarProduct\n// {\n// /// Evaluation of square norm\n// template \n// double operator()(Function f,Function g) \n// {\n// Integral integral;\n// FunctionViews::Dot dotfg(f,g);\n// return integral(dotfg);\n// }\n// \n// /// Evaluation of norm\n// template \n// double operator()(Function f) \n// {\n// return std::sqrt(this->operator()(f,f));\n// }\n// };\n\n/// H1-semi-norms\nstruct H1SemiNorm\n{\n/// Evaluation of square norm\n template \n double square(Function const& f) const\n {\n Integral integral;\n FunctionViews::GradientAbsSquare asf(f);\n return integral(asf);\n// FunctionViews::Gradient gf(f);\n// L2Norm l2Norm;\n// return l2Norm.square(gf);\n } \n\n/// Evaluation of norm\n template \n double operator()(Function const& f) const\n {\n return std::sqrt(square(f));\n }\n};\n\n\n// THE FOLLOWING CODE IS UNDOCUMENTED, APPEARS TO BE RATHER PROJECT-SPECIFIC, AND IS NOWHERE USED IN\n// THE SVN REPOSITORY. UNLESS SOME UNEXPECTED PROBLEMS ARISE, THIS CODE WILL BE DELETED AS OF \n// 2016-03-31.\n// \n// template \n// struct Decrement\n// {\n// static constexpr int value = val-1;\n// };\n// \n// \n// \n// template \n// struct MyNormEvaluator\n// {\n// template \n// static double square(DomainElement const& x, Norm const& norm)\n// {\n// return norm.square( boost::fusion::at_c(x.data) ) + MyNormEvaluator::square(x,norm);\n// }\n// };\n// \n// template \n// struct MyNormEvaluator<0,numberOfVariables>\n// {\n// template \n// static double square(DomainElement const& x, Norm const& norm)\n// {\n// return norm.square( boost::fusion::at_c<0>(x.data) );\n// }\n// };\n// \n// struct MyH1SemiNorm\n// {\n// template \n// static double square(DomainElement const& x)\n// {\n// return MyNormEvaluator::square(x,H1SemiNorm());\n// }\n// \n// template \n// double operator()(DomainElement const& x) const\n// {\n// return sqrt(square(x));\n// }\n// };\n\n// struct MyL2Norm\n// {\n// template \n// static double square(DomainElement const& x)\n// {\n// return MyNormEvaluator::square(x,L2Norm());\n// }\n// \n// template \n// double operator()(DomainElement const& x) const\n// {\n// return sqrt(square(x));\n// }\n// };\n\n\n/// H1-norms\nstruct H1Norm\n{\n/// Evaluation of square norm\n template \n double square(Function f) \n {\n H1SemiNorm h1Norm;\n L2Norm l2Norm;\n return h1Norm.square(f)+l2Norm.square(f);\n } \n\n/// Evaluation of norm\n template \n double operator()(Function f) \n {\n return std::sqrt(square(f));\n }\n};\n\ntemplate class LocalIntegral;\ntemplate class CellData;\n\n/// local (cellwise) H1-semi-norms\ntemplate\ntypename CellData::CellDataVector localH1SemiNorm(Function const& f)\n{\n typedef typename Function::Space Space;\n typedef typename Space::Grid Grid;\n LocalIntegral localIntegral;\n typename CellData::CellDataVector\n errorIndicator(localIntegral(\n makeView(makeView(f))));\n return errorIndicator;\n}\n\n/// local (cellwise) L2-norms\ntemplate\ntypename CellData::CellDataVector localL2Norm(Function const& f)\n{\n typedef typename Function::Space Space;\n typedef typename Space::Grid Grid;\n LocalIntegral localIntegral;\n typename CellData::CellDataVector\n errorIndicator(localIntegral(\n makeView(f)));\n return errorIndicator;\n}\n\n\n/**\n * @brief boundaryL2Norm computes the L2-norm of an FE function on the whole boundary of the underlying grid.\n *\n * @param function is the FE function to be integrated.\n * @tparam FEFunction is the type of the integrand.\n * @return value of integral\n *\n */\ntemplate \ntypename FEFunction::Space::Scalar boundaryL2Norm(FEFunction const& function) {\n FunctionViews::AbsSquare functionSquared(function);\n return std::sqrt(integrateOverBoundary(functionSquared));\n}\n} // end of namespace Kaskade\n#endif\n", "meta": {"hexsha": "6ed61c74d007b10b1fe436064eca49c87bda6e9d", "size": 6376, "ext": "hh", "lang": "C++", "max_stars_repo_path": "Kaskade/fem/norms.hh", "max_stars_repo_name": "chenzongxiong/streambox", "max_stars_repo_head_hexsha": "76f95780d1bf6c02731e39d8ac73937cea352b95", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2019-07-03T14:03:31.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-19T10:18:49.000Z", "max_issues_repo_path": "Kaskade/fem/norms.hh", "max_issues_repo_name": "chenzongxiong/streambox", "max_issues_repo_head_hexsha": "76f95780d1bf6c02731e39d8ac73937cea352b95", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2020-02-17T12:01:31.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-09T22:02:36.000Z", "max_forks_repo_path": "Kaskade/fem/norms.hh", "max_forks_repo_name": "chenzongxiong/streambox", "max_forks_repo_head_hexsha": "76f95780d1bf6c02731e39d8ac73937cea352b95", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-12-03T04:41:18.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-11T21:44:42.000Z", "avg_line_length": 28.9818181818, "max_line_length": 144, "alphanum_fraction": 0.6314303639, "num_tokens": 1582, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.890294223211224, "lm_q2_score": 0.611381973294151, "lm_q1q2_score": 0.5443098389992614}} {"text": "/*\n * Copyright 2019 © Centre Interdisciplinaire de développement en Cartographie des Océans (CIDCO), Tous droits réservés\n */\n\n/* \n * File: SideScanGeoreferencing.hpp\n * Author: Jordan McManus \n *\n * Created on March 11, 2020, 12:40 PM\n */\n\n#ifndef SIDESCANGEOREFERENCING_HPP\n#define SIDESCANGEOREFERENCING_HPP\n\n#include \n#include \"../Position.hpp\"\n#include \"../math/CoordinateTransform.hpp\"\n\nclass SideScanGeoreferencing {\npublic:\n\n static void georeferenceSideScanEcef(\n Eigen::Vector3d & antennaEcef,\n Eigen::Vector3d & antenna2TowPointLeverArmEcef,\n Eigen::Vector3d & layBackEcef,\n Eigen::Vector3d & sideDistanceEcef,\n Position & georeferencedPosition\n ) {\n\n Eigen::Vector3d objectPositionEcef =\n antennaEcef +\n antenna2TowPointLeverArmEcef +\n layBackEcef +\n sideDistanceEcef;\n\n CoordinateTransform::convertECEFToLongitudeLatitudeElevation(objectPositionEcef, georeferencedPosition);\n }\n};\n\n#endif /* SIDESCANGEOREFERENCING_HPP */\n\n", "meta": {"hexsha": "be107f0c668af2422558156272cfd817e92c9fb3", "size": 1123, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/sidescan/SideScanGeoreferencing.hpp", "max_stars_repo_name": "JordanMcManus/MBES-lib", "max_stars_repo_head_hexsha": "618d64f4e042bf5660015819f89537cdd70e696d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 13.0, "max_stars_repo_stars_event_min_datetime": "2019-10-29T14:16:13.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-24T06:44:37.000Z", "max_issues_repo_path": "src/sidescan/SideScanGeoreferencing.hpp", "max_issues_repo_name": "JordanMcManus/MBES-lib", "max_issues_repo_head_hexsha": "618d64f4e042bf5660015819f89537cdd70e696d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 62.0, "max_issues_repo_issues_event_min_datetime": "2019-04-16T13:53:50.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-07T19:44:23.000Z", "max_forks_repo_path": "src/sidescan/SideScanGeoreferencing.hpp", "max_forks_repo_name": "JordanMcManus/MBES-lib", "max_forks_repo_head_hexsha": "618d64f4e042bf5660015819f89537cdd70e696d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 18.0, "max_forks_repo_forks_event_min_datetime": "2019-04-10T19:51:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-31T21:42:22.000Z", "avg_line_length": 26.7380952381, "max_line_length": 119, "alphanum_fraction": 0.679430098, "num_tokens": 287, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891392358014, "lm_q2_score": 0.6619228825191871, "lm_q1q2_score": 0.5442258050189309}} {"text": "/**\n * MULTIDRONE Project:\n *\n * Geographic to Cartesian coordinate conversion and vice versa, with an intermediate conversion to UTM.\n *\n * This library suppose that the path of the robot cannot cross more than 2 different UTM zones.\n *\n */\n\n#ifndef GEOGRAPHIC_TO_CARTESIAN\n#define GEOGRAPHIC_TO_CARTESIAN\n\n#include \n#include \n#include \n#include \n#include \n\n#include // IMPORTANT TO INSTALL GEODESY: sudo apt-get install ros-kinetic-geographic-info\n\n// #define USING_IN_PYTHON\n\n// #ifdef USING_IN_PYTHON\n// #include \n// #endif\n\nnamespace multidrone {\n\ninline geometry_msgs::Point32 geographic_to_cartesian (const geographic_msgs::GeoPoint& _actual_coordinate_geo, const geographic_msgs::GeoPoint& _origin_geo) {\n\n geodesy::UTMPoint actual_coordinate_UTM(_actual_coordinate_geo); // Conversion from geographic coordinates to UTM.\n geodesy::UTMPoint origin_UTM(_origin_geo); // Conversion from geographic coordinates to UTM.\n\n geometry_msgs::Point32 actual_coordinate_cartesian; // Cartesian coordinate that this function will return.\n\n // The problem with UTM is that if there are coordinates in more than one zone, it's difficult to merge the coordinates of the different zones.\n // This is because each zone has 6 degrees of longitude, and the width in meters of the zone is variable from equator to the poles.\n // Something similar when the coordinates are in different hemispheres, separated by the equator. Each hemisphere has a different origin for the y axis.\n // These are the reasons why the x and y assignation for the Cartesian conversion isn't a simple UTM substraction.\n\n // Assignating \"actual_coordinate_cartesian.x\" is tricky when the actual coordinate and the origin of the Cartesian coordinates are on different zones.\n if ( int(actual_coordinate_UTM.zone)==60 && origin_UTM.zone==1 ) { // Coordinate and origin separated by the +-180º longitude\n geographic_msgs::GeoPoint geo_180_w;\n geographic_msgs::GeoPoint geo_180_e;\n geo_180_w.longitude = 179.9999999;\n geo_180_w.latitude = _actual_coordinate_geo.latitude;\n geo_180_w.altitude = _actual_coordinate_geo.altitude;\n geo_180_e.longitude = -179.9999999;\n geo_180_e.latitude = _actual_coordinate_geo.latitude;\n geo_180_e.altitude = _actual_coordinate_geo.altitude;\n geodesy::UTMPoint utm_180_w(geo_180_w);\n geodesy::UTMPoint utm_180_e(geo_180_e);\n actual_coordinate_cartesian.x = actual_coordinate_UTM.easting - utm_180_w.easting + utm_180_e.easting - origin_UTM.easting; // Transformation of the x coordinate taking into account the different zones. \" - utm_180_w.easting + utm_180_e.easting \" computes the x step in both sides of the border longitude.\n } else if ( origin_UTM.zone==60 && int(actual_coordinate_UTM.zone)==1 ) { // Coordinate and origin separated by the +-180º longitude\n geographic_msgs::GeoPoint geo_180_w;\n geographic_msgs::GeoPoint geo_180_e;\n geo_180_w.longitude = 179.9999999;\n geo_180_w.latitude = _actual_coordinate_geo.latitude;\n geo_180_w.altitude = _actual_coordinate_geo.altitude;\n geo_180_e.longitude = -179.9999999;\n geo_180_e.latitude = _actual_coordinate_geo.latitude;\n geo_180_e.altitude = _actual_coordinate_geo.altitude;\n geodesy::UTMPoint utm_180_w(geo_180_w);\n geodesy::UTMPoint utm_180_e(geo_180_e);\n actual_coordinate_cartesian.x = actual_coordinate_UTM.easting - utm_180_e.easting + utm_180_w.easting - origin_UTM.easting; // Transformation of the x coordinate taking into account the different zones. \" - utm_180_w.easting + utm_180_e.easting \" computes the x step in both sides of the border longitude.\n } else if ( int(actual_coordinate_UTM.zone) < origin_UTM.zone ) {\n int quotient_from_int_division = (int) ( std::max(std::abs(_actual_coordinate_geo.longitude),std::abs(_origin_geo.longitude))/6 ); // int division of the max longitude (absolute, without sign)\n double border_longitude = quotient_from_int_division * 6.0 *pow(-1,std::signbit(std::max(_actual_coordinate_geo.longitude,_origin_geo.longitude))); // border_longitude = quotient_from_int_division * 6 *(-1)^(1 if negative longitude, 0 if positive)\n geographic_msgs::GeoPoint geo_w;\n geographic_msgs::GeoPoint geo_e;\n geo_w.longitude = border_longitude - 0.0000001;\n geo_w.latitude = _actual_coordinate_geo.latitude;\n geo_w.altitude = _actual_coordinate_geo.altitude;\n geo_e.longitude = border_longitude + 0.0000001;\n geo_e.latitude = _actual_coordinate_geo.latitude;\n geo_e.altitude = _actual_coordinate_geo.altitude;\n geodesy::UTMPoint utm_w(geo_w);\n geodesy::UTMPoint utm_e(geo_e);\n actual_coordinate_cartesian.x = actual_coordinate_UTM.easting - utm_w.easting + utm_e.easting - origin_UTM.easting; // Transformation of the x coordinate taking into account the different zones. \" - utm_w.easting + utm_e.easting \" computes the x step in both sides of the border longitude.\n } else if ( origin_UTM.zone < int(actual_coordinate_UTM.zone) ) {\n int quotient_from_int_division = (int) ( std::max(std::abs(_actual_coordinate_geo.longitude),std::abs(_origin_geo.longitude))/6 ); // int division of the max longitude (absolute, without sign)\n double border_longitude = quotient_from_int_division * 6.0 *pow(-1,std::signbit(std::max(_actual_coordinate_geo.longitude,_origin_geo.longitude))); // border_longitude = quotient_from_int_division * 6 *(-1)^(1 if negative longitude, 0 if positive)\n geographic_msgs::GeoPoint geo_w;\n geographic_msgs::GeoPoint geo_e;\n geo_w.longitude = border_longitude - 0.0000001;\n geo_w.latitude = _actual_coordinate_geo.latitude;\n geo_w.altitude = _actual_coordinate_geo.altitude;\n geo_e.longitude = border_longitude + 0.0000001;\n geo_e.latitude = _actual_coordinate_geo.latitude;\n geo_e.altitude = _actual_coordinate_geo.altitude;\n geodesy::UTMPoint utm_w(geo_w);\n geodesy::UTMPoint utm_e(geo_e);\n actual_coordinate_cartesian.x = actual_coordinate_UTM.easting - utm_e.easting + utm_w.easting - origin_UTM.easting; // Transformation of the x coordinate taking into account the different zones. \" - utm_w.easting + utm_e.easting \" computes the x step in both sides of the border longitude.\n } else {\n // The actual coordinate is in the same zone that the origin (the first station). This is the normal situation, the assigntation of the x axis value is trivial (simple subtraction).\n actual_coordinate_cartesian.x = actual_coordinate_UTM.easting -origin_UTM.easting;\n }\n\n // Assignating \"actual_coordinate_cartesian.y\" is also tricky when the actual coordinate and the origin of the Cartesian coordinates are on different hemispheres:\n if ( origin_UTM.band=='N' && actual_coordinate_UTM.band=='M' ) { // Coordinate and origin separated by the 0º latitude\n geographic_msgs::GeoPoint geo_0_n;\n geographic_msgs::GeoPoint geo_0_s;\n geo_0_n.longitude = _actual_coordinate_geo.longitude;\n geo_0_n.latitude = 0.0000001;\n geo_0_n.altitude = _actual_coordinate_geo.altitude;\n geo_0_s.longitude = _actual_coordinate_geo.longitude;\n geo_0_s.latitude = -0.0000001;\n geo_0_s.altitude = _actual_coordinate_geo.altitude;\n geodesy::UTMPoint utm_0_n(geo_0_n);\n geodesy::UTMPoint utm_0_s(geo_0_s);\n actual_coordinate_cartesian.y = actual_coordinate_UTM.northing - utm_0_s.northing + utm_0_n.northing - origin_UTM.northing; // Transformation of the y coordinate taking into account the different hemispheres. \" - utm_0_s.northing + utm_0_n.northing \" computes the y step in both sides of the equator.\n } else if ( actual_coordinate_UTM.band=='N' && origin_UTM.band=='M' ) { // Coordinate and origin separated by the 0º latitude\n geographic_msgs::GeoPoint geo_0_n;\n geographic_msgs::GeoPoint geo_0_s;\n geo_0_n.longitude = _actual_coordinate_geo.longitude;\n geo_0_n.latitude = 0.0000001;\n geo_0_n.altitude = _actual_coordinate_geo.altitude;\n geo_0_s.longitude = _actual_coordinate_geo.longitude;\n geo_0_s.latitude = -0.0000001;\n geo_0_s.altitude = _actual_coordinate_geo.altitude;\n geodesy::UTMPoint utm_0_n(geo_0_n);\n geodesy::UTMPoint utm_0_s(geo_0_s);\n actual_coordinate_cartesian.y = actual_coordinate_UTM.northing - utm_0_n.northing + utm_0_s.northing - origin_UTM.northing; // Transformation of the y coordinate taking into account the different hemispheres. \" - utm_0_n.northing + utm_0_s.northing \" computes the y step in both sides of the equator.\n } else {\n // The actual coordinate is in the same hemisphere that the origin (the first station). This is the normal situation, the assigntation of the y axis value is trivial (simple subtraction).\n actual_coordinate_cartesian.y = actual_coordinate_UTM.northing-origin_UTM.northing;\n }\n\n // Assignating \"actual_coordinate_cartesian.z\" is trivial always, simple subtraction.\n actual_coordinate_cartesian.z = actual_coordinate_UTM.altitude-origin_UTM.altitude;\n\n return actual_coordinate_cartesian;\n} // end geographic_to_cartesian\n\n\n\ninline geographic_msgs::GeoPoint cartesian_to_geographic (const geometry_msgs::Point32& _actual_coordinate_cartesian, const geographic_msgs::GeoPoint& _origin_geo) {\n geodesy::UTMPoint actual_coordinate_aux(_origin_geo); // Conversion from geographic coordinates to UTM.\n\n actual_coordinate_aux.easting += _actual_coordinate_cartesian.x;\n actual_coordinate_aux.northing += _actual_coordinate_cartesian.y;\n actual_coordinate_aux.altitude += _actual_coordinate_cartesian.z;\n\n // Convert to geographic coordinates and return the coordinate. This conversion is easier as it doesn't matter if the points are in different zones or hemispheres, but in that case the error increases if the points are very far from each other.\n return geodesy::toMsg (actual_coordinate_aux);\n\n} // end cartesian_to_geographic\n\n\n\n// #ifdef USING_IN_PYTHON\n// BOOST_PYTHON_MODULE(geographic_to_cartesian_and_vice_verse) {\n// using namespace boost::python;\n// def(\"geographic_to_cartesian\", geographic_to_cartesian);\n// def(\"cartesian_to_geographic\", cartesian_to_geographic);\n// }\n// #endif\n\n} // end namespace multidrone\n\n#endif // GEOGRAPHIC_TO_CARTESIAN", "meta": {"hexsha": "5e6f3082b05ef40505cc3d1ddc8961c2d4d021e3", "size": 10707, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "multidrone_kml_parser/include/multidrone_kml_parser/geographic_to_cartesian.hpp", "max_stars_repo_name": "grvcTeam/multidrone_planning", "max_stars_repo_head_hexsha": "421a7d81a3417cdc6bcb690d3d88bb4e9d6b6638", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 12.0, "max_stars_repo_stars_event_min_datetime": "2020-07-02T07:00:35.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-08T07:59:41.000Z", "max_issues_repo_path": "multidrone_kml_parser/include/multidrone_kml_parser/geographic_to_cartesian.hpp", "max_issues_repo_name": "grvcTeam/multidrone_planning", "max_issues_repo_head_hexsha": "421a7d81a3417cdc6bcb690d3d88bb4e9d6b6638", "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": "multidrone_kml_parser/include/multidrone_kml_parser/geographic_to_cartesian.hpp", "max_forks_repo_name": "grvcTeam/multidrone_planning", "max_forks_repo_head_hexsha": "421a7d81a3417cdc6bcb690d3d88bb4e9d6b6638", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-01T06:35:22.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-24T09:54:21.000Z", "avg_line_length": 66.5031055901, "max_line_length": 313, "alphanum_fraction": 0.7404501728, "num_tokens": 2607, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891130942474, "lm_q2_score": 0.6619228691808011, "lm_q1q2_score": 0.5442257767485624}} {"text": "/**\n * \\file RemezBasedFilter.cpp\n */\n\n#include \n\n#include \n\n#include \n\n#include \n#include \n#include \n\n#include \n\nnamespace\n{\n template\n class RemezBuilder\n {\n public:\n using AlignedScalarVector = typename ATK::TypedBaseFilter::AlignedScalarVector;\n private:\n const static gsl::index grid_size = 1024; // grid size, power of two better for FFT\n constexpr static DataType SN = 1e-8;\n\n gsl::index M;\n std::vector grid;\n std::vector, std::pair> > target;\n \n /// Computed coefficients\n AlignedScalarVector coeffs;\n /// Selected indices\n std::vector indices;\n /// Weight function on the grid\n std::vector weights;\n /// Objective function on the grid\n std::vector objective;\n /// Alternate signs\n std::vector s;\n\n ATK::FFT fft_processor;\n\n public:\n RemezBuilder(gsl::index order, const std::vector, std::pair> >& target)\n :M(order / 2), target(target)\n {\n grid.resize(grid_size);\n for(gsl::index i = 0; i < grid_size; ++i)\n {\n grid[i] = i * boost::math::constants::pi() / grid_size;\n }\n fft_processor.set_size(2 * grid_size);\n }\n \n void init()\n {\n coeffs.assign(M * 2 + 1, 0);\n indices.assign(M + 2, -1);\n s.assign(M+2, 0);\n \n weights.assign(grid_size, 0);\n objective.assign(grid_size, 0);\n\n int current_template = 0;\n for(gsl::index i = 0; i < grid_size; ++i)\n {\n auto reduced_freq = grid[i] / boost::math::constants::pi();\n if(reduced_freq > target[current_template].first.second && current_template + 1 < target.size())\n {\n ++current_template;\n }\n if (reduced_freq < target[current_template].first.first || reduced_freq > target[current_template].first.second)\n {\n weights[i] = 0;\n objective[i] = 0;\n }\n else\n {\n weights[i] = target[current_template].second.second;\n objective[i] = target[current_template].second.first;\n }\n }\n int flag = -1;\n for (gsl::index i = 0; i < M + 2; ++i)\n {\n s[i] = flag;\n flag = -flag;\n }\n indices = set_starting_conditions();\n }\n\n std::vector set_starting_conditions() const\n {\n std::vector indices;\n\n std::vector valid_indices;\n for (gsl::index i = 0; i < grid_size; ++i)\n {\n if (weights[i] != 0)\n {\n valid_indices.push_back(i);\n }\n }\n\n for (gsl::index i = 0; i < M + 2; ++i)\n {\n indices.push_back(valid_indices[std::lround(valid_indices.size() / (M + 4.) * (i + 1))]);\n }\n\n return indices;\n }\n \n AlignedScalarVector build()\n {\n if(target.empty())\n {\n coeffs.clear();\n return coeffs;\n }\n init();\n while(true)\n {\n Eigen::Matrix A(M + 2, M + 2);\n for (gsl::index i = 0; i < M + 2; ++i)\n {\n for (gsl::index j = 0; j < M + 1; ++j)\n {\n A(i, j) = std::cos(grid[indices[i]] * j);\n }\n }\n for (gsl::index i = 0; i < M + 2; ++i)\n {\n A(i, M + 1) = s[i] / weights[indices[i]];\n }\n\n Eigen::Matrix b(M + 2, 1);\n for (gsl::index i = 0; i < M + 2; ++i)\n {\n b(i) = objective[indices[i]];\n }\n Eigen::Matrix x = A.colPivHouseholderQr().solve(b);\n\n for (gsl::index i = 0; i < M; ++i)\n {\n coeffs[i] = coeffs[2 * M - i] = x[M - i] / 2;\n }\n coeffs[M] = x[0];\n auto delta = std::abs(x[M + 1]); // maximum cost\n\n auto newerr = compute_new_error();\n auto new_indices = locmax(newerr);\n\n filter_SN(delta, new_indices, newerr);\n filter_monotony(new_indices, newerr);\n\n DataType max = 0;\n for (auto indice : new_indices)\n {\n max = std::max(max, std::abs(newerr[indice]));\n }\n\n if ((max - delta) / delta < SN)\n {\n break;\n }\n\n indices = std::move(new_indices);\n }\n\n return coeffs;\n }\n \n private:\n /// Creates a spectral response for a given set of coeffs through an FFT\n std::vector firamp() const\n {\n std::vector> output(grid_size * 2);\n fft_processor.process_forward(coeffs.data(), output.data(), coeffs.size());\n std::vector amp(grid_size);\n for (gsl::index i = 0; i < grid_size; ++i)\n {\n amp[i] = (std::complex(std::cos(M * grid[i]), std::sin(M * grid[i])) * output[i]).real() * grid_size * 2;\n }\n return amp;\n }\n\n std::vector compute_new_error() const\n {\n auto fir_result = firamp();\n std::vector newerr(grid_size);\n for (gsl::index i = 0; i < grid_size; ++i)\n {\n newerr[i] = (fir_result[i] - objective[i]) * weights[i];\n }\n\n return newerr;\n }\n\n // Finds min and max\n std::vector locmax(const std::vector& data) const\n {\n std::vector v;\n\n std::vector temp1;\n std::vector temp2;\n temp1.push_back(data[0] - 1);\n for (gsl::index i = 0; i < data.size() - 1; ++i)\n {\n temp1.push_back(data[i]);\n temp2.push_back(data[i + 1]);\n }\n temp2.push_back(data.back() - 1);\n\n for (gsl::index i = 0; i < data.size(); ++i)\n {\n if ((data[i] > temp1[i]) && (data[i] > temp2[i]))\n {\n v.push_back(i);\n }\n }\n\n temp1.clear();\n temp2.clear();\n temp1.push_back(-data[0] - 1);\n for (gsl::index i = 0; i < data.size() - 1; ++i)\n {\n temp1.push_back(-data[i]);\n temp2.push_back(-data[i + 1]);\n }\n temp2.push_back(-data.back() - 1);\n\n for (gsl::index i = 0; i < data.size(); ++i)\n {\n if ((-data[i] > temp1[i]) && (-data[i] > temp2[i]))\n {\n v.push_back(i);\n }\n }\n\n std::sort(v.begin(), v.end());\n\n return v;\n }\n\n void filter_SN(DataType delta, std::vector& indices, const std::vector& err) const\n {\n std::vector new_indices;\n\n for (auto indice : indices)\n {\n if (std::abs(err[indice]) > (delta - SN))\n {\n new_indices.push_back(indice);\n }\n }\n\n indices = std::move(new_indices);\n }\n\n std::vector etap(const std::vector& data) const\n {\n std::vector v;\n auto xe = data[0];\n gsl::index xv = 0;\n for (gsl::index i = 1; i < data.size(); ++i)\n {\n if (std::signbit(data[i]) == std::signbit(xe))\n {\n if (std::abs(data[i]) > std::abs(xe))\n {\n xe = data[i];\n xv = i;\n }\n }\n else\n {\n v.push_back(xv);\n xe = data[i];\n xv = i;\n }\n }\n v.push_back(xv);\n return v;\n }\n\n void filter_monotony(std::vector& indices, const std::vector& err) const\n {\n std::vector filtered_err;\n for (auto indice : indices)\n {\n filtered_err.push_back(err[indice]);\n }\n\n auto selected_indices = etap(filtered_err);\n std::vector new_indices;\n for (gsl::index i = 0; i < M + 2; ++i)\n {\n new_indices.push_back(indices[selected_indices[i]]);\n }\n indices = std::move(new_indices);\n }\n };\n}\n\nnamespace ATK\n{\n template\n RemezBasedCoefficients::RemezBasedCoefficients(gsl::index nb_channels)\n :Parent(nb_channels, nb_channels)\n {\n }\n\n template\n RemezBasedCoefficients::RemezBasedCoefficients(RemezBasedCoefficients&& other)\n :Parent(std::move(other)), target(std::move(other.target)), in_order(std::move(other.in_order)), coefficients_in(std::move(other.coefficients_in))\n {\n }\n\n template\n void RemezBasedCoefficients::set_template(const std::vector, std::pair > >& target)\n {\n this->target = target;\n setup();\n }\n \n template\n const std::vector::CoeffDataType, typename RemezBasedCoefficients::CoeffDataType>, std::pair::CoeffDataType, typename RemezBasedCoefficients::CoeffDataType> > >& RemezBasedCoefficients::get_template() const\n {\n return target;\n }\n \n template\n void RemezBasedCoefficients::set_order(gsl::index order)\n {\n if(order % 2 == 1)\n {\n throw ATK::RuntimeError(\"Need an even filter order (considering order 0 has 1 coefficients)\");\n }\n in_order = order;\n setup();\n }\n\n template\n void RemezBasedCoefficients::setup()\n {\n Parent::setup();\n \n std::sort(target.begin(), target.end());\n for(gsl::index i = 0; i + 1 < target.size(); ++i)\n {\n if(target[i].first.second > target[i + 1].first.first)\n {\n target.clear();\n throw ATK::RuntimeError(\"Bad template\");\n }\n }\n \n if (in_order > 0)\n {\n RemezBuilder builder(in_order, target);\n coefficients_in = builder.build();\n }\n }\n \n template class ATK_EQ_EXPORT RemezBasedCoefficients;\n#if ATK_ENABLE_INSTANTIATION\n template class ATK_EQ_EXPORT RemezBasedCoefficients >;\n#endif\n}\n", "meta": {"hexsha": "d00f3e3af922e3b74e6ba9723818e672efe1f12f", "size": 10021, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ATK/EQ/RemezBasedFilter.cpp", "max_stars_repo_name": "D-J-Roberts/AudioTK", "max_stars_repo_head_hexsha": "accf009d7238f32702eb1d5ee23c5148fc68e3bd", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 249.0, "max_stars_repo_stars_event_min_datetime": "2015-01-05T13:36:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-15T18:47:46.000Z", "max_issues_repo_path": "ATK/EQ/RemezBasedFilter.cpp", "max_issues_repo_name": "D-J-Roberts/AudioTK", "max_issues_repo_head_hexsha": "accf009d7238f32702eb1d5ee23c5148fc68e3bd", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 22.0, "max_issues_repo_issues_event_min_datetime": "2015-07-28T15:20:24.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-11T14:18:19.000Z", "max_forks_repo_path": "ATK/EQ/RemezBasedFilter.cpp", "max_forks_repo_name": "D-J-Roberts/AudioTK", "max_forks_repo_head_hexsha": "accf009d7238f32702eb1d5ee23c5148fc68e3bd", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 48.0, "max_forks_repo_forks_event_min_datetime": "2015-08-15T12:08:13.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-07T02:33:07.000Z", "avg_line_length": 26.938172043, "max_line_length": 342, "alphanum_fraction": 0.5604231115, "num_tokens": 2765, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835207180243, "lm_q2_score": 0.6513548646660543, "lm_q1q2_score": 0.5441962555680073}} {"text": "#ifndef VECTORQUANTIZER_HPP\n#define VECTORQUANTIZER_HPP\n\n#include \n#include \"../iterator/iterator.hpp\"\n/**\n * @brief plain old vector quantizer\n */\ntemplate\nclass vectorquantizer {\n\n typedef Eigen::Matrix < T, D, 1 > vec_t;\n\n static_assert( ((C % 2 == 0) || ( C == 1)), \"vectorquantizer: cells = 0 mod 2 failed or C==1\");\n\npublic:\n\n // ================================================================================\n // Methods\n // ================================================================================\n\n vectorquantizer(){\n _raw_centroids = new T[C * D];\n _centroids = Eigen::Map>(_raw_centroids, C, D);\n\n }\n\n ~vectorquantizer() {\n delete[] _raw_centroids;\n\n }\n\n void getAssignment(iterator &iter) {\n // for each vector ...\n for (uint n = 0, n_e = iter.num(); n < n_e; ++n) {\n // find minimum\n uint bestIdx = 0;\n T bestDist = HUGE_VAL;\n vec_t vec = iter[n];\n // for each cluster\n for (uint c = 0, c_e = _step; c < c_e; ++c) {\n vec_t cec = _centroids.row(c);\n T curDist = (vec - cec).squaredNorm();\n if ( curDist < bestDist ) {\n bestDist = curDist;\n bestIdx = c;\n }\n }\n _mapping[n] = bestIdx;\n _distances[n] = bestDist;\n }\n }\n\n void updateCentroids(iterator &iter) {\n _centroids = Eigen::Matrix::Zero(C, D);\n T centerCounter[C] = {0};\n // find mean\n for (uint n = 0, n_e = iter.num(); n < n_e; ++n) {\n const uint c = _mapping[n];\n _centroids.row(c) += iter[n];\n ++centerCounter[c];\n }\n for (uint c = 0; c < C; ++c) {\n if (centerCounter[c] != 0)\n _centroids.row(c).array() /= centerCounter[c];\n\n }\n }\n\n void augmentCentroids() {\n for (uint i = 0; i < _step; ++i) {\n _centroids.row(i + _step) = _centroids.row(i).array() + 0.001;\n _centroids.row(i) = _centroids.row(i).array() - 0.001;\n }\n _step *= 2;\n }\n\n T loss(iterator &iter) {\n Eigen::MatrixXf l = Eigen::Map< Eigen::MatrixXf >(_distances, iter.num(), 1);\n return l.sum();\n }\n\n uint id(const vec_t &vec) {\n // compute all l1 distances (row=part)\n for (uint c = 0; c < C; ++c) {\n const Eigen::Matrix< T, D, 1> cec = _centroids.row(c);\n const Eigen::Matrix< T, D, 1> diff = vec - cec;\n _L1distances[c] = diff.squaredNorm();\n _L1order[c] = c;\n\n }\n\n // now sort them according their distances (sort each row)\n auto comparator = [&](const uint8_t &lhs, const uint8_t &rhs) -> bool {\n return _L1distances[lhs] < _L1distances[rhs];\n };\n\n std::sort(_L1order, _L1order + C, comparator);\n\n return _L1order[0];\n\n }\n\n void dist(const vec_t &vec) {\n // compute all l1 distances (row=part)\n for (uint c = 0; c < C; ++c) {\n const Eigen::Matrix< T, D, 1> cec = _centroids.row(c);\n const Eigen::Matrix< T, D, 1> diff = vec - cec;\n _L1distances[c] = diff.squaredNorm();\n _L1order[c] = c;\n\n }\n\n\n }\n\n void generate(iterator &iter) {\n _step = 1;\n\n _mapping = new uint8_t[iter.num()]();\n _distances = new T[iter.num()]();\n\n _centroids.row(0) = iter.center();\n\n T currentLoss = 0.0;\n T lastLoss = 0.0;\n\n if (C == 1) {\n getAssignment(iter); // E step\n updateCentroids(iter); // M step\n return; // do nothing\n }\n\n do {\n augmentCentroids();\n do {\n lastLoss = currentLoss;\n getAssignment(iter); // E step\n updateCentroids(iter); // M step\n currentLoss = loss(iter);\n } while ((abs(lastLoss - currentLoss) > 0.005));\n } while (_step < C );\n\n delete[] _mapping;\n delete[] _distances;\n }\n\n\n // ================================================================================\n // Variables\n // ================================================================================\n\n Eigen::Matrix _centroids;\n T *_raw_centroids;\n uint _step;\n uint8_t *_mapping;\n T *_distances;\n\n T _L1distances[C];\n uint _L1order[C];\n\n};\n\n#endif", "meta": {"hexsha": "382cb1a5dff0b058fee96486caa327e3ca832f94", "size": 4581, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "cpu_version/quantizer/vectorquantizer.hpp", "max_stars_repo_name": "takanokage/Product-Quantization-Tree", "max_stars_repo_head_hexsha": "2651ba871100ff4c0ccef42ba57e871fbc6181f8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 98.0, "max_stars_repo_stars_event_min_datetime": "2016-07-18T07:38:07.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-02T15:28:01.000Z", "max_issues_repo_path": "cpu_version/quantizer/vectorquantizer.hpp", "max_issues_repo_name": "takanokage/Product-Quantization-Tree", "max_issues_repo_head_hexsha": "2651ba871100ff4c0ccef42ba57e871fbc6181f8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 14.0, "max_issues_repo_issues_event_min_datetime": "2016-08-03T08:43:36.000Z", "max_issues_repo_issues_event_max_datetime": "2017-11-02T14:39:41.000Z", "max_forks_repo_path": "cpu_version/quantizer/vectorquantizer.hpp", "max_forks_repo_name": "takanokage/Product-Quantization-Tree", "max_forks_repo_head_hexsha": "2651ba871100ff4c0ccef42ba57e871fbc6181f8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 36.0, "max_forks_repo_forks_event_min_datetime": "2016-07-27T13:47:12.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-13T14:34:46.000Z", "avg_line_length": 27.9329268293, "max_line_length": 99, "alphanum_fraction": 0.4523029906, "num_tokens": 1217, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835371034368, "lm_q2_score": 0.6513548511303336, "lm_q1q2_score": 0.5441962549318536}} {"text": "#include \"teca_2d_component_area.h\"\n\n#include \"teca_mesh.h\"\n#include \"teca_array_collection.h\"\n#include \"teca_variant_array.h\"\n#include \"teca_metadata.h\"\n#include \"teca_cartesian_mesh.h\"\n\n#include \n#include \n#include \n#include \n#define _USE_MATH_DEFINES\n#include \n\n#if defined(TECA_HAS_BOOST)\n#include \n#endif\n\nnamespace {\n\ntemplate \ncomponent_t get_max_component_id(unsigned long n, const component_t *labels)\n{\n component_t max_component_id = std::numeric_limits::lowest();\n for (unsigned long i = 0; i < n; ++i)\n {\n component_t label = labels[i];\n max_component_id = label > max_component_id ? label : max_component_id;\n }\n return max_component_id;\n}\n\n// visit each node in the mesh, the node is treated as a cell in\n// the dual mesh defined by mid points between nodes. the area of\n// the cell is added to the corresponding label. this formulation\n// requires a layer of ghost nodes\n//\n// The exact area of the sperical rectangular patch A_i is given by:\n//\n// A_i = rho^2(cos(phi_0) - cos(phi_1))(theta_1 - theta_0)\n//\n// = rho^2(sin(rad_lat_0) - sin(rad_lat_1))(theta_1 - theta_0)\n//\n// where\n//\n// theta = deg_lon * pi/180\n// phi = pi/2 - rad_lat\n// rad_lat = deg_lat * pi/180\n// sin(rad_lat) = cos(pi/2 - rad_lat)\n//\ntemplate\nvoid component_area(unsigned long nlon, unsigned long nlat,\n const coord_t *deg_lon, const coord_t *deg_lat, const component_t *labels,\n container_t &area)\n{\n // This calculation is sensative to floating point precision and\n // should be done in double precision\n using calc_t = double;\n\n calc_t R_e = 6378.1370; // km\n calc_t R_e_sq = R_e*R_e;\n calc_t rad_per_deg = M_PI/180.0;\n\n unsigned long nlonm1 = nlon - 1;\n unsigned long nlatm1 = nlat - 1;\n\n // convert to spherical coordinates in units of radians,\n // move to the dual mesh, and pre-compute factors in A\n calc_t *rho_sq_d_theta = (calc_t*)malloc(nlon*sizeof(calc_t));\n rho_sq_d_theta[0] = calc_t();\n for (unsigned long i = 1; i < nlonm1; ++i)\n rho_sq_d_theta[i] = R_e_sq*calc_t(0.5)*(deg_lon[i + 1] - deg_lon[i - 1])*rad_per_deg;\n rho_sq_d_theta[nlonm1] = calc_t();\n\n calc_t *rad_lat = (calc_t*)malloc(nlat*sizeof(calc_t));\n for (unsigned long j = 0; j < nlat; ++j)\n rad_lat[j] = deg_lat[j]*rad_per_deg;\n\n calc_t *d_cos_phi = (calc_t*)malloc(nlat*sizeof(calc_t));\n for (unsigned long j = 1; j < nlatm1; ++j)\n {\n calc_t cos_phi_1 = sin(calc_t(0.5)*(rad_lat[j - 1] + rad_lat[j]));\n calc_t cos_phi_0 = sin(calc_t(0.5)*(rad_lat[j] + rad_lat[j + 1]));\n d_cos_phi[j] = cos_phi_0 - cos_phi_1;\n }\n d_cos_phi[0] = calc_t();\n d_cos_phi[nlatm1] = calc_t();\n\n // finish off the calc by multiplying the factors\n for (unsigned long j = 1; j < nlatm1; ++j)\n {\n calc_t d_cos_phi_j = d_cos_phi[j];\n unsigned long jj = j*nlon;\n for (unsigned long i = 1; i < nlonm1; ++i)\n {\n area[labels[jj + i]] += rho_sq_d_theta[i]*d_cos_phi_j;\n }\n }\n\n free(rad_lat);\n free(d_cos_phi);\n free(rho_sq_d_theta);\n}\n\n}\n\n\n\n// --------------------------------------------------------------------------\nteca_2d_component_area::teca_2d_component_area() :\n component_variable(\"\"), contiguous_component_ids(0), background_id(-1)\n{\n this->set_number_of_input_connections(1);\n this->set_number_of_output_ports(1);\n}\n\n// --------------------------------------------------------------------------\nteca_2d_component_area::~teca_2d_component_area()\n{}\n\n#if defined(TECA_HAS_BOOST)\n// --------------------------------------------------------------------------\nvoid teca_2d_component_area::get_properties_description(\n const std::string &prefix, options_description &global_opts)\n{\n options_description opts(\"Options for \"\n + (prefix.empty()?\"teca_2d_component_area\":prefix));\n\n opts.add_options()\n TECA_POPTS_GET(std::string, prefix, component_variable,\n \"name of the varibale containing region labels\")\n TECA_POPTS_GET(int, prefix, contiguous_component_ids,\n \"when the region label ids start at 0 and are consecutive \"\n \"this flag enables use of an optimization\")\n TECA_POPTS_GET(long, prefix, background_id,\n \"the label id that corresponds to the background\")\n ;\n\n this->teca_algorithm::get_properties_description(prefix, opts);\n\n global_opts.add(opts);\n}\n\n// --------------------------------------------------------------------------\nvoid teca_2d_component_area::set_properties(const std::string &prefix,\n variables_map &opts)\n{\n this->teca_algorithm::set_properties(prefix, opts);\n\n TECA_POPTS_SET(opts, std::string, prefix, component_variable)\n TECA_POPTS_SET(opts, int, prefix, contiguous_component_ids)\n TECA_POPTS_SET(opts, long, prefix, background_id)\n}\n#endif\n\n// --------------------------------------------------------------------------\nint teca_2d_component_area::get_component_variable(std::string &component_var)\n{\n if (this->component_variable.empty())\n return -1;\n\n component_var = this->component_variable;\n return 0;\n}\n\n// --------------------------------------------------------------------------\nteca_metadata teca_2d_component_area::get_output_metadata(\n unsigned int port,\n const std::vector &input_md)\n{\n#ifdef TECA_DEBUG\n cerr << teca_parallel_id()\n << \"teca_2d_component_area::get_output_metadata\" << endl;\n#endif\n (void) port;\n\n teca_metadata md = input_md[0];\n return md;\n}\n\n// --------------------------------------------------------------------------\nstd::vector teca_2d_component_area::get_upstream_request(\n unsigned int port,\n const std::vector &input_md,\n const teca_metadata &request)\n{\n#ifdef TECA_DEBUG\n cerr << teca_parallel_id()\n << \"teca_2d_component_area::get_upstream_request\" << endl;\n#endif\n (void) port;\n (void) input_md;\n\n std::vector up_reqs;\n\n // get the name of the array to request\n std::string component_var;\n if (this->get_component_variable(component_var))\n {\n TECA_FATAL_ERROR(\"component_variable was not specified\")\n return up_reqs;\n }\n\n // pass the incoming request upstream, and\n // add in what we need\n teca_metadata req(request);\n std::set arrays;\n if (req.has(\"arrays\"))\n req.get(\"arrays\", arrays);\n arrays.insert(component_var);\n\n req.set(\"arrays\", arrays);\n\n // send up\n up_reqs.push_back(req);\n return up_reqs;\n}\n\n\n// --------------------------------------------------------------------------\nconst_p_teca_dataset teca_2d_component_area::execute(\n unsigned int port,\n const std::vector &input_data,\n const teca_metadata &request)\n{\n#ifdef TECA_DEBUG\n cerr << teca_parallel_id()\n << \"teca_2d_component_area::execute\" << endl;\n#endif\n (void)port;\n (void)request;\n\n // get the input\n const_p_teca_cartesian_mesh in_mesh =\n std::dynamic_pointer_cast(\n input_data[0]);\n if (!in_mesh)\n {\n TECA_FATAL_ERROR(\"empty input, or not a cartesian_mesh\")\n return nullptr;\n }\n\n // create output and copy metadata, coordinates, etc\n p_teca_cartesian_mesh out_mesh = teca_cartesian_mesh::New();\n\n out_mesh->shallow_copy(\n std::const_pointer_cast(in_mesh));\n\n // get the input array\n std::string component_var;\n if (this->get_component_variable(component_var))\n {\n TECA_FATAL_ERROR(\"component_variable was not specified\")\n return nullptr;\n }\n\n const_p_teca_variant_array component_array\n = out_mesh->get_point_arrays()->get(component_var);\n if (!component_array)\n {\n TECA_FATAL_ERROR(\"label variable \\\"\" << component_var\n << \"\\\" is not in the input\")\n return nullptr;\n }\n\n // get mesh dimension\n unsigned long extent[6];\n out_mesh->get_extent(extent);\n\n unsigned long nx = extent[1] - extent[0] + 1;\n unsigned long ny = extent[3] - extent[2] + 1;\n unsigned long nxy = nx*ny;\n\n unsigned long nz = extent[5] - extent[4] + 1;\n if (nz != 1)\n {\n TECA_FATAL_ERROR(\"This calculation requires 2D data. The current dataset \"\n \"extents are [\" << extent[0] << \", \" << extent[1] << \", \"\n << extent[2] << \", \" << extent[3] << \", \" << extent[4] << \", \"\n << extent[5] << \"]\")\n return nullptr;\n }\n\n // get the coordinate axes\n const_p_teca_variant_array xc = in_mesh->get_x_coordinates();\n const_p_teca_variant_array yc = in_mesh->get_y_coordinates();\n\n // get the input and output metadata\n teca_metadata &in_metadata =\n const_cast(in_mesh->get_metadata());\n\n teca_metadata &out_metadata = out_mesh->get_metadata();\n\n // get the background_id, and pass it through\n long bg_id = this->background_id;\n if (this->background_id == -1)\n {\n if (in_metadata.get(\"background_id\", bg_id))\n {\n TECA_FATAL_ERROR(\"Metadata is missing the key \\\"background_id\\\". \"\n \"One should specify it via the \\\"background_id\\\" algorithm \"\n \"property\")\n return nullptr;\n }\n }\n out_metadata.set(\"background_id\", bg_id);\n\n // calculate area of components\n NESTED_TEMPLATE_DISPATCH_FP(const teca_variant_array_impl,\n xc.get(),\n _COORD,\n // the calculation is sensative to floating point precision\n // and should be made in double precision\n using calc_t = double;\n\n const NT_COORD *p_xc = static_cast(xc.get())->get();\n const NT_COORD *p_yc = static_cast(yc.get())->get();\n\n NESTED_TEMPLATE_DISPATCH_I(const teca_variant_array_impl,\n component_array.get(),\n _LABEL,\n\n const NT_LABEL *p_labels = static_cast(component_array.get())->get();\n\n unsigned int n_labels = 0;\n\n bool has_component_id = in_metadata.has(\"component_ids\");\n if (this->contiguous_component_ids || has_component_id)\n {\n // use a contiguous buffer to hold the result, only for\n // contiguous lables that start at 0\n p_teca_variant_array component_id;\n if (has_component_id)\n {\n in_metadata.get(\"number_of_components\", int(0), n_labels);\n component_id = in_metadata.get(\"component_ids\");\n }\n else\n {\n NT_LABEL max_component_id = ::get_max_component_id(nxy, p_labels);\n n_labels = max_component_id + 1;\n p_teca_variant_array_impl tmp = teca_variant_array_impl::New(n_labels);\n for (unsigned int i = 0; i < n_labels; ++i)\n tmp->set(i, NT_LABEL(i));\n component_id = tmp;\n }\n std::vector component_area(n_labels);\n ::component_area(nx,ny, p_xc,p_yc, p_labels, component_area);\n\n // transfer the result to the output\n out_metadata.set(\"number_of_components\", n_labels);\n out_metadata.set(\"component_ids\", component_id);\n out_metadata.set(\"component_area\", component_area);\n }\n else\n {\n // use an associative array to handle any labels\n //std::map result;\n decltype(std::map()) result;\n ::component_area(nx,ny, p_xc,p_yc, p_labels, result);\n\n // transfer the result to the output\n n_labels = result.size();\n\n p_teca_variant_array_impl component_id =\n teca_variant_array_impl::New(n_labels);\n\n p_teca_variant_array_impl component_area =\n teca_variant_array_impl::New(n_labels);\n\n //std::map::iterator it = result.begin();\n auto it = result.begin();\n for (unsigned int i = 0; i < n_labels; ++i,++it)\n {\n component_id->set(i, it->first);\n component_area->set(i, it->second);\n }\n\n out_metadata.set(\"number_of_components\", n_labels);\n out_metadata.set(\"component_ids\", component_id);\n out_metadata.set(\"component_area\", component_area);\n }\n )\n )\n\n return out_mesh;\n}\n", "meta": {"hexsha": "f556dc8e28c2cadee63c5aa62bf513e0e186e62d", "size": 12863, "ext": "cxx", "lang": "C++", "max_stars_repo_path": "alg/teca_2d_component_area.cxx", "max_stars_repo_name": "LBL-EESA/TECA", "max_stars_repo_head_hexsha": "63923b8a12914f3758dc9525239bc48cd8864b39", "max_stars_repo_licenses": ["BSD-3-Clause-LBNL"], "max_stars_count": 34.0, "max_stars_repo_stars_event_min_datetime": "2017-03-28T14:22:25.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-23T05:02:25.000Z", "max_issues_repo_path": "alg/teca_2d_component_area.cxx", "max_issues_repo_name": "LBL-EESA/TECA", "max_issues_repo_head_hexsha": "63923b8a12914f3758dc9525239bc48cd8864b39", "max_issues_repo_licenses": ["BSD-3-Clause-LBNL"], "max_issues_count": 476.0, "max_issues_repo_issues_event_min_datetime": "2016-11-28T18:06:06.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-25T05:31:42.000Z", "max_forks_repo_path": "alg/teca_2d_component_area.cxx", "max_forks_repo_name": "LBL-EESA/TECA", "max_forks_repo_head_hexsha": "63923b8a12914f3758dc9525239bc48cd8864b39", "max_forks_repo_licenses": ["BSD-3-Clause-LBNL"], "max_forks_count": 19.0, "max_forks_repo_forks_event_min_datetime": "2017-04-25T18:15:04.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-28T18:16:05.000Z", "avg_line_length": 33.0668380463, "max_line_length": 111, "alphanum_fraction": 0.6011039415, "num_tokens": 3064, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7606506526772883, "lm_q2_score": 0.7154240018510026, "lm_q1q2_score": 0.5441877339489627}} {"text": "// To use the simple FFT implementation\r\n// g++ -o demofft -I.. -Wall -O3 FFT.cpp \r\n\r\n// To use the FFTW implementation\r\n// g++ -o demofft -I.. -DUSE_FFTW -Wall -O3 FFT.cpp -lfftw3 -lfftw3f -lfftw3l\r\n\r\n#ifdef USE_FFTW\r\n#include \r\n#endif\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\nusing namespace std;\r\nusing namespace Eigen;\r\n\r\ntemplate \r\nT mag2(T a)\r\n{\r\n return a*a;\r\n}\r\ntemplate \r\nT mag2(std::complex a)\r\n{\r\n return norm(a);\r\n}\r\n\r\ntemplate \r\nT mag2(const std::vector & vec)\r\n{\r\n T out=0;\r\n for (size_t k=0;k\r\nT mag2(const std::vector > & vec)\r\n{\r\n T out=0;\r\n for (size_t k=0;k\r\nvector operator-(const vector & a,const vector & b )\r\n{\r\n vector c(a);\r\n for (size_t k=0;k\r\nvoid RandomFill(std::vector & vec)\r\n{\r\n for (size_t k=0;k\r\nvoid RandomFill(std::vector > & vec)\r\n{\r\n for (size_t k=0;k ( T( rand() )/T(RAND_MAX) - .5, T( rand() )/T(RAND_MAX) - .5);\r\n}\r\n\r\ntemplate \r\nvoid fwd_inv(size_t nfft)\r\n{\r\n typedef typename NumTraits::Real Scalar;\r\n vector timebuf(nfft);\r\n RandomFill(timebuf);\r\n\r\n vector freqbuf;\r\n static FFT fft;\r\n fft.fwd(freqbuf,timebuf);\r\n\r\n vector timebuf2;\r\n fft.inv(timebuf2,freqbuf);\r\n\r\n long double rmse = mag2(timebuf - timebuf2) / mag2(timebuf);\r\n cout << \"roundtrip rmse: \" << rmse << endl;\r\n}\r\n\r\ntemplate \r\nvoid two_demos(int nfft)\r\n{\r\n cout << \" scalar \";\r\n fwd_inv >(nfft);\r\n cout << \" complex \";\r\n fwd_inv,std::complex >(nfft);\r\n}\r\n\r\nvoid demo_all_types(int nfft)\r\n{\r\n cout << \"nfft=\" << nfft << endl;\r\n cout << \" float\" << endl;\r\n two_demos(nfft);\r\n cout << \" double\" << endl;\r\n two_demos(nfft);\r\n cout << \" long double\" << endl;\r\n two_demos(nfft);\r\n}\r\n\r\nint main()\r\n{\r\n demo_all_types( 2*3*4*5*7 );\r\n demo_all_types( 2*9*16*25 );\r\n demo_all_types( 1024 );\r\n return 0;\r\n}\r\n", "meta": {"hexsha": "3e50061d844ce312890194596eb280d96917057f", "size": 2636, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "thirdparty/eigen3.2.10/unsupported/doc/examples/FFT.cpp", "max_stars_repo_name": "rgijsen/opengl_tmp_poc", "max_stars_repo_head_hexsha": "93e3a08e30ed100475034281208200ed724db5d9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2020-02-24T17:39:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T11:02:38.000Z", "max_issues_repo_path": "thirdparty/eigen3.2.10/unsupported/doc/examples/FFT.cpp", "max_issues_repo_name": "rgijsen/opengl_tmp_poc", "max_issues_repo_head_hexsha": "93e3a08e30ed100475034281208200ed724db5d9", "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": "thirdparty/eigen3.2.10/unsupported/doc/examples/FFT.cpp", "max_forks_repo_name": "rgijsen/opengl_tmp_poc", "max_forks_repo_head_hexsha": "93e3a08e30ed100475034281208200ed724db5d9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2019-01-24T13:35:40.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-30T14:40:05.000Z", "avg_line_length": 22.1512605042, "max_line_length": 96, "alphanum_fraction": 0.5830804249, "num_tokens": 797, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7606506526772884, "lm_q2_score": 0.7154240018510026, "lm_q1q2_score": 0.5441877339489627}} {"text": "/**\n * @brief 視錐台クラス\n */\n\n#include \"View/Frustum.h\"\n\n#include \n#include \n#include \n#include \n#include \n\nvoid Frustum::SetupPerspective(float fovy, float aspectRatio, float near,\n float far) {\n fovy_ = fovy;\n ar_ = aspectRatio;\n near_ = near;\n far_ = far;\n\n type_ = ProjectionType::Perspective;\n}\n\nvoid Frustum::SetupOrtho(float left, float right, float bottom, float top,\n float near, float far) {\n left_ = left;\n right_ = right;\n bottom_ = bottom;\n top_ = top;\n near_ = near;\n far_ = far;\n\n type_ = ProjectionType::Ortho;\n}\n\nvoid Frustum::SetupCorners(const glm::vec3 &eyePt, const glm::vec3 &lookatPt,\n const glm::vec3 &upVec) {\n corners_[0] = glm::vec3(-1.0, 1.0, 1.0);\n corners_[1] = glm::vec3(1.0, 1.0, 1.0);\n corners_[2] = glm::vec3(1.0, -1.0, 1.0);\n corners_[3] = glm::vec3(-1.0, -1.0, 1.0);\n\n corners_[4] = glm::vec3(-1.0, 1.0, -1.0);\n corners_[5] = glm::vec3(1.0, 1.0, -1.0);\n corners_[6] = glm::vec3(1.0, -1.0, -1.0);\n corners_[7] = glm::vec3(-1.0, -1.0, -1.0);\n\n const auto kView = glm::lookAt(eyePt, lookatPt, upVec);\n const auto kProj = GetProjectionMatrix();\n const auto kInvVP = glm::inverse(kProj * kView);\n for (int i = 0; i < 8; i++) {\n const auto corner = kInvVP * glm::vec4(corners_[i], 1.0f);\n corners_[i] = glm::vec3(corner) / corner.w;\n }\n}\n\nBSphere Frustum::ComputeBSphere() const {\n glm::vec3 center = glm::vec3(0.0f);\n for (int i = 0; i < 8; i++) {\n center += corners_[i];\n }\n center /= 8.0f;\n\n float radius = 0.0f;\n for (int i = 0; i < 8; i++) {\n float len = glm::length(corners_[i] - center);\n radius = glm::max(radius, len);\n }\n radius = std::ceil(radius * 16.0f) / 16.0f;\n\n return {center, radius};\n}\n\nglm::mat4 Frustum::GetProjectionMatrix() const {\n if (type_ == ProjectionType::Perspective) {\n return glm::perspective(fovy_, ar_, near_, far_);\n } else {\n return glm::ortho(left_, right_, bottom_, top_, near_, far_);\n }\n}\n", "meta": {"hexsha": "2f89410f228523d1b2026468cb1b52dfb84de315", "size": 2082, "ext": "cc", "lang": "C++", "max_stars_repo_path": "Common/View/Frustum.cc", "max_stars_repo_name": "mnrn/ReGL", "max_stars_repo_head_hexsha": "922b36716ff29fa5ed8f18c078d2369ef9fba6a9", "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": "Common/View/Frustum.cc", "max_issues_repo_name": "mnrn/ReGL", "max_issues_repo_head_hexsha": "922b36716ff29fa5ed8f18c078d2369ef9fba6a9", "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": "Common/View/Frustum.cc", "max_forks_repo_name": "mnrn/ReGL", "max_forks_repo_head_hexsha": "922b36716ff29fa5ed8f18c078d2369ef9fba6a9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.025, "max_line_length": 77, "alphanum_fraction": 0.5965417867, "num_tokens": 747, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833841649233, "lm_q2_score": 0.7025300573952054, "lm_q1q2_score": 0.544168109334756}} {"text": "//---------------------------------------------------------------------------\n// $Id: theta_timestepping.cc 28377 2013-02-13 15:22:32Z heister $\n//\n// Copyright (C) 2005-2006, 2010, 2012 by the deal.II authors\n//\n// This file is subject to QPL and may not be distributed\n// without copyright and license information. Please refer\n// to the file deal.II/doc/license.html for the text and\n// further information on this license.\n//\n//---------------------------------------------------------------------------\n\n// See documentation of ThetaTimestepping for documentation of this example\n\n#include \n#include \n#include \n\n#include \n#include \n\n#include \n\nusing namespace dealii;\nusing namespace Algorithms;\n\n\nclass Explicit\n : public Operator >\n{\npublic:\n Explicit(const FullMatrix &matrix);\n void operator() (NamedData*> &out,\n const NamedData*> &in);\n\n void initialize_timestep_data(const TimestepData &);\nprivate:\n const TimestepData *timestep_data;\n SmartPointer, Explicit> matrix;\n FullMatrix m;\n};\n\n\nclass Implicit\n : public Operator >\n{\npublic:\n Implicit(const FullMatrix &matrix);\n void operator() (NamedData*> &out,\n const NamedData*> &in);\n\n void initialize_timestep_data(const TimestepData &);\nprivate:\n const TimestepData *timestep_data;\n SmartPointer, Implicit> matrix;\n FullMatrix m;\n};\n\n// End of declarations\n\nint main()\n{\n FullMatrix matrix(2);\n matrix(0,0) = 1.;\n matrix(1,1) = 1.;\n matrix(0,1) = 31.4;\n matrix(1,0) = -31.4;\n\n OutputOperator > out;\n out.initialize_stream(std::cout);\n\n Explicit op_explicit(matrix);\n Implicit op_implicit(matrix);\n ThetaTimestepping > solver(op_explicit, op_implicit);\n op_explicit.initialize_timestep_data(solver.explicit_data());\n op_implicit.initialize_timestep_data(solver.implicit_data());\n solver.set_output(out);\n\n Vector value(2);\n value(0) = 1.;\n NamedData*> indata;\n NamedData*> outdata;\n Vector *p = &value;\n outdata.add(p, \"value\");\n\n solver.notify(Events::initial);\n solver(outdata, indata);\n}\n\n\nExplicit::Explicit(const FullMatrix &M)\n :\n matrix(&M)\n{\n m.reinit(M.m(), M.n());\n}\n\n\nvoid\nExplicit::initialize_timestep_data(const TimestepData &t)\n{\n timestep_data = &t;\n}\n\n\nvoid\nExplicit::operator() (NamedData*> &out, const NamedData*> &in)\n{\n if (this->notifications.test(Events::initial) || this->notifications.test(Events::new_timestep_size))\n {\n m.equ(-timestep_data->step, *matrix);\n for (unsigned int i=0; inotifications.clear();\n unsigned int i = in.find(\"Previous iterate\");\n m.vmult(*out(0), *in(i));\n}\n\n\nImplicit::Implicit(const FullMatrix &M)\n :\n matrix(&M)\n{\n m.reinit(M.m(), M.n());\n}\n\n\nvoid\nImplicit::initialize_timestep_data(const TimestepData &t)\n{\n timestep_data = &t;\n}\n\n\nvoid\nImplicit::operator() (NamedData*> &out, const NamedData*> &in)\n{\n if (this->notifications.test(Events::initial) || this->notifications.test(Events::new_timestep_size))\n {\n m.equ(timestep_data->step, *matrix);\n for (unsigned int i=0; inotifications.clear();\n\n unsigned int i = in.find(\"Previous time\");\n m.vmult(*out(0), *in(i));\n}\n\n\n", "meta": {"hexsha": "cb859b5414043eb1e78489088fb94895eb07e3b2", "size": 3728, "ext": "cc", "lang": "C++", "max_stars_repo_path": "MHD/examples/doxygen/theta_timestepping.cc", "max_stars_repo_name": "wathen/PhD", "max_stars_repo_head_hexsha": "35524f40028541a4d611d8c78574e4cf9ddc3278", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2020-10-25T13:30:20.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-10T21:27:30.000Z", "max_issues_repo_path": "MHD/examples/doxygen/theta_timestepping.cc", "max_issues_repo_name": "wathen/PhD", "max_issues_repo_head_hexsha": "35524f40028541a4d611d8c78574e4cf9ddc3278", "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": "MHD/examples/doxygen/theta_timestepping.cc", "max_forks_repo_name": "wathen/PhD", "max_forks_repo_head_hexsha": "35524f40028541a4d611d8c78574e4cf9ddc3278", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2019-10-28T16:12:13.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-13T13:59:44.000Z", "avg_line_length": 24.3660130719, "max_line_length": 103, "alphanum_fraction": 0.6566523605, "num_tokens": 971, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833841649233, "lm_q2_score": 0.7025300573952052, "lm_q1q2_score": 0.5441681093347559}} {"text": "\n#pragma once\n\n// #include \n// #include \n// #include \n// #include \n#include \n\nnamespace perceive\n{\n//\n// Shortest path on a DAG, using sparse representations\n//\ntemplate\ninline vector shortest_path_sparse(\n const V source,\n const V sink,\n std::function edge_weight,\n std::function)>\n for_each_neighbour,\n const real k_max_cost = std::numeric_limits::max())\n{\n if(source == sink) return {};\n\n Expects(edge_weight);\n Expects(for_each_neighbour);\n\n using Key = std::pair;\n using Compare = std::less;\n\n // boost::container::pmr::monotonic_buffer_resource alloc(1024 * 10);\n std::set Q;\n\n std::unordered_map parent_v;\n std::unordered_map dist_;\n\n real max_cost = std::isfinite(k_max_cost) ? k_max_cost\n : std::numeric_limits::max();\n\n auto dist = [&](const V u) {\n auto ii = dist_.find(u);\n return (ii == cend(dist_)) ? max_cost : ii->second;\n };\n\n Q.insert({0.0, source});\n dist_[source] = 0.0;\n real path_score = dNAN;\n\n while(Q.size() > 0) {\n const V u = Q.begin()->second;\n Q.erase(Q.begin()); // Remove element\n if(u == sink) {\n Expects(parent_v.find(u) != cend(parent_v));\n break; // We're done\n }\n Expects(dist(u) < std::numeric_limits::max());\n const auto dist_u = dist(u);\n\n for_each_neighbour(u, [&](const V v) {\n const real w = edge_weight(u, v);\n Expects(std::isfinite(w));\n const auto dist_v = dist(v);\n if(dist_v > dist_u + w) {\n Q.erase({dist_v, v});\n const auto new_dist_v = dist_u + w;\n Q.insert({new_dist_v, v});\n parent_v[v] = u;\n dist_[v] = new_dist_v;\n }\n });\n }\n\n if(parent_v.find(sink) == cend(parent_v)) return {};\n\n // Reconstruct the path\n vector out;\n {\n out.reserve(Q.size() + 2);\n out.push_back(sink);\n while(out.back() != source) {\n const auto ii = parent_v.find(out.back());\n Expects(ii != cend(parent_v));\n out.push_back(ii->second);\n }\n std::reverse(begin(out), end(out));\n }\n\n return out;\n}\n\n} // namespace perceive\n", "meta": {"hexsha": "ce986a175b5b45e72c9ed2ea47f28aaef6038076", "size": 2501, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "multiview/multiview_cpp/src/perceive/optimization/shortest-path.hpp", "max_stars_repo_name": "prcvlabs/multiview", "max_stars_repo_head_hexsha": "1a03e14855292967ffb0c0ec7fff855c5abbc9d2", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2021-09-03T23:12:08.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T21:43:32.000Z", "max_issues_repo_path": "multiview/multiview_cpp/src/perceive/optimization/shortest-path.hpp", "max_issues_repo_name": "prcvlabs/multiview", "max_issues_repo_head_hexsha": "1a03e14855292967ffb0c0ec7fff855c5abbc9d2", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2021-09-08T02:57:46.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-26T05:33:02.000Z", "max_forks_repo_path": "multiview/multiview_cpp/src/perceive/optimization/shortest-path.hpp", "max_forks_repo_name": "prcvlabs/multiview", "max_forks_repo_head_hexsha": "1a03e14855292967ffb0c0ec7fff855c5abbc9d2", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-09-26T03:14:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-26T06:42:52.000Z", "avg_line_length": 26.8924731183, "max_line_length": 80, "alphanum_fraction": 0.581367453, "num_tokens": 662, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833945721304, "lm_q2_score": 0.7025300449389326, "lm_q1q2_score": 0.5441681069977097}} {"text": "// (C) Copyright John Maddock 2005.\r\n// Use, modification and distribution are subject to the\r\n// Boost Software License, Version 1.0. (See accompanying file\r\n// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\r\n\r\n#ifndef BOOST_MATH_LOG1P_INCLUDED\r\n#define BOOST_MATH_LOG1P_INCLUDED\r\n\r\n#include \r\n#include // platform's ::log1p\r\n#include \r\n#include \r\n\r\n#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS\r\n# include \r\n#else\r\n# include \r\n#endif\r\n\r\n#ifdef BOOST_NO_STDC_NAMESPACE\r\nnamespace std{ using ::fabs; using ::log; }\r\n#endif\r\n\r\n\r\nnamespace boost{ namespace math{\r\n\r\nnamespace detail{\r\n\r\n//\r\n// Functor log1p_series returns the next term in the Taylor series\r\n// pow(-1, k-1)*pow(x, k) / k\r\n// each time that operator() is invoked.\r\n//\r\ntemplate \r\nstruct log1p_series\r\n{\r\n typedef T result_type;\r\n\r\n log1p_series(T x)\r\n : k(0), m_mult(-x), m_prod(-1){}\r\n\r\n T operator()()\r\n {\r\n m_prod *= m_mult;\r\n return m_prod / ++k; \r\n }\r\n\r\n int count()const\r\n {\r\n return k;\r\n }\r\n\r\nprivate:\r\n int k;\r\n const T m_mult;\r\n T m_prod;\r\n log1p_series(const log1p_series&);\r\n log1p_series& operator=(const log1p_series&);\r\n};\r\n\r\n} // namespace\r\n\r\n//\r\n// Algorithm log1p is part of C99, but is not yet provided by many compilers.\r\n//\r\n// This version uses a Taylor series expansion for 0.5 > x > epsilon, which may\r\n// require up to std::numeric_limits::digits+1 terms to be calculated. It would\r\n// be much more efficient to use the equivalence:\r\n// log(1+x) == (log(1+x) * x) / ((1-x) - 1)\r\n// Unfortunately optimizing compilers make such a mess of this, that it performs\r\n// no better than log(1+x): which is to say not very well at all.\r\n//\r\ntemplate \r\nT log1p(T x)\r\n{\r\n#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS\r\n BOOST_STATIC_ASSERT(::std::numeric_limits::is_specialized);\r\n#else\r\n BOOST_ASSERT(std::numeric_limits::is_specialized);\r\n#endif\r\n T a = std::fabs(x);\r\n if(a > T(0.5L))\r\n return std::log(T(1.0) + x);\r\n if(a < std::numeric_limits::epsilon())\r\n return x;\r\n detail::log1p_series s(x);\r\n return detail::kahan_sum_series(s, std::numeric_limits::digits + 2);\r\n}\r\n#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))\r\n// these overloads work around a type deduction bug:\r\ninline float log1p(float z)\r\n{\r\n return log1p(z);\r\n}\r\ninline double log1p(double z)\r\n{\r\n return log1p(z);\r\n}\r\ninline long double log1p(long double z)\r\n{\r\n return log1p(z);\r\n}\r\n#endif\r\n\r\n#ifdef log1p\r\n# ifndef BOOST_HAS_LOG1P\r\n# define BOOST_HAS_LOG1P\r\n# endif\r\n# undef log1p\r\n#endif\r\n\r\n#ifdef BOOST_HAS_LOG1P\r\n# if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)\r\ninline float log1p(float x){ return ::log1pf(x); }\r\ninline long double log1p(long double x){ return ::log1pl(x); }\r\n#else\r\ninline float log1p(float x){ return ::log1p(x); }\r\n#endif\r\ninline double log1p(double x){ return ::log1p(x); }\r\n#endif\r\n\r\n} } // namespaces\r\n\r\n#endif // BOOST_MATH_HYPOT_INCLUDED\r\n", "meta": {"hexsha": "28e65528c4f1cc8b9c4549fac86dc0af759f960c", "size": 3144, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/boost/math/special_functions/log1p.hpp", "max_stars_repo_name": "dstrigl/mcotf", "max_stars_repo_head_hexsha": "92a9caf6173b1241a2f9ed45cd379469762b7178", "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": "include/boost/math/special_functions/log1p.hpp", "max_issues_repo_name": "dstrigl/mcotf", "max_issues_repo_head_hexsha": "92a9caf6173b1241a2f9ed45cd379469762b7178", "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": "include/boost/math/special_functions/log1p.hpp", "max_forks_repo_name": "dstrigl/mcotf", "max_forks_repo_head_hexsha": "92a9caf6173b1241a2f9ed45cd379469762b7178", "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": 25.152, "max_line_length": 84, "alphanum_fraction": 0.6701653944, "num_tokens": 867, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833841649232, "lm_q2_score": 0.702530051167069, "lm_q1q2_score": 0.544168104510545}} {"text": "/* ---------------------------------------------------------------------\n *\n * Copyright (C) 1999 - 2019 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 of the deal.II distribution.\n *\n * ---------------------------------------------------------------------\n *\n * based on deal.II step-1\n * \n */\n\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\nusing namespace dealii;\n\nclass MyTuple\n{\n std::tuple Tuple;\n\npublic:\n MyTuple(Triangulation<2> &T)\n : Tuple(std::make_tuple(T.n_levels(), T.n_cells(), T.n_active_cells())) {}\n\n void print()\n {\n std::cout << \"Number of level:\\t\" << std::get<0>(this->Tuple) << \"\\n\"\n << \"Number of cells:\\t\" << std::get<1>(this->Tuple) << \"\\n\"\n << \"Number of active cells:\\t\" << std::get<2>(this->Tuple) << std::endl;\n }\n};\n\nMyTuple helper(Triangulation<2> &T) {return MyTuple(T);}\n\nvoid\ncircle_grid()\n{\n const Point<2> center(0, 0);\n const double radius = 1.0;\n\n Triangulation<2> triangulation;\n GridGenerator::hyper_ball(triangulation, center, radius, false);\n triangulation.refine_global(2);\n\n std::ofstream out(\"circle_grid.svg\");\n GridOut grid_out;\n grid_out.write_svg(triangulation, out);\n std::cout << \"Grid written to circle_grid.svg\" << std::endl;\n\n Triangulation<2> triangulation2;\n GridGenerator::hyper_ball(triangulation2, center, radius, true);\n triangulation2.refine_global(2);\n\n std::ofstream out2(\"circle_grid2.svg\");\n GridOut grid_out2;\n grid_out2.write_svg(triangulation2, out2);\n std::cout << \"Grid written to circle_grid2.svg\" << std::endl;\n}\n\nvoid\nfirst_grid()\n{\n Triangulation<2> triangulation;\n\n GridGenerator::hyper_cube(triangulation);\n\n std::cout << \"Number of original vertices: \" << triangulation.n_vertices()\n << std::endl;\n\n triangulation.refine_global(4);\n\n std::cout << \"Numbe r of vertices after 4 refinmentss: \"\n << triangulation.n_vertices() << std::endl;\n\n std::ofstream out(\"grid-1.vtk\");\n GridOut grid_out;\n grid_out.write_svg(triangulation, out);\n std::cout << \"Grid written to grid-1.vtk\" << std::endl;\n \n MyTuple t = helper(triangulation);\n t.print();\n}\n\n\n\nvoid\nsecond_grid()\n{\n Triangulation<2> triangulation;\n\n const Point<2> center(1, 0);\n const double inner_radius = 0.5, outer_radius = 1.0;\n GridGenerator::hyper_shell(\n triangulation, center, inner_radius, outer_radius, 10);\n\n // triangulation.reset_manifold(0);\n /*\n questo comando fa si che la triangolazione passi dal descrivere \n il Manifold che aveva in precedenza (in questo caso una hyper shell)\n al descrivere un FlatManifold\n */\n\n\n for (unsigned int step = 0; step < 5; ++step)\n {\n for (auto &cell : triangulation.active_cell_iterators())\n {\n for (const auto v : cell->vertex_indices())\n {\n const double distance_from_center =\n center.distance(cell->vertex(v));\n\n if (std::fabs(distance_from_center - inner_radius) <=\n 1e-6 * inner_radius)\n {\n cell->set_refine_flag();\n break;\n }\n }\n }\n\n triangulation.execute_coarsening_and_refinement();\n }\n\n\n std::ofstream out(\"grid-2.svg\");\n GridOut grid_out;\n grid_out.write_svg(triangulation, out);\n\n std::cout << \"Grid written to grid-2.vtk\" << std::endl;\n \n MyTuple t = helper(triangulation);\n t.print();\n}\n\nvoid\nthird_grid()\n{\n Triangulation<2> triangulation;\n GridGenerator::hyper_L(triangulation, 0., 0.9);\n /*triangulation.refine_global(1);*/\n const Point<2> corner(0.45, 0.45);\n\n for (unsigned int step = 0; step < 6; ++step)\n {\n for (auto &cell : triangulation.active_cell_iterators())\n {\n Point<2> cell_center = cell->center();\n const double distance_from_corner = corner.distance(cell_center);\n\n if (distance_from_corner < 1. / 3)\n {\n cell->set_refine_flag();\n }\n }\n triangulation.execute_coarsening_and_refinement();\n }\n\n std::ofstream out(\"grid-3.vtk\");\n GridOut grid_out;\n grid_out.write_svg(triangulation, out);\n\n std::cout << \"Grid written to grid-3.vtk\" << std::endl;\n \n MyTuple t = helper(triangulation);\n t.print();\n}\n\n\nint\nmain()\n{\n first_grid();\n second_grid();\n third_grid();\n\n circle_grid();\n}", "meta": {"hexsha": "1a7cabd4ee88508774d997026ccd0f8120ee6a7e", "size": 4955, "ext": "cc", "lang": "C++", "max_stars_repo_path": "source/step-1.cc", "max_stars_repo_name": "dealii-courses/triangulation-dofhandler-and-finiteelement-YuriChiucconi", "max_stars_repo_head_hexsha": "4eef83eea2faaca46a2b40c2b4c0dc8eede68a42", "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": "source/step-1.cc", "max_issues_repo_name": "dealii-courses/triangulation-dofhandler-and-finiteelement-YuriChiucconi", "max_issues_repo_head_hexsha": "4eef83eea2faaca46a2b40c2b4c0dc8eede68a42", "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": "source/step-1.cc", "max_forks_repo_name": "dealii-courses/triangulation-dofhandler-and-finiteelement-YuriChiucconi", "max_forks_repo_head_hexsha": "4eef83eea2faaca46a2b40c2b4c0dc8eede68a42", "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.4102564103, "max_line_length": 86, "alphanum_fraction": 0.6195761857, "num_tokens": 1310, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7025300449389326, "lm_q2_score": 0.7745833737577158, "lm_q1q2_score": 0.5441680923749581}} {"text": "/*******************************************************************************\n *\n * Standard domain of numerical congruences extended with bitwise\n * operations.\n *\n * Author: Alexandre C. D. Wimmers (alexandre.c.wimmers@nasa.gov)\n *\n * Contributors: Jorge A. Navas (jorge.a.navaslaserna@nasa.gov)\n *\n * Notices:\n *\n * Copyright (c) 2011 United States Government as represented by the\n * Administrator of the National Aeronautics and Space Administration.\n * All Rights Reserved.\n *\n * Disclaimers:\n *\n * No Warranty: THE SUBJECT SOFTWARE IS PROVIDED \"AS IS\" WITHOUT ANY WARRANTY OF\n * ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED\n * TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO SPECIFICATIONS,\n * ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,\n * OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE\n * ERROR FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO\n * THE SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER, CONSTITUTE AN\n * ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT OF ANY RESULTS,\n * RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY OTHER APPLICATIONS\n * RESULTING FROM USE OF THE SUBJECT SOFTWARE. FURTHER, GOVERNMENT AGENCY\n * DISCLAIMS ALL WARRANTIES AND LIABILITIES REGARDING THIRD-PARTY SOFTWARE,\n * IF PRESENT IN THE ORIGINAL SOFTWARE, AND DISTRIBUTES IT \"AS IS.\"\n *\n * Waiver and Indemnity: RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS AGAINST\n * THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL\n * AS ANY PRIOR RECIPIENT. IF RECIPIENT'S USE OF THE SUBJECT SOFTWARE RESULTS\n * IN ANY LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARISING FROM SUCH\n * USE, INCLUDING ANY DAMAGES FROM PRODUCTS BASED ON, OR RESULTING FROM,\n * RECIPIENT'S USE OF THE SUBJECT SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD\n * HARMLESS THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS,\n * AS WELL AS ANY PRIOR RECIPIENT, TO THE EXTENT PERMITTED BY LAW.\n * RECIPIENT'S SOLE REMEDY FOR ANY SUCH MATTER SHALL BE THE IMMEDIATE,\n * UNILATERAL TERMINATION OF THIS AGREEMENT.\n *\n ******************************************************************************/\n\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nnamespace ikos {\n\ntemplate \nclass congruence {\n typedef interval interval_t;\n \npublic:\n typedef congruence congruence_t;\n\nprivate:\n bool _is_bottom;\n \n /// A congruence is denoted by aZ + b, where b \\in Z and a \\in N.\n /// The abstract state aZ + b represents all numbers that are\n /// congruent to b modulo a.\n Number _a; // modulo\n Number _b; // remainder\n\n // Notes about the % operator\n // \n // The semantics of r = n % d is to set r to \"n mod d\". The sign of\n // the d is ignored and r is always non-negative.\n // \n // We assume that n % d (also n /d) raises a runtime error if d==0.\n \n void normalize(void) {\n // Set to standard form: 0 <= b < a for a != 0\n if (_a != 0) {\n _b = _b % _a;\n }\n }\n \n // if true then top (1Z + 0) else bottom\n congruence(bool b): _is_bottom(!b), _a(1), _b(0) {}\n\n congruence(int n): _is_bottom(false), _a(0), _b(n) {}\n\n congruence(Number a, Number b)\n : _is_bottom(false),\n _a(a),\n _b(b) {\n normalize();\n }\n\n Number abs(Number x) const { return x < 0 ? -x : x; }\n\n Number max(Number x, Number y) const { return x.operator<=(y) ? y : x; }\n\n Number min(Number x, Number y) const { return x.operator<(y) ? x : y; }\n\n Number gcd(Number x, Number y, Number z) const { return gcd(x, gcd(y, z)); }\n // Not to be called explicitly outside of gcd\n Number gcd_helper(Number x, Number y) const {\n return (y == 0) ? x : gcd_helper(y, x % y);\n } \n Number gcd(Number x, Number y) const { return gcd_helper(abs(x), abs(y)); }\n\n Number lcm(Number x, Number y) const {\n Number tmp = gcd(x, y);\n return abs(x * y) / tmp;\n }\n\n bool is_zero() const {\n return !is_bottom() && _a == 0 && _b == 0;\n }\n\n bool all_ones() const {\n return !is_bottom() && _a == 0 && _b == -1;\n }\n\n interval_t to_interval() const {\n assert(singleton());\n return interval_t(*(singleton()));\n }\n \npublic:\n \n static congruence_t top() { return congruence(true); }\n\n static congruence_t bottom() { return congruence(false); }\n\n congruence(): _is_bottom(false), _a(1), _b(0) {}\n\n congruence(Number n): _is_bottom(false), _a(0), _b(n) {}\n\n congruence(const congruence_t& o)\n : _is_bottom(o._is_bottom), _a(o._a), _b(o._b) {}\n\n congruence_t operator=(congruence_t o) {\n _is_bottom = o._is_bottom;\n _a = o._a;\n _b = o._b;\n return *this;\n }\n\n bool is_bottom() const { return _is_bottom; }\n\n bool is_top() const { return _a == 1; }\n\n boost::optional singleton() const {\n if (!this->is_bottom() && _a == 0) {\n return boost::optional(_b);\n } else {\n return boost::optional();\n }\n }\n\n Number get_modulo() const { return _a;}\n\n Number get_remainder() const { return _b;}\n \n bool operator==(congruence_t o) const {\n return (is_bottom() == o.is_bottom() && _a == o._a && _b == o._b) ;\n }\n\n bool operator!=(congruence_t x) const { return !this->operator==(x); }\n\n /** Lattice Operations **/\n \n bool operator<=(congruence_t o) {\n if (is_bottom()) {\n return true;\n } else if (o.is_bottom()) {\n return false;\n } else if (_a == 0 && o._a == 0) {\n return (_b == o._b);\n } else if (_a == 0) {\n if ((_b % o._a) == (o._b % o._a)) {\n return true;\n }\n } else if (o._a == 0) {\n if (_b % _a == (o._b % _a)) {\n return false;\n }\n }\n return (_a % o._a == 0) && (_b % o._a == o._b % o._a);\n }\n\n congruence_t operator|(congruence_t o) {\n if (is_bottom()) {\n return o;\n } else if (o.is_bottom()) {\n return *this;\n } else if (is_top() || o.is_top()) {\n return top();\n } else {\n return congruence_t(gcd(_a, o._a, abs(_b - o._b)), min(_b, o._b));\n }\n }\n\n congruence_t operator&(congruence_t o) {\n if (is_bottom() || o.is_bottom()) {\n return bottom();\n }\n\n // lcm has meaning only if both a and o.a are not 0\n if (_a == 0 && o._a == 0) {\n if (_b == o._b) {\n return *this;\n } else {\n return bottom();\n }\n } else if (_a == 0) {\n // b & a'Z + b' iff \\exists k such that a'*k + b' = b iff ((b - b') %a' == 0)\n if ((_b - o._b) % o._a == 0) {\n return *this;\n } else {\n return bottom();\n }\n } else if (o._a == 0) {\n // aZ+b & b' iff \\exists k such that a*k+b = b' iff ((b'-b %a) == 0)\n if ((o._b - _b) % _a == 0) {\n return o;\n } else {\n return bottom();\n }\n } else {\n // pre: a and o.a != 0\n Number x = gcd(_a, o._a);\n if (_b % x == (o._b % x)) {\n // the part max(b,o.b) needs to be verified. What we really\n // want is to find b'' such that\n // 1) b'' % lcm(a,a') == b % lcm(a,a'), and\n // 2) b'' % lcm(a,a') == b' % lcm(a,a').\n // An algorithm for that is provided in Granger'89.\n return congruence_t(lcm(_a, o._a), max(_b, o._b));\n } else {\n return congruence_t::bottom();\n }\n }\n\n }\n\n congruence_t operator||(congruence_t o) {\n // Equivalent to join, domain is flat\n return *this | o;\n }\n\n congruence_t operator&&(congruence_t o) {\n // Simply refines top element\n return (is_top()) ? o : *this;\n }\n\n /** Arithmetic Operators **/\n\n congruence_t operator+(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else\n return congruence_t(gcd(_a, o._a), _b + o._b);\n }\n\n congruence_t operator-(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else\n return congruence_t(gcd(_a, o._a), _b - o._b);\n }\n\n congruence_t operator-() {\n if (this->is_bottom() || this->is_top())\n return *this;\n else\n return congruence_t(_a, -_b + _a);\n }\n\n congruence_t operator*(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if ((this->is_top() || o.is_top()) && _a != 0 && o._a != 0)\n return congruence_t::top();\n else\n return congruence_t(gcd(_a * o._a, _a * o._b, o._a * _b), _b * o._b);\n }\n\n // signed division\n congruence_t operator/(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (o == congruence(0))\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n\n /*\n aZ+b / 0Z+b':\n if b'|a then (a/b')Z + b/b'\n else top\n */ \n if (o._a == 0) {\n if (_a % o._b == 0)\n return congruence_t(_a / o._b, _b / o._b);\n else\n return congruence_t::top();\n }\n\n /*\n 0Z+b / a'Z+b':\n if N>0 (b div N)Z + 0\n else 0Z + 0\n\n where N = a'((b-b') div a') + b'\n */\n if (_a == 0) {\n Number n(o._a * (((_b - o._b) / o._a) + o._b));\n if (n > 0) {\n return congruence_t(_b / n, 0);\n } else {\n return congruence_t(0, 0);\n }\n }\n\n /*\n General case: no singleton\n */\n return congruence_t::top();\n }\n }\n\n // signed remainder operator\n congruence_t operator%(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (o == congruence(0))\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n /*\n aZ+b mod 0Z+b':\n if b'|a then (a/b')Z + b/b'\n else top\n */\n if (o._a == 0) {\n if (_a % o._b == 0) {\n return congruence_t(0, _b % o._b);\n } else {\n return congruence_t(gcd(_a, o._b), _b);\n }\n }\n\n /*\n 0Z+b mod a'Z+b':\n if N<=0 then 0Z+b\n if (b div N) == 1 then gcd(b',a')Z + b\n if (b div N) >= 2 then N(b div N)Z + b\n\n where N = a'((b-b') div a') + b'\n */\n if (_a == 0) {\n Number n(o._a * (((_b - o._b) / o._a) + o._b));\n if (n <= 0) {\n return congruence_t(_a, _b);\n } else if (_b == n) {\n return congruence_t(gcd(o._b, o._a), _b);\n } else if ((_b / n) >= 2) {\n return congruence_t(_b, _b);\n } else {\n CRAB_ERROR(\"unreachable\");\n }\n }\n \n /*\n general case: no singleton\n */\n return congruence_t(gcd(_a, o._a, o._b), _b);\n }\n }\n\n /** \n Bitwise operators.\n They are very imprecise because we ignore bitwidth. \n \n Bitwise operation can be implemented more precisely based on\n Stefan Bygde's paper: Static WCET analysis based on abstract\n interpretation and counting of elements, Vasteras : School of\n Innovation, Design and Engineering, Malardalen University (2010).\n **/\n \n congruence_t And(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n if (is_zero() || o.is_zero()) {\n\treturn congruence_t(0);\n } else if (all_ones()) {\n\treturn o;\n } else if (o.all_ones()) {\n\treturn *this;\n } else if (_a == 0 && o._a == 0) {\n\treturn congruence_t(_b & o._b);\n } else {\n\treturn top();\n } \n }\n }\n\n congruence_t Or(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n if (all_ones() || o.all_ones()) {\n\treturn congruence_t(-1);\n } else if (is_zero()) {\n\treturn o;\n } else if (o.is_zero()) {\n\treturn *this;\n } else if (_a == 0 && o._a == 0) {\n\treturn congruence_t(_b | o._b);\n } else {\n\treturn top();\n } \n } \n }\n\n congruence_t Xor(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n if (is_zero()) {\n\treturn o;\n } else if (o.is_zero()) {\n\treturn *this;\n } else if (_a == 0 && o._a == 0) {\n\treturn congruence_t(_b ^ o._b);\n } else {\n\treturn top();\n } \n } \n }\n\n congruence_t Shl(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n \n if (o._a == 0) { // singleton\n\n\tif (o._b < 0) {\n\t return bottom();\n\t}\n\t\n // aZ + b << 0Z + b' = (a*2^b')Z + b*2^b'\n Number x = Number(1) << o._b;\n return congruence_t(_a * x, _b * x);\n } else {\n\t\n Number x = Number(1) << o._b;\n Number y = Number(1) << o._a;\n // aZ + b << a'Z + b' = (gcd(a, b * (2^a' - 1)))*(2^b')Z + b*(2^b')\n return congruence_t(gcd(_a, _b * (y - 1)) * x, _b * x);\n }\n }\n }\n\n congruence_t AShr(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n\n if (o._a == 0) { // singleton\n\t// aZ + b >> 0Z + b'\n\tif (o._b < 0) {\n\t return congruence_t::bottom();\n\t}\n }\n\n if (singleton() && o.singleton()) {\n\tinterval_t res = to_interval().AShr(o.to_interval());\n\tif (boost::optional n = res.singleton()) {\n\t return congruence(*n);\n\t}\n }\n \n return congruence_t::top();\n }\n }\n\n congruence_t LShr(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n\n if (o._a == 0) { \n\t// aZ + b >> 0Z + b'\n\tif (o._b < 0) {\n\t return congruence_t::bottom();\n\t}\n }\n\n if (singleton() && o.singleton()) {\n\tinterval_t res = to_interval().LShr(o.to_interval());\n\tif (boost::optional n = res.singleton()) {\n\t return congruence(*n);\n\t}\n }\n\n return congruence_t::top();\n }\n }\n\n // division and remainder operations\n\n congruence_t SDiv(congruence_t x) { return this->operator/(x); }\n\n congruence_t UDiv(congruence_t x) { return congruence_t::top(); }\n\n congruence_t SRem(congruence_t x) { return this->operator%(x); }\n\n congruence_t URem(congruence_t x) { return congruence_t::top(); }\n\n\n void write(crab::crab_os& o) const {\n if (is_bottom()) {\n o << \"_|_\";\n return;\n }\n\n if (_a == 0) {\n o << _b;\n return;\n }\n \n o << _a << \"Z+\" << _b;\n \n }\n}; // end class congruence\n\ntemplate\ninline crab::crab_os& operator<<(crab::crab_os& o, const congruence& c) {\n c.write(o);\n return o;\n}\n\ntemplate \ninline congruence operator+(\n Number c, congruence x) {\n return congruence(c) + x;\n}\n\ntemplate \ninline congruence operator+(\n congruence x, Number c) {\n return x + congruence(c);\n}\n\ntemplate \ninline congruence operator*(\n Number c, congruence x) {\n return congruence(c) * x;\n}\n\ntemplate \ninline congruence operator*(\n congruence x, Number c) {\n return x * congruence(c);\n}\n\ntemplate \ninline congruence operator/(\n Number c, congruence x) {\n return congruence(c) / x;\n}\n\ntemplate \ninline congruence operator/(\n congruence x, Number c) {\n return x / congruence(c);\n}\n\ntemplate \ninline congruence operator-(\n Number c, congruence x) {\n return congruence(c) - x;\n}\n\ntemplate \ninline congruence operator-(\n congruence x, Number c) {\n return x - congruence(c);\n}\n\ntemplate \nclass equality_congruence_solver {\n // TODO: check correctness of the solver. Granger provides a sound\n // and more precise solver for equality linear congruences (see\n // Theorem 4.4).\nprivate:\n typedef congruence congruence_t;\n typedef variable variable_t;\n typedef linear_expression linear_expression_t;\n typedef linear_constraint linear_constraint_t;\n typedef linear_constraint_system\n linear_constraint_system_t;\n\n typedef std::vector cst_table_t;\n typedef typename linear_constraint_t::variable_set_t variable_set_t;\n\n std::size_t m_max_cycles;\n bool m_is_contradiction;\n cst_table_t m_cst_table;\n variable_set_t m_refined_variables;\n std::size_t m_op_count;\n\nprivate:\n bool refine(variable_t v, congruence_t i, \n CongruenceCollection& env) {\n congruence_t old_i = env[v];\n congruence_t new_i = old_i & i;\n if (new_i.is_bottom()) {\n return true;\n }\n if (old_i != new_i) {\n env.set(v, new_i);\n m_refined_variables += v;\n ++(m_op_count);\n }\n return false;\n }\n\n congruence_t compute_residual(linear_constraint_t cst,\n variable_t pivot,\n CongruenceCollection& env) {\n congruence_t residual(cst.constant());\n for (typename linear_constraint_t::iterator it = cst.begin();\n it != cst.end();\n ++it) {\n variable_t v = it->second;\n if (!(v == pivot)) {\n residual = residual - (it->first * env[v]);\n ++(m_op_count);\n }\n }\n return residual;\n }\n\n bool propagate(linear_constraint_t cst, CongruenceCollection& env) {\n for (typename linear_constraint_t::iterator it = cst.begin();\n it != cst.end();\n ++it) {\n Number c = it->first;\n variable_t pivot = it->second;\n congruence_t rhs =\n compute_residual(cst, pivot, env) / congruence_t(c);\n\n if (cst.is_equality()) {\n if (refine(pivot, rhs, env)) {\n\t return true;\n\t}\n } else if (cst.is_inequality() || cst.is_strict_inequality()) {\n // Inequations (>=, <=, >, and <) do not work well with\n // congruences because for any number n there is always x and y\n // \\in gamma(aZ+b) such that n < x and n > y.\n //\n // The only cases we can catch is when all the expressions\n // are constants. We do not bother because any product\n // with intervals or constants should get those cases.\n continue;\n } else {\n // TODO: cst is a disequation \n }\n }\n return false;\n }\n\n bool solve_system(CongruenceCollection& env) {\n std::size_t cycle = 0;\n do {\n ++cycle;\n m_refined_variables.clear();\n for (typename cst_table_t::iterator it = m_cst_table.begin();\n it != m_cst_table.end();\n ++it) {\n if (propagate(*it, env)) {\n\t return true;\n\t}\n }\n } while (m_refined_variables.size() > 0 && \n cycle <= m_max_cycles);\n return false;\n }\n\npublic:\n equality_congruence_solver(linear_constraint_system_t csts,\n std::size_t max_cycles)\n : m_max_cycles(max_cycles), m_is_contradiction(false) {\n for (typename linear_constraint_system_t::iterator it = csts.begin();\n it != csts.end();\n ++it) {\n linear_constraint_t cst = *it;\n if (cst.is_contradiction()) {\n m_is_contradiction = true;\n return;\n } else if (cst.is_tautology()) {\n continue;\n } else {\n m_cst_table.push_back(cst);\n }\n }\n }\n\n void run(CongruenceCollection& env) {\n if (m_is_contradiction) {\n env.set_to_bottom();\n } else {\n if (solve_system(env)) {\n\tenv.set_to_bottom();\n }\n }\n }\n\n}; // class equality_congruence_solver\n\ntemplate \nclass congruence_domain final:\n public crab::domains::abstract_domain> {\npublic:\n typedef congruence congruence_t;\n\nprivate:\n // note that this is assuming that all variables have the same bit\n // width which is unrealistic.\n typedef congruence_domain\n congruence_domain_t;\n typedef crab::domains::abstract_domain\n abstract_domain_t;\n\npublic:\n using typename abstract_domain_t::linear_expression_t;\n using typename abstract_domain_t::linear_constraint_t;\n using typename abstract_domain_t::linear_constraint_system_t;\n using typename abstract_domain_t::disjunctive_linear_constraint_system_t; \n using typename abstract_domain_t::variable_t;\n using typename abstract_domain_t::variable_vector_t;\n typedef Number number_t;\n typedef VariableName varname_t;\n using typename abstract_domain_t::pointer_constraint_t;\n\nprivate:\n typedef separate_domain separate_domain_t;\n typedef equality_congruence_solver solver_t;\n\npublic:\n typedef typename separate_domain_t::iterator iterator;\n\nprivate:\n separate_domain_t _env;\n\nprivate:\n congruence_domain(separate_domain_t env) : _env(env) {}\n\npublic:\n void set_to_top() {\n congruence_domain abs(separate_domain_t::top());\n std::swap(*this, abs);\n }\n\n void set_to_bottom() {\n congruence_domain abs(separate_domain_t::bottom());\n std::swap(*this, abs);\n }\n\n congruence_domain() : _env(separate_domain_t::top()) {}\n\n congruence_domain(const congruence_domain_t& e)\n : _env(e._env) {\n crab::CrabStats::count(getDomainName() + \".count.copy\");\n crab::ScopedCrabStats __st__(getDomainName() + \".copy\");\n }\n\n congruence_domain_t& operator=(const congruence_domain_t& o) {\n crab::CrabStats::count(getDomainName() + \".count.copy\");\n crab::ScopedCrabStats __st__(getDomainName() + \".copy\");\n if (this != &o)\n this->_env = o._env;\n return *this;\n }\n\n iterator begin() { return this->_env.begin(); }\n\n iterator end() { return this->_env.end(); }\n\n bool is_bottom() { return this->_env.is_bottom(); }\n\n bool is_top() { return this->_env.is_top(); }\n\n bool operator<=(congruence_domain_t e) { \n crab::CrabStats::count(getDomainName() + \".count.leq\");\n crab::ScopedCrabStats __st__(getDomainName() + \".leq\");\n return this->_env <= e._env; \n }\n\n void operator|=(congruence_domain_t e) {\n crab::CrabStats::count(getDomainName() + \".count.join\");\n crab::ScopedCrabStats __st__(getDomainName() + \".join\");\n this->_env = this->_env | e._env;\n }\n\n congruence_domain_t operator|(congruence_domain_t e) {\n crab::CrabStats::count(getDomainName() + \".count.join\");\n crab::ScopedCrabStats __st__(getDomainName() + \".join\");\n return this->_env | e._env;\n }\n\n congruence_domain_t operator&(congruence_domain_t e) {\n crab::CrabStats::count(getDomainName() + \".count.meet\");\n crab::ScopedCrabStats __st__(getDomainName() + \".meet\");\n return this->_env & e._env;\n }\n\n congruence_domain_t operator||(congruence_domain_t e) {\n crab::CrabStats::count(getDomainName() + \".count.widening\");\n crab::ScopedCrabStats __st__(getDomainName() + \".widening\");\n return this->_env || e._env;\n }\n\n congruence_domain_t widening_thresholds(congruence_domain_t other, \n\t\t\t\t\t const crab::iterators::thresholds&) {\n return (*this || other);\n }\n\n congruence_domain_t operator&&(congruence_domain_t e) {\n crab::CrabStats::count(getDomainName() + \".count.narrowing\");\n crab::ScopedCrabStats __st__(getDomainName() + \".narrowing\");\n return this->_env && e._env;\n }\n\n void set(variable_t v, congruence_t i) { \n crab::CrabStats::count(getDomainName() + \".count.assign\");\n crab::ScopedCrabStats __st__(getDomainName() + \".assign\");\n this->_env.set(v, i); \n }\n\n void set(variable_t v, number_t n) {\n crab::CrabStats::count(getDomainName() + \".count.assign\");\n crab::ScopedCrabStats __st__(getDomainName() + \".assign\");\n this->_env.set(v, congruence_t(n)); \n }\n\n void operator-=(variable_t v) { \n crab::CrabStats::count(getDomainName() + \".count.forget\");\n crab::ScopedCrabStats __st__(getDomainName() + \".forget\");\n this->_env -= v; \n }\n\n void operator-=(std::vector vs) {\n for (typename std::vector::iterator it = vs.begin(),\n\t end = vs.end(); it != end; ++it) {\n this->operator-=* it;\n }\n }\n\n congruence_t operator[](variable_t v) { return this->_env[v]; }\n\n congruence_t operator[](linear_expression_t expr) {\n congruence_t r(expr.constant());\n for (typename linear_expression_t::iterator it = expr.begin();\n it != expr.end();\n ++it) {\n congruence_t c(it->first);\n r = r + (c * this->_env[it->second]);\n }\n return r;\n }\n\n void add(linear_constraint_system_t csts) {\n crab::CrabStats::count(getDomainName() + \".count.add_constraints\");\n crab::ScopedCrabStats __st__(getDomainName() + \".add_constraints\");\n const std::size_t threshold = 10;\n if (!this->is_bottom()) {\n solver_t solver(csts, threshold);\n solver.run(this->_env);\n }\n }\n\n void operator+=(linear_constraint_system_t csts) { \n this->add(csts); \n }\n\n congruence_domain_t operator+(linear_constraint_system_t csts) {\n congruence_domain_t e(this->_env);\n e += csts;\n return e;\n }\n\n void assign(variable_t x, linear_expression_t e) {\n crab::CrabStats::count(getDomainName() + \".count.assign\");\n crab::ScopedCrabStats __st__(getDomainName() + \".assign\");\n\n congruence_t r = e.constant();\n for (typename linear_expression_t::iterator it = e.begin(); it != e.end();\n ++it) {\n r = r + (it->first * this->_env[it->second]);\n }\n this->_env.set(x, r);\n }\n\n void apply(operation_t op, variable_t x, variable_t y, variable_t z) {\n crab::CrabStats::count(getDomainName() + \".count.apply\");\n crab::ScopedCrabStats __st__(getDomainName() + \".apply\");\n\n congruence_t yi = this->_env[y];\n congruence_t zi = this->_env[z];\n congruence_t xi = congruence_t::bottom();\n\n switch (op) {\n case OP_ADDITION:\n xi = yi + zi;\n break;\n case OP_SUBTRACTION:\n xi = yi - zi;\n break;\n case OP_MULTIPLICATION: \n xi = yi * zi;\n break;\n case OP_SDIV: \n xi = yi / zi;\n break;\n case OP_UDIV: \n xi = yi.UDiv(zi);\n break;\n case OP_SREM: \n xi = yi.SRem(zi);\n break;\n case OP_UREM: \n xi = yi.URem(zi);\n break;\n default:\n CRAB_ERROR(\"Operation \", op, \" not supported\");\n }\n this->_env.set(x, xi);\n }\n\n void apply(operation_t op, variable_t x, variable_t y, number_t k) {\n crab::CrabStats::count(getDomainName() + \".count.apply\");\n crab::ScopedCrabStats __st__(getDomainName() + \".apply\");\n\n congruence_t yi = this->_env[y];\n congruence_t zi(k);\n congruence_t xi = congruence_t::bottom();\n\n switch (op) {\n case OP_ADDITION: \n xi = yi + zi;\n break;\n case OP_SUBTRACTION: \n xi = yi - zi;\n break;\n case OP_MULTIPLICATION:\n xi = yi * zi;\n break;\n case OP_SDIV:\n xi = yi / zi;\n break;\n case OP_UDIV:\n xi = yi.UDiv(zi);\n break;\n case OP_SREM:\n xi = yi.SRem(zi);\n break;\n case OP_UREM:\n xi = yi.URem(zi);\n break;\n default:\n\tCRAB_ERROR(\"Operation \", op, \" not supported\");\n }\n this->_env.set(x, xi);\n }\n\n // backward operations\n void backward_assign(variable_t x, linear_expression_t e,\n\t\t congruence_domain_t inv) {\n crab::CrabStats::count(getDomainName() + \".count.backward_assign\");\n crab::ScopedCrabStats __st__(getDomainName() + \".backward_assign\");\n \n crab::domains::BackwardAssignOps::\n assign(*this, x, e, inv);\n }\n \n void backward_apply(operation_t op,\n\t\t variable_t x, variable_t y, number_t z,\n\t\t congruence_domain_t inv) {\n crab::CrabStats::count(getDomainName() + \".count.backward_apply\");\n crab::ScopedCrabStats __st__(getDomainName() + \".backward_apply\");\n \n crab::domains::BackwardAssignOps::\n apply(*this, op, x, y, z, inv);\n }\n \n void backward_apply(operation_t op,\n\t\t variable_t x, variable_t y, variable_t z,\n\t\t congruence_domain_t inv) {\n crab::CrabStats::count(getDomainName() + \".count.backward_apply\");\n crab::ScopedCrabStats __st__(getDomainName() + \".backward_apply\");\n \n crab::domains::BackwardAssignOps::\n apply(*this, op, x, y, z, inv);\n }\n\n // cast operations\n \n void apply(crab::domains::int_conv_operation_t /*op*/,\n\t variable_t dst, variable_t src) { \n // ignore widths\n assign(dst, src);\n }\n\n // bitwise operations\n \n void apply(bitwise_operation_t op, variable_t x, variable_t y, variable_t z) {\n crab::CrabStats::count(getDomainName() + \".count.apply\");\n crab::ScopedCrabStats __st__(getDomainName() + \".apply\");\n\n congruence_t yi = this->_env[y];\n congruence_t zi = this->_env[z];\n congruence_t xi = congruence_t::bottom();\n\n switch (op) {\n case OP_AND: {\n xi = yi.And(zi);\n break;\n }\n case OP_OR: {\n xi = yi.Or(zi);\n break;\n }\n case OP_XOR: {\n xi = yi.Xor(zi);\n break;\n }\n case OP_SHL: {\n xi = yi.Shl(zi);\n break;\n }\n case OP_LSHR: {\n xi = yi.LShr(zi);\n break;\n }\n case OP_ASHR: {\n xi = yi.AShr(zi);\n break;\n }\n default: { CRAB_ERROR(\"unreachable\"); }\n }\n this->_env.set(x, xi);\n }\n\n void apply(bitwise_operation_t op, variable_t x, variable_t y, number_t k) {\n crab::CrabStats::count(getDomainName() + \".count.apply\");\n crab::ScopedCrabStats __st__(getDomainName() + \".apply\");\n\n congruence_t yi = this->_env[y];\n congruence_t zi(k);\n congruence_t xi = congruence_t::bottom();\n\n switch (op) {\n case OP_AND: {\n xi = yi.And(zi);\n break;\n }\n case OP_OR: {\n xi = yi.Or(zi);\n break;\n }\n case OP_XOR: {\n xi = yi.Xor(zi);\n break;\n }\n case OP_SHL: {\n xi = yi.Shl(zi);\n break;\n }\n case OP_LSHR: {\n xi = yi.LShr(zi);\n break;\n }\n case OP_ASHR: {\n xi = yi.AShr(zi);\n break;\n }\n default: { CRAB_ERROR(\"unreachable\"); }\n }\n this->_env.set(x, xi);\n }\n \n /* \n Begin unimplemented operations \n \n congruence_domain implements only standard abstract operations of\n a numerical domain. The implementation of boolean, array, or\n pointer operations is empty because they should never be called.\n */\n \n // boolean operations\n void assign_bool_cst(variable_t lhs, linear_constraint_t rhs) {}\n void assign_bool_var(variable_t lhs, variable_t rhs, bool is_not_rhs) {}\n void apply_binary_bool(crab::domains::bool_operation_t op,\n\t\t\t variable_t x,variable_t y,variable_t z) {}\n void assume_bool(variable_t v, bool is_negated) {}\n // backward boolean operations\n void backward_assign_bool_cst(variable_t lhs, linear_constraint_t rhs,\n\t\t\t\tcongruence_domain_t invariant){}\n void backward_assign_bool_var(variable_t lhs, variable_t rhs, bool is_not_rhs,\n\t\t\t\tcongruence_domain_t invariant) {}\n void backward_apply_binary_bool(crab::domains::bool_operation_t op,\n\t\t\t\t variable_t x,variable_t y,variable_t z,\n\t\t\t\t congruence_domain_t invariant) {}\n // array operations\n void array_init(variable_t a, linear_expression_t elem_size,\n\t\t linear_expression_t lb_idx, linear_expression_t ub_idx, \n\t\t linear_expression_t val) {} \n void array_load(variable_t lhs,\n\t\t variable_t a, linear_expression_t elem_size,\n\t\t linear_expression_t i) {}\n void array_store(variable_t a, linear_expression_t elem_size,\n\t\t linear_expression_t i, linear_expression_t v, \n\t\t bool is_strong_update) {}\n void array_store(variable_t a_new, variable_t a_old,\n\t\t linear_expression_t elem_size,\n\t\t linear_expression_t i, linear_expression_t v, \n\t\t bool is_strong_update) {}\n void array_store_range(variable_t a, linear_expression_t elem_size,\n\t\t\t linear_expression_t i, linear_expression_t j,\n\t\t\t linear_expression_t v) {}\n void array_store_range(variable_t a_new, variable_t a_old,\n\t\t\t linear_expression_t elem_size,\n\t\t\t linear_expression_t i, linear_expression_t j,\n\t\t\t linear_expression_t v) {} \n void array_assign(variable_t lhs, variable_t rhs) {}\n // backward array operations\n void backward_array_init(variable_t a, linear_expression_t elem_size,\n\t\t\t linear_expression_t lb_idx, linear_expression_t ub_idx, \n\t\t\t linear_expression_t val, congruence_domain_t invariant) {} \n void backward_array_load(variable_t lhs,\n\t\t\t variable_t a, linear_expression_t elem_size,\n\t\t\t linear_expression_t i, congruence_domain_t invariant) {}\n void backward_array_store(variable_t a, linear_expression_t elem_size,\n\t\t\t linear_expression_t i, linear_expression_t v, \n\t\t\t bool is_strong_update, congruence_domain_t invariant) {}\n void backward_array_store(variable_t a_new, variable_t a_old,\n\t\t\t linear_expression_t elem_size,\n\t\t\t linear_expression_t i, linear_expression_t v, \n\t\t\t bool is_strong_update, congruence_domain_t invariant) {} \n void backward_array_store_range(variable_t a, linear_expression_t elem_size,\n\t\t\t\t linear_expression_t i, linear_expression_t j,\n\t\t\t\t linear_expression_t v, congruence_domain_t invariant) {}\n void backward_array_store_range(variable_t a_new, variable_t a_old,\n\t\t\t\t linear_expression_t elem_size,\n\t\t\t\t linear_expression_t i, linear_expression_t j,\n\t\t\t\t linear_expression_t v, congruence_domain_t invariant) {} \n void backward_array_assign(variable_t lhs, variable_t rhs, congruence_domain_t invariant) {}\n // pointer operations\n void pointer_load(variable_t lhs, variable_t rhs) {}\n void pointer_store(variable_t lhs, variable_t rhs) {} \n void pointer_assign(variable_t lhs, variable_t rhs, linear_expression_t offset) {}\n void pointer_mk_obj(variable_t lhs, ikos::index_t address) {}\n void pointer_function(variable_t lhs, varname_t func) {}\n void pointer_mk_null(variable_t lhs) {}\n void pointer_assume(pointer_constraint_t cst) {}\n void pointer_assert(pointer_constraint_t cst) {}\n /* End unimplemented operations */\n \n void forget(const variable_vector_t& variables) {\n if (is_bottom() || is_top()) {\n return;\n }\n for (variable_t var: variables){\n this->operator-=(var); \n }\n }\n\n void project(const variable_vector_t& variables){\n crab::CrabStats::count(getDomainName() + \".count.project\");\n crab::ScopedCrabStats __st__(getDomainName() + \".project\");\n \n if (is_bottom() || is_top()) {\n return;\n }\n \n separate_domain_t env;\n for (variable_t var : variables){\n env.set(var, this->_env[var]); \n }\n std::swap(_env, env);\n }\n \n void expand(variable_t x, variable_t new_x) {\n crab::CrabStats::count(getDomainName() + \".count.expand\");\n crab::ScopedCrabStats __st__(getDomainName() + \".expand\");\n \n if (is_bottom() || is_top()) {\n return;\n }\n \n set(new_x , this->_env[x]);\n }\n\n void normalize() {}\n\n void minimize() {} \n \n void write(crab::crab_os& o) {\n crab::CrabStats::count(getDomainName() + \".count.write\");\n crab::ScopedCrabStats __st__(getDomainName() + \".write\");\n \n this->_env.write(o); \n }\n\n linear_constraint_system_t to_linear_constraint_system() {\n crab::CrabStats::count(getDomainName() + \".count.to_linear_constraint_system\");\n crab::ScopedCrabStats __st__(getDomainName() + \".to_linear_constraint_system\");\n \n linear_constraint_system_t csts;\n if (is_bottom()) {\n csts += linear_constraint_t::get_false();\n return csts;\n }\n\n for (iterator it = this->_env.begin(); it != this->_env.end(); ++it) {\n variable_t v = it->first;\n congruence_t c = it->second;\n boost::optional n = c.singleton();\n if (n) {\n csts += (v == *n);\n }\n }\n return csts;\n }\n\n disjunctive_linear_constraint_system_t to_disjunctive_linear_constraint_system() {\n auto lin_csts = to_linear_constraint_system();\n if (lin_csts.is_false()) {\n return disjunctive_linear_constraint_system_t(true /*is_false*/); \n } else if (lin_csts.is_true()) {\n return disjunctive_linear_constraint_system_t(false /*is_false*/);\n } else {\n return disjunctive_linear_constraint_system_t(lin_csts);\n }\n }\n \n static std::string getDomainName() {\n return \"Congruences\"; \n }\n\n}; // class congruence_domain\n\n} // namespace ikos\n\nnamespace crab {\nnamespace domains {\n\n template \n struct abstract_domain_traits> {\n typedef Number number_t;\n typedef VariableName varname_t; \n };\n \n}\n}\n\n", "meta": {"hexsha": "bc7af4351885ef09dddcf96973295b2c73183b0f", "size": 37446, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/crab/domains/congruences.hpp", "max_stars_repo_name": "numairmansur/crab", "max_stars_repo_head_hexsha": "316e3946d3a4d92db638c54fbfa8fb7bee1ebbc7", "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/crab/domains/congruences.hpp", "max_issues_repo_name": "numairmansur/crab", "max_issues_repo_head_hexsha": "316e3946d3a4d92db638c54fbfa8fb7bee1ebbc7", "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/crab/domains/congruences.hpp", "max_forks_repo_name": "numairmansur/crab", "max_forks_repo_head_hexsha": "316e3946d3a4d92db638c54fbfa8fb7bee1ebbc7", "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": 28.9158301158, "max_line_length": 94, "alphanum_fraction": 0.6159002297, "num_tokens": 10616, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7931059511841119, "lm_q2_score": 0.6859494485880927, "lm_q1q2_score": 0.5440305898866763}} {"text": "#ifndef MATHTOOLBOX_NUMERICAL_OPTIMIZATION_HPP\n#define MATHTOOLBOX_NUMERICAL_OPTIMIZATION_HPP\n\n#include \n#include \n#include \n#include \n#include \n\nnamespace mathtoolbox\n{\n namespace optimization\n {\n enum class Algorithm\n {\n Bfgs,\n LBfgs\n };\n\n enum class Type\n {\n Min,\n Max\n };\n\n struct Setting\n {\n Algorithm algorithm = Algorithm::Bfgs;\n Eigen::VectorXd x_init = Eigen::VectorXd(0);\n std::function f = nullptr;\n std::function g = nullptr;\n double epsilon = 1e-05;\n unsigned int max_num_iterations = 1000;\n Type type = Type::Min;\n };\n\n struct Result\n {\n Eigen::VectorXd x_star;\n unsigned num_iterations;\n };\n\n /// \\brief Run optimization with the specified setting\n ///\n /// \\details This is a utility function to run various optimization types in a consitent interface.\n inline Result RunOptimization(const Setting& input)\n {\n const auto f = (input.type == Type::Min) ? input.f : [&input](const Eigen::VectorXd& x) -> double {\n return -input.f(x);\n };\n const auto g = (input.type == Type::Min) ? input.g : [&input](const Eigen::VectorXd& x) -> Eigen::VectorXd {\n return -input.g(x);\n };\n\n switch (input.algorithm)\n {\n case Algorithm::Bfgs:\n {\n if (!input.f || !input.g || input.x_init.rows() == 0)\n {\n throw std::invalid_argument(\"Invalid setting.\");\n }\n\n Result result;\n RunBfgs(input.x_init,\n f,\n g,\n input.epsilon,\n input.max_num_iterations,\n result.x_star,\n result.num_iterations);\n return result;\n }\n case Algorithm::LBfgs:\n {\n if (!input.f || !input.g || input.x_init.rows() == 0)\n {\n throw std::invalid_argument(\"Invalid setting.\");\n }\n\n Result result;\n RunLBfgs(input.x_init,\n f,\n g,\n input.epsilon,\n input.max_num_iterations,\n result.x_star,\n result.num_iterations);\n return result;\n }\n }\n }\n } // namespace optimization\n} // namespace mathtoolbox\n\n#endif // MATHTOOLBOX_NUMERICAL_OPTIMIZATION_HPP\n", "meta": {"hexsha": "e34a6fccd565d6d938380e5c17d7fba9825ef940", "size": 3359, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/mathtoolbox/numerical-optimization.hpp", "max_stars_repo_name": "yuki-koyama/mathtoolbox", "max_stars_repo_head_hexsha": "eb7449c3c489f465849a74405e72aff016a296f7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 195.0, "max_stars_repo_stars_event_min_datetime": "2018-04-28T16:12:06.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T03:52:56.000Z", "max_issues_repo_path": "include/mathtoolbox/numerical-optimization.hpp", "max_issues_repo_name": "amazing89/mathtoolbox", "max_issues_repo_head_hexsha": "8904bb06ced2ac501594f9574ef1ba3454b8e38e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 52.0, "max_issues_repo_issues_event_min_datetime": "2018-04-15T01:24:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-02T09:14:23.000Z", "max_forks_repo_path": "include/mathtoolbox/numerical-optimization.hpp", "max_forks_repo_name": "amazing89/mathtoolbox", "max_forks_repo_head_hexsha": "8904bb06ced2ac501594f9574ef1ba3454b8e38e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 21.0, "max_forks_repo_forks_event_min_datetime": "2018-06-05T04:11:22.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-17T13:28:12.000Z", "avg_line_length": 34.6288659794, "max_line_length": 120, "alphanum_fraction": 0.4120273891, "num_tokens": 581, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.793105941403651, "lm_q2_score": 0.6859494485880927, "lm_q1q2_score": 0.5440305831777745}} {"text": "#define DEBUG 1\n/**\n * File : F.cpp\n * Author : Kazune Takahashi\n * Created : 5/18/2020, 3:01:31 PM\n * Powered by Visual Studio Code\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n// ----- boost -----\n#include \n#include \n// ----- using directives and manipulations -----\nusing namespace std;\nusing boost::rational;\nusing boost::multiprecision::cpp_int;\nusing ll = long long;\ntemplate \nusing max_heap = priority_queue;\ntemplate \nusing min_heap = priority_queue, greater>;\n// ----- constexpr for Mint and Combination -----\nconstexpr ll MOD{1000000007LL};\n// constexpr ll MOD{998244353LL}; // be careful\nconstexpr ll MAX_SIZE{3000010LL};\n// constexpr ll MAX_SIZE{30000010LL}; // if 10^7 is needed\n// ----- ch_max and ch_min -----\ntemplate \nvoid ch_max(T &left, T right)\n{\n if (left < right)\n {\n left = right;\n }\n}\ntemplate \nvoid ch_min(T &left, T right)\n{\n if (left > right)\n {\n left = right;\n }\n}\n// ----- Mint -----\ntemplate \nclass Mint\n{\npublic:\n ll x;\n Mint() : x{0LL} {}\n Mint(ll x) : x{(x % MOD + MOD) % MOD} {}\n Mint operator-() const { return x ? MOD - x : 0; }\n Mint &operator+=(const Mint &a)\n {\n if ((x += a.x) >= MOD)\n {\n x -= MOD;\n }\n return *this;\n }\n Mint &operator-=(const Mint &a) { return *this += -a; }\n Mint &operator++() { return *this += 1; }\n Mint operator++(int)\n {\n Mint tmp{*this};\n ++*this;\n return tmp;\n }\n Mint &operator--() { return *this -= 1; }\n Mint operator--(int)\n {\n Mint tmp{*this};\n --*this;\n return tmp;\n }\n Mint &operator*=(const Mint &a)\n {\n (x *= a.x) %= MOD;\n return *this;\n }\n Mint &operator/=(const Mint &a)\n {\n Mint b{a};\n return *this *= b.power(MOD - 2);\n }\n Mint operator+(const Mint &a) const { return Mint(*this) += a; }\n Mint operator-(const Mint &a) const { return Mint(*this) -= a; }\n Mint operator*(const Mint &a) const { return Mint(*this) *= a; }\n Mint operator/(const Mint &a) const { return Mint(*this) /= a; }\n bool operator<(const Mint &a) const { return x < a.x; }\n bool operator<=(const Mint &a) const { return x <= a.x; }\n bool operator>(const Mint &a) const { return x > a.x; }\n bool operator>=(const Mint &a) const { return x >= a.x; }\n bool operator==(const Mint &a) const { return x == a.x; }\n bool operator!=(const Mint &a) const { return !(*this == a); }\n const Mint power(ll N)\n {\n if (N == 0)\n {\n return 1;\n }\n else if (N % 2 == 1)\n {\n return *this * power(N - 1);\n }\n else\n {\n Mint half = power(N / 2);\n return half * half;\n }\n }\n};\ntemplate \nMint operator+(ll lhs, const Mint &rhs)\n{\n return rhs + lhs;\n}\ntemplate \nMint operator-(ll lhs, const Mint &rhs)\n{\n return -rhs + lhs;\n}\ntemplate \nMint operator*(ll lhs, const Mint &rhs)\n{\n return rhs * lhs;\n}\ntemplate \nMint operator/(ll lhs, const Mint &rhs)\n{\n return Mint{lhs} / rhs;\n}\ntemplate \nistream &operator>>(istream &stream, Mint &a)\n{\n return stream >> a.x;\n}\ntemplate \nostream &operator<<(ostream &stream, const Mint &a)\n{\n return stream << a.x;\n}\n// ----- Combination -----\ntemplate \nclass Combination\n{\npublic:\n vector> inv, fact, factinv;\n Combination() : inv(MAX_SIZE), fact(MAX_SIZE), factinv(MAX_SIZE)\n {\n inv[1] = 1;\n for (auto i = 2LL; i < MAX_SIZE; i++)\n {\n inv[i] = (-inv[MOD % i]) * (MOD / i);\n }\n fact[0] = factinv[0] = 1;\n for (auto i = 1LL; i < MAX_SIZE; i++)\n {\n fact[i] = Mint(i) * fact[i - 1];\n factinv[i] = inv[i] * factinv[i - 1];\n }\n }\n Mint operator()(int n, int k)\n {\n if (n >= 0 && k >= 0 && n - k >= 0)\n {\n return fact[n] * factinv[k] * factinv[n - k];\n }\n return 0;\n }\n Mint catalan(int x, int y)\n {\n return (*this)(x + y, y) - (*this)(x + y, y - 1);\n }\n};\n// ----- for C++14 -----\nusing mint = Mint;\nusing combination = Combination;\ntemplate \nT gcd(T x, T y) { return y ? gcd(y, x % y) : x; }\ntemplate \nT lcm(T x, T y) { return x / gcd(x, y) * y; }\n// ----- for C++17 -----\ntemplate \nint popcount(T x) // C++20\n{\n int ans{0};\n while (x != 0)\n {\n ans += x & 1;\n x >>= 1;\n }\n return ans;\n}\n// ----- frequently used constexpr -----\n// constexpr long double epsilon{1e-10};\n// constexpr ll infty{1000000000000000LL}; // or\n// constexpr int infty{1'000'000'010};\n// constexpr int dx[4] = {1, 0, -1, 0};\n// constexpr int dy[4] = {0, 1, 0, -1};\n// ----- Yes() and No() -----\nvoid Yes()\n{\n cout << \"Yes\" << endl;\n exit(0);\n}\nvoid No()\n{\n cout << \"No\" << endl;\n exit(0);\n}\n\n// ----- Point -----\n\nclass Point\n{\npublic:\n ll x, v;\n\n Point() {}\n Point(ll x, ll v) : x{x}, v{v} {}\n\n long double now(long double t) const { return x + v * t; }\n};\n\nlong double cross(Point const &p, Point const &q)\n{\n if (q.v == p.v)\n {\n return 0.0;\n }\n return (static_cast(p.x) - q.x) / (q.v - p.v);\n}\n\nbool operator<(Point const &p, Point const &q)\n{\n assert(p.v == q.v);\n return p.x < q.x;\n}\n\n// ----- Axis -----\n\nclass Axis\n{\n vector> points;\n vector candidates;\n vector snapshots;\n\npublic:\n Axis(vector const &V) : points(3)\n {\n for (auto const &p : V)\n {\n points[p.v].push_back(p);\n }\n for (auto i = 0; i < 3; ++i)\n {\n if (points[i].empty())\n {\n continue;\n }\n candidates.push_back(*max_element(points[i].begin(), points[i].end()));\n candidates.push_back(*min_element(points[i].begin(), points[i].end()));\n }\n for (auto it = candidates.begin(); it != candidates.end(); ++it)\n {\n for (auto it2 = it + 1; it2 != candidates.end(); ++it2)\n {\n long double tmp{cross(*it, *it2)};\n if (tmp > 0)\n {\n snapshots.push_back(tmp);\n }\n }\n }\n }\n\n long double delta(long double t) const;\n\n vector const &timer() const { return snapshots; }\n};\n\nlong double Axis::delta(long double t) const\n{\n vector V;\n for (auto const &p : candidates)\n {\n V.push_back(p.now(t));\n }\n return *max_element(V.begin(), V.end()) - *min_element(V.begin(), V.end());\n}\n\n// ----- main() -----\n\nint main()\n{\n vector PX, PY;\n int N;\n cin >> N;\n for (auto i = 0; i < N; ++i)\n {\n ll x, y;\n char c;\n cin >> x >> y >> c;\n if (c == 'R')\n {\n PX.emplace_back(x, 2);\n PY.emplace_back(y, 1);\n }\n else if (c == 'L')\n {\n PX.emplace_back(x, 0);\n PY.emplace_back(y, 1);\n }\n else if (c == 'U')\n {\n PX.emplace_back(x, 1);\n PY.emplace_back(y, 2);\n }\n else\n {\n PX.emplace_back(x, 1);\n PY.emplace_back(y, 0);\n }\n }\n Axis X(PX), Y(PY);\n vector timer;\n copy(X.timer().begin(), X.timer().end(), back_inserter(timer));\n copy(Y.timer().begin(), Y.timer().end(), back_inserter(timer));\n long double ans{X.delta(0) * Y.delta(0)};\n for (auto t : timer)\n {\n ch_min(ans, X.delta(t) * Y.delta(t));\n#if DEBUG == 1\n cerr << \"t = \" << t << \", X.delta = \" << X.delta(t) << \", Y.delta = \" << Y.delta(t) << endl;\n#endif\n }\n cout << fixed << setprecision(15) << ans << endl;\n}\n", "meta": {"hexsha": "10b259c44e342517f32a0e83efe77a86850707a0", "size": 7754, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "2019/0616_ABC130/F.cpp", "max_stars_repo_name": "kazunetakahashi/atcoder", "max_stars_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2019-03-24T14:06:29.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-17T21:16:36.000Z", "max_issues_repo_path": "2019/0616_ABC130/F.cpp", "max_issues_repo_name": "kazunetakahashi/atcoder", "max_issues_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "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": "2019/0616_ABC130/F.cpp", "max_forks_repo_name": "kazunetakahashi/atcoder", "max_forks_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-07-22T17:27:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-22T17:27:09.000Z", "avg_line_length": 21.4792243767, "max_line_length": 96, "alphanum_fraction": 0.5551973175, "num_tokens": 2442, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744673038222, "lm_q2_score": 0.6654105454764747, "lm_q1q2_score": 0.5440226722562745}} {"text": "/* +------------------------------------------------------------------------+\n | Mobile Robot Programming Toolkit (MRPT) |\n | https://www.mrpt.org/ |\n | |\n | Copyright (c) 2005-2019, Individual contributors, see AUTHORS file |\n | See: https://www.mrpt.org/Authors - All rights reserved. |\n | Released under BSD License. See: https://www.mrpt.org/License |\n +------------------------------------------------------------------------+ */\n\n#include \"poses-precomp.h\" // Precompiled headers\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace mrpt;\nusing namespace mrpt::math;\nusing namespace mrpt::poses;\nusing namespace mrpt::poses::Lie;\n\n// See .h for documentation\n\n// ====== SE(3) ===========\nSE<3>::type SE<3>::exp(const SE<3>::tangent_vector& x)\n{\n\treturn CPose3D(Lie::SO<3>::exp(x.tail<3>()), x.head<3>());\n}\n\nSE<3>::tangent_vector SE<3>::log(const SE<3>::type& P)\n{\n\ttangent_vector v;\n\tconst auto log_R = mrpt::poses::Lie::SO<3>::log(P.getRotationMatrix());\n\tv[0] = P.x();\n\tv[1] = P.y();\n\tv[2] = P.z();\n\tv[3] = log_R[0];\n\tv[4] = log_R[1];\n\tv[5] = log_R[2];\n\treturn v;\n}\n\nSE<3>::manifold_vector SE<3>::asManifoldVector(const SE<3>::type& pose)\n{\n\tmanifold_vector v;\n\tpose.getAs12Vector(v);\n\treturn v;\n}\n\nSE<3>::type SE<3>::fromManifoldVector(const SE<3>::manifold_vector& v)\n{\n\treturn type(v);\n}\n\n// See 10.3.1 in \\cite blanco_se3_tutorial\nSE<3>::tang2mat_jacob SE<3>::jacob_dexpe_de(const SE<3>::tangent_vector& x)\n{\n\t// 12x6 Jacobian:\n\ttang2mat_jacob J = tang2mat_jacob::Zero();\n\tJ.block<3, 3>(9, 0) = Eigen::Matrix3d::Identity();\n\tconst auto w = SO<3>::tangent_vector(x.tail<3>());\n\tJ.block<9, 3>(0, 3) = SO<3>::jacob_dexpe_de(w).asEigen();\n\treturn J;\n}\n\nSE<3>::mat2tang_jacob SE<3>::jacob_dlogv_dv(const SE<3>::type& P)\n{\n\tmrpt::math::CMatrixDouble6_12 J;\n\tJ.setZero();\n\tconst CMatrixDouble33& R = P.getRotationMatrix();\n\tJ.block<3, 9>(3, 0) = SO<3>::jacob_dlogv_dv(R).asEigen();\n\tJ(0, 9) = J(1, 10) = J(2, 11) = 1.0;\n\treturn J;\n}\n\n// Section 10.3.3 in tech report\n// http://ingmec.ual.es/~jlblanco/papers/jlblanco2010geometry3D_techrep.pdf\nSE<3>::tang2mat_jacob SE<3>::jacob_dexpeD_de(const CPose3D& D)\n{\n\tmrpt::math::CMatrixDouble12_6 jacob;\n\tjacob.block<9, 3>(0, 0).setZero();\n\tjacob.block<3, 3>(9, 0).setIdentity();\n\tfor (int i = 0; i < 3; i++)\n\t{\n\t\tauto trg_blc = jacob.block<3, 3>(3 * i, 3);\n\t\tmrpt::math::skew_symmetric3_neg(\n\t\t\tD.getRotationMatrix().blockCopy<3, 1>(0, i), trg_blc);\n\t}\n\t{\n\t\tauto trg_blc = jacob.block<3, 3>(9, 3);\n\t\tmrpt::math::skew_symmetric3_neg(D.m_coords, trg_blc);\n\t}\n\treturn jacob;\n}\n\n// Section 10.3.4 in tech report\n// http://ingmec.ual.es/~jlblanco/papers/jlblanco2010geometry3D_techrep.pdf\nSE<3>::tang2mat_jacob SE<3>::jacob_dDexpe_de(const CPose3D& D)\n{\n\tmrpt::math::CMatrixDouble12_6 jacob;\n\tconst auto& dRot = D.getRotationMatrix();\n\tjacob.setZero();\n\tjacob.block<3, 3>(9, 0) = dRot.asEigen();\n\n\tjacob.block<3, 1>(3, 5) = -dRot.col(0);\n\tjacob.block<3, 1>(6, 4) = dRot.col(0);\n\n\tjacob.block<3, 1>(0, 5) = dRot.col(1);\n\tjacob.block<3, 1>(6, 3) = -dRot.col(1);\n\n\tjacob.block<3, 1>(0, 4) = -dRot.col(2);\n\tjacob.block<3, 1>(3, 3) = dRot.col(2);\n\treturn jacob;\n}\n\n// Eq. 10.3.7 in tech report\n// http://ingmec.ual.es/~jlblanco/papers/jlblanco2010geometry3D_techrep.pdf\nSE<3>::tang2mat_jacob SE<3>::jacob_dAexpeD_de(\n\tconst CPose3D& A, const CPose3D& D)\n{\n\tconst auto& Arot = A.getRotationMatrix();\n\n\tmrpt::math::CMatrixDouble12_6 jacob;\n\tjacob.block<9, 3>(0, 0).setZero();\n\tjacob.block<3, 3>(9, 0) = A.getRotationMatrix().asEigen();\n\tEigen::Matrix aux;\n\tfor (int i = 0; i < 3; i++)\n\t{\n\t\tmrpt::math::skew_symmetric3_neg(\n\t\t\tD.getRotationMatrix().blockCopy<3, 1>(0, i), aux);\n\t\tjacob.block<3, 3>(3 * i, 3) = Arot.asEigen() * aux;\n\t}\n\tmrpt::math::skew_symmetric3_neg(D.m_coords, aux);\n\tjacob.block<3, 3>(9, 3) = Arot.asEigen() * aux;\n\treturn jacob;\n}\n\nvoid SE<3>::jacob_dDinvP1invP2_de1e2(\n\tconst CPose3D& Dinv, const CPose3D& P1, const CPose3D& P2,\n\tmrpt::optional_ref df_de1,\n\tmrpt::optional_ref df_de2)\n{\n\tusing namespace mrpt::math;\n\n\t// The rotation matrix of the overall error expression:\n\tconst CPose3D P1inv = -P1;\n\tconst CPose3D DinvP1invP2 = Dinv + P1inv + P2;\n\n\t// Common part: d_PseudoLn(T)_dT:\n\t// (6x12 matrix)\n\tconst auto dLnT_dT = SE<3>::jacob_dlogv_dv(DinvP1invP2);\n\n\t// See section 10.3.10 of Tech. report:\n\t// \"A tutorial on SE(3) transformation parameterizations and on-manifold\n\t// optimization\"\n\tif (df_de1)\n\t{\n\t\tmatrix_TxT& J1 = df_de1.value().get();\n\n\t\tconst CMatrixFixed J1a =\n\t\t\tSE<3>::jacob_dAB_dA(Dinv, P1inv + P2);\n\t\tconst auto J1b = CMatrixDouble12_6(-SE<3>::jacob_dDexpe_de(Dinv));\n\n\t\tJ1 = dLnT_dT.asEigen() * J1a.asEigen() * J1b.asEigen();\n\t}\n\tif (df_de2)\n\t{\n\t\tmatrix_TxT& J2 = df_de2.value().get();\n\t\tconst auto dAe_de = SE<3>::jacob_dDexpe_de(DinvP1invP2);\n\t\tJ2 = dLnT_dT * dAe_de;\n\t}\n}\n\nSE<3>::matrix_MxM SE<3>::jacob_dAB_dA(\n\tconst SE<3>::type& A, const SE<3>::type& B)\n{\n\tusing namespace mrpt::math;\n\n\tmatrix_MxM J = matrix_MxM::Zero();\n\t// J_wrt_A = kron(B,eye(3));\n\tconst auto B_HM =\n\t\tB.getHomogeneousMatrixVal().transpose().eval();\n\tfor (int c = 0; c < 4; c++)\n\t\tfor (int r = 0; r < 4; r++)\n\t\t\tfor (int q = 0; q < 3; q++) J(r * 3 + q, c * 3 + q) = B_HM(r, c);\n\n\treturn J;\n}\n\nSE<3>::matrix_MxM SE<3>::jacob_dAB_dB(\n\tconst SE<3>::type& A, const SE<3>::type& B)\n{\n\tmatrix_MxM J = matrix_MxM::Zero();\n\t// J_wrt_B = kron(eye(3),A_rot);\n\tconst auto& AR = A.getRotationMatrix();\n\tfor (int c = 0; c < 4; c++) J.block<3, 3>(c * 3, c * 3) = AR.asEigen();\n\treturn J;\n}\n\n// See .h for documentation\n// ====== SE(2) ===========\nSE<2>::type SE<2>::exp(const SE<2>::tangent_vector& x)\n{\n\tSE<2>::type P;\n\tP.x(x[0]);\n\tP.y(x[1]);\n\tP.phi(x[2]);\n\treturn P;\n}\n\nSE<2>::tangent_vector SE<2>::log(const SE<2>::type& P)\n{\n\tSE<2>::tangent_vector x;\n\tx[0] = P.x();\n\tx[1] = P.y();\n\tx[2] = mrpt::math::wrapToPi(P.phi());\n\treturn x;\n}\n\nSE<2>::manifold_vector SE<2>::asManifoldVector(const SE<2>::type& pose)\n{\n\tmanifold_vector v;\n\tv[0] = pose.x();\n\tv[1] = pose.y();\n\tv[2] = mrpt::math::wrapToPi(pose.phi());\n\treturn v;\n}\n\nSE<2>::type SE<2>::fromManifoldVector(const SE<2>::manifold_vector& v)\n{\n\treturn type(v[0], v[1], mrpt::math::wrapToPi(v[2]));\n}\n\nSE<2>::matrix_MxM SE<2>::jacob_dAB_dA(\n\tconst SE<2>::type& A, const SE<2>::type& B)\n{\n\tconst auto bx = B.x(), by = B.y();\n\tconst auto cphia = A.phi_cos(), sphia = A.phi_sin();\n\n\tmatrix_MxM J = matrix_MxM::Identity();\n\tJ(0, 2) = -bx * sphia - by * cphia;\n\tJ(1, 2) = +bx * cphia - by * sphia;\n\treturn J;\n}\n\nSE<2>::matrix_MxM SE<2>::jacob_dAB_dB(\n\tconst SE<2>::type& A, const SE<2>::type& B)\n{\n\tmatrix_MxM J = matrix_MxM::Identity();\n\tconst auto cphia = A.phi_cos(), sphia = A.phi_sin();\n\tJ(0, 0) = cphia;\n\tJ(0, 1) = -sphia;\n\tJ(1, 0) = sphia;\n\tJ(1, 1) = cphia;\n\treturn J;\n}\n\nSE<2>::tang2mat_jacob SE<2>::jacob_dDexpe_de(const SE<2>::type& D)\n{\n\tconst auto c = D.phi_cos(), s = D.phi_sin();\n\n\t// clang-format off\n\treturn SE<2>::tang2mat_jacob((Eigen::Matrix3d() <<\n\t c, -s, 0,\n\t s, c, 0,\n\t 0, 0, 1\n\t ).finished());\n\t// clang-format on\n}\n\nvoid SE<2>::jacob_dDinvP1invP2_de1e2(\n\tconst CPose2D& Dinv, const CPose2D& P1, const CPose2D& P2,\n\tmrpt::optional_ref df_de1,\n\tmrpt::optional_ref df_de2)\n{\n\tconst CPose2D P1inv = -P1;\n\tconst CPose2D P1invP2 = P1inv + P2;\n\tconst CPose2D DinvP1invP2 = Dinv + P1invP2;\n\n\tif (df_de1)\n\t{\n\t\tauto& J1 = df_de1.value().get();\n\t\tJ1 = jacob_dAB_dA(Dinv, P1invP2).asEigen() * (-jacob_dDexpe_de(Dinv));\n\t}\n\n\tif (df_de2)\n\t{\n\t\tauto& J2 = df_de2.value().get();\n\t\tJ2 = SE<2>::jacob_dDexpe_de(DinvP1invP2);\n\t}\n}\n", "meta": {"hexsha": "88457471487a37f9e62c9b89b90e5a0db4538222", "size": 7893, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libs/poses/src/Lie/SE.cpp", "max_stars_repo_name": "zarmomin/mrpt", "max_stars_repo_head_hexsha": "1baff7cf8ec9fd23e1a72714553bcbd88c201966", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-12-10T06:24:08.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-10T06:24:08.000Z", "max_issues_repo_path": "libs/poses/src/Lie/SE.cpp", "max_issues_repo_name": "gao-ouyang/mrpt", "max_issues_repo_head_hexsha": "4af5fdf7e45b00be4a64c3d4f009acb9ef415ec7", "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": "libs/poses/src/Lie/SE.cpp", "max_forks_repo_name": "gao-ouyang/mrpt", "max_forks_repo_head_hexsha": "4af5fdf7e45b00be4a64c3d4f009acb9ef415ec7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-09-11T02:55:04.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-11T02:55:04.000Z", "avg_line_length": 26.8469387755, "max_line_length": 80, "alphanum_fraction": 0.6101609021, "num_tokens": 3037, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467675095294, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.5439988181240503}} {"text": "// Copyright ETHZ 2017\n// autor: mathias, 2017, mathias.rothermel@geod.baug.ethz.ch \n#include \"OriGeom.h\"\n#include \"Orientation.h\"\n#include \n#include \n\nnamespace OriGeom\n{\n\n\tvoid computeRelative( const Orientation &identity, const Orientation &other, Orientation &out )\n\t{\n\t \t// Copy\n\t \tout=other;\n\n\t\t// First Cam (after transform this is identity)\n\t\tEigen::Vector3d C0=identity.getC();\n\t\tEigen::Matrix3d R0=identity.getR();\n\t\tEigen::Vector3d t0=(-1.0)*R0*C0;\n\t\t\n\t\t// Second cam\n\t\tEigen::Vector3d C1=other.getC();\n\t\tEigen::Matrix3d R1=other.getR();\n\t\tEigen::Matrix3d K1=other.getK();\n\t\tEigen::Vector3d t1=(-1.0)*R1*C1;\n\n\t\t// New cam\n\t\tEigen::Matrix3d R10=R1*R0.transpose();\n\t\tEigen::Vector3d C10=R1*C0+t1;\n\t\n\t\tout.setK(K1); \n\t\tout.setR(R10); \n\t\tout.setC(C10); \n\t}\n}\n", "meta": {"hexsha": "d038d94ca51c186ced16f8394c87cc67b2d42227", "size": 794, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Ori/OriGeom.cpp", "max_stars_repo_name": "Hivemapper/MRef", "max_stars_repo_head_hexsha": "fb903a1587ea587f3f2a3233f4835bec3a82a1bb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2020-05-26T14:22:25.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-11T09:41:13.000Z", "max_issues_repo_path": "Ori/OriGeom.cpp", "max_issues_repo_name": "Hivemapper/MRef", "max_issues_repo_head_hexsha": "fb903a1587ea587f3f2a3233f4835bec3a82a1bb", "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": "Ori/OriGeom.cpp", "max_forks_repo_name": "Hivemapper/MRef", "max_forks_repo_head_hexsha": "fb903a1587ea587f3f2a3233f4835bec3a82a1bb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-07-14T19:07:40.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-14T19:07:40.000Z", "avg_line_length": 22.0555555556, "max_line_length": 96, "alphanum_fraction": 0.6687657431, "num_tokens": 280, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467548438126, "lm_q2_score": 0.6187804267137441, "lm_q1q2_score": 0.5439988041062577}} {"text": "\n\n#include \n#include \n#include \n#include \n\n#include \n\n#include \n\nNTL_START_IMPL\n\n\n\n\nstatic\nvoid IterSqr(GF2E& c, const GF2E& a, long n)\n{\n GF2E res;\n\n long i;\n\n res = a;\n\n for (i = 0; i < n; i++)\n sqr(res, res);\n\n c = res;\n}\n \n\n\nvoid SquareFreeDecomp(vec_pair_GF2EX_long& u, const GF2EX& ff)\n{\n GF2EX f = ff;\n\n if (!IsOne(LeadCoeff(f)))\n Error(\"SquareFreeDecomp: bad args\");\n\n GF2EX r, t, v, tmp1;\n long m, j, finished, done;\n\n u.SetLength(0);\n\n if (deg(f) == 0)\n return;\n\n m = 1;\n finished = 0;\n\n do {\n j = 1;\n diff(tmp1, f);\n GCD(r, f, tmp1);\n div(t, f, r);\n\n if (deg(t) > 0) {\n done = 0;\n do {\n GCD(v, r, t);\n div(tmp1, t, v);\n if (deg(tmp1) > 0) append(u, cons(tmp1, j*m));\n if (deg(v) > 0) {\n div(r, r, v);\n t = v;\n j++;\n }\n else\n done = 1;\n } while (!done);\n if (deg(r) == 0) finished = 1;\n }\n\n if (!finished) {\n /* r is a square */\n\n long k, d;\n d = deg(r)/2;\n f.rep.SetLength(d+1);\n for (k = 0; k <= d; k++) \n IterSqr(f.rep[k], r.rep[k*2], GF2E::degree()-1);\n m = m*2;\n }\n } while (!finished);\n}\n \n\n\nstatic\nvoid NullSpace(long& r, vec_long& D, vec_GF2XVec& M, long verbose)\n{\n long k, l, n;\n long i, j;\n long pos;\n GF2X t1, t2;\n GF2X *x, *y;\n\n const GF2XModulus& p = GF2E::modulus();\n\n n = M.length();\n\n D.SetLength(n);\n for (j = 0; j < n; j++) D[j] = -1;\n\n r = 0;\n\n l = 0;\n for (k = 0; k < n; k++) {\n\n if (verbose && k % 10 == 0) cerr << \"+\";\n\n pos = -1;\n for (i = l; i < n; i++) {\n rem(t1, M[i][k], p);\n M[i][k] = t1;\n if (pos == -1 && !IsZero(t1))\n pos = i;\n }\n\n if (pos != -1) {\n swap(M[pos], M[l]);\n\n // make M[l, k] == -1 mod p, and make row l reduced\n\n InvMod(t1, M[l][k], p);\n for (j = k+1; j < n; j++) {\n rem(t2, M[l][j], p);\n MulMod(M[l][j], t2, t1, p);\n }\n\n for (i = l+1; i < n; i++) {\n // M[i] = M[i] + M[l]*M[i,k]\n\n t1 = M[i][k]; // this is already reduced\n\n x = M[i].elts() + (k+1);\n y = M[l].elts() + (k+1);\n\n for (j = k+1; j < n; j++, x++, y++) {\n // *x = *x + (*y)*t1\n\n mul(t2, *y, t1);\n add(*x, *x, t2);\n }\n }\n\n D[k] = l; // variable k is defined by row l\n l++;\n\n }\n else {\n r++;\n }\n }\n}\n\n\n\nstatic\nvoid BuildMatrix(vec_GF2XVec& M, long n, const GF2EX& g, const GF2EXModulus& F,\n long verbose)\n{\n long i, j, m;\n GF2EX h;\n\n\n M.SetLength(n);\n for (i = 0; i < n; i++)\n M[i].SetSize(n, 2*GF2E::WordLength());\n\n set(h);\n for (j = 0; j < n; j++) {\n if (verbose && j % 10 == 0) cerr << \"+\";\n\n m = deg(h);\n for (i = 0; i < n; i++) {\n if (i <= m)\n M[i][j] = rep(h.rep[i]);\n else\n clear(M[i][j]);\n }\n\n if (j < n-1)\n MulMod(h, h, g, F);\n }\n\n for (i = 0; i < n; i++)\n add(M[i][i], M[i][i], 1);\n\n}\n\n\nstatic\nvoid TraceMap(GF2EX& h, const GF2EX& a, const GF2EXModulus& F)\n\n// one could consider making a version based on modular composition,\n// as in ComposeFrobeniusMap...\n\n{\n GF2EX res, tmp;\n\n res = a;\n tmp = a;\n\n long i;\n for (i = 0; i < GF2E::degree()-1; i++) {\n SqrMod(tmp, tmp, F);\n add(res, res, tmp);\n }\n\n h = res;\n}\n\nvoid PlainFrobeniusMap(GF2EX& h, const GF2EXModulus& F)\n{\n GF2EX res;\n\n SetX(res);\n long i;\n for (i = 0; i < GF2E::degree(); i++) \n SqrMod(res, res, F);\n\n h = res;\n}\n\nlong UseComposeFrobenius(long d, long n)\n{\n long i;\n i = 1;\n while (i <= d) i = i << 1;\n i = i >> 1;\n\n i = i >> 1;\n long m = 1;\n\n long dz;\n\n if (n == 2) {\n dz = 1;\n }\n else {\n while (i) {\n long m1 = 2*m;\n if (i & d) m1++;\n \n if (m1 >= NTL_BITS_PER_LONG-1 || (1L << m1) >= n) break;\n \n m = m1;\n i = i >> 1;\n }\n\n dz = 1L << m;\n }\n\n long rootn = SqrRoot(n);\n long cnt = 0;\n\n if (i) {\n cnt += SqrRoot(dz+1);\n i = i >> 1;\n }\n\n while (i) {\n cnt += rootn;\n i = i >> 1;\n }\n\n return 4*cnt <= d;\n}\n\nvoid ComposeFrobeniusMap(GF2EX& y, const GF2EXModulus& F)\n{\n long d = GF2E::degree();\n long n = deg(F);\n\n long i;\n i = 1;\n while (i <= d) i = i << 1;\n i = i >> 1;\n\n GF2EX z(INIT_SIZE, n), z1(INIT_SIZE, n);\n\n i = i >> 1;\n long m = 1;\n\n if (n == 2) {\n SetX(z);\n SqrMod(z, z, F);\n }\n else {\n while (i) {\n long m1 = 2*m;\n if (i & d) m1++;\n \n if (m1 >= NTL_BITS_PER_LONG-1 || (1L << m1) >= n) break;\n \n m = m1;\n i = i >> 1;\n }\n\n clear(z);\n SetCoeff(z, 1L << m);\n }\n\n\n while (i) {\n z1 = z;\n\n long j, k, dz;\n dz = deg(z);\n\n for (j = 0; j <= dz; j++)\n for (k = 0; k < m; k++)\n sqr(z1.rep[j], z1.rep[j]);\n\n CompMod(z, z1, z, F);\n m = 2*m;\n\n if (d & i) {\n SqrMod(z, z, F);\n m++;\n }\n\n i = i >> 1;\n }\n\n y = z;\n}\n\nvoid FrobeniusMap(GF2EX& h, const GF2EXModulus& F)\n{\n long n = deg(F);\n long d = GF2E::degree();\n\n if (n == 1) {\n h = ConstTerm(F);\n return;\n }\n\n if (UseComposeFrobenius(d, n))\n ComposeFrobeniusMap(h, F);\n else\n PlainFrobeniusMap(h, F);\n}\n\n\n\n \n\n\n\nstatic\nvoid RecFindRoots(vec_GF2E& x, const GF2EX& f)\n{\n if (deg(f) == 0) return;\n\n if (deg(f) == 1) {\n long k = x.length();\n x.SetLength(k+1);\n x[k] = ConstTerm(f);\n return;\n }\n \n GF2EX h;\n\n GF2E r;\n\n \n {\n GF2EXModulus F;\n build(F, f);\n\n do {\n random(r);\n clear(h);\n SetCoeff(h, 1, r);\n TraceMap(h, h, F);\n GCD(h, h, f);\n } while (deg(h) <= 0 || deg(h) == deg(f));\n }\n\n RecFindRoots(x, h);\n div(h, f, h); \n RecFindRoots(x, h);\n}\n\nvoid FindRoots(vec_GF2E& x, const GF2EX& ff)\n{\n GF2EX f = ff;\n\n if (!IsOne(LeadCoeff(f)))\n Error(\"FindRoots: bad args\");\n\n x.SetMaxLength(deg(f));\n x.SetLength(0);\n RecFindRoots(x, f);\n}\n\n\nstatic\nvoid RandomBasisElt(GF2EX& g, const vec_long& D, const vec_GF2XVec& M)\n{\n static GF2X t1, t2;\n\n long n = D.length();\n\n long i, j, s;\n\n g.rep.SetLength(n);\n\n vec_GF2E& v = g.rep;\n\n for (j = n-1; j >= 0; j--) {\n if (D[j] == -1)\n random(v[j]);\n else {\n i = D[j];\n\n // v[j] = sum_{s=j+1}^{n-1} v[s]*M[i,s]\n\n clear(t1);\n\n for (s = j+1; s < n; s++) {\n mul(t2, rep(v[s]), M[i][s]);\n add(t1, t1, t2);\n }\n\n conv(v[j], t1);\n }\n }\n\n g.normalize();\n}\n\n\n\nstatic\nvoid split(GF2EX& f1, GF2EX& g1, GF2EX& f2, GF2EX& g2,\n const GF2EX& f, const GF2EX& g, \n const vec_GF2E& roots, long lo, long mid)\n{\n long r = mid-lo+1;\n\n GF2EXModulus F;\n build(F, f);\n\n vec_GF2E lroots(INIT_SIZE, r);\n long i;\n\n for (i = 0; i < r; i++)\n lroots[i] = roots[lo+i];\n\n\n GF2EX h, a, d;\n BuildFromRoots(h, lroots);\n CompMod(a, h, g, F);\n\n\n GCD(f1, a, f);\n \n div(f2, f, f1);\n\n rem(g1, g, f1);\n rem(g2, g, f2);\n}\n\nstatic\nvoid RecFindFactors(vec_GF2EX& factors, const GF2EX& f, const GF2EX& g,\n const vec_GF2E& roots, long lo, long hi)\n{\n long r = hi-lo+1;\n\n if (r == 0) return;\n\n if (r == 1) {\n append(factors, f);\n return;\n }\n\n GF2EX f1, g1, f2, g2;\n\n long mid = (lo+hi)/2;\n\n split(f1, g1, f2, g2, f, g, roots, lo, mid);\n\n RecFindFactors(factors, f1, g1, roots, lo, mid);\n RecFindFactors(factors, f2, g2, roots, mid+1, hi);\n}\n\n\nstatic\nvoid FindFactors(vec_GF2EX& factors, const GF2EX& f, const GF2EX& g,\n const vec_GF2E& roots)\n{\n long r = roots.length();\n\n factors.SetMaxLength(r);\n factors.SetLength(0);\n\n RecFindFactors(factors, f, g, roots, 0, r-1);\n}\n\n#if 0\n\nstatic\nvoid IterFindFactors(vec_GF2EX& factors, const GF2EX& f,\n const GF2EX& g, const vec_GF2E& roots)\n{\n long r = roots.length();\n long i;\n GF2EX h;\n\n factors.SetLength(r);\n\n for (i = 0; i < r; i++) {\n add(h, g, roots[i]);\n GCD(factors[i], f, h);\n }\n}\n\n#endif\n\n\n \n\nvoid SFBerlekamp(vec_GF2EX& factors, const GF2EX& ff, long verbose)\n{\n GF2EX f = ff;\n\n if (!IsOne(LeadCoeff(f)))\n Error(\"SFBerlekamp: bad args\");\n\n if (deg(f) == 0) {\n factors.SetLength(0);\n return;\n }\n\n if (deg(f) == 1) {\n factors.SetLength(1);\n factors[0] = f;\n return;\n }\n\n double t;\n\n long n = deg(f);\n\n GF2EXModulus F;\n\n build(F, f);\n\n GF2EX g, h;\n\n if (verbose) { cerr << \"computing X^p...\"; t = GetTime(); }\n FrobeniusMap(g, F);\n if (verbose) { cerr << (GetTime()-t) << \"\\n\"; }\n\n vec_long D;\n long r;\n\n vec_GF2XVec M;\n\n if (verbose) { cerr << \"building matrix...\"; t = GetTime(); }\n BuildMatrix(M, n, g, F, verbose);\n if (verbose) { cerr << (GetTime()-t) << \"\\n\"; }\n\n if (verbose) { cerr << \"diagonalizing...\"; t = GetTime(); }\n NullSpace(r, D, M, verbose);\n if (verbose) { cerr << (GetTime()-t) << \"\\n\"; }\n\n\n if (verbose) cerr << \"number of factors = \" << r << \"\\n\";\n\n if (r == 1) {\n factors.SetLength(1);\n factors[0] = f;\n return;\n }\n\n if (verbose) { cerr << \"factor extraction...\"; t = GetTime(); }\n\n vec_GF2E roots;\n\n RandomBasisElt(g, D, M);\n MinPolyMod(h, g, F, r);\n if (deg(h) == r) M.kill();\n FindRoots(roots, h);\n FindFactors(factors, f, g, roots);\n\n GF2EX g1;\n vec_GF2EX S, S1;\n long i;\n\n while (factors.length() < r) {\n if (verbose) cerr << \"+\";\n RandomBasisElt(g, D, M);\n S.kill();\n for (i = 0; i < factors.length(); i++) {\n const GF2EX& f = factors[i];\n if (deg(f) == 1) {\n append(S, f);\n continue;\n }\n build(F, f);\n rem(g1, g, F);\n if (deg(g1) <= 0) {\n append(S, f);\n continue;\n }\n MinPolyMod(h, g1, F, min(deg(f), r-factors.length()+1));\n FindRoots(roots, h);\n S1.kill();\n FindFactors(S1, f, g1, roots);\n append(S, S1);\n }\n swap(factors, S);\n }\n\n if (verbose) { cerr << (GetTime()-t) << \"\\n\"; }\n\n if (verbose) {\n cerr << \"degrees:\";\n long i;\n for (i = 0; i < factors.length(); i++)\n cerr << \" \" << deg(factors[i]);\n cerr << \"\\n\";\n }\n}\n\n\nvoid berlekamp(vec_pair_GF2EX_long& factors, const GF2EX& f, long verbose)\n{\n double t;\n vec_pair_GF2EX_long sfd;\n vec_GF2EX x;\n\n if (!IsOne(LeadCoeff(f)))\n Error(\"berlekamp: bad args\");\n\n \n if (verbose) { cerr << \"square-free decomposition...\"; t = GetTime(); }\n SquareFreeDecomp(sfd, f);\n if (verbose) cerr << (GetTime()-t) << \"\\n\";\n\n factors.SetLength(0);\n\n long i, j;\n\n for (i = 0; i < sfd.length(); i++) {\n if (verbose) {\n cerr << \"factoring multiplicity \" << sfd[i].b \n << \", deg = \" << deg(sfd[i].a) << \"\\n\";\n }\n\n SFBerlekamp(x, sfd[i].a, verbose);\n\n for (j = 0; j < x.length(); j++)\n append(factors, cons(x[j], sfd[i].b));\n }\n}\n\n\n\nstatic\nvoid AddFactor(vec_pair_GF2EX_long& factors, const GF2EX& g, long d, long verbose)\n{\n if (verbose)\n cerr << \"degree=\" << d << \", number=\" << deg(g)/d << \"\\n\";\n append(factors, cons(g, d));\n}\n\nstatic\nvoid ProcessTable(GF2EX& f, vec_pair_GF2EX_long& factors, \n const GF2EXModulus& F, long limit, const vec_GF2EX& tbl,\n long d, long verbose)\n\n{\n if (limit == 0) return;\n\n if (verbose) cerr << \"+\";\n\n GF2EX t1;\n\n if (limit == 1) {\n GCD(t1, f, tbl[0]);\n if (deg(t1) > 0) {\n AddFactor(factors, t1, d, verbose);\n div(f, f, t1);\n }\n\n return;\n }\n\n long i;\n\n t1 = tbl[0];\n for (i = 1; i < limit; i++)\n MulMod(t1, t1, tbl[i], F);\n\n GCD(t1, f, t1);\n\n if (deg(t1) == 0) return;\n\n div(f, f, t1);\n\n GF2EX t2;\n\n i = 0;\n d = d - limit + 1;\n\n while (2*d <= deg(t1)) {\n GCD(t2, tbl[i], t1); \n if (deg(t2) > 0) {\n AddFactor(factors, t2, d, verbose);\n div(t1, t1, t2);\n }\n\n i++;\n d++;\n }\n\n if (deg(t1) > 0)\n AddFactor(factors, t1, deg(t1), verbose);\n}\n\n\nvoid TraceMap(GF2EX& w, const GF2EX& a, long d, const GF2EXModulus& F, \n const GF2EX& b)\n\n{\n if (d < 0) Error(\"TraceMap: bad args\");\n\n GF2EX y, z, t;\n\n z = b;\n y = a;\n clear(w);\n\n while (d) {\n if (d == 1) {\n if (IsZero(w)) \n w = y;\n else {\n CompMod(w, w, z, F);\n add(w, w, y);\n }\n }\n else if ((d & 1) == 0) {\n Comp2Mod(z, t, z, y, z, F);\n add(y, t, y);\n }\n else if (IsZero(w)) {\n w = y;\n Comp2Mod(z, t, z, y, z, F);\n add(y, t, y);\n }\n else {\n Comp3Mod(z, t, w, z, y, w, z, F);\n add(w, w, y);\n add(y, t, y);\n }\n\n d = d >> 1;\n }\n}\n\n\nvoid PowerCompose(GF2EX& y, const GF2EX& h, long q, const GF2EXModulus& F)\n{\n if (q < 0) Error(\"powerCompose: bad args\");\n\n GF2EX z(INIT_SIZE, F.n);\n long sw;\n\n z = h;\n SetX(y);\n\n while (q) {\n sw = 0;\n\n if (q > 1) sw = 2;\n if (q & 1) {\n if (IsX(y))\n y = z;\n else\n sw = sw | 1;\n }\n\n switch (sw) {\n case 0:\n break;\n\n case 1:\n CompMod(y, y, z, F);\n break;\n\n case 2:\n CompMod(z, z, z, F);\n break;\n\n case 3:\n Comp2Mod(y, z, y, z, z, F);\n break;\n }\n\n q = q >> 1;\n }\n}\n\n\nlong ProbIrredTest(const GF2EX& f, long iter)\n{\n long n = deg(f);\n\n if (n <= 0) return 0;\n if (n == 1) return 1;\n\n GF2EXModulus F;\n\n build(F, f);\n\n GF2EX b, r, s;\n\n FrobeniusMap(b, F);\n\n long all_zero = 1;\n\n long i;\n\n for (i = 0; i < iter; i++) {\n random(r, n);\n TraceMap(s, r, n, F, b);\n\n all_zero = all_zero && IsZero(s);\n\n if (deg(s) > 0) return 0;\n }\n\n if (!all_zero || (n & 1)) return 1;\n\n PowerCompose(s, b, n/2, F);\n return !IsX(s);\n}\n\n\nlong GF2EX_BlockingFactor = 10;\n\nvoid DDF(vec_pair_GF2EX_long& factors, const GF2EX& ff, const GF2EX& hh, \n long verbose)\n{\n GF2EX f = ff;\n GF2EX h = hh;\n\n if (!IsOne(LeadCoeff(f)))\n Error(\"DDF: bad args\");\n\n factors.SetLength(0);\n\n if (deg(f) == 0)\n return;\n\n if (deg(f) == 1) {\n AddFactor(factors, f, 1, verbose);\n return;\n }\n\n long CompTableSize = 2*SqrRoot(deg(f)); \n\n long GCDTableSize = GF2EX_BlockingFactor;\n\n GF2EXModulus F;\n build(F, f);\n\n GF2EXArgument H;\n\n build(H, h, F, min(CompTableSize, deg(f)));\n\n long i, d, limit, old_n;\n GF2EX g, X;\n\n\n vec_GF2EX tbl(INIT_SIZE, GCDTableSize);\n\n SetX(X);\n\n i = 0;\n g = h;\n d = 1;\n limit = GCDTableSize;\n\n\n while (2*d <= deg(f)) {\n\n old_n = deg(f);\n add(tbl[i], g, X);\n i++;\n if (i == limit) {\n ProcessTable(f, factors, F, i, tbl, d, verbose);\n i = 0;\n }\n\n d = d + 1;\n if (2*d <= deg(f)) {\n // we need to go further\n\n if (deg(f) < old_n) {\n // f has changed \n\n build(F, f);\n rem(h, h, f);\n rem(g, g, f);\n build(H, h, F, min(CompTableSize, deg(f)));\n }\n\n CompMod(g, g, H, F);\n }\n }\n\n ProcessTable(f, factors, F, i, tbl, d-1, verbose);\n\n if (!IsOne(f)) AddFactor(factors, f, deg(f), verbose);\n}\n\n\n\nvoid RootEDF(vec_GF2EX& factors, const GF2EX& f, long verbose)\n{\n vec_GF2E roots;\n double t;\n\n if (verbose) { cerr << \"finding roots...\"; t = GetTime(); }\n FindRoots(roots, f);\n if (verbose) { cerr << (GetTime()-t) << \"\\n\"; }\n\n long r = roots.length();\n factors.SetLength(r);\n for (long j = 0; j < r; j++) {\n SetX(factors[j]);\n add(factors[j], factors[j], roots[j]);\n }\n}\n\nstatic\nvoid EDFSplit(vec_GF2EX& v, const GF2EX& f, const GF2EX& b, long d)\n{\n GF2EX a, g, h;\n GF2EXModulus F;\n vec_GF2E roots;\n \n build(F, f);\n long n = F.n;\n long r = n/d;\n random(a, n);\n TraceMap(g, a, d, F, b);\n MinPolyMod(h, g, F, r);\n FindRoots(roots, h);\n FindFactors(v, f, g, roots);\n}\n\nstatic\nvoid RecEDF(vec_GF2EX& factors, const GF2EX& f, const GF2EX& b, long d,\n long verbose)\n{\n vec_GF2EX v;\n long i;\n GF2EX bb;\n\n if (verbose) cerr << \"+\";\n\n EDFSplit(v, f, b, d);\n for (i = 0; i < v.length(); i++) {\n if (deg(v[i]) == d) {\n append(factors, v[i]);\n }\n else {\n GF2EX bb;\n rem(bb, b, v[i]);\n RecEDF(factors, v[i], bb, d, verbose);\n }\n }\n}\n \n\nvoid EDF(vec_GF2EX& factors, const GF2EX& ff, const GF2EX& bb,\n long d, long verbose)\n\n{\n GF2EX f = ff;\n GF2EX b = bb;\n\n if (!IsOne(LeadCoeff(f)))\n Error(\"EDF: bad args\");\n\n long n = deg(f);\n long r = n/d;\n\n if (r == 0) {\n factors.SetLength(0);\n return;\n }\n\n if (r == 1) {\n factors.SetLength(1);\n factors[0] = f;\n return;\n }\n\n if (d == 1) {\n RootEDF(factors, f, verbose);\n return;\n }\n\n \n double t;\n if (verbose) { \n cerr << \"computing EDF(\" << d << \",\" << r << \")...\"; \n t = GetTime(); \n }\n\n factors.SetLength(0);\n\n RecEDF(factors, f, b, d, verbose);\n\n if (verbose) cerr << (GetTime()-t) << \"\\n\";\n}\n\n\nvoid SFCanZass(vec_GF2EX& factors, const GF2EX& ff, long verbose)\n{\n GF2EX f = ff;\n\n if (!IsOne(LeadCoeff(f)))\n Error(\"SFCanZass: bad args\");\n\n if (deg(f) == 0) {\n factors.SetLength(0);\n return;\n }\n\n if (deg(f) == 1) {\n factors.SetLength(1);\n factors[0] = f;\n return;\n }\n\n factors.SetLength(0);\n\n double t;\n\n \n GF2EXModulus F;\n build(F, f);\n\n GF2EX h;\n\n if (verbose) { cerr << \"computing X^p...\"; t = GetTime(); }\n FrobeniusMap(h, F);\n if (verbose) { cerr << (GetTime()-t) << \"\\n\"; }\n\n vec_pair_GF2EX_long u;\n if (verbose) { cerr << \"computing DDF...\"; t = GetTime(); }\n NewDDF(u, f, h, verbose);\n if (verbose) { \n t = GetTime()-t; \n cerr << \"DDF time: \" << t << \"\\n\";\n }\n\n GF2EX hh;\n vec_GF2EX v;\n\n long i;\n for (i = 0; i < u.length(); i++) {\n const GF2EX& g = u[i].a;\n long d = u[i].b;\n long r = deg(g)/d;\n\n if (r == 1) {\n // g is already irreducible\n\n append(factors, g);\n }\n else {\n // must perform EDF\n\n if (d == 1) {\n // root finding\n RootEDF(v, g, verbose);\n append(factors, v);\n }\n else {\n // general case\n rem(hh, h, g);\n EDF(v, g, hh, d, verbose);\n append(factors, v);\n }\n }\n }\n}\n \nvoid CanZass(vec_pair_GF2EX_long& factors, const GF2EX& f, long verbose)\n{\n if (!IsOne(LeadCoeff(f)))\n Error(\"CanZass: bad args\");\n\n double t;\n vec_pair_GF2EX_long sfd;\n vec_GF2EX x;\n\n \n if (verbose) { cerr << \"square-free decomposition...\"; t = GetTime(); }\n SquareFreeDecomp(sfd, f);\n if (verbose) cerr << (GetTime()-t) << \"\\n\";\n\n factors.SetLength(0);\n\n long i, j;\n\n for (i = 0; i < sfd.length(); i++) {\n if (verbose) {\n cerr << \"factoring multiplicity \" << sfd[i].b \n << \", deg = \" << deg(sfd[i].a) << \"\\n\";\n }\n\n SFCanZass(x, sfd[i].a, verbose);\n\n for (j = 0; j < x.length(); j++)\n append(factors, cons(x[j], sfd[i].b));\n }\n}\n\nvoid mul(GF2EX& f, const vec_pair_GF2EX_long& v)\n{\n long i, j, n;\n\n n = 0;\n for (i = 0; i < v.length(); i++)\n n += v[i].b*deg(v[i].a);\n\n GF2EX g(INIT_SIZE, n+1);\n\n set(g);\n for (i = 0; i < v.length(); i++)\n for (j = 0; j < v[i].b; j++) {\n mul(g, g, v[i].a);\n }\n\n f = g;\n}\n\n\n\n\nstatic\nlong BaseCase(const GF2EX& h, long q, long a, const GF2EXModulus& F)\n{\n long b, e;\n GF2EX lh(INIT_SIZE, F.n);\n\n lh = h;\n b = 1;\n e = 0;\n while (e < a-1 && !IsX(lh)) {\n e++;\n b *= q;\n PowerCompose(lh, lh, q, F);\n }\n\n if (!IsX(lh)) b *= q;\n\n return b;\n}\n\n\n\nstatic\nvoid TandemPowerCompose(GF2EX& y1, GF2EX& y2, const GF2EX& h, \n long q1, long q2, const GF2EXModulus& F)\n{\n GF2EX z(INIT_SIZE, F.n);\n long sw;\n\n z = h;\n SetX(y1);\n SetX(y2);\n\n while (q1 || q2) {\n sw = 0;\n\n if (q1 > 1 || q2 > 1) sw = 4;\n\n if (q1 & 1) {\n if (IsX(y1))\n y1 = z;\n else\n sw = sw | 2;\n }\n\n if (q2 & 1) {\n if (IsX(y2))\n y2 = z;\n else\n sw = sw | 1;\n }\n\n switch (sw) {\n case 0:\n break;\n\n case 1:\n CompMod(y2, y2, z, F);\n break;\n\n case 2:\n CompMod(y1, y1, z, F);\n break;\n\n case 3:\n Comp2Mod(y1, y2, y1, y2, z, F);\n break;\n\n case 4:\n CompMod(z, z, z, F);\n break;\n\n case 5:\n Comp2Mod(z, y2, z, y2, z, F);\n break;\n\n case 6:\n Comp2Mod(z, y1, z, y1, z, F);\n break;\n\n case 7:\n Comp3Mod(z, y1, y2, z, y1, y2, z, F);\n break;\n }\n\n q1 = q1 >> 1;\n q2 = q2 >> 1;\n }\n}\n\n\n\nstatic\nlong RecComputeDegree(long u, const GF2EX& h, const GF2EXModulus& F,\n FacVec& fvec)\n{\n if (IsX(h)) return 1;\n\n if (fvec[u].link == -1) return BaseCase(h, fvec[u].q, fvec[u].a, F);\n\n GF2EX h1, h2;\n long q1, q2, r1, r2;\n\n q1 = fvec[fvec[u].link].val; \n q2 = fvec[fvec[u].link+1].val;\n\n TandemPowerCompose(h1, h2, h, q1, q2, F);\n r1 = RecComputeDegree(fvec[u].link, h2, F, fvec);\n r2 = RecComputeDegree(fvec[u].link+1, h1, F, fvec);\n return r1*r2;\n}\n\n \n\n\nlong RecComputeDegree(const GF2EX& h, const GF2EXModulus& F)\n // f = F.f is assumed to be an \"equal degree\" polynomial\n // h = X^p mod f\n // the common degree of the irreducible factors of f is computed\n{\n if (F.n == 1 || IsX(h)) \n return 1;\n\n FacVec fvec;\n\n FactorInt(fvec, F.n);\n\n return RecComputeDegree(fvec.length()-1, h, F, fvec);\n}\n\n\nvoid FindRoot(GF2E& root, const GF2EX& ff)\n// finds a root of ff.\n// assumes that ff is monic and splits into distinct linear factors\n\n{\n GF2EXModulus F;\n GF2EX h, h1, f;\n GF2E r;\n\n f = ff;\n \n if (!IsOne(LeadCoeff(f)))\n Error(\"FindRoot: bad args\");\n\n if (deg(f) == 0)\n Error(\"FindRoot: bad args\");\n\n\n while (deg(f) > 1) {\n build(F, f);\n random(r);\n clear(h);\n SetCoeff(h, 1, r);\n TraceMap(h, h, F);\n GCD(h, h, f);\n if (deg(h) > 0 && deg(h) < deg(f)) {\n if (deg(h) > deg(f)/2)\n div(f, f, h);\n else\n f = h;\n }\n }\n \n root = ConstTerm(f);\n}\n\n\nstatic\nlong power(long a, long e)\n{\n long i, res;\n\n res = 1;\n for (i = 1; i <= e; i++)\n res = res * a;\n\n return res;\n}\n\n\nstatic\nlong IrredBaseCase(const GF2EX& h, long q, long a, const GF2EXModulus& F)\n{\n long e;\n GF2EX X, s, d;\n\n e = power(q, a-1);\n PowerCompose(s, h, e, F);\n SetX(X);\n add(s, s, X);\n GCD(d, F.f, s);\n return IsOne(d);\n}\n\n\nstatic\nlong RecIrredTest(long u, const GF2EX& h, const GF2EXModulus& F,\n const FacVec& fvec)\n{\n long q1, q2;\n GF2EX h1, h2;\n\n if (IsX(h)) return 0;\n\n if (fvec[u].link == -1) {\n return IrredBaseCase(h, fvec[u].q, fvec[u].a, F);\n }\n\n\n q1 = fvec[fvec[u].link].val; \n q2 = fvec[fvec[u].link+1].val;\n\n TandemPowerCompose(h1, h2, h, q1, q2, F);\n return RecIrredTest(fvec[u].link, h2, F, fvec) \n && RecIrredTest(fvec[u].link+1, h1, F, fvec);\n}\n\nlong DetIrredTest(const GF2EX& f)\n{\n if (deg(f) <= 0) return 0;\n if (deg(f) == 1) return 1;\n\n GF2EXModulus F;\n\n build(F, f);\n \n GF2EX h;\n\n FrobeniusMap(h, F);\n\n GF2EX s;\n PowerCompose(s, h, F.n, F);\n if (!IsX(s)) return 0;\n\n FacVec fvec;\n\n FactorInt(fvec, F.n);\n\n return RecIrredTest(fvec.length()-1, h, F, fvec);\n}\n\n\n\nlong IterIrredTest(const GF2EX& f)\n{\n if (deg(f) <= 0) return 0;\n if (deg(f) == 1) return 1;\n\n GF2EXModulus F;\n\n build(F, f);\n \n GF2EX h;\n\n FrobeniusMap(h, F);\n\n long CompTableSize = 2*SqrRoot(deg(f));\n\n GF2EXArgument H;\n\n build(H, h, F, CompTableSize);\n\n long i, d, limit, limit_sqr;\n GF2EX g, X, t, prod;\n\n\n SetX(X);\n\n i = 0;\n g = h;\n d = 1;\n limit = 2;\n limit_sqr = limit*limit;\n\n set(prod);\n\n\n while (2*d <= deg(f)) {\n add(t, g, X);\n MulMod(prod, prod, t, F);\n i++;\n if (i == limit_sqr) {\n GCD(t, f, prod);\n if (!IsOne(t)) return 0;\n\n set(prod);\n limit++;\n limit_sqr = limit*limit;\n i = 0;\n }\n\n d = d + 1;\n if (2*d <= deg(f)) {\n CompMod(g, g, H, F);\n }\n }\n\n if (i > 0) {\n GCD(t, f, prod);\n if (!IsOne(t)) return 0;\n }\n\n return 1;\n}\n\nstatic\nvoid MulByXPlusY(vec_GF2EX& h, const GF2EX& f, const GF2EX& g)\n// h represents the bivariate polynomial h[0] + h[1]*Y + ... + h[n-1]*Y^k,\n// where the h[i]'s are polynomials in X, each of degree < deg(f),\n// and k < deg(g).\n// h is replaced by the bivariate polynomial h*(X+Y) (mod f(X), g(Y)).\n\n{\n long n = deg(g);\n long k = h.length()-1;\n\n if (k < 0) return;\n\n if (k < n-1) {\n h.SetLength(k+2);\n h[k+1] = h[k];\n for (long i = k; i >= 1; i--) {\n MulByXMod(h[i], h[i], f);\n add(h[i], h[i], h[i-1]);\n }\n MulByXMod(h[0], h[0], f);\n }\n else {\n GF2EX b, t;\n\n b = h[n-1];\n for (long i = n-1; i >= 1; i--) {\n mul(t, b, g.rep[i]);\n MulByXMod(h[i], h[i], f);\n add(h[i], h[i], h[i-1]);\n add(h[i], h[i], t);\n }\n mul(t, b, g.rep[0]);\n MulByXMod(h[0], h[0], f);\n add(h[0], h[0], t);\n }\n\n // normalize\n\n k = h.length()-1;\n while (k >= 0 && IsZero(h[k])) k--;\n h.SetLength(k+1);\n}\n\n\nstatic\nvoid IrredCombine(GF2EX& x, const GF2EX& f, const GF2EX& g)\n{\n if (deg(f) < deg(g)) {\n IrredCombine(x, g, f);\n return;\n }\n\n // deg(f) >= deg(g)...not necessary, but maybe a little more\n // time & space efficient\n\n long df = deg(f);\n long dg = deg(g);\n long m = df*dg;\n\n vec_GF2EX h(INIT_SIZE, dg);\n\n long i;\n for (i = 0; i < dg; i++) h[i].SetMaxLength(df);\n\n h.SetLength(1);\n set(h[0]);\n\n vec_GF2E a;\n\n a.SetLength(2*m);\n\n for (i = 0; i < 2*m; i++) {\n a[i] = ConstTerm(h[0]);\n if (i < 2*m-1)\n MulByXPlusY(h, f, g);\n }\n\n MinPolySeq(x, a, m);\n}\n\n\nstatic\nvoid BuildPrimePowerIrred(GF2EX& f, long q, long e)\n{\n long n = power(q, e);\n\n do {\n random(f, n);\n SetCoeff(f, n);\n } while (!IterIrredTest(f));\n}\n\nstatic\nvoid RecBuildIrred(GF2EX& f, long u, const FacVec& fvec)\n{\n if (fvec[u].link == -1)\n BuildPrimePowerIrred(f, fvec[u].q, fvec[u].a);\n else {\n GF2EX g, h;\n RecBuildIrred(g, fvec[u].link, fvec);\n RecBuildIrred(h, fvec[u].link+1, fvec);\n IrredCombine(f, g, h);\n }\n}\n\n\nvoid BuildIrred(GF2EX& f, long n)\n{\n if (n <= 0)\n Error(\"BuildIrred: n must be positive\");\n\n if (NTL_OVERFLOW(n, 1, 0))\n Error(\"overflow in BuildIrred\");\n\n if (n == 1) {\n SetX(f);\n return;\n }\n\n FacVec fvec;\n\n FactorInt(fvec, n);\n\n RecBuildIrred(f, fvec.length()-1, fvec);\n}\n\n\n\n#if 0\nvoid BuildIrred(GF2EX& f, long n)\n{\n if (n <= 0)\n Error(\"BuildIrred: n must be positive\");\n\n if (NTL_OVERFLOW(n, 1, 0))\n Error(\"overflow in BuildIrred\");\n\n if (n == 1) {\n SetX(f);\n return;\n }\n\n GF2EX g;\n\n do {\n random(g, n);\n SetCoeff(g, n);\n } while (!IterIrredTest(g));\n\n f = g;\n\n}\n#endif\n\n\n\nvoid BuildRandomIrred(GF2EX& f, const GF2EX& g)\n{\n GF2EXModulus G;\n GF2EX h, ff;\n\n build(G, g);\n do {\n random(h, deg(g));\n IrredPolyMod(ff, h, G);\n } while (deg(ff) < deg(g));\n\n f = ff;\n}\n\n\n/************* NEW DDF ****************/\n\nlong GF2EX_GCDTableSize = 4;\nchar GF2EX_stem[256] = \"\";\n\ndouble GF2EXFileThresh = 256;\n\nstatic vec_GF2EX BabyStepFile;\nstatic vec_GF2EX GiantStepFile;\n\nstatic long use_files;\n\n\nstatic\ndouble CalcTableSize(long n, long k)\n{\n double sz = GF2E::storage();\n sz = sz * n;\n sz = sz + NTL_VECTOR_HEADER_SIZE + sizeof(vec_GF2E);\n sz = sz * k;\n sz = sz/1024;\n return sz;\n}\n\n\n\nstatic\nvoid GenerateBabySteps(GF2EX& h1, const GF2EX& f, const GF2EX& h, long k,\n long verbose)\n\n{\n double t;\n\n if (verbose) { cerr << \"generating baby steps...\"; t = GetTime(); }\n\n GF2EXModulus F;\n build(F, f);\n\n GF2EXArgument H;\n\n#if 0\n double n2 = sqrt(double(F.n));\n double n4 = sqrt(n2);\n double n34 = n2*n4;\n long sz = long(ceil(n34/sqrt(sqrt(2.0))));\n#else\n long sz = 2*SqrRoot(F.n);\n#endif\n\n build(H, h, F, sz);\n\n\n h1 = h;\n\n long i;\n\n long HexOutput = GF2X::HexOutput;\n GF2X::HexOutput = 1;\n\n if (!use_files) {\n BabyStepFile.kill();\n BabyStepFile.SetLength(k-1);\n }\n\n for (i = 1; i <= k-1; i++) {\n if (use_files) {\n ofstream s;\n OpenWrite(s, FileName(GF2EX_stem, \"baby\", i));\n s << h1 << \"\\n\";\n s.close();\n }\n else\n BabyStepFile(i) = h1;\n\n CompMod(h1, h1, H, F);\n if (verbose) cerr << \"+\";\n }\n\n if (verbose)\n cerr << (GetTime()-t) << \"\\n\";\n\n GF2X::HexOutput = HexOutput;\n}\n\n\nstatic\nvoid GenerateGiantSteps(const GF2EX& f, const GF2EX& h, long l, long verbose)\n{\n\n double t;\n\n if (verbose) { cerr << \"generating giant steps...\"; t = GetTime(); }\n\n GF2EXModulus F;\n build(F, f);\n\n GF2EXArgument H;\n\n#if 0\n double n2 = sqrt(double(F.n));\n double n4 = sqrt(n2);\n double n34 = n2*n4;\n long sz = long(ceil(n34/sqrt(sqrt(2.0))));\n#else\n long sz = 2*SqrRoot(F.n);\n#endif\n\n build(H, h, F, sz);\n\n GF2EX h1;\n\n h1 = h;\n\n long i;\n\n long HexOutput = GF2X::HexOutput; \n GF2X::HexOutput = 1;\n\n if (!use_files) {\n GiantStepFile.kill();\n GiantStepFile.SetLength(l);\n }\n\n for (i = 1; i <= l-1; i++) {\n if (use_files) {\n ofstream s;\n OpenWrite(s, FileName(GF2EX_stem, \"giant\", i));\n s << h1 << \"\\n\";\n s.close();\n }\n else\n GiantStepFile(i) = h1;\n\n CompMod(h1, h1, H, F);\n if (verbose) cerr << \"+\";\n }\n\n if (use_files) {\n ofstream s;\n OpenWrite(s, FileName(GF2EX_stem, \"giant\", i));\n s << h1 << \"\\n\";\n s.close();\n }\n else\n GiantStepFile(i) = h1;\n\n if (verbose)\n cerr << (GetTime()-t) << \"\\n\";\n\n GF2X::HexOutput = HexOutput;\n}\n\nstatic\nvoid FileCleanup(long k, long l)\n{\n if (use_files) {\n long i;\n \n for (i = 1; i <= k-1; i++)\n remove(FileName(GF2EX_stem, \"baby\", i));\n \n for (i = 1; i <= l; i++)\n remove(FileName(GF2EX_stem, \"giant\", i));\n }\n else {\n BabyStepFile.kill();\n GiantStepFile.kill();\n }\n}\n\n\nstatic\nvoid NewAddFactor(vec_pair_GF2EX_long& u, const GF2EX& g, long m, long verbose)\n{\n long len = u.length();\n\n u.SetLength(len+1);\n u[len].a = g;\n u[len].b = m;\n\n if (verbose) {\n cerr << \"split \" << m << \" \" << deg(g) << \"\\n\";\n }\n}\n\n \n\n\nstatic\nvoid NewProcessTable(vec_pair_GF2EX_long& u, GF2EX& f, const GF2EXModulus& F,\n vec_GF2EX& buf, long size, long StartInterval,\n long IntervalLength, long verbose)\n\n{\n if (size == 0) return;\n\n GF2EX& g = buf[size-1];\n\n long i;\n\n for (i = 0; i < size-1; i++)\n MulMod(g, g, buf[i], F);\n\n GCD(g, f, g);\n\n if (deg(g) == 0) return;\n\n div(f, f, g);\n\n long d = (StartInterval-1)*IntervalLength + 1;\n i = 0;\n long interval = StartInterval;\n\n while (i < size-1 && 2*d <= deg(g)) {\n GCD(buf[i], buf[i], g);\n if (deg(buf[i]) > 0) {\n NewAddFactor(u, buf[i], interval, verbose);\n div(g, g, buf[i]);\n }\n\n i++;\n interval++;\n d += IntervalLength;\n }\n\n if (deg(g) > 0) {\n if (i == size-1)\n NewAddFactor(u, g, interval, verbose);\n else\n NewAddFactor(u, g, (deg(g)+IntervalLength-1)/IntervalLength, verbose);\n }\n}\n\n\nstatic\nvoid FetchGiantStep(GF2EX& g, long gs, const GF2EXModulus& F)\n{\n if (use_files) {\n ifstream s;\n \n OpenRead(s, FileName(GF2EX_stem, \"giant\", gs));\n \n s >> g;\n s.close();\n }\n else\n g = GiantStepFile(gs);\n\n rem(g, g, F);\n}\n\n\nstatic\nvoid FetchBabySteps(vec_GF2EX& v, long k)\n{\n v.SetLength(k);\n\n SetX(v[0]);\n\n long i;\n for (i = 1; i <= k-1; i++) {\n if (use_files) {\n ifstream s;\n OpenRead(s, FileName(GF2EX_stem, \"baby\", i));\n s >> v[i];\n s.close();\n }\n else\n v[i] = BabyStepFile(i);\n }\n}\n \n\n\nstatic\nvoid GiantRefine(vec_pair_GF2EX_long& u, const GF2EX& ff, long k, long l,\n long verbose)\n\n{\n double t;\n\n if (verbose) {\n cerr << \"giant refine...\";\n t = GetTime();\n }\n\n u.SetLength(0);\n\n vec_GF2EX BabyStep;\n\n FetchBabySteps(BabyStep, k);\n\n vec_GF2EX buf(INIT_SIZE, GF2EX_GCDTableSize);\n\n GF2EX f;\n f = ff;\n\n GF2EXModulus F;\n build(F, f);\n\n GF2EX g;\n GF2EX h;\n\n long size = 0;\n\n long first_gs;\n\n long d = 1;\n\n while (2*d <= deg(f)) {\n\n long old_n = deg(f);\n\n long gs = (d+k-1)/k;\n long bs = gs*k - d;\n\n if (bs == k-1) {\n size++;\n if (size == 1) first_gs = gs;\n FetchGiantStep(g, gs, F);\n add(buf[size-1], g, BabyStep[bs]);\n }\n else {\n add(h, g, BabyStep[bs]);\n MulMod(buf[size-1], buf[size-1], h, F);\n }\n\n if (verbose && bs == 0) cerr << \"+\";\n\n if (size == GF2EX_GCDTableSize && bs == 0) {\n NewProcessTable(u, f, F, buf, size, first_gs, k, verbose);\n if (verbose) cerr << \"*\";\n size = 0;\n }\n\n d++;\n\n if (2*d <= deg(f) && deg(f) < old_n) {\n build(F, f);\n\n long i;\n for (i = 1; i <= k-1; i++) \n rem(BabyStep[i], BabyStep[i], F);\n }\n }\n\n if (size > 0) {\n NewProcessTable(u, f, F, buf, size, first_gs, k, verbose);\n if (verbose) cerr << \"*\";\n }\n\n if (deg(f) > 0) \n NewAddFactor(u, f, 0, verbose);\n\n if (verbose) {\n t = GetTime()-t;\n cerr << \"giant refine time: \" << t << \"\\n\";\n }\n}\n\n\nstatic\nvoid IntervalRefine(vec_pair_GF2EX_long& factors, const GF2EX& ff,\n long k, long gs, const vec_GF2EX& BabyStep, long verbose)\n\n{\n vec_GF2EX buf(INIT_SIZE, GF2EX_GCDTableSize);\n\n GF2EX f;\n f = ff;\n\n GF2EXModulus F;\n build(F, f);\n\n GF2EX g;\n\n FetchGiantStep(g, gs, F);\n\n long size = 0;\n\n long first_d;\n\n long d = (gs-1)*k + 1;\n long bs = k-1;\n\n while (bs >= 0 && 2*d <= deg(f)) {\n\n long old_n = deg(f);\n\n if (size == 0) first_d = d;\n rem(buf[size], BabyStep[bs], F);\n add(buf[size], buf[size], g);\n size++;\n\n if (size == GF2EX_GCDTableSize) {\n NewProcessTable(factors, f, F, buf, size, first_d, 1, verbose);\n size = 0;\n }\n\n d++;\n bs--;\n\n if (bs >= 0 && 2*d <= deg(f) && deg(f) < old_n) {\n build(F, f);\n rem(g, g, F);\n }\n }\n\n NewProcessTable(factors, f, F, buf, size, first_d, 1, verbose);\n\n if (deg(f) > 0) \n NewAddFactor(factors, f, deg(f), verbose);\n}\n \n\n\n\nstatic\nvoid BabyRefine(vec_pair_GF2EX_long& factors, const vec_pair_GF2EX_long& u,\n long k, long l, long verbose)\n\n{\n double t;\n\n if (verbose) {\n cerr << \"baby refine...\";\n t = GetTime();\n }\n\n factors.SetLength(0);\n\n vec_GF2EX BabyStep;\n\n long i;\n for (i = 0; i < u.length(); i++) {\n const GF2EX& g = u[i].a;\n long gs = u[i].b;\n\n if (gs == 0 || 2*((gs-1)*k+1) > deg(g))\n NewAddFactor(factors, g, deg(g), verbose);\n else {\n if (BabyStep.length() == 0)\n FetchBabySteps(BabyStep, k);\n IntervalRefine(factors, g, k, gs, BabyStep, verbose);\n }\n }\n\n if (verbose) {\n t = GetTime()-t;\n cerr << \"baby refine time: \" << t << \"\\n\";\n }\n}\n\n \n \n\n \n\nvoid NewDDF(vec_pair_GF2EX_long& factors,\n const GF2EX& f,\n const GF2EX& h,\n long verbose)\n\n{\n if (!IsOne(LeadCoeff(f)))\n Error(\"NewDDF: bad args\");\n\n if (deg(f) == 0) {\n factors.SetLength(0);\n return;\n }\n\n if (deg(f) == 1) {\n factors.SetLength(0);\n append(factors, cons(f, 1L));\n return;\n }\n\n if (!GF2EX_stem[0])\n sprintf(GF2EX_stem, \"ddf-%ld\", RandomBnd(10000));\n \n long B = deg(f)/2;\n long k = SqrRoot(B);\n long l = (B+k-1)/k;\n\n GF2EX h1;\n\n if (CalcTableSize(deg(f), k + l - 1) > GF2EXFileThresh)\n use_files = 1;\n else\n use_files = 0;\n\n GenerateBabySteps(h1, f, h, k, verbose);\n\n GenerateGiantSteps(f, h1, l, verbose);\n\n vec_pair_GF2EX_long u;\n GiantRefine(u, f, k, l, verbose);\n BabyRefine(factors, u, k, l, verbose);\n\n FileCleanup(k, l);\n}\n\nlong IterComputeDegree(const GF2EX& h, const GF2EXModulus& F)\n{\n long n = deg(F);\n\n if (n == 1 || IsX(h)) return 1;\n\n long B = n/2;\n long k = SqrRoot(B);\n long l = (B+k-1)/k;\n\n\n GF2EXArgument H;\n\n#if 0\n double n2 = sqrt(double(n));\n double n4 = sqrt(n2);\n double n34 = n2*n4;\n long sz = long(ceil(n34/sqrt(sqrt(2.0))));\n#else\n long sz = 2*SqrRoot(F.n);\n#endif\n\n build(H, h, F, sz);\n\n GF2EX h1;\n h1 = h;\n\n vec_GF2EX baby;\n baby.SetLength(k);\n\n SetX(baby[0]);\n\n long i;\n\n for (i = 1; i <= k-1; i++) {\n baby[i] = h1;\n CompMod(h1, h1, H, F);\n if (IsX(h1)) return i+1;\n }\n\n build(H, h1, F, sz);\n\n long j;\n\n for (j = 2; j <= l; j++) {\n CompMod(h1, h1, H, F);\n\n for (i = k-1; i >= 0; i--) {\n if (h1 == baby[i])\n return j*k-i;\n }\n }\n\n return n;\n}\n\nNTL_END_IMPL\n", "meta": {"hexsha": "b4798c1f6f3fcd4cee5c5e928798aad94774a658", "size": 37695, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/ntl/GF2EXFactoring.cpp", "max_stars_repo_name": "av-elier/fast-exponentiation-algs", "max_stars_repo_head_hexsha": "1d6393021583686372564a7ca52b09dc7013fb38", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2016-10-17T20:30:05.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-24T19:52:14.000Z", "max_issues_repo_path": "src/ntl/GF2EXFactoring.cpp", "max_issues_repo_name": "av-elier/fast-exponentiation-algs", "max_issues_repo_head_hexsha": "1d6393021583686372564a7ca52b09dc7013fb38", "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/ntl/GF2EXFactoring.cpp", "max_forks_repo_name": "av-elier/fast-exponentiation-algs", "max_forks_repo_head_hexsha": "1d6393021583686372564a7ca52b09dc7013fb38", "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": 17.1966240876, "max_line_length": 82, "alphanum_fraction": 0.4735376045, "num_tokens": 13318, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8397339756938819, "lm_q2_score": 0.6477982315512489, "lm_q1q2_score": 0.5439781844279962}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n/* #include */\n#include \n\n#include \n#include \n\n#include \"nanoflann.hpp\"\n\nusing Vector3f = Eigen::Vector3f;\nusing Transform = Eigen::Isometry3f;\nusing Cloud = Eigen::MatrixX3f;\n\nCloud TransformPointCloud(const Cloud& source_cloud,\n const Transform& transform)\n{\n // TODO(yycho0108): implement\n Cloud out(source_cloud.rows(), source_cloud.cols());\n for (int i = 0; i < source_cloud.rows(); ++i) {\n out.row(i).transpose() = transform * source_cloud.row(i).transpose();\n }\n return out;\n}\n\n//template \n//struct TXTYTZRZParametrization {\n// static const std::size_t Dimensions = 4;\n// Eigen::Matrix ApplyTransform(const Eigen::Matrix& point);\n// void FromTransform(const Transform&);\n// Transform ToTransform();\n//};\n\nstatic constexpr const int kParamSize = 4;\ntemplate \nstruct ParametrizedIsometryCost : public Eigen::DenseFunctor {\n ParametrizedIsometryCost(const Cloud& source, const Cloud& target)\n : Eigen::DenseFunctor(kParamSize, source.size())\n , source_(source)\n , target_(target)\n {\n }\n\n template \n int operator()(const Eigen::Matrix& parameter,\n Eigen::Matrix& fvec) const\n {\n const Eigen::Matrix& translation = parameter.template head<3>();\n //const Eigen::Matrix& rvec = parameter.template tail<3>();\n //const T1 angle = rvec.norm();\n //const Eigen::AngleAxis& rotation{angle, rvec / angle};\n //Eigen::Quaternion rotation;\n const Eigen::AngleAxis& rotation{ parameter(3), Eigen::Matrix{ 0, 0, 1 } };\n\n for (int i = 0; i < source_.rows(); ++i) {\n //fvec.segment(i * 3, 3) = source_.row(i).template cast() + translation.transpose() - target_.row(i).template cast();\n fvec.segment(i * 3, 3) = (rotation * source_.row(i).template cast().transpose()).transpose() + translation.transpose() - target_.row(i).template cast();\n }\n return 0;\n //// Set to simpler version for now.\n // Eigen::Transform transform;\n // transform.translation() = translation;\n\n //// Will this work?\n // std::cout << \"here1\" << std::endl;\n // auto transformed = (transform.linear() * source_.transpose().template\n // cast()).transpose();\n ///* transformed.rowwise() += transform.translation().transpose(); */\n // std::cout << \"here2\" << std::endl;\n // Eigen::Matrix delta = (transformed -\n // target_).template cast(); std::cout << \"here2.5\" << std::endl; if\n // (!(delta.Flags & Eigen::RowMajorBit)) {\n // // 3xN memory layout -> Nx3 memory layout\n // Eigen::Matrix data = delta.transpose();\n // Eigen::Map> rhs(data.data(),\n // fvec.rows(), 1);\n // fvec.segment(0, fvec.rows()) = rhs;\n //} else {\n // Eigen::Map> rhs(delta.data(),\n // fvec.rows(), 1);\n // fvec.segment(0, fvec.rows()) = rhs;\n //}\n ////std::cout << \"here3\" << std::endl;\n ////std::cout << delta.rows() << 'x' << delta.cols() << std::endl;\n ////std::cout << fvec.rows() << 'x' << fvec.cols() << std::endl;\n ////std::cout << rhs.rows() << 'x' << rhs.cols() << std::endl;\n ////fvec = rhs;\n // return 0;\n };\n\n int df(const Eigen::Matrix& parameter,\n Eigen::MatrixXf& jac) const\n {\n using Scalar = Eigen::AutoDiffScalar;\n using ScalarVector = Eigen::Matrix;\n ScalarVector ax = parameter.template cast();\n ScalarVector av(this->values());\n\n for (int j = 0; j < this->values(); ++j) {\n av[j].derivatives().resize(this->inputs());\n }\n for (int i = 0; i < this->inputs(); ++i) {\n ax[i].derivatives().resize(this->inputs());\n ax[i].derivatives().setZero();\n ax[i].derivatives()(i) = 1.0;\n //ax[i].derivatives() = Eigen::Vector3f::Unit(this->inputs(), i);\n //ax[i].derivatives().resize(this->inputs());\n }\n\n operator()(ax, av);\n\n // jac = (48x3)\n for (int i = 0; i < this->values(); ++i) {\n // std::cout << \"==\" << std::endl;\n // std::cout << jac.row(i).rows() << std::endl; // 1\n // std::cout << jac.row(i).cols() << std::endl; // 3\n // std::cout << av[i].derivatives().rows() << std::endl; // 0\n // std::cout << av[i].derivatives().cols() << std::endl; // 1\n jac.row(i) = av[i].derivatives();\n }\n }\n const Cloud& source_;\n const Cloud& target_;\n /* IsometryCost cost; */\n};\n\n/**\n * Generalized ICP implementation, based on\n * \"Generalized-ICP\" Segal et al.\n * www.roboticsproceedings.org/rss05/p21.pdf\n */\nclass GeneralizedICP {\npublic:\n using KDTree = nanoflann::KDTreeEigenMatrixAdaptor;\n\n GeneralizedICP()\n : source(nullptr)\n , target(nullptr)\n {\n }\n void SetSourceCloud(const Cloud& source_cloud)\n {\n source = &source_cloud;\n /* source_tree = std::make_shared(3, std::cref(source_cloud),\n * 10); */\n /* source_tree->index->buildIndex(); */\n }\n void SetTargetCloud(const Cloud& target_cloud)\n {\n target = &target_cloud;\n target_tree = std::make_shared(3, std::cref(target_cloud), 10);\n target_tree->index->buildIndex();\n }\n\n void FindCorrespondences(const Cloud& source,\n std::vector* indices,\n std::vector* squared_distances)\n {\n // Reset memory.\n indices->clear();\n squared_distances->clear();\n indices->reserve(source.rows());\n squared_distances->reserve(source.rows());\n\n // Temps\n std::vector knn_indices(5);\n std::vector knn_squared_distances(5);\n\n for (int i = 0; i < source.rows(); ++i) {\n const Vector3f& query_point = source.row(i);\n /* fmt::print(\"query {}\\n\", query_point.transpose()); */\n /* const float* check = reinterpret_cast(query_point.data()); */\n /* fmt::print(\"check {} {} {}\\n\", check[0], check[1], check[2]); */\n bool suc = target_tree->index->knnSearch(reinterpret_cast(query_point.data()), 1,\n &knn_indices[0], &knn_squared_distances[0]);\n if (!suc) {\n fmt::print(\"unsuccessful\");\n exit(1);\n }\n /* fmt::print(\"{},\", knn_indices[0]); */\n\n indices->emplace_back(knn_indices[0]);\n squared_distances->emplace_back(knn_squared_distances[0]);\n }\n }\n\n float TransformCost(const Cloud& source, const Cloud& target,\n const Transform& transform)\n {\n // Nx3 = (3x3?) * (3xN)\n const Cloud& target_ = (transform * source.transpose()).transpose();\n const Cloud& delta = target - target_;\n\n /* delta = b - Ta */\n const Eigen::Matrix3f& R = transform.rotation();\n\n float total_cost{ 0 };\n for (int i = 0; i < source.rows(); ++i) {\n const Vector3f& d = delta.row(i);\n const float cost = d.transpose() * R * Eigen::Matrix3f::Identity() * R.transpose() * d;\n total_cost += cost;\n }\n return total_cost;\n }\n\n Transform OptimizeTransform(const Cloud& a, const Cloud& b, const Transform& seed = Transform::Identity())\n {\n // Initialize system.\n ParametrizedIsometryCost cost_fun{ a, b };\n Eigen::LevenbergMarquardt> lm{ cost_fun };\n\n // Apply parametrization.\n Eigen::Matrix param(4, 1);\n param.head<3>() = seed.translation();\n param(3) = Eigen::AngleAxis{ seed.rotation() }.angle();\n\n // Run Optimization.\n lm.minimize(param);\n\n // Extract output and return.\n Transform out = Transform::Identity();\n out.translation() = param.head<3>();\n out.linear() = Eigen::AngleAxis{ param(3), Eigen::Vector3f{ 0, 0, 1 } }.toRotationMatrix();\n return out;\n }\n\n Transform ComputeTransform()\n {\n static constexpr const float kTransformEpsilon = 0.001;\n static constexpr const float kRotationEpsilon = 0.001;\n static constexpr const float kMaxIterations = 100;\n\n Cloud tmp = *source;\n Transform transform = Transform::Identity();\n std::vector target_indices;\n std::vector squared_distances;\n\n bool converged = false;\n for (int count = 0; count < kMaxIterations; ++count) {\n FindCorrespondences(tmp, &target_indices, &squared_distances);\n for (std::size_t i = 0; i < source->rows(); ++i) {\n const std::size_t& source_index = i;\n const std::size_t& target_index = target_indices[i];\n const float& squared_distance = squared_distances[i];\n //fmt::print(\"{} {} {}\\n\", source_index, target_index,\n // squared_distance);\n }\n\n // Make a copy for now. FIXME(yycho0108): better indexing scheme\n // const Cloud& X = target(target_indices, Eigen::internal::all);\n Cloud tmp_target(tmp.rows(), tmp.cols());\n for (std::size_t i = 0; i < source->rows(); ++i) {\n tmp_target.row(i) = target->row(target_indices[i]);\n }\n\n Transform target_from_tmp = OptimizeTransform(tmp, tmp_target);\n if (target_from_tmp.translation().squaredNorm() < kTransformEpsilon\n && std::abs(std::acos(0.5 * (target_from_tmp.linear().trace() - 1.0))) < kRotationEpsilon) {\n converged = true;\n break;\n }\n tmp = TransformPointCloud(tmp, target_from_tmp);\n transform = target_from_tmp * transform;\n\n ++count;\n }\n fmt::print(\"Converged : {}\\n\", bool(converged));\n return transform;\n }\n\n const Cloud *source, *target;\n /* std::shared_ptr source_tree; */\n std::shared_ptr target_tree;\n};\n\nint main()\n{\n Transform ground_truth_transform = Transform::Identity();\n ground_truth_transform.translation() = Eigen::Vector3f{ 0.2, 0.2, 0.3 };\n ground_truth_transform.linear() = Eigen::AngleAxisf(0.1, Eigen::Vector3f{ 0., 0., 1. }).toRotationMatrix();\n\n Cloud source_cloud = Cloud::Zero(16, 3);\n source_cloud.setRandom();\n\n Cloud target_cloud = Cloud::Zero(17, 3);\n //target_cloud.block<16, 3>(0, 0) = source_cloud;\n target_cloud.block<16, 3>(0, 0) = TransformPointCloud(source_cloud, ground_truth_transform);\n\n /* fmt::print(\"{} vs {}\", source_cloud.row(0), target_cloud.row(0)); */\n\n GeneralizedICP gicp;\n gicp.SetSourceCloud(source_cloud);\n gicp.SetTargetCloud(target_cloud);\n const Transform& estimated_transform = gicp.ComputeTransform();\n\n fmt::print(\"ground truth : \\n{}\\n\", ground_truth_transform.matrix());\n fmt::print(\"computed : \\n{}\\n\", estimated_transform.matrix());\n return 0;\n}\n", "meta": {"hexsha": "8318bf1943c7cb95373725ab8bcbf31df8149a78", "size": 11659, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "main.cpp", "max_stars_repo_name": "yycho0108/GeneralizedICP", "max_stars_repo_head_hexsha": "c4f6202802ac8341832dbcf69981a456e6765e1b", "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": "main.cpp", "max_issues_repo_name": "yycho0108/GeneralizedICP", "max_issues_repo_head_hexsha": "c4f6202802ac8341832dbcf69981a456e6765e1b", "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": "main.cpp", "max_forks_repo_name": "yycho0108/GeneralizedICP", "max_forks_repo_head_hexsha": "c4f6202802ac8341832dbcf69981a456e6765e1b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-08-19T09:15:29.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-19T09:15:29.000Z", "avg_line_length": 38.3519736842, "max_line_length": 172, "alphanum_fraction": 0.5760356806, "num_tokens": 2999, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8397339676722393, "lm_q2_score": 0.6477982247516797, "lm_q1q2_score": 0.543978173521761}} {"text": "#include \n#include \n#include \n#include \n\n#include \"ransac.h\"\n\nusing namespace std;\n\nRansac::Ransac(int n_iterations, double threshold): n_iterations(n_iterations),\n threshold(threshold)\n{ // Seed the generator\n generator.seed(rd());\n};\n\ndouble Ransac::mahalanobis_distance(const point3d& X, const point3d& A, const point3d& B,\n const Eigen::Vector3d& D, const Eigen::Matrix3d& U)\n{\n // Apply affine transform to points\n Eigen::Vector3d A_affine = ((D.array().inverse()).sqrt()).matrix().asDiagonal() * U.transpose() * (A - X);\n Eigen::Vector3d B_affine = ((D.array().inverse()).sqrt()).matrix().asDiagonal() * U.transpose() * (B - X);\n\n double distance = A_affine.cross(B_affine).norm()/(A_affine - B_affine).norm();\n\n return distance;\n}\n\nEigen::Matrix3Xd Ransac::removeOutlierPoints(const Eigen::Matrix3Xd& linepoints, const std::vector& eig_val,\n const std::vector& eig_vector, std::vector& updated_covariance,\n std::vector& updated_inv_root_covariance, const std::vector& cov_G,\n const std::vector& inv_cov_G)\n{\n Eigen::Matrix3Xd best_inliers;\n int best_num_inliers = -1;\n float distance;\n\n // solace in not copying this over and over\n std::shared_ptr> ptr_to_best_inlier_indices = NULL;\n \n // Setup the range from which we choose random numbers\n std::uniform_int_distribution distribution(0,linepoints.cols()-1); // end inclusive\n \n for(int iter=0; iter < n_iterations; ++iter){\n int inliers = 0;\n auto ptr_to_inlier_indices = std::make_shared>();\n\n // re-generate i and j randomly until they are not equal\n int i = distribution(generator), j = distribution(generator);\n while(i == j){\n i = distribution(generator), j = distribution(generator);\n }\n \n Eigen::Matrix3Xd support_points(3, linepoints.cols());\n Eigen::Vector3d A = linepoints.col(i), B = linepoints.col(j);\n\n // calculate support for chosen endpoint indices\n for(int k=0; k < linepoints.cols(); ++k){\n distance = mahalanobis_distance(linepoints.col(k), A, B, eig_val[k], eig_vector[k]);\n // cout << distance << endl;\n if (distance < threshold){\n support_points.col(inliers++) = linepoints.col(k);\n ptr_to_inlier_indices->push_back(k);\n }\n\n }\n\n if(inliers > best_num_inliers){\n best_num_inliers = inliers;\n best_inliers = support_points.leftCols(inliers);\n ptr_to_best_inlier_indices = ptr_to_inlier_indices;\n }\n }\n\n // Take the indices of new covariances and populate updated covariances\n // Very slow - refactor to deal with indices/pointers instead of copying over data\n for(auto i: *ptr_to_best_inlier_indices){\n updated_covariance.push_back(cov_G[i]);\n updated_inv_root_covariance.push_back(inv_cov_G[i]);\n }\n \n return best_inliers;\n}\n", "meta": {"hexsha": "9089d1083be4b06a15218bceb1aef78291c53dc9", "size": 3316, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/ransac.cpp", "max_stars_repo_name": "SubramanianKrish/roblineVO", "max_stars_repo_head_hexsha": "9c977c63cc02e8a3a9e42dfa8bae77198f5347f7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-09-09T08:28:48.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-09T08:28:48.000Z", "max_issues_repo_path": "src/ransac.cpp", "max_issues_repo_name": "SubramanianKrish/roblineVO", "max_issues_repo_head_hexsha": "9c977c63cc02e8a3a9e42dfa8bae77198f5347f7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2020-10-11T07:00:50.000Z", "max_issues_repo_issues_event_max_datetime": "2020-10-11T07:00:50.000Z", "max_forks_repo_path": "src/ransac.cpp", "max_forks_repo_name": "SubramanianKrish/roblineVO", "max_forks_repo_head_hexsha": "9c977c63cc02e8a3a9e42dfa8bae77198f5347f7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-06-01T11:55:45.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-12T19:24:46.000Z", "avg_line_length": 39.9518072289, "max_line_length": 146, "alphanum_fraction": 0.619119421, "num_tokens": 774, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8397339756938819, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5439781730083374}} {"text": "# include \n// [[ Rcpp :: depends ( RcppArmadillo )]]\nusing namespace Rcpp;\n\n//######################################################################################################################//\n\n\n//' @title ECDF transformation of the training data\n//'\n//' @description Quadrianto and Ghahramani (2015) reccomend the use of the probability intergral transform to transform the continuous input features. The code is edited from https://github.com/dmbates/ecdfExample\n//' @param originaldata Training data matrix\n// [[Rcpp::depends(RcppArmadillo)]]\n//' @export\n// [[Rcpp::export]]\nNumericMatrix cpptrans_cdf(NumericMatrix originaldata){\n NumericMatrix transformedData(originaldata.nrow(), originaldata.ncol());\n for(int i=0; i output_dyck, long length) {\n long height = 0;\n long local_height = 0;\n int x = 1;\n\n for(long i = 0; i < length; i ++) {\n int y = output_dyck[p_ind+i];\n local_height += y;\n if(local_height < 0) {\n y = 1;\n height += 2;\n local_height = 0;\n }\n output_dyck[p_ind+i] = x;\n x = y;\n }\n\n return height;\n}\n\n\n\n//######################################################################################################################//\n// turns a Dyck prefix into a Dyck path of length -1 (length should be odd)\n// [[Rcpp::export]]\nvoid fold(std::vector output_dyck, long length, long height) {\n long local_height = 0;\n int x = -1;\n // Rcout << \"Line 121. \\n\";\n // Rcout << \"output_dyck.size() =\" << output_dyck.size() << \". \\n\";\n // Rcout << \"length - 1 =\" << length - 1 << \". \\n\";\n\n\n for(long i = length - 1; height > 0; i --) {\n int y = output_dyck[i];\n local_height -= y;\n if(local_height < 0) {\n y = -1;\n height -= 2;\n local_height = 0;\n }\n output_dyck[i] = x;\n x = y;\n }\n // Rcout << \"Line 134. \\n\";\n\n}\n\n// // writes a random Dyck prefix, returns its final height\n// // at least length bytes should be allocated first\n// long dyck_prefix(signed char *p, long length) {\n// long height = 0;\n//\n// for(long i = 0; i < length; i ++) {\n// signed char x = random_int(1) ? 1 : -1;\n// p[i] = x;\n// height += x;\n//\n// if(height < 0) {\n// long j = random_int(i);\n// height += unfold(p + j, i + 1 - j);\n// }\n// }\n//\n// return height;\n// }\n\n\n\n\n\n\n//######################################################################################################################//\n// wrleast length + 1 bytes should be allocated first\n// [[Rcpp::deites a random Dyck path (length should be even)\n// at pends(RcppArmadillo)]]\n// [[Rcpp::depends(dqrng, BH, sitmo)]]\n\n#include \n#include \n//#include \n\n// [[Rcpp::export]]\nvoid dyck_path(std::vector output_dyck, long length) {\n //long height = dyck_prefix(p, length + 1);\n // Rcout << \"Line 172. \\n\";\n\n //std::vector p(length);\n //std::vector p(length);\n //char p;\n //signed char p;// = new signed char[length];\n int p_ind=0;\n\n std::random_device device;\n //std::mt19937 gen(device());\n\n //possibly use seed?\n //// std::mt19937 gen(seed);\n\n dqrng::xoshiro256plus gen(device()); // properly seeded rng\n\n //dqrng::xoshiro256plus gen(seed); // properly seeded rng\n\n std::bernoulli_distribution coin_flip_evev(0.5);\n\n\n long height = 0;\n\n // Rcout << \"Line 195. \\n\";\n\n for(long i = 0; i < length+1; i ++) {\n //signed char x = random_int(1) ? 1 : -1;\n int x = coin_flip_evev(gen) ? 1 : -1;\n output_dyck[i] = x;\n height += x;\n\n if(height < 0) {\n // this should return a uniform random integer between 0 and x\n //unsigned long random_int(unsigned long x);\n std::uniform_int_distribution<> random_int(0, i);\n long j = random_int(gen);\n //long j = random_int(i);\n height += unfold(p_ind + j,output_dyck, i + 1 - j);\n }\n }\n\n // Rcout << \"Line 213. \\n\";\n\n\n //fold(output_dyck, length + 1, height);\n long local_height = 0;\n int x = -1;\n // Rcout << \"Line 121. \\n\";\n // Rcout << \"output_dyck.size() =\" << output_dyck.size() << \". \\n\";\n // Rcout << \"length - 1 =\" << length - 1 << \". \\n\";\n\n\n for(long i = length; height > 0; i --) {\n int y = output_dyck[i];\n local_height -= y;\n if(local_height < 0) {\n y = -1;\n height -= 2;\n local_height = 0;\n }\n output_dyck[i] = x;\n x = y;\n }\n // Rcout << \"Line 134. \\n\";\n\n\n // Rcout << \"Line 217. \\n\";\n\n}\n\n\n\n//######################################################################################################################//\n// wrleast length + 1 bytes should be allocated first\n// [[Rcpp::deites a random Dyck path (length should be even)\n// at pends(RcppArmadillo)]]\n// [[Rcpp::depends(dqrng, BH, sitmo)]]\n\n#include \n#include \n//#include \n\n//' @description Test draw of trees of given length\n//' @export\n// [[Rcpp::export]]\nIntegerVector wrapper_dyck_path(long length) {\n //signed char *p;\n //p=&output_dyck[0];\n //int p_ind=0;\n //Rcout << \"Line 235. \\n\";\n //dyck_path(output_dyck,length);\n\n\n //long height = dyck_prefix(p, length + 1);\n //Rcout << \"Line 172. \\n\";\n\n //std::vector p(length);\n //std::vector p(length);\n //char p;\n //signed char p;// = new signed char[length];\n\n static std::random_device device;\n static std::mt19937 gen(device());\n\n //possibly use seed?\n //// std::mt19937 gen(seed);\n\n //static dqrng::xoshiro256plus gen(device()); // properly seeded rng\n\n //dqrng::xoshiro256plus gen(seed); // properly seeded rng\n\n std::bernoulli_distribution coin_flip_evev(0.5);\n\n\n std::vector output_dyck(length+1);\n int p_ind=0;\n long height = 0;\n\n //Rcout << \"Line 195. \\n\";\n\n for(long i = 0; i < length+1; i ++) {\n //signed char x = random_int(1) ? 1 : -1;\n int x = coin_flip_evev(gen) ? 1 : -1;\n output_dyck[i] = x;\n height += x;\n\n if(height < 0) {\n // this should return a uniform random integer between 0 and x\n //unsigned long random_int(unsigned long x);\n std::uniform_int_distribution<> random_int(0, i);\n long j = random_int(gen);\n //long j = random_int(i);\n //height += unfold(p_ind + j,output_dyck, i + 1 - j);\n\n long length1=i+1-j;\n long height1 = 0;\n long local_height = 0;\n int x = 1;\n\n for(long i = 0; i < length1; i ++) {\n int y = output_dyck[p_ind+j+i];\n local_height += y;\n if(local_height < 0) {\n y = 1;\n height1 += 2;\n local_height = 0;\n }\n output_dyck[p_ind+j+i] = x;\n x = y;\n }\n height +=height1;\n\n\n\n\n }\n }\n\n //Rcout << \"Line 213. \\n\";\n\n\n //fold(output_dyck, length + 1, height);\n long local_height = 0;\n int x = -1;\n //Rcout << \"Line 121. \\n\";\n //Rcout << \"output_dyck.size() =\" << output_dyck.size() << \". \\n\";\n //Rcout << \"length - 1 =\" << length - 1 << \". \\n\";\n\n\n for(long i = length; height > 0; i --) {\n int y = output_dyck[i];\n local_height -= y;\n if(local_height < 0) {\n y = -1;\n height -= 2;\n local_height = 0;\n }\n output_dyck[i] = x;\n x = y;\n }\n //Rcout << \"Line 134. \\n\";\n\n\n //Rcout << \"Line 217. \\n\";\n\n //Rcout << \"Line 238. \\n\";\n std::replace (output_dyck.begin(), output_dyck.end(), -1, 0); // 10 99 30 30 99 10 10 99\n\n return(wrap(output_dyck));\n\n}\n//######################################################################################################################//\n\n// [[Rcpp::depends(RcppArmadillo)]]\n// [[Rcpp::export]]\n\nNumericVector find_term_nodes(NumericMatrix tree_table){\n arma::mat arma_tree(tree_table.begin(),tree_table.nrow(), tree_table.ncol(), false);\n\n //arma::vec colmat=arma_tree.col(4);\n //arma::uvec term_nodes=arma::find(colmat==-1);\n\n //arma::vec colmat=arma_tree.col(2);\n //arma::uvec term_nodes=arma::find(colmat==0);\n\n arma::vec colmat=arma_tree.col(4);\n arma::uvec term_nodes=arma::find(colmat==0);\n\n term_nodes=term_nodes+1;\n\n return(wrap(term_nodes));\n}\n\n//######################################################################################################################//\n\n#include /* tgamma */\n// [[Rcpp::depends(RcppArmadillo)]]\n// [[Rcpp::export]]\n\nList get_treepreds(NumericVector original_y, int num_cats, NumericVector alpha_pars,\n NumericMatrix originaldata, //NumericMatrix test_data,\n NumericMatrix treetable//, NumericMatrix tree_data\n) {\n // Function to make predictions from test data, given a single tree and the terminal node predictions, this function will be called\n //for each tree accepted in Occam's Window.\n\n //test_data is a nxp matrix with the same variable names as the training data the model was built on\n\n //tree_data is the tree table with the tree information i.e. split points and split variables and terminal node mean values\n\n //term_node_means is a vector storing the terminal node mean values\n arma::vec orig_y_arma= as(original_y);\n arma::vec alpha_pars_arma= as(alpha_pars);\n\n double lik_prod=1;\n double alph_prod=1;\n for(unsigned int i=0; i(terminal_nodes);\n //NumericVector tree_predictions;\n\n //now for each internal node find the observations that belong to the terminal nodes\n\n //NumericVector predictions(test_data.nrow());\n //List term_obs(terminal_nodes.size());\n\n if(terminal_nodes.size()==1){\n //double nodemean=tree_data(terminal_nodes[0]-1,5);\t\t\t\t// let nodemean equal tree_data row terminal_nodes[i]^th row , 6th column. The minus 1 is because terminal nodes consists of indices starting at 1, but need indices to start at 0.\n //predictions=rep(nodemean,test_data.nrow());\n //Rcout << \"Line 67 .\\n\";\n\n //IntegerVector temp_obsvec = seq_len(test_data.nrow())-1;\n //term_obs[0]= temp_obsvec;\n double denom_temp= orig_y_arma.n_elem+arma::sum(alpha_pars_arma);\n\n double num_prod=1;\n double num_sum=0;\n //Rcout << \"Line 129.\\n\";\n\n for(int k=0; k temp_split);\n }\n //Rcout << \"Line 236.\\n\";\n\n arma::uvec temp_pred_indices;\n\n //arma::vec data_subset = testd.col(split);\n arma::vec data_subset = arma_orig_data.col(split);\n\n data_subset=data_subset.elem(pred_indices);\n\n //now loop through each row of node_split_mat\n int n=node_split_mat.n_rows;\n //Rcout << \"Line 174. i = \" << i << \". n = \" << n << \".\\n\";\n //Rcout << \"Line 248.\\n\";\n\n for(int j=1;j split_p);\n }\n pred_indices=pred_indices.elem(temp_pred_indices);\n\n if(pred_indices.size()==0){\n continue;\n }\n\n }\n //Rcout << \"Line 199. i = \" << i << \".\\n\";\n\n //double nodemean=tree_data(terminal_nodes[i]-1,5);\n //IntegerVector predind=as(wrap(pred_indices));\n //predictions[predind]= nodemean;\n //term_obs[i]=predind;\n\n double denom_temp= pred_indices.n_elem+arma::sum(alpha_pars_arma);\n //Rcout << \"Line 207. predind = \" << predind << \".\\n\";\n //Rcout << \"Line 207. denom_temp = \" << denom_temp << \".\\n\";\n // << \"Line 207. term_node = \" << term_node << \".\\n\";\n\n double num_prod=1;\n double num_sum=0;\n\n for(int k=0; k(s)){\n //if current set of trees contains more than one tree...usually does!\n //List sum_tree=treetable_list[i];\n\n //save all info in list of list format the same as the trees.\n //List term_nodes_trees(sum_tree.size());\n //List term_obs_trees(sum_tree.size());\n //NumericMatrix predictions(num_obs,sum_tree.size());\n\n // for(int k=0;k(treepred_output[1]);\n overall_liks[i]= pow(templik,beta_pow);\n\n\n\n //overall_term_nodes_trees[i]=term_nodes_trees;\n //overall_term_obs_trees[i]= term_obs_trees;\n //overall_predictions[i]=predictions;\n }else{\n // NumericMatrix sum_tree=overall_sum_trees[i];\n // List tree_info=get_termobs_test_data(test_data, sum_tree) ;\n // //overall_term_nodes_trees[i]=tree_info[0];\n // List term_obs_trees(1);\n // term_obs_trees[0]=tree_info ;\n // //NumericVector term_preds=tree_info[2];\n // //NumericVector predictions=term_preds;\n // overall_term_obs_trees[i]= term_obs_trees;\n // //overall_predictions[i]=predictions;\n //\n\n //overall_treetables[i]=get_treepreds(original_y, num_cats, alpha_pars,\n // originaldata,\n // treetable_list[i] );\n\n\n List treepred_output = get_treepreds(original_y, num_cats, alpha_pars,\n originaldata,\n treetable_list[i] );\n\n overall_treetables[i]= treepred_output[0];\n double templik = as(treepred_output[1]);\n overall_liks[i]= pow(templik,beta_pow);\n\n }\n }\n //List ret(1);\n //ret[0]=overall_term_nodes_trees;\n //ret[0]=overall_term_obs_trees;\n //ret[2]=overall_predictions;\n //return(overall_term_obs_trees);\n\n //return(overall_treetables);\n\n overall_liks=overall_liks/sum(overall_liks);\n\n List ret(2);\n ret[0]=overall_treetables;\n ret[1]=overall_liks;\n return(ret);\n\n\n\n}\n//######################################################################################################################//\n\n// [[Rcpp::depends(RcppArmadillo)]]\n// [[Rcpp::export]]\n\narma::mat get_test_probs(NumericVector weights, int num_cats,\n NumericMatrix testdata, //NumericMatrix test_data,\n NumericMatrix treetable//, NumericMatrix tree_data\n) {\n // Function to make predictions from test data, given a single tree and the terminal node predictions, this function will be called\n //for each tree accepted in Occam's Window.\n\n //test_data is a nxp matrix with the same variable names as the training data the model was built on\n\n //tree_data is the tree table with the tree information i.e. split points and split variables and terminal node mean values\n\n //term_node_means is a vector storing the terminal node mean values\n // arma::vec orig_y_arma= as(original_y);\n // arma::vec alpha_pars_arma= as(alpha_pars);\n //\n // double lik_prod=1;\n // double alph_prod=1;\n // for(unsigned int i=0; i(terminal_nodes);\n //NumericVector tree_predictions;\n\n //now for each internal node find the observations that belong to the terminal nodes\n\n //NumericVector predictions(test_data.nrow());\n\n arma::mat pred_mat(testdata.nrow(),num_cats);\n //arma::vec filled_in(testdata.nrow());\n\n\n //List term_obs(terminal_nodes.size());\n if(terminal_nodes.size()==1){\n\n //Rcout << \"Line 422. \\n\";\n\n\n pred_mat=repmat(arma_tree_table(0,arma::span(5,5+num_cats-1)),testdata.nrow(),1);\n\n\n //Rcout << \"Line 424. \\n\";\n\n\n // for(int k=0; k temp_split);\n }\n\n arma::uvec temp_pred_indices;\n\n //arma::vec data_subset = testd.col(split);\n arma::vec data_subset = arma_test_data.col(split);\n\n data_subset=data_subset.elem(pred_indices);\n\n //now loop through each row of node_split_mat\n int n=node_split_mat.n_rows;\n //Rcout << \"Line 174. i = \" << i << \". n = \" << n << \".\\n\";\n //Rcout << \"Line 174. node_split_mat= \" << node_split_mat << \". n = \" << n << \".\\n\";\n\n\n for(int j=1;j split_p);\n }\n pred_indices=pred_indices.elem(temp_pred_indices);\n\n if(pred_indices.size()==0){\n continue;\n }\n\n }\n //Rcout << \"Line 199. i = \" << i << \".\\n\";\n\n //double nodemean=tree_data(terminal_nodes[i]-1,5);\n //IntegerVector predind=as(wrap(pred_indices));\n //predictions[predind]= nodemean;\n //term_obs[i]=predind;\n\n //Rcout << \"Line 635. \\n\";\n //Rcout << \"pred_indices = \" << pred_indices << \".\\n\";\n\n //pred_mat.rows(pred_indices)=arma::repmat(arma_tree_table(curr_term-1,arma::span(5,5+num_cats-1)),pred_indices.n_elem,1);\n pred_mat.each_row(pred_indices)=arma_tree_table(curr_term-1,arma::span(5,4+num_cats));\n\n\n\n //Rcout << \"Line 588. \\n\";\n\n // for(int k=0; k(testdata.nrow(),num_cats);\n\n\n for(int i=0;i(s)){\n //if current set of trees contains more than one tree...usually does!\n //List sum_tree=treetable_list[i];\n\n //save all info in list of list format the same as the trees.\n //List term_nodes_trees(sum_tree.size());\n //List term_obs_trees(sum_tree.size());\n //NumericMatrix predictions(num_obs,sum_tree.size());\n\n // for(int k=0;k(treepred_output[1]);\n //overall_liks[i]= pow(templik,beta_pow);\n\n\n\n //overall_term_nodes_trees[i]=term_nodes_trees;\n //overall_term_obs_trees[i]= term_obs_trees;\n //overall_predictions[i]=predictions;\n }else{\n // NumericMatrix sum_tree=overall_sum_trees[i];\n // List tree_info=get_termobs_test_data(test_data, sum_tree) ;\n // //overall_term_nodes_trees[i]=tree_info[0];\n // List term_obs_trees(1);\n // term_obs_trees[0]=tree_info ;\n // //NumericVector term_preds=tree_info[2];\n // //NumericVector predictions=term_preds;\n // overall_term_obs_trees[i]= term_obs_trees;\n // //overall_predictions[i]=predictions;\n //\n\n //overall_treetables[i]=get_treepreds(original_y, num_cats, alpha_pars,\n // originaldata,\n // treetable_list[i] );\n\n\n // List treepred_output = get_treepreds(original_y, num_cats, alpha_pars,\n // originaldata,\n // treetable_list[i] );\n //\n // overall_treetables[i]= treepred_output[0];\n // double templik = as(treepred_output[1]);\n // overall_liks[i]= pow(templik,beta_pow);\n\n\n //Rcout << \"Line 732. i== \" << i << \". \\n\";\n\n arma::mat treeprob_output = get_test_probs(weights, num_cats,\n testdata,\n treetable_list[i] );\n\n //Rcout << \"Line 738. i== \" << i << \". \\n\";\n\n double weighttemp = weights[i];\n //Rcout << \"Line 741. i== \" << i << \". \\n\";\n //Rcout << \"treeprob_output.n_rows\" << treeprob_output.n_rows << \".\\n\";\n //Rcout << \"treeprob_output.n_cols\" << treeprob_output.n_cols << \".\\n\";\n\n\n pred_mat_overall = pred_mat_overall + weighttemp*treeprob_output;\n //Rcout << \"Line 744. i== \" << i << \". \\n\";\n //Rcout << \"pred_mat_overall \" << pred_mat_overall << \". \\n\";\n\n }\n }\n //List ret(1);\n //ret[0]=overall_term_nodes_trees;\n //ret[0]=overall_term_obs_trees;\n //ret[2]=overall_predictions;\n //return(overall_term_obs_trees);\n\n //return(overall_treetables);\n\n // overall_liks=overall_liks/sum(overall_liks);\n //\n // List ret(2);\n // ret[0]=overall_treetables;\n // ret[1]=overall_liks;\n // return(ret);\n\n return(wrap(pred_mat_overall));\n\n}\n//######################################################################################################################//\n\n// [[Rcpp::depends(RcppArmadillo)]]\n//// [[Rcpp::depends(dqrng)]]\n//// [[Rcpp::depends(BH)]]\n//// [[Rcpp::depends(dqrng, BH, RcppArmadillo)]]\n\n#include \n\n//#include \n\n//#include \n//using binomial = boost::random::binomial_distribution;\n//' @title Draw a set of trees from the prior.\n//' @export\n// [[Rcpp::export]]\nList draw_trees(double lambda, int num_trees, int seed, int num_split_vars, int num_cats ){\n\n //dqrng::dqRNGkind(\"Xoroshiro128+\");\n //dqrng::dqset_seed(IntegerVector::create(seed));\n\n //use following with binomial?\n //dqrng::xoshiro256plus rng(seed);\n\n //std::vector lambdavec = {lambda, 1-lambda};\n\n //typedef boost::mt19937 RNGType;\n //boost::random::uniform_int_distribution<> sample_splitvardist(1,num_split_vars);\n //boost::variate_generator< RNGType, boost::uniform_int<> > sample_splitvars(rng, sample_splitvardist);\n\n //boost::random::uniform_real_distribution b_unifdist(0,1);\n //boost::variate_generator< RNGType, boost::uniform_real<> > b_unif_point(rng, b_unifdist);\n\n\n\n // std::random_device device;\n // std::mt19937 gen(device());\n\n //possibly use seed?\n //// std::mt19937 gen(seed);\n\n\n // std::bernoulli_distribution coin_flip(lambda);\n\n // std::uniform_int_distribution<> distsampvar(1, num_split_vars);\n //std::uniform_real_distribution<> dis_cont_unif(0, 1);\n\n\n\n List table_list(num_trees);\n\n\n\n\n for(int j=0; j treenodes_bin;\n //std::vector split_var_vec;\n\n\n int count_terminals = 0;\n int count_internals = 0;\n\n //int count_treebuild = 0;\n\n while(count_internals > (count_terminals -1)){\n\n //Also consider standard library and random header\n // std::random_device device;\n // std::mt19937 gen(device());\n // std::bernoulli_distribution coin_flip(lambda);\n // bool outcome = coin_flip(gen);\n\n\n //int tempdraw = coin_flip(gen);\n\n //int tempdraw = rbinom(n = 1, prob = lambda,size=1);\n\n\n //int tempdraw = Rcpp::rbinom(1,lambda,1);\n int tempdraw = R::rbinom(1,lambda);\n treenodes_bin.push_back(tempdraw);\n\n //Rcout << \"tempdraw = \" << tempdraw << \".\\n\" ;\n\n //int tempdraw = dqrng::dqsample_int(2, 1, true,lambdavec )-1;\n //need to update rng if use boost?\n //int tempdraw = bernoulli(rng, binomial::param_type(1, lambda));\n if(tempdraw==1){\n count_internals=count_internals+1;\n }else{\n count_terminals=count_terminals+1;\n }\n\n }//end of while loop creating parent vector treenodes_bin\n\n //Consider making this an armadillo vector\n //IntegerVector split_var_vec(treenodes_bin.size());\n //arma::uvec split_var_vec(treenodes_bin.size());\n std::vector split_var_vec(treenodes_bin.size());\n //std::vector split_var_vectemp(treenodes_bin.size());\n //split_var_vec.reserve(treenodes_bin.size());\n\n //loop drawing splitting variables\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i distsampvar(1, num_split_vars);\n //\n // split_var_vec[i] <- distsampvar(engine);\n\n // split_var_vec[i] <- distsampvar(gen);\n\n\n //consider using boost\n //might need to update rng\n //split_var_vec[i] <- sample_splitvars(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_var_vec[i] = dqrng::dqsample_int(num_split_vars, 1, true);\n\n //not sure if this returns an integer or a vector?\n //split_var_vec[i] = RcppArmadillo::sample(num_split_vars, 1,true);\n //could try\n split_var_vec[i] = as(Rcpp::sample(num_split_vars, 1,true));\n\n //split_var_vec.push_back(as(Rcpp::sample(num_split_vars, 1,true)));\n //could also try RcppArmadillo::rmultinom\n\n }\n\n }// end of for-loop drawing split variables\n\n //split_var_vec=split_var_vectemp;\n\n //Consider making this an armadillo vector\n //NumericVector split_point_vec(treenodes_bin.size());\n //arma::vec split_point_vec(treenodes_bin.size());\n std::vector split_point_vec(treenodes_bin.size());\n\n\n //loop drawing splitting points\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i dis_cont_unif(0, 1);\n\n // split_point_vec[i] = dis_cont_unif(gen);\n\n //////////////////////////////////////////////////////////\n //from armadillo\n split_point_vec[i] = arma::randu();\n\n //////////////////////////////////////////////////////////\n //probably not adviseable for paralelization\n //From Rcpp\n split_point_vec[i] = as(Rcpp::runif(1,0,1));\n\n //////////////////////////////////////////////////////////\n //consider using boost\n //might need to update rng\n //split_point_vec[i] <- b_unif_point(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_point_vec[i] = dqrng::dqrunif(1, 0, 1);\n\n //not sure if this returns an integer or a vector?\n\n\n\n\n\n }\n\n }// end of for-loop drawing split points\n\n\n //Create tree table matrix\n\n //NumericMatrix tree_table1(treenodes_bin.size(),5+num_cats);\n\n //Rcout << \"Line 1037. \\n\";\n //arma::mat tree_table1(treenodes_bin.size(),5+num_cats);\n\n //initialize with zeros. Not sure if this is necessary\n arma::mat tree_table1=arma::zeros(treenodes_bin.size(),5+num_cats);\n //Rcout << \"Line 1040. \\n\";\n\n\n //tree_table1(_,2) = wrap(split_var_vec);\n //tree_table1(_,3) = wrap(split_point_vec);\n //tree_table1(_,4) = wrap(treenodes_bin);\n\n //It might be more efficient to make everything an armadillo object initially\n // but then would need to replace push_back etc with a different approach (but this might be more efficient anyway)\n arma::colvec split_var_vec_arma=arma::conv_to::from(split_var_vec);\n arma::colvec split_point_vec_arma(split_point_vec);\n arma::colvec treenodes_bin_arma=arma::conv_to::from(treenodes_bin);\n\n\n //Rcout << \"Line 1054. \\n\";\n\n tree_table1.col(2) = split_var_vec_arma;\n tree_table1.col(3) = split_point_vec_arma;\n tree_table1.col(4) = treenodes_bin_arma;\n\n\n //Rcout << \"Line 1061. j = \" << j << \". \\n\";\n\n\n\n // Now start filling in left daughter and right daughter columns\n std::vector rd_spaces;\n int prev_node = -1;\n\n for(unsigned int i=0; in)\n throw std::range_error(\"Sterling number undefined for k>n\");\n if(k==0 && n==0)\n return 1;\n if (n == 0 || k == 0 || k > n)\n return 0;\n if (k == 1 || k == n)\n return 1;\n\n arma::mat sf=arma::zeros(n + 1,n + 1);\n for (int i = 0; i < k+1; i++) {\n sf(i,i) = 1;\n }\n for(int i=1; i< n+1 ; i++){\n sf(i,1)=1;\n }\n for (int i = 3; i < n + 1; i++) {\n for (int j = 2; j < k + 1; j++) {\n sf(i,j) = j * sf(i - 1,j) + sf(i - 1,j - 1);\n }\n }\n return sf(n,k);\n}\n\n//###########################################################################################################################//\n#include \n\n// [[Rcpp::depends(BH)]]\n// [[Rcpp::export]]\ndouble mixt_eval_cdf(double x_val, double d_o_f, std::vector mean_vec, std::vector var_vec, std::vector weights_vec, double quant_val) {\n\n boost::math::students_t dist(d_o_f);\n\n double ret_val=0;\n for(unsigned int i=0; i < weights_vec.size();i++){\n if(var_vec[i]>0){\n double tempx = (x_val-mean_vec[i])/sqrt(var_vec[i]);\n ret_val += weights_vec[i]*boost::math::cdf(dist,tempx);\n }else{//in some cases (for ITEs) there is zero variance, and can't divide by zero\n //Rcout << \" \\n \\n VARIANCE = \" << var_vec[i] << \".\\n \\n\" ;\n if(x_val>=mean_vec[i]){ //if no variance, cdf is zero below mean, and one above mean\n ret_val += weights_vec[i];\n } // no else statement because add zero if below mean (when there is zero variance)\n }\n }\n\n return (ret_val-quant_val) ; // approximation\n}\n\n//###########################################################################################################################//\n// [[Rcpp::export]]\ndouble rootmixt(double d_o_f, double a, double b,\n std::vector mean_vec,\n std::vector var_vec,\n std::vector weights_vec, double quant_val, double root_alg_precision){\n\n static const double EPS = root_alg_precision;//1e-15; // 1×10^(-15)\n\n double fa = mixt_eval_cdf(a, d_o_f, mean_vec, var_vec, weights_vec,quant_val), fb = mixt_eval_cdf(b, d_o_f, mean_vec, var_vec, weights_vec,quant_val);\n\n // if either f(a) or f(b) are the root, return that\n // nothing else to do\n if (fa == 0) return a;\n if (fb == 0) return b;\n\n //Rcout << \"quant_val = \" << quant_val << \".\\n\";\n\n //Rcout << \"fa = \" << fa << \".\\n\";\n //Rcout << \"fb = \" << fb << \".\\n\";\n\n // this method only works if the signs of f(a) and f(b)\n // are different. so just assert that\n assert(fa * fb < 0); // 8.- macro assert from header cassert.\n\n\n do {\n // calculate fun at the midpoint of a,b\n // if that's the root, we're done\n\n // this line is awful, never write code like this...\n //if ((f = fun((s = (a + b) / 2))) == 0) break;\n\n // prefer:\n double midpt = (a + b) / 2;\n double fmid = mixt_eval_cdf(midpt, d_o_f, mean_vec, var_vec, weights_vec,quant_val);\n\n if (fmid == 0) return midpt;\n\n // adjust our bounds to either [a,midpt] or [midpt,b]\n // based on where fmid ends up being. I'm pretty\n // sure the code in the question is wrong, so I fixed it\n if (fa * fmid < 0) { // fmid, not f1\n fb = fmid;\n b = midpt;\n }\n else {\n fa = fmid;\n a = midpt;\n }\n } while (b-a > EPS); // only loop while\n // a and b are sufficiently far\n // apart\n //Rcout << \"a = \" << a << \".\\n\";\n //Rcout << \"b = \" << b << \".\\n\";\n return (a + b) / 2; // approximation\n}\n\n\n//###########################################################################################################################//\n\nstd::vector mixt_find_boundsQ(double d_o_f, std::vector mean_vec, std::vector var_vec, double quant_val) {\n //boost::math::students_t dist1(d_o_f);\n\n std::vector tempbounds(mean_vec.size());\n\n for(unsigned int i=0; i< mean_vec.size();i++){\n //tempbounds[i]= mean_vec[i]+sqrt(var_vec[i])*boost::math::quantile(dist1,quant_val);\n tempbounds[i]= mean_vec[i]+sqrt(var_vec[i])*quant_val;\n }\n\n std::vector ret(2);\n ret[0]= *std::min_element(tempbounds.begin(), tempbounds.end());\n ret[1]= *std::max_element(tempbounds.begin(), tempbounds.end());\n\n return(ret) ;\n}\n\n\n//######################################################################################################################//\n\n// [[Rcpp::depends(RcppArmadillo)]]\n//' @title Safe-Bayesian Random Forest. Initial test function.\n//' @export\n// [[Rcpp::export]]\n\nNumericMatrix sBayesRF(double lambda, int num_trees,\n int seed, int num_cats,\n NumericVector y, NumericMatrix original_datamat,\n NumericVector alpha_parameters, double beta_par,\n NumericMatrix test_datamat){\n\n int num_split_vars= original_datamat.ncol();\n NumericMatrix Data_transformed = cpptrans_cdf(original_datamat);\n NumericMatrix testdat_trans = cpptrans_cdf_test(original_datamat,test_datamat);\n\n //Rcout << \"Line 1134 . \\n\";\n List table_list = draw_trees(lambda, num_trees, seed, num_split_vars, num_cats );\n //Rcout << \"Line 1136 . \\n\";\n\n\n List tree_list_output = get_treelist(y, num_cats, alpha_parameters, beta_par,\n Data_transformed,\n table_list );\n //Rcout << \"Line 1141 . \\n\";\n\n NumericMatrix probmat = get_test_prob_overall(tree_list_output[1],num_cats,\n testdat_trans,\n tree_list_output[0]);\n //Rcout << \"Line 1146 . \\n\";\n\n return(probmat);\n\n}\n//######################################################################################################################//\n\n// [[Rcpp::depends(RcppArmadillo)]]\n//' @title Safe-Bayesian Random Forest\n//'\n//' @description An implementation of the Safe-Bayesian Random Forest described by Quadrianto and Ghahramani (2015)\n//' @param lambda A real number between 0 and 1 that determines the splitting probability in the prior (which is used as the importance sampler of tree models). Quadrianto and Ghahramani (2015) recommend a value less than 0.5 .\n//' @param num_trees The number of trees to be sampled.\n//' @param seed The seed for random number generation.\n//' @param num_cats The number of possible values for the outcome variable.\n//' @param y The training data vector of outcomes. This must be a vector of integers between 1 and num_cats.\n//' @param original_datamat The original training data. Currently all variables must be continuous. The training data does not need to be transformed before being entered to this function.\n//' @param alpha_parameters Vector of prior parameters.\n//' @param beta_par The power to which the likelihood is to be raised. For BMA, set beta_par=1.\n//' @param original_datamat The original test data. This matrix must have the same number of columns (variables) as the training data. Currently all variables must be continuous. The test data does not need to be transformed before being entered to this function.\n//' @export\n// [[Rcpp::export]]\n\nNumericMatrix sBayesRF_onefunc(double lambda, int num_trees,\n int seed, int num_cats,\n NumericVector y, NumericMatrix original_datamat,\n NumericVector alpha_parameters, double beta_par,\n NumericMatrix test_datamat){\n\n int num_split_vars= original_datamat.ncol();\n\n\n ///////////////////////\n //NumericMatrix Data_transformed = cpptrans_cdf(original_datamat);\n NumericMatrix Data_transformed(original_datamat.nrow(), original_datamat.ncol());\n for(int i=0; i lambdavec = {lambda, 1-lambda};\n\n //typedef boost::mt19937 RNGType;\n //boost::random::uniform_int_distribution<> sample_splitvardist(1,num_split_vars);\n //boost::variate_generator< RNGType, boost::uniform_int<> > sample_splitvars(rng, sample_splitvardist);\n\n //boost::random::uniform_real_distribution b_unifdist(0,1);\n //boost::variate_generator< RNGType, boost::uniform_real<> > b_unif_point(rng, b_unifdist);\n\n\n\n // std::random_device device;\n // std::mt19937 gen(device());\n\n //possibly use seed?\n //// std::mt19937 gen(seed);\n\n\n // std::bernoulli_distribution coin_flip(lambda);\n\n // std::uniform_int_distribution<> distsampvar(1, num_split_vars);\n //std::uniform_real_distribution<> dis_cont_unif(0, 1);\n\n\n arma::vec orig_y_arma= as(y);\n arma::vec alpha_pars_arma= as(alpha_parameters);\n\n arma::mat arma_orig_data(Data_transformed.begin(), Data_transformed.nrow(), Data_transformed.ncol(), false);\n arma::mat arma_test_data(testdat_trans.begin(), testdat_trans.nrow(), testdat_trans.ncol(), false);\n\n\n arma::mat pred_mat_overall=arma::zeros(test_datamat.nrow(),num_cats);\n\n\n //List overall_treetables(num_trees);\n NumericVector overall_liks(num_trees);\n\n\n //overall_treetables[i]= wrap(tree_table1);\n //double templik = as(treepred_output[1]);\n //overall_liks[i]= pow(lik_prod,beta_pow);\n\n\n\n for(int j=0; j treenodes_bin;\n\n\n int count_terminals = 0;\n int count_internals = 0;\n\n //int count_treebuild = 0;\n\n while(count_internals > (count_terminals -1)){\n\n //Also consider standard library and random header\n // std::random_device device;\n // std::mt19937 gen(device());\n // std::bernoulli_distribution coin_flip(lambda);\n // bool outcome = coin_flip(gen);\n\n\n //int tempdraw = coin_flip(gen);\n\n //int tempdraw = rbinom(n = 1, prob = lambda,size=1);\n\n\n //int tempdraw = Rcpp::rbinom(1,lambda,1);\n int tempdraw = R::rbinom(1,lambda);\n treenodes_bin.push_back(tempdraw);\n\n //Rcout << \"tempdraw = \" << tempdraw << \".\\n\" ;\n\n //int tempdraw = dqrng::dqsample_int(2, 1, true,lambdavec )-1;\n //need to update rng if use boost?\n //int tempdraw = bernoulli(rng, binomial::param_type(1, lambda));\n if(tempdraw==1){\n count_internals=count_internals+1;\n }else{\n count_terminals=count_terminals+1;\n }\n\n }//end of while loop creating parent vector treenodes_bin\n\n //Consider making this an armadillo vector\n //IntegerVector split_var_vec(treenodes_bin.size());\n //arma::uvec split_var_vec(treenodes_bin.size());\n std::vector split_var_vec(treenodes_bin.size());\n\n //loop drawing splitting variables\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i distsampvar(1, num_split_vars);\n //\n // split_var_vec[i] <- distsampvar(engine);\n\n // split_var_vec[i] <- distsampvar(gen);\n\n\n //consider using boost\n //might need to update rng\n //split_var_vec[i] <- sample_splitvars(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_var_vec[i] = dqrng::dqsample_int(num_split_vars, 1, true);\n\n //not sure if this returns an integer or a vector?\n //split_var_vec[i] = RcppArmadillo::sample(num_split_vars, 1,true);\n //could try\n split_var_vec[i] = as(Rcpp::sample(num_split_vars, 1,true));\n //could also try RcppArmadillo::rmultinom\n\n }\n\n }// end of for-loop drawing split variables\n\n\n //Consider making this an armadillo vector\n //NumericVector split_point_vec(treenodes_bin.size());\n //arma::vec split_point_vec(treenodes_bin.size());\n std::vector split_point_vec(treenodes_bin.size());\n\n\n //loop drawing splitting points\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i dis_cont_unif(0, 1);\n\n // split_point_vec[i] = dis_cont_unif(gen);\n\n //////////////////////////////////////////////////////////\n //from armadillo\n //split_point_vec[i] = arma::randu();\n\n //////////////////////////////////////////////////////////\n //probably not adviseable for paralelization\n //From Rcpp\n split_point_vec[i] = as(Rcpp::runif(1,0,1));\n\n //////////////////////////////////////////////////////////\n //consider using boost\n //might need to update rng\n //split_point_vec[i] <- b_unif_point(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_point_vec[i] = dqrng::dqrunif(1, 0, 1);\n\n //not sure if this returns an integer or a vector?\n\n\n\n\n\n }\n\n }// end of for-loop drawing split points\n\n\n //Create tree table matrix\n\n //NumericMatrix tree_table1(treenodes_bin.size(),5+num_cats);\n\n //Rcout << \"Line 1037. \\n\";\n //arma::mat tree_table1(treenodes_bin.size(),5+num_cats);\n\n //initialize with zeros. Not sure if this is necessary\n arma::mat tree_table1=arma::zeros(treenodes_bin.size(),5+num_cats);\n //Rcout << \"Line 1040. \\n\";\n\n\n //tree_table1(_,2) = wrap(split_var_vec);\n //tree_table1(_,3) = wrap(split_point_vec);\n //tree_table1(_,4) = wrap(treenodes_bin);\n\n //It might be more efficient to make everything an armadillo object initially\n // but then would need to replace push_back etc with a different approach (but this might be more efficient anyway)\n arma::colvec split_var_vec_arma=arma::conv_to::from(split_var_vec);\n arma::colvec split_point_vec_arma(split_point_vec);\n arma::colvec treenodes_bin_arma=arma::conv_to::from(treenodes_bin);\n\n\n //Rcout << \"Line 1054. \\n\";\n\n tree_table1.col(2) = split_var_vec_arma;\n tree_table1.col(3) = split_point_vec_arma;\n tree_table1.col(4) = treenodes_bin_arma;\n\n\n //Rcout << \"Line 1061. j = \" << j << \". \\n\";\n\n\n\n // Now start filling in left daughter and right daughter columns\n std::vector rd_spaces;\n int prev_node = -1;\n\n for(unsigned int i=0; i(terminal_nodes);\n //NumericVector tree_predictions;\n\n //now for each internal node find the observations that belong to the terminal nodes\n\n //NumericVector predictions(test_data.nrow());\n //List term_obs(terminal_nodes.size());\n if(terminal_nodes.size()==1){\n //double nodemean=tree_data(terminal_nodes[0]-1,5);\t\t\t\t// let nodemean equal tree_data row terminal_nodes[i]^th row , 6th column. The minus 1 is because terminal nodes consists of indices starting at 1, but need indices to start at 0.\n //predictions=rep(nodemean,test_data.nrow());\n //Rcout << \"Line 67 .\\n\";\n\n //IntegerVector temp_obsvec = seq_len(test_data.nrow())-1;\n //term_obs[0]= temp_obsvec;\n double denom_temp= orig_y_arma.n_elem+arma::sum(alpha_pars_arma);\n\n double num_prod=1;\n double num_sum=0;\n //Rcout << \"Line 129.\\n\";\n\n for(int k=0; k temp_split);\n }\n //Rcout << \"Line 236.\\n\";\n\n arma::uvec temp_pred_indices;\n\n //arma::vec data_subset = testd.col(split);\n arma::vec data_subset = arma_orig_data.col(split);\n\n data_subset=data_subset.elem(pred_indices);\n\n //now loop through each row of node_split_mat\n int n=node_split_mat.n_rows;\n //Rcout << \"Line 174. i = \" << i << \". n = \" << n << \".\\n\";\n //Rcout << \"Line 248.\\n\";\n\n for(int j=1;j split_p);\n }\n pred_indices=pred_indices.elem(temp_pred_indices);\n\n if(pred_indices.size()==0){\n continue;\n }\n\n }\n //Rcout << \"Line 199. i = \" << i << \".\\n\";\n\n //double nodemean=tree_data(terminal_nodes[i]-1,5);\n //IntegerVector predind=as(wrap(pred_indices));\n //predictions[predind]= nodemean;\n //term_obs[i]=predind;\n\n double denom_temp= pred_indices.n_elem+arma::sum(alpha_pars_arma);\n //Rcout << \"Line 207. predind = \" << predind << \".\\n\";\n //Rcout << \"Line 207. denom_temp = \" << denom_temp << \".\\n\";\n // << \"Line 207. term_node = \" << term_node << \".\\n\";\n\n double num_prod=1;\n double num_sum=0;\n\n for(int k=0; k(treepred_output[1]);\n\n double templik = pow(lik_prod,beta_par);\n overall_liks[j]= templik;\n\n\n\n\n\n\n //arma::mat arma_tree_table(treetable.begin(), treetable.nrow(), treetable.ncol(), false);\n //arma::mat arma_test_data(testdata.begin(), testdata.nrow(), testdata.ncol(), false);\n\n\n //arma::mat arma_tree(tree_data.begin(), tree_data.nrow(), tree_data.ncol(), false);\n //arma::mat testd(test_data.begin(), test_data.nrow(), test_data.ncol(), false);\n\n //NumericVector internal_nodes=find_internal_nodes_gs(tree_data);\n\n //NumericVector terminal_nodes=find_term_nodes(treetable);\n //arma::vec arma_terminal_nodes=Rcpp::as(terminal_nodes);\n //NumericVector tree_predictions;\n\n //now for each internal node find the observations that belong to the terminal nodes\n\n //NumericVector predictions(test_data.nrow());\n\n arma::mat pred_mat(test_datamat.nrow(),num_cats);\n //arma::vec filled_in(testdata.nrow());\n\n\n //List term_obs(terminal_nodes.size());\n if(terminal_nodes.size()==1){\n\n //Rcout << \"Line 422. \\n\";\n\n\n pred_mat=repmat(tree_table1(0,arma::span(5,5+num_cats-1)),test_datamat.nrow(),1);\n\n\n //Rcout << \"Line 424. \\n\";\n\n\n // for(int k=0; k temp_split);\n }\n\n arma::uvec temp_pred_indices;\n\n //arma::vec data_subset = testd.col(split);\n arma::vec data_subset = arma_test_data.col(split);\n\n data_subset=data_subset.elem(pred_indices);\n\n //now loop through each row of node_split_mat\n int n=node_split_mat.n_rows;\n //Rcout << \"Line 174. i = \" << i << \". n = \" << n << \".\\n\";\n //Rcout << \"Line 174. node_split_mat= \" << node_split_mat << \". n = \" << n << \".\\n\";\n\n\n for(int j=1;j split_p);\n }\n pred_indices=pred_indices.elem(temp_pred_indices);\n\n if(pred_indices.size()==0){\n continue;\n }\n\n }\n //Rcout << \"Line 199. i = \" << i << \".\\n\";\n\n //double nodemean=tree_data(terminal_nodes[i]-1,5);\n //IntegerVector predind=as(wrap(pred_indices));\n //predictions[predind]= nodemean;\n //term_obs[i]=predind;\n\n //Rcout << \"Line 635. \\n\";\n //Rcout << \"pred_indices = \" << pred_indices << \".\\n\";\n\n //pred_mat.rows(pred_indices)=arma::repmat(arma_tree_table(curr_term-1,arma::span(5,5+num_cats-1)),pred_indices.n_elem,1);\n pred_mat.each_row(pred_indices)=tree_table1(curr_term-1,arma::span(5,4+num_cats));\n\n\n\n //Rcout << \"Line 588. \\n\";\n\n // for(int k=0; k(original_datamat);\n arma::mat testdata_arma= as(test_datamat);\n arma::vec orig_y_arma= as(y);\n arma::vec alpha_pars_arma= as(alpha_parameters);\n\n ///////////////////////\n //NumericMatrix Data_transformed = cpptrans_cdf(original_datamat);\n // NumericMatrix Data_transformed(original_datamat.nrow(), original_datamat.ncol());\n // for(int i=0; i(originaldata);\n\n //THIS CAN BE PARALLELIZED IF THERE ARE MANY VARIABLES\n arma::mat arma_test_data(testdata_arma.n_rows,testdata_arma.n_cols);\n for(unsigned int k=0; ksref.size()){\n }else{\n while (sref(j) < ssampi && j < sref.size()){\n ++j;\n if(j==sref.size()) break;\n }\n }\n ans(ind) = j; // j is the 1-based index of the lower bound\n }\n\n arma_test_data.col(k)=(ans)/nobsref;\n\n }\n\n\n\n\n\n\n\n /////////////////////////////////////////////////////////////////////////////////////////\n\n\n\n //////////////////////////////////////////////////////////////////////////////////////\n //List table_list = draw_trees(lambda, num_trees, seed, num_split_vars, num_cats );\n\n\n\n //dqrng::dqRNGkind(\"Xoroshiro128+\");\n //dqrng::dqset_seed(IntegerVector::create(seed));\n\n //use following with binomial?\n //dqrng::xoshiro256plus rng(seed);\n\n //std::vector lambdavec = {lambda, 1-lambda};\n\n //typedef boost::mt19937 RNGType;\n //boost::random::uniform_int_distribution<> sample_splitvardist(1,num_split_vars);\n //boost::variate_generator< RNGType, boost::uniform_int<> > sample_splitvars(rng, sample_splitvardist);\n\n //boost::random::uniform_real_distribution b_unifdist(0,1);\n //boost::variate_generator< RNGType, boost::uniform_real<> > b_unif_point(rng, b_unifdist);\n\n\n\n std::random_device device;\n std::mt19937 gen(device());\n\n //possibly use seed?\n //// std::mt19937 gen(seed);\n\n\n std::bernoulli_distribution coin_flip(lambda);\n\n std::uniform_int_distribution<> distsampvar(1, num_split_vars);\n std::uniform_real_distribution<> dis_cont_unif(0, 1);\n\n\n\n\n //arma::mat arma_test_data(testdat_trans.begin(), testdat_trans.nrow(), testdat_trans.ncol(), false);\n\n\n arma::mat pred_mat_overall=arma::zeros(arma_test_data.n_rows,num_cats);\n\n\n //List overall_treetables(num_trees);\n arma::vec overall_liks(num_trees);\n\n\n //overall_treetables[i]= wrap(tree_table1);\n //double templik = as(treepred_output[1]);\n //overall_liks[i]= pow(lik_prod,beta_pow);\n\n\n\n for(int j=0; j treenodes_bin;\n\n\n int count_terminals = 0;\n int count_internals = 0;\n\n //int count_treebuild = 0;\n\n while(count_internals > (count_terminals -1)){\n\n //Also consider standard library and random header\n // std::random_device device;\n // std::mt19937 gen(device());\n // std::bernoulli_distribution coin_flip(lambda);\n // bool outcome = coin_flip(gen);\n\n\n int tempdraw = coin_flip(gen);\n\n //int tempdraw = rbinom(n = 1, prob = lambda,size=1);\n\n\n //int tempdraw = Rcpp::rbinom(1,lambda,1);\n //int tempdraw = R::rbinom(1,lambda);\n treenodes_bin.push_back(tempdraw);\n\n //Rcout << \"tempdraw = \" << tempdraw << \".\\n\" ;\n\n //int tempdraw = dqrng::dqsample_int(2, 1, true,lambdavec )-1;\n //need to update rng if use boost?\n //int tempdraw = bernoulli(rng, binomial::param_type(1, lambda));\n if(tempdraw==1){\n count_internals=count_internals+1;\n }else{\n count_terminals=count_terminals+1;\n }\n\n }//end of while loop creating parent vector treenodes_bin\n\n //Consider making this an armadillo vector\n //IntegerVector split_var_vec(treenodes_bin.size());\n //arma::uvec split_var_vec(treenodes_bin.size());\n std::vector split_var_vec(treenodes_bin.size());\n\n //loop drawing splitting variables\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i distsampvar(1, num_split_vars);\n //\n // split_var_vec[i] = distsampvar(engine);\n\n split_var_vec[i] = distsampvar(gen);\n\n\n //consider using boost\n //might need to update rng\n //split_var_vec[i] <- sample_splitvars(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_var_vec[i] = dqrng::dqsample_int(num_split_vars, 1, true);\n\n //not sure if this returns an integer or a vector?\n //split_var_vec[i] = RcppArmadillo::sample(num_split_vars, 1,true);\n //could try\n //split_var_vec[i] = as(Rcpp::sample(num_split_vars, 1,true));\n //could also try RcppArmadillo::rmultinom\n\n }\n\n }// end of for-loop drawing split variables\n\n\n //Consider making this an armadillo vector\n //NumericVector split_point_vec(treenodes_bin.size());\n //arma::vec split_point_vec(treenodes_bin.size());\n std::vector split_point_vec(treenodes_bin.size());\n\n\n //loop drawing splitting points\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i dis_cont_unif(0, 1);\n\n split_point_vec[i] = dis_cont_unif(gen);\n\n //////////////////////////////////////////////////////////\n //from armadillo\n //split_point_vec[i] = arma::randu();\n\n //////////////////////////////////////////////////////////\n //probably not adviseable for paralelization\n //From Rcpp\n //split_point_vec[i] = as(Rcpp::runif(1,0,1));\n\n //////////////////////////////////////////////////////////\n //consider using boost\n //might need to update rng\n //split_point_vec[i] <- b_unif_point(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_point_vec[i] = dqrng::dqrunif(1, 0, 1);\n\n //not sure if this returns an integer or a vector?\n\n\n\n\n\n }\n\n }// end of for-loop drawing split points\n\n\n //Create tree table matrix\n\n //NumericMatrix tree_table1(treenodes_bin.size(),5+num_cats);\n\n //Rcout << \"Line 1037. \\n\";\n //arma::mat tree_table1(treenodes_bin.size(),5+num_cats);\n\n //initialize with zeros. Not sure if this is necessary\n arma::mat tree_table1=arma::zeros(treenodes_bin.size(),5+num_cats);\n //Rcout << \"Line 1040. \\n\";\n\n\n //tree_table1(_,2) = wrap(split_var_vec);\n //tree_table1(_,3) = wrap(split_point_vec);\n //tree_table1(_,4) = wrap(treenodes_bin);\n\n //It might be more efficient to make everything an armadillo object initially\n // but then would need to replace push_back etc with a different approach (but this might be more efficient anyway)\n arma::colvec split_var_vec_arma=arma::conv_to::from(split_var_vec);\n arma::colvec split_point_vec_arma(split_point_vec);\n arma::colvec treenodes_bin_arma=arma::conv_to::from(treenodes_bin);\n\n\n //Rcout << \"Line 1054. \\n\";\n\n tree_table1.col(2) = split_var_vec_arma;\n tree_table1.col(3) = split_point_vec_arma;\n tree_table1.col(4) = treenodes_bin_arma;\n\n\n //Rcout << \"Line 1061. j = \" << j << \". \\n\";\n\n\n\n // Now start filling in left daughter and right daughter columns\n std::vector rd_spaces;\n int prev_node = -1;\n\n for(unsigned int i=0; i(terminal_nodes);\n //NumericVector tree_predictions;\n\n //now for each internal node find the observations that belong to the terminal nodes\n\n //NumericVector predictions(test_data.nrow());\n //List term_obs(term_nodes.n_elem);\n if(term_nodes.n_elem==1){\n //double nodemean=tree_data(terminal_nodes[0]-1,5);\t\t\t\t// let nodemean equal tree_data row terminal_nodes[i]^th row , 6th column. The minus 1 is because terminal nodes consists of indices starting at 1, but need indices to start at 0.\n //predictions=rep(nodemean,test_data.nrow());\n //Rcout << \"Line 67 .\\n\";\n\n //IntegerVector temp_obsvec = seq_len(test_data.nrow())-1;\n //term_obs[0]= temp_obsvec;\n double denom_temp= orig_y_arma.n_elem+arma::sum(alpha_pars_arma);\n\n double num_prod=1;\n double num_sum=0;\n //Rcout << \"Line 129.\\n\";\n\n for(int k=0; k temp_split);\n }\n //Rcout << \"Line 236.\\n\";\n\n arma::uvec temp_pred_indices;\n\n //arma::vec data_subset = testd.col(split);\n arma::vec data_subset = arma_orig_data.col(split);\n\n data_subset=data_subset.elem(pred_indices);\n\n //now loop through each row of node_split_mat\n int n=node_split_mat.n_rows;\n //Rcout << \"Line 174. i = \" << i << \". n = \" << n << \".\\n\";\n //Rcout << \"Line 248.\\n\";\n\n for(int j=1;j split_p);\n }\n pred_indices=pred_indices.elem(temp_pred_indices);\n\n if(pred_indices.size()==0){\n continue;\n }\n\n }\n //Rcout << \"Line 199. i = \" << i << \".\\n\";\n\n //double nodemean=tree_data(terminal_nodes[i]-1,5);\n //IntegerVector predind=as(wrap(pred_indices));\n //predictions[predind]= nodemean;\n //term_obs[i]=predind;\n\n double denom_temp= pred_indices.n_elem+arma::sum(alpha_pars_arma);\n //Rcout << \"Line 207. predind = \" << predind << \".\\n\";\n //Rcout << \"Line 207. denom_temp = \" << denom_temp << \".\\n\";\n // << \"Line 207. term_node = \" << term_node << \".\\n\";\n\n double num_prod=1;\n double num_sum=0;\n\n for(int k=0; k(treepred_output[1]);\n\n double templik = pow(lik_prod,beta_par);\n overall_liks(j)= templik;\n\n\n\n\n\n\n //arma::mat arma_tree_table(treetable.begin(), treetable.nrow(), treetable.ncol(), false);\n //arma::mat arma_test_data(testdata.begin(), testdata.nrow(), testdata.ncol(), false);\n\n\n //arma::mat arma_tree(tree_data.begin(), tree_data.nrow(), tree_data.ncol(), false);\n //arma::mat testd(test_data.begin(), test_data.nrow(), test_data.ncol(), false);\n\n //NumericVector internal_nodes=find_internal_nodes_gs(tree_data);\n\n //NumericVector terminal_nodes=find_term_nodes(treetable);\n //arma::vec arma_terminal_nodes=Rcpp::as(terminal_nodes);\n //NumericVector tree_predictions;\n\n //now for each internal node find the observations that belong to the terminal nodes\n\n //NumericVector predictions(test_data.nrow());\n\n arma::mat pred_mat(testdata_arma.n_rows,num_cats);\n //arma::vec filled_in(testdata.nrow());\n\n\n //List term_obs(terminal_nodes.size());\n if(term_nodes.size()==1){\n\n //Rcout << \"Line 422. \\n\";\n\n\n pred_mat=repmat(tree_table1(0,arma::span(5,5+num_cats-1)),testdata_arma.n_rows,1);\n\n\n //Rcout << \"Line 424. \\n\";\n\n\n // for(int k=0; k temp_split);\n }\n\n arma::uvec temp_pred_indices;\n\n //arma::vec data_subset = testd.col(split);\n arma::vec data_subset = arma_test_data.col(split);\n\n data_subset=data_subset.elem(pred_indices);\n\n //now loop through each row of node_split_mat\n int n=node_split_mat.n_rows;\n //Rcout << \"Line 174. i = \" << i << \". n = \" << n << \".\\n\";\n //Rcout << \"Line 174. node_split_mat= \" << node_split_mat << \". n = \" << n << \".\\n\";\n\n\n for(int j=1;j split_p);\n }\n pred_indices=pred_indices.elem(temp_pred_indices);\n\n if(pred_indices.size()==0){\n continue;\n }\n\n }\n //Rcout << \"Line 199. i = \" << i << \".\\n\";\n\n //double nodemean=tree_data(terminal_nodes[i]-1,5);\n //IntegerVector predind=as(wrap(pred_indices));\n //predictions[predind]= nodemean;\n //term_obs[i]=predind;\n\n //Rcout << \"Line 635. \\n\";\n //Rcout << \"pred_indices = \" << pred_indices << \".\\n\";\n\n //pred_mat.rows(pred_indices)=arma::repmat(arma_tree_table(curr_term-1,arma::span(5,5+num_cats-1)),pred_indices.n_elem,1);\n pred_mat.each_row(pred_indices)=tree_table1(curr_term-1,arma::span(5,4+num_cats));\n\n\n\n //Rcout << \"Line 588. \\n\";\n\n // for(int k=0; k\n#include \n//#include \n\n// [[Rcpp::plugins(openmp)]]\n#include \n\n//' @title Parallel Safe-BART\n//'\n//' @description A parallelized implementation of safe-Bayesian Additive Regression Trees\n//' @param lambda A real number between 0 and 1 that determines the splitting probability in the prior (which is used as the importance sampler of tree models). Quadrianto and Ghahramani (2015) recommend a value less than 0.5 .\n//' @param num_trees The number of trees to be sampled.\n//' @param seed The seed for random number generation.\n//' @param num_cats The number of possible values for the outcome variable.\n//' @param y The training data vector of outcomes. This must be a vector of integers between 1 and num_cats.\n//' @param original_datamat The original training data. Currently all variables must be continuous. The training data does not need to be transformed before being entered to this function.\n//' @param alpha_parameters Vector of prior parameters.\n//' @param beta_par The power to which the likelihood is to be raised. For BMA, set beta_par=1.\n//' @param original_datamat The original test data. This matrix must have the same number of columns (variables) as the training data. Currently all variables must be continuous. The test data does not need to be transformed before being entered to this function.\n//' @param ncores The number of cores to be used in parallelization.\n//' @return A vector of out-of-sample predictions.\n//' @export\n// [[Rcpp::export]]\nNumericVector sBART_onefunc_parallel(double lambda,\n int num_models,\n int num_trees,\n int seed,\n NumericVector ytrain,\n NumericMatrix original_datamat,\n double beta_par,\n NumericMatrix test_datamat,\n int ncores,\n int outsamppreds,\n double nu,\n double a,\n double lambdaBART,\n int valid_trees,\n int tree_prior,\n int imp_sampler,\n double alpha_BART,\n double beta_BART,\n int s_t_hyperprior,\n double p_s_t,\n double a_s_t,\n double b_s_t,\n double lambda_poisson,\n int fast_approx){\n\n\n //Rcout << \"imp_sampler = \" << imp_sampler << \".\\n\";\n\n NumericVector y_scaled=scale_response(min(ytrain),max(ytrain),-0.5,0.5,ytrain);\n\n int num_split_vars= original_datamat.ncol();\n arma::mat data_arma= as(original_datamat);\n arma::mat testdata_arma= as(test_datamat);\n arma::vec orig_y_arma= as(y_scaled);\n //arma::vec alpha_pars_arma= as(alpha_parameters);\n int num_obs = data_arma.n_rows;\n int num_test_obs = testdata_arma.n_rows;\n\n int num_vars = data_arma.n_cols;\n\n //calculations for likelihood\n arma::mat y(num_obs,1);\n y.col(0)=orig_y_arma;\n //get exponent\n double expon=(num_obs+nu)*0.5;\n //get y^Tpsi^{-1}y\n // arma::mat psi_inv=psi.i();\n arma::mat yty=y.t()*y;\n\n\n ///////////////////////\n //NumericMatrix Data_transformed = cpptrans_cdf(original_datamat);\n // NumericMatrix Data_transformed(original_datamat.nrow(), original_datamat.ncol());\n // for(int i=0; i(originaldata);\n\n //THIS CAN BE PARALLELIZED IF THERE ARE MANY VARIABLES\n arma::mat arma_test_data(testdata_arma.n_rows,testdata_arma.n_cols);\n for(unsigned int k=0; ksref.size()){\n }else{\n while (sref(j) < ssampi && j < sref.size()){\n ++j;\n if(j==sref.size()) break;\n }\n }\n ans(ind) = j; // j is the 1-based index of the lower bound\n }\n\n arma_test_data.col(k)=(ans)/nobsref;\n\n }\n\n\n\n\n\n\n\n /////////////////////////////////////////////////////////////////////////////////////////\n\n\n\n //////////////////////////////////////////////////////////////////////////////////////\n //List table_list = draw_trees(lambda, num_trees, seed, num_split_vars, num_cats );\n\n\n\n //dqrng::dqRNGkind(\"Xoroshiro128+\");\n //dqrng::dqset_seed(IntegerVector::create(seed));\n\n //use following with binomial?\n //dqrng::xoshiro256plus rng(seed);\n\n std::vector lambdavec = {lambda, 1-lambda};\n\n //typedef boost::mt19937 RNGType;\n //boost::random::uniform_int_distribution<> sample_splitvardist(1,num_split_vars);\n //boost::variate_generator< RNGType, boost::uniform_int<> > sample_splitvars(rng, sample_splitvardist);\n\n //boost::random::uniform_real_distribution b_unifdist(0,1);\n //boost::variate_generator< RNGType, boost::uniform_real<> > b_unif_point(rng, b_unifdist);\n\n\n\n std::random_device device;\n //std::mt19937 gen(device());\n\n //possibly use seed?\n //// std::mt19937 gen(seed);\n\n dqrng::xoshiro256plus gen(device()); // properly seeded rng\n\n //dqrng::xoshiro256plus gen(seed); // properly seeded rng\n\n\n\n\n std::bernoulli_distribution coin_flip(lambda);\n\n\n std::bernoulli_distribution coin_flip_even(0.5);\n\n double spike_prob1;\n if(s_t_hyperprior==1){\n spike_prob1=a_s_t/(a_s_t + b_s_t);\n }else{\n spike_prob1=p_s_t;\n }\n\n std::bernoulli_distribution coin_flip_spike(spike_prob1);\n\n\n std::uniform_int_distribution<> distsampvar(1, num_split_vars);\n std::uniform_real_distribution<> dis_cont_unif(0, 1);\n\n std::poisson_distribution gen_num_term(lambda_poisson);\n\n\n //dqrng::uniform_distribution dis_cont_unif(0.0, 1.0); // Uniform distribution [0,1)\n\n //Following three functions can't be used in parallel\n //dqrng::dqsample_int coin_flip2(2, 1, true,lambdavec );\n //dqrng::dqsample_int distsampvar(num_split_vars, 1, true);\n //dqrng::dqrunif dis_cont_unif(1, 0, 1);\n\n\n\n //arma::mat arma_test_data(testdat_trans.begin(), testdat_trans.nrow(), testdat_trans.ncol(), false);\n\n\n arma::vec pred_vec_overall=arma::zeros(arma_test_data.n_rows);\n\n\n //arma::field overall_treetables(num_models);\n\n arma::field overall_preds(num_models);\n\n arma::vec overall_liks(num_models);\n\n\n //overall_treetables[i]= wrap(tree_table1);\n //double templik = as(treepred_output[1]);\n //overall_liks[i]= pow(lik_prod,beta_pow);\n\n //Rcout << \"Line 3338. \\n\";\n\n\n#pragma omp parallel num_threads(ncores)\n{//start of pragma omp code\n dqrng::xoshiro256plus lgen(gen); // make thread local copy of rng\n lgen.jump(omp_get_thread_num() + 1); // advance rng by 1 ... ncores jumps\n\n#pragma omp for\n for(int j=0; j treenodes_bin;\n std::vector split_var_vec;\n\n\n int count_terminals = 0;\n int count_internals = 0;\n\n //int count_treebuild = 0;\n\n if(imp_sampler==2){ // If sampling from SPike and Tree\n\n //Rcout << \"Line 3737 .\\n\";\n\n\n //make coinflip_spike before loop\n //also make bernoulli with probability 0.5\n\n //make a poisson distribtion\n\n\n //might be easier to store indices as armadillo vector, because will have to remove\n //potential splits when allocating to terminal nodes\n std::vector potentialsplitvars;\n\n for(int varcount=0; varcount treenodes_bintemp(length+1);\n int p_ind=0;\n long height = 0;\n\n //Rcout << \"Line 195. \\n\";\n //Rcout << \"Line 3781 .\\n\";\n //Rcout << \"q_numsplitvars = \" << q_numsplitvars << \".\\n\";\n\n for(long i = 0; i < length+1; i ++) {\n //signed char x = random_int(1) ? 1 : -1;\n int x = coin_flip_even(lgen) ? 1 : -1;\n treenodes_bintemp[i] = x;\n height += x;\n\n if(height < 0) {\n // this should return a uniform random integer between 0 and x\n //unsigned long random_int(unsigned long x);\n std::uniform_int_distribution<> random_int(0, i);\n long j = random_int(lgen);\n //long j = random_int(i);\n //height += unfold(p_ind + j,treenodes_bintemp, i + 1 - j);\n\n long length1=i+1-j;\n long height1 = 0;\n long local_height = 0;\n int x = 1;\n\n for(long i = 0; i < length1; i ++) {\n int y = treenodes_bintemp[p_ind+j+i];\n local_height += y;\n if(local_height < 0) {\n y = 1;\n height1 += 2;\n local_height = 0;\n }\n treenodes_bintemp[p_ind+j+i] = x;\n x = y;\n }\n height +=height1;\n\n\n\n\n }\n }\n\n //Rcout << \"Line 213. \\n\";\n //Rcout << \"Line 3822 .\\n\";\n\n\n //fold(treenodes_bintemp, length + 1, height);\n long local_height = 0;\n int x = -1;\n ////Rcout << \"Line 121. \\n\";\n //Rcout << \"treenodes_bintemp.size() =\" << treenodes_bintemp.size() << \". \\n\";\n //Rcout << \"length - 1 =\" << length - 1 << \". \\n\";\n\n\n for(long i = length; height > 0; i --) {\n int y = treenodes_bintemp[i];\n local_height -= y;\n if(local_height < 0) {\n y = -1;\n height -= 2;\n local_height = 0;\n }\n treenodes_bintemp[i] = x;\n x = y;\n }\n //Rcout << \"Line 134. \\n\";\n\n\n //Rcout << \"Line 217. \\n\";\n //Rcout << \"Line 3847 .\\n\";\n\n //Rcout << \"Line 238. \\n\";\n std::replace(treenodes_bintemp.begin(), treenodes_bintemp.end(), -1, 0); // 10 99 30 30 99 10 10 99\n\n\n // Then store tree structure as treenodes_bintemp\n\n //create splitting variable vector\n std::vector splitvar_vectemp(treenodes_bintemp.size());\n\n std::vector drawnvarstemp(num_term_nodes_draw-1);\n\n //keep count of how many splitting points have been filled in\n int splitcount=0;\n\n //loop through nodes, filling in splitting variables for nonterminal nodes\n //when less than q_numsplitvars remaining internal nodes to be filled in\n //have to start reducing the set of potential splitting variables\n //to ensure that each selected potential split variable is used at least once. [hence the if statement containing .erase]\n\n int index_remaining=0;\n for(unsigned int nodecount=0; nodecountnum_term_nodes_draw-1-q_numsplitvars){//CHECK THIS CONDITION\n //To ensure each variable used at least once, fill in the rest of the splits with all the variables\n //The split variables will be randomly shuffled anyway, therefore the order is not important here.\n drawnvarstemp[splitcount-1]=potentialsplitvars[index_remaining]+1;\n index_remaining++;\n }else{\n //randomly draw a splitting varaible from the set of potential splitting variables\n std::uniform_int_distribution<> draw_var(0,potentialsplitvars.size()-1);//q_numsplitvars-splitcount could replace potentialsplitvars.size()\n int tempsplitvar = draw_var(lgen);\n drawnvarstemp[splitcount-1]=potentialsplitvars[tempsplitvar]+1;\n\n }\n\n //if(splitcount>num_term_nodes_draw-1-q_numsplitvars){//CHECK THIS CONDITION\n // potentialsplitvars.erase(potentialsplitvars.begin()+tempsplitvar);\n //}\n\n }else{//if not a split\n //splitvar_vectemp[nodecount]=-1;\n }\n }\n\n std::shuffle(drawnvarstemp.begin(),drawnvarstemp.end(),lgen);\n\n splitcount=0;\n for(unsigned int nodecount=0; nodecount (count_terminals -1)){\n samp_prob=alpha_BART*pow(double(depth1+1),-beta_BART);\n std::bernoulli_distribution coin_flip2(samp_prob);\n\n int tempdraw = coin_flip2(lgen);\n treenodes_bin.push_back(tempdraw);\n\n if(tempdraw==1){\n\n depth1=depth1+1; //after a split, the depth will increase by 1\n prev_node=1;\n count_internals=count_internals+1;\n\n }else{\n\n if(prev_node==1){//zero following a 1, therefore at same depth.\n //Don't change depth. Do nothing\n }else{ //zero following a zero, therefore the depth will decrease by 1\n depth1=depth1-1;\n }\n prev_node=0;\n count_terminals=count_terminals+1;\n\n }\n\n }\n\n }else{ //If not sampling from BART prior\n //If sampling from default Q+G prior. i.e. not sampling from BART nor spike and tree prior\n\n while(count_internals > (count_terminals -1)){\n\n //Also consider standard library and random header\n // std::random_device device;\n // std::mt19937 gen(device());\n // std::bernoulli_distribution coin_flip(lambda);\n // bool outcome = coin_flip(gen);\n\n\n int tempdraw = coin_flip(lgen);\n\n //int tempdraw = rbinom(n = 1, prob = lambda,size=1);\n\n\n //int tempdraw = Rcpp::rbinom(1,lambda,1);\n //int tempdraw = R::rbinom(1,lambda);\n\n ////Rcout << \"tempdraw = \" << tempdraw << \".\\n\" ;\n\n //int tempdraw = coin_flip2(lgen)-1;\n\n //int tempdraw = dqrng::dqsample_int(2, 1, true,lambdavec )-1;\n\n\n //need to update rng if use boost?\n //int tempdraw = bernoulli(rng, binomial::param_type(1, lambda));\n\n treenodes_bin.push_back(tempdraw);\n\n\n if(tempdraw==1){\n count_internals=count_internals+1;\n }else{\n count_terminals=count_terminals+1;\n }\n\n }//end of while loop creating parent vector treenodes_bin\n }//end of Q+H sampling else statement\n }//end of not Spike and Tree sampler else statement\n\n //Rcout << \"Line 3961 .\\n\";\n\n\n if(imp_sampler==2){\n //already filled in splitting variable above for spike and tree prior\n }else{\n //Consider making this an armadillo vector\n //IntegerVector split_var_vec(treenodes_bin.size());\n //arma::uvec split_var_vec(treenodes_bin.size());\n std::vector split_var_vectemp(treenodes_bin.size());\n\n // possibly faster alternative\n // split_var_vec.reserve( treenodes_bin.size() );\n // then push_back elements to split_var_vec in the for loop\n\n //loop drawing splitting variables\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i distsampvar(1, num_split_vars);\n //\n // split_var_vec[i] = distsampvar(engine);\n\n split_var_vectemp[i] = distsampvar(lgen);\n\n\n //consider using boost\n //might need to update rng\n //split_var_vec[i] <- sample_splitvars(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_var_vec[i] = dqrng::dqsample_int(num_split_vars, 1, true);\n\n //not sure if this returns an integer or a vector?\n //split_var_vec[i] = RcppArmadillo::sample(num_split_vars, 1,true);\n //could try\n //split_var_vec[i] = as(Rcpp::sample(num_split_vars, 1,true));\n //could also try RcppArmadillo::rmultinom\n\n }\n\n }// end of for-loop drawing split variables\n\n split_var_vec=split_var_vectemp;\n }//end else statrement filling in splitting variable vector\n\n //Consider making this an armadillo vector\n //NumericVector split_point_vec(treenodes_bin.size());\n //arma::vec split_point_vec(treenodes_bin.size());\n std::vector split_point_vec(treenodes_bin.size());\n\n\n //loop drawing splitting points\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i dis_cont_unif(0, 1);\n\n split_point_vec[i] = dis_cont_unif(lgen);\n\n //////////////////////////////////////////////////////////\n //from armadillo\n //split_point_vec[i] = arma::randu();\n\n //////////////////////////////////////////////////////////\n //probably not adviseable for paralelization\n //From Rcpp\n //split_point_vec[i] = as(Rcpp::runif(1,0,1));\n\n //////////////////////////////////////////////////////////\n //consider using boost\n //might need to update rng\n //split_point_vec[i] <- b_unif_point(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_point_vec[i] = dqrng::dqrunif(1, 0, 1);\n\n //not sure if this returns an integer or a vector?\n\n\n\n\n\n }\n\n }// end of for-loop drawing split points\n\n\n\n //Rcout << \"Line 4081 .\\n\";\n\n\n //CODE FOR ADJUSTING SPLITTING POINTS SO THAT THE TREES ARE VALID\n if(valid_trees==1){\n for(unsigned int i=0; iprevent_term_count-1){ //if this rule is satisfied then in subtree that is not to be updated\n continue; //still in subtree, therefore continue instead of checking for splits to be updates\n }else{\n preventing_updates=0; // no longer in subtree, therefore reset preventing_updates to zero\n }\n }\n\n\n if(sub_int_nodes>sub_term_nodes-1){\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]*first_split_point;\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }else{\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]+first_split_point-first_split_point*split_point_vec[k];\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }\n\n\n\n }//end of inner loop over k\n }//end of if statement treenodes_bin[i]==1)\n }//end of loop over i\n }//end of if statement valid_trees==1\n\n\n\n\n\n //Rcout << \"Line 4161 .\\n\";\n\n\n\n\n\n //Create tree table matrix\n\n //NumericMatrix tree_table1(treenodes_bin.size(),5+num_cats);\n\n ////Rcout << \"Line 1037. \\n\";\n //arma::mat tree_table1(treenodes_bin.size(),5+num_cats);\n\n //initialize with zeros. Not sure if this is necessary\n arma::mat tree_table1=arma::zeros(treenodes_bin.size(),6);\n //Rcout << \"Line 1040. \\n\";\n\n\n //tree_table1(_,2) = wrap(split_var_vec);\n //tree_table1(_,3) = wrap(split_point_vec);\n //tree_table1(_,4) = wrap(treenodes_bin);\n\n\n\n //It might be more efficient to make everything an armadillo object initially\n // but then would need to replace push_back etc with a different approach (but this might be more efficient anyway)\n arma::colvec split_var_vec_arma=arma::conv_to::from(split_var_vec);\n //arma::colvec split_point_vec_arma(split_point_vec);\n //arma::colvec split_point_vec_arma(split_point_vec);\n arma::colvec split_point_vec_arma=arma::conv_to::from(split_point_vec);\n\n arma::colvec treenodes_bin_arma=arma::conv_to::from(treenodes_bin);\n\n//Rcout << \"split_var_vec_arma = \" << split_var_vec_arma << \" . \\n\";\n\n//Rcout << \"split_point_vec_arma = \" << split_point_vec_arma << \" . \\n\";\n\n//Rcout << \"treenodes_bin_arma = \" << treenodes_bin_arma << \" . \\n\";\n\n\n //Rcout << \"Line 1054. \\n\";\n\n //Fill in splitting variable column\n tree_table1.col(2) = split_var_vec_arma;\n //Fill in splitting point column\n tree_table1.col(3) = split_point_vec_arma;\n //Fill in split/parent column\n tree_table1.col(4) = treenodes_bin_arma;\n\n\n //Rcout << \"Line 4200. j = \" << j << \". \\n\";\n\n ////Rcout << \"Line 4081 .\\n\";\n\n\n // Now start filling in left daughter and right daughter columns\n std::vector rd_spaces;\n int prev_node = -1;\n\n for(unsigned int i=0; i(terminal_nodes);\n //NumericVector tree_predictions;\n\n //now for each internal node find the observations that belong to the terminal nodes\n\n //NumericVector predictions(test_data.nrow());\n //List term_obs(term_nodes.n_elem);\n\n //GET J MATRIX\n\n //Rcout << \"Line 4311 .\\n\";\n\n if(term_nodes.n_elem==1){\n //double nodemean=tree_data(terminal_nodes[0]-1,5);\t\t\t\t// let nodemean equal tree_data row terminal_nodes[i]^th row , 6th column. The minus 1 is because terminal nodes consists of indices starting at 1, but need indices to start at 0.\n //predictions=rep(nodemean,test_data.nrow());\n //Rcout << \"Line 67 .\\n\";\n\n //IntegerVector temp_obsvec = seq_len(test_data.nrow())-1;\n //term_obs[0]= temp_obsvec;\n //double denom_temp= orig_y_arma.n_elem+arma::sum(alpha_pars_arma);\n\n //double num_prod=1;\n //double num_sum=0;\n //Rcout << \"Line 129.\\n\";\n Jmat.col(0) = arma::ones(num_obs);\n Jtilde.col(0) = arma::ones(num_test_obs);\n\n //for(int k=0; k temp_split);\n pred_test_indices = arma::find(temptest_vec > temp_split);\n }\n //Rcout << \"Line 236.\\n\";\n\n arma::uvec temp_pred_indices;\n arma::uvec temp_test_pred_indices;\n\n //arma::vec data_subset = testd.col(split);\n arma::vec data_subset = arma_orig_data.col(split);\n arma::vec data_test_subset = arma_test_data.col(split);\n\n data_subset=data_subset.elem(pred_indices);\n data_test_subset=data_test_subset.elem(pred_test_indices);\n\n //now loop through each row of node_split_mat\n int n=node_split_mat.n_rows;\n //Rcout << \"Line 174. i = \" << i << \". n = \" << n << \".\\n\";\n //Rcout << \"Line 248.\\n\";\n\n for(int j=1;j split_p);\n temp_test_pred_indices=arma::find(data_test_subset > split_p);\n }\n pred_indices=pred_indices.elem(temp_pred_indices);\n pred_test_indices=pred_test_indices.elem(temp_test_pred_indices);\n\n //if(pred_indices.size()==0){\n // continue;\n //}\n\n }\n //Rcout << \"Line 199. i = \" << i << \".\\n\";\n\n //There is probably a more efficient way of doing this\n //e.g. initialize J matrix so that all elements are equal to zero\n arma::vec tempcol_J=arma::zeros(num_obs);\n tempcol_J(pred_indices) = arma::ones(pred_indices.size());\n Jmat.col(i) = tempcol_J;\n\n arma::vec tempcol_Jtilde=arma::zeros(num_test_obs);\n tempcol_Jtilde(pred_test_indices) = arma::ones(pred_test_indices.size());\n Jtilde.col(i) = tempcol_Jtilde;\n\n //double nodemean=tree_data(terminal_nodes[i]-1,5);\n //IntegerVector predind=as(wrap(pred_indices));\n //predictions[predind]= nodemean;\n //term_obs[i]=predind;\n\n //double denom_temp= pred_indices.n_elem+arma::sum(alpha_pars_arma);\n //Rcout << \"Line 207. predind = \" << predind << \".\\n\";\n //Rcout << \"Line 207. denom_temp = \" << denom_temp << \".\\n\";\n // << \"Line 207. term_node = \" << term_node << \".\\n\";\n\n //double num_prod=1;\n //double num_sum=0;\n\n // for(int k=0; k(p.n_rows, p.n_rows);\n\n arma::mat parameters = arma::solve(cov, p * r.t(), arma::solve_opts::fast);\n\n arma::rowvec preds_temp_arma_t=arma::trans(parameters) * W_tilde.t();\n arma::rowvec preds_insamp_arma=arma::trans(parameters) * p;\n\n arma::vec preds_temp_arma= preds_temp_arma_t.t();\n\n arma::vec tempresids=y-preds_insamp_arma.t();\n double temp_sse= arma::dot(tempresids, tempresids);\n\n //double templik0=exp(-b*0.5*log(num_obs)+log(temp_sse)*(-num_obs)*0.5);\n\n\n //double templik0=exp(-b*0.5*log(num_obs)+log(temp_sse)*(-num_obs)*0.5);\n\n\n //double templik0=exp(-0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs))) ;\n\n double templik0=(num_obs*log(temp_sse/num_obs)+b*log(num_obs)) ;\n\n // //Rcout << \"num_obs= \" << num_obs << \". \\n\";\n // //Rcout << \"b= \" << b << \". \\n\";\n // Rcout << \"log(num_obs)= \" << log(num_obs) << \". \\n\";\n // Rcout << \"log(temp_sse/num_obs)= \" << log(temp_sse/num_obs) << \". \\n\";\n //Rcout << \"templik0= \" << templik0 << \". \\n\";\n // Rcout << \"-0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs))= \" << -0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs)) << \". \\n\";\n\n\n //double templik = pow(templik0,beta_par);\n double templik = beta_par*templik0;\n\n\n if(imp_sampler!=tree_prior){//check if importance sampler is not equal to the prior\n //templik=templik*(sum_tree_prior_prob/sum_tree_samp_prob);\n //templik=templik*sum_prior_over_samp_prob;\n templik=templik+log(sum_prior_over_samp_prob);\n\n }\n overall_liks(j)= templik;\n\n overall_preds(j)=preds_temp_arma;\n\n }else{\n\n\n\n // ///////////////////////////////////\n //get t(y)inv(psi)J\n arma::mat ytW=y.t()*Wmat;\n //get t(J)inv(psi)J\n arma::mat WtW=Wmat.t()*Wmat;\n //get jpsij +aI\n arma::mat aI(b,b);\n aI=a*aI.eye();\n arma::mat sec_term=WtW+aI;\n //arma::mat sec_term_inv=sec_term.i();\n arma::mat sec_term_inv=inv_sympd(sec_term);\n //get t(J)inv(psi)y\n arma::mat third_term=Wmat.t()*y;\n //get m^TV^{-1}m\n arma::mat mvm= ytW*sec_term_inv*third_term;\n //arma::mat rel=(b/2)*log(a)-(1/2)*log(det(sec_term))-expon*log(nu*lambdaBART - mvm +yty);\n // /////////////////////////////////////////////\n\n\n //\n // Rcout << \"-b*0.5*log(num_obs)= \" << -b*0.5*log(num_obs) << \". \\n\";\n // Rcout << \"log(temp_sse)*(-num_obs)*0.5= \" << log(temp_sse)*(-num_obs)*0.5 << \". \\n\";\n //\n\n //double templik0=pow(num_obs, -b*0.5)*pow(temp_sse,-num_obs*0.5);\n\n //\n // arma::vec temppred1=Wmat*sec_term_inv*third_term;\n // arma::vec temperrors= y-temppred1;\n // arma::vec tempcoeffs= sec_term_inv*third_term;\n //\n // double new_penalty= as_scalar(b*temppred1.t()*temppred1/(tempcoeffs.t()*tempcoeffs*(double(num_obs)-b)));\n //\n // Rcout << \" new_penalty =\" << new_penalty << \".\\n\";\n\n\n //double val1;\n //double sign1;\n\n //log_det(val1, sign1, sec_term);\n //double templik0=exp(arma::as_scalar((b*0.5)*log(a)-0.5*val1-expon*log(nu*lambdaBART - mvm +yty)));\n\n\n ////////////////////\n //double templik0=exp(arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term))-expon*log(nu*lambdaBART - mvm +yty)));\n //////////////\n double templik0=arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term))-expon*log(nu*lambdaBART - mvm +yty));\n\n\n\n //double templik0=exp(arma::as_scalar((b*0.5)*log(a)-0.5*log(det(sec_term))-expon*log(nu*lambdaBART - mvm +yty)));\n\n\n\n\n\n //\n //\n // arma::mat aI2(b,b);\n // aI2=new_penalty*aI2.eye();\n // arma::mat sec_term2=WtW+aI2;\n // //arma::mat sec_term_inv=sec_term.i();\n // arma::mat sec_term_inv2=inv_sympd(sec_term2);\n // //get t(J)inv(psi)y\n // //arma::mat third_term=Wmat.t()*y;\n // //get m^TV^{-1}m\n // arma::mat mvm2= ytW*sec_term_inv2*third_term;\n //\n //\n // double templik0=exp(arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term2))-expon*log(nu*lambdaBART - mvm2 +yty)));\n //\n\n\n\n\n\n // Rcout << \"log(temp_sse)= \" << log(temp_sse) << \". \\n\";\n //\n //\n // Rcout << \"temp_sse= \" << temp_sse << \". \\n\";\n //\n\n\n\n // Rcout << \"templik0= \" << templik0 << \". \\n\";\n//\n// Rcout << \"b= \" << b << \". \\n\";\n// Rcout << \"(b*0.5)*log(a)= \" << (b*0.5)*log(a) << \". \\n\";\n//\n// Rcout << \"-0.5*log(det(sec_term))= \" << -0.5*log(det(sec_term)) << \". \\n\";\n// Rcout << \"det(sec_term)= \" << det(sec_term) << \". \\n\";\n// Rcout << \"arma::det(sec_term)= \" << arma::det(sec_term) << \". \\n\";\n// Rcout << \"arma::log_det(sec_term)= \" << arma::log_det(sec_term) << \". \\n\";\n// Rcout << \"real(arma::log_det(sec_term))= \" << real(arma::log_det(sec_term)) << \". \\n\";\n// Rcout << \"log(det(sec_term))= \" << log(det(sec_term)) << \". \\n\";\n// Rcout << \"log(arma::det(sec_term))= \" << log(arma::det(sec_term)) << \". \\n\";\n//\n// Rcout << \"-expon*log(nu*lambdaBART - mvm +yty)= \" << -expon*log(nu*lambdaBART - mvm +yty) << \". \\n\";\n//\n//\n// // Rcout << \"val= \" << val << \". \\n\";\n//\n// Rcout << \"arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term))-expon*log(nu*lambdaBART - mvm +yty)) .\\n\" << arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term))-expon*log(nu*lambdaBART - mvm +yty)) << \".\\n\";\n// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n ////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n //overall_treetables[j]= wrap(tree_table1);\n\n\n //double templik = as(treepred_output[1]);\n\n //double templik = pow(templik0,beta_par);\n\n double templik = beta_par*templik0;\n\n if(imp_sampler!=tree_prior){//check if importance sampler is not equal to the prior\n //templik=templik*(sum_tree_prior_prob/sum_tree_samp_prob);\n //templik=templik*sum_prior_over_samp_prob;\n templik=templik+log(sum_prior_over_samp_prob);\n\n }\n overall_liks(j)= templik;\n\n // if(std::isnan(templik)){\n // Rcout << \"Line 3943, j= \" << j << \". \\n\";\n // Rcout << \"templik= \" << templik << \". \\n\";\n // Rcout << \"sum_tree_prior_prob= \" << sum_tree_prior_prob << \". \\n\";\n // Rcout << \"sum_tree_samp_prob= \" << sum_tree_samp_prob << \". \\n\";\n // }\n\n\n //now fill in the predictions\n\n //If want tree tables with predictions filled in, use\n // arma::vec term_node_par_means = sec_term_inv*third_term;\n // //and would need to save a field of tree tables,\n // //add add a column, or begin with one more column\n // //then the first treetableF[0].n_rows elements of term_node_par_means\n // //give the first\n // int row_count1=0;\n // for(int tree_i=0; tree_i < treetableF.n_elem; tree_i++){\n // tabletemp= treetableF(i);\n // tabletemp.col(5) = term_node_par_means(arma::span(row_count1,tabletemp.n_rows));\n // treetableF(i)=tabletemp;\n // row_count1+=tabletemp.n_rows;\n // }\n //This would give an alternative method for obtaining test data predictions\n //Look up the terminal nodes and add the relevant terminal node parameters\n\n\n\n\n //arma::vec pred_vec(testdata_arma.n_rows);\n\n ////////////\n arma::vec preds_temp_arma= W_tilde*sec_term_inv*third_term;\n\n ////////////////////\n\n\n\n\n\n //arma::vec preds_temp_arma= W_tilde*sec_term_inv2*third_term;\n\n\n\n //THIS SHOULD BE DIFFERENT IF THE CODE IS TO BE PARALLELIZED\n //EACH THREAD SHOULD OUTPUT ITS OWN MATRIX AND SUM OF LIKELIHOODS\n //THEN ADD THE MATRICES TOGETHER AND DIVIDE BY THE TOTAL SUM OF LIKELIHOODS\n //OR JUST SAVE ALL MATRICES TO ONE LIST\n\n\n //pred_mat_overall = pred_mat_overall + templik*pred_mat;\n //overall_treetables(j)= pred_mat*templik;\n\n\n //overall_preds(j)=preds_temp_arma*templik;\n\n overall_preds(j)=preds_temp_arma;\n\n\n\n\n //Rcout << \"Line 3985, j= \" << j << \". \\n\";\n\n\n //Rcout << \"preds_temp_arma= \" << preds_temp_arma << \". \\n\";\n //Rcout << \"preds_temp_arma*templik= \" << preds_temp_arma*templik << \". \\n\";\n\n //overall_treetables(j)= pred_mat;\n //overall_liks(j) =templik;\n\n //arma::mat treeprob_output = get_test_probs(weights, num_cats,\n // testdata,\n // treetable_list[i] );\n\n //Rcout << \"Line 688. i== \" << i << \". \\n\";\n\n //double weighttemp = weights[i];\n //Rcout << \"Line 691. i== \" << i << \". \\n\";\n\n //pred_mat_overall = pred_mat_overall + weighttemp*treeprob_output;\n\n\n }//end of else statement\n }//end of loop over all trees\n\n}//end of pragma omp code\n\n\n///////////////////////////////////////////////////////////////////////////////////////\n\n/////////////////////////////////////////////////////////////////////////////////\n\n\n//for(unsigned int i=0; i(arma_test_data.n_rows);\n #pragma omp for nowait //fill result_private in parallel\n for(unsigned int i=0; i(arma_test_data.n_rows);\n #pragma omp for nowait //fill result_private in parallel\n for(unsigned int i=0; i\n#include \n//#include \n\n// [[Rcpp::plugins(openmp)]]\n#include \n\n//' @title Parallel Safe-Bayesian Causal Forest\n//'\n//' @description A parallelized implementation of the Safe-Bayesian Random Forest described by Quadrianto and Ghahramani (2015)\n//' @param lambda A real number between 0 and 1 that determines the splitting probability in the prior (which is used as the importance sampler of tree models). Quadrianto and Ghahramani (2015) recommend a value less than 0.5 .\n//' @param num_trees The number of trees to be sampled.\n//' @param seed The seed for random number generation.\n//' @param num_cats The number of possible values for the outcome variable.\n//' @param y The training data vector of outcomes. This must be a vector of integers between 1 and num_cats.\n//' @param original_datamat The original training data. Currently all variables must be continuous. The training data does not need to be transformed before being entered to this function.\n//' @param alpha_parameters Vector of prior parameters.\n//' @param beta_par The power to which the likelihood is to be raised. For BMA, set beta_par=1.\n//' @param original_datamat The original test data. This matrix must have the same number of columns (variables) as the training data. Currently all variables must be continuous. The test data does not need to be transformed before being entered to this function.\n//' @param ncores The number of cores to be used in parallelization.\n//' @return A matrix of probabilities with the number of rows equl to the number of test observations and the number of columns equal to the number of possible outcome categories.\n//' @export\n// [[Rcpp::export]]\nNumericVector sBCF_onefunc_parallel(double lambda_mu,\n double lambda_tau,\n int num_models,\n int num_trees_mu,\n int num_trees_tau,\n int seed,\n NumericVector ytrain,\n NumericMatrix original_datamat,\n NumericVector ztrain,\n NumericMatrix pihat_train,\n double beta_par,\n NumericMatrix test_datamat,\n NumericMatrix test_pihat,\n int ncores,\n int outsamppreds,\n double nu,\n double a_mu,\n double a_tau,\n double lambdaBCF,\n int valid_trees,\n int tree_prior,\n int imp_sampler,\n double alpha_BCF_mu,\n double beta_BCF_mu,\n double alpha_BCF_tau,\n double beta_BCF_tau,\n int include_pi2,\n int fast_approx,\n int PIT_propensity){\n\n\n //Check that various input vectors and matrices have consistent dimensions\n\n //Rcout << \"Line 4528.\\n\";\n\n bool is_test_data=0;\t\t\t\t\t// create bool is_test_data. Initialize equal to 0.\n if(test_datamat.nrow()>0){\t\t\t\t\t// If test data has non-zero number of rows.\n is_test_data=1;\t\t\t\t\t\t// set is_test_data equal to 1.\n }\n if(ytrain.size() !=original_datamat.nrow()){\t\t\t\t// If the length of input vector y is not equal to the nunber of rows in the input data (covariates)\n if(ytrain.size()0 && (original_datamat.ncol() != test_datamat.ncol())){\t// If the number of rows in the test data is >0 AND the number of columns (variables) is not equal to that of data (the training data)\n throw std::range_error(\"Test data and training data must have the same number of variables. BART BMA assumes variables are in the same order.\");\n }\n //if(test_z.size() != test_datamat.nrow()){\t// If the number of rows in the test data covariate matrix is not equal to that of the test data treatment indicator variable\n // throw std::range_error(\"Test data covariates and test data treatment indicator variable must have the same number of observations.\");\n //}\n if(test_datamat.nrow() != test_pihat.nrow()){\t// If the number of rows in the test data covariate matrix is not equal to that of the test data propensity score estimates matrix\n throw std::range_error(\"Test data covariates and test data propensity score estimates must have the same number of observations.\");\n }\n if(test_pihat.nrow()>0 && (pihat_train.ncol() != test_pihat.ncol())){\t// If the number of rows in the test data propensity score estimates is >0 AND the number of columns (variables) is not equal to that of the training data propensity score estimates\n throw std::range_error(\"Test data propensity score estimates and training data propensity score estimates must have the same number of columns. BART BMA assumes variables are in the same order.\");\n }\n\n ///////////////////////////////////////////////////////////////////////////////////////////////\n ///////////////////////////////////////////////////////////////////////////////////////////////\n\n\n\n // Now add propensity score estimates matrix as new leftmost column of data matrix. Call the resulting matrix x_control (to be consistent with terminology used by bcf package).\n arma::mat D1(original_datamat.begin(), original_datamat.nrow(), original_datamat.ncol(), false);\t\t\t\t// copy the covariate data matrix into an arma mat\n arma::mat pihat_1(pihat_train.begin(), pihat_train.nrow(), pihat_train.ncol(), false);\t\t\t\t// copy the pihat matrix into an arma mat\n //arma::mat x_control_a=D1;\t\t\t\t// create a copy of data arma mat called x_control_a\n\n\n //THIS CAN BE PARALLELIZED IF THERE ARE MANY VARIABLES\n arma::mat x_control_a_temp(D1.n_rows,D1.n_cols);\n for(unsigned int k=0; k0 ){\n x_control_a.insert_cols(0,pihat_a);\t\t// add propensity scores as new leftmost columns of x_control_a\n }\n }\n // Rcout << \"Number of columns of matrix\" << x_control_a.n_cols << \".\\n\";\n\n\n //NumericMatrix x_control=wrap(x_control_a);\t// convert x_control_a to a NumericMatrix called x_control\n\n // Name the matrix without the estimated propensity scores x_moderate.[CAN REMOVE THE DUPLICATION AND ADD x_control, x_moderate, and include_pi as input parameters later]\n //NumericMatrix x_moderate = data;\t// x_moderate matrix is the covariate data without the propensity scores\n //arma::mat x_moderate_a=D1;\t\t\t// create arma mat copy of x_moderate.\n if((include_pi2==1)| (include_pi2==2) ){\n if(pihat_train.nrow()>0 ){\n x_moderate_a.insert_cols(0,pihat_a);\t\t// add propensity scores as new leftmost columns of x_control_a\n }\n }\n\n\n //NumericMatrix x_moderate=wrap(x_moderate_a);\t// convert x_control_a to a NumericMatrix called x_control\n\n\n // Rcout << \"Get to Line 7139 \" << \".\\n\";\n // Add test propensity scores to test data matrix\n arma::mat T1(test_datamat.begin(), test_datamat.nrow(), test_datamat.ncol(), false);\t\t\t\t// copy the covariate test_data matrix into an arma mat\n arma::mat pihat_1_test(test_pihat.begin(), test_pihat.nrow(), test_pihat.ncol(), false);\t\t\t\t// copy the test_pihat matrix into an arma mat\n //arma::mat x_control_test_a=T1;\t\t\t\t// create a copy of test_data arma mat called x_control_test_a\n\n arma::mat x_control_test_a(T1.n_rows,T1.n_cols);\n arma::mat x_moderate_test_a(T1.n_rows,T1.n_cols);\n arma::mat pihat_a_test(pihat_1_test.n_rows,pihat_1_test.n_cols);\n\n if(is_test_data==1){\n //THIS CAN BE PARALLELIZED IF THERE ARE MANY VARIABLES\n arma::mat x_control_a_test_temp(T1.n_rows,T1.n_cols);\n\n for(unsigned int k=0; k0 ){\n x_control_test_a.insert_cols(0,pihat_a_test);\t\t// add propensity scores as new leftmost columns of x_control_test_a\n }\n }\n\n\n //NumericMatrix x_control_test=wrap(x_control_test_a);\t// convert x_control_test_a to a NumericMatrix called x_control_test\n\n\n // Name the matrix without the estimated propensity scores x_moderate_test.[CAN REMOVE THE DUPLICATION AND ADD x_control_test, x_moderate_test, and include_pi as input parameters later]\n //NumericMatrix x_moderate_test = test_data;\t// x_moderate_test matrix is the covariate test_data without the propensity scores\n //arma::mat x_moderate_test_a=T1;\t\t\t// create arma mat copy of x_moderate_test.\n if((include_pi2==1)| (include_pi2==2) ){\n if(test_pihat.nrow()>0 ){\n x_moderate_test_a.insert_cols(0,pihat_a_test);\t\t// add propensity scores as new leftmost columns of x_control_a\n }\n }\n\n //NumericMatrix x_moderate_test=wrap(x_moderate_test_a);\t// convert x_control_test_a to a NumericMatrix called x_control_test\n\n\n\n //////////////////////////////////////////////////////////////////////////////////////////\n //Rcout << \"Line 4715.\\n\";\n\n //////////////////////////////////////////////////////////////////////////////////////////\n\n //End of checks and adding propensity scores to matrices\n\n NumericVector y_scaled=scale_response(min(ytrain),max(ytrain),-0.5,0.5,ytrain);\n\n arma::vec z_ar=Rcpp::as(ztrain);\t\t// converts to arma vec\n\n\n int num_split_vars_mu= x_control_a.n_cols;\n\n int num_split_vars_tau= x_moderate_a.n_cols;\n\n\n //Rcout << \"num_split_vars_mu = \" << num_split_vars_mu << \".\\n\" ;\n //Rcout << \"num_split_vars_tau = \" << num_split_vars_tau << \".\\n\" ;\n\n //arma::mat data_arma= as(original_datamat);\n //arma::mat testdata_arma= as(test_datamat);\n\n\n arma::vec orig_y_arma= as(y_scaled);\n //arma::vec alpha_pars_arma= as(alpha_parameters);\n int num_obs = x_control_a.n_rows;\n int num_test_obs = x_control_test_a.n_rows;\n\n\n //calculations for likelihood\n arma::mat y(num_obs,1);\n y.col(0)=orig_y_arma;\n //get exponent\n double expon=(num_obs+nu)*0.5;\n //get y^Tpsi^{-1}y\n // arma::mat psi_inv=psi.i();\n arma::mat yty=y.t()*y;\n\n\n\n\n\n\n\n /////////////////////////////////////////////////////////////////////////////////////////\n\n\n\n //////////////////////////////////////////////////////////////////////////////////////\n //List table_list = draw_trees(lambda, num_trees, seed, num_split_vars, num_cats );\n\n\n\n //dqrng::dqRNGkind(\"Xoroshiro128+\");\n //dqrng::dqset_seed(IntegerVector::create(seed));\n\n //use following with binomial?\n //dqrng::xoshiro256plus rng(seed);\n\n std::vector lambdavec_mu = {lambda_mu, 1-lambda_mu};\n std::vector lambdavec_tau = {lambda_tau, 1-lambda_tau};\n\n //typedef boost::mt19937 RNGType;\n //boost::random::uniform_int_distribution<> sample_splitvardist(1,num_split_vars);\n //boost::variate_generator< RNGType, boost::uniform_int<> > sample_splitvars(rng, sample_splitvardist);\n\n //boost::random::uniform_real_distribution b_unifdist(0,1);\n //boost::variate_generator< RNGType, boost::uniform_real<> > b_unif_point(rng, b_unifdist);\n\n\n\n std::random_device device;\n //std::mt19937 gen(device());\n\n //possibly use seed?\n //// std::mt19937 gen(seed);\n\n dqrng::xoshiro256plus gen(device()); // properly seeded rng\n\n //dqrng::xoshiro256plus gen(seed); // properly seeded rng\n\n\n\n\n std::bernoulli_distribution coin_flip_mu(lambda_mu);\n std::bernoulli_distribution coin_flip_tau(lambda_tau);\n\n std::uniform_int_distribution<> distsampvar_mu(1, num_split_vars_mu);\n std::uniform_int_distribution<> distsampvar_tau(1, num_split_vars_tau);\n\n std::uniform_real_distribution<> dis_cont_unif(0, 1);\n\n\n //dqrng::uniform_distribution dis_cont_unif(0.0, 1.0); // Uniform distribution [0,1)\n\n //Following three functions can't be used in parallel\n //dqrng::dqsample_int coin_flip2(2, 1, true,lambdavec );\n //dqrng::dqsample_int distsampvar(num_split_vars, 1, true);\n //dqrng::dqrunif dis_cont_unif(1, 0, 1);\n\n\n\n //arma::mat arma_test_data(testdat_trans.begin(), testdat_trans.nrow(), testdat_trans.ncol(), false);\n\n\n arma::vec pred_vec_overall;\n arma::vec pred_vec_overall_mu;\n arma::vec pred_vec_overall_y;\n\n if(is_test_data==1){\n pred_vec_overall=arma::zeros(x_moderate_test_a.n_rows);\n }else{\n pred_vec_overall=arma::zeros(x_moderate_a.n_rows);\n pred_vec_overall_mu=arma::zeros(x_moderate_a.n_rows);\n pred_vec_overall_y=arma::zeros(x_moderate_a.n_rows);\n\n }\n\n //arma::field overall_treetables(num_models);\n\n arma::field overall_preds(num_models);\n //arma::field overall_preds_mu(num_models);\n //arma::field overall_preds_y(num_models);\n\n\n // arma::mat overall_preds(x_moderate_a.n_rows, num_models);\n // arma::mat overall_preds_mu(x_moderate_a.n_rows, num_models);\n // arma::mat overall_preds_y(x_moderate_a.n_rows, num_models);\n\n arma::vec overall_liks(num_models);\n\n\n //overall_treetables[i]= wrap(tree_table1);\n //double templik = as(treepred_output[1]);\n //overall_liks[i]= pow(lik_prod,beta_pow);\n\n //Rcout << \"Line 3338. \\n\";\n\n //Rcout << \"Line 4836.\\n\";\n\n#pragma omp parallel num_threads(ncores)\n{//start of pragma omp code\n dqrng::xoshiro256plus lgen(gen); // make thread local copy of rng\n lgen.jump(omp_get_thread_num() + 1); // advance rng by 1 ... ncores jumps\n\n#pragma omp for\n for(int j=0; j treenodes_bin;\n\n\n int count_terminals = 0;\n int count_internals = 0;\n\n //int count_treebuild = 0;\n\n\n if(imp_sampler==1){ //If sampling from BART prior\n\n double depth1=0;\n int prev_node=0; //1 if previous node splits, zero otherwise\n\n double samp_prob;\n\n while(count_internals > (count_terminals -1)){\n samp_prob=alpha_BCF_mu*pow(double(depth1+1),-beta_BCF_mu);\n std::bernoulli_distribution coin_flip2(samp_prob);\n\n int tempdraw = coin_flip2(lgen);\n treenodes_bin.push_back(tempdraw);\n\n if(tempdraw==1){\n\n depth1=depth1+1; //after a split, the depth will increase by 1\n prev_node=1;\n count_internals=count_internals+1;\n\n }else{\n\n if(prev_node==1){//zero following a 1, therefore at same depth.\n //Don't change depth. Do nothing\n }else{ //zero following a zero, therefore the depth will decrease by 1\n depth1=depth1-1;\n }\n prev_node=0;\n count_terminals=count_terminals+1;\n\n }\n\n }\n\n }else{ //If not sampling from BAT prior\n if(imp_sampler==2){//If sampling from spike and tree prior\n throw std::range_error(\"code not yet written for spike and tree sampling\");\n\n }else{//If sampling from default Q+G prior. i.e. not sampling from BART nor spike and tree prior\n\n while(count_internals > (count_terminals -1)){\n\n //Also consider standard library and random header\n // std::random_device device;\n // std::mt19937 gen(device());\n // std::bernoulli_distribution coin_flip(lambda);\n // bool outcome = coin_flip(gen);\n\n\n int tempdraw = coin_flip_mu(lgen);\n\n //int tempdraw = rbinom(n = 1, prob = lambda,size=1);\n\n\n //int tempdraw = Rcpp::rbinom(1,lambda,1);\n //int tempdraw = R::rbinom(1,lambda);\n\n ////Rcout << \"tempdraw = \" << tempdraw << \".\\n\" ;\n\n //int tempdraw = coin_flip2(lgen)-1;\n\n //int tempdraw = dqrng::dqsample_int(2, 1, true,lambdavec )-1;\n\n\n //need to update rng if use boost?\n //int tempdraw = bernoulli(rng, binomial::param_type(1, lambda));\n\n treenodes_bin.push_back(tempdraw);\n\n\n if(tempdraw==1){\n count_internals=count_internals+1;\n }else{\n count_terminals=count_terminals+1;\n }\n\n }//end of while loop creating parent vector treenodes_bin\n }\n\n }\n\n\n\n //Consider making this an armadillo vector\n //IntegerVector split_var_vec(treenodes_bin.size());\n //arma::uvec split_var_vec(treenodes_bin.size());\n std::vector split_var_vec(treenodes_bin.size());\n\n //loop drawing splitting variables\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i distsampvar(1, num_split_vars);\n //\n // split_var_vec[i] = distsampvar(engine);\n\n split_var_vec[i] = distsampvar_mu(lgen);\n\n\n //consider using boost\n //might need to update rng\n //split_var_vec[i] <- sample_splitvars(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_var_vec[i] = dqrng::dqsample_int(num_split_vars, 1, true);\n\n //not sure if this returns an integer or a vector?\n //split_var_vec[i] = RcppArmadillo::sample(num_split_vars, 1,true);\n //could try\n //split_var_vec[i] = as(Rcpp::sample(num_split_vars, 1,true));\n //could also try RcppArmadillo::rmultinom\n\n }\n\n }// end of for-loop drawing split variables\n\n\n //Consider making this an armadillo vector\n //NumericVector split_point_vec(treenodes_bin.size());\n //arma::vec split_point_vec(treenodes_bin.size());\n std::vector split_point_vec(treenodes_bin.size());\n\n\n //loop drawing splitting points\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i dis_cont_unif(0, 1);\n\n split_point_vec[i] = dis_cont_unif(lgen);\n\n //////////////////////////////////////////////////////////\n //from armadillo\n //split_point_vec[i] = arma::randu();\n\n //////////////////////////////////////////////////////////\n //probably not adviseable for paralelization\n //From Rcpp\n //split_point_vec[i] = as(Rcpp::runif(1,0,1));\n\n //////////////////////////////////////////////////////////\n //consider using boost\n //might need to update rng\n //split_point_vec[i] <- b_unif_point(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_point_vec[i] = dqrng::dqrunif(1, 0, 1);\n\n //not sure if this returns an integer or a vector?\n\n\n\n\n\n }\n\n }// end of for-loop drawing split points\n\n\n\n\n\n //CODE FOR ADJUSTING SPLITTING POINTS SO THAT THE TREES ARE VALID\n if(valid_trees==1){\n for(unsigned int i=0; iprevent_term_count-1){ //if this rule is satisfied then in subtree that is not to be updated\n continue; //still in subtree, therefore continue instead of checking for splits to be updates\n }else{\n preventing_updates=0; // no longer in subtree, therefore reset preventing_updates to zero\n }\n }\n\n\n if(sub_int_nodes>sub_term_nodes-1){\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]*first_split_point;\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }else{\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]+first_split_point-first_split_point*split_point_vec[k];\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }\n\n\n\n }//end of inner loop over k\n }//end of if statement treenodes_bin[i]==1)\n }//end of loop over i\n }//end of if statement valid_trees==1\n\n\n\n\n\n //Rcout << \"Line 5150.\\n\";\n\n\n\n\n\n //Create tree table matrix\n\n //NumericMatrix tree_table1(treenodes_bin.size(),5+num_cats);\n\n //Rcout << \"Line 1037. \\n\";\n //arma::mat tree_table1(treenodes_bin.size(),5+num_cats);\n\n //initialize with zeros. Not sure if this is necessary\n arma::mat tree_table1=arma::zeros(treenodes_bin.size(),6);\n //Rcout << \"Line 1040. \\n\";\n\n\n //tree_table1(_,2) = wrap(split_var_vec);\n //tree_table1(_,3) = wrap(split_point_vec);\n //tree_table1(_,4) = wrap(treenodes_bin);\n\n //It might be more efficient to make everything an armadillo object initially\n // but then would need to replace push_back etc with a different approach (but this might be more efficient anyway)\n arma::colvec split_var_vec_arma=arma::conv_to::from(split_var_vec);\n arma::colvec split_point_vec_arma(split_point_vec);\n arma::colvec treenodes_bin_arma=arma::conv_to::from(treenodes_bin);\n\n\n //Rcout << \"Line 1054. \\n\";\n\n //Fill in splitting variable column\n tree_table1.col(2) = split_var_vec_arma;\n //Fill in splitting point column\n tree_table1.col(3) = split_point_vec_arma;\n //Fill in split/parent column\n tree_table1.col(4) = treenodes_bin_arma;\n\n\n //Rcout << \"Line 5189. j = \" << j << \". \\n\";\n //Rcout << \"Line 5190. tree_table1 mu = \" << tree_table1 << \". \\n\";\n\n\n\n // Now start filling in left daughter and right daughter columns\n std::vector rd_spaces;\n int prev_node = -1;\n\n for(unsigned int i=0; i(terminal_nodes);\n //NumericVector tree_predictions;\n\n //now for each internal node find the observations that belong to the terminal nodes\n\n //NumericVector predictions(test_data.nrow());\n //List term_obs(term_nodes.n_elem);\n\n //GET J MATRIX\n\n if(term_nodes.n_elem==1){\n //double nodemean=tree_data(terminal_nodes[0]-1,5);\t\t\t\t// let nodemean equal tree_data row terminal_nodes[i]^th row , 6th column. The minus 1 is because terminal nodes consists of indices starting at 1, but need indices to start at 0.\n //predictions=rep(nodemean,test_data.nrow());\n //Rcout << \"Line 67 .\\n\";\n\n //IntegerVector temp_obsvec = seq_len(test_data.nrow())-1;\n //term_obs[0]= temp_obsvec;\n //double denom_temp= orig_y_arma.n_elem+arma::sum(alpha_pars_arma);\n\n //double num_prod=1;\n //double num_sum=0;\n //Rcout << \"Line 129.\\n\";\n Jmat.col(0) = arma::ones(num_obs);\n\n if(is_test_data==1){\n Jtilde.col(0) = arma::ones(num_test_obs);\n }\n\n //for(int k=0; k temp_split);\n }\n\n if(is_test_data==1){\n arma::vec temptest_vec = x_control_test_a.col(split);\n\n if(node_split_mat(0,2)==0){\n pred_test_indices = arma::find(temptest_vec <= temp_split);\n }else{\n pred_test_indices = arma::find(temptest_vec > temp_split);\n }\n }\n\n\n //Rcout << \"Line 236.\\n\";\n\n arma::uvec temp_pred_indices;\n arma::uvec temp_test_pred_indices;\n\n //arma::vec data_subset = testd.col(split);\n arma::vec data_subset = x_control_a.col(split);\n data_subset=data_subset.elem(pred_indices);\n\n arma::vec data_test_subset;\n if(is_test_data==1){\n data_test_subset =x_control_test_a.col(split);\n data_test_subset=data_test_subset.elem(pred_test_indices);\n }\n\n //now loop through each row of node_split_mat\n int n=node_split_mat.n_rows;\n //Rcout << \"Line 174. i = \" << i << \". n = \" << n << \".\\n\";\n //Rcout << \"Line 248.\\n\";\n\n for(int j=1;j split_p);\n }\n pred_indices=pred_indices.elem(temp_pred_indices);\n\n\n if(is_test_data==1){\n data_test_subset = x_control_test_a.col(curr_sv-1);\n data_test_subset=data_test_subset.elem(pred_test_indices);\n\n if(node_split_mat(j,2)==0){\n //split is to the left\n temp_test_pred_indices=arma::find(data_test_subset <= split_p);\n }else{\n //split is to the right\n temp_test_pred_indices=arma::find(data_test_subset > split_p);\n }\n pred_test_indices=pred_test_indices.elem(temp_test_pred_indices);\n\n }\n\n\n //if(pred_indices.size()==0){\n // continue;\n //}\n\n }\n //Rcout << \"Line 199. i = \" << i << \".\\n\";\n\n //There is probably a more efficient way of doing this\n //e.g. initialize J matrix so that all elements are equal to zero\n arma::vec tempcol_J=arma::zeros(num_obs);\n tempcol_J(pred_indices) = arma::ones(pred_indices.size());\n Jmat.col(i) = tempcol_J;\n\n if(is_test_data==1){\n arma::vec tempcol_Jtilde=arma::zeros(num_test_obs);\n tempcol_Jtilde(pred_test_indices) = arma::ones(pred_test_indices.size());\n Jtilde.col(i) = tempcol_Jtilde;\n }\n\n //double nodemean=tree_data(terminal_nodes[i]-1,5);\n //IntegerVector predind=as(wrap(pred_indices));\n //predictions[predind]= nodemean;\n //term_obs[i]=predind;\n\n //double denom_temp= pred_indices.n_elem+arma::sum(alpha_pars_arma);\n //Rcout << \"Line 207. predind = \" << predind << \".\\n\";\n //Rcout << \"Line 207. denom_temp = \" << denom_temp << \".\\n\";\n // << \"Line 207. term_node = \" << term_node << \".\\n\";\n\n //double num_prod=1;\n //double num_sum=0;\n\n // for(int k=0; k treenodes_bin;\n\n\n int count_terminals = 0;\n int count_internals = 0;\n\n //int count_treebuild = 0;\n\n\n if(imp_sampler==1){ //If sampling from BART prior\n\n double depth1=0;\n int prev_node=0; //1 if previous node splits, zero otherwise\n\n double samp_prob;\n\n while(count_internals > (count_terminals -1)){\n samp_prob=alpha_BCF_tau*pow(double(depth1+1),-beta_BCF_tau);\n std::bernoulli_distribution coin_flip2(samp_prob);\n\n int tempdraw = coin_flip2(lgen);\n treenodes_bin.push_back(tempdraw);\n\n if(tempdraw==1){\n\n depth1=depth1+1; //after a split, the depth will increase by 1\n prev_node=1;\n count_internals=count_internals+1;\n\n }else{\n\n if(prev_node==1){//zero following a 1, therefore at same depth.\n //Don't change depth. Do nothing\n }else{ //zero following a zero, therefore the depth will decrease by 1\n depth1=depth1-1;\n }\n prev_node=0;\n count_terminals=count_terminals+1;\n\n }\n\n }\n\n }else{ //If not sampling from BART prior\n if(imp_sampler==2){//If sampling from spike and tree prior\n throw std::range_error(\"code not yet written for spike and tree sampling\");\n\n }else{//If sampling from default Q+G prior. i.e. not sampling from BART nor spike and tree prior\n\n while(count_internals > (count_terminals -1)){\n\n //Also consider standard library and random header\n // std::random_device device;\n // std::mt19937 gen(device());\n // std::bernoulli_distribution coin_flip(lambda);\n // bool outcome = coin_flip(gen);\n\n\n int tempdraw = coin_flip_tau(lgen);\n\n //int tempdraw = rbinom(n = 1, prob = lambda,size=1);\n\n\n //int tempdraw = Rcpp::rbinom(1,lambda,1);\n //int tempdraw = R::rbinom(1,lambda);\n\n ////Rcout << \"tempdraw = \" << tempdraw << \".\\n\" ;\n\n //int tempdraw = coin_flip2(lgen)-1;\n\n //int tempdraw = dqrng::dqsample_int(2, 1, true,lambdavec )-1;\n\n\n //need to update rng if use boost?\n //int tempdraw = bernoulli(rng, binomial::param_type(1, lambda));\n\n treenodes_bin.push_back(tempdraw);\n\n\n if(tempdraw==1){\n count_internals=count_internals+1;\n }else{\n count_terminals=count_terminals+1;\n }\n\n }//end of while loop creating parent vector treenodes_bin\n }\n\n }\n\n\n\n //Consider making this an armadillo vector\n //IntegerVector split_var_vec(treenodes_bin.size());\n //arma::uvec split_var_vec(treenodes_bin.size());\n std::vector split_var_vec(treenodes_bin.size());\n\n //loop drawing splitting variables\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i distsampvar(1, num_split_vars);\n //\n // split_var_vec[i] = distsampvar(engine);\n\n split_var_vec[i] = distsampvar_tau(lgen);\n\n\n //consider using boost\n //might need to update rng\n //split_var_vec[i] <- sample_splitvars(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_var_vec[i] = dqrng::dqsample_int(num_split_vars, 1, true);\n\n //not sure if this returns an integer or a vector?\n //split_var_vec[i] = RcppArmadillo::sample(num_split_vars, 1,true);\n //could try\n //split_var_vec[i] = as(Rcpp::sample(num_split_vars, 1,true));\n //could also try RcppArmadillo::rmultinom\n\n }\n\n }// end of for-loop drawing split variables\n\n\n //Consider making this an armadillo vector\n //NumericVector split_point_vec(treenodes_bin.size());\n //arma::vec split_point_vec(treenodes_bin.size());\n std::vector split_point_vec(treenodes_bin.size());\n\n\n //loop drawing splitting points\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i dis_cont_unif(0, 1);\n\n split_point_vec[i] = dis_cont_unif(lgen);\n\n //////////////////////////////////////////////////////////\n //from armadillo\n //split_point_vec[i] = arma::randu();\n\n //////////////////////////////////////////////////////////\n //probably not adviseable for paralelization\n //From Rcpp\n //split_point_vec[i] = as(Rcpp::runif(1,0,1));\n\n //////////////////////////////////////////////////////////\n //consider using boost\n //might need to update rng\n //split_point_vec[i] <- b_unif_point(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_point_vec[i] = dqrng::dqrunif(1, 0, 1);\n\n //not sure if this returns an integer or a vector?\n\n\n\n\n\n }\n\n }// end of for-loop drawing split points\n\n\n\n //Rcout << \"Line 6000.\\n\";\n\n\n //CODE FOR ADJUSTING SPLITTING POINTS SO THAT THE TREES ARE VALID\n if(valid_trees==1){\n for(unsigned int i=0; iprevent_term_count-1){ //if this rule is satisfied then in subtree that is not to be updated\n continue; //still in subtree, therefore continue instead of checking for splits to be updates\n }else{\n preventing_updates=0; // no longer in subtree, therefore reset preventing_updates to zero\n }\n }\n\n\n if(sub_int_nodes>sub_term_nodes-1){\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]*first_split_point;\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }else{\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]+first_split_point-first_split_point*split_point_vec[k];\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }\n\n\n\n }//end of inner loop over k\n }//end of if statement treenodes_bin[i]==1)\n }//end of loop over i\n }//end of if statement valid_trees==1\n\n\n\n\n\n\n\n //Rcout << \"Line 6078.\\n\";\n\n\n\n //Create tree table matrix\n\n //NumericMatrix tree_table1(treenodes_bin.size(),5+num_cats);\n\n //Rcout << \"Line 1037. \\n\";\n //arma::mat tree_table1(treenodes_bin.size(),5+num_cats);\n\n //initialize with zeros. Not sure if this is necessary\n arma::mat tree_table1=arma::zeros(treenodes_bin.size(),6);\n //Rcout << \"Line 1040. \\n\";\n\n\n //tree_table1(_,2) = wrap(split_var_vec);\n //tree_table1(_,3) = wrap(split_point_vec);\n //tree_table1(_,4) = wrap(treenodes_bin);\n\n //It might be more efficient to make everything an armadillo object initially\n // but then would need to replace push_back etc with a different approach (but this might be more efficient anyway)\n arma::colvec split_var_vec_arma=arma::conv_to::from(split_var_vec);\n arma::colvec split_point_vec_arma(split_point_vec);\n arma::colvec treenodes_bin_arma=arma::conv_to::from(treenodes_bin);\n\n\n //Rcout << \"Line 1054. \\n\";\n\n //Fill in splitting variable column\n tree_table1.col(2) = split_var_vec_arma;\n //Fill in splitting point column\n tree_table1.col(3) = split_point_vec_arma;\n //Fill in split/parent column\n tree_table1.col(4) = treenodes_bin_arma;\n\n\n //Rcout << \"Line 1061. j = \" << j << \". \\n\";\n //Rcout << \"Line 6117. j = \" << j << \". \\n\";\n //Rcout << \"Line 6118. tree_table1 tau = \" << tree_table1 << \". \\n\";\n\n\n\n // Now start filling in left daughter and right daughter columns\n std::vector rd_spaces;\n int prev_node = -1;\n\n for(unsigned int i=0; i(terminal_nodes);\n //NumericVector tree_predictions;\n\n //now for each internal node find the observations that belong to the terminal nodes\n\n //NumericVector predictions(test_data.nrow());\n //List term_obs(term_nodes.n_elem);\n\n //GET J MATRIX\n\n if(term_nodes.n_elem==1){\n //double nodemean=tree_data(terminal_nodes[0]-1,5);\t\t\t\t// let nodemean equal tree_data row terminal_nodes[i]^th row , 6th column. The minus 1 is because terminal nodes consists of indices starting at 1, but need indices to start at 0.\n //predictions=rep(nodemean,test_data.nrow());\n //Rcout << \"Line 67 .\\n\";\n\n //IntegerVector temp_obsvec = seq_len(test_data.nrow())-1;\n //term_obs[0]= temp_obsvec;\n //double denom_temp= orig_y_arma.n_elem+arma::sum(alpha_pars_arma);\n\n //double num_prod=1;\n //double num_sum=0;\n //Rcout << \"Line 129.\\n\";\n Jmat.col(0) = arma::ones(num_obs);\n\n if(is_test_data==1){\n Jtilde.col(0) = arma::ones(num_test_obs);\n }\n\n //for(int k=0; k temp_split);\n }\n\n //Rcout << \"Line 6351.\\n\";\n\n if(is_test_data==1){\n arma::vec temptest_vec = x_moderate_test_a.col(split);\n //Rcout << \"Line 6355.\\n\";\n\n if(node_split_mat(0,2)==0){\n pred_test_indices = arma::find(temptest_vec <= temp_split);\n }else{\n pred_test_indices = arma::find(temptest_vec > temp_split);\n }\n }\n\n\n //Rcout << \"Line 6361.\\n\";\n\n arma::uvec temp_pred_indices;\n arma::uvec temp_test_pred_indices;\n\n //arma::vec data_subset = testd.col(split);\n arma::vec data_subset = x_moderate_a.col(split);\n data_subset=data_subset.elem(pred_indices);\n\n arma::vec data_test_subset;\n if(is_test_data==1){\n data_test_subset =x_moderate_test_a.col(split);\n data_test_subset=data_test_subset.elem(pred_test_indices);\n }\n\n //now loop through each row of node_split_mat\n int n=node_split_mat.n_rows;\n\n //Rcout << \"Line 6378. i = \" << i << \". n = \" << n << \".\\n\";\n\n for(int j=1;j split_p);\n }\n pred_indices=pred_indices.elem(temp_pred_indices);\n\n\n if(is_test_data==1){\n data_test_subset = x_moderate_test_a.col(curr_sv-1);\n data_test_subset=data_test_subset.elem(pred_test_indices);\n\n if(node_split_mat(j,2)==0){\n //split is to the left\n temp_test_pred_indices=arma::find(data_test_subset <= split_p);\n }else{\n //split is to the right\n temp_test_pred_indices=arma::find(data_test_subset > split_p);\n }\n pred_test_indices=pred_test_indices.elem(temp_test_pred_indices);\n\n }\n\n\n //if(pred_indices.size()==0){\n // continue;\n //}\n\n }\n //Rcout << \"Line 6425. i = \" << i << \".\\n\";\n\n //There is probably a more efficient way of doing this\n //e.g. initialize J matrix so that all elements are equal to zero\n arma::vec tempcol_J=arma::zeros(num_obs);\n tempcol_J(pred_indices) = arma::ones(pred_indices.size());\n Jmat.col(i) = tempcol_J;\n\n if(is_test_data==1){\n arma::vec tempcol_Jtilde=arma::zeros(num_test_obs);\n tempcol_Jtilde(pred_test_indices) = arma::ones(pred_test_indices.size());\n Jtilde.col(i) = tempcol_Jtilde;\n }\n\n //double nodemean=tree_data(terminal_nodes[i]-1,5);\n //IntegerVector predind=as(wrap(pred_indices));\n //predictions[predind]= nodemean;\n //term_obs[i]=predind;\n\n //double denom_temp= pred_indices.n_elem+arma::sum(alpha_pars_arma);\n //Rcout << \"Line 207. predind = \" << predind << \".\\n\";\n //Rcout << \"Line 207. denom_temp = \" << denom_temp << \".\\n\";\n // << \"Line 207. term_node = \" << term_node << \".\\n\";\n\n //double num_prod=1;\n //double num_sum=0;\n\n // for(int k=0; k(b_mu);\n arma::vec a_vec_tau = a_tau*arma::ones(b_tau);\n arma::vec a_vec(b);\n a_vec.head(b_mu) = a_vec_mu;\n a_vec.tail(b_tau) = a_vec_tau;\n aI.diag() = a_vec;\n //finish creating diagonal mat\n\n arma::mat cov = p * p.t() + aI;\n\n arma::mat parameters = arma::solve(cov, p * r.t(), arma::solve_opts::fast);\n\n arma::rowvec preds_insamp_arma=arma::trans(parameters) * p;\n\n\n\n\n\n arma::vec tempresids=y-preds_insamp_arma.t();\n double temp_sse= arma::dot(tempresids, tempresids);\n\n //double templik0=exp(-b*0.5*log(num_obs)+log(temp_sse)*(-num_obs)*0.5);\n\n\n //double templik0=exp(-b*0.5*log(num_obs)+log(temp_sse)*(-num_obs)*0.5);\n\n\n //double templik0=exp(-0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs))) ;\n\n double templik0=(num_obs*log(temp_sse/num_obs)+b*log(num_obs)) ;\n\n // Rcout << \"num_obs= \" << num_obs << \". \\n\";\n // Rcout << \"b= \" << b << \". \\n\";\n // Rcout << \"log(num_obs)= \" << log(num_obs) << \". \\n\";\n // Rcout << \"log(temp_sse/num_obs)= \" << log(temp_sse/num_obs) << \". \\n\";\n //Rcout << \"templik0= \" << templik0 << \". \\n\";\n // Rcout << \"-0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs))= \" << -0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs)) << \". \\n\";\n\n\n //double templik = pow(templik0,beta_par);\n double templik = beta_par*templik0;\n\n\n if(imp_sampler!=tree_prior){//check if importance sampler is not equal to the prior\n //templik=templik*(sum_tree_prior_prob/sum_tree_samp_prob);\n templik=templik*sum_prior_over_samp_prob;\n\n }\n overall_liks(j)= templik;\n\n\n //Now get and save predictions\n if(is_test_data==1){ //save out of sample predictions if is_test_data==1\n //arma::mat zeromat(arma::size(Wmat_mu),arma::fill::zeros);\n //arma::mat zeromat(num_obs ,b_mu ,arma::fill::zeros);\n arma::mat zeromat=arma::zeros(num_test_obs,b_mu);\n arma::mat Vmat = join_rows(zeromat,W_tilde_tau);\n\n //arma::vec preds_temp_arma= Vmat*sec_term_inv*third_term;\n\n arma::rowvec preds_temp_arma_t=arma::trans(parameters) * Vmat.t();\n arma::vec preds_temp_arma= preds_temp_arma_t.t();\n\n // overall_preds(j)=preds_temp_arma*templik;\n overall_preds(j)=preds_temp_arma;\n //overall_preds.col(j)=preds_temp_arma;\n\n\n //arma::mat covar_t=as_scalar((1/double(nu+num_obs))*(nu*lambda+yty-mvm))*(Vmat*sec_term_inv*(Vmat.t()));\n\n //arma::mat catevartemp=averagingvec.t()*covar_t*averagingvec;\n //arma::mat cattvartemp=catt_averagingvec.t()*covar_t*catt_averagingvec;\n //arma::mat catntvartemp=catnt_averagingvec.t()*covar_t*catnt_averagingvec;\n\n // preds_all_models_arma.col(i)=preds_temp_arma;\n // t_vars_arma.col(i)=covar_t.diag();\n // cate_means_arma(i)=as_scalar(averagingvec.t()*preds_temp_arma);\n // cate_means_weighted_arma(i)=cate_means_arma(i)*post_weights_arma(i);\n // cate_vars_arma(i)=as_scalar(catevartemp);\n // catt_means_arma(i)=as_scalar(catt_averagingvec.t()*preds_temp_arma);\n // catt_means_weighted_arma(i)=catt_means_arma(i)*post_weights_arma(i);\n // catt_vars_arma(i)=as_scalar(cattvartemp);\n // catnt_means_arma(i)=as_scalar(catnt_averagingvec.t()*preds_temp_arma);\n // catnt_means_weighted_arma(i)=catnt_means_arma(i)*post_weights_arma(i);\n // catnt_vars_arma(i)=as_scalar(catntvartemp);\n //\n\n }else{\n\n //arma::mat zeromat(arma::size(Wmat_mu),arma::fill::zeros);\n //arma::mat zeromat(num_obs ,b_mu ,arma::fill::zeros);\n arma::mat zeromat=arma::zeros(num_obs ,b_mu);\n arma::mat Vmat = join_rows(zeromat,Wmat_tau);\n\n //Rcout <<\"Vmat = \" << Vmat <<\".\\n\";\n\n //arma::vec preds_temp_arma= Vmat*sec_term_inv*third_term;\n\n arma::rowvec preds_temp_arma_t=arma::trans(parameters) * Vmat.t();\n arma::vec preds_temp_arma= preds_temp_arma_t.t();\n overall_preds(j)=preds_temp_arma;\n\n //overall_preds(j)=preds_temp_arma*templik;\n\n\n //arma::mat covar_t=as_scalar((1/double(nu+num_obs))*(nu*lambda+yty-mvm))*(Vmat*sec_term_inv*(Vmat.t()));\n\n //arma::mat catevartemp=averagingvec.t()*covar_t*averagingvec;\n //arma::mat cattvartemp=catt_averagingvec.t()*covar_t*catt_averagingvec;\n //arma::mat catntvartemp=catnt_averagingvec.t()*covar_t*catnt_averagingvec;\n\n // preds_all_models_arma.col(i)=preds_temp_arma;\n // t_vars_arma.col(i)=covar_t.diag();\n // cate_means_arma(i)=as_scalar(averagingvec.t()*preds_temp_arma);\n // cate_means_weighted_arma(i)=cate_means_arma(i)*post_weights_arma(i);\n // cate_vars_arma(i)=as_scalar(catevartemp);\n // catt_means_arma(i)=as_scalar(catt_averagingvec.t()*preds_temp_arma);\n // catt_means_weighted_arma(i)=catt_means_arma(i)*post_weights_arma(i);\n // catt_vars_arma(i)=as_scalar(cattvartemp);\n // catnt_means_arma(i)=as_scalar(catnt_averagingvec.t()*preds_temp_arma);\n // catnt_means_weighted_arma(i)=catnt_means_arma(i)*post_weights_arma(i);\n // catnt_vars_arma(i)=as_scalar(catntvartemp);\n //\n\n }//end of else statement (not test data)\n\n\n }else{ // if fast_approx ==0\n\n\n\n\n\n //get t(orig_y_arma)inv(psi)J_bcf\n arma::mat ytW=orig_y_arma.t()*Wmat;\t\t\t\t\t\t\t\t// orig_y_arma transpose W_bcf\n //get t(J_bcf)inv(psi)J_bcf\n arma::mat WtW=Wmat.t()*Wmat;\t\t\t\t\t\t\t// W_bcf transpose W_bcf\n //get jpsij +aI\n arma::mat aI(b,b);\t\t\t\t\t\t\t\t\t// create b by b matrix called aI. NOT INIIALIZED.\n aI=aI.eye();\t\t\t\t\t\t\t\t\t\t// a times b by b identity matrix. The .eye() turns aI into an identity matrix.\n arma::vec a_vec_mu = a_mu*arma::ones(b_mu);\n arma::vec a_vec_tau = a_tau*arma::ones(b_tau);\n arma::vec a_vec(b);\n a_vec.head(b_mu) = a_vec_mu;\n a_vec.tail(b_tau) = a_vec_tau;\n aI.diag() = a_vec;\n\n arma::mat sec_term=WtW+aI;\t\t\t\t\t\t\t//\n //arma::mat sec_term_inv=sec_term.i();\t\t\t\t\t// matrix inverse expression in middle of eq 5 in the paper. The .i() obtains the matrix inverse.\n arma::mat sec_term_inv=inv_sympd(sec_term);\t\t\t\t\t// matrix inverse expression in middle of eq 5 in the paper. The .i() obtains the matrix inverse.\n\n //get t(J_bcf)inv(psi)orig_y_arma\n arma::mat third_term=Wmat.t()*orig_y_arma;\t\t\t\t\t\t// W_bcf transpose orig_y_arma\n //get m^TV^{-1}m\n arma::mat mvm= ytW*sec_term_inv*third_term;\t\t// matrix expression in middle of equation 5\n //arma::mat rel=(b_mu*0.5)*log(a_mu)+(b_tau*0.5)*log(a_tau)-(1*0.5)*log(det(sec_term))-expon*log(nu*lambda - mvm +yty);\t\t// log of all of equation 5 (i.e. the log of the marginal likelihood of the sum of tree model)\n\n //Rcout << \"Line 14724.\\n\";\n\n\n\n //arma::vec preds_temp_arma= Vmat*sec_term_inv*Wmat.t()*orig_y_arma;\n //arma::vec preds_temp_arma= Vmat*inv_sympd(sec_term)*Wmat.t()*orig_y_arma;\n //arma::vec preds_temp_arma= Vmat*inv_sympd(sec_term)*third_term;\n\n\n //double templik0=exp(arma::as_scalar((b_mu*0.5)*log(a_mu)+(b_tau*0.5)*log(a_tau)-(0.5)*log(det(sec_term))-expon*log(nu*lambdaBCF - mvm +yty)) );\n\n //double templik0=exp(arma::as_scalar((b_mu*0.5)*log(a_mu)+(b_tau*0.5)*log(a_tau)-(0.5)*real(arma::log_det(sec_term))-expon*log(nu*lambdaBCF - mvm +yty)) );\n\n double templik0=arma::as_scalar((b_mu*0.5)*log(a_mu)+(b_tau*0.5)*log(a_tau)-(0.5)*real(arma::log_det(sec_term))-expon*log(nu*lambdaBCF - mvm +yty)) ;\n\n\n ////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n //double templik = pow(templik0,beta_par);\n double templik = beta_par*templik0;\n\n if(imp_sampler!=tree_prior){//check if importance sampler is not equal to the prior\n //templik=templik*(sum_tree_prior_prob/sum_tree_samp_prob);\n //templik=templik*sum_prior_over_samp_prob;\n templik=templik+log(sum_prior_over_samp_prob);\n\n }\n overall_liks(j)= templik;\n\n\n //now get and save predictions\n if(is_test_data==1){\n //arma::mat zeromat(arma::size(Wmat_mu),arma::fill::zeros);\n //arma::mat zeromat(num_obs ,b_mu ,arma::fill::zeros);\n arma::mat zeromat=arma::zeros(num_test_obs,b_mu);\n arma::mat Vmat = join_rows(zeromat,W_tilde_tau);\n\n\n //arma::rowvec preds_temp_arma_t=arma::trans(parameters) * Vmat.t();\n //arma::vec preds_temp_arma= preds_temp_arma_t.t();\n //overall_preds(j)=preds_temp_arma;\n\n\n arma::vec preds_temp_arma= Vmat*sec_term_inv*third_term;\n overall_preds(j)=preds_temp_arma;\n\n //overall_preds(j)=preds_temp_arma*templik;\n\n\n //arma::mat covar_t=as_scalar((1/double(nu+num_obs))*(nu*lambda+yty-mvm))*(Vmat*sec_term_inv*(Vmat.t()));\n\n //arma::mat catevartemp=averagingvec.t()*covar_t*averagingvec;\n //arma::mat cattvartemp=catt_averagingvec.t()*covar_t*catt_averagingvec;\n //arma::mat catntvartemp=catnt_averagingvec.t()*covar_t*catnt_averagingvec;\n\n // preds_all_models_arma.col(i)=preds_temp_arma;\n // t_vars_arma.col(i)=covar_t.diag();\n // cate_means_arma(i)=as_scalar(averagingvec.t()*preds_temp_arma);\n // cate_means_weighted_arma(i)=cate_means_arma(i)*post_weights_arma(i);\n // cate_vars_arma(i)=as_scalar(catevartemp);\n // catt_means_arma(i)=as_scalar(catt_averagingvec.t()*preds_temp_arma);\n // catt_means_weighted_arma(i)=catt_means_arma(i)*post_weights_arma(i);\n // catt_vars_arma(i)=as_scalar(cattvartemp);\n // catnt_means_arma(i)=as_scalar(catnt_averagingvec.t()*preds_temp_arma);\n // catnt_means_weighted_arma(i)=catnt_means_arma(i)*post_weights_arma(i);\n // catnt_vars_arma(i)=as_scalar(catntvartemp);\n //\n\n }else{\n\n //arma::mat zeromat(arma::size(Wmat_mu),arma::fill::zeros);\n //arma::mat zeromat(num_obs ,b_mu ,arma::fill::zeros);\n arma::mat zeromat=arma::zeros(num_obs ,b_mu);\n arma::mat Vmat = join_rows(zeromat,Wmat_tau);\n\n //Rcout <<\"Vmat = \" << Vmat <<\".\\n\";\n\n //arma::rowvec preds_temp_arma_t=arma::trans(parameters) * Vmat.t();\n //arma::vec preds_temp_arma= preds_temp_arma_t.t();\n //overall_preds(j)=preds_temp_arma;\n\n //Rcout <<\"coeffs = \" << sec_term_inv*third_term << \".\\n\";\n //Rcout <<\"Vmat = \" << Vmat << \".\\n\";\n //Rcout <<\"Wmat_tau = \" << Wmat_tau << \".\\n\";\n\n\n\n //arma::mat Vmattemp = join_rows(zeromat,DiagZ_Wmat_tau);\n\n //Rcout <<\"Vmattemp*coeffs = \" << Vmattemp*sec_term_inv*third_term << \".\\n\";\n //Rcout <<\"Vmat*coeffs = \" << Vmat*sec_term_inv*third_term << \".\\n\";\n\n\n //Rcout <<\"z%Vmat*coeffs = Vmattemp*coeffs?\" << z_ar%Vmat*sec_term_inv*third_term ==Vmattemp*sec_term_inv*third_term << \".\\n\";\n\n //coeffs(j)= sec_term_inv*third_term;\n\n\n arma::vec preds_temp_arma= Vmat*sec_term_inv*third_term;\n overall_preds(j)=preds_temp_arma;\n\n\n // arma::mat zeromat_mu=arma::zeros(num_obs ,b_tau);\n // arma::mat Vmat_mu = join_rows(Wmat_mu,zeromat_mu);\n // arma::vec preds_temp_arma_mu= Vmat_mu*sec_term_inv*third_term;\n //\n // //arma::vec temppredstest=preds_temp_arma%z_ar;\n // //Rcout <<\"temppredstest = \" << temppredstest << \".\\n\";\n //\n // overall_preds_mu(j)=preds_temp_arma_mu;\n //\n // arma::vec preds_temp_arma_y= Wmat*sec_term_inv*third_term;\n // overall_preds_y(j)=preds_temp_arma_y;\n\n\n //overall_preds(j)=preds_temp_arma*templik;\n\n\n //arma::mat covar_t=as_scalar((1/double(nu+num_obs))*(nu*lambda+yty-mvm))*(Vmat*sec_term_inv*(Vmat.t()));\n\n //arma::mat catevartemp=averagingvec.t()*covar_t*averagingvec;\n //arma::mat cattvartemp=catt_averagingvec.t()*covar_t*catt_averagingvec;\n //arma::mat catntvartemp=catnt_averagingvec.t()*covar_t*catnt_averagingvec;\n\n\n // preds_all_models_arma.col(i)=preds_temp_arma;\n // t_vars_arma.col(i)=covar_t.diag();\n // cate_means_arma(i)=as_scalar(averagingvec.t()*preds_temp_arma);\n // cate_means_weighted_arma(i)=cate_means_arma(i)*post_weights_arma(i);\n // cate_vars_arma(i)=as_scalar(catevartemp);\n // catt_means_arma(i)=as_scalar(catt_averagingvec.t()*preds_temp_arma);\n // catt_means_weighted_arma(i)=catt_means_arma(i)*post_weights_arma(i);\n // catt_vars_arma(i)=as_scalar(cattvartemp);\n // catnt_means_arma(i)=as_scalar(catnt_averagingvec.t()*preds_temp_arma);\n // catnt_means_weighted_arma(i)=catnt_means_arma(i)*post_weights_arma(i);\n // catnt_vars_arma(i)=as_scalar(catntvartemp);\n //\n\n }//end of else statement (not test data)\n\n\n\n }// end if statement fast_approx==1\n }//end of loop over all trees\n\n}//end of pragma omp code\n\n\n///////////////////////////////////////////////////////////////////////////////////////\n\n/////////////////////////////////////////////////////////////////////////////////\n//Rcout << \"Line 6852.\\n\";\n\n\n//for(unsigned int i=0; i(x_control_test_a.n_rows);\n// #pragma omp for nowait //fill result_private in parallel\n// for(unsigned int i=0; i(x_control_a.n_rows);\n// #pragma omp for nowait //fill result_private in parallel\n// for(unsigned int i=0; i(x_control_test_a.n_rows);\n }else{\n result_private=arma::zeros(x_control_a.n_rows);\n }\n\n#pragma omp for nowait //fill result_private in parallel\n for(unsigned int i=0; i(x_control_test_a.n_rows);\n }else{\n result_private=arma::zeros(x_control_a.n_rows);\n //result_private_mu=arma::zeros(x_control_a.n_rows);\n //result_private_y=arma::zeros(x_control_a.n_rows);\n\n }\n\n#pragma omp for nowait //fill result_private in parallel\n for(unsigned int i=0; i\n#include \n//#include \n\n// [[Rcpp::plugins(openmp)]]\n#include \n\n//' @title Parallel Safe-BART with prediction intervals\n//'\n//' @description A parallelized implementation of safe-Bayesian Additive Regression Trees.\n//' @param lambda A real number between 0 and 1 that determines the splitting probability in the prior (which is used as the importance sampler of tree models). Quadrianto and Ghahramani (2015) recommend a value less than 0.5 .\n//' @param num_trees The number of trees to be sampled.\n//' @param seed The seed for random number generation.\n//' @param num_cats The number of possible values for the outcome variable.\n//' @param y The training data vector of outcomes. This must be a vector of integers between 1 and num_cats.\n//' @param original_datamat The original training data. Currently all variables must be continuous. The training data does not need to be transformed before being entered to this function.\n//' @param alpha_parameters Vector of prior parameters.\n//' @param beta_par The power to which the likelihood is to be raised. For BMA, set beta_par=1.\n//' @param original_datamat The original test data. This matrix must have the same number of columns (variables) as the training data. Currently all variables must be continuous. The test data does not need to be transformed before being entered to this function.\n//' @param ncores The number of cores to be used in parallelization.\n//' @return A List containing 1. A vector of predictions, and 2. A matrix of prediction intervals, the first row corresponds to the lower quantile, the second row is the median, and the third row is the upper quantile.\n//' @export\n// [[Rcpp::export]]\nList sBART_with_ints_parallel(double lambda,\n int num_models,\n int num_trees,\n int seed,\n NumericVector ytrain,\n NumericMatrix original_datamat,\n double beta_par,\n NumericMatrix test_datamat,\n int ncores,\n int outsamppreds,\n double nu,\n double a,\n double lambdaBART,\n int valid_trees,\n int tree_prior,\n int imp_sampler,\n double alpha_BART,\n double beta_BART,\n int s_t_hyperprior,\n double p_s_t,\n double a_s_t,\n double b_s_t,\n double lambda_poisson,\n int fast_approx,\n double lower_prob,\n double upper_prob,\n double root_alg_precision){\n\n\n //Rcout << \"imp_sampler = \" << imp_sampler << \".\\n\";\n\n NumericVector y_scaled=scale_response(min(ytrain),max(ytrain),-0.5,0.5,ytrain);\n\n int num_split_vars= original_datamat.ncol();\n arma::mat data_arma= as(original_datamat);\n arma::mat testdata_arma= as(test_datamat);\n arma::vec orig_y_arma= as(y_scaled);\n //arma::vec alpha_pars_arma= as(alpha_parameters);\n int num_obs = data_arma.n_rows;\n int num_test_obs = testdata_arma.n_rows;\n\n int num_vars = data_arma.n_cols;\n\n //calculations for likelihood\n arma::mat y(num_obs,1);\n y.col(0)=orig_y_arma;\n //get exponent\n double expon=(num_obs+nu)*0.5;\n //get y^Tpsi^{-1}y\n // arma::mat psi_inv=psi.i();\n arma::mat yty=y.t()*y;\n\n arma::mat I_test(num_test_obs,num_test_obs);\n I_test=I_test.eye();\n\n ///////////////////////\n //NumericMatrix Data_transformed = cpptrans_cdf(original_datamat);\n // NumericMatrix Data_transformed(original_datamat.nrow(), original_datamat.ncol());\n // for(int i=0; i(originaldata);\n\n //THIS CAN BE PARALLELIZED IF THERE ARE MANY VARIABLES\n arma::mat arma_test_data(testdata_arma.n_rows,testdata_arma.n_cols);\n for(unsigned int k=0; ksref.size()){\n }else{\n while (sref(j) < ssampi && j < sref.size()){\n ++j;\n if(j==sref.size()) break;\n }\n }\n ans(ind) = j; // j is the 1-based index of the lower bound\n }\n\n arma_test_data.col(k)=(ans)/nobsref;\n\n }\n\n\n\n\n\n\n\n /////////////////////////////////////////////////////////////////////////////////////////\n\n\n\n //////////////////////////////////////////////////////////////////////////////////////\n //List table_list = draw_trees(lambda, num_trees, seed, num_split_vars, num_cats );\n\n\n\n //dqrng::dqRNGkind(\"Xoroshiro128+\");\n //dqrng::dqset_seed(IntegerVector::create(seed));\n\n //use following with binomial?\n //dqrng::xoshiro256plus rng(seed);\n\n std::vector lambdavec = {lambda, 1-lambda};\n\n //typedef boost::mt19937 RNGType;\n //boost::random::uniform_int_distribution<> sample_splitvardist(1,num_split_vars);\n //boost::variate_generator< RNGType, boost::uniform_int<> > sample_splitvars(rng, sample_splitvardist);\n\n //boost::random::uniform_real_distribution b_unifdist(0,1);\n //boost::variate_generator< RNGType, boost::uniform_real<> > b_unif_point(rng, b_unifdist);\n\n\n\n std::random_device device;\n //std::mt19937 gen(device());\n\n //possibly use seed?\n //// std::mt19937 gen(seed);\n\n dqrng::xoshiro256plus gen(device()); // properly seeded rng\n\n //dqrng::xoshiro256plus gen(seed); // properly seeded rng\n\n\n\n\n std::bernoulli_distribution coin_flip(lambda);\n\n\n std::bernoulli_distribution coin_flip_even(0.5);\n\n double spike_prob1;\n if(s_t_hyperprior==1){\n spike_prob1=a_s_t/(a_s_t + b_s_t);\n }else{\n spike_prob1=p_s_t;\n }\n\n std::bernoulli_distribution coin_flip_spike(spike_prob1);\n\n\n std::uniform_int_distribution<> distsampvar(1, num_split_vars);\n std::uniform_real_distribution<> dis_cont_unif(0, 1);\n\n std::poisson_distribution gen_num_term(lambda_poisson);\n\n\n //dqrng::uniform_distribution dis_cont_unif(0.0, 1.0); // Uniform distribution [0,1)\n\n //Following three functions can't be used in parallel\n //dqrng::dqsample_int coin_flip2(2, 1, true,lambdavec );\n //dqrng::dqsample_int distsampvar(num_split_vars, 1, true);\n //dqrng::dqrunif dis_cont_unif(1, 0, 1);\n\n\n\n //arma::mat arma_test_data(testdat_trans.begin(), testdat_trans.nrow(), testdat_trans.ncol(), false);\n\n\n arma::vec pred_vec_overall=arma::zeros(arma_test_data.n_rows);\n\n\n //arma::field overall_treetables(num_models);\n\n //::field overall_preds(num_models);\n\n arma::vec overall_liks(num_models);\n\n arma::mat overall_preds(num_test_obs,num_models);\n arma::mat t_vars_arma(num_test_obs,num_models);\n\n\n //overall_treetables[i]= wrap(tree_table1);\n //double templik = as(treepred_output[1]);\n //overall_liks[i]= pow(lik_prod,beta_pow);\n\n //Rcout << \"Line 3338. \\n\";\n\n\n#pragma omp parallel num_threads(ncores)\n{//start of pragma omp code\n dqrng::xoshiro256plus lgen(gen); // make thread local copy of rng\n lgen.jump(omp_get_thread_num() + 1); // advance rng by 1 ... ncores jumps\n\n#pragma omp for\n for(int j=0; j treenodes_bin;\n std::vector split_var_vec;\n\n\n int count_terminals = 0;\n int count_internals = 0;\n\n //int count_treebuild = 0;\n\n if(imp_sampler==2){ // If sampling from SPike and Tree\n\n //Rcout << \"Line 3737 .\\n\";\n\n\n //make coinflip_spike before loop\n //also make bernoulli with probability 0.5\n\n //make a poisson distribtion\n\n\n //might be easier to store indices as armadillo vector, because will have to remove\n //potential splits when allocating to terminal nodes\n std::vector potentialsplitvars;\n\n for(int varcount=0; varcount treenodes_bintemp(length+1);\n int p_ind=0;\n long height = 0;\n\n //Rcout << \"Line 195. \\n\";\n //Rcout << \"Line 3781 .\\n\";\n //Rcout << \"q_numsplitvars = \" << q_numsplitvars << \".\\n\";\n\n for(long i = 0; i < length+1; i ++) {\n //signed char x = random_int(1) ? 1 : -1;\n int x = coin_flip_even(lgen) ? 1 : -1;\n treenodes_bintemp[i] = x;\n height += x;\n\n if(height < 0) {\n // this should return a uniform random integer between 0 and x\n //unsigned long random_int(unsigned long x);\n std::uniform_int_distribution<> random_int(0, i);\n long j = random_int(lgen);\n //long j = random_int(i);\n //height += unfold(p_ind + j,treenodes_bintemp, i + 1 - j);\n\n long length1=i+1-j;\n long height1 = 0;\n long local_height = 0;\n int x = 1;\n\n for(long i = 0; i < length1; i ++) {\n int y = treenodes_bintemp[p_ind+j+i];\n local_height += y;\n if(local_height < 0) {\n y = 1;\n height1 += 2;\n local_height = 0;\n }\n treenodes_bintemp[p_ind+j+i] = x;\n x = y;\n }\n height +=height1;\n\n\n\n\n }\n }\n\n //Rcout << \"Line 213. \\n\";\n //Rcout << \"Line 3822 .\\n\";\n\n\n //fold(treenodes_bintemp, length + 1, height);\n long local_height = 0;\n int x = -1;\n ////Rcout << \"Line 121. \\n\";\n //Rcout << \"treenodes_bintemp.size() =\" << treenodes_bintemp.size() << \". \\n\";\n //Rcout << \"length - 1 =\" << length - 1 << \". \\n\";\n\n\n for(long i = length; height > 0; i --) {\n int y = treenodes_bintemp[i];\n local_height -= y;\n if(local_height < 0) {\n y = -1;\n height -= 2;\n local_height = 0;\n }\n treenodes_bintemp[i] = x;\n x = y;\n }\n //Rcout << \"Line 134. \\n\";\n\n\n //Rcout << \"Line 217. \\n\";\n //Rcout << \"Line 3847 .\\n\";\n\n //Rcout << \"Line 238. \\n\";\n std::replace(treenodes_bintemp.begin(), treenodes_bintemp.end(), -1, 0); // 10 99 30 30 99 10 10 99\n\n\n // Then store tree structure as treenodes_bintemp\n\n //create splitting variable vector\n std::vector splitvar_vectemp(treenodes_bintemp.size());\n\n std::vector drawnvarstemp(num_term_nodes_draw-1);\n\n //keep count of how many splitting points have been filled in\n int splitcount=0;\n\n //loop through nodes, filling in splitting variables for nonterminal nodes\n //when less than q_numsplitvars remaining internal nodes to be filled in\n //have to start reducing the set of potential splitting variables\n //to ensure that each selected potential split variable is used at least once. [hence the if statement containing .erase]\n\n int index_remaining=0;\n for(unsigned int nodecount=0; nodecountnum_term_nodes_draw-1-q_numsplitvars){//CHECK THIS CONDITION\n //To ensure each variable used at least once, fill in the rest of the splits with all the variables\n //The split variables will be randomly shuffled anyway, therefore the order is not important here.\n drawnvarstemp[splitcount-1]=potentialsplitvars[index_remaining]+1;\n index_remaining++;\n }else{\n //randomly draw a splitting varaible from the set of potential splitting variables\n std::uniform_int_distribution<> draw_var(0,potentialsplitvars.size()-1);//q_numsplitvars-splitcount could replace potentialsplitvars.size()\n int tempsplitvar = draw_var(lgen);\n drawnvarstemp[splitcount-1]=potentialsplitvars[tempsplitvar]+1;\n\n }\n\n //if(splitcount>num_term_nodes_draw-1-q_numsplitvars){//CHECK THIS CONDITION\n // potentialsplitvars.erase(potentialsplitvars.begin()+tempsplitvar);\n //}\n\n }else{//if not a split\n //splitvar_vectemp[nodecount]=-1;\n }\n }\n\n std::shuffle(drawnvarstemp.begin(),drawnvarstemp.end(),lgen);\n\n splitcount=0;\n for(unsigned int nodecount=0; nodecount (count_terminals -1)){\n samp_prob=alpha_BART*pow(double(depth1+1),-beta_BART);\n std::bernoulli_distribution coin_flip2(samp_prob);\n\n int tempdraw = coin_flip2(lgen);\n treenodes_bin.push_back(tempdraw);\n\n if(tempdraw==1){\n\n depth1=depth1+1; //after a split, the depth will increase by 1\n prev_node=1;\n count_internals=count_internals+1;\n\n }else{\n\n if(prev_node==1){//zero following a 1, therefore at same depth.\n //Don't change depth. Do nothing\n }else{ //zero following a zero, therefore the depth will decrease by 1\n depth1=depth1-1;\n }\n prev_node=0;\n count_terminals=count_terminals+1;\n\n }\n\n }\n\n }else{ //If not sampling from BART prior\n //If sampling from default Q+G prior. i.e. not sampling from BART nor spike and tree prior\n\n while(count_internals > (count_terminals -1)){\n\n //Also consider standard library and random header\n // std::random_device device;\n // std::mt19937 gen(device());\n // std::bernoulli_distribution coin_flip(lambda);\n // bool outcome = coin_flip(gen);\n\n\n int tempdraw = coin_flip(lgen);\n\n //int tempdraw = rbinom(n = 1, prob = lambda,size=1);\n\n\n //int tempdraw = Rcpp::rbinom(1,lambda,1);\n //int tempdraw = R::rbinom(1,lambda);\n\n ////Rcout << \"tempdraw = \" << tempdraw << \".\\n\" ;\n\n //int tempdraw = coin_flip2(lgen)-1;\n\n //int tempdraw = dqrng::dqsample_int(2, 1, true,lambdavec )-1;\n\n\n //need to update rng if use boost?\n //int tempdraw = bernoulli(rng, binomial::param_type(1, lambda));\n\n treenodes_bin.push_back(tempdraw);\n\n\n if(tempdraw==1){\n count_internals=count_internals+1;\n }else{\n count_terminals=count_terminals+1;\n }\n\n }//end of while loop creating parent vector treenodes_bin\n }//end of Q+H sampling else statement\n }//end of not Spike and Tree sampler else statement\n\n //Rcout << \"Line 3961 .\\n\";\n\n\n if(imp_sampler==2){\n //already filled in splitting variable above for spike and tree prior\n }else{\n //Consider making this an armadillo vector\n //IntegerVector split_var_vec(treenodes_bin.size());\n //arma::uvec split_var_vec(treenodes_bin.size());\n std::vector split_var_vectemp(treenodes_bin.size());\n\n // possibly faster alternative\n // split_var_vec.reserve( treenodes_bin.size() );\n // then push_back elements to split_var_vec in the for loop\n\n //loop drawing splitting variables\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i distsampvar(1, num_split_vars);\n //\n // split_var_vec[i] = distsampvar(engine);\n\n split_var_vectemp[i] = distsampvar(lgen);\n\n\n //consider using boost\n //might need to update rng\n //split_var_vec[i] <- sample_splitvars(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_var_vec[i] = dqrng::dqsample_int(num_split_vars, 1, true);\n\n //not sure if this returns an integer or a vector?\n //split_var_vec[i] = RcppArmadillo::sample(num_split_vars, 1,true);\n //could try\n //split_var_vec[i] = as(Rcpp::sample(num_split_vars, 1,true));\n //could also try RcppArmadillo::rmultinom\n\n }\n\n }// end of for-loop drawing split variables\n\n split_var_vec=split_var_vectemp;\n }//end else statrement filling in splitting variable vector\n\n //Consider making this an armadillo vector\n //NumericVector split_point_vec(treenodes_bin.size());\n //arma::vec split_point_vec(treenodes_bin.size());\n std::vector split_point_vec(treenodes_bin.size());\n\n\n //loop drawing splitting points\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i dis_cont_unif(0, 1);\n\n split_point_vec[i] = dis_cont_unif(lgen);\n\n //////////////////////////////////////////////////////////\n //from armadillo\n //split_point_vec[i] = arma::randu();\n\n //////////////////////////////////////////////////////////\n //probably not adviseable for paralelization\n //From Rcpp\n //split_point_vec[i] = as(Rcpp::runif(1,0,1));\n\n //////////////////////////////////////////////////////////\n //consider using boost\n //might need to update rng\n //split_point_vec[i] <- b_unif_point(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_point_vec[i] = dqrng::dqrunif(1, 0, 1);\n\n //not sure if this returns an integer or a vector?\n\n\n\n\n\n }\n\n }// end of for-loop drawing split points\n\n\n\n //Rcout << \"Line 4081 .\\n\";\n\n\n //CODE FOR ADJUSTING SPLITTING POINTS SO THAT THE TREES ARE VALID\n if(valid_trees==1){\n for(unsigned int i=0; iprevent_term_count-1){ //if this rule is satisfied then in subtree that is not to be updated\n continue; //still in subtree, therefore continue instead of checking for splits to be updates\n }else{\n preventing_updates=0; // no longer in subtree, therefore reset preventing_updates to zero\n }\n }\n\n\n if(sub_int_nodes>sub_term_nodes-1){\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]*first_split_point;\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }else{\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]+first_split_point-first_split_point*split_point_vec[k];\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }\n\n\n\n }//end of inner loop over k\n }//end of if statement treenodes_bin[i]==1)\n }//end of loop over i\n }//end of if statement valid_trees==1\n\n\n\n\n\n //Rcout << \"Line 4161 .\\n\";\n\n\n\n\n\n //Create tree table matrix\n\n //NumericMatrix tree_table1(treenodes_bin.size(),5+num_cats);\n\n ////Rcout << \"Line 1037. \\n\";\n //arma::mat tree_table1(treenodes_bin.size(),5+num_cats);\n\n //initialize with zeros. Not sure if this is necessary\n arma::mat tree_table1=arma::zeros(treenodes_bin.size(),6);\n //Rcout << \"Line 1040. \\n\";\n\n\n //tree_table1(_,2) = wrap(split_var_vec);\n //tree_table1(_,3) = wrap(split_point_vec);\n //tree_table1(_,4) = wrap(treenodes_bin);\n\n\n\n //It might be more efficient to make everything an armadillo object initially\n // but then would need to replace push_back etc with a different approach (but this might be more efficient anyway)\n arma::colvec split_var_vec_arma=arma::conv_to::from(split_var_vec);\n //arma::colvec split_point_vec_arma(split_point_vec);\n //arma::colvec split_point_vec_arma(split_point_vec);\n arma::colvec split_point_vec_arma=arma::conv_to::from(split_point_vec);\n\n arma::colvec treenodes_bin_arma=arma::conv_to::from(treenodes_bin);\n\n //Rcout << \"split_var_vec_arma = \" << split_var_vec_arma << \" . \\n\";\n\n //Rcout << \"split_point_vec_arma = \" << split_point_vec_arma << \" . \\n\";\n\n //Rcout << \"treenodes_bin_arma = \" << treenodes_bin_arma << \" . \\n\";\n\n\n //Rcout << \"Line 1054. \\n\";\n\n //Fill in splitting variable column\n tree_table1.col(2) = split_var_vec_arma;\n //Fill in splitting point column\n tree_table1.col(3) = split_point_vec_arma;\n //Fill in split/parent column\n tree_table1.col(4) = treenodes_bin_arma;\n\n\n //Rcout << \"Line 4200. j = \" << j << \". \\n\";\n\n ////Rcout << \"Line 4081 .\\n\";\n\n\n // Now start filling in left daughter and right daughter columns\n std::vector rd_spaces;\n int prev_node = -1;\n\n for(unsigned int i=0; i(terminal_nodes);\n //NumericVector tree_predictions;\n\n //now for each internal node find the observations that belong to the terminal nodes\n\n //NumericVector predictions(test_data.nrow());\n //List term_obs(term_nodes.n_elem);\n\n //GET J MATRIX\n\n //Rcout << \"Line 4311 .\\n\";\n\n if(term_nodes.n_elem==1){\n //double nodemean=tree_data(terminal_nodes[0]-1,5);\t\t\t\t// let nodemean equal tree_data row terminal_nodes[i]^th row , 6th column. The minus 1 is because terminal nodes consists of indices starting at 1, but need indices to start at 0.\n //predictions=rep(nodemean,test_data.nrow());\n //Rcout << \"Line 67 .\\n\";\n\n //IntegerVector temp_obsvec = seq_len(test_data.nrow())-1;\n //term_obs[0]= temp_obsvec;\n //double denom_temp= orig_y_arma.n_elem+arma::sum(alpha_pars_arma);\n\n //double num_prod=1;\n //double num_sum=0;\n //Rcout << \"Line 129.\\n\";\n Jmat.col(0) = arma::ones(num_obs);\n Jtilde.col(0) = arma::ones(num_test_obs);\n\n //for(int k=0; k temp_split);\n pred_test_indices = arma::find(temptest_vec > temp_split);\n }\n //Rcout << \"Line 236.\\n\";\n\n arma::uvec temp_pred_indices;\n arma::uvec temp_test_pred_indices;\n\n //arma::vec data_subset = testd.col(split);\n arma::vec data_subset = arma_orig_data.col(split);\n arma::vec data_test_subset = arma_test_data.col(split);\n\n data_subset=data_subset.elem(pred_indices);\n data_test_subset=data_test_subset.elem(pred_test_indices);\n\n //now loop through each row of node_split_mat\n int n=node_split_mat.n_rows;\n //Rcout << \"Line 174. i = \" << i << \". n = \" << n << \".\\n\";\n //Rcout << \"Line 248.\\n\";\n\n for(int j=1;j split_p);\n temp_test_pred_indices=arma::find(data_test_subset > split_p);\n }\n pred_indices=pred_indices.elem(temp_pred_indices);\n pred_test_indices=pred_test_indices.elem(temp_test_pred_indices);\n\n //if(pred_indices.size()==0){\n // continue;\n //}\n\n }\n //Rcout << \"Line 199. i = \" << i << \".\\n\";\n\n //There is probably a more efficient way of doing this\n //e.g. initialize J matrix so that all elements are equal to zero\n arma::vec tempcol_J=arma::zeros(num_obs);\n tempcol_J(pred_indices) = arma::ones(pred_indices.size());\n Jmat.col(i) = tempcol_J;\n\n arma::vec tempcol_Jtilde=arma::zeros(num_test_obs);\n tempcol_Jtilde(pred_test_indices) = arma::ones(pred_test_indices.size());\n Jtilde.col(i) = tempcol_Jtilde;\n\n //double nodemean=tree_data(terminal_nodes[i]-1,5);\n //IntegerVector predind=as(wrap(pred_indices));\n //predictions[predind]= nodemean;\n //term_obs[i]=predind;\n\n //double denom_temp= pred_indices.n_elem+arma::sum(alpha_pars_arma);\n //Rcout << \"Line 207. predind = \" << predind << \".\\n\";\n //Rcout << \"Line 207. denom_temp = \" << denom_temp << \".\\n\";\n // << \"Line 207. term_node = \" << term_node << \".\\n\";\n\n //double num_prod=1;\n //double num_sum=0;\n\n // for(int k=0; k(p.n_rows, p.n_rows);\n //\n // arma::mat parameters = arma::solve(cov, p * r.t(), arma::solve_opts::fast);\n //\n // arma::rowvec preds_temp_arma_t=arma::trans(parameters) * W_tilde.t();\n // arma::rowvec preds_insamp_arma=arma::trans(parameters) * p;\n //\n // arma::vec preds_temp_arma= preds_temp_arma_t.t();\n //\n // arma::vec tempresids=y-preds_insamp_arma.t();\n // double temp_sse= arma::dot(tempresids, tempresids);\n //\n // //double templik0=exp(-b*0.5*log(num_obs)+log(temp_sse)*(-num_obs)*0.5);\n //\n //\n // //double templik0=exp(-b*0.5*log(num_obs)+log(temp_sse)*(-num_obs)*0.5);\n //\n //\n // //double templik0=exp(-0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs))) ;\n //\n // double templik0=(num_obs*log(temp_sse/num_obs)+b*log(num_obs)) ;\n //\n // // //Rcout << \"num_obs= \" << num_obs << \". \\n\";\n // // //Rcout << \"b= \" << b << \". \\n\";\n // // Rcout << \"log(num_obs)= \" << log(num_obs) << \". \\n\";\n // // Rcout << \"log(temp_sse/num_obs)= \" << log(temp_sse/num_obs) << \". \\n\";\n // //Rcout << \"templik0= \" << templik0 << \". \\n\";\n // // Rcout << \"-0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs))= \" << -0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs)) << \". \\n\";\n //\n //\n // //double templik = pow(templik0,beta_par);\n // double templik = beta_par*templik0;\n //\n //\n // if(imp_sampler!=tree_prior){//check if importance sampler is not equal to the prior\n // //templik=templik*(sum_tree_prior_prob/sum_tree_samp_prob);\n // //templik=templik*sum_prior_over_samp_prob;\n // templik=templik+log(sum_prior_over_samp_prob);\n //\n // }\n // overall_liks(j)= templik;\n //\n // overall_preds(j)=preds_temp_arma;\n //\n // }else{\n\n\n\n // ///////////////////////////////////\n //get t(y)inv(psi)J\n arma::mat ytW=y.t()*Wmat;\n //get t(J)inv(psi)J\n arma::mat WtW=Wmat.t()*Wmat;\n //get jpsij +aI\n arma::mat aI(b,b);\n aI=a*aI.eye();\n arma::mat sec_term=WtW+aI;\n //arma::mat sec_term_inv=sec_term.i();\n arma::mat sec_term_inv=inv_sympd(sec_term);\n //get t(J)inv(psi)y\n arma::mat third_term=Wmat.t()*y;\n //get m^TV^{-1}m\n arma::mat mvm= ytW*sec_term_inv*third_term;\n //arma::mat rel=(b/2)*log(a)-(1/2)*log(det(sec_term))-expon*log(nu*lambdaBART - mvm +yty);\n // /////////////////////////////////////////////\n\n\n //\n // Rcout << \"-b*0.5*log(num_obs)= \" << -b*0.5*log(num_obs) << \". \\n\";\n // Rcout << \"log(temp_sse)*(-num_obs)*0.5= \" << log(temp_sse)*(-num_obs)*0.5 << \". \\n\";\n //\n\n //double templik0=pow(num_obs, -b*0.5)*pow(temp_sse,-num_obs*0.5);\n\n //\n // arma::vec temppred1=Wmat*sec_term_inv*third_term;\n // arma::vec temperrors= y-temppred1;\n // arma::vec tempcoeffs= sec_term_inv*third_term;\n //\n // double new_penalty= as_scalar(b*temppred1.t()*temppred1/(tempcoeffs.t()*tempcoeffs*(double(num_obs)-b)));\n //\n // Rcout << \" new_penalty =\" << new_penalty << \".\\n\";\n\n\n //double val1;\n //double sign1;\n\n //log_det(val1, sign1, sec_term);\n //double templik0=exp(arma::as_scalar((b*0.5)*log(a)-0.5*val1-expon*log(nu*lambdaBART - mvm +yty)));\n\n\n ////////////////////\n //double templik0=exp(arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term))-expon*log(nu*lambdaBART - mvm +yty)));\n //////////////\n double templik0=arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term))-expon*log(nu*lambdaBART - mvm +yty));\n\n\n\n //double templik0=exp(arma::as_scalar((b*0.5)*log(a)-0.5*log(det(sec_term))-expon*log(nu*lambdaBART - mvm +yty)));\n\n\n\n\n\n //\n //\n // arma::mat aI2(b,b);\n // aI2=new_penalty*aI2.eye();\n // arma::mat sec_term2=WtW+aI2;\n // //arma::mat sec_term_inv=sec_term.i();\n // arma::mat sec_term_inv2=inv_sympd(sec_term2);\n // //get t(J)inv(psi)y\n // //arma::mat third_term=Wmat.t()*y;\n // //get m^TV^{-1}m\n // arma::mat mvm2= ytW*sec_term_inv2*third_term;\n //\n //\n // double templik0=exp(arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term2))-expon*log(nu*lambdaBART - mvm2 +yty)));\n //\n\n\n\n\n\n // Rcout << \"log(temp_sse)= \" << log(temp_sse) << \". \\n\";\n //\n //\n // Rcout << \"temp_sse= \" << temp_sse << \". \\n\";\n //\n\n\n\n // Rcout << \"templik0= \" << templik0 << \". \\n\";\n //\n // Rcout << \"b= \" << b << \". \\n\";\n // Rcout << \"(b*0.5)*log(a)= \" << (b*0.5)*log(a) << \". \\n\";\n //\n // Rcout << \"-0.5*log(det(sec_term))= \" << -0.5*log(det(sec_term)) << \". \\n\";\n // Rcout << \"det(sec_term)= \" << det(sec_term) << \". \\n\";\n // Rcout << \"arma::det(sec_term)= \" << arma::det(sec_term) << \". \\n\";\n // Rcout << \"arma::log_det(sec_term)= \" << arma::log_det(sec_term) << \". \\n\";\n // Rcout << \"real(arma::log_det(sec_term))= \" << real(arma::log_det(sec_term)) << \". \\n\";\n // Rcout << \"log(det(sec_term))= \" << log(det(sec_term)) << \". \\n\";\n // Rcout << \"log(arma::det(sec_term))= \" << log(arma::det(sec_term)) << \". \\n\";\n //\n // Rcout << \"-expon*log(nu*lambdaBART - mvm +yty)= \" << -expon*log(nu*lambdaBART - mvm +yty) << \". \\n\";\n //\n //\n // // Rcout << \"val= \" << val << \". \\n\";\n //\n // Rcout << \"arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term))-expon*log(nu*lambdaBART - mvm +yty)) .\\n\" << arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term))-expon*log(nu*lambdaBART - mvm +yty)) << \".\\n\";\n // ////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n ////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n //overall_treetables[j]= wrap(tree_table1);\n\n\n //double templik = as(treepred_output[1]);\n\n //double templik = pow(templik0,beta_par);\n\n double templik = beta_par*templik0;\n\n if(imp_sampler!=tree_prior){//check if importance sampler is not equal to the prior\n //templik=templik*(sum_tree_prior_prob/sum_tree_samp_prob);\n //templik=templik*sum_prior_over_samp_prob;\n templik=templik+log(sum_prior_over_samp_prob);\n\n }\n overall_liks(j)= templik;\n\n // if(std::isnan(templik)){\n // Rcout << \"Line 3943, j= \" << j << \". \\n\";\n // Rcout << \"templik= \" << templik << \". \\n\";\n // Rcout << \"sum_tree_prior_prob= \" << sum_tree_prior_prob << \". \\n\";\n // Rcout << \"sum_tree_samp_prob= \" << sum_tree_samp_prob << \". \\n\";\n // }\n\n\n //now fill in the predictions\n\n //If want tree tables with predictions filled in, use\n // arma::vec term_node_par_means = sec_term_inv*third_term;\n // //and would need to save a field of tree tables,\n // //add add a column, or begin with one more column\n // //then the first treetableF[0].n_rows elements of term_node_par_means\n // //give the first\n // int row_count1=0;\n // for(int tree_i=0; tree_i < treetableF.n_elem; tree_i++){\n // tabletemp= treetableF(i);\n // tabletemp.col(5) = term_node_par_means(arma::span(row_count1,tabletemp.n_rows));\n // treetableF(i)=tabletemp;\n // row_count1+=tabletemp.n_rows;\n // }\n //This would give an alternative method for obtaining test data predictions\n //Look up the terminal nodes and add the relevant terminal node parameters\n\n\n\n\n //arma::vec pred_vec(testdata_arma.n_rows);\n\n ////////////\n arma::vec preds_temp_arma= W_tilde*sec_term_inv*third_term;\n\n ////////////////////\n\n\n\n\n\n //arma::vec preds_temp_arma= W_tilde*sec_term_inv2*third_term;\n\n\n\n //THIS SHOULD BE DIFFERENT IF THE CODE IS TO BE PARALLELIZED\n //EACH THREAD SHOULD OUTPUT ITS OWN MATRIX AND SUM OF LIKELIHOODS\n //THEN ADD THE MATRICES TOGETHER AND DIVIDE BY THE TOTAL SUM OF LIKELIHOODS\n //OR JUST SAVE ALL MATRICES TO ONE LIST\n\n\n //pred_mat_overall = pred_mat_overall + templik*pred_mat;\n //overall_treetables(j)= pred_mat*templik;\n\n\n //overall_preds(j)=preds_temp_arma*templik;\n\n overall_preds.col(j)=preds_temp_arma;\n\n\n\n arma::mat temp_for_scal = ((nu*lambdaBART+yty-mvm)/(nu+num_obs));\n double temp_scal= as_scalar(temp_for_scal) ;\n //Rcout << \"Line 4156\";\n //arma::mat covar_t=temp_scal*(I_test+w_tilde_M_inv*(W_tilde.t()));\n arma::mat covar_t=temp_scal*(I_test+W_tilde*sec_term_inv*(W_tilde.t()));\n\n t_vars_arma.col(j)=covar_t.diag();\n\n\n //Rcout << \"Line 3985, j= \" << j << \". \\n\";\n\n\n //Rcout << \"preds_temp_arma= \" << preds_temp_arma << \". \\n\";\n //Rcout << \"preds_temp_arma*templik= \" << preds_temp_arma*templik << \". \\n\";\n\n //overall_treetables(j)= pred_mat;\n //overall_liks(j) =templik;\n\n //arma::mat treeprob_output = get_test_probs(weights, num_cats,\n // testdata,\n // treetable_list[i] );\n\n //Rcout << \"Line 688. i== \" << i << \". \\n\";\n\n //double weighttemp = weights[i];\n //Rcout << \"Line 691. i== \" << i << \". \\n\";\n\n //pred_mat_overall = pred_mat_overall + weighttemp*treeprob_output;\n\n\n //}//end of else statement\n }//end of loop over all trees\n\n}//end of pragma omp code\n\n\n///////////////////////////////////////////////////////////////////////////////////////\n\n/////////////////////////////////////////////////////////////////////////////////\n\n\n//for(unsigned int i=0; i(arma_test_data.n_rows);\n// #pragma omp for nowait //fill result_private in parallel\n// for(unsigned int i=0; i(arma_test_data.n_rows);\n#pragma omp for nowait //fill result_private in parallel\n for(unsigned int i=0; i probs_for_quantiles {lower_prob, 0.5, upper_prob};\n\n\n\ntypedef std::vector stdvec;\n//std::vector weights_vec= as(post_weights);\nstd::vector weights_vec= arma::conv_to::from(weighted_lik);\n\n\nboost::math::students_t dist2(nu+num_obs);\ndouble lq_tstandard= boost::math::quantile(dist2,lower_prob);\ndouble med_tstandard= boost::math::quantile(dist2,0.5); //This is just 0 ??\ndouble uq_tstandard= boost::math::quantile(dist2,upper_prob);\n\n\nif(weights_vec.size()==1){\n#pragma omp parallel num_threads(ncores)\n#pragma omp for\n for(int i=0;i tempmeans= arma::conv_to::from(overall_preds.row(i));\n std::vector tempvars= arma::conv_to::from(t_vars_arma.row(i));\n\n //boost::math::students_t dist2(nu+num_obs);\n\n\n output(0,i)= tempmeans[0]+sqrt(tempvars[0])*lq_tstandard;\n output(1,i)= tempmeans[0]+sqrt(tempvars[0])*med_tstandard;\n output(2,i)= tempmeans[0]+sqrt(tempvars[0])*uq_tstandard;\n\n\n }\n#pragma omp barrier\n}else{\n#pragma omp parallel num_threads(ncores)\n#pragma omp for\n for(int i=0;i tempmeans= arma::conv_to::from(overall_preds.row(i));\n std::vector tempvars= arma::conv_to::from(t_vars_arma.row(i));\n\n\n std::vector bounds_lQ = mixt_find_boundsQ( nu+num_obs, tempmeans, tempvars, lq_tstandard);\n\n output(0,i)=rootmixt(nu+num_obs,\n bounds_lQ[0]-0.0001,\n bounds_lQ[1]+0.0001,\n tempmeans,\n tempvars,\n weights_vec, lower_prob,root_alg_precision);\n\n\n std::vector bounds_med = mixt_find_boundsQ( nu+num_obs, tempmeans, tempvars, med_tstandard);\n\n output(1,i)=rootmixt(nu+num_obs,\n bounds_med[0]-0.0001,\n bounds_med[1]+0.0001,\n tempmeans,\n tempvars,\n weights_vec, 0.5,root_alg_precision);\n\n std::vector bounds_uQ = mixt_find_boundsQ( nu+num_obs, tempmeans, tempvars, uq_tstandard);\n\n output(2,i)=rootmixt(nu+num_obs,\n bounds_uQ[0]-0.0001,\n bounds_uQ[1]+0.0001,\n tempmeans,\n tempvars,\n weights_vec, upper_prob,root_alg_precision);\n\n\n }\n#pragma omp barrier\n}\n\n\n//Rcout << \"Line 10924. \\n\";\n\narma::mat output_rescaled(output.n_rows, output.n_cols);\n\ndouble min_y = min(ytrain);\ndouble max_y = max(ytrain);\n\n#pragma omp parallel num_threads(ncores)\n#pragma omp for\nfor(unsigned int i=0;i\n#include \n//#include \n\n// [[Rcpp::plugins(openmp)]]\n#include \n\n//' @title Parallel Safe-Bayesian Causal Forest\n//'\n//' @description A parallelized implementation of the Safe-Bayesian Random Forest described by Quadrianto and Ghahramani (2015)\n//' @param lambda A real number between 0 and 1 that determines the splitting probability in the prior (which is used as the importance sampler of tree models). Quadrianto and Ghahramani (2015) recommend a value less than 0.5 .\n//' @param num_trees The number of trees to be sampled.\n//' @param seed The seed for random number generation.\n//' @param num_cats The number of possible values for the outcome variable.\n//' @param y The training data vector of outcomes. This must be a vector of integers between 1 and num_cats.\n//' @param original_datamat The original training data. Currently all variables must be continuous. The training data does not need to be transformed before being entered to this function.\n//' @param alpha_parameters Vector of prior parameters.\n//' @param beta_par The power to which the likelihood is to be raised. For BMA, set beta_par=1.\n//' @param original_datamat The original test data. This matrix must have the same number of columns (variables) as the training data. Currently all variables must be continuous. The test data does not need to be transformed before being entered to this function.\n//' @param ncores The number of cores to be used in parallelization.\n//' @return A matrix of probabilities with the number of rows equl to the number of test observations and the number of columns equal to the number of possible outcome categories.\n//' @export\n// [[Rcpp::export]]\nList sBCF_with_ints_parallel(double lambda_mu,\n double lambda_tau,\n int num_models,\n int num_trees_mu,\n int num_trees_tau,\n int seed,\n NumericVector ytrain,\n NumericMatrix original_datamat,\n NumericVector ztrain,\n NumericMatrix pihat_train,\n double beta_par,\n NumericMatrix test_datamat,\n NumericMatrix test_pihat,\n int ncores,\n int outsamppreds,\n double nu,\n double a_mu,\n double a_tau,\n double lambdaBCF,\n int valid_trees,\n int tree_prior,\n int imp_sampler,\n double alpha_BCF_mu,\n double beta_BCF_mu,\n double alpha_BCF_tau,\n double beta_BCF_tau,\n int include_pi2,\n int fast_approx,\n int PIT_propensity,\n double lower_prob,\n double upper_prob,\n double root_alg_precision){\n\n\n //Check that various input vectors and matrices have consistent dimensions\n\n //Rcout << \"Line 4528.\\n\";\n\n bool is_test_data=0;\t\t\t\t\t// create bool is_test_data. Initialize equal to 0.\n if(test_datamat.nrow()>0){\t\t\t\t\t// If test data has non-zero number of rows.\n is_test_data=1;\t\t\t\t\t\t// set is_test_data equal to 1.\n }\n if(ytrain.size() !=original_datamat.nrow()){\t\t\t\t// If the length of input vector y is not equal to the nunber of rows in the input data (covariates)\n if(ytrain.size()0 && (original_datamat.ncol() != test_datamat.ncol())){\t// If the number of rows in the test data is >0 AND the number of columns (variables) is not equal to that of data (the training data)\n throw std::range_error(\"Test data and training data must have the same number of variables. BART BMA assumes variables are in the same order.\");\n }\n //if(test_z.size() != test_datamat.nrow()){\t// If the number of rows in the test data covariate matrix is not equal to that of the test data treatment indicator variable\n // throw std::range_error(\"Test data covariates and test data treatment indicator variable must have the same number of observations.\");\n //}\n if(test_datamat.nrow() != test_pihat.nrow()){\t// If the number of rows in the test data covariate matrix is not equal to that of the test data propensity score estimates matrix\n throw std::range_error(\"Test data covariates and test data propensity score estimates must have the same number of observations.\");\n }\n if(test_pihat.nrow()>0 && (pihat_train.ncol() != test_pihat.ncol())){\t// If the number of rows in the test data propensity score estimates is >0 AND the number of columns (variables) is not equal to that of the training data propensity score estimates\n throw std::range_error(\"Test data propensity score estimates and training data propensity score estimates must have the same number of columns. BART BMA assumes variables are in the same order.\");\n }\n\n ///////////////////////////////////////////////////////////////////////////////////////////////\n ///////////////////////////////////////////////////////////////////////////////////////////////\n\n\n\n // Now add propensity score estimates matrix as new leftmost column of data matrix. Call the resulting matrix x_control (to be consistent with terminology used by bcf package).\n arma::mat D1(original_datamat.begin(), original_datamat.nrow(), original_datamat.ncol(), false);\t\t\t\t// copy the covariate data matrix into an arma mat\n arma::mat pihat_1(pihat_train.begin(), pihat_train.nrow(), pihat_train.ncol(), false);\t\t\t\t// copy the pihat matrix into an arma mat\n //arma::mat x_control_a=D1;\t\t\t\t// create a copy of data arma mat called x_control_a\n\n\n //THIS CAN BE PARALLELIZED IF THERE ARE MANY VARIABLES\n arma::mat x_control_a_temp(D1.n_rows,D1.n_cols);\n for(unsigned int k=0; k0 ){\n x_control_a.insert_cols(0,pihat_a);\t\t// add propensity scores as new leftmost columns of x_control_a\n }\n }\n // Rcout << \"Number of columns of matrix\" << x_control_a.n_cols << \".\\n\";\n\n\n //NumericMatrix x_control=wrap(x_control_a);\t// convert x_control_a to a NumericMatrix called x_control\n\n // Name the matrix without the estimated propensity scores x_moderate.[CAN REMOVE THE DUPLICATION AND ADD x_control, x_moderate, and include_pi as input parameters later]\n //NumericMatrix x_moderate = data;\t// x_moderate matrix is the covariate data without the propensity scores\n //arma::mat x_moderate_a=D1;\t\t\t// create arma mat copy of x_moderate.\n if((include_pi2==1)| (include_pi2==2) ){\n if(pihat_train.nrow()>0 ){\n x_moderate_a.insert_cols(0,pihat_a);\t\t// add propensity scores as new leftmost columns of x_control_a\n }\n }\n\n\n //NumericMatrix x_moderate=wrap(x_moderate_a);\t// convert x_control_a to a NumericMatrix called x_control\n\n\n // Rcout << \"Get to Line 7139 \" << \".\\n\";\n // Add test propensity scores to test data matrix\n arma::mat T1(test_datamat.begin(), test_datamat.nrow(), test_datamat.ncol(), false);\t\t\t\t// copy the covariate test_data matrix into an arma mat\n arma::mat pihat_1_test(test_pihat.begin(), test_pihat.nrow(), test_pihat.ncol(), false);\t\t\t\t// copy the test_pihat matrix into an arma mat\n //arma::mat x_control_test_a=T1;\t\t\t\t// create a copy of test_data arma mat called x_control_test_a\n\n arma::mat x_control_test_a(T1.n_rows,T1.n_cols);\n arma::mat x_moderate_test_a(T1.n_rows,T1.n_cols);\n arma::mat pihat_a_test(pihat_1_test.n_rows,pihat_1_test.n_cols);\n\n if(is_test_data==1){\n //THIS CAN BE PARALLELIZED IF THERE ARE MANY VARIABLES\n arma::mat x_control_a_test_temp(T1.n_rows,T1.n_cols);\n\n for(unsigned int k=0; k0 ){\n x_control_test_a.insert_cols(0,pihat_a_test);\t\t// add propensity scores as new leftmost columns of x_control_test_a\n }\n }\n\n\n //NumericMatrix x_control_test=wrap(x_control_test_a);\t// convert x_control_test_a to a NumericMatrix called x_control_test\n\n\n // Name the matrix without the estimated propensity scores x_moderate_test.[CAN REMOVE THE DUPLICATION AND ADD x_control_test, x_moderate_test, and include_pi as input parameters later]\n //NumericMatrix x_moderate_test = test_data;\t// x_moderate_test matrix is the covariate test_data without the propensity scores\n //arma::mat x_moderate_test_a=T1;\t\t\t// create arma mat copy of x_moderate_test.\n if((include_pi2==1)| (include_pi2==2) ){\n if(test_pihat.nrow()>0 ){\n x_moderate_test_a.insert_cols(0,pihat_a_test);\t\t// add propensity scores as new leftmost columns of x_control_a\n }\n }\n\n //NumericMatrix x_moderate_test=wrap(x_moderate_test_a);\t// convert x_control_test_a to a NumericMatrix called x_control_test\n\n\n\n //////////////////////////////////////////////////////////////////////////////////////////\n //Rcout << \"Line 4715.\\n\";\n\n //////////////////////////////////////////////////////////////////////////////////////////\n\n //End of checks and adding propensity scores to matrices\n\n NumericVector y_scaled=scale_response(min(ytrain),max(ytrain),-0.5,0.5,ytrain);\n\n arma::vec z_ar=Rcpp::as(ztrain);\t\t// converts to arma vec\n\n\n int num_split_vars_mu= x_control_a.n_cols;\n\n int num_split_vars_tau= x_moderate_a.n_cols;\n\n\n //Rcout << \"num_split_vars_mu = \" << num_split_vars_mu << \".\\n\" ;\n //Rcout << \"num_split_vars_tau = \" << num_split_vars_tau << \".\\n\" ;\n\n //arma::mat data_arma= as(original_datamat);\n //arma::mat testdata_arma= as(test_datamat);\n\n\n arma::vec orig_y_arma= as(y_scaled);\n //arma::vec alpha_pars_arma= as(alpha_parameters);\n int num_obs = x_control_a.n_rows;\n int num_test_obs = x_control_test_a.n_rows;\n\n\n //calculations for likelihood\n arma::mat y(num_obs,1);\n y.col(0)=orig_y_arma;\n //get exponent\n double expon=(num_obs+nu)*0.5;\n //get y^Tpsi^{-1}y\n // arma::mat psi_inv=psi.i();\n arma::mat yty=y.t()*y;\n\n\n\n\n\n\n\n /////////////////////////////////////////////////////////////////////////////////////////\n\n\n\n //////////////////////////////////////////////////////////////////////////////////////\n //List table_list = draw_trees(lambda, num_trees, seed, num_split_vars, num_cats );\n\n\n\n //dqrng::dqRNGkind(\"Xoroshiro128+\");\n //dqrng::dqset_seed(IntegerVector::create(seed));\n\n //use following with binomial?\n //dqrng::xoshiro256plus rng(seed);\n\n std::vector lambdavec_mu = {lambda_mu, 1-lambda_mu};\n std::vector lambdavec_tau = {lambda_tau, 1-lambda_tau};\n\n //typedef boost::mt19937 RNGType;\n //boost::random::uniform_int_distribution<> sample_splitvardist(1,num_split_vars);\n //boost::variate_generator< RNGType, boost::uniform_int<> > sample_splitvars(rng, sample_splitvardist);\n\n //boost::random::uniform_real_distribution b_unifdist(0,1);\n //boost::variate_generator< RNGType, boost::uniform_real<> > b_unif_point(rng, b_unifdist);\n\n\n\n std::random_device device;\n //std::mt19937 gen(device());\n\n //possibly use seed?\n //// std::mt19937 gen(seed);\n\n dqrng::xoshiro256plus gen(device()); // properly seeded rng\n\n //dqrng::xoshiro256plus gen(seed); // properly seeded rng\n\n\n\n\n std::bernoulli_distribution coin_flip_mu(lambda_mu);\n std::bernoulli_distribution coin_flip_tau(lambda_tau);\n\n std::uniform_int_distribution<> distsampvar_mu(1, num_split_vars_mu);\n std::uniform_int_distribution<> distsampvar_tau(1, num_split_vars_tau);\n\n std::uniform_real_distribution<> dis_cont_unif(0, 1);\n\n\n //dqrng::uniform_distribution dis_cont_unif(0.0, 1.0); // Uniform distribution [0,1)\n\n //Following three functions can't be used in parallel\n //dqrng::dqsample_int coin_flip2(2, 1, true,lambdavec );\n //dqrng::dqsample_int distsampvar(num_split_vars, 1, true);\n //dqrng::dqrunif dis_cont_unif(1, 0, 1);\n\n\n\n //arma::mat arma_test_data(testdat_trans.begin(), testdat_trans.nrow(), testdat_trans.ncol(), false);\n\n\n arma::vec pred_vec_overall;\n arma::vec pred_vec_overall_mu;\n arma::vec pred_vec_overall_y;\n\n if(is_test_data==1){\n pred_vec_overall=arma::zeros(x_moderate_test_a.n_rows);\n }else{\n pred_vec_overall=arma::zeros(x_moderate_a.n_rows);\n pred_vec_overall_mu=arma::zeros(x_moderate_a.n_rows);\n pred_vec_overall_y=arma::zeros(x_moderate_a.n_rows);\n\n }\n\n //arma::field overall_treetables(num_models);\n\n //arma::field overall_preds(num_models);\n\n arma::mat overall_preds;\n if(is_test_data==1){\n overall_preds= arma::zeros(num_test_obs,num_models);\n }else{\n overall_preds= arma::zeros(num_obs,num_models);\n }\n\n //arma::field overall_preds_mu(num_models);\n //arma::field overall_preds_y(num_models);\n\n\n arma::mat t_vars_arma;\n if(is_test_data==1){\n t_vars_arma= arma::zeros(num_test_obs,num_models);\n }else{\n t_vars_arma= arma::zeros(num_obs,num_models);\n }\n\n\n\n // arma::mat overall_preds(x_moderate_a.n_rows, num_models);\n // arma::mat overall_preds_mu(x_moderate_a.n_rows, num_models);\n // arma::mat overall_preds_y(x_moderate_a.n_rows, num_models);\n\n arma::vec overall_liks(num_models);\n\n\n arma::vec cate_means_arma(num_models);\n arma::vec cate_vars_arma(num_models);\n\n arma::vec averagingvec=(1/double(num_obs))*arma::ones(num_obs);\n\n //overall_treetables[i]= wrap(tree_table1);\n //double templik = as(treepred_output[1]);\n //overall_liks[i]= pow(lik_prod,beta_pow);\n\n //Rcout << \"Line 3338. \\n\";\n\n //Rcout << \"Line 4836.\\n\";\n\n#pragma omp parallel num_threads(ncores)\n{//start of pragma omp code\n dqrng::xoshiro256plus lgen(gen); // make thread local copy of rng\n lgen.jump(omp_get_thread_num() + 1); // advance rng by 1 ... ncores jumps\n\n#pragma omp for\n for(int j=0; j treenodes_bin;\n\n\n int count_terminals = 0;\n int count_internals = 0;\n\n //int count_treebuild = 0;\n\n\n if(imp_sampler==1){ //If sampling from BART prior\n\n double depth1=0;\n int prev_node=0; //1 if previous node splits, zero otherwise\n\n double samp_prob;\n\n while(count_internals > (count_terminals -1)){\n samp_prob=alpha_BCF_mu*pow(double(depth1+1),-beta_BCF_mu);\n std::bernoulli_distribution coin_flip2(samp_prob);\n\n int tempdraw = coin_flip2(lgen);\n treenodes_bin.push_back(tempdraw);\n\n if(tempdraw==1){\n\n depth1=depth1+1; //after a split, the depth will increase by 1\n prev_node=1;\n count_internals=count_internals+1;\n\n }else{\n\n if(prev_node==1){//zero following a 1, therefore at same depth.\n //Don't change depth. Do nothing\n }else{ //zero following a zero, therefore the depth will decrease by 1\n depth1=depth1-1;\n }\n prev_node=0;\n count_terminals=count_terminals+1;\n\n }\n\n }\n\n }else{ //If not sampling from BAT prior\n if(imp_sampler==2){//If sampling from spike and tree prior\n throw std::range_error(\"code not yet written for spike and tree sampling\");\n\n }else{//If sampling from default Q+G prior. i.e. not sampling from BART nor spike and tree prior\n\n while(count_internals > (count_terminals -1)){\n\n //Also consider standard library and random header\n // std::random_device device;\n // std::mt19937 gen(device());\n // std::bernoulli_distribution coin_flip(lambda);\n // bool outcome = coin_flip(gen);\n\n\n int tempdraw = coin_flip_mu(lgen);\n\n //int tempdraw = rbinom(n = 1, prob = lambda,size=1);\n\n\n //int tempdraw = Rcpp::rbinom(1,lambda,1);\n //int tempdraw = R::rbinom(1,lambda);\n\n ////Rcout << \"tempdraw = \" << tempdraw << \".\\n\" ;\n\n //int tempdraw = coin_flip2(lgen)-1;\n\n //int tempdraw = dqrng::dqsample_int(2, 1, true,lambdavec )-1;\n\n\n //need to update rng if use boost?\n //int tempdraw = bernoulli(rng, binomial::param_type(1, lambda));\n\n treenodes_bin.push_back(tempdraw);\n\n\n if(tempdraw==1){\n count_internals=count_internals+1;\n }else{\n count_terminals=count_terminals+1;\n }\n\n }//end of while loop creating parent vector treenodes_bin\n }\n\n }\n\n\n\n //Consider making this an armadillo vector\n //IntegerVector split_var_vec(treenodes_bin.size());\n //arma::uvec split_var_vec(treenodes_bin.size());\n std::vector split_var_vec(treenodes_bin.size());\n\n //loop drawing splitting variables\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i distsampvar(1, num_split_vars);\n //\n // split_var_vec[i] = distsampvar(engine);\n\n split_var_vec[i] = distsampvar_mu(lgen);\n\n\n //consider using boost\n //might need to update rng\n //split_var_vec[i] <- sample_splitvars(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_var_vec[i] = dqrng::dqsample_int(num_split_vars, 1, true);\n\n //not sure if this returns an integer or a vector?\n //split_var_vec[i] = RcppArmadillo::sample(num_split_vars, 1,true);\n //could try\n //split_var_vec[i] = as(Rcpp::sample(num_split_vars, 1,true));\n //could also try RcppArmadillo::rmultinom\n\n }\n\n }// end of for-loop drawing split variables\n\n\n //Consider making this an armadillo vector\n //NumericVector split_point_vec(treenodes_bin.size());\n //arma::vec split_point_vec(treenodes_bin.size());\n std::vector split_point_vec(treenodes_bin.size());\n\n\n //loop drawing splitting points\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i dis_cont_unif(0, 1);\n\n split_point_vec[i] = dis_cont_unif(lgen);\n\n //////////////////////////////////////////////////////////\n //from armadillo\n //split_point_vec[i] = arma::randu();\n\n //////////////////////////////////////////////////////////\n //probably not adviseable for paralelization\n //From Rcpp\n //split_point_vec[i] = as(Rcpp::runif(1,0,1));\n\n //////////////////////////////////////////////////////////\n //consider using boost\n //might need to update rng\n //split_point_vec[i] <- b_unif_point(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_point_vec[i] = dqrng::dqrunif(1, 0, 1);\n\n //not sure if this returns an integer or a vector?\n\n\n\n\n\n }\n\n }// end of for-loop drawing split points\n\n\n\n\n\n //CODE FOR ADJUSTING SPLITTING POINTS SO THAT THE TREES ARE VALID\n if(valid_trees==1){\n for(unsigned int i=0; iprevent_term_count-1){ //if this rule is satisfied then in subtree that is not to be updated\n continue; //still in subtree, therefore continue instead of checking for splits to be updates\n }else{\n preventing_updates=0; // no longer in subtree, therefore reset preventing_updates to zero\n }\n }\n\n\n if(sub_int_nodes>sub_term_nodes-1){\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]*first_split_point;\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }else{\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]+first_split_point-first_split_point*split_point_vec[k];\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }\n\n\n\n }//end of inner loop over k\n }//end of if statement treenodes_bin[i]==1)\n }//end of loop over i\n }//end of if statement valid_trees==1\n\n\n\n\n\n //Rcout << \"Line 5150.\\n\";\n\n\n\n\n\n //Create tree table matrix\n\n //NumericMatrix tree_table1(treenodes_bin.size(),5+num_cats);\n\n //Rcout << \"Line 1037. \\n\";\n //arma::mat tree_table1(treenodes_bin.size(),5+num_cats);\n\n //initialize with zeros. Not sure if this is necessary\n arma::mat tree_table1=arma::zeros(treenodes_bin.size(),6);\n //Rcout << \"Line 1040. \\n\";\n\n\n //tree_table1(_,2) = wrap(split_var_vec);\n //tree_table1(_,3) = wrap(split_point_vec);\n //tree_table1(_,4) = wrap(treenodes_bin);\n\n //It might be more efficient to make everything an armadillo object initially\n // but then would need to replace push_back etc with a different approach (but this might be more efficient anyway)\n arma::colvec split_var_vec_arma=arma::conv_to::from(split_var_vec);\n arma::colvec split_point_vec_arma(split_point_vec);\n arma::colvec treenodes_bin_arma=arma::conv_to::from(treenodes_bin);\n\n\n //Rcout << \"Line 1054. \\n\";\n\n //Fill in splitting variable column\n tree_table1.col(2) = split_var_vec_arma;\n //Fill in splitting point column\n tree_table1.col(3) = split_point_vec_arma;\n //Fill in split/parent column\n tree_table1.col(4) = treenodes_bin_arma;\n\n\n //Rcout << \"Line 5189. j = \" << j << \". \\n\";\n //Rcout << \"Line 5190. tree_table1 mu = \" << tree_table1 << \". \\n\";\n\n\n\n // Now start filling in left daughter and right daughter columns\n std::vector rd_spaces;\n int prev_node = -1;\n\n for(unsigned int i=0; i(terminal_nodes);\n //NumericVector tree_predictions;\n\n //now for each internal node find the observations that belong to the terminal nodes\n\n //NumericVector predictions(test_data.nrow());\n //List term_obs(term_nodes.n_elem);\n\n //GET J MATRIX\n\n if(term_nodes.n_elem==1){\n //double nodemean=tree_data(terminal_nodes[0]-1,5);\t\t\t\t// let nodemean equal tree_data row terminal_nodes[i]^th row , 6th column. The minus 1 is because terminal nodes consists of indices starting at 1, but need indices to start at 0.\n //predictions=rep(nodemean,test_data.nrow());\n //Rcout << \"Line 67 .\\n\";\n\n //IntegerVector temp_obsvec = seq_len(test_data.nrow())-1;\n //term_obs[0]= temp_obsvec;\n //double denom_temp= orig_y_arma.n_elem+arma::sum(alpha_pars_arma);\n\n //double num_prod=1;\n //double num_sum=0;\n //Rcout << \"Line 129.\\n\";\n Jmat.col(0) = arma::ones(num_obs);\n\n if(is_test_data==1){\n Jtilde.col(0) = arma::ones(num_test_obs);\n }\n\n //for(int k=0; k temp_split);\n }\n\n if(is_test_data==1){\n arma::vec temptest_vec = x_control_test_a.col(split);\n\n if(node_split_mat(0,2)==0){\n pred_test_indices = arma::find(temptest_vec <= temp_split);\n }else{\n pred_test_indices = arma::find(temptest_vec > temp_split);\n }\n }\n\n\n //Rcout << \"Line 236.\\n\";\n\n arma::uvec temp_pred_indices;\n arma::uvec temp_test_pred_indices;\n\n //arma::vec data_subset = testd.col(split);\n arma::vec data_subset = x_control_a.col(split);\n data_subset=data_subset.elem(pred_indices);\n\n arma::vec data_test_subset;\n if(is_test_data==1){\n data_test_subset =x_control_test_a.col(split);\n data_test_subset=data_test_subset.elem(pred_test_indices);\n }\n\n //now loop through each row of node_split_mat\n int n=node_split_mat.n_rows;\n //Rcout << \"Line 174. i = \" << i << \". n = \" << n << \".\\n\";\n //Rcout << \"Line 248.\\n\";\n\n for(int j=1;j split_p);\n }\n pred_indices=pred_indices.elem(temp_pred_indices);\n\n\n if(is_test_data==1){\n data_test_subset = x_control_test_a.col(curr_sv-1);\n data_test_subset=data_test_subset.elem(pred_test_indices);\n\n if(node_split_mat(j,2)==0){\n //split is to the left\n temp_test_pred_indices=arma::find(data_test_subset <= split_p);\n }else{\n //split is to the right\n temp_test_pred_indices=arma::find(data_test_subset > split_p);\n }\n pred_test_indices=pred_test_indices.elem(temp_test_pred_indices);\n\n }\n\n\n //if(pred_indices.size()==0){\n // continue;\n //}\n\n }\n //Rcout << \"Line 199. i = \" << i << \".\\n\";\n\n //There is probably a more efficient way of doing this\n //e.g. initialize J matrix so that all elements are equal to zero\n arma::vec tempcol_J=arma::zeros(num_obs);\n tempcol_J(pred_indices) = arma::ones(pred_indices.size());\n Jmat.col(i) = tempcol_J;\n\n if(is_test_data==1){\n arma::vec tempcol_Jtilde=arma::zeros(num_test_obs);\n tempcol_Jtilde(pred_test_indices) = arma::ones(pred_test_indices.size());\n Jtilde.col(i) = tempcol_Jtilde;\n }\n\n //double nodemean=tree_data(terminal_nodes[i]-1,5);\n //IntegerVector predind=as(wrap(pred_indices));\n //predictions[predind]= nodemean;\n //term_obs[i]=predind;\n\n //double denom_temp= pred_indices.n_elem+arma::sum(alpha_pars_arma);\n //Rcout << \"Line 207. predind = \" << predind << \".\\n\";\n //Rcout << \"Line 207. denom_temp = \" << denom_temp << \".\\n\";\n // << \"Line 207. term_node = \" << term_node << \".\\n\";\n\n //double num_prod=1;\n //double num_sum=0;\n\n // for(int k=0; k treenodes_bin;\n\n\n int count_terminals = 0;\n int count_internals = 0;\n\n //int count_treebuild = 0;\n\n\n if(imp_sampler==1){ //If sampling from BART prior\n\n double depth1=0;\n int prev_node=0; //1 if previous node splits, zero otherwise\n\n double samp_prob;\n\n while(count_internals > (count_terminals -1)){\n samp_prob=alpha_BCF_tau*pow(double(depth1+1),-beta_BCF_tau);\n std::bernoulli_distribution coin_flip2(samp_prob);\n\n int tempdraw = coin_flip2(lgen);\n treenodes_bin.push_back(tempdraw);\n\n if(tempdraw==1){\n\n depth1=depth1+1; //after a split, the depth will increase by 1\n prev_node=1;\n count_internals=count_internals+1;\n\n }else{\n\n if(prev_node==1){//zero following a 1, therefore at same depth.\n //Don't change depth. Do nothing\n }else{ //zero following a zero, therefore the depth will decrease by 1\n depth1=depth1-1;\n }\n prev_node=0;\n count_terminals=count_terminals+1;\n\n }\n\n }\n\n }else{ //If not sampling from BART prior\n if(imp_sampler==2){//If sampling from spike and tree prior\n throw std::range_error(\"code not yet written for spike and tree sampling\");\n\n }else{//If sampling from default Q+G prior. i.e. not sampling from BART nor spike and tree prior\n\n while(count_internals > (count_terminals -1)){\n\n //Also consider standard library and random header\n // std::random_device device;\n // std::mt19937 gen(device());\n // std::bernoulli_distribution coin_flip(lambda);\n // bool outcome = coin_flip(gen);\n\n\n int tempdraw = coin_flip_tau(lgen);\n\n //int tempdraw = rbinom(n = 1, prob = lambda,size=1);\n\n\n //int tempdraw = Rcpp::rbinom(1,lambda,1);\n //int tempdraw = R::rbinom(1,lambda);\n\n ////Rcout << \"tempdraw = \" << tempdraw << \".\\n\" ;\n\n //int tempdraw = coin_flip2(lgen)-1;\n\n //int tempdraw = dqrng::dqsample_int(2, 1, true,lambdavec )-1;\n\n\n //need to update rng if use boost?\n //int tempdraw = bernoulli(rng, binomial::param_type(1, lambda));\n\n treenodes_bin.push_back(tempdraw);\n\n\n if(tempdraw==1){\n count_internals=count_internals+1;\n }else{\n count_terminals=count_terminals+1;\n }\n\n }//end of while loop creating parent vector treenodes_bin\n }\n\n }\n\n\n\n //Consider making this an armadillo vector\n //IntegerVector split_var_vec(treenodes_bin.size());\n //arma::uvec split_var_vec(treenodes_bin.size());\n std::vector split_var_vec(treenodes_bin.size());\n\n //loop drawing splitting variables\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i distsampvar(1, num_split_vars);\n //\n // split_var_vec[i] = distsampvar(engine);\n\n split_var_vec[i] = distsampvar_tau(lgen);\n\n\n //consider using boost\n //might need to update rng\n //split_var_vec[i] <- sample_splitvars(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_var_vec[i] = dqrng::dqsample_int(num_split_vars, 1, true);\n\n //not sure if this returns an integer or a vector?\n //split_var_vec[i] = RcppArmadillo::sample(num_split_vars, 1,true);\n //could try\n //split_var_vec[i] = as(Rcpp::sample(num_split_vars, 1,true));\n //could also try RcppArmadillo::rmultinom\n\n }\n\n }// end of for-loop drawing split variables\n\n\n //Consider making this an armadillo vector\n //NumericVector split_point_vec(treenodes_bin.size());\n //arma::vec split_point_vec(treenodes_bin.size());\n std::vector split_point_vec(treenodes_bin.size());\n\n\n //loop drawing splitting points\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i dis_cont_unif(0, 1);\n\n split_point_vec[i] = dis_cont_unif(lgen);\n\n //////////////////////////////////////////////////////////\n //from armadillo\n //split_point_vec[i] = arma::randu();\n\n //////////////////////////////////////////////////////////\n //probably not adviseable for paralelization\n //From Rcpp\n //split_point_vec[i] = as(Rcpp::runif(1,0,1));\n\n //////////////////////////////////////////////////////////\n //consider using boost\n //might need to update rng\n //split_point_vec[i] <- b_unif_point(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_point_vec[i] = dqrng::dqrunif(1, 0, 1);\n\n //not sure if this returns an integer or a vector?\n\n\n\n\n\n }\n\n }// end of for-loop drawing split points\n\n\n\n //Rcout << \"Line 6000.\\n\";\n\n\n //CODE FOR ADJUSTING SPLITTING POINTS SO THAT THE TREES ARE VALID\n if(valid_trees==1){\n for(unsigned int i=0; iprevent_term_count-1){ //if this rule is satisfied then in subtree that is not to be updated\n continue; //still in subtree, therefore continue instead of checking for splits to be updates\n }else{\n preventing_updates=0; // no longer in subtree, therefore reset preventing_updates to zero\n }\n }\n\n\n if(sub_int_nodes>sub_term_nodes-1){\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]*first_split_point;\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }else{\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]+first_split_point-first_split_point*split_point_vec[k];\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }\n\n\n\n }//end of inner loop over k\n }//end of if statement treenodes_bin[i]==1)\n }//end of loop over i\n }//end of if statement valid_trees==1\n\n\n\n\n\n\n\n //Rcout << \"Line 6078.\\n\";\n\n\n\n //Create tree table matrix\n\n //NumericMatrix tree_table1(treenodes_bin.size(),5+num_cats);\n\n //Rcout << \"Line 1037. \\n\";\n //arma::mat tree_table1(treenodes_bin.size(),5+num_cats);\n\n //initialize with zeros. Not sure if this is necessary\n arma::mat tree_table1=arma::zeros(treenodes_bin.size(),6);\n //Rcout << \"Line 1040. \\n\";\n\n\n //tree_table1(_,2) = wrap(split_var_vec);\n //tree_table1(_,3) = wrap(split_point_vec);\n //tree_table1(_,4) = wrap(treenodes_bin);\n\n //It might be more efficient to make everything an armadillo object initially\n // but then would need to replace push_back etc with a different approach (but this might be more efficient anyway)\n arma::colvec split_var_vec_arma=arma::conv_to::from(split_var_vec);\n arma::colvec split_point_vec_arma(split_point_vec);\n arma::colvec treenodes_bin_arma=arma::conv_to::from(treenodes_bin);\n\n\n //Rcout << \"Line 1054. \\n\";\n\n //Fill in splitting variable column\n tree_table1.col(2) = split_var_vec_arma;\n //Fill in splitting point column\n tree_table1.col(3) = split_point_vec_arma;\n //Fill in split/parent column\n tree_table1.col(4) = treenodes_bin_arma;\n\n\n //Rcout << \"Line 1061. j = \" << j << \". \\n\";\n //Rcout << \"Line 6117. j = \" << j << \". \\n\";\n //Rcout << \"Line 6118. tree_table1 tau = \" << tree_table1 << \". \\n\";\n\n\n\n // Now start filling in left daughter and right daughter columns\n std::vector rd_spaces;\n int prev_node = -1;\n\n for(unsigned int i=0; i(terminal_nodes);\n //NumericVector tree_predictions;\n\n //now for each internal node find the observations that belong to the terminal nodes\n\n //NumericVector predictions(test_data.nrow());\n //List term_obs(term_nodes.n_elem);\n\n //GET J MATRIX\n\n if(term_nodes.n_elem==1){\n //double nodemean=tree_data(terminal_nodes[0]-1,5);\t\t\t\t// let nodemean equal tree_data row terminal_nodes[i]^th row , 6th column. The minus 1 is because terminal nodes consists of indices starting at 1, but need indices to start at 0.\n //predictions=rep(nodemean,test_data.nrow());\n //Rcout << \"Line 67 .\\n\";\n\n //IntegerVector temp_obsvec = seq_len(test_data.nrow())-1;\n //term_obs[0]= temp_obsvec;\n //double denom_temp= orig_y_arma.n_elem+arma::sum(alpha_pars_arma);\n\n //double num_prod=1;\n //double num_sum=0;\n //Rcout << \"Line 129.\\n\";\n Jmat.col(0) = arma::ones(num_obs);\n\n if(is_test_data==1){\n Jtilde.col(0) = arma::ones(num_test_obs);\n }\n\n //for(int k=0; k temp_split);\n }\n\n //Rcout << \"Line 6351.\\n\";\n\n if(is_test_data==1){\n arma::vec temptest_vec = x_moderate_test_a.col(split);\n //Rcout << \"Line 6355.\\n\";\n\n if(node_split_mat(0,2)==0){\n pred_test_indices = arma::find(temptest_vec <= temp_split);\n }else{\n pred_test_indices = arma::find(temptest_vec > temp_split);\n }\n }\n\n\n //Rcout << \"Line 6361.\\n\";\n\n arma::uvec temp_pred_indices;\n arma::uvec temp_test_pred_indices;\n\n //arma::vec data_subset = testd.col(split);\n arma::vec data_subset = x_moderate_a.col(split);\n data_subset=data_subset.elem(pred_indices);\n\n arma::vec data_test_subset;\n if(is_test_data==1){\n data_test_subset =x_moderate_test_a.col(split);\n data_test_subset=data_test_subset.elem(pred_test_indices);\n }\n\n //now loop through each row of node_split_mat\n int n=node_split_mat.n_rows;\n\n //Rcout << \"Line 6378. i = \" << i << \". n = \" << n << \".\\n\";\n\n for(int j=1;j split_p);\n }\n pred_indices=pred_indices.elem(temp_pred_indices);\n\n\n if(is_test_data==1){\n data_test_subset = x_moderate_test_a.col(curr_sv-1);\n data_test_subset=data_test_subset.elem(pred_test_indices);\n\n if(node_split_mat(j,2)==0){\n //split is to the left\n temp_test_pred_indices=arma::find(data_test_subset <= split_p);\n }else{\n //split is to the right\n temp_test_pred_indices=arma::find(data_test_subset > split_p);\n }\n pred_test_indices=pred_test_indices.elem(temp_test_pred_indices);\n\n }\n\n\n //if(pred_indices.size()==0){\n // continue;\n //}\n\n }\n //Rcout << \"Line 6425. i = \" << i << \".\\n\";\n\n //There is probably a more efficient way of doing this\n //e.g. initialize J matrix so that all elements are equal to zero\n arma::vec tempcol_J=arma::zeros(num_obs);\n tempcol_J(pred_indices) = arma::ones(pred_indices.size());\n Jmat.col(i) = tempcol_J;\n\n if(is_test_data==1){\n arma::vec tempcol_Jtilde=arma::zeros(num_test_obs);\n tempcol_Jtilde(pred_test_indices) = arma::ones(pred_test_indices.size());\n Jtilde.col(i) = tempcol_Jtilde;\n }\n\n //double nodemean=tree_data(terminal_nodes[i]-1,5);\n //IntegerVector predind=as(wrap(pred_indices));\n //predictions[predind]= nodemean;\n //term_obs[i]=predind;\n\n //double denom_temp= pred_indices.n_elem+arma::sum(alpha_pars_arma);\n //Rcout << \"Line 207. predind = \" << predind << \".\\n\";\n //Rcout << \"Line 207. denom_temp = \" << denom_temp << \".\\n\";\n // << \"Line 207. term_node = \" << term_node << \".\\n\";\n\n //double num_prod=1;\n //double num_sum=0;\n\n // for(int k=0; k(b_mu);\n // arma::vec a_vec_tau = a_tau*arma::ones(b_tau);\n // arma::vec a_vec(b);\n // a_vec.head(b_mu) = a_vec_mu;\n // a_vec.tail(b_tau) = a_vec_tau;\n // aI.diag() = a_vec;\n // //finish creating diagonal mat\n //\n // arma::mat cov = p * p.t() + aI;\n //\n // arma::mat parameters = arma::solve(cov, p * r.t(), arma::solve_opts::fast);\n //\n // arma::rowvec preds_insamp_arma=arma::trans(parameters) * p;\n //\n //\n //\n //\n //\n // arma::vec tempresids=y-preds_insamp_arma.t();\n // double temp_sse= arma::dot(tempresids, tempresids);\n //\n // //double templik0=exp(-b*0.5*log(num_obs)+log(temp_sse)*(-num_obs)*0.5);\n //\n //\n // //double templik0=exp(-b*0.5*log(num_obs)+log(temp_sse)*(-num_obs)*0.5);\n //\n //\n // //double templik0=exp(-0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs))) ;\n //\n // double templik0=(num_obs*log(temp_sse/num_obs)+b*log(num_obs)) ;\n //\n // // Rcout << \"num_obs= \" << num_obs << \". \\n\";\n // // Rcout << \"b= \" << b << \". \\n\";\n // // Rcout << \"log(num_obs)= \" << log(num_obs) << \". \\n\";\n // // Rcout << \"log(temp_sse/num_obs)= \" << log(temp_sse/num_obs) << \". \\n\";\n // //Rcout << \"templik0= \" << templik0 << \". \\n\";\n // // Rcout << \"-0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs))= \" << -0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs)) << \". \\n\";\n //\n //\n // //double templik = pow(templik0,beta_par);\n // double templik = beta_par*templik0;\n //\n //\n // if(imp_sampler!=tree_prior){//check if importance sampler is not equal to the prior\n // //templik=templik*(sum_tree_prior_prob/sum_tree_samp_prob);\n // templik=templik*sum_prior_over_samp_prob;\n //\n // }\n // overall_liks(j)= templik;\n //\n //\n // //Now get and save predictions\n // if(is_test_data==1){ //save out of sample predictions if is_test_data==1\n // //arma::mat zeromat(arma::size(Wmat_mu),arma::fill::zeros);\n // //arma::mat zeromat(num_obs ,b_mu ,arma::fill::zeros);\n // arma::mat zeromat=arma::zeros(num_test_obs,b_mu);\n // arma::mat Vmat = join_rows(zeromat,W_tilde_tau);\n //\n // //arma::vec preds_temp_arma= Vmat*sec_term_inv*third_term;\n //\n // arma::rowvec preds_temp_arma_t=arma::trans(parameters) * Vmat.t();\n // arma::vec preds_temp_arma= preds_temp_arma_t.t();\n //\n // // overall_preds(j)=preds_temp_arma*templik;\n // overall_preds.col(j)=preds_temp_arma;\n // //overall_preds.col(j)=preds_temp_arma;\n //\n //\n // //arma::mat covar_t=as_scalar((1/double(nu+num_obs))*(nu*lambdaBCF+yty-mvm))*(Vmat*sec_term_inv*(Vmat.t()));\n //\n // //arma::mat catevartemp=averagingvec.t()*covar_t*averagingvec;\n // //arma::mat cattvartemp=catt_averagingvec.t()*covar_t*catt_averagingvec;\n // //arma::mat catntvartemp=catnt_averagingvec.t()*covar_t*catnt_averagingvec;\n //\n // //preds_all_models_arma.col(i)=preds_temp_arma;\n // t_vars_arma.col(j)=covar_t.diag();\n // cate_means_arma(j)=as_scalar(averagingvec.t()*preds_temp_arma);\n // // cate_means_weighted_arma(i)=cate_means_arma(i)*post_weights_arma(i);\n // cate_vars_arma(j)=as_scalar(catevartemp);\n // // catt_means_arma(i)=as_scalar(catt_averagingvec.t()*preds_temp_arma);\n // // catt_means_weighted_arma(i)=catt_means_arma(i)*post_weights_arma(i);\n // // catt_vars_arma(i)=as_scalar(cattvartemp);\n // // catnt_means_arma(i)=as_scalar(catnt_averagingvec.t()*preds_temp_arma);\n // // catnt_means_weighted_arma(i)=catnt_means_arma(i)*post_weights_arma(i);\n // // catnt_vars_arma(i)=as_scalar(catntvartemp);\n // //\n //\n // }else{\n //\n // //arma::mat zeromat(arma::size(Wmat_mu),arma::fill::zeros);\n // //arma::mat zeromat(num_obs ,b_mu ,arma::fill::zeros);\n // arma::mat zeromat=arma::zeros(num_obs ,b_mu);\n // arma::mat Vmat = join_rows(zeromat,Wmat_tau);\n //\n // //Rcout <<\"Vmat = \" << Vmat <<\".\\n\";\n //\n // //arma::vec preds_temp_arma= Vmat*sec_term_inv*third_term;\n //\n // arma::rowvec preds_temp_arma_t=arma::trans(parameters) * Vmat.t();\n // arma::vec preds_temp_arma= preds_temp_arma_t.t();\n // overall_preds.col(j)=preds_temp_arma;\n //\n // //overall_preds(j)=preds_temp_arma*templik;\n //\n //\n // arma::mat covar_t=as_scalar((1/double(nu+num_obs))*(nu*lambdaBCF+yty-mvm))*(Vmat*sec_term_inv*(Vmat.t()));\n //\n // //arma::mat catevartemp=averagingvec.t()*covar_t*averagingvec;\n // //arma::mat cattvartemp=catt_averagingvec.t()*covar_t*catt_averagingvec;\n // //arma::mat catntvartemp=catnt_averagingvec.t()*covar_t*catnt_averagingvec;\n //\n // // preds_all_models_arma.col(i)=preds_temp_arma;\n // t_vars_arma.col(j)=covar_t.diag();\n // cate_means_arma(j)=as_scalar(averagingvec.t()*preds_temp_arma);\n // // cate_means_weighted_arma(i)=cate_means_arma(i)*post_weights_arma(i);\n // cate_vars_arma(j)=as_scalacalar(catt_averagingvec.t()*preds_temp_arma);\n // // catt_means_weighted_armr(catevartemp);\n // // catt_means_arma(i)=as_sa(i)=catt_means_arma(i)*post_weights_arma(i);\n // // catt_vars_arma(i)=as_scalar(cattvartemp);\n // // catnt_means_arma(i)=as_scalar(catnt_averagingvec.t()*preds_temp_arma);\n // // catnt_means_weighted_arma(i)=catnt_means_arma(i)*post_weights_arma(i);\n // // catnt_vars_arma(i)=as_scalar(catntvartemp);\n // //\n //\n // }//end of else statement (not test data)\n //\n //\n // }else{ // if fast_approx ==0\n //\n\n\n\n\n //get t(orig_y_arma)inv(psi)J_bcf\n arma::mat ytW=orig_y_arma.t()*Wmat;\t\t\t\t\t\t\t\t// orig_y_arma transpose W_bcf\n //get t(J_bcf)inv(psi)J_bcf\n arma::mat WtW=Wmat.t()*Wmat;\t\t\t\t\t\t\t// W_bcf transpose W_bcf\n //get jpsij +aI\n arma::mat aI(b,b);\t\t\t\t\t\t\t\t\t// create b by b matrix called aI. NOT INIIALIZED.\n aI=aI.eye();\t\t\t\t\t\t\t\t\t\t// a times b by b identity matrix. The .eye() turns aI into an identity matrix.\n arma::vec a_vec_mu = a_mu*arma::ones(b_mu);\n arma::vec a_vec_tau = a_tau*arma::ones(b_tau);\n arma::vec a_vec(b);\n a_vec.head(b_mu) = a_vec_mu;\n a_vec.tail(b_tau) = a_vec_tau;\n aI.diag() = a_vec;\n\n arma::mat sec_term=WtW+aI;\t\t\t\t\t\t\t//\n //arma::mat sec_term_inv=sec_term.i();\t\t\t\t\t// matrix inverse expression in middle of eq 5 in the paper. The .i() obtains the matrix inverse.\n arma::mat sec_term_inv=inv_sympd(sec_term);\t\t\t\t\t// matrix inverse expression in middle of eq 5 in the paper. The .i() obtains the matrix inverse.\n\n //get t(J_bcf)inv(psi)orig_y_arma\n arma::mat third_term=Wmat.t()*orig_y_arma;\t\t\t\t\t\t// W_bcf transpose orig_y_arma\n //get m^TV^{-1}m\n arma::mat mvm= ytW*sec_term_inv*third_term;\t\t// matrix expression in middle of equation 5\n //arma::mat rel=(b_mu*0.5)*log(a_mu)+(b_tau*0.5)*log(a_tau)-(1*0.5)*log(det(sec_term))-expon*log(nu*lambda - mvm +yty);\t\t// log of all of equation 5 (i.e. the log of the marginal likelihood of the sum of tree model)\n\n //Rcout << \"Line 14724.\\n\";\n\n\n\n //arma::vec preds_temp_arma= Vmat*sec_term_inv*Wmat.t()*orig_y_arma;\n //arma::vec preds_temp_arma= Vmat*inv_sympd(sec_term)*Wmat.t()*orig_y_arma;\n //arma::vec preds_temp_arma= Vmat*inv_sympd(sec_term)*third_term;\n\n\n //double templik0=exp(arma::as_scalar((b_mu*0.5)*log(a_mu)+(b_tau*0.5)*log(a_tau)-(0.5)*log(det(sec_term))-expon*log(nu*lambdaBCF - mvm +yty)) );\n\n //double templik0=exp(arma::as_scalar((b_mu*0.5)*log(a_mu)+(b_tau*0.5)*log(a_tau)-(0.5)*real(arma::log_det(sec_term))-expon*log(nu*lambdaBCF - mvm +yty)) );\n\n double templik0=arma::as_scalar((b_mu*0.5)*log(a_mu)+(b_tau*0.5)*log(a_tau)-(0.5)*real(arma::log_det(sec_term))-expon*log(nu*lambdaBCF - mvm +yty)) ;\n\n\n ////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n //double templik = pow(templik0,beta_par);\n double templik = beta_par*templik0;\n\n if(imp_sampler!=tree_prior){//check if importance sampler is not equal to the prior\n //templik=templik*(sum_tree_prior_prob/sum_tree_samp_prob);\n //templik=templik*sum_prior_over_samp_prob;\n templik=templik+log(sum_prior_over_samp_prob);\n\n }\n overall_liks(j)= templik;\n\n\n //now get and save predictions\n if(is_test_data==1){\n //arma::mat zeromat(arma::size(Wmat_mu),arma::fill::zeros);\n //arma::mat zeromat(num_obs ,b_mu ,arma::fill::zeros);\n arma::mat zeromat=arma::zeros(num_test_obs,b_mu);\n arma::mat Vmat = join_rows(zeromat,W_tilde_tau);\n\n\n //arma::rowvec preds_temp_arma_t=arma::trans(parameters) * Vmat.t();\n //arma::vec preds_temp_arma= preds_temp_arma_t.t();\n //overall_preds(j)=preds_temp_arma;\n\n\n arma::vec preds_temp_arma= Vmat*sec_term_inv*third_term;\n overall_preds.col(j)=preds_temp_arma;\n\n //overall_preds(j)=preds_temp_arma*templik;\n\n\n arma::mat covar_t=as_scalar((1/double(nu+num_obs))*(nu*lambdaBCF+yty-mvm))*(Vmat*sec_term_inv*(Vmat.t()));\n\n arma::mat catevartemp=averagingvec.t()*covar_t*averagingvec;\n //arma::mat cattvartemp=catt_averagingvec.t()*covar_t*catt_averagingvec;\n //arma::mat catntvartemp=catnt_averagingvec.t()*covar_t*catnt_averagingvec;\n\n // preds_all_models_arma.col(i)=preds_temp_arma;\n t_vars_arma.col(j)=covar_t.diag();\n cate_means_arma(j)=as_scalar(averagingvec.t()*preds_temp_arma);\n // cate_means_weighted_arma(i)=cate_means_arma(i)*post_weights_arma(i);\n cate_vars_arma(j)=as_scalar(catevartemp);\n // catt_means_arma(i)=as_scalar(catt_averagingvec.t()*preds_temp_arma);\n // catt_means_weighted_arma(i)=catt_means_arma(i)*post_weights_arma(i);\n // catt_vars_arma(i)=as_scalar(cattvartemp);\n // catnt_means_arma(i)=as_scalar(catnt_averagingvec.t()*preds_temp_arma);\n // catnt_means_weighted_arma(i)=catnt_means_arma(i)*post_weights_arma(i);\n // catnt_vars_arma(i)=as_scalar(catntvartemp);\n //\n\n }else{\n\n //arma::mat zeromat(arma::size(Wmat_mu),arma::fill::zeros);\n //arma::mat zeromat(num_obs ,b_mu ,arma::fill::zeros);\n arma::mat zeromat=arma::zeros(num_obs ,b_mu);\n arma::mat Vmat = join_rows(zeromat,Wmat_tau);\n\n //Rcout <<\"Vmat = \" << Vmat <<\".\\n\";\n\n //arma::rowvec preds_temp_arma_t=arma::trans(parameters) * Vmat.t();\n //arma::vec preds_temp_arma= preds_temp_arma_t.t();\n //overall_preds(j)=preds_temp_arma;\n\n //Rcout <<\"coeffs = \" << sec_term_inv*third_term << \".\\n\";\n //Rcout <<\"Vmat = \" << Vmat << \".\\n\";\n //Rcout <<\"Wmat_tau = \" << Wmat_tau << \".\\n\";\n\n\n\n //arma::mat Vmattemp = join_rows(zeromat,DiagZ_Wmat_tau);\n\n //Rcout <<\"Vmattemp*coeffs = \" << Vmattemp*sec_term_inv*third_term << \".\\n\";\n //Rcout <<\"Vmat*coeffs = \" << Vmat*sec_term_inv*third_term << \".\\n\";\n\n\n //Rcout <<\"z%Vmat*coeffs = Vmattemp*coeffs?\" << z_ar%Vmat*sec_term_inv*third_term ==Vmattemp*sec_term_inv*third_term << \".\\n\";\n\n //coeffs(j)= sec_term_inv*third_term;\n\n\n arma::vec preds_temp_arma= Vmat*sec_term_inv*third_term;\n overall_preds.col(j)=preds_temp_arma;\n\n\n // arma::mat zeromat_mu=arma::zeros(num_obs ,b_tau);\n // arma::mat Vmat_mu = join_rows(Wmat_mu,zeromat_mu);\n // arma::vec preds_temp_arma_mu= Vmat_mu*sec_term_inv*third_term;\n //\n // //arma::vec temppredstest=preds_temp_arma%z_ar;\n // //Rcout <<\"temppredstest = \" << temppredstest << \".\\n\";\n //\n // overall_preds_mu(j)=preds_temp_arma_mu;\n //\n // arma::vec preds_temp_arma_y= Wmat*sec_term_inv*third_term;\n // overall_preds_y(j)=preds_temp_arma_y;\n\n\n //overall_preds(j)=preds_temp_arma*templik;\n\n\n arma::mat covar_t=as_scalar((1/double(nu+num_obs))*(nu*lambdaBCF+yty-mvm))*(Vmat*sec_term_inv*(Vmat.t()));\n\n arma::mat catevartemp=averagingvec.t()*covar_t*averagingvec;\n //arma::mat cattvartemp=catt_averagingvec.t()*covar_t*catt_averagingvec;\n //arma::mat catntvartemp=catnt_averagingvec.t()*covar_t*catnt_averagingvec;\n\n\n // preds_all_models_arma.col(i)=preds_temp_arma;\n t_vars_arma.col(j)=covar_t.diag();\n cate_means_arma(j)=as_scalar(averagingvec.t()*preds_temp_arma);\n // cate_means_weighted_arma(i)=cate_means_arma(i)*post_weights_arma(i);\n cate_vars_arma(j)=as_scalar(catevartemp);\n // catt_means_arma(i)=as_scalar(catt_averagingvec.t()*preds_temp_arma);\n // catt_means_weighted_arma(i)=catt_means_arma(i)*post_weights_arma(i);\n // catt_vars_arma(i)=as_scalar(cattvartemp);\n // catnt_means_arma(i)=as_scalar(catnt_averagingvec.t()*preds_temp_arma);\n // catnt_means_weighted_arma(i)=catnt_means_arma(i)*post_weights_arma(i);\n // catnt_vars_arma(i)=as_scalar(catntvartemp);\n //\n\n }//end of else statement (not test data)\n\n\n\n // } // end if statement fast_approx==1\n }//end of loop over all trees\n\n}//end of pragma omp code\n\n\n///////////////////////////////////////////////////////////////////////////////////////\n\n/////////////////////////////////////////////////////////////////////////////////\n//Rcout << \"Line 6852.\\n\";\n\n\n//for(unsigned int i=0; i(x_control_test_a.n_rows);\n// #pragma omp for nowait //fill result_private in parallel\n// for(unsigned int i=0; i(x_control_a.n_rows);\n// #pragma omp for nowait //fill result_private in parallel\n// for(unsigned int i=0; i probs_for_quantiles {lower_prob, 0.5, upper_prob};\narma::mat cate_ints(3, 1);\n//arma::mat catt_ints(3, 1);\n//arma::mat catnt_ints(3, 1);\n\n\n\n\n\n\n\n\n\n\n\n\nif(fast_approx==1){\n arma::vec BICi=-0.5*overall_liks;\n double max_BIC=max(BICi);\n\n // weighted_BIC is actually the posterior model probability\n arma::vec weighted_BIC(overall_liks.size());\n\n\n double tempterm=(max_BIC+log(sum(exp(BICi-max_BIC))));\n\n for(unsigned int k=0;k(x_control_test_a.n_rows);\n }else{\n result_private=arma::zeros(x_control_a.n_rows);\n }\n\n#pragma omp for nowait //fill result_private in parallel\n for(unsigned int i=0; i(x_control_test_a.n_rows);\n }else{\n result_private=arma::zeros(x_control_a.n_rows);\n //result_private_mu=arma::zeros(x_control_a.n_rows);\n //result_private_y=arma::zeros(x_control_a.n_rows);\n\n }\n\n#pragma omp for nowait //fill result_private in parallel\n for(unsigned int i=0; i stdvec;\n std::vector weights_vec= arma::conv_to::from(weighted_lik);\n\n boost::math::students_t dist2(nu+num_obs);\n double lq_tstandard= boost::math::quantile(dist2,lower_prob);\n double med_tstandard= boost::math::quantile(dist2,0.5); //This is just 0 ??\n double uq_tstandard= boost::math::quantile(dist2,upper_prob);\n\n\n\n ///////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n\n\n\n if(weights_vec.size()==1){\n\n cate_ints(0,0)= cate_means_arma(0)+sqrt(cate_vars_arma(0))*lq_tstandard;\n cate_ints(1,0)= cate_means_arma(0)+sqrt(cate_vars_arma(0))*med_tstandard;\n cate_ints(2,0)= cate_means_arma(0)+sqrt(cate_vars_arma(0))*uq_tstandard;\n\n // catt_ints(0,0)= catt_means_arma(0)+sqrt(catt_vars_arma(0))*lq_tstandard;\n // catt_ints(1,0)= catt_means_arma(0)+sqrt(catt_vars_arma(0))*med_tstandard;\n // catt_ints(2,0)= catt_means_arma(0)+sqrt(catt_vars_arma(0))*uq_tstandard;\n //\n // catnt_ints(0,0)= catnt_means_arma(0)+sqrt(catnt_vars_arma(0))*lq_tstandard;\n // catnt_ints(1,0)= catnt_means_arma(0)+sqrt(catnt_vars_arma(0))*med_tstandard;\n // catnt_ints(2,0)= catnt_means_arma(0)+sqrt(catnt_vars_arma(0))*uq_tstandard;\n\n#pragma omp parallel num_threads(ncores)\n#pragma omp for\n for(int i=0;i tempmeans= arma::conv_to::from(overall_preds.row(i));\n std::vector tempvars= arma::conv_to::from(t_vars_arma.row(i));\n\n //boost::math::students_t dist2(nu+num_obs);\n\n //Rcout << \"Line 13812 tempvars\" << t_vars_arma.row(i) << \".\\n\";\n //Rcout << \"tempmeans\" << overall_preds.row(i) << \".\\n\";\n\n\n output(0,i)= tempmeans[0]+sqrt(tempvars[0])*lq_tstandard;\n output(1,i)= tempmeans[0]+sqrt(tempvars[0])*med_tstandard;\n output(2,i)= tempmeans[0]+sqrt(tempvars[0])*uq_tstandard;\n\n\n }\n#pragma omp barrier\n }else{\n std::vector tempmeans_cate= arma::conv_to::from(cate_means_arma);\n std::vector tempvars_cate= arma::conv_to::from(cate_vars_arma);\n\n std::vector bounds_lQ_cate = mixt_find_boundsQ( nu+num_obs, tempmeans_cate, tempvars_cate, lq_tstandard);\n\n //Rcout << \"line 13828 cate_vars_arma = \" << cate_vars_arma << \".\\n\";\n //Rcout << \"cate_means_arma = \" << cate_means_arma << \".\\n\";\n\n //Rcout << \"bounds_lQ_cate[0] = \" << bounds_lQ_cate[0] << \".\\n\";\n //Rcout << \"bounds_lQ_cate[1] = \" << bounds_lQ_cate[1] << \".\\n\";\n\n cate_ints(0,0)= rootmixt(nu+num_obs,\n bounds_lQ_cate[0]-0.0001,\n bounds_lQ_cate[1]+0.0001,\n tempmeans_cate,\n tempvars_cate,\n weights_vec, lower_prob,root_alg_precision);\n\n std::vector bounds_med_cate = mixt_find_boundsQ( nu+num_obs, tempmeans_cate, tempvars_cate, med_tstandard);\n\n //Rcout << \"bounds_lQ_cate[0] = \" << bounds_lQ_cate[0] << \".\\n\";\n //Rcout << \"bounds_lQ_cate[1] = \" << bounds_lQ_cate[1] << \".\\n\";\n\n cate_ints(1,0)= rootmixt(nu+num_obs,\n bounds_med_cate[0]-0.0001,\n bounds_med_cate[1]+0.0001,\n tempmeans_cate,\n tempvars_cate,\n weights_vec, 0.5, root_alg_precision);\n\n std::vector bounds_uQ_cate = mixt_find_boundsQ( nu+num_obs, tempmeans_cate, tempvars_cate, uq_tstandard);\n\n //Rcout << \"bounds_lQ_cate[0] = \" << bounds_lQ_cate[0] << \".\\n\";\n //Rcout << \"bounds_lQ_cate[1] = \" << bounds_lQ_cate[1] << \".\\n\";\n\n cate_ints(2,0)= rootmixt(nu+num_obs,\n bounds_uQ_cate[0]-0.0001,\n bounds_uQ_cate[1]+0.0001,\n tempmeans_cate,\n tempvars_cate,\n weights_vec, upper_prob, root_alg_precision);\n\n //Rcout << \"line 13871 cate_ints = \" << cate_ints << \".\\n\";\n\n\n //\n //\n // std::vector tempmeans_catt= arma::conv_to::from(catt_means_arma);\n // std::vector tempvars_catt= arma::conv_to::from(catt_vars_arma);\n //\n // std::vector bounds_lQ_catt = mixt_find_boundsQ( nu+num_obs, tempmeans_catt, tempvars_catt, lq_tstandard);\n //\n //\n // catt_ints(0,0)= rootmixt(nu+num_obs,\n // bounds_lQ_catt[0]-0.0001,\n // bounds_lQ_catt[1]+0.0001,\n // tempmeans_catt,\n // tempvars_catt,\n // weights_vec, lower_prob,root_alg_precision);\n //\n // std::vector bounds_med_catt = mixt_find_boundsQ( nu+num_obs, tempmeans_catt, tempvars_catt, med_tstandard);\n //\n // //Rcout << \"bounds_lQ_catt[0] = \" << bounds_lQ_catt[0] << \".\\n\";\n // //Rcout << \"bounds_lQ_catt[1] = \" << bounds_lQ_catt[1] << \".\\n\";\n //\n // catt_ints(1,0)= rootmixt(nu+num_obs,\n // bounds_med_catt[0]-0.0001,\n // bounds_med_catt[1]+0.0001,\n // tempmeans_catt,\n // tempvars_catt,\n // weights_vec, 0.5, root_alg_precision);\n //\n // std::vector bounds_uQ_catt = mixt_find_boundsQ( nu+num_obs, tempmeans_catt, tempvars_catt, uq_tstandard);\n //\n // //Rcout << \"bounds_lQ_catt[0] = \" << bounds_lQ_catt[0] << \".\\n\";\n // //Rcout << \"bounds_lQ_catt[1] = \" << bounds_lQ_catt[1] << \".\\n\";\n //\n // catt_ints(2,0)= rootmixt(nu+num_obs,\n // bounds_uQ_catt[0]-0.0001,\n // bounds_uQ_catt[1]+0.0001,\n // tempmeans_catt,\n // tempvars_catt,\n // weights_vec, upper_prob, root_alg_precision);\n //\n //\n //\n // //\n //\n //\n // std::vector tempmeans_catnt= arma::conv_to::from(catnt_means_arma);\n // std::vector tempvars_catnt= arma::conv_to::from(catnt_vars_arma);\n //\n // std::vector bounds_lQ_catnt = mixt_find_boundsQ( nu+num_obs, tempmeans_catnt, tempvars_catnt, lq_tstandard);\n //\n //\n //\n // catnt_ints(0,0)= rootmixt(nu+num_obs,\n // bounds_lQ_catnt[0]-0.0001,\n // bounds_lQ_catnt[1]+0.0001,\n // tempmeans_catnt,\n // tempvars_catnt,\n // weights_vec, lower_prob,root_alg_precision);\n //\n // std::vector bounds_med_catnt = mixt_find_boundsQ( nu+num_obs, tempmeans_catnt, tempvars_catnt, med_tstandard);\n //\n // //Rcout << \"bounds_lQ_catnt[0] = \" << bounds_lQ_catnt[0] << \".\\n\";\n // //Rcout << \"bounds_lQ_catnt[1] = \" << bounds_lQ_catnt[1] << \".\\n\";\n //\n // catnt_ints(1,0)= rootmixt(nu+num_obs,\n // bounds_med_catnt[0]-0.0001,\n // bounds_med_catnt[1]+0.0001,\n // tempmeans_catnt,\n // tempvars_catnt,\n // weights_vec, 0.5, root_alg_precision);\n //\n // std::vector bounds_uQ_catnt = mixt_find_boundsQ( nu+num_obs, tempmeans_catnt, tempvars_catnt, uq_tstandard);\n //\n // //Rcout << \"bounds_lQ_catnt[0] = \" << bounds_lQ_catnt[0] << \".\\n\";\n // //Rcout << \"bounds_lQ_catnt[1] = \" << bounds_lQ_catnt[1] << \".\\n\";\n //\n // catnt_ints(2,0)= rootmixt(nu+num_obs,\n // bounds_uQ_catnt[0]-0.0001,\n // bounds_uQ_catnt[1]+0.0001,\n // tempmeans_catnt,\n // tempvars_catnt,\n // weights_vec, upper_prob, root_alg_precision);\n\n\n\n#pragma omp parallel num_threads(ncores)\n#pragma omp for\n for(int i=0;i tempmeans= arma::conv_to::from(overall_preds.row(i));\n std::vector tempvars= arma::conv_to::from(t_vars_arma.row(i));\n\n //Rcout << \"Line 13859. tempvars\" << t_vars_arma.row(i) << \".\\n\";\n //Rcout << \"tempmeans\" << overall_preds.row(i) << \".\\n\";\n\n std::vector bounds_lQ = mixt_find_boundsQ( nu+num_obs, tempmeans, tempvars, lq_tstandard);\n\n output(0,i)=rootmixt(nu+num_obs,\n bounds_lQ[0]-0.0001,\n bounds_lQ[1]+0.0001,\n tempmeans,\n tempvars,\n weights_vec, lower_prob,root_alg_precision);\n\n\n std::vector bounds_med = mixt_find_boundsQ( nu+num_obs, tempmeans, tempvars, med_tstandard);\n\n output(1,i)=rootmixt(nu+num_obs,\n bounds_med[0]-0.0001,\n bounds_med[1]+0.0001,\n tempmeans,\n tempvars,\n weights_vec, 0.5,root_alg_precision);\n\n std::vector bounds_uQ = mixt_find_boundsQ( nu+num_obs, tempmeans, tempvars, uq_tstandard);\n\n output(2,i)=rootmixt(nu+num_obs,\n bounds_uQ[0]-0.0001,\n bounds_uQ[1]+0.0001,\n tempmeans,\n tempvars,\n weights_vec, upper_prob,root_alg_precision);\n\n\n }\n#pragma omp barrier\n } // close else statement (number of models not equal to 1)\n\n\n /////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n\n\n\n//double sumlik_total= arma::sum(overall_liks);\n//Rcout << \"sumlik_total = \" << sumlik_total << \". \\n\";\n\n//pred_vec_overall=pred_vec_overall*(1/sumlik_total);\n\n// pred_vec_overall=arma::sum(overall_preds,1);\n// pred_vec_overall_mu=arma::sum(overall_preds_mu,1);\n// pred_vec_overall_y=arma::sum(overall_preds_y,1);\n\n} // close else statement for fast_approx==0\n\n\n\n\n\n\n\narma::mat output_rescaled(output.n_rows, output.n_cols);\ndouble min_y=min(ytrain);\ndouble max_y=max(ytrain);\n\n#pragma omp parallel num_threads(ncores)\n#pragma omp for\nfor(unsigned int i=0;i\n#include \n//#include \n\n// [[Rcpp::plugins(openmp)]]\n#include \n\n//' @title Parallel Safe-BART with prediction intervals\n//'\n//' @description A parallelized implementation of safe-Bayesian Additive Regression Trees.\n//' @param lambda A real number between 0 and 1 that determines the splitting probability in the prior (which is used as the importance sampler of tree models). Quadrianto and Ghahramani (2015) recommend a value less than 0.5 .\n//' @param num_trees The number of trees to be sampled.\n//' @param seed The seed for random number generation.\n//' @param num_cats The number of possible values for the outcome variable.\n//' @param y The training data vector of outcomes. This must be a vector of integers between 1 and num_cats.\n//' @param original_datamat The original training data. Currently all variables must be continuous. The training data does not need to be transformed before being entered to this function.\n//' @param alpha_parameters Vector of prior parameters.\n//' @param beta_par The power to which the likelihood is to be raised. For BMA, set beta_par=1.\n//' @param original_datamat The original test data. This matrix must have the same number of columns (variables) as the training data. Currently all variables must be continuous. The test data does not need to be transformed before being entered to this function.\n//' @param ncores The number of cores to be used in parallelization.\n//' @return A List containing 1. A vector of predictions, and 2. A matrix of prediction intervals, the first row corresponds to the lower quantile, the second row is the median, and the third row is the upper quantile.\n//' @export\n// [[Rcpp::export]]\nList sBART_ITEs_with_ints(double lambda,\n int num_models,\n int num_trees,\n int seed,\n NumericVector ytrain,\n NumericMatrix original_datamat,\n NumericVector ztrain,\n NumericMatrix pihat_train,\n double beta_par,\n NumericMatrix test_datamat,\n NumericMatrix test_pihat,\n int ncores,\n int outsamppreds,\n double nu,\n double a,\n double lambdaBART,\n int valid_trees,\n int tree_prior,\n int imp_sampler,\n double alpha_BART,\n double beta_BART,\n int s_t_hyperprior,\n double p_s_t,\n double a_s_t,\n double b_s_t,\n double lambda_poisson,\n int fast_approx,\n int PIT_propensity,\n double lower_prob,\n double upper_prob,\n double root_alg_precision){\n\n\n //Rcout << \"imp_sampler = \" << imp_sampler << \".\\n\";\n\n\n //Check that various input vectors and matrices have consistent dimensions\n\n //Rcout << \"Line 4528.\\n\";\n\n bool is_test_data=0;\t\t\t\t\t// create bool is_test_data. Initialize equal to 0.\n if(test_datamat.nrow()>0){\t\t\t\t\t// If test data has non-zero number of rows.\n is_test_data=1;\t\t\t\t\t\t// set is_test_data equal to 1.\n }\n if(ytrain.size() !=original_datamat.nrow()){\t\t\t\t// If the length of input vector y is not equal to the nunber of rows in the input data (covariates)\n if(ytrain.size()0 && (original_datamat.ncol() != test_datamat.ncol())){\t// If the number of rows in the test data is >0 AND the number of columns (variables) is not equal to that of data (the training data)\n throw std::range_error(\"Test data and training data must have the same number of variables. BART BMA assumes variables are in the same order.\");\n }\n //if(test_z.size() != test_datamat.nrow()){\t// If the number of rows in the test data covariate matrix is not equal to that of the test data treatment indicator variable\n // throw std::range_error(\"Test data covariates and test data treatment indicator variable must have the same number of observations.\");\n //}\n if(test_datamat.nrow() != test_pihat.nrow()){\t// If the number of rows in the test data covariate matrix is not equal to that of the test data propensity score estimates matrix\n throw std::range_error(\"Test data covariates and test data propensity score estimates must have the same number of observations.\");\n }\n if(test_pihat.nrow()>0 && (pihat_train.ncol() != test_pihat.ncol())){\t// If the number of rows in the test data propensity score estimates is >0 AND the number of columns (variables) is not equal to that of the training data propensity score estimates\n throw std::range_error(\"Test data propensity score estimates and training data propensity score estimates must have the same number of columns. BART BMA assumes variables are in the same order.\");\n }\n\n ///////////////////////////////////////////////////////////////////////////////////////////////\n ///////////////////////////////////////////////////////////////////////////////////////////////\n\n\n\n // Now add propensity score estimates matrix as new leftmost column of data matrix. Call the resulting matrix x_control (to be consistent with terminology used by bcf package).\n arma::mat D1(original_datamat.begin(), original_datamat.nrow(), original_datamat.ncol(), false);\t\t\t\t// copy the covariate data matrix into an arma mat\n arma::mat pihat_1(pihat_train.begin(), pihat_train.nrow(), pihat_train.ncol(), false);\t\t\t\t// copy the pihat matrix into an arma mat\n //arma::mat x_control_a=D1;\t\t\t\t// create a copy of data arma mat called x_control_a\n\n\n //THIS CAN BE PARALLELIZED IF THERE ARE MANY VARIABLES\n arma::mat x_control_a_temp(D1.n_rows,D1.n_cols);\n for(unsigned int k=0; k0 ){\n x_control_a.insert_cols(0,pihat_a);\t\t// add propensity scores as new leftmost columns of x_control_a\n // }\n //}\n\n\n // Rcout << \"Number of columns of matrix\" << x_control_a.n_cols << \".\\n\";\n\n\n //NumericMatrix x_control=wrap(x_control_a);\t// convert x_control_a to a NumericMatrix called x_control\n\n // Name the matrix without the estimated propensity scores x_moderate.[CAN REMOVE THE DUPLICATION AND ADD x_control, x_moderate, and include_pi as input parameters later]\n //NumericMatrix x_moderate = data;\t// x_moderate matrix is the covariate data without the propensity scores\n //arma::mat x_moderate_a=D1;\t\t\t// create arma mat copy of x_moderate.\n //if((include_pi2==1)| (include_pi2==2) ){\n // if(pihat_train.nrow()>0 ){\n // x_moderate_a.insert_cols(0,pihat_a);\t\t// add propensity scores as new leftmost columns of x_control_a\n // }\n //}\n\n\n //NumericMatrix x_moderate=wrap(x_moderate_a);\t// convert x_control_a to a NumericMatrix called x_control\n\n\n // Rcout << \"Get to Line 7139 \" << \".\\n\";\n // Add test propensity scores to test data matrix\n arma::mat T1(test_datamat.begin(), test_datamat.nrow(), test_datamat.ncol(), false);\t\t\t\t// copy the covariate test_data matrix into an arma mat\n arma::mat pihat_1_test(test_pihat.begin(), test_pihat.nrow(), test_pihat.ncol(), false);\t\t\t\t// copy the test_pihat matrix into an arma mat\n //arma::mat x_control_test_a=T1;\t\t\t\t// create a copy of test_data arma mat called x_control_test_a\n\n arma::mat x_control_test_a(T1.n_rows,T1.n_cols);\n //arma::mat x_moderate_test_a(T1.n_rows,T1.n_cols);\n arma::mat pihat_a_test(pihat_1_test.n_rows,pihat_1_test.n_cols);\n\n if(is_test_data==1){\n //THIS CAN BE PARALLELIZED IF THERE ARE MANY VARIABLES\n arma::mat x_control_a_test_temp(T1.n_rows,T1.n_cols);\n\n for(unsigned int k=0; k0 ){\n x_control_test_a.insert_cols(0,pihat_a_test);\t\t// add propensity scores as new leftmost columns of x_control_test_a\n // }\n //}\n\n\n //NumericMatrix x_control_test=wrap(x_control_test_a);\t// convert x_control_test_a to a NumericMatrix called x_control_test\n\n\n // Name the matrix without the estimated propensity scores x_moderate_test.[CAN REMOVE THE DUPLICATION AND ADD x_control_test, x_moderate_test, and include_pi as input parameters later]\n //NumericMatrix x_moderate_test = test_data;\t// x_moderate_test matrix is the covariate test_data without the propensity scores\n //arma::mat x_moderate_test_a=T1;\t\t\t// create arma mat copy of x_moderate_test.\n // if((include_pi2==1)| (include_pi2==2) ){\n // if(test_pihat.nrow()>0 ){\n // x_moderate_test_a.insert_cols(0,pihat_a_test);\t\t// add propensity scores as new leftmost columns of x_control_a\n // }\n // }\n\n //NumericMatrix x_moderate_test=wrap(x_moderate_test_a);\t// convert x_control_test_a to a NumericMatrix called x_control_test\n\n\n\n //////////////////////////////////////////////////////////////////////////////////////////\n //Rcout << \"Line 4715.\\n\";\n\n //////////////////////////////////////////////////////////////////////////////////////////\n\n //End of checks and adding propensity scores to matrices\n\n\n\n\n\n\n\n NumericVector y_scaled=scale_response(min(ytrain),max(ytrain),-0.5,0.5,ytrain);\n int num_obs = x_control_a.n_rows;\n int num_test_obs = x_control_test_a.n_rows;\n\n arma::vec z_ar=Rcpp::as(ztrain);\t\t// converts to arma vec\n\n arma::mat ztempmat(num_obs,1);\n ztempmat.col(0)=z_ar;\n //x_control_a.insert_cols(0,z_ar);\t\t// add propensity scores as new leftmost columns of x_control_a\n\n arma::mat x_with_z = join_rows(ztempmat,x_control_a);\n\n arma::mat x_with_ones(x_with_z.n_rows, x_with_z.n_cols);\n arma::mat x_with_zeros(x_with_z.n_rows, x_with_z.n_cols);\n arma::mat x_with_ones_test(num_test_obs, x_with_z.n_cols);\n arma::mat x_with_zeros_test(num_test_obs, x_with_z.n_cols);\n\n if(is_test_data==1){\n arma::mat temp_one_mat=arma::ones(num_test_obs,1);\n arma::mat temp_zero_mat=arma::zeros(num_test_obs,1);\n\n x_with_ones_test=join_rows(temp_one_mat, x_control_test_a);\n x_with_zeros_test=join_rows(temp_zero_mat, x_control_test_a);\n\n }else{\n arma::mat temp_one_mat=arma::ones(num_obs,1);\n arma::mat temp_zero_mat=arma::zeros(num_obs,1);\n\n x_with_ones=join_rows(temp_one_mat, x_control_a);\n x_with_zeros=join_rows(temp_zero_mat, x_control_a);\n\n }\n\n\n int num_split_vars= x_with_z.n_cols;\n //arma::mat data_arma= as(original_datamat);\n //arma::mat testdata_arma= as(test_datamat);\n\n\n arma::vec orig_y_arma= as(y_scaled);\n //arma::vec alpha_pars_arma= as(alpha_parameters);\n\n\n int num_vars = x_with_z.n_cols;\n\n //calculations for likelihood\n arma::mat y(num_obs,1);\n y.col(0)=orig_y_arma;\n //get exponent\n double expon=(num_obs+nu)*0.5;\n //get y^Tpsi^{-1}y\n // arma::mat psi_inv=psi.i();\n arma::mat yty=y.t()*y;\n\n //arma::mat I_test(num_test_obs,num_test_obs);\n //I_test=I_test.eye();\n\n ///////////////////////\n //NumericMatrix Data_transformed = cpptrans_cdf(original_datamat);\n // NumericMatrix Data_transformed(original_datamat.nrow(), original_datamat.ncol());\n // for(int i=0; i(originaldata);\n\n //THIS CAN BE PARALLELIZED IF THERE ARE MANY VARIABLES\n // arma::mat arma_test_data(testdata_arma.n_rows,testdata_arma.n_cols);\n // for(unsigned int k=0; ksref.size()){\n // }else{\n // while (sref(j) < ssampi && j < sref.size()){\n // ++j;\n // if(j==sref.size()) break;\n // }\n // }\n // ans(ind) = j; // j is the 1-based index of the lower bound\n // }\n //\n // arma_test_data.col(k)=(ans)/nobsref;\n //\n // }\n //\n\n\n\n\n\n\n /////////////////////////////////////////////////////////////////////////////////////////\n\n\n\n //////////////////////////////////////////////////////////////////////////////////////\n //List table_list = draw_trees(lambda, num_trees, seed, num_split_vars, num_cats );\n\n\n\n //dqrng::dqRNGkind(\"Xoroshiro128+\");\n //dqrng::dqset_seed(IntegerVector::create(seed));\n\n //use following with binomial?\n //dqrng::xoshiro256plus rng(seed);\n\n std::vector lambdavec = {lambda, 1-lambda};\n\n //typedef boost::mt19937 RNGType;\n //boost::random::uniform_int_distribution<> sample_splitvardist(1,num_split_vars);\n //boost::variate_generator< RNGType, boost::uniform_int<> > sample_splitvars(rng, sample_splitvardist);\n\n //boost::random::uniform_real_distribution b_unifdist(0,1);\n //boost::variate_generator< RNGType, boost::uniform_real<> > b_unif_point(rng, b_unifdist);\n\n\n\n std::random_device device;\n //std::mt19937 gen(device());\n\n //possibly use seed?\n //// std::mt19937 gen(seed);\n\n dqrng::xoshiro256plus gen(device()); // properly seeded rng\n\n //dqrng::xoshiro256plus gen(seed); // properly seeded rng\n\n\n\n\n std::bernoulli_distribution coin_flip(lambda);\n\n\n std::bernoulli_distribution coin_flip_even(0.5);\n\n double spike_prob1;\n if(s_t_hyperprior==1){\n spike_prob1=a_s_t/(a_s_t + b_s_t);\n }else{\n spike_prob1=p_s_t;\n }\n\n std::bernoulli_distribution coin_flip_spike(spike_prob1);\n\n\n std::uniform_int_distribution<> distsampvar(1, num_split_vars);\n std::uniform_real_distribution<> dis_cont_unif(0, 1);\n\n std::poisson_distribution gen_num_term(lambda_poisson);\n\n\n //dqrng::uniform_distribution dis_cont_unif(0.0, 1.0); // Uniform distribution [0,1)\n\n //Following three functions can't be used in parallel\n //dqrng::dqsample_int coin_flip2(2, 1, true,lambdavec );\n //dqrng::dqsample_int distsampvar(num_split_vars, 1, true);\n //dqrng::dqrunif dis_cont_unif(1, 0, 1);\n\n\n\n //arma::mat arma_test_data(testdat_trans.begin(), testdat_trans.nrow(), testdat_trans.ncol(), false);\n\n\n arma::vec pred_vec_overall;\n if(is_test_data==1){\n pred_vec_overall=arma::zeros(x_with_ones_test.n_rows);\n }else{\n pred_vec_overall=arma::zeros(x_with_z.n_rows);\n }\n\n\n\n //arma::field overall_treetables(num_models);\n\n //::field overall_preds(num_models);\n\n arma::vec overall_liks(num_models);\n\n int numobstemp0;\n if(is_test_data==1){\n numobstemp0=num_test_obs;\n }else{\n numobstemp0=num_obs;\n }\n\n arma::mat overall_preds(numobstemp0,num_models);\n arma::mat t_vars_arma(numobstemp0,num_models);\n\n arma::vec cate_means_arma(num_models);\n arma::vec cate_vars_arma(num_models);\n\n\n arma::vec averagingvec;\n\n if(is_test_data==1){\n averagingvec=(1/double(num_test_obs))*arma::ones(num_test_obs);\n }else{\n averagingvec=(1/double(num_obs))*arma::ones(num_obs);\n }\n\n\n //overall_treetables[i]= wrap(tree_table1);\n //double templik = as(treepred_output[1]);\n //overall_liks[i]= pow(lik_prod,beta_pow);\n\n //Rcout << \"Line 3338. \\n\";\n\n\n#pragma omp parallel num_threads(ncores)\n{//start of pragma omp code\n dqrng::xoshiro256plus lgen(gen); // make thread local copy of rng\n lgen.jump(omp_get_thread_num() + 1); // advance rng by 1 ... ncores jumps\n\n#pragma omp for\n for(int j=0; j treenodes_bin;\n std::vector split_var_vec;\n\n\n int count_terminals = 0;\n int count_internals = 0;\n\n //int count_treebuild = 0;\n\n if(imp_sampler==2){ // If sampling from Spike and Tree\n\n //// Rcout << \"Line 3737 .\\n\";\n\n\n //make coinflip_spike before loop\n //also make bernoulli with probability 0.5\n\n //make a poisson distribtion\n\n\n //might be easier to store indices as armadillo vector, because will have to remove\n //potential splits when allocating to terminal nodes\n std::vector potentialsplitvars;\n\n for(int varcount=0; varcount treenodes_bintemp(length+1);\n int p_ind=0;\n long height = 0;\n\n //Rcout << \"Line 195. \\n\";\n //Rcout << \"Line 3781 .\\n\";\n //Rcout << \"q_numsplitvars = \" << q_numsplitvars << \".\\n\";\n\n for(long i = 0; i < length+1; i ++) {\n //signed char x = random_int(1) ? 1 : -1;\n int x = coin_flip_even(lgen) ? 1 : -1;\n treenodes_bintemp[i] = x;\n height += x;\n\n if(height < 0) {\n // this should return a uniform random integer between 0 and x\n //unsigned long random_int(unsigned long x);\n std::uniform_int_distribution<> random_int(0, i);\n long j = random_int(lgen);\n //long j = random_int(i);\n //height += unfold(p_ind + j,treenodes_bintemp, i + 1 - j);\n\n long length1=i+1-j;\n long height1 = 0;\n long local_height = 0;\n int x = 1;\n\n for(long i = 0; i < length1; i ++) {\n int y = treenodes_bintemp[p_ind+j+i];\n local_height += y;\n if(local_height < 0) {\n y = 1;\n height1 += 2;\n local_height = 0;\n }\n treenodes_bintemp[p_ind+j+i] = x;\n x = y;\n }\n height +=height1;\n\n\n\n\n }\n }\n\n //Rcout << \"Line 213. \\n\";\n //Rcout << \"Line 3822 .\\n\";\n\n\n //fold(treenodes_bintemp, length + 1, height);\n long local_height = 0;\n int x = -1;\n ////Rcout << \"Line 121. \\n\";\n //Rcout << \"treenodes_bintemp.size() =\" << treenodes_bintemp.size() << \". \\n\";\n //Rcout << \"length - 1 =\" << length - 1 << \". \\n\";\n\n\n for(long i = length; height > 0; i --) {\n int y = treenodes_bintemp[i];\n local_height -= y;\n if(local_height < 0) {\n y = -1;\n height -= 2;\n local_height = 0;\n }\n treenodes_bintemp[i] = x;\n x = y;\n }\n //Rcout << \"Line 134. \\n\";\n\n\n //Rcout << \"Line 217. \\n\";\n //Rcout << \"Line 3847 .\\n\";\n\n //Rcout << \"Line 238. \\n\";\n std::replace(treenodes_bintemp.begin(), treenodes_bintemp.end(), -1, 0); // 10 99 30 30 99 10 10 99\n\n\n // Then store tree structure as treenodes_bintemp\n\n //create splitting variable vector\n std::vector splitvar_vectemp(treenodes_bintemp.size());\n\n std::vector drawnvarstemp(num_term_nodes_draw-1);\n\n //keep count of how many splitting points have been filled in\n int splitcount=0;\n\n //loop through nodes, filling in splitting variables for nonterminal nodes\n //when less than q_numsplitvars remaining internal nodes to be filled in\n //have to start reducing the set of potential splitting variables\n //to ensure that each selected potential split variable is used at least once. [hence the if statement containing .erase]\n\n int index_remaining=0;\n for(unsigned int nodecount=0; nodecountnum_term_nodes_draw-1-q_numsplitvars){//CHECK THIS CONDITION\n //To ensure each variable used at least once, fill in the rest of the splits with all the variables\n //The split variables will be randomly shuffled anyway, therefore the order is not important here.\n drawnvarstemp[splitcount-1]=potentialsplitvars[index_remaining]+1;\n index_remaining++;\n }else{\n //randomly draw a splitting varaible from the set of potential splitting variables\n std::uniform_int_distribution<> draw_var(0,potentialsplitvars.size()-1);//q_numsplitvars-splitcount could replace potentialsplitvars.size()\n int tempsplitvar = draw_var(lgen);\n drawnvarstemp[splitcount-1]=potentialsplitvars[tempsplitvar]+1;\n\n }\n\n //if(splitcount>num_term_nodes_draw-1-q_numsplitvars){//CHECK THIS CONDITION\n // potentialsplitvars.erase(potentialsplitvars.begin()+tempsplitvar);\n //}\n\n }else{//if not a split\n //splitvar_vectemp[nodecount]=-1;\n }\n }\n\n std::shuffle(drawnvarstemp.begin(),drawnvarstemp.end(),lgen);\n\n splitcount=0;\n for(unsigned int nodecount=0; nodecount (count_terminals -1)){\n samp_prob=alpha_BART*pow(double(depth1+1),-beta_BART);\n std::bernoulli_distribution coin_flip2(samp_prob);\n\n int tempdraw = coin_flip2(lgen);\n treenodes_bin.push_back(tempdraw);\n\n if(tempdraw==1){\n\n depth1=depth1+1; //after a split, the depth will increase by 1\n prev_node=1;\n count_internals=count_internals+1;\n\n }else{\n\n if(prev_node==1){//zero following a 1, therefore at same depth.\n //Don't change depth. Do nothing\n }else{ //zero following a zero, therefore the depth will decrease by 1\n depth1=depth1-1;\n }\n prev_node=0;\n count_terminals=count_terminals+1;\n\n }\n\n }\n\n }else{ //If not sampling from BART prior\n //If sampling from default Q+G prior. i.e. not sampling from BART nor spike and tree prior\n\n while(count_internals > (count_terminals -1)){\n\n //Also consider standard library and random header\n // std::random_device device;\n // std::mt19937 gen(device());\n // std::bernoulli_distribution coin_flip(lambda);\n // bool outcome = coin_flip(gen);\n\n\n int tempdraw = coin_flip(lgen);\n\n //int tempdraw = rbinom(n = 1, prob = lambda,size=1);\n\n\n //int tempdraw = Rcpp::rbinom(1,lambda,1);\n //int tempdraw = R::rbinom(1,lambda);\n\n ////Rcout << \"tempdraw = \" << tempdraw << \".\\n\" ;\n\n //int tempdraw = coin_flip2(lgen)-1;\n\n //int tempdraw = dqrng::dqsample_int(2, 1, true,lambdavec )-1;\n\n\n //need to update rng if use boost?\n //int tempdraw = bernoulli(rng, binomial::param_type(1, lambda));\n\n treenodes_bin.push_back(tempdraw);\n\n\n if(tempdraw==1){\n count_internals=count_internals+1;\n }else{\n count_terminals=count_terminals+1;\n }\n\n }//end of while loop creating parent vector treenodes_bin\n }//end of Q+H sampling else statement\n }//end of not Spike and Tree sampler else statement\n\n //Rcout << \"Line 3961 .\\n\";\n\n\n if(imp_sampler==2){\n //already filled in splitting variable above for spike and tree prior\n }else{\n //Consider making this an armadillo vector\n //IntegerVector split_var_vec(treenodes_bin.size());\n //arma::uvec split_var_vec(treenodes_bin.size());\n std::vector split_var_vectemp(treenodes_bin.size());\n\n // possibly faster alternative\n // split_var_vec.reserve( treenodes_bin.size() );\n // then push_back elements to split_var_vec in the for loop\n\n //loop drawing splitting variables\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i distsampvar(1, num_split_vars);\n //\n // split_var_vec[i] = distsampvar(engine);\n\n split_var_vectemp[i] = distsampvar(lgen);\n\n\n //consider using boost\n //might need to update rng\n //split_var_vec[i] <- sample_splitvars(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_var_vec[i] = dqrng::dqsample_int(num_split_vars, 1, true);\n\n //not sure if this returns an integer or a vector?\n //split_var_vec[i] = RcppArmadillo::sample(num_split_vars, 1,true);\n //could try\n //split_var_vec[i] = as(Rcpp::sample(num_split_vars, 1,true));\n //could also try RcppArmadillo::rmultinom\n\n }\n\n }// end of for-loop drawing split variables\n\n split_var_vec=split_var_vectemp;\n }//end else statrement filling in splitting variable vector\n\n //Consider making this an armadillo vector\n //NumericVector split_point_vec(treenodes_bin.size());\n //arma::vec split_point_vec(treenodes_bin.size());\n std::vector split_point_vec(treenodes_bin.size());\n\n\n //loop drawing splitting points\n //REPLACE SQUARE BRACKETS WITH \"( )\" if using ARMADILLO vector for split_var_vec or treenodes_bin\n\n //if using armadillo, it might be faster to subset to split nodes\n //then use a vector of draws\n for(unsigned int i=0; i dis_cont_unif(0, 1);\n\n split_point_vec[i] = dis_cont_unif(lgen);\n\n //////////////////////////////////////////////////////////\n //from armadillo\n //split_point_vec[i] = arma::randu();\n\n //////////////////////////////////////////////////////////\n //probably not adviseable for paralelization\n //From Rcpp\n //split_point_vec[i] = as(Rcpp::runif(1,0,1));\n\n //////////////////////////////////////////////////////////\n //consider using boost\n //might need to update rng\n //split_point_vec[i] <- b_unif_point(rng);\n\n //or use dqrng\n //not sure if have to update the random number\n //check if the following line is written properly\n //split_point_vec[i] = dqrng::dqrunif(1, 0, 1);\n\n //not sure if this returns an integer or a vector?\n\n\n\n\n\n }\n\n }// end of for-loop drawing split points\n\n\n\n //Rcout << \"Line 4081 .\\n\";\n\n\n //CODE FOR ADJUSTING SPLITTING POINTS SO THAT THE TREES ARE VALID\n if(valid_trees==1){\n for(unsigned int i=0; iprevent_term_count-1){ //if this rule is satisfied then in subtree that is not to be updated\n continue; //still in subtree, therefore continue instead of checking for splits to be updates\n }else{\n preventing_updates=0; // no longer in subtree, therefore reset preventing_updates to zero\n }\n }\n\n\n if(sub_int_nodes>sub_term_nodes-1){\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]*first_split_point;\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }else{\n if(treenodes_bin[k]==1){\n if(split_var_vec[k]==first_split_var){\n split_point_vec[k]=split_point_vec[k]+first_split_point-first_split_point*split_point_vec[k];\n //beginning count of subtree that should not have\n //further splits on first_split_var updated\n preventing_updates=1; //indicates if still within subtree that is not to be updated\n prevent_int_count=1;\n prevent_term_count=0;\n }\n }\n }\n\n\n\n }//end of inner loop over k\n }//end of if statement treenodes_bin[i]==1)\n }//end of loop over i\n }//end of if statement valid_trees==1\n\n\n\n\n\n //Rcout << \"Line 4161 .\\n\";\n\n\n\n\n\n //Create tree table matrix\n\n //NumericMatrix tree_table1(treenodes_bin.size(),5+num_cats);\n\n ////Rcout << \"Line 1037. \\n\";\n //arma::mat tree_table1(treenodes_bin.size(),5+num_cats);\n\n //initialize with zeros. Not sure if this is necessary\n arma::mat tree_table1=arma::zeros(treenodes_bin.size(),6);\n //Rcout << \"Line 1040. \\n\";\n\n\n //tree_table1(_,2) = wrap(split_var_vec);\n //tree_table1(_,3) = wrap(split_point_vec);\n //tree_table1(_,4) = wrap(treenodes_bin);\n\n\n\n //It might be more efficient to make everything an armadillo object initially\n // but then would need to replace push_back etc with a different approach (but this might be more efficient anyway)\n arma::colvec split_var_vec_arma=arma::conv_to::from(split_var_vec);\n //arma::colvec split_point_vec_arma(split_point_vec);\n //arma::colvec split_point_vec_arma(split_point_vec);\n arma::colvec split_point_vec_arma=arma::conv_to::from(split_point_vec);\n\n arma::colvec treenodes_bin_arma=arma::conv_to::from(treenodes_bin);\n\n //Rcout << \"split_var_vec_arma = \" << split_var_vec_arma << \" . \\n\";\n\n //Rcout << \"split_point_vec_arma = \" << split_point_vec_arma << \" . \\n\";\n\n //Rcout << \"treenodes_bin_arma = \" << treenodes_bin_arma << \" . \\n\";\n\n\n //Rcout << \"Line 1054. \\n\";\n\n //Fill in splitting variable column\n tree_table1.col(2) = split_var_vec_arma;\n //Fill in splitting point column\n tree_table1.col(3) = split_point_vec_arma;\n //Fill in split/parent column\n tree_table1.col(4) = treenodes_bin_arma;\n\n\n //Rcout << \"Line 4200. j = \" << j << \". \\n\";\n\n ////Rcout << \"Line 4081 .\\n\";\n\n\n // Now start filling in left daughter and right daughter columns\n std::vector rd_spaces;\n int prev_node = -1;\n\n for(unsigned int i=0; i(terminal_nodes);\n //NumericVector tree_predictions;\n\n //now for each internal node find the observations that belong to the terminal nodes\n\n //NumericVector predictions(test_data.nrow());\n //List term_obs(term_nodes.n_elem);\n\n //GET J MATRIX\n\n //Rcout << \"Line 4311 .\\n\";\n\n if(term_nodes.n_elem==1){\n //double nodemean=tree_data(terminal_nodes[0]-1,5);\t\t\t\t// let nodemean equal tree_data row terminal_nodes[i]^th row , 6th column. The minus 1 is because terminal nodes consists of indices starting at 1, but need indices to start at 0.\n //predictions=rep(nodemean,test_data.nrow());\n //Rcout << \"Line 67 .\\n\";\n\n //IntegerVector temp_obsvec = seq_len(test_data.nrow())-1;\n //term_obs[0]= temp_obsvec;\n //double denom_temp= orig_y_arma.n_elem+arma::sum(alpha_pars_arma);\n\n //double num_prod=1;\n //double num_sum=0;\n //Rcout << \"Line 129.\\n\";\n Jmat.col(0) = arma::ones(num_obs);\n\n\n if(is_test_data==1){\n //Jtilde.col(0) = arma::ones(num_test_obs);\n Jtilde1.col(0) = arma::ones(num_test_obs);\n Jtilde0.col(0) = arma::ones(num_test_obs);\n }else{\n Jmat1.col(0) = arma::ones(num_obs);\n Jmat0.col(0) = arma::ones(num_obs);\n\n }\n\n //for(int k=0; k temp_split);\n // pred_test_indices = arma::find(temptest_vec > temp_split);\n // }\n //Rcout << \"Line 236.\\n\";\n\n\n\n\n\n if(is_test_data==1){\n data_subset = x_with_z.col(split);\n data_test_subset1 = x_with_ones_test.col(split);\n data_test_subset0 = x_with_zeros_test.col(split);\n\n\n\n arma::vec tempvec = x_with_z.col(split);\n arma::vec temptest_vec1 = x_with_ones_test.col(split);\n arma::vec temptest_vec0 = x_with_zeros_test.col(split);\n\n if(node_split_mat(0,2)==0){\n pred_indices = arma::find(tempvec <= temp_split);\n pred_test_indices1 = arma::find(temptest_vec1 <= temp_split);\n pred_test_indices0 = arma::find(temptest_vec0 <= temp_split);\n }else{\n pred_indices = arma::find(tempvec > temp_split);\n pred_test_indices1 = arma::find(temptest_vec1 > temp_split);\n pred_test_indices0 = arma::find(temptest_vec0 > temp_split);\n }\n\n data_subset=data_subset.elem(pred_indices);\n data_test_subset1=data_test_subset1.elem(pred_test_indices1);\n data_test_subset0=data_test_subset0.elem(pred_test_indices0);\n\n }else{\n data_subset = x_with_z.col(split);\n data_subset1 = x_with_ones.col(split);\n data_subset0 = x_with_zeros.col(split);\n\n\n\n arma::vec tempvec = x_with_z.col(split);\n arma::vec tempvec1 = x_with_ones.col(split);\n arma::vec tempvec0 = x_with_zeros.col(split);\n\n if(node_split_mat(0,2)==0){\n pred_indices = arma::find(tempvec <= temp_split);\n pred_indices1 = arma::find(tempvec1 <= temp_split);\n pred_indices0 = arma::find(tempvec0 <= temp_split);\n }else{\n pred_indices = arma::find(tempvec > temp_split);\n pred_indices1 = arma::find(tempvec1 > temp_split);\n pred_indices0 = arma::find(tempvec0 > temp_split);\n }\n\n data_subset=data_subset.elem(pred_indices);\n data_subset1=data_subset1.elem(pred_indices1);\n data_subset0=data_subset0.elem(pred_indices0);\n\n }\n\n\n //now loop through each row of node_split_mat\n int n=node_split_mat.n_rows;\n //Rcout << \"Line 174. i = \" << i << \". n = \" << n << \".\\n\";\n //Rcout << \"Line 248.\\n\";\n\n for(int j=1;j split_p);\n temp_test_pred_indices1=arma::find(data_test_subset1 > split_p);\n temp_test_pred_indices0=arma::find(data_test_subset0 > split_p);\n }\n\n pred_indices=pred_indices.elem(temp_pred_indices);\n pred_test_indices1=pred_test_indices1.elem(temp_test_pred_indices1);\n pred_test_indices0=pred_test_indices0.elem(temp_test_pred_indices0);\n\n\n }else{\n data_subset = x_with_z.col(curr_sv-1);\n data_subset1 = x_with_ones.col(curr_sv-1);\n data_subset0 = x_with_zeros.col(curr_sv-1);\n\n data_subset=data_subset.elem(pred_indices);\n data_subset1=data_subset1.elem(pred_indices1);\n data_subset0=data_subset0.elem(pred_indices0);\n\n if(node_split_mat(j,2)==0){\n //split is to the left\n temp_pred_indices=arma::find(data_subset <= split_p);\n temp_pred_indices1=arma::find(data_subset1 <= split_p);\n temp_pred_indices0=arma::find(data_subset0 <= split_p);\n }else{\n //split is to the right\n temp_pred_indices=arma::find(data_subset > split_p);\n temp_pred_indices1=arma::find(data_subset1 > split_p);\n temp_pred_indices0=arma::find(data_subset0 > split_p);\n }\n\n pred_indices=pred_indices.elem(temp_pred_indices);\n pred_indices1=pred_indices1.elem(temp_pred_indices1);\n pred_indices0=pred_indices0.elem(temp_pred_indices0);\n\n }\n\n\n //if(pred_indices.size()==0){\n // continue;\n //}\n\n }//end of for loop of length n\n //Rcout << \"Line 199. i = \" << i << \".\\n\";\n\n //There is probably a more efficient way of doing this\n //e.g. initialize J matrix so that all elements are equal to zero\n arma::vec tempcol_J=arma::zeros(num_obs);\n tempcol_J(pred_indices) = arma::ones(pred_indices.size());\n Jmat.col(i) = tempcol_J;\n\n if(is_test_data==1){\n arma::vec tempcol_Jtilde1=arma::zeros(num_test_obs);\n tempcol_Jtilde1(pred_test_indices1) = arma::ones(pred_test_indices1.size());\n Jtilde1.col(i) = tempcol_Jtilde1;\n\n arma::vec tempcol_Jtilde0=arma::zeros(num_test_obs);\n tempcol_Jtilde0(pred_test_indices0) = arma::ones(pred_test_indices0.size());\n Jtilde0.col(i) = tempcol_Jtilde0;\n\n\n }else{\n arma::vec tempcol_J1=arma::zeros(num_obs);\n tempcol_J1(pred_indices1) = arma::ones(pred_indices1.size());\n Jmat1.col(i) = tempcol_J1;\n\n arma::vec tempcol_J0=arma::zeros(num_obs);\n tempcol_J0(pred_indices0) = arma::ones(pred_indices0.size());\n Jmat0.col(i) = tempcol_J0;\n\n }\n\n //double nodemean=tree_data(terminal_nodes[i]-1,5);\n //IntegerVector predind=as(wrap(pred_indices));\n //predictions[predind]= nodemean;\n //term_obs[i]=predind;\n\n //double denom_temp= pred_indices.n_elem+arma::sum(alpha_pars_arma);\n //Rcout << \"Line 207. predind = \" << predind << \".\\n\";\n //Rcout << \"Line 207. denom_temp = \" << denom_temp << \".\\n\";\n // << \"Line 207. term_node = \" << term_node << \".\\n\";\n\n //double num_prod=1;\n //double num_sum=0;\n\n // for(int k=0; k(p.n_rows, p.n_rows);\n //\n // arma::mat parameters = arma::solve(cov, p * r.t(), arma::solve_opts::fast);\n //\n // arma::rowvec preds_temp_arma_t=arma::trans(parameters) * W_tilde.t();\n // arma::rowvec preds_insamp_arma=arma::trans(parameters) * p;\n //\n // arma::vec preds_temp_arma= preds_temp_arma_t.t();\n //\n // arma::vec tempresids=y-preds_insamp_arma.t();\n // double temp_sse= arma::dot(tempresids, tempresids);\n //\n // //double templik0=exp(-b*0.5*log(num_obs)+log(temp_sse)*(-num_obs)*0.5);\n //\n //\n // //double templik0=exp(-b*0.5*log(num_obs)+log(temp_sse)*(-num_obs)*0.5);\n //\n //\n // //double templik0=exp(-0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs))) ;\n //\n // double templik0=(num_obs*log(temp_sse/num_obs)+b*log(num_obs)) ;\n //\n // // //Rcout << \"num_obs= \" << num_obs << \". \\n\";\n // // //Rcout << \"b= \" << b << \". \\n\";\n // // Rcout << \"log(num_obs)= \" << log(num_obs) << \". \\n\";\n // // Rcout << \"log(temp_sse/num_obs)= \" << log(temp_sse/num_obs) << \". \\n\";\n // //Rcout << \"templik0= \" << templik0 << \". \\n\";\n // // Rcout << \"-0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs))= \" << -0.5*(num_obs*log(temp_sse/num_obs)+b*log(num_obs)) << \". \\n\";\n //\n //\n // //double templik = pow(templik0,beta_par);\n // double templik = beta_par*templik0;\n //\n //\n // if(imp_sampler!=tree_prior){//check if importance sampler is not equal to the prior\n // //templik=templik*(sum_tree_prior_prob/sum_tree_samp_prob);\n // //templik=templik*sum_prior_over_samp_prob;\n // templik=templik+log(sum_prior_over_samp_prob);\n //\n // }\n // overall_liks(j)= templik;\n //\n // overall_preds(j)=preds_temp_arma;\n //\n // }else{\n\n\n\n // ///////////////////////////////////\n //get t(y)inv(psi)J\n arma::mat ytW=y.t()*Wmat;\n //get t(J)inv(psi)J\n arma::mat WtW=Wmat.t()*Wmat;\n //get jpsij +aI\n arma::mat aI(b,b);\n aI=a*aI.eye();\n arma::mat sec_term=WtW+aI;\n //arma::mat sec_term_inv=sec_term.i();\n arma::mat sec_term_inv=inv_sympd(sec_term);\n //get t(J)inv(psi)y\n arma::mat third_term=Wmat.t()*y;\n //get m^TV^{-1}m\n arma::mat mvm= ytW*sec_term_inv*third_term;\n //arma::mat rel=(b/2)*log(a)-(1/2)*log(det(sec_term))-expon*log(nu*lambdaBART - mvm +yty);\n // /////////////////////////////////////////////\n\n\n //\n // Rcout << \"-b*0.5*log(num_obs)= \" << -b*0.5*log(num_obs) << \". \\n\";\n // Rcout << \"log(temp_sse)*(-num_obs)*0.5= \" << log(temp_sse)*(-num_obs)*0.5 << \". \\n\";\n //\n\n //double templik0=pow(num_obs, -b*0.5)*pow(temp_sse,-num_obs*0.5);\n\n //\n // arma::vec temppred1=Wmat*sec_term_inv*third_term;\n // arma::vec temperrors= y-temppred1;\n // arma::vec tempcoeffs= sec_term_inv*third_term;\n //\n // double new_penalty= as_scalar(b*temppred1.t()*temppred1/(tempcoeffs.t()*tempcoeffs*(double(num_obs)-b)));\n //\n // Rcout << \" new_penalty =\" << new_penalty << \".\\n\";\n\n\n //double val1;\n //double sign1;\n\n //log_det(val1, sign1, sec_term);\n //double templik0=exp(arma::as_scalar((b*0.5)*log(a)-0.5*val1-expon*log(nu*lambdaBART - mvm +yty)));\n\n\n ////////////////////\n //double templik0=exp(arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term))-expon*log(nu*lambdaBART - mvm +yty)));\n //////////////\n double templik0=arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term))-expon*log(nu*lambdaBART - mvm +yty));\n\n\n\n //double templik0=exp(arma::as_scalar((b*0.5)*log(a)-0.5*log(det(sec_term))-expon*log(nu*lambdaBART - mvm +yty)));\n\n\n\n\n\n //\n //\n // arma::mat aI2(b,b);\n // aI2=new_penalty*aI2.eye();\n // arma::mat sec_term2=WtW+aI2;\n // //arma::mat sec_term_inv=sec_term.i();\n // arma::mat sec_term_inv2=inv_sympd(sec_term2);\n // //get t(J)inv(psi)y\n // //arma::mat third_term=Wmat.t()*y;\n // //get m^TV^{-1}m\n // arma::mat mvm2= ytW*sec_term_inv2*third_term;\n //\n //\n // double templik0=exp(arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term2))-expon*log(nu*lambdaBART - mvm2 +yty)));\n //\n\n\n\n\n\n // Rcout << \"log(temp_sse)= \" << log(temp_sse) << \". \\n\";\n //\n //\n // Rcout << \"temp_sse= \" << temp_sse << \". \\n\";\n //\n\n\n\n // Rcout << \"templik0= \" << templik0 << \". \\n\";\n //\n // Rcout << \"b= \" << b << \". \\n\";\n // Rcout << \"(b*0.5)*log(a)= \" << (b*0.5)*log(a) << \". \\n\";\n //\n // Rcout << \"-0.5*log(det(sec_term))= \" << -0.5*log(det(sec_term)) << \". \\n\";\n // Rcout << \"det(sec_term)= \" << det(sec_term) << \". \\n\";\n // Rcout << \"arma::det(sec_term)= \" << arma::det(sec_term) << \". \\n\";\n // Rcout << \"arma::log_det(sec_term)= \" << arma::log_det(sec_term) << \". \\n\";\n // Rcout << \"real(arma::log_det(sec_term))= \" << real(arma::log_det(sec_term)) << \". \\n\";\n // Rcout << \"log(det(sec_term))= \" << log(det(sec_term)) << \". \\n\";\n // Rcout << \"log(arma::det(sec_term))= \" << log(arma::det(sec_term)) << \". \\n\";\n //\n // Rcout << \"-expon*log(nu*lambdaBART - mvm +yty)= \" << -expon*log(nu*lambdaBART - mvm +yty) << \". \\n\";\n //\n //\n // // Rcout << \"val= \" << val << \". \\n\";\n //\n // Rcout << \"arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term))-expon*log(nu*lambdaBART - mvm +yty)) .\\n\" << arma::as_scalar((b*0.5)*log(a)-0.5*real(arma::log_det(sec_term))-expon*log(nu*lambdaBART - mvm +yty)) << \".\\n\";\n // ////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n ////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n //overall_treetables[j]= wrap(tree_table1);\n\n\n //double templik = as(treepred_output[1]);\n\n //double templik = pow(templik0,beta_par);\n\n double templik = beta_par*templik0;\n\n if(imp_sampler!=tree_prior){//check if importance sampler is not equal to the prior\n //templik=templik*(sum_tree_prior_prob/sum_tree_samp_prob);\n //templik=templik*sum_prior_over_samp_prob;\n templik=templik+log(sum_prior_over_samp_prob);\n\n }\n overall_liks(j)= templik;\n\n // if(std::isnan(templik)){\n // Rcout << \"Line 3943, j= \" << j << \". \\n\";\n // Rcout << \"templik= \" << templik << \". \\n\";\n // Rcout << \"sum_tree_prior_prob= \" << sum_tree_prior_prob << \". \\n\";\n // Rcout << \"sum_tree_samp_prob= \" << sum_tree_samp_prob << \". \\n\";\n // }\n\n\n //now fill in the predictions\n\n //If want tree tables with predictions filled in, use\n // arma::vec term_node_par_means = sec_term_inv*third_term;\n // //and would need to save a field of tree tables,\n // //add add a column, or begin with one more column\n // //then the first treetableF[0].n_rows elements of term_node_par_means\n // //give the first\n // int row_count1=0;\n // for(int tree_i=0; tree_i < treetableF.n_elem; tree_i++){\n // tabletemp= treetableF(i);\n // tabletemp.col(5) = term_node_par_means(arma::span(row_count1,tabletemp.n_rows));\n // treetableF(i)=tabletemp;\n // row_count1+=tabletemp.n_rows;\n // }\n //This would give an alternative method for obtaining test data predictions\n //Look up the terminal nodes and add the relevant terminal node parameters\n\n\n\n\n if(is_test_data==1){\n arma::mat Treat_diff = W_tilde1-W_tilde0;\n arma::mat w_tilde_M_inv = Treat_diff*sec_term_inv;\n arma::vec preds_temp_arma= w_tilde_M_inv*third_term;\n // Rcout << \"Line 16593\";\n\n overall_preds.col(j)=preds_temp_arma;\n arma::mat temp_for_scal = ((nu*lambdaBART+yty-mvm)/(nu+num_obs));\n double temp_scal= as_scalar(temp_for_scal) ;\n //Rcout << \"Line 4156\";\n //arma::mat covar_t=temp_scal*(I_test+w_tilde_M_inv*(W_tilde.t()));\n arma::mat covar_t=temp_scal*(w_tilde_M_inv*(Treat_diff.t()));\n\n arma::mat catevartemp=temp_scal*(averagingvec.t()*w_tilde_M_inv*(Treat_diff.t())*averagingvec);\n\n t_vars_arma.col(j)=covar_t.diag();\n cate_means_arma(j)=as_scalar(averagingvec.t()*preds_temp_arma);\n cate_vars_arma(j)=as_scalar(catevartemp);\n\n\n }else{\n arma::mat Treat_diff = Wmat1-Wmat0;\n arma::mat w_tilde_M_inv = Treat_diff*sec_term_inv;\n arma::vec preds_temp_arma= w_tilde_M_inv*third_term;\n // Rcout << \"Line 16613\";\n\n overall_preds.col(j)=preds_temp_arma;\n // Rcout << \"Line 16616\";\n\n arma::mat temp_for_scal = ((nu*lambdaBART+yty-mvm)/(nu+num_obs));\n double temp_scal= as_scalar(temp_for_scal) ;\n //Rcout << \"Line 4156\";\n //arma::mat covar_t=temp_scal*(I_test+w_tilde_M_inv*(W_tilde.t()));\n arma::mat covar_t=temp_scal*(w_tilde_M_inv*(Treat_diff.t()));\n\n arma::mat catevartemp=temp_scal*(averagingvec.t()*w_tilde_M_inv*(Treat_diff.t())*averagingvec);\n\n // Rcout << \"Line 16626\";\n t_vars_arma.col(j)=covar_t.diag();\n cate_means_arma(j)=as_scalar(averagingvec.t()*preds_temp_arma);\n cate_vars_arma(j)=as_scalar(catevartemp);\n // Rcout << \"Line 16630\";\n\n\n }\n\n //arma::vec pred_vec(testdata_arma.n_rows);\n\n ////////////\n //arma::vec preds_temp_arma= W_tilde*sec_term_inv*third_term;\n\n ////////////////////\n\n\n // Rcout << \"Line 16634 .\\n\";\n\n\n\n //arma::vec preds_temp_arma= W_tilde*sec_term_inv2*third_term;\n\n\n\n //THIS SHOULD BE DIFFERENT IF THE CODE IS TO BE PARALLELIZED\n //EACH THREAD SHOULD OUTPUT ITS OWN MATRIX AND SUM OF LIKELIHOODS\n //THEN ADD THE MATRICES TOGETHER AND DIVIDE BY THE TOTAL SUM OF LIKELIHOODS\n //OR JUST SAVE ALL MATRICES TO ONE LIST\n\n\n //pred_mat_overall = pred_mat_overall + templik*pred_mat;\n //overall_treetables(j)= pred_mat*templik;\n\n\n //overall_preds(j)=preds_temp_arma*templik;\n\n // overall_preds.col(j)=preds_temp_arma;\n //\n //\n //\n // arma::mat temp_for_scal = ((nu*lambdaBART+yty-mvm)/(nu+num_obs));\n // double temp_scal= as_scalar(temp_for_scal) ;\n // //// Rcout << \"Line 4156\";\n // //arma::mat covar_t=temp_scal*(I_test+w_tilde_M_inv*(W_tilde.t()));\n // arma::mat covar_t=temp_scal*(I_test+W_tilde*sec_term_inv*(W_tilde.t()));\n //\n // t_vars_arma.col(j)=covar_t.diag();\n\n\n //Rcout << \"Line 3985, j= \" << j << \". \\n\";\n\n\n //Rcout << \"preds_temp_arma= \" << preds_temp_arma << \". \\n\";\n //Rcout << \"preds_temp_arma*templik= \" << preds_temp_arma*templik << \". \\n\";\n\n //overall_treetables(j)= pred_mat;\n //overall_liks(j) =templik;\n\n //arma::mat treeprob_output = get_test_probs(weights, num_cats,\n // testdata,\n // treetable_list[i] );\n\n //Rcout << \"Line 688. i== \" << i << \". \\n\";\n\n //double weighttemp = weights[i];\n //Rcout << \"Line 691. i== \" << i << \". \\n\";\n\n //pred_mat_overall = pred_mat_overall + weighttemp*treeprob_output;\n\n\n //}//end of else statement\n }//end of loop over all trees\n\n}//end of pragma omp code\n\n\n///////////////////////////////////////////////////////////////////////////////////////\n\n/////////////////////////////////////////////////////////////////////////////////\n\n\n\n\n// Rcout << \"Line 16701 .\\n\";\n\n\n\ndouble cate_pred=0;\n//double catt_pred;\n//double catnt_pred;\n\n//NumericMatrix draws_wrapped= wrap(draws_for_preds);\n//arma::mat output(3, num_obs);\n//NumericVector probs_for_quantiles = NumericVector::create(lower_prob, 0.5, upper_prob);\n\n//std::vector probs_for_quantiles {lower_prob, 0.5, upper_prob};\narma::mat cate_ints(3, 1);\n\n\n//for(unsigned int i=0; i(arma_test_data.n_rows);\n// #pragma omp for nowait //fill result_private in parallel\n// for(unsigned int i=0; i(x_control_test_a.n_rows);\n }else{\n result_private=arma::zeros(x_control_a.n_rows);\n\n }\n\n#pragma omp for nowait //fill result_private in parallel\n for(unsigned int i=0; i stdvec;\n//std::vector weights_vec= as(post_weights);\nstd::vector weights_vec= arma::conv_to::from(weighted_lik);\n\n\nboost::math::students_t dist2(nu+num_obs);\ndouble lq_tstandard= boost::math::quantile(dist2,lower_prob);\ndouble med_tstandard= boost::math::quantile(dist2,0.5); //This is just 0 ??\ndouble uq_tstandard= boost::math::quantile(dist2,upper_prob);\n\n\nif(weights_vec.size()==1){\n\n cate_ints(0,0)= cate_means_arma(0)+sqrt(cate_vars_arma(0))*lq_tstandard;\n cate_ints(1,0)= cate_means_arma(0)+sqrt(cate_vars_arma(0))*med_tstandard;\n cate_ints(2,0)= cate_means_arma(0)+sqrt(cate_vars_arma(0))*uq_tstandard;\n\n#pragma omp parallel num_threads(ncores)\n#pragma omp for\n for(int i=0;i tempmeans= arma::conv_to::from(overall_preds.row(i));\n std::vector tempvars= arma::conv_to::from(t_vars_arma.row(i));\n\n //boost::math::students_t dist2(nu+num_obs);\n\n\n output(0,i)= tempmeans[0]+sqrt(tempvars[0])*lq_tstandard;\n output(1,i)= tempmeans[0]+sqrt(tempvars[0])*med_tstandard;\n output(2,i)= tempmeans[0]+sqrt(tempvars[0])*uq_tstandard;\n\n\n }\n#pragma omp barrier\n}else{\n\n std::vector tempmeans_cate= arma::conv_to::from(cate_means_arma);\n std::vector tempvars_cate= arma::conv_to::from(cate_vars_arma);\n\n std::vector bounds_lQ_cate = mixt_find_boundsQ( nu+num_obs, tempmeans_cate, tempvars_cate, lq_tstandard);\n\n //Rcout << \"line 13828 cate_vars_arma = \" << cate_vars_arma << \".\\n\";\n //Rcout << \"cate_means_arma = \" << cate_means_arma << \".\\n\";\n\n //Rcout << \"bounds_lQ_cate[0] = \" << bounds_lQ_cate[0] << \".\\n\";\n //Rcout << \"bounds_lQ_cate[1] = \" << bounds_lQ_cate[1] << \".\\n\";\n\n cate_ints(0,0)= rootmixt(nu+num_obs,\n bounds_lQ_cate[0]-0.0001,\n bounds_lQ_cate[1]+0.0001,\n tempmeans_cate,\n tempvars_cate,\n weights_vec, lower_prob,root_alg_precision);\n\n std::vector bounds_med_cate = mixt_find_boundsQ( nu+num_obs, tempmeans_cate, tempvars_cate, med_tstandard);\n\n //Rcout << \"bounds_lQ_cate[0] = \" << bounds_lQ_cate[0] << \".\\n\";\n //Rcout << \"bounds_lQ_cate[1] = \" << bounds_lQ_cate[1] << \".\\n\";\n\n cate_ints(1,0)= rootmixt(nu+num_obs,\n bounds_med_cate[0]-0.0001,\n bounds_med_cate[1]+0.0001,\n tempmeans_cate,\n tempvars_cate,\n weights_vec, 0.5, root_alg_precision);\n\n std::vector bounds_uQ_cate = mixt_find_boundsQ( nu+num_obs, tempmeans_cate, tempvars_cate, uq_tstandard);\n\n //Rcout << \"bounds_lQ_cate[0] = \" << bounds_lQ_cate[0] << \".\\n\";\n //Rcout << \"bounds_lQ_cate[1] = \" << bounds_lQ_cate[1] << \".\\n\";\n\n cate_ints(2,0)= rootmixt(nu+num_obs,\n bounds_uQ_cate[0]-0.0001,\n bounds_uQ_cate[1]+0.0001,\n tempmeans_cate,\n tempvars_cate,\n weights_vec, upper_prob, root_alg_precision);\n\n#pragma omp parallel num_threads(ncores)\n#pragma omp for\n for(int i=0;i tempmeans= arma::conv_to::from(overall_preds.row(i));\n std::vector tempvars= arma::conv_to::from(t_vars_arma.row(i));\n\n\n std::vector bounds_lQ = mixt_find_boundsQ( nu+num_obs, tempmeans, tempvars, lq_tstandard);\n\n output(0,i)=rootmixt(nu+num_obs,\n bounds_lQ[0]-0.0001,\n bounds_lQ[1]+0.0001,\n tempmeans,\n tempvars,\n weights_vec, lower_prob,root_alg_precision);\n\n\n std::vector bounds_med = mixt_find_boundsQ( nu+num_obs, tempmeans, tempvars, med_tstandard);\n\n output(1,i)=rootmixt(nu+num_obs,\n bounds_med[0]-0.0001,\n bounds_med[1]+0.0001,\n tempmeans,\n tempvars,\n weights_vec, 0.5,root_alg_precision);\n\n std::vector bounds_uQ = mixt_find_boundsQ( nu+num_obs, tempmeans, tempvars, uq_tstandard);\n\n output(2,i)=rootmixt(nu+num_obs,\n bounds_uQ[0]-0.0001,\n bounds_uQ[1]+0.0001,\n tempmeans,\n tempvars,\n weights_vec, upper_prob,root_alg_precision);\n\n\n }\n#pragma omp barrier\n}\n\n\narma::mat output_rescaled(output.n_rows, output.n_cols);\ndouble min_y=min(ytrain);\ndouble max_y=max(ytrain);\n\n#pragma omp parallel num_threads(ncores)\n#pragma omp for\nfor(unsigned int i=0;i\n#include \n#include \n\nclass su2_x_lattice;\n\ntypedef Eigen::Matrix, 2, 2> su2_link;\ntypedef Eigen::Matrix, 1, 2> su2_vector;\n#define su2_identity su2_link::Identity()\n#define su2_zero su2_link::Zero()\n\n#define I complex(0,1)\n#define Q(s) s->link[0]\n#define D_MAX 6\n#define SQRT3 1.73205080756887729352744634151 // sqrt(3)\n#define SQRT1_3 0.577350269189625764509148780502 // 1 / sqrt(3)\n\nclass su2_x_site {\npublic:\n // variables\n su2_x_lattice* lattice; // parent lattice\n su2_link link[D_MAX]; // link values in each direction\n su2_link link_inverse[D_MAX]; // link inverse values\n su2_link p_link[D_MAX]; // conjugate momenta in each direction\n su2_x_site* forward[D_MAX]; // adjacent sites in the forward direction\n su2_x_site* backward[D_MAX]; // adjacent sites in the backward direction\n std::mt19937* gen; // random number generator for this time-slice\n bool forward_edge; // site is at the forward edge of the extra dimension\n bool backward_edge; // site is at the backward edge of the extra dimension\n bool is_locked;\n double eps;\n su2_link wf_z[D_MAX]; // exponent for wilson flow\n\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n\n // methods\n void init(su2_x_lattice* lattice, su2_x_site* lattice_sites, int s);\n su2_link make_unitary(const su2_link& g);\n su2_link exp_su2(const su2_link& g);\n bool lock();\n void unlock();\n double rand_double(double min = 0.0, double max = 1.0);\n int rand_int(int min, int max);\n double rand_normal(double mean = 0.0, double stdev = 1.0);\n void reset_links(bool cold);\n void copy_links(su2_x_site* site);\n void read_links(std::ifstream& ckptFile, bool bigEndian);\n void set_link(int d, const su2_link& value);\n void init_momenta();\n su2_link create_random_link();\n su2_link create_link(double a);\n double action();\n double hamiltonian();\n void hmc_step_p(double frac);\n void hmc_step_link();\n su2_link p_link_dot(int d);\n double link_trace();\n double plaq();\n su2_link plaquette(int d1, int d2);\n su2_link staple(int d1);\n su2_link reverse_staple(int d1);\n su2_link staple_x(int d1);\n su2_link reverse_staple_x(int d1);\n su2_link cloverleaf(int d1, int d2);\n double wilson_loop(int a, int b);\n std::complex polyakov_loop(int r);\n double correlator(int T);\n double field_strength();\n// double field_strength_x();\n double topological_charge();\n double mag_U();\n double abs_U();\n double four_point(int T, int R);\n su2_link overrelax(su2_link g);\n void relax(bool coulomb);\n double sum_landau();\n double sum_coulomb();\n su2_link sum_G(bool coulomb);\n void heat_bath();\n void heat_bath_link(int d1);\n void cool();\n void cool_link(int d1);\n void wilson_flow(su2_x_site* target, int step);\n void wilson_flow_link(su2_x_site* target, int step, int d);\n void stout_smear(su2_x_site* target, double rho);\n void stout_smear_link(su2_x_site* target, double rho, int d1);\n};\n\nclass su2_x_lattice {\npublic:\n // variables\n int N; // array size (spacial)\n int T; // array size (time)\n int N5; // 5th dimension size\n int D; // number of dimensions\n double beta; // coupling factor\n double eps5; // ratio of coupling in extra dimension to normal coupling\n int n_sites; // number of sites in the entire lattice\n int n_sites_5; // number of sites in a 5d sub-lattice\n int n_slice; // number of sites in each time slice of the entire lattice\n int n5_center; // center lattice\n std::vector site; // site values\n std::vector gen; // array of random number generators (one for each time-slice)\n std::vector sigma; // pauli spin matrices\n int verbose;\n bool parallel;\n\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n\n // hmc\n std::vector site_1; // site values for hmc\n double dt; // hmc step size\n int n_steps; // hmc step count\n int hmc_accept; // number of accepted hmc configurations\n int hmc_count; // number of attempted hmc configurations\n\n // time step for wilson flow algorithm\n double wf_dt;\n\n // methods\n su2_x_lattice(int N, int T, int N5, int D, double beta, double eps5, bool cold = false);\n su2_x_lattice(su2_x_lattice* lattice);\n su2_x_lattice(int N, int T, int N5, int D, double beta, double eps5, std::ifstream& ckptFile, bool isNersc = false);\n ~su2_x_lattice();\n void init();\n double rand_double(double min = 0.0, double max = 1.0);\n int rand_int(int min, int max);\n double rand_normal(double mean = 0.0, double stdev = 1.0);\n int get_site(int s, int d, int n);\n double link_trace();\n double plaq(int n5);\n double action(int n5);\n double wilson_loop(int a, int b, int n5);\n double polyakov_loop(int R, int n5);\n double correlator(int T, int n5);\n double four_point(int T, int R, int n5);\n double hamiltonian();\n void hmc(int n_sweeps = 0, bool update_dt = false, bool no_metropolis = false);\n void heat_bath(int n_sweeps = 0);\n void cool(int n5, int n_sweeps = 0);\n void wilson_flow_x(int n_sweeps = 0);\n void wilson_flow(int n5, int n_sweeps = 0);\n void stout_smear(int n5, double rho = 0.1, int n_sweeps = 0);\n double field_strength(int n5);\n double field_strength_x(int n5);\n double topological_charge(int n5);\n int thermalize(int n_min = 0, int n_max = 0);\n double ave_link_t(int n5);\n double theta(bool coulomb, int n5);\n long double relax(long double error_target, bool coulomb, int n5);\n};\n\n#endif /* su2_x_hpp */\n", "meta": {"hexsha": "566521597317452d3ef193416e19ada8b498d178", "size": 5790, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "su2_x/su2_x.hpp", "max_stars_repo_name": "ekowen86/lattice", "max_stars_repo_head_hexsha": "878b59a5b1ce79328c2f57a8133ddfa65186536a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2021-06-23T02:02:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-26T15:11:34.000Z", "max_issues_repo_path": "su2_x/su2_x.hpp", "max_issues_repo_name": "ekowen86/lattice", "max_issues_repo_head_hexsha": "878b59a5b1ce79328c2f57a8133ddfa65186536a", "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": "su2_x/su2_x.hpp", "max_forks_repo_name": "ekowen86/lattice", "max_forks_repo_head_hexsha": "878b59a5b1ce79328c2f57a8133ddfa65186536a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-12-01T19:37:34.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-01T19:37:34.000Z", "avg_line_length": 35.3048780488, "max_line_length": 120, "alphanum_fraction": 0.689119171, "num_tokens": 1682, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920020959544, "lm_q2_score": 0.6791787056691697, "lm_q1q2_score": 0.5438129576231864}} {"text": "#include \"CMeshModelInstance.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n\n// Function equivalent and improved from igl::per_vertex_normals\n// [270, 452] ms\ntemplate \ninline T getNormTriplet(const T* const ptr)\n{\n return std::sqrt(ptr[0]*ptr[0] + ptr[1]*ptr[1] + ptr[2]*ptr[2]);\n}\ntemplate \ninline void normalizeTriplet(T* ptr, const T norm)\n{\n ptr[0] /= norm;\n ptr[1] /= norm;\n ptr[2] /= norm;\n}\ntemplate \ninline void normalizeTriplet(T* ptr)\n{\n const auto norm = getNormTriplet(ptr);\n normalizeTriplet(ptr, norm);\n}\nvoid per_vertex_normals(\n const Eigen::Matrix& V,\n const Eigen::Matrix& F,\n Eigen::Matrix& N\n)\n{\n Eigen::Matrix FN;\n FN.resize(F.rows(),3);\n auto* FN_data = FN.data();\n const auto* const F_data = F.data();\n const auto* const V_data = V.data();\n // loop over faces\n for (int i = 0; i < F.rows();i++)\n {\n const auto baseIndex = 3*i;\n const auto F_data0 = 3*F_data[baseIndex];\n const auto F_data1 = 3*F_data[baseIndex+1];\n const auto F_data2 = 3*F_data[baseIndex+2];\n const Eigen::Matrix v1(\n V_data[F_data1] - V_data[F_data0],\n V_data[F_data1+1] - V_data[F_data0+1],\n V_data[F_data1+2] - V_data[F_data0+2]);\n const Eigen::Matrix v2(\n V_data[F_data2] - V_data[F_data0],\n V_data[F_data2+1] - V_data[F_data0+1],\n V_data[F_data2+2] - V_data[F_data0+2]);\n FN.row(i) = v1.cross(v2);\n auto* fnRowPtr = &FN_data[baseIndex];\n const double norm = getNormTriplet(fnRowPtr);\n if (norm == 0)\n {\n fnRowPtr[0] = 0;\n fnRowPtr[1] = 0;\n fnRowPtr[2] = 0;\n }\n else\n normalizeTriplet(fnRowPtr, norm);\n }\n\n // Resize for output\n N.resize(V.rows(),3);\n std::fill(N.data(), N.data() + N.rows() * N.cols(), 0.0);\n\n Eigen::Matrix A(F.rows(), 1);\n auto* A_data = A.data();\n const auto Fcols = F.cols();\n const auto Vcols = V.cols();\n\n // Projected area helper\n const auto & proj_doublearea =\n [&V_data,&F_data, &Vcols, &Fcols](const int x, const int y, const int f)\n ->double\n {\n const auto baseIndex = f*Fcols;\n const auto baseIndex2 = F_data[baseIndex + 2]*Vcols;\n const auto rx = V_data[F_data[baseIndex]*Vcols + x] - V_data[baseIndex2 + x];\n const auto sx = V_data[F_data[baseIndex + 1]*Vcols + x] - V_data[baseIndex2 + x];\n const auto ry = V_data[F_data[baseIndex]*Vcols + y] - V_data[baseIndex2 + y];\n const auto sy = V_data[F_data[baseIndex + 1]*Vcols + y] - V_data[baseIndex2 + y];\n return rx*sy - ry*sx;\n };\n\n for (auto f = 0;f V_3(m_vertices.size(), 3);\n auto* V_3_data = V_3.data();\n\n for (int r = 0; r < V_3.rows(); ++r)\n {\n auto* v3rowPtr = &V_3_data[3*r];\n v3rowPtr[0] = m_vertices[r].x; // V_3(r, 0)\n v3rowPtr[1] = m_vertices[r].y; // V_3(r, 1)\n v3rowPtr[2] = m_vertices[r].z; // V_3(r, 2)\n }\n // Eigen::MatrixXd NV;\n Eigen::Matrix NV;\n\n if (m_meshType==MESH_TYPE_SMPL)\n {\n std::string errorMessage(\"Not supporting MESH_TYPE_SMPL currently\");\n throw std::runtime_error(errorMessage);\n // igl::per_vertex_normals(V_3, g_smpl.faces_, NV);\n }\n if (m_meshType == MESH_TYPE_TOTAL || m_meshType == MESH_TYPE_ADAM)\n {\n // igl::per_vertex_normals(V_3, model.m_faces, NV);\n per_vertex_normals(V_3, model.m_faces, NV);\n // Eigen::Matrix NVAux;\n // igl::per_vertex_normals(V_3, model.m_faces, NVAux);\n // std::cout << (NV - NVAux).norm() << std::endl;\n // assert((NV - NVAux).norm() < 1e-6);\n }\n m_normals.resize(NV.rows());\n auto* NV_data = NV.data();\n for (int r = 0; r < NV.rows(); ++r)\n {\n const auto* const nvRow = &NV_data[3*r];\n m_normals[r] = cv::Point3f(nvRow[0], nvRow[1], nvRow[2]); // cv::Point3f(NV(r, 0), NV(r, 1), NV(r, 2))\n }\n}\n\nvoid CMeshModelInstance::clearMesh()\n{\n m_face_vertexIndices.clear();\n m_vertices.clear();\n m_colors.clear();\n m_normals.clear();\n m_uvs.clear();\n m_joints.clear();\n m_joints_regress.clear();\n m_alpha.clear();\n}\n\nbool compareTupleDepth(const std::tuple& a, const std::tuple& b)\n{\n return std::get<1>(a) > std::get<1>(b); // from far to near\n}\n\nbool compareTupleAlpha(const std::tuple& a, const std::tuple& b)\n{\n return std::get<0>(a) > std::get<0>(b); // opaque first, then transparent\n}\n\nvoid CMeshModelInstance::sortFaceDepth(const cv::Point3d angleaxis)\n{\n // const auto start = std::chrono::high_resolution_clock::now();\n std::vector depth_vertex(m_vertices.size());\n if (angleaxis == cv::Point3d(0., 0., 0.)) // no rotation\n {\n for (auto i = 0u; i < m_vertices.size(); i++)\n depth_vertex[i] = m_vertices[i].z;\n }\n else\n {\n const double angle_axis[3] = {angleaxis.x, angleaxis.y, angleaxis.z};\n for (auto i = 0u; i < m_vertices.size(); i++)\n {\n const double pt[3] = {m_vertices[i].x, m_vertices[i].y, m_vertices[i].z};\n double result[3];\n ceres::AngleAxisRotatePoint(angle_axis, pt, result);\n depth_vertex[i] = result[2];\n }\n }\n\n assert(m_face_vertexIndices.size() % 3 == 0);\n std::vector> vecSort;\n const uint num_face = m_face_vertexIndices.size() / 3;\n vecSort.reserve(num_face);\n for (auto i = 0u; i < num_face; i++)\n {\n const uint I1 = m_face_vertexIndices[3 * i];\n const uint I2 = m_face_vertexIndices[3 * i + 1];\n const uint I3 = m_face_vertexIndices[3 * i + 2];\n const double depth = (depth_vertex[I1] + depth_vertex[I2] + depth_vertex[I3]) / 3;\n const double alpha = (m_alpha[I1] + m_alpha[I2] + m_alpha[I3]) / 3; // opaqueness\n vecSort.emplace_back(std::make_tuple(alpha, depth, cv::Point3i(I1, I2, I3)));\n }\n std::sort(vecSort.begin(), vecSort.end(), compareTupleAlpha); // first sort according to opacity, put opaque face first\n auto it = vecSort.begin();\n while(it != vecSort.end())\n {\n // find the first element that is not completely opaque\n if (std::get<0>(*it) != 1.0)\n break;\n it++;\n }\n std::sort(it, vecSort.end(), compareTupleDepth); // now sort according to depth, far first\n for (auto i = 0u; i < num_face; i++)\n {\n auto& pt = std::get<2>(vecSort[i]);\n m_face_vertexIndices[3 * i + 0] = pt.x;\n m_face_vertexIndices[3 * i + 1] = pt.y;\n m_face_vertexIndices[3 * i + 2] = pt.z;\n }\n // const auto duration = std::chrono::duration_cast(std::chrono::high_resolution_clock::now() - start).count();\n // std::cout << \"Sort depth duration \" << duration * 1e-6 << \" ms\" << std::endl;\n}", "meta": {"hexsha": "f71ba1a6199b7e6fc0f650d2cedc6a8662a1bbd7", "size": 8574, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "visualization/FitAdam/src/CMeshModelInstance.cpp", "max_stars_repo_name": "alvaro-budria/body2hands", "max_stars_repo_head_hexsha": "0eba438b4343604548120bdb03c7e1cb2b08bcd6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 63.0, "max_stars_repo_stars_event_min_datetime": "2021-05-14T02:55:16.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-13T01:51:12.000Z", "max_issues_repo_path": "visualization/FitAdam/src/CMeshModelInstance.cpp", "max_issues_repo_name": "human2b/body2hands", "max_issues_repo_head_hexsha": "8ab4b206dc397c3b326f2b4ec9448c84ee8801fe", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 9.0, "max_issues_repo_issues_event_min_datetime": "2021-06-24T09:59:41.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-31T08:15:20.000Z", "max_forks_repo_path": "visualization/FitAdam/src/CMeshModelInstance.cpp", "max_forks_repo_name": "human2b/body2hands", "max_forks_repo_head_hexsha": "8ab4b206dc397c3b326f2b4ec9448c84ee8801fe", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 9.0, "max_forks_repo_forks_event_min_datetime": "2021-05-17T03:33:28.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-17T02:30:44.000Z", "avg_line_length": 35.725, "max_line_length": 141, "alphanum_fraction": 0.5922556566, "num_tokens": 2664, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920020959544, "lm_q2_score": 0.6791786926816161, "lm_q1q2_score": 0.5438129472241561}} {"text": "#include \n#include \n#include \n\n//[[Rcpp::export(.partialSumEigen)]]\nEigen::VectorXd partialSumEigen(const Eigen::VectorXd & x)\n{\n const std::size_t N = x.size();\n Eigen::VectorXd partialSum(N + 1);\n\n partialSum[0] = 0;\n for (std::size_t i = 1; i < N + 1; i++)\n {\n partialSum[i] = x[i - 1] + partialSum[i - 1];\n }\n\n return partialSum;\n}\n\nEigen::MatrixXd bindColumns(const Eigen::MatrixXd & A, const Eigen::MatrixXd & B)\n{\n Eigen::MatrixXd C(A.rows(), A.cols() + B.cols());\n C << A, B;\n return C;\n}\n\n\nEigen::VectorXd STDEigen(const std::vector &x)\n{\n Eigen::VectorXd xEigen(x.size());\n for (std::size_t i = 0; i < x.size(); i++)\n xEigen[i] = x[i];\n\n return xEigen;\n}\n\nstd::vector EigenSTD(const Eigen::VectorXd &x)\n{\n std::vector xNEWMAT(x.size());\n for (std::size_t i = 0; i < x.size(); i++)\n xNEWMAT[i] = x[i];\n\n return xNEWMAT;\n}\n\nEigen::Vector2i nonZeroElementsOfMarker(const Eigen::VectorXd & decodedProfile_m)\n{\n const std::size_t N = decodedProfile_m.size();\n\n Eigen::Vector2i res;\n std::size_t i = 0;\n std::size_t j = 0;\n while(j < 2)\n {\n if (decodedProfile_m[i] != 0)\n {\n int k = static_cast(decodedProfile_m[i]);\n while(k > 0)\n {\n res[j] = i;\n k -= 1;\n j += 1;\n }\n }\n i += 1;\n }\n\n return res;\n}\n\nstd::vector sortedIndex(const Eigen::VectorXd & x)\n{\n std::vector x_sorted(x.size());\n std::iota(x_sorted.begin(), x_sorted.end(), 0);\n auto comparator = [&x](int i, int j){ return x[i] > x[j]; };\n\n std::sort(x_sorted.begin(), x_sorted.end(), comparator);\n\n return x_sorted;\n}\n\n//[[Rcpp::export()]]\nEigen::MatrixXd generatePossibleGenotypes(const std::size_t & N)\n{\n if (N == 1)\n {\n Eigen::MatrixXd possibleSingleprofilesMatrix = 2*Eigen::MatrixXd::Ones(N, N);\n return possibleSingleprofilesMatrix;\n }\n\n const std::size_t possibleSingles = N;\n const std::size_t possiblePairs = boost::math::binomial_coefficient(N, 2);\n\n const std::size_t totalPossibleOutcomes = possibleSingles + possiblePairs;\n const std::size_t totalRuns = std::floor(possiblePairs / N);\n\n Eigen::MatrixXd possibleSingleprofilesMatrix = Eigen::MatrixXd::Zero(N, totalPossibleOutcomes);\n for (std::size_t i = 0; i < N; i++)\n {\n // Single Values\n Eigen::VectorXd singleVector = Eigen::VectorXd::Zero(N);\n singleVector(i) = 2;\n possibleSingleprofilesMatrix.col(i) = singleVector;\n\n // Paired Values\n for (std::size_t j = 1; j <= totalRuns; j++)\n {\n Eigen::VectorXd pairsVector = Eigen::VectorXd::Zero(N);\n pairsVector(i) = 1;\n pairsVector((i + j) % N) = 1;\n possibleSingleprofilesMatrix.col(j*N + i) = pairsVector;\n }\n }\n\n // Remaining Paired Values\n for (std::size_t k = (totalRuns + 1)*N; k < totalPossibleOutcomes; k++)\n {\n Eigen::VectorXd pairsVector = Eigen::VectorXd::Zero(N);\n pairsVector(k % N) = 1;\n pairsVector(((k % N) + (totalRuns + 1)) % N) = 1;\n possibleSingleprofilesMatrix.col(k) = pairsVector;\n }\n\n return possibleSingleprofilesMatrix;\n}\n", "meta": {"hexsha": "3d6f577ff4102a5c6d9849998bf47c823b9620cc", "size": 3352, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/AuxiliaryFunctions.cpp", "max_stars_repo_name": "svilsen/MPSMixtures", "max_stars_repo_head_hexsha": "07b21c593bee795162f6282446ff370985ceec38", "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/AuxiliaryFunctions.cpp", "max_issues_repo_name": "svilsen/MPSMixtures", "max_issues_repo_head_hexsha": "07b21c593bee795162f6282446ff370985ceec38", "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/AuxiliaryFunctions.cpp", "max_forks_repo_name": "svilsen/MPSMixtures", "max_forks_repo_head_hexsha": "07b21c593bee795162f6282446ff370985ceec38", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.6031746032, "max_line_length": 99, "alphanum_fraction": 0.5832338902, "num_tokens": 939, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7634837743174788, "lm_q2_score": 0.7122321964553657, "lm_q1q2_score": 0.5437777255401707}} {"text": "/** @file */\n#pragma once\n#include \n#include \n#include \n\nnamespace pw85 {\n\nnamespace metadata {\nconstexpr std::string_view author{\"S. Brisard\"};\n// clang-format off\nconstexpr std::string_view description{\"Implementation of the \\\"contact function\\\" defined by Perram and Wertheim (J. Comp. Phys. 58(3), 409-416, DOI:10.1016/0021-9991(85)90171-8) for two ellipsoids.\"};\n// clang-format on\nconstexpr std::string_view author_email{\"sebastien.brisard@univ-eiffel.fr\"};\nconstexpr std::string_view license{\"BSD 3-Clause License\"};\nconstexpr std::string_view name{\"pw85\"};\nconstexpr std::string_view url{\"https://github.com/sbrisard/pw85\"};\nconstexpr std::string_view version{\"2.0\"};\nconstexpr std::string_view year{\"2021\"};\n} // namespace metadata\n\n/** The dimension of the physical space (3).*/\nconstexpr size_t dim = 3;\n\n/** The dimension of the space of symmetric matrices (6). */\nconstexpr size_t sym = 6;\n\n/*\n * For the Brent algorithm, these two constants should be such that\n *\n * [(3 - sqrt(5)) / 2] ** n < eps\n *\n * where\n *\n * n = max_iter\n * eps = lambda_atol\n */\n\n/**\n * The absolute tolerance for the stopping criterion of Brent’s method (in\n * function contact_function()).\n */\nconstexpr double lambda_atol = 1e-6;\n\n/**\n * The maximum number of iterations of Brent’s method (in function\n * contact_function()).\n */\nconstexpr size_t max_iter = 25;\n\n/**\n * The total number of iterations of the Newton–Raphson refinement phase (in\n * function contact_function()).\n */\nconstexpr size_t nr_iter = 3;\n\n/**\n * Compute the Cholesky decomposition of a symmetric, positive matrix.\n *\n * Let `A` be a symmetric, positive matrix, defined by the `double[6]` array\n * `a`. This function computes the lower-triangular matrix `L`, defined by\n * the `double[6]` array `l`, such that `Lᵀ⋅L = A`.\n *\n * The array `l` must be pre-allocated; it is modified by this function. Note\n * that storage of the coefficients of `L` is as follows\n *\n * ```\n * ⎡ l[0] 0 0 ⎤\n * L = ⎢ l[1] l[3] 0 ⎥.\n * ⎣ l[2] l[4] l[5] ⎦\n * ```\n */\nvoid _cholesky_decomp(double const *a, double *l) {\n l[0] = sqrt(a[0]);\n l[1] = a[1] / l[0];\n l[2] = a[2] / l[0];\n l[3] = sqrt(a[3] - l[1] * l[1]);\n l[4] = (a[4] - l[1] * l[2]) / l[3];\n l[5] = sqrt(a[5] - l[2] * l[2] - l[4] * l[4]);\n}\n\n/**\n * Compute the solution to a previously Cholesky decomposed linear system.\n *\n * Let `L` be a lower-triangular matrix, defined by the `double[6]` array `l`\n * (see pw85::_cholesky_decomp() for ordering of the coefficients). This\n * function solves (by substitution) the linear system `Lᵀ⋅L⋅x = b`, where the\n * vectors `x` and `b` are specified through their `double[3]` array of\n * coordinates; `x` is modified by this function.\n */\nvoid _cholesky_solve(const double *l, const double *b, double *x) {\n /* Solve L.y = b */\n double const y0 = b[0] / l[0];\n double const y1 = (b[1] - l[1] * y0) / l[3];\n double const y2 = (b[2] - l[2] * y0 - l[4] * y1) / l[5];\n\n /* Solve L^T.x = y */\n x[2] = y2 / l[5];\n x[1] = (y1 - l[4] * x[2]) / l[3];\n x[0] = (y0 - l[1] * x[1] - l[2] * x[2]) / l[0];\n}\n\n/**\n * Compute the quadratic form associated to a spheroid.\n *\n * The spheroid is defined by its equatorial radius `a`, its polar radius `c`\n * and the direction of its axis of revolution, `n` (unit-vector, `double[3]`\n * array).\n *\n * `q` is the representation of a symmetric matrix as a `double[6]` array. It is\n * modified in-place.\n */\nvoid spheroid(double a, double c, const double *n, double *q) {\n double const a2 = a * a;\n double const c2_minus_a2 = c * c - a2;\n double const nx = n[0];\n double const ny = n[1];\n double const nz = n[2];\n q[0] = nx * nx * c2_minus_a2 + a2;\n q[3] = ny * ny * c2_minus_a2 + a2;\n q[5] = nz * nz * c2_minus_a2 + a2;\n q[4] = ny * nz * c2_minus_a2;\n q[2] = nx * nz * c2_minus_a2;\n q[1] = nx * ny * c2_minus_a2;\n}\n\n/**\n * Return the value of the opposite of the function ``f`` defined as (see\n * @verbatim embed:rst:inline :ref:`theory`@endverbatim).\n *\n * @f[f(\\lambda)=\\lambda\\bigl(1-\\lambda\\bigr)r_{12}^{\\mathsf{T}}\n * \\cdot Q^{-1}\\cdot r_{12},@f]\n *\n * with\n *\n * @f[Q = \\bigl(1-\\lambda\\bigr)Q_1 + \\lambda Q_2,@f]\n *\n * where ellipsoids 1 and 2 are defined as the sets of points @f$m@f$\n * (column-vector) such that\n *\n * @f[\\bigl(m-c_i\\bigr)\\cdot Q_i^{-1}\\cdot\\bigl(m-c_i\\bigr)\\leq1.@f]\n *\n * In the above inequality, @f$c_i@f$ is the center; @f$r_{12}=c_2-c_1@f$ is the\n * center-to-center radius-vector, represented by the `double[3]` array `r12`.\n * The symmetric, positive-definite matrices @f$Q_1@f$ and @f$Q_2@f$ are\n * specified through the `double[6]` arrays `q1` and `q2`.\n *\n * The value of @f$\\lambda@f$ is specified through the parameter ``lambda``.\n *\n * This function returns the value of @f$−f(\\lambda)@f$ (the “minus” sign comes\n * from the fact that we seek the maximum of @f$f@f$, or the minimum of\n * @f$−f@f$).\n *\n * This implementation uses\n * @verbatim embed:rst:inline:ref:`Cholesky decompositions\n * `@endverbatim.\n */\ndouble f_neg(double lambda, const double *r12, const double *q1,\n const double *q2) {\n double const *q1_i = q1;\n double const *q2_i = q2;\n double q[sym];\n double *q_i = q;\n double q12[sym];\n double *q12_i = q12;\n for (size_t i = 0; i < sym; i++, q1_i++, q2_i++, q_i++, q12_i++) {\n *q_i = (1 - lambda) * (*q1_i) + lambda * (*q2_i);\n *q12_i = (*q2_i) - (*q1_i);\n }\n double l[sym];\n _cholesky_decomp(q, l);\n double s[dim];\n _cholesky_solve(l, r12, s);\n double const *r_i = r12;\n double *s_i = s;\n double rs = 0.;\n for (size_t i = 0; i < dim; i++, r_i++, s_i++) {\n rs += (*r_i) * (*s_i);\n }\n return -lambda * (1. - lambda) * rs;\n}\n\n/**\n * Compute the residual \\f$g(\\lambda)=\\mu_2^2-\\mu_1^2\\f$.\n *\n * See @verbatim embed:rst:inline :ref:`optimization` @endverbatim for the\n * definition of \\f$g\\f$. The value of \\f$\\lambda\\f$ is specified through the\n * parameter `lambda`. See contact_function() for the definition of the\n * parameters `r12`, `q1` and `q2`.\n *\n * The preallocated `double[3]` array `out` is updated as follows:\n * `out[0]=`\\f$f(\\lambda)\\f$, `out[1]=`\\f$g(\\lambda)\\f$ and\n * `out[2]=`\\f$g'(\\lambda)\\f$.\n *\n * This function is used in function\n * @verbatim embed:rst:inline :cpp:func:`pw85::contact_function` @endverbatim\n * for the final Newton–Raphson refinement step.\n */\nvoid _residual(double lambda, const double *r12, const double *q1,\n const double *q2, double *out) {\n double q[sym];\n double q12[sym];\n for (size_t i = 0; i < sym; i++) {\n q[i] = (1. - lambda) * q1[i] + lambda * q2[i];\n q12[i] = q2[i] - q1[i];\n }\n double l[sym];\n _cholesky_decomp(q, l);\n double s[dim];\n _cholesky_solve(l, r12, s);\n double u[] = {q12[0] * s[0] + q12[1] * s[1] + q12[2] * s[2],\n q12[1] * s[0] + q12[3] * s[1] + q12[4] * s[2],\n q12[2] * s[0] + q12[4] * s[1] + q12[5] * s[2]};\n double v[dim];\n _cholesky_solve(l, u, v);\n double rs = r12[0] * s[0] + r12[1] * s[1] + r12[2] * s[2];\n double su = s[0] * u[0] + s[1] * u[1] + s[2] * u[2];\n double uv = u[0] * v[0] + u[1] * v[1] + u[2] * v[2];\n\n out[0] = lambda * (1. - lambda) * rs;\n out[1] = (2 * lambda - 1.) * rs + lambda * (1. - lambda) * su;\n out[2] =\n 2. * rs + 2. * (1. - 2. * lambda) * su - 2. * lambda * (1. - lambda) * uv;\n}\n\n/**\n * Compute the value of the contact function of two ellipsoids.\n *\n * The center-to-center radius-vector @f$r_{12}@f$ is specified by the\n * `double[3]` array `r12`. The symmetric, positive-definite matrices @f$Q_1@f$\n * and @f$Q_2@f$ that define the two ellipsoids are specified through the\n * `double[6]` arrays `q1` and `q2`.\n *\n * This function computes the value of @f$\\mu^2@f$, defined as\n *\n * @f[\\mu^2=\\max_{0\\leq\\lambda\\leq 1}\\bigl\\{\\lambda\\bigl(1-\\lambda\\bigr)\n * r_{12}^{\\mathsf{T}}\\cdot\\bigl[\\bigl(1-\\lambda\\bigr)Q_1+\\lambda Q_2\\bigr]^{-1}\n * \\cdot r_{12}\\bigr\\},@f]\n *\n * and the maximizer @f$\\lambda@f$, see\n * @verbatim embed:rst:inline:ref:`theory` @endverbatim. Both values are stored\n * in the preallocated `double[2]` array `out`: `out[0] = `@f$\\mu^2@f$ and\n * `out[1] = `@f$\\lambda@f$.\n *\n * @f$\\mu@f$ is the common factor by which the two ellipsoids must be scaled\n * (their centers being fixed) in order to be tangentially in contact.\n *\n * This function returns `0`.\n *\n * @verbatim embed:rst:leading-asterisk\n * .. todo:: This function should return an error code.\n * @endverbatim\n */\nint contact_function(const double *r12, const double *q1, const double *q2,\n double *out) {\n auto f = [r12, q1, q2](double lambda) { return f_neg(lambda, r12, q1, q2); };\n\n auto r = boost::math::tools::brent_find_minima(\n f, 0., 1., std::numeric_limits::digits / 2);\n auto lambda_brent = r.first;\n auto mu2_brent = -r.second;\n\n double out_res[3];\n _residual(lambda_brent, r12, q1, q2, out_res);\n double res_brent = fabs(out_res[1]);\n\n /* Try to refine the estimate. */\n double lambda_nr = lambda_brent;\n double mu2_nr = mu2_brent;\n double res_nr = res_brent;\n\n for (size_t i = 0; i < nr_iter; i++) {\n double lambda_trial = lambda_nr - out_res[1] / out_res[2];\n if ((lambda_trial < 0.) || (lambda_trial > 1.)) {\n break;\n }\n _residual(lambda_trial, r12, q1, q2, out_res);\n lambda_nr = lambda_trial;\n mu2_nr = out_res[0];\n res_nr = fabs(out_res[1]);\n }\n\n if (res_nr < res_brent) {\n out[0] = mu2_nr;\n out[1] = lambda_nr;\n } else {\n out[0] = mu2_brent;\n out[1] = lambda_brent;\n }\n\n /* TODO: return error code. */\n return 0;\n}\n} // namespace pw85\n", "meta": {"hexsha": "57f35f2f6101bb4d1f569a16b2ab2b711e762750", "size": 9594, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/pw85/pw85.hpp", "max_stars_repo_name": "sbrisard/pw85", "max_stars_repo_head_hexsha": "515da5a74002c956c9e12b4918659a51b92eca37", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/pw85/pw85.hpp", "max_issues_repo_name": "sbrisard/pw85", "max_issues_repo_head_hexsha": "515da5a74002c956c9e12b4918659a51b92eca37", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 19.0, "max_issues_repo_issues_event_min_datetime": "2018-08-02T07:15:25.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-24T04:52:38.000Z", "max_forks_repo_path": "include/pw85/pw85.hpp", "max_forks_repo_name": "sbrisard/pw85", "max_forks_repo_head_hexsha": "515da5a74002c956c9e12b4918659a51b92eca37", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.5220338983, "max_line_length": 202, "alphanum_fraction": 0.613404211, "num_tokens": 3399, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7634837635542924, "lm_q2_score": 0.7122321964553657, "lm_q1q2_score": 0.5437777178742828}} {"text": "/*!\n \\file gpp_knowledge_gradient_inner_optimization.hpp\n \\rst\n 1. OVERVIEW OF KNOWLEDGE GRADIENT WHAT ARE WE TRYING TO DO?\n 2. IMPLEMENTATION NOTES\n 3. CITATIONS\n\n **1. OVERVIEW OF KNOWLEDGE GRADIENT; WHAT ARE WE TRYING TO DO?**\n\n .. Note:: these comments are copied in Python: interfaces/__init__.py\n\n The optimization process models the objective using a Gaussian process (GP) prior\n (also called a GP predictor) based on the specified covariance and the input\n data (e.g., through member functions ComputeMeanOfPoints, ComputeVarianceOfPoints). Using the GP,\n we can compute the knowledge gradient (KG) from sampling any particular point. KG\n is defined relative to the best currently known value, and it represents what the\n algorithm believes is the most likely outcome from sampling a particular point in parameter\n space (aka conducting a particular experiment).\n\n See KnowledgeGradientEvaluator class docs for further details on computing KG.\n Both support ComputeKnowledgeGradient() and ComputeGradKnowledgeGradient().\n\n The behavior of the GP is controlled by its underlying\n covariance function and the data/uncertainty of prior points (experiments).\n\n With the ability of the compute KG, the final step is to optimize\n to find the best KG. This is done using multistart gradient descent (MGD), in\n ComputeKGOptimalPointsToSample(). This method wraps a MGD call and falls back on random search\n if that fails. See gpp_optimization.hpp for multistart/optimization templates. This method\n can evaluate and optimize KG at serval points simultaneously; e.g., if we wanted to run 4 simultaneous\n experiments, we can use KG to select all 4 points at once.\n\n Additionally, there are use cases where we have existing experiments that are not yet complete but\n we have an opportunity to start some new trials. For example, maybe we are a drug company currently\n testing 2 combinations of dosage levels. We got some new funding, and can now afford to test\n 3 more sets of dosage parameters. Ideally, the decision on the new experiments should depend on\n the existence of the 2 ongoing tests. We may not have any data from the ongoing experiments yet;\n e.g., they are [double]-blind trials. If nothing else, we would not want to duplicate any\n existing experiments! So we want to solve 3-KG using the knowledge of the 2 ongoing experiments.\n\n We call this q,p-KG, so the previous example would be 3,2-KG. So q is the number of new\n (simultaneous) experiments to select. In code, this would be the size of the output from KG\n optimization (i.e., ``best_points_to_sample``, of which there are ``q = num_to_sample points``).\n p is the number of ongoing/incomplete experiments to take into account (i.e., ``points_being_sampled``\n of which there are ``p = num_being_sampled`` points).\n\n Back to optimization: the idea behind gradient descent is simple. The gradient gives us the\n direction of steepest ascent (negative gradient is steepest descent). So each iteration, we\n compute the gradient and take a step in that direction. The size of the step is not specified\n by GD and is left to the specific implementation. Basically if we take steps that are\n too large, we run the risk of over-shooting the solution and even diverging. If we\n take steps that are too small, it may take an intractably long time to reach the solution.\n Thus the magic is in choosing the step size; we do not claim that our implementation is\n perfect, but it seems to work reasonably. See ``gpp_optimization.hpp`` for more details about\n GD as well as the template definition.\n\n For particularly difficult problems or problems where gradient descent's parameters are not\n well-chosen, GD can fail to converge. If this happens, we can fall back on heuristics;\n e.g., 'dumb' search (i.e., evaluate EI at a large number of random points and take the best\n one). Naive search lives in: ComputeOptimalPointsToSampleViaLatinHypercubeSearch<>().\n\n **2. IMPLEMENTATION NOTES**\n\n a. This file has a few primary endpoints for KG optimization:\n\n i. ComputeKGOptimalPointsToSampleWithRandomStarts<>():\n\n Solves the q,p-KG problem.\n\n Takes in a gaussian_process describing the prior, domain, config, etc.; outputs the next best point(s) (experiment)\n to sample (run). Uses gradient descent.\n\n ii. ComputeKGOptimalPointsToSampleViaLatinHypercubeSearch<>():\n\n Estimates the q,p-KG problem.\n\n Takes in a gaussian_process describing the prior, domain, etc.; outputs the next best point(s) (experiment)\n to sample (run). Uses 'dumb' search.\n\n iii. ComputeKGOptimalPointsToSample<>() (Recommended):\n\n Solves the q,p-KG problem.\n\n Wraps the previous two items; relies on gradient descent and falls back to \"dumb\" search if it fails.\n\n .. NOTE::\n See ``gpp_knowledge_gradient_optimization.cpp``'s header comments for more detailed implementation notes.\n\n There are also several other functions with external linkage in this header; these\n are provided primarily to ease testing and to permit lower level access from python.\n\n b. See ``gpp_common.hpp`` header comments for additional implementation notes.\n\n **3. CITATIONS**\n\n a. Gaussian Processes for Machine Learning.\n Carl Edward Rasmussen and Christopher K. I. Williams. 2006.\n Massachusetts Institute of Technology. 55 Hayward St., Cambridge, MA 02142.\n http://www.gaussianprocess.org/gpml/ (free electronic copy)\n\n b. The Knowledge-Gradient Policy for Correlated Normal Beliefs.\n P.I. Frazier, W.B. Powell & S. Dayanik.\n INFORMS Journal on Computing, 2009.\n\n c. Differentiation of the Cholesky Algorithm.\n S. P. Smith. 1995.\n Journal of Computational and Graphical Statistics. Volume 4. Number 2. p134-147\n\n d. A Multi-points Criterion for Deterministic Parallel Global Optimization based on Gaussian Processes.\n David Ginsbourger, Rodolphe Le Riche, and Laurent Carraro. 2008.\n D´epartement 3MI. Ecole Nationale Sup´erieure des Mines. 158 cours Fauriel, Saint-Etienne, France.\n ginsbourger@emse.fr, leriche@emse.fr, carraro@emse.fr\n\\endrst*/\n\n#ifndef MOE_OPTIMAL_LEARNING_CPP_GPP_KNOWLEDGE_GRADIENT_INNER_OPTIMIZATION_HPP_\n#define MOE_OPTIMAL_LEARNING_CPP_GPP_KNOWLEDGE_GRADIENT_INNER_OPTIMIZATION_HPP_\n\n#include \n#include \n#include \n#include \n\n#include // NOLINT(build/include_order)\n\n#include \"gpp_common.hpp\"\n#include \"gpp_domain.hpp\"\n#include \"gpp_exception.hpp\"\n#include \"gpp_covariance.hpp\"\n#include \"gpp_logging.hpp\"\n#include \"gpp_math.hpp\"\n#include \"gpp_optimization.hpp\"\n#include \"gpp_optimizer_parameters.hpp\"\n#include \"gpp_random.hpp\"\n\nnamespace optimal_learning {\n\nstruct FuturePosteriorMeanState;\n/*!\\rst\n This is a specialization of the ExpectedImprovementEvaluator class for when the number of potential samples is 1; i.e.,\n ``num_to_sample == 1`` and the number of concurrent samples is 0; i.e. ``num_being_sampled == 0``.\n In other words, this class only supports the computation of 1,0-EI. In this case, we have analytic formulas\n for computing EI and its gradient.\n Thus this class does not perform any explicit numerical integration, nor do its EI functions require access to a\n random number generator.\n This class's methods have some parameters that are unused or redundant. This is so that the interface matches that of\n the more general ExpectedImprovementEvaluator.\n For other details, see ExpectedImprovementEvaluator for more complete description of what EI is and the outputs of\n EI and grad EI computations.\n\\endrst*/\nclass FuturePosteriorMeanEvaluator final {\n public:\n using StateType = FuturePosteriorMeanState;\n\n /*!\\rst\n Constructs a OnePotentialSampleExpectedImprovementEvaluator object. All inputs are required; no default constructor nor copy/assignment are allowed.\n \\param\n :gaussian_process: GaussianProcess object (holds ``points_sampled``, ``values``, ``noise_variance``, derived quantities)\n that describes the underlying GP\n :best_so_far: best (minimum) objective function value (in ``points_sampled_value``)\n \\endrst*/\n FuturePosteriorMeanEvaluator(const GaussianProcess& gaussian_process_in,\n double const * coefficient,\n double const * to_sample,\n const int num_to_sample,\n int const * to_sample_derivatives,\n int num_derivatives,\n double const * chol,\n double const * train_sample);\n\n int dim() const noexcept OL_PURE_FUNCTION OL_WARN_UNUSED_RESULT {\n return dim_;\n }\n\n const GaussianProcess * gaussian_process() const noexcept OL_PURE_FUNCTION OL_WARN_UNUSED_RESULT {\n return gaussian_process_;\n }\n\n std::vector to_sample_points(double const * to_sample,\n int num_to_sample) noexcept OL_WARN_UNUSED_RESULT {\n std::vector result(num_to_sample*dim_);\n std::copy(to_sample, to_sample + num_to_sample*dim_, result.data());\n return result;\n }\n\n std::vector derivatives(int const * to_sample_derivatives,\n int num_derivatives) noexcept OL_WARN_UNUSED_RESULT {\n std::vector result(num_derivatives);\n std::copy(to_sample_derivatives, to_sample_derivatives + num_derivatives, result.data());\n return result;\n }\n\n std::vector coeff(double const * coefficient, double const * chol,\n int num_to_sample, int num_derivatives) noexcept OL_WARN_UNUSED_RESULT {\n std::vector result(num_to_sample*(1+num_derivatives));\n std::copy(coefficient, coefficient + num_to_sample*(1+num_derivatives), result.data());\n TriangularMatrixVectorSolve(chol, 'T', num_to_sample_*(1+num_derivatives_),\n num_to_sample_*(1+num_derivatives_), result.data());\n return result;\n }\n\n std::vector coeff_combine(double const * coefficient, double const * train_sample,\n int num_to_sample, int num_derivatives) noexcept OL_WARN_UNUSED_RESULT {\n std::vector temp(num_to_sample*(1+num_derivatives));\n std::copy(coefficient, coefficient + num_to_sample*(1+num_derivatives), temp.data());\n\n std::vector result(gaussian_process_->get_K_inv_y());\n int num_observations = gaussian_process_->num_sampled() * (1 + gaussian_process_->num_derivatives());\n GeneralMatrixVectorMultiply(train_sample, 'N', temp.data(), -1.0, 1.0,\n num_observations, num_to_sample*(1+num_derivatives),\n num_observations, result.data());\n return result;\n }\n\n /*!\\rst\n Wrapper for ComputeExpectedImprovement(); see that function for details.\n \\endrst*/\n double ComputeObjectiveFunction(StateType * ps_state) const OL_NONNULL_POINTERS OL_WARN_UNUSED_RESULT {\n return ComputePosteriorMean(ps_state);\n }\n\n /*!\\rst\n Wrapper for ComputeGradExpectedImprovement(); see that function for details.\n \\endrst*/\n void ComputeGradObjectiveFunction(StateType * ps_state, double * restrict grad_PS) const OL_NONNULL_POINTERS {\n ComputeGradPosteriorMean(ps_state, grad_PS);\n }\n\n /*!\\rst\n Computes the expected improvement ``EI(Xs) = E_n[[f^*_n(X) - min(f(Xs_1),...,f(Xs_m))]^+]``\n Uses analytic formulas to evaluate the expected improvement.\n \\param\n :ei_state[1]: properly configured state object\n \\output\n :ei_state[1]: state with temporary storage modified\n \\return\n the expected improvement from sampling ``point_to_sample``\n \\endrst*/\n double ComputePosteriorMean(StateType * ps_state) const;\n\n /*!\\rst\n Computes the (partial) derivatives of the expected improvement with respect to the point to sample.\n Uses analytic formulas to evaluate the spatial gradient of the expected improvement.\n \\param\n :ei_state[1]: properly configured state object\n \\output\n :ei_state[1]: state with temporary storage modified\n :grad_EI[dim]: gradient of EI, ``\\pderiv{EI(x)}{x_d}``, where ``x`` is ``points_to_sample``\n \\endrst*/\n void ComputeGradPosteriorMean(StateType * ps_state, double * restrict grad_PS) const;\n\n OL_DISALLOW_DEFAULT_AND_COPY_AND_ASSIGN(FuturePosteriorMeanEvaluator);\n\n private:\n //! spatial dimension (e.g., entries per point of ``points_sampled``)\n const int dim_;\n\n //! pointer to gaussian process used in computations\n const GaussianProcess * gaussian_process_;\n\n //! points to sample in the next sampling step\n const std::vector to_sample_;\n\n //! number of points in the next sampling step\n const int num_to_sample_;\n\n //! the dims with derivatives\n const std::vector to_sample_derivatives_;\n\n //! number of derivatives\n const int num_derivatives_;\n\n //! transpose(Chol)^-1 * (sampled Z)\n const std::vector coeff_;\n const std::vector coeff_combined_;\n};\n\n/*!\\rst\n State object for OnePotentialSampleExpectedImprovementEvaluator. This tracks the *ONE* ``point_to_sample``\n being evaluated via expected improvement.\n This is just a special case of ExpectedImprovementState; see those class docs for more details.\n See general comments on State structs in ``gpp_common.hpp``'s header docs.\n\\endrst*/\nstruct FuturePosteriorMeanState final {\n using EvaluatorType = FuturePosteriorMeanEvaluator;\n\n /*!\\rst\n Constructs an OnePotentialSampleExpectedImprovementState object for the purpose of computing EI\n (and its gradient) over the specified point to sample.\n This establishes properly sized/initialized temporaries for EI computation, including dependent state from the\n associated Gaussian Process (which arrives as part of the ``ei_evaluator``).\n .. WARNING::\n This object is invalidated if the associated ei_evaluator is mutated. SetupState() should be called to reset.\n .. WARNING::\n Using this object to compute gradients when ``configure_for_gradients`` := false results in UNDEFINED BEHAVIOR.\n \\param\n :ei_evaluator: expected improvement evaluator object that specifies the parameters & GP for EI evaluation\n :point_to_sample[dim]: point at which to evaluate EI and/or its gradient to check their value in future experiments (i.e., test point for GP predictions)\n :configure_for_gradients: true if this object will be used to compute gradients, false otherwise\n \\endrst*/\n FuturePosteriorMeanState(const EvaluatorType& ps_evaluator, const int num_fidelity_in, double const * restrict point_to_sample_in, bool configure_for_gradients);\n\n FuturePosteriorMeanState(FuturePosteriorMeanState&& other);\n\n int GetProblemSize() const noexcept OL_PURE_FUNCTION OL_WARN_UNUSED_RESULT {\n return dim - num_fidelity;\n }\n\n std::vector BuildUnionOfPoints(double const * restrict points_to_sample) noexcept OL_WARN_UNUSED_RESULT {\n std::vector union_of_points(dim);\n std::copy(points_to_sample, points_to_sample + dim - num_fidelity, union_of_points.data());\n std::fill(union_of_points.data() + dim - num_fidelity, union_of_points.data() + dim, 1.0);\n return union_of_points;\n }\n\n /*!\\rst\n Get ``point_to_sample``: the potential future sample whose EI (and/or gradients) is being evaluated\n \\output\n :point_to_sample[dim]: potential sample whose EI is being evaluted\n \\endrst*/\n void GetCurrentPoint(double * restrict point_to_sample_out) const noexcept OL_NONNULL_POINTERS {\n std::copy(point_to_sample.data(), point_to_sample.data() + dim - num_fidelity, point_to_sample_out);\n }\n\n void Initialize(const EvaluatorType& ps_evaluator);\n\n /*!\\rst\n Change the potential sample whose EI (and/or gradient) is being evaluated.\n Update the state's derived quantities to be consistent with the new point.\n \\param\n :ei_evaluator: expected improvement evaluator object that specifies the parameters & GP for EI evaluation\n :point_to_sample[dim]: potential future sample whose EI (and/or gradients) is being evaluated\n \\endrst*/\n void SetCurrentPoint(const EvaluatorType& ps_evaluator,\n double const * restrict point_to_sample_in) OL_NONNULL_POINTERS;\n\n /*!\\rst\n Configures this state object with a new ``point_to_sample``, the location of the potential sample whose EI is to be evaluated.\n Ensures all state variables & temporaries are properly sized.\n Properly sets all dependent state variables (e.g., GaussianProcess's state) for EI evaluation.\n .. WARNING::\n This object's state is INVALIDATED if the ei_evaluator (including the GaussianProcess it depends on) used in\n SetupState is mutated! SetupState() should be called again in such a situation.\n \\param\n :ei_evaluator: expected improvement evaluator object that specifies the parameters & GP for EI evaluation\n :point_to_sample[dim]: potential future sample whose EI (and/or gradients) is being evaluated\n \\endrst*/\n void SetupState(const EvaluatorType& ps_evaluator,\n double const * restrict point_to_sample_in) OL_NONNULL_POINTERS;\n\n // size information\n //! spatial dimension (e.g., entries per point of ``points_sampled``)\n const int dim;\n //! dim of the fidelity\n const int num_fidelity;\n //! number of points to sample (i.e., the \"q\" in q,p-EI); MUST be 1\n const int num_to_sample = 1;\n //! number of derivative terms desired (usually 0 for no derivatives or num_to_sample)\n const int num_derivatives;\n\n //! point at which to evaluate EI and/or its gradient (e.g., to check its value in future experiments)\n std::vector point_to_sample;\n\n std::vector K_star;\n std::vector grad_K_star;\n\n UniformRandomGenerator randomGenerator;\n OL_DISALLOW_DEFAULT_AND_COPY_AND_ASSIGN(FuturePosteriorMeanState);\n};\n\n/*!\\rst\n Set up vector of FuturePosteriorMeanState::StateType.\n\n This is a utility function just for reducing code duplication.\n\n \\param\n :ei_evaluator: evaluator object associated w/the state objects being constructed\n :points_to_sample[dim][num_to_sample]: initial points to load into state (must be a valid point for the problem);\n i.e., points at which to evaluate EI and/or its gradient\n :points_being_sampled[dim][num_being_sampled]: points that are being sampled in concurrently experiments\n :num_to_sample: number of potential future samples; gradients are evaluated wrt these points (i.e., the \"q\" in q,p-EI)\n :num_being_sampled: number of points being sampled concurrently (i.e., the p in q,p-EI)\n :max_num_threads: maximum number of threads for use by OpenMP (generally should be <= # cores)\n :configure_for_gradients: true if these state objects will be used to compute gradients, false otherwise\n :state_vector[arbitrary]: vector of state objects, arbitrary size (usually 0)\n :normal_rng[max_num_threads]: a vector of NormalRNG objects that provide the (pesudo)random source for MC integration\n \\output\n :state_vector[max_num_threads]: vector of states containing ``max_num_threads`` properly initialized state objects\n\\endrst*/\ninline OL_NONNULL_POINTERS void SetupFuturePosteriorMeanState(\n const FuturePosteriorMeanEvaluator& fpm_evaluator,\n double const * restrict points_to_sample,\n int max_num_threads,\n bool configure_for_gradients,\n const int num_fidelity,\n std::vector * state_vector) {\n state_vector->reserve(max_num_threads);\n for (int i = 0; i < max_num_threads; ++i) {\n state_vector->emplace_back(fpm_evaluator, num_fidelity, points_to_sample, configure_for_gradients);\n }\n}\n\n\n/*!\\rst\n Perform multistart gradient descent (MGD) to solve the q,p-EI problem (see ComputeOptimalPointsToSample and/or\n header docs), starting from ``num_multistarts`` points selected randomly from the within th domain.\n This function is a simple wrapper around ComputeOptimalPointsToSampleViaMultistartGradientDescent(). It additionally\n generates a set of random starting points and is just here for convenience when better initial guesses are not\n available.\n See ComputeOptimalPointsToSampleViaMultistartGradientDescent() for more details.\n \\param\n :gaussian_process: GaussianProcess object (holds ``points_sampled``, ``values``, ``noise_variance``, derived quantities)\n that describes the underlying GP\n :optimizer_parameters: GradientDescentParameters object that describes the parameters controlling EI optimization\n (e.g., number of iterations, tolerances, learning rate)\n :domain: object specifying the domain to optimize over (see ``gpp_domain.hpp``)\n :thread_schedule: struct instructing OpenMP on how to schedule threads; i.e., (suggestions in parens)\n max_num_threads (num cpu cores), schedule type (omp_sched_dynamic), chunk_size (0).\n :points_being_sampled[dim][num_being_sampled]: points that are being sampled in concurrent experiments\n :num_to_sample: number of potential future samples; gradients are evaluated wrt these points (i.e., the \"q\" in q,p-EI)\n :num_being_sampled: number of points being sampled concurrently (i.e., the \"p\" in q,p-EI)\n :best_so_far: value of the best sample so far (must be ``min(points_sampled_value)``)\n :max_int_steps: maximum number of MC iterations\n :uniform_generator[1]: a UniformRandomGenerator object providing the random engine for uniform random numbers\n :normal_rng[thread_schedule.max_num_threads]: a vector of NormalRNG objects that provide\n the (pesudo)random source for MC integration\n \\output\n :found_flag[1]: true if best_next_point corresponds to a nonzero EI\n :uniform_generator[1]: UniformRandomGenerator object will have its state changed due to random draws\n :normal_rng[thread_schedule.max_num_threads]: NormalRNG objects will have their state changed due to random draws\n :best_next_point[dim][num_to_sample]: points yielding the best EI according to MGD\n\\endrst*/\ntemplate \nvoid RestartedGradientDescentFuturePosteriorMeanOptimization(const GaussianProcess& gaussian_process, const int num_fidelity,\n double const * coefficient, double const * to_sample, const int num_to_sample,\n int const * to_sample_derivatives, int num_derivatives,\n double const * chol, double const * train_sample,\n const GradientDescentParameters& optimizer_parameters,\n const DomainType& domain, double const * restrict initial_guess,\n double& best_objective_value, double * restrict best_next_point) {\n if (unlikely(optimizer_parameters.max_num_restarts <= 0)) {\n return;\n }\n bool configure_for_gradients = true;\n OL_VERBOSE_PRINTF(\"Posterior Mean Optimization via %s:\\n\", OL_CURRENT_FUNCTION_NAME);\n\n // special analytic case when we are not using (or not accounting for) multiple, simultaneous experiments\n FuturePosteriorMeanEvaluator ps_evaluator(gaussian_process, coefficient, to_sample,\n num_to_sample, to_sample_derivatives,\n num_derivatives, chol, train_sample);\n\n typename FuturePosteriorMeanEvaluator::StateType ps_state(ps_evaluator, num_fidelity, initial_guess, configure_for_gradients);\n\n GradientDescentOptimizer gd_opt;\n gd_opt.Optimize(ps_evaluator, optimizer_parameters, domain, &ps_state);\n ps_state.GetCurrentPoint(best_next_point);\n best_objective_value = ps_evaluator.ComputeObjectiveFunction(&ps_state);\n}\n\n/*!\\rst\n Perform multistart gradient descent (MGD) to solve the q,p-EI problem (see ComputeOptimalPointsToSample and/or\n header docs), starting from ``num_multistarts`` points selected randomly from the within th domain.\n This function is a simple wrapper around ComputeOptimalPointsToSampleViaMultistartGradientDescent(). It additionally\n generates a set of random starting points and is just here for convenience when better initial guesses are not\n available.\n See ComputeOptimalPointsToSampleViaMultistartGradientDescent() for more details.\n \\param\n :gaussian_process: GaussianProcess object (holds ``points_sampled``, ``values``, ``noise_variance``, derived quantities)\n that describes the underlying GP\n :optimizer_parameters: GradientDescentParameters object that describes the parameters controlling EI optimization\n (e.g., number of iterations, tolerances, learning rate)\n :domain: object specifying the domain to optimize over (see ``gpp_domain.hpp``)\n :thread_schedule: struct instructing OpenMP on how to schedule threads; i.e., (suggestions in parens)\n max_num_threads (num cpu cores), schedule type (omp_sched_dynamic), chunk_size (0).\n :points_being_sampled[dim][num_being_sampled]: points that are being sampled in concurrent experiments\n :num_to_sample: number of potential future samples; gradients are evaluated wrt these points (i.e., the \"q\" in q,p-EI)\n :num_being_sampled: number of points being sampled concurrently (i.e., the \"p\" in q,p-EI)\n :best_so_far: value of the best sample so far (must be ``min(points_sampled_value)``)\n :max_int_steps: maximum number of MC iterations\n :uniform_generator[1]: a UniformRandomGenerator object providing the random engine for uniform random numbers\n :normal_rng[thread_schedule.max_num_threads]: a vector of NormalRNG objects that provide\n the (pesudo)random source for MC integration\n \\output\n :found_flag[1]: true if best_next_point corresponds to a nonzero EI\n :uniform_generator[1]: UniformRandomGenerator object will have its state changed due to random draws\n :normal_rng[thread_schedule.max_num_threads]: NormalRNG objects will have their state changed due to random draws\n :best_next_point[dim][num_to_sample]: points yielding the best EI according to MGD\n\\endrst*/\ntemplate \nvoid ComputeOptimalFuturePosteriorMean(const GaussianProcess& gaussian_process, const int num_fidelity, double const * coefficient,\n double const * to_sample, const int num_to_sample, int const * to_sample_derivatives,\n int num_derivatives, double const * chol, double const * train_sample,\n const GradientDescentParameters& optimizer_parameters, const DomainType& domain,\n int max_num_threads, double const * restrict start_point_set,\n int num_multistarts, double * restrict best_function_value, double * restrict best_next_point);\n\n// template explicit instantiation declarations, see gpp_common.hpp header comments, item 6\nextern template void ComputeOptimalFuturePosteriorMean(const GaussianProcess& gaussian_process, const int num_fidelity, double const * coefficient,\n double const * to_sample, const int num_to_sample, int const * to_sample_derivatives,\n int num_derivatives, double const * chol, double const * train_sample,\n const GradientDescentParameters& optimizer_parameters, const TensorProductDomain& domain,\n int max_num_threads, double const * restrict start_point_set,\n int num_multistarts, double * restrict best_function_value,\n double * restrict best_next_point);\nextern template void ComputeOptimalFuturePosteriorMean(const GaussianProcess& gaussian_process, const int num_fidelity, double const * coefficient,\n double const * to_sample, const int num_to_sample, int const * to_sample_derivatives,\n int num_derivatives, double const * chol, double const * train_sample,\n const GradientDescentParameters& optimizer_parameters, const SimplexIntersectTensorProductDomain& domain,\n int max_num_threads, double const * restrict start_point_set,\n int num_multistarts, double * restrict best_function_value,\n double * restrict best_next_point);\n} // end namespace optimal_learning\n#endif // MOE_OPTIMAL_LEARNING_CPP_GPP_KNOWLEDGE_GRADIENT_INNER_OPTIMIZATION_HPP_", "meta": {"hexsha": "72c840d3a8890e0bf5fedf52cb8a88f3ff51e7ac", "size": 29102, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "moe/optimal_learning/cpp/gpp_knowledge_gradient_inner_optimization.hpp", "max_stars_repo_name": "AliBaheri/Cornell-MOE", "max_stars_repo_head_hexsha": "5c36a1c60eecfeea6e45c485179b671e12f07ad9", "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": "moe/optimal_learning/cpp/gpp_knowledge_gradient_inner_optimization.hpp", "max_issues_repo_name": "AliBaheri/Cornell-MOE", "max_issues_repo_head_hexsha": "5c36a1c60eecfeea6e45c485179b671e12f07ad9", "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": "moe/optimal_learning/cpp/gpp_knowledge_gradient_inner_optimization.hpp", "max_forks_repo_name": "AliBaheri/Cornell-MOE", "max_forks_repo_head_hexsha": "5c36a1c60eecfeea6e45c485179b671e12f07ad9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-08-02T14:48:26.000Z", "max_forks_repo_forks_event_max_datetime": "2019-08-02T14:48:26.000Z", "avg_line_length": 56.83984375, "max_line_length": 163, "alphanum_fraction": 0.7212906329, "num_tokens": 6303, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7634837635542924, "lm_q2_score": 0.7122321720225278, "lm_q1q2_score": 0.5437776992202077}} {"text": "#pragma once\n\n#include \n\n#include \"nifty/math/math.hxx\"\n#include \"nifty/histogram/histogram.hxx\"\n#include \"nifty/cgp/geometry.hxx\"\n#include \"nifty/cgp/bounds.hxx\"\n#include \"nifty/marray/marray.hxx\"\n#include \"nifty/filters/gaussian_curvature.hxx\"\n#include \"nifty/features/accumulated_features.hxx\"\n\n#include \n#include \n#include \n\n\nnamespace nifty{\nnamespace cgp{\n\n class Cell1CurvatureFeatures2D{\n private:\n typedef nifty::features::DefaultAccumulatedStatistics AccType;\n public:\n Cell1CurvatureFeatures2D(\n const std::vector & sigmas = std::vector({1.0f, 2.0f, 4.0f})\n )\n : sigmas_(sigmas)\n {\n\n }\n\n size_t numberOfFeatures()const{\n return sigmas_.size() * AccType::NFeatures::value; \n }\n \n\n std::vector names()const{\n\n std::string accNames [] = {\n std::string(\"Mean\"),\n std::string(\"Sum\"),\n std::string(\"Min\"),\n std::string(\"Max\"),\n std::string(\"Moment2\"),\n std::string(\"Moment3\"),\n std::string(\"Q0.10\"),\n std::string(\"Q0.25\"),\n std::string(\"Q0.50\"),\n std::string(\"Q0.75\"),\n std::string(\"Q0.90\")\n };\n std::vector res;\n auto baseName = std::string(\"GaussianCurvatureSigma\");\n for(auto sigmaIndex=0; sigmaIndex\n void operator()(\n const CellGeometryVector<2,1> & cell1GeometryVector,\n const CellBoundedByVector<2,1> & cell1BoundedByVector,\n nifty::marray::View & features\n )const{ \n\n std::vector curvature;\n std::vector buffer(AccType::NFeatures::value);\n \n\n \n for(auto sigmaIndex=0; sigmaIndex op(sigma, -1, 2.5);\n\n\n for(auto cell1Index=0; cell1Index=4){\n\n \n // we use a larger size?\n if(curvature.capacity() < geo.size()){\n curvature.resize(geo.size()*2);\n }\n else{\n curvature.resize(geo.size());\n }\n\n // calculate curvature\n //std::cout<<\" is closed \"<<\"\\n\";\n const auto closedLine = cell1BoundedByVector[cell1Index].size() == 0;\n //std::cout<<\" calculate curvature \"<<\"\\n\";\n op(geo.begin(), geo.end(), curvature.begin(), closedLine);\n\n // accumulate the values\n AccType acc;\n for(auto pass=0; pass < acc.requiredPasses(); ++pass){\n for(const auto & c : curvature){\n acc.acc(c, pass);\n }\n }\n // write to buffer\n acc.result(buffer.begin(), buffer.end()); \n \n // write to features out\n const auto fIndex = sigmaIndex*AccType::NFeatures::value;\n for(auto afi=0; afi sigmas_;\n };\n\n\n\n\n class Cell1LineSegmentDist2D{\n private:\n typedef nifty::features::DefaultAccumulatedStatistics AccType;\n public:\n Cell1LineSegmentDist2D(\n const std::vector & dists = std::vector({size_t(3),size_t(5),size_t(7)})\n )\n : dists_(dists)\n {\n }\n\n size_t numberOfFeatures()const{\n return dists_.size()*AccType::NFeatures::value;\n }\n\n std::vector names()const{\n\n std::string accNames [] = {\n std::string(\"Mean\"),\n std::string(\"Sum\"),\n std::string(\"Min\"),\n std::string(\"Max\"),\n std::string(\"Moment2\"),\n std::string(\"Moment3\"),\n std::string(\"Q0.10\"),\n std::string(\"Q0.25\"),\n std::string(\"Q0.50\"),\n std::string(\"Q0.75\"),\n std::string(\"Q0.90\")\n };\n std::vector res;\n auto baseName = std::string(\"Cell1LineSegmentDistD\");\n for(auto i=0; i\n void operator()(\n const CellGeometryVector<2,1> & cell1GeometryVector,\n nifty::marray::View & features\n )const{ \n\n std::vector buffer(AccType::NFeatures::value);\n\n typedef boost::geometry::model::d2::point_xy point_type;\n typedef boost::geometry::model::linestring linestring_type;\n\n\n for(auto di=0; di=4){\n\n AccType acc;\n\n for(auto pass=0; pass < acc.requiredPasses(); ++pass){\n\n for(auto i=0; i dists_;\n };\n\n\n class Cell1BasicGeometricFeatures2D{\n private:\n typedef nifty::features::DefaultAccumulatedStatistics AccType;\n public:\n Cell1BasicGeometricFeatures2D(){\n }\n\n size_t numberOfFeatures()const{\n return 4 * 4 + 2*AccType::NFeatures::value + 4; \n }\n\n\n\n std::vector names()const{\n\n std::string accNames [] = {\n std::string(\"Mean\"),\n std::string(\"Sum\"),\n std::string(\"Min\"),\n std::string(\"Max\"),\n std::string(\"Moment2\"),\n std::string(\"Moment3\"),\n std::string(\"Q0.10\"),\n std::string(\"Q0.25\"),\n std::string(\"Q0.50\"),\n std::string(\"Q0.75\"),\n std::string(\"Q0.90\")\n };\n\n std::vector res;\n const auto baseName = std::string(\"BasicGeometricFeatures\");\n auto insertUVFeat = [&](const std::string & name){\n res.push_back(baseName+name+std::string(\"UV-Min\"));\n res.push_back(baseName+name+std::string(\"UV-Max\"));\n res.push_back(baseName+name+std::string(\"UV-Sum\"));\n res.push_back(baseName+name+std::string(\"UV-AbsDiff\"));\n };\n auto insertStatFeat = [&](const std::string & name){\n for(const auto & an : accNames){\n res.push_back(baseName+name+an);\n }\n };\n\n res.push_back(baseName+std::string(\"EdgeSize\"));\n insertUVFeat(\"NodeSize\");\n insertUVFeat(\"NodeEdgeSizeRatio\");\n\n res.push_back(baseName+std::string(\"EdgeEndpointDistance\"));\n res.push_back(baseName+std::string(\"EdgeRelativeEndpointDistance\"));\n res.push_back(baseName+std::string(\"NodeEndpointDistance\"));\n\n \n insertUVFeat(\"EdgeNodeCenterOfMassDist\");\n insertUVFeat(\"EdgeNodeCenterOfMassRatio\"); \n\n insertStatFeat(\"CenterOfMassCell1PointsDist\");\n insertStatFeat(\"CenterOfMassCell2PointsDist\");\n\n return res;\n }\n\n template\n void operator()(\n const CellGeometryVector<2,1> & cell1GeometryVector,\n const CellGeometryVector<2,2> & cell2GeometryVector,\n const CellBoundsVector<2,1> & cell1BoundsVector,\n nifty::marray::View & features\n )const{ \n\n using namespace nifty::math;\n std::vector buffer(AccType::NFeatures::value);\n for(auto cell1Index=0; cell1Index dists_;\n };\n\n\n /**\n class GeometricAccumulator{\n private:\n typedef nifty::features::DefaultAccumulatedStatistics AccType;\n public:\n GeometricAccumulator(\n const std::vector & dists = std::vector({size_t(3),size_t(5),size_t(7)})\n )\n : dists_(dists)\n {\n }\n\n size_t numberOfFeatures()const{\n return dists_.size()*AccType::NFeatures::value;\n }\n \n\n template\n void operator()(\n const CellGeometryVector<2,1> & cell1GeometryVector,\n nifty::marray::View & features\n )const{ \n\n std::vector buffer(AccType::NFeatures::value);\n\n typedef boost::geometry::model::d2::point_xy point_type;\n typedef boost::geometry::model::linestring linestring_type;\n\n\n \n for(auto cell1Index=0; cell1Index dists_;\n };\n */\n\n\n\n}\n}", "meta": {"hexsha": "a8c70d812d95910b2a780ac46a0744f9019334c0", "size": 17300, "ext": "hxx", "lang": "C++", "max_stars_repo_path": "include/nifty/cgp/features/geometric_features.hxx", "max_stars_repo_name": "k-dominik/nifty", "max_stars_repo_head_hexsha": "067e137e9c1f33cccb22052b53ff0d75c288d667", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/nifty/cgp/features/geometric_features.hxx", "max_issues_repo_name": "k-dominik/nifty", "max_issues_repo_head_hexsha": "067e137e9c1f33cccb22052b53ff0d75c288d667", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/nifty/cgp/features/geometric_features.hxx", "max_forks_repo_name": "k-dominik/nifty", "max_forks_repo_head_hexsha": "067e137e9c1f33cccb22052b53ff0d75c288d667", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-02-07T09:29:26.000Z", "max_forks_repo_forks_event_max_datetime": "2018-02-07T09:29:26.000Z", "avg_line_length": 35.020242915, "max_line_length": 101, "alphanum_fraction": 0.4660115607, "num_tokens": 3706, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392909114836, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.5437618316386885}} {"text": "#include \n#include \n\nvoid MetaScale::normalize() {\n uint32_t a = mNum<0?-mNum:mNum;\n uint32_t gcd = boost::math::gcd(a,mDenom);\n mNum /= gcd;\n mDenom /= gcd;\n}\n\nMetaScale& MetaScale::operator*=(const MetaScale& b) {\n mNum*=b.num();\n mDenom*=b.denom();\n normalize();\n return *this;\n}\n\nMetaScale& MetaScale::operator/=(const MetaScale& b) {\n uint32_t temp = mNum*b.denom();\n mDenom*=b.num();\n mNum = temp;\n normalize();\n return *this;\n}\nMetaScale MetaScale::operator*(const MetaScale& b) const {\n return MetaScale(*this) *= b;\n}\n\nMetaScale MetaScale::operator/(const MetaScale& b) const {\n return MetaScale(*this) /= b;\n}\n", "meta": {"hexsha": "fc00dcb79e30350956abe0f01b5bcd49c0457ab5", "size": 683, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/MetaScale.cpp", "max_stars_repo_name": "steup/ASEIA", "max_stars_repo_head_hexsha": "498538fbefa95bac7723ad20582ff9d3dace3674", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/MetaScale.cpp", "max_issues_repo_name": "steup/ASEIA", "max_issues_repo_head_hexsha": "498538fbefa95bac7723ad20582ff9d3dace3674", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2017-10-29T01:07:55.000Z", "max_issues_repo_issues_event_max_datetime": "2017-10-29T01:07:55.000Z", "max_forks_repo_path": "src/MetaScale.cpp", "max_forks_repo_name": "steup/ASEIA", "max_forks_repo_head_hexsha": "498538fbefa95bac7723ad20582ff9d3dace3674", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.34375, "max_line_length": 58, "alphanum_fraction": 0.6647144949, "num_tokens": 213, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8633916240341031, "lm_q2_score": 0.6297746004557471, "lm_q1q2_score": 0.5437421150629158}} {"text": "/* Copyright (c) 2010-2015, Delft University of Technology\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without modification, are\n * permitted provided that the following conditions are met:\n * - Redistributions of source code must retain the above copyright notice, this list of\n * conditions and the following disclaimer.\n * - Redistributions in binary form must reproduce the above copyright notice, this list of\n * conditions and the following disclaimer in the documentation and/or other materials\n * provided with the distribution.\n * - Neither the name of the Delft University of Technology nor the names of its contributors\n * may be used to endorse or promote products derived from this software without specific\n * prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS\n * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE\n * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE\n * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED\n * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED\n * OF THE POSSIBILITY OF SUCH DAMAGE.\n *\n * Changelog\n * YYMMDD Author Comment\n * 121128 R.C.A. Boon File created (in progress).\n * 130124 R.C.A. Boon Removed retrograde function, reworked Kepler to MEE conversion\n * to properly convert inclination to range [0,180) and use\n * retrograde factor internally\n * 130131 R.C.A. Boon Added Cartesian conversion cases, added avoidSingularityAtPi~\n * boolean flag to Kepler conversions, optimized computation\n * (partially)\n * 130225 D. Dirkx Added overloaded function for Kepler to MEE that determines\n * retrogradeness based on Kepler state\n * 130301 R.C.A. Boon Updated use of mathematics::PI to basic_mathematics::\n * mathematical_constants::PI, minor textual changes.\n * 130305 R.C.A. Boon Replaced Eigen::VectorXd by basic_mathematics::Vector6d\n *\n * References\n * Verified Interval Propagation, Bart Rˆmgens; Delft (2011). Code archive.\n * Modified Equinoctial Orbital Elements, author unknown;\n * http://www.cdeagle.com/pdf/mee.pdf (2010?).\n * Survey of Orbital Element Sets, Gerald R. Hintz; Journal of Guidance, Control and\n * Dynamics (2008, Vol. 31 - Nr. 3).\n * Code archive, E. Heeren (fellow Tudat developer).\n *\n * Notes\n *\n */\n\n#include \n\n#include \n\n#include \"Tudat/Astrodynamics/BasicAstrodynamics/orbitalElementConversions.h\"\n#include \"Tudat/Mathematics/BasicMathematics/mathematicalConstants.h\"\n#include \"Tudat/Mathematics/BasicMathematics/basicMathematicsFunctions.h\"\n\n#include \"Tudat/Astrodynamics/BasicAstrodynamics/missionGeometry.h\"\n#include \"Tudat/Astrodynamics/BasicAstrodynamics/modifiedEquinoctialElementConversions.h\"\n#include \"Tudat/Astrodynamics/BasicAstrodynamics/stateVectorIndices.h\"\n\nnamespace tudat\n{\n\nnamespace orbital_element_conversions\n{\n\n//! Convert Keplerian to modified equinoctial orbital elements using implicit MEE equation set.\nbasic_mathematics::Vector6d convertKeplerianToModifiedEquinoctialElements(\n const basic_mathematics::Vector6d& keplerianElements )\n// Based on Hintz, 2008.\n{\n // Check if orbit is retrograde\n bool avoidSingularityAtPiInclination =\n mission_geometry::isOrbitRetrograde( keplerianElements );\n\n // Convert to modified equinoctial elements.\n return convertKeplerianToModifiedEquinoctialElements( keplerianElements,\n avoidSingularityAtPiInclination );\n}\n\n//! Convert Keplerian to modified equinoctial orbital elements using MEE explicit equation set.\nbasic_mathematics::Vector6d convertKeplerianToModifiedEquinoctialElements(\n const basic_mathematics::Vector6d& keplerianElements,\n const bool avoidSingularityAtPiInclination )\n// Based on Hintz, 2008.\n{\n using mathematical_constants::PI;\n\n // Declaring eventual output vector.\n basic_mathematics::Vector6d modifiedEquinoctialState( 6 );\n\n // Compute semi-latus rectum.\n double singularityTolerance = 1.0e-15; // Based on tolerance chosen in\n // orbitalElementConversions.cpp in Tudat Core.\n\n // Extracting eccentricity for ease of referencing.\n double eccentricity = keplerianElements( eccentricityIndex );\n\n // If e is (very near) one, then semi-major axis is undefined and thus the first kepler\n // element is the semi-latus rectum.\n if ( std::fabs( eccentricity - 1.0 ) < singularityTolerance )\n {\n modifiedEquinoctialState( semiLatusRectumIndex )\n = keplerianElements( semiLatusRectumIndex );\n }\n else // eccentricity is significantly away from singularity and can be computed with p=a(1-e≤).\n {\n modifiedEquinoctialState( semiLatusRectumIndex ) = keplerianElements( semiMajorAxisIndex )\n * ( 1.0 - eccentricity * eccentricity );\n }\n\n // Determine prograde-ness, as other five parameters depend on that fact.\n double inclination = keplerianElements( inclinationIndex );\n\n // If inclination is outside range [0,PI].\n if ( ( inclination < 0.0 ) || ( inclination > PI ) )\n {\n // Define the error message.\n std::stringstream errorMessage;\n errorMessage << \"Inclination is expected in range [0,\" << PI << \"]\\n\"\n << \"Specified inclination: \" << inclination << \" rad.\" << std::endl;\n\n // Throw exception.\n boost::throw_exception( std::runtime_error( errorMessage.str( ) ) );\n }\n //Else, nothing wrong and continue.\n\n // Compute set dependant helper parameters.\n double argumentOfPeriapsisAndAscendingNode = 0.0;\n double tangentOfHalfInclination = 0.0;\n\n // If normal set of equations is to be used (i.e. not inverse set for singularity).\n if ( !avoidSingularityAtPiInclination )\n {\n // Add (+) argument of periapsis and longitude of ascending node.\n argumentOfPeriapsisAndAscendingNode = keplerianElements( argumentOfPeriapsisIndex )\n + keplerianElements( longitudeOfAscendingNodeIndex );\n\n // Take the tangent of half the inclination.\n tangentOfHalfInclination = std::tan( inclination / 2.0 );\n }\n else // the orbit is retrograde.\n {\n // Subtract (-) longitude of ascending node from argument of periapsis.\n argumentOfPeriapsisAndAscendingNode = keplerianElements( argumentOfPeriapsisIndex )\n - keplerianElements( longitudeOfAscendingNodeIndex );\n\n // Take the inverse of the tangent of half the inclination to avoid singularity at tan\n // PI/2.\n tangentOfHalfInclination = 1.0 / std::tan( inclination / 2.0 );\n }\n\n // Compute f-element.\n modifiedEquinoctialState( fElementIndex ) = eccentricity\n * std::cos( argumentOfPeriapsisAndAscendingNode );\n\n // Compute g-element.\n modifiedEquinoctialState( gElementIndex ) = eccentricity\n * std::sin( argumentOfPeriapsisAndAscendingNode );\n\n // Compute h-element.\n modifiedEquinoctialState( hElementIndex ) = tangentOfHalfInclination\n * std::cos( keplerianElements( longitudeOfAscendingNodeIndex ) );\n\n // Compute k-element.\n modifiedEquinoctialState( kElementIndex ) = tangentOfHalfInclination\n * std::sin( keplerianElements( longitudeOfAscendingNodeIndex ) );\n\n // Compute true longitude (modulo 2 PI to keep within interval -2PI to 2PI).\n modifiedEquinoctialState( trueLongitudeIndex )\n = basic_mathematics::computeModulo(\n argumentOfPeriapsisAndAscendingNode\n + keplerianElements( trueAnomalyIndex ), 2.0 * PI );\n\n // Give back result.\n return modifiedEquinoctialState;\n}\n\n//! Convert modified equinoctial to Keplerian orbital elements.\nbasic_mathematics::Vector6d convertModifiedEquinoctialToKeplerianElements(\n const basic_mathematics::Vector6d& modifiedEquinoctialElements,\n const bool avoidSingularityAtPiInclination )\n// Using unknown source pdf, code archive E. Heeren and personal derivation based on Hintz 2008.\n{\n using mathematical_constants::PI;\n\n // Declaration of output vector.\n basic_mathematics::Vector6d convertedKeplerianElements = basic_mathematics::\n Vector6d::Zero( 6 );\n\n // for ease of referencing, almost all modified equinoctial elements.\n double fElement = modifiedEquinoctialElements( fElementIndex );\n double gElement = modifiedEquinoctialElements( gElementIndex );\n double hElement = modifiedEquinoctialElements( hElementIndex );\n double kElement = modifiedEquinoctialElements( kElementIndex );\n\n // Tolerance for singularities.\n double singularityTolerance = 1.0e-15;\n\n // Compute eccentricity.\n double eccentricity = std::sqrt( fElement * fElement + gElement * gElement );\n convertedKeplerianElements( eccentricityIndex ) = eccentricity;\n\n // Compute semi-major axis.\n // If eccentricity is not near-parabolic.\n if ( std::fabs( eccentricity - 1.0 ) > singularityTolerance )\n {\n // Use semi-latus rectum and eccentricity to calculate semi-major axis with a=p/(1-e^2).\n convertedKeplerianElements( semiMajorAxisIndex ) =\n modifiedEquinoctialElements( semiLatusRectumIndex ) /\n ( 1.0 - eccentricity * eccentricity );\n }\n // This is (almost) a parabola and the semimajor axis will tend to infinity and be useless.\n else\n {\n // Give semi-latus rectum instead.\n convertedKeplerianElements( semiLatusRectumIndex ) =\n modifiedEquinoctialElements( semiLatusRectumIndex );\n }\n\n // Compute longitude of ascending node.\n\n // Compute solution in [-PI,PI] interval with atan2.\n double longitudeOfAscendingNode = std::atan2( kElement, hElement );\n\n // Store longitude of ascending node.\n convertedKeplerianElements( longitudeOfAscendingNodeIndex ) = basic_mathematics::\n computeModulo( longitudeOfAscendingNode, 2.0 * PI );\n\n // Compute inclination.\n\n // If prograde factor must be positive, otherwise negative.\n double retrogradeFactor = avoidSingularityAtPiInclination ? -1.0 : 1.0;\n\n // Calculate magnitude of inclination with retrogradeFactor (derived based on Hintz, 2008).\n double hSquaredPlusKSquared = std::pow( hElement * hElement + kElement * kElement ,\n retrogradeFactor );\n\n convertedKeplerianElements( inclinationIndex ) =\n 2.0 * std::atan( std::sqrt( hSquaredPlusKSquared ) );\n // Was: std::atan2(2.0 * std::sqrt(hSquaredPlusKSquared) , (1.0 - hSquaredPlusKSquared));\n\n // Compute argument of periapsis.\n\n // Helper quantity (omega + I * OMEGA ), for argument of periapsis and true anomaly.\n double argumentOfPeriapsisAndLongitude;\n\n // If eccentricity is (near) circular\n if ( eccentricity < singularityTolerance )\n // Then the composite argument of periapsis and longitude together cannot be determined\n // because both arguments of the atan2 functions will be zero.\n {\n // Set argument of periapsis to zero.\n convertedKeplerianElements( argumentOfPeriapsisIndex ) = 0.0;\n\n // Set composite argument to longitude only, since argument of periapsis is now zero.\n argumentOfPeriapsisAndLongitude = retrogradeFactor * longitudeOfAscendingNode;\n }\n else\n // Argument of periapsis can be found from composite argument.\n {\n // Compute composite argument.\n argumentOfPeriapsisAndLongitude = std::atan2( gElement, fElement );\n\n // Compute argument of periapsis.\n convertedKeplerianElements( argumentOfPeriapsisIndex ) = basic_mathematics::\n computeModulo( argumentOfPeriapsisAndLongitude\n - retrogradeFactor * longitudeOfAscendingNode, 2.0 * PI );\n }\n\n // Compute true anomaly.\n convertedKeplerianElements( trueAnomalyIndex ) = basic_mathematics::\n computeModulo( modifiedEquinoctialElements( trueLongitudeIndex )\n - argumentOfPeriapsisAndLongitude, 2.0 * PI );\n\n // Return converted elements.\n return convertedKeplerianElements;\n}\n\n//! Convert Cartesian to modified equinoctial orbital elements using implicit MEE equation set.\nbasic_mathematics::Vector6d convertCartesianToModifiedEquinoctialElements(\n const basic_mathematics::Vector6d& cartesianElements,\n const double centralBodyGravitationalParameter )\n{\n using mathematical_constants::PI;\n\n // Convert to keplerian elements.\n basic_mathematics::Vector6d keplerianElements = convertCartesianToKeplerianElements(\n cartesianElements, centralBodyGravitationalParameter );\n\n // Check whether orbit is retrograde.\n bool avoidSingularityAtPiInclination =\n mission_geometry::isOrbitRetrograde( keplerianElements );\n\n // Convert to modified equinoctial elements.\n return convertKeplerianToModifiedEquinoctialElements(\n keplerianElements, avoidSingularityAtPiInclination );\n}\n\n//! Convert Cartesian to modified equinoctial orbital elements using explicit MEE equation set.\nbasic_mathematics::Vector6d convertCartesianToModifiedEquinoctialElements(\n const basic_mathematics::Vector6d& cartesianElements,\n const double centralBodyGravitationalParameter,\n const bool avoidSingularityAtPiInclination )\n{\n // Convert Cartesian to Keplerian to modified equinoctial elements.\n return convertKeplerianToModifiedEquinoctialElements(\n convertCartesianToKeplerianElements(\n cartesianElements, centralBodyGravitationalParameter ),\n avoidSingularityAtPiInclination );\n}\n\n//! Convert Modified Equinoctial Elements to Cartesian Elements.\nbasic_mathematics::Vector6d convertModifiedEquinoctialToCartesianElements(\n const basic_mathematics::Vector6d& modifiedEquinoctialElements,\n const double centralBodyGravitationalParameter,\n const bool avoidSingularityAtPiInclination )\n// Using unnamed pdf and code archive Bart Rˆmgens.\n{\n // Creating output vector.\n basic_mathematics::Vector6d convertedCartesianElements = basic_mathematics::\n Vector6d::Zero( 6 );\n\n // If the prograde equations are to be used.\n if ( !avoidSingularityAtPiInclination )\n {\n // Local storage of elements for ease of access.\n double semiLatusRectum = modifiedEquinoctialElements( semiLatusRectumIndex );\n double fElement = modifiedEquinoctialElements( fElementIndex );\n double gElement = modifiedEquinoctialElements( gElementIndex );\n double hElement = modifiedEquinoctialElements( hElementIndex );\n double kElement = modifiedEquinoctialElements( kElementIndex );\n double trueLongitude = modifiedEquinoctialElements( trueLongitudeIndex );\n\n // Computing helper parameters.\n\n // Square-root\n double squareRootOfGravitationalParameterOverSemiLatusRectum =\n std::sqrt( centralBodyGravitationalParameter / semiLatusRectum );\n\n // Cosines and sine.\n double cosineTrueLongitude = std::cos( trueLongitude );\n double sineTrueLongitude = std::sin( trueLongitude );\n\n // s≤, a≤, w, r from references.\n double sSquaredParameter = 1.0 + hElement * hElement + kElement * kElement;\n double aSquaredParameter = hElement * hElement - kElement*kElement;\n double wParameter = 1.0 + fElement * cosineTrueLongitude\n + gElement * sineTrueLongitude;\n double radius = semiLatusRectum / wParameter;\n\n // Computing position and storing (using code archive Bart Rˆmgens and unnamed pdf).\n convertedCartesianElements( xCartesianPositionIndex )\n = radius / sSquaredParameter * ( cosineTrueLongitude + aSquaredParameter\n * cosineTrueLongitude + 2.0 * hElement * kElement\n * sineTrueLongitude );\n convertedCartesianElements( yCartesianPositionIndex )\n = radius / sSquaredParameter * ( sineTrueLongitude - aSquaredParameter\n * sineTrueLongitude + 2.0 * hElement * kElement\n * cosineTrueLongitude );\n convertedCartesianElements( zCartesianPositionIndex ) = 2.0 * radius / sSquaredParameter\n * ( hElement * sineTrueLongitude - kElement * cosineTrueLongitude );\n\n // Computing velocities (these can probably use more optimal computation).\n convertedCartesianElements( xCartesianVelocityIndex ) = -1.0 / sSquaredParameter\n * squareRootOfGravitationalParameterOverSemiLatusRectum\n * ( sineTrueLongitude + aSquaredParameter * sineTrueLongitude\n - 2.0 * hElement * kElement * cosineTrueLongitude + gElement\n - 2.0 * fElement * hElement * kElement + aSquaredParameter * gElement );\n convertedCartesianElements( yCartesianVelocityIndex ) = -1.0 / sSquaredParameter\n * squareRootOfGravitationalParameterOverSemiLatusRectum\n * ( -cosineTrueLongitude + aSquaredParameter * cosineTrueLongitude\n + 2.0 * hElement * kElement * sineTrueLongitude - fElement\n + 2.0 * gElement * hElement * kElement + aSquaredParameter * fElement );\n convertedCartesianElements( zCartesianVelocityIndex ) = 2.0 / sSquaredParameter\n * squareRootOfGravitationalParameterOverSemiLatusRectum\n * ( hElement * cosineTrueLongitude + kElement * sineTrueLongitude\n + fElement * hElement + gElement * kElement );\n }\n else // use the indirect transformation via an intermediate Kepler state.\n {\n // Use the Keplerian state as an intermediary step, as there is no direct transformation\n // available in literature (personal derivation forgone for now due to time constraints).\n convertedCartesianElements =\n convertKeplerianToCartesianElements(\n convertModifiedEquinoctialToKeplerianElements(\n modifiedEquinoctialElements, avoidSingularityAtPiInclination ),\n centralBodyGravitationalParameter );\n }\n\n // Return converted set of elements.\n return convertedCartesianElements;\n}\n\n} // namespace orbital_element_conversions\n\n} // namespace tudat\n", "meta": {"hexsha": "79f1a771dba2d9f24adb801339efd5f31d8cb22f", "size": 19321, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Tudat/Astrodynamics/BasicAstrodynamics/modifiedEquinoctialElementConversions.cpp", "max_stars_repo_name": "JPelamatti/ThesisTUDAT", "max_stars_repo_head_hexsha": "b94ce35fb7c8fa44ae83238e296a979dfa3adfe8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Tudat/Astrodynamics/BasicAstrodynamics/modifiedEquinoctialElementConversions.cpp", "max_issues_repo_name": "JPelamatti/ThesisTUDAT", "max_issues_repo_head_hexsha": "b94ce35fb7c8fa44ae83238e296a979dfa3adfe8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Tudat/Astrodynamics/BasicAstrodynamics/modifiedEquinoctialElementConversions.cpp", "max_forks_repo_name": "JPelamatti/ThesisTUDAT", "max_forks_repo_head_hexsha": "b94ce35fb7c8fa44ae83238e296a979dfa3adfe8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-05-30T03:42:22.000Z", "max_forks_repo_forks_event_max_datetime": "2019-05-30T03:42:22.000Z", "avg_line_length": 48.1820448878, "max_line_length": 99, "alphanum_fraction": 0.6897158532, "num_tokens": 4353, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.863391602943619, "lm_q2_score": 0.6297746074044134, "lm_q1q2_score": 0.5437421077800848}} {"text": "//######################################################################\n//# SDF_Fusion Module \n//# \n//# Copyright (C) 2020 Siemens AG\n//# SPDX-License-Identifier: MIT\n//# Author 2020: This module has been developed by \n//# or under supervision of Slobodan Ilic\n//#######################################################################\n\n#include \n#include \n#include \"utils.hpp\"\n#include \"io_utils.hpp\"\n\n#include \"reconstructor_3d.hpp\"\n#include \"marching_cubes.hpp\"\n#include \"rgbd_types.hpp\"\n\nusing namespace std;\nusing namespace cv;\nusing namespace Eigen;\n\nsdf initialize_sdf(const Configuration &configuration, const vector &volume)\n{\n\tfloat voxel_size = configuration.get_voxel_size();\n\n\tint voxel_count_x = static_cast(std::ceil((volume[1] - volume[0]) / voxel_size));\n\tint voxel_count_y = static_cast(std::ceil((volume[3] - volume[2]) / voxel_size));\n\tint voxel_count_z = static_cast(std::ceil((volume[5] - volume[4]) / voxel_size));\n\n\tsdf model(voxel_count_x, voxel_count_y, voxel_count_z, voxel_size, 0.f, 1.f);\n\n\treturn model;\n}\n\ntemplate \nTransform to_isometry(const Matrix &pose_matrix)\n{\n\tTransform pose;\n\tpose.setIdentity();\n\n\tpose.linear() = pose_matrix.block<3, 3>(0, 0);\n\tpose.translation() = pose_matrix.block<3, 1>(0, 3);\n\t\n\treturn pose;\n}\n\nsdf generate_tsdf(const Mat& depth_map, const Mat& color_map, const Isometry3f &transformation_matrix, const Matrix3f &intrinsics, const vector& dimensions,\n\tconst Configuration& configuration) {\n\n\tsdf s = initialize_sdf(configuration, dimensions);\n\tconst float voxel_size = configuration.get_voxel_size();\n\n\tfloat delta = voxel_size;\n\tfloat eta = 3 * voxel_size;\n\n\tVector3f lower_left(dimensions[0], dimensions[2], dimensions[4]);\n\n#pragma omp parallel for\n\tfor (int z = 0; z < s.size_z; ++z)\n\t\tfor (int y = 0; y < s.size_y; ++y)\n\t\t\tfor (int x = 0; x < s.size_x; ++x) {\n\t\t\t\tVector3f rp = lower_left + voxel_size * Vector3f(x + 0.5f, y + 0.5f, z + 0.5f);\n\t\t\t\tVector3f transformed_point = transformation_matrix * rp;\n\n\t\t\t\tVector2f point2d = project_point(transformed_point, intrinsics);\n\n\t\t\t\tint imgx = static_cast(ceil(point2d(0)));\n\t\t\t\tint imgy = static_cast(ceil(point2d(1)));\n\n\t\t\t\tif (imgx >= 0 && imgy >= 0 && imgx < depth_map.cols && imgy < depth_map.rows) {\n\n\t\t\t\t\tfloat depth = depth_map.at(imgy, imgx);\n\t\t\t\t\tif (isfinite(depth) && depth > .0f) {\n\t\t\t\t\t\tconst float signed_distance = depth - transformed_point(2);\n\t\t\t\t\t\ts.weights.at(x, y, z) = signed_distance > -eta;\n\t\t\t\t\t\ts.distance_field.at(x, y, z) = min(1.f, max(-1.f, signed_distance / delta));\n\n\t\t\t\t\t\tcv::Vec3b color = color_map.at(imgy, imgx);\n\t\t\t\t\t\ts.color_field.red.at(x, y, z) = color[2] / 255.f;\n\t\t\t\t\t\ts.color_field.green.at(x, y, z) = color[1] / 255.f;\n\t\t\t\t\t\ts.color_field.blue.at(x, y, z) = color[0] / 255.f;\n\t\t\t\t\t} // otherwise no need to change values (works only when they are initialized)\n\t\t\t\t}\n\t\t\t}\n\n\treturn s;\n}\n\nvoid integrate_into_weighted_average(sdf& wa, const sdf& s) {\n\tcolor_cube & wa_colors = wa.color_field;\n\tconst color_cube & s_colors = s.color_field;\n\n#pragma omp parallel for\n\tfor (int z = 0; z < wa.size_z; ++z)\n\t\tfor (int y = 0; y < wa.size_y; ++y)\n\t\t\tfor (int x = 0; x < wa.size_x; ++x) {\n\t\t\t\tfloat old_weight = wa.weights.at(x, y, z);\n\t\t\t\tfloat added_weight = s.weights.at(x, y, z);\n\t\t\t\tfloat new_weight = old_weight + added_weight;\n\n\t\t\t\tif (new_weight > 0.f) {\n\t\t\t\t\t//wa.distance_field.at(x, y, z) /= wa.weights.at(x, y, z);\n\t\t\t\t\twa.distance_field.at(x, y, z) = (wa.distance_field.at(x, y, z) * old_weight + s.distance_field.at(x, y, z) * added_weight) / new_weight;\n\n\t\t\t\t\t//if (fabs(wa.distance_field.at(x, y, z)) < 1.f) { // assign color only at near-surface voxels\n\t\t\t\t\twa_colors.red.at(x, y, z) = (wa_colors.red.at(x, y, z) * old_weight + s_colors.red.at(x, y, z) * added_weight) / new_weight;\n\t\t\t\t\twa_colors.green.at(x, y, z) = (wa_colors.green.at(x, y, z) * old_weight + s_colors.green.at(x, y, z) * added_weight) / new_weight;\n\t\t\t\t\twa_colors.blue.at(x, y, z) = (wa_colors.blue.at(x, y, z) * old_weight + s_colors.blue.at(x, y, z) * added_weight) / new_weight;\n\t\t\t\t\t//}\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\twa.distance_field.at(x, y, z) = -1.f;\n\t\t\t\t\t// and do not change color\n\t\t\t\t}\n\t\t\t\twa.weights.at(x, y, z) = new_weight;\n\t\t\t}\n}\n\nsdf reconstruct_sdf(const Configuration& configuration, const vector& volume, const vector &input_images, const vector &poses)\n{\n\n\tsdf model = initialize_sdf(configuration, volume);\n\tconst int number_of_frames = static_cast(input_images.size());\n\n\tint64 elapsed_time = 0;\n\n\tfor (int i = 0; i < number_of_frames; ++i)\n\t{\n\t\tRgbdFrame rgbd_frame = get_rgbd_frame(input_images[i]);\n\t\tIsometry3f pose = to_isometry(poses[i]);\n\n\t\tauto start_time = getTickCount();\n\t\tsdf current_sdf = generate_tsdf(rgbd_frame.second, rgbd_frame.first, pose.inverse(), configuration.get_intrinsics(),\n\t\t volume, configuration);\n\t\tintegrate_into_weighted_average(model, current_sdf);\n\t\telapsed_time += getTickCount() - start_time;\n\t\tcout << \"Integrated \" << i + 1 << \" out of \" << number_of_frames << \" frames into reconstruction\" << endl;\n\t}\n\n\tstd::cout << \"sdf fusion elapsed time: \" << elapsed_time / getTickFrequency() << \" sec\" << std::endl;\n\t\n\treturn model;\n}\n\nbool run_reconstruction(const Configuration &configuration, const vector &volume)\n{\n\tvector input_images = get_input_images(configuration.get_out_rgb_images_dir(), configuration.get_out_depth_images_dir());\n\tvector poses = read_scene_poses(configuration.get_poses_file());\n\n\tif (input_images.size() != poses.size())\n\t{\n\t\tcerr << \"Number of frames (\" << input_images.size() << \") and number of poses (\" << poses.size() << \") don't match\" << endl;\n\t\treturn false;\n\t}\n\n\tsdf model = reconstruct_sdf(configuration, volume, input_images, poses);\n\tvector model_mesh = mesh_valid_only(model);\n\n\tsave_mesh_ply(model_mesh, configuration.get_model_file(), true);\n\treturn true;\n}\n", "meta": {"hexsha": "b39db3fb1130f02e474758d4ddff72ad75f3fba5", "size": 6086, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "sdf_fusion/src/aruco_sdffusion/src/reconstructor_3d.cpp", "max_stars_repo_name": "YyYyYong0331/homebrewdb", "max_stars_repo_head_hexsha": "02fb883b1630f21db6348e2605def5bd8cc6e2c0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 18.0, "max_stars_repo_stars_event_min_datetime": "2020-10-21T16:29:18.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-29T05:47:29.000Z", "max_issues_repo_path": "sdf_fusion/src/aruco_sdffusion/src/reconstructor_3d.cpp", "max_issues_repo_name": "YyYyYong0331/homebrewdb", "max_issues_repo_head_hexsha": "02fb883b1630f21db6348e2605def5bd8cc6e2c0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2021-04-16T15:03:54.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-12T07:28:52.000Z", "max_forks_repo_path": "sdf_fusion/src/aruco_sdffusion/src/reconstructor_3d.cpp", "max_forks_repo_name": "YyYyYong0331/homebrewdb", "max_forks_repo_head_hexsha": "02fb883b1630f21db6348e2605def5bd8cc6e2c0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2020-08-27T09:02:02.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-11T10:42:33.000Z", "avg_line_length": 37.3374233129, "max_line_length": 163, "alphanum_fraction": 0.6593821886, "num_tokens": 1716, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.863391617003942, "lm_q2_score": 0.6297745935070806, "lm_q1q2_score": 0.5437421046360786}} {"text": "//\n// meanie3D-satconv\n//\n\n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace boost;\n\n#pragma mark -\n#pragma mark Definitions\n\ntypedef enum {\n RadicanceToTemperature,\n TemperatureToRadiance\n} ConversionType;\n\n// Radiation constant #1\nconst double c1 = 1.19104e-05;\n// Radiation constant #2\nconst double c2 = 1.43877;\n\n// Names of the variables available for conversion\nconst string variables[8] = {\n \"msevi_l15_ir_039\", \n \"msevi_l15_ir_087\", \n \"msevi_l15_ir_097\", \n \"msevi_l15_ir_108\", \n \"msevi_l15_ir_120\", \n \"msevi_l15_ir_134\",\n \"msevi_l15_wv_062\",\n \"msevi_l15_wv_073\"\n};\n\n// Calibration constant alpha\nconst double alpha[8] = {\n 0.9954, \n 0.9996, \n 0.9999,\n 0.9983, \n 0.9988, \n 0.9981,\n 0.9963,\n 0.9991\n};\n\n// Calibration constant beta\nconst double beta[8] = {\n 3.438, \n 0.179, \n 0.056, \n 0.64, \n 0.408, \n 0.561,\n 2.185,\n 0.47\n};\n\n// Wavenumber \nconst double wavenum[8] = {\n 2568.832, \n 1148.62, \n 1035.289, \n 931.7, \n 836.445, \n 751.792,\n 1600.548,\n 1360.33\n};\n \n#pragma mark -\n#pragma mark Command line parsing\n\nvoid parse_commmandline(program_options::variables_map vm, \n int& variableIndex,\n double &value,\n ConversionType &conversionType) \n{\n if (vm.count(\"temperature\") != 0) {\n conversionType = RadicanceToTemperature;\n } else if (vm.count(\"radiance\") != 0) {\n conversionType = TemperatureToRadiance;\n } else {\n cerr << \"Specify -r or -t\" << endl;\n exit(EXIT_FAILURE);\n }\n \n if (vm.count(\"value\") == 0) {\n cerr << \"Missing --value argument\" << endl;\n exit(EXIT_FAILURE);\n }\n value = vm[\"value\"].as();\n \n if (vm.count(\"variable\") == 0) {\n cerr << \"Missing --variable argument\" << endl;\n exit(EXIT_FAILURE);\n }\n string variable = vm[\"variable\"].as();\n \n variableIndex = -1;\n for (int i=0; i<8; i++) {\n if (variables[i] == variable) {\n variableIndex = i;\n break;\n }\n }\n if (variableIndex < 0) {\n cerr << \"Illegal value for --variable\" << endl;\n exit(EXIT_FAILURE);\n }\n\n}\n\n#pragma mark -\n#pragma mark Helper Methods\n \n/** Calculates the brightness temperature in degree centigrade\n* from the given spectral radiance.\n * \n* @param index of the variable to be converted\n* @param radiance value for the given channel\n* @return equivalent brightness temperature in [degree C]\n*/\ndouble brightness_temperature(const int var_index, const double &radiance) {\n double nu = wavenum[var_index];\n double Tbb = c2 * nu / log(1 + nu * nu * nu * c1 / radiance);\n double Tb = (Tbb - beta[var_index]) / alpha[var_index];\n return Tb - 273.15;\n}\n\n/** Inverse calculation. Spectral radiance from temperature\n* in degree centigrade\n * \n* @param index of the variable to be converted\n* @param brightness temperature in [degree C]\n* @return radiance value for the given channel\n*/\ndouble spectral_radiance(const size_t var_index, const double &temperature) {\n double nu = wavenum[var_index];\n double Tbb = (temperature + 273.15) * alpha[var_index] + beta[var_index];\n return nu * nu * nu * c1 / (exp(c2 * nu / Tbb) - 1);\n}\n\n#pragma mark -\n#pragma mark MAIN\n\nint main(int argc, char** argv)\n{\n // Declare the supported options.\n namespace po = boost::program_options;\n \n po::positional_options_description p;\n p.add(\"value\", -1);\n \n po::options_description desc(\"Converts spectral radiance to equivalent brightness temperature or vice versa.\");\n desc.add_options()\n (\"temperature,t\", \"radiance to temperature\")\n (\"radiance,r\", \"temperature to radiance\")\n (\"value\", po::value(), \"value to convert\")\n (\"variable,v\", po::value(), \"One of msevi_l15_ir_039, msevi_l15_ir_087, msevi_l15_ir_097, msevi_l15_ir_108, msevi_l15_ir_120, msevi_l15_ir_134, msevi_l15_wv_062,msevi_l15_wv_073\")\n ;\n \n if (argc < 2) {\n cout << desc << \"\\n\";\n exit(EXIT_SUCCESS);\n }\n \n po::variables_map vm;\n try\n {\n po::store(parse_command_line(argc, argv, desc, po::command_line_style::unix_style ^ po::command_line_style::allow_short), vm);\n po::notify(vm);\n } catch (std::exception &e) {\n cerr << \"FATAL:parsing command line caused exception: \" << e.what()\n << \": check meanie3D-satconv --help for command line options\"\n << endl;\n exit(EXIT_FAILURE);\n }\n\n // Evaluate user input\n double value;\n int variableIndex;\n ConversionType type;\n try {\n parse_commmandline(vm,variableIndex,value,type);\n } catch (const std::exception &e) {\n cerr << \"ERROR:exception \" << e.what() << endl;\n exit(EXIT_FAILURE);\n }\n\n switch (type) {\n case RadicanceToTemperature:\n cout << brightness_temperature(variableIndex,value) << endl;\n break;\n case TemperatureToRadiance:\n cout << spectral_radiance(variableIndex,value) << endl;\n break;\n }\n \n return EXIT_SUCCESS;\n};\n", "meta": {"hexsha": "fb69b6ad2f00a69db2cd0a5121a5d2336e9fa310", "size": 5237, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/executables/meanie3D-satconv.cpp", "max_stars_repo_name": "JuergenSimon/meanie3D", "max_stars_repo_head_hexsha": "776890f6b63d735153566fecc5a76c68a23ef333", "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/executables/meanie3D-satconv.cpp", "max_issues_repo_name": "JuergenSimon/meanie3D", "max_issues_repo_head_hexsha": "776890f6b63d735153566fecc5a76c68a23ef333", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2016-09-17T13:46:23.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-01T16:31:29.000Z", "max_forks_repo_path": "src/executables/meanie3D-satconv.cpp", "max_forks_repo_name": "JuergenSimon/meanie3D", "max_forks_repo_head_hexsha": "776890f6b63d735153566fecc5a76c68a23ef333", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2016-04-18T13:13:28.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-18T12:30:05.000Z", "avg_line_length": 25.5463414634, "max_line_length": 199, "alphanum_fraction": 0.6175291197, "num_tokens": 1441, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8438951025545426, "lm_q2_score": 0.6442251133170357, "lm_q1q2_score": 0.5436584180708917}} {"text": "/* Copyright © 2017 Apple Inc. All rights reserved.\n *\n * Use of this source code is governed by a BSD-3-clause license that can\n * be found in the LICENSE.txt file or at https://opensource.org/licenses/BSD-3-Clause\n */\n#ifndef TURI_CONSTRAINTS_H_\n#define TURI_CONSTRAINTS_H_\n\n#include \n#include \n\n// Eigen\n#include \n#include \n\n// Optimizaiton\n#include \n#include \n#include \n\n// TODO: List of todo's for this file\n//------------------------------------------------------------------------------\n//\n\nnamespace turi {\n\nnamespace optimization {\n\n/**\n * \\ingroup group_optimization\n * \\addtogroup optimization_constraints Optimization Constraints\n * \\{\n */\n\n\n/**\n * Interface for non-negative constriants.\n * x >= 0\n */\nclass non_negative_orthant : public constraint_interface {\n\n protected:\n\n size_t variables; /**< # Variables in the problem */\n\n public:\n\n\n /**\n * Default constructor.\n */\n non_negative_orthant(const size_t& _variables){\n variables = _variables;\n }\n\n /**\n * Default desctuctor. Do nothing.\n */\n ~non_negative_orthant(){\n }\n\n\n /**\n * Project a dense point into the constraint space.\n * \\param[in,out] point Point (Dense Vector)\n *\n * Given a convex set X, the projection operator is given by\n * P(y) = \\std::max(x, o)\n *\n */\n inline void project(DenseVector &point) const {\n DASSERT_EQ(variables, point.size());\n point = point.cwiseMax(0);\n }\n\n /**\n * Project a block of a dense point into the constraint space.\n *\n * \\param[in,out] point A block project the point.\n * \\param[in] block_start Start index of the block\n * \\param[in] block_size Size of the block\n *\n * Given a convex set X, the projection operator is given by\n * P(y) = \\std::max(x, o)\n *\n */\n inline void project_block(DenseVector &point, const size_t block_start, const\n size_t block_size) const {\n DASSERT_LE(variables, block_start + block_size);\n DASSERT_EQ(block_size, point.size());\n point = point.cwiseMax(0);\n }\n\n /**\n * Boolean function to deterstd::mine if a dense point is present in a constraint\n * space.\n * \\param[in] point Point which we are querying.\n *\n */\n inline bool is_satisfied(const DenseVector &point) const {\n DASSERT_EQ(variables, point.size());\n for(size_t i=0; i < size_t(point.size()); i++){\n if( point(i) <= -OPTIMIZATION_ZERO)\n return false;\n }\n return true;\n }\n\n\n /**\n * A measure of the first order optimality conditions.\n *\n * \\param[in] point Point which we are querying.\n * \\param[in] gradient Gradient at that point for a given function\n *\n * Use the Cauchy point as a measure of optimality. See Pg 486 of\n * Nocedal and Wright (Edition 2)\n *\n */\n inline double first_order_optimality_conditions(const DenseVector &point,\n const DenseVector& gradient) const{\n DASSERT_TRUE(is_satisfied(point));\n DenseVector proj_gradient = gradient;\n for(size_t i=0; i < size_t(point.size()); i++){\n if(point(i) <= OPTIMIZATION_ZERO){\n proj_gradient(i) = std::min(0.0, gradient(i));\n } else {\n proj_gradient(i) = gradient(i);\n }\n }\n return compute_residual(proj_gradient);\n }\n};\n\n\n\n/**\n * Interface for box-constraints on variables.\n * lb <= x <= ub\n */\nclass box_constraints: public constraint_interface {\n\n protected:\n\n DenseVector lb; /**< # Upper bound */\n DenseVector ub; /**< # Lower bound */\n size_t variables; /**< # Variables in the problem */\n\n public:\n\n\n /**\n * Default constructor.\n * \\param[in] _variables Number of variables\n * \\param[in] _lb Lower bound\n * \\param[in] _ub Upper bound\n */\n box_constraints(const double& _lb, const double& _ub, const size_t&\n _variables){\n variables = _variables;\n lb.resize(variables);\n lb.setConstant(_lb);\n ub.resize(variables);\n ub.setConstant(_ub);\n }\n\n /**\n * Default constructor.\n * \\param[in] _variables Number of variables\n * \\param[in] _lb Lower bound\n * \\param[in] _ub Upper bound\n */\n box_constraints(const DenseVector& _lb, const\n DenseVector& _ub){\n variables = _lb.size();\n DASSERT_EQ(variables, _ub.size());\n lb = _lb;\n ub = _ub;\n }\n\n /**\n * Default desctuctor. Do nothing.\n */\n ~box_constraints(){\n }\n\n\n /**\n * Project a dense point into the constraint space.\n * \\param[in,out] point Point (Dense Vector)\n *\n * Given a convex set X, the projection operator is given by\n * P(y) = \\std::max(x, o)\n *\n */\n inline void project(DenseVector &point) const {\n DASSERT_EQ(variables, point.size());\n for(size_t i=0; i < size_t(point.size()); i++){\n point(i) = std::min(std::max(point(i), lb(i)), ub(i));\n }\n }\n\n /**\n * Project a block of a dense point into the constraint space.\n *\n * \\param[in,out] point A block project the point.\n * \\param[in] block_start Start index of the block\n * \\param[in] block_size Size of the block\n *\n * Given a convex set X, the projection operator is given by\n * P(y) = \\std::max(x, o)\n *\n */\n inline void project_block(DenseVector &point, const size_t block_start, const\n size_t block_size) const {\n DASSERT_GE(variables, block_start + block_size);\n DASSERT_EQ(block_size, point.size());\n for(size_t i=0; i < block_size; i++){\n point(i) = std::min(std::max(point(i),\n lb(block_start + i)), ub(block_start + i));\n }\n }\n\n /**\n * Boolean function to determine if a dense point is present in a constraint\n * space.\n * \\param[in] point Point which we are querying.\n *\n */\n inline bool is_satisfied(const DenseVector &point) const {\n DASSERT_EQ(variables, point.size());\n for(size_t i=0; i < size_t(point.size()); i++){\n if( point(i) <= lb(i) - OPTIMIZATION_ZERO ||\n point(i) >= ub(i) + OPTIMIZATION_ZERO)\n return false;\n }\n return true;\n }\n\n\n /**\n * A measure of the first order optimality conditions.\n *\n * \\param[in] point Point which we are querying.\n * \\param[in] gradient Gradient at that point for a given function\n *\n * Use the Cauchy point as a measure of optimality. See Pg 486 of\n * Nocedal and Wright (Edition 2)\n *\n */\n inline double first_order_optimality_conditions(const DenseVector &point,\n const DenseVector& gradient) const{\n DASSERT_TRUE(is_satisfied(point));\n DenseVector proj_gradient = gradient;\n for(size_t i=0; i < size_t(point.size()); i++){\n if(point(i) <= OPTIMIZATION_ZERO + lb(i)){\n proj_gradient(i) = std::min(0.0, gradient(i));\n } else if (point(i) >= ub(i) - OPTIMIZATION_ZERO){\n proj_gradient(i) = std::max(0.0, gradient(i));\n } else {\n proj_gradient(i) = gradient(i);\n }\n }\n return compute_residual(proj_gradient);\n }\n\n\n};\n\n\n} // optimization\n} // turicreate\n\n#endif\n", "meta": {"hexsha": "cdb8dfcf90ede2c1dbc3a032d71b484a81596252", "size": 7211, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/ml/optimization/constraints-inl.hpp", "max_stars_repo_name": "Bpowers4/turicreate", "max_stars_repo_head_hexsha": "73dad213cc1c4f74337b905baea2b3a1e5a0266c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 11356.0, "max_stars_repo_stars_event_min_datetime": "2017-12-08T19:42:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T16:55:25.000Z", "max_issues_repo_path": "src/ml/optimization/constraints-inl.hpp", "max_issues_repo_name": "Bpowers4/turicreate", "max_issues_repo_head_hexsha": "73dad213cc1c4f74337b905baea2b3a1e5a0266c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2402.0, "max_issues_repo_issues_event_min_datetime": "2017-12-08T22:31:01.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-28T19:25:52.000Z", "max_forks_repo_path": "src/ml/optimization/constraints-inl.hpp", "max_forks_repo_name": "Bpowers4/turicreate", "max_forks_repo_head_hexsha": "73dad213cc1c4f74337b905baea2b3a1e5a0266c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1343.0, "max_forks_repo_forks_event_min_datetime": "2017-12-08T19:47:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-26T11:31:36.000Z", "avg_line_length": 26.2218181818, "max_line_length": 86, "alphanum_fraction": 0.614477881, "num_tokens": 1840, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998714925403, "lm_q2_score": 0.6992544273261175, "lm_q1q2_score": 0.5435303765011811}} {"text": "#pragma once\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"utils/types.hpp\"\n#include \"utils/utils.hpp\"\n#include \"utils/assert.hpp\"\n#include \"utils/comparators.hpp\"\n\nnamespace ample {\n\n namespace _impl {\n\n template\n using vector_t = Eigen::Matrix;\n\n template\n using matrix_t = Eigen::Matrix;\n\n template\n struct solver_type {\n\n using type = Eigen::EigenSolver>;\n\n };\n\n template\n struct solver_type> {\n\n using type = Eigen::ComplexEigenSolver>>;\n\n };\n\n\n template\n using solver_type_t = typename solver_type::type;\n\n template\n struct pade_coefficients {\n\n auto operator()(const types::vector1d_t& c, const size_t& n, const size_t& m) {\n vector_t b(m);\n matrix_t A(m, m);\n\n for (size_t i = 0, ci = n + 1; i < m; ++i, ++ci) {\n b(i) = -c[ci];\n\n for (size_t j = 0; j < std::min(ci, m); ++j)\n A(i, j) = c[ci - j - 1];\n }\n\n const vector_t x = A.colPivHouseholderQr().solve(b);\n\n types::vector1d_t ac(n + 1), bc(m + 1, T(1));\n for (size_t i = 0; i < n + 1; ++i) {\n ac[i] = c[i];\n for (size_t j = 0; j < std::min(i, m); ++j)\n ac[i] += c[i - j - 1] * x(j);\n }\n\n for (size_t i = 0; i < m; ++i)\n bc[i + 1] = x(i);\n\n return std::make_tuple(ac, bc);\n }\n\n };\n\n template\n struct theta_pade_coefficients {\n\n T theta{};\n\n auto operator()(const types::vector1d_t& c, const size_t& n, const size_t& m) {\n utils::dynamic_assert(n == m, \"coefficients: n(\", n, \") must be equal to m(\", m, \") for theta-weighted coefficients\");\n\n pade_coefficients coefficients{};\n const auto [a0, b0] = coefficients(c, n - 1, n);\n auto [a1, b1] = coefficients(c, n, n);\n\n const auto theta1 = T(1) - theta;\n for (size_t i = 0; i < a0.size(); ++i)\n a1[i] = a1[i] * theta + a0[i] * theta1;\n\n a1.back() *= theta;\n\n for (size_t i = 0; i < b0.size(); ++i)\n b1[i] = b1[i] * theta + b0[i] * theta1;\n\n return std::make_tuple(a1, b1);\n }\n\n };\n\n template\n struct exp_taylor {\n\n static constexpr auto on = T(1);\n static constexpr auto tw = T(2);\n static constexpr auto fo = T(4);\n static constexpr auto si = T(6);\n\n auto operator()(const T& value, const size_t& n) {\n const auto v2 = std::pow(value, 2);\n\n types::vector1d_t c(n);\n c[0] = on;\n c[1] = value /tw;\n\n for (size_t i = 2, m = 0; i < n; ++i, ++m) {\n const auto mm = T(m);\n c[i] = (v2 * c[m] - (tw + si * mm + fo * mm * mm) * c[m + 1]) / (fo * (on + mm) * (tw + mm));\n }\n\n return c;\n }\n\n };\n\n template\n struct root_taylor {\n\n auto operator()(const T& value, const size_t& n) {\n types::vector1d_t c(n, T(0));\n std::for_each(c.begin() + 1, c.end(), \n [&value, p=T(1), i=size_t(0), f=T(1)](auto& x) mutable {\n ++i;\n x = value * (p *= (T(1.5) - T(i))) / (f *= i);\n }\n );\n\n return c;\n }\n\n };\n\n template\n struct no_transform {\n\n auto operator()(types::vector1d_t& p, types::vector1d_t& q) {}\n\n };\n\n template\n struct wampe_transform {\n\n auto operator()(types::vector1d_t& p, types::vector1d_t& q) {\n for (size_t i = 0; i < p.size(); ++i) {\n const auto q2 = T(2) * q[i];\n std::tie(p[i], q[i]) = std::make_tuple(-p[i] - q2, p[i] - q2);\n }\n\n for (size_t i = p.size(); i < q.size(); ++i) {\n const auto q2 = T(-2) * q[i];\n p.push_back(q2);\n q[i] = q2;\n }\n }\n\n };\n\n template\n auto get_roots(const types::vector1d_t& c) {\n const auto n = c.size() - 1;\n matrix_t A = matrix_t::Zero(n, n);\n\n for (size_t i = 0; i < n - 1; ++i)\n A(i + 1, i) = T(1);\n\n for (size_t i = 0; i < n; ++i)\n A(0, i) = -c[n - i - 1] / c.back();\n\n solver_type_t solver;\n solver.compute(A);\n const vector_t values = solver.eigenvalues();\n\n auto result = utils::make_vector_i(n, [&values](const auto& i) { return values(i); });\n std::sort(result.begin(), result.end(), utils::less{});\n return result;\n }\n\n }// namespace ample::_impl\n\n template\n class coefficients {\n\n public:\n\n using taylor_func_t = std::function(const T&, const size_t&)>;\n using transform_func_t = std::function&, types::vector1d_t&)>;\n using coeficients_func_t = std::function, types::vector1d_t>(const types::vector1d_t&, const size_t&, const size_t&)>;\n\n coefficients(const size_t& n,\n taylor_func_t taylor,\n transform_func_t transform,\n coeficients_func_t coefficients) : ample::coefficients(n, n, std::move(taylor), std::move(transform), std::move(coefficients)) {}\n\n coefficients(const size_t& n, const size_t& m,\n taylor_func_t taylor,\n transform_func_t transform,\n coeficients_func_t coefficients) : _n(n), _m(m), _taylor(std::move(taylor)), _transform(std::move(transform)), _coefficients(std::move(coefficients)) {\n utils::dynamic_assert(n > 0, \"coefficients: n(\", n, \") must be positive\");\n utils::dynamic_assert(n <= m, \"coefficients: n(\", n, \") must be less or equal to m(\", m, \")\");\n }\n\n auto get(const T& value) const {\n const auto tc = _taylor(value, _n + _m + 1);\n auto [np, dp] = _coefficients(tc, _n, _m);\n\n _transform(np, dp);\n\n const auto nr = _impl::get_roots(np);\n const auto dr = _impl::get_roots(dp);\n\n types::vector1d_t ix(_m);\n std::iota(ix.begin(), ix.end(), size_t(0));\n\n auto a = types::vector1d_t(_m);\n for (size_t i = 0; i < _m; ++i) {\n const auto p = std::accumulate(nr.begin(), nr.end(), np.back(), [&x=dr[i]](const auto& a, const auto& x0) { return a * (x - x0); });\n const auto q = std::accumulate(ix.begin(), ix.end(), dp.back(),\n [&x=dr[i], &i, &dr](const auto& a, const auto& j) {\n return i == j ? a : a * (x - dr[j]);\n }\n );\n\n a[i] = -p / q / dr[i];\n }\n\n auto a0 = np.front() / dp.front() - std::accumulate(a.begin(), a.end(), T(0));\n return std::make_tuple(a0, std::move(a), utils::make_vector(dr, [](const auto& x) { return -T(1) / x; }));\n }\n\n [[nodiscard]] auto nc() const {\n return _m;\n }\n\n private:\n\n size_t _n{}, _m{};\n taylor_func_t _taylor;\n transform_func_t _transform;\n coeficients_func_t _coefficients;\n\n };\n\n template\n auto ssp_coefficients(const size_t& n, const size_t& m) {\n return coefficients(n, m, _impl::exp_taylor{}, _impl::no_transform{}, _impl::pade_coefficients{});\n }\n\n template\n auto ssp_coefficients(const size_t& n) {\n return ssp_coefficients(n, n);\n }\n\n template\n auto theta_ssp_coefficients(const size_t& n, const T& theta) {\n return coefficients(n, n, _impl::exp_taylor{}, _impl::no_transform{}, _impl::theta_pade_coefficients{ theta });\n }\n\n template\n auto wampe_coefficients(const size_t& n, const size_t& m) {\n return coefficients(n, m, _impl::root_taylor{}, _impl::wampe_transform{}, _impl::pade_coefficients{});\n }\n\n template\n auto wampe_coefficients(const size_t& n) {\n return wampe_coefficients(n, n);\n }\n\n template\n auto theta_wampe_coefficients(const size_t& n, const T& theta) {\n return coefficients(n, n, _impl::root_taylor{}, _impl::wampe_transform{}, _impl::theta_pade_coefficients{ theta });\n }\n\n}// namespace ample\n", "meta": {"hexsha": "de0f158cbadbf10f21df964b669695b1cbfb7a24", "size": 9411, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/coefficients.hpp", "max_stars_repo_name": "GoldFeniks/Acoustic", "max_stars_repo_head_hexsha": "44122f7a1d815aeeb4f06b60342c8db932a806f3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2019-12-06T21:11:59.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-05T11:11:12.000Z", "max_issues_repo_path": "include/coefficients.hpp", "max_issues_repo_name": "GoldFeniks/Acoustic", "max_issues_repo_head_hexsha": "44122f7a1d815aeeb4f06b60342c8db932a806f3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2021-01-31T14:09:41.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-07T05:48:05.000Z", "max_forks_repo_path": "include/coefficients.hpp", "max_forks_repo_name": "GoldFeniks/Ample", "max_forks_repo_head_hexsha": "44122f7a1d815aeeb4f06b60342c8db932a806f3", "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": 33.1373239437, "max_line_length": 172, "alphanum_fraction": 0.4836892998, "num_tokens": 2482, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577681049901037, "lm_q2_score": 0.6334102636778401, "lm_q1q2_score": 0.5433191215562229}} {"text": "#pragma once\n#include\n#include\n#include\"mkl_lapacke.h\"\n#include \n#include \n\nnamespace Many_Body{\n struct TriDiagMat{\n TriDiagMat(const Eigen::VectorXd& diagel, const Eigen::VectorXd& offDiag): diagel(diagel), offDiag(offDiag){}\n Eigen::VectorXd diagel;\n Eigen::VectorXd offDiag;\n auto dData(){return diagel.data();}\n auto offData(){return offDiag.data();}\n };\n\n\n void diag( Many_Body::TriDiagMat& tri, Eigen::MatrixXd& z, Eigen::VectorXd& ev)\n {\n MKL_INT N= ev.size();\n MKL_INT info= LAPACKE_dstedc(LAPACK_COL_MAJOR, 'I', N, tri.dData(), tri.offData(), z.data(), N);\n if(info!=0)\n {\n \tstd::cout << \" diagonalization failed\" << '\\n';\n }\n ev=tri.diagel;\n\n\n\n }\n template\n struct threeLVec\n {\n threeLVec(size_t dim, const Matrix& A): A(A), beta(1), alpha(0) {\n Vector vecOne=Eigen::VectorXcd::Zero(dim);\n Vector vecTwo=Eigen::VectorXcd::Zero(dim);\n Vector vecThree=Eigen::VectorXcd::Zero(dim);\n }\n const Matrix& A;\n double beta{1};\n double alpha{};\n Vector vecOne;\n Vector vecTwo;\n Vector vecThree;\n\nvoid iterate()\n {\n \tvecThree=A*vecTwo;\t\n\t//\tstd::complex c=qk.adjoint()*qMiddle;\n\tstd::complex c=(vecTwo).adjoint()*vecThree;\n\n \talpha=real(c);\n\n\t//\tEigen::VectorXcd rk=qMiddle - alpha*qk -beta*qkmin;\n\n\tEigen::VectorXcd rk=vecThree - alpha*vecTwo -beta*vecOne;\n\t\n \tbeta=rk.norm();\t\t\n\tvecOne=vecTwo;\n\n\t//qk=rk/rk.norm();\n\tvecTwo=rk/rk.norm();\n }\n void lastIterate()\n {\n \tvecThree=A*vecTwo;\t\n\n\tstd::complex c=(vecTwo).adjoint()*vecThree;\n\n \talpha=real(c);\n\n\n }\n \n \n \n };\n template\n TriDiagMat Lanczos3Vec(Matrix& A, Eigen::VectorXcd& state, const size_t iterations)\n {\n using namespace Eigen::internal;\n using namespace Eigen;\n \tassert(std::abs(state.norm() -1.) < Many_Body::err);\n\n\n\n\tthreeLVec< Eigen::VectorXcd, Matrix> threeLanczVec(A.rows(), A);\n\tthreeLanczVec.vecTwo=state;\n long double beta=1;\n\n double alpha(0);\n Eigen::VectorXd bandTdiag(iterations);\n Eigen::VectorXd bandTOff(iterations-1);\n bandTdiag.setZero();\n bandTOff.setZero();\n\n Eigen::VectorXcd qk=state;\n Eigen::VectorXcd qkmin(A.rows());\n qkmin.setZero();\n threeLanczVec.vecOne=qkmin;\n size_t dim=0;\n\n for (size_t k = 1; k < iterations; ++k)\n {\n\t threeLanczVec.iterate();\n\n \talpha=threeLanczVec.alpha;\n \tbeta=threeLanczVec.beta;\n\n\tbandTdiag(k-1)=alpha;\n \tbandTOff(k-1)=beta;\n \t \n\t \t if( std::abs(beta)<0.00001)\n \t {\n\t\t \n \t\t bandTdiag.resize( k);\n \t\t bandTOff.resize( k-1);\n\n\t\t \n \t break;\n \t }\n \t dim=k; \n \t }\n \n \n \n\n \n {\n\n threeLanczVec.lastIterate();\n bandTdiag(dim)=threeLanczVec.alpha;\n\n }\n\n\n\n\n\t \n\t \n TriDiagMat T(bandTdiag, bandTOff);\n return T;\n }\n template\n TriDiagMat Lanczos(Matrix& A, Eigen::VectorXcd& state, const size_t iterations, Eigen::MatrixXcd& Q)\n {\n using namespace Eigen::internal;\n using namespace Eigen;\n \tassert(std::abs(state.norm() -1.) < Many_Body::err);\n\n\tQ.setZero();\n\tQ.col(0)=state;\n long double beta=1;\n double alpha(0);\n Eigen::VectorXd bandTdiag(iterations);\n Eigen::VectorXd bandTOff(iterations-1);\n\t bandTdiag.setZero();\n bandTOff.setZero();\n\n Eigen::VectorXcd qk=state;\n Eigen::VectorXcd qkmin(A.rows());\n qkmin.setZero();\n size_t dim=0;\n for (size_t k = 1; k < iterations; ++k)\n {\n\t Eigen::VectorXcd qMiddle=A*qk;\n\t\t\n\t \tstd::complex c=qk.adjoint()*qMiddle;\n\t \talpha=real(c);\n\n \tEigen::VectorXcd rk=qMiddle - alpha*qk -beta*qkmin;\n \tbeta=rk.norm();\n\n\tbandTdiag(k-1)=alpha;\n \tbandTOff(k-1)=beta;\n\n \tqkmin=qk;\n\tqk=rk/rk.norm();\n\t Q.col(k)=qk;\n \t \n\t \t if( std::abs(beta)<0.0001)\n \t {\n\t Eigen::MatrixXcd W=Q;\n\t Q.resize(A.rows(), k);\n\t\t for (size_t i = 0; i < k; ++i)\n\t\t {\n\t\t Q.col(i)=W.col(i);\n\t\t \n\t\t }\n \t\t bandTdiag.resize( k);\n \t\t bandTOff.resize( k-1);\n\t\t break;\n \t }\n\tdim=k;\n }\n {\n Eigen::VectorXcd qMiddle=A*qk;\n \tstd::complex c=qk.adjoint()*qMiddle;\n \talpha=real(c);\n\n \t\t bandTdiag(dim)=(alpha);\n\n }\n // assert(std::abs( (Q.adjoint()*Q).sum() -(dim+1)) < Many_Body::err); \n std::cout<<\"Qdag Q sum \"<< (Q.adjoint()*Q).sum()<\n auto lanczTrafo(const Vector & state, const Vector2 & iniState, size_t iteration, const Matrix& A)\n ->Eigen::VectorXcd\n {\n Many_Body::threeLVec< Eigen::VectorXcd, Matrix> threeLanczVec(A.rows(), A);\n Eigen::VectorXcd newVec=Eigen::VectorXcd::Zero(A.rows());\n threeLanczVec.vecTwo=iniState;\n Eigen::VectorXcd qkmin(A.rows());\n qkmin.setZero();\n threeLanczVec.vecOne=qkmin;\n for(size_t i=0; i\n#include \n\nusing namespace std;\nusing namespace arma;\n\ndouble coeff_a1(unsigned int q_idx, cx_dvec &psi)\n{\n int d = psi.size();\n double mysum = 0.0;\n for (int y=0; y_{q_idx} state.\ndouble optimized_theta(unsigned int q_idx, unsigned int x, unsigned int z, cx_dvec &psi)\n{\n double a1 = coeff_a1(q_idx, psi);\n double a2 = coeff_a2(q_idx, x, psi);\n double a3 = coeff_a3(q_idx, x, z, psi);\n\n double theta1, theta2;\n if (a1==a2)\n theta1= 3.14159265358979/2.0;\n else\n theta1 = atan(a3/(a1 - a2))/2.0;\n \n theta2 = theta1 + 3.14159265358979/2.0;\n\n double f1 = ((a1-a2) * cos(2*theta1) + a3 * sin(2*theta1))/2.0;\n double f2 = ((a1-a2) * cos(2*theta2) + a3 * sin(2*theta2))/2.0;\n\n f1 += (a1+a2)/2.0;\n f2 += (a1+a2)/2.0;\n\n if (f1>f2)\n return theta1;\n else\n return theta2;\n}\n\n// Given a Pauli string, find the optimal overlap with the |0>_{q_idx} using\n// a PPR.\ndouble optimal_overlap(unsigned int q_idx, unsigned int x, unsigned int z, cx_dvec &psi)\n{\n double a1 = coeff_a1(q_idx, psi);\n double a2 = coeff_a2(q_idx, x, psi);\n double a3 = coeff_a3(q_idx, x, z, psi);\n\n double theta1, theta2;\n if (a1==a2)\n theta1= 3.14159265358979/2.0;\n else\n theta1 = atan(a3/(a1 - a2))/2.0;\n \n theta2 = theta1 + 3.14159265358979/2.0;\n double f1 = ((a1-a2) * cos(2*theta1) + a3 * sin(2*theta1))/2.0;\n double f2 = ((a1-a2) * cos(2*theta2) + a3 * sin(2*theta2))/2.0;\n\n f1 += (a1+a2)/2.0;\n f2 += (a1+a2)/2.0;\n\n if (f1>f2)\n return f1;\n else\n return f2;\n}\n\n// Find the optimal Pauli string that maximizes the overlap with |0>_q\n// and apply the corresponding PPR to psi. Here the PPR is assumed to be restricted\n// to a set of first 'bits' qubits\nvoid optimal_update(unsigned int q_idx, unsigned int setbits, cx_dvec &psi)\n{\n int i_best, j_best;\n double f = 0.0;\n double theta = 0.0;\n for (int i=0; i<(1<0.0001))\n\t exit (EXIT_FAILURE);*/\n\n\t // Apply optimal update only if the PPR acts nontrivially on q_idx.\n\t if ((i & (1< f)\n\t\t{\n\t\t f = optimal_overlap(q_idx, i, j, psi);\n\t\t //\t cout << \"New record: \" << f << endl;\n\t\t i_best = i;\n\t\t j_best = j;\n\t\t}\n\t }\n\t \n\t}\n }\n theta = optimized_theta(0, i_best, j_best, psi);\n apply_ppr(i_best, j_best, theta, psi);\n}\n\n// Skip the given choice of i and j with probability 1-ratio.\nvoid randomized_update(unsigned int q_idx, unsigned int setbits, double ratio, cx_dvec &psi)\n{\n int i_best, j_best;\n double f = 0.0;\n double theta = 0.0;\n for (int i=0; i<(1< f)\n\t\t {\n\t\t f = optimal_overlap(q_idx, i, j, psi);\n\t\t //\t cout << \"New record: \" << f << endl;\n\t\t i_best = i;\n\t\t j_best = j;\n\t\t }\n\t\t}\n\t }\n\t \n\t}\n }\n theta = optimized_theta(0, i_best, j_best, psi);\n apply_ppr(i_best, j_best, theta, psi);\n}\n\n// Decode and print the result.\nvoid decode(unsigned q_idx, cx_dvec &psi, unsigned int setbits, double eps)\n{\n double f = 0.0;\n int itt = 0;\n while (f<1-eps)\n {\n itt++;\n optimal_update(q_idx, setbits, psi);\n f = coeff_a1(0, psi);\n cout << itt << \":\" << f << endl;\n }\n}\n\nvoid randomized_decode(unsigned q_idx, cx_dvec &psi, unsigned int setbits, double ratio, double eps)\n{\n double f = 0.0;\n int itt = 0;\n while (f<1-eps)\n {\n itt++;\n randomized_update(q_idx, setbits, ratio, psi);\n f = coeff_a1(0, psi);\n cout << itt << \":\" << f << endl;\n }\n}\n\ndouble decode_cost(unsigned q_idx, cx_dvec &psi, unsigned int setbits, double eps)\n{\n double f = 0.0;\n double cost = 0.0;\n int itt = 0;\n while (f<1-eps)\n {\n itt++;\n optimal_update(q_idx, setbits, psi);\n f = coeff_a1(0, psi);\n // cout << itt << \":\" << f << endl;\n cost += 1.0;\n }\n return cost;\n}\n\ndouble randomized_decode_cost(unsigned q_idx, cx_dvec &psi, unsigned int setbits, double ratio, double eps)\n{\n double f = 0.0;\n double cost = 0.0;\n int itt = 0;\n while (f<1-eps)\n {\n itt++;\n randomized_update(q_idx, setbits, ratio, psi);\n f = coeff_a1(0, psi);\n // cout << itt << \":\" << f << endl;\n cost += 1.0;\n }\n return cost;\n}\n", "meta": {"hexsha": "a4e0f55d23986d9058d6022c7364d515a75a072e", "size": 6167, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "c++/decode.cpp", "max_stars_repo_name": "ikim-quantum/DecodeInterior", "max_stars_repo_head_hexsha": "c07649e8728c784dc1bd2a25602fec14a344a234", "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": "c++/decode.cpp", "max_issues_repo_name": "ikim-quantum/DecodeInterior", "max_issues_repo_head_hexsha": "c07649e8728c784dc1bd2a25602fec14a344a234", "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": "c++/decode.cpp", "max_forks_repo_name": "ikim-quantum/DecodeInterior", "max_forks_repo_head_hexsha": "c07649e8728c784dc1bd2a25602fec14a344a234", "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": 23.3598484848, "max_line_length": 145, "alphanum_fraction": 0.5636452084, "num_tokens": 2213, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577681195338728, "lm_q2_score": 0.6334102498375401, "lm_q1q2_score": 0.5433191188966273}} {"text": "/*\n* @file \t\tex8.cpp\n* @details \tThis file is the solution to exercise 8.\n* @author \tAlexander Rettkowski\n* @date \t12.07.2017\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\n#include \n#include \n#include \n#include \n#include \n\nusing namespace boost;\n\nnamespace exercise8\n{\n\tnamespace qi = boost::spirit::qi;\n\tnamespace ascii = boost::spirit::ascii;\n\tstruct edge\n\t{\n\t\tint startNode;\n\t\tint endNode;\n\t\tint length;\n\t};\n}\n\n\nBOOST_FUSION_ADAPT_STRUCT(\n\texercise8::edge,\n\t(int, startNode)\n\t(int, endNode)\n\t(int, length)\n)\n\nnamespace exercise8\n{\n\ttemplate \n\tstruct line_parser : qi::grammar\n\t{\n\t\tline_parser() : line_parser::base_type(start)\n\t\t{\n\t\t\tusing qi::int_;\n\t\t\tstart %= int_ >> ' ' >> int_ >> ' ' >> int_;\n\t\t}\n\n\t\tqi::rule start;\n\t};\n}\n\n/**\n* The function that calculates the shortest paths using Dijkstra's method.\n* @param numberOfNodes Number of nodes in the graph.\n* @param graph The graph represented as a vector auf edge-vectors.\n* @param startNode The id of the node where the search starts.\n*/\nstd::vector dijkstra(int numberOfNodes, std::vector< std::vector< std::pair > > graph, int startNode, std::vector& predecessors)\n{\n\tpredecessors.resize(numberOfNodes, -1);\n\tstd::vector distanceTo(numberOfNodes, INT_MAX);\n\tstd::priority_queue< std::pair, std::vector< std::pair >, std::greater< std::pair > > queue;\n\tqueue.push(std::pair(startNode, 0));\n\tdistanceTo[startNode] = 0;\n\t//predecessors[startNode] = -1;\n\n\tint currentNode, compareNode, compareNodeDistance, currentNodeDistance;\n\n\twhile (!queue.empty()) {\n\t\tcurrentNode = queue.top().first;\n\t\tcurrentNodeDistance = queue.top().second;\n\t\tqueue.pop();\n\n\t\tif (distanceTo[currentNode] < currentNodeDistance) continue;\n\n\t\tfor (int i = 0; i < graph[currentNode].size(); i++) {\n\t\t\tcompareNode = graph[currentNode][i].first;\n\t\t\tcompareNodeDistance = graph[currentNode][i].second;\n\t\t\tif (distanceTo[compareNode] > distanceTo[currentNode] + compareNodeDistance) {\n\t\t\t\tdistanceTo[compareNode] = distanceTo[currentNode] + compareNodeDistance;\n\t\t\t\tqueue.push(std::pair(compareNode, distanceTo[compareNode]));\n\t\t\t\tpredecessors[compareNode] = currentNode;\n\t\t\t}\n\t\t}\n\t}\n\treturn distanceTo;\n}\n\n\n/**\n* This method checks (in a naive way), if a given number is prime or not.\n* @param number The number to check.\n* @returns True, if number is prime; false otherwise.\n*/\nbool isPrime(int number) {\n\tif (number == 2)\n\t\treturn true;\n\tif (number % 2 == 0)\n\t\treturn false;\n\tfor (int i = 3; (i*i) <= number; i += 2) {\n\t\tif (number % i == 0) return false;\n\t}\n\treturn true;\n}\n\n/**\n* The main function that reads in a file and processes it.\n* @param argc Number of command line arguments.\n* @param *argv a pointer to the array of command line arguments.\n*/\nint main(int argc, char *argv[])\n{\n\ttimer::cpu_timer boostTimer;\n\n\tusing boost::spirit::ascii::space;\n\ttypedef std::string::const_iterator iterator_type;\n\ttypedef exercise8::line_parser line_parser;\n\tline_parser parser;\n\tstd::string currentLine;\n\tstd::ifstream file(argv[1]);\n\n\t// get number of nodes\n\tchar delimiter = ' ';\n\tgetline(file, currentLine, delimiter);\n\tconst int numberOfNodes = stoi(currentLine);\n\tgetline(file, currentLine);\n\tint constSub = 1;\n\n\tstd::vector>> edges(numberOfNodes);\n\twhile (getline(file, currentLine))\n\t{\n\t\texercise8::edge parsedLine;\n\t\tstd::string::const_iterator currentPosition = currentLine.begin();\n\t\tstd::string::const_iterator lineEnd = currentLine.end();\n\t\tbool parsingSucceeded = phrase_parse(currentPosition, lineEnd, parser, space, parsedLine);\n\n\t\tif (parsingSucceeded && currentPosition == lineEnd)\n\t\t{\n\t\t\tstd::pair *tempEdge = new std::pair();\n\t\t\ttempEdge->first = parsedLine.endNode - constSub;\n\t\t\ttempEdge->second = parsedLine.length;\n\t\t\tedges[parsedLine.startNode - constSub].push_back(*tempEdge);\n\n\t\t\tstd::pair *reverseEdge = new std::pair();\n\t\t\treverseEdge->first = parsedLine.startNode - constSub;\n\t\t\treverseEdge->second = parsedLine.length;\n\t\t\tedges[parsedLine.endNode - constSub].push_back(*reverseEdge);\n\t\t}\n\t}\n\n\tfile.close();\n\t\n\n\n\n\n\n\n\tstd::vector connectedVertices, unconnectedTerminals;\n\tfor (int i = 0; i < numberOfNodes; i++)\n\t{\n\t\tif (isPrime(i))\n\t\t\tunconnectedTerminals.push_back(i);\n\t}\n\n\tconnectedVertices.push_back(unconnectedTerminals.back());\n\tunconnectedTerminals.pop_back();\n\n\tstd::map> distancesFromTerminals;\n\tstd::map> predecessorsFromTerminals;\n\tfor (int i : unconnectedTerminals)\n\t{\n\t\tstd::vector predecessors;\n\t\tstd::vector distancesFromI = dijkstra(numberOfNodes, edges, i, predecessors);\n\t\tdistancesFromTerminals.insert(std::pair>(i, distancesFromI));\n\t\tpredecessorsFromTerminals.insert(std::pair>(i, predecessors));\n\t}\n\n\tint steinerWeight = 0;\n\n\twhile (unconnectedTerminals.size() > 0)\n\t{\n\t\tint connectingPointId = -1, connectingPointDistance = INT32_MAX;\n\t\tstd::vector path;\n\n\t\tint pathFrom = -1, pathTo = -1, mindist = INT32_MAX;\n\t\tfor (int i = 0; i < unconnectedTerminals.size(); i++)\n\t\t{\n\t\t\tint vertexId = unconnectedTerminals[i];\n\t\t\tfor (int j : connectedVertices)\n\t\t\t{\n\t\t\t\tif (distancesFromTerminals[vertexId][j] < mindist)\n\t\t\t\t{\n\t\t\t\t\tmindist = distancesFromTerminals[vertexId][j];\n\t\t\t\t\tpathTo = j;\n\t\t\t\t\tpathFrom = vertexId;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tpath.push_back(pathFrom);\n\t\tdo\n\t\t{\n\t\t\tpath.push_back(pathTo);\n\t\t\tpathTo = predecessorsFromTerminals[pathFrom][pathTo];\n\t\t} while (pathTo != pathFrom);\n\n\t\t// get path from \n\t\tfor (int i : path)\n\t\t{\n\t\t\t// if the vertex wasn't in the tree before, add\n\t\t\tif (std::find(connectedVertices.begin(), connectedVertices.end(), i) == connectedVertices.end())\n\t\t\t{\n\t\t\t\tconnectedVertices.push_back(i);\n\t\t\t}\n\t\t\t// if it was an unconnected terminal, delete from the list\n\t\t\tauto pos = std::find(unconnectedTerminals.begin(), unconnectedTerminals.end(), i);\n\t\t\tif (pos != unconnectedTerminals.end())\n\t\t\t{\n\t\t\t\tunconnectedTerminals.erase(pos);\n\t\t\t}\n\t\t}\n\n\t\tsteinerWeight += mindist;\n\n\t}\n\n\tstd::cout << steinerWeight;\n\n\treturn 0;\n}\n\n", "meta": {"hexsha": "37f9071cb1e9c23be671b9b0d8f9d4ac9624497d", "size": 6736, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "rettkowski/ex8.cpp", "max_stars_repo_name": "appfs/appfs", "max_stars_repo_head_hexsha": "8cbbfa0e40e4d4a75a498ce8dd894bb2fbc3a9e3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2017-04-21T11:39:55.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-11T20:25:18.000Z", "max_issues_repo_path": "rettkowski/ex8.cpp", "max_issues_repo_name": "appfs/appfs", "max_issues_repo_head_hexsha": "8cbbfa0e40e4d4a75a498ce8dd894bb2fbc3a9e3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 69.0, "max_issues_repo_issues_event_min_datetime": "2017-04-26T09:30:38.000Z", "max_issues_repo_issues_event_max_datetime": "2017-08-01T11:31:21.000Z", "max_forks_repo_path": "rettkowski/ex8.cpp", "max_forks_repo_name": "appfs/appfs", "max_forks_repo_head_hexsha": "8cbbfa0e40e4d4a75a498ce8dd894bb2fbc3a9e3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 53.0, "max_forks_repo_forks_event_min_datetime": "2017-04-20T16:16:11.000Z", "max_forks_repo_forks_event_max_datetime": "2017-07-19T12:53:01.000Z", "avg_line_length": 27.2712550607, "max_line_length": 148, "alphanum_fraction": 0.7050178147, "num_tokens": 1810, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.766293653760418, "lm_q2_score": 0.7090191399336402, "lm_q1q2_score": 0.5433168673258183}} {"text": "/*\n * Copyright 2013-2015 Raphael Bost\n *\n * This file is part of ciphermed.\n\n * ciphermed is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * ciphermed is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with ciphermed. If not, see . 2\n *\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n/* The algorithms here are from Victor Shoup's Book\n * A Computational Introduction to Number Theory and Algebra\n * or Shoup's NTL library (for Sophie Germain primes)\n */\n\nstd::vector gen_rand_non_increasing_seq(const mpz_class &m, gmp_randstate_t state)\n{\n std::vector seq;\n\n mpz_class n = m;\n mpz_class new_n;\n do {\n // pick a new n between 1...n\n mpz_urandomm(new_n.get_mpz_t(),state,n.get_mpz_t());\n n = new_n + 1;\n seq.push_back(n);\n } while (n != 1);\n\n return seq;\n}\n\nstd::vector extract_prime_seq(const std::vector &seq, int reps)\n{\n std::vector primes;\n for (size_t i = 0; i < seq.size(); i++) {\n if (mpz_class_probab_prime_p(seq[i],reps) != 0) {\n primes.push_back(seq[i]);\n }\n }\n\n return primes;\n}\n\n// generates a random integer with its factorization (returns the factorization)\nstd::vector gen_rand_number_factorization(const mpz_class &m, mpz_class *result, gmp_randstate_t state, int reps)\n{\n for (; ; ) {\n std::vector seq = gen_rand_non_increasing_seq(m,state);\n std::vector primes = extract_prime_seq(seq, reps);\n\n mpz_class y = 1;\n for (size_t i = 0; i < primes.size(); i++) {\n y *= primes[i];\n if (y > m) {\n break;\n }\n }\n if (y > m) {\n continue;\n }\n\n mpz_class x;\n mpz_urandomm(x.get_mpz_t(),state,m.get_mpz_t());\n x += 1;\n\n if (x <= y) {\n if (result) {\n *result = y;\n }\n return primes;\n }\n }\n}\n\n// generates a random prime p with the factorization of p-1 (returns the factorization)\nstd::vector gen_rand_prime_with_factorization(const mpz_class &m, mpz_class *p, gmp_randstate_t state, int reps)\n{\n for (; ; ) {\n mpz_class n;\n std::vector factorization = gen_rand_number_factorization(m,&n,state,reps);\n\n if (mpz_class_probab_prime_p(n+1, reps) != 0) {\n if (p) {\n *p = n+1;\n }\n return factorization;\n }\n }\n}\n\nmpz_class simple_safe_prime_gen(size_t n_bits, gmp_randstate_t state, int reps)\n{\n for (size_t count = 1; ; count ++) {\n mpz_class n;\n mpz_urandom_len(n.get_mpz_t(),state,n_bits);\n\n if (mpz_class_probab_prime_p(n,reps) !=0) {\n if (mpz_class_probab_prime_p(2*n+1,reps) != 0 ) {\n std::cout << count << \" iterations needed to generate safe prime\" << std::endl;\n return n;\n }\n }\n }\n}\n\n\nstatic long bit_count(long a)\n{\n unsigned long aa;\n if (a < 0)\n aa = - ((unsigned long) a);\n else\n aa = a;\n\n long k = 0;\n while (aa) {\n k++;\n aa = aa >> 1;\n }\n\n return k;\n}\n\n/* The following code is just NTL's code for generating Germain primes using GMP */\n\n// prime_bound computes a reasonable bound for trial\n// division in the Miller-Rabin test.\n// It is computed a bit on the \"low\" side, since being a bit\n// low doesn't hurt much, but being too high can hurt a lot.\n\nstatic\nlong prime_bound(long bn)\n{\n long wn = (bn+NBITS_MAX-1)/NBITS_MAX;\n\n long fn;\n\n if (wn <= 36)\n fn = wn/4 + 1;\n else\n fn = long(1.67*sqrt(double(wn)));\n\n long prime_bnd;\n\n if (bit_count(bn) + bit_count(fn) > NBITS_MAX)\n prime_bnd = (1L << NBITS_MAX);\n else\n prime_bnd = bn*fn;\n\n return prime_bnd;\n}\n\nstatic\nlong ErrBoundTest(long kk, long tt, long nn)\n\n{\n const double fudge = (1.0 + 1024.0/NTL_FDOUBLE_PRECISION);\n const double log2_3 = log2(3.0);\n const double log2_7 = log2(7.0);\n const double log2_20 = log2(20.0);\n\n double k = kk;\n double t = tt;\n double n = nn;\n\n if (k < 3 || t < 1) return 0;\n if (n < 1) return 1;\n\n // the following test is largely academic\n assert(9*t < NTL_FDOUBLE_PRECISION);\n\n double log2_k = log2(k);\n\n if ((n + log2_k)*fudge <= 2*t)\n return 1;\n\n if ((2*log2_k + 4.0 + n)*fudge <= 2*sqrt(k))\n return 2;\n\n if ((t == 2 && k >= 88) || (3 <= t && 9*t <= k && k >= 21)) {\n if ((1.5*log2_k + t + 4.0 + n)*fudge <= 0.5*log2(t) + 2*(sqrt(t*k)))\n return 3;\n }\n\n if (k <= 9*t && 4*t <= k && k >= 21) {\n if ( ((log2_3 + log2_7 + log2_k + n)*fudge <= log2_20 + 5*t) &&\n ((log2_3 + (15.0/4.0)*log2_k + n)*fudge <= log2_7 + k/2 + 2*t) &&\n ((2*log2_3 + 2 + log2_k + n)*fudge <= k/4 + 3*t) )\n return 4;\n }\n\n if (4*t >= k && k >= 21) {\n if (((15.0/4.0)*log2_k + n)*fudge <= log2_7 + k/2 + 2*t)\n return 5;\n }\n\n return 0;\n}\n\nstatic long make_odd(mpz_class &n)\n{\n long k = 0;\n\n while (mpz_even_p(n.get_mpz_t())) {\n n >>= 1;\n k++;\n }\n\n return k;\n}\n\nstatic long is_Miller_witness(const mpz_class& n, const mpz_class& x)\n{\n mpz_class m(0), y(0), z(0);\n long j, k;\n\n if (x == 0) return 0;\n\n m = n-1;\n k = make_odd(m);\n\n z = mpz_class_powm(x,m,n);\n\n if (z == 1) return 0;\n\n j = 0;\n do {\n y = z;\n z = (y*y) %n;\n j++;\n } while (j != k && z != 1);\n\n if (z != 1) return 1;\n y = y + 1;\n if (y != n) return 1;\n return 0;\n}\n\nvoid gen_germain_prime(mpz_class& n, long k, gmp_randstate_t state, long err)\n{\n assert(k > 1);\n assert(k <= (1L << 20));\n\n if (err < 1) err = 1;\n if (err > 512) err = 512;\n\n if (k == 2) {\n if (gmp_urandomm_ui(state,2))\n n = 3;\n else\n n = 2;\n\n return;\n }\n\n\n long prime_bnd = prime_bound(k);\n\n if (bit_count(prime_bnd) >= k/2)\n prime_bnd = (1L << (k/2-1));\n\n\n mpz_class two;\n two = 2;\n\n mpz_class n1;\n\n\n PrimeSeq s;\n\n mpz_class iter;\n iter = 0;\n\n\n for (;;) {\n iter++;\n\n mpz_urandom_len(n.get_mpz_t(),state,k);\n\n if (mpz_even_p(n.get_mpz_t())) {\n n = n+1;\n }\n\n s.reset(3);\n long p;\n\n long sieve_passed = 1;\n\n p = s.next();\n while (p && p < prime_bnd) {\n mpz_class r;\n mpz_tdiv_r_ui(r.get_mpz_t(),n.get_mpz_t(),p);\n\n if (r == 0) {\n sieve_passed = 0;\n break;\n }\n\n // test if 2*r + 1 = 0 (mod p)\n if (r == p-r-1) {\n sieve_passed = 0;\n break;\n }\n\n p = s.next();\n }\n\n if (!sieve_passed) continue;\n\n\n if (is_Miller_witness(n, two)) continue;\n\n n1 = 2*n+1;\n\n if (is_Miller_witness(n1, two)) continue;\n\n // now do t M-R iterations...just to make sure\n\n // First compute the appropriate number of M-R iterations, t\n // The following computes t such that\n // p(k,t)*8/k <= 2^{-err}/(5*iter^{1.25})\n // which suffices to get an overall error probability of 2^{-err}.\n // Note that this method has the advantage of not requiring\n // any assumptions on the density of Germain primes.\n long iter_n_bits = mpz_sizeinbase(iter.get_mpz_t(),2);\n long err1 = std::max(1L, err + 7 + (5*iter_n_bits + 3)/4 - bit_count(k));\n long t;\n t = 1;\n while (!ErrBoundTest(k, t, err1))\n t++;\n\n if(mpz_probab_prime_p(n.get_mpz_t(),t))\n break;\n }\n}\n\n// Constructs a generator for the cyclic group \\Z^*_p where p is a Sophie Germain prime\nmpz_class get_generator_for_cyclic_group(const mpz_class &p, gmp_randstate_t state)\n{\n mpz_class q = (p >> 1);\n mpz_class g;\n\n\n // find a generator for ZZ*_p\n // Shoup's algorithm\n\n mpz_class alpha, beta;\n do {\n mpz_urandomm(alpha.get_mpz_t(),state,p.get_mpz_t());\n\n beta = mpz_class_powm(alpha,q,p);\n } while (beta == 1);\n\n g = beta;\n\n do {\n mpz_urandomm(alpha.get_mpz_t(),state,p.get_mpz_t());\n beta = (alpha*alpha) %p;\n\n } while (beta == 1);\n\n g = (g*beta) %p;\n\n return g;\n}\n", "meta": {"hexsha": "6e2fd090c1fbd0171044755cc8c8187dd67babf8", "size": 8924, "ext": "cc", "lang": "C++", "max_stars_repo_path": "Source/math/num_th_alg.cc", "max_stars_repo_name": "TarekIbnZiad/CryptoImg", "max_stars_repo_head_hexsha": "5ecb2a34c7daa55c428c14c6eb370232b474707f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2019-11-05T18:23:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-03T07:33:10.000Z", "max_issues_repo_path": "Source/math/num_th_alg.cc", "max_issues_repo_name": "TarekIbnZiad/CryptoImg", "max_issues_repo_head_hexsha": "5ecb2a34c7daa55c428c14c6eb370232b474707f", "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": "Source/math/num_th_alg.cc", "max_forks_repo_name": "TarekIbnZiad/CryptoImg", "max_forks_repo_head_hexsha": "5ecb2a34c7daa55c428c14c6eb370232b474707f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2020-10-11T00:32:47.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-08T23:35:20.000Z", "avg_line_length": 23.1191709845, "max_line_length": 124, "alphanum_fraction": 0.5490811295, "num_tokens": 2700, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7310585786300049, "lm_q2_score": 0.7431680143008301, "lm_q1q2_score": 0.543299352218048}} {"text": "// Boost.Geometry\n\n// Copyright (c) 2017-2021, Oracle and/or its affiliates.\n\n// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle\n// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle\n\n// Licensed under the Boost Software License version 1.0.\n// http://www.boost.org/users/license.html\n\n#ifndef BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DENSIFY_HPP\n#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DENSIFY_HPP\n\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\nnamespace boost { namespace geometry\n{\n\nnamespace strategy { namespace densify\n{\n\n\n/*!\n\\brief Densification of spherical segment.\n\\ingroup strategies\n\\tparam RadiusTypeOrSphere \\tparam_radius_or_sphere\n\\tparam CalculationType \\tparam_calculation\n\n\\qbk{\n[heading See also]\n[link geometry.reference.algorithms.densify.densify_4_with_strategy densify (with strategy)]\n}\n */\ntemplate\n<\n typename RadiusTypeOrSphere = double,\n typename CalculationType = void\n>\nclass spherical\n{\npublic:\n typedef typename strategy_detail::get_radius\n <\n RadiusTypeOrSphere\n >::type radius_type;\n\n // For consistency with area strategy the radius is set to 1\n inline spherical()\n : m_radius(1.0)\n {}\n\n template \n explicit inline spherical(RadiusOrSphere const& radius_or_sphere)\n : m_radius(strategy_detail::get_radius\n <\n RadiusOrSphere\n >::apply(radius_or_sphere))\n {}\n\n template \n inline void apply(Point const& p0, Point const& p1, AssignPolicy & policy, T const& length_threshold) const\n {\n typedef typename AssignPolicy::point_type out_point_t;\n typedef typename select_most_precise\n <\n typename coordinate_type::type,\n typename coordinate_type::type,\n CalculationType\n >::type calc_t;\n\n calc_t angle01;\n\n formula::interpolate_point_spherical formula;\n formula.compute_angle(p0, p1, angle01);\n\n BOOST_GEOMETRY_ASSERT(length_threshold > T(0));\n\n signed_size_type n = signed_size_type(angle01 * m_radius / length_threshold);\n if (n <= 0)\n return;\n\n formula.compute_axis(p0, angle01);\n\n calc_t step = angle01 / (n + 1);\n\n calc_t a = step;\n for (signed_size_type i = 0 ; i < n ; ++i, a += step)\n {\n out_point_t p;\n formula.compute_point(a, p);\n\n geometry::detail::conversion::point_to_point\n <\n Point, out_point_t,\n 2, dimension::value\n >::apply(p0, p);\n\n policy.apply(p);\n }\n }\n\n inline radius_type radius() const\n {\n return m_radius;\n }\n\nprivate:\n radius_type m_radius;\n};\n\n\n#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS\nnamespace services\n{\n\ntemplate <>\nstruct default_strategy\n{\n typedef strategy::densify::spherical<> type;\n};\n\n\n} // namespace services\n#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS\n\n\n}} // namespace strategy::densify\n\n\n}} // namespace boost::geometry\n\n#endif // BOOST_GEOMETRY_ALGORITHMS_DENSIFY_HPP\n", "meta": {"hexsha": "8b14f7ae64d52a6b3913ef1180c1fffa95d1ecc0", "size": 4193, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "lib/boost_1.78.0/boost/geometry/strategies/spherical/densify.hpp", "max_stars_repo_name": "LaudateCorpus1/math", "max_stars_repo_head_hexsha": "990a66b3cccd27a5fd48626360bb91093a48278b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 326.0, "max_stars_repo_stars_event_min_datetime": "2015-02-08T13:47:49.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-16T02:13:59.000Z", "max_issues_repo_path": "lib/boost_1.78.0/boost/geometry/strategies/spherical/densify.hpp", "max_issues_repo_name": "LaudateCorpus1/math", "max_issues_repo_head_hexsha": "990a66b3cccd27a5fd48626360bb91093a48278b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 623.0, "max_issues_repo_issues_event_min_datetime": "2015-01-02T23:45:23.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-09T11:15:23.000Z", "max_forks_repo_path": "lib/boost_1.78.0/boost/geometry/strategies/spherical/densify.hpp", "max_forks_repo_name": "LaudateCorpus1/math", "max_forks_repo_head_hexsha": "990a66b3cccd27a5fd48626360bb91093a48278b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 215.0, "max_forks_repo_forks_event_min_datetime": "2015-01-14T15:50:38.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-23T03:58:36.000Z", "avg_line_length": 27.5855263158, "max_line_length": 111, "alphanum_fraction": 0.6987836871, "num_tokens": 935, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677506936878, "lm_q2_score": 0.640635854839898, "lm_q1q2_score": 0.5432385448423163}} {"text": "#ifndef SM_NUMERICAL_DIFF_HPP\n#define SM_NUMERICAL_DIFF_HPP\n\n#include \n#include \n#include \n#include \n\nnamespace sm {\nnamespace eigen {\n\ntemplate \nstruct NumericalDiffFunctor {\n typedef RESULT_VEC_T value_t;\n typedef typename value_t::Scalar scalar_t;\n typedef INPUT_VEC_T input_t;\n typedef JACOBIAN_T jacobian_t;\n\n NumericalDiffFunctor(boost::function f) : _f(f) {}\n\n value_t operator()(const input_t& x) { return _f(x); }\n\n input_t update(const input_t& x, int c, scalar_t delta) {\n input_t xnew = x;\n xnew[c] += delta;\n return xnew;\n }\n boost::function _f;\n};\n\n// A simple implementation of central differences to estimate a Jacobian matrix\ntemplate \nstruct NumericalDiff {\n typedef FUNCTOR_T functor_t;\n typedef typename functor_t::input_t input_t;\n typedef typename functor_t::value_t value_t;\n typedef typename functor_t::scalar_t scalar_t;\n typedef typename functor_t::jacobian_t jacobian_t;\n\n NumericalDiff(functor_t f, scalar_t eps = sqrt(std::numeric_limits::epsilon())) : functor(f), eps(eps) {}\n\n jacobian_t estimateJacobian(input_t const& x0) {\n // evaluate the function at the operating point:\n value_t fx0 = functor(x0);\n size_t N = x0.size();\n size_t M = fx0.size();\n\n // std::cout << \"Size: \" << M << \", \" << N << std::endl;\n jacobian_t J;\n J.resize(M, N);\n\n SM_ASSERT_EQ(std::runtime_error, x0.size(), J.cols(), \"Unexpected number of columns for input size\");\n SM_ASSERT_EQ(std::runtime_error, fx0.size(), J.rows(), \"Unexpected number of columns for output size\");\n\n for (unsigned c = 0; c < N; c++) {\n // Calculate a central difference.\n // This step size was stolen from cminpack: temp = eps * fabs(x[j]);\n scalar_t rcEps = std::max(static_cast(fabs(x0(c))) * eps, eps);\n\n value_t fxp = functor(functor.update(x0, c, rcEps));\n value_t fxm = functor(functor.update(x0, c, -rcEps));\n J.block(0, c, M, 1) = (fxp - fxm).template cast() /\n (typename jacobian_t::Scalar)(rcEps * (scalar_t)2.0);\n }\n return J;\n }\n\n functor_t functor;\n scalar_t eps;\n};\n\ntemplate \nEigen::MatrixXd numericalDiff(\n std::function function, InputType_ const& input,\n double eps =\n sqrt(std::numeric_limits::scalar_t>::epsilon())) {\n typedef NumericalDiffFunctor Functor;\n\n NumericalDiff numDiff(Functor(function), eps);\n return numDiff.estimateJacobian(input);\n}\n\n} // namespace eigen\n} // namespace sm\n\n#endif /* SM_NUMERICAL_DIFF_HPP */\n", "meta": {"hexsha": "91e8f6ed90019a43965c7ab127f0d3a512c1a85a", "size": 3033, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "Schweizer-Messer/sm_eigen/include/sm/eigen/NumericalDiff.hpp", "max_stars_repo_name": "chengfzy/kalibr", "max_stars_repo_head_hexsha": "fe9705b380b160dc939607135f7d30efa64ea2e9", "max_stars_repo_licenses": ["BSD-4-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Schweizer-Messer/sm_eigen/include/sm/eigen/NumericalDiff.hpp", "max_issues_repo_name": "chengfzy/kalibr", "max_issues_repo_head_hexsha": "fe9705b380b160dc939607135f7d30efa64ea2e9", "max_issues_repo_licenses": ["BSD-4-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": "Schweizer-Messer/sm_eigen/include/sm/eigen/NumericalDiff.hpp", "max_forks_repo_name": "chengfzy/kalibr", "max_forks_repo_head_hexsha": "fe9705b380b160dc939607135f7d30efa64ea2e9", "max_forks_repo_licenses": ["BSD-4-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.8620689655, "max_line_length": 119, "alphanum_fraction": 0.6663369601, "num_tokens": 772, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7279754371026367, "lm_q2_score": 0.7461389873857264, "lm_q1q2_score": 0.5431708554814428}} {"text": "////////////////////////////////////////////////////////////////////////////////////\n// The MIT License (MIT) //\n// //\n// Copyright (c) 2015 Whit Armstrong //\n// //\n// Permission is hereby granted, free of charge, to any person obtaining a copy //\n// of this software and associated documentation files (the \"Software\"), to deal //\n// in the Software without restriction, including without limitation the rights //\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell //\n// copies of the Software, and to permit persons to whom the Software is //\n// furnished to do so, subject to the following conditions: //\n// //\n// The above copyright notice and this permission notice shall be included in all //\n// copies or substantial portions of the Software. //\n// //\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR //\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, //\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE //\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER //\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, //\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE //\n// SOFTWARE. //\n////////////////////////////////////////////////////////////////////////////////////\n\n#pragma once\n\n#include \n#include \n#include \n\nnamespace arma {\n\n // lgamma\n class eop_lgamma : public eop_core {};\n\n template<> template arma_hot arma_pure arma_inline eT\n eop_core::process(const eT val, const eT ) {\n return boost::math::lgamma(val);\n }\n\n // Base\n template\n arma_inline\n const eOp lgamma(const Base& A) {\n arma_extra_debug_sigprint();\n return eOp(A.get_ref());\n }\n\n // BaseCube\n template\n arma_inline\n const eOpCube lgamma(const BaseCube& A) {\n arma_extra_debug_sigprint();\n return eOpCube(A.get_ref());\n }\n\n\n\n\n // factln\n double factln(const int i) {\n static std::vector factln_table;\n\n if(i < 0) {\n return -std::numeric_limits::infinity();\n }\n\n if(i > 100) {\n return boost::math::lgamma(static_cast(i) + 1);\n }\n\n if(factln_table.size() < static_cast(i+1)) {\n for(int j = factln_table.size(); j < (i+1); j++) {\n factln_table.push_back(std::log(boost::math::factorial(static_cast(j))));\n }\n }\n //for(auto v : factln_table) { std::cout << v << \"|\"; } std::cout << std::endl;\n return factln_table[i];\n }\n\n class eop_factln : public eop_core {};\n\n template<> template arma_hot arma_pure arma_inline eT\n eop_core::process(const eT val, const eT ) {\n return factln(val);\n }\n\n // Base\n template\n arma_inline\n const eOp factln(const Base& A) {\n arma_extra_debug_sigprint();\n return eOp(A.get_ref());\n }\n\n // BaseCube\n template\n arma_inline\n const eOpCube factln(const BaseCube& A) {\n arma_extra_debug_sigprint();\n return eOpCube(A.get_ref());\n }\n\n // cube\n //! element-wise multiplication of BaseCube objects with same element type\n template\n arma_inline\n const eGlueCube\n schur_prod\n (\n const BaseCube& X,\n const BaseCube& Y\n )\n {\n arma_extra_debug_sigprint();\n return eGlueCube(X.get_ref(), Y.get_ref());\n }\n\n //! element-wise multiplication of BaseCube objects with different element types\n template\n inline\n const mtGlueCube::result, T1, T2, glue_mixed_schur>\n schur_prod\n (\n const BaseCube< typename force_different_type::T1_result, T1>& X,\n const BaseCube< typename force_different_type::T2_result, T2>& Y\n )\n {\n arma_extra_debug_sigprint();\n typedef typename T1::elem_type eT1;\n typedef typename T2::elem_type eT2;\n typedef typename promote_type::result out_eT;\n promote_type::check();\n return mtGlueCube( X.get_ref(), Y.get_ref() );\n }\n\n // matrix\n template\n arma_inline\n const eGlue\n schur_prod(const Base& X, const Base& Y) {\n arma_extra_debug_sigprint();\n return eGlue(X.get_ref(), Y.get_ref());\n }\n\n //! element-wise multiplication of Base objects with different element types\n template\n inline\n const mtGlue::result, T1, T2, glue_mixed_schur>\n schur_prod\n (\n const Base< typename force_different_type::T1_result, T1>& X,\n const Base< typename force_different_type::T2_result, T2>& Y\n )\n {\n arma_extra_debug_sigprint();\n typedef typename T1::elem_type eT1;\n typedef typename T2::elem_type eT2;\n typedef typename promote_type::result out_eT;\n promote_type::check();\n return mtGlue( X.get_ref(), Y.get_ref() );\n }\n\n\n //! Base * scalar\n template\n arma_inline\n const eOp\n schur_prod\n (const Base& X, const typename T1::elem_type k)\n {\n arma_extra_debug_sigprint();\n return eOp(X.get_ref(),k);\n }\n\n //! scalar * Base\n template\n arma_inline\n const eOp\n schur_prod\n (const typename T1::elem_type k, const Base& X)\n {\n arma_extra_debug_sigprint();\n return eOp(X.get_ref(),k); // NOTE: order is swapped\n }\n\n double schur_prod(const int x, const double y) { return x * y; }\n double schur_prod(const double x, const int y) { return x * y; }\n double schur_prod(const double& x, const double& y) { return x * y; }\n double schur_prod(const int& x, const int& y) { return x * y; }\n\n // insert an 'any' function for bools into the arma namespace\n bool any(const bool x) {\n return x;\n }\n\n bool vectorise(bool x) {\n return x;\n }\n} // namespace arma\n", "meta": {"hexsha": "3977770489e3e88b13767a0b5a43596a58634817", "size": 7374, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "armalogp/arma.extensions.hpp", "max_stars_repo_name": "armaMCMC/arma-log-likelihood", "max_stars_repo_head_hexsha": "c8323afb0a99fbb69cdf738b7fbbde98432a7c66", "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": "armalogp/arma.extensions.hpp", "max_issues_repo_name": "armaMCMC/arma-log-likelihood", "max_issues_repo_head_hexsha": "c8323afb0a99fbb69cdf738b7fbbde98432a7c66", "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": "armalogp/arma.extensions.hpp", "max_forks_repo_name": "armaMCMC/arma-log-likelihood", "max_forks_repo_head_hexsha": "c8323afb0a99fbb69cdf738b7fbbde98432a7c66", "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.6865671642, "max_line_length": 123, "alphanum_fraction": 0.6277461351, "num_tokens": 1916, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311856832191, "lm_q2_score": 0.6893056167854461, "lm_q1q2_score": 0.5431253919318592}} {"text": "#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \"diffusion_map.h\"\r\n#include \"distance_matrix.h\"\r\n\r\n#ifdef _OPENMP\r\n#include \r\n#endif\r\n\r\nusing namespace Spectra;\r\n\r\nnamespace dmaps\r\n{\r\n\r\n diffusion_map::diffusion_map(const matrix_t& d, const vector_t& w, int num_threads) : \r\n dint_(d), d_(dint_), w_(w)\r\n {\r\n check_params();\r\n \r\n #ifdef _OPENMP\r\n if(num_threads) omp_set_num_threads(num_threads);\r\n #endif \r\n }\r\n\r\n diffusion_map::diffusion_map(const distance_matrix& dm, const vector_t& w, int num_threads) : \r\n d_(dm.get_distances()), w_(w)\r\n {\r\n check_params();\r\n\r\n #ifdef _OPENMP\r\n if(num_threads) omp_set_num_threads(num_threads);\r\n #endif\r\n }\r\n\r\n void diffusion_map::check_params()\r\n {\r\n if(d_.cols() != d_.rows())\r\n throw std::invalid_argument(\"Distance matrix must be square.\");\r\n \r\n if(w_.size() == 0)\r\n w_ = vector_t::Ones(d_.cols());\r\n else if(w_.size() != d_.cols())\r\n throw std::invalid_argument(\"Weights vector length must match distance matrix size.\");\r\n }\r\n\r\n void diffusion_map::set_kernel_bandwidth(f_type eps)\r\n {\r\n if(eps <= 0)\r\n throw std::invalid_argument(\"Kernel bandwidth must be positive.\"); \r\n eps_ = eps; \r\n }\r\n\r\n f_type diffusion_map::get_kernel_bandwidth() const\r\n {\r\n return eps_;\r\n }\r\n\r\n f_type diffusion_map::sum_similarity_matrix(f_type eps, f_type alpha) const\r\n {\r\n matrix_t wwt = w_*w_.transpose();\r\n return ((-0.5/eps*d_.array().square().pow(alpha)).exp()*wwt.array()).sum();\r\n }\r\n\r\n /*\r\n void diffusion_map::estimate_local_scale(int k)\r\n {\r\n // Default choice of k.\r\n if(k == 0) k = static_cast(std::sqrt(d_.rows()));\r\n\r\n // Set local epsilon scale for each entry.\r\n #ifdef _OPENMP\r\n #pragma omp parallel\r\n #endif\r\n {\r\n // Create sort indexer.\r\n std::vector idx(d_.rows());\r\n std::iota(std::begin(idx), std::end(idx), static_cast(0));\r\n\r\n #ifdef _OPENMP\r\n #pragma for schedule(static)\r\n #endif\r\n for(size_t i = 0; i < eps_.size(); ++i)\r\n {\r\n const vector_t& dist = d_.row(i);\r\n\r\n // Get indices of sorted distances (ascending).\r\n std::sort(std::begin(idx), std::end(idx),\r\n [&](size_t a, size_t b) { return dist[a] < dist[b]; }\r\n );\r\n \r\n // Sum and determine weight.\r\n // We skip the first element which is itself.\r\n f_type sum = 0.;\r\n for(size_t j = 1; j < idx.size(); ++j)\r\n {\r\n sum += w_[idx[j]];\r\n // Break at k value.\r\n if(sum >= k)\r\n {\r\n eps_[i] = dist[idx[j]];\r\n break;\r\n }\r\n }\r\n }\r\n }\r\n }\r\n */\r\n\r\n void diffusion_map::compute(int n, f_type alpha, f_type beta)\r\n {\r\n if(eps_ == 0)\r\n throw std::runtime_error(\"Kernel bandwidth must be defined before computing diffusion coordinates.\");\r\n \r\n if(alpha <= 0 || alpha > 1)\r\n throw std::invalid_argument(\"Distance scaling must be in the interval (0,1].\");\r\n \r\n // Compute similarity matrix and row normalize\r\n // to get right stochastic matrix.\r\n k_ = -0.5/eps_*d_.array().square().pow(alpha);\r\n k_.array() = k_.array().exp();\r\n k_.array() *= (w_*w_.transpose()).array();\r\n\r\n // Density normalization.\r\n vector_t rsum = k_.rowwise().sum().array().pow(-beta);\r\n k_ = rsum.asDiagonal()*k_*rsum.asDiagonal();\r\n\r\n // Right stochastic matrix. \r\n rsum = k_.rowwise().sum().array().cwiseInverse();\r\n k_ = rsum.asDiagonal()*k_;\r\n\r\n // Define eigensolver.\r\n DenseGenMatProd op(k_);\r\n GenEigsSolver > eigs(&op, n, 2*n);\r\n \r\n // Solve. \r\n eigs.init();\r\n eigs.compute();\r\n \r\n if(eigs.info() != SUCCESSFUL)\r\n throw std::runtime_error(\"Eigensolver did not converge.\");\r\n \r\n dvals_ = eigs.eigenvalues().real();\r\n dvecs_ = eigs.eigenvectors().real();\r\n }\r\n\r\n vector_t diffusion_map::nystrom(const vector_t& distances, f_type alpha, f_type beta)\r\n {\r\n if(dvals_.size() == 0)\r\n throw std::runtime_error(\"Eigenvectors must be computed first.\");\r\n \r\n vector_t k = -0.5/eps_*distances.array().square().pow(alpha);\r\n k.array() = k.array().exp();\r\n k /= k.sum();\r\n\r\n vector_t point(dvals_.size());\r\n\r\n for(int i = 0; i < dvals_.size(); ++i)\r\n point[i] = 1./dvals_[i]*(k.array()*dvecs_.col(i).array()).sum();\r\n \r\n return point;\r\n }\r\n\r\n const matrix_t& diffusion_map::get_eigenvectors() const\r\n {\r\n return dvecs_;\r\n }\r\n\r\n const vector_t& diffusion_map::get_eigenvalues() const\r\n {\r\n return dvals_;\r\n }\r\n\r\n const matrixc_t& diffusion_map::get_kernel_matrix() const\r\n {\r\n return k_;\r\n }\r\n}", "meta": {"hexsha": "d4f7d20d77ce614a1d7d10ce7f82ff07c2cacf91", "size": 5434, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "dmaps/diffusion_map.cpp", "max_stars_repo_name": "hsidky/dmaps", "max_stars_repo_head_hexsha": "e260724727cc14423b7ef09975649e274c004fc0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 17.0, "max_stars_repo_stars_event_min_datetime": "2017-08-30T21:20:14.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-10T17:33:39.000Z", "max_issues_repo_path": "dmaps/diffusion_map.cpp", "max_issues_repo_name": "hsidky/dmaps", "max_issues_repo_head_hexsha": "e260724727cc14423b7ef09975649e274c004fc0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2019-07-23T23:57:44.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-19T21:59:59.000Z", "max_forks_repo_path": "dmaps/diffusion_map.cpp", "max_forks_repo_name": "hsidky/dmaps", "max_forks_repo_head_hexsha": "e260724727cc14423b7ef09975649e274c004fc0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2018-12-05T21:17:42.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-25T14:47:02.000Z", "avg_line_length": 30.0220994475, "max_line_length": 114, "alphanum_fraction": 0.517298491, "num_tokens": 1296, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956580903722561, "lm_q2_score": 0.6825737344123242, "lm_q1q2_score": 0.5430953140607694}} {"text": "#include \n#include \n#include \n\nint main (int argc, char** argv) {\n \n S3d q;\n std::cout << q << std::endl;\n\n std::cout << q.Exp(Eigen::Vector3d(0.,M_PI/2.,0.)).norm() << std::endl;\n std::cout << q.Exp(q.ToAmbient(Eigen::Vector2d(0.,M_PI/2.))).norm() << std::endl;\n\n S3d mu;\n mu.vector() << 1./sqrt(2),1./sqrt(2), 0.;\n std::cout << mu << std::endl;\n\n double delta = 0.1;\n double f_prev = 1e99;\n double f = mu.dot(q);\n std::cout << \"f=\" << f << std::endl;\n for (uint32_t it=0; it<100; ++it) {\n Eigen::Vector3d J = -2.*(mu.vector() - q.vector()*q.dot(mu)); \n\n q = q.Exp(-delta*J);\n// q = q.RetractOrtho(-delta*J);\n\n f_prev = f;\n f = mu.dot(q);\n std::cout << \"@\" << it << \": f=\" << f \n << \" df/f=\" << (f_prev - f)/fabs(f) << std::endl;\n if ((f_prev - f)/fabs(f) > -1e-10) break;\n }\n std::cout << std::endl << mu << std::endl;\n std::cout << std::endl << q << std::endl;\n}\n\n", "meta": {"hexsha": "2ec18203899653eebf7bc83e8b3f427c1c0b5fe7", "size": 946, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "test/S.cpp", "max_stars_repo_name": "jstraub/tdp", "max_stars_repo_head_hexsha": "dcab53662be5b88db1538cf831707b07ab96e387", "max_stars_repo_licenses": ["MIT-feh"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2017-10-17T19:25:47.000Z", "max_stars_repo_stars_event_max_datetime": "2017-10-17T19:25:47.000Z", "max_issues_repo_path": "test/S.cpp", "max_issues_repo_name": "jstraub/tdp", "max_issues_repo_head_hexsha": "dcab53662be5b88db1538cf831707b07ab96e387", "max_issues_repo_licenses": ["MIT-feh"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2018-05-02T06:04:06.000Z", "max_issues_repo_issues_event_max_datetime": "2018-05-02T06:04:06.000Z", "max_forks_repo_path": "test/S.cpp", "max_forks_repo_name": "jstraub/tdp", "max_forks_repo_head_hexsha": "dcab53662be5b88db1538cf831707b07ab96e387", "max_forks_repo_licenses": ["MIT-feh"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2017-09-17T18:46:20.000Z", "max_forks_repo_forks_event_max_datetime": "2019-03-11T12:52:57.000Z", "avg_line_length": 25.5675675676, "max_line_length": 83, "alphanum_fraction": 0.5137420719, "num_tokens": 358, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8723473846343394, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.5430007696151778}} {"text": "\n#include \n#include \n#include \n\n#include \"flame/constants.h\"\n#include \"flame/moment.h\"\n\n#define sqr(x) ((x)*(x))\n#define cube(x) ((x)*(x)*(x))\n\n#ifdef DEFPATH\n #define defpath DEFPATH\n#else\n #define defpath \".\"\n#endif\n\nstd::map > CurveMap;\n\n// http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl?LU_Matrix_Inversion\n// by LU-decomposition.\nvoid inverse(MomentElementBase::value_t& out, const MomentElementBase::value_t& in)\n{\n using boost::numeric::ublas::permutation_matrix;\n using boost::numeric::ublas::lu_factorize;\n using boost::numeric::ublas::lu_substitute;\n using boost::numeric::ublas::identity_matrix;\n\n MomentElementBase::value_t scratch(in); // copy\n permutation_matrix pm(scratch.size1());\n if(lu_factorize(scratch, pm)!=0)\n throw std::runtime_error(\"Failed to invert matrix\");\n out.assign(identity_matrix(scratch.size1()));\n //out = identity_matrix(scratch.size1());\n lu_substitute(scratch, pm, out);\n}\n\nvoid RotMat(const double dx, const double dy,\n const double theta_x, const double theta_y, const double theta_z,\n typename MomentElementBase::value_t &R)\n{\n typedef typename MomentElementBase::state_t state_t;\n\n MomentState::matrix_t T = boost::numeric::ublas::identity_matrix(state_t::maxsize);\n\n R = boost::numeric::ublas::identity_matrix(state_t::maxsize);\n\n // Left-handed coordinate system => theta_y -> -theta_y.\n\n double m11 = cos(-theta_y)*cos(theta_z),\n m12 = sin(theta_x)*sin(-theta_y)*cos(theta_z) + cos(theta_x)*sin(theta_z),\n m13 = -cos(theta_x)*sin(-theta_y)*cos(theta_z) + sin(theta_x)*sin(theta_z),\n\n m21 = -cos(-theta_y)*sin(theta_z),\n m22 = -sin(theta_x)*sin(-theta_y)*sin(theta_z) + cos(theta_x)*cos(theta_z),\n m23 = cos(theta_x)*sin(-theta_y)*sin(theta_z) + sin(theta_x)*cos(theta_z),\n\n m31 = sin(-theta_y),\n m32 = -sin(theta_x)*cos(-theta_y),\n m33 = cos(theta_x)*cos(-theta_y);\n\n R(0, 0) = m11, R(0, 2) = m12, R(0, 4) = m13;\n R(2, 0) = m21, R(2, 2) = m22, R(2, 4) = m23;\n R(4, 0) = m31, R(4, 2) = m32, R(4, 4) = m33;\n\n R(1, 1) = m11, R(1, 3) = m12, R(1, 5) = m13;\n R(3, 1) = m21, R(3, 3) = m22, R(3, 5) = m23;\n R(5, 1) = m31, R(5, 3) = m32, R(5, 5) = m33;\n\n T(0, 6) = -dx, T(2, 6) = -dy;\n\n R = prod(R, T);\n}\n\n\nvoid GetQuadMatrix(const double L, const double K, const unsigned ind, typename MomentElementBase::value_t &M)\n{\n // 2D quadrupole transport matrix.\n double sqrtK,\n psi,\n cs,\n sn;\n\n if (K > 0e0) {\n // Focusing.\n sqrtK = sqrt(K);\n psi = sqrtK*L;\n cs = ::cos(psi);\n sn = ::sin(psi);\n\n M(ind, ind) = M(ind+1, ind+1) = cs;\n if (sqrtK != 0e0)\n M(ind, ind+1) = sn/sqrtK;\n else\n M(ind, ind+1) = L;\n if (sqrtK != 0e0)\n M(ind+1, ind) = -sqrtK*sn;\n else\n M(ind+1, ind) = 0e0;\n } else {\n // Defocusing.\n sqrtK = sqrt(-K);\n psi = sqrtK*L;\n cs = ::cosh(psi);\n sn = ::sinh(psi);\n\n M(ind, ind) = M(ind+1, ind+1) = cs;\n if (sqrtK != 0e0)\n M(ind, ind+1) = sn/sqrtK;\n else\n M(ind, ind+1) = L;\n if (sqrtK != 0e0)\n M(ind+1, ind) = sqrtK*sn;\n else\n M(ind+1, ind) = 0e0;\n }\n}\n\nvoid GetSextMatrix(const double L, const double K3, double Dx, double Dy,\n const double D2x, const double D2y, const double D2xy, const bool thinlens, const bool dstkick, typename MomentElementBase::value_t &M)\n{\n typedef typename MomentElementBase::state_t state_t;\n // 2D sextupole transport matrix.\n double sqrtK, psi, cs, sn, ch, sh,\n dr = sqrt(sqr(Dx)+sqr(Dx));\n\n if (thinlens) {\n\n //thin-lens (drift-kick-drift) model\n\n MomentState::matrix_t T = boost::numeric::ublas::identity_matrix(state_t::maxsize);\n MomentState::matrix_t P = boost::numeric::ublas::identity_matrix(state_t::maxsize);\n MomentState::matrix_t scratch;\n\n T(state_t::PS_X, state_t::PS_PX) = L/2e0;\n T(state_t::PS_Y, state_t::PS_PY) = L/2e0;\n\n P(state_t::PS_PX, state_t::PS_X) = -K3*L*Dx;\n P(state_t::PS_PX, state_t::PS_Y) = K3*L*Dy;\n\n P(state_t::PS_PY, state_t::PS_X) = K3*L*Dy;\n P(state_t::PS_PY, state_t::PS_Y) = K3*L*Dx;\n\n scratch = prod(P,T);\n M = prod(T,scratch);\n\n } else {\n\n //thick-lens model\n\n sqrtK = sqrt(fabs(K3)*dr);\n psi = sqrtK*L;\n\n // Focusing or Defocusing switch\n Dx *= copysign(1e0,K3);\n Dy *= copysign(1e0,K3);\n\n cs = ::cos(psi);\n sn = ::sin(psi);\n ch = ::cosh(psi);\n sh = ::sinh(psi);\n\n\n if (sqrtK != 0e0) {\n M(state_t::PS_X, state_t::PS_X) = M(state_t::PS_PX, state_t::PS_PX) = ((dr+Dx)*cs+(dr-Dx)*ch)/(2e0*dr);\n M(state_t::PS_X, state_t::PS_PX) = ((dr+Dx)*sn+(dr-Dx)*sh)/(2e0*sqrtK*dr);\n M(state_t::PS_X, state_t::PS_Y) = M(state_t::PS_PX, state_t::PS_PY) =\n M(state_t::PS_Y, state_t::PS_X) = M(state_t::PS_PY, state_t::PS_PX) = Dy*(-cs+ch)/(2e0*dr);\n M(state_t::PS_X, state_t::PS_PY) = Dy*(-sn+sh)/(2e0*sqrtK*dr);\n\n M(state_t::PS_PX, state_t::PS_X) = sqrtK*(-(dr+Dx)*sn+(dr-Dx)*sh)/(2e0*dr);\n M(state_t::PS_PX, state_t::PS_Y) = M(state_t::PS_PY, state_t::PS_X) = Dy*sqrtK*(sn+sh)/(2e0*dr);\n\n M(state_t::PS_Y, state_t::PS_PX) = Dy*(-sn+sh)/(2e0*sqrtK*dr);\n M(state_t::PS_Y, state_t::PS_Y) = M(state_t::PS_PY, state_t::PS_PY) = ((dr-Dx)*cs+(dr+Dx)*ch)/(2e0*dr);\n M(state_t::PS_Y, state_t::PS_PY) = ((dr-Dx)*sn+(dr+Dx)*sh)/(2e0*sqrtK*dr);\n\n M(state_t::PS_PY, state_t::PS_Y) = sqrtK*(-(dr-Dx)*sn+(dr+Dx)*sh)/(2e0*dr);\n\n } else {\n M(state_t::PS_X, state_t::PS_PX) = L;\n M(state_t::PS_Y, state_t::PS_PY) = L;\n }\n\n } // option\n if (dstkick){\n M(state_t::PS_PX, 6) = -K3*L*(D2x-D2y);\n M(state_t::PS_PY, 6) = 2e0*K3*L*D2xy;\n }\n}\n\nvoid GetEdgeMatrix(const double rho, const double phi, typename MomentElementBase::value_t &M)\n{\n typedef typename MomentElementBase::state_t state_t;\n\n M = boost::numeric::ublas::identity_matrix(state_t::maxsize);\n\n M(state_t::PS_PX, state_t::PS_X) = tan(phi)/rho;\n M(state_t::PS_PY, state_t::PS_Y) = -tan(phi)/rho;\n}\n\n\nvoid GetEEdgeMatrix(const double fringe_x, const double fringe_y, const double kappa, typename MomentElementBase::value_t &M)\n{\n // Edge focusing for electrostatic dipole.\n typedef typename MomentElementBase::state_t state_t;\n\n M = boost::numeric::ublas::identity_matrix(state_t::maxsize);\n\n M(state_t::PS_PX, state_t::PS_X) = fringe_x;\n M(state_t::PS_PX, state_t::PS_PX) = sqrt(1e0+kappa);\n M(state_t::PS_PY, state_t::PS_Y) = fringe_y;\n M(state_t::PS_PS, state_t::PS_PS) = 1e0+kappa;\n}\n\n\nvoid GetSBendMatrix(const double L, const double phi, const double phi1, const double phi2, const double K,\n const double IonEs, const double ref_gamma, const double qmrel,\n const double dip_beta, const double dip_gamma, const double d, const double dip_IonK, typename MomentElementBase::value_t &M)\n{\n typedef typename MomentElementBase::state_t state_t;\n\n MomentState::matrix_t edge1, edge2, R;\n\n double rho = L/phi,\n Kx = K + 1e0/sqr(rho),\n Ky = -K,\n dx = 0e0,\n sx = 0e0;\n\n // Horizontal plane.\n GetQuadMatrix(L, Kx, (unsigned)state_t::PS_X, M);\n // Vertical plane.\n GetQuadMatrix(L, Ky, (unsigned)state_t::PS_Y, M);\n\n // Include dispersion.\n if (Kx == 0e0) {\n dx = sqr(L)/(2e0*rho);\n sx = L/rho;\n } else if (Kx > 0e0) {\n dx = (1e0-cos(sqrt(Kx)*L))/(rho*Kx);\n sx = sin(sqrt(Kx)*L)/(rho*sqrt(Kx));\n } else {\n dx = (1e0-cosh(sqrt(-Kx)*L))/(rho*Kx);\n sx = sin(sqrt(-Kx)*L)/(rho*sqrt(-Kx));\n }\n\n M(state_t::PS_X, state_t::PS_PS) = dx/(sqr(dip_beta)*dip_gamma*IonEs/MeVtoeV);\n M(state_t::PS_PX, state_t::PS_PS) = sx/(sqr(dip_beta)*dip_gamma*IonEs/MeVtoeV);\n\n M(state_t::PS_S, state_t::PS_X) = sx*dip_IonK;\n M(state_t::PS_S, state_t::PS_PX) = dx*dip_IonK;\n // Low beta approximation.\n M(state_t::PS_S, state_t::PS_PS) =\n ((L/rho-sx)/(Kx*rho)-L/sqr(ref_gamma))*dip_IonK\n /(sqr(dip_beta)*dip_gamma*IonEs/MeVtoeV);\n\n // Add dipole terms.\n M(state_t::PS_S, 6) = ((L/rho-sx)/(Kx*rho)*d-L/sqr(ref_gamma)*(d+qmrel))*dip_IonK;\n M(state_t::PS_X, 6) = dx*d;\n M(state_t::PS_PX, 6) = sx*d;\n\n // Edge focusing.\n GetEdgeMatrix(rho, phi1, edge1);\n GetEdgeMatrix(rho, phi2, edge2);\n\n M = prod(M, edge1);\n M = prod(edge2, M);\n\n // Longitudinal plane.\n // For total path length.\n // M(state_t::PS_S, state_t::PS_S) = L;\n}\n\n\nvoid GetSolMatrix(const double L, const double K, typename MomentElementBase::value_t &M)\n{\n typedef typename MomentElementBase::state_t state_t;\n\n double C = ::cos(K*L),\n S = ::sin(K*L);\n\n M(state_t::PS_X, state_t::PS_X)\n = M(state_t::PS_PX, state_t::PS_PX)\n = M(state_t::PS_Y, state_t::PS_Y)\n = M(state_t::PS_PY, state_t::PS_PY)\n = sqr(C);\n\n if (K != 0e0)\n M(state_t::PS_X, state_t::PS_PX) = S*C/K;\n else\n M(state_t::PS_X, state_t::PS_PX) = L;\n M(state_t::PS_X, state_t::PS_Y) = S*C;\n if (K != 0e0)\n M(state_t::PS_X, state_t::PS_PY) = sqr(S)/K;\n else\n M(state_t::PS_X, state_t::PS_PY) = 0e0;\n\n M(state_t::PS_PX, state_t::PS_X) = -K*S*C;\n M(state_t::PS_PX, state_t::PS_Y) = -K*sqr(S);\n M(state_t::PS_PX, state_t::PS_PY) = S*C;\n\n M(state_t::PS_Y, state_t::PS_X) = -S*C;\n if (K != 0e0)\n M(state_t::PS_Y, state_t::PS_PX) = -sqr(S)/K;\n else\n M(state_t::PS_Y, state_t::PS_PX) = 0e0;\n if (K != 0e0)\n M(state_t::PS_Y, state_t::PS_PY) = S*C/K;\n else\n M(state_t::PS_Y, state_t::PS_PY) = L;\n\n M(state_t::PS_PY, state_t::PS_X) = K*sqr(S);\n M(state_t::PS_PY, state_t::PS_PX) = -S*C;\n M(state_t::PS_PY, state_t::PS_Y) = -K*S*C;\n\n // Longitudinal plane.\n // For total path length.\n// M(state_t::PS_S, state_t::PS_S) = L;\n}\n\n\nvoid GetEBendMatrix(const double L, const double phi, const double fringe_x, const double fringe_y, const double kappa,\n const double Kx, const double Ky, const double IonEs, const double real_gamma, const double eta0, const double h,\n const double delta_K, const double delta_KZ, const double SampleIonK, typename MomentElementBase::value_t &M)\n{\n typedef typename MomentElementBase::state_t state_t;\n\n MomentState::matrix_t edge;\n\n double rho = L/phi,\n scl = (real_gamma - 1e0)*IonEs/MeVtoeV,\n dx = 0e0,\n sx = 0e0;\n\n // Horizontal plane.\n GetQuadMatrix(L, Kx, (unsigned)state_t::PS_X, M);\n // Vertical plane.\n GetQuadMatrix(L, Ky, (unsigned)state_t::PS_Y, M);\n\n // Include dispersion.\n if (Kx == 0e0) {\n dx = 0e0;\n sx = 0e0;\n } else if (Kx > 0e0) {\n dx = (1e0-cos(sqrt(Kx)*L))/(rho*Kx);\n sx = sin(sqrt(Kx)*L)/sqrt(Kx);\n } else {\n dx = (1e0-cosh(sqrt(-Kx)*L))/(rho*Kx);\n sx = sin(sqrt(Kx)*L)/sqrt(Kx);\n }\n\n double Nk = (sqr(1e0+2e0*eta0)+h)/(2e0*(1e0+eta0)*(1e0+2e0*eta0)),\n Nt = 1e0 + h/sqr(1e0+2e0*eta0),\n CorT = -real_gamma/(1e0+real_gamma),\n tx = sx/rho*Nt*CorT,\n txp = dx*Nt*CorT,\n tzp = (-L/(2e0*(1e0+eta0)*(1e0+2e0*eta0))+((L-sx)/Kx/sqr(rho))*Nk*Nt)*CorT;\n\n M(state_t::PS_X, state_t::PS_PS) = dx*Nk/scl;\n M(state_t::PS_PX, state_t::PS_PS) = sx/rho*Nk/scl;\n\n M(state_t::PS_S, state_t::PS_X) = -tx*SampleIonK;\n M(state_t::PS_S, state_t::PS_PX) = -txp*SampleIonK;\n // Low beta approximation.\n M(state_t::PS_S, state_t::PS_PS) = -tzp*SampleIonK/scl;\n\n // Add dipole terms.\n double Nkz = (1e0+2e0*eta0-h)/(2e0*(1e0+eta0)*(1e0+2e0*eta0));\n\n M(state_t::PS_X, 6) = dx*(Nk*delta_K+Nkz*delta_KZ);\n M(state_t::PS_PX, 6) = sx/rho*(Nk*delta_K+Nkz*delta_KZ);\n\n // Edge focusing.\n GetEEdgeMatrix(fringe_x, fringe_y ,kappa, edge);\n\n M = prod(M, edge);\n M = prod(edge, M);\n\n // Longitudinal plane.\n // For total path length.\n // M(state_t::PS_S, state_t::PS_S) = L;\n}\n\nvoid GetCurveData(const Config &c, const unsigned ncurve, std::vector &Scales,\n std::vector > &Curves)\n{\n boost::shared_ptr conf;\n\n std::string filename;\n std::vector range;\n bool checker = c.tryGet(\"CurveFile\", filename),\n rngchecker = c.tryGet >(\"use_range\", range);\n\n if (checker){\n std::string CurveFile = c.get(\"Eng_Data_Dir\", defpath);\n CurveFile += \"/\" + filename;\n std::string key(SB()<(n));\n std::vector cv;\n bool cvchecker;\n if (checker){\n cvchecker = conf->tryGet >(\"curve\"+num, cv);\n } else {\n cvchecker = c.tryGet >(\"curve\"+num, cv);\n }\n if (!cvchecker)throw std::runtime_error(SB()<<\"'curve\" << num << \"' is missing in lattice file.\\n\");\n\n if (rngchecker){\n unsigned start, end;\n if (range.size() != 2)\n throw std::runtime_error(SB()<<\"Size of 'use_range' must be 2.\\n\");\n start = static_cast(range[0]);\n end = static_cast(range[1]);\n\n if (start > cv.size() or end > cv.size())\n throw std::runtime_error(SB()<<\"'use_range' is out of curve size.\\n\");\n\n std::vector part(cv.begin()+start, cv.begin()+end);\n Curves.push_back(part);\n } else {\n Curves.push_back(cv);\n }\n\n if (n != 0 and prev_size != cv.size())\n throw std::runtime_error(SB()<<\"Size of 'curve\" << n << \"' (\" << cv.size() <<\") and 'curve\" << n-1 <<\n \"' (\" << prev_size <<\") are inconsistent. All curves must have the same size.\\n\");\n prev_size = cv.size();\n\n Scales.push_back(c.get(\"scl_fac\"+num, 0.0));\n }\n}", "meta": {"hexsha": "6f5387efb3609c1c7a371c048fdddc89fe21a73b", "size": 15365, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/moment_sup.cpp", "max_stars_repo_name": "PierreSchnizer/FLAME", "max_stars_repo_head_hexsha": "44f42c6175be536236058452bec71c87a138710e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10.0, "max_stars_repo_stars_event_min_datetime": "2016-04-04T20:14:25.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-17T22:37:49.000Z", "max_issues_repo_path": "src/moment_sup.cpp", "max_issues_repo_name": "PierreSchnizer/FLAME", "max_issues_repo_head_hexsha": "44f42c6175be536236058452bec71c87a138710e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 24.0, "max_issues_repo_issues_event_min_datetime": "2016-04-07T19:23:31.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-21T14:31:14.000Z", "max_forks_repo_path": "src/moment_sup.cpp", "max_forks_repo_name": "PierreSchnizer/FLAME", "max_forks_repo_head_hexsha": "44f42c6175be536236058452bec71c87a138710e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13.0, "max_forks_repo_forks_event_min_datetime": "2016-04-13T13:26:36.000Z", "max_forks_repo_forks_event_max_datetime": "2019-12-20T01:55:24.000Z", "avg_line_length": 33.8436123348, "max_line_length": 154, "alphanum_fraction": 0.5640741946, "num_tokens": 5078, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767874818408, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.5429654671581736}} {"text": "#ifndef TRIUMF_BNMR_SLR_GAUSS_DIST_EXP_HPP\n#define TRIUMF_BNMR_SLR_GAUSS_DIST_EXP_HPP\n\n#include \n#include \n#include \n#include \n#include \n\n// TRIUMF: Canada's particle accelerator centre\nnamespace triumf {\n\n// β-detected nuclear magnetic resonance (β-NMR)\nnamespace bnmr {\n\n// spin-lattice relaxation (SLR)\nnamespace slr {\n\n/// pulsed Gaussian distribution of exponentials integral\n/// (from 0 to time_p <= time)\ntemplate \nT pulsed_gauss_dist_exp_integral(T time, T time_p, T nuclear_lifetime,\n T slr_rate, T sigma) {\n // imaginary number i\n std::complex i(0.0, -1.0);\n // common exponential factor\n T expo =\n std::exp(-slr_rate / nuclear_lifetime / sigma / sigma -\n 1.0 / 2.0 / sigma / sigma / nuclear_lifetime / nuclear_lifetime -\n slr_rate * slr_rate / 2.0 / sigma / sigma);\n std::cout << \"expo = \" << expo << \"\\n\";\n // argument for the first error function\n std::complex erf_arg1 =\n (((boost::math::constants::root_two() * i * time -\n boost::math::constants::root_two() * i * time_p) *\n sigma * sigma -\n boost::math::constants::root_two() * i * slr_rate) *\n nuclear_lifetime -\n boost::math::constants::root_two() * i) /\n (2.0 * sigma * nuclear_lifetime);\n std::cout << \"erf_arg1 = \" << erf_arg1 << \"\\n\";\n // argument for the second error function\n std::complex erf_arg2 =\n ((i * time * sigma * sigma - i * slr_rate) * nuclear_lifetime - i) /\n (boost::math::constants::root_two() * sigma * nuclear_lifetime);\n std::cout << \"erf_arg2 = \" << erf_arg2 << \"\\n\";\n // evaluate the result\n std::complex result = boost::math::constants::root_pi() * i * expo *\n (triumf::math::faddeeva::erf(erf_arg1) -\n triumf::math::faddeeva::erf(erf_arg2)) /\n (boost::math::constants::root_two() * sigma);\n std::cout << \"result = \" << result << \"\\n\";\n // return only the real part\n return result.real();\n}\n\n/// pulsed Gaussian distribution of exponentials\ntemplate \nT pulsed_gauss_dist_exp(T time, T nuclear_lifetime, T pulse_length, T asymmetry,\n T slr_rate, T sigma) {\n if (time == 0.0) {\n return asymmetry;\n } else if (time > 0.0 and time <= pulse_length) {\n return asymmetry *\n pulsed_gauss_dist_exp_integral(time, time, nuclear_lifetime,\n slr_rate, sigma) /\n normalization(time, nuclear_lifetime);\n } else if (time > pulse_length) {\n return (asymmetry *\n pulsed_gauss_dist_exp_integral(pulse_length, pulse_length,\n nuclear_lifetime, slr_rate, sigma) /\n normalization(pulse_length, nuclear_lifetime)) /\n std::exp(-(time - pulse_length) / nuclear_lifetime);\n } else {\n return 0.0;\n }\n}\n\n/// pulsed Gaussian distribution of exponentials (ROOT)\ntemplate \nT pulsed_gauss_dist_exp(const T *x, const T *par) {\n return pulsed_gauss_dist_exp(*x, par[0], par[1], par[2], par[3], par[4]);\n}\n\n} // namespace slr\n\n} // namespace bnmr\n\n} // namespace triumf\n\n#endif // TRIUMF_BNMR_SLR_GAUSS_DIST_EXP_HPP\n", "meta": {"hexsha": "58b1aa5b429fb99e3baaa1810487112931a1ad46", "size": 3378, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "tmp/gauss_dist_exp.hpp", "max_stars_repo_name": "rmlmcfadden/triumfpp", "max_stars_repo_head_hexsha": "da3911cdf1b0ee4600d27999d484f9a1bdb89b91", "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": "tmp/gauss_dist_exp.hpp", "max_issues_repo_name": "rmlmcfadden/triumfpp", "max_issues_repo_head_hexsha": "da3911cdf1b0ee4600d27999d484f9a1bdb89b91", "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": "tmp/gauss_dist_exp.hpp", "max_forks_repo_name": "rmlmcfadden/triumfpp", "max_forks_repo_head_hexsha": "da3911cdf1b0ee4600d27999d484f9a1bdb89b91", "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.7173913043, "max_line_length": 80, "alphanum_fraction": 0.6163410302, "num_tokens": 901, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505299595163, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.5429607172802771}} {"text": "#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nstatic int n_vars = 3;\n\ntemplate\nEigen::MatrixXd ic(const F &f,\n const Grid &grid,\n const PolynomialBasis &poly_basis,\n const DGHandler &dg_handler)\n{\n int n_coeff = 1 + poly_basis.get_degree();\n Eigen::MatrixXd u0 = Eigen::MatrixXd::Zero (n_vars*n_coeff,\n grid.n_cells);\n\n auto [quad_points, quad_weights] = dg_handler.get_quadrature();\n int n_quad = static_cast(quad_points.size());\n\n /// eval basis and its derivate for all quadrature points\n Eigen::MatrixXd basis(n_coeff, n_quad);\n for (int k = 0; k < n_quad; k++) {\n basis.col(k) = poly_basis(quad_points(k));\n }\n\n // L2-projection\n for (int j = 0; j < grid.n_cells; ++j)\n {\n for (int k = 0; k < quad_points.size(); k++)\n {\n auto fVal = f(cell_point(grid, j, quad_points(k)));\n for (int i = 0; i < n_vars; i++) {\n u0.col(j).segment(i*n_coeff, n_coeff)\n += quad_weights(k)*fVal(i)*basis.col(k);\n }\n }\n }\n\n return u0*grid.dx;\n}\n\nTimeLoop make_dg(const nlohmann::json &config,\n const Grid &grid,\n const PolynomialBasis &poly_basis,\n const DGHandler &dg_handler,\n std::shared_ptr &model)\n{\n double t_end = config[\"t_end\"];\n double cfl_number = config[\"cfl_number\"];\n\n auto n_ghost = grid.n_ghost;\n auto n_cells = grid.n_cells;\n\n auto n_vars = model->get_nvars();\n int n_coeff = 1 + poly_basis.get_degree();\n\n auto simulation_time = std::make_shared(t_end);\n auto boundary_condition\n = make_boundary_condition(n_ghost,\n config[\"boundary_condition\"]);\n auto dg_rate_of_change\n = make_dg_rate_of_change(config, grid, model,\n poly_basis, dg_handler,\n simulation_time);\n auto dg_limiting\n = make_dg_limiting(config, grid, dg_handler);\n auto time_integrator = make_runge_kutta(config,\n dg_rate_of_change,\n boundary_condition,\n dg_limiting,\n n_vars*n_coeff, n_cells);\n auto cfl_condition\n = make_cfl_condition(grid, model, dg_handler, cfl_number);\n auto snapshot_writer = std::make_shared>\n (grid, model, dg_handler, simulation_time,\n std::string(config[\"output_dir\"]),\n std::string(config[\"output_file\"]));\n\n return TimeLoop(simulation_time, time_integrator,\n cfl_condition, snapshot_writer);\n}\n\nvoid sod_shock_tube_test(const nlohmann::json &config)\n{\n int deg = int(config[\"degree\"]);\n\n double gamma = 7./5.;\n std::shared_ptr model = std::make_shared();\n auto model_euler = dynamic_cast(model.get());\n model_euler->set_gamma(gamma);\n\n auto fn = [gamma](double x) {\n Eigen::VectorXd u(n_vars);\n if (x <= 0.5) { // left state\n u(0) = 1;\n u(1) = 0;\n u(2) = 1/(gamma-1);\n } else { // right state\n u(0) = 0.125;\n u(1) = 0;\n u(2) = 0.1/(gamma-1);\n }\n return u;\n };\n\n int n_ghost = config[\"n_ghost\"];\n int n_cells = int(config[\"n_interior_cells\"]) + n_ghost * 2;\n\n auto grid = Grid({0.0, 1.0}, n_cells, n_ghost);\n auto poly_basis = PolynomialBasis(deg, 1./sqrt(grid.dx));\n auto dg_handler = DGHandler(model, poly_basis);\n auto u0 = ic(fn, grid, poly_basis, dg_handler);\n\n auto dg = make_dg(config, grid, poly_basis, dg_handler, model);\n dg(u0);\n}\n\nint main(int argc, char* const argv[])\n{\n nlohmann::json config;\n std::string fileName;\n if (argc == 2) {\n fileName = argv[1];\n } else {\n fileName = \"../config.json\";\n }\n config = get_config (fileName);\n\n std::string ic_key = config[\"initial_conditions\"];\n if (ic_key == \"sod_shock_tube\") {\n sod_shock_tube_test(config);\n }\n\n return 0;\n}\n", "meta": {"hexsha": "4fdce2b85caee9eef9a04a293424ffea1a23db54", "size": 4556, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "series2_handout/hyp_sys_1d/src/dg_euler.cpp", "max_stars_repo_name": "BeatHubmann/19H-AdvNCSE", "max_stars_repo_head_hexsha": "3979f768da933de82bd6ab29bbf31ea9fc31e501", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-01-05T22:38:47.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-05T22:38:47.000Z", "max_issues_repo_path": "series2_handout/hyp_sys_1d/src/dg_euler.cpp", "max_issues_repo_name": "BeatHubmann/19H-AdvNCSE", "max_issues_repo_head_hexsha": "3979f768da933de82bd6ab29bbf31ea9fc31e501", "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": "series2_handout/hyp_sys_1d/src/dg_euler.cpp", "max_forks_repo_name": "BeatHubmann/19H-AdvNCSE", "max_forks_repo_head_hexsha": "3979f768da933de82bd6ab29bbf31ea9fc31e501", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-12-08T20:43:27.000Z", "max_forks_repo_forks_event_max_datetime": "2019-12-08T20:43:27.000Z", "avg_line_length": 31.6388888889, "max_line_length": 70, "alphanum_fraction": 0.5614574188, "num_tokens": 1118, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8670357598021707, "lm_q2_score": 0.6261241772283034, "lm_q1q2_score": 0.542872051733651}} {"text": "/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2017 Hidekazu Ikeno\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n#include \n#include \n\n#include \"constants.hpp\"\n#include \"legendre.hpp\"\n#include \"tanh_sinh_rule.hpp\"\n\n#include \n#include \n#include \n\n#include \n\ntemplate \nconstexpr T pi()\n{\n return T(\n 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679);\n}\n///\n/// ### BesselKernel\n///\n/// Compute the multi-exponential function that approximates the spherical\n/// Bessel function of the first kind such that\n///\n/// \\f[\n/// \\|j_{n}(x)-sum_{m=1}^{M} w_{m} e^{-a_{m} x} \\| < \\epsilon\n/// \\f]\n///\n/// for integer `n` on real axis `(x)`, where \\f$ \\epsilon \\f$ is an arbitrary\n/// small positive number.\n///\n/// The multi-exponential function is obtained by discretize the integral\n/// representation of spherical Bessel function\n///\n/// \\f[\n/// j_{n}(x)=\\int_{-1}^{1} e^{ixt} P_n(t) dt\n/// \\f]\n///\n/// The integrand in above expression is highly oscillating when `x` becomes\n/// large, thus the direct application of some quadrature rule is inefficient.\n/// To avoid this problem, we extend the integral on the complex plane and\n/// select the contour as the steepest descent paths, as follows.\n///\n/// \\f{eqnarray*}{\n/// j_{n}(x) &=& I_1 + I_2 + (-1)^{n}(I_1^{\\ast} + I_{2}^{\\ast}), \\\\\n/// I_{1} &=& \\frac{(-i)^{n+1}}{2} \\int_{0}^{R} e^{-(y-i)x} P_{n}(1+iy) dy, \\\\\n/// I_{2} &=& \\frac{(-i)^{n}}{2} \\int_{-1}^{0} e^{-(R-ix)y} P_{n}(y+iR) dy, \\\\\n/// \\f}\n///\n/// The integrals \\f$ I_1 \\f$ and \\f$ I_2 \\f$ are discretized using appropriate\n/// quadrature rule, then the balanced truncation method is applied to reduce\n/// the number of terms.\n///\ntemplate \nclass BesselKernel\n{\npublic:\n typename VecY, using Index = Eigen::Index;\n using Real = T;\n using Complex = std::complex;\n\n using ExponentialSumType = mxpfit::ExponentialSum;\n using ExponentsArray = typename ExponentialSumType::ExponentsArray;\n using WeightsArray = typename ExponentialSumType::WeightsArray;\n\n static ExponentialSumType compute(Index order, Real threshold);\n};\n\ntemplate \ntypename BesselKernel::ExponentialSumType\nBesselKernel::compute(Index n, Real threshold)\n{\n using Eigen::numext::conj;\n using Eigen::numext::exp;\n using Eigen::numext::log;\n using Eigen::numext::cos;\n using Eigen::numext::acos;\n using Eigen::numext::sin;\n using Eigen::numext::sqrt;\n // ----- Constants\n constexpr const auto zero = Real();\n constexpr const auto one = Real(1);\n constexpr const auto half = Real(0.5);\n constexpr const auto eps = std::numeric_limits::epsilon();\n // (-i)^n\n constexpr const Complex pow_i[4] = {Complex(one, zero), Complex(zero, -one),\n Complex(-one, zero),\n Complex(zero, one)};\n\n //----- adjustable parameters\n const auto R = Real(3) / std::max(Index(1), n);\n\n const auto n_quad1 = Index(500);\n const auto tiny1 = sqrt(eps) * threshold / n_quad1;\n\n const auto n_quad2 = Index(150 + 2 * n);\n const auto tiny2 = eps / n_quad2;\n //---------------------------\n\n //\n // Find R_shift such that j_n(R_shift) < eps\n //\n Real R_shift = Real();\n if (n > Index())\n {\n Real log_dfact = Real(); // log[2^n * n!]\n for (Index k = 1; k <= n; ++k)\n {\n log_dfact += log(Real(2 * k));\n }\n const auto thresh = std::min(threshold, sqrt(eps));\n R_shift = exp((log_dfact + log(thresh)) / Real(n));\n if (R_shift < Real(0.1))\n {\n R_shift = Real();\n }\n }\n\n ExponentialSumType es_merged(n_quad1 + n_quad2);\n\n //\n // Discretization of integral I_2 on the path `z = x + iR` for `0<=x<=1`\n //\n quad::DESinhTanhRule rule2(n_quad2, tiny2);\n\n // std::cout << \"*** quadrature rule\\n\";\n // Real xsum = Real();\n // for (Index k = 0; k < n_quad2; ++k)\n // {\n // xsum += rule2.adjacentDifference(k);\n // std::cout << rule2.x(k) << '\\t' << rule2.adjacentDifference(k) <<\n // '\\t'\n // << xsum << '\\t' << std::abs(rule2.x(k) - xsum) << '\\n';\n // }\n\n for (Index k = 0; k < n_quad2; ++k)\n {\n const auto xk = half * rule2.distanceFromLower(k); // node\n const auto uk = half * rule2.distanceFromUpper(k); // 1 - x\n const auto wk = half * rule2.w(k); // weight\n\n const auto ak = Complex(R, -xk);\n const auto pk = wk * exp(ak * R_shift) *\n cos(Real(n) * acos(Complex(xk, R))) /\n sqrt(Complex(one + xk, R) * Complex(uk, -R));\n\n es_merged.exponent(k) = ak;\n es_merged.weight(k) = pk;\n }\n\n //\n // Discretization of integral I_1 on the path `1 + i y` for\n // `0 <= y <= R`\n //\n quad::DESinhTanhRule rule1(n_quad1, tiny1);\n\n const auto R_half = R / 2;\n Index ipos = n_quad2;\n for (Index k = n_quad1; k > 0; --k)\n {\n const auto yk = R_half * rule1.distanceFromLower(k - 1); // node\n const auto wk = R_half * rule1.w(k - 1); // weight\n const auto ak = Complex(yk, -one);\n const auto pk = Complex(zero, -wk) * exp(ak * R_shift) *\n cos(Real(n) * acos(Complex(one, yk))) /\n (sqrt(yk * Complex(yk, Real(-2))));\n\n es_merged.exponent(ipos) = ak;\n es_merged.weight(ipos) = pk;\n ++ipos;\n }\n\n // Remove terms with same exponents\n es_merged.uniqueExponents(Real());\n\n //\n // Truncation for I_1 and I_2 separately\n //\n // mxpfit::BalancedTruncation trunc1;\n // es1 = trunc1.compute(es1, threshold * eps);\n\n // mxpfit::BalancedTruncation trunc2;\n // es2 = trunc2.compute(es2, threshold);\n\n //\n // Truncation for I_1 and I_2 simultaneously\n //\n mxpfit::BalancedTruncation trunc1;\n es_merged = trunc1.compute(es_merged, threshold * eps * eps);\n\n // mxpfit::AAKReduction reduction;\n // reduction.setThreshold(threshold);\n // reduction.compute(es_merged);\n\n ExponentialSumType es_result(2 * es_merged.size());\n const auto pre1 = pow_i[n % 4] / pi(); // (-i)^n / pi\n const auto pre2 = (n & 1) ? -pre1 : pre1;\n\n for (Index i = 0; i < es_merged.size(); ++i)\n {\n const auto ai = es_merged.exponent(i);\n es_result.exponent(2 * i + 0) = ai;\n es_result.exponent(2 * i + 1) = conj(ai);\n\n const auto wi = es_merged.weight(i) * exp(-ai * R_shift);\n es_result.weight(2 * i + 0) = pre1 * wi;\n es_result.weight(2 * i + 1) = pre2 * conj(wi);\n }\n\n return es_result;\n}\n\n// template \n// typename BesselKernel::ExponentialSumType\n// BesselKernel::compute(Index n, Real threshold)\n// {\n// using Eigen::numext::conj;\n// using Eigen::numext::exp;\n// using Eigen::numext::log;\n// using Eigen::numext::cos;\n// using Eigen::numext::acos;\n// using Eigen::numext::sin;\n// using Eigen::numext::sqrt;\n// // ----- Constants\n// constexpr const auto zero = Real();\n// constexpr const auto one = Real(1);\n// constexpr const auto half = Real(0.5);\n// constexpr const auto eps = std::numeric_limits::epsilon();\n// // (-i)^n\n// constexpr const Complex pow_i[4] = {Complex(one, zero), Complex(zero,\n// -one),\n// Complex(-one, zero),\n// Complex(zero, one)};\n\n// //----- adjustable parameters\n// const auto R = Real(3) / std::max(Index(1), n);\n// const auto n_quad1 = Index(500);\n// // const auto tiny1 = eps * eps;\n// const auto tiny1 = eps * sqrt(eps) / n_quad1;\n\n// const auto n_quad2 = Index(150 + 2 * n);\n// const auto tiny2 = eps / n_quad2;\n// //---------------------------\n\n// //\n// // Find R_shift such that j_n(R_shift) < eps\n// //\n// Real R_shift = Real();\n// if (n > Index())\n// {\n// Real log_dfact = Real(); // log[2^n * n!]\n// for (Index k = 1; k <= n; ++k)\n// {\n// log_dfact += log(Real(2 * k));\n// }\n// const auto thresh = std::min(threshold, sqrt(eps));\n// R_shift = exp((log_dfact + log(thresh)) / Real(n));\n// if (R_shift < Real(0.1))\n// {\n// R_shift = Real();\n// }\n// }\n\n// //\n// // Discretization of integral I_1 on the path `-1 + i y` for\n// // `0 <= y <= R`\n// //\n// quad::DESinhTanhRule rule1(n_quad1, tiny1);\n// ExponentialSumType es1(n_quad1);\n\n// const auto R_half = R / 2;\n// for (Index k = 0; k < n_quad1; ++k)\n// {\n// const auto yk = R_half * rule1.distanceFromLower(k); // node\n// const auto wk = R_half * rule1.w(k); // weight\n// const auto ak = Complex(yk, one);\n// const auto pk = Complex(zero, wk) * exp(ak * R_shift) *\n// cos(Real(n) * acos(Complex(-one, yk))) /\n// (sqrt(yk * Complex(yk, Real(2))));\n\n// es1.exponent(k) = ak;\n// es1.weight(k) = pk;\n// }\n\n// //\n// // Discretization of integral I_2 on the path `z = x + iR` for `-1<=x<=0`\n// //\n// quad::DESinhTanhRule rule2(n_quad2, tiny2);\n// ExponentialSumType es2(n_quad2);\n\n// for (Index k = 0; k < n_quad2; ++k)\n// {\n// const auto xk = -half * rule2.distanceFromUpper(k); // node\n// const auto lk = half * rule2.distanceFromLower(k); // x + 1\n// const auto wk = half * rule2.w(k); // weight\n\n// const auto ak = Complex(R, -xk);\n// const auto pk = wk * exp(ak * R_shift) *\n// cos(Real(n) * acos(Complex(xk, R))) /\n// sqrt(Complex(lk, R) * Complex(one - xk, -R));\n\n// es2.exponent(k) = ak;\n// es2.weight(k) = pk;\n// }\n// //\n// // Truncation for I_1 and I_2 separately\n// //\n// // mxpfit::BalancedTruncation trunc1;\n// // es1 = trunc1.compute(es1, threshold * eps);\n\n// // mxpfit::BalancedTruncation trunc2;\n// // es2 = trunc2.compute(es2, threshold);\n\n// //\n// // Merge two sums\n// //\n// ExponentialSumType es_merged(es1.size() + es2.size());\n// es_merged.exponents().head(es1.size()) = es1.exponents();\n// es_merged.exponents().tail(es2.size()) = es2.exponents();\n// es_merged.weights().head(es1.size()) = es1.weights();\n// es_merged.weights().tail(es2.size()) = es2.weights();\n\n// //\n// // Truncation for I_1 and I_2 simultaneously\n// //\n// // mxpfit::BalancedTruncation trunc1;\n// // es_merged = trunc1.compute(es_merged, threshold * eps * eps);\n\n// ExponentialSumType es_result(2 * es_merged.size());\n// const auto pre1 = pow_i[n % 4] / pi(); // (-i)^n / pi\n// const auto pre2 = (n & 1) ? -pre1 : pre1;\n\n// for (Index i = 0; i < es_merged.size(); ++i)\n// {\n// const auto ai = es_merged.exponent(i);\n// es_result.exponent(2 * i + 0) = ai;\n// es_result.exponent(2 * i + 1) = conj(ai);\n\n// const auto wi = es_merged.weight(i) * exp(-ai *\n// R_shift); es_result.weight(2 * i + 0) = pre1 * wi; es_result.weight(2\n// * i + 1) = pre2 * conj(wi);\n// }\n\n// return es_result;\n// }\n\n//==============================================================================\n// Main\n//==============================================================================\n\nusing Index = Eigen::Index;\nusing Real = double;\nusing Complex = std::complex;\nusing RealArray = Eigen::Array;\nusing ComplexArray = Eigen::Array;\nusing ExponentialSumType = BesselKernel::ExponentialSumType;\n\nvoid bessel_j_kernel_error(int l, const RealArray& x,\n const ExponentialSumType& ret)\n{\n RealArray exact(x.size());\n RealArray approx(x.size());\n\n for (Index i = 0; i < x.size(); ++i)\n {\n exact(i) = boost::math::cyl_bessel_j(l, x(i));\n approx(i) = std::real(ret(x(i)));\n }\n\n RealArray abserr(Eigen::abs(exact - approx));\n\n for (Index i = 0; i < x.size(); ++i)\n {\n std::cout << std::setw(24) << x(i) << ' ' // point\n << std::setw(24) << exact(i) << ' ' // exact value\n << std::setw(24) << approx(i) << ' ' // approximation\n << std::setw(24) << abserr(i) << '\\n';\n }\n\n Index imax;\n abserr.maxCoeff(&imax);\n\n std::cout << \"\\n abs. error in interval [\" << x(0) << \",\"\n << x(x.size() - 1) << \"]\\n\"\n << \" maximum : \" << abserr(imax) << '\\n'\n << \" averaged: \" << abserr.sum() / x.size() << std::endl;\n}\n\nint main()\n{\n std::cout.precision(15);\n std::cout.setf(std::ios::scientific);\n\n const Real threshold = 1.0e-14;\n const Real eps = Eigen::NumTraits::epsilon();\n const Index lmax = 4;\n const Index N = 2000; // # of sampling points\n\n std::cout\n << \"# Approximation of spherical Bessel function by exponential sum\\n\";\n\n RealArray x = Eigen::exp(RealArray::LinSpaced(N, -20.0, 20.0));\n ExponentialSumType ret;\n for (Index l = 0; l <= lmax; ++l)\n {\n std::cout << \"\\n# --- order \" << l;\n ret = BesselKernel::compute(l, threshold);\n const auto thresh_weight = std::max(eps, threshold) / Real(ret.size());\n ret = mxpfit::removeIf(\n ret, [=](const Complex& /*exponent*/, const Complex& wi) {\n return std::abs(std::real(wi)) < thresh_weight &&\n std::abs(std::imag(wi)) < thresh_weight;\n });\n std::cout << \" (\" << ret.size() << \" terms approximation)\\n\"\n << ret << '\\n';\n\n // std::cout << \" (\" << ret.size() << \" terms approximation)\\n\";\n // std::cout\n // << \"# real(exponent), imag(exponent), real(weight),\n // imag(weight)\\n\";\n // for (Index i = 0; i < ret.size(); ++i)\n // {\n // std::cout << std::setw(24) << std::real(ret.exponent(i)) << '\\t'\n // << std::setw(24) << std::imag(ret.exponent(i)) << '\\t'\n // << std::setw(24) << std::real(ret.weight(i)) << '\\t'\n // << std::setw(24) << std::imag(ret.weight(i)) << '\\n';\n // }\n // std::cout << '\\n' << std::endl;\n\n std::cout << \"\\n# errors in small x\\n\";\n bessel_j_kernel_error(l, x, ret);\n }\n\n return 0;\n}\n", "meta": {"hexsha": "a77a2b5189a9ce2adddc2d704eb2f80d58b3c90b", "size": 16067, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/bessel_j_kernel.cpp", "max_stars_repo_name": "hydeik/mxpfit", "max_stars_repo_head_hexsha": "a18621b191e426f549374cff0af3374861e9f065", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2018-04-25T07:07:50.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T09:13:11.000Z", "max_issues_repo_path": "examples/bessel_j_kernel.cpp", "max_issues_repo_name": "hydeik/mxpfit", "max_issues_repo_head_hexsha": "a18621b191e426f549374cff0af3374861e9f065", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2018-07-04T08:42:03.000Z", "max_issues_repo_issues_event_max_datetime": "2019-08-15T02:57:05.000Z", "max_forks_repo_path": "examples/bessel_j_kernel.cpp", "max_forks_repo_name": "hydeik/mxpfit", "max_forks_repo_head_hexsha": "a18621b191e426f549374cff0af3374861e9f065", "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.852494577, "max_line_length": 112, "alphanum_fraction": 0.5357565196, "num_tokens": 4543, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8670357494949105, "lm_q2_score": 0.6261241772283033, "lm_q1q2_score": 0.5428720452800261}} {"text": "/*\n For more information, please see: http://software.sci.utah.edu\n\n The MIT License\n\n Copyright (c) 2020 Scientific Computing and Imaging Institute,\n University of Utah.\n\n Permission is hereby granted, free of charge, to any person obtaining a\n copy of this software and associated documentation files (the \"Software\"),\n to deal in the Software without restriction, including without limitation\n the rights to use, copy, modify, merge, publish, distribute, sublicense,\n and/or sell copies of the Software, and to permit persons to whom the\n Software is furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included\n in all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n DEALINGS IN THE SOFTWARE.\n\n\t Author: \t\t\t\t\t\t\tJaume Coll-Font, Yesim Serinagaoglu & Alireza Ghodrati\n\t Last Modification:\t\tSeptember 6 2017\n*/\n\n\n#include \n#include \n#include \n#include \n\n// Tikhonov inverse libraries\n#include \n#include \n\n// EIGEN LIBRARY\n#include \n#include \n\n\nusing namespace SCIRun;\nusing namespace SCIRun::Core::Datatypes;\n// using namespace SCIRun::Modules::Inverse;\n// using namespace SCIRun::Dataflow::Networks;\nusing namespace SCIRun::Core::Logging;\nusing namespace SCIRun::Core::Algorithms;\nusing namespace SCIRun::Core::Algorithms::Inverse;\n\n\n\n///////////////////////////////////////////////////////////////////\n/////// prealocate Matrices for inverse compuation\n/// This function precalcualtes the SVD of the forward matrix and prepares singular vectors and values for posterior computations\n///////////////////////////////////////////////////////////////////\nvoid SolveInverseProblemWithTSVD_impl::preAlocateInverseMatrices(const SCIRun::Core::Datatypes::DenseMatrix& forwardMatrix_, const SCIRun::Core::Datatypes::DenseMatrix& measuredData_ , const SCIRun::Core::Datatypes::DenseMatrix& sourceWeighting_, const SCIRun::Core::Datatypes::DenseMatrix& sensorWeighting_, const SCIRun::Core::Datatypes::DenseMatrix& matrixU_, const SCIRun::Core::Datatypes::DenseMatrix& singularValues_, const SCIRun::Core::Datatypes::DenseMatrix& matrixV_)\n{\n\n\t\t// alocate U and V matrices\n\t\t\tsvd_MatrixU = matrixU_;\n\t\t\tsvd_MatrixV = matrixV_;\n\n\t\t// alocate singular values\n\t\t\tif (singularValues_.ncols() == 1 ){\n\t\t\t\tsvd_SingularValues = singularValues_;\n\t\t\t}\n\t\t\telse{\n\t\t\t\tsvd_SingularValues = singularValues_.diagonal();\n\t\t\t}\n\n\t\t// Compute the projection of data y on the left singular vectors\n\t\t\tUy = svd_MatrixU.transpose() * (measuredData_);\n\n\t\t// determine rank\n\t rank = svd_SingularValues.nrows();\n\n}\n\nvoid SolveInverseProblemWithTSVD_impl::preAlocateInverseMatrices(const SCIRun::Core::Datatypes::DenseMatrix& forwardMatrix_, const SCIRun::Core::Datatypes::DenseMatrix& measuredData_ , const SCIRun::Core::Datatypes::DenseMatrix& sourceWeighting_, const SCIRun::Core::Datatypes::DenseMatrix& sensorWeighting_)\n{\n\n\t // Compute the SVD of the forward matrix\n\t Eigen::JacobiSVD SVDdecomposition( forwardMatrix_, Eigen::ComputeFullU | Eigen::ComputeFullV);\n\n\t\t// alocate the left and right singular vectors and the singular values\n\t\t\tsvd_MatrixU = SVDdecomposition.matrixU();\n\t\t\tsvd_MatrixV = SVDdecomposition.matrixV();\n\t\t\tsvd_SingularValues = SVDdecomposition.singularValues();\n\n\t // determine rank\n\t rank = SVDdecomposition.nonzeroSingularValues();\n\n\t // Compute the projection of data y on the left singular vectors\n\t Uy = svd_MatrixU.transpose() * (measuredData_);\n}\n\n//////////////////////////////////////////////////////////////////////\n// THIS FUNCTION returns regularized solution by tikhonov method\n//////////////////////////////////////////////////////////////////////\nSCIRun::Core::Datatypes::DenseMatrix SolveInverseProblemWithTSVD_impl::computeInverseSolution( double lambda, bool inverseCalculation ) const\n{\n\n // prealocate matrices\n const int N = svd_MatrixV.cols();\n const int M = svd_MatrixU.rows();\n const int numTimeSamples = Uy.ncols();\n DenseMatrix solution(DenseMatrix::Zero(N,numTimeSamples));\n DenseMatrix tempInverse(DenseMatrix::Zero(N,M));\n\n\t\tconst int truncationPoint = Min( int(lambda), rank, int(9999999999999) );\n\n // Compute inverse SolveInverseProblemWithTSVD\n for (int rr=0; rr < truncationPoint ; rr++)\n {\n // evaluate filter factor\n double singVal = svd_SingularValues[rr];\n auto filterFactor_i = 1 / ( singVal );\n\n // update solution\n solution += filterFactor_i * svd_MatrixV.col(rr) * Uy.row(rr);\n\n // update inverse operator\n if (inverseCalculation)\n tempInverse += filterFactor_i * ( svd_MatrixV.col(rr) * svd_MatrixU.col(rr).transpose() );\n }\n\n // output solutions\n // if (inverseCalculation)\n // inverseMatrix_.reset( new SCIRun::Core::Datatypes::DenseMatrix(tempInverse) );\n\n return solution;\n}\n\n//////////////////////////////////////////////////////////////////////\n// THIS FUNCTION returns a string of lambdas from which the L-curve is computed\n//////////////////////////////////////////////////////////////////////\nstd::vector SolveInverseProblemWithTSVD_impl::computeLambdaArray( double lambdaMin, double lambdaMax, int nLambda ) const\n{\n\tstd::vector lambdaArray(nLambda,0.0);\n\tconst double lam_step = 1;\n\n\tlambdaArray[0] = lambdaMin;\n\tfor (int j = 1; j < nLambda; j++)\n\t{\n\t\tlambdaArray[j] = lambdaArray[j-1] + lam_step;\n\t}\n\treturn lambdaArray;\n}\n", "meta": {"hexsha": "1217362f2e831b38c511511400e38e42b64e4696", "size": 6314, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/Core/Algorithms/Legacy/Inverse/SolveInverseProblemWithTSVD_impl.cc", "max_stars_repo_name": "mckees/SCIRun", "max_stars_repo_head_hexsha": "40c2c5b17925181bd2581ab8e11b325d58618165", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Core/Algorithms/Legacy/Inverse/SolveInverseProblemWithTSVD_impl.cc", "max_issues_repo_name": "mckees/SCIRun", "max_issues_repo_head_hexsha": "40c2c5b17925181bd2581ab8e11b325d58618165", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Core/Algorithms/Legacy/Inverse/SolveInverseProblemWithTSVD_impl.cc", "max_forks_repo_name": "mckees/SCIRun", "max_forks_repo_head_hexsha": "40c2c5b17925181bd2581ab8e11b325d58618165", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.2679738562, "max_line_length": 477, "alphanum_fraction": 0.6851441242, "num_tokens": 1489, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.82893881677331, "lm_q2_score": 0.6548947425132315, "lm_q1q2_score": 0.5428676729699797}} {"text": "//Copyright (c) 2018, Changjie\n//All rights reserved.\n//\n//Redistribution and use in source and binary forms, with or without\n//modification, are permitted provided that the following conditions are met:\n//\n//* Redistributions of source code must retain the above copyright 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//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n//AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n//IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n//DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n//FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n//DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n//SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n//OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n//OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\n\n#ifndef __BFGS_HPP__\n#define __BFGS_HPP__\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace Eigen;\n\nusing Eigen::MatrixXd;\nusing Eigen::VectorXd;\n\n// ref: http://en.cppreference.com/w/cpp/utility/functional/function\n\n// input is the position(parameter)\n// Add const to avoid error of invalid initialization of non-const reference\ntypedef std::function Cost_Fun;\n// param1: returned gradient\n// param2: input position\ntypedef std::function Diff_Fun;\n// param1: returned hessian matrix\n// param2: input position\ntypedef std::function Hess_Fun;\n\n\nstruct NonConstraintObj\n{\n\tVectorXd m_x;\n\tsize_t m_n;\n\n\tNonConstraintObj()\n\t{\n\t\tm_n = 1;\n\t\tm_x.resize(m_n);\n\t\tm_x.fill(0.);\n\t}\n\tvirtual ~NonConstraintObj() = default;\n\tvirtual double cost(VectorXd const &x) = 0;\n\tvirtual void grad(VectorXd &grad, VectorXd &x) = 0;\n};\n\nstruct BFGS\n{\n\tsize_t MAX_STEP;\n\tsize_t stop_step;\n\tsize_t step;\n\tdouble rho;\n\tdouble sigma;\n\tdouble epsilon;\n\n\tbool improved;\n\tbool initialized;\n\n\tCost_Fun cost_fun;\n\tDiff_Fun grad_fun;\n\n\tstd::shared_ptr funPtr;\n\tBFGS()\n\t{\n\t\tMAX_STEP = 80;\n\t\tstop_step = 5;\n\t\tstep = 0;\n\t\trho = 0.55;\n\t\tsigma = 0.4;\n\t\tepsilon = 1e-5;\n\t\timproved = false;\n\t\tinitialized = false;\n\t\tfunPtr = nullptr;\n\t}\n\ttemplate \n\tvoid init(T &obj)\n\t{\n\t\t// store a call to a member function and object\n\t\tusing std::placeholders::_1;\n\t\tusing std::placeholders::_2;\n\t\tcost_fun = std::bind(&T::cost, obj, _1);\n\t\tgrad_fun = std::bind(&T::grad, obj, _1, _2);\n\t\tinitialized = true;\n\t}\n\tdouble solve_(Cost_Fun fun, Diff_Fun dfun, VectorXd &input);\n\tdouble solve_(Cost_Fun fun, Diff_Fun dfun, Hess_Fun hfun, VectorXd &input);\n\tdouble solve(VectorXd &input)\n\t{\n\t\tif (initialized)\n\t\t{\n\t\t\treturn solve_(cost_fun, grad_fun, input);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tprintf(\"BFGS is not initialized! Return zeros.\\n\");\n\t\t\treturn 1e9;\n\t\t}\n\t}\n};\n\nstruct BFGS_V2\n{\n\t//double *Bk;\n\n\tBFGS_V2()\n\t{\n\t\t//Bk = nullptr;\n\t\t//cudaMalloc((void **)&Bk, sizeof(double)*3);\n\t}\n\ttemplate \n\tstatic double bfgs(std::shared_ptr ptr, VectorXd &x0)\n\t{\n\t\tsize_t maxk = 500, stop_step = 5;\n\t\tdouble rho = 0.55, sigma = 0.4, epsilon = 1e-5;\n\n\t\tsize_t k = 0, n = x0.size();\n\t\tMatrixXd Bk = MatrixXd::Identity(n, n);\n\n\t\tVectorXd gk, dk, sk, yk, x;\n\t\tsize_t m = 0, mk = 0, bad = 0;\n\t\tdouble fit = 0., tmp = 0.;\n\t\tdouble best = 1e10;\n\t\twhile (k < maxk && bad < stop_step)\n\t\t{\n\t\t\tfit = ptr->cost(x0);\n\t\t\tif (fit < best - epsilon)\n\t\t\t{\n\t\t\t\tbest = fit;\n\t\t\t\tbad = 0;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tbad++;\n\t\t\t}\n\t\t\tptr->grad(gk, x0);\n\t\t\t//std::cout<<\"gk = \"<cost(x0 + pow(rho, m) * dk) < (fit + sigma * pow(rho, m) * tmp))\n\t\t\t\t{\n\t\t\t\t\tmk = m;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tm++;\n\t\t\t}\n\t\t\tx = x0 + pow(rho, mk) * dk;\n\t\t\tsk = pow(rho, mk) * dk;\n\t\t\tptr->grad(yk, x);\n\t\t\tyk = yk - gk;\n\t\t\tif (yk.transpose() * sk > 0)\n\t\t\t{\n\t\t\t\tBk = Bk - (Bk * sk * sk.transpose() * Bk) / (sk.transpose() * Bk * sk) + (yk * yk.transpose()) / (yk.transpose() * sk);\n\t\t\t}\n\t\t\tx0 = x;\n\t\t\tk++;\n\t\t}\n\t\tx0 = x;\n\t\t#ifdef DEBUG\n\t\tstd::cout << \"BFGS stops at step \" << k << std::endl;\n\t\t#endif\n\t\treturn fit;\n\t}\n};\n\n#endif\n", "meta": {"hexsha": "a49a133091f593bc9347fc4341e10612a13835a3", "size": 4739, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/bfgs/bfgs.hpp", "max_stars_repo_name": "gcjyzdd/BFGS", "max_stars_repo_head_hexsha": "f546224d787faf8e37f49ab6a03ab919187b16e8", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2018-05-13T08:10:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-03T11:00:45.000Z", "max_issues_repo_path": "src/bfgs/bfgs.hpp", "max_issues_repo_name": "gcjyzdd/BFGS", "max_issues_repo_head_hexsha": "f546224d787faf8e37f49ab6a03ab919187b16e8", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/bfgs/bfgs.hpp", "max_forks_repo_name": "gcjyzdd/BFGS", "max_forks_repo_head_hexsha": "f546224d787faf8e37f49ab6a03ab919187b16e8", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.0558375635, "max_line_length": 123, "alphanum_fraction": 0.6615319688, "num_tokens": 1451, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7799928900257127, "lm_q2_score": 0.6959583250334526, "lm_q1q2_score": 0.542842545280297}} {"text": "#ifndef fast_gauss_noise_h\n#define fast_gauss_noise_h\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"fastrandombytes.h\"\n\n#ifdef BOOST_RAPHSON\n#include \n#endif\n\n\n//#define OUTPUT_BARRIERS\n//#define OUTPUT_LUT_FLAGS\n// Use it to test rare values do not happen too often\n//#define UNITTEST_ONEMILLION\n\nnamespace nfl {\n\ntemplate\nconstexpr inline auto tstbit(T0 x, T1 n) -> decltype((x << (63 - n)) >> 63 ) { return ((x << (63 - n)) >> 63 ); }\n\ntemplate\nstruct output {\n out_class val;\n bool flag;\n std::list l_b_ptr;\n};\n\ntemplate\nclass FastGaussianNoise {\n typedef output output_t;\n private:\n unsigned int _bit_precision;\n unsigned int _word_precision;\n unsigned int _number_of_barriers;\n unsigned int _lu_size;\n unsigned int _flag_ctr1;\n unsigned int _flag_ctr2;\n double _sigma;\n mpfr_t _const_sigma;\n mpfr_t _center;\n int rounded_center;\n unsigned int _security;\n unsigned int _samples; \n double _tail_bound;\n bool _verbose;\n\n in_class **barriers;\n output_t *lu_table;\n output_t **lu_table2;\n\n void check_template_params();\n void init();\n void precomputeBarrierValues(); \n void buildLookupTables();\n void nn_gaussian_law(mpfr_t rop, const mpfr_t x_fr);\n int cmp(in_class *op1, in_class *op2); \n\n public:\n static const unsigned int default_k;\n FastGaussianNoise(double sigma, unsigned int security, unsigned int samples, double center_d = 0, bool verbose = false);\n FastGaussianNoise(double sigma, unsigned int security, unsigned int samples, mpfr_t center, bool verbose = false);\n ~FastGaussianNoise();\n void getNoise(out_class * const rand_data2out, uint64_t rlen); \n};\n\n\n/* NOTATIONS (from paper Sampling from discrete Gaussians \n * for lattice-based cryptography on a constrainded device\n * Nagarjun C. Dwarakanath, Steven Galbraith\n * Journal : AAECC 2014 (25)\n *\n * m : lattice dimension, we set it to 1 in here (better results for same security) !!!!\n *\n * security : output distribution should be within 2^{-security} \n * statistical distance from the Gaussian distribution\n *\n * sigma : parameter of the Gaussian distribution (close \n * to the standard deviation but not equal)\n * SUM = \\sum_{k=-\\inf}^{\\inf} exp(-(k-c)^2/(2*sigma^2))\n *\n * D_{sigma} : distribution such that for x\\in \\mathcal{Z}\n * Pr(x) = ro_{sigma}(x) = 1/SUM exp(-(x-c)^2/(2*sigma^2))\n *\n * Warning : can be replaced in some works by s = sqrt(2*pi)*sigma\n * if Pr(x) = 1/SUM exp(-pi*(x-c)^2/s^2)\n *\n * tail_bound : tail bound we only output points with \n * norm(point-c) < tail_bound*sigma\n *\n * bit_precision : bit precision when computing the probabilities \n *\n * delta_tailbound : statistical distance introduced \n * by the tail bound\n *\n * delta_epsi : statistical distance introduced by \n * probability approximation\n */\n\n\n\n// HELPER FUNCTIONS\n\n/* /!\\ Warning only for x64 */\nextern __inline__ uint64_t rdtsc(void) \n{\n uint64_t a, d;\n __asm__ volatile (\"rdtsc\" : \"=a\" (a), \"=d\" (d));\n return (d<<32) | a;\n}\n\n// Function to be used in a Newton-Raphson solver\nstruct funct\n{\n\tfunct(double const& target) : k(target){}\n\tstd::tuple operator()(double const& x)\n\t{\n\t\treturn std::make_tuple(x*x - 2*log(x) - 1 - 2*k*log(2), 2*x-2/x); \n\t}\n\tprivate:\n\tdouble k;\n};\n\ninline\ndouble newton_raphson(double k, double max_guess, int digits)\n{\n unsigned max_counter = 1U<<15;\n std::tuple values;\n double delta;\n double guess = max_guess;\n for (unsigned counter = 0 ; counter < max_counter; counter++)\n {\n values = funct(k)(guess);\n delta = std::get<0>(values)/std::get<1>(values);\n guess -= delta;\n if ( fabs(delta)/fabs(guess) < pow(10.0,-digits) ) break;\n }\n // In case there is a flat zone in the function\n while(0.95*guess*0.95*guess - 2*log(0.95*guess) - 1 - 2*k*log(2)>=0) guess*=0.95;\n // Test result\n if(guess*guess - 2*log(guess) - 1 - 2*k*log(2)<0)\n {\n std::cout << \"FastGaussianNoise: WARNING Newton-Raphson failed the generator is NOT secure\" << std::endl;\n }\n return guess;\n}\n\n\n// Constructors\n\n\ntemplate\nFastGaussianNoise::FastGaussianNoise( double sigma, \n\t\tunsigned int security, unsigned int samples, double center_d /*=0*/, bool verbose /*=true*/):\n\t_sigma(sigma),\n\t_security(security),\n _samples(samples),\n _verbose(verbose)\n{\n // Check template parameters\n check_template_params();\n \n //Center cannot be initialized before the constructor\n mpfr_init_set_d(_center, center_d, MPFR_RNDN);\n rounded_center = round(center_d);\n\n //Initialization functions\n\tinit(); \n\tprecomputeBarrierValues();\n\tbuildLookupTables();\n}\n\ntemplate\nFastGaussianNoise::FastGaussianNoise( double sigma, \n\t\tunsigned int security, unsigned int samples, mpfr_t center /*=0*/, bool verbose /*=true*/):\n\t_sigma(sigma),\n\t_security(security),\n _samples(samples),\n _verbose(verbose)\n{\n // Check template parameters\n check_template_params();\n\n //Center cannot be initialized before the constructor\n mpfr_init_set(_center, center, MPFR_RNDN);\n rounded_center = mpfr_get_d(_center, MPFR_RNDN);\n\n //Initialization functions\n\tinit(); \n\tprecomputeBarrierValues();\n\tbuildLookupTables();\n}\n\n\n// Check template parameters\ntemplate\nvoid FastGaussianNoise::check_template_params() \n{\n // Lookup tables can only have depth 1 or 2\n if (_lu_depth != 1 && _lu_depth != 2)\n {\n std::cout << \"FastGaussianNoise: CRITICAL _lu_depth must be 1 or 2\" << std::endl;\n exit(1);\n }\n\n // Lookup tables can only have uint8_t or uint16_t indexes\n if (typeid(in_class) == typeid(uint8_t))\n _lu_size = 1<<8;\n else if(typeid(in_class) == typeid(uint16_t))\n _lu_size = 1<<16;\n else\n {\n std::cout << \"FastGaussianNoise: CRITICAL in_class must be uint8_t or uint16_t\" << std::endl;\n exit(2);\n }\n}\n\n\n// Compute some values (precision, number of barriers and outputs)\ntemplate\nvoid FastGaussianNoise::init() \n{\n\tdouble epsi, k;\n\n\t/* Lemma 1: \n\t * tail_bound >= sqrt(1 + 2*log(tail_bound) + 2*k*log(2)) \n\t * IMPLIES delta_tailbound < 2**(-k)\n *\n * -epsi <= -k - log2(2 * tail_bound * sigma)) \n\t * IMPLIES 2 * tail_bound * sigma * 2**(-epsi) <= 2**(-k)\n\t * \n * Lemma 2 (and Lemma 1): \n\t * 2 * tail_bound * sigma * 2**(-epsi) <= 2**(-k)\n\t * IMPLIES delta_epsilon < 2**(-k)\n */\n\n\t// THUS setting \n\tk = _security + 1 + ceil(log(_samples)/log(2));\n\t// IMPLIES (delta_tailbound + delta_epsilon)*_samples < 2**(-_security)\n\t// We can thus generate vectors of _samples samples securely\n\n // To compute the tail bound we use Newton-Raphson with three digits of precision\n\t// WE HAVE tail_bound >= sqrt(1 + 2*log(tail_bound) + 2*k*log(2)) \n // IS EQUIV TO tail_bound**2 -2*log(tail_bound) - 1- 2*k*log(2) >= 0\n\tint digits = 3;\n#ifdef BOOST_RAPHSON\n double max_guess = 1+2*k*log(2);\n double min_guess = sqrt(1 + 2*k*log(2)), guess = min_guess;\n\t_tail_bound = boost::math::tools::newton_raphson_iterate(funct(k),guess, min_guess, max_guess, digits);\n#else\n double min_guess = sqrt(1 + 2*k*log(2));\n _tail_bound = newton_raphson(k, min_guess, digits);\n#endif\n\t// We now can compute the precision needed \n\tepsi = k + log2(2 * _tail_bound * _sigma);\n\t_bit_precision = ceil(epsi);\n\t_word_precision = ceil(_bit_precision/(8.0*sizeof(in_class)));\n // For the same cost we get a simpler situation and more precision\n\t_bit_precision = _word_precision*8*sizeof(in_class);\n // And the number of probabilities that must be computed\n // Only half of them are computed (others are symmetric)\n // but all values are stored to speedup noise generation\n _number_of_barriers = 1+2*ceil(_tail_bound*_sigma);\n if ( ((uint64_t)_number_of_barriers >> (sizeof(out_class) * 8 - 1)) != 0)\n std::cout << \"FastGaussianNoise: WARNING out_class too small to contain some of the (signed) results\" << std::endl;\n if ( ((uint64_t)_number_of_barriers >> (sizeof(int) * 8 - 1)) != 0)\n std::cout << \"FastGaussianNoise: WARNING outputs are above 2**31, unexpected results\" << std::endl;\n\n // Finally we precompute 1/(2*sigma**2) to accelerate things\n\tmpfr_inits2(_bit_precision, _const_sigma, nullptr);\n mpfr_set_d(_const_sigma, _sigma, MPFR_RNDN);\n\tmpfr_sqr(_const_sigma, _const_sigma, MPFR_RNDN);\n\tmpfr_mul_ui(_const_sigma, _const_sigma, 2, MPFR_RNDN); \n\tmpfr_ui_div(_const_sigma, 1, _const_sigma, MPFR_RNDN);\n\n // Give some feedback\n if (_verbose) std::cout << \"FastGaussianNoise: \" << _number_of_barriers << \n \" barriers with \" << _bit_precision << \n \" bits of precision will be computed\" << std::endl;\n}\n\n\ntemplate\nvoid FastGaussianNoise::precomputeBarrierValues() \n{\n // Declare and init mpfr vars\n mpfr_t sum, tmp, tmp2;\n mpfr_t *mp_barriers;\n mpfr_inits2(_bit_precision, sum, tmp, tmp2, nullptr);\n\n // This var is used to export mpfr values\n mpz_t int_value;\n mpz_init2(int_value, _bit_precision);\n\n // Init SUM = \\sum_{k=-ceil(tail_bound*sigma)}^{ceil(tail_bound*sigma)} exp(-(k+round(c)-c)^2/(2*sigma^2))\n // and compute on the loop with the barriers\n mpfr_set_ui(sum, 0, MPFR_RNDN);\n\n // Allocate memory for the barrier pointers\n barriers = (in_class **) malloc(_number_of_barriers*sizeof(in_class *)); \n mp_barriers = (mpfr_t *) malloc(_number_of_barriers*sizeof(mpfr_t)); \n\n // Now loop over the barriers\n for (int i = 0; i < (int)_number_of_barriers; i++)\n {\n // Init mpfr var\n mpfr_init2(mp_barriers[i], _bit_precision);\n\n // Compute the barrier value (without normalization)\n mpfr_set_si(tmp2, rounded_center+i-((int)_number_of_barriers-1)/2, MPFR_RNDN);\n nn_gaussian_law(tmp, tmp2);\n //mpfr_out_str(stdout, 10, 0, tmp2, MPFR_RNDN);\n //std::cout << std::endl;\n if (i==0) mpfr_set(mp_barriers[0], tmp, MPFR_RNDN);\n else \n {\n mpfr_add(mp_barriers[i], mp_barriers[i-1], tmp, MPFR_RNDN);\n }\n\n // Add the probability to the sum\n mpfr_add(sum, sum, tmp, MPFR_RNDN);\n }\t\n \n // Invert the sum and scale it \n mpfr_ui_div(sum, 1, sum, MPFR_RNDN);\n mpfr_set_ui(tmp, 2, MPFR_RNDN);\n mpfr_pow_ui(tmp, tmp, _bit_precision, MPFR_RNDN);\n mpfr_sub_ui(tmp, tmp, 1, MPFR_RNDN);\n mpfr_mul(sum, sum, tmp, MPFR_RNDN);\n\n // Now that we got the inverted sum normalize and export\n for (unsigned i = 0; i < _number_of_barriers; i++)\n {\n // Allocate space\n barriers[i] = (in_class *) calloc(_word_precision,sizeof(in_class)); \n\t \n mpfr_mul(mp_barriers[i], mp_barriers[i], sum, MPFR_RNDN); \n mpfr_get_z(int_value, mp_barriers[i], MPFR_RNDN);\n mpz_export((void *) (barriers[i] + ((int)_word_precision - \n (int)ceil( (float)mpz_sizeinbase(int_value, 256)/sizeof(in_class) ))), nullptr, 1, sizeof(in_class), 0, 0, int_value);\n#ifdef OUTPUT_BARRIERS\n mpz_out_str(stdout, 10, int_value);\n std::cout << \" = Barriers[\" << i << \"] = \" << std::endl;\n if (sizeof(in_class) == 1) for (unsigned j = 0 ; j < _word_precision; j++)\n printf(\"%.2x\", barriers[i][j]);\n if (sizeof(in_class) == 2) for (unsigned j = 0 ; j < _word_precision; j++)\n printf(\"%.4x\", barriers[i][j]);\n std::cout << std::endl;\n#endif \n mpfr_clear(mp_barriers[i]);\n }\n\tmpfr_clears(sum, tmp, tmp2, nullptr);\n mpz_clear(int_value);\n\tmpfr_free_cache();\n free(mp_barriers);\n}\n\n\n\n//Build lookup tables used during noise generation\ntemplate\nvoid FastGaussianNoise::buildLookupTables() \n{\n\tunsigned lu_index1 = 0, lu_index2 = 0;\n _flag_ctr1 = _flag_ctr2 = 0;\n\n // Allocate space for the lookup tables\n lu_table = new output_t[_lu_size](); \n if(_lu_depth == 2) \n lu_table2 = (output_t **) calloc(_lu_size,sizeof(output_t *)); \n\n\t// We start building the first dimension of the lookup table\n // corresponding to the first in_class word of the barriers\n\tfor (int64_t val = -((int)_number_of_barriers-1)/2 + rounded_center, b_index = 0; val <= ((int)_number_of_barriers-1)/2 + rounded_center && lu_index1 < _lu_size;) \n {\n\n\t\twhile (lu_index1 < barriers[b_index][0] && lu_index1 < _lu_size) \n {\n lu_table[lu_index1].val = val;\n\t\t\tlu_index1++;\n\t\t}\n\n\t\t// Flag the entry\n\t\tlu_table[lu_index1].val = val;\n\t\tlu_table[lu_index1].flag = true;\n _flag_ctr1++;\n\t\t// If _lu_depth == 1 we have to list the barriers here\n if (_lu_depth == 1)\n {\n#ifdef OUTPUT_LUT_FLAGS\n std::cout << \"FastGaussianNoise: flagged lu_table[\" \n << lu_index1 << \"] for barriers \" << val;\n#endif\n \n // Prepare the first element of the chained list of barrier\n\t\t\tlu_table[lu_index1].l_b_ptr.push_back(barriers[b_index++]);\n val++;\n\t\t\t// If more that one barrier is present, we add them to the chained list \n\t\t\twhile ( (b_index<_number_of_barriers) && (lu_index1 == barriers[b_index][0])) \n {\n\t\t\t lu_table[lu_index1].l_b_ptr.push_back(barriers[b_index]);\n#ifdef OUTPUT_LUT_FLAGS\n std::cout << \"FastGaussianNoise: flagged lu_table[\" << lu_index1 << \"] for barriers \" << val;\n#endif\n\t\t\t\tb_index++;\n\t\t\t\tval++;\n\t\t\t} // while\n } // if\n\t\n if (_lu_depth == 2)\n {\n // When we meet a barrier in an entry of the lu_table, \n // we build another lu_table inside that entry\n\t\t // corresponding to the next in_class word of the barriers \n\t\t lu_index2 = 0;\n lu_table2[lu_index1] = new output_t[_lu_size](); \n\t\t while (lu_index2 < _lu_size) \n {\n\t\t\t if(lu_index1 < barriers[b_index][0] || lu_index2 < barriers[b_index][1])\n {\n lu_table2[lu_index1][lu_index2].val = val;\n }\n else\n {\n\t\t // If we are on a barrier\n\t\t if (lu_index1 == barriers[b_index][0] && lu_index2 == barriers[b_index][1]) \n {\n\t\t\t // Flag the entry\n\t\t\t lu_table2[lu_index1][lu_index2].val = val;\n\t\t\t lu_table2[lu_index1][lu_index2].flag = true;\n#ifdef OUTPUT_LUT_FLAGS\n std::cout << \"FastGaussianNoise: flagged lu_table2[\" << lu_index1 << \"][\" << lu_index2 << \"] for barriers \" << val;\n#endif\n _flag_ctr2++;\n\t\t\t // And prepare the first element of the chained list of barrier\n\t\t\t lu_table2[lu_index1][lu_index2].l_b_ptr.push_back(barriers[b_index++]);\n val++;\n\t\t\t // If more that one barrier is present, we add them to the chained list \n\t\t\t while ( (b_index<_number_of_barriers) && \n (lu_index1 == barriers[b_index][0]) && \n (lu_index2 == barriers[b_index][1]) ) \n {\n\t\t\t\t lu_table2[lu_index1][lu_index2].l_b_ptr.push_back(barriers[b_index]);\n#ifdef OUTPUT_LUT_FLAGS\n std::cout << \" \" << val;\n#endif\n\t\t\t\t b_index++;\n\t\t\t\t val++;\n\t\t\t } // while\n#ifdef OUTPUT_LUT_FLAGS\n std::cout << std::endl;\n#endif\n } // if\n } // else\n lu_index2++;\n } // while\n\t\t} // if\n\n\t\tlu_index1++;\n\t}\n // Give some feedback\n if (_verbose) std::cout << \"FastGaussianNoise: Lookup tables built\" << std::endl;\n}\n\ntemplate\nvoid FastGaussianNoise::getNoise(out_class* const rand_outdata, uint64_t rlen) \n{\n\tuint64_t computed_outputs, innoise_bytesize, innoise_words, used_words;\n\tint64_t output;\n bool flagged;\n\tin_class *noise, *noise_init_ptr, input1, input2;\n float innoise_multiplier;\n \n // Expected number of input bytes per output byte. Lowering this \n // (e.g. by a factor .5) works but could lead to segfaults.\n if (_lu_depth == 1)\n {\n innoise_multiplier = 1.05 * ((float)(_lu_size - _flag_ctr1)/(float)_lu_size) + _word_precision * ((float)_flag_ctr1/_lu_size);\n } \n else // _lu_depth == 2\n {\n innoise_multiplier = 1.05 * ((float)(_lu_size - _flag_ctr1)/(float)_lu_size) + 2.0 * ((float)_flag_ctr1/(float)_lu_size) + _word_precision * ((float)_flag_ctr2/((float)_lu_size*_lu_size));\n }\n innoise_words = rlen * innoise_multiplier;\n innoise_bytesize = sizeof(in_class) * innoise_words;\n\tnoise = noise_init_ptr = new in_class[innoise_words];\n used_words = 0;\n if (_verbose) std::cout << \"FastGaussianNoise: Using \" << \" \" < _sigma * 6) || (output < -_sigma*6) )\n {\n std::cout << output << \"FastGaussianNoise: Unit test failed, this should happen once in a million. Uniform input leading to this is \";\n for (unsigned i = 0; i < _word_precision ; i++)\n printf(\"%.2x\", *(noise-_word_precision+i));\n std::cout << std::endl;\n }\n#endif\n\n#if 1\n // If too much noise has been used regenerate it\n if ((used_words+_word_precision) >= innoise_words)\n {\n noise = noise_init_ptr;\n used_words = 0; \n if (_verbose) std::cout << \"FastGaussianNoise: All the input bits have been used, regenerating them ...\" << std::endl;\n \n\t fastrandombytes((uint8_t*)noise, innoise_bytesize);\n }\n#endif\n\t}\n\tdelete[] noise_init_ptr;\n}\n\n/* Compare two arrays word by word.\n * return 1 if op1 > op2, 0 if equals and -1 if op1 < op2 */\ntemplate\ninline int FastGaussianNoise::cmp(in_class *op1, in_class *op2) \n{\n\n\tfor (int i = 0; i < (int)_word_precision; i++) \n {\n\n\t\tif (op1[i] > op2[i]) return 1;\n\n\t\telse if (op1[i] < op2[i]) return -1;\n\t}\n\treturn 0;\n}\n\n\n// Compute exp(-(x-center)^2/(2*sigma^2)) this is not normalized ! (hence the nn)\ntemplate\nvoid inline FastGaussianNoise::nn_gaussian_law(mpfr_t rop, const mpfr_t x) \n{\n\tmpfr_sub(rop, x, _center, MPFR_RNDN);\n\tmpfr_sqr(rop, rop, MPFR_RNDN);\n\tmpfr_neg(rop, rop, MPFR_RNDN);\n\tmpfr_mul(rop, rop, _const_sigma, MPFR_RNDN);\n\tmpfr_exp(rop, rop, MPFR_RNDN);\n}\n\n\ntemplate\nFastGaussianNoise::~FastGaussianNoise() \n{\n // Freed allocated memory for the barriers\n for (unsigned ctr = 0; ctr < _number_of_barriers; ctr++)\n {\n if (barriers[ctr] != nullptr) free(barriers[ctr]); \n barriers[ctr] = nullptr;\n }\n if (barriers != nullptr) free(barriers);\n barriers=nullptr;\n\n // Free other variables\n mpfr_clear(_const_sigma);\n mpfr_clear(_center);\n delete[](lu_table);\n if(_lu_depth == 2) \n {\n for (unsigned ctr = 0 ; ctr < _lu_size; ctr++)\n {\n if (lu_table2[ctr]!=nullptr) delete[](lu_table2[ctr]);\n }\n free(lu_table2);\n }\n}\n\n} // namespace nfl\n\n#endif\n", "meta": {"hexsha": "f0ffc599d2306b54f40acb515411bb42ecd2e49b", "size": 21264, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/nfl/prng/FastGaussianNoise.hpp", "max_stars_repo_name": "Valeh2012/NFLlib", "max_stars_repo_head_hexsha": "5cf40ed6a4929bfc304f3283aafd62c4149c55e2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 128.0, "max_stars_repo_stars_event_min_datetime": "2015-12-14T09:58:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-20T21:16:37.000Z", "max_issues_repo_path": "include/nfl/prng/FastGaussianNoise.hpp", "max_issues_repo_name": "Valeh2012/NFLlib", "max_issues_repo_head_hexsha": "5cf40ed6a4929bfc304f3283aafd62c4149c55e2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 43.0, "max_issues_repo_issues_event_min_datetime": "2015-11-26T23:39:07.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-20T21:19:19.000Z", "max_forks_repo_path": "include/nfl/prng/FastGaussianNoise.hpp", "max_forks_repo_name": "Valeh2012/NFLlib", "max_forks_repo_head_hexsha": "5cf40ed6a4929bfc304f3283aafd62c4149c55e2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 51.0, "max_forks_repo_forks_event_min_datetime": "2015-11-26T14:41:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-10T06:42:05.000Z", "avg_line_length": 32.4641221374, "max_line_length": 213, "alphanum_fraction": 0.6679834462, "num_tokens": 6186, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619436290699, "lm_q2_score": 0.6584175139669998, "lm_q1q2_score": 0.5428401832846529}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"../include/TriMesh.h\"\n#include \"../include/utils.h\"\n#include \"../include/lagrange.h\"\n#include \"../include/geometry.h\"\n#include \"../include/ConstructCurveMesh.h\"\n#include \"../include/GetQuadraturePointsWeight2D.h\"\n#include \"../include/solver.h\"\n#include \"../include/euler.h\"\n#include \"../include/Param.h\"\n#include \"../include/Collective.h\"\n#include \"../include/InvertMatrix.h\"\n\nusing namespace std;\nusing namespace utils;\nusing namespace lagrange;\n\n\nint main(int argc, char *argv[])\n{\n namespace ublas = boost::numeric::ublas;\n\n Param param;\n // Set up the param struct\n param = ReadParamIn(string(argv[1]));\n TriMesh mesh(param.mesh_file);\n // Testing Calculate Residaul\n int p = param.order;\n int q = param.order_geo;\n int Np = int((p + 1) * (p + 2) / 2);\n TriMesh curved_mesh = mesh;\n string boundary_name=\"bottom\";\n ConstructCurveMesh(mesh, curved_mesh, geometry::BumpFunction, boundary_name, q);\n\n\n ublas::vector States (curved_mesh.num_element * Np * 4, 0.0);\n // Construct free stream state\n ublas::vector u_free = euler::CalcFreeStreamState_2DEuler(param);\n for (int ielem = 0; ielem < curved_mesh.num_element; ielem++)\n {\n for (int ip = 0; ip < Np; ip++)\n {\n States(ielem * Np * 4 + ip * 4 + 0) = u_free(0);\n States(ielem * Np * 4 + ip * 4 + 1) = u_free(1);\n States(ielem * Np * 4 + ip * 4 + 2) = u_free(2);\n States(ielem * Np * 4 + ip * 4 + 3) = u_free(3);\n }\n }\n\n ResData resdata, resdata_postproc;\n solver::CalcResData(curved_mesh, p, resdata);\n if (p == 0)\n {\n solver::CalcResData(curved_mesh, 1, resdata_postproc);\n }else\n {\n solver::CalcResData(curved_mesh, p, resdata_postproc);\n }\n\n ublas::vector dt(curved_mesh.E.size());\n // ublas::vector Residual = solver::CalcResidual(curved_mesh, param, resdata, States, dt, p);\n // cout << setprecision(20) << ublas::norm_2(Residual) << endl;\n ublas::vector > M = lagrange::ConstructMassMatrix(p, curved_mesh, resdata);\n ublas::vector > invM = lagrange::CalcInvMassMatrix(M);\n int MAXITER = param.MAXITER;\n int converged = 0;\n ublas::vector States_new (curved_mesh.num_element * Np * 4, 0.0);\n ofstream file_residual;\n file_residual.open(\"residual.log\");\n for (int niter = 0; niter < MAXITER; niter++)\n {\n // cout << niter << endl;\n double norm_residual = 0.0;\n States_new = solver::TimeMarching_TVDRK3(curved_mesh, param, resdata, States, invM, p, converged, norm_residual);\n\t if (niter % param.dnOutput == 0)\n\t {\n std::cout << \"NITER: \" << niter << \"\\t\" << \"Residual Norm_Inf: \";\n cout.setf(ios::scientific, ios::floatfield);\n std::cout << setprecision(10) << norm_residual << std::endl;\n }\n file_residual << niter << \"\\t\" << setprecision(20) << norm_residual << std::endl;\n States = States_new;\n if (converged)\n break;\n }\n file_residual.close();\n\n // PostProcessing the States, the output will be the global coordinate of the lagrange nodes in each element and the states on the nodes\n int Np_solution;\n if (p == 0)\n Np_solution = 3;\n else\n Np_solution = Np;\n ublas::vector > Nodes(curved_mesh.E.size(), ublas::matrix(Np_solution, 2, 0.0));\n ublas::vector > State_on_Nodes(curved_mesh.E.size(), ublas::matrix(Np_solution, 4, 0.0));\n solver::PostProc(curved_mesh, States, p, Nodes, State_on_Nodes);\n // Write the Nodes Coordinates and States into the file\n ofstream file_nodes, file_states, file_info;\n file_nodes.open(\"nodes.dat\");\n file_states.open(\"states.dat\");\n file_info.open(\"info.dat\");\n for (int ielem = 0; ielem < curved_mesh.E.size(); ielem++)\n {\n for (int ip = 0; ip < Np_solution; ip++)\n {\n file_nodes << Nodes(ielem)(ip, 0) << ' ' << Nodes(ielem)(ip, 1) << std::endl;\n file_states << State_on_Nodes(ielem)(ip, 0) << ' ' << State_on_Nodes(ielem)(ip, 1) << ' ' <<\n State_on_Nodes(ielem)(ip, 2) << ' ' << State_on_Nodes(ielem)(ip, 3) << std::endl;\n }\n }\n file_info << curved_mesh.E.size() << ' ' << p << std::endl;\n file_nodes.close();\n file_states.close();\n file_info.close();\n\n return 0;\n}\n", "meta": {"hexsha": "92b24f5a44205abd637000b0e87eee3b53b1769f", "size": 4659, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/main.cpp", "max_stars_repo_name": "xtwang1996/DG_Euler_2D", "max_stars_repo_head_hexsha": "1218ef7af9a85db48c84386e0fc396d09286be33", "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/main.cpp", "max_issues_repo_name": "xtwang1996/DG_Euler_2D", "max_issues_repo_head_hexsha": "1218ef7af9a85db48c84386e0fc396d09286be33", "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/main.cpp", "max_forks_repo_name": "xtwang1996/DG_Euler_2D", "max_forks_repo_head_hexsha": "1218ef7af9a85db48c84386e0fc396d09286be33", "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": 37.272, "max_line_length": 140, "alphanum_fraction": 0.6215926164, "num_tokens": 1347, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619350028205, "lm_q2_score": 0.6584175005616829, "lm_q1q2_score": 0.5428401665528058}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"SHTools.h\"\n\ntypedef CGAL::Exact_predicates_inexact_constructions_kernel K;\ntypedef CGAL::Triangulation_vertex_base_with_info_2 Vb;\ntypedef CGAL::Triangulation_data_structure_2 Tds;\ntypedef CGAL::Delaunay_triangulation_2 Delaunay;\ntypedef Delaunay::Face_circulator Face_circulator;\ntypedef Delaunay::Face_handle Face_handle;\ntypedef Delaunay::Point Point;\ntypedef Eigen::Vector3d Vector3d;\ntypedef Eigen::VectorXd VectorXd;\ntypedef Eigen::Matrix3d Matrix3d;\ntypedef Eigen::Matrix3Xd Matrix3Xd;\ntypedef Eigen::Map Map3Xd;\n\nint main(){\n\n // Read the polydata\n vtkNew reader;\n reader->SetFileName(\"T7.vtk\");\n reader->Update();\n auto pointCloud = reader->GetOutput();\n int N = pointCloud->GetNumberOfPoints();\n\n // A lambda function to write a Eigen::Matrix3Xd to VTK file\n auto writeMatToVTK =\n\t[](Eigen::Matrix3Xd M, std::string file, bool Proj = false){\n\t vtkNew pts;\n\t vtkNew verts;\n\t for( auto b = 0; b < M.cols(); ++b ){\n\t\tdouble x, y, z;\n\t\tx = M(0,b);\n\t\ty = M(1,b);\n\t\tz = Proj? 0.0 : M(2,b);\n\t\tpts->InsertNextPoint(x, y, z);\n\t\tverts->InsertNextCell( 1 );\n\t\tverts->InsertCellPoint( b );\n\t }\n\t vtkNew poly;\n\t poly->SetPoints( pts );\n\t poly->SetVerts( verts );\n\t vtkNew wr;\n\t wr->SetInputData( poly );\n\t wr->SetFileName( file.c_str() );\n\t wr->Write();\n\t};\n\n // Test function: 2*Y_1,-1 + Y_10 + 3*Y_11, so l=1, m=-1,0,1\n int lmax = std::floor( sqrt(N) - 1 );\n Eigen::VectorXd plms( (lmax + 1)*(lmax + 2)/2 );\n auto Plm = [&plms](const size_t l, const size_t m){\n\treturn plms( l*(l+1)/2 + m );\n };\n\n // Map the point coordinates into a matrix\n Map3Xd pointsOrig((double_t*)pointCloud->GetPoints()\n\t ->GetData()->GetVoidPointer(0),3,N);\n Matrix3Xd points(3,N);\n points = pointsOrig;\n\n //**********************************************************************//\n // Create the Gauss-Lengendre grid\n int nlat, nlong;\n Eigen::VectorXd latglq(lmax + 1);\n Eigen::VectorXd longlq(2*lmax + 1);\n glqgridcoord_wrapper_(latglq.data(), longlq.data(), &lmax, &nlat, &nlong);\n auto numQ = nlat*nlong;\n\n Eigen::VectorXd gridglq((lmax + 1)*(2*lmax + 1));\n Eigen::VectorXd plx( (lmax + 1)*(lmax + 1)*(lmax + 2)/2 );\n Eigen::VectorXd w( lmax + 1 ), zero( lmax + 1 );\n Eigen::VectorXd cilm( 2*(lmax + 1)*(lmax + 1) );\n Eigen::VectorXd pspectrum( lmax + 1 );\n\n // Pre-compute all the matrices needed for expansion\n shglq_wrapper_(&lmax, zero.data(), w.data(), plx.data() );\n\n //Now we need to first identify which triangles each of the quadrature\n //points belongs to. For this, we need the coordinates of the points\n Eigen::Matrix3Xd Q0(3,numQ);// Original quadrature points\n Eigen::Matrix3Xd Qr(3,numQ);// Rotated quadrature points\n Eigen::Matrix3Xd Qsp(3,numQ);// StereoProjection of quadrature points\n\n size_t index = 0;\n for( auto ip = 0; ip < nlong; ++ip){\n\tauto phi = longlq(ip)*M_PI/180.0;\n\tauto sin_p = std::sin(phi);\n\tauto cos_p = std::cos(phi);\n\tfor( auto it = 0; it < nlat; ++it){\n\t auto theta = (90.0 - latglq(it))*M_PI/180.0;\n\t auto sin_t = std::sin(theta);\n\t Q0.col(index++) << sin_t*cos_p, sin_t*sin_p, std::cos(theta);\n\t}\n }\n\n // Write Quadrature points to VTK file\n //writeMatToVTK( Q0, \"QuadPointsOrig.vtk\" );\n\n //**********************************************************************//\n\n VectorXd finput(N);\n // A function to interpolate data to the quadrature points\n auto interpolate = [&points, &Q0, &gridglq, &finput](const size_t i,\n\t const size_t j, const size_t k, const size_t q){\n\tEigen::Vector3d v0 = points.col(i);\n\tEigen::Vector3d v1 = points.col(j);\n\tEigen::Vector3d v2 = points.col(k);\n\tEigen::Vector3d qp = Q0.col(q);\n\tauto A0 = ((v1-qp).cross((v2-qp))).norm();\n\tauto A1 = ((v2-qp).cross((v0-qp))).norm();\n\tauto A2 = ((v0-qp).cross((v1-qp))).norm();\n\tauto A = A0 + A1 + A2;\n\tgridglq(q) = (A0/A)*finput(i) + (A1/A)*finput(j) + (A2/A)*finput(k);\n };\n\n clock_t t = clock();\n for( auto z = 0; z < 1000; ++z){\n\n\t// Project points to unit sphere\n\tpoints.colwise().normalize();\n\n\t// Reset the center of the sphere to origin by translating\n\tVector3d center = points.rowwise().mean();\n\tpoints = points.colwise() - center;\n\n\t// Calculate the function to be expanded using Spherical Harmonics\n\tfor(auto i = 0; i < N; ++i){\n\t Eigen::Vector3d q;\n\t q = points.col(i);\n\t double_t x = q(0);\n\t double_t y = q(1);\n\t double_t z = q(2);\n\t plmon_wrapper_(plms.data(), &lmax, &z);\n\t auto phi = std::atan2(y,x);\n\t finput(i) = 2*Plm(1,1)*std::sin(phi) + Plm(1,0) +\n\t\t3*Plm(1,1)*std::cos(phi);\n\t}\n\n\t// Rotate all points so that the 0th point is along z-axis\n\tVector3d c = points.col(0);\n\tdouble_t cos_t = c(2);\n\tdouble_t sin_t = std::sqrt( 1 - cos_t*cos_t );\n\tVector3d axis;\n\taxis << c(1), -c(0), 0.;\n\taxis.normalize();\n\tMatrix3d rotMat, axis_cross, outer;\n\taxis_cross << 0. , -axis(2), axis(1),\n\t\t axis(2), 0., -axis(0),\n\t\t -axis(1), axis(0), 0.;\n\n\touter.noalias() = axis*axis.transpose();\n\n\trotMat = cos_t*Matrix3d::Identity() + sin_t*axis_cross + (1-cos_t)*outer;\n\tMatrix3Xd rPts(3,N);\n\trPts = rotMat*points; // The points on a sphere rotated\n\n\t// Write the rotated points to VTK\n\t//writeMatToVTK( rPts, \"RotBasePoints.vtk\" );\n\n\t// Calculate the stereographic projections\n\tVector3d p0;\n\tMap3Xd l0( &(rPts(0,1)), 3, N-1 );\n\tMatrix3Xd l(3,N-1), proj(3,N-1);\n\tp0 << 0,0,-1; // Point on the plane of projection\n\tc = rPts.col(0); // The point from which we are projecting\n\tl = (l0.colwise() - c).colwise().normalized(); // dirns of projections\n\tfor( auto j=0; j < N-1; ++j ){\n\t proj.col(j) = ((p0(2) - l0(2,j))/l(2,j))*l.col(j) + l0.col(j);\n\t}\n\n\t// Write the rotated points to VTK\n\t//writeMatToVTK( proj, \"ProjBasePoints.vtk\" );\n\n\t// Insert the projected points in a CGAL vertex_with_info vector\n\tstd::vector< std::pair< Point, unsigned> > verts;\n\tfor( auto j=0; j < N-1; ++j ){\n\t verts.push_back(std::make_pair(Point(proj(0,j),proj(1,j)),j+1));\n\t}\n\n\t// Triangulate\n\tDelaunay dt( verts.begin(), verts.end() );\n\n\t/*\n\t// Write the triangulation to file\n\tvtkNew sphere;\n\tvtkNew sphereTri;\n\tvtkNew spherePts;\n\tfor(auto zz = 0; zz < N; ++zz){\n\tVector3d pp = points.col(zz);\n\tspherePts->InsertNextPoint( &pp(0) );\n\t}\n\tfor( auto fc = dt.all_faces_begin(); fc != dt.all_faces_end(); ++fc ){\n\tsphereTri->InsertNextCell(3);\n\tfor( auto zz = 2; zz >= 0; --zz ){\n\tauto vid = dt.is_infinite( fc->vertex( zz ) )? 0 :\n\tfc->vertex(zz)->info();\n\tsphereTri->InsertCellPoint(vid);\n\t}\n\t}\n\tsphere->SetPoints( spherePts );\n\tsphere->SetPolys( sphereTri );\n\tvtkNew wr;\n\twr->SetInputData( sphere );\n\twr->SetFileName( \"UnitSphere.vtk\" );\n\twr->Write();\n\t*/\n\n\t// Rotate and project the quadrature points\n\tQr = rotMat*Q0; // Rotate the quadrature points\n\n\t// Write the rotated points to VTK\n\t//writeMatToVTK( Qr, \"RotQuadPoints.vtk\" );\n\n\tEigen::Matrix3Xd lQ(3,numQ);\n\tlQ = (Qr.colwise() - c).colwise().normalized();//projn dirn unit vectors\n\tfor( auto j=0; j < numQ; ++j ){\n\t Qsp.col(j) = ((p0(2) - Qr(2,j))/lQ(2,j))*lQ.col(j) + Qr.col(j);\n\t}\n\n\t// Write Stereographic projections of quadrature points to VTK file\n\t//writeMatToVTK( Qsp, \"ProjQuadPoints.vtk\" );\n\n\t// Locate the quadrature points using stereographic triangulation\n\tfor( auto j=0; j < numQ; ++j ){\n\t auto query = Point( Qsp(0,j), Qsp(1,j) );\n\t Delaunay::Locate_type lt;\n\t int li;\n\t Face_handle face = dt.locate( query, lt, li );\n\t switch(lt){\n\t\tcase Delaunay::FACE:\n\t\t {\n\t\t\tauto id0 = face->vertex(0)->info();\n\t\t\tauto id1 = face->vertex(1)->info();\n\t\t\tauto id2 = face->vertex(2)->info();\n\t\t\tinterpolate( id0, id1, id2, j );\n\t\t\tbreak;\n\t\t }\n\t\tcase Delaunay::EDGE:\n\t\t {\n\t\t\tauto id1 = face->vertex( (li + 1)%3 )->info();\n\t\t\tauto id2 = face->vertex( (li + 2)%3 )->info();\n\t\t\tEigen::Vector3d v1, v2, qp;\n\t\t\tv1 = points.col(id1);\n\t\t\tv2 = points.col(id2);\n\t\t\tqp = Q0.col(j);\n\t\t\tdouble_t ratio = (qp - v1).norm()/(qp - v2).norm();\n\t\t\tgridglq(j) = (finput(id1) +\n\t\t\t\tratio*finput(id2))/(1 + ratio);\n\t\t\tbreak;\n\t\t }\n\t\tcase Delaunay::VERTEX:\n\t\t gridglq(j) = finput( face->vertex( li )->info() );\n\t\t break;\n\t\tcase Delaunay::OUTSIDE_CONVEX_HULL:\n\t\t {\n\t\t\tEigen::Vector3d v0, v1, v2;\n\t\t\tauto id0 = dt.is_infinite(face->vertex(0))?\n\t\t\t 0 : face->vertex(0)->info();\n\t\t\tauto id1 = dt.is_infinite(face->vertex(1))?\n\t\t\t 0 : face->vertex(1)->info();\n\t\t\tauto id2 = dt.is_infinite(face->vertex(2))?\n\t\t\t 0 : face->vertex(2)->info();\n\t\t\tinterpolate( id0, id1, id2, j );\n\t\t\tbreak;\n\t\t }\n\t\tdefault:\n\t\t std::cout<< \"Quadrature point \" << j << \" not found!\"\n\t\t\t<< std::endl;\n\t }\n\t}\n\n\t// Expand using Gauss-Legendre Quadrature and get the power spectrum\n\tshexpandglq_wrapper_( cilm.data(), &lmax, gridglq.data(), w.data(),\n\t\tplx.data());\n\tshpowerspectrum_wrapper_( cilm.data(), &lmax, pspectrum.data() );\n }\n t = clock() - t;\n std::cout<< \"Time for 1000 steps GLQ = \" << ((float)t)/CLOCKS_PER_SEC\n\t<< std::endl;\n\n // Cross-check\n Eigen::VectorXd gridglq_out( (lmax + 1)*(2*lmax + 1) );\n makegridglq_wrapper_(gridglq_out.data(), cilm.data(), &lmax, plx.data());\n std::cout<< \"Error norm of GLQ = \" << (gridglq - gridglq_out).norm()\n\t<< std::endl;\n\n // Print the coefficients\n std::cout<< \"l\\tm\\tAlm_GLQ\" << std::endl;\n for( int l = 0; l <= lmax; ++l ){\n\tfor( int m = -l; m <=l; ++m ){\n\t int i = m < 0? 1 : 0;\n\t int n = m < 0? -m: m;\n\t std::cout<< l << \"\\t\" << m << \"\\t\"\n\t\t<< cilm( i + 2*(l + n*(lmax + 1)) )<< \"\\t\"\n\t\t<< std::endl;\n\t}\n }\n return 0;\n}\n", "meta": {"hexsha": "d16ae4ef794348f2c63d7f8fb38c2650eb05f02c", "size": 10416, "ext": "cxx", "lang": "C++", "max_stars_repo_path": "TestSHE.cxx", "max_stars_repo_name": "amit112amit/ops-spherical-harmonics", "max_stars_repo_head_hexsha": "27a0d5e6ed4635d9b1cd6cb1d625d3cc4147beed", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-03-31T13:42:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-31T13:42:53.000Z", "max_issues_repo_path": "TestSHE.cxx", "max_issues_repo_name": "amit112amit/ops-spherical-harmonics", "max_issues_repo_head_hexsha": "27a0d5e6ed4635d9b1cd6cb1d625d3cc4147beed", "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": "TestSHE.cxx", "max_forks_repo_name": "amit112amit/ops-spherical-harmonics", "max_forks_repo_head_hexsha": "27a0d5e6ed4635d9b1cd6cb1d625d3cc4147beed", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.8532110092, "max_line_length": 78, "alphanum_fraction": 0.6213517665, "num_tokens": 3472, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619350028205, "lm_q2_score": 0.6584175005616829, "lm_q1q2_score": 0.5428401665528058}} {"text": "// Copyright 2002 - 2008, 2010, 2011 National Technology Engineering\n// Solutions of Sandia, LLC (NTESS). Under the terms of Contract\n// DE-NA0003525 with NTESS, the U.S. Government retains certain rights\n// in this software.\n//\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n#ifndef percept_math_TransformationMatrix_hpp\n#define percept_math_TransformationMatrix_hpp\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \n\n#include \n#include \n#include \n\n#include \n#include \n\nnamespace percept {\n\n namespace ublas = boost::numeric::ublas;\n\n class Math\n {\n public:\n\n typedef ublas::c_matrix Matrix;\n\n typedef ublas::c_vector Vector;\n\n typedef ublas::c_vector ubvec;\n\n class MyVector : public ubvec\n {\n public:\n\n MyVector(double x=0.0) : ubvec()\n {\n (*this)(0) = x;\n (*this)(1) = x;\n (*this)(2) = x;\n }\n\n MyVector(double *x) : ubvec()\n {\n (*this)(0) = x[0];\n (*this)(1) = x[1];\n (*this)(2) = x[2];\n }\n //Vector(const ubvec& v) : ubvec(v) {}\n\n MyVector& operator=(const ubvec& v)\n {\n //ubvec& v0 = ubvec::operator=(v);\n (*this)(0) = v(0);\n (*this)(1) = v(1);\n (*this)(2) = v(2);\n return *this;\n }\n\n //v = ublas::prod(m_rotMat, v);\n\n };\n\n static double my_abs_hi(double x, double eps=1.e-6) { return std::sqrt(x*x + eps*eps); }\n static double my_min_hi(double x, double y, double eps=1.e-6) { return 0.5*(x+y - my_abs_hi(x-y,eps)); }\n static double my_max_hi(double x, double y, double eps=1.e-6) { return 0.5*(x+y + my_abs_hi(x-y,eps)); }\n // heavyside\n static double heavy_smooth(double x, double x0, double eps=1.e-6) { return 1./(1.+std::exp(-2.0*(x-x0)/eps)); }\n\n static double random01()\n {\n double rnd = Teuchos::ScalarTraits::random();\n return (rnd+1.0)/2.0;\n }\n\n static Matrix rotationMatrix(int axis, double angle_degrees)\n {\n Matrix rm;\n rm.clear();\n double theta = M_PI * angle_degrees / 180.0;\n double cost = std::cos(theta);\n double sint = std::sin(theta);\n if (axis == 2)\n {\n rm(0,0) = cost; rm(0,1) = -sint;\n rm(1,0) = sint; rm(1,1) = cost;\n rm(2,2) = 1.0;\n }\n else if (axis == 1)\n {\n rm(0,0) = cost; rm(0,2) = -sint;\n rm(2,0) = sint; rm(2,2) = cost;\n rm(1,1) = 1.0;\n }\n else if (axis == 0)\n {\n rm(1,1) = cost; rm(1,2) = -sint;\n rm(2,1) = sint; rm(2,2) = cost;\n rm(0,0) = 1.0;\n }\n return rm;\n }\n\n static Matrix scalingMatrix(int axis, double scale)\n {\n Matrix sm;\n sm.clear();\n sm(0,0)=1.0;\n sm(1,1)=1.0;\n sm(2,2)=1.0;\n sm(axis,axis)=scale;\n return sm;\n }\n\n static Matrix scalingMatrix( double scale)\n {\n Matrix sm;\n sm.clear();\n sm(0,0)=scale;\n sm(1,1)=scale;\n sm(2,2)=scale;\n return sm;\n }\n\n static double norm_3d(const double * vec)\n {\n double norm = std::sqrt(vec[0]*vec[0]+\n vec[1]*vec[1]+\n vec[2]*vec[2]);\n return norm;\n }\n\n static void normalize_3d(double * vec)\n {\n double norm = norm_3d(vec);\n if (norm > 0.0)\n {\n vec[0] /= norm;\n vec[1] /= norm;\n vec[2] /= norm;\n }\n else\n {\n std::cout << \"norm= \" << vec[0] << \", \" << vec[1] << \", \" << vec[2] << \"\\n\"\n << Stacktrace::demangled_stacktrace(30) << std::endl;\n VERIFY_MSG(\"bad norm\");\n }\n }\n static void cross_3d(const double * a, const double * b, double * axb)\n {\n axb[0] = (a[1]*b[2]-a[2]*b[1]);\n axb[1] = -(a[0]*b[2]-a[2]*b[0]);\n axb[2] = (a[0]*b[1]-a[1]*b[0]);\n }\n static double dot_3d(const double *a, const double *b)\n {\n return a[0]*b[0] + a[1]*b[1] + a[2]*b[2];\n }\n static double distance_squared_3d(const double *a, const double *b)\n {\n return (a[0]-b[0])*(a[0]-b[0]) + (a[1]-b[1])*(a[1]-b[1]) + (a[2]-b[2])*(a[2]-b[2]);\n }\n static double distance_3d(const double *a, const double *b)\n {\n return std::sqrt(distance_squared_3d(a,b));\n }\n static void copy_3d(double *a, const double *b)\n {\n a[0] = b[0];\n a[1] = b[1];\n a[2] = b[2];\n }\n static void copy_2d(double *a, const double *b)\n {\n a[0] = b[0];\n a[1] = b[1];\n }\n static std::string print_3d(const double *a, int prec=6)\n {\n std::ostringstream ostr;\n ostr << std::setprecision(prec);\n ostr << \" \" << a[0] << \", \" << a[1] << \", \" << a[2];\n return ostr.str();\n }\n static std::string print_2d(const double *a, int prec=6)\n {\n std::ostringstream ostr;\n ostr << std::setprecision(prec);\n ostr << \" \" << a[0] << \", \" << a[1];\n return ostr.str();\n }\n static void subtract_3d(double *a, const double *b)\n {\n a[0] -= b[0];\n a[1] -= b[1];\n a[2] -= b[2];\n }\n\n static double project_to_line_3d(const double *a, const double *b, double *xyz, double& u)\n {\n double xma[3] = {0,0,0}, bma[3] = {0,0,0}, bman[3] = {0,0,0}, xyz_in[3] = {0,0,0};\n copy_3d(xyz_in, xyz);\n copy_3d(bma, b);\n subtract_3d(bma, a);\n copy_3d(xma, xyz);\n subtract_3d(xma, a);\n copy_3d(bman, bma);\n normalize_3d(bman);\n double dd = dot_3d(xma, bman);\n double ba_len = distance_3d(a, b);\n if (dd < 0.0)\n {\n u = 0.0;\n copy_3d(xyz, a);\n }\n else if (dd > ba_len)\n {\n u = 1.0;\n copy_3d(xyz, b);\n }\n else\n {\n u = dd/ba_len;\n xyz[0] = a[0] + u*(b[0] - a[0]);\n xyz[1] = a[1] + u*(b[1] - a[1]);\n xyz[2] = a[2] + u*(b[2] - a[2]);\n }\n return distance_3d(xyz, xyz_in);\n }\n };\n\n inline Math::Vector operator*(Math::Matrix& mat, Math::Vector& vec) { return ublas::prod(mat, vec); }\n inline Math::Matrix operator*(Math::Matrix& mat, Math::Matrix& mat2) { return ublas::prod(mat, mat2); }\n\n}\n\n#endif\n", "meta": {"hexsha": "57128b74236cd3d7657bb454d72c8992949b0199", "size": 6481, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/percept/math/Math.hpp", "max_stars_repo_name": "jrood-nrel/percept", "max_stars_repo_head_hexsha": "363cdd0050443760d54162f140b2fb54ed9decf0", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2017-08-08T21:06:02.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-08T13:23:36.000Z", "max_issues_repo_path": "src/percept/math/Math.hpp", "max_issues_repo_name": "jrood-nrel/percept", "max_issues_repo_head_hexsha": "363cdd0050443760d54162f140b2fb54ed9decf0", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2016-12-17T00:18:56.000Z", "max_issues_repo_issues_event_max_datetime": "2019-08-09T15:29:25.000Z", "max_forks_repo_path": "src/percept/math/Math.hpp", "max_forks_repo_name": "jrood-nrel/percept", "max_forks_repo_head_hexsha": "363cdd0050443760d54162f140b2fb54ed9decf0", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2017-11-30T07:02:41.000Z", "max_forks_repo_forks_event_max_datetime": "2019-08-05T17:07:04.000Z", "avg_line_length": 25.8207171315, "max_line_length": 115, "alphanum_fraction": 0.5096435735, "num_tokens": 2167, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619177503206, "lm_q2_score": 0.658417487156366, "lm_q1q2_score": 0.5428401441412847}} {"text": "#ifndef NBT_DYNAMICS_ENGINE_HPP\n#define NBT_DYNAMICS_ENGINE_HPP\n\n#include \n#include \"octree.hpp\"\n#include \"units.hpp\"\n\n/**\n * Abstract class for Dynamics engines.\n * Used to update the accelerations of a set of\n * particles based on their positions and masses.\n */\nclass DynamicsEngine {\n public:\n /**\n * @brief Recalculates acceleration matrix using object positions and masses\n * \n * @param a Acceleration matrix\n * @param x Position matrix\n * @param m Mass vector\n */\n virtual void updateAccelerations(Eigen::Ref a,\n const Eigen::Ref& x,\n const Eigen::Ref& m) = 0;\n \n /**\n * @brief Updates the individual acceleration between particles i and j\n * \n * @param a_i Acceleration of i\n * @param x_i Position of i\n * @param x_j Position of j\n * @param m_i Mass of i\n * @param m_j Mass of j\n */\n virtual void pairAcceleration(Eigen::Ref a_i,\n const Eigen::Vector3d& x_i,\n const Eigen::Vector3d& x_j,\n double m_i,\n double m_j) = 0;\n \n /**\n * @brief Returns the potential energy of a system based on particle positions and masses.\n * \n * @param x Position matrix\n * @param m Mass vector\n * \n * @return double\n */\n double totalPotentialEnergy(const Eigen::Ref& x,\n const Eigen::Ref& m);\n \n /**\n * @brief Returns the potential energy between a pair of particles i and j.\n * Default abstract class method returns zero for everything, can be overriden\n * in custom subclasses.\n * \n * @param x_i Position of i\n * @param x_j Position of j\n * @param m_i Mass of i\n * @param m_j Mass of j\n * @return double \n */\n virtual double pairPotentialEnergy(const Eigen::Vector3d& x_i,\n const Eigen::Vector3d& x_j,\n double m_i,\n double m_j);\n};\n\n\n/* ABSTRACT CLASSES FOR N-BODY UPDATE METHODS */\n/* Implements DynamicsEngine::updateAccelerations() */\n\n\n/**\n * Computes force directly between every pair of objects. O(n^2)\n */\nclass Abstract_Direct: public DynamicsEngine {\n public:\n /**\n * @brief Computes force between each pair of particles individually.\n * \n * @param a\n * @param x\n * @param m\n */\n void updateAccelerations(Eigen::Ref a,\n const Eigen::Ref& x,\n const Eigen::Ref& m) override;\n};\n\n\n/**\n * A multithreaded Barnes-Hut force computer. O(nlogn)\n */\nclass Abstract_BarnesHut: public DynamicsEngine {\n public:\n OctreeNode* root; //!< Root node of the Barnes-Hut tree.\n const double theta; //!< Theta parameter for Barnes-Hut algorithm\n \n /**\n * @brief Construct a Abstract_Direct object.\n * \n * @param theta Theta parameter for the Barnes-Hut algorithm\n */\n Abstract_BarnesHut(double theta);\n\n /**\n * @brief Destroy the Abstract_BarnesHut object\n */\n ~Abstract_BarnesHut();\n \n /**\n * @brief Function for threads. Computes the acceleration of bodies from indices startIdx to endIdx (endIdx not included)\n * \n * @param a\n * @param x \n * @param m \n * @param startIdx\n * @param endIdx\n */\n void threadUpdateAccelerations(Eigen::Ref a,\n const Eigen::Ref& x,\n const Eigen::Ref& m,\n int startIdx,\n int endIdx);\n\n /**\n * @brief Computes forces acting on each particle using the Barnes-Hut algorithm\n * \n * @param a \n * @param x \n * @param m \n */\n void updateAccelerations(Eigen::Ref a,\n const Eigen::Ref& x,\n const Eigen::Ref& m) override;\n};\n\n\n/* SPECIFIC DYNAMICS ENGINES */\n/* Implement DynamicsEngine::pairAccleration() */\n\n\nclass Gravitational_Direct: public Abstract_Direct {\n public:\n const double G;\n const double softening;\n\n /**\n * @brief Construct a new Gravitational_Direct object\n * \n * @param softening Softening parameter\n * @param l Unit of length\n * @param m Unit of mass\n * @param t Unit of time\n */\n Gravitational_Direct(double softening, unit_t l = Unit::Meter, unit_t m = Unit::Kilogram, unit_t t = Unit::Second);\n\n /**\n * @brief Computes acceleration from Newtonian gravitation between two particles i and j\n * \n * @param a_i \n * @param x_i \n * @param x_j \n * @param m_i \n * @param m_j \n */\n void pairAcceleration(Eigen::Ref a_i,\n const Eigen::Vector3d& x_i,\n const Eigen::Vector3d& x_j,\n double m_i,\n double m_j) override;\n \n /**\n * @brief Returns the gravitational potential energy between a pair of particles i and j.\n * \n * @param x_i Position of i\n * @param x_j Position of j\n * @param m_i Mass of i\n * @param m_j Mass of j\n * @return double \n */\n double pairPotentialEnergy(const Eigen::Vector3d& x_i,\n const Eigen::Vector3d& x_j,\n double m_i,\n double m_j) override;\n};\n\n\nclass Gravitational_BarnesHut: public Abstract_BarnesHut {\n public:\n const double G;\n const double softening;\n\n /**\n * @brief Construct a new Gravitational_Direct object\n * \n * @param theta Theta parameter for the Barnes-Hut algorithm\n * @param softening Softening parameter\n * @param l Unit of length\n * @param m Unit of mass\n * @param t Unit of time\n */\n Gravitational_BarnesHut(double theta, double softening, unit_t l = Unit::Meter, unit_t m = Unit::Kilogram, unit_t t = Unit::Second);\n\n /**\n * @brief Computes acceleration from Newtonian gravitation between two particles i and j\n * \n * @param a_i \n * @param x_i \n * @param x_j \n * @param m_i \n * @param m_j \n */\n void pairAcceleration(Eigen::Ref a_i,\n const Eigen::Vector3d& x_i,\n const Eigen::Vector3d& x_j,\n double m_i,\n double m_j) override;\n \n /**\n * @brief Returns the gravitational potential energy between a pair of particles i and j.\n * \n * @param x_i Position of i\n * @param x_j Position of j\n * @param m_i Mass of i\n * @param m_j Mass of j\n * @return double \n */\n double pairPotentialEnergy(const Eigen::Vector3d& x_i,\n const Eigen::Vector3d& x_j,\n double m_i,\n double m_j) override;\n};\n\n\n#endif", "meta": {"hexsha": "ddd221bc09ef3b10219864b4c6f15e2b94e6cbf1", "size": 8094, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/dynamics_engine.hpp", "max_stars_repo_name": "tdude92/nbody-tool", "max_stars_repo_head_hexsha": "cf8feedb974c5d23a0ab6981d8ccbeab35aeacb0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2021-11-12T08:20:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-06T19:37:44.000Z", "max_issues_repo_path": "include/dynamics_engine.hpp", "max_issues_repo_name": "tdude92/nbody-tool", "max_issues_repo_head_hexsha": "cf8feedb974c5d23a0ab6981d8ccbeab35aeacb0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/dynamics_engine.hpp", "max_forks_repo_name": "tdude92/nbody-tool", "max_forks_repo_head_hexsha": "cf8feedb974c5d23a0ab6981d8ccbeab35aeacb0", "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.1518987342, "max_line_length": 140, "alphanum_fraction": 0.511242896, "num_tokens": 1730, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802370707283, "lm_q2_score": 0.705785040214066, "lm_q1q2_score": 0.5428053260488074}} {"text": "// Copyright 2015 Rainer Gemulla\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/** \\file\n *\n * A simple example that demonstrates the usage of mpi2. Spawns a couple of tasks that each run\n * Monte Carlo integration to estimate the value of pi; then averages and outputs the result.\n */\n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \n#include \n\n#include \n\nusing namespace std;\nusing namespace mpi2;\nusing namespace rg;\n\nlog4cxx::LoggerPtr logger(log4cxx::Logger::getLogger(\"main\"));\n\n/** Task that computes pi via Monte Carlo integration */\nstruct PiTask {\n\tstatic inline string id() { return \"PiTask\"; }\n\tstatic inline void run(Channel ch, TaskInfo info) {\n\t\t// receive the seed for the random number generator\n\t\tRandom32 random = getSeed(ch);\n\n\t\t// receive the number of iterations to perform\n\t\tunsigned n;\n\t\tch.recv(n);\n\n\t\t// run Monte Carlo integration\n\t\tLOG4CXX_INFO(logger, \"Task \" << info.groupId() << \": Generating \" << n\n\t\t\t\t<< \" MC samples\");\n\t\tint count = 0;\n\t\tfor (unsigned i=0; i();\n\n\t// fire up task managers (this blocks on all but the root node)\n\tmpi2start();\n\n\t// main driver; only executed at root rank\n\tif (world.rank() == 0) {\n\t\t// spawn 3 copies of PiTask at each rank\n\t\tstd::vector channels;\n\t\tint threads = 3;\n\t\ttm.spawnAll(threads, channels);\n\n\t\t// send them each a different random number seed\n\t\tRandom32 random; // note: this takes a default seed (not randomized!)\n\t\tseed(channels, random);\n\n\t\t// send them the number of samples to take\n\t\tsendAll(channels, 100000); // each thread computes 100000 samples\n\n\t\t// receive the results\n\t\tstd::vector results(channels.size());\n\t\trecvAll(channels, results);\n\n\t\t// aggregate and output the result\n\t\tdouble pi = std::accumulate(results.begin(), results.end(), 0.) / channels.size();\n\t\tLOG4CXX_INFO(logger, \"Estimate of pi: \" << pi);\n\t}\n\n\t// shut down task managers\n\tmpi2stop();\n\n\t// shut down mpi2 and mpi\n\tmpi2finalize();\n\n\treturn 0;\n}\n", "meta": {"hexsha": "265886f4cf5a793fc4584d2ae42439c818f25712", "size": 3221, "ext": "cc", "lang": "C++", "max_stars_repo_path": "examples/pi_task.cc", "max_stars_repo_name": "Hui-Li/mpi2", "max_stars_repo_head_hexsha": "40c09937a16f6ccc0bea9dafcc8aa731da4b8d38", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2018-08-02T15:06:08.000Z", "max_stars_repo_stars_event_max_datetime": "2019-05-29T08:57:05.000Z", "max_issues_repo_path": "examples/pi_task.cc", "max_issues_repo_name": "uma-pi1/mpi2", "max_issues_repo_head_hexsha": "1b00acefa50d672e79c8d9238f2966471e70b8e3", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2018-08-02T15:08:57.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-15T07:13:06.000Z", "max_forks_repo_path": "examples/pi_task.cc", "max_forks_repo_name": "Hui-Li/mpi2", "max_forks_repo_head_hexsha": "40c09937a16f6ccc0bea9dafcc8aa731da4b8d38", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-01-17T08:52:54.000Z", "max_forks_repo_forks_event_max_datetime": "2019-01-17T08:52:54.000Z", "avg_line_length": 29.2818181818, "max_line_length": 95, "alphanum_fraction": 0.6845700093, "num_tokens": 846, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802264851919, "lm_q2_score": 0.7057850340255386, "lm_q1q2_score": 0.5428053138182202}} {"text": "/**\n* @file mdm_ParamSummaryStats.cxx\n* @brief Implementation of mdm_ParamSummaryStats class\n*\n* Original author MA Berks 13 Nov 2020\n* (c) Copyright QBI, University of Manchester 2020\n*/\n\n#ifndef MDM_API_EXPORTS\n#define MDM_API_EXPORTS\n#endif // !MDM_API_EXPORTS\n\n#include \"mdm_ParamSummaryStats.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nconst std::vector mdm_ParamSummaryStats::headers_ = {\n\t\"param\",\n\t\"n_valid\",\n\t\"n_invalid\",\n\t\"mean\",\n\t\"stddev\",\n\t\"median\",\n\t\"lowerQ\",\n\t\"upperQ\",\n\t\"iqr\"\n};\n\n//!Helper function to compute percentile of vector of values\ndouble percentile(const std::vector &A, const double &prct)\n{\n\t//We only ever call this function for 25,50 and 100, but for completeness\n\tassert(prct >= 0 && prct <= 100.0);\n\tif (prct == 0)\n\t\treturn A[0];\n\tif (prct == 100)\n\t\treturn A.back();\n\n\t//See https://en.wikipedia.org/wiki/Quartile#Method_4\n\tdouble n1 = (double)A.size() + 1;\n\tdouble pn1 = n1 * prct / 100.00;\n\tsize_t k = size_t(std::floor(pn1));\n\n\t//If size A < 3, then k = 0 for prctile(25) and k = 3 for prctile(75)\n\tif (!k)\n\t\treturn A[0];\n\telse if (k == A.size())\n\t\treturn A.back();\n\n\tdouble alpha = pn1 - k;\n\treturn A[k - 1] + alpha * (A[k] - A[k - 1]);//Remember indexing starts at 0 in cxx\n\n\t/*double x = (double)A.size() * prct / 100.00;\n\tint i2 = std::floor(x); \n\tint i1 = i2 - 1;\n\tdouble m1 = 0.5 - (x - (double)i2);\n\tdouble m2 = 1.0 - m1;\n\treturn A[i1] * m1 + A[i2] * m2;*/\n}\n\n//\nMDM_API mdm_ParamSummaryStats::mdm_ParamSummaryStats()\n\t:\n\troiIdx_(0)\n{\n\n}\n\n//\nMDM_API mdm_ParamSummaryStats::~mdm_ParamSummaryStats()\n{\n\tcloseNewStatsFile();\n}\n\n//!Set ROI\nMDM_API void mdm_ParamSummaryStats::setROI(const mdm_Image3D& roi)\n{\n\t//Don't store the image, just save the non-zero IDX\n\troiIdx_.clear();\n\tfor (int i = 0; i < roi.numVoxels(); i++)\n\t{\n\t\tif (roi.voxel(i))\n\t\t\troiIdx_.push_back(i);\n\t}\n\t\t\n\txmm_ = roi.info().Xmm.value();\n\tymm_ = roi.info().Ymm.value();\n\tzmm_ = roi.info().Zmm.value();\n}\n\n//!Make output stats for an image given an ROI\nMDM_API void mdm_ParamSummaryStats::makeStats(const mdm_Image3D& img, const std::string ¶mName, \n\tconst double scale, bool invert)\n{\n\t//Set param name\n\tstats_.paramName_ = paramName;\n\n\t//Check ROI idx are set\n\tcheckIdx(img);\n\n\t//Reset the stats\n\tstats_.reset();\n\n\t// loop image extracting parameter values and taking running sum\n\tdouble ROI_sum = 0.0;\n\tdouble ROI_sumsq = 0.0;\n\n\tstd::vector paramVals;\n\tfor (const auto &idx : roiIdx_)\n\t{\n\t\t// Get value from image\n\t\tdouble voxValue = scale * img.voxel(idx);\n\n\t\tif (std::isnan(voxValue))\n\t\t{\n\t\t\tstats_.invalidVoxels_++;\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (invert)\n\t\t{\n\t\t\t//Can't invert negative values, just skip\n\t\t\tif (voxValue <= 0.0)\n\t\t\t{\n\t\t\t\tstats_.invalidVoxels_++;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\t\t\n\n\t\t\telse\n\t\t\t\tvoxValue = 1 / voxValue;\n\t\t}\n\n\t\t//Increment sums and save value\n\t\tROI_sum += voxValue;\n\t\tROI_sumsq += voxValue * voxValue;\n\t\tparamVals.push_back(voxValue);\n\t\tstats_.validVoxels_++;\n\t}\n\n\t//If we haven't got any voxels, return\n\tif (!stats_.validVoxels_)\n\t\treturn;\n\n\telse if (stats_.validVoxels_ == 1)\n\t{\n\t\tstats_.mean_ = paramVals[0];\n\t\tstats_.median_ = paramVals[0];\n\t\tstats_.lowerQ_ = paramVals[0];\n\t\tstats_.upperQ_ = paramVals[0];\n\n\t\t//std and iqr are 0\n\t\treturn;\n\t}\n\n\t//Compute summary stats from data values\n\t//Sort the data arrays\n\tstd::sort(paramVals.begin(), paramVals.end());\n\n\t//Compute mean and std\n\tdouble validVoxels = (double)stats_.validVoxels_;\n\tstats_.mean_ = ROI_sum / validVoxels;\n\n\t// This is the unbiased estimator for the sd of the parent distribution ... i.e. strong gaussian assumption\n\tstats_.stddev_ = sqrt((ROI_sumsq - ROI_sum * ROI_sum /\n\t\tvalidVoxels) / (validVoxels - 1));\n\n\t//Compute median and IQR\n\tstats_.median_ = percentile(paramVals, 50);\n\tstats_.lowerQ_ = percentile(paramVals, 25);\n\tstats_.upperQ_ = percentile(paramVals, 75);\n\tstats_.iqr_ = stats_.upperQ_ - stats_.lowerQ_;\n}\n\nMDM_API const mdm_ParamSummaryStats::SummaryStats& mdm_ParamSummaryStats::stats() const\n{\n\treturn stats_;\n}\n\n//\nMDM_API void mdm_ParamSummaryStats::writeROISummary(const std::string &roiFile)\n{\n\tstd::ofstream roiStream(roiFile);\n\tif (!roiStream)\n\t throw mdm_exception(__func__, boost::format(\"Failed to open stats file %1%\") % roiFile);\n\t\t\n\n\tdouble nVoxels = (double)roiIdx_.size();\n\troiStream <<\n\t\t\"number_of_voxels = \" << nVoxels <<\n\t\t\" volume = \" << nVoxels * xmm_ * ymm_ * zmm_;\n}\n\n//\nMDM_API void mdm_ParamSummaryStats::openNewStatsFile(const std::string &statsFile)\n{\n\tstatsOStream_.open(statsFile, std::ios::out);\n\tif (!statsOStream_)\n throw mdm_exception(__func__, boost::format(\"Failed to open stats file %1%\") % statsFile);\n\n\t//Write stats headers\n\tfor (const auto hdr : headers_)\n\t\tstatsOStream_ << hdr << \",\";\n\t\n\tstatsOStream_ << \"\\n\";\n\n}\n\n//\nMDM_API void mdm_ParamSummaryStats::closeNewStatsFile()\n{\n\tif (statsOStream_)\n\t\tstatsOStream_.close();\n\n}\n\n//\nMDM_API void mdm_ParamSummaryStats::writeStats()\n{\n\tif (!statsOStream_.is_open())\n throw mdm_exception(__func__, \n \"Tried to write stats, but no stats file open\");\n\n\tstatsOStream_ <<\n\t\tstats_.paramName_ << \",\" <<\n\t\tstats_.validVoxels_ << \",\" <<\n\t\tstats_.invalidVoxels_ << \",\" <<\n\t\tstats_.mean_ << \",\" <<\n\t\tstats_.stddev_ << \",\" <<\n\t\tstats_.median_ << \",\"<<\n\t\tstats_.lowerQ_ << \",\" <<\n\t\tstats_.upperQ_ << \",\" <<\n\t\tstats_.iqr_ << \",\\n\";\n\n}\n\n//\nMDM_API void mdm_ParamSummaryStats::openStatsFile(const std::string &statsFile)\n{\n\tstatsIStream_.open(statsFile, std::ios::in);\n\tif (!statsIStream_)\n throw mdm_exception(__func__, boost::format(\"Failed to open stats file %1%\") % statsFile);\n\n\t//Write stats headers\n\tstd::string hdr_in;\n\tfor (const auto hdr : headers_)\n\t{\n\t\tstd::getline(statsIStream_, hdr_in, ',');\n\t\tif (hdr_in != hdr)\n throw mdm_exception(__func__, boost::format(\"Incorrect headers in %1%, cannot open\") % statsFile);\n\t}\n\t//Get rid of final comma to \\n part\n\tstd::getline(statsIStream_, hdr_in);\n}\n\n//\nMDM_API void mdm_ParamSummaryStats::closeStatsFile()\n{\n\tif (statsIStream_)\n\t\tstatsIStream_.close();\n}\n\n//\nMDM_API void mdm_ParamSummaryStats::readStats()\n{\n\tif (!statsIStream_.is_open())\n throw mdm_exception(__func__,\n \"Tried to read stats, but no stats file open\");\n\n\tstd::getline(statsIStream_, stats_.paramName_, ',');\n\n\tstd::string val;\n\tstd::getline(statsIStream_, val, ',');\n\tstats_.validVoxels_ = std::stoi(val);\n\n\tstd::getline(statsIStream_, val, ',');\n\tstats_.invalidVoxels_ = std::stoi(val);\n\n\tstd::getline(statsIStream_, val, ',');\n\tstats_.mean_ = std::stod(val);\n\n\tstd::getline(statsIStream_, val, ',');\n\tstats_.stddev_ = std::stod(val);\n\n\tstd::getline(statsIStream_, val, ',');\n\tstats_.median_ = std::stod(val);\n\n\tstd::getline(statsIStream_, val, ',');\n\tstats_.lowerQ_ = std::stod(val);\n\n\tstd::getline(statsIStream_, val, ',');\n\tstats_.upperQ_ = std::stod(val);\n\n\tstd::getline(statsIStream_, val, ',');\n\tstats_.iqr_ = std::stod(val);\n\n\t//Get rid of final comma to \\n part\n\tstd::getline(statsIStream_, val);\n}\n\n//------------------------------------------------------------------------\n// Private\n//------------------------------------------------------------------------\nvoid mdm_ParamSummaryStats::checkIdx(const mdm_Image3D& img)\n{\n\tif (roiIdx_.empty())\n\t{\n\t\tfor (int i = 0; i < img.numVoxels(); i++)\n\t\t\troiIdx_.push_back(i);\n\t}\n\n\txmm_ = img.info().Xmm.value();\n\tymm_ = img.info().Ymm.value();\n\tzmm_ = img.info().Zmm.value();\n}\n", "meta": {"hexsha": "22420ae8c3b295e76ee913278bd84941c56b8981", "size": 7409, "ext": "cxx", "lang": "C++", "max_stars_repo_path": "madym/mdm_ParamSummaryStats.cxx", "max_stars_repo_name": "michaelberks/madym_cxx", "max_stars_repo_head_hexsha": "647b6e59a3ef7aa6b3f3f58e16d23dc313b7dd16", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-10-04T15:43:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-04T15:43:15.000Z", "max_issues_repo_path": "madym/mdm_ParamSummaryStats.cxx", "max_issues_repo_name": "michaelberks/madym_cxx", "max_issues_repo_head_hexsha": "647b6e59a3ef7aa6b3f3f58e16d23dc313b7dd16", "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": "madym/mdm_ParamSummaryStats.cxx", "max_forks_repo_name": "michaelberks/madym_cxx", "max_forks_repo_head_hexsha": "647b6e59a3ef7aa6b3f3f58e16d23dc313b7dd16", "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": 23.0809968847, "max_line_length": 108, "alphanum_fraction": 0.661762721, "num_tokens": 2263, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802370707281, "lm_q2_score": 0.7057850216484838, "lm_q1q2_score": 0.5428053117703849}} {"text": "/**\n * @date Tue Jan 10 21:14 2016 +0100\n * @author Tiago de Freitas Pereira \n *\n * Copyright (C) Idiap Research Institute, Martigny, Switzerland\n */\n\n#include \n#include \n\n#include \n\n#include \n#include \n#include \n#include \n\n\n// Declaration of the external LAPACK function (Divide and conquer SVD)\nextern \"C\" void dggsvd3_(const char *jobu,\n const char *jobv, \n const char *jobq,\n const int *M,\n const int *N,\n const int *P,\n const int *K,\n const int *L,\n double *A, \n const int *lda, \n double *B, \n const int *ldb,\n double *alpha,\n double *beta,\n double *U,\n const int *ldu, \n double *V,\n const int *ldv, \n double *Q,\n const int *ldq, \n double *work,\n const int *lwork,\n int *iwork,\n int *info);\n\n\nvoid bob::math::gsvd( blitz::Array& A,\n blitz::Array& B,\n blitz::Array& U,\n blitz::Array& V,\n blitz::Array& zeroR,\n blitz::Array& Q,\n blitz::Array& X,\n blitz::Array& C,\n blitz::Array& S)\n{\n const char jobu = 'U';\n const char jobv = 'V';\n const char jobq = 'Q';\n\n // Size variables\n const int M = A.extent(0);\n const int N = A.extent(1);\n const int P = B.extent(0);\n \n const int lda = std::max(1,M);\n const int ldb = std::max(1,P);\n const int ldu = std::max(1,M);\n const int ldv = std::max(1,P);\n const int ldq = std::max(1,N);\n \n int K = 0; //out\n int L = 0; //out \n \n // Prepares to call LAPACK function:\n // We will decompose A^T rather than A and B^T rather than B to reduce the required number of copy\n // We recall that FORTRAN/LAPACK is column-major order whereas blitz arrays\n // are row-major order by default.\n\n //A_lapack = A^T\n blitz::Array A_blitz_lapack(bob::core::array::ccopy(const_cast&>(A).transpose(1,0)));\n double* A_lapack = A_blitz_lapack.data();\n\n\n //B_lapack = B^T\n blitz::Array B_blitz_lapack(bob::core::array::ccopy(const_cast&>(B).transpose(1,0)));\n double* B_lapack = B_blitz_lapack.data();\n \n \n // U. We will trainpose this one in the end\n double *U_lapack = U.data();\n\n // V. We will trainpose this one in the end\n double *V_lapack = V.data();\n\n // For Q, we will return the transpose \n double *Q_lapack = Q.data();\n\n // In LAPACK C and S is 1-d. Our code makes it diagonal\n blitz::Array C_1d(N); C_1d = 0;\n double *C_lapack = C_1d.data();\n \n blitz::Array S_1d(N); S_1d = 0;\n double *S_lapack = S_1d.data();\n\n const int lwork_query = -1;\n double work_query;\n\n boost::shared_array iwork(new int[N]);\n\n int info = 0;\n // A/ Queries the optimal size of the working array\n \n dggsvd3_(&jobu,\n &jobv, \n &jobq,\n &M,\n &N,\n &P,\n &K,\n &L,\n A_lapack, \n &lda, \n B_lapack, \n &ldb,\n C_lapack,\n S_lapack,\n U_lapack,\n &ldu, \n V_lapack,\n &ldv, \n Q_lapack,\n &ldq, \n &work_query,\n &lwork_query,\n iwork.get(),\n &info);\n \n if (info != 0)\n throw std::runtime_error(\"The LAPACK dggsvd3 function returned a non-zero value during the checking\");\n\n // B/ Computes\n \n const int lwork = static_cast(work_query);\n boost::shared_array work(new double[lwork]);\n \n dggsvd3_(&jobu,\n &jobv, \n &jobq,\n &M,\n &N,\n &P,\n &K,\n &L,\n A_lapack, \n &lda, \n B_lapack, \n &ldb,\n C_lapack,\n S_lapack,\n U_lapack,\n &ldu, \n V_lapack,\n &ldv, \n Q_lapack,\n &ldq, \n work.get(),\n &lwork,\n iwork.get(),\n &info);\n if (info != 0)\n throw std::runtime_error(\"The LAPACK dggsvd3 function returned a non-zero value during the computation.\");\n \n\n /* \n According to the website http://www.netlib.org/lapack/explore-html/d1/d7e/group__double_g_esing_ga4a187519e5c71da3b3f67c85e9baf0f2.html#ga4a187519e5c71da3b3f67c85e9baf0f2\n \n if (M-K-L >= 0)\n N-K-L K L\n ( 0 R ) = K ( 0 R11 R12 )\n L ( 0 0 R22 )\n \n \n Where R11, R12, R22, = A(1:K+L,N-K-L+1:N)\n \n else\n \n N-K-L K M-K K+L-M\n ( 0 R ) = K ( 0 R11 R12 R13 )\n M-K ( 0 0 R22 R23 )\n K+L-M ( 0 0 0 R33 )\n\n\n where R11, R12, R13, R22, R23 = A(1:M, N-K-L+1:N)\n where R33 = B(M-K+1:L,N+M-K-L+1:N)\n\n */\n int r = K + L; //Dimension of R\n C.resize(M, r);\n S.resize(P, r);\n S = 0;\n C = 0;\n zeroR.resize(r, N);\n zeroR = 0;\n X.resize(r,N);\n if (M-K-L >= 0){\n\n //1. First we need the [0 R], which has the shape (N-K-L + K + L, K+L) \n zeroR(blitz::Range(0, r-1), blitz::Range(N-r, N-1)) = A_blitz_lapack.transpose(1,0)(blitz::Range(0,r-1), blitz::Range(N-r,N-1));\n // 2. Now we have to deal with C and S according to http://www.netlib.org/lapack/lug/node36.html\n // In the end C is m-by-r and is p-by-r, both are real, nonnegative and diagonal and C'C + S'S = I ,\n // They have the following structure \n // COPY AND PASTE\n\n //2.1 Preparing C\n // K L\n // C = K ( I 0 )\n // L ( 0 C )\n // M-K-L ( 0 0 )\n \n // A - Identity part\n if (K>0){\n blitz::Array I (K,K); I= 0;\n bob::math::eye_(I);\n C(blitz::Range(0, K-1), blitz::Range(0, K-1)) = I;\n }\n // B - diag(C) part. Here the C is LxL\n // Swaping\n \n bob::math::swap_(C_1d, iwork.get(), K, std::min(M,r));\n blitz::Array C_diag (L,L); C_diag = 0;\n bob::math::diag(C_1d(blitz::Range(K,K+L-1)), C_diag);\n C(blitz::Range(K, M-1), blitz::Range(K, K+L-1)) = C_diag;\n\n //2.2 Preparing S\n // K L\n //D2 = L ( 0 S )\n // P-L ( 0 0 )\n\n // A - diag(S) part\n // Swap\n bob::math::swap_(S_1d, iwork.get(), K, std::min(M,r));\n blitz::Array S_diag (L,L); S_diag = 0;\n bob::math::diag(S_1d(blitz::Range(K,K+L-1)), S_diag);\n S(blitz::Range(0, L-1), blitz::Range(K, K+L-1)) = S_diag;\n\n }\n else{\n\n //1. First we need the [0 R], which has the shape (N-K-L K M-K K+L-M , k + M-K K+L-M )\n\n //A. First part of R is in A(1:M, N-K-L+1:N) \n zeroR(blitz::Range(0,M-1), blitz::Range(N-K-L, N-1)) = A_blitz_lapack.transpose(1,0)(blitz::Range(0,M-1) , blitz::Range(N-K-L,N-1));\n\n //B. Second part of R is in B(M-K+1:L,N+M-K-L+1:N)\n zeroR(blitz::Range(M, r - 1), blitz::Range(N-L+M-K,N-1)) = B_blitz_lapack.transpose(1,0)(blitz::Range(M-K, L-1) , blitz::Range(N+M-K-L, N-1));\n\n //2. Now we have to deal with C and S according to http://www.netlib.org/lapack/lug/node36.html\n // In the end C is m-by-r and is p-by-r, both are real, nonnegative and diagonal and C'C + S'S = I ,\n // They have the following structure \n // COPY AND PASTE\n\n //2.1 Preparing C, where C=diag( ALPHA(K+1), ... , ALPHA(M) ),\n // K M-K K+L-M\n // D1 = K ( I 0 0 )\n // M-K ( 0 C 0 )\n\n // A - Identity part\n if (K>0){\n blitz::Array I (K,K); I = 0;\n bob::math::eye_(I);\n C(blitz::Range(0, K-1), blitz::Range(0, K-1)) = I;\n }\n\n // B - diag(C) part\n // Swaping\n blitz::Array C_1d_cropped(M-K); C_1d_cropped = 0;\n C_1d_cropped = C_1d(blitz::Range(K,K+M-1));\n bob::math::swap_(C_1d_cropped, iwork.get(), K, std::min(M,r));\n blitz::Array C_diag (M,M); C_diag = 0;\n bob::math::diag(C_1d_cropped, C_diag);\n C(blitz::Range(K,M-1), blitz::Range(K,M-1)) = C_diag;\n\n\n //2.2 Preparing S\n // K M-K K+L-M\n // D2 = M-K ( 0 S 0 )\n // K+L-M ( 0 0 I )\n // P-L ( 0 0 0 )\n\n // A - Identity part\n if (K+L-M>0){\n blitz::Array I (K+L-M,K+L-M); I= 0;\n bob::math::eye_(I);\n S(blitz::Range(M-K,L-1), blitz::Range(M,K+L-1)) = I;\n }\n\n // B - diag(S) part\n // Swaping\n blitz::Array S_1d_cropped(M-K); S_1d_cropped = 0;\n S_1d_cropped = S_1d(blitz::Range(K,K+M-1));\n \n bob::math::swap_(S_1d_cropped, iwork.get(), K, std::min(M,r));\n blitz::Array S_diag (M,M); S_diag = 0;\n bob::math::diag(S_1d_cropped, S_diag);\n S(blitz::Range(0,M-K-1), blitz::Range(K,M-1)) = S_diag;\n }\n\n // Transposing U and V\n blitz::Array Ut(\n bob::core::array::ccopy(const_cast&>(U).transpose(1,0)));\n U = Ut;\n\n blitz::Array Vt(\n bob::core::array::ccopy(const_cast&>(V).transpose(1,0)));\n V = Vt;\n\n // Swaping U\n bob::math::swap_(U, iwork.get(), K, std::min(M,r));\n // Swaping V\n bob::math::swap_(V, iwork.get(), K, std::min(M,r));\n\n //Computing X\n bob::math::prod_(zeroR, Q, X);\n blitz::Array Xt(\n bob::core::array::ccopy(const_cast&>(X).transpose(1,0)));\n X = Xt;\n bob::math::swap_(X, iwork.get(), K, std::min(M,r));\n\n} \n", "meta": {"hexsha": "c447f4f33b5f14075d4094954e609432b925c570", "size": 9971, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "bob/math/cpp/gsvd.cpp", "max_stars_repo_name": "bioidiap/bob.math", "max_stars_repo_head_hexsha": "e0efcd51a609755e55b723e97dca2b5eac6b7976", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "bob/math/cpp/gsvd.cpp", "max_issues_repo_name": "bioidiap/bob.math", "max_issues_repo_head_hexsha": "e0efcd51a609755e55b723e97dca2b5eac6b7976", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2015-12-02T01:42:32.000Z", "max_issues_repo_issues_event_max_datetime": "2016-05-26T16:37:07.000Z", "max_forks_repo_path": "bob/math/cpp/gsvd.cpp", "max_forks_repo_name": "bioidiap/bob.math", "max_forks_repo_head_hexsha": "e0efcd51a609755e55b723e97dca2b5eac6b7976", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.2151515152, "max_line_length": 172, "alphanum_fraction": 0.5016547989, "num_tokens": 3357, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8333245828938678, "lm_q2_score": 0.6513548646660542, "lm_q1q2_score": 0.5427900209137313}} {"text": "/**\n * \\file ToneStackFilter.hxx\n */\n\n#include \n\n#include \n\nnamespace ATK\n{\n template\n ToneStackCoefficients::ToneStackCoefficients(gsl::index nb_channels)\n :TypedBaseFilter(nb_channels, nb_channels)\n {\n }\n \n template\n ToneStackCoefficients::ToneStackCoefficients(ToneStackCoefficients&& other)\n :Parent(std::move(other)), R1(other.R1), R2(other.R2), R3(other.R3), R4(other.R4), C1(other.C1), C2(other.C2), C3(other.C3), low(other.low), middle(other.middle), high(other.high)\n {\n \n }\n\n template\n void ToneStackCoefficients::setup()\n {\n Parent::setup();\n \n coefficients_in.assign(in_order+1, 0);\n coefficients_out.assign(out_order, 0);\n\n CoeffDataType tempm[2] = {static_cast(-2) * input_sampling_rate, static_cast(2) * input_sampling_rate};\n CoeffDataType tempp[2] = {static_cast(1), static_cast(1)};\n boost::math::tools::polynomial poly1(tempm, 1);\n boost::math::tools::polynomial poly2(tempp, 1);\n\n boost::math::tools::polynomial b;\n boost::math::tools::polynomial a;\n \n b = poly2 * poly2 * poly1 * (high*C1*R1 + middle*C3*R3 + low*(C1*R2 + C2*R2) + (C1*R3 + C2*R3));\n b += poly2 * poly1 * poly1 * (high*(C1*C2*R1*R4 + C1*C3*R1*R4) - middle*middle*(C1*C3*R3*R3 + C2*C3*R3*R3) + middle*(C1*C3*R1*R3 + C1*C3*R3*R3 + C2*C3*R3*R3)\n + low*(C1*C2*R1*R2 + C1*C2*R2*R4 + C1*C3*R2*R4) + low*middle*(C1*C3*R2*R3 + C2*C3*R2*R3)\n + (C1*C2*R1*R3 + C1*C2*R3*R4 + C1*C3*R3*R4));\n b += poly1 * poly1 * poly1 * (low*middle*(C1*C2*C3*R1*R2*R3 + C1*C2*C3*R2*R3*R4) - middle*middle*(C1*C2*C3*R1*R3*R3 + C1*C2*C3*R3*R3*R4)\n + middle*(C1*C2*C3*R1*R3*R3 + C1*C2*C3*R3*R3*R4) + high*C1*C2*C3*R1*R3*R4 - high*middle*C1*C2*C3*R1*R3*R4\n + high*low*C1*C2*C3*R1*R2*R4);\n\n a = poly2 * poly2 * poly2;\n a += poly2 * poly2 * poly1 * ((C1*R1 + C1*R3 + C2*R3 + C2*R4 + C3*R4) + middle*C3*R3 + low*(C1*R2 + C2*R2));\n a += poly2 * poly1 * poly1 * (middle*(C1*C3*R1*R3 - C2*C3*R3*R4 + C1*C3*R3*R3 + C2*C3*R3*R3)\n + low*middle*(C1*C3*R2*R3 + C2*C3*R2*R3) - middle*middle*(C1*C3*R3*R3 + C2*C3*R3*R3) + low*(C1*C2*R2*R4 + C1*C2*R1*R2 + C1*C3*R2*R4 + C2*C3*R2*R4)\n + (C1*C2*R1*R4 + C1*C3*R1*R4 + C1*C2*R3*R4 + C1*C2*R1*R3 + C1*C3*R3*R4 + C2*C3*R3*R4));\n a += poly1 * poly1 * poly1 * (low*middle*(C1*C2*C3*R1*R2*R3 + C1*C2*C3*R2*R3*R4) - middle*middle*(C1*C2*C3*R1*R3*R3 + C1*C2*C3*R3*R3*R4)\n + middle*(C1*C2*C3*R3*R3*R4 + C1*C2*C3*R1*R3*R3 - C1*C2*C3*R1*R3*R4)\n + low*C1*C2*C3*R1*R2*R4 + C1*C2*C3*R1*R3*R4);\n\n for(gsl::index i = 0; i < in_order + 1; ++i)\n {\n coefficients_in[i] = b[i] / a[out_order];\n }\n for(gsl::index i = 0; i < out_order; ++i)\n {\n coefficients_out[i] = -a[i] / a[out_order];\n }\n }\n\n template\n void ToneStackCoefficients::set_low(CoeffDataType low)\n {\n if(low < 0 || low > 1)\n {\n throw std::out_of_range(\"Low is outside the interval [0,1]\");\n }\n this->low = low;\n\n setup();\n }\n \n template\n typename ToneStackCoefficients::CoeffDataType ToneStackCoefficients::get_low() const\n {\n return low;\n }\n\n template\n void ToneStackCoefficients::set_middle(CoeffDataType middle)\n {\n if(middle < 0 || middle > 1)\n {\n throw std::out_of_range(\"Middle is outside the interval [0,1]\");\n }\n this->middle = middle;\n\n setup();\n }\n\n template\n typename ToneStackCoefficients::CoeffDataType ToneStackCoefficients::get_middle() const\n {\n return middle;\n }\n\n\n template\n void ToneStackCoefficients::set_high(CoeffDataType high)\n {\n if(high < 0 || high > 1)\n {\n throw std::out_of_range(\"high is outside the interval [0,1]\");\n }\n this->high = high;\n\n setup();\n }\n\n template\n typename ToneStackCoefficients::CoeffDataType ToneStackCoefficients::get_high() const\n {\n return high;\n }\n\n template\n IIRFilter > ToneStackCoefficients::buildBassmanStack()\n {\n IIRFilter > filter;\n filter.set_coefficients(static_cast(250e3), static_cast(1e6), static_cast(25e3), static_cast(45e3),\n static_cast(250e-12), static_cast(20e-9), static_cast(20e-9));\n return std::move(filter);\n }\n\n template\n IIRFilter > ToneStackCoefficients::buildJCM800Stack()\n {\n IIRFilter > filter;\n filter.set_coefficients(static_cast(220e3), static_cast(1e6), static_cast(22e3), static_cast(33e3),\n static_cast(470e-12), static_cast(22e-9), static_cast(22e-9));\n return std::move(filter);\n }\n\n template\n void ToneStackCoefficients::set_coefficients(CoeffDataType R1, CoeffDataType R2, CoeffDataType R3, CoeffDataType R4, CoeffDataType C1, CoeffDataType C2, CoeffDataType C3)\n {\n this->R1 = R1;\n this->R2 = R2;\n this->R3 = R3;\n this->R4 = R4;\n this->C1 = C1;\n this->C2 = C2;\n this->C3 = C3;\n }\n}\n", "meta": {"hexsha": "f66f6078a1da611eacff9b8de0bd297f55e8a39c", "size": 5623, "ext": "hxx", "lang": "C++", "max_stars_repo_path": "ATK/EQ/ToneStackFilter.hxx", "max_stars_repo_name": "D-J-Roberts/AudioTK", "max_stars_repo_head_hexsha": "accf009d7238f32702eb1d5ee23c5148fc68e3bd", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 249.0, "max_stars_repo_stars_event_min_datetime": "2015-01-05T13:36:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-15T18:47:46.000Z", "max_issues_repo_path": "ATK/EQ/ToneStackFilter.hxx", "max_issues_repo_name": "D-J-Roberts/AudioTK", "max_issues_repo_head_hexsha": "accf009d7238f32702eb1d5ee23c5148fc68e3bd", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 22.0, "max_issues_repo_issues_event_min_datetime": "2015-07-28T15:20:24.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-11T14:18:19.000Z", "max_forks_repo_path": "ATK/EQ/ToneStackFilter.hxx", "max_forks_repo_name": "D-J-Roberts/AudioTK", "max_forks_repo_head_hexsha": "accf009d7238f32702eb1d5ee23c5148fc68e3bd", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 48.0, "max_forks_repo_forks_event_min_datetime": "2015-08-15T12:08:13.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-07T02:33:07.000Z", "avg_line_length": 36.9934210526, "max_line_length": 183, "alphanum_fraction": 0.666370265, "num_tokens": 1951, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278540866548, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.542770656417805}} {"text": "/* Author: Wolfgang Bangerth, University of Texas at Austin, 2000, 2004, 2005 */\n\n/* $Id: step-18.cc 28563 2013-02-25 23:21:10Z heister $ */\n/* */\n/* Copyright (C) 2000, 2004-2009, 2011-2012 by the deal.II authors */\n/* */\n/* This file is subject to QPL and may not be distributed */\n/* without copyright and license information. Please refer */\n/* to the file deal.II/doc/license.html for the text and */\n/* further information on this license. */\n\n\n// First the usual list of header files that have already been used in\n// previous example programs:\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// And here the only two new things among the header files: an include file in\n// which symmetric tensors of rank 2 and 4 are implemented, as introduced in\n// the introduction:\n#include \n\n// And a header that implements filters for iterators looping over all\n// cells. We will use this when selecting only those cells for output that are\n// owned by the present process in a %parallel program:\n#include \n\n// This is then simply C++ again:\n#include \n#include \n#include \n#include \n\n// The last step is as in all previous programs:\nnamespace Step18\n{\n using namespace dealii;\n\n // @sect3{The PointHistory class}\n\n // As was mentioned in the introduction, we have to store the old stress in\n // quadrature point so that we can compute the residual forces at this point\n // during the next time step. This alone would not warrant a structure with\n // only one member, but in more complicated applications, we would have to\n // store more information in quadrature points as well, such as the history\n // variables of plasticity, etc. In essence, we have to store everything\n // that affects the present state of the material here, which in plasticity\n // is determined by the deformation history variables.\n //\n // We will not give this class any meaningful functionality beyond being\n // able to store data, i.e. there are no constructors, destructors, or other\n // member functions. In such cases of `dumb' classes, we usually opt to\n // declare them as struct rather than class, to\n // indicate that they are closer to C-style structures than C++-style\n // classes.\n template \n struct PointHistory\n {\n SymmetricTensor<2,dim> old_stress;\n };\n\n\n // @sect3{The stress-strain tensor}\n\n // Next, we define the linear relationship between the stress and the strain\n // in elasticity. It is given by a tensor of rank 4 that is usually written\n // in the form $C_{ijkl} = \\mu (\\delta_{ik} \\delta_{jl} + \\delta_{il}\n // \\delta_{jk}) + \\lambda \\delta_{ij} \\delta_{kl}$. This tensor maps\n // symmetric tensor of rank 2 to symmetric tensors of rank 2. A function\n // implementing its creation for given values of the Lame constants lambda\n // and mu is straightforward:\n template \n SymmetricTensor<4,dim>\n get_stress_strain_tensor (const double lambda, const double mu)\n {\n SymmetricTensor<4,dim> tmp;\n for (unsigned int i=0; iinline.\n //\n // The first one computes the symmetric strain tensor for shape function\n // shape_func at quadrature point q_point by\n // forming the symmetric gradient of this shape function. We need that when\n // we want to form the matrix, for example.\n //\n // We should note that in previous examples where we have treated\n // vector-valued problems, we have always asked the finite element object in\n // which of the vector component the shape function is actually non-zero,\n // and thereby avoided to compute any terms that we could prove were zero\n // anyway. For this, we used the fe.system_to_component_index\n // function that returns in which component a shape function was zero, and\n // also that the fe_values.shape_value and\n // fe_values.shape_grad functions only returned the value and\n // gradient of the single non-zero component of a shape function if this is\n // a vector-valued element.\n //\n // This was an optimization, and if it isn't terribly time critical, we can\n // get away with a simpler technique: just ask the fe_values\n // for the value or gradient of a given component of a given shape function\n // at a given quadrature point. This is what the\n // fe_values.shape_grad_component(shape_func,q_point,i) call\n // does: return the full gradient of the ith component of shape\n // function shape_func at quadrature point\n // q_point. If a certain component of a certain shape function\n // is always zero, then this will simply always return zero.\n //\n // As mentioned, using fe_values.shape_grad_component instead\n // of the combination of fe.system_to_component_index and\n // fe_values.shape_grad may be less efficient, but its\n // implementation is optimized for such cases and shouldn't be a big\n // slowdown. We demonstrate the technique here since it is so much simpler\n // and straightforward.\n template \n inline\n SymmetricTensor<2,dim>\n get_strain (const FEValues &fe_values,\n const unsigned int shape_func,\n const unsigned int q_point)\n {\n // Declare a temporary that will hold the return value:\n SymmetricTensor<2,dim> tmp;\n\n // First, fill diagonal terms which are simply the derivatives in\n // direction i of the i component of the\n // vector-valued shape function:\n for (unsigned int i=0; iSymmetricTensor class makes sure that at least to the\n // outside the symmetric entries are also filled (in practice, the class\n // of course stores only one copy). Here, we have picked the upper right\n // half of the tensor, but the lower left one would have been just as\n // good:\n for (unsigned int i=0; ife_values.get_function_grads function allows you to extract\n // the gradients of each component of your solution field at a quadrature\n // point. It returns this as a vector of rank-1 tensors: one rank-1 tensor\n // (gradient) per vector component of the solution. From this we have to\n // reconstruct the (symmetric) strain tensor by transforming the data\n // storage format and symmetrization. We do this in the same way as above,\n // i.e. we avoid a few computations by filling first the diagonal and then\n // only one half of the symmetric tensor (the SymmetricTensor\n // class makes sure that it is sufficient to write only one of the two\n // symmetric components).\n //\n // Before we do this, though, we make sure that the input has the kind of\n // structure we expect: that is that there are dim vector\n // components, i.e. one displacement component for each coordinate\n // direction. We test this with the Assert macro that will\n // simply abort our program if the condition is not met.\n template \n inline\n SymmetricTensor<2,dim>\n get_strain (const std::vector > &grad)\n {\n Assert (grad.size() == dim, ExcInternalError());\n\n SymmetricTensor<2,dim> strain;\n for (unsigned int i=0; i\n get_rotation_matrix (const std::vector > &grad_u)\n {\n // First, compute the curl of the velocity field from the gradients. Note\n // that we are in 2d, so the rotation is a scalar:\n const double curl = (grad_u[1][0] - grad_u[0][1]);\n\n // From this, compute the angle of rotation:\n const double angle = std::atan (curl);\n\n // And from this, build the antisymmetric rotation matrix:\n const double t[2][2] = {{ cos(angle), sin(angle) },\n {-sin(angle), cos(angle) }\n };\n return Tensor<2,2>(t);\n }\n\n\n // The 3d case is a little more contrived:\n Tensor<2,3>\n get_rotation_matrix (const std::vector > &grad_u)\n {\n // Again first compute the curl of the velocity field. This time, it is a\n // real vector:\n const Point<3> curl (grad_u[2][1] - grad_u[1][2],\n grad_u[0][2] - grad_u[2][0],\n grad_u[1][0] - grad_u[0][1]);\n\n // From this vector, using its magnitude, compute the tangent of the angle\n // of rotation, and from it the actual angle:\n const double tan_angle = std::sqrt(curl*curl);\n const double angle = std::atan (tan_angle);\n\n // Now, here's one problem: if the angle of rotation is too small, that\n // means that there is no rotation going on (for example a translational\n // motion). In that case, the rotation matrix is the identity matrix.\n //\n // The reason why we stress that is that in this case we have that\n // tan_angle==0. Further down, we need to divide by that\n // number in the computation of the axis of rotation, and we would get\n // into trouble when dividing doing so. Therefore, let's shortcut this and\n // simply return the identity matrix if the angle of rotation is really\n // small:\n if (angle < 1e-9)\n {\n static const double rotation[3][3]\n = {{ 1, 0, 0}, { 0, 1, 0 }, { 0, 0, 1 } };\n static const Tensor<2,3> rot(rotation);\n return rot;\n }\n\n // Otherwise compute the real rotation matrix. The algorithm for this is\n // not exactly obvious, but can be found in a number of books,\n // particularly on computer games where rotation is a very frequent\n // operation. Online, you can find a description at\n // http://www.makegames.com/3drotation/ and (this particular form, with\n // the signs as here) at\n // http://www.gamedev.net/reference/articles/article1199.asp:\n const double c = std::cos(angle);\n const double s = std::sin(angle);\n const double t = 1-c;\n\n const Point<3> axis = curl/tan_angle;\n const double rotation[3][3]\n = {{\n t *axis[0] *axis[0]+c,\n t *axis[0] *axis[1]+s *axis[2],\n t *axis[0] *axis[2]-s *axis[1]\n },\n {\n t *axis[0] *axis[1]-s *axis[2],\n t *axis[1] *axis[1]+c,\n t *axis[1] *axis[2]+s *axis[0]\n },\n {\n t *axis[0] *axis[2]+s *axis[1],\n t *axis[1] *axis[1]-s *axis[0],\n t *axis[2] *axis[2]+c\n }\n };\n return Tensor<2,3>(rotation);\n }\n\n\n\n // @sect3{The TopLevel class}\n\n // This is the main class of the program. Since the namespace already\n // indicates what problem we are solving, let's call it by what it does: it\n // directs the flow of the program, i.e. it is the toplevel driver.\n //\n // The member variables of this class are essentially as before, i.e. it has\n // to have a triangulation, a DoF handler and associated objects such as\n // constraints, variables that describe the linear system, etc. There are a\n // good number of more member functions now, which we will explain below.\n //\n // The external interface of the class, however, is unchanged: it has a\n // public constructor and desctructor, and it has a run\n // function that initiated all the work.\n template \n class TopLevel\n {\n public:\n TopLevel ();\n ~TopLevel ();\n void run ();\n\n private:\n // The private interface is more extensive than in step-17. First, we\n // obviously need functions that create the initial mesh, set up the\n // variables that describe the linear system on the present mesh\n // (i.e. matrices and vectors), and then functions that actually assemble\n // the system, direct what has to be solved in each time step, a function\n // that solves the linear system that arises in each timestep (and returns\n // the number of iterations it took), and finally output the solution\n // vector on the currect mesh:\n void create_coarse_grid ();\n\n void setup_system ();\n\n void assemble_system ();\n\n void solve_timestep ();\n\n unsigned int solve_linear_problem ();\n\n void output_results () const;\n\n // All, except for the first two, of these functions are called in each\n // timestep. Since the first time step is a little special, we have\n // separate functions that describe what has to happen in a timestep: one\n // for the first, and one for all following timesteps:\n void do_initial_timestep ();\n\n void do_timestep ();\n\n // Then we need a whole bunch of functions that do various things. The\n // first one refines the initial grid: we start on the coarse grid with a\n // pristine state, solve the problem, then look at it and refine the mesh\n // accordingly, and start the same process over again, again with a\n // pristine state. Thus, refining the initial mesh is somewhat simpler\n // than refining a grid between two successive time steps, since it does\n // not involve transferring data from the old to the new triangulation, in\n // particular the history data that is stored in each quadrature point.\n void refine_initial_grid ();\n\n // At the end of each time step, we want to move the mesh vertices around\n // according to the incremental displacement computed in this time\n // step. This is the function in which this is done:\n void move_mesh ();\n\n // Next are two functions that handle the history variables stored in each\n // quadrature point. The first one is called before the first timestep to\n // set up a pristine state for the history variables. It only works on\n // those quadrature points on cells that belong to the present processor:\n void setup_quadrature_point_history ();\n\n // The second one updates the history variables at the end of each\n // timestep:\n void update_quadrature_point_history ();\n\n // After the member functions, here are the member variables. The first\n // ones have all been discussed in more detail in previous example\n // programs:\n Triangulation triangulation;\n\n FESystem fe;\n\n DoFHandler dof_handler;\n\n ConstraintMatrix hanging_node_constraints;\n\n // One difference of this program is that we declare the quadrature\n // formula in the class declaration. The reason is that in all the other\n // programs, it didn't do much harm if we had used different quadrature\n // formulas when computing the matrix and the righ hand side, for\n // example. However, in the present case it does: we store information in\n // the quadrature points, so we have to make sure all parts of the program\n // agree on where they are and how many there are on each cell. Thus, let\n // us first declare the quadrature formula that will be used throughout...\n const QGauss quadrature_formula;\n\n // ... and then also have a vector of history objects, one per quadrature\n // point on those cells for which we are responsible (i.e. we don't store\n // history data for quadrature points on cells that are owned by other\n // processors).\n std::vector > quadrature_point_history;\n\n // The way this object is accessed is through a user pointer\n // that each cell, face, or edge holds: it is a void* pointer\n // that can be used by application programs to associate arbitrary data to\n // cells, faces, or edges. What the program actually does with this data\n // is within its own responsibility, the library just allocates some space\n // for these pointers, and application programs can set and read the\n // pointers for each of these objects.\n\n\n // Further: we need the objects of linear systems to be solved,\n // i.e. matrix, right hand side vector, and the solution vector. Since we\n // anticipate solving big problems, we use the same types as in step-17,\n // i.e. distributed %parallel matrices and vectors built on top of the\n // PETSc library. Conveniently, they can also be used when running on only\n // a single machine, in which case this machine happens to be the only one\n // in our %parallel universe.\n //\n // However, as a difference to step-17, we do not store the solution\n // vector -- which here is the incremental displacements computed in each\n // time step -- in a distributed fashion. I.e., of course it must be a\n // distributed vector when computing it, but immediately after that we\n // make sure each processor has a complete copy. The reason is that we had\n // already seen in step-17 that many functions needed a complete\n // copy. While it is not hard to get it, this requires communication on\n // the network, and is thus slow. In addition, these were repeatedly the\n // same operations, which is certainly undesirable unless the gains of not\n // always having to store the entire vector outweighs it. When writing\n // this program, it turned out that we need a complete copy of the\n // solution in so many places that it did not seem worthwhile to only get\n // it when necessary. Instead, we opted to obtain the complete copy once\n // and for all, and instead get rid of the distributed copy\n // immediately. Thus, note that the declaration of\n // inremental_displacement does not denote a distribute\n // vector as would be indicated by the middle namespace MPI:\n PETScWrappers::MPI::SparseMatrix system_matrix;\n\n PETScWrappers::MPI::Vector system_rhs;\n\n PETScWrappers::Vector incremental_displacement;\n\n // The next block of variables is then related to the time dependent\n // nature of the problem: they denote the length of the time interval\n // which we want to simulate, the present time and number of time step,\n // and length of present timestep:\n double present_time;\n double present_timestep;\n double end_time;\n unsigned int timestep_no;\n\n // Then a few variables that have to do with %parallel processing: first,\n // a variable denoting the MPI communicator we use, and then two numbers\n // telling us how many participating processors there are, and where in\n // this world we are. Finally, a stream object that makes sure only one\n // processor is actually generating output to the console. This is all the\n // same as in step-17:\n MPI_Comm mpi_communicator;\n\n const unsigned int n_mpi_processes;\n\n const unsigned int this_mpi_process;\n\n ConditionalOStream pcout;\n\n // Here is a vector where each entry denotes the numbers of degrees of\n // freedom that are stored on the processor with that particular number:\n std::vector local_dofs_per_process;\n\n // Next, how many degrees of freedom the present processor stores. This\n // is, of course, an abbreviation to\n // local_dofs_per_process[this_mpi_process].\n unsigned int n_local_dofs;\n\n // In the same direction, also cache how many cells the present processor\n // owns. Note that the cells that belong to a processor are not\n // necessarily contiguously numbered (when iterating over them using\n // active_cell_iterator).\n unsigned int n_local_cells;\n\n // Finally, we have a static variable that denotes the linear relationship\n // between the stress and strain. Since it is a constant object that does\n // not depend on any input (at least not in this program), we make it a\n // static variable and will initialize it in the same place where we\n // define the constructor of this class:\n static const SymmetricTensor<4,dim> stress_strain_tensor;\n };\n\n\n // @sect3{The BodyForce class}\n\n // Before we go on to the main functionality of this program, we have to\n // define what forces will act on the body whose deformation we want to\n // study. These may either be body forces or boundary forces. Body forces\n // are generally mediated by one of the four basic physical types of forces:\n // gravity, strong and weak interaction, and electromagnetism. Unless one\n // wants to consider subatomic objects (for which quasistatic deformation is\n // irrelevant and an inappropriate description anyway), only gravity and\n // electromagnetic forces need to be considered. Let us, for simplicity\n // assume that our body has a certain mass density, but is either\n // non-magnetic and not electrically conducting or that there are no\n // significant electromagnetic fields around. In that case, the body forces\n // are simply rho g, where rho is the material\n // density and g is a vector in negative z-direction with\n // magnitude 9.81 m/s^2. Both the density and g are defined in\n // the function, and we take as the density 7700 kg/m^3, a value commonly\n // assumed for steel.\n //\n // To be a little more general and to be able to do computations in 2d as\n // well, we realize that the body force is always a function returning a\n // dim dimensional vector. We assume that gravity acts along\n // the negative direction of the last, i.e. dim-1th\n // coordinate. The rest of the implementation of this function should be\n // mostly self-explanatory given similar definitions in previous example\n // programs. Note that the body force is independent of the location; to\n // avoid compiler warnings about unused function arguments, we therefore\n // comment out the name of the first argument of the\n // vector_value function:\n template \n class BodyForce : public Function\n {\n public:\n BodyForce ();\n\n virtual\n void\n vector_value (const Point &p,\n Vector &values) const;\n\n virtual\n void\n vector_value_list (const std::vector > &points,\n std::vector > &value_list) const;\n };\n\n\n template \n BodyForce::BodyForce ()\n :\n Function (dim)\n {}\n\n\n template \n inline\n void\n BodyForce::vector_value (const Point & /*p*/,\n Vector &values) const\n {\n Assert (values.size() == dim,\n ExcDimensionMismatch (values.size(), dim));\n\n const double g = 9.81;\n const double rho = 7700;\n\n values = 0;\n values(dim-1) = -rho * g;\n }\n\n\n\n template \n void\n BodyForce::vector_value_list (const std::vector > &points,\n std::vector > &value_list) const\n {\n const unsigned int n_points = points.size();\n\n Assert (value_list.size() == n_points,\n ExcDimensionMismatch (value_list.size(), n_points));\n\n for (unsigned int p=0; p::vector_value (points[p],\n value_list[p]);\n }\n\n\n\n // @sect3{The IncrementalBoundaryValue class}\n\n // In addition to body forces, movement can be induced by boundary forces\n // and forced boundary displacement. The latter case is equivalent to forces\n // being chosen in such a way that they induce certain displacement.\n //\n // For quasistatic displacement, typical boundary forces would be pressure\n // on a body, or tangential friction against another body. We chose a\n // somewhat simpler case here: we prescribe a certain movement of (parts of)\n // the boundary, or at least of certain components of the displacement\n // vector. We describe this by another vector-valued function that, for a\n // given point on the boundary, returns the prescribed displacement.\n //\n // Since we have a time-dependent problem, the displacement increment of the\n // boundary equals the displacement accumulated during the length of the\n // timestep. The class therefore has to know both the present time and the\n // length of the present time step, and can then approximate the incremental\n // displacement as the present velocity times the present timestep.\n //\n // For the purposes of this program, we choose a simple form of boundary\n // displacement: we displace the top boundary with constant velocity\n // downwards. The rest of the boundary is either going to be fixed (and is\n // then described using an object of type ZeroFunction) or free\n // (Neumann-type, in which case nothing special has to be done). The\n // implementation of the class describing the constant downward motion\n // should then be obvious using the knowledge we gained through all the\n // previous example programs:\n template \n class IncrementalBoundaryValues : public Function\n {\n public:\n IncrementalBoundaryValues (const double present_time,\n const double present_timestep);\n\n virtual\n void\n vector_value (const Point &p,\n Vector &values) const;\n\n virtual\n void\n vector_value_list (const std::vector > &points,\n std::vector > &value_list) const;\n\n private:\n const double velocity;\n const double present_time;\n const double present_timestep;\n };\n\n\n template \n IncrementalBoundaryValues::\n IncrementalBoundaryValues (const double present_time,\n const double present_timestep)\n :\n Function (dim),\n velocity (.1),\n present_time (present_time),\n present_timestep (present_timestep)\n {}\n\n\n template \n void\n IncrementalBoundaryValues::\n vector_value (const Point & /*p*/,\n Vector &values) const\n {\n Assert (values.size() == dim,\n ExcDimensionMismatch (values.size(), dim));\n\n values = 0;\n values(2) = -present_timestep * velocity;\n }\n\n\n\n template \n void\n IncrementalBoundaryValues::\n vector_value_list (const std::vector > &points,\n std::vector > &value_list) const\n {\n const unsigned int n_points = points.size();\n\n Assert (value_list.size() == n_points,\n ExcDimensionMismatch (value_list.size(), n_points));\n\n for (unsigned int p=0; p::vector_value (points[p],\n value_list[p]);\n }\n\n\n\n // @sect3{Implementation of the TopLevel class}\n\n // Now for the implementation of the main class. First, we initialize the\n // stress-strain tensor, which we have declared as a static const\n // variable. We chose Lame constants that are appropriate for steel:\n template \n const SymmetricTensor<4,dim>\n TopLevel::stress_strain_tensor\n = get_stress_strain_tensor (/*lambda = */ 9.695e10,\n /*mu = */ 7.617e10);\n\n\n\n // @sect4{The public interface}\n\n // The next step is the definition of constructors and descructors. There\n // are no surprises here: we choose linear and continuous finite elements\n // for each of the dim vector components of the solution, and a\n // Gaussian quadrature formula with 2 points in each coordinate\n // direction. The destructor should be obvious:\n template \n TopLevel::TopLevel ()\n :\n fe (FE_Q(1), dim),\n dof_handler (triangulation),\n quadrature_formula (2),\n mpi_communicator (MPI_COMM_WORLD),\n n_mpi_processes (Utilities::MPI::n_mpi_processes(mpi_communicator)),\n this_mpi_process (Utilities::MPI::this_mpi_process(mpi_communicator)),\n pcout (std::cout, this_mpi_process == 0)\n {}\n\n\n\n template \n TopLevel::~TopLevel ()\n {\n dof_handler.clear ();\n }\n\n\n\n // The last of the public functions is the one that directs all the work,\n // run(). It initializes the variables that describe where in\n // time we presently are, then runs the first time step, then loops over all\n // the other time steps. Note that for simplicity we use a fixed time step,\n // whereas a more sophisticated program would of course have to choose it in\n // some more reasonable way adaptively:\n template \n void TopLevel::run ()\n {\n present_time = 0;\n present_timestep = 1;\n end_time = 10;\n timestep_no = 0;\n\n do_initial_timestep ();\n\n while (present_time < end_time)\n do_timestep ();\n }\n\n\n // @sect4{TopLevel::create_coarse_grid}\n\n // The next function in the order in which they were declared above is the\n // one that creates the coarse grid from which we start. For this example\n // program, we want to compute the deformation of a cylinder under axial\n // compression. The first step therefore is to generate a mesh for a\n // cylinder of length 3 and with inner and outer radii of 0.8 and 1,\n // respectively. Fortunately, there is a library function for such a mesh.\n //\n // In a second step, we have to associated boundary conditions with the\n // upper and lower faces of the cylinder. We choose a boundary indicator of\n // 0 for the boundary faces that are characterized by their midpoints having\n // z-coordinates of either 0 (bottom face), an indicator of 1 for z=3 (top\n // face); finally, we use boundary indicator 2 for all faces on the inside\n // of the cylinder shell, and 3 for the outside.\n template \n void TopLevel::create_coarse_grid ()\n {\n const double inner_radius = 0.8,\n outer_radius = 1;\n GridGenerator::cylinder_shell (triangulation,\n 3, inner_radius, outer_radius);\n for (typename Triangulation::active_cell_iterator\n cell=triangulation.begin_active();\n cell!=triangulation.end(); ++cell)\n for (unsigned int f=0; f::faces_per_cell; ++f)\n if (cell->face(f)->at_boundary())\n {\n const Point face_center = cell->face(f)->center();\n\n if (face_center[2] == 0)\n cell->face(f)->set_boundary_indicator (0);\n else if (face_center[2] == 3)\n cell->face(f)->set_boundary_indicator (1);\n else if (std::sqrt(face_center[0]*face_center[0] +\n face_center[1]*face_center[1])\n <\n (inner_radius + outer_radius) / 2)\n cell->face(f)->set_boundary_indicator (2);\n else\n cell->face(f)->set_boundary_indicator (3);\n }\n\n // In order to make sure that new vertices are placed correctly on mesh\n // refinement, we have to associate objects describing those parts of the\n // boundary that do not consist of straight parts. Corresponding to the\n // cylinder shell generator function used above, there are classes that\n // can be used to describe the geometry of cylinders. We need to use\n // different objects for the inner and outer parts of the cylinder, with\n // different radii; the second argument to the constructor indicates the\n // axis around which the cylinder revolves -- in this case the\n // z-axis. Note that the boundary objects need to live as long as the\n // triangulation does; we can achieve this by making the objects static,\n // which means that they live as long as the program runs:\n static const CylinderBoundary inner_cylinder (inner_radius, 2);\n static const CylinderBoundary outer_cylinder (outer_radius, 2);\n // We then attach these two objects to the triangulation, and make them\n // correspond to boundary indicators 2 and 3:\n triangulation.set_boundary (2, inner_cylinder);\n triangulation.set_boundary (3, outer_cylinder);\n\n // There's one more thing we have to take care of (we should have done so\n // above already, but for didactic reasons it was more appropriate to\n // handle it after discussing boundary objects). %Boundary indicators in\n // deal.II, for mostly historic reasons, serve a dual purpose: they\n // describe the type of a boundary for other places in a program where\n // different boundary conditions are implemented; and they describe which\n // boundary object (as the ones associated above) should be queried when\n // new boundary points need to be placed upon mesh refinement. In the\n // prefix to this function, we have discussed the boundary condition\n // issue, and the boundary geometry issue was mentioned just above. But\n // there is a case where we have to be careful with geometry: what happens\n // if a cell is refined that has two faces with different boundary\n // indicators? For example one at the edges of the cylinder? In that case,\n // the library wouldn't know where to put new points in the middle of\n // edges (one of the twelve lines of a hexahedron). In fact, the library\n // doesn't even care about the boundary indicator of adjacent faces when\n // refining edges: it considers the boundary indicators associated with\n // the edges themselves. So what do we want to happen with the edges of\n // the cylinder shell: they sit on both faces with boundary indicators 2\n // or 3 (inner or outer shell) and 0 or 1 (for which no boundary objects\n // have been specified, and for which the library therefore assumes\n // straight lines). Obviously, we want these lines to follow the curved\n // shells, so we have to assign all edges along faces with boundary\n // indicators 2 or 3 these same boundary indicators to make sure they are\n // refined using the appropriate geometry objects. This is easily done:\n for (typename Triangulation::active_face_iterator\n face=triangulation.begin_active_face();\n face!=triangulation.end_face(); ++face)\n if (face->at_boundary())\n if ((face->boundary_indicator() == 2)\n ||\n (face->boundary_indicator() == 3))\n for (unsigned int edge = 0; edge::lines_per_face;\n ++edge)\n face->line(edge)\n ->set_boundary_indicator (face->boundary_indicator());\n\n // Once all this is done, we can refine the mesh once globally:\n triangulation.refine_global (1);\n\n\n // As the final step, we need to set up a clean state of the data that we\n // store in the quadrature points on all cells that are treated on the\n // present processor. To do so, we also have to know which processors are\n // ours in the first place. This is done in the following two function\n // calls:\n GridTools::partition_triangulation (n_mpi_processes, triangulation);\n setup_quadrature_point_history ();\n }\n\n\n\n\n // @sect4{TopLevel::setup_system}\n\n // The next function is the one that sets up the data structures for a given\n // mesh. This is done in most the same way as in step-17: distribute the\n // degrees of freedom, then sort these degrees of freedom in such a way that\n // each processor gets a contiguous chunk of them. Note that subdivions into\n // chunks for each processor is handled in the functions that create or\n // refine grids, unlike in the previous example program (the point where\n // this happens is mostly a matter of taste; here, we chose to do it when\n // grids are created since in the do_initial_timestep and\n // do_timestep functions we want to output the number of cells\n // on each processor at a point where we haven't called the present function\n // yet).\n template \n void TopLevel::setup_system ()\n {\n dof_handler.distribute_dofs (fe);\n DoFRenumbering::subdomain_wise (dof_handler);\n\n // The next thing is to store some information for later use on how many\n // cells or degrees of freedom the present processor, or any of the\n // processors has to work on. First the cells local to this processor...\n n_local_cells\n = GridTools::count_cells_with_subdomain_association (triangulation,\n this_mpi_process);\n\n // ...and then a list of numbers of how many degrees of freedom each\n // processor has to handle:\n local_dofs_per_process.resize (n_mpi_processes);\n for (unsigned int i=0; iCompressedSparsityPattern class\n // here that was already introduced in step-11, rather than the\n // SparsityPattern class that we have used in all other\n // cases. The reason for this is that for the latter class to work we have\n // to give an initial upper bound for the number of entries in each row, a\n // task that is traditionally done by\n // DoFHandler::max_couplings_between_dofs(). However, this\n // function suffers from a serious problem: it has to compute an upper\n // bound to the number of nonzero entries in each row, and this is a\n // rather complicated task, in particular in 3d. In effect, while it is\n // quite accurate in 2d, it often comes up with much too large a number in\n // 3d, and in that case the SparsityPattern allocates much\n // too much memory at first, often several 100 MBs. This is later\n // corrected when DoFTools::make_sparsity_pattern is called\n // and we realize that we don't need all that much memory, but at time it\n // is already too late: for large problems, the temporary allocation of\n // too much memory can lead to out-of-memory situations.\n //\n // In order to avoid this, we resort to the\n // CompressedSparsityPattern class that is slower but does\n // not require any up-front estimate on the number of nonzero entries per\n // row. It therefore only ever allocates as much memory as it needs at any\n // given time, and we can build it even for large 3d problems.\n //\n // It is also worth noting that the sparsity pattern we construct is\n // global, i.e. comprises all degrees of freedom whether they will be\n // owned by the processor we are on or another one (in case this program\n // is run in %parallel via MPI). This of course is not optimal -- it\n // limits the size of the problems we can solve, since storing the entire\n // sparsity pattern (even if only for a short time) on each processor does\n // not scale well. However, there are several more places in the program\n // in which we do this, for example we always keep the global\n // triangulation and DoF handler objects around, even if we only work on\n // part of them. At present, deal.II does not have the necessary\n // facilities to completely distribute these objects (a task that, indeed,\n // is very hard to achieve with adaptive meshes, since well-balanced\n // subdivisions of a domain tend to become unbalanced as the mesh is\n // adaptively refined).\n //\n // With this data structure, we can then go to the PETSc sparse matrix and\n // tell it to pre-allocate all the entries we will later want to write to:\n system_matrix.reinit (mpi_communicator,\n sparsity_pattern,\n local_dofs_per_process,\n local_dofs_per_process,\n this_mpi_process);\n // After this point, no further explicit knowledge of the sparsity pattern\n // is required any more and we can let the sparsity_pattern\n // variable go out of scope without any problem.\n\n // The last task in this function is then only to reset the right hand\n // side vector as well as the solution vector to its correct size;\n // remember that the solution vector is a local one, unlike the right hand\n // side that is a distributed %parallel one and therefore needs to know\n // the MPI communicator over which it is supposed to transmit messages:\n system_rhs.reinit (mpi_communicator, dof_handler.n_dofs(), n_local_dofs);\n incremental_displacement.reinit (dof_handler.n_dofs());\n }\n\n\n\n // @sect4{TopLevel::assemble_system}\n\n // Again, assembling the system matrix and right hand side follows the same\n // structure as in many example programs before. In particular, it is mostly\n // equivalent to step-17, except for the different right hand side that now\n // only has to take into account internal stresses. In addition, assembling\n // the matrix is made significantly more transparent by using the\n // SymmetricTensor class: note the elegance of forming the\n // scalar products of symmetric tensors of rank 2 and 4. The implementation\n // is also more general since it is independent of the fact that we may or\n // may not be using an isotropic elasticity tensor.\n //\n // The first part of the assembly routine is as always:\n template \n void TopLevel::assemble_system ()\n {\n system_rhs = 0;\n system_matrix = 0;\n\n FEValues fe_values (fe, quadrature_formula,\n update_values | update_gradients |\n update_quadrature_points | update_JxW_values);\n\n const unsigned int dofs_per_cell = fe.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 Vector cell_rhs (dofs_per_cell);\n\n std::vector local_dof_indices (dofs_per_cell);\n\n BodyForce body_force;\n std::vector > body_force_values (n_q_points,\n Vector(dim));\n\n // As in step-17, we only need to loop over all cells that belong to the\n // present processor:\n typename DoFHandler::active_cell_iterator\n cell = dof_handler.begin_active(),\n endc = dof_handler.end();\n for (; cell!=endc; ++cell)\n if (cell->subdomain_id() == this_mpi_process)\n {\n cell_matrix = 0;\n cell_rhs = 0;\n\n fe_values.reinit (cell);\n\n // Then loop over all indices i,j and quadrature points and assemble\n // the system matrix contributions from this cell. Note how we\n // extract the symmetric gradients (strains) of the shape functions\n // at a given quadrature point from the FEValues\n // object, and the elegance with which we form the triple\n // contraction eps_phi_i : C : eps_phi_j; the latter\n // needs to be compared to the clumsy computations needed in\n // step-17, both in the introduction as well as in the respective\n // place in the program:\n for (unsigned int i=0; i\n eps_phi_i = get_strain (fe_values, i, q_point),\n eps_phi_j = get_strain (fe_values, j, q_point);\n\n cell_matrix(i,j)\n += (eps_phi_i * stress_strain_tensor * eps_phi_j\n *\n fe_values.JxW (q_point));\n }\n\n\n // Then also assemble the local right hand side contributions. For\n // this, we need to access the prior stress value in this quadrature\n // point. To get it, we use the user pointer of this cell that\n // points into the global array to the quadrature point data\n // corresponding to the first quadrature point of the present cell,\n // and then add an offset corresponding to the index of the\n // quadrature point we presently consider:\n const PointHistory *local_quadrature_points_data\n = reinterpret_cast*>(cell->user_pointer());\n // In addition, we need the values of the external body forces at\n // the quadrature points on this cell:\n body_force.vector_value_list (fe_values.get_quadrature_points(),\n body_force_values);\n // Then we can loop over all degrees of freedom on this cell and\n // compute local contributions to the right hand side:\n for (unsigned int i=0; i &old_stress\n = local_quadrature_points_data[q_point].old_stress;\n\n cell_rhs(i) += (body_force_values[q_point](component_i) *\n fe_values.shape_value (i,q_point)\n -\n old_stress *\n get_strain (fe_values,i,q_point))\n *\n fe_values.JxW (q_point);\n }\n }\n\n // Now that we have the local contributions to the linear system, we\n // need to transfer it into the global objects. This is done exactly\n // as in step-17:\n cell->get_dof_indices (local_dof_indices);\n\n hanging_node_constraints\n\t .distribute_local_to_global (cell_matrix, cell_rhs,\n local_dof_indices,\n\t\t\t\t\t system_matrix, system_rhs);\n }\n\n // Now compress the vector and the system matrix:\n system_matrix.compress(VectorOperation::add);\n system_rhs.compress(VectorOperation::add);\n\n \n // The last step is to again fix up boundary values, just as we already\n // did in previous programs. A slight complication is that the\n // apply_boundary_values function wants to have a solution\n // vector compatible with the matrix and right hand side (i.e. here a\n // distributed %parallel vector, rather than the sequential vector we use\n // in this program) in order to preset the entries of the solution vector\n // with the correct boundary values. We provide such a compatible vector\n // in the form of a temporary vector which we then copy into the\n // sequential one.\n\n // We make up for this complication by showing how boundary values can be\n // used flexibly: following the way we create the triangulation, there are\n // three distinct boundary indicators used to describe the domain,\n // corresponding to the bottom and top faces, as well as the inner/outer\n // surfaces. We would like to impose boundary conditions of the following\n // type: The inner and outer cylinder surfaces are free of external\n // forces, a fact that corresponds to natural (Neumann-type) boundary\n // conditions for which we don't have to do anything. At the bottom, we\n // want no movement at all, corresponding to the cylinder being clamped or\n // cemented in at this part of the boundary. At the top, however, we want\n // a prescribed vertical downward motion compressing the cylinder; in\n // addition, we only want to restrict the vertical movement, but not the\n // horizontal ones -- one can think of this situation as a well-greased\n // plate sitting on top of the cylinder pushing it downwards: the atoms of\n // the cylinder are forced to move downward, but they are free to slide\n // horizontally along the plate.\n\n // The way to describe this is as follows: for boundary indicator zero\n // (bottom face) we use a dim-dimensional zero function representing no\n // motion in any coordinate direction. For the boundary with indicator 1\n // (top surface), we use the IncrementalBoundaryValues class,\n // but we specify an additional argument to the\n // VectorTools::interpolate_boundary_values function denoting\n // which vector components it should apply to; this is a vector of bools\n // for each vector component and because we only want to restrict vertical\n // motion, it has only its last component set:\n FEValuesExtractors::Scalar z_component (dim-1);\n std::map boundary_values;\n VectorTools::\n interpolate_boundary_values (dof_handler,\n 0,\n ZeroFunction (dim),\n boundary_values);\n VectorTools::\n interpolate_boundary_values (dof_handler,\n 1,\n IncrementalBoundaryValues(present_time,\n present_timestep),\n boundary_values,\n fe.component_mask(z_component));\n\n PETScWrappers::MPI::Vector tmp (mpi_communicator, dof_handler.n_dofs(),\n n_local_dofs);\n MatrixTools::apply_boundary_values (boundary_values,\n system_matrix, tmp,\n system_rhs, false);\n incremental_displacement = tmp;\n }\n\n\n\n // @sect4{TopLevel::solve_timestep}\n\n // The next function is the one that controls what all has to happen within\n // a timestep. The order of things should be relatively self-explanatory\n // from the function names:\n template \n void TopLevel::solve_timestep ()\n {\n pcout << \" Assembling system...\" << std::flush;\n assemble_system ();\n pcout << \" norm of rhs is \" << system_rhs.l2_norm()\n << std::endl;\n\n const unsigned int n_iterations = solve_linear_problem ();\n\n pcout << \" Solver converged in \" << n_iterations\n << \" iterations.\" << std::endl;\n\n pcout << \" Updating quadrature point data...\" << std::flush;\n update_quadrature_point_history ();\n pcout << std::endl;\n }\n\n\n\n // @sect4{TopLevel::solve_linear_problem}\n\n // Solving the linear system again works mostly as before. The only\n // difference is that we want to only keep a complete local copy of the\n // solution vector instead of the distributed one that we get as output from\n // PETSc's solver routines. To this end, we declare a local temporary\n // variable for the distributed vector and initialize it with the contents\n // of the local variable (remember that the\n // apply_boundary_values function called in\n // assemble_system preset the values of boundary nodes in this\n // vector), solve with it, and at the end of the function copy it again into\n // the complete local vector that we declared as a member variable. Hanging\n // node constraints are then distributed only on the local copy,\n // i.e. independently of each other on each of the processors:\n template \n unsigned int TopLevel::solve_linear_problem ()\n {\n PETScWrappers::MPI::Vector\n distributed_incremental_displacement (mpi_communicator,\n dof_handler.n_dofs(),\n n_local_dofs);\n distributed_incremental_displacement = incremental_displacement;\n\n SolverControl solver_control (dof_handler.n_dofs(),\n 1e-16*system_rhs.l2_norm());\n PETScWrappers::SolverCG cg (solver_control,\n mpi_communicator);\n\n PETScWrappers::PreconditionBlockJacobi preconditioner(system_matrix);\n\n cg.solve (system_matrix, distributed_incremental_displacement, system_rhs,\n preconditioner);\n\n incremental_displacement = distributed_incremental_displacement;\n\n hanging_node_constraints.distribute (incremental_displacement);\n\n return solver_control.last_step();\n }\n\n\n\n // @sect4{TopLevel::output_results}\n\n // This function generates the graphical output in intermediate format as\n // explained in the introduction. Each process will only work on the cells\n // it owns, and then write the result into a file of its own. These files\n // may later be merged to get a single file in any of the supported output\n // files, as mentioned in the introduction.\n //\n // The crucial part of this function is to give the DataOut\n // class a way to only work on the cells that the present process owns. This\n // class is already well-equipped for that: it has two virtual functions\n // first_cell and next_cell that return the first\n // cell to be worked on, and given one cell return the next cell to be\n // worked on. By default, these functions return the first active cell\n // (i.e. the first one that has no children) and the next active cell. What\n // we have to do here is derive a class from DataOut that\n // overloads these two functions to only iterate over those cells with the\n // right subdomain indicator.\n //\n // We do this at the beginning of this function. The first_cell\n // function just starts with the first active cell, and then iterates to the\n // next cells while the cell presently under consideration does not yet have\n // the correct subdomain id. The only thing that needs to be taken care of\n // is that we don't try to keep iterating when we have hit the end iterator.\n //\n // The next_cell function could be implemented in a similar\n // way. However, we use this occasion as a pretext to introduce one more\n // thing that the library offers: filtered iterators. These are wrappers for\n // the iterator classes that just skip all cells (or faces, lines, etc) that\n // do not satisfy a certain predicate (a predicate in computer-lingo is a\n // function that when applied to a data element either returns true or\n // false). In the present case, the predicate is that the cell has to have a\n // certain subdomain id, and the library already has this predicate built\n // in. If the cell iterator is not the end iterator, what we then have to do\n // is to initialize such a filtered iterator with the present cell and the\n // predicate, and then increase the iterator exactly once. While the more\n // conventional loop would probably not have been much longer, this is\n // definitely the more elegant way -- and then, these example programs also\n // serve the purpose of introducing what is available in deal.II.\n template\n class FilteredDataOut : public DataOut\n {\n public:\n FilteredDataOut (const unsigned int subdomain_id)\n :\n subdomain_id (subdomain_id)\n {}\n\n virtual typename DoFHandler::cell_iterator\n first_cell ()\n {\n typename DoFHandler::active_cell_iterator\n cell = this->dofs->begin_active();\n while ((cell != this->dofs->end()) &&\n (cell->subdomain_id() != subdomain_id))\n ++cell;\n\n return cell;\n }\n\n virtual typename DoFHandler::cell_iterator\n next_cell (const typename DoFHandler::cell_iterator &old_cell)\n {\n if (old_cell != this->dofs->end())\n {\n const IteratorFilters::SubdomainEqualTo\n predicate(subdomain_id);\n\n return\n ++(FilteredIterator\n ::active_cell_iterator>\n (predicate,old_cell));\n }\n else\n return old_cell;\n }\n\n private:\n const unsigned int subdomain_id;\n };\n\n\n\n template \n void TopLevel::output_results () const\n {\n // With this newly defined class, declare an object that is going to\n // generate the graphical output and attach the dof handler with it from\n // which to get the solution vector:\n FilteredDataOut data_out(this_mpi_process);\n data_out.attach_dof_handler (dof_handler);\n\n // Then, just as in step-17, define the names of solution variables (which\n // here are the displacement increments) and queue the solution vector for\n // output. Note in the following switch how we make sure that if the space\n // dimension should be unhandled that we throw an exception saying that we\n // haven't implemented this case yet (another case of defensive\n // programming):\n std::vector solution_names;\n switch (dim)\n {\n case 1:\n solution_names.push_back (\"delta_x\");\n break;\n case 2:\n solution_names.push_back (\"delta_x\");\n solution_names.push_back (\"delta_y\");\n break;\n case 3:\n solution_names.push_back (\"delta_x\");\n solution_names.push_back (\"delta_y\");\n solution_names.push_back (\"delta_z\");\n break;\n default:\n Assert (false, ExcNotImplemented());\n }\n\n data_out.add_data_vector (incremental_displacement,\n solution_names);\n\n\n // The next thing is that we wanted to output something like the average\n // norm of the stresses that we have stored in each cell. This may seem\n // complicated, since on the present processor we only store the stresses\n // in quadrature points on those cells that actually belong to the present\n // process. In other words, it seems as if we can't compute the average\n // stresses for all cells. However, remember that our class derived from\n // DataOut only iterates over those cells that actually do\n // belong to the present processor, i.e. we don't have to compute anything\n // for all the other cells as this information would not be touched. The\n // following little loop does this. We enclose the entire block into a\n // pair of braces to make sure that the iterator variables do not remain\n // accidentally visible beyond the end of the block in which they are\n // used:\n Vector norm_of_stress (triangulation.n_active_cells());\n {\n // Loop over all the cells...\n typename Triangulation::active_cell_iterator\n cell = triangulation.begin_active(),\n endc = triangulation.end();\n for (unsigned int index=0; cell!=endc; ++cell, ++index)\n // ... and pick those that are relevant to us:\n if (cell->subdomain_id() == this_mpi_process)\n {\n // On these cells, add up the stresses over all quadrature\n // points...\n SymmetricTensor<2,dim> accumulated_stress;\n for (unsigned int q=0;\n q*>(cell->user_pointer())[q]\n .old_stress;\n\n // ...then write the norm of the average to their destination:\n norm_of_stress(index)\n = (accumulated_stress /\n quadrature_formula.size()).norm();\n }\n // And on the cells that we are not interested in, set the respective\n // value in the vector to a bogus value (norms must be positive, and a\n // large negative value should catch your eye) in order to make sure\n // that if we were somehow wrong about our assumption that these\n // elements would not appear in the output file, that we would find out\n // by looking at the graphical output:\n else\n norm_of_stress(index) = -1e+20;\n }\n // Finally attach this vector as well to be treated for output:\n data_out.add_data_vector (norm_of_stress, \"norm_of_stress\");\n\n // As a last piece of data, let us also add the partitioning of the domain\n // into subdomains associated with the processors if this is a parallel\n // job. This works in the exact same way as in the step-17 program:\n std::vector partition_int (triangulation.n_active_cells());\n GridTools::get_subdomain_association (triangulation, partition_int);\n const Vector partitioning(partition_int.begin(),\n partition_int.end());\n data_out.add_data_vector (partitioning, \"partitioning\");\n\n // Finally, with all this data, we can instruct deal.II to munge the\n // information and produce some intermediate data structures that contain\n // all these solution and other data vectors:\n data_out.build_patches ();\n\n\n // Now that we have generated the intermediate format, let us determine\n // the name of the file we will want to write it to. We compose it of the\n // prefix solution-, followed by a representation of the\n // present time written as a fixed point number so that file names sort\n // naturally:\n std::ostringstream filename;\n filename << \"solution-\";\n filename << std::setfill('0');\n filename.setf(std::ios::fixed, std::ios::floatfield);\n filename << std::setw(9) << std::setprecision(4) << present_time;\n\n // Next, in case there are multiple processes working together, we have to\n // generate different file names for the output of each process. In our\n // case, we encode the process number as a three-digit integer, padded\n // with zeros. The assertion in the first line of the block makes sure\n // that there are less than 1000 processes (a very conservative check, but\n // worth having anyway) as our scheme of generating process numbers would\n // overflow if there were 1000 processes or more. Note that we choose to\n // use AssertThrow rather than Assert since the\n // number of processes is a variable that depends on input files or the\n // way the process is started, rather than static assumptions in the\n // program code. Therefore, it is inappropriate to use Assert\n // that is optimized away in optimized mode, whereas here we actually can\n // assume that users will run the largest computations with the most\n // processors in optimized mode, and we should check our assumptions in\n // this particular case, and not only when running in debug mode:\n if (n_mpi_processes != 1)\n {\n AssertThrow (n_mpi_processes < 1000, ExcNotImplemented());\n\n filename << '-';\n filename << std::setfill('0');\n filename << std::setw(3) << this_mpi_process;\n }\n\n // To the file name, attach the file name suffix usually used for the\n // deal.II intermediate format. To determine it, we use the same function\n // that has already been used in step-13:\n filename << data_out.default_suffix(DataOut::deal_II_intermediate);\n\n // With the so-completed filename, let us open a file and write the data\n // we have generated into it, using the intermediate format:\n std::ofstream output (filename.str().c_str());\n data_out.write_deal_II_intermediate (output);\n }\n\n\n\n // @sect4{TopLevel::do_initial_timestep}\n\n // This and the next function handle the overall structure of the first and\n // following timesteps, respectively. The first timestep is slightly more\n // involved because we want to compute it multiple times on successively\n // refined meshes, each time starting from a clean state. At the end of\n // these computations, in which we compute the incremental displacements\n // each time, we use the last results obtained for the incremental\n // displacements to compute the resulting stress updates and move the mesh\n // accordingly. On this new mesh, we then output the solution and any\n // additional data we consider important.\n //\n // All this is interspersed by generating output to the console to update\n // the person watching the screen on what is going on. As in step-17, the\n // use of pcout instead of std::cout makes sure\n // that only one of the parallel processes is actually writing to the\n // console, without having to explicitly code an if-statement in each place\n // where we generate output:\n template \n void TopLevel::do_initial_timestep ()\n {\n present_time += present_timestep;\n ++timestep_no;\n pcout << \"Timestep \" << timestep_no << \" at time \" << present_time\n << std::endl;\n\n for (unsigned int cycle=0; cycle<2; ++cycle)\n {\n pcout << \" Cycle \" << cycle << ':' << std::endl;\n\n if (cycle == 0)\n create_coarse_grid ();\n else\n refine_initial_grid ();\n\n pcout << \" Number of active cells: \"\n << triangulation.n_active_cells()\n << \" (by partition:\";\n for (unsigned int p=0; p\n void TopLevel::do_timestep ()\n {\n present_time += present_timestep;\n ++timestep_no;\n pcout << \"Timestep \" << timestep_no << \" at time \" << present_time\n << std::endl;\n if (present_time > end_time)\n {\n present_timestep -= (present_time - end_time);\n present_time = end_time;\n }\n\n\n solve_timestep ();\n\n move_mesh ();\n output_results ();\n\n pcout << std::endl;\n }\n\n\n // @sect4{TopLevel::refine_initial_grid}\n\n // The following function is called when solving the first time step on\n // successively refined meshes. After each iteration, it computes a\n // refinement criterion, refines the mesh, and sets up the history variables\n // in each quadrature point again to a clean state.\n template \n void TopLevel::refine_initial_grid ()\n {\n // First, let each process compute error indicators for the cells it owns:\n Vector error_per_cell (triangulation.n_active_cells());\n KellyErrorEstimator::estimate (dof_handler,\n QGauss(2),\n typename FunctionMap::type(),\n incremental_displacement,\n error_per_cell,\n ComponentMask(),\n 0,\n multithread_info.n_default_threads,\n this_mpi_process);\n\n // Then set up a global vector into which we merge the local indicators\n // from each of the %parallel processes:\n const unsigned int n_local_cells\n = GridTools::count_cells_with_subdomain_association (triangulation,\n this_mpi_process);\n PETScWrappers::MPI::Vector\n distributed_error_per_cell (mpi_communicator,\n triangulation.n_active_cells(),\n n_local_cells);\n\n for (unsigned int i=0; icell-@>vertex_dof_index(v,d) function that returns the index\n // of the dth degree of freedom at vertex v of the\n // given cell. In the present case, displacement in the k-th coordinate\n // direction corresonds to the kth component of the finite element. Using a\n // function like this bears a certain risk, because it uses knowledge of the\n // order of elements that we have taken together for this program in the\n // FESystem element. If we decided to add an additional\n // variable, for example a pressure variable for stabilization, and happened\n // to insert it as the first variable of the element, then the computation\n // below will start to produce non-sensical results. In addition, this\n // computation rests on other assumptions: first, that the element we use\n // has, indeed, degrees of freedom that are associated with vertices. This\n // is indeed the case for the present Q1 element, as would be for all Qp\n // elements of polynomial order p. However, it would not hold\n // for discontinuous elements, or elements for mixed formulations. Secondly,\n // it also rests on the assumption that the displacement at a vertex is\n // determined solely by the value of the degree of freedom associated with\n // this vertex; in other words, all shape functions corresponding to other\n // degrees of freedom are zero at this particular vertex. Again, this is the\n // case for the present element, but is not so for all elements that are\n // presently available in deal.II. Despite its risks, we choose to use this\n // way in order to present a way to query individual degrees of freedom\n // associated with vertices.\n //\n // In this context, it is instructive to point out what a more general way\n // would be. For general finite elements, the way to go would be to take a\n // quadrature formula with the quadrature points in the vertices of a\n // cell. The QTrapez formula for the trapezoidal rule does\n // exactly this. With this quadrature formula, we would then initialize an\n // FEValues object in each cell, and use the\n // FEValues::get_function_values function to obtain the values\n // of the solution function in the quadrature points, i.e. the vertices of\n // the cell. These are the only values that we really need, i.e. we are not\n // at all interested in the weights (or the JxW values)\n // associated with this particular quadrature formula, and this can be\n // specified as the last argument in the constructor to\n // FEValues. The only point of minor inconvenience in this\n // scheme is that we have to figure out which quadrature point corresponds\n // to the vertex we consider at present, as they may or may not be ordered\n // in the same order.\n //\n // Another point worth explaining about this short function is the way in\n // which the triangulation class exports information about its vertices:\n // through the Triangulation::n_vertices function, it\n // advertises how many vertices there are in the triangulation. Not all of\n // them are actually in use all the time -- some are left-overs from cells\n // that have been coarsened previously and remain in existence since deal.II\n // never changes the number of a vertex once it has come into existence,\n // even if vertices with lower number go away. Secondly, the location\n // returned by cell-@>vertex(v) is not only a read-only object\n // of type Point@, but in fact a reference that can be\n // written to. This allows to move around the nodes of a mesh with relative\n // ease, but it is worth pointing out that it is the responsibility of an\n // application program using this feature to make sure that the resulting\n // cells are still useful, i.e. are not distorted so much that the cell is\n // degenerated (indicated, for example, by negative Jacobians). Note that we\n // do not have any provisions in this function to actually ensure this, we\n // just have faith.\n //\n // After this lengthy introduction, here are the full 20 or so lines of\n // code:\n template \n void TopLevel::move_mesh ()\n {\n pcout << \" Moving mesh...\" << std::endl;\n\n std::vector vertex_touched (triangulation.n_vertices(),\n false);\n for (typename DoFHandler::active_cell_iterator\n cell = dof_handler.begin_active ();\n cell != dof_handler.end(); ++cell)\n for (unsigned int v=0; v::vertices_per_cell; ++v)\n if (vertex_touched[cell->vertex_index(v)] == false)\n {\n vertex_touched[cell->vertex_index(v)] = true;\n\n Point vertex_displacement;\n for (unsigned int d=0; dvertex_dof_index(v,d));\n\n cell->vertex(v) += vertex_displacement;\n }\n }\n\n\n // @sect4{TopLevel::setup_quadrature_point_history}\n\n // At the beginning of our computations, we needed to set up initial values\n // of the history variables, such as the existing stresses in the material,\n // that we store in each quadrature point. As mentioned above, we use the\n // user_pointer for this that is available in each cell.\n //\n // To put this into larger perspective, we note that if we had previously\n // available stresses in our model (which we assume do not exist for the\n // purpose of this program), then we would need to interpolate the field of\n // pre-existing stresses to the quadrature points. Likewise, if we were to\n // simulate elasto-plastic materials with hardening/softening, then we would\n // have to store additional history variables like the present yield stress\n // of the accumulated plastic strains in each quadrature\n // points. Pre-existing hardening or weakening would then be implemented by\n // interpolating these variables in the present function as well.\n template \n void TopLevel::setup_quadrature_point_history ()\n {\n // What we need to do here is to first count how many quadrature points\n // are within the responsibility of this processor. This, of course,\n // equals the number of cells that belong to this processor times the\n // number of quadrature points our quadrature formula has on each cell.\n //\n // For good measure, we also set all user pointers of all cells, whether\n // ours of not, to the null pointer. This way, if we ever access the user\n // pointer of a cell which we should not have accessed, a segmentation\n // fault will let us know that this should not have happened:\n unsigned int our_cells = 0;\n for (typename Triangulation::active_cell_iterator\n cell = triangulation.begin_active();\n cell != triangulation.end(); ++cell)\n if (cell->subdomain_id() == this_mpi_process)\n ++our_cells;\n\n triangulation.clear_user_data();\n\n // Next, allocate as many quadrature objects as we need. Since the\n // resize function does not actually shrink the amount of\n // allocated memory if the requested new size is smaller than the old\n // size, we resort to a trick to first free all memory, and then\n // reallocate it: we declare an empty vector as a temporary variable and\n // then swap the contents of the old vector and this temporary\n // variable. This makes sure that the\n // quadrature_point_history is now really empty, and we can\n // let the temporary variable that now holds the previous contents of the\n // vector go out of scope and be destroyed. In the next step. we can then\n // re-allocate as many elements as we need, with the vector\n // default-initializing the PointHistory objects, which\n // includes setting the stress variables to zero.\n {\n std::vector > tmp;\n tmp.swap (quadrature_point_history);\n }\n quadrature_point_history.resize (our_cells *\n quadrature_formula.size());\n\n // Finally loop over all cells again and set the user pointers from the\n // cells that belong to the present processor to point to the first\n // quadrature point objects corresponding to this cell in the vector of\n // such objects:\n unsigned int history_index = 0;\n for (typename Triangulation::active_cell_iterator\n cell = triangulation.begin_active();\n cell != triangulation.end(); ++cell)\n if (cell->subdomain_id() == this_mpi_process)\n {\n cell->set_user_pointer (&quadrature_point_history[history_index]);\n history_index += quadrature_formula.size();\n }\n\n // At the end, for good measure make sure that our count of elements was\n // correct and that we have both used up all objects we allocated\n // previously, and not point to any objects beyond the end of the\n // vector. Such defensive programming strategies are always good checks to\n // avoid accidental errors and to guard against future changes to this\n // function that forget to update all uses of a variable at the same\n // time. Recall that constructs using the Assert macro are\n // optimized away in optimized mode, so do not affect the run time of\n // optimized runs:\n Assert (history_index == quadrature_point_history.size(),\n ExcInternalError());\n }\n\n\n\n\n // @sect4{TopLevel::update_quadrature_point_history}\n\n // At the end of each time step, we should have computed an incremental\n // displacement update so that the material in its new configuration\n // accommodates for the difference between the external body and boundary\n // forces applied during this time step minus the forces exerted through\n // pre-existing internal stresses. In order to have the pre-existing\n // stresses available at the next time step, we therefore have to update the\n // pre-existing stresses with the stresses due to the incremental\n // displacement computed during the present time step. Ideally, the\n // resulting sum of internal stresses would exactly counter all external\n // forces. Indeed, a simple experiment can make sure that this is so: if we\n // choose boundary conditions and body forces to be time independent, then\n // the forcing terms (the sum of external forces and internal stresses)\n // should be exactly zero. If you make this experiment, you will realize\n // from the output of the norm of the right hand side in each time step that\n // this is almost the case: it is not exactly zero, since in the first time\n // step the incremental displacement and stress updates were computed\n // relative to the undeformed mesh, which was then deformed. In the second\n // time step, we again compute displacement and stress updates, but this\n // time in the deformed mesh -- there, the resulting updates are very small\n // but not quite zero. This can be iterated, and in each such iteration the\n // residual, i.e. the norm of the right hand side vector, is reduced; if one\n // makes this little experiment, one realizes that the norm of this residual\n // decays exponentially with the number of iterations, and after an initial\n // very rapid decline is reduced by roughly a factor of about 3.5 in each\n // iteration (for one testcase I looked at, other testcases, and other\n // numbers of unknowns change the factor, but not the exponential decay).\n\n // In a sense, this can then be considered as a quasi-timestepping scheme to\n // resolve the nonlinear problem of solving large-deformation elasticity on\n // a mesh that is moved along in a Lagrangian manner.\n //\n // Another complication is that the existing (old) stresses are defined on\n // the old mesh, which we will move around after updating the stresses. If\n // this mesh update involves rotations of the cell, then we need to also\n // rotate the updated stress, since it was computed relative to the\n // coordinate system of the old cell.\n //\n // Thus, what we need is the following: on each cell which the present\n // processor owns, we need to extract the old stress from the data stored\n // with each quadrature point, compute the stress update, add the two\n // together, and then rotate the result together with the incremental\n // rotation computed from the incremental displacement at the present\n // quadrature point. We will detail these steps below:\n template \n void TopLevel::update_quadrature_point_history ()\n {\n // First, set up an FEValues object by which we will evaluate\n // the incremental displacements and the gradients thereof at the\n // quadrature points, together with a vector that will hold this\n // information:\n FEValues fe_values (fe, quadrature_formula,\n update_values | update_gradients);\n std::vector > >\n displacement_increment_grads (quadrature_formula.size(),\n std::vector >(dim));\n\n // Then loop over all cells and do the job in the cells that belong to our\n // subdomain:\n for (typename DoFHandler::active_cell_iterator\n cell = dof_handler.begin_active();\n cell != dof_handler.end(); ++cell)\n if (cell->subdomain_id() == this_mpi_process)\n {\n // Next, get a pointer to the quadrature point history data local to\n // the present cell, and, as a defensive measure, make sure that\n // this pointer is within the bounds of the global array:\n PointHistory *local_quadrature_points_history\n = reinterpret_cast *>(cell->user_pointer());\n Assert (local_quadrature_points_history >=\n &quadrature_point_history.front(),\n ExcInternalError());\n Assert (local_quadrature_points_history <\n &quadrature_point_history.back(),\n ExcInternalError());\n\n // Then initialize the FEValues object on the present\n // cell, and extract the gradients of the displacement at the\n // quadrature points for later computation of the strains\n fe_values.reinit (cell);\n fe_values.get_function_grads (incremental_displacement,\n displacement_increment_grads);\n\n // Then loop over the quadrature points of this cell:\n for (unsigned int q=0; q new_stress\n = (local_quadrature_points_history[q].old_stress\n +\n (stress_strain_tensor *\n get_strain (displacement_increment_grads[q])));\n\n // Finally, we have to rotate the result. For this, we first\n // have to compute a rotation matrix at the present quadrature\n // point from the incremental displacements. In fact, it can be\n // computed from the gradients, and we already have a function\n // for that purpose:\n const Tensor<2,dim> rotation\n = get_rotation_matrix (displacement_increment_grads[q]);\n // Note that the result, a rotation matrix, is in general an\n // antisymmetric tensor of rank 2, so we must store it as a full\n // tensor.\n\n // With this rotation matrix, we can compute the rotated tensor\n // by contraction from the left and right, after we expand the\n // symmetric tensor new_stress into a full tensor:\n const SymmetricTensor<2,dim> rotated_new_stress\n = symmetrize(transpose(rotation) *\n static_cast >(new_stress) *\n rotation);\n // Note that while the result of the multiplication of these\n // three matrices should be symmetric, it is not due to floating\n // point round off: we get an asymmetry on the order of 1e-16 of\n // the off-diagonal elements of the result. When assigning the\n // result to a SymmetricTensor, the constuctor of\n // that class checks the symmetry and realizes that it isn't\n // exactly symmetric; it will then raise an exception. To avoid\n // that, we explicitly symmetrize the result to make it exactly\n // symmetric.\n\n // The result of all these operations is then written back into\n // the original place:\n local_quadrature_points_history[q].old_stress\n = rotated_new_stress;\n }\n }\n }\n\n // This ends the project specific namespace Step18. The rest is\n // as usual and as already shown in step-17: A main() function\n // that initializes and terminates PETSc, calls the classes that do the\n // actual work, and makes sure that we catch all exceptions that propagate\n // up to this point:\n}\n\n\nint main (int argc, char **argv)\n{\n try\n {\n using namespace dealii;\n using namespace Step18;\n\n Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv);\n {\n deallog.depth_console (0);\n\n TopLevel<3> elastic_problem;\n elastic_problem.run ();\n }\n }\n catch (std::exception &exc)\n {\n std::cerr << std::endl << 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 << 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", "meta": {"hexsha": "843a882e8831cf52c83b255839ae0c44af695999", "size": 94409, "ext": "cc", "lang": "C++", "max_stars_repo_path": "MHD/examples/step-18/step-18.cc", "max_stars_repo_name": "wathen/PhD", "max_stars_repo_head_hexsha": "35524f40028541a4d611d8c78574e4cf9ddc3278", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2020-10-25T13:30:20.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-10T21:27:30.000Z", "max_issues_repo_path": "MHD/examples/step-18/step-18.cc", "max_issues_repo_name": "wathen/PhD", "max_issues_repo_head_hexsha": "35524f40028541a4d611d8c78574e4cf9ddc3278", "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": "MHD/examples/step-18/step-18.cc", "max_forks_repo_name": "wathen/PhD", "max_forks_repo_head_hexsha": "35524f40028541a4d611d8c78574e4cf9ddc3278", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2019-10-28T16:12:13.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-13T13:59:44.000Z", "avg_line_length": 46.5757276764, "max_line_length": 86, "alphanum_fraction": 0.6719910178, "num_tokens": 21680, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125848754472, "lm_q2_score": 0.7217431943271998, "lm_q1q2_score": 0.5427599651822598}} {"text": "\n#include \n#include \n#include \n\n#include \n#include \n\n#include \"SDOT/SemiDiscreteOT.h\"\n#include \"SDOT/Distances/Wasserstein2.h\"\n\n#include \"SDOT/PolygonRasterize.h\"\n#include \"SDOT/RegularGrid.h\"\n#include \"SDOT/DiscretizedDistribution.h\"\n\nusing namespace sdot;\nusing namespace sdot::distances;\n\nvoid LaguerreDiagramTest()\n{\n int numPts = 2;\n\n Eigen::VectorXd prices = Eigen::VectorXd::Ones(numPts);\n prices << 1, 0.873;//, 0.978674;//, 0.851588;//, 0.996466;\n\n Eigen::Matrix2Xd pts(2,numPts);\n pts << 0.823295, 0.329554,\n 0.604897, 0.536459;\n //pts = Eigen::Matrix2Xd::Random(2,numPts).cwiseAbs();\n\n Eigen::VectorXd discrProbs(numPts);\n discrProbs = (1.0/numPts)*Eigen::VectorXd::Ones(numPts);\n\n LaguerreDiagram lagDiag(0, 1, 0, 1, pts, prices);\n\n LaguerreDiagram::Point_2 startPt = std::get<1>(lagDiag.InternalEdges(0).at(0));\n LaguerreDiagram::Point_2 endPt = std::get<2>(lagDiag.InternalEdges(0).at(0));\n\n std::cout << \"Dividing edge = (\" << CGAL::to_double(startPt.x()) << \",\" << CGAL::to_double(startPt.y()) << \") -> (\" << CGAL::to_double(endPt.x()) << \",\" << CGAL::to_double(endPt.y()) << \")\" << std::endl;\n LaguerreDiagram::Point_2 midPt = startPt + 0.5*(endPt-startPt);\n\n double dist1 = std::sqrt( CGAL::to_double(CGAL::squared_distance(startPt,midPt)));\n double dist2 = std::sqrt( CGAL::to_double(CGAL::squared_distance(endPt,midPt)));\n\n assert( std::abs( (dist1 - prices(0)) - (dist2 - prices(0)))<1e-14 );\n}\n\n\nint main(int argc, char* argv[])\n{\n LaguerreDiagramTest();\n\n int numPts = 100;\n\n Eigen::VectorXd prices = Eigen::VectorXd::Ones(numPts);\n\n Eigen::Matrix2Xd pts = Eigen::Matrix2Xd::Random(2,numPts).cwiseAbs();\n\n std::cout << \"Points = \\n\";\n std::cout << \"[[\" << pts(0,0) << \",\" << pts(1,0) << \"]\";\n for(int i=1; i(domain(0,0),domain(1,0), domain(0,2), domain(1,2), 10,10);\n\n // Unnormalized density. Will be normalized in DiscretizedDistribution constructor\n Eigen::MatrixXd density = Eigen::MatrixXd::Ones(grid->NumCells(0), grid->NumCells(1));\n\n auto dist = std::make_shared(grid, density);\n\n // Evalaute the SDOT objective\n auto sdot = std::make_shared>(dist, pts, discrProbs);\n\n Eigen::VectorXd optPrices;\n double optVal;\n std::tie(optPrices,optVal) = sdot->Solve(Eigen::VectorXd::Ones(numPts));\n std::cout << \"Optimal prices = \" << optPrices.transpose() << std::endl;\n\n std::shared_ptr lagDiag = sdot->Diagram();\n\n std::cout << \"Laguerre cells = \" << std::endl;\n for(int polyInd=0; polyInd poly = lagDiag->GetCell(polyInd)->ToCGAL();\n\n auto vertIt = poly->vertices_begin();\n std::cout << \"[[\" << vertIt->x() << \",\" << vertIt->y() << \"]\";\n vertIt++;\n for(; vertIt != poly->vertices_end(); ++vertIt){\n std::cout << \", [\" << vertIt->x() << \",\" << vertIt->y() << \"]\";\n }\n std::cout << \"]\" << std::endl;\n }\n\n return 0;\n}\n", "meta": {"hexsha": "544334a254a481dab68224a0029caebec676e2f8", "size": 3418, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "tests/ComputeSDOT.cpp", "max_stars_repo_name": "mparno/sdot2d", "max_stars_repo_head_hexsha": "f632824fc4f0285eab6de911cca8932f69ece705", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "tests/ComputeSDOT.cpp", "max_issues_repo_name": "mparno/sdot2d", "max_issues_repo_head_hexsha": "f632824fc4f0285eab6de911cca8932f69ece705", "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": "tests/ComputeSDOT.cpp", "max_forks_repo_name": "mparno/sdot2d", "max_forks_repo_head_hexsha": "f632824fc4f0285eab6de911cca8932f69ece705", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.9439252336, "max_line_length": 205, "alphanum_fraction": 0.6383850205, "num_tokens": 1137, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031737963569016, "lm_q2_score": 0.6757646140788307, "lm_q1q2_score": 0.542756430533351}} {"text": "#ifndef CX_SVD_HPP\n#define CX_SVD_HPP\n\n#include \"print.hpp\"\n//#include \"cx_modify.hpp\"\n#include \"sub.hpp\"\n#include \"../tools.hpp\"\n// #include \"cx_multiply.hpp\"\n// #include \"cx_special.hpp\"\n\n#include \n\n#include \n#include \n\n#include \n#include \n#include \n\n// inline bool comparator ( const max_pair& l, const max_pair& r) { return l.first > r.first; }\n\nnamespace dqmc {\n namespace la {\n\n\tinline perm_mat cx_find_col_perm(cx_mat&__restrict in,\n\t\t\t\t\t cx_mat&__restrict out) {\n\t using namespace std;\n\t using namespace Eigen;\n\t mat_t::Index min_col;\n\t ivec col_ids(in.cols());\n\t for (int i = 0; i < in.rows(); ++i) {\n\t\tin.col(i).cwiseAbs().minCoeff(&min_col);\n\t\tcout << min_col << endl;\n\t\tcol_ids[i] = int(min_col) - 1;\n\t }\n\t // for (std::vector::iterator it=min_indices.begin();\n\t // \t it != min_indices.end(); ++it) {\n\t // \tcol_ids((*it).second) = std::distance(min_indices.begin(), it);\n\t // \t// cout << row_ids((*it).second) << \" \";\n\t // }\n\t // // cout << endl;\n\t perm_mat col_perm(col_ids);\n\t \n\t out = in * col_perm.transpose();\n\t return col_perm;\n\t}\n\t\n\tinline perm_mat cx_row_sort(cx_mat&__restrict in, cx_mat&__restrict out) {\n\t using namespace std;\n\t using namespace Eigen;\n\t vector max_index(in.rows());\n\t vector max_indices;\n\t vec max_vals(in.rows());\n\t mat A = in.cwiseAbs().real().cast();\n\t \n\t for(int i = 0; i < in.rows(); ++i) {\n\t\tmax_vals(i) = A.cwiseAbs().real().row(i).maxCoeff( &max_index[i] );\n\t\tmax_indices.push_back(max_pair(max_vals(i), i));\n\t }\n\t std::sort(max_indices.begin(), max_indices.end(), comparator);\n\n\t ivec row_ids(in.rows());\n\t for (std::vector::iterator it=max_indices.begin(); it != max_indices.end(); ++it) {\n\t\trow_ids((*it).second) = std::distance(max_indices.begin(), it);\n\t\t// cout << row_ids((*it).second) << \" \";\n\t }\n\t // cout << endl;\n\t perm_mat row_perm(row_ids);\n\t \n\t out = row_perm * in;\n\t return row_perm;\n\t}\n\n\n\tinline perm_mat cx_col_sort(cx_mat&__restrict in,\n\t\t\t\t cx_mat&__restrict out) {\n\t using namespace std;\n\t using namespace Eigen;\n\t vector max_index(in.cols());\n\t vector max_indices;\n\t vec max_vals(in.cols());\n\t mat A = in.cwiseAbs().real().cast();\n\t for(int i = 0; i < in.cols(); ++i) {\n\t\tmax_vals(i) = A.col(i).maxCoeff( &max_index[i] );\n\t\tmax_indices.push_back(max_pair(max_vals(i), i));\n\t }\n\t std::sort(max_indices.begin(), max_indices.end(), comparator);\n\n\t ivec col_ids(in.cols());\n\t for (std::vector::iterator it=max_indices.begin();\n\t\t it != max_indices.end(); ++it) {\n\t\tcol_ids((*it).second) = std::distance(max_indices.begin(), it);\n\t\t// cout << row_ids((*it).second) << \" \";\n\t }\n\t // cout << endl;\n\t perm_mat col_perm(col_ids);\n\t \n\t out = in * col_perm;\n\t return col_perm;\n\t}\n\n\n\tinline void decompose_svd(cx_mat&__restrict__ in,\n\t\t\t\t cx_mat&__restrict__ U, \n\t\t\t\t vec&__restrict__ D,\n\t\t\t\t cx_mat&__restrict__ T) {\n\t int lwork = -1;\n\t int m = in.rows();\n\t int n = in.cols();\n\t int lda = m;\n\t int ldu = m;\n\t int ldvt = n;\n\t cx_double wkopt;\n\t vec_t rwork(5 * m);\n\t int info = -1;\n\n\t cx_mat_t U_temp(m, m);\n\t vec D_temp(m);\n\t vec_t superb(std::min(m, n) - 1);\n\t info = LAPACKE_zgesvd( LAPACK_COL_MAJOR, 'A', 'A', m, n, in.data(), m,\n\t\t\t\t D_temp.data(), U_temp.data(), m, T.data(), n, superb.data());\n\t U = U_temp.block(0, 0, m, n);\n\t D = D_temp.segment(0, n);\n\t // lwork = -1;\n\t // zgesvd( \"All\", \"All\", &m, &n, in.data(), &lda, D.data(), U.data(), &ldu, T.data(),\n\t // \t &ldvt, &wkopt, &lwork,\n\t // \t rwork.data(), &info );\n\t // lwork = int(wkopt.real());\n\t // cx_vec_t work(lwork);\n\t // /* Compute SVD */\n\t // zgesvd( \"All\", \"All\", &m, &n, in.data(), &lda, D.data(), U.data(), &ldu, T.data(), &ldvt, work.data(), &lwork,\n\t // \t rwork.data(), &info );\n\n\t \n\t}\n\n\tinline void decompose_udt_full_piv(cx_mat&__restrict__ in,\n\t\t\t\t\t cx_mat&__restrict__ U, \n\t\t\t\t\t vec&__restrict__ D,\n\t\t\t\t\t cx_mat&__restrict__ T) {\n\t using namespace std;\n\t using namespace Eigen;\n\n\t if (U.rows() != in.rows() || U.cols() != in.cols()) {\n\t\tcout << U.rows() << \" vs. \" << in.rows() << \"\\tand\\t\"\n\t\t << U.cols() << \" vs. \" << in.cols() << endl;\n\t\tthrow std::runtime_error(\"dimensions of U are wrong\");\n\t }\n\t \n\t if (D.size() != in.cols()) {\n\t\tcout << D.size() << endl;\n\t\tthrow std::runtime_error(\"dimensions of D are wrong\");\n\t }\n\t \n\t if (T.rows() != in.cols() || U.cols() != in.cols()) {\n\t\tcout << T.rows() << \" vs. \" << in.cols() << \"\\tand\\t\"\n\t\t << U.cols() << \" vs. \" << in.cols() << endl;\n\t\tthrow std::runtime_error(\"dimensions of T are wrong\");\n\t }\n\n\t cx_mat_t scaled_in = in;\n\t // perm_mat row_perm = dqmc::la::cx_row_sort(in, scaled_in);\n\t // perm_mat col_perm = dqmc::la::cx_col_sort(scaled_in, in);\n\t \n\t Eigen::FullPivHouseholderQR qr(in);\n\t \n\t qr.compute(in);\n\t // U = row_perm.inverse() * qr.matrixQ().block(0, 0, in.rows(), in.cols());\n\t U = qr.matrixQ().block(0, 0, in.rows(), in.cols());\n\t \n\t cx_mat upper = qr.matrixQR().triangularView();// .block(0, 0, in.cols(), in.cols());\n\t // cout << \"upper\" << endl << upper << endl << endl;\n\t D = upper.block(0, 0, in.cols(), in.cols()).diagonal().real().cast();\n\t vec d_inv = D;\n\t \n\t for (int i = 0; i < in.cols(); ++i) {\n\t\tif (D(i) == 0.) {\t\t \n\t\t // std::cout << \"culprit \" << D(i) << \" was \"\n\t\t // \t << upper(i, i) << std::endl;\n\t\t dqmc::tools::abort(\"Invalid upper triangle\"); }\n\t\t // throw std::runtime_error(\"Invalid upper triangle\"); }\t\n\t\td_inv(i) = 1./D(i);\n\t\tif (D(i) < 0) { D(i) *= -1.;\n\t\t d_inv(i) *= -1.; }\n\t }\n\t // cout << \"D \" << endl << D.transpose() << endl << endl;\n\t // cout << \"inv D \" << endl << d_inv.transpose() << endl << endl;\n\t T = (d_inv.asDiagonal() * upper.block(0, 0, in.cols(), in.cols()))\n\t \t* qr.colsPermutation().transpose(); // * col_perm.inverse();\n\t if (D(0) != D(0)) std::cout << \"NaN alert\" << endl;\n\t}\n\n\tinline void decompose_udt_full_sort(cx_mat&__restrict__ in,\n\t\t\t\t\t cx_mat&__restrict__ U,\n\t\t\t\t\t vec&__restrict__ D,\n\t\t\t\t\t cx_mat&__restrict__ T) {\n\t using namespace std;\n\t using namespace Eigen;\n\n\t if (U.rows() != in.rows() || U.cols() != in.cols())\n\t\tthrow std::runtime_error(\"dimensions of U are wrong\");\n\t \n\t if (D.size() != in.cols()) {\n\t\tcout << D.size() << endl;\n\t\tthrow std::runtime_error(\"dimensions of D are wrong\");\n\t }\n\t \n\t if (T.rows() != in.cols() || U.cols() != in.cols())\n\t\tthrow std::runtime_error(\"dimensions of T are wrong\");\n\n\t cx_mat_t scaled_in;// = cx_mat_t::Zero(in.rows(), in.cols());\n\t scaled_in.fill(cx_double(0., 0.));\n\t perm_mat row_perm = dqmc::la::cx_row_sort(in, scaled_in);\n\t perm_mat col_perm = dqmc::la::cx_col_sort(scaled_in, in);\n\t \n\t // Very crude scaling...\n\t //\t double scale = pow(in.cwiseAbs().maxCoeff(), 0.5);\n\t double scale = 1.;\n\n\t cx_vec_t taus(in.cols());\n\t ivec iwork(in.cols());\n\t \n\t // vec work(in.rows() * in.rows() * in.rows());\n\t int lwork = -1;\n\t // int info = 0;\n\t int M = in.rows();\n\t int N = in.cols();\n\t \n\t scaled_in.block(0, 0, in.rows(), in.cols()) = in;\n\n\t iwork.setZero();\n\t lapack_int info = LAPACKE_zgeqp3( LAPACK_COL_MAJOR, M, N, scaled_in.data(),\n\t\t\t\t\t M, iwork.data(), taus.data() );\n\n\t // cout << iwork.size() << \" \" << work.size() << \" \" << taus.size() << endl;\n\t // lwork = -1;\n\t // zgeqp3_(&M, &N, scaled_in.data(), &M, iwork.data(),\n\t // \t taus.data(), taus.data(),\n\t // \t &lwork, &info);\n\t // lwork = taus(0);\n\t // cx_vec_t work(lwork);\n\t // work.setZero();\n\t // taus.setZero();\n\t \n\t // zgeqp3_(&M, &N, scaled_in.data(), &M, iwork.data(),\n\t // \t taus.data(), work.data(),\n\t // \t &lwork, &info);\n\n\t cx_mat_t upper = scaled_in.triangularView();\n\t D = upper.block(0, 0, in.cols(), in.cols()).diagonal().real().cast();\n\t vec d_inv = D;\n\t \n\t for (int i = 0; i < in.cols(); ++i) {\n\t\tif (D(i) == 0.) {\t\t \n\t\t // std::cout << \"culprit \" << D(i) << \" was \"\n\t\t // \t << upper(i, i) << std::endl;\n\t\t dqmc::tools::abort(\"Invalid upper triangle\"); }\n\t\t // throw std::runtime_error(\"Invalid upper triangle\"); }\t\n\t\td_inv(i) = 1./D(i);\n\t\tif (D(i) < 0) { D(i) *= -1.;\n\t\t d_inv(i) *= -1.; }\n\t }\n\t lwork = -1;\n\n\t info = LAPACKE_zungqr( LAPACK_COL_MAJOR, M, N, N,\n\t\t\t\t scaled_in.data(), M, taus.data() );\n\n\t // zungqr_(&M, &N, &N, scaled_in.data(), &M, taus.data(),\n\t // \t work.data(), &lwork, &info);\n\t // // if (work(0) > work.size()) {\n\t // // \tcout << \"Need more lwork for dorgqr\" << endl;\n\t // // }\n\t // lwork = work(0);\n\t // work.resize(lwork);\t \n\t // // cout << \"in\" << endl << scaled_in << endl << endl;\n\t // zungqr_(&M, &N, &N, scaled_in.data(), &M, taus.data(),\n\t // \t work.data(), &lwork, &info);\n\t // cout << \"out\" << endl << scaled_in << endl << endl;\n\t \n\t U = row_perm.inverse() * scaled_in.block(0, 0, in.rows(), in.cols()); \n\t ivec col_ids(in.cols());\n\t for (int i = 0; i < in.cols(); ++i) {\n\t\tcol_ids(i) = iwork(i) - 1;\n\t }\n\t \n\t Eigen::PermutationMatrix lapack_col_perm(col_ids);\n\t T = (d_inv.cast().asDiagonal()\n\t\t * upper.block(0, 0, in.cols(), in.cols()))\n\t\t* lapack_col_perm.transpose() * col_perm.transpose();\n\t D *= scale;\n\t if (D(0) != D(0)) std::cout << \"NaN alert\" << endl;\n\t}\n\n\tinline void decompose_udt_col_piv(cx_mat&__restrict__ in,\n\t\t\t\t\t cx_mat&__restrict__ U,\n\t\t\t\t\t vec&__restrict__ D,\n\t\t\t\t\t cx_mat&__restrict__ T) {\n\t using namespace std;\n\t using namespace Eigen;\n\t if (U.rows() != in.rows() || U.cols() != in.cols() || U.cols() == 0) {\n\t\tcout << U.rows() << \" \" << U.cols() << endl;\n\t\tthrow std::runtime_error(\"dimensions of U are wrong\");\n\t }\n\t \n\t if (D.size() != in.cols() || D.size() == 0) {\n\t\tcout << D.size() << endl;\n\t\tthrow std::runtime_error(\"dimensions of D are wrong\");\n\t }\n\t \n\t if (T.rows() != in.cols() || T.cols() == 0)\n\t\tthrow std::runtime_error(\"dimensions of T are wrong\");\n\n\t \n\t cx_mat_t scaled_in = cx_mat_t::Zero(in.rows(), in.cols());\n\t scaled_in.fill(cx_double(0., 0.));\n\n\t cx_vec_t taus(in.cols());\n\t ivec iwork(in.cols());\n\t \n\t int lwork = -1;\n\t int M = in.rows();\n\t int N = in.cols();\n\t \n\t perm_mat row_sort_perm = cx_row_sort(in, scaled_in);\n\t // scaled_in.block(0, 0, in.rows(), in.cols()) = in;\n\t iwork.setZero();\n\t lapack_int info = LAPACKE_zgeqp3( LAPACK_COL_MAJOR, M, N, scaled_in.data(),\n\t\t\t\t\t M, iwork.data(), taus.data() );\n\t \n\t cx_mat_t upper = scaled_in.triangularView();\n\t D = upper.block(0, 0, in.cols(), in.cols()).diagonal().real().cast();\n\t vec d_inv = D;\n\t \n\t for (int i = 0; i < in.cols(); ++i) {\n\t\tif (D(i) == 0.) {\t\t \n\t\t // std::cout << \"culprit \" << D(i) << \" was \"\n\t\t // \t << upper(i, i) << std::endl;\n\t\t dqmc::tools::abort(\"Invalid upper triangle\");\n\t\t // throw std::runtime_error(\"Invalid upper triangle\"); \n\t\t}\t\n\t\td_inv(i) = 1./D(i);\n\t\tif (D(i) < 0) { D(i) *= -1.;\n\t\t d_inv(i) *= -1.; }\n\t }\n\t lwork = -1;\n\n\t info = LAPACKE_zungqr( LAPACK_COL_MAJOR, M, N, N,\n\t\t\t\t scaled_in.data(), M, taus.data() );\n\n\t U = (row_sort_perm.inverse() * scaled_in).block(0, 0, in.rows(), in.cols()); \n\t ivec col_ids(in.cols());\n\t for (int i = 0; i < in.cols(); ++i) {\n\t\tcol_ids(i) = iwork(i) - 1;\n\t }\n\t \n\t Eigen::PermutationMatrix lapack_col_perm(col_ids);\n\t T = (d_inv.cast().asDiagonal()\n\t\t * upper.block(0, 0, in.cols(), in.cols()))\n\t\t* lapack_col_perm.transpose();\n\t if (D(0) != D(0)) std::cout << \"NaN alert\" << endl;\n\t}\n\t\n\n\tinline void decompose_udt(cx_mat&__restrict__ in,\n\t\t\t\t cx_mat&__restrict__ U,\n\t\t\t\t vec&__restrict__ D,\n\t\t\t\t cx_mat&__restrict__ T) {\n\t using namespace std;\n\t using namespace Eigen;\n\t if (U.rows() != in.rows() || U.cols() != in.cols() || U.cols() == 0) {\n\t\tcout << U.rows() << \" \" << U.cols() << endl;\n\t\tthrow std::runtime_error(\"dimensions of U are wrong\");\n\t }\n\t \n\t if (D.size() != in.cols() || D.size() == 0) {\n\t\tcout << D.size() << endl;\n\t\tthrow std::runtime_error(\"dimensions of D are wrong\");\n\t }\n\t \n\t if (T.rows() != in.cols() || T.cols() == 0)\n\t\tthrow std::runtime_error(\"dimensions of T are wrong\");\n\n\t \n\t cx_mat_t scaled_in = cx_mat_t::Zero(in.rows(), in.cols());\n\t scaled_in.fill(cx_double(0., 0.));\n\n\t cx_vec_t taus(in.cols());\n\t ivec iwork(in.cols());\n\t \n\t int lwork = -1;\n\t int M = in.rows();\n\t int N = in.cols();\n\t \n\t scaled_in.block(0, 0, in.rows(), in.cols()) = in;\n\t iwork.setZero();\n\n\t lapack_int info = LAPACKE_zgeqrf( LAPACK_COL_MAJOR, M, N,\n\t\t\t\t\t scaled_in.data(),\n\t\t\t\t\t M, taus.data() );\n\t \n\t cx_mat_t upper = scaled_in.triangularView();\n\t D = upper.block(0, 0, in.cols(), in.cols()).diagonal().real().cast();\n\t vec d_inv = D;\n\t \n\t for (int i = 0; i < in.cols(); ++i) {\n\t\tif (D(i) == 0.) {\t\t \n\t\t dqmc::tools::abort(\"Invalid upper triangle\");\n\t\t} \n\t\t // throw std::runtime_error(\"Invalid upper triangle\"); }\t\n\t\td_inv(i) = 1./D(i);\n\t\tif (D(i) < 0) { D(i) *= -1.;\n\t\t d_inv(i) *= -1.; }\n\t }\n\t lwork = -1;\n\n\t info = LAPACKE_zungqr( LAPACK_COL_MAJOR, M, N, N,\n\t\t\t\t scaled_in.data(), M, taus.data() );\n\n\t U = scaled_in.block(0, 0, in.rows(), in.cols()); \n\t ivec col_ids(in.cols());\n\t for (int i = 0; i < in.cols(); ++i) {\n\t\tcol_ids(i) = iwork(i) - 1;\n\t }\n\t \n\t T = (d_inv.cast().asDiagonal()\n\t\t * upper.block(0, 0, in.cols(), in.cols()));\n\t if (D(0) != D(0)) std::cout << \"NaN alert\" << endl;\n\t}\n }\t\n}\n#endif\n", "meta": {"hexsha": "e0391283eac3863f2b5092447f7fd5b404623523", "size": 13977, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "libdqmc/la/cx_svd.hpp", "max_stars_repo_name": "pebroecker/DQMC", "max_stars_repo_head_hexsha": "c4a96cb20347ef722b6ae68c415233d464c89e93", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "libdqmc/la/cx_svd.hpp", "max_issues_repo_name": "pebroecker/DQMC", "max_issues_repo_head_hexsha": "c4a96cb20347ef722b6ae68c415233d464c89e93", "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": "libdqmc/la/cx_svd.hpp", "max_forks_repo_name": "pebroecker/DQMC", "max_forks_repo_head_hexsha": "c4a96cb20347ef722b6ae68c415233d464c89e93", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.3541666667, "max_line_length": 118, "alphanum_fraction": 0.5375974816, "num_tokens": 4304, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031737963569014, "lm_q2_score": 0.6757645879592642, "lm_q1q2_score": 0.5427564095547994}} {"text": "// -*- mode: c++; indent-tabs-mode: nil; -*-\n//\n// Copyright (c) 2009-2013 Illumina, Inc.\n//\n// This software is provided under the terms and conditions of the\n// Illumina Open Source Software License 1.\n//\n// You should have received a copy of the Illumina Open Source\n// Software License 1 along with this program. If not, see\n// \n//\n\n/// \\file\n\n/// \\author Chris Saunders\n///\n#include \"blt_util/stat_util.hh\"\n\n#include \n\n\n\nbool\nis_chi_sqr_reject(const double xsq,\n const unsigned df,\n const double alpha) {\n\n assert(xsq>=0);\n assert(df>0);\n\n boost::math::chi_squared dist(df);\n return ((1.-boost::math::cdf(dist,xsq)) < alpha);\n\n#if 0\n // alternate implementation (is one faster?):\n const double xsq_crit_val(boost::math::quantile(dist,1.-alpha));\n return xsq>xsq_crit_val;\n#endif\n}\n\n\n\nbool\nis_lrt_reject_null(const double null_loghood,\n const double alt_loghood,\n const unsigned df,\n const double alpha) {\n\n if (df == 0) return false;\n if (null_loghood>alt_loghood) return false;\n\n const double log_lrt(-2.*(null_loghood-alt_loghood));\n\n return is_chi_sqr_reject(log_lrt,df,alpha);\n}\n", "meta": {"hexsha": "fd7501837dd998d5cdf7db1611c44d33be0084b9", "size": 1292, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "isaac_variant_caller/src/lib/blt_util/stat_util.cpp", "max_stars_repo_name": "sequencing/isaac_variant_caller", "max_stars_repo_head_hexsha": "ed24e20b097ee04629f61014d3b81a6ea902c66b", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 21.0, "max_stars_repo_stars_event_min_datetime": "2015-01-09T01:11:28.000Z", "max_stars_repo_stars_event_max_datetime": "2019-09-04T03:48:21.000Z", "max_issues_repo_path": "isaac_variant_caller/src/lib/blt_util/stat_util.cpp", "max_issues_repo_name": "sequencing/isaac_variant_caller", "max_issues_repo_head_hexsha": "ed24e20b097ee04629f61014d3b81a6ea902c66b", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 4.0, "max_issues_repo_issues_event_min_datetime": "2015-07-23T09:38:39.000Z", "max_issues_repo_issues_event_max_datetime": "2018-02-01T05:37:26.000Z", "max_forks_repo_path": "isaac_variant_caller/src/lib/blt_util/stat_util.cpp", "max_forks_repo_name": "sequencing/isaac_variant_caller", "max_forks_repo_head_hexsha": "ed24e20b097ee04629f61014d3b81a6ea902c66b", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 13.0, "max_forks_repo_forks_event_min_datetime": "2015-01-29T16:41:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-25T02:42:32.000Z", "avg_line_length": 23.0714285714, "max_line_length": 68, "alphanum_fraction": 0.649380805, "num_tokens": 326, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.819893353516963, "lm_q2_score": 0.66192288918838, "lm_q1q2_score": 0.542706177386298}} {"text": "#include \n#include \n#include \n#include \n#include \n\nint findBestPack( const std::vector > & ,\n std::set & , const int ) ;\n\nint main( ) {\n std::vector > items ;\n //===========fill the vector with data====================\n items.push_back( boost::make_tuple( \"\" , 0 , 0 ) ) ;\n items.push_back( boost::make_tuple( \"map\" , 9 , 150 ) ) ;\n items.push_back( boost::make_tuple( \"compass\" , 13 , 35 ) ) ;\n items.push_back( boost::make_tuple( \"water\" , 153 , 200 ) ) ;\n items.push_back( boost::make_tuple( \"sandwich\", 50 , 160 ) ) ;\n items.push_back( boost::make_tuple( \"glucose\" , 15 , 60 ) ) ;\n items.push_back( boost::make_tuple( \"tin\", 68 , 45 ) ) ;\n items.push_back( boost::make_tuple( \"banana\", 27 , 60 ) ) ;\n items.push_back( boost::make_tuple( \"apple\" , 39 , 40 ) ) ;\n items.push_back( boost::make_tuple( \"cheese\" , 23 , 30 ) ) ;\n items.push_back( boost::make_tuple( \"beer\" , 52 , 10 ) ) ;\n items.push_back( boost::make_tuple( \"suntan creme\" , 11 , 70 ) ) ;\n items.push_back( boost::make_tuple( \"camera\" , 32 , 30 ) ) ;\n items.push_back( boost::make_tuple( \"T-shirt\" , 24 , 15 ) ) ;\n items.push_back( boost::make_tuple( \"trousers\" , 48 , 10 ) ) ;\n items.push_back( boost::make_tuple( \"umbrella\" , 73 , 40 ) ) ;\n items.push_back( boost::make_tuple( \"waterproof trousers\" , 42 , 70 ) ) ;\n items.push_back( boost::make_tuple( \"waterproof overclothes\" , 43 , 75 ) ) ;\n items.push_back( boost::make_tuple( \"note-case\" , 22 , 80 ) ) ;\n items.push_back( boost::make_tuple( \"sunglasses\" , 7 , 20 ) ) ;\n items.push_back( boost::make_tuple( \"towel\" , 18 , 12 ) ) ;\n items.push_back( boost::make_tuple( \"socks\" , 4 , 50 ) ) ;\n items.push_back( boost::make_tuple( \"book\" , 30 , 10 ) ) ;\n const int maximumWeight = 400 ;\n std::set bestItems ; //these items will make up the optimal value\n int bestValue = findBestPack( items , bestItems , maximumWeight ) ;\n std::cout << \"The best value that can be packed in the given knapsack is \" <<\n bestValue << \" !\\n\" ;\n int totalweight = 0 ;\n std::cout << \"The following items should be packed in the knapsack:\\n\" ;\n for ( std::set::const_iterator si = bestItems.begin( ) ;\n\t si != bestItems.end( ) ; si++ ) {\n std::cout << (items.begin( ) + *si)->get<0>( ) << \"\\n\" ;\n totalweight += (items.begin( ) + *si)->get<1>( ) ;\n }\n std::cout << \"The total weight of all items is \" << totalweight << \" !\\n\" ;\n return 0 ;\n}\n\nint findBestPack( const std::vector > & items ,std::set & bestItems , const int weightlimit ) {\n //dynamic programming approach sacrificing storage space for execution\n //time , creating a table of optimal values for every weight and a\n //second table of sets with the items collected so far in the knapsack\n //the best value is in the bottom right corner of the values table,\n //the set of items in the bottom right corner of the sets' table.\n const int n = items.size( ) ;\n int bestValues [ n ][ weightlimit ] ;\n std::set solutionSets[ n ][ weightlimit ] ;\n std::set emptyset ;\n for ( int i = 0 ; i < n ; i++ ) {\n for ( int j = 0 ; j < weightlimit ; j++ ) {\n\t bestValues[ i ][ j ] = 0 ;\n\t solutionSets[ i ][ j ] = emptyset ;\n }\n }\n for ( int i = 0 ; i < n ; i++ ) {\n for ( int weight = 0 ; weight < weightlimit ; weight++ ) {\n\t if ( i == 0 )\n\t bestValues[ i ][ weight ] = 0 ;\n\t else {\n\t int itemweight = (items.begin( ) + i)->get<1>( ) ;\n\t if ( weight < itemweight ) {\n\t\tbestValues[ i ][ weight ] = bestValues[ i - 1 ][ weight ] ;\n\t\tsolutionSets[ i ][ weight ] = solutionSets[ i - 1 ][ weight ] ;\n\t } else { // weight >= itemweight\n\t\tif ( bestValues[ i - 1 ][ weight - itemweight ] +\n\t\t (items.begin( ) + i)->get<2>( ) >\n\t\t bestValues[ i - 1 ][ weight ] ) {\n\t\t bestValues[ i ][ weight ] =\n\t\t bestValues[ i - 1 ][ weight - itemweight ] +\n\t \t(items.begin( ) + i)->get<2>( ) ;\n\t\t solutionSets[ i ][ weight ] =\n\t\t solutionSets[ i - 1 ][ weight - itemweight ] ;\n\t\t solutionSets[ i ][ weight ].insert( i ) ;\n\t }\n\t else {\n\t\tbestValues[ i ][ weight ] = bestValues[ i - 1 ][ weight ] ;\n\t\tsolutionSets[ i ][ weight ] = solutionSets[ i - 1 ][ weight ] ;\n\t }\n\t }\n }\n }\n }\n bestItems.swap( solutionSets[ n - 1][ weightlimit - 1 ] ) ;\n return bestValues[ n - 1 ][ weightlimit - 1 ] ;\n}\n", "meta": {"hexsha": "2bdb241a0396d883c7fcaa7929115ba0bdd45ebd", "size": 4531, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "lang/C++/knapsack-problem-0-1.cpp", "max_stars_repo_name": "ethansaxenian/RosettaDecode", "max_stars_repo_head_hexsha": "8ea1a42a5f792280b50193ad47545d14ee371fb7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2021-01-29T20:08:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T06:16:05.000Z", "max_issues_repo_path": "lang/C++/knapsack-problem-0-1.cpp", "max_issues_repo_name": "ethansaxenian/RosettaDecode", "max_issues_repo_head_hexsha": "8ea1a42a5f792280b50193ad47545d14ee371fb7", "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": "lang/C++/knapsack-problem-0-1.cpp", "max_forks_repo_name": "ethansaxenian/RosettaDecode", "max_forks_repo_head_hexsha": "8ea1a42a5f792280b50193ad47545d14ee371fb7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-04-13T04:19:31.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-13T04:19:31.000Z", "avg_line_length": 45.7676767677, "max_line_length": 138, "alphanum_fraction": 0.5824321342, "num_tokens": 1412, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933359135361, "lm_q2_score": 0.6619228758499942, "lm_q1q2_score": 0.5427061547981331}} {"text": "#pragma once\n\n#include \n#include \n#include \"shannonEntropy.hpp\"\n#include \n \n// using Eigen::ArrayXi;\n\nusing ArrayXL = Eigen::Array; \n\nusing namespace std;\n// using namespace arma;\n\n// static_assert(sizeof(sword) ==8); //findHFPair works on the assumption that arma::sword is 64 bit\n\nstruct ETC {\n\n union pair {\n struct {\n uint64_t i1;\n uint64_t i2;\n } __attribute__((packed));\n __int128 i128;\n\n bool operator==(const pair& other)\n {\n return i128 == other.i128;\n }\n };\n \n static ETC::pair makeETCPair (uint64_t a, uint64_t b) {ETC::pair p; p.i1 = a; p.i2 = b; return p;};\n\n typedef unordered_map<__int128, unsigned int> pairFreqTable;\n\n\n static ETC::pair findHFPair(const ArrayXL &seq) {\n /*\n this implementation works very slightly differently from the matlab original where more that one pair wins the highest frequency\n - the matlab version depends on arbitrary behaviour of max(x)\n [m,indx]=max(Count_Array(:));\n i.e. chooses winner based on first position in 2d frequency matrix\n whereas this version chooses the first winner in the order of the array, which is slightly faster\n tests show this occasionally makes very minor differences in the results\n */\n ETC::pairFreqTable histo;\n ETC::pair winner;\n unsigned int highScore=0;\n\n unsigned int seqPos = 0;\n while (seqPos < seq.size()-1) {\n ETC::pair currPair = ETC::makeETCPair(seq[seqPos], seq[seqPos+1]);\n ETC::pairFreqTable::iterator it = histo.find(currPair.i128);\n unsigned int score;\n if (it == histo.end()) {\n histo.insert(std::make_pair(currPair.i128, 1));\n score=1;\n }else{\n score = it->second + 1;\n it->second = score;\n }\n if (score > highScore) {\n highScore = score;\n winner = currPair;\n }\n if (currPair.i1 == currPair.i2) {\n if (seqPos < seq.size()-2) {\n if (seq[seqPos+2] == seq[seqPos]) {\n seqPos++;\n }\n }\n }\n seqPos++;\n }\n return winner;\n }\n \n\n static auto substitute(const ArrayXL &seq, ETC::pair p) {\n int64_t replacementSymbol = seq.maxCoeff() + 1;\n ArrayXL newSeq(seq.size());\n size_t src=0, dest=0;\n size_t replaceCount=0;\n while(src < seq.size()) {\n if (src < seq.size()-1) {\n if (seq[src] == p.i1 && seq[src+1] == p.i2) {\n newSeq[dest] = replacementSymbol;\n src++;\n replaceCount++;\n } else {\n newSeq[dest] = seq[src];\n }\n }else{\n newSeq[dest] = seq[src];\n }\n src++;\n dest++;\n }\n ArrayXL finalSeq = newSeq.head(dest);\n return std::make_tuple(finalSeq, replaceCount, replacementSymbol);\n }\n\n // static double calcOld(const ivec &seq) {\n // double N = 0; //ETC measure\n // double Hnew = shannonEntropy::calc(seq);\n // ivec newSeq = seq;\n \n // //todo: this can be optimised by continually editing the shannon histo instead of redoing it every time\n // while(Hnew >1e-6 && newSeq.size() > 1) {\n // ETC::pair hfPair = ETC::findHFPair(newSeq);\n // auto [newSeqRepl, replaceCount, replaceSym] = ETC::substitute(newSeq, hfPair);\n // Hnew = shannonEntropy::calc(newSeqRepl);\n // newSeq = newSeqRepl;\n // N++;\n // // cout << newSeq << endl;\n // // cout << N << \", \" << Hnew << endl;\n // }\n \n // return N;\n // }\n \n static double calc(const ArrayXL &seq) {\n double N = 0; //ETC measure\n// cout << seq << endl;\n if (seq.size() > 1) {\n shannonEntropy::histoMap histo = shannonEntropy::calcDistribution(seq);\n double Hnew = shannonEntropy::calcProbability(histo, seq);\n\n ArrayXL newSeq = seq;\n \n while(Hnew >1e-6 && newSeq.size() > 1) {\n ETC::pair hfPair = ETC::findHFPair(newSeq);\n auto [newSeqRepl, replaceCount, replaceSym] = ETC::substitute(newSeq, hfPair);\n //reduce counts of replacement pair\n shannonEntropy::histoMap::iterator it = histo.find(hfPair.i1);\n it->second -= replaceCount;\n if (it->second == 0) {\n //remove from the histo\n histo.erase(it);\n }\n it = histo.find(hfPair.i2);\n it->second -= replaceCount;\n if (it->second == 0) {\n //remove from the histo\n histo.erase(it);\n }\n //add the new symbol into the histogram\n auto histoEntry = make_pair(replaceSym, replaceCount);\n histo.insert(histoEntry);\n \n \n Hnew = shannonEntropy::calcProbability(histo, newSeqRepl);\n newSeq = newSeqRepl;\n N++;\n }\n N /= (seq.size() -1);\n }\n return N;\n }\n \n static double calcJoint(const ArrayXL& seq1, const ArrayXL& seq2) {\n \n ArrayXL combSeq(seq1.size());\n for (size_t i=0; i < seq1.size(); i++) {\n combSeq[i] =(uint64_t)( seq1[i] | (seq2[i] << 32));\n }\n return ETC::calc(combSeq);\n }\n\n};\n", "meta": {"hexsha": "28f11e6d59aa44b983e46482cb35f3df9cd3b724", "size": 5754, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "ETC.hpp", "max_stars_repo_name": "chriskiefer/libcccrt", "max_stars_repo_head_hexsha": "e05edc8ed65cecc5515ccb5469e4c73fc4549231", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2021-03-19T23:16:06.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-19T03:20:15.000Z", "max_issues_repo_path": "ETC.hpp", "max_issues_repo_name": "chriskiefer/libcccrt", "max_issues_repo_head_hexsha": "e05edc8ed65cecc5515ccb5469e4c73fc4549231", "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": "ETC.hpp", "max_forks_repo_name": "chriskiefer/libcccrt", "max_forks_repo_head_hexsha": "e05edc8ed65cecc5515ccb5469e4c73fc4549231", "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": 33.649122807, "max_line_length": 137, "alphanum_fraction": 0.5034758429, "num_tokens": 1395, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933271118222, "lm_q2_score": 0.6619228758499942, "lm_q1q2_score": 0.5427061489720774}} {"text": "//==================================================================================================\n/*!\n @file\n\n @copyright 2016 NumScale SAS\n\n Distributed under the Boost Software License, Version 1.0.\n (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)\n\n**/\n//==================================================================================================\n#ifndef BOOST_SIMD_HYPERBOLIC_HPP_INCLUDED\n#define BOOST_SIMD_HYPERBOLIC_HPP_INCLUDED\n\nnamespace boost { namespace simd\n{\n /*!\n @ingroup group-functions\n @defgroup group-hyperbolic Hyperbolic functions\n\n These functions provides scalar and SIMD version of\n hyperbolic and inverse hyperbolic functions.\n\n - Direct hyperbolic functors\n\n

\n | name | name | name | name |\n |:-------------:|:------------:|:--------------:|:------------:|\n | @ref cosh | @ref csch | @ref sinh | @ref sinhcosh|\n | @ref coth | @ref sech | @ref sinhc | @ref tanh |\n
\n\n @ref sinhc is the hyperbolic sinus cardinal function\n (\\f$\\sinh x/x\\f$).\n\n @ref sinhcosh allows the simultaneous\n computation of hyperbolic sine and cosine at lower cost.\n\n @ref sech and @ref csch are the hyperbolic secant (inverse of\n the hyperbolic cosine) and cosecant (inverse of the hyperbolic sine)\n\n - Inverse hyperbolic functors\n\n
\n | name | name | name |\n |:-----------:|:------------:|:-----------:|\n | @ref acosh | @ref acsch | @ref asinh |\n | @ref acoth | @ref asech | @ref atanh |\n
\n **/\n\n} }\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#endif\n", "meta": {"hexsha": "ef45e4030b5d22b8e29d2e235eb0966453fca352", "size": 2315, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "third_party/boost/simd/hyperbolic.hpp", "max_stars_repo_name": "xmar/pythran", "max_stars_repo_head_hexsha": "dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2018-02-20T11:21:12.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-12T13:45:09.000Z", "max_issues_repo_path": "third_party/boost/simd/hyperbolic.hpp", "max_issues_repo_name": "xmar/pythran", "max_issues_repo_head_hexsha": "dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "third_party/boost/simd/hyperbolic.hpp", "max_forks_repo_name": "xmar/pythran", "max_forks_repo_head_hexsha": "dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2017-12-12T12:29:52.000Z", "max_forks_repo_forks_event_max_datetime": "2019-04-08T15:55:25.000Z", "avg_line_length": 33.0714285714, "max_line_length": 100, "alphanum_fraction": 0.5555075594, "num_tokens": 560, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933271118221, "lm_q2_score": 0.6619228758499942, "lm_q1q2_score": 0.5427061489720773}} {"text": "#include \n#include \n#include \n\n// CGAL headers\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// Qt headers\n#include \n#include \n#include \n#include \n#include \n\n// GraphicsView items and event filters (input classes)\n#include \n#include \"ArcsGraphicsItem.h\"\n\n// the two base classes\n#include \"ui_Circular_kernel_2.h\"\n#include \n\ntypedef CGAL::Quotient NT;\ntypedef CGAL::Cartesian Linear_k;\n\ntypedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k;\ntypedef CGAL::Circular_kernel_2 CircularKernel;\n\ntypedef CircularKernel::Point_2 Point_2;\ntypedef CircularKernel::Segment_2 Segment_2;\ntypedef CircularKernel::Line_arc_2 Line_arc_2;\ntypedef CircularKernel::Circular_arc_2 Circular_arc_2;\ntypedef CircularKernel::Circular_arc_point_2 Circular_arc_point_2;\n\n\ntypedef CGAL::Qt::ArcsGraphicsItem ArcsGraphicsItem;\n\n\ntypedef std::vector ArcContainer;\n\nclass MainWindow :\n public CGAL::Qt::DemosMainWindow,\n public Ui::Circular_kernel_2\n{\n Q_OBJECT\n\nprivate:\n ArcContainer arcs;\n ArcContainer intersections;\n QGraphicsScene scene;\n\n ArcsGraphicsItem * agi;\n\n\n CGAL::Qt::GraphicsViewCircularArcInput * cai;\n\npublic:\n MainWindow();\n\npublic Q_SLOTS:\n\n virtual void open(QString);\n\n void processInput(CGAL::Object o);\n\n\n void on_actionInsertCircularArc_toggled(bool checked);\n\n void on_actionClear_triggered();\n\n void on_actionLoadLineAndCircularArcs_triggered();\n\n void on_actionRecenter_triggered();\n\n\nQ_SIGNALS:\n void changed();\n};\n\n\nMainWindow::MainWindow()\n : DemosMainWindow()\n{\n setupUi(this);\n\n // Add a GraphicItem for the Circular triangulation\n agi = new CGAL::Qt::ArcsGraphicsItem(arcs, intersections);\n\n agi->setIntersectionsPen(QPen(Qt::red, 3, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));\n\n QObject::connect(this, SIGNAL(changed()),\n agi, SLOT(modelChanged()));\n\n agi->setInputPen(QPen(Qt::black, 0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));\n scene.addItem(agi);\n agi->hide();\n\n // Setup input handlers. They get events before the scene gets them\n // and the input they generate is passed to the triangulation with\n // the signal/slot mechanism\n cai = new CGAL::Qt::GraphicsViewCircularArcInput(this, &scene);\n\n QObject::connect(cai, SIGNAL(generate(CGAL::Object)),\n this, SLOT(processInput(CGAL::Object)));\n\n // Manual handling of actions\n //\n QObject::connect(this->actionQuit, SIGNAL(triggered()),\n qApp, SLOT(quit()));\n\n // Check two actions\n this->actionInsertCircularArc->setChecked(true);\n\n //\n // Setup the scene and the view\n //\n scene.setItemIndexMethod(QGraphicsScene::NoIndex);\n scene.setSceneRect(-100, -100, 100, 100);\n this->graphicsView->setScene(&scene);\n\n // Uncomment the following line to get antialiasing by default.\n// actionUse_Antialiasing->setChecked(true);\n\n // Turn the vertical axis upside down\n this->graphicsView->scale(1, -1);\n\n // The navigation adds zooming and translation functionality to the\n // QGraphicsView\n this->addNavigation(this->graphicsView);\n\n this->setupStatusBar();\n this->setupOptionsMenu();\n this->addAboutDemo(\":/cgal/help/about_Circular_kernel_2.html\");\n this->addAboutCGAL();\n this->addRecentFiles(this->menuFile, this->actionQuit);\n connect(this, SIGNAL(openRecentFile(QString)),\n this, SLOT(open(QString)));\n}\n\n\nvoid\nMainWindow::processInput(CGAL::Object o)\n{\n Circular_arc_2 ca;\n Line_arc_2 la;\n bool is_circular = false;\n\n if(assign(ca, o)){\n is_circular = true;\n } else if(! assign(la, o)){\n std::cerr << \"unknown object\" << std::endl;\n return;\n }\n\n for(std::vector::iterator it = arcs.begin(); it != arcs.end(); ++it){\n Circular_arc_2 vca;\n Line_arc_2 vla;\n if(assign(vca, *it)){\n if(is_circular){\n CGAL::intersection(ca, vca, std::back_inserter(intersections));\n } else {\n CGAL::intersection(la, vca, std::back_inserter(intersections));\n }\n } else if(assign(vla, *it)){\n if(is_circular){\n CGAL::intersection(ca, vla, std::back_inserter(intersections));\n } else {\n CGAL::intersection(la, vla, std::back_inserter(intersections));\n }\n }\n }\n arcs.push_back(o);\n Q_EMIT( changed());\n}\n\n\n/*\n * Qt Automatic Connections\n * https://doc.qt.io/qt-5/designer-using-a-ui-file.html#automatic-connections\n *\n * setupUi(this) generates connections to the slots named\n * \"on__\"\n */\n\nvoid\nMainWindow::on_actionInsertCircularArc_toggled(bool checked)\n{\n if(checked){\n scene.installEventFilter(cai);\n } else {\n scene.removeEventFilter(cai);\n }\n}\n\nvoid\nMainWindow::on_actionClear_triggered()\n{\n arcs.clear();\n intersections.clear();\n Q_EMIT( changed());\n}\n\nvoid\nMainWindow::on_actionLoadLineAndCircularArcs_triggered()\n{\n QString fileName = QFileDialog::getOpenFileName(this,\n tr(\"Open Line and Circular Arc File\"),\n \".\",\n tr(\"Edge files (*.arc)\\n\"\n \"WKT files (*.wkt *.WKT)\\n\"\n ));\n if(! fileName.isEmpty()){\n open(fileName);\n this->addToRecentFiles(fileName);\n }\n}\n\n\nvoid\nMainWindow::open(QString fileName)\n{\n std::ifstream ifs(qPrintable(fileName));\n\n char c;\n double x,y;\n if(fileName.endsWith(\".wkt\", Qt::CaseInsensitive))\n {\n //read pairs as Line_arc_2 and triplets as circular_arc_2\n do\n {\n std::vector multi_points;\n CGAL::IO::read_multi_point_WKT(ifs, multi_points);\n if(multi_points.size() == 2)\n {\n Line_arc_2 la(Segment_2(multi_points[0],\n multi_points[1]));\n for(std::vector::iterator it = arcs.begin(); it != arcs.end(); ++it){\n Circular_arc_2 vca;\n Line_arc_2 vla;\n if(assign(vca, *it)){\n CGAL::intersection(la, vca, std::back_inserter(intersections));\n } else if(assign(vla, *it)){\n CGAL::intersection(la, vla, std::back_inserter(intersections));\n }\n }\n arcs.push_back(make_object(la));\n }\n else if(multi_points.size() == 3)\n {\n Circular_arc_2 ca(multi_points[0],\n multi_points[1],\n multi_points[2]);\n for(std::vector::iterator it = arcs.begin(); it != arcs.end(); ++it){\n Circular_arc_2 vca;\n Line_arc_2 vla;\n if(assign(vca, *it)){\n CGAL::intersection(ca, vca, std::back_inserter(intersections));\n } else if(assign(vla, *it)){\n CGAL::intersection(ca, vla, std::back_inserter(intersections));\n }\n }\n arcs.push_back(make_object(ca));\n }\n else if(multi_points.size()>0)\n {\n std::cerr<<\"unreadable object.\"<> c){\n if(c == 's'){\n ifs >> x >> y;\n Point_2 p(x,y);\n ifs >> x >> y;\n Point_2 q(x,y);\n\n Line_arc_2 la(Segment_2(p,q));\n for(std::vector::iterator it = arcs.begin(); it != arcs.end(); ++it){\n Circular_arc_2 vca;\n Line_arc_2 vla;\n if(assign(vca, *it)){\n CGAL::intersection(la, vca, std::back_inserter(intersections));\n } else if(assign(vla, *it)){\n CGAL::intersection(la, vla, std::back_inserter(intersections));\n }\n }\n arcs.push_back(make_object(la));\n } else if(c == 'c'){\n ifs >> x >> y;\n Point_2 p(x,y);\n ifs >> x >> y;\n Point_2 q(x,y);\n ifs >> x >> y;\n Point_2 r(x,y);\n Circular_arc_2 ca(p,q,r);\n for(std::vector::iterator it = arcs.begin(); it != arcs.end(); ++it){\n Circular_arc_2 vca;\n Line_arc_2 vla;\n if(assign(vca, *it)){\n CGAL::intersection(ca, vca, std::back_inserter(intersections));\n } else if(assign(vla, *it)){\n CGAL::intersection(ca, vla, std::back_inserter(intersections));\n }\n }\n arcs.push_back(make_object(ca));\n }\n }\n }\n Q_EMIT( changed());\n}\n\nvoid\nMainWindow::on_actionRecenter_triggered()\n{\n this->graphicsView->setSceneRect(agi->boundingRect());\n this->graphicsView->fitInView(agi->boundingRect(), Qt::KeepAspectRatio);\n}\n\n\n#include \"Circular_kernel_2.moc\"\n#include \n\nint main(int argc, char **argv)\n{\n QApplication app(argc, argv);\n\n app.setOrganizationDomain(\"geometryfactory.com\");\n app.setOrganizationName(\"GeometryFactory\");\n app.setApplicationName(\"Circular_kernel_2 demo\");\n\n // Import resources from libCGAL (Qt5).\n CGAL_QT_INIT_RESOURCES;\n\n MainWindow mainWindow;\n mainWindow.show();\n return app.exec();\n}\n", "meta": {"hexsha": "4fa766fb87c91bfbdd9d94fc4882dcb422050078", "size": 9777, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "GraphicsView/demo/Circular_kernel_2/Circular_kernel_2.cpp", "max_stars_repo_name": "ffteja/cgal", "max_stars_repo_head_hexsha": "c1c7f4ad9a4cd669e33ca07a299062a461581812", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 3227.0, "max_stars_repo_stars_event_min_datetime": "2015-03-05T00:19:18.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T08:20:35.000Z", "max_issues_repo_path": "GraphicsView/demo/Circular_kernel_2/Circular_kernel_2.cpp", "max_issues_repo_name": "ffteja/cgal", "max_issues_repo_head_hexsha": "c1c7f4ad9a4cd669e33ca07a299062a461581812", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 5574.0, "max_issues_repo_issues_event_min_datetime": "2015-03-05T00:01:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T15:08:11.000Z", "max_forks_repo_path": "GraphicsView/demo/Circular_kernel_2/Circular_kernel_2.cpp", "max_forks_repo_name": "ffteja/cgal", "max_forks_repo_head_hexsha": "c1c7f4ad9a4cd669e33ca07a299062a461581812", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 1274.0, "max_forks_repo_forks_event_min_datetime": "2015-03-05T00:01:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T14:47:56.000Z", "avg_line_length": 28.0948275862, "max_line_length": 93, "alphanum_fraction": 0.6078551703, "num_tokens": 2405, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933315126791, "lm_q2_score": 0.6619228691808011, "lm_q1q2_score": 0.5427061464170783}} {"text": "// Distributed under the MIT License.\n// See LICENSE.txt for details.\n\n// Defines the class BulgedCube.\n\n#pragma once\n\n#include \n#include \n#include \n#include \n\n#include \"DataStructures/Tensor/TypeAliases.hpp\"\n#include \"Utilities/TypeTraits/RemoveReferenceWrapper.hpp\"\n\n/// \\cond\nnamespace PUP {\nclass er;\n} // namespace PUP\n/// \\endcond\n\nnamespace domain {\nnamespace CoordinateMaps {\n\n/*!\n * \\ingroup CoordinateMapsGroup\n *\n * \\brief Three dimensional map from the cube to a bulged cube.\n * The cube is shaped such that the surface is compatible\n * with the inner surface of Wedge3D.\n * The shape of the object can be chosen to be cubical,\n * if the sphericity is set to 0, or to a sphere, if\n * the sphericity is set to 1. The sphericity can\n * be set to any number between 0 and 1 for a bulged cube.\n *\n * \\details The volume map from the cube to a bulged cube is obtained by\n * interpolating between six surface maps, twelve bounding curves, and\n * eight corners. The surface map for the upper +z axis is obtained by\n * interpolating between a cubical surface and a spherical surface. The\n * two surfaces are chosen such that the latter circumscribes the former.\n *\n * We make a choice here as to whether we wish to use the logical coordinates\n * parameterizing these surface as they are, in which case we have the\n * equidistant choice of coordinates, or whether to apply a tangent map to them\n * which leads us to the equiangular choice of coordinates. In terms of the\n * logical coordinates, the equiangular coordinates are:\n *\n * \\f[\\textrm{equiangular xi} : \\Xi(\\xi) = \\textrm{tan}(\\xi\\pi/4)\\f]\n *\n * \\f[\\textrm{equiangular eta} : \\mathrm{H}(\\eta) = \\textrm{tan}(\\eta\\pi/4)\\f]\n *\n * With derivatives:\n *\n * \\f[\\Xi'(\\xi) = \\frac{\\pi}{4}(1+\\Xi^2)\\f]\n *\n * \\f[\\mathrm{H}'(\\eta) = \\frac{\\pi}{4}(1+\\mathrm{H}^2)\\f]\n *\n * The equidistant coordinates are:\n *\n * \\f[ \\textrm{equidistant xi} : \\Xi = \\xi\\f]\n *\n * \\f[ \\textrm{equidistant eta} : \\mathrm{H} = \\eta\\f]\n *\n * with derivatives:\n *\n *
\\f$\\Xi'(\\xi) = 1\\f$, and \\f$\\mathrm{H}'(\\eta) = 1\\f$
\n *\n * We also define the variable \\f$\\rho\\f$, given by:\n *\n * \\f[\\rho = \\sqrt{1+\\Xi^2+\\mathrm{H}^2}\\f]\n *\n * ### The Spherical Face Map\n * The surface map for the spherical face of radius \\f$R\\f$ lying in the\n * \\f$+z\\f$\n * direction in either choice of coordinates is then given by:\n *\n * \\f[\n * \\vec{\\sigma}_{spherical}(\\xi,\\eta) =\n * \\begin{bmatrix}\n * x(\\xi,\\eta)\\\\\n * y(\\xi,\\eta)\\\\\n * z(\\xi,\\eta)\\\\\n * \\end{bmatrix} = \\frac{R}{\\rho}\n * \\begin{bmatrix}\n * \\Xi\\\\\n * \\mathrm{H}\\\\\n * 1\\\\\n * \\end{bmatrix}\n * \\f]\n *\n * ### The Cubical Face Map\n * The surface map for the cubical face of side length \\f$2L\\f$ lying in the\n * \\f$+z\\f$ direction is given by:\n *\n * \\f[\n * \\vec{\\sigma}_{cubical}(\\xi,\\eta) =\n * \\begin{bmatrix}\n * x(\\xi,\\eta)\\\\\n * y(\\xi,\\eta)\\\\\n * L\\\\\n * \\end{bmatrix} = L\n * \\begin{bmatrix}\n * \\Xi\\\\\n * \\mathrm{H}\\\\\n * 1\\\\\n * \\end{bmatrix}\n * \\f]\n *\n * ### The Bulged Face Map\n * To construct the bulged map we interpolate between a cubical face map of\n * side length \\f$2L\\f$ and a spherical face map of radius \\f$R\\f$, with the\n * interpolation parameter being \\f$s\\f$, the `sphericity`.\n * The surface map for the bulged face lying in the \\f$+z\\f$ direction is then\n * given by:\n *\n * \\f[\n * \\vec{\\sigma}_{+\\zeta}(\\xi,\\eta) = \\left\\{(1-s)L + \\frac{sR}{\\rho}\\right\\}\n * \\begin{bmatrix}\n * \\Xi\\\\\n * \\mathrm{H}\\\\\n * 1\\\\\n * \\end{bmatrix}\n * \\f]\n *\n * This equation defines the upper-z map \\f$\\vec{\\sigma}_{+\\zeta}\\f$, and we\n * similarly define the other five surface maps \\f$\\vec{\\sigma}_{+\\eta}\\f$,\n * \\f$\\vec{\\sigma}_{+\\xi}\\f$, and so on by appropriate rotations.\n * We constrain L by demanding that the spherical face circumscribe the cube.\n * With this condition, we have \\f$L = R/\\sqrt3\\f$.\n *\n * ### The General Formula for 3D Isoparametric Maps\n * The general formula is given by Eq. 1 in section 2.1 of Hesthaven's paper\n * \"A Stable Penalty Method For The Compressible Navier-Stokes Equations III.\n * Multidimensional Domain Decomposition Schemes\" available\n * here .\n *\n * Hesthaven's formula is general in the degree of the shape functions used,\n * so for our purposes we take the special case where the shape functions are\n * linear in the interpolation variable, and define new variables accordingly.\n * However, our interpolation variables do not necessarily have to be the\n * logical coordinates themselves, though they often are. To make this\n * distinction clear, we will define the new interpolation variables\n * \\f$\\{\\tilde{\\xi},\\tilde{\\eta},\\tilde{\\zeta}\\}\\f$, which may either be the\n * logical coordinates themselves or a invertible transformation of them. For\n * the purposes of the bulged cube map, this transformation will be the same\n * transformation that takes the logical coordinates into the equiangular\n * coordinates. We will later see how this choice can lead to simplifications\n * in the final map.\n *\n * We define the following variables for\n * \\f$\\alpha, \\beta, \\gamma \\in\\{\\tilde{\\xi},\\tilde{\\eta},\\tilde{\\zeta}\\}\\f$:\n *\n * \\f[\n * f^{\\pm}_{\\alpha} = \\frac{1}{2}(1\\pm\\alpha)\\\\\n * f^{\\pm\\pm}_{\\alpha \\ \\beta} = \\frac{1}{4}(1\\pm\\alpha)(1\\pm\\beta)\\\\\n * f^{\\pm\\pm\\pm}_{\\alpha \\ \\beta \\ \\gamma} =\n * \\frac{1}{8}(1\\pm\\alpha)(1\\pm\\beta)(1\\pm\\gamma)\n * \\f]\n *\n * The formula involves six surfaces, which we will denote by\n * \\f$\\vec{\\sigma}\\f$, twelve curves, denoted by \\f$\\vec{\\Gamma}\\f$, and eight\n * vertices, denoted by \\f$\\vec{\\pi}\\f$, with the subscripts denoting which\n * face(s) these objects belong to. The full volume map is given by:\n *\n * \\f{align*}\n * \\vec{x}(\\xi,\\eta,\\zeta) = &\n * f^{+}_{\\tilde{\\zeta}}\\vec{\\sigma}_{+\\zeta}(\\xi, \\eta)+\n * f^{-}_{\\tilde{\\zeta}}\\vec{\\sigma}_{-\\zeta}(\\xi, \\eta)\\\\\n * &+ f^{+}_{\\tilde{\\eta}}\\vec{\\sigma}_{+\\eta}(\\xi, \\zeta)+\n * f^{-}_{\\tilde{\\eta}}\\vec{\\sigma}_{-\\eta}(\\xi, \\zeta)+\n * f^{+}_{\\tilde{\\xi}}\\vec{\\sigma}_{+\\xi}(\\eta, \\zeta)+\n * f^{-}_{\\tilde{\\xi}}\\vec{\\sigma}_{-\\xi}(\\eta, \\zeta)\\\\\n * &- f^{++}_{\\tilde{\\xi} \\ \\tilde{\\eta}}\\vec{\\Gamma}_{+\\xi +\\eta}(\\zeta)-\n * f^{-+}_{\\tilde{\\xi} \\ \\tilde{\\eta}}\\vec{\\Gamma}_{-\\xi +\\eta}(\\zeta)-\n * f^{+-}_{\\tilde{\\xi} \\ \\tilde{\\eta}}\\vec{\\Gamma}_{+\\xi -\\eta}(\\zeta)-\n * f^{--}_{\\tilde{\\xi} \\ \\tilde{\\eta}}\\vec{\\Gamma}_{-\\xi -\\eta}(\\zeta)\\\\\n * &- f^{++}_{\\tilde{\\xi} \\ \\tilde{\\zeta}}\\vec{\\Gamma}_{+\\xi +\\zeta}(\\eta)-\n * f^{-+}_{\\tilde{\\xi} \\ \\tilde{\\zeta}}\\vec{\\Gamma}_{-\\xi +\\zeta}(\\eta)-\n * f^{+-}_{\\tilde{\\xi} \\ \\tilde{\\zeta}}\\vec{\\Gamma}_{+\\xi -\\zeta}(\\eta)-\n * f^{--}_{\\tilde{\\xi} \\ \\tilde{\\zeta}}\\vec{\\Gamma}_{-\\xi -\\zeta}(\\eta)\\\\\n * &- f^{++}_{\\tilde{\\eta} \\ \\tilde{\\zeta}}\\vec{\\Gamma}_{+\\eta +\\zeta}(\\xi)-\n * f^{-+}_{\\tilde{\\eta} \\ \\tilde{\\zeta}}\\vec{\\Gamma}_{-\\eta +\\zeta}(\\xi)-\n * f^{+-}_{\\tilde{\\eta} \\ \\tilde{\\zeta}}\\vec{\\Gamma}_{+\\eta -\\zeta}(\\xi)-\n * f^{--}_{\\tilde{\\eta} \\tilde{\\zeta}}\\vec{\\Gamma}_{-\\eta -\\zeta}(\\xi)\\\\\n * &+ f^{+++}_{\\tilde{\\xi} \\ \\tilde{\\eta} \\ \\tilde{\\zeta}}\\vec{\\pi}_{+\\xi +\\eta\n * +\\zeta}+ f^{-++}_{\\tilde{\\xi} \\ \\tilde{\\eta} \\ \\tilde{\\zeta}}\\vec{\\pi}_{-\\xi\n * +\\eta +\\zeta}+ f^{+-+}_{\\tilde{\\xi} \\ \\tilde{\\eta} \\\n * \\tilde{\\zeta}}\\vec{\\pi}_{+\\xi -\\eta +\\zeta}+\n * f^{--+}_{\\tilde{\\xi} \\ \\tilde{\\eta} \\ \\tilde{\\zeta}}\\vec{\\pi}_{-\\xi -\\eta\n * +\\zeta}\\\\\n * &+ f^{++-}_{\\tilde{\\xi} \\ \\tilde{\\eta} \\ \\tilde{\\zeta}}\\vec{\\pi}_{+\\xi +\\eta\n * -\\zeta}+ f^{-+-}_{\\tilde{\\xi} \\ \\tilde{\\eta} \\ \\tilde{\\zeta}}\\vec{\\pi}_{-\\xi\n * +\\eta -\\zeta}+ f^{+--}_{\\tilde{\\xi} \\ \\tilde{\\eta} \\\n * \\tilde{\\zeta}}\\vec{\\pi}_{+\\xi -\\eta -\\zeta}+ f^{---}_{\\tilde{\\xi} \\\n * \\tilde{\\eta} \\ \\tilde{\\zeta}}\\vec{\\pi}_{-\\xi -\\eta -\\zeta} \\f}\n *\n *\n * ### The Special Case for Octahedral Symmetry\n * The general formula is for the case in which there are six independently\n * specified bounding surfaces. In our case, the surfaces are obtained by\n * rotations and reflections of the upper-\\f$\\zeta\\f$ face.\n *\n * We define the matrices corresponding to these transformations to be:\n *\n * \\f[\n * S_{xy} =\n * \\begin{bmatrix}\n * 0 & 1 & 0\\\\\n * 1 & 0 & 0\\\\\n * 0 & 0 & 1\\\\\n * \\end{bmatrix},\\\n *\n * S_{xz} =\n * \\begin{bmatrix}\n * 0 & 0 & 1\\\\\n * 0 & 1 & 0\\\\\n * 1 & 0 & 0\\\\\n * \\end{bmatrix},\\\n *\n * S_{yz} =\n * \\begin{bmatrix}\n * 1 & 0 & 0\\\\\n * 0 & 0 & 1\\\\\n * 0 & 1 & 0\\\\\n * \\end{bmatrix}\\f]\n *\n * \\f[C_{zxy} =\n * \\begin{bmatrix}\n * 0 & 0 & 1\\\\\n * 1 & 0 & 0\\\\\n * 0 & 1 & 0\\\\\n * \\end{bmatrix},\\\n *\n * C_{yzx} =\n * \\begin{bmatrix}\n * 0 & 1 & 0\\\\\n * 0 & 0 & 1\\\\\n * 1 & 0 & 0\\\\\n * \\end{bmatrix}\\f]\n *\n * \\f[N_{x} =\n * \\begin{bmatrix}\n * -1 & 0 & 0\\\\\n * 0 & 1 & 0\\\\\n * 0 & 0 & 1\\\\\n * \\end{bmatrix},\\\n *\n * N_{y} =\n * \\begin{bmatrix}\n * 1 & 0 & 0\\\\\n * 0 & -1 & 0\\\\\n * 0 & 0 & 1\\\\\n * \\end{bmatrix},\\\n *\n * N_{z} =\n * \\begin{bmatrix}\n * 1 & 0 & 0\\\\\n * 0 & 1 & 0\\\\\n * 0 & 0 & -1\\\\\n * \\end{bmatrix}\n * \\f]\n *\n * The surface maps can now all be written in terms of\n * \\f$\\vec{\\sigma}_{+\\zeta}\\f$ and these matrices:\n *
\n * \\f$\\vec{\\sigma}_{-\\zeta}(\\xi, \\eta) = N_z\\vec{\\sigma}_{+\\zeta}(\\xi, \\eta)\\\\\n * \\vec{\\sigma}_{+\\eta}(\\xi, \\zeta) = S_{yz}\\vec{\\sigma}_{+\\zeta}(\\xi, \\zeta)\\\\\n * \\vec{\\sigma}_{-\\eta}(\\xi, \\zeta) = N_yS_{yz}\\vec{\\sigma}_{+\\zeta}(\\xi,\n * \\zeta)\\\\\n * \\vec{\\sigma}_{+\\xi}(\\eta, \\zeta) = C_{zxy}\\vec{\\sigma}_{+\\zeta}(\\eta,\n * \\zeta)\\\\\n * \\vec{\\sigma}_{-\\xi}(\\eta, \\zeta) = N_xC_{zyx}\\vec{\\sigma}_{+\\zeta}(\\eta,\n * \\zeta)\\f$\n *
\n *\n * The four bounding curves \\f$\\vec{\\Gamma}\\f$ on the \\f$+\\zeta\\f$ face are\n * given by:\n *\n *
\n * \\f$\\vec{\\Gamma}_{+\\xi,+\\zeta}(\\eta) = \\vec{\\sigma}_{+\\zeta}(+1,\\eta)\\\\\n * \\vec{\\Gamma}_{-\\xi,+\\zeta}(\\eta) = \\vec{\\sigma}_{+\\zeta}(-1,\\eta)\n * = N_x\\vec{\\sigma}_{+\\zeta}(+1, \\eta)\\\\\n * \\vec{\\Gamma}_{+\\eta,+\\zeta}(\\xi) = \\vec{\\sigma}_{+\\zeta}(\\xi,+1)\n * = S_{xy}\\vec{\\sigma}_{+\\zeta}(+1, \\xi)\\\\\n * \\vec{\\Gamma}_{-\\eta,+\\zeta}(\\xi) = \\vec{\\sigma}_{+\\zeta}(\\xi,-1)\n * = N_yS_{xy}\\vec{\\sigma}_{+\\zeta}(+1,\\xi)\\f$\n *
\n *\n * The bounding curves on the other surfaces can be obtained by transformations\n * on the \\f$+\\zeta\\f$ face:\n *\n *
\n * \\f$\\vec{\\Gamma}_{+\\xi,-\\zeta}(\\eta) = N_z\\vec{\\sigma}_{+\\zeta}(+1,\\eta)\\\\\n * \\vec{\\Gamma}_{-\\xi,-\\zeta}(\\eta) = N_z\\vec{\\sigma}_{+\\zeta}(-1,\\eta)\n * = N_zN_x\\vec{\\sigma}_{+\\zeta}(+1,\\eta)\\\\\n * \\vec{\\Gamma}_{+\\eta,-\\zeta}(\\xi) = N_z\\vec{\\sigma}_{+\\zeta}(\\xi,+1)\n * = N_zS_{xy}\\vec{\\sigma}_{+\\zeta}(+1, \\xi)\\\\\n * \\vec{\\Gamma}_{-\\eta,-\\zeta}(\\xi) = N_z\\vec{\\sigma}_{+\\zeta}(\\xi,-1)\n * = N_zN_yS_{xy}\\vec{\\sigma}_{+\\zeta}(+1, \\xi)\\\\\n * \\vec{\\Gamma}_{+\\xi,+\\eta}(\\zeta) =\n * C_{zxy}\\vec{\\sigma}_{+\\zeta}(+1,\\zeta)\\\\\n * \\vec{\\Gamma}_{-\\xi,+\\eta}(\\zeta) =\n * N_xC_{zxy}\\vec{\\sigma}_{+\\zeta}(+1,\\zeta)\\\\\n * \\vec{\\Gamma}_{+\\xi,-\\eta}(\\zeta) = C_{zxy}\\vec{\\sigma}_{+\\zeta}(-1,\\zeta)\n * = C_{zxy}N_x\\vec{\\sigma}_{+\\zeta}(+1,\\zeta)\\\\\n * \\vec{\\Gamma}_{-\\xi,-\\eta}(\\zeta) = N_xC_{zxy}\\vec{\\sigma}_{+\\zeta}(-1,\\zeta)\n * = N_xC_{zxy}N_x\\vec{\\sigma}_{+\\zeta}(+1,\\zeta)\\f$\n *
\n *\n * Now we can write the volume map in terms of\n * \\f$\\vec{\\sigma}_{+\\zeta}\\f$ only:\n * \\f{align*}\\vec{x}(\\xi,\\eta,\\zeta) = &\n * (f^{+}_{\\tilde{\\zeta}} + f^{-}_{\\tilde{\\zeta}}N_z)\n * \\vec{\\sigma}_{+\\zeta}(\\xi, \\eta)\\\\\n * &+ (f^{+}_{\\tilde{\\eta}} + f^{-}_{\\tilde{\\eta}}N_y)\n * S_{yz}\\vec{\\sigma}_{+\\zeta}(\\xi, \\zeta)\\\\\n * &+ (f^{+}_{\\tilde{\\xi}} + f^{-}_{\\tilde{\\xi}}N_x)\n * C_{zxy}\\vec{\\sigma}_{+\\zeta}(\\eta, \\zeta)\\\\\n * &- (f^{+}_{\\tilde{\\xi}}+f^{-}_{\\tilde{\\xi}}N_x)\n * (f^{+}_{\\tilde{\\eta}}+f^{-}_{\\tilde{\\eta}}N_y)\n * C_{zxy}\\vec{\\sigma}_{+\\zeta}(+1, \\zeta)\\\\\n * &- (f^{+}_{\\tilde{\\zeta}}+f^{-}_{\\tilde{\\zeta}}N_z)\\left\\{\n * (f^{+}_{\\tilde{\\xi}}+f^{-}_{\\tilde{\\xi}}N_x)\\vec{\\sigma}_{+\\zeta}(+1, \\eta)+\n * (f^{+}_{\\tilde{\\eta}}+f^{-}_{\\tilde{\\eta}}N_y)S_{xy}\\vec{\\sigma}_{+\\zeta}(+1,\n * \\xi)\\right\\}\\\\\n * &+ \\frac{r}{\\sqrt{3}}\\vec{\\tilde{\\xi}}\n * \\f}\n *\n * Note that we can now absorb all of the \\f$f\\f$s into the matrix prefactors\n * in the above equation and obtain a final set of matrices. We define the\n * following *blending matrices*:\n *\n * \\f[\n * B_{\\tilde{\\xi}} =\n * \\begin{bmatrix}\n * 0 & 0 & \\tilde{\\xi}\\\\\n * 1 & 0 & 0\\\\\n * 0 & 1 & 0\\\\\n * \\end{bmatrix},\\\n *\n * B_{\\tilde{\\eta}} =\n * \\begin{bmatrix}\n * 1 & 0 & 0\\\\\n * 0 & 0 & \\tilde{\\eta}\\\\\n * 0 & 1 & 0\\\\\n * \\end{bmatrix},\\\n *\n * B_{\\tilde{\\zeta}} =\n * \\begin{bmatrix}\n * 1 & 0 & 0\\\\\n * 0 & 1 & 0\\\\\n * 0 & 0 & \\tilde{\\zeta}\\\\\n * \\end{bmatrix}\\\\\n *\n * B_{\\tilde{\\xi}\\tilde{\\eta}} =\n * \\begin{bmatrix}\n * 0 & 0 & \\tilde{\\xi}\\\\\n * \\tilde{\\eta} & 0 & 0\\\\\n * 0 & 1 & 0\\\\\n * \\end{bmatrix},\\\n *\n * B_{\\tilde{\\xi}\\tilde{\\zeta}} =\n * \\begin{bmatrix}\n * \\tilde{\\xi} & 0 & 0\\\\\n * 0 & 1 & 0\\\\\n * 0 & 0 & \\tilde{\\zeta}\\\\\n * \\end{bmatrix},\\\n *\n * B_{\\tilde{\\eta}\\tilde{\\zeta}} =\n * \\begin{bmatrix}\n * 0 & 1 & 0\\\\\n * \\tilde{\\eta} & 0 & 0\\\\\n * 0 & 0 & \\tilde{\\zeta}\\\\\n * \\end{bmatrix}\\\\\n *\n * B_{\\tilde{\\xi}\\tilde{\\eta}\\tilde{\\zeta}} =\n * \\begin{bmatrix}\n * \\tilde{\\xi} & 0 & 0\\\\\n * 0 & \\tilde{\\eta} & 0\\\\\n * 0 & 0 & \\tilde{\\zeta}\\\\\n * \\end{bmatrix}\n * \\f]\n *\n * Now we can write the volume map in these terms:\n *\n * \\f{align*}\n * \\vec{x}(\\xi,\\eta,\\zeta) = &\n * B_{\\tilde{\\zeta}}\n * \\vec{\\sigma}_{+\\zeta}(\\xi, \\eta)\\\\& +\n * B_{\\tilde{\\eta}}\n * \\vec{\\sigma}_{+\\zeta}(\\xi, \\zeta)+\n * B_{\\tilde{\\xi}}\n * \\vec{\\sigma}_{+\\zeta}(\\eta, \\zeta)\\\\& -\n * B_{\\tilde{\\xi} \\tilde{\\eta}}\n * \\vec{\\sigma}_{+\\zeta}(+1, \\zeta)-\n * B_{\\tilde{\\xi} \\tilde{\\zeta}}\n * \\vec{\\sigma}_{+\\zeta}(+1, \\eta)+\n * B_{\\tilde{\\eta} \\tilde{\\zeta}}\n * \\vec{\\sigma}_{+\\zeta}(+1, \\xi)\\\\& +\n * B_{\\tilde{\\xi} \\tilde{\\eta} \\tilde{\\zeta}}\n * \\vec{\\sigma}_{+\\zeta}(+1, +1)\n * \\f}\n *\n * ### The Bulged Cube Map\n * We now use the result above to provide the mapping for the bulged cube.\n * First we will define the variables \\f$\\rho_A\\f$ and \\f$\\rho_{AB}\\f$, for\n * \\f$A, B \\in \\{\\Xi,\\mathrm{H}, \\mathrm{Z}\\} \\f$, where \\f$\\mathrm{Z}\\f$\n * is \\f$\\tan(\\zeta\\pi/4)\\f$ in the equiangular case and \\f$\\zeta\\f$ in the\n * equidistant case:\n *\n * \\f[\n * \\rho_A = \\sqrt{2 + A^2}\\\\\n * \\rho_{AB} = \\sqrt{1 + A^2 + B^2}\n * \\f]\n * The final mapping is then:\n * \\f[\n * \\vec{x}(\\xi,\\eta,\\zeta) = \\frac{(1-s)R}{\\sqrt{3}}\n * \\begin{bmatrix}\n * \\Xi\\\\\n * \\mathrm{H}\\\\\n * \\mathrm{Z}\\\\\n * \\end{bmatrix} +\n * \\frac{sR}{\\sqrt{3}}\n * \\begin{bmatrix}\n * \\tilde{\\xi}\\\\\n * \\tilde{\\eta}\\\\\n * \\tilde{\\zeta}\\\\\n * \\end{bmatrix} + sR\n * \\begin{bmatrix}\n * \\tilde{\\xi} & \\Xi & \\Xi\\\\\n * \\mathrm{H} & \\tilde{\\eta} &\\mathrm{H}\\\\\n * \\mathrm{Z} & \\mathrm{Z} & \\tilde{\\zeta}\\\\\n * \\end{bmatrix}\n * \\begin{bmatrix}\n * 1/\\rho_{\\mathrm{H}\\mathrm{Z}}\\\\\n * 1/\\rho_{\\Xi\\mathrm{Z}}\\\\\n * 1/\\rho_{\\Xi\\mathrm{H}}\\\\\n * \\end{bmatrix} - sR\n * \\begin{bmatrix}\n * \\Xi & \\tilde{\\xi} & \\tilde{\\xi}\\\\\n * \\tilde{\\eta} & \\mathrm{H} &\\tilde{\\eta}\\\\\n * \\tilde{\\zeta} & \\tilde{\\zeta} & \\mathrm{Z}\\\\\n * \\end{bmatrix}\n * \\begin{bmatrix}\n * 1/\\rho_{\\Xi}\\\\\n * 1/\\rho_{\\mathrm{H}}\\\\\n * 1/\\rho_{\\mathrm{Z}}\\\\\n * \\end{bmatrix}\n * \\f]\n *\n * Recall that the lower case Greek letters with tildes are the variables\n * used for the linear interpolation between the six bounding surfaces, and\n * that the upper case Greek letters are the coordinates along these surfaces -\n * both of which can be specified to be either\n * equidistant or equiangular. In the case where the\n * interpolation variable is chosen to match that of the\n * coordinates along the surface, we have \\f$\\tilde{\\xi} = \\Xi\\f$, etc. In this\n * case, the formula reduces further. The reduced formula below is the one used\n * for this CoordinateMap. It is given by:\n *\n * \\f[\n * \\vec{x}(\\xi,\\eta,\\zeta) =\n * \\left\\{\n * \\frac{R}{\\sqrt{3}}\n * + sR\n * \\left(\n * 1/\\rho_{\\mathrm{H}\\mathrm{Z}}+\n * 1/\\rho_{\\Xi\\mathrm{Z}}+\n * 1/\\rho_{\\Xi\\mathrm{H}}-\n * 1/\\rho_{\\Xi}-\n * 1/\\rho_{\\mathrm{H}}-\n * 1/\\rho_{\\mathrm{Z}}\n * \\right)\n * \\right\\}\n * \\begin{bmatrix}\n * \\Xi\\\\\n * \\mathrm{H}\\\\\n * \\mathrm{Z}\\\\\n * \\end{bmatrix}\n * \\f]\n *\n * The inverse mapping is analytic in the angular directions. A root find\n * must be performed for the inverse mapping in the radial direction. This\n * one-dimensional formula is obtained by taking the magnitude of both sides\n * of the mapping, and changing variables from \\f$\\xi, \\eta, \\zeta\\f$ to\n * \\f$x, y, z\\f$ and introducing \\f$\\rho^2 := \\sqrt{\\xi^2+\\eta^2+\\zeta^2}\\f$.\n */\nclass BulgedCube {\n public:\n static constexpr size_t dim = 3;\n BulgedCube(double radius, double sphericity,\n bool use_equiangular_map) noexcept;\n BulgedCube() noexcept = default;\n ~BulgedCube() noexcept = default;\n BulgedCube(BulgedCube&&) noexcept = default;\n BulgedCube(const BulgedCube&) noexcept = default;\n BulgedCube& operator=(const BulgedCube&) noexcept = default;\n BulgedCube& operator=(BulgedCube&&) noexcept = default;\n\n template \n std::array, 3> operator()(\n const std::array& source_coords) const noexcept;\n\n boost::optional> inverse(\n const std::array& target_coords) const noexcept;\n\n template \n tnsr::Ij, 3, Frame::NoFrame> jacobian(\n const std::array& source_coords) const noexcept;\n\n template \n tnsr::Ij, 3, Frame::NoFrame> inv_jacobian(\n const std::array& source_coords) const noexcept;\n\n // clang-tidy: google runtime references\n void pup(PUP::er& p) noexcept; // NOLINT\n\n bool is_identity() const noexcept { return is_identity_; }\n\n private:\n template \n std::array, 3> xi_derivative(\n const std::array& source_coords) const noexcept;\n friend bool operator==(const BulgedCube& lhs, const BulgedCube& rhs) noexcept;\n\n double radius_{std::numeric_limits::signaling_NaN()};\n double sphericity_{std::numeric_limits::signaling_NaN()};\n bool use_equiangular_map_ = false;\n bool is_identity_ = false;\n};\n\nbool operator!=(const BulgedCube& lhs, const BulgedCube& rhs) noexcept;\n} // namespace CoordinateMaps\n} // namespace domain\n", "meta": {"hexsha": "f3a6a3ad4522d452a13f4d278e4f8796e217af08", "size": 18083, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/Domain/CoordinateMaps/BulgedCube.hpp", "max_stars_repo_name": "keefemitman/spectre", "max_stars_repo_head_hexsha": "a8c3e387addc34d8a4544728f405991e6c9e5e38", "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/Domain/CoordinateMaps/BulgedCube.hpp", "max_issues_repo_name": "keefemitman/spectre", "max_issues_repo_head_hexsha": "a8c3e387addc34d8a4544728f405991e6c9e5e38", "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/Domain/CoordinateMaps/BulgedCube.hpp", "max_forks_repo_name": "keefemitman/spectre", "max_forks_repo_head_hexsha": "a8c3e387addc34d8a4544728f405991e6c9e5e38", "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": 33.6741154562, "max_line_length": 87, "alphanum_fraction": 0.5796604546, "num_tokens": 7083, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933271118221, "lm_q2_score": 0.6619228691808012, "lm_q1q2_score": 0.5427061435040504}} {"text": "#include \n#include \n\n#include \n#include \n#include \n\n#include \n#include \n\n#include \"examples.h\"\n\ntypedef boost::multiprecision::number\ne_float_type;\n\nvoid examples::nr_021::boost_bindings()\n{\n const e_float_type y(char(1));\n const e_float_type x(3.0L);\n const e_float_type z(y / x);\n\n const e_float_type a(z);\n\n const e_float_type lg_max = log((std::numeric_limits::max)());\n const e_float_type eps = std::numeric_limits::epsilon();\n\n std::cout << std::setprecision(std::numeric_limits::digits10) << e_float_type(0.5F) << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << z << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << sin (z) << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << floor(e_float_type(1.5F)) << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << ceil (e_float_type(1.5F)) << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << sqrt (e_float_type(2)) << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << boost::math::cbrt(e_float_type(2)) << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << exp (z) << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << atan2(y, x) << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << atan (z) << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << log (e_float_type(2)) << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << lg_max << std::endl;\n\n std::cout << std::setprecision(std::numeric_limits::digits10) << eps << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << sqrt(eps) << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << boost::math::cbrt(eps) << std::endl;\n\n std::cout << std::setprecision(std::numeric_limits::digits10) << boost::math::tgamma(e_float_type(0.5F)) << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << sqrt(boost::math::constants::pi()) << std::endl;\n\n std::cout << std::setprecision(std::numeric_limits::digits10) << boost::math::cyl_bessel_j(e_float_type(1) / 7, e_float_type(2.5F)) << std::endl;\n\n int nexp;\n std::cout << std::setprecision(std::numeric_limits::digits10) << frexp(e_float_type(2), &nexp) << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10) << ldexp(e_float_type(1), 2) << std::endl;\n\n std::cout << std::boolalpha << (x < y) << std::endl;\n std::cout << std::boolalpha << (y > x) << std::endl;\n\n std::cout << std::boolalpha << (lg_max > (std::numeric_limits::max)()) << std::endl;\n std::cout << std::boolalpha << (lg_max > (std::numeric_limits::min)()) << std::endl;\n\n const e_float_type a3((\"33.\" + std::string(std::size_t(std::numeric_limits::digits10 - 2), char('3')) + std::string(16U, char('4'))).c_str());\n const e_float_type b3(e_float_type(100U) / 3);\n\n std::cout << std::setprecision(std::numeric_limits::digits10 + 4) << a3 << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10 + 4) << b3 << std::endl;\n\n std::cout << std::boolalpha << (a3 == b3) << std::endl;\n std::cout << std::boolalpha << (a3 > b3) << std::endl;\n std::cout << std::boolalpha << (a3 < b3) << std::endl;\n\n const e_float_type c3((\"33.\" + std::string(120U, char('3'))).c_str());\n const e_float_type d3(e_float_type(100U) / 3);\n\n std::cout << std::setprecision(std::numeric_limits::digits10 + 4) << c3 << std::endl;\n std::cout << std::setprecision(std::numeric_limits::digits10 + 4) << d3 << std::endl;\n\n std::cout << std::boolalpha << (c3 == d3) << std::endl;\n std::cout << std::boolalpha << (c3 > d3) << std::endl;\n std::cout << std::boolalpha << (c3 < d3) << std::endl;\n}\n", "meta": {"hexsha": "119e324f1fc1d7516a71f584368de2a6281055fd", "size": 4809, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libs/e_float/example/example_021_boost_bindings.cpp", "max_stars_repo_name": "ckormanyos/e_float-2021", "max_stars_repo_head_hexsha": "fac3eef3aa15cc5b74fb19135d6474396cbc6fa8", "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": "libs/e_float/example/example_021_boost_bindings.cpp", "max_issues_repo_name": "ckormanyos/e_float-2021", "max_issues_repo_head_hexsha": "fac3eef3aa15cc5b74fb19135d6474396cbc6fa8", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 10.0, "max_issues_repo_issues_event_min_datetime": "2021-02-08T14:43:47.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-17T15:12:27.000Z", "max_forks_repo_path": "libs/e_float/example/example_021_boost_bindings.cpp", "max_forks_repo_name": "ckormanyos/e_float-2021", "max_forks_repo_head_hexsha": "fac3eef3aa15cc5b74fb19135d6474396cbc6fa8", "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": 60.1125, "max_line_length": 162, "alphanum_fraction": 0.6360989811, "num_tokens": 1412, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.837619979547273, "lm_q2_score": 0.647798211152541, "lm_q1q2_score": 0.5426087243763514}} {"text": "//------------------------------------------------------------------------------\n// Copyright 2007-2011 by Jyh-Ming Lien and George Mason University\n// See the file \"LICENSE\" for more information\n//------------------------------------------------------------------------------\n\n#include \"polygon.h\"\n#include \"intersection.h\"\n#include \n#include \n\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \"adapt_boost_poly.h\"\n\nusing namespace std;\nnamespace bp = boost::polygon;\nnamespace bg = boost::geometry;\n\n#ifdef WIN32\nextern \"C\"{\n#include \"triangulate.h\"\n}\n#else\n#include \"triangulate.h\"\n#endif\n\ntemplate\nply_vertex::~ply_vertex()\n{\n //doing nothing for now\n}\n\n// - compute normal\n// - check if the vertex is reflex or not\ntemplate\nvoid\nply_vertex::computeExtraInfo()\n{\n //compute normal direction\n point_type v= next->pos;\n bg::subtract_point(v, pos);\n if( bg::get<0>(v) == 0 ){\n if (bg::get<1>(v)>0) { bg::set<0>(normal,1); bg::set<1>(normal,0); }\n else { bg::set<0>(normal,-1); bg::set<1>(normal,0); }\n }\n else if( bg::get<0>(v)>0 ){\n bg::set<1>(normal, -1);\n bg::set<0>(normal, bg::get<1>(v) / bg::get<0>(v));\n }\n else{//get<0>(v)<0\n bg::set<1>(normal, 1);\n bg::set<0>(normal, -(bg::get<1>(v) / bg::get<0>(v)));\n }\n\n // normalize\n normalize(normal);\n\n // compute left or right turn\n reflex = !leftTurn(pre->pos, pos, next->pos);\n}\n\ntemplate\nvoid\nply_vertex::negate()\n{\n bg::multiply_value(normal, -1);\n bg::multiply_value(pos, -1);\n}\n\ntemplate\nvoid\nply_vertex::reverse()\n{\n swap(next,pre);\n //normal=-normal;\n computeExtraInfo();\n}\n\ntemplate\nvoid\nply_vertex::copy(ply_vertex * other)\n{\n pos=other->pos;\n normal=other->normal;\n reflex=other->reflex;\n vid=other->vid;\n}\n\n///////////////////////////////////////////////////////////////////////////////\n\n//copy from the given ply\ntemplate\nvoid\nc_ply::copy(const c_ply& other)\n{\n destroy();//detroy myself first\n\n vertex_type* ptr=other.head;\n beginPoly();\n do{\n vertex_type * v=new vertex_type();\n assert(v); //check for memory\n v->copy(ptr);\n addVertex(v);\n ptr=ptr->getNext();\n }while( ptr!=other.head );\n\n //endPoly();\n //finish up\n tail->setNext(head);\n\n //copy extra info\n area=other.area;\n bg::assign_point(center, other.center);\n radius=other.radius;\n type=other.type;\n triangulation=other.triangulation;\n extra_info=other.extra_info;\n}\n\n// clean up the space allocated\ntemplate\nvoid\nc_ply::destroy()\n{\n if( head==NULL ) return;\n vertex_type* ptr=head;\n do{\n vertex_type * n=ptr->getNext();\n delete ptr;\n ptr=n;\n }while( ptr!=head );\n head=tail=NULL;\n\n all.clear();\n triangulation.clear();\n}\n\n// Create a empty polygon\ntemplate\nvoid\nc_ply::beginPoly()\n{\n head=tail=NULL;\n all.clear();\n triangulation.clear();\n}\n\n// Add a vertex to the polygonal chian\ntemplate\nvoid\nc_ply::addVertex(\n typename c_ply::coordinate_type x,\n typename c_ply::coordinate_type y,\n bool remove_duplicate )\n{\n point_type pt(x,y);\n\n if(tail!=NULL){\n if(bg::equals(tail->getPos(), pt) && remove_duplicate) return; //don't add\n }\n\n vertex_type * v=new vertex_type(pt);\n if( tail!=NULL ){\n tail->setNext(v);\n }\n tail=v;\n if( head==NULL ) head=tail;\n v->setVID(all.size()); //id of the vertex in this ply\n\tall.push_back(v);\n\n}\n\n// Add a vertex to the polygonal chian\ntemplate\nvoid\nc_ply::addVertex( vertex_type * v )\n{\n if( tail!=NULL ){\n tail->setNext(v);\n }\n tail=v;\n if( head==NULL ) head=tail;\n v->setVID(all.size()); //id of the vertex in this ply\n all.push_back(v);\n}\n\n// finish building the polygon\ntemplate\nvoid\nc_ply::endPoly(bool remove_duplicate)\n{\n if(head!=NULL && tail!=NULL){\n if(remove_duplicate){\n if(bg::equals(head->getPos(), tail->getPos())){ //remove tail..\n delete tail;\n all.pop_back();\n tail=all.back();\n }\n }//\n }\n\n tail->setNext(head);\n doInit();\n}\n\n// initialize property of the this polychain\n// Compute normals and find reflective vertices\ntemplate\nvoid\nc_ply::doInit()\n{\n //compute area\n getArea();\n if(this->area<0 && type==POUT){\n //cerr<<\"! Warning: polygon type is POUT but has negative area. Reverse the vertex ordering.\"<area>0 && type==PIN){\n //cerr<<\"! Warning: polygon type is PIN but has positive area. Reverse the vertex ordering.\"<computeExtraInfo();\n ptr=ptr->getNext();\n }while( ptr!=head );\n}\n\ntemplate\nconst typename c_ply::point_type&\nc_ply::getCenter()\n{\n if(radius<0){\n center = point_type(0,0);\n vertex_type * ptr=head;\n const point_type& first=ptr->getPos();\n uint size=0;\n do{\n size++;\n point_type v = ptr->getPos();\n bg::subtract_point(v, first);\n bg::add_point(center, v);\n ptr=ptr->getNext();\n }while(ptr!=head); //end while\n bg::divide_value(center, size);\n bg::add_point(center, first);\n\n radius=0;\n }\n\n return center;\n}\n\n\n///////////////////////////////////////////////////////////////////////////\ntemplate\nvoid\nc_ply::negate()\n{\n vertex_type * ptr=head;\n do{\n ptr->negate();\n ptr=ptr->getNext();\n }while(ptr!=head); //end while\n}\n\n//reverse the order of the vertices\ntemplate\nvoid\nc_ply::reverse()\n{\n vertex_type * ptr=head;\n do{\n ptr->reverse();\n ptr=ptr->getNext();\n }\n while(ptr!=head); //end while\n\n this->area=-this->area;\n all.clear();\n triangulation.clear();\n}\n\n///////////////////////////////////////////////////////////////////////////\ntemplate\nvoid\nc_ply::translate(const point_type& p)\n{\n vertex_type * ptr=head;\n do{\n ptr->translate(p);\n ptr=ptr->getNext();\n }while(ptr!=head); //end while\n\n //translate box\n extra_info.box[0] += bg::get<0>(p);\n extra_info.box[1] += bg::get<0>(p);\n extra_info.box[2] += bg::get<1>(p);\n extra_info.box[3] += bg::get<1>(p);\n}\n\n///////////////////////////////////////////////////////////////////////////\n//compute the Radius of the poly chain\ntemplate\ntypename c_ply::coordinate_type\nc_ply::getRadius()\n{\n if(radius<0) getCenter();\n\n if(radius==0){\n vertex_type * ptr=head;\n do{\n point_type v = center;\n bg::subtract_point(v, ptr->getPos());\n coordinate_type d;\n normalize(v, d);\n if(d>radius) radius=d;\n ptr=ptr->getNext();\n }while(ptr!=head); //end while\n radius=sqrt(radius);\n }\n\n return radius;\n}\n\n\ntemplate\ntypename c_ply::coordinate_type\nc_ply::getArea()\n{\n if (area == numeric_limits::lowest())\n area = bp::area(*this);\n\n return area;\n}\n\n\ntemplate\nbool\nc_ply::enclosed(const typename c_ply::point_type& p)\n{\n if(triangulation.empty())\n triangulate(triangulation);\n\n //find the largest triangle\n for(uint i=0;igetPos();\n const point_type& p2=all[tri.v[1]]->getPos();\n const point_type& p3=all[tri.v[2]]->getPos();\n coordinate_type area1=Area(p1,p2,p);\n coordinate_type area2=Area(p2,p3,p);\n coordinate_type area3=Area(p3,p1,p);\n if(area1>=0 && area2>=0 && area3>=0) return true; //in\n if(area1<=0 && area2<=0 && area3<=0) return true; //in\n }\n\n return false; //out\n}\n\ntemplate\ntypename c_ply::point_type\nc_ply::findEnclosedPt()\n{\n if(triangulation.empty())\n triangulate(triangulation);\n\n if(triangulation.empty()){ //too few points...\n const point_type& p1=head->getPos();\n const point_type& p2=head->getNext()->getPos();\n point_type pt;\n bg::assign_point(pt, p1);\n bg::add_point(pt, p2);\n bg::divide_value(pt, 2);\n return pt;\n }\n\n //find the largest triangle\n coordinate_type largest_area=-1;\n uint largest_tri=0;\n for(uint i=0;igetPos();\n const point_type& p2=all[tri.v[1]]->getPos();\n const point_type& p3=all[tri.v[2]]->getPos();\n coordinate_type area=fabs(Area(p1,p2,p3));\n if(area>largest_area){\n largest_area=area;\n largest_tri=i;\n }\n }\n\n //find a node near the vertex of the triangle\n triangle & tri=triangulation[largest_tri];\n const point_type& p1=(*this)[tri.v[0]]->getPos();\n const point_type& p2=(*this)[tri.v[1]]->getPos();\n const point_type& p3=(*this)[tri.v[2]]->getPos();\n\n point_type pt;\n bg::assign_point(pt, p1);\n bg::add_point(pt, p2);\n bg::add_point(pt, p3);\n bg::divide_value(pt, 3);\n\n return pt;\n}\n\ntemplate\nvoid\nc_ply::triangulate(vector& tris)\n{\n indexing();\n if(triangulation.empty()){\n\n const point_type& O=getHead()->getPos();\n\n int * ringVN=new int[1]; //number of vertices for each ring\n assert(ringVN);\n ringVN[0]=getSize();\n int vN=ringVN[0]; //total number of vertices\n\n if( vN<3 ){\n triangle tri;\n for(short i=0;i<3;i++) tri.v[i]=i;\n tris.push_back(tri);\n return;\n }\n\n //more than 3 vertices\n int tN=(vN-2); //# of triangles\n double * V = new double[vN*2]; //to hold vertices pos\n int *T=new int[3*tN]; //to hold resulting triangles\n assert(T&&V);\n\n //copy vertices\n {\n int i=0;\n vertex_type * ptr=getHead();\n do{\n point_type pt=ptr->getPos();\n V[i*2]=bg::get<0>(pt)-bg::get<0>(O); // potential implicit conversion\n V[i*2+1]=bg::get<1>(pt)-bg::get<1>(O);\n ptr=ptr->getNext();\n i++;\n }while( ptr!=getHead() );\n }\n\n FIST_PolygonalArray(1, ringVN, (double (*)[2])V, &tN, (int (*)[3])T);\n\n for(int i=0;i\nbool\nc_ply::is_convex() const\n{\n vertex_type * ptr=head;\n do{\n if(ptr->isReflex()) return false;\n ptr=ptr->getNext();\n }while(ptr!=head); //end while\n\n return true;\n}\n\ntemplate\nvoid\nc_ply::delete_vertex(vertex_type * v)\n{\n vertex_type *pre=v->getPre();\n vertex_type *next=v->getNext();\n\n pre->setNext(next);\n next->setPre(pre);\n pre->computeExtraInfo(); //recompute info\n\n if(head==v){\n head=next;\n tail=pre;\n }\n delete v;\n\n triangulation.clear(); //not valid anymore\n all.clear(); //not valid anymore\n}\n\ntemplate\nvoid\nc_ply::indexing()\n{\n uint vid=0;\n all.clear();\n vertex_type * ptr=head;\n do{\n ptr->setVID(vid++);\n all.push_back(ptr);\n ptr=ptr->getNext();\n }while(ptr!=head); //end while\n}\n\ntemplate\nbool\nc_ply::identical(const c_ply& other)\n{\n\n //do some basic checks\n if((*this)==other) return true; //same head ptr\n if(type!=other.type) return false;\n if(getSize()!=other.getSize()) return false;\n if( fabs(getArea()-other.getArea())>SMALLNUMBER ) return false;\n\n //find the first match\n const vertex_type * o_ptr=other.head;\n bool found_first_match=false;\n do{\n const point_type& pos=o_ptr->getPos();\n coordinate_type dx=fabs(bg::get<0>(pos)-bg::get<0>(head->getPos()));\n coordinate_type dy=fabs(bg::get<1>(pos)-bg::get<0>(head->getPos()));\n\n if( dxgetNext();\n }while(o_ptr!=other.head); //end while\n\n if(!found_first_match) return false;\n\n //check the rest of the match\n const vertex_type * ptr=head;\n\n //since we are sure that ptr matches to o_ptr, we first advance\n ptr=ptr->getNext();\n o_ptr=o_ptr->getNext();\n\n do\n {\n const point_type& o_pos=o_ptr->getPos();\n const point_type& pos=ptr->getPos();\n\n coordinate_type dx=fabs(bg::get<0>(pos)-bg::get<0>(o_pos));\n coordinate_type dy=fabs(bg::get<1>(pos)-bg::get<1>(o_pos));\n\n if( dx>SMALLNUMBER || dy>SMALLNUMBER){\n return false; //don't match\n }\n\n //advance\n ptr=ptr->getNext();\n o_ptr=o_ptr->getNext();\n\n }\n while(ptr!=head);\n\n return true;\n}\n\n//\n//\n// Compute the center and the box of a list of plys\n//\n//\ntemplate\nvoid\nc_plylist::buildBoxAndCenter()\n{\n box[0] = box[2] = std::numeric_limits::max();\n box[0] = box[3] = std::numeric_limits::lowest();\n for(auto i=begin();i!=end();i++){\n\n const vertex_type * ptr=i->getHead();\n do{\n const point_type& p=ptr->getPos();\n if(bg::get<0>(p)(p);\n if(bg::get<0>(p)>box[1]) box[1]= bg::get<0>(p);\n if(bg::get<1>(p)(p);\n if(bg::get<1>(p)>box[3]) box[3]= bg::get<1>(p);\n ptr=ptr->getNext();\n }\n while(ptr!=i->getHead()); //end while\n }\n\n bg::set<0>(center, (box[0]+box[1])/2);\n bg::set<1>(center, (box[2]+box[3])/2);\n\n is_buildboxandcenter_called=true;\n}\n\ntemplate\nvoid\nc_plylist::translate(const typename c_plylist::point_type& p)\n{\n for (auto i=begin();i!=end();i++) i->translate(p);\n}\n\ntemplate\nvoid\nc_polygon::reverse()\n{\n for(auto i=begin();i!=end();i++) i->reverse();\n triangulation.clear();\n all.clear();\n}\n\ntemplate\nbool\nc_polygon::valid() const\n{\n if(empty()) return false;\n if(front().getType()!=ring_type::POUT) return false;\n for(auto i=++begin();i!=end();i++)\n if(i->getType()!=ring_type::PIN)\n return false;\n\n return true;\n}\n\n//copy from the given polygon\ntemplate\nvoid\nc_polygon::copy(const c_polygon& other)\n{\n destroy();\n\n for(auto i=other.cbegin();i!=other.cend();i++){\n this->emplace_back(i->getType());\n this->back().copy(*i);\n }\n indexing();\n}\n\n//check if a point is enclosed\n//the behavior is unknown if pt is on the boundary of the polygon\ntemplate\nbool\nc_polygon::enclosed(const typename c_polygon::point_type& p) const\n{\n //find the largest triangle\n for(uint i=0;igetPos();\n const point_type& p2=(*this)[tri.v[1]]->getPos();\n const point_type& p3=(*this)[tri.v[2]]->getPos();\n coordinate_type area1=Area(p1,p2,p);\n coordinate_type area2=Area(p2,p3,p);\n coordinate_type area3=Area(p3,p1,p);\n if(area1>=0 && area2>=0 && area3>=0) return true; //in\n if(area1<=0 && area2<=0 && area3<=0) return true; //in\n }\n\n return false; //out\n}\n\ntemplate\ntypename c_polygon::point_type\nc_polygon::findEnclosedPt()\n{\n if(triangulation.empty())\n triangulate(triangulation);\n\n if(triangulation.empty())\n return front().findEnclosedPt();\n\n //find the largest triangle\n coordinate_type largest_area=-1;\n uint largest_tri=0;\n for(uint i=0;igetPos();\n const point_type& p2=(*this)[tri.v[1]]->getPos();\n const point_type& p3=(*this)[tri.v[2]]->getPos();\n coordinate_type area=fabs(Area(p1,p2,p3));\n if(area>largest_area){\n largest_area=area;\n largest_tri=i;\n }\n }\n\n //find a node near the vertex of the triangle\n triangle & tri=triangulation[largest_tri];\n const point_type& p1=(*this)[tri.v[0]]->getPos();\n const point_type& p2=(*this)[tri.v[1]]->getPos();\n const point_type& p3=(*this)[tri.v[2]]->getPos();\n\n point_type pt;\n bg::assign_point(pt, p1);\n bg::add_point(pt, p2);\n bg::add_point(pt, p3);\n bg::divide_value(pt, 3);\n\n return pt;\n}\n\ntemplate\nvoid\nc_polygon::triangulate(vector& tris)\n{\n if(triangulation.empty())\n {\n const point_type& O=front().getHead()->getPos();\n\n int ringN=size(); //number of rings\n int * ringVN=new int[ringN]; //number of vertices for each ring\n assert(ringVN);\n\n int vN=0; //total number of vertices\n {\n int i=0;\n for(auto ip=begin();ip!=end();ip++,i++){\n vN+=ip->getSize();\n ringVN[i]=ip->getSize();\n }\n }\n\n if( vN<3 ){\n// triangle tri;\n// for(short i=0;i<3;i++) tri.v[i]=i;\n// tris.push_back(tri);\n return;\n }\n\n int tN=(vN-2)+2*(ringN-1); //# of triangles, (n-2)+2*(#holes)\n double * V=new double[vN*2]; //to hold vertices pos\n int *T=new int[3*tN]; //to hold resulting triangles\n assert(T&&V);\n\n //copy vertices\n int i=0;\n for(auto ip=begin();ip!=end();ip++){\n vertex_type * ptr=ip->getHead();\n do{\n point_type pt=ptr->getPos();\n V[i*2]=bg::get<0>(pt)-bg::get<0>(O); // potential implicit conversion to double\n V[i*2+1]=bg::get<1>(pt)-bg::get<1>(O);\n ptr=ptr->getNext();\n i++;\n }while( ptr!=ip->getHead() );\n }\n\n FIST_PolygonalArray(ringN, ringVN,\n (double (*)[2])V, &tN, (int (*)[3])T);\n\n for(int i=0;i\nvoid\nc_polygon::pop_front()\n{\n ring_type &ply = front();\n ply.indexing(); // reset vertex IDs\n c_plylist::pop_front();\n /* These must be recomputed */\n all.clear();\n triangulation.clear();\n indexing();\n}\n\ntemplate\nvoid\nc_polygon::destroy()\n{\n for(auto i=begin();i!=end();i++){\n i->destroy();\n }\n clear(); //remove all ply from this list\n all.clear();\n triangulation.clear();\n}\n\ntemplate\nbool\nc_polygon::is_convex() const\n{\n if(size()>1) return false; //contains hole\n return front().is_convex();\n}\n\ntemplate\nvoid\nc_polygon::indexing()\n{\n uint vid=0;\n for(auto i=begin();i!=end();i++){\n uint vsize=i->getSize();\n for(uint j=0;jsetVID(vid++); //id of vertex in the polygons\n all.push_back((*i)[j]);\n }\n }//end for i\n}\n\ntemplate\ntypename c_polygon::coordinate_type\nc_polygon::getArea()\n{\n if (area == 0) {\n area = bp::area(*this);\n }\n\n return area;\n}\n\n\ntemplate\nbool\nc_polygon::identical(c_polygon& p)\n{\n if(size()!=p.size()) return false;\n\n coordinate_type a1=getArea();\n coordinate_type a2=p.getArea();\n if( fabs(a1-a2)>SMALLNUMBER ) return false;\n\n\n\n for(auto i=begin();i!=end();i++)\n {\n bool match=false;\n for(auto j=p.begin();j!=p.end();j++){\n if( i->identical(*j) ){\n match=true;\n break;\n }\n }\n if(!match) return false;\n }\n\n return true;\n}\n\ntemplate\nistream& operator>>( istream& is, c_ply& poly)\n{\n typedef typename c_ply::coordinate_type coordinate_type;\n typedef typename c_ply::point_type point_type;\n\n int vsize; string str_type;\n is>>vsize>>str_type;\n\n if( str_type.find(\"out\")!=string::npos )\n poly.type=c_ply::POUT;\n else poly.type=c_ply::PIN;\n\n poly.beginPoly();\n //read in all the vertices\n int iv;\n vector pts; pts.reserve(vsize);\n for( iv=0;iv>x>>y;\n pts.emplace_back(x,y);\n //coordinate_type d=x*x+y*y;\n }\n int id;\n for( iv=0;iv>id; id=id-1;\n poly.addVertex(bg::get<0>(pts[id]), bg::get<1>(pts[id]));\n }\n\n poly.endPoly();\n return is;\n}\n\ntemplate\nistream& operator>>( istream& is, c_plylist& p)\n{\n //remove header commnets\n do{\n char tmp[1024];\n char c=is.peek();\n if(isspace(c)) is.get(c); //eat it\n else if(c=='#') {\n is.getline(tmp,1024);\n }\n else break;\n }while(true);\n\n //start reading\n uint size;\n is>>size;\n uint vid=0;\n for(uint i=0;i poly(c_ply::UNKNOWN);\n is>>poly;\n p.push_back(poly);\n uint vsize=poly.getSize();\n for(uint j=0;jsetVID(vid++); //id of vertex in the polygons\n //p.all.push_back(poly[j]);\n }\n }\n return is;\n}\n\ntemplate\nostream&\noperator<<( ostream& os, const c_ply& p)\n{\n os<::PIN)?\"PIN \":\"POUT \");\n const typename c_ply::vertex_type * ptr=p.head;\n os << \"< \" << ptr->getPos();\n ptr = ptr->getNext();\n while(ptr!=p.head)\n {\n os<< \", \" << ptr->getPos();\n ptr=ptr->getNext();\n }\n\n return os;\n}\n\ntemplate\nostream&\noperator<<( ostream& out, const c_plylist& p)\n{\n out<\nostream &\noperator<<(ostream &os, const c_polygon &p)\n{\n unsigned int idx = 0u;\n os << \"c_polygon({\" << endl;\n for (auto ply_it = p.cbegin(); ply_it != p.cend(); ++ply_it)\n os << \" [\" << setw(2) << idx++ << \"] \" << *ply_it << endl;\n os << \"})\";\n return os;\n}\n\ntemplate\nostream &\noperator<<(ostream &os, const vector > &v)\n{\n os << \"vector({\" << endl;\n unsigned int idx = 0u;\n for (auto it = v.begin(); it != v.end(); ++it)\n os << \" [\" << setw(2) << idx++ << \"] \" << *it << endl;\n os << \"})\";\n return os;\n}\n\ntemplate\nostream & operator<<(ostream &os,\n boost::geometry::model::d2::point_xy const&p)\n{\n os << \"(\" << bg::get<0>(p) << \",\" << bg::get<1>(p) << \")\";\n return os;\n}\n\nPLY_INSTANTIATE(boost::geometry::model::d2::point_xy, );\nPLY_INSTANTIATE(boost::geometry::model::d2::point_xy, );\n\ntemplate std::ostream &operator<< (std::ostream&,\n boost::geometry::model::d2::point_xy const&);\ntemplate std::ostream &operator<< (std::ostream&,\n boost::geometry::model::d2::point_xy const&);\n", "meta": {"hexsha": "d01c53e79cb4a8a2a2404b185c5893647c3b3a5c", "size": 24117, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/shapefile/polygon.cpp", "max_stars_repo_name": "fritzr/voronoi-game", "max_stars_repo_head_hexsha": "77fcc6a40076ab092795445f4e2a73f475338090", "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/shapefile/polygon.cpp", "max_issues_repo_name": "fritzr/voronoi-game", "max_issues_repo_head_hexsha": "77fcc6a40076ab092795445f4e2a73f475338090", "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/shapefile/polygon.cpp", "max_forks_repo_name": "fritzr/voronoi-game", "max_forks_repo_head_hexsha": "77fcc6a40076ab092795445f4e2a73f475338090", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-07-12T03:44:53.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-12T03:44:53.000Z", "avg_line_length": 24.2138554217, "max_line_length": 107, "alphanum_fraction": 0.5574905668, "num_tokens": 6771, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199633332891, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5426087195684167}} {"text": "/*\n Total variation denoising based on the paper \n \"The Split Bregman Method for L1-Regularized Problems\" by Tom Goldstein and Stanley Osher. \n Siam J. Imaging Sciences. Vol. 2, No. 2, pp. 323-343.\n*/\n\n// Gadgetron includes\n#include \"cuNDArray.h\"\n#include \"hoNDArray_fileio.h\"\n#include \"cuSbCgSolver.h\"\n#include \"cuCgSolver.h\"\n#include \"identityOperator.h\"\n#include \"cuPartialDerivativeOperator.h\"\n#include \"parameterparser.h\"\n#include \"cuNDDWT.h\"\n#include \"cuDWTOperator.h\"\n#include \n// Std includes\n#include \n\nusing namespace std;\nusing namespace Gadgetron;\n\n// Define desired precision\ntypedef float _real; \n\nint main(int argc, char** argv)\n{\n //\n // Parse command line\n //\n\n ParameterParser parms;\n parms.add_parameter( 'd', COMMAND_LINE_STRING, 1, \"Noisy image file name (.real)\", true );\n parms.add_parameter( 'r', COMMAND_LINE_STRING, 1, \"Result file name\", true, \"denoised_image_TV.real\" );\n parms.add_parameter( 'i', COMMAND_LINE_INT, 1, \"Number of cg iterations\", true, \"20\" );\n parms.add_parameter( 'I', COMMAND_LINE_INT, 1, \"Number of sb inner iterations\", true, \"1\" );\n parms.add_parameter( 'O', COMMAND_LINE_INT, 1, \"Number of sb outer iterations\", true, \"10\" );\n parms.add_parameter( 'l', COMMAND_LINE_FLOAT, 1, \"Total variation weight (lambda)\", true, \"50.0\" );\n parms.add_parameter( 'm', COMMAND_LINE_FLOAT, 1, \"Regularization weight (mu)\", true, \"25.0\" );\n parms.add_parameter('w', COMMAND_LINE_FLOAT, 1, \"Wavelet weight\" ,true, \"0\");\n\n parms.parse_parameter_list(argc, argv);\n if( parms.all_required_parameters_set() ){\n cout << \" Running denoising with the following parameters: \" << endl;\n parms.print_parameter_list();\n }\n else{\n cout << \" Some required parameters are missing: \" << endl;\n parms.print_parameter_list();\n parms.print_usage();\n return 1;\n }\n \n // Load sample data from disk\n boost::shared_ptr< hoNDArray<_real> > host_data = \n read_nd_array<_real>((char*)parms.get_parameter('d')->get_string_value());\n\n if( !host_data.get() ){\n cout << endl << \"Input image not found. Quitting!\\n\" << endl;\n return 1;\n }\n \n if( host_data->get_number_of_dimensions() != 2 ){\n cout << endl << \"Input image is not two-dimensional. Quitting!\\n\" << endl;\n return 1;\n }\n \n // Upload host data to device\n cuNDArray<_real> data(host_data.get());\n \n _real mu = (_real) parms.get_parameter('m')->get_float_value();\n _real lambda = (_real)parms.get_parameter('l')->get_float_value();\n\n if( mu <= (_real) 0.0 ) {\n cout << endl << \"Regularization parameter mu should be strictly positive. Quitting!\\n\" << endl;\n return 1;\n }\n\n unsigned int num_cg_iterations = parms.get_parameter('i')->get_int_value();\n unsigned int num_inner_iterations = parms.get_parameter('I')->get_int_value();\n unsigned int num_outer_iterations = parms.get_parameter('O')->get_int_value();\n \n // Define encoding operator (identity)\n boost::shared_ptr< identityOperator > > E( new identityOperator >() );\n E->set_weight( mu );\n E->set_domain_dimensions(data.get_dimensions().get());\n E->set_codomain_dimensions(data.get_dimensions().get());\n\n // Setup split-Bregman solver\n cuSbCgSolver<_real> sb;\n sb.set_encoding_operator( E );\n sb.set_max_outer_iterations(num_outer_iterations);\n sb.set_max_inner_iterations(num_inner_iterations);\n sb.set_output_mode( cuCgSolver<_real>::OUTPUT_VERBOSE );\n // Setup regularization operators\n\n if (lambda > 0){\n boost::shared_ptr< cuPartialDerivativeOperator<_real,2> > Rx( new cuPartialDerivativeOperator<_real,2>(0) );\n Rx->set_weight( lambda );\n Rx->set_domain_dimensions(data.get_dimensions().get());\n Rx->set_codomain_dimensions(data.get_dimensions().get());\n\n boost::shared_ptr< cuPartialDerivativeOperator<_real,2> > Ry( new cuPartialDerivativeOperator<_real,2>(1) );\n Ry->set_weight( lambda );\n Ry->set_domain_dimensions(data.get_dimensions().get());\n Ry->set_codomain_dimensions(data.get_dimensions().get());\n //sb.add_regularization_operator( Rx ); // Anisotropic denoising\n //sb.add_regularization_operator( Ry ); // Anisotropic denoising\n sb.add_regularization_group_operator( Rx ); // Isotropic denoising\n sb.add_regularization_group_operator( Ry); // Isotropic denoising\n sb.add_group();\n }\n \n _real wavelet = parms.get_parameter('w')->get_float_value();\n if (wavelet > 0){\n\t auto dwt = boost::make_shared>();\n\t dwt->set_levels(3);\n\t dwt->set_weight(wavelet);\n\t sb.add_regularization_operator(dwt);\n\t dwt->set_domain_dimensions(data.get_dimensions().get());\n\t dwt->set_codomain_dimensions(data.get_dimensions().get());\n\t dwt->use_random(true);\n }\n\n // Setup inner conjugate gradient solver\n sb.get_inner_solver()->set_max_iterations( num_cg_iterations );\n sb.get_inner_solver()->set_tc_tolerance( 1e-4 );\n sb.get_inner_solver()->set_output_mode( cuCgSolver<_real>::OUTPUT_WARNINGS );\n\n // Run split-Bregman solver\n boost::shared_ptr< cuNDArray<_real> > sbresult = sb.solve(&data);\n\n /*\n boost::shared_ptr< cuNDArray<_real> > sbresult(new cuNDArray<_real>(data.get_dimensions()));\n clear(sbresult.get());\n\n vector_td daubechies4({0.6830127f,1.1830127f,0.3169873f,-0.1830127f});\n vector_td haahr(1.0f,1.0f);\n vector_td daubechies6{0.47046721f,1.14111692f,0.650365f,-0.19093442f, -0.12083221f,0.0498175f};\n\n cuDWTOperator dwt;\n dwt.set_levels(3);\n dwt.mult_M(&data,sbresult.get());\n //data = *sbresult;\n shrink1(sbresult.get(),30.0f,&data);\n dwt.mult_MH(&data,sbresult.get());*/\n //clear(sbresult.get());\n // All done, write out the result\n boost::shared_ptr< hoNDArray<_real> > host_result = sbresult->to_host();\n write_nd_array<_real>(host_result.get(), (char*)parms.get_parameter('r')->get_string_value());\n \n return 0;\n}\n", "meta": {"hexsha": "51ea43e9bf9b1dd3db170608cb51d40fc8458ccf", "size": 5830, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "apps/standalone/gpu/denoising/2d/denoise_TV.cpp", "max_stars_repo_name": "roopchansinghv/gadgetron", "max_stars_repo_head_hexsha": "fb6c56b643911152c27834a754a7b6ee2dd912da", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2022-02-22T21:06:36.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-22T21:06:36.000Z", "max_issues_repo_path": "apps/standalone/gpu/denoising/2d/denoise_TV.cpp", "max_issues_repo_name": "apd47/gadgetron", "max_issues_repo_head_hexsha": "073e84dabe77d2dae3b3dd9aa4bf9edbf1f890f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "apps/standalone/gpu/denoising/2d/denoise_TV.cpp", "max_forks_repo_name": "apd47/gadgetron", "max_forks_repo_head_hexsha": "073e84dabe77d2dae3b3dd9aa4bf9edbf1f890f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.6129032258, "max_line_length": 110, "alphanum_fraction": 0.712864494, "num_tokens": 1635, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199552262967, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5426087143167215}} {"text": "/*\n * Copyright (C) 2015, Nils Moehrle\n * TU Darmstadt - Graphics, Capture and Massively Parallel Computing\n * All rights reserved.\n *\n * This software may be modified and distributed under the terms\n * of the BSD 3-Clause license. See the LICENSE.txt file for details.\n */\n\n#include \n#include \n\n#include \n#include \n#include \n\n#include \"poisson_blending.h\"\n\ntypedef Eigen::SparseMatrix SpMat;\n\nmath::Vec3f simple_laplacian(int i, mve::FloatImage::ConstPtr img) {\n const int width = img->width();\n assert(i > width + 1 && i < img->get_pixel_amount() - width - 1);\n\n return -4.0f * math::Vec3f(&img->at(i, 0))\n + math::Vec3f(&img->at(i - width, 0)) + math::Vec3f(&img->at(i - 1, 0))\n + math::Vec3f(&img->at(i + 1, 0))\n + math::Vec3f(&img->at(i + width, 0));\n}\n\nbool valid_mask(mve::ByteImage::ConstPtr mask) {\n const int width = mask->width();\n const int height = mask->height();\n\n for (int x = 0; x < width; ++x)\n if (mask->at(x, 0, 0) == 255 || mask->at(x, height - 1, 0) == 255)\n return false;\n\n for (int y = 0; y < height; ++y)\n if (mask->at(0, y, 0) == 255 || mask->at(width - 1, y, 0) == 255)\n return false;\n\n // TODO check for sane boundary conditions...\n\n return true;\n}\n\nvoid poisson_blend(\n mve::FloatImage::ConstPtr src,\n mve::ByteImage::ConstPtr mask,\n mve::FloatImage::Ptr dest,\n float alpha) {\n assert(src->width() == mask->width() && mask->width() == dest->width());\n assert(src->height() == mask->height() && mask->height() == dest->height());\n assert(src->channels() >= 3 && dest->channels() == src->channels());\n assert(mask->channels() == 1);\n assert(valid_mask(mask));\n\n const int n = dest->get_pixel_amount();\n const int width = dest->width();\n const int height = dest->height();\n // only do poisson on the color channels--first three\n // TODO dwh: get rid of hard coded color channels=3\n const int channels = std::min(dest->channels(), 3);\n\n mve::Image::Ptr indices = mve::Image::create(width, height, 1);\n indices->fill(-1);\n int index = 0;\n for (int i = 0; i < n; ++i) {\n if (mask->at(i) != 0) {\n indices->at(i) = index;\n index += 1;\n }\n }\n const int nnz = index;\n\n std::vector coefficients_b;\n coefficients_b.resize(nnz);\n // std::cout << \"blend 0 \" << std::endl;\n std::vector<\n Eigen::Triplet,\n Eigen::aligned_allocator>>\n coefficients_A;\n coefficients_A.reserve(nnz); // TODO better estimate...\n // std::cout << \"blend A \" << std::endl;\n for (int i = 0; i < n; ++i) {\n const int row = indices->at(i);\n if (mask->at(i) == 128 || mask->at(i) == 64) {\n Eigen::Triplet t(row, row, 1.0f);\n coefficients_A.push_back(t);\n\n coefficients_b[row] = math::Vec3f(&dest->at(i, 0));\n }\n\n if (mask->at(i) == 255) {\n const int i01 = indices->at(i - width);\n const int i10 = indices->at(i - 1);\n const int i11 = indices->at(i);\n const int i12 = indices->at(i + 1);\n const int i21 = indices->at(i + width);\n\n /* All neighbours should be eighter border conditions or part of the\n * optimization. */\n assert(i01 != -1 && i10 != -1 && i11 != -1 && i12 != -1 && i21 != -1);\n\n Eigen::Triplet t01(row, i01, 1.0f);\n\n Eigen::Triplet t10(row, i10, 1.0f);\n Eigen::Triplet t11(row, i11, -4.0f);\n Eigen::Triplet t12(row, i12, 1.0f);\n\n Eigen::Triplet t21(row, i21, 1.0f);\n\n Eigen::Triplet triplets[] = {t01, t10, t11, t12, t21};\n\n coefficients_A.insert(coefficients_A.end(), triplets, triplets + 5);\n\n math::Vec3f l_d = simple_laplacian(i, dest);\n math::Vec3f l_s = simple_laplacian(i, src);\n\n coefficients_b[row] = (alpha * l_s + (1.0f - alpha) * l_d);\n }\n }\n // std::cout << \"blend B \" << std::endl;\n SpMat A(nnz, nnz);\n A.setFromTriplets(coefficients_A.begin(), coefficients_A.end());\n // std::cout << \"blend C \" << std::endl;\n Eigen::SparseLU> solver;\n // std::cout << \"blend Cp \" << std::endl;\n // std::cout << nnz << std::endl;\n solver.compute(A);\n // std::cout << \"blend D \" << std::endl;\n for (int channel = 0; channel < channels; ++channel) {\n Eigen::VectorXf b(nnz);\n for (std::size_t i = 0; i < coefficients_b.size(); ++i)\n b[i] = coefficients_b[i][channel];\n\n Eigen::VectorXf x(n);\n x = solver.solve(b);\n\n for (int i = 0; i < n; ++i) {\n int index = indices->at(i);\n if (index != -1)\n dest->at(i, channel) = x[index];\n }\n }\n // std::cout << \"blend E \" << std::endl;\n}\n", "meta": {"hexsha": "baa3d06d31c208c92413f1e8147c4f45c8252441", "size": 4718, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libs/tex/poisson_blending.cpp", "max_stars_repo_name": "Hivemapper/HM-colony-mvs-texturing", "max_stars_repo_head_hexsha": "2930c8926886d33fcec5ed42137d2f21ce834c2a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-12-04T16:38:50.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-04T16:38:50.000Z", "max_issues_repo_path": "libs/tex/poisson_blending.cpp", "max_issues_repo_name": "Hivemapper/HM-colony-mvs-texturing", "max_issues_repo_head_hexsha": "2930c8926886d33fcec5ed42137d2f21ce834c2a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2019-07-15T21:58:26.000Z", "max_issues_repo_issues_event_max_datetime": "2020-10-06T02:56:46.000Z", "max_forks_repo_path": "libs/tex/poisson_blending.cpp", "max_forks_repo_name": "Hivemapper/HM-colony-mvs-texturing", "max_forks_repo_head_hexsha": "2930c8926886d33fcec5ed42137d2f21ce834c2a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-03-28T18:15:52.000Z", "max_forks_repo_forks_event_max_datetime": "2019-03-28T18:15:52.000Z", "avg_line_length": 31.6644295302, "max_line_length": 80, "alphanum_fraction": 0.5862653667, "num_tokens": 1519, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199552262967, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5426087143167215}} {"text": "#ifndef __PARTICLE_FILTER_HAND_PREDICTION_HPP\n#define __PARTICLE_FILTER_HAND_PREDICTION_HPP\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"particle_filter_hand.hpp\"\n#include \"particle_filter_base.hpp\"\n\n#define SMOOTH_FACTOR (1.)\n\nclass HandPredictionModel: public PredictionModel\n{\nprivate:\n double initQSigma;\n double initWSigma;\n double updateQSigma;\n double updateWSigma;\n \n \n void _updateParticle(Particle &p,\n\t\t double deltaT, double qSigma, double wSigma,\n\t\t boost::random::mt19937 &rng) const\n {\n // Quaternion kinematics from\n // Sola, Joan. \"Quaternion kinematics for the error-state KF.\" Laboratoire d’Analyse et d’Architecture des Systemes-Centre national de la recherche scientifique (LAAS-CNRS), Toulouse, France, Tech. Rep (2012).\n boost::random::normal_distribution Nq(0., qSigma);\n boost::random::normal_distribution Nw(0., wSigma);\n boost::random::uniform_01 U;\n\n // Current state quaternions (orientation and angular velocity)\n Eigen::Quaternion qt, wt;\n qt.w() = p.state[0];\n qt.x() = p.state[1];\n qt.y() = p.state[2];\n qt.z() = p.state[3];\n wt.w() = 0.;\n wt.x() = p.state[4]; \n wt.y() = p.state[5]; \n wt.z() = p.state[6];\n \n // Perturbation quaternions\n Eigen::Quaternion deltaqt, deltawt;\n //deltaqt.w() =1. +Nq(rng);\n //deltaqt.x() = Nq(rng);\n //deltaqt.y() = Nq(rng);\n //deltaqt.z() = Nq(rng);\n Eigen::AngleAxisd deltaaxt;\n deltaaxt.angle() = Nq(rng);\n deltaaxt.axis().x() = -1.+2.*U(rng);\n deltaaxt.axis().y() = -1.+2.*U(rng);\n deltaaxt.axis().z() = -1.+2.*U(rng);\n deltaqt = deltaaxt;\n deltawt.w() = 0;\n deltawt.x() = Nw(rng);\n deltawt.y() = Nw(rng);\n deltawt.z() = Nw(rng);\n\n // Update quaternion rotation\n Eigen::Quaternion qtw,qt1;\n // - quaternion update (for non zero velocity)\n if (deltaT)\n {\n qtw.w() = cos(wt.norm()*deltaT/2);\n qtw.x() = wt.x()/wt.norm()*sin(wt.norm()*deltaT/2);\n qtw.y() = wt.y()/wt.norm()*sin(wt.norm()*deltaT/2);\n qtw.z() = wt.z()/wt.norm()*sin(wt.norm()*deltaT/2);\n // - multiply by perturbation and update\n qt1 = deltaqt * qtw * qt;\n }\n else\n {\n // Null velocity, apply the random perturbation only\n qt1 = deltaqt * qt;\n }\n\t// Normalize\n\tqt1.normalize();\n\n // Update velocity\n Eigen::Quaternion deltaq, wt1;\n Eigen::AngleAxisd axang;\n if (deltaT)\n {\n deltaq = qt1 * qt.inverse();\n axang = deltaq;\n wt1.w() = 0.;\n wt1.x() = axang.axis().x()*axang.angle()/deltaT + deltawt.x();\n wt1.y() = axang.axis().y()*axang.angle()/deltaT + deltawt.y();\n wt1.z() = axang.axis().z()*axang.angle()/deltaT + deltawt.z();\n }\n else\n {\n wt1.w() = 0.;\n wt1.x() = wt.x()+deltawt.x();\n wt1.y() = wt.y()+deltawt.y();\n wt1.z() = wt.z()+deltawt.z();\n }\n\n\n // Done, update particle status\n Eigen::Quaternion iq;\n iq = qt.slerp(SMOOTH_FACTOR, qt1);\n p.state[0] = iq.w();\n p.state[1] = iq.x();\n p.state[2] = iq.y();\n p.state[3] = iq.z();\n \n p.state[4] = SMOOTH_FACTOR*wt1.x() + (1.-SMOOTH_FACTOR)*wt.x();\n p.state[5] = SMOOTH_FACTOR*wt1.y() + (1.-SMOOTH_FACTOR)*wt.y();\n p.state[6] = SMOOTH_FACTOR*wt1.z() + (1.-SMOOTH_FACTOR)*wt.z();\n }\n\n\n void _updateParticles(std::vector > &particles,\n\t\t\tdouble deltaT, double qSigma, double wSigma) const\n {\n boost::random::mt19937 rng(time(NULL));\n for (std::vector >::iterator it=particles.begin();\n\t it!=particles.end(); ++it)\n {\n Particle &p = *it;\n _updateParticle(p, deltaT, qSigma, wSigma, rng);\n }\n }\n\npublic:\n HandPredictionModel(double initQSigma, double initWSigma,\n\t\t double updateQSigma, double updateWSigma):\n initQSigma(initQSigma),\n initWSigma(initWSigma),\n updateQSigma(updateQSigma),\n updateWSigma(updateWSigma)\n {}\n\n void init(const double *initState,\n\t std::vector > &particles) const\n {\n // Set all particle to the initial state\n for (std::vector >::iterator it=particles.begin();\n\t it!=particles.end(); ++it)\n {\n Particle &p = *it;\n std::copy(initState, initState+HAND_STATE_SIZE, p.state);\n p.likelihood = 0.;\n }\n \n _updateParticles(particles, 0., initQSigma, initWSigma);\n }\n\n void update(std::vector > &particles, double deltaT) const\n {\n _updateParticles(particles, deltaT, updateQSigma, updateWSigma);\n }\n};\n\n\n\n\n#endif // __PARTICLE_FILTER_HAND_PREDICTION_HPP\n", "meta": {"hexsha": "3e4c85ef18ca02d4eeaefebc19f75a806cf91e29", "size": 4833, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/particle_filter/particle_filter_hand_prediction.hpp", "max_stars_repo_name": "mUogoro/hand_rotation_estimation_tutorial", "max_stars_repo_head_hexsha": "98707de67448016e63bb8480090e4fa139dbc896", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2017-09-15T01:05:09.000Z", "max_stars_repo_stars_event_max_datetime": "2017-09-15T01:05:09.000Z", "max_issues_repo_path": "src/particle_filter/particle_filter_hand_prediction.hpp", "max_issues_repo_name": "mUogoro/hand_rotation_estimation_tutorial", "max_issues_repo_head_hexsha": "98707de67448016e63bb8480090e4fa139dbc896", "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/particle_filter/particle_filter_hand_prediction.hpp", "max_forks_repo_name": "mUogoro/hand_rotation_estimation_tutorial", "max_forks_repo_head_hexsha": "98707de67448016e63bb8480090e4fa139dbc896", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2018-11-08T09:15:38.000Z", "max_forks_repo_forks_event_max_datetime": "2019-05-29T07:57:45.000Z", "avg_line_length": 29.6503067485, "max_line_length": 213, "alphanum_fraction": 0.626939789, "num_tokens": 1463, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382023207901, "lm_q2_score": 0.6297746074044134, "lm_q1q2_score": 0.5425748831304796}} {"text": "#include \n#include \n#include \n#include \n#include \n\n\nnamespace ub = boost::numeric::ublas;\n\ntypedef kv::interval< kv::dd > itvdd;\ntypedef kv::interval itv;\n\nint main()\n{\n\tub::matrix a;\n\tub::matrix< kv::complex > v, d;\n\n\tstd::cout.precision(17);\n\n\ta.resize(2,2);\n\n\ta(0,0) = 1.;\n\ta(0,1) = 2.;\n\ta(1,0) = 3.;\n\ta(1,1) = 4.;\n\n\t// approximation\n\teig(a, v, d);\n\tstd::cout << v << \"\\n\";\n\tstd::cout << d << \"\\n\";\n\n\t// verified\n\tub::vector< kv::complex > l;\n\tveig(a, l);\n\tstd::cout << l << \"\\n\";\n\n\t// verified (interval matrix)\n\tub::matrix ia;\n\tia = a;\n\tveig(ia, l);\n\tstd::cout << l << \"\\n\";\n\n\t// verified (interval dd matrix)\n\tub::matrix iadd;\n\tub::vector< kv::complex > ldd;\n\tstd::cout.precision(34);\n\tiadd = a;\n\tveig(iadd, ldd);\n\tstd::cout << ldd << \"\\n\";\n}\n", "meta": {"hexsha": "4dbb54bcd62ca0b931796cb6704166baf19b0d96", "size": 896, "ext": "cc", "lang": "C++", "max_stars_repo_path": "test/test-eig.cc", "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": "test/test-eig.cc", "max_issues_repo_name": "soonho-tri/kv", "max_issues_repo_head_hexsha": "4963be6560d8600cdc9ff22d004b2b965ae7b1df", "max_issues_repo_licenses": ["MIT"], "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": "test/test-eig.cc", "max_forks_repo_name": "soonho-tri/kv", "max_forks_repo_head_hexsha": "4963be6560d8600cdc9ff22d004b2b965ae7b1df", "max_forks_repo_licenses": ["MIT"], "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": 17.568627451, "max_line_length": 41, "alphanum_fraction": 0.5870535714, "num_tokens": 330, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382023207901, "lm_q2_score": 0.6297746074044134, "lm_q1q2_score": 0.5425748831304796}} {"text": "//#define ARMA_NO_DEBUG\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\nusing namespace std;\r\nusing namespace arma;\r\n\r\ntypedef double (*callback_type)(int, double[]);\r\ntypedef bool (*is_terminate_type)(long, int, double); // runid, iter, value -> isTerminate\r\n\r\nstatic uvec inverse(const uvec& indices) {\r\n uvec inverse = uvec(indices.size());\r\n for (int i = 0; i < indices.size(); i++)\r\n inverse(indices(i)) = i;\r\n return inverse;\r\n}\r\n\r\nstatic vec sequence(double start, double end, double step) {\r\n int size = (int) ((end - start) / step + 1);\r\n vec d(size);\r\n double value = start;\r\n for (int r = 0; r < size; r++) {\r\n d(r) = value;\r\n value += step;\r\n }\r\n return d;\r\n}\r\n\r\n// wrapper around the fittness function, scales according to boundaries\r\n\r\nclass Fittness {\r\n\r\npublic:\r\n\r\n Fittness(callback_type pfunc, const vec &lower_limit,\r\n const vec &upper_limit) {\r\n func = pfunc;\r\n lower = lower_limit;\r\n upper = upper_limit;\r\n evaluationCounter = 0;\r\n if (lower.size() > 0) { // bounds defined\r\n scale = 0.5 * (upper - lower);\r\n typx = 0.5 * (upper + lower);\r\n }\r\n }\r\n\r\n void closestFeasible(vec &X) const { // in place\r\n if (lower.size() > 0)\r\n X.for_each([](double &val) {\r\n val = max(min(val, 1.0), -1.0);\r\n });\r\n }\r\n\r\n vec getClosestFeasible(const vec &col) const {\r\n if (lower.size() > 0) {\r\n vec X(col);\r\n X.for_each([](double &val) {\r\n val = max(min(val, 1.0), -1.0);\r\n });\r\n return X;\r\n }\r\n return col;\r\n }\r\n\r\n double eval(const vec &X) {\r\n int n = X.size();\r\n double parg[n];\r\n for (int i = 0; i < n; i++)\r\n parg[i] = X(i);\r\n double res = func(n, parg);\r\n evaluationCounter++;\r\n return res;\r\n }\r\n\r\n double value(const vec &X) {\r\n double value;\r\n if (lower.size() > 0) {\r\n return eval(decode(getClosestFeasible(X)));\r\n } else\r\n return eval(X);\r\n }\r\n\r\n vec encode(const vec &X) const {\r\n if (lower.size() > 0)\r\n return (X - typx) / scale;\r\n else\r\n return X;\r\n }\r\n\r\n vec decode(const vec &X) const {\r\n if (lower.size() > 0)\r\n return (X % scale) + typx;\r\n else\r\n return X;\r\n }\r\n\r\n int getEvaluations() {\r\n return evaluationCounter;\r\n }\r\n\r\nprivate:\r\n callback_type func;\r\n vec lower;\r\n vec upper;\r\n long evaluationCounter;\r\n vec scale;\r\n vec typx;\r\n};\r\n\r\nclass AcmaesOptimizer {\r\n\r\npublic:\r\n\r\n AcmaesOptimizer(long runid_, Fittness* fitfun_, int popsize_, int mu_, const vec &guess_, const vec &inputSigma_,\r\n int maxIterations_, int maxEvaluations_, double accuracy_, double stopfitness_, is_terminate_type isTerminate_) {\r\n// runid used in isTerminate callback to identify a specific run at different iteration\r\n runid = runid_;\r\n// fitness function to minimize\r\n fitfun = fitfun_;\r\n// initial guess for the arguments of the fitness function\r\n guess = guess_;\r\n// accuracy = 1.0 is default, > 1.0 reduces accuracy\r\n accuracy = accuracy_;\r\n// callback to check if to terminate\r\n isTerminate = isTerminate_;\r\n// Number of objective variables/problem dimension\r\n dim = guess_.size();\r\n// Population size, offspring number. The primary strategy parameter to play\r\n// with, which can be increased from its default value. Increasing the\r\n// population size improves global search properties in exchange to speed.\r\n// Speed decreases, as a rule, at most linearly with increasing population\r\n// size. It is advisable to begin with the default small population size.\r\n if (popsize_ > 0)\r\n popsize = popsize_;\r\n else\r\n popsize = 4 + int(3. * log(dim));\r\n// Individual sigma values - initial search volume. inputSigma determines\r\n// the initial coordinate wise standard deviations for the search. Setting\r\n// SIGMA one third of the initial search region is appropriate.\r\n if (inputSigma_.size() == 1)\r\n inputSigma = vec(dim).fill(inputSigma_(0));\r\n else\r\n inputSigma = inputSigma_;\r\n// Overall standard deviation - search volume.\r\n sigma = max(inputSigma);\r\n// termination criteria\r\n// maximal number of evaluations allowed.\r\n maxEvaluations = maxEvaluations_;\r\n// maximal number of iterations allowed.\r\n maxIterations = maxIterations_;\r\n// Limit for fitness value.\r\n stopfitness = stopfitness_;\r\n// Stop if x-changes larger stopTolUpX.\r\n stopTolUpX = 1e3 * sigma;\r\n// Stop if x-change smaller stopTolX.\r\n stopTolX = 1e-11 * sigma * accuracy;\r\n// Stop if fun-changes smaller stopTolFun.\r\n stopTolFun = 1e-12 * accuracy;\r\n// Stop if back fun-changes smaller stopTolHistFun.\r\n stopTolHistFun = 1e-13 * accuracy;\r\n// selection strategy parameters\r\n// Number of parents/points for recombination.\r\n mu = mu_ > 0 ? mu_ : popsize / 2;\r\n// Array for weighted recombination.\r\n weights = (log(sequence(1, mu, 1)) * -1.) + log(mu + 0.5);\r\n double sumw = sum(weights);\r\n double sumwq = sum(weights % weights);\r\n weights *= 1. / sumw;\r\n// Variance-effectiveness of sum w_i x_i.\r\n mueff = sumw * sumw / sumwq;\r\n\r\n// dynamic strategy parameters and constants\r\n// Cumulation constant.\r\n cc = (4. + mueff / dim) / (dim + 4. + 2. * mueff / dim);\r\n// Cumulation constant for step-size.\r\n cs = (mueff + 2.) / (dim + mueff + 3.);\r\n// Damping for step-size.\r\n damps = (1. + 2. * ::max(0., ::sqrt((mueff - 1.)\r\n / (dim + 1.)) - 1.))\r\n * max(0.3, 1.\r\n - // modification for short runs\r\n dim / (1e-6 + min(maxIterations, maxEvaluations\r\n / popsize))) + cs; // minor increment\r\n// Learning rate for rank-one update.\r\n ccov1 = 2. / ((dim + 1.3) * (dim + 1.3) + mueff);\r\n// Learning rate for rank-mu update'\r\n ccovmu = min(1. - ccov1,\r\n 2. * (mueff - 2. + 1. / mueff)\r\n / ((dim + 2.) * (dim + 2.) + mueff));\r\n// Expectation of ||N(0,I)|| == norm(randn(N,1)).\r\n chiN = sqrt(dim) * (1. - 1. / (4. * dim) + 1 / (21. * dim * dim));\r\n ccov1Sep = min(1., ccov1 * (dim + 1.5) / 3.);\r\n ccovmuSep = min(1. - ccov1, ccovmu * (dim + 1.5) / 3.);\r\n\r\n// CMA internal values - updated each generation\r\n// Objective variables.\r\n xmean = fitfun->encode(guess);\r\n// Evolution path.\r\n pc = zeros(dim);\r\n// Evolution path for sigma.\r\n ps = zeros(dim);\r\n// Norm of ps, stored for efficiency.\r\n normps = norm(ps);\r\n// Coordinate system.\r\n B = mat(dim,dim).eye();\r\n// Diagonal of sqrt(D), stored for efficiency.\r\n diagD = inputSigma / sigma;\r\n diagC = square(diagD);\r\n// B*D, stored for efficiency.\r\n BD = B % repmat(diagD.t(), dim, 1);\r\n// Covariance matrix.\r\n C = B * (mat(dim,dim).eye() * B.t());\r\n// Number of iterations already performed.\r\n iterations = 0;\r\n// Size of history queue of best values.\r\n historySize = 10 + int(3. * 10. * dim / popsize);\r\n// stop criteria\r\n stop = 0;\r\n// best value so far\r\n bestValue = fitfun->value(xmean);\r\n// best parameters so far\r\n bestX = guess;\r\n// History queue of best values.\r\n fitnessHistory = vec(historySize).fill(DBL_MAX);\r\n fitnessHistory(0) = bestValue;\r\n }\r\n\r\n // param zmean weighted row matrix of the gaussian random numbers generating the current offspring\r\n // param xold xmean matrix of the previous generation\r\n // return hsig flag indicating a small correction\r\n\r\n bool updateEvolutionPaths(const vec& zmean, const vec& xold) {\r\n ps = ps * (1. - cs) + ((B * zmean) * sqrt(cs * (2. - cs) * mueff));\r\n normps = norm(ps);\r\n bool hsig = normps / sqrt(1. - pow(1. - cs, 2. * iterations)) / chiN < 1.4 + 2. / (dim + 1.);\r\n pc *= (1. - cc);\r\n if (hsig)\r\n pc += (xmean - xold) * (sqrt(cc * (2. - cc) * mueff) / sigma);\r\n return hsig;\r\n }\r\n\r\n // param hsig flag indicating a small correction\r\n // param bestArx fitness-sorted matrix of the argument vectors producing the current offspring\r\n // param arz unsorted matrix containing the gaussian random values of the current offspring\r\n // param arindex indices indicating the fitness-order of the current offspring\r\n // param xold xmean matrix of the previous generation\r\n\r\n double updateCovariance(bool hsig, const mat& bestArx, const mat& arz,\r\n const uvec& arindex, const mat& xold) {\r\n double negccov = 0;\r\n if (ccov1 + ccovmu > 0) {\r\n mat arpos = (bestArx - repmat(xold, 1, mu)) * (1. / sigma); // mu difference vectors\r\n mat roneu = pc * pc.t() * ccov1;\r\n // minor correction if hsig==false\r\n double oldFac = hsig ? 0 : ccov1 * cc * (2. - cc);\r\n oldFac += 1. - ccov1 - ccovmu;\r\n // Adapt covariance matrix C active CMA\r\n negccov = (1. - ccovmu) * 0.25 * mueff\r\n / (pow(dim + 2., 1.5) + 2. * mueff);\r\n double negminresidualvariance = 0.66;\r\n // keep at least 0.66 in all directions, small popsize are most critical\r\n double negalphaold = 0.5; // where to make up for the variance loss,\r\n // prepare vectors, compute negative updating matrix Cneg\r\n uvec arReverseIndex = reverse(arindex);\r\n mat arzneg = arz.cols(arReverseIndex.head(mu));\r\n vec arnorms = sqrt(sum(square(arzneg.t()), 1)); // rowsum\r\n uvec idxnorms = sort_index(arnorms);\r\n vec arnormsSorted = arnorms(idxnorms);\r\n uvec idxReverse = reverse(idxnorms);\r\n vec arnormsReverse = arnorms(idxReverse);\r\n arnorms = arnormsReverse / arnormsSorted;\r\n vec arnormsInv = arnorms(inverse(idxnorms));\r\n mat sqarnw = square(arnormsInv).t() * weights;\r\n double negcovMax = (1. - negminresidualvariance) / sqarnw(0);\r\n if (negccov > negcovMax)\r\n negccov = negcovMax;\r\n arzneg = arzneg % repmat(arnormsInv.t(), dim, 1);\r\n mat artmp = BD * arzneg;\r\n mat Cneg = artmp * diagmat(weights) * artmp.t();\r\n oldFac += negalphaold * negccov;\r\n C = (C * oldFac) + roneu\r\n + ( arpos * (ccovmu + (1. - negalphaold) * negccov) *\r\n (repmat(weights, 1, dim) % arpos.t()))\r\n - (Cneg * negccov);\r\n }\r\n return negccov;\r\n }\r\n\r\n // Update B and diagD from C\r\n // param negccov Negative covariance factor.\r\n\r\n void updateBD(double negccov) {\r\n\r\n if (ccov1 + ccovmu + negccov > 0\r\n && (std::fmod(iterations, 1. / (ccov1 + ccovmu + negccov) / dim / 10.)) < 1.) {\r\n // to achieve O(N^2) enforce symmetry to prevent complex numbers\r\n C = trimatu(C) + trimatu(C, 1).t();\r\n // diagD defines the scaling\r\n vec eigval;\r\n mat eigvec;\r\n eig_sym(eigval, eigvec, C);\r\n\r\n diagD = reverse(eigval); // descending order of eigenvalues\r\n for (int i = 0; i < dim; i++)\r\n B.col(i) = eigvec.col(dim - 1 - i);\r\n\r\n if (diagD.min() <= 0) {\r\n for (int i = 0; i < dim; i++)\r\n if (diagD(i, 0) < 0)\r\n diagD(i, 0) = 0.;\r\n double tfac = diagD.max() / 1e14;\r\n C += mat(dim,dim).eye() * tfac;\r\n diagD += ones(dim, 1) * tfac;\r\n }\r\n if (diagD.max() > 1e14 * diagD.min()) {\r\n double tfac = diagD.max() / 1e14 - diagD.min();\r\n C += mat(dim,dim).eye() * tfac;\r\n diagD += ones(dim, 1) * tfac;\r\n }\r\n diagC = C.diag();\r\n diagD = sqrt(diagD); // D contains standard deviations now\r\n BD = B % repmat(diagD.t(), dim, 1);\r\n }\r\n }\r\n\r\n void doOptimize() {\r\n\r\n // -------------------- Generation Loop --------------------------------\r\n\r\n for (iterations = 1; iterations <= maxIterations &&\r\n fitfun->getEvaluations() < maxEvaluations; iterations++) {\r\n // Generate and evaluate popsize offspring\r\n mat arz = mat(dim, popsize).randn();\r\n mat arx = mat(dim, popsize);\r\n vec fitness = vec(popsize).fill(DBL_MAX);\r\n // generate random offspring\r\n fitfun->closestFeasible(xmean);\r\n for (int k = 0; k < popsize; k++) {\r\n vec delta = (BD * arz.col(k)) * sigma;\r\n arx.col(k) = fitfun->getClosestFeasible(xmean + delta);\r\n fitness[k] = fitfun->value(arx.col(k)); // compute fitness\r\n if (!isfinite(fitness[k])) {\r\n stop = -1;\r\n break;\r\n }\r\n }\r\n if (stop != 0)\r\n break;\r\n // Sort by fitness and compute weighted mean into xmean\r\n uvec arindex = sort_index(fitness);\r\n\r\n // Calculate new xmean, this is selection and recombination\r\n vec xold = xmean; // for speed up of Eq. (2) and (3)\r\n uvec bestIndex = arindex.head(mu);\r\n mat bestArx = arx.cols(bestIndex);\r\n xmean = bestArx * weights;\r\n mat bestArz = arz.cols(bestIndex);\r\n mat zmean = bestArz * weights;\r\n\r\n bool hsig = updateEvolutionPaths(zmean, xold);\r\n double negccov = updateCovariance(hsig, bestArx, arz, arindex, xold);\r\n updateBD(negccov);\r\n // Adapt step size sigma - Eq. (5)\r\n sigma *= exp(min(1.0, (normps / chiN - 1.) * cs / damps));\r\n double bestFitness = fitness(arindex(0));\r\n double worstFitness = fitness(arindex(arindex.size()-1));\r\n if (bestValue > bestFitness) {\r\n bestValue = bestFitness;\r\n bestX = fitfun->decode(bestArx.col(0));\r\n }\r\n\r\n // handle termination criteria\r\n if (isfinite(stopfitness) && bestFitness < stopfitness) {\r\n stop = 1;\r\n break;\r\n }\r\n vec sqrtDiagC = sqrt(diagC);\r\n vec pcCol = pc;\r\n\r\n for (int i = 0; i < dim; i++) {\r\n if (sigma * (max(abs(pcCol[i]), sqrtDiagC[i])) > stopTolX)\r\n break;\r\n if (i >= dim - 1)\r\n stop = 2;\r\n }\r\n for (int i = 0; i < dim; i++)\r\n if (sigma * sqrtDiagC[i] > stopTolUpX)\r\n stop = 3;\r\n if (stop > 0)\r\n break;\r\n double historyBest = min(fitnessHistory);\r\n double historyWorst = max(fitnessHistory);\r\n if (iterations > 2\r\n && max(historyWorst, worstFitness)\r\n - min(historyBest, bestFitness) < stopTolFun) {\r\n stop = 4;\r\n break;\r\n }\r\n if (iterations > fitnessHistory.size()\r\n && historyWorst - historyBest < stopTolHistFun) {\r\n stop = 5;\r\n break;\r\n }\r\n // condition number of the covariance matrix exceeds 1e14\r\n if ( diagD.max() / diagD.min() > 1e7 * 1.0 / sqrt(accuracy)) {\r\n stop = 6;\r\n break;\r\n }\r\n if (isTerminate != NULL && isTerminate(runid, iterations, bestValue)) {\r\n stop = 7;\r\n break;\r\n }\r\n // Adjust step size in case of equal function values (flat fitness)\r\n if (bestValue == fitness[arindex[(int) (0.1 + popsize / 4.)]]) {\r\n sigma *= exp(0.2 + cs / damps);\r\n }\r\n if (iterations > 2\r\n && max(historyWorst, bestFitness)\r\n - ::min(historyBest, bestFitness) == 0) {\r\n sigma *= ::exp(0.2 + cs / damps);\r\n }\r\n // store best in history\r\n for (int i = 1; i < fitnessHistory.size(); i++)\r\n fitnessHistory[i] = fitnessHistory[i - 1];\r\n fitnessHistory[0] = bestFitness;\r\n }\r\n }\r\n\r\n vec getBestX() {\r\n return bestX;\r\n }\r\n\r\n double getBestValue() {\r\n return bestValue;\r\n }\r\n\r\n double getIterations() {\r\n return iterations;\r\n }\r\n\r\n double getStop() {\r\n return stop;\r\n }\r\n\r\n\r\nprivate:\r\n long runid;\r\n Fittness* fitfun;\r\n vec guess;\r\n double accuracy;\r\n is_terminate_type isTerminate;\r\n int popsize; // population size\r\n vec inputSigma;\r\n int dim;\r\n int maxIterations;\r\n int maxEvaluations;\r\n double stopfitness;\r\n double stopTolUpX;\r\n double stopTolX;\r\n double stopTolFun;\r\n double stopTolHistFun;\r\n int mu; //\r\n vec weights;\r\n double mueff; //\r\n double sigma;\r\n double cc;\r\n double cs;\r\n double damps;\r\n double ccov1;\r\n double ccovmu;\r\n double chiN;\r\n double ccov1Sep;\r\n double ccovmuSep;\r\n vec xmean;\r\n vec pc;\r\n vec ps;\r\n double normps;\r\n mat B;\r\n mat BD;\r\n mat diagD;\r\n mat C;\r\n vec diagC;\r\n int iterations;\r\n vec fitnessHistory;\r\n int historySize;\r\n double bestValue;\r\n vec bestX;\r\n int stop;\r\n};\r\n\r\n// see https://cvstuff.wordpress.com/2014/11/27/wraping-c-code-with-python-ctypes-memory-and-pointers/\r\n\r\nextern \"C\" {\r\n void seed(int s) {\r\n arma_rng::set_seed(s);\r\n }\r\n}\r\n\r\nextern \"C\" {\r\n void seedRandom() {\r\n arma_rng::set_seed_random();\r\n }\r\n}\r\n\r\nextern \"C\" {\r\n void free_mem(double* a) {\r\n delete[] a;\r\n }\r\n}\r\n\r\nextern \"C\" {\r\n double* optimizeACMA_C(long runid, callback_type func, int dim, double *init,\r\n double *lower, double *upper, double *sigma, int maxIter, int maxEvals,\r\n double stopfitness, int mu, int popsize, double accuracy,\r\n bool useTerminate, is_terminate_type isTerminate) {\r\n int n = dim;\r\n double *res = new double[n + 4];\r\n vec guess(n), lower_limit(n), upper_limit(n), inputSigma(n);\r\n bool useLimit = false;\r\n for (int i = 0; i < n; i++) {\r\n guess[i] = init[i];\r\n inputSigma[i] = sigma[i];\r\n lower_limit[i] = lower[i];\r\n upper_limit[i] = upper[i];\r\n useLimit |= (lower[i] != 0);\r\n useLimit |= (upper[i] != 0);\r\n }\r\n if (useLimit == false) {\r\n lower_limit.resize(0);\r\n upper_limit.resize(0);\r\n } \r\n Fittness fitfun(func, lower_limit, upper_limit);\r\n AcmaesOptimizer opt(\r\n runid,\r\n &fitfun,\r\n popsize,\r\n mu,\r\n guess,\r\n inputSigma,\r\n maxIter,\r\n maxEvals,\r\n accuracy,\r\n stopfitness,\r\n useTerminate ? isTerminate : NULL);\r\n try {\r\n opt.doOptimize();\r\n vec bestX = opt.getBestX();\r\n double bestY = opt.getBestValue();\r\n for (int i = 0; i < n; i++)\r\n res[i] = bestX[i];\r\n res[n] = bestY;\r\n res[n+1] = fitfun.getEvaluations();\r\n res[n+2] = opt.getIterations();\r\n res[n+3] = opt.getStop();\r\n return res;\r\n } catch (std::exception& e) {\r\n cout << e.what() << endl;\r\n return res;\r\n }\r\n }\r\n}\r\n", "meta": {"hexsha": "544ec4912a10f70aec845b96869d58f5e0523efc", "size": 19895, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "_fcmaescpp/acmaesoptimizer.cpp", "max_stars_repo_name": "juliendehos/fast-cma-es", "max_stars_repo_head_hexsha": "ebf74f908dcee22b617fc6759480fc6f9f717460", "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": "_fcmaescpp/acmaesoptimizer.cpp", "max_issues_repo_name": "juliendehos/fast-cma-es", "max_issues_repo_head_hexsha": "ebf74f908dcee22b617fc6759480fc6f9f717460", "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": "_fcmaescpp/acmaesoptimizer.cpp", "max_forks_repo_name": "juliendehos/fast-cma-es", "max_forks_repo_head_hexsha": "ebf74f908dcee22b617fc6759480fc6f9f717460", "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": 35.2123893805, "max_line_length": 126, "alphanum_fraction": 0.511837145, "num_tokens": 5053, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.754914975839675, "lm_q2_score": 0.7185944046238981, "lm_q1q2_score": 0.5424776776051757}} {"text": "#include \n#include \n\nusing namespace std;\nusing namespace boost::math::differentiation;\n\nconstexpr double PI = M_PI;\n\ntemplate\nauto sqr(const X& x) { return x * x; }\n\n#include \n\ndouble clamp(double x, double min_x, double max_x) {\n if (x > max_x) return max_x;\n if (x < min_x) return min_x;\n return x;\n}\n\n// TODO adam, vector as input, benchmarks\n\ntemplate\nvoid optimize(const char* name, double range, bool newton, const Func& func) {\n cout << name << endl;\n std::mt19937 rng(0);\n\n double best = 1e100;\n std::uniform_real_distribution unif(-range, range);\n double best_wx = unif(rng), best_wy = unif(rng);\n double dev = range / 3;\n size_t evals = 100 * 1000 * 1000;\n const double alpha = newton ? 1 : 1e-2;\n size_t misses = 0;\n\n for (size_t j = 0; evals > 0; j++) {\n double wx = clamp(std::normal_distribution<>(best_wx, dev)(rng), -range, range);\n double wy = clamp(std::normal_distribution<>(best_wy, dev)(rng), -range, range);\n bool improved = false;\n for (size_t i = 0; i < 10000; i++) {\n double result, dx, dy, d2x = 1, d2y = 1;\n if (newton) {\n const auto in = make_ftuple(wx, wy);\n const auto& f = func(std::get<0>(in), std::get<1>(in));\n result = f.derivative(0, 0);\n dx = f.derivative(1, 0);\n dy = f.derivative(0, 1);\n d2x = f.derivative(2, 0);\n d2y = f.derivative(0, 2);\n } else {\n const auto in = make_ftuple(wx, wy);\n const auto& f = func(std::get<0>(in), std::get<1>(in));\n result = f.derivative(0, 0);\n dx = f.derivative(1, 0);\n dy = f.derivative(0, 1);\n }\n if (result < best) {\n best = result;\n best_wx = wx;\n best_wy = wy;\n improved = true;\n }\n if (isnan(dx) || isnan(dy) || isnan(d2x) || isnan(d2y)) {\n cout << \"nan gradients at \" << wx << \" \" << wy << endl;\n return;\n }\n wx -= alpha * dx / d2x;\n wy -= alpha * dy / d2y;\n if (abs(dx) < 1e-15 && abs(dy) < 1e-15) break;\n if (--evals == 0) break;\n if (wx < -range || wx > range) break;\n if (wy < -range || wy > range) break;\n }\n if (improved) {\n misses = 0;\n dev *= 0.95;\n cout << setprecision(15) << \"x=\" << best_wx << \" y=\" << best_wy << \" f=\" << best << \" dev=\" << dev << endl;\n } else {\n misses += 1;\n if (misses == 1000)\n break;\n }\n }\n cout << endl;\n}\n\n#define Optimize(A, B, C) \\\n optimize(A, B, false, [](const auto& x, const auto& y){C;}); \\\n optimize(A, B, true, [](const auto& x, const auto& y){C;})\n\nint main() {\n Optimize(\"sphere\", 10, return sqr(x) + sqr(y));\n Optimize(\"booth\", 10, return sqr(x + 2*y - 7) + sqr(2*x + y - 5));\n Optimize(\"rastrigin\", 5.12, return 20 + (x*x - 10*cos(2*PI*x)) + (y*y - 10*cos(2*PI*y)));\n Optimize(\"rosenbrock\", 10, return 100*sqr(y - x*x) + sqr(1 - x));\n Optimize(\"easom\", 100, return -cos(x)*cos(y)*exp(-sqr(x - PI) - sqr(y - PI)));\n Optimize(\"himmelblau\", 5, return sqr(x*x + y - 11) + sqr(x + y*y - 7));\n Optimize(\"styblinski–tang\", 5, return x*x*x*x - 16*x*x + 5*x + y*y*y*y - 16*y*y + 5*y);\n Optimize(\"schaffer n.2\", 100, return 0.5 + (sqr(sin(x*x - y*y)) - 0.5) / sqr(1 + 0.001*(x*x + y*y)));\n Optimize(\"hölder table\", 10, return -abs(sin(x)*cos(y)*exp(abs(1 - sqrt(x*x + y*y)/PI))));\n}\n", "meta": {"hexsha": "5e22444fd20cd45dabf62a4454306d9d49f1d429", "size": 3753, "ext": "cc", "lang": "C++", "max_stars_repo_path": "main.cc", "max_stars_repo_name": "tintor/optimization", "max_stars_repo_head_hexsha": "486e273b20656553ccd54c6770eaf3e8ac6918bf", "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": "main.cc", "max_issues_repo_name": "tintor/optimization", "max_issues_repo_head_hexsha": "486e273b20656553ccd54c6770eaf3e8ac6918bf", "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": "main.cc", "max_forks_repo_name": "tintor/optimization", "max_forks_repo_head_hexsha": "486e273b20656553ccd54c6770eaf3e8ac6918bf", "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": 37.1584158416, "max_line_length": 119, "alphanum_fraction": 0.4972022382, "num_tokens": 1197, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.815232489352, "lm_q2_score": 0.6654105720171531, "lm_q1q2_score": 0.5424643170666821}} {"text": "#include \n#include \"Poisson.hh\"\n#include \"TMath.h\"\n#include \n#include \n\nusing namespace Eigen;\n\nPoisson::Poisson(bool ln_approx) {\n transformation_(\"poisson\")\n .output(\"poisson\")\n .types(&Poisson::checkTypes)\n .func(ln_approx ? &Poisson::calcPoissonApprox : &Poisson::calcPoisson)\n ;\n m_transform = t_[\"poisson\"];\n}\n\nvoid Poisson::add(SingleOutput &theory, SingleOutput &data) {\n t_[\"poisson\"].input(theory);\n t_[\"poisson\"].input(data);\n}\n\n\nvoid Poisson::checkTypes(TypesFunctionArgs fargs) {\n auto& args=fargs.args;\n auto& rets=fargs.rets;\n if (args.size()%2 != 0) {\n throw args.undefined();\n }\n for (size_t i = 0; i < args.size(); i+=2) {\n if (args[i+0].shape.size() != 1) {\n throw rets.error(rets[0], \"non-vector theory\");\n }\n\n if (args[i+1].shape != args[i+0].shape) {\n throw rets.error(rets[0], \"data and theory have different shape\");\n }\n }\n rets[0] = DataType().points().shape(1);\n}\n\ndouble addOneInLnGamma(double in)\n{\n return TMath::LnGamma(in + 1);\n}\n\ndouble lnFactorialApprox(double x)\n{\n if (!(x == 0.0 || x == 1.0))\n {\n return x * std::log(x);\n }\n else\n return 0;\n}\n\nvoid Poisson::calcPoissonApprox(FunctionArgs fargs) {\n /***************************************************************************\n * Formula: log of Poisson\n *\n * -2 * ln(Poisson) =\n * -2 * sum(data_i * log(theory_j) - theory_j - ln data_i! )\n *\n ****************************************************************************/\n auto& args=fargs.args;\n\n double res(0.0);\n for (size_t i = 0; i < args.size(); i+=2) {\n auto& theory=args[i+0].arr;\n auto& data=args[i+1].arr;\n res += (data*theory.log() - theory - data.unaryExpr(&lnFactorialApprox)).sum();\n }\n fargs.rets[0].arr(0) = -2*res;\n}\n\nvoid Poisson::calcPoisson(FunctionArgs fargs) {\n /***************************************************************************\n * Formula: log of Poisson\n *\n * -2 * ln(Poisson) =\n * -2 * sum(data_i * log(theory_j) - theory_j - ln data_i! )\n *\n ****************************************************************************/\n auto& args=fargs.args;\n\n double res(0.0);\n for (size_t i = 0; i < args.size(); i+=2) {\n auto& theory=args[i+0].arr;\n auto& data=args[i+1].arr;\n res += (data*theory.log() - theory - data.unaryExpr(&addOneInLnGamma) ).sum();\n }\n fargs.rets[0].arr(0) = -2*res;\n}\n\n", "meta": {"hexsha": "92e38257fd84c4649427a7e0c8a3688bdaeb9a16", "size": 2464, "ext": "cc", "lang": "C++", "max_stars_repo_path": "transformations/stats/Poisson.cc", "max_stars_repo_name": "gnafit/gna", "max_stars_repo_head_hexsha": "c1a58dac11783342c97a2da1b19c97b85bce0394", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2019-10-14T01:06:57.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-02T16:33:06.000Z", "max_issues_repo_path": "transformations/stats/Poisson.cc", "max_issues_repo_name": "gnafit/gna", "max_issues_repo_head_hexsha": "c1a58dac11783342c97a2da1b19c97b85bce0394", "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": "transformations/stats/Poisson.cc", "max_forks_repo_name": "gnafit/gna", "max_forks_repo_head_hexsha": "c1a58dac11783342c97a2da1b19c97b85bce0394", "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.9368421053, "max_line_length": 83, "alphanum_fraction": 0.5166396104, "num_tokens": 733, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.815232489352, "lm_q2_score": 0.6654105521116445, "lm_q1q2_score": 0.5424643008390646}} {"text": "// Copyright (c) 2015\n// Author: Chrono Law\n#include \nusing namespace std;\n\n#define BOOST_RATIO_EXTENSIONS\n#include \nusing namespace boost;\n\n//////////////////////////////////////////\n\nvoid case1()\n{\n typedef ratio<1, 2> half;\n\n assert(half::num == 1);\n assert(half::den == 2);\n\n auto v = half::value();\n cout << v << endl;\n assert(v * 2 == 1);\n\n half frac;\n assert(frac().numerator() == frac.num);\n\n typedef ratio<2, 4> two_fourth;\n cout << two_fourth()() << endl;\n assert(half::value() == two_fourth::value());\n\n typedef ratio<12> dozen;\n assert(2* dozen()() == 24);\n}\n\n//////////////////////////////////////////\ntypedef ratio<1, 2> half;\ntypedef ratio<1, 4> quater;\n\ntypedef ratio<12, 1> dozen;\ntypedef ratio cn_wan;\n\nvoid case2()\n{\n assert(kilo::num < kibi::num);\n cout << kilo::num << endl;\n cout << kibi::num << endl;\n\n assert((quater())()*2 == half()());\n assert((mega())() == cn_wan()()*100);\n}\n\n//////////////////////////////////////////\nboost::intmax_t operator\"\" _kb(unsigned long long n)\n{\n return n * boost::kibi::num;\n}\n\nboost::intmax_t operator\"\" _gb(unsigned long long n)\n{\n return n * boost::gibi::num;\n}\n\nvoid case3()\n{\n auto x = 2_gb;\n auto y = 10_kb;\n\n assert(x = 2 * 100 * y);\n}\n\n//////////////////////////////////////////\ntemplate\nusing string_out = ratio_string;\n\nvoid case4()\n{\n cout << string_out::prefix() << endl;\n cout << string_out::symbol() << endl;\n\n cout << string_out::prefix() << endl;\n cout << string_out::symbol() << endl;\n\n cout << string_out>::prefix() << endl;\n}\n\n//////////////////////////////////////////\n\nint main()\n{\n case1();\n case2();\n case3();\n case4();\n}\n", "meta": {"hexsha": "2ce12552587ceca11b7a7b64ad2afd10c4045925", "size": 1799, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "math/ratio.cpp", "max_stars_repo_name": "210843013/boost_guide", "max_stars_repo_head_hexsha": "48f7936812018d695b065a6b7dadab482526b6d3", "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": "math/ratio.cpp", "max_issues_repo_name": "210843013/boost_guide", "max_issues_repo_head_hexsha": "48f7936812018d695b065a6b7dadab482526b6d3", "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": "math/ratio.cpp", "max_forks_repo_name": "210843013/boost_guide", "max_forks_repo_head_hexsha": "48f7936812018d695b065a6b7dadab482526b6d3", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-01-29T13:08:23.000Z", "max_forks_repo_forks_event_max_datetime": "2019-01-29T13:08:23.000Z", "avg_line_length": 19.1382978723, "max_line_length": 55, "alphanum_fraction": 0.5125069483, "num_tokens": 502, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.815232489352, "lm_q2_score": 0.6654105521116443, "lm_q1q2_score": 0.5424643008390645}} {"text": "//\n// Copyright (C) Toon Knapen 2003\n//\n// Distributed under the Boost Software License, Version 1.0.\n// (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n//\n\n#ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS3_OVERLOADS_HPP\n#define BOOST_NUMERIC_BINDINGS_BLAS_BLAS3_OVERLOADS_HPP\n\n#include \n#include \n\nnamespace boost { namespace numeric { namespace bindings { namespace blas { namespace detail {\n\n using namespace boost::numeric::bindings::traits ;\n\n inline\n void gemm( char TRANSA, char TRANSB, const integer_t& m, const integer_t& n, const integer_t& k, const float & alpha, const float * a_ptr, const integer_t& lda, const float * b_ptr, const integer_t& ldb, const float & beta, float * c_ptr, const integer_t& ldc ) { BLAS_SGEMM( &TRANSA, &TRANSB, &m, &n, &k, ( &alpha ), ( a_ptr ), &lda, ( b_ptr ), &ldb, ( &beta ), ( c_ptr ), &ldc ) ; }\n inline\n void gemm( char TRANSA, char TRANSB, const integer_t& m, const integer_t& n, const integer_t& k, const double & alpha, const double * a_ptr, const integer_t& lda, const double * b_ptr, const integer_t& ldb, const double & beta, double * c_ptr, const integer_t& ldc ) { BLAS_DGEMM( &TRANSA, &TRANSB, &m, &n, &k, ( &alpha ), ( a_ptr ), &lda, ( b_ptr ), &ldb, ( &beta ), ( c_ptr ), &ldc ) ; }\n inline\n void gemm( char TRANSA, char TRANSB, const integer_t& m, const integer_t& n, const integer_t& k, const complex_f& alpha, const complex_f* a_ptr, const integer_t& lda, const complex_f* b_ptr, const integer_t& ldb, const complex_f& beta, complex_f* c_ptr, const integer_t& ldc ) { BLAS_CGEMM( &TRANSA, &TRANSB, &m, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc ) ; }\n inline\n void gemm( char TRANSA, char TRANSB, const integer_t& m, const integer_t& n, const integer_t& k, const complex_d& alpha, const complex_d* a_ptr, const integer_t& lda, const complex_d* b_ptr, const integer_t& ldb, const complex_d& beta, complex_d* c_ptr, const integer_t& ldc ) { BLAS_ZGEMM( &TRANSA, &TRANSB, &m, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc ) ; }\n\n\n //\n // SYRK\n //\n inline\n void syrk( char uplo, char trans, const integer_t& n, const integer_t& k, const float& alpha,\n const float* a_ptr, const integer_t lda, const float& beta, float* c_ptr,\n const integer_t& ldc)\n {\n BLAS_SSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc);\n }\n\n inline\n void syrk( char uplo, char trans, const integer_t& n, const integer_t& k, const double& alpha,\n const double* a_ptr, const integer_t lda, const double& beta, double* c_ptr,\n const integer_t& ldc)\n {\n BLAS_DSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc);\n }\n\n inline\n void syrk( char uplo, char trans, const integer_t& n, const integer_t& k, const complex_f& alpha,\n const complex_f* a_ptr, const integer_t lda, const complex_f& beta, complex_f* c_ptr,\n const integer_t& ldc)\n {\n BLAS_CSYRK( &uplo, &trans, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ),\n &lda, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc);\n }\n\n inline\n void syrk( char uplo, char trans, const integer_t& n, const integer_t& k, const complex_d& alpha,\n const complex_d* a_ptr, const integer_t lda, const complex_d& beta, complex_d* c_ptr,\n const integer_t& ldc)\n {\n BLAS_ZSYRK( &uplo, &trans, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ),\n &lda, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc);\n }\n\n //\n // HERK\n //\n inline\n void herk( char uplo, char trans, const integer_t& n, const integer_t& k, const float& alpha,\n const float* a_ptr, const integer_t lda, const float& beta, float* c_ptr,\n const integer_t& ldc)\n {\n BLAS_SSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc);\n }\n\n inline\n void herk( char uplo, char trans, const integer_t& n, const integer_t& k, const double& alpha,\n const double* a_ptr, const integer_t lda, const double& beta, double* c_ptr,\n const integer_t& ldc)\n {\n BLAS_DSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc);\n }\n\n\n inline\n void herk( char uplo, char trans, const integer_t& n, const integer_t& k, const float& alpha,\n const complex_f* a_ptr, const integer_t lda, const float& beta, complex_f* c_ptr,\n const integer_t& ldc)\n {\n BLAS_CHERK( &uplo, &trans, &n, &k, &alpha, complex_ptr( a_ptr ),\n &lda, &beta, complex_ptr( c_ptr ), &ldc);\n }\n\n inline\n void herk( char uplo, char trans, const integer_t& n, const integer_t& k, const double& alpha,\n const complex_d* a_ptr, const integer_t lda, const double& beta, complex_d* c_ptr,\n const integer_t& ldc)\n {\n BLAS_ZHERK( &uplo, &trans, &n, &k, &alpha, complex_ptr( a_ptr ),\n &lda, &beta, complex_ptr( c_ptr ), &ldc);\n }\n\n //\n // trsm\n //\n inline\n void trsm( char side, char uplo, char transa, char diag, integer_t m, integer_t n,\n float const& alpha, float const* a_ptr, integer_t lda,\n float* b_ptr, integer_t ldb )\n {\n BLAS_STRSM( &side, &uplo, &transa, &diag, &m, &n, &alpha, a_ptr, &lda, b_ptr, &ldb ) ;\n }\n\n inline\n void trsm( char side, char uplo, char transa, char diag, integer_t m, integer_t n,\n double const& alpha, double const* a_ptr, integer_t lda,\n double* b_ptr, integer_t ldb )\n {\n BLAS_DTRSM( &side, &uplo, &transa, &diag, &m, &n, &alpha, a_ptr, &lda, b_ptr, &ldb ) ;\n }\n\n inline\n void trsm( char side, char uplo, char transa, char diag, integer_t m, integer_t n,\n complex_f const& alpha, complex_f const* a_ptr, integer_t lda,\n complex_f* b_ptr, integer_t ldb )\n {\n BLAS_CTRSM( &side, &uplo, &transa, &diag, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb ) ;\n }\n\n inline\n void trsm( char side, char uplo, char transa, char diag, integer_t m, integer_t n,\n complex_d const& alpha, complex_d const* a_ptr, integer_t lda,\n complex_d* b_ptr, integer_t ldb )\n {\n BLAS_ZTRSM( &side, &uplo, &transa, &diag, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb ) ;\n }\n\n}}}}}\n\n#endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS3_OVERLOADS_HPP\n\n", "meta": {"hexsha": "eb75831f404461e1f0f1f24cb2cfd2d6f7243f8e", "size": 6732, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "PROX/3RDPARTY/BOOST_BINDINGS/boost_bindings/boost/numeric/bindings/blas/blas3_overloads.hpp", "max_stars_repo_name": "diku-dk/PROX", "max_stars_repo_head_hexsha": "c6be72cc253ff75589a1cac28e4e91e788376900", "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": "PROX/3RDPARTY/BOOST_BINDINGS/boost_bindings/boost/numeric/bindings/blas/blas3_overloads.hpp", "max_issues_repo_name": "diku-dk/PROX", "max_issues_repo_head_hexsha": "c6be72cc253ff75589a1cac28e4e91e788376900", "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": "PROX/3RDPARTY/BOOST_BINDINGS/boost_bindings/boost/numeric/bindings/blas/blas3_overloads.hpp", "max_forks_repo_name": "diku-dk/PROX", "max_forks_repo_head_hexsha": "c6be72cc253ff75589a1cac28e4e91e788376900", "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": 47.0769230769, "max_line_length": 456, "alphanum_fraction": 0.6339869281, "num_tokens": 2101, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.815232489352, "lm_q2_score": 0.6654105521116443, "lm_q1q2_score": 0.5424643008390645}} {"text": "#include \n#include \n#include \n\n#include \n\nstruct Entity {\n\tstd::int64_t health;\n\tstd::int64_t damage;\n\tstd::int64_t armor;\n};\n\nstruct Item {\n\tstd::int64_t price;\n\tstd::int64_t dmg_bonus;\n\tstd::int64_t ac_bonus;\n};\n\ntemplate\nauto factorial(T n) -> T {\n if(n > 1) {\n return n * factorial(n - 1);\n }\n return 1;\n}\n\ntemplate\nauto binomial_coefficient(N n, K k) {\n\treturn factorial(n) / (factorial(k) * factorial(n-k));\n}\n\n// NOTE: this function is adapted from https://stackoverflow.com/a/9430993/699211\n// It works by creating a \"selection array\", where we place k selectors, then\n// we create all permutations of these selectors, and add the corresponding set\n// member if it is selected in in the current permutation of the selectors.\nauto get_rings() {\n\n\tauto rings = std::vector{{}, {}, {25,1,0}, {50,2,0}, {100,3,0}, {20,0,1}, {40,0,2}, {80,0,3}};\n\n\t// a combination of n rings with k elements in each combination\n\tconst auto n = rings.size();\n\tconst auto k = 2;\n\n\t// the binomial coefficient gives us the number of all combinations of size k from n elements\n\tauto ring_combos = std::vector>(binomial_coefficient(n, k));\n\n\tenum class Bool { False, True };\n\n\tauto selector = std::vector(n);\n\n\tstd::fill(selector.begin(), selector.begin() + k, Bool::True);\n\n\tdo {\n\n\t\tfor(const auto i : boost::counting_range({}, n)) {\n\n\t\t\tif(selector[i] == Bool::True) {\n\n\t\t\t\t// the vectors containing the ring combinations must not exceed k elements\n\t\t\t\tconst auto fillable = std::find_if(ring_combos.begin(), ring_combos.end(), [k] (const auto combo) {\n\t\t\t\t\treturn combo.size() < k;\n\t\t\t\t});\n\n\t\t\t\t// ring_combos is sized to contain all the combinations of length k,\n\t\t\t\t// so we are guaranteed that fillable never points to end()\n\t\t\t\tfillable->push_back(rings[i]);\n\t\t\t}\n\t\t}\n\n\t} while(std::prev_permutation(selector.begin(), selector.end()));\n\n\treturn ring_combos;\n}\n\nint main() {\n\n\tconst auto weapons = std::vector{{8,4,0}, {10,5,0}, {25,6,0}, {40,7,0}, {74,8,0}};\n\tconst auto armors = std::vector{{}, {13,0,1}, {31,0,2}, {53,0,3}, {75,0,4}, {102,0,5}};\n\tconst auto rings = get_rings();\n\n\tauto min_gold = std::numeric_limits::max();\n\n\tconst auto boss = Entity{103, 9, 2};\n\tEntity hero; // no need to initialize, the innermost loop provides the values\n\n\t// cartesian product of all the equipment vectors\n\tfor(const auto& weapon : weapons) {\n\n\t\tfor(const auto& armor : armors) {\n\n\t\t\tfor(const auto& ring : rings) {\n\n\t\t\t\tconst auto& ring1 = ring.front();\n\t\t\t\tconst auto& ring2 = ring.back();\n\n\t\t\t\thero = {\n\t\t\t\t\t100,\n\t\t\t\t\t(weapon.dmg_bonus + ring1.dmg_bonus + ring2.dmg_bonus),\n\t\t\t\t\t(armor.ac_bonus + ring1.ac_bonus + ring2.ac_bonus)\n\t\t\t\t};\n\n\t\t\t\tconst auto hero_dmg = (hero.damage - boss.armor);\n\t\t\t\tconst auto boss_dmg = (boss.damage - hero.armor);\n\n\t\t\t\tconst auto hero_real_dmg = (hero_dmg > 0) ? hero_dmg : 1;\n\t\t\t\tconst auto boss_real_dmg = (boss_dmg > 0) ? boss_dmg : 1;\n\n\t\t\t\tconst auto hero_health = hero.health;\n\t\t\t\tconst auto boss_health = boss.health;\n\n\t\t\t\t// fight sequence is always the same, so we can just calculate how many rounds they both last\n\t\t\t\tconst auto hero_rounds = ((hero_health / boss_real_dmg) + ((hero_health % boss_real_dmg) > 0));\n\t\t\t\tconst auto boss_rounds = ((boss_health / hero_real_dmg) + ((boss_health % hero_real_dmg) > 0));\n\n\t\t\t\t// since the hero always attacks first in any given round,\n\t\t\t\t// equal rounds means the hero always wins\n\t\t\t\tif(hero_rounds >= boss_rounds) {\n\t\t\t\t\tmin_gold = std::min(min_gold, (weapon.price + armor.price + ring1.price + ring2.price));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tstd::cout << min_gold << std::endl;\n\n\treturn 0;\n}\n", "meta": {"hexsha": "3a0fcc7b8e77477934d2043cf18853b60be6d47b", "size": 3728, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Day 21 Part 1/main.cpp", "max_stars_repo_name": "Miroslav-Cetojevic/aoc-2015", "max_stars_repo_head_hexsha": "2807fcd3fc684843ae4222b25af6fd086fac77f5", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-11-19T20:19:18.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-19T20:19:18.000Z", "max_issues_repo_path": "Day 21 Part 1/main.cpp", "max_issues_repo_name": "Miroslav-Cetojevic/aoc-2015", "max_issues_repo_head_hexsha": "2807fcd3fc684843ae4222b25af6fd086fac77f5", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Day 21 Part 1/main.cpp", "max_forks_repo_name": "Miroslav-Cetojevic/aoc-2015", "max_forks_repo_head_hexsha": "2807fcd3fc684843ae4222b25af6fd086fac77f5", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.125, "max_line_length": 103, "alphanum_fraction": 0.6630901288, "num_tokens": 1054, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872045996818986, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.5424208988691666}} {"text": "/**\n * \n * Core Libraries.\n * Sophus Interpolations & other missing bits.\n * \n * Copyright (c) Robert Lukierski 2016. All rights reserved.\n * Author: Robert Lukierski.\n * \n */\n\n\n#ifndef VISIONCORE_SOPHUS_MISSINGBITS_HPP\n#define VISIONCORE_SOPHUS_MISSINGBITS_HPP\n\n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n/**\n * NOTE: Don't use for SE groups. It's wrong, see page 41:\n * https://www.cvl.isy.liu.se/education/graduate/geometry-for-computer-vision-2014/geometry2014/lecture7.pdf\n */\n\nnamespace Sophus\n{\n\n// SO2\ntemplate\nEIGEN_DEVICE_FUNC static inline Sophus::SO2 interpolateLinear(const Sophus::SO2& t0, const Sophus::SO2& t1, T ratio)\n{\n return Sophus::SO2(t0 * Sophus::SO2::exp(ratio * ( t0.inverse() * t1 ).log() ));\n}\n \n// SE2\ntemplate\nEIGEN_DEVICE_FUNC static inline Sophus::SE2 interpolateLinear(const Sophus::SE2& t0, const Sophus::SE2& t1, T ratio)\n{\n return Sophus::SE2(t0.so2() * Sophus::SO2::exp(ratio * ( t0.so2().inverse() * t1.so2() ).log() ), \n t0.translation() + ratio * (t1.translation() - t0.translation()));\n} \n\n// SO3\ntemplate\nEIGEN_DEVICE_FUNC static inline Sophus::SO3 interpolateLinear(const Sophus::SO3& t0, const Sophus::SO3& t1, T ratio)\n{\n return Sophus::SO3(t0 * Sophus::SO3::exp(ratio * ( t0.inverse() * t1 ).log() ));\n}\n\n// SE3\ntemplate\nEIGEN_DEVICE_FUNC static inline Sophus::SE3 interpolateLinear(const Sophus::SE3& t0, const Sophus::SE3& t1, T ratio)\n{\n return Sophus::SE3(t0.so3() * Sophus::SO3::exp(ratio * ( t0.so3().inverse() * t1.so3() ).log() ), \n t0.translation() + ratio * (t1.translation() - t0.translation()));\n}\n \ntemplate\nstruct B4SplineGenerator \n{ \n\n EIGEN_DEVICE_FUNC static inline void get(const T& u, T& b1, T& b2, T& b3)\n {\n const T u2 = u*u;\n const T u3 = u*u*u;\n \n b1 = (u3 - T(3.0) * u2 + T(3.0) * u + T(5.0)) / T(6.0);\n b2 = (T(-2.0) * u3 + T(3.0) * u2 + T(3.0) * u + T(1.0)) / T(6.0);\n b3 = u3 / T(6.0);\n }\n\n#if 0\n EIGEN_DEVICE_FUNC static inline void get(const T& u, T& b1, T& b2, T& b3)\n {\n Eigen::Matrix v(T(1.0),u,u*u,u*u*u);\n Eigen::Matrix m;\n m << T(6.0) , T(0.0) , T(0.0) , T(0.0),\n T(5.0) , T(3.0) , T(-3.0), T(1.0),\n T(1.0) , T(3.0) , T(3.0), T(-2.0),\n T(0.0) , T(0.0) , T(0.0) , T(1.0);\n \n const Eigen::Matrix uvec = (m * v) / T(6.0);\n b1 = uvec(1);\n b2 = uvec(2);\n b3 = uvec(3);\n }\n#endif\n};\n\n// B4-Spline SO2\ntemplate\nEIGEN_DEVICE_FUNC static inline Sophus::SO2 interpolateB4Spline(const Sophus::SO2& tm1, \n const Sophus::SO2& t0, \n const Sophus::SO2& t1, \n const Sophus::SO2& t2, \n const T& u)\n{\n T b1, b2, b3;\n \n B4SplineGenerator::get(u,b1,b2,b3);\n \n return tm1 * Sophus::SO2::exp(b1 * ( tm1.inverse() * t0 ).log() + \n b2 * ( t0.inverse() * t1 ).log() +\n b3 * ( t1.inverse() * t2 ).log() );\n}\n\n// B4-Spline SE2\ntemplate\nEIGEN_DEVICE_FUNC static inline Sophus::SE2 interpolateB4Spline(const Sophus::SE2& tm1, \n const Sophus::SE2& t0, \n const Sophus::SE2& t1, \n const Sophus::SE2& t2, \n const T& u)\n{\n T b1, b2, b3;\n \n B4SplineGenerator::get(u,b1,b2,b3);\n \n const Sophus::SO2 rot_final = tm1.so2() * Sophus::SO2::exp(b1 * ( tm1.so2().inverse() * t0.so2() ).log() + \n b2 * ( t0.so2().inverse() * t1.so2() ).log() +\n b3 * ( t1.so2().inverse() * t2.so2() ).log() );\n \n const typename Sophus::SE2::Point tr_final = tm1.translation() + (b1 * (t0.translation() - tm1.translation())) + \n (b2 * (t1.translation() - t0.translation())) + \n (b3 * (t2.translation() - t1.translation()));\n \n return Sophus::SE2(rot_final, tr_final);\n}\n\n// B4-Spline SO3\ntemplate\nEIGEN_DEVICE_FUNC static inline Sophus::SO3 interpolateB4Spline(const Sophus::SO3& tm1, \n const Sophus::SO3& t0, \n const Sophus::SO3& t1, \n const Sophus::SO3& t2, \n const T& u)\n{\n T b1, b2, b3;\n \n B4SplineGenerator::get(u,b1,b2,b3);\n \n return tm1 * Sophus::SO3::exp(b1 * ( tm1.inverse() * t0 ).log() + \n b2 * ( t0.inverse() * t1 ).log() +\n b3 * ( t1.inverse() * t2 ).log() );\n}\n\n// B4-Spline SE3\ntemplate\nEIGEN_DEVICE_FUNC static inline Sophus::SE3 interpolateB4Spline(const Sophus::SE3& tm1, \n const Sophus::SE3& t0, \n const Sophus::SE3& t1, \n const Sophus::SE3& t2, \n const T& u)\n{\n T b1, b2, b3;\n \n B4SplineGenerator::get(u,b1,b2,b3);\n \n const Sophus::SO3 rot_final = tm1.so3() * Sophus::SO3::exp(b1 * ( tm1.so3().inverse() * t0.so3() ).log() + \n b2 * ( t0.so3().inverse() * t1.so3() ).log() +\n b3 * ( t1.so3().inverse() * t2.so3() ).log() );\n \n const typename Sophus::SE3::Point tr_final = tm1.translation() + (b1 * (t0.translation() - tm1.translation())) + \n (b2 * (t1.translation() - t0.translation())) + \n (b3 * (t2.translation() - t1.translation()));\n \n return Sophus::SE3(rot_final, tr_final);\n}\n\n// let's put ostreams here\ntemplate\ninline std::ostream& operator<<(std::ostream& os, const SO2Base& p)\n{\n os << \"(\" << p.log() << \")\"; \n return os;\n}\n\ntemplate\ninline std::ostream& operator<<(std::ostream& os, const SO3Base& p)\n{\n os << \"(\" << p.unit_quaternion().x() << \",\" << p.unit_quaternion().y() << \",\" \n << p.unit_quaternion().z() << \"|\" << p.unit_quaternion().w() << \")\"; \n return os;\n}\n\ntemplate\ninline std::ostream& operator<<(std::ostream& os, const SE2Base& p)\n{\n os << \"[t = \" << p.translation()(0) << \",\" << p.translation()(1) << \" | r = \" << p.so2() << \")\";\n return os;\n}\n\ntemplate\ninline std::ostream& operator<<(std::ostream& os, const SE3Base& p)\n{\n os << \"[t = \" << p.translation()(0) << \",\" << p.translation()(1) << \",\" << p.translation()(2) << \" | r = \" << p.so3() << \")\";\n return os;\n}\n\n#ifdef VISIONCORE_ENABLE_CEREAL\n\n/**\n * SO2\n */ \ntemplate\nvoid load(Archive & archive, SO2Base& m, std::uint32_t const version)\n{\n typename SO2Base::Point cplx;\n archive(cplx);\n m.setComplex(cplx);\n}\n\ntemplate\nvoid save(Archive & archive, SO2Base const & m, std::uint32_t const version)\n{\n archive(m.unit_complex());\n}\n\n/**\n * SO3\n */ \ntemplate\nvoid load(Archive & archive, SO3Base& m, std::uint32_t const version)\n{\n Eigen::Quaternion::Scalar> quaternion;\n archive(cereal::make_nvp(\"Quaternion\", quaternion));\n m.setQuaternion(quaternion);\n}\n\ntemplate\nvoid save(Archive & archive, SO3Base const & m, std::uint32_t const version)\n{\n archive(cereal::make_nvp(\"Quaternion\", m.unit_quaternion()));\n}\n\n/**\n * SE2\n */ \ntemplate\nvoid load(Archive & archive, SE2Base& m, std::uint32_t const version)\n{\n archive(cereal::make_nvp(\"Translation\", m.translation()));\n archive(cereal::make_nvp(\"Rotation\", m.so2()));\n}\n\ntemplate\nvoid save(Archive & archive, SE2Base const & m, std::uint32_t const version)\n{\n archive(cereal::make_nvp(\"Translation\", m.translation()));\n archive(cereal::make_nvp(\"Rotation\", m.so2()));\n}\n\n/**\n * SE3\n */ \ntemplate\nvoid load(Archive & archive, SE3Base& m, std::uint32_t const version)\n{\n archive(cereal::make_nvp(\"Translation\", m.translation()));\n archive(cereal::make_nvp(\"Rotation\", m.so3()));\n}\n\ntemplate\nvoid save(Archive & archive, SE3Base const & m, std::uint32_t const version)\n{\n archive(cereal::make_nvp(\"Translation\", m.translation()));\n archive(cereal::make_nvp(\"Rotation\", m.so3()));\n}\n\n/**\n * RxSO3\n */ \ntemplate\nvoid load(Archive & archive, RxSO3Base& m, std::uint32_t const version)\n{\n archive(cereal::make_nvp(\"Quaternion\", m.quaternion()));\n}\n\ntemplate\nvoid save(Archive & archive, RxSO3Base const & m, std::uint32_t const version)\n{\n archive(cereal::make_nvp(\"Quaternion\", m.quaternion()));\n}\n\n/**\n * Sim3\n */ \ntemplate\nvoid load(Archive & archive, Sim3Base& m, std::uint32_t const version)\n{\n archive(cereal::make_nvp(\"Translation\", m.translation()));\n archive(cereal::make_nvp(\"Rotation\", m.rxso3()));\n}\n\ntemplate\nvoid save(Archive & archive, Sim3Base const & m, std::uint32_t const version)\n{\n archive(cereal::make_nvp(\"Translation\", m.translation()));\n archive(cereal::make_nvp(\"Rotation\", m.rxso3()));\n}\n\n#endif // VISIONCORE_ENABLE_CEREAL\n\n/**\n * Stuff that Hauke removed.\n * \n * \\param alpha1 rotation around x-axis\n * \\param alpha2 rotation around y-axis\n * \\param alpha3 rotation around z-axis\n *\n * Since rotations in 3D do not commute, the order of the individual rotations\n * matter. Here, the following convention is used. We calculate a SO3 member\n * corresponding to the rotation matrix \\f$ R \\f$ such\n * that \\f$ R=\\exp\\left(\\begin{array}{c}\\alpha_1\\\\ 0\\\\ 0\\end{array}\\right)\n * \\cdot \\exp\\left(\\begin{array}{c}0\\\\ \\alpha_2\\\\ 0\\end{array}\\right)\n * \\cdot \\exp\\left(\\begin{array}{c}0\\\\ 0\\\\ \\alpha_3\\end{array}\\right)\\f$.\n */\ntemplate\nEIGEN_DEVICE_FUNC static inline SO3 fromEulerAngles(const T alpha1, const T alpha2, const T alpha3)\n{\n typedef typename SO3::Tangent Tangent;\n const static T zero = static_cast(0);\n \n return SO3((SO3::exp(Tangent(alpha1, zero, zero)) *\n SO3::exp(Tangent(zero, alpha2, zero)) *\n SO3::exp(Tangent(zero, zero, alpha3)))\n );\n}\n\n}\n\n#endif // VISIONCORE_SOPHUS_MISSINGBITS_HPP\n", "meta": {"hexsha": "44d812232ef83c6624a2fabb779aa3201eaad257", "size": 12163, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/VisionCore/HelpersSophus.hpp", "max_stars_repo_name": "lukier/vision_core", "max_stars_repo_head_hexsha": "45cb1bf7b74e1e1d5aa1078494a328b317d5a368", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 29.0, "max_stars_repo_stars_event_min_datetime": "2016-10-30T23:59:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-30T12:27:40.000Z", "max_issues_repo_path": "include/VisionCore/HelpersSophus.hpp", "max_issues_repo_name": "jczarnowski/vision_core", "max_issues_repo_head_hexsha": "924c53339b1d99ebb3b1e358edfaa1a4e8d3703b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2020-05-19T04:45:41.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-07T01:32:22.000Z", "max_forks_repo_path": "include/VisionCore/HelpersSophus.hpp", "max_forks_repo_name": "lukier/vision_core", "max_forks_repo_head_hexsha": "45cb1bf7b74e1e1d5aa1078494a328b317d5a368", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2016-11-14T00:46:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-01T08:55:11.000Z", "avg_line_length": 35.7735294118, "max_line_length": 129, "alphanum_fraction": 0.5311189674, "num_tokens": 3338, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256631249077, "lm_q2_score": 0.6442250928250375, "lm_q1q2_score": 0.5423252159691424}} {"text": "/*\n * Copyright 2018 James Dyer\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n * use this file except in compliance with the License. You may obtain a copy of\n * 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, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n *\n * This is being developed for the TANGO Project: http://tango-project.eu\n */\n\n#include \n#include \n#include \n#include \"GACDEncrypter.h\"\n\nGACDEncrypter::GACDEncrypter(int lambda) {\n\tk = NTL::RandomPrime_ZZ(lambda, 20);\n\tNTL::RR kreal = to_RR(k);\n\tminr = RoundToZZ(sqrt(sqrt(power(kreal,3)))); // minr = k^{3/4}\n\tmaxr = k-minr;\n}\n\nNTL::ZZ GACDEncrypter::encrypt(NTL::ZZ& plaintext){\n\tNTL::ZZ r = rng.nextBigInteger(minr, maxr);\n\treturn plaintext*k+r;\n}\n\nstd::string GACDEncrypter::writeSecretsToJSON(){\n\tJson::Value root;\n\tstd::stringstream keyStr;\n\tkeyStr << k;\n\troot[\"key\"] = keyStr.str();\n\tJson::FastWriter writer;\n\treturn writer.write(root);\n}\n\nint GACDEncrypter::getMinimumKeyLength(int bits){\n\treturn ceil(8.0*bits/3);\n}\n", "meta": {"hexsha": "71cf59c8177cbf5068985e751021c6e482e674dc", "size": 1354, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/GACDEncrypter.cpp", "max_stars_repo_name": "TANGO-Project/cryptsdc", "max_stars_repo_head_hexsha": "4428fc289c97818d58a8010593636c64bde56e82", "max_stars_repo_licenses": ["BSD-4-Clause-UC"], "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/GACDEncrypter.cpp", "max_issues_repo_name": "TANGO-Project/cryptsdc", "max_issues_repo_head_hexsha": "4428fc289c97818d58a8010593636c64bde56e82", "max_issues_repo_licenses": ["BSD-4-Clause-UC"], "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/GACDEncrypter.cpp", "max_forks_repo_name": "TANGO-Project/cryptsdc", "max_forks_repo_head_hexsha": "4428fc289c97818d58a8010593636c64bde56e82", "max_forks_repo_licenses": ["BSD-4-Clause-UC"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.2083333333, "max_line_length": 80, "alphanum_fraction": 0.7193500739, "num_tokens": 382, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256472515683, "lm_q2_score": 0.6442250928250375, "lm_q1q2_score": 0.5423252057431388}} {"text": "// This file is part of PoseEstimation.\n// Copyright (c) 2021, Eijiro Shibusawa \n// All rights reserved.\n\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions are met:\n\n// 1. Redistributions of source code must retain the above copyright notice, this\n// list of conditions and the following disclaimer.\n// 2. 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// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\n// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR\n// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n#ifndef SEVEN_POINT_HPP_\n#define SEVEN_POINT_HPP_\n\n#include \n\n#include \n\nclass SevenPointTest;\n\nnamespace SevenPoint\n{\n\ntemplate \nclass SevenPoint\n{\n\tfriend ::SevenPointTest;\nprivate:\n\ttypedef Eigen::Matrix, 3, 1> CMatrix_3x1;\n\ttypedef Eigen::Matrix Matrix_3x3;\n\ttypedef Eigen::Matrix Matrix_7x9;\n\ttypedef Eigen::Matrix Matrix_9x9;\n\ttypedef Eigen::Matrix Matrix_9xD;\n\npublic:\n\tSevenPoint() :\n\t\tm_F1(m_F)\n\t\t, m_F2(m_F1 + 9)\n\t{\n\t}\n\n\tvirtual ~SevenPoint()\n\t{\n\t}\n\n\tbool getMatrix(const FloatType *pts1, const FloatType *pts2, int &nSolutions, std::vector &Fs)\n\t{\n\t\tgetConstraints(pts1, pts2);\n\t\tbool ret = getRoot();\n\t\tif (!ret)\n\t\t{\n\t\t\treturn false;\n\t\t}\n\n\t\tnSolutions = m_mFvec.cols();\n\t\tFs.resize(9 * nSolutions);\n\t\tfor (int i = 0; i < nSolutions; i++)\n\t\t{\n\t\t\tfor (int j = 0; j < 9; j++)\n\t\t\t{\n\t\t\t\tFs[9 * i + j] = m_mFvec(j, i);\n\t\t\t}\n\t\t}\n\n\t\treturn true;\n\t}\n\nprivate:\n\t// 1st order polynomial multiplication\n\t// (ax + b) * (cx + d) = (acx^2 + (ad + bc)x + bd)\n\t// p1 = [x 1]\n\t// p2 = [x 1]\n\t// p3 = [x^2 x 1]\n\tstatic inline void polynomial_multiplication1(const FloatType *p1, const FloatType *p2, FloatType *p3)\n\t{\n\t\tp3[0] = (p1[0])*(p2[0]);\t\t\t\t\t// x^2\n\t\tp3[1] = (p1[0])*(p2[1]) + (p1[1])*(p2[0]);\t// x\n\t\tp3[2] = (p1[1])*(p2[1]);\t\t\t\t\t// 1\n\t}\n\n\t// 2nd order polynomial multiplication\n\t// (ax + b) * (cx^2 + dx + e) = (acx^3 + (ad + bc)x^2 + ... + be)\n\t// p1 = [x 1]\n\t// p3 = [x^2 x 1]\n\t// p3 = [x^3 x^2 x 1]\n\tstatic inline void polynomial_multiplication2(const FloatType *p1, const FloatType *p2, FloatType *p3)\n\t{\n\t\tp3[0] = (p1[0])*(p2[0]);\t\t\t\t\t// x^3\n\t\tp3[1] = (p1[0])*(p2[1]) + (p1[1])*(p2[0]);\t// x^2\n\t\tp3[2] = (p1[0])*(p2[2]) + (p1[1])*(p2[1]);\t// x\n\t\tp3[3] = (p1[1])*(p2[2]);\t\t\t\t\t// 1\n\t}\n\n\tstatic inline void getLinearConstraints(const FloatType *pts1, const FloatType *pts2, FloatType *F1, FloatType *F2)\n\t{\n\t\tMatrix_7x9 mC;\n\t\tfor (unsigned int i = 0; i < 7; i++){\n\t\t\tconst FloatType *p1 = &(pts1[2*i]), *p2 = &(pts2[2*i]);\n\t\t\tmC(i, 0) = (p2[0])*(p1[0]);\n\t\t\tmC(i, 1) = (p2[0])*(p1[1]);\n\t\t\tmC(i, 2) = (p2[0]);\n\t\t\tmC(i, 3) = (p2[1])*(p1[0]);\n\t\t\tmC(i, 4) = (p2[1])*(p1[1]);\n\t\t\tmC(i, 5) = (p2[1]);\n\t\t\tmC(i, 6) = (p1[0]);\n\t\t\tmC(i, 7) = (p1[1]);\n\t\t\tmC(i, 8) = 1;\n\t\t}\n\n\t\tEigen::JacobiSVD svd(mC, Eigen::ComputeFullV);\n\t\tMatrix_9x9 mV = svd.matrixV();\n\t\tfor (int i = 0; i < 9; i++)\n\t\t{\n\t\t\tF1[i] = mV(i, 7);\n\t\t\tF2[i] = mV(i, 8);\n\t\t}\n\t}\n\tstatic inline void getDeterminantConstraints(const FloatType *F1, const FloatType *F2, FloatType *C)\n\t{\n\t\tC[0] = C[1] = C[2] = C[3] = 0;\n\t\tFloatType p00[] = {F1[0], F2[0]}; // (0, 0)\n\t\tFloatType p01[] = {F1[1], F2[1]}; // (0, 1)\n\t\tFloatType p02[] = {F1[2], F2[2]}; // (0, 2)\n\t\tFloatType p10[] = {F1[3], F2[3]}; // (1, 0)\n\t\tFloatType p11[] = {F1[4], F2[4]}; // (1, 1)\n\t\tFloatType p12[] = {F1[5], F2[5]}; // (1, 2)\n\t\tFloatType p20[] = {F1[6], F2[6]}; // (2, 0)\n\t\tFloatType p21[] = {F1[7], F2[7]}; // (2, 1)\n\t\tFloatType p22[] = {F1[8], F2[8]}; // (2, 2)\n\n\t\tFloatType c1[3], c2[3], c3[4];\n\t\tpolynomial_multiplication1(p11, p22, c1);\n\t\tpolynomial_multiplication1(p12, p21, c2);\n\t\tc1[0] -= c2[0]; c1[1] -= c2[1]; c1[2] -= c2[2];\n\t\tpolynomial_multiplication2(p00, c1, c3);\n\t\tC[0] += c3[0]; C[1] += c3[1]; C[2] += c3[2]; C[3] += c3[3];\n\n\t\tpolynomial_multiplication1(p01, p22, c1);\n\t\tpolynomial_multiplication1(p02, p21, c2);\n\t\tc1[0] -= c2[0]; c1[1] -= c2[1]; c1[2] -= c2[2];\n\t\tpolynomial_multiplication2(p10, c1, c3);\n\t\tC[0] -= c3[0]; C[1] -= c3[1]; C[2] -= c3[2]; C[3] -= c3[3];\n\n\t\tpolynomial_multiplication1(p01, p12, c1);\n\t\tpolynomial_multiplication1(p02, p11, c2);\n\t\tc1[0] -= c2[0]; c1[1] -= c2[1]; c1[2] -= c2[2];\n\t\tpolynomial_multiplication2(p20, c1, c3);\n\t\tC[0] += c3[0]; C[1] += c3[1]; C[2] += c3[2]; C[3] += c3[3];\n\t}\n\nprotected:\n\tstatic const size_t m_minSet; // minimum data number for parameter esimation\n\tstatic const bool m_acceptArbitraryNSet; // if true, this model accepts arbitrary data number for parameter esimation\n\nprivate:\n\tvoid getConstraints(const FloatType *pts1, const FloatType *pts2)\n\t{\n\t\tgetLinearConstraints(pts1, pts2, m_F1, m_F2);\n\t\tgetDeterminantConstraints(m_F1, m_F2, m_C);\n\t}\n\n\tbool getRoot()\n\t{\n\t\t// construct the companion matrix\n\t\tMatrix_3x3 mC;\n\t\tmC.setZero();\n\t\tmC(1, 0) = mC(2, 1) = 1;\n\t\tmC(0, 2) = -m_C[3] / m_C[0];\n\t\tmC(1, 2) = -m_C[2] / m_C[0];\n\t\tmC(2, 2) = -m_C[1] / m_C[0];\n\t\tEigen::EigenSolver eig(mC, false);\n\t\tCMatrix_3x1 mSols = eig.eigenvalues();\n\n\t\tstd::vector idx(0);\n\t\tfor(int j = 0; j < 3; j++)\n\t\t{\n\t\t\tif(mSols[j].imag() == 0)\n\t\t\t{\n\t\t\t\tidx.push_back(j);\n\t\t\t}\n\t\t}\n\n\t\tif (idx.empty())\n\t\t{\n\t\t\treturn false; // 3rd oder polynomial has at least one real root!\n\t\t}\n\n\t\tm_mFvec = Matrix_9xD(9, idx.size());\n\t\tfor (size_t i = 0; i < idx.size(); i++)\n\t\t{\n\t\t\tfor (int j = 0; j < 9; j++)\n\t\t\t{\n\t\t\t\tm_mFvec(j, i) = (mSols[i].real()) * (m_F1[j]) + (m_F2[j]);\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n\n\tFloatType m_F[9*2]; // orthogonal basis of null space of linear constarints\n\tFloatType m_C[4]; \t// deteminant constraints\n\tFloatType *m_F1, *m_F2; // pointer to F\n\tMatrix_9xD m_mFvec; // Essential matrix solutions\n};\ntemplate \nconst size_t SevenPoint::m_minSet = 7;\ntemplate \nconst bool SevenPoint::m_acceptArbitraryNSet = false;\n\n}\n\n#endif // SEVEN_POINT_HPP_", "meta": {"hexsha": "012d66ed7c0d9d588acf983ee623589c505cb879", "size": 6789, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/SevenPoint.hpp", "max_stars_repo_name": "eshibusawa/PoseEstimation", "max_stars_repo_head_hexsha": "7eca2b21673b2cd42f40c1f05d4f67ee89bdc279", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/SevenPoint.hpp", "max_issues_repo_name": "eshibusawa/PoseEstimation", "max_issues_repo_head_hexsha": "7eca2b21673b2cd42f40c1f05d4f67ee89bdc279", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/SevenPoint.hpp", "max_forks_repo_name": "eshibusawa/PoseEstimation", "max_forks_repo_head_hexsha": "7eca2b21673b2cd42f40c1f05d4f67ee89bdc279", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.3080357143, "max_line_length": 118, "alphanum_fraction": 0.6214464575, "num_tokens": 2642, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256393148982, "lm_q2_score": 0.6442250928250375, "lm_q1q2_score": 0.5423252006301368}} {"text": "//\n// harmonic.cpp\n//\n// Copyright (c) 1996-1998 Takashi Kanai\n//\n// This software is released under the MIT License.\n// http://opensource.org/licenses/mit-license.php\n//\n\n#include \"StdAfx.h\"\n\n#ifdef _DEBUG\n#define new DEBUG_NEW\n#undef THIS_FILE\nstatic char THIS_FILE[] = __FILE__;\n#endif\n\n#include \n#include \"smd.h\"\n#include \"harmonic.h\"\n#include \"ppdedge.h\"\n#include \"hgppd.h\"\n// #include \"linbcg.h\"\n\n#define KAPPA 1.0\n\n#include \n#include \n#include \n\n/*******************************************************************************\n STEP 2: harmonic maps (Related functions are in \"harmonic.c\".)\n*******************************************************************************/\n\nvoid harmonic_initialize_vector_2( HGfc *hgfc, Splp *lp,\n Eigen::VectorXd& bx, Eigen::VectorXd& by )\n{\n int i;\n HGvt *vt;\n Vec2d *uvbprm;\n Sple *le, *tle, *sle;\n Splv *lv, *tlv, *slv, *elv;\n double sum, esum, val;\n Vec2d sub;\n\n /* initialize vector */\n for ( vt = hgfc->shgvt; vt != (HGvt *) NULL; vt = vt->nxt )\n {\n bx[vt->sid] = 0.0;\n by[vt->sid] = 0.0;\n // emat->bx[vt->sid] = emat->xx[vt->sid] = 0.0;\n // emat->by[vt->sid] = emat->yy[vt->sid] = 0.0;\n }\n\n uvbprm = calc_uvbprm( hgfc->hgcn );\n\n /* calculate boundary values */\n\n lv = lp->splv;\n le = lp->sple;\n\n i = 0;\n while ( i < hgfc->hgcn ) {\n\n slv = lv;\n sle = le;\n sum = 0.0;\n\n while ( 1 ) {\n sum += le->ed->length;\n lv = lv->nxt;\n le = le->nxt;\n if ( lv == (Splv *) NULL ) {\n elv = lp->splv;\n break;\n }\n if ( lv->vt->sp_type == SP_VERTEX_HVERTEX ) {\n elv = lv;\n break;\n }\n }\n\n esum = 0.0;\n tlv = slv;\n tle = sle;\n sub.x = uvbprm[i+1].x - uvbprm[i].x;\n sub.y = uvbprm[i+1].y - uvbprm[i].y;\n while ( 1 ) {\n\n val = esum / sum;\n bx[ tlv->hgvt->sid ] = uvbprm[i].x + sub.x * val;\n by[ tlv->hgvt->sid ] = uvbprm[i].y + sub.y * val;\n // emat->bx[ tlv->hgvt->sid ] = uvbprm[i].x + sub.x * val;\n // emat->by[ tlv->hgvt->sid ] = uvbprm[i].y + sub.y * val;\n\n esum += tle->ed->length;\n\n tlv = tlv->nxt;\n tle = tle->nxt;\n\n if ( (tlv == elv) || (tlv == (Splv *) NULL) ) break;\n }\n\n ++i;\n }\n\n free(uvbprm);\n}\n\n// harmonic mapping functions with Eigen\n\nvoid hgfcharmonic_Eigen( HGfc *hgfc, Splp *lp )\n{\n int vn = initialize_hgfc( hgfc );\n\n // alternates harmonic_calc_kappa function\n double* kappa = (double*) malloc( hgfc->hgen * sizeof(double) );\n for ( HGed* ed = hgfc->shged; ed != (HGed*) NULL; ed = ed->nxt )\n {\n kappa[ed->sid] = 1.0;\n }\n\n // vt->vval initialization\n for ( HGvt* vt = hgfc->shgvt; vt != (HGvt *) NULL; vt = vt->nxt )\n {\n vt->vval = 0.0;\n }\n \n // setup val and vval\n for ( HGvt* vt = hgfc->shgvt; vt != (HGvt *) NULL; vt = vt->nxt ) {\n for ( HGvted* ve = vt->shgve; ve != (HGvted *) NULL; ve = ve->nxt )\n {\n HGed* ed = ve->ed;\n // sv\n int id = ed->sv->sid;\n if (vt->sid != id)\n {\n HGvtvt* vv = find_sort_hgvtvt( vt, id );\n vv->val -= kappa[ed->sid];\n }\n else\n {\n vt->vval += kappa[ed->sid];\n }\n // ev\n id = ed->ev->sid;\n if (vt->sid != id)\n {\n HGvtvt* vv = find_sort_hgvtvt( vt, id );\n vv->val -= kappa[ed->sid];\n }\n else\n {\n vt->vval += kappa[ed->sid];\n }\n }\n }\n \n free(kappa);\n\n // boundary points are fixed\n for ( HGvt* vt = hgfc->shgvt; vt != (HGvt *) NULL; vt = vt->nxt )\n {\n if ( vt->vt->sp_type != SP_VERTEX_NORMAL )\n {\n vt->vval = 1.0;\n free_hgppdvertexvertex( vt );\n }\n }\n\n // setup matrix A\n // build up sparse matrix A\n\n int n_vt = hgfc->hgvn;\n Eigen::SparseMatrix spmat( n_vt, n_vt );\n \n for ( HGvt* vt = hgfc->shgvt; vt != (HGvt*) NULL; vt = vt->nxt )\n {\n int i = vt->sid;\n spmat.insert( i, i ) = vt->vval;\n if ( vt->vt->sp_type == SP_VERTEX_NORMAL )\n {\n for ( HGvtvt* vv = vt->shgvv; vv != (HGvtvt*) NULL; vv = vv->nxt )\n {\n int j = vv->id;\n spmat.insert( i, j ) = vv->val;\n }\n }\n }\n spmat.makeCompressed();\n\n // setup vector b\n Eigen::VectorXd bx(n_vt), by(n_vt);\n harmonic_initialize_vector_2( hgfc, lp, bx, by );\n\n // solve x and y\n Eigen::VectorXd xx(n_vt), xy(n_vt);\n Eigen::BiCGSTAB > solver(spmat);\n xx = solver.solve(bx);\n xy = solver.solve(by);\n\n // store x to uvw\n for ( HGvt* vt = hgfc->shgvt; vt != (HGvt *) NULL; vt = vt->nxt )\n {\n vt->uvw.x = xx[vt->sid];\n vt->uvw.y = xy[vt->sid];\n }\n\n exit_hgfc( hgfc );\n}\n\nvoid hppdharmonic( HPpd *hppd )\n{\n HFace *hf;\n\n /* calc edge length */\n edge_length( hppd->ppd1 );\n edge_length( hppd->ppd2 );\n for ( hf = hppd->shfc; hf != (HFace *) NULL; hf = hf->nxt )\n {\n hgfcharmonic_Eigen( hf->hgfc1, hf->hloop->lp1 );\n hgfcharmonic_Eigen( hf->hgfc2, hf->hloop->lp2 );\n // hgfcharmonic( hf->hgfc1, hf->hloop->lp1 );\n // hgfcharmonic( hf->hgfc2, hf->hloop->lp2 );\n }\n}\n\n#if 0\n/* harmonic mapping functions */\nvoid hgfcharmonic( HGfc *hgfc, Splp *lp )\n{\n int iter;\n int vn;\n double rsq;\n Semat *emat;\n\n vn = initialize_hgfc( hgfc );\n emat = create_harmonic_emat( hgfc );\n harmonic_initialize_vector( hgfc, lp, emat );\n\n linbcg( emat, emat->bx, emat->xx, 1, SMDZEROEPS, 1000, &iter, &rsq );\n linbcg( emat, emat->by, emat->yy, 1, SMDZEROEPS, 1000, &iter, &rsq );\n solvec_hgfc( hgfc, emat );\n\n free_emat( emat );\n exit_hgfc( hgfc );\n}\n#endif\n\nint initialize_hgfc( HGfc *hgfc )\n{\n int i;\n int cnt = 0;\n HGvt *hv;\n HGed *he;\n\n /* id */\n\n for (i = 0, hv = hgfc->shgvt; hv != (HGvt *) NULL; hv = hv->nxt, ++i) {\n hv->sid = i;\n if ( hv->vt->sp_type == SP_VERTEX_NORMAL ) {\n ++cnt;\n }\n }\n /* , and create hgvt->hged links */\n for (i = 0, he = hgfc->shged; he != (HGed *) NULL; he = he->nxt, ++i) {\n he->sid = i;\n create_hgvted( he->sv, he );\n create_hgvted( he->ev, he );\n }\n return cnt;\n}\n\n#if 0\nSemat *create_harmonic_emat( HGfc *hgfc )\n{\n int i, vn;\n int id;\n double *kappa;\n Semat *emat;\n HGvt *vt;\n HGed *ed;\n HGvted *ve;\n HGvtvt *vv;\n\n emat = init_emat( hgfc->hgvn );\n\n kappa = harmonic_calc_kappa( hgfc );\n\n for ( vt = hgfc->shgvt; vt != (HGvt *) NULL; vt = vt->nxt ) {\n vt->vval = 0.0;\n }\n\n for ( vt = hgfc->shgvt; vt != (HGvt *) NULL; vt = vt->nxt ) {\n for ( ve = vt->shgve; ve != (HGvted *) NULL; ve = ve->nxt ) {\n\n ed = ve->ed;\n /* sv */\n id = ed->sv->sid;\n if (vt->sid != id) {\n vv = find_sort_hgvtvt( vt, id );\n vv->val -= kappa[ed->sid];\n } else {\n vt->vval += kappa[ed->sid];\n }\n /* ev */\n id = ed->ev->sid;\n if (vt->sid != id) {\n vv = find_sort_hgvtvt( vt, id );\n vv->val -= kappa[ed->sid];\n } else {\n vt->vval += kappa[ed->sid];\n }\n }\n }\n\n /* Boundary Points are fixed. */\n for ( vt = hgfc->shgvt; vt != (HGvt *) NULL; vt = vt->nxt ) {\n\n if ( vt->vt->sp_type != SP_VERTEX_NORMAL ) {\n vt->vval = 1.0;\n free_hgppdvertexvertex( vt );\n }\n\n }\n\n vn = 0;\n for ( vt = hgfc->shgvt; vt != (HGvt *) NULL; vt = vt->nxt ) {\n vn += vt->hgvvn;\n }\n\n emat->num = vn + hgfc->hgvn + 1;\n emat->sa = (double *) malloc(emat->num * sizeof(double));\n for (i = 0; i < emat->num; ++i) emat->sa[i] = 0.0;\n emat->ija = (int *) malloc(emat->num * sizeof(int));\n\n dsprsin( hgfc, emat );\n \n free(kappa);\n\n FreeHGppdVertexVertex( hgfc );\n\n return emat;\n}\n\ndouble *harmonic_calc_kappa( HGfc *hgfc )\n{\n double *kappa;\n HGed *ed;\n\n /* initialize length, area, kappa */\n kappa = (double *) malloc( hgfc->hgen * sizeof(double));\n\n for ( ed = hgfc->shged; ed != (HGed *) NULL; ed = ed->nxt ) {\n kappa[ed->sid] = 1.0;\n }\n return kappa;\n}\n\nvoid harmonic_initialize_vector( HGfc *hgfc, Splp *lp, Semat *emat )\n{\n int i;\n HGvt *vt;\n Vec2d *uvbprm;\n Sple *le, *tle, *sle;\n Splv *lv, *tlv, *slv, *elv;\n double sum, esum, val;\n Vec2d sub;\n\n /* initialize vector */\n for ( vt = hgfc->shgvt; vt != (HGvt *) NULL; vt = vt->nxt ) {\n\n emat->bx[vt->sid] = emat->xx[vt->sid] = 0.0;\n emat->by[vt->sid] = emat->yy[vt->sid] = 0.0;\n\n }\n\n uvbprm = calc_uvbprm( hgfc->hgcn );\n\n /* calculate boundary values */\n\n lv = lp->splv;\n le = lp->sple;\n\n i = 0;\n while ( i < hgfc->hgcn ) {\n\n slv = lv;\n sle = le;\n sum = 0.0;\n\n while ( 1 ) {\n sum += le->ed->length;\n lv = lv->nxt;\n le = le->nxt;\n if ( lv == (Splv *) NULL ) {\n elv = lp->splv;\n break;\n }\n if ( lv->vt->sp_type == SP_VERTEX_HVERTEX ) {\n elv = lv;\n break;\n }\n }\n\n esum = 0.0;\n tlv = slv;\n tle = sle;\n sub.x = uvbprm[i+1].x - uvbprm[i].x;\n sub.y = uvbprm[i+1].y - uvbprm[i].y;\n while ( 1 ) {\n\n val = esum / sum;\n emat->bx[ tlv->hgvt->sid ] = uvbprm[i].x + sub.x * val;\n emat->by[ tlv->hgvt->sid ] = uvbprm[i].y + sub.y * val;\n\n esum += tle->ed->length;\n\n tlv = tlv->nxt;\n tle = tle->nxt;\n\n if ( (tlv == elv) || (tlv == (Splv *) NULL) ) break;\n }\n\n ++i;\n }\n\n free(uvbprm);\n}\n#endif\n\nVec2d *calc_uvbprm( int cn )\n{\n int i;\n double angle;\n Vec2d *uvbprm;\n\n uvbprm = (Vec2d *) malloc( (cn+1) * sizeof(Vec2d) );\n\n for ( i = 0; i <= cn; ++i ) {\n angle = 2 * (double) i * SMDPI / (double) cn;\n uvbprm[i].x = cos( angle );\n uvbprm[i].y = sin( angle );\n/* display(\"uvbprm %g %g\\n\", uvbprm[i].x, uvbprm[i].y); */\n }\n return uvbprm;\n}\n\n#if 0\nvoid solvec_hgfc( HGfc *hgfc, Semat *emat )\n{\n HGvt *vt;\n\n for ( vt = hgfc->shgvt; vt != (HGvt *) NULL; vt = vt->nxt ) {\n vt->uvw.x = emat->xx[vt->sid];\n vt->uvw.y = emat->yy[vt->sid];\n }\n}\n#endif\n\nvoid exit_hgfc( HGfc *hgfc )\n{\n HGvt *hv;\n HGed *he;\n\n for ( hv = hgfc->shgvt; hv != (HGvt *) NULL; hv = hv->nxt ) {\n hv->sid = SMDNULL;\n hv->vval = 0.0;\n free_hgppdvertexedge( hv );\n }\n\n /* create hgfc surface */\n\n for ( he = hgfc->shged; he != (HGed *) NULL; he = he->nxt ) {\n he->sid = SMDNULL;\n }\n\n}\n\n#if 0\n/* Semat functions */\nSemat *init_emat( int num )\n{\n Semat *emat;\n\n emat = (Semat *) malloc(sizeof(Semat));\n emat->rnum = num;\n emat->cnum = num;\n /* constant vectors initialize */\n emat->bx = (double *) malloc(num * sizeof(double));\n emat->by = (double *) malloc(num * sizeof(double));\n /* solution vectors initialize */\n emat->xx = (double *) malloc(num * sizeof(double));\n emat->yy = (double *) malloc(num * sizeof(double));\n\n return emat;\n}\n\nvoid free_emat(Semat *emat)\n{\n free(emat->sa);\n free(emat->ija);\n free(emat->bx);\n free(emat->by);\n free(emat->xx);\n free(emat->yy);\n free(emat);\n}\n#endif\n\n/*\nvoid printemat(Semat *emat)\n{\n int i;\n\n for (i = 0; i < emat->cnum; ++i) {\n display(\"%d (b) %f %f\\n\", i, emat->bx[i], emat->by[i]);\n display(\"%d (x) %f %f\\n\", i, emat->xx[i], emat->yy[i]);\n }\n for (i = 0; i < emat->num; ++i) \n display(\"(%d) (sa) %f (ija) %d\\n\", i, emat->sa[i], emat->ija[i]);\n}\n*/\n\n", "meta": {"hexsha": "361bbbe63cefc52cd683f484c05d38538f718422", "size": 11215, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/harmonic.cpp", "max_stars_repo_name": "kanait/gmorph", "max_stars_repo_head_hexsha": "e1461845c56e89221a4cdfb9933f575b456a852c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2019-04-30T17:12:50.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-28T03:45:17.000Z", "max_issues_repo_path": "src/harmonic.cpp", "max_issues_repo_name": "kanait/gmorph", "max_issues_repo_head_hexsha": "e1461845c56e89221a4cdfb9933f575b456a852c", "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/harmonic.cpp", "max_forks_repo_name": "kanait/gmorph", "max_forks_repo_head_hexsha": "e1461845c56e89221a4cdfb9933f575b456a852c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-09-07T10:15:11.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-16T12:43:11.000Z", "avg_line_length": 21.3619047619, "max_line_length": 80, "alphanum_fraction": 0.5012929113, "num_tokens": 4138, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303236047049, "lm_q2_score": 0.6859494614282923, "lm_q1q2_score": 0.5422638497193809}} {"text": "\n\n/* --------------------------------------------------------------------- \n * \n * Copyright (C) 2006 - 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 * Authors: Yan Li, Wolfgang Bangerth, Texas A&M University, 2006 \n */ \n\n\n\n// 这个程序是对 step-20 的改编，包括一些来自 step-12 的DG方法的技术。因此，该程序的很大一部分与 step-20 非常相似，我们将不再对这些部分进行评论。只有新的东西才会被详细讨论。\n\n// @sect3{Include files} \n\n// 这些include文件以前都用过了。\n\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\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \n#include \n\n// 在这个程序中，我们使用一个张量值的系数。由于它可能具有空间依赖性，我们认为它是一个张量值的函数。下面的include文件提供了提供这种功能的 TensorFunction 类。\n\n#include \n\n// 此外，我们使用 DiscreteTime 类来执行与时间递增有关的操作。\n\n#include \n\n// 最后一步和以前所有的程序一样。\n\nnamespace Step21 \n{ \n using namespace dealii; \n// @sect3{The TwoPhaseFlowProblem class} \n\n// 这是该程序的主类。它与 step-20 中的类很接近，但增加了一些功能。\n\n//
    \n//
  • \n// assemble_rhs_S 集合了饱和度方程的右侧。正如介绍中所解释的，这不能被集成到 assemble_rhs 中，因为它取决于在时间步长的第一部分计算的速度。\n\n//
  • \n// get_maximal_velocity 的作用正如其名称所示。这个函数用于计算时间步长。\n\n//
  • \n// project_back_saturation 将所有饱和度小于0的自由度重置为0，所有饱和度大于1的自由度重置为1。
\n\n// 该类的其余部分应该是非常明显的。变量 viscosity 存储粘度 $\\mu$ ，它进入了非线性方程中的几个公式。变量 time 记录了模拟过程中的时间信息。\n\n template \n class TwoPhaseFlowProblem \n { \n public: \n TwoPhaseFlowProblem(const unsigned int degree); \n void run(); \n\n private: \n void make_grid_and_dofs(); \n void assemble_system(); \n void assemble_rhs_S(); \n double get_maximal_velocity() const; \n void solve(); \n void project_back_saturation(); \n void output_results() const; \n\n const unsigned int degree; \n\n Triangulation triangulation; \n FESystem fe; \n DoFHandler dof_handler; \n\n BlockSparsityPattern sparsity_pattern; \n BlockSparseMatrix system_matrix; \n\n const unsigned int n_refinement_steps; \n\n DiscreteTime time; \n double viscosity; \n\n BlockVector solution; \n BlockVector old_solution; \n BlockVector system_rhs; \n }; \n// @sect3{Equation data} \n// @sect4{Pressure right hand side} \n\n// 目前，压力方程的右侧仅仅是零函数。但是，如果需要的话，程序的其余部分完全可以处理其他的东西。\n\n template \n class PressureRightHandSide : public Function \n { \n public: \n PressureRightHandSide() \n : Function(1) \n {} \n\n virtual double value(const Point & /*p*/, \n const unsigned int /*component*/ = 0) const override \n { \n return 0; \n } \n }; \n\n// @sect4{Pressure boundary values} \n\n// 接下来是压力边界值。正如介绍中提到的，我们选择一个线性压力场。\n\n template \n class PressureBoundaryValues : public Function \n { \n public: \n PressureBoundaryValues() \n : Function(1) \n {} \n\n virtual double value(const Point &p, \n const unsigned int /*component*/ = 0) const override \n { \n return 1 - p[0]; \n } \n }; \n\n// @sect4{Saturation boundary values} \n\n// 然后，我们还需要边界的流入部分的边界值。某物是否为流入部分的问题是在组装右手边时决定的，我们只需要提供边界值的功能描述。这正如介绍中所解释的。\n\n template \n class SaturationBoundaryValues : public Function \n { \n public: \n SaturationBoundaryValues() \n : Function(1) \n {} \n\n virtual double value(const Point &p, \n const unsigned int /*component*/ = 0) const override \n { \n if (p[0] == 0) \n return 1; \n else \n return 0; \n } \n }; \n\n// @sect4{Initial data} \n\n// 最后，我们需要初始数据。实际上，我们只需要饱和度的初始数据，但我们很懒，所以以后在第一个时间步骤之前，我们会简单地从一个包含所有矢量分量的函数中插值出前一个时间步骤的整个解决方案。\n//因此，\n//我们简单地创建一个所有分量都返回0的函数。我们通过简单地将每个函数转发到 Functions::ZeroFunction 类来做到这一点。为什么不在这个程序中我们目前使用 InitialValues 类的地方立即使用呢？因为这样，以后再回去选择不同的函数来做初始值就更简单了。\n\n template \n class InitialValues : public Function \n { \n public: \n InitialValues() \n : Function(dim + 2) \n {} \n\n virtual double value(const Point & p, \n const unsigned int component = 0) const override \n { \n return Functions::ZeroFunction(dim + 2).value(p, component); \n } \n\n virtual void vector_value(const Point &p, \n Vector & values) const override \n { \n Functions::ZeroFunction(dim + 2).vector_value(p, values); \n } \n }; \n\n// @sect3{The inverse permeability tensor} \n\n// 正如介绍中所宣布的，我们实现了两个不同的渗透率张量场。我们把它们各自放入一个命名空间，这样以后就可以很容易地在代码中用另一个来代替一个。\n\n// @sect4{Single curving crack permeability} \n\n// 渗透率的第一个函数是模拟单个弯曲裂缝的函数。它在 step-20 的结尾已经使用过了，它的函数形式在本教程程序的介绍中给出。和以前的一些程序一样，我们必须声明KInverse类的一个（似乎是不必要的）默认构造函数，以避免某些编译器的警告。\n\n namespace SingleCurvingCrack \n { \n template \n class KInverse : public TensorFunction<2, dim> \n { \n public: \n KInverse() \n : TensorFunction<2, dim>() \n {} \n\n virtual void \n value_list(const std::vector> &points, \n std::vector> & values) const override \n { \n Assert(points.size() == values.size(), \n ExcDimensionMismatch(points.size(), values.size())); \n\n for (unsigned int p = 0; p < points.size(); ++p) \n { \n values[p].clear(); \n\n const double distance_to_flowline = \n std::fabs(points[p][1] - 0.5 - 0.1 * std::sin(10 * points[p][0])); \n\n const double permeability = \n std::max(std::exp(-(distance_to_flowline * distance_to_flowline) / \n (0.1 * 0.1)), \n 0.01); \n\n for (unsigned int d = 0; d < dim; ++d) \n values[p][d][d] = 1. / permeability; \n } \n } \n }; \n } // namespace SingleCurvingCrack \n// @sect4{Random medium permeability} \n\n// 这个函数的作用与介绍中公布的一样，即在随机的地方创建一个叠加的指数。对于这个类，有一件事值得考虑。这个问题的核心是，这个类使用随机函数创建指数的中心。如果我们因此在每次创建本类型的对象时都创建中心，我们每次都会得到一个不同的中心列表。这不是我们对这种类型的类的期望：它们应该可靠地表示同一个函数。\n\n// 解决这个问题的方法是使中心列表成为这个类的静态成员变量，也就是说，在整个程序中只存在一个这样的变量，而不是为这个类型的每个对象。这正是我们所要做的。\n\n// 然而，接下来的问题是，我们需要一种方法来初始化这个变量。由于这个变量是在程序开始时初始化的，我们不能使用普通的成员函数来实现，因为当时身边可能没有这个类型的对象。因此C++标准规定，只有非成员函数和静态成员函数可以用来初始化静态变量。我们通过定义一个函数 get_centers 来使用后一种可能性，该函数在调用时计算中心点的列表。\n\n// 注意，这个类在2D和3D中都能正常工作，唯一的区别是我们在3D中使用了更多的点：通过实验我们发现，我们在3D中比2D中需要更多的指数（毕竟我们有更多的地方需要覆盖，如果我们想保持中心之间的距离大致相等），所以我们在2D中选择40，在3D中选择100。对于任何其他维度，该函数目前不知道该怎么做，所以只是抛出一个异常，表明这一点。\n\n namespace RandomMedium \n { \n template \n class KInverse : public TensorFunction<2, dim> \n { \n public: \n KInverse() \n : TensorFunction<2, dim>() \n {} \n\n virtual void \n value_list(const std::vector> &points, \n std::vector> & values) const override \n { \n Assert(points.size() == values.size(), \n ExcDimensionMismatch(points.size(), values.size())); \n\n for (unsigned int p = 0; p < points.size(); ++p) \n { \n values[p].clear(); \n\n double permeability = 0; \n for (unsigned int i = 0; i < centers.size(); ++i) \n permeability += std::exp(-(points[p] - centers[i]).norm_square() / \n (0.05 * 0.05)); \n\n const double normalized_permeability = \n std::min(std::max(permeability, 0.01), 4.); \n\n for (unsigned int d = 0; d < dim; ++d) \n values[p][d][d] = 1. / normalized_permeability; \n } \n } \n\n private: \n static std::vector> centers; \n\n static std::vector> get_centers() \n { \n const unsigned int N = \n (dim == 2 ? 40 : (dim == 3 ? 100 : throw ExcNotImplemented())); \n\n std::vector> centers_list(N); \n for (unsigned int i = 0; i < N; ++i) \n for (unsigned int d = 0; d < dim; ++d) \n centers_list[i][d] = static_cast(rand()) / RAND_MAX; \n\n return centers_list; \n } \n }; \n\n template \n std::vector> \n KInverse::centers = KInverse::get_centers(); \n } // namespace RandomMedium \n\n// @sect3{The inverse mobility and saturation functions} \n\n// 还有两个数据我们需要描述，即反流动性函数和饱和度曲线。它们的形式也在介绍中给出。\n\n double mobility_inverse(const double S, const double viscosity) \n { \n return 1.0 / (1.0 / viscosity * S * S + (1 - S) * (1 - S)); \n } \n\n double fractional_flow(const double S, const double viscosity) \n { \n return S * S / (S * S + viscosity * (1 - S) * (1 - S)); \n } \n\n// @sect3{Linear solvers and preconditioners} \n\n// 我们使用的线性求解器也完全类似于 step-20 中使用的。因此，下面的类是逐字逐句从那里复制过来的。请注意，这里的类不仅是从 step-20 中复制的，而且在deal.II中也有重复的类。在这个例子的未来版本中，它们应该被一个有效的方法所取代，不过。有一个变化：如果线性系统的尺寸很小，即当网格很粗时，那么在 src.size() 函数中的求解器收敛之前，设置 vmult() CG迭代的最大值有时是不够的。(当然，这是数值取舍的结果，因为我们知道在纸面上，CG方法最多在 src.size() 步内收敛)。因此，我们将最大的迭代次数设定为等于线性系统的最大规模和200。\n\n template \n class InverseMatrix : public Subscriptor \n { \n public: \n InverseMatrix(const MatrixType &m) \n : matrix(&m) \n {} \n\n void vmult(Vector &dst, const Vector &src) const \n { \n SolverControl solver_control(std::max(src.size(), 200), \n 1e-8 * src.l2_norm()); \n SolverCG> cg(solver_control); \n\n dst = 0; \n\n cg.solve(*matrix, dst, src, PreconditionIdentity()); \n } \n\n private: \n const SmartPointer matrix; \n }; \n\n class SchurComplement : public Subscriptor \n { \n public: \n SchurComplement(const BlockSparseMatrix & A, \n const InverseMatrix> &Minv) \n : system_matrix(&A) \n , m_inverse(&Minv) \n , tmp1(A.block(0, 0).m()) \n , tmp2(A.block(0, 0).m()) \n {} \n\n void vmult(Vector &dst, const Vector &src) const \n { \n system_matrix->block(0, 1).vmult(tmp1, src); \n m_inverse->vmult(tmp2, tmp1); \n system_matrix->block(1, 0).vmult(dst, tmp2); \n } \n\n private: \n const SmartPointer> system_matrix; \n const SmartPointer>> m_inverse; \n\n mutable Vector tmp1, tmp2; \n }; \n\n class ApproximateSchurComplement : public Subscriptor \n { \n public: \n ApproximateSchurComplement(const BlockSparseMatrix &A) \n : system_matrix(&A) \n , tmp1(A.block(0, 0).m()) \n , tmp2(A.block(0, 0).m()) \n {} \n\n void vmult(Vector &dst, const Vector &src) const \n { \n system_matrix->block(0, 1).vmult(tmp1, src); \n system_matrix->block(0, 0).precondition_Jacobi(tmp2, tmp1); \n system_matrix->block(1, 0).vmult(dst, tmp2); \n } \n\n private: \n const SmartPointer> system_matrix; \n\n mutable Vector tmp1, tmp2; \n }; \n\n// @sect3{TwoPhaseFlowProblem class implementation} \n\n// 现在是主类的实现。它的大部分内容实际上是从 step-20 中复制过来的，所以我们不会对它进行详细的评论。你应该试着先熟悉一下那个程序，然后这里发生的大部分事情就应该很清楚了。\n\n// @sect4{TwoPhaseFlowProblem::TwoPhaseFlowProblem} \n\n// 首先是构造函数。我们使用 $RT_k \\times DQ_k \\times DQ_k$ 空间。对于初始化DiscreteTime对象，我们不在构造函数中设置时间步长，因为我们还没有它的值。时间步长最初被设置为零，但在需要增量时间之前，它将被计算出来，正如介绍的一个小节中所描述的。时间对象在内部阻止自己在 $dt = 0$ 时被递增，迫使我们在推进时间之前为 $dt$ 设置一个非零的期望大小。\n\n template \n TwoPhaseFlowProblem::TwoPhaseFlowProblem(const unsigned int degree) \n : degree(degree) \n , fe(FE_RaviartThomas(degree), \n 1, \n FE_DGQ(degree), \n 1, \n FE_DGQ(degree), \n 1) \n , dof_handler(triangulation) \n , n_refinement_steps(5) \n , time(/*start time*/ 0., /*end time*/ 1.) \n , viscosity(0.2) \n {} \n\n// @sect4{TwoPhaseFlowProblem::make_grid_and_dofs} \n\n// 下一个函数从众所周知的函数调用开始，创建和细化一个网格，然后将自由度与之关联。它所做的事情与 step-20 中的相同，只是现在是三个组件而不是两个。\n\n template \n void TwoPhaseFlowProblem::make_grid_and_dofs() \n { \n GridGenerator::hyper_cube(triangulation, 0, 1); \n triangulation.refine_global(n_refinement_steps); \n\n dof_handler.distribute_dofs(fe); \n DoFRenumbering::component_wise(dof_handler); \n\n const std::vector dofs_per_component = \n DoFTools::count_dofs_per_fe_component(dof_handler); \n const unsigned int n_u = dofs_per_component[0], \n n_p = dofs_per_component[dim], \n n_s = dofs_per_component[dim + 1]; \n\n std::cout << \"Number of active cells: \" << triangulation.n_active_cells() \n << std::endl \n << \"Number of degrees of freedom: \" << dof_handler.n_dofs() \n << \" (\" << n_u << '+' << n_p << '+' << n_s << ')' << std::endl \n << std::endl; \n\n const unsigned int n_couplings = dof_handler.max_couplings_between_dofs(); \n\n sparsity_pattern.reinit(3, 3); \n sparsity_pattern.block(0, 0).reinit(n_u, n_u, n_couplings); \n sparsity_pattern.block(1, 0).reinit(n_p, n_u, n_couplings); \n sparsity_pattern.block(2, 0).reinit(n_s, n_u, n_couplings); \n sparsity_pattern.block(0, 1).reinit(n_u, n_p, n_couplings); \n sparsity_pattern.block(1, 1).reinit(n_p, n_p, n_couplings); \n sparsity_pattern.block(2, 1).reinit(n_s, n_p, n_couplings); \n sparsity_pattern.block(0, 2).reinit(n_u, n_s, n_couplings); \n sparsity_pattern.block(1, 2).reinit(n_p, n_s, n_couplings); \n sparsity_pattern.block(2, 2).reinit(n_s, n_s, n_couplings); \n\n sparsity_pattern.collect_sizes(); \n\n DoFTools::make_sparsity_pattern(dof_handler, sparsity_pattern); \n sparsity_pattern.compress(); \n\n system_matrix.reinit(sparsity_pattern); \n\n solution.reinit(3); \n solution.block(0).reinit(n_u); \n solution.block(1).reinit(n_p); \n solution.block(2).reinit(n_s); \n solution.collect_sizes(); \n\n old_solution.reinit(3); \n old_solution.block(0).reinit(n_u); \n old_solution.block(1).reinit(n_p); \n old_solution.block(2).reinit(n_s); \n old_solution.collect_sizes(); \n\n system_rhs.reinit(3); \n system_rhs.block(0).reinit(n_u); \n system_rhs.block(1).reinit(n_p); \n system_rhs.block(2).reinit(n_s); \n system_rhs.collect_sizes(); \n } \n// @sect4{TwoPhaseFlowProblem::assemble_system} \n\n// 这是组装线性系统的函数，或者至少是除了(1,3)块之外的所有东西，它取决于在这个时间步长中计算的仍然未知的速度（我们在 assemble_rhs_S 中处理这个问题）。它的大部分内容与 step-20 一样，但这次我们必须处理一些非线性的问题。 然而，该函数的顶部与往常一样（注意我们在开始时将矩阵和右手边设置为零— 对于静止问题我们不必这样做，因为在那里我们只使用一次矩阵对象，而且在开始时它是空的）。\n\n// 注意，在目前的形式下，该函数使用 RandomMedium::KInverse 类中实现的渗透率。切换到单曲裂缝渗透率函数就像改变命名空间名称一样简单。\n\n template \n void TwoPhaseFlowProblem::assemble_system() \n { \n system_matrix = 0; \n system_rhs = 0; \n\n QGauss quadrature_formula(degree + 2); \n QGauss face_quadrature_formula(degree + 2); \n\n FEValues fe_values(fe, \n quadrature_formula, \n update_values | update_gradients | \n update_quadrature_points | update_JxW_values); \n FEFaceValues fe_face_values(fe, \n face_quadrature_formula, \n update_values | update_normal_vectors | \n update_quadrature_points | \n update_JxW_values); \n\n const unsigned int dofs_per_cell = fe.n_dofs_per_cell(); \n\n const unsigned int n_q_points = quadrature_formula.size(); \n const unsigned int n_face_q_points = face_quadrature_formula.size(); \n\n FullMatrix local_matrix(dofs_per_cell, dofs_per_cell); \n Vector local_rhs(dofs_per_cell); \n\n std::vector local_dof_indices(dofs_per_cell); \n\n const PressureRightHandSide pressure_right_hand_side; \n const PressureBoundaryValues pressure_boundary_values; \n const RandomMedium::KInverse k_inverse; \n\n std::vector pressure_rhs_values(n_q_points); \n std::vector boundary_values(n_face_q_points); \n std::vector> k_inverse_values(n_q_points); \n\n std::vector> old_solution_values(n_q_points, \n Vector(dim + 2)); \n std::vector>> old_solution_grads( \n n_q_points, std::vector>(dim + 2)); \n\n const FEValuesExtractors::Vector velocities(0); \n const FEValuesExtractors::Scalar pressure(dim); \n const FEValuesExtractors::Scalar saturation(dim + 1); \n\n for (const auto &cell : dof_handler.active_cell_iterators()) \n { \n fe_values.reinit(cell); \n local_matrix = 0; \n local_rhs = 0; \n\n// 这里是第一个重要的区别。我们必须在正交点上获得前一个时间步骤的饱和函数值。为此，我们可以使用 FEValues::get_function_values （之前已经在 step-9 、 step-14 和 step-15 中使用），这个函数接收一个解向量并返回当前单元的正交点的函数值列表。事实上，它返回每个正交点的完整矢量值解，即不仅是饱和度，还有速度和压力。\n\n fe_values.get_function_values(old_solution, old_solution_values); \n\n// 然后，我们还必须得到压力的右手边和反渗透性张量在正交点的数值。\n\n pressure_right_hand_side.value_list(fe_values.get_quadrature_points(), \n pressure_rhs_values); \n k_inverse.value_list(fe_values.get_quadrature_points(), \n k_inverse_values); \n\n// 有了这些，我们现在可以在这个单元格上的所有正交点和形状函数上进行循环，并将我们在这个函数中处理的矩阵和右手边的那些部分组合起来。考虑到引言中所述的双线性形式的明确形式，贡献中的各个条款应该是不言自明的。\n\n for (unsigned int q = 0; q < n_q_points; ++q) \n for (unsigned int i = 0; i < dofs_per_cell; ++i) \n { \n const double old_s = old_solution_values[q](dim + 1); \n\n const Tensor<1, dim> phi_i_u = fe_values[velocities].value(i, q); \n const double div_phi_i_u = fe_values[velocities].divergence(i, q); \n const double phi_i_p = fe_values[pressure].value(i, q); \n const double phi_i_s = fe_values[saturation].value(i, q); \n\n for (unsigned int j = 0; j < dofs_per_cell; ++j) \n { \n const Tensor<1, dim> phi_j_u = \n fe_values[velocities].value(j, q); \n const double div_phi_j_u = \n fe_values[velocities].divergence(j, q); \n const double phi_j_p = fe_values[pressure].value(j, q); \n const double phi_j_s = fe_values[saturation].value(j, q); \n\n local_matrix(i, j) += \n (phi_i_u * k_inverse_values[q] * \n mobility_inverse(old_s, viscosity) * phi_j_u - \n div_phi_i_u * phi_j_p - phi_i_p * div_phi_j_u + \n phi_i_s * phi_j_s) * \n fe_values.JxW(q); \n } \n\n local_rhs(i) += \n (-phi_i_p * pressure_rhs_values[q]) * fe_values.JxW(q); \n } \n\n// 接下来，我们还必须处理压力边界值。这一点，还是和 step-20 中一样。\n\n for (const auto &face : cell->face_iterators()) \n if (face->at_boundary()) \n { \n fe_face_values.reinit(cell, face); \n\n pressure_boundary_values.value_list( \n fe_face_values.get_quadrature_points(), boundary_values); \n\n for (unsigned int q = 0; q < n_face_q_points; ++q) \n for (unsigned int i = 0; i < dofs_per_cell; ++i) \n { \n const Tensor<1, dim> phi_i_u = \n fe_face_values[velocities].value(i, q); \n\n local_rhs(i) += \n -(phi_i_u * fe_face_values.normal_vector(q) * \n boundary_values[q] * fe_face_values.JxW(q)); \n } \n } \n\n// 在所有单元的循环中，最后一步是将局部贡献转移到全局矩阵和右侧向量中。\n\n cell->get_dof_indices(local_dof_indices); \n for (unsigned int i = 0; i < dofs_per_cell; ++i) \n for (unsigned int j = 0; j < dofs_per_cell; ++j) \n system_matrix.add(local_dof_indices[i], \n local_dof_indices[j], \n local_matrix(i, j)); \n\n for (unsigned int i = 0; i < dofs_per_cell; ++i) \n system_rhs(local_dof_indices[i]) += local_rhs(i); \n } \n } \n\n// 矩阵和右手边的组装就这么多了。请注意，我们不需要插值和应用边界值，因为它们都已经在弱式中被处理过了。\n\n// @sect4{TwoPhaseFlowProblem::assemble_rhs_S} \n\n// 正如在介绍中所解释的，我们只有在计算出速度后才能评估饱和方程的右边。因此，我们有这个单独的函数来实现这个目的。\n\n template \n void TwoPhaseFlowProblem::assemble_rhs_S() \n { \n QGauss quadrature_formula(degree + 2); \n QGauss face_quadrature_formula(degree + 2); \n FEValues fe_values(fe, \n quadrature_formula, \n update_values | update_gradients | \n update_quadrature_points | update_JxW_values); \n FEFaceValues fe_face_values(fe, \n face_quadrature_formula, \n update_values | update_normal_vectors | \n update_quadrature_points | \n update_JxW_values); \n FEFaceValues fe_face_values_neighbor(fe, \n face_quadrature_formula, \n update_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 const unsigned int n_face_q_points = face_quadrature_formula.size(); \n\n Vector local_rhs(dofs_per_cell); \n\n std::vector> old_solution_values(n_q_points, \n Vector(dim + 2)); \n std::vector> old_solution_values_face(n_face_q_points, \n Vector(dim + \n 2)); \n std::vector> old_solution_values_face_neighbor( \n n_face_q_points, Vector(dim + 2)); \n std::vector> present_solution_values(n_q_points, \n Vector(dim + \n 2)); \n std::vector> present_solution_values_face( \n n_face_q_points, Vector(dim + 2)); \n\n std::vector neighbor_saturation(n_face_q_points); \n std::vector local_dof_indices(dofs_per_cell); \n\n SaturationBoundaryValues saturation_boundary_values; \n\n const FEValuesExtractors::Scalar saturation(dim + 1); \n\n for (const auto &cell : dof_handler.active_cell_iterators()) \n { \n local_rhs = 0; \n fe_values.reinit(cell); \n\n fe_values.get_function_values(old_solution, old_solution_values); \n fe_values.get_function_values(solution, present_solution_values); \n\n// 首先是单元格条款。按照介绍中的公式，这些是 $(S^n,\\sigma)-(F(S^n) \\mathbf{v}^{n+1},\\nabla \\sigma)$ ，其中 $\\sigma$ 是测试函数的饱和成分。\n\n for (unsigned int q = 0; q < n_q_points; ++q) \n for (unsigned int i = 0; i < dofs_per_cell; ++i) \n { \n const double old_s = old_solution_values[q](dim + 1); \n Tensor<1, dim> present_u; \n for (unsigned int d = 0; d < dim; ++d) \n present_u[d] = present_solution_values[q](d); \n\n const double phi_i_s = fe_values[saturation].value(i, q); \n const Tensor<1, dim> grad_phi_i_s = \n fe_values[saturation].gradient(i, q); \n\n local_rhs(i) += \n (time.get_next_step_size() * fractional_flow(old_s, viscosity) * \n present_u * grad_phi_i_s + \n old_s * phi_i_s) * \n fe_values.JxW(q); \n } \n\n// 其次，我们必须处理面的边界上的通量部分。这就有点麻烦了，因为我们首先要确定哪些是细胞边界的流入和流出部分。如果我们有一个流入的边界，我们需要评估面的另一边的饱和度（或者边界值，如果我们在域的边界上）。\n\n// 所有这些都有点棘手，但在 step-9 中已经有了一些详细的解释。请看这里，这应该是如何工作的!\n\n for (const auto face_no : cell->face_indices()) \n { \n fe_face_values.reinit(cell, face_no); \n\n fe_face_values.get_function_values(old_solution, \n old_solution_values_face); \n fe_face_values.get_function_values(solution, \n present_solution_values_face); \n\n if (cell->at_boundary(face_no)) \n saturation_boundary_values.value_list( \n fe_face_values.get_quadrature_points(), neighbor_saturation); \n else \n { \n const auto neighbor = cell->neighbor(face_no); \n const unsigned int neighbor_face = \n cell->neighbor_of_neighbor(face_no); \n\n fe_face_values_neighbor.reinit(neighbor, neighbor_face); \n\n fe_face_values_neighbor.get_function_values( \n old_solution, old_solution_values_face_neighbor); \n\n for (unsigned int q = 0; q < n_face_q_points; ++q) \n neighbor_saturation[q] = \n old_solution_values_face_neighbor[q](dim + 1); \n } \n\n for (unsigned int q = 0; q < n_face_q_points; ++q) \n { \n Tensor<1, dim> present_u_face; \n for (unsigned int d = 0; d < dim; ++d) \n present_u_face[d] = present_solution_values_face[q](d); \n\n const double normal_flux = \n present_u_face * fe_face_values.normal_vector(q); \n\n const bool is_outflow_q_point = (normal_flux >= 0); \n\n for (unsigned int i = 0; i < dofs_per_cell; ++i) \n local_rhs(i) -= \n time.get_next_step_size() * normal_flux * \n fractional_flow((is_outflow_q_point == true ? \n old_solution_values_face[q](dim + 1) : \n neighbor_saturation[q]), \n viscosity) * \n fe_face_values[saturation].value(i, q) * \n fe_face_values.JxW(q); \n } \n } \n\n cell->get_dof_indices(local_dof_indices); \n for (unsigned int i = 0; i < dofs_per_cell; ++i) \n system_rhs(local_dof_indices[i]) += local_rhs(i); \n } \n } \n\n// @sect4{TwoPhaseFlowProblem::solve} \n\n// 在所有这些准备工作之后，我们最终以与 step-20 相同的方式解决速度和压力的线性系统。在这之后，我们必须处理饱和方程（见下文）。\n\n template \n void TwoPhaseFlowProblem::solve() \n { \n const InverseMatrix> m_inverse( \n system_matrix.block(0, 0)); \n Vector tmp(solution.block(0).size()); \n Vector schur_rhs(solution.block(1).size()); \n Vector tmp2(solution.block(2).size()); \n\n// 首先是压力，使用前两个方程的压力舒尔补。\n\n { \n m_inverse.vmult(tmp, system_rhs.block(0)); \n system_matrix.block(1, 0).vmult(schur_rhs, tmp); \n schur_rhs -= system_rhs.block(1); \n\n SchurComplement schur_complement(system_matrix, m_inverse); \n\n ApproximateSchurComplement approximate_schur_complement(system_matrix); \n\n InverseMatrix preconditioner( \n approximate_schur_complement); \n\n SolverControl solver_control(solution.block(1).size(), \n 1e-12 * schur_rhs.l2_norm()); \n SolverCG> cg(solver_control); \n\n cg.solve(schur_complement, solution.block(1), schur_rhs, preconditioner); \n\n std::cout << \" \" << solver_control.last_step() \n << \" CG Schur complement iterations for pressure.\" << std::endl; \n } \n\n// 现在是速度。\n\n { \n system_matrix.block(0, 1).vmult(tmp, solution.block(1)); \n tmp *= -1; \n tmp += system_rhs.block(0); \n\n m_inverse.vmult(solution.block(0), tmp); \n } \n\n// 最后，我们必须处理好饱和度方程。在这里，我们要做的第一件事是使用介绍中的公式来确定时间步长。知道了我们领域的形状，以及我们通过有规律地划分单元来创建网格，我们可以很容易地计算出每个单元的直径（事实上我们使用的是单元坐标方向上的线性扩展，而不是直径）。请注意，我们将在 step-24 中学习一种更通用的方法，在那里我们使用 GridTools::minimal_cell_diameter 函数。\n\n// 我们使用一个辅助函数来计算下面定义的最大速度，有了这些，我们就可以评估我们新的时间步长了。我们使用方法 DiscreteTime::set_desired_next_time_step() 来向DiscreteTime对象建议新的时间步长的计算值。在大多数情况下，时间对象使用精确提供的值来增加时间。在某些情况下，时间对象可以进一步修改步骤大小。例如，如果计算出的时间增量超过了结束时间，它将被相应地截断。\n\n time.set_desired_next_step_size(std::pow(0.5, double(n_refinement_steps)) / \n get_maximal_velocity()); \n\n// 下一步是组装右手边，然后把所有的东西都传给解。最后，我们把饱和度投射回物理上合理的范围。\n\n assemble_rhs_S(); \n { \n SolverControl solver_control(system_matrix.block(2, 2).m(), \n 1e-8 * system_rhs.block(2).l2_norm()); \n SolverCG> cg(solver_control); \n cg.solve(system_matrix.block(2, 2), \n solution.block(2), \n system_rhs.block(2), \n PreconditionIdentity()); \n\n project_back_saturation(); \n\n std::cout << \" \" << solver_control.last_step() \n << \" CG iterations for saturation.\" << std::endl; \n } \n\n old_solution = solution; \n } \n// @sect4{TwoPhaseFlowProblem::output_results} \n\n// 这里没有什么值得惊讶的。由于程序会做大量的时间步骤，我们只在每第五个时间步骤创建一个输出文件，并在文件的顶部已经跳过所有其他时间步骤。\n\n// 在为接近函数底部的输出创建文件名时，我们将时间步长的数字转换为字符串表示，用前导零填充到四位数。我们这样做是因为这样所有的输出文件名都有相同的长度，因此在创建目录列表时可以很好地排序。\n\n template \n void TwoPhaseFlowProblem::output_results() const \n { \n if (time.get_step_number() % 5 != 0) \n return; \n\n std::vector solution_names; \n switch (dim) \n { \n case 2: \n solution_names = {\"u\", \"v\", \"p\", \"S\"}; \n break; \n\n case 3: \n solution_names = {\"u\", \"v\", \"w\", \"p\", \"S\"}; \n break; \n\n default: \n Assert(false, ExcNotImplemented()); \n } \n\n DataOut data_out; \n\n data_out.attach_dof_handler(dof_handler); \n data_out.add_data_vector(solution, solution_names); \n\n data_out.build_patches(degree + 1); \n\n std::ofstream output(\"solution-\" + \n Utilities::int_to_string(time.get_step_number(), 4) + \n \".vtk\"); \n data_out.write_vtk(output); \n } \n\n// @sect4{TwoPhaseFlowProblem::project_back_saturation} \n\n// 在这个函数中，我们简单地遍历所有的饱和自由度，并确保如果它们离开了物理上的合理范围，它们将被重置到区间 $[0,1]$ 。要做到这一点，我们只需要循环解决向量的所有饱和分量；这些分量存储在块2中（块0是速度，块1是压力）。\n\n// 值得注意的是，当时间步长选择如介绍中提到的那样时，这个函数几乎从未触发过，这一点可能很有启发。然而，如果我们只选择稍大的时间步长，我们会得到大量超出适当范围的数值。严格来说，如果我们选择的时间步长足够小，这个函数因此是不必要的。从某种意义上说，这个函数只是一个安全装置，以避免由于个别自由度在几个时间步长之前变得不符合物理条件而导致我们的整个解决方案变得不符合物理条件的情况。\n\n template \n void TwoPhaseFlowProblem::project_back_saturation() \n { \n for (unsigned int i = 0; i < solution.block(2).size(); ++i) \n if (solution.block(2)(i) < 0) \n solution.block(2)(i) = 0; \n else if (solution.block(2)(i) > 1) \n solution.block(2)(i) = 1; \n } \n// @sect4{TwoPhaseFlowProblem::get_maximal_velocity} \n\n// 下面的函数用于确定允许的最大时间步长。它的作用是在域中的所有正交点上循环，找出速度的最大幅度。\n\n template \n double TwoPhaseFlowProblem::get_maximal_velocity() const \n { \n QGauss quadrature_formula(degree + 2); \n const unsigned int n_q_points = quadrature_formula.size(); \n\n FEValues fe_values(fe, quadrature_formula, update_values); \n std::vector> solution_values(n_q_points, \n Vector(dim + 2)); \n double max_velocity = 0; \n\n for (const auto &cell : dof_handler.active_cell_iterators()) \n { \n fe_values.reinit(cell); \n fe_values.get_function_values(solution, solution_values); \n\n for (unsigned int q = 0; q < n_q_points; ++q) \n { \n Tensor<1, dim> velocity; \n for (unsigned int i = 0; i < dim; ++i) \n velocity[i] = solution_values[q](i); \n\n max_velocity = std::max(max_velocity, velocity.norm()); \n } \n } \n\n return max_velocity; \n } \n// @sect4{TwoPhaseFlowProblem::run} \n\n// 这是我们主类的最后一个函数。它的简洁不言自明。只有两点是值得注意的。首先，该函数在开始时将初始值投射到有限元空间上； VectorTools::project 函数这样做需要一个表明悬挂节点约束的参数。我们在这个程序中没有（我们在一个均匀细化的网格上计算），但是这个函数当然需要这个参数。所以我们必须创建一个约束对象。在原始状态下，约束对象是没有排序的，在使用前必须进行排序（使用 AffineConstraints::close 函数）。这就是我们在这里所做的，这也是为什么我们不能简单地用一个匿名的临时对象 AffineConstraints() 作为第二个参数来调用 VectorTools::project 函数。\n\n// 值得一提的第二点是，我们只在求解每个时间步长对应的线性系统的过程中计算当前时间步长。因此，我们只有在时间步长结束时才能输出一个时间步长的当前时间。我们通过调用循环内的方法 DiscreteTime::advance_time() 来增加时间。由于我们在增量后报告时间和dt，我们必须调用方法 DiscreteTime::get_previous_step_size() ，而不是 DiscreteTime::get_next_step_size(). 。 经过许多步，当模拟到达结束时间时，最后的dt由DiscreteTime类选择，其方式是最后一步正好在结束时间完成。\n\n template \n void TwoPhaseFlowProblem::run() \n { \n make_grid_and_dofs(); \n\n { \n AffineConstraints constraints; \n constraints.close(); \n\n VectorTools::project(dof_handler, \n constraints, \n QGauss(degree + 2), \n InitialValues(), \n old_solution); \n } \n\n do \n { \n std::cout << \"Timestep \" << time.get_step_number() + 1 << std::endl; \n\n assemble_system(); \n\n solve(); \n\n output_results(); \n\n time.advance_time(); \n std::cout << \" Now at t=\" << time.get_current_time() \n << \", dt=\" << time.get_previous_step_size() << '.' \n << std::endl \n << std::endl; \n } \n while (time.is_at_end() == false); \n } \n} // namespace Step21 \n// @sect3{The main function} \n\n// 这就是了。在主函数中，我们将有限元空间的度数传递给TwoPhaseFlowProblem对象的构造函数。 这里，我们使用零度元素，即 $RT_0\\times DQ_0 \\times DQ_0$ 。其余部分与其他所有程序一样。\n\nint main() \n{ \n try \n { \n using namespace Step21; \n\n TwoPhaseFlowProblem<2> two_phase_flow_problem(0); \n two_phase_flow_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\n", "meta": {"hexsha": "155c2dfc59b5868d5fa821764a109678730abee8", "size": 35822, "ext": "cc", "lang": "C++", "max_stars_repo_path": "Translator_file/examples/step-21/step-21.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-21/step-21.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-21/step-21.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": 35.1886051081, "max_line_length": 335, "alphanum_fraction": 0.5998827536, "num_tokens": 12225, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303186696747, "lm_q2_score": 0.6859494485880928, "lm_q1q2_score": 0.5422638361836327}} {"text": "#pragma once\n//! c/c++ headers\n//! dependency headers\n#include \n//! project headers\n#include \"types.hpp\"\n\nnamespace correspondences {\n\n/**\n * @brief compute pairwise consistency score; see Eqn. 49 from reference\n *\n * @param [in] si ith point in source distribution\n * @param [in] tj jth point in target distribution\n * @param [in] sk kth point in source distribution\n * @param [in] tl lth point in target distribution\n * @return pairwise consistency score for (i, j, k, l)\n */\ndouble consistency(arma::vec3 const & si, arma::vec3 const & tj,\n arma::vec3 const & sk, arma::vec3 const & tl) noexcept;\n\n/**\n * @brief populate weight tensor for optimization problem; see `w` in Eqn. 48 from paper\n *\n * @param[in] source_pts distribution of (columnar) source points\n * @param[in] target_pts distribution of (columnar) target points\n * @return weight tensor with weights for pairwise correspondences in optimization objective\n */\nWeightTensor generate_weight_tensor(arma::mat const & source_pts,\n arma::mat const & target_pts, double const & eps, double const & pw_thresh) noexcept;\n\n/**\n * @brief Find vector x that minimizes inner product subject to bounds constraints\n * lb <= x <= ub and equality constraint A*x==b\n *\n * @param [in] c vector c in above\n * @param [in] A matrix A in Ax==b above\n * @param [in] b vector b in Ax==b above\n * @param [in] lower_bound lower bound on (individual components of) x\n * @param [in] upper_bound upper bound on (individual components of) x\n * @param [in][out] x_opt value of x that minimizes subject to defined constraints\n * @return\n *\n * @note Uses Google's ORTools\n */\nbool linear_programming(arma::colvec const & c, arma::mat const & A, arma::colvec const & b,\n double const & lower_bound, double const & upper_bound, arma::colvec & x_opt) noexcept;\n} // namespace correspondences\n", "meta": {"hexsha": "c99de1747b9df667c474deafd16028b018fba2cd", "size": 1865, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "correspondences/common/include/correspondences/common/utilities.hpp", "max_stars_repo_name": "jwdinius/nmsac", "max_stars_repo_head_hexsha": "b765be4340cf8367e1af345dc156597ce425c818", "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": "correspondences/common/include/correspondences/common/utilities.hpp", "max_issues_repo_name": "jwdinius/nmsac", "max_issues_repo_head_hexsha": "b765be4340cf8367e1af345dc156597ce425c818", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 8.0, "max_issues_repo_issues_event_min_datetime": "2020-07-19T23:38:48.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-14T22:36:30.000Z", "max_forks_repo_path": "correspondences/common/include/correspondences/common/utilities.hpp", "max_forks_repo_name": "jwdinius/nmsac", "max_forks_repo_head_hexsha": "b765be4340cf8367e1af345dc156597ce425c818", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-08-06T06:59:04.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-06T06:59:04.000Z", "avg_line_length": 38.0612244898, "max_line_length": 93, "alphanum_fraction": 0.7120643432, "num_tokens": 490, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434978390746, "lm_q2_score": 0.7025300449389326, "lm_q1q2_score": 0.542243247222708}} {"text": "#include \n\n#include \n\n#include // Needed for .inverse()\n\n#include \n#include \n#include \n#include \n\nnamespace swr {\n\nvoid rasterize_triangle(\n const Shaders& shaders,\n const UniformAttributes& uniform,\n const VertexAttributes& v1,\n const VertexAttributes& v2,\n const VertexAttributes& v3,\n FrameBuffer& frame_buffer)\n{\n // Collect coordinates into a matrix and convert to canonical representation\n Eigen::Matrix p;\n p.row(0) = v1.position.array() / v1.position.w();\n p.row(1) = v2.position.array() / v2.position.w();\n p.row(2) = v3.position.array() / v3.position.w();\n\n // Coordinates are in -1..1, rescale to pixel size (x,y only)\n p.col(0) = ((p.col(0).array() + 1.0) / 2.0) * frame_buffer.rows();\n p.col(1) = ((p.col(1).array() + 1.0) / 2.0) * frame_buffer.cols();\n\n // Find bounding box in pixels\n int lx = std::floor(p.col(0).minCoeff());\n int ly = std::floor(p.col(1).minCoeff());\n int ux = std::ceil(p.col(0).maxCoeff());\n int uy = std::ceil(p.col(1).maxCoeff());\n\n // Clamp to framebuffer\n lx = std::min(std::max(lx, int(0)), int(frame_buffer.rows() - 1));\n ly = std::min(std::max(ly, int(0)), int(frame_buffer.cols() - 1));\n ux = std::max(std::min(ux, int(frame_buffer.rows() - 1)), int(0));\n uy = std::max(std::min(uy, int(frame_buffer.cols() - 1)), int(0));\n\n // Build the implicit triangle representation\n Matrix3F A;\n A.col(0) = p.row(0).head<3>();\n A.col(1) = p.row(1).head<3>();\n A.col(2) = p.row(2).head<3>();\n A.row(2) << 1.0, 1.0, 1.0;\n\n Matrix3F Ai = A.inverse();\n\n // Rasterize the triangle\n tbb::parallel_for(\n tbb::blocked_range2d(lx, ux + 1, ly, uy + 1),\n [&](const tbb::blocked_range2d& r) {\n for (size_t i = r.rows().begin(); i < r.rows().end(); i++) {\n for (size_t j = r.cols().begin(); j < r.cols().end(); j++) {\n // The pixel center is offset by 0.5, 0.5\n Vector3F pixel(i + 0.5, j + 0.5, 1);\n Vector3F b = Ai * pixel;\n if (b.minCoeff() >= 0) {\n VertexAttributes va = VertexAttributes::interpolate(\n v1, v2, v3, b[0], b[1], b[2]);\n // Only render fragments within the bi-unit cube\n if (va.position.z() >= -1 && va.position.z() <= 1) {\n FragmentAttributes frag =\n shaders.fragment_shader(va, uniform);\n shaders.blending_shader(frag, frame_buffer(i, j));\n }\n }\n }\n }\n });\n}\n\nvoid rasterize_triangles(\n const Shaders& shaders,\n const UniformAttributes& uniform,\n const std::vector& vertices,\n FrameBuffer& frame_buffer)\n{\n // Call vertex shader on all vertices (parallel)\n std::vector v(vertices.size());\n tbb::parallel_for(\n tbb::blocked_range(size_t(0), vertices.size()),\n [&](const tbb::blocked_range& r) {\n for (size_t i = r.begin(); i < r.end(); i++) {\n v[i] = shaders.vertex_shader(vertices[i], uniform);\n }\n });\n\n tbb::enumerable_thread_specific storage(frame_buffer);\n\n // Call the rasterization function on every triangle\n assert(vertices.size() % 3 == 0);\n tbb::parallel_for(\n tbb::blocked_range(size_t(0), vertices.size() / 3),\n [&](const tbb::blocked_range r) {\n FrameBuffer& local_frame_buffer = storage.local();\n\n for (size_t i = r.begin(); i < r.end(); i++) {\n rasterize_triangle(\n shaders, uniform, v[i * 3 + 0], v[i * 3 + 1], v[i * 3 + 2],\n local_frame_buffer);\n }\n });\n\n // Blend the frame buffers\n for (const FrameBuffer& local_frame_buffer : storage) {\n tbb::parallel_for(\n tbb::blocked_range2d(\n 0, frame_buffer.rows(), 0, frame_buffer.cols()),\n\n [&](const tbb::blocked_range2d& r) {\n for (size_t i = r.rows().begin(); i < r.rows().end(); i++) {\n for (size_t j = r.cols().begin(); j < r.cols().end(); j++) {\n shaders.blending_shader(\n local_frame_buffer(i, j), frame_buffer(i, j));\n }\n }\n });\n }\n}\n\nvoid rasterize_line(\n const Shaders& shaders,\n const UniformAttributes& uniform,\n const VertexAttributes& v1,\n const VertexAttributes& v2,\n Float line_thickness,\n FrameBuffer& frame_buffer)\n{\n // Collect coordinates into a matrix and convert to canonical\n // representation\n Eigen::Matrix p;\n p.row(0) = v1.position.array() / v1.position[3];\n p.row(1) = v2.position.array() / v2.position[3];\n\n // Coordinates are in -1..1, rescale to pixel size (x,y only)\n p.col(0) = ((p.col(0).array() + 1.0) / 2.0) * frame_buffer.rows();\n p.col(1) = ((p.col(1).array() + 1.0) / 2.0) * frame_buffer.cols();\n\n // Find bounding box in pixels, adding the line thickness\n int lx = std::floor(p.col(0).minCoeff() - line_thickness);\n int ly = std::floor(p.col(1).minCoeff() - line_thickness);\n int ux = std::ceil(p.col(0).maxCoeff() + line_thickness);\n int uy = std::ceil(p.col(1).maxCoeff() + line_thickness);\n\n // Clamp to framebuffer\n lx = std::min(std::max(lx, int(0)), int(frame_buffer.rows() - 1));\n ly = std::min(std::max(ly, int(0)), int(frame_buffer.cols() - 1));\n ux = std::max(std::min(ux, int(frame_buffer.rows() - 1)), int(0));\n uy = std::max(std::min(uy, int(frame_buffer.cols() - 1)), int(0));\n\n // We only need the 2d coordinates of the endpoints of the line\n Vector2F l1(p(0, 0), p(0, 1));\n Vector2F l2(p(1, 0), p(1, 1));\n\n // Parametrize the line as l1 + t (l2-l1)\n Float t = -1;\n Float ll = (l1 - l2).squaredNorm();\n\n // Rasterize the line\n tbb::parallel_for(\n tbb::blocked_range2d(lx, ux + 1, ly, uy + 1),\n [&](const tbb::blocked_range2d& r) {\n for (size_t i = r.rows().begin(); i != r.rows().end(); i++) {\n for (size_t j = r.cols().begin(); j != r.cols().end(); j++) {\n // The pixel center is offset by 0.5, 0.5\n Vector2F pixel(i + 0.5, j + 0.5);\n\n if (ll == 0.0)\n // The segment has zero length\n t = 0;\n else {\n // Project p on the line\n t = (pixel - l1).dot(l2 - l1) / ll;\n // Clamp between 0 and 1\n t = std::fmax(0, std::fmin(1, t));\n }\n\n Vector2F pixel_p = l1 + t * (l2 - l1);\n\n if ((pixel - pixel_p).squaredNorm()\n < (line_thickness * line_thickness)) {\n VertexAttributes va = VertexAttributes::interpolate(\n v1, v2, v1, 1 - t, t, 0);\n // Only render fragments within the bi-unit cube\n if (va.position[2] >= -1 && va.position[2] <= 1) {\n FragmentAttributes frag =\n shaders.fragment_shader(va, uniform);\n shaders.blending_shader(frag, frame_buffer(i, j));\n }\n }\n }\n }\n });\n}\n\nvoid rasterize_lines(\n const Shaders& shaders,\n const UniformAttributes& uniform,\n const std::vector& vertices,\n Float line_thickness,\n FrameBuffer& frame_buffer)\n{\n // Call vertex shader on all vertices (parallel)\n std::vector v(vertices.size());\n tbb::parallel_for(\n tbb::blocked_range(size_t(0), vertices.size()),\n [&](const tbb::blocked_range& r) {\n for (size_t i = r.begin(); i < r.end(); i++) {\n v[i] = shaders.vertex_shader(vertices[i], uniform);\n }\n });\n\n tbb::enumerable_thread_specific storage(frame_buffer);\n\n // Call the rasterization function on every line\n assert(vertices.size() % 2 == 0);\n tbb::parallel_for(\n tbb::blocked_range(size_t(0), vertices.size() / 2),\n [&](const tbb::blocked_range r) {\n FrameBuffer& local_frame_buffer = storage.local();\n\n for (size_t i = r.begin(); i < r.end(); i++) {\n rasterize_line(\n shaders, uniform, v[i * 2 + 0], v[i * 2 + 1],\n line_thickness, local_frame_buffer);\n }\n });\n\n // Blend the frame buffers\n for (const FrameBuffer& local_frame_buffer : storage) {\n tbb::parallel_for(\n tbb::blocked_range2d(\n 0, frame_buffer.rows(), 0, frame_buffer.cols()),\n\n [&](const tbb::blocked_range2d& r) {\n for (size_t i = r.rows().begin(); i < r.rows().end(); i++) {\n for (size_t j = r.cols().begin(); j < r.cols().end(); j++) {\n shaders.blending_shader(\n local_frame_buffer(i, j), frame_buffer(i, j));\n }\n }\n });\n }\n}\n\nvoid framebuffer_to_uint8(\n const FrameBuffer& frame_buffer, std::vector& image)\n{\n const int w = frame_buffer.rows(); // Image width\n const int h = frame_buffer.cols(); // Image height\n const int comp = 4; // 4 Channels Red, Green, Blue, Alpha\n const int stride_in_bytes = w * comp; // Length of one row in bytes\n image.resize(w * h * comp, 0); // The image itself;\n\n for (unsigned wi = 0; wi < w; ++wi) {\n for (unsigned hi = 0; hi < h; ++hi) {\n unsigned hif = h - 1 - hi;\n image[(hi * w * 4) + (wi * 4) + 0] = frame_buffer(wi, hif).color[0];\n image[(hi * w * 4) + (wi * 4) + 1] = frame_buffer(wi, hif).color[1];\n image[(hi * w * 4) + (wi * 4) + 2] = frame_buffer(wi, hif).color[2];\n image[(hi * w * 4) + (wi * 4) + 3] = frame_buffer(wi, hif).color[3];\n }\n }\n}\n\n} // namespace swr\n", "meta": {"hexsha": "11d0c813c936932d0e7a3334b4b55ea976ab8919", "size": 10502, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/raster.cpp", "max_stars_repo_name": "zfergus/software-renderer", "max_stars_repo_head_hexsha": "97fe94bb9eb0038378484d6e7f34866cfe399389", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-09-01T02:10:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-01T02:10:14.000Z", "max_issues_repo_path": "src/raster.cpp", "max_issues_repo_name": "zfergus/software-renderer", "max_issues_repo_head_hexsha": "97fe94bb9eb0038378484d6e7f34866cfe399389", "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/raster.cpp", "max_forks_repo_name": "zfergus/software-renderer", "max_forks_repo_head_hexsha": "97fe94bb9eb0038378484d6e7f34866cfe399389", "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": 38.6102941176, "max_line_length": 80, "alphanum_fraction": 0.5192344315, "num_tokens": 2838, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942067038785, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.5421466678508493}} {"text": "#define _USE_MATH_DEFINES\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"yaml-cpp/yaml.h\"\n#include \n#include \"mpc_car_batch/optim_batch.h\"\n\n\n#include \"geometry_msgs/msg/pose_array.hpp\"\n#include \"rclcpp/rclcpp.hpp\"\n// #include \"nav_msgs/msg/odometry.hpp\"\n// #include \"geometry_msgs/msg/twist.hpp\"\n// #include \"geometry_msgs/msg/vector3.hpp\"\n#include \"msgs_car/msg/controls.hpp\"\n#include \"msgs_car/msg/states.hpp\"\n\n#define MPC 0\nusing namespace std;\nusing namespace optim;\nusing std::placeholders::_1;\n\nclass MinimalPublisher : public rclcpp::Node\n{\n public:\n \n ArrayXXf lane, tot_time, x_g, y_g, tot_time_up;\n ArrayXXf x_obs_temp, y_obs_temp, vx_obs, vy_obs, old, meta_cost;\n\n three_var PPP, PPP_up;\n probData prob_data;\n float x_init, y_init, v_init, psi_init, psidot_init, total_time, speed, avg_time, avg_speed;\n float prev_v_send, prev_w_send, w0, w1, w2, w3;\n\n bool Gotit, warm;\n\n float min = 1000000;\n int index, cnt, loop;\n clock_t start, end;\n ofstream outdata, outdata2, outdata3, outdata4;\n\n MinimalPublisher(): Node(\"minimal_publisher\"), count_(0)\n {\n Gotit = false;\n warm = true;\n\n avg_speed = 0.0;\n speed = 0.0;\n total_time = 0.0;\n avg_time = 0.0;\n index = 0;\n loop = 0;\n prev_v_send = 0.0;\n prev_w_send = 0.0;\n\n x_init = 0.0;\n y_init = 10.0;\n v_init = 15.0;\n psi_init = 0.0;\n psidot_init = 0.0;\n\n prob_data.t_fin = 8.0;\n prob_data.num = 100;\n prob_data.t = prob_data.t_fin/prob_data.num;\n prob_data.weight_smoothness = 2.5;\n prob_data.weight_psi = 5;\n prob_data.maxiter = 100;\n prob_data.num_obs = 6;\n prob_data.v_max = 24.0;\n prob_data.a_max = 4.0;\n prob_data.a_obs = 5.6;\n prob_data.b_obs = 3.0;\n prob_data.rho_ineq = 1.0;\n prob_data.rho_psi = 1.0;\n prob_data.rho_nonhol = 1.0;\n prob_data.rho_obs = 1.0;\n prob_data.weight_smoothness_psi = 5.0;\n\n tot_time = ArrayXXf(prob_data.num, 1);\n tot_time.col(0).setLinSpaced(prob_data.num, 0.0, prob_data.t_fin);\n\n PPP = compute_bernstein(tot_time, prob_data.t_fin, prob_data.num);\n prob_data.nvar = PPP.a.cols();\n\n //__________________________________________________________________________\n tot_time_up = ArrayXXf((int)(prob_data.t_fin/0.008), 1);\n tot_time_up.col(0).setLinSpaced(prob_data.t_fin/0.008, 0.0, prob_data.t_fin);\n \n PPP_up = compute_bernstein(tot_time_up, prob_data.t_fin, prob_data.t_fin/0.008);\n prob_data.Pdot_upsample = PPP_up.b;\n //__________________________________________________________________________\n \n prob_data.cost_smoothness = prob_data.weight_smoothness * PPP.c.transpose().matrix() * PPP.c.matrix();\n prob_data.cost_smoothness_psi = prob_data.weight_smoothness_psi * PPP.c.transpose().matrix() * PPP.c.matrix();\n prob_data.lincost_smoothness_psi = 0 * ones(prob_data.nvar, 1);\n\n prob_data.A_eq = ArrayXXf(3, prob_data.nvar);\n prob_data.A_eq_psi = ArrayXXf(4, prob_data.nvar);\n \n prob_data.A_eq << PPP.a.row(0), PPP.b.row(0), PPP.a.row(PPP.a.rows() - 1);\n prob_data.A_eq_psi << PPP.a.row(0), PPP.b.row(0), PPP.a.row(PPP.a.rows() - 1), PPP.b.row(PPP.b.rows() - 1);\n\n prob_data.A_nonhol = PPP.b;\n prob_data.A_psi = PPP.a;\n prob_data.A_ineq = PPP.c;\n prob_data.A_acc = PPP.c;\n \n prob_data.A_obs = stack(PPP.a, PPP.a, 'v');\n for (int i = 0; i < prob_data.num_obs - 2; i++)\n prob_data.A_obs = stack(prob_data.A_obs, PPP.a, 'v');\n \n\n x_obs_temp = ArrayXXf(prob_data.num_obs, 1);\n y_obs_temp = ArrayXXf(prob_data.num_obs, 1);\n vx_obs = ArrayXXf(prob_data.num_obs, 1);\n vy_obs = ArrayXXf(prob_data.num_obs, 1);\n\n x_obs_temp = 0;\n y_obs_temp = 0;\n vx_obs = 0;\n vy_obs = 0.0;\n\n YAML::Node map = YAML::LoadFile(\"src/mpc_car_batch/config.yaml\");\n \n string setting = map[\"setting\"].as();\n\n prob_data.num_goal = map[\"configuration\"][setting][\"goal\"].as();\n w0 = map[\"configuration\"][setting][\"weights\"][0].as();\n w1 = map[\"configuration\"][setting][\"weights\"][1].as();\n w2 = map[\"configuration\"][setting][\"weights\"][2].as();\n w3 = map[\"configuration\"][setting][\"weights\"][3].as();\n \n x_g = ArrayXXf(prob_data.num_goal, 1);\n y_g = ArrayXXf(prob_data.num_goal, 1);\n\n meta_cost = ArrayXXf(prob_data.num_goal, 9);\n meta_cost = -1;\n\n\t\tfor(int i = 0; i < prob_data.num_goal; i++)\n {\n x_g(i) = map[\"configuration\"][setting][\"x_g\"][i].as();\n y_g(i) = map[\"configuration\"][setting][\"y_g\"][i].as();\n meta_cost(i, 0) = i+1;\n }\n // cout << x_g;\n old = x_g;\n\n \n subscription_ = this->create_subscription(\n \"ego_vehicle_obs\", 10, std::bind(&MinimalPublisher::topic_callback, this, _1));\n\n publisher_ = this->create_publisher(\"ego_vehicle_cmds\", 10);\n timer_ = this->create_wall_timer(10ms, bind(&MinimalPublisher::timer_callback, this));\n cnt = 1;\n\n RCLCPP_INFO(this->get_logger(),\"NODES ARE UP\");\n // outdata.open(map[\"configuration\"][setting][\"file\"].as());\n }\n \n private:\n void topic_callback(const msgs_car::msg::States::SharedPtr msg)\n {\n \n x_init = msg->x[0];\n y_init = msg->y[0];\n v_init = sqrt(msg->vx[0] * msg->vx[0] + msg->vy[0] * msg->vy[0]);\n psi_init = msg->psi[0];\n psidot_init = msg->psidot; \n \n x_obs_temp << msg->x[1], msg->x[2], msg->x[3], msg->x[4], msg->x[5], msg->x[6];\n y_obs_temp << msg->y[1], msg->y[2], msg->y[3], msg->y[4], msg->y[5], msg->y[6];\n vx_obs << msg->vx[1], msg->vx[2], msg->vx[3], msg->vx[4], msg->vx[5], msg->vx[6];\n vy_obs << msg->vy[1], msg->vy[2], msg->vy[3], msg->vy[4], msg->vy[5], msg->vy[6];\n\n if(loop == 0)\n prev_v_send = v_init;\n \n Gotit = 1;\n }\n void timer_callback();\n void get_ranks();\n rclcpp::TimerBase::SharedPtr timer_;\n rclcpp::Subscription::SharedPtr subscription_;\n rclcpp::Publisher::SharedPtr publisher_;\n size_t count_;\n};\n\nvoid MinimalPublisher :: get_ranks()\n{\n float v_cruise = 15.0;\n for(int i = 0; i < prob_data.num_goal; i++)\n {\n meta_cost(i, 1) = (prob_data.v.row(i) - v_cruise).matrix().lpNorm<2>(); // 5\n meta_cost(i, 2) = prob_data.res_obs.row(i).matrix().lpNorm<2>(); // 6\n meta_cost(i, 3) = (prob_data.y.row(i) - (-10)).matrix().lpNorm<2>(); // 7\n meta_cost(i, 4) = (prob_data.v.row(i) - 24).matrix().lpNorm<2>(); // 8\n meta_cost(i, 5) = -1;\n meta_cost(i, 6) = -1;\n meta_cost(i, 7) = -1;\n meta_cost(i, 8) = -1;\n }\n float inf = std::numeric_limits::infinity();\n for(int i = 0; i < prob_data.num_goal; i++)\n {\n float min0 = inf, min1 = inf, min2 = inf, min3 = inf; \n int index0 = -1, index1 = -1, index2 = -1, index3 = -1;\n for(int j = 0; j < prob_data.num_goal; j++)\n {\n if(meta_cost(j, 1) < min0 && meta_cost(j, 5) < 0)\n {\n min0 = meta_cost(j, 1);\n index0 = j;\n }\n if(meta_cost(j, 2) < min1 && meta_cost(j, 6) < 0)\n {\n min1 = meta_cost(j, 2);\n index1 = j;\n }\n if(meta_cost(j, 3) < min2 && meta_cost(j, 7) < 0)\n {\n min2 = meta_cost(j, 3);\n index2 = j;\n }\n if(meta_cost(j, 4) < min3 && meta_cost(j, 8) < 0)\n {\n min3 = meta_cost(j, 4);\n index3 = j;\n }\n }\n meta_cost(index0, 5) = i+1; // cruise \n meta_cost(index1, 6) = i+1; // optimal\n meta_cost(index2, 7) = i+1; // rightmost lane\n meta_cost(index3, 8) = i+1; // max average velocity\n }\n}\nvoid MinimalPublisher :: timer_callback()\n{\n auto message = msgs_car::msg::Controls();\n \n if(Gotit)\n {\n \n x_g = old + x_init;\n cnt+=1;\n \n start = clock();\n prob_data = mpc(prob_data, PPP, x_g, y_g, x_init, y_init, v_init, psi_init, psidot_init, x_obs_temp, y_obs_temp, \n vx_obs, vy_obs, warm);\n end = clock();\n warm = false;\n \n get_ranks();\n min = 100000000;\n index = 5;\n // cruise = 50, 50, 0, 0\n // righlane = 0, 50, 50, 0\n // highspeed rightlane = 0, 50, 25, 25\n\n //ngsim2 hsrl 0, 60, 19, 21\n for(int i = 0; i < prob_data.num_goal; i++)\n {\n float cost = w0 * meta_cost(i, 5) + w1 * meta_cost(i, 6) + w2 * meta_cost(i, 7) + w3 * meta_cost(i, 8); \n // cruise optimal rightlane max avg velocity\n if( cost < min)\n {\n min = cost; \n index = i;\n } \n }\n // message.w = prob_data.w_controls.row(index).leftCols(18).mean();\n // message.v = prob_data.v_controls.row(index).leftCols(18).mean();\n message.w = prob_data.psidot.row(index).leftCols(3).mean();\n message.v = prob_data.v.row(index).leftCols(3).mean();\n\n message.index = index;\n message.goals = prob_data.num_goal;\n loop++;\n \n speed += message.v;\n total_time += double(end - start) / double(CLOCKS_PER_SEC);\n avg_speed = speed/loop;\n avg_time = total_time/loop;\n\n // outdata << x_init << \" \" << y_init << \" \" << psi_init << \" \" << message.v << \" \" << message.w \n // << \" \" << (message.v - prev_v_send)/prob_data.t << \" \" << (message.w - prev_w_send)/prob_data.t\n // << \" \" << double(end - start) / double(CLOCKS_PER_SEC) << \" \" << loop << \" \" << index << endl;\n // outdata2 << prob_data.x << \" \" << prob_data.y << endl;\n prev_v_send = message.v;\n\t\tprev_w_send = message.w;\n\n for(int i = 0; i < prob_data.num_goal; i++)\n {\n for(int j = 0; j < prob_data.num; j++)\n {\n geometry_msgs::msg::Pose pose;\n pose.position.x = prob_data.x(i, j);\n pose.position.y = prob_data.y(i, j);\n message.batch.poses.push_back(pose); \n }\n }\n // RCLCPP_INFO(this->get_logger(),\"Time taken = %f index = %d res_obs = %f\", time_taken, index, prob_data.res_obs.matrix().lpNorm<2>());\n RCLCPP_INFO(this->get_logger(),\"Average time = %f Average speed = %f\", avg_time, avg_speed);\n publisher_->publish(message);\n Gotit = false;\n }\n \n}\n\nint main(int argc, char * argv[])\n{\n \n rclcpp::init(argc, argv);\n rclcpp::spin(std::make_shared());\n rclcpp::shutdown();\n return 0;\n}", "meta": {"hexsha": "1be7bc60b63738cee6f1bfe9b697bb1d9217f831", "size": 11319, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ros_ws/src/mpc_car_batch/src/main_batch.cpp", "max_stars_repo_name": "vivek-uka/Batch-Opt-Highway-Driving", "max_stars_repo_head_hexsha": "6aa10d723b437a2d598b4b5111f8282fabc09e1c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 9.0, "max_stars_repo_stars_event_min_datetime": "2022-01-24T11:07:58.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-05T07:55:28.000Z", "max_issues_repo_path": "ros_ws/src/mpc_car_batch/src/main_batch.cpp", "max_issues_repo_name": "vivek-uka/Batch-Opt-Highway-Driving", "max_issues_repo_head_hexsha": "6aa10d723b437a2d598b4b5111f8282fabc09e1c", "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": "ros_ws/src/mpc_car_batch/src/main_batch.cpp", "max_forks_repo_name": "vivek-uka/Batch-Opt-Highway-Driving", "max_forks_repo_head_hexsha": "6aa10d723b437a2d598b4b5111f8282fabc09e1c", "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": 35.371875, "max_line_length": 144, "alphanum_fraction": 0.5468680979, "num_tokens": 3287, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942067038785, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.5421466678508493}} {"text": "#pragma once\n// matrix_generators.hpp: generators for special matrices\n//\n// Copyright (C) 2017-2020 Stillwater Supercomputing, Inc.\n//\n// This file is part of the HPRBLAS project, which is released under an MIT Open Source license.\n#include \n#include \n#include \n#include \n#include \n\nnamespace sw {\nnamespace hprblas {\n\n// fill a dense matrix with random values between [lowerbound, upperbound]\ntemplate \nvoid uniform_rand(Matrix& A, double lowerbound = 0.0, double upperbound = 1.0)\n{\n\t// Use random_device to generate a seed for Mersenne twister engine.\n\tstd::random_device rd{};\n\t// Use Mersenne twister engine to generate pseudo-random numbers.\n\tstd::mt19937 engine{ rd() };\n\t// \"Filter\" MT engine's output to generate pseudo-random double values,\n\t// **uniformly distributed** on the closed interval [lowerbound, upperbound].\n\t// (Note that the range is [inclusive, inclusive].)\n\tstd::uniform_real_distribution dist{ lowerbound, upperbound };\n\t// Pattern to generate pseudo-random number.\n\t// double rnd_value = dist(engine);\n\n\ttypedef typename mtl::Collection::value_type value_type;\n\ttypedef typename mtl::Collection::size_type size_type;\n\n\t// inserters add to the elements, so we need to set the value to 0 before we begin\n\tA = 0.0;\n\t{ // extra block unfortunately needed for VS2013\n\t\t// Create inserter for matrix m\n\t\tmtl::mat::inserter ins(A, num_cols(A));\n\n\t\t// generate and insert random values in A\n\t\tfor (size_type r = 0; r < num_rows(A); r++) {\n\t\t\tfor (size_type c = 0; c < num_cols(A); c++) {\n\t\t\t\tins[r][c] << value_type(dist(engine));\n\t\t\t}\n\t\t}\n\t\t// Destructor of ins sets final state of m\n\t}\n}\n\n// create a dense matrix with random values between [lowerbound, upperbound]\ntemplate\nmtl::mat::dense2D uniform_rand(size_t m, size_t n, double lowerbound = 0.0, double upperbound = 1.0) {\n\tmtl::mat::dense2D A(m, n);\n\tuniform_rand(A, lowerbound, upperbound);\n\treturn A;\n}\n\n// fill a dense MTL matrix with random values between [lowerbound, upperbound]\ntemplate \nvoid uniform_rand_sorted(Matrix& A, double lowerbound = 0.0, double upperbound = 1.0)\n{\n\t// Use random_device to generate a seed for Mersenne twister engine.\n\tstd::random_device rd{};\n\t// Use Mersenne twister engine to generate pseudo-random numbers.\n\tstd::mt19937 engine{ rd() };\n\t// \"Filter\" MT engine's output to generate pseudo-random double values,\n\t// **uniformly distributed** on the closed interval [lowerbound, upperbound].\n\t// (Note that the range is [inclusive, inclusive].)\n\tstd::uniform_real_distribution dist{ lowerbound, upperbound };\n\t// Pattern to generate pseudo-random number.\n\t// double rnd_value = dist(engine);\n\n\ttypedef typename mtl::Collection::value_type value_type;\n\ttypedef typename mtl::Collection::size_type size_type;\n\n\t// generate a good set of randoms\n\tstd::vector v(size(A));\n\tfor (size_type r = 0; r < num_rows(A); ++r) {\n\t\tfor (size_type c = 0; c < num_cols(A); ++c) {\n\t\t\tv.push_back(value_type(dist(engine)));\n\t\t}\n\t}\n\t// sort them so that we have better control over the scale of each element in a row vector\n\tsort(v.begin(), v.end(), std::greater());\n\n\t// for each row minus the last column, calculate the sum of elements without rounding\n\tsw::unum::posit one(1), p;\n\tfor (size_type r = 0; r < num_rows(A); ++r) {\n\t\tsw::unum::quire q1, q2;\n\t\tsize_type lastElement = num_cols(A) - 1;\n\t\tfor (size_type c = 0; c < lastElement; ++c) {\n\t\t\tq1 += sw::unum::quire_mul(one, v[r*num_cols(A) + c]);\n\t\t}\n\t\t// truncate the value in the quire\n\t\tconvert(q1.to_value(), p);\n\t\t// calculate the difference between the truncated and the non-truncated quire values\n\t\tq2 = p;\n//\t\t\t\tstd::cout << \"q1 :\" << q1 << std::endl;\n//\t\t\t\tstd::cout << \"q2 :\" << q2 << std::endl;\n\t\tq2 -= q1;\n\t\tconvert(q2.to_value(), p);\n//\t\t\t\tstd::cout << \"Residual is: \" << double(p) << std::endl;\n//\t\tif (p.iszero()) p = one;\n\t\tv[r*num_cols(A) + lastElement] = p;\n\t}\n\n\n\t// inserters add to the elements, so we need to set the value to 0 before we begin\n\tA = 0;\n\t{ // extra block unfortunately needed for VS2013\n\t\t// Create inserter for matrix m\n\t\tmtl::mat::inserter ins(A, num_cols(A));\n\n\t\t// insert sorted values in A\n\t\tsize_type i = 0;\n\t\tfor (size_type r = 0; r < num_rows(A); r++) {\n\t\t\tfor (size_type c = 0; c < num_cols(A); c++) {\n\t\t\t\tins[r][c] << v[i++];\n\t\t\t}\n\t\t}\n\t\t// Destructor of ins sets final state of m\n\t}\n}\n\n// fill a dense MTL matrix with diagonally dominant random values between [lowerbound, upperbound]\ntemplate\nvoid uniform_rand_diagonally_dominant(Matrix& A, double lowerbound = 0.0, double upperbound = 1.0) {\n\t// generate off-diagonal entries, calculate the sum, scale to upperbound, and set diagonal entry to slightly larger\n\n\t// Use random_device to generate a seed for Mersenne twister engine.\n\tstd::random_device rd{};\n\t// Use Mersenne twister engine to generate pseudo-random numbers.\n\tstd::mt19937 engine{ rd() };\n\t// \"Filter\" MT engine's output to generate pseudo-random double values,\n\t// **uniformly distributed** on the closed interval [lowerbound, upperbound].\n\t// (Note that the range is [inclusive, inclusive].)\n\tstd::uniform_real_distribution dist{ lowerbound, upperbound };\n\t// Pattern to generate pseudo-random number.\n\t// double rnd_value = dist(engine);\n\n\ttypedef typename mtl::Collection::value_type value_type;\n\ttypedef typename mtl::Collection::size_type size_type;\n\n\t// no need to null A as each element is assigned explicitely\n\tfor (size_type r = 0; r < num_rows(A); ++r) {\n\t\t// generate a random vector of N\n\t\tsize_type N = num_cols(A);\n\t\tmtl::dense_vector v(N);\n\t\tfor (size_type c = 0; c < N; ++c) {\n\t\t\tv[c] = value_type(dist(engine));\n\t\t}\n\t\t// add the sum of the other row elements to the diagonal\n\t\tfor (size_type c = 0; c < N; ++c) {\n\t\t\tif (r != c) v[r] += v[c];\n\t\t}\n\t\tvalue_type factor = v[r] / upperbound;\n\t\tfor (size_type c = 0; c < N; ++c) {\n\t\t\tA[r][c] = v[c] / factor;\n\t\t}\n\t}\n}\n\n// Random Orthogonal Matrices\n\n/*\nStandard methods for generating random orthogonal matrices with Haar distribution \nare based on the method of Heiberger (1978). With this method, an (n x\u0002 n) matrix A is\nfirst generated with entries xij \u0018~ Normal(0; 1). Then a QR factorization (X = QR) is computed. \nThis method provides a random Q with correct distribution.\n*/\ntemplate\nvoid uniform_random_orthogonal_Heiberger(Matrix& Q) {\n\t// Use random_device to generate a seed for Mersenne twister engine.\n\tstd::random_device rd{};\n\t// Use Mersenne twister engine to generate pseudo-random numbers.\n\tstd::mt19937 engine{ rd() };\n\t// \"Filter\" MT engine's output to generate pseudo-random double values,\n\t// **uniformly distributed** on the closed interval [lowerbound, upperbound].\n\t// (Note that the range is [inclusive, inclusive].)\n\tstd::uniform_real_distribution dist{ 0.0, 1.0 };\n\t// Pattern to generate pseudo-random number.\n\t// double rnd_value = dist(engine);\n\n\ttypedef typename mtl::Collection::value_type value_type;\n\ttypedef typename mtl::Collection::size_type size_type;\n\tMatrix A(mtl::mat::num_rows(Q), mtl::mat::num_cols(Q));\n\tMatrix R(mtl::mat::num_rows(Q), mtl::mat::num_cols(Q));\n\n\t// fill X with elements from Normal(0,1)\n\t// inserters add to the elements, so we need to set the value to 0 before we begin\n\tA = 0.0;\n\t{ // extra block unfortunately needed for VS2013\n\t\t// Create inserter for matrix A\n\t\tmtl::mat::inserter ins(A, num_cols(A));\n\n\t\t// insert random values in A\n\t\tfor (size_type r = 0; r < num_rows(A); r++) {\n\t\t\tfor (size_type c = 0; c < num_cols(A); c++) {\n\t\t\t\tins[r][c] << value_type(dist(engine));\n\t\t\t}\n\t\t}\n\t\t// Destructor of ins sets final state of A\n\t}\n\t// QR method to generate orthonormal matrix Q\n\tmtl::mat::qr(A, Q, R);\n\tstd::cout << A << std::endl;\n\tstd::cout << Q << std::endl;\n\tstd::cout << R << std::endl;\n}\n/*\nC.3: Generating a Random Matrix with Specified Eigenvalues\nGenerate random orthogonal matrix G. W. Stewart (1980).\n\nstart RandOrthog(n);\nA = I(n); // identity matrix \nd = j(n, 1, 0);\nd[n] = sgn(RndNormal(1, 1)); // +/- 1 \ndo k = n - 1 to 1 by - 1;\n\t// generate random Householder transformation \n\tx = RndNormal(n - k + 1, 1); // column vector from N(0,1) \n\ts = sqrt(x[##]); // norm(x) \n\tsgn = sgn(x[1]);\n\ts = sgn*s;\n\td[k] = -sgn;\n\tx[1] = x[1] + s;\n\tbeta = s*x[1];\n\t// apply the Householder transformation to A \n\ty = x`*A[k:n, ];\n\tA[k:n, ] = A[k:n, ] - x*(y / beta);\nend;\nA = d # A; // change signs of i_th row when d[i]=-1 \nreturn(A);\nfinish;\n\n// helper functions \n// return matrix of same size as A with\n// m[i,j]= { 1 if A[i,j]>=0\n// { -1 if A[i,j]< 0\n// Similar to the SIGN function, except SIGN(0)=0 \nstart sgn(A);\n\treturn(choose(A >= 0, 1, -1));\nfinish;\n\n// return (r x c) matrix of standard normal variates \nstart RndNormal(r, c);\n\tx = j(r, c);\n\tcall randgen(x, \"Normal\");\n\treturn(x);\nfinish;\n\n// The following statements call the RANDORTHOG function to generate a random 4x4 orthogonal matrix.\ncall randseed(1);\nQ = RandOrthog(4);\nprint(Q);\n*/\ntemplate\nvoid uniform_rand_orthogonal(Matrix& A) {\n\n}\n\n//\n// fill a dense upper-triangular matrix with elements: [i][j] = 0.5 + (1 + j - i)*0.5\ntemplate \nvoid fill_U(Matrix& A, double lowerbound = 0.0, double upperbound = 1.0)\n{\n\tusing namespace mtl;\n\ttypedef typename Collection::value_type value_type;\n\ttypedef typename Collection::size_type size_type;\n\n\t// inserters add to the elements, so we need to set the value to 0 before we begin\n\tA = 0.0;\n\t{ // extra block unfortunately needed for VS2013\n\t\t// Create inserter for matrix m\n\t\tmat::inserter ins(A, num_cols(A));\n\n\t\t// generate and insert random values in A\n\t\tfor (size_type r = 0; r < num_rows(A); r++) {\n\t\t\tfor (size_type c = r; c < num_cols(A); c++) {\n\t\t\t\tins[r][c] << value_type(0.5) + value_type(1 + c - r)*value_type(0.5);\n\t\t\t\tins[r][c] << value_type(1.0);\n\t\t\t}\n\t\t}\n\t\t// Destructor of ins sets final state of m\n\t}\n}\n\n// fill a dense lower-triangular matrix with elements: [i][j] = 0.5 + (1 + i - j)*0.5\ntemplate \nvoid fill_L(Matrix& A, double lowerbound = 0.0, double upperbound = 1.0)\n{\n\tusing namespace mtl;\n\ttypedef typename Collection::value_type value_type;\n\ttypedef typename Collection::size_type size_type;\n\n\t// inserters add to the elements, so we need to set the value to 0 before we begin\n\tA = 0.0;\n\t{ // extra block unfortunately needed for VS2013\n\t\t// Create inserter for matrix m\n\t\tmat::inserter ins(A, num_cols(A));\n\n\t\t// generate and insert random values in A\n\t\tfor (size_type r = 0; r < num_rows(A); r++) {\n\t\t\tfor (size_type c = 0; c <= r; c++) {\n\t\t\t\tins[r][c] << value_type(0.5) + value_type(1 + r - c)*value_type(0.5);\n\t\t\t\tins[r][c] << value_type(1.0);\n\n\t\t\t}\n\t\t}\n\t\t// Destructor of ins sets final state of m\n\t}\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////\n/// Hilbert matrices\n\n// Greatest Common Divisor of two numbers, a and b\ntemplate\nIntegerType gcd(IntegerType a, IntegerType b)\n{\n\tif (b == IntegerType(0))\treturn a;\n\treturn gcd(b, a % b);\n}\n\n// Least Common Multiple of n numbers\ntemplate\nIntegerType findlcm(const std::vector& v)\n{\n\tIntegerType lcm = v[0];\n\tfor (size_t i = 1; i < v.size(); i++) {\n\t\tlcm = (v[i] * lcm) / gcd(v[i], lcm);\n\t}\n\treturn lcm;\n}\n\n// Generate the scaling factor of a Hilbert matrix so that its elements are representable\n// that is, no infinite expensions of rationals, such as 1/3, 1/10, etc.\ntemplate\nIntegerType HilbertScalingFactor(IntegerType N) {\n\tstd::vector coef;\n\tfor (IntegerType i = 2; i <= N; ++i) coef.push_back(i);\n\tfor (IntegerType j = 2; j <= N; ++j) coef.push_back(N + j - IntegerType(1));\n\treturn findlcm(coef);\n}\n\n// Generate a scaled/unscaled Hilbert matrix depending on the bScale parameter\ntemplate\nsize_t GenerateHilbertMatrix(mtl::mat::dense2D& M, bool bScale = true) {\n\tassert(M.num_rows() == M.num_cols());\n\tsize_t N = M.num_rows();\n\tsize_t lcm = HilbertScalingFactor(N); // always calculate the Least Common Multiplier\n\tScalar scale = bScale ? Scalar(lcm) : Scalar(1);\n\tfor (int i = 1; i <= N; ++i) {\n\t\tfor (int j = 1; j <= N; ++j) {\n\t\t\tM[i - 1][j - 1] = scale / Scalar(i + j - 1);\n\t\t}\n\t}\n\treturn lcm;\n}\n\ntemplate\nvoid GenerateHilbertMatrixInverse(mtl::mat::dense2D& m, Scalar scale = Scalar(1.0)) {\n\tassert(m.num_rows() == m.num_cols());\n\tsize_t N = m.num_rows();\n\tfor (int i = 1; i <= N; ++i) {\n\t\tfor (int j = 1; j <= N; ++j) {\n\t\t\tScalar sign = ((i + j) % 2) ? Scalar(-1) : Scalar(1);\n\t\t\tScalar factor1 = Scalar(i + j - 1);\n\t\t\tScalar factor2 = Scalar(sw::function::binomial(N + i - 1, N - j));\n\t\t\tScalar factor3 = Scalar(sw::function::binomial(N + j - 1, N - i));\n\t\t\tScalar factor4 = Scalar(sw::function::binomial(i + j - 2, i - 1));\n\t\t\tm[i - 1][j - 1] = Scalar(sign * factor1 * factor2 * factor3 * factor4 * factor4);\n\t\t\t/* for tracing dynamic range failures\n\t\t\tstd::cout << \"element \" << i << \",\" << j << std::endl;\n\t\t\tstd::cout << \"sign \" << sign << std::endl;\n\t\t\tstd::cout << \"factor1 \" << factor1 << std::endl;\n\t\t\tstd::cout << \"factor2 \" << factor2 << std::endl;\n\t\t\tstd::cout << \"factor3 \" << factor3 << std::endl;\n\t\t\tstd::cout << \"factor4 \" << factor4 << std::endl;\n\t\t\t*/\n\t\t}\n\t}\n}\n\n// isEqual compares to matrices\ntemplate\nbool isEqual(const Matrix& lhs, const Matrix& rhs) {\n\tsize_t r = lhs.num_rows();\n\tsize_t c = lhs.num_cols();\n\tfor (size_t i = 0; i < r; ++i) {\n\t\tfor (size_t j = 0; j < c; ++j) {\n\t\t\tif (lhs[i][j] != rhs[i][j]) return false;\n\t\t}\n\t}\n\treturn true;\n}\n\n} // namespace hprblas\n} // namespace sw\n", "meta": {"hexsha": "279b2178ec845ebc8b14876f645bde44dc943768", "size": 13959, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/generators/matrix_generators.hpp", "max_stars_repo_name": "fossabot/hpr-blas", "max_stars_repo_head_hexsha": "dad4656f556ea62abddbf3ddbb712d6b77fe7e91", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/generators/matrix_generators.hpp", "max_issues_repo_name": "fossabot/hpr-blas", "max_issues_repo_head_hexsha": "dad4656f556ea62abddbf3ddbb712d6b77fe7e91", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/generators/matrix_generators.hpp", "max_forks_repo_name": "fossabot/hpr-blas", "max_forks_repo_head_hexsha": "dad4656f556ea62abddbf3ddbb712d6b77fe7e91", "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.984962406, "max_line_length": 116, "alphanum_fraction": 0.6645175156, "num_tokens": 4145, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7154239836484143, "lm_q2_score": 0.757794360334681, "lm_q1q2_score": 0.5421442600569394}} {"text": "/*\n Copyright (c) 2018-2019 Alexander A. Ganin. All rights reserved.\n Twitter: @alxga. Website: alexganin.com.\n Licensed under the MIT License.\n See LICENSE file in the project root for full license information.\n*/\n\n#include \"stdafx.h\"\n#include \"Utils/rand01.h\"\n\n#ifdef HAVE_BOOST\n\n#include \n#include \nusing namespace boost;\nusing namespace boost::random;\n\nstatic double boost_rand_0_1()\n{\n static mt19937 eng(((unsigned int) time(NULL)) * rand());\n static uniform_01<> dist;\n static variate_generator> var(eng, dist);\n return var();\n}\n\n#endif\n\n\n// Minimal random number generator of Park and Miller with Bays-Durham shuffle and added\n// safeguards. Returns a uniform random deviate between 0.0 and 1.0 (exclusive of the endpoint\n// values). Call with idum a negative integer to initialize; thereafter, do not alter idum between\n// successive deviates in a sequence. RNMX should approximate the largest floating value that is\n// less than 1\n\n#define IA 16807\n#define IM 2147483647\n#define AM (1.0/IM)\n#define IQ 127773\n#define IR 2836\n#define NTAB 32\n#define NDIV (1+(IM-1)/NTAB)\n#define EPS 1.2e-7\n#define RNMX (1.0-EPS)\n\nstatic double park_miller_rand_0_1(long *idum)\n{\n int j;\n long k;\n static long iy = 0;\n static long iv[NTAB];\n double temp;\n\n if (*idum <= 0 || !iy)\n {\n // Initialize\n if (-(*idum) < 1)\n *idum = 1; // Be sure to prevent idum = 0\n else\n *idum = -(*idum);\n\n for (j = NTAB + 7; j >= 0; j--)\n { // Load the shuffle table (after 8 warm-ups)\n k = (*idum) / IQ;\n *idum = IA * (*idum - k * IQ) - IR * k;\n if (*idum < 0) *idum += IM;\n if (j < NTAB) iv[j] = *idum;\n }\n iy = iv[0];\n }\n\n k = (*idum) / IQ; // Start here when not initializing\n *idum = IA * (*idum - k * IQ) - IR*k; // Compute idum = (IA * idum) % IM without overlows by Schrage's method\n if (*idum < 0)\n *idum += IM;\n\n j = iy / NDIV; // Will be in the range 0 ... NTAB-1\n iy = iv[j]; // Output previously stored value and refill the shuffle table\n iv[j] = *idum;\n if ((temp = AM * iy) > RNMX)\n return RNMX; // Because users don't expect endpoint values\n else\n return temp;\n}\n\n\ndouble Rand01::generate()\n{\n // return boost_rand_0_1();\n static long seed = -rand();\n return park_miller_rand_0_1(&seed);\n}\n", "meta": {"hexsha": "1f6c12c8ed3c041a5a2b66d039a69625b86cf9c5", "size": 2340, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "rand01.cpp", "max_stars_repo_name": "alxga/utils", "max_stars_repo_head_hexsha": "01ca9fb2084ba5e7bead20b45f52b3557ce8c337", "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": "rand01.cpp", "max_issues_repo_name": "alxga/utils", "max_issues_repo_head_hexsha": "01ca9fb2084ba5e7bead20b45f52b3557ce8c337", "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": "rand01.cpp", "max_forks_repo_name": "alxga/utils", "max_forks_repo_head_hexsha": "01ca9fb2084ba5e7bead20b45f52b3557ce8c337", "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.4347826087, "max_line_length": 111, "alphanum_fraction": 0.6457264957, "num_tokens": 736, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789178257654, "lm_q2_score": 0.6688802669716107, "lm_q1q2_score": 0.5421133549301601}} {"text": "#include \n#include \"servicecontainer.h\"\n\n\ndouble compile_time_expression_structure::serviceContainer::degrees(double rad)\n{\n constexpr double pi = boost::math::constants::pi();\n return rad * 180.0 / pi;\n}\n\ndouble compile_time_expression_structure::serviceContainer::radians(double deg)\n{\n constexpr double pi = boost::math::constants::pi();\n return deg * pi / 180.0;\n}\n\n// const std::map\n// compile_time_expression_structure::serviceContainer::global_constants\n// {\n// {constantId::pi, boost::math::constants::pi()},\n// {constantId::e, boost::math::constants::e()}\n// };\n// \n// const std::map\n// compile_time_expression_structure::serviceContainer::global_constants_id\n// {\n// {\"pi\", constantId::pi},\n// {\"e\", constantId::e}\n// };\n// \n// \n// const std::map\n// compile_time_expression_structure::serviceContainer::global_variables_id\n// {\n// {\"x\", variableId::x},\n// {\"y\", variableId::y},\n// {\"r\", variableId::r}\n// };\n", "meta": {"hexsha": "e2b44cde86c180d2a36c50283758dcbc18e830ed", "size": 1201, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ctexpression/servicecontainer.cpp", "max_stars_repo_name": "vega1986/wcalc_expression_parser", "max_stars_repo_head_hexsha": "e9645a5fa8086c4108ce4dc1f3ad7da3cead6480", "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": "ctexpression/servicecontainer.cpp", "max_issues_repo_name": "vega1986/wcalc_expression_parser", "max_issues_repo_head_hexsha": "e9645a5fa8086c4108ce4dc1f3ad7da3cead6480", "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": "ctexpression/servicecontainer.cpp", "max_forks_repo_name": "vega1986/wcalc_expression_parser", "max_forks_repo_head_hexsha": "e9645a5fa8086c4108ce4dc1f3ad7da3cead6480", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.7948717949, "max_line_length": 79, "alphanum_fraction": 0.7010824313, "num_tokens": 287, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104788903594354, "lm_q2_score": 0.6688802735722128, "lm_q1q2_score": 0.5421133419081227}} {"text": "/*\n * This is part of the fl library, a C++ Bayesian filtering library\n * (https://github.com/filtering-library)\n *\n * Copyright (c) 2015 Max Planck Society,\n * \t\t\t\t Autonomous Motion Department,\n * \t\t\t Institute for Intelligent Systems\n *\n * This Source Code Form is subject to the terms of the MIT License (MIT).\n * A copy of the license can be found in the LICENSE file distributed with this\n * source code.\n */\n\n/**\n * \\file cauchy_distribution.hpp\n * \\date August 2015\n * \\author Jan Issac (jan.issac@gmail.com)\n */\n\n#pragma once\n\n#include \n\n#include \n#include \n\nnamespace fl\n{\n\n/**\n * \\ingroup distributions\n *\n * \\brief CauchyDistribution represents a multivariate cauchy distribution. It\n * is a special case of student's t-distribution and is equal to\n * \\f$t_1(\\mu, \\Sigma)\\f$.\n */\ntemplate \nclass CauchyDistribution\n : public TDistribution\n{\npublic:\n /**\n * Creates a dynamic or fixed size multivariate cauchy distribution\n *\n * \\param dimension Dimension of the distribution. The default is defined by\n * the dimension of the variable type \\em Vector. If the\n * size of the Variate at compile time is fixed, this will\n * be adapted. For dynamic-sized Variable the dimension is\n * initialized to 0.\n */\n explicit CauchyDistribution(int dim = DimensionOf())\n : TDistribution(Real(1), dim)\n { }\n};\n\n}\n", "meta": {"hexsha": "1768db0ce9d37ed05442c0547a3a22833a3490b4", "size": 1546, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/fl/distribution/cauchy_distribution.hpp", "max_stars_repo_name": "aeolusbot-tommyliu/fl", "max_stars_repo_head_hexsha": "a50d0c9620a8f86e0cd14a5e22ee0f022d00bd02", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 17.0, "max_stars_repo_stars_event_min_datetime": "2015-07-03T06:53:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-15T20:55:12.000Z", "max_issues_repo_path": "include/fl/distribution/cauchy_distribution.hpp", "max_issues_repo_name": "aeolusbot-tommyliu/fl", "max_issues_repo_head_hexsha": "a50d0c9620a8f86e0cd14a5e22ee0f022d00bd02", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2015-02-20T12:48:17.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-18T08:45:13.000Z", "max_forks_repo_path": "include/fl/distribution/cauchy_distribution.hpp", "max_forks_repo_name": "aeolusbot-tommyliu/fl", "max_forks_repo_head_hexsha": "a50d0c9620a8f86e0cd14a5e22ee0f022d00bd02", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 15.0, "max_forks_repo_forks_event_min_datetime": "2015-02-20T11:34:14.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-15T20:55:13.000Z", "avg_line_length": 27.1228070175, "max_line_length": 80, "alphanum_fraction": 0.6636481242, "num_tokens": 361, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104788995148791, "lm_q2_score": 0.6688802603710086, "lm_q1q2_score": 0.5421133373327208}} {"text": "// FastIterativePca.cpp : Defines the entry point for the console application.\n//\n\n#include \"stdafx.h\"\n#include \n#include \n#include \n#include \n\n//you need boost to compile\n#include \n#include \n#include \n \n\n#pragma region ServiceFunctions\ntemplate\n__inline void normalizeL2(Collection& collection)\n{\n\ttypedef typename Collection::value_type value_type;\n\tvalue_type summ = std::accumulate(collection.begin(), collection.end(), (value_type)0, [](value_type & a, value_type b)->value_type{a = a + sqr(b); return a; });\n\tsumm = sqrt(summ);\n\tif (summ < std::numeric_limits::epsilon())\n\t\treturn;\n\tstd::for_each(collection.begin(), collection.end(), [summ](value_type& val)\n\t{\n\t\tval /= summ;\n\t});\n}\n\n\n\ntemplate\n__inline OutArg dotProduct(const VecIn1& a, const VecIn2& b)\n{\n\tOutArg prod = 0;\n\tfor (int i = 0; i < (int)a.size(); i++)\n\t{\n\t\tprod += static_cast(a[i]) * static_cast(b[i]);\n\t}\n\treturn prod;\n}\ntemplate\n__inline Type sqr(Type t)\n{\n\treturn t * t;\n}\ndouble selectRandom(double a, double b, int range)\n{\n\treturn a + (b - a) *(rand() % range) / (range - 1);\n}\n\n\n\n\nstruct NormalRandomGenerator\n{\npublic:\n\ttypedef boost::normal_distribution NormalDistribution;\n\ttypedef boost::variate_generator VarGen;\n\ttypedef boost::shared_ptr VarGenPtr;\npublic:\n\tNormalRandomGenerator() :\n\t\tm_normalDist(0.0, 1.0)\n\t{\n\t\tm_varNor.reset(new VarGen(m_rng, m_normalDist));\n\t}\n\tvoid setParams(double middle, double sigma)\n\t{\n\t\tm_normalDist = boost::normal_distribution(middle, sigma);\n\t\tm_varNor.reset(new VarGen(m_rng, m_normalDist));\n\t}\n\tdouble generate()\n\t{\n \n\t\treturn (*m_varNor)();\n\t}\nprivate:\n\tNormalDistribution m_normalDist;\n\tVarGenPtr m_varNor;\n\tboost::mt19937 m_rng;\n};\n#pragma endregion ServiceFunctions\n\n\n\ntemplate\nstruct FastIterativePcaSelector\n{\n\ttypedef boost::array Element;\n\ttypedef std::vector Elements;\n\ttypedef std::vector Weights;\n\n\tElement getFirstPC(const Elements& elements, const Weights& weights, int numIterations, const Elements& prevBazis)\n\t{\n\t\t//sds we maximze projections on space with size 2\n\t\tstd::vector currentVecs(2);\n\t\tfor (int i1 = 0; i1 < 2; i1++)\n\t\t{\n\t\t\tif (i1 == 0)\n\t\t\t\tcurrentVecs[i1] = selectRandomVec(prevBazis);\n\t\t\telse\n\t\t\t{\n\t\t\t\tcurrentVecs[i1] = getRandomOrthogonalVec(currentVecs[0], prevBazis);\n\t\t\t}\n\t\t}\n\t\tdouble bestSigma = 0;\n\t\tfor (int i1 = 0; i1 < numIterations; i1++)\n\t\t{\n\t\t\tElement currentApproximation = getApproximation(currentVecs.data(), elements, weights);\n\t\t\tElement newVec = getRandomOrthogonalVec(currentApproximation, prevBazis);\n\t\t\tcurrentVecs[0] = currentApproximation;\n\t\t\tcurrentVecs[1] = newVec;\n\t\t\tdouble sigma = calcSigma(elements, weights, currentApproximation);\n\t\t\t//stop criterion -- stabilization\n\t\t\tif (abs(sigma - bestSigma) < sigma * 0.00000001)\n\t\t\t\tbreak;\n\n\t\t\tstd::cout << \"num component \" << prevBazis.size() << \" \" << \"current sigma \" << sigma << std::endl;\n\t\t}\n\t\treturn currentVecs[0];\n\t}\n\tstatic double calcSigma(const Elements& elements, const Weights& weights, const Element& element)\n\t{\n\t\tdouble sigma = 0;\n\t\tfor (int i1 = 0; i1 < (int)elements.size(); i1++)\n\t\t{\n\t\t\tsigma += sqr(dotProduct(elements[i1], element))* weights[i1];\n\t\t}\n\t\treturn sigma;\n\t}\nprivate:\n\t\n\tstatic Element selectRandomVec(const Elements& prevBazis)\n\t{\n\t\t//select random vector, orthogonal to previous got bazis\n\t\tElement result;\n\t\tfloat dp = 0;\n\t\t\n\n\t\t//try new vector until it has some orthogonal part to previous bazis\n\t\tdo\n\t\t{\n\t\t\tfor (int i1 = 0; i1 < (int)result.size(); i1++)\n\t\t\t{\n\t\t\t\tresult[i1] = (float)selectRandom(-1.0f, 1.0f, 1000);\n\t\t\t}\n\t\t\tfor (int i1 = 0; i1 < (int)prevBazis.size(); i1++)\n\t\t\t{\n\t\t\t\tfloat dp = dotProduct(result, prevBazis[i1]);\n\t\t\t\tfor (int i2 = 0; i2 < (int)result.size(); i2++)\n\t\t\t\t{\n\t\t\t\t\tresult[i2] = result[i2] - prevBazis[i1][i2] * dp;\n\t\t\t\t}\n\t\t\t}\n\t\t\tnormalizeL2(result);\n\t\t\tdp = dotProduct(result, result);\n\t\t} while (dp < 0.99);\n\t\treturn result;\n\t}\n\tstatic Element getRandomOrthogonalVec(const Element& vec, const Elements& prevBazis)\n\t{\n\t\t\n\t\tElement result;\n\t\tfloat dp = 0;\n\t\t//try new vector until it has some orthogonal part to previous part and current best vector (vec) \n\t\tdo\n\t\t{\n\t\t\tresult = selectRandomVec(prevBazis);\n\t\t\tdp = dotProduct(result, vec);\n\t\t\tfor (int i1 = 0; i1 < (int)result.size(); i1++)\n\t\t\t{\n\t\t\t\tresult[i1] = result[i1] - vec[i1] * dp;\n\t\t\t}\n\t\t\tnormalizeL2(result);\n\t\t\tdp = dotProduct(result, result);\n\t\t} while (dp < 0.5f);\n\t\treturn result;\n\t}\n\n\n\n\tElement getApproximation(const Element* approximationStack, const Elements& elements, const Weights& weights)\n\t{\n\t\t/*\n\t\tMaximize decomposition to R2 space spanned on two vectors .\n\t\t2 Plum -- you could use int D(w) * H(w) dw instead\n\t\t*/\n\t\t\n\t\t//fill covariation matrix\n\t\tdouble matrix[4] = { 0., 0., 0., 0. };\n\t\tfor (int i0 = 0; i0 < (int)weights.size(); i0++)\n\t\t{\n\t\t\tfloat dps[2] = { dotProduct(approximationStack[0], elements[i0]), dotProduct(approximationStack[1], elements[i0]) };\n\t\t\tfor (int i1 = 0; i1 < 2; i1++)\n\t\t\t{\n\t\t\t\tfor (int i2 = 0; i2 < 2; i2++)\n\t\t\t\t{\n\t\t\t\t\tmatrix[i1 * 2 + i2] += dps[i1] * dps[i2] * weights[i0];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t//calc eigen vectors/values\n\t\tdouble offset = (matrix[0] + matrix[3]);\n\t\tdouble d = std::max(sqr(matrix[0] - matrix[3]) + 4 * (matrix[1] * matrix[2]), 0.);\n\t\td = sqrt(d);\n\t\tdouble eV = offset < 0 ? offset / 2.0 - d / 2.0 : offset / 2.0 + d / 2.0;\n\t\tfloat coeffs[2];\n\t\tif (abs(matrix[0] - eV) > abs(matrix[3] - eV))\n\t\t{\n\t\t\tcoeffs[0] = static_cast(matrix[1] / (matrix[0] - eV));\n\t\t\tcoeffs[1] = -1.f;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tcoeffs[0] = -1.f;\n\t\t\tcoeffs[1] = static_cast(matrix[2] / (matrix[3] - eV));\n\t\t}\n\t\t//make decomposition\n\t\tElement result;\n\t\tfor (int i1 = 0; i1 < (int)approximationStack[0].size(); i1++)\n\t\t{\n\t\t\tresult[i1] = approximationStack[0][i1] * coeffs[0] + approximationStack[1][i1] * coeffs[1];\n\t\t}\n\t\tnormalizeL2(result);\n\t\treturn result;\n\t}\n\n\n\n\n\n\n\n};\n//test function shows, how to use\nstruct FastIterativePcaSelectorTest\n{\n\tstatic const int numDimensions = 10000;\n\ttypedef FastIterativePcaSelector FiPC;\n\ttypedef FiPC::Element Element;\n\ttypedef FiPC::Elements Elements;\n\tvoid test()\n\t{\n\t\tstd::vector sigmas(numDimensions);\n\t\tstd::vector > normalDistributions(numDimensions);\n\t\t//generate some random distribution\n\t\tfor (int i1 = 0; i1 < (int)sigmas.size(); i1++)\n\t\t{\n\t\t\tsigmas[i1] = 0.2 + (rand() & 0xff)*(200.0 - 0.2) / 255.0;\n\t\t\tnormalDistributions[i1].reset(new NormalRandomGenerator());\n\t\t\tnormalDistributions[i1]->setParams(0, sigmas[i1]);\n\t\t}\n\t\tint maxElt = std::max_element(sigmas.begin(), sigmas.end()) - sigmas.begin();\n\t\tint numElements = 200;\n\t\tstd::vector elements(numElements);\n\t\t//assign all weights to 1\n\t\tstd::vector weights(numElements);\n\t\tfor (int i1 = 0; i1 < (int)elements.size(); i1++)\n\t\t{\n\t\t\tfor (int i2 = 0; i2 < numDimensions; i2++)\n\t\t\t{\n\t\t\t\telements[i1][i2] = (float)normalDistributions[i2]->generate();\n\t\t\t}\n\t\t\tweights[i1] = 1.0;\n\t\t}\n\t\t//calc reference sigma along main axis\n\t\tElement bestElt;\n\t\tstd::fill(bestElt.begin(), bestElt.end(), 0.f);\n\t\tbestElt[maxElt] = 1.0;\n\n\n\n\t\tdouble bestSigma = FiPC().calcSigma(elements, weights, bestElt);\n\t\tstd::cout << bestSigma << std::endl;\n\t\tElements bazis;\n\t\tElement middle;\n\t\tstd::fill(middle.begin(), middle.end(), 1.0f);\n\t\tnormalizeL2(middle);\n\t\t//insert middle in bazis, to maximize only zero mean vectors\n\t\tbazis.push_back(middle);\n\t\tstatic const int numComponents = 10;\n\t\tboost::shared_ptr fipcPtr(new FiPC());\n\t\t{\n\t\t\tfor (int i1 = 0; i1 < numComponents; i1++)\n\t\t\t{\n\t\t\t\tElement comp = fipcPtr->getFirstPC(elements, weights, numDimensions, bazis);\n\t\t\t\tbazis.push_back(comp);\n\t\t\t}\n\t\t\tint j = 0;\n\t\t}\n\n\t}\nprivate:\n\n\n};\n\nint _tmain(int argc, _TCHAR* argv[])\n{\n\tFastIterativePcaSelectorTest().test();\n\treturn 0;\n}\n\n", "meta": {"hexsha": "b578048b8d2a24736206d05d33867c05fddd0f39", "size": 8065, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "FastIterativePca/FastIterativePca.cpp", "max_stars_repo_name": "sdeniskos/FastIterativePca", "max_stars_repo_head_hexsha": "891c287bef9dbf32a49d0ddbf3062a46ed9dd106", "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": "FastIterativePca/FastIterativePca.cpp", "max_issues_repo_name": "sdeniskos/FastIterativePca", "max_issues_repo_head_hexsha": "891c287bef9dbf32a49d0ddbf3062a46ed9dd106", "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": "FastIterativePca/FastIterativePca.cpp", "max_forks_repo_name": "sdeniskos/FastIterativePca", "max_forks_repo_head_hexsha": "891c287bef9dbf32a49d0ddbf3062a46ed9dd106", "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.3562091503, "max_line_length": 162, "alphanum_fraction": 0.6654680719, "num_tokens": 2539, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867873410141, "lm_q2_score": 0.6791787121629466, "lm_q1q2_score": 0.5421114742917497}} {"text": "/** @file planar.cc\n * @author David F. Gleich\n * @date 2008-09-29\n * @copyright Stanford University, 2008\n * Planar graph algorithm wrappers\n */\n\n/** History\n * 2008-09-29: Initial coding\n */\n\n#include \"include/matlab_bgl.h\"\n\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#include \n\n#include \n#include \n#include \n\n#include \n\n#include \"libmbgl_util.hpp\"\n\n/** Copy an edge iterator to a pair of arrays\n */\ntemplate \nmbglIndex copy_to_ij(Graph& g, Iterator oi,\n Iterator oi_end, mbglIndex* i, mbglIndex* j)\n{\n using namespace boost;\n\n mbglIndex ei;\n for (ei= 0; oi != oi_end; ++oi, ++ei) {\n typename graph_traits::edge_descriptor e = *oi;\n i[ei] = source(e,g);\n j[ei] = target(e,g);\n }\n\n return (ei);\n}\n\n/** Translate the boost embedding information to the libmbgl embedding output\n */\ntemplate \nvoid copy_embedding(Graph& g, PlanarEmbedding e, mbglIndex *eip, mbglIndex *eie)\n{\n using namespace boost;\n typename graph_traits::vertex_iterator vi, viend;\n mbglIndex nedges= num_edges(g);\n mbglIndex curi= 0;\n mbglIndex nullv= graph_traits::null_vertex();\n mbglIndex oldv= nullv;\n for (boost::tie(vi,viend)=vertices(g); vi!=viend; ++vi) {\n if (oldv!=nullv) { assert(*vi==oldv+1); }\n assert(*vi::value_type::const_iterator\n ei=e[*vi].begin(), eiend=e[*vi].end();\n for (; ei!=eiend; ++ei) {\n assert(source(*ei,g) == *vi || target(*ei,g) == *vi);\n assert(curi crs_graph;\n crs_graph g(nverts, nverts, ia[nverts], ia, ja, NULL);\n\n //Define the storage type for the planar embedding\n typedef std::vector< std::vector< graph_traits::edge_descriptor > >\n embedding_storage_t;\n typedef boost::iterator_property_map\n < embedding_storage_t::iterator,\n property_map::type\n >\n embedding_t;\n\n\n bool planar=false;\n if ((i == NULL || j == NULL || nedges == NULL) &&\n (eip == NULL || eip == NULL)) {\n // just test for a planar graph\n planar= boyer_myrvold_planarity_test(g);\n } else if (eip == NULL || eie == NULL ) {\n // just get the kuratowski subgraph\n std::vector::edge_descriptor>\n kuratowski_edges;\n planar= boyer_myrvold_planarity_test(\n boyer_myrvold_params::graph = g,\n boyer_myrvold_params::kuratowski_subgraph =\n std::back_inserter(kuratowski_edges)\n );\n if (planar == false) {\n *nedges =\n copy_to_ij(g, kuratowski_edges.begin(), kuratowski_edges.end(), i, j);\n } else { *nedges = 0; }\n } else if (i == NULL || j == NULL || nedges == NULL) {\n embedding_storage_t embedding_storage(num_vertices(g));\n embedding_t embedding(embedding_storage.begin(), get(vertex_index,g));\n planar= boyer_myrvold_planarity_test(boyer_myrvold_params::graph = g,\n boyer_myrvold_params::embedding = embedding\n );\n if (planar == true) {\n copy_embedding(g, embedding, eip, eie);\n } else {\n memset(eip, 0, sizeof(mbglIndex)*(nverts+1));\n }\n } else {\n // get the kuratowski subgraph and the planar embedding\n std::vector::edge_descriptor>\n kuratowski_edges;\n embedding_storage_t embedding_storage(num_vertices(g));\n embedding_t embedding(embedding_storage.begin(), get(vertex_index,g));\n planar= boyer_myrvold_planarity_test(\n boyer_myrvold_params::graph = g,\n boyer_myrvold_params::embedding = embedding,\n boyer_myrvold_params::kuratowski_subgraph =\n std::back_inserter(kuratowski_edges)\n );\n if (planar == false) {\n *nedges =\n copy_to_ij(g, kuratowski_edges.begin(), kuratowski_edges.end(), i, j);\n } else { *nedges = 0; }\n if (planar == true) {\n copy_embedding(g, embedding, eip, eie);\n } else {\n memset(eip, 0, sizeof(mbglIndex)*(nverts+1));\n }\n }\n if (is_planar) {\n if (planar) { *is_planar = 1; }\n else { *is_planar = 0; }\n }\n return (0);\n}\n\n/** An edge filter that only returns the edges in an upper-triangular part\n */\ntemplate \nstruct upper_triangle_edge_filter {\n upper_triangle_edge_filter() : _g(NULL) {}\n upper_triangle_edge_filter(const Graph& g_) : _g(&g_) {}\n template \n bool operator()(const Edge& e) const {\n return (boost::source(e,*_g) < boost::target(e,*_g));\n }\n const Graph* _g;\n};\n\n\n/** Test is a graph is Kuratowski (i.e. contracts to K_3,3 or K_5)\n * This function only uses the upper triangular set of edges. It will\n * silently report incorrect ouput if there are too many parallel edges,\n * so beware.\n * @param nverts the number of vertices in the graph\n * @param ja the connectivity for each vertex\n * @param ia the row connectivity points into ja\n * @param is_ksubgraph set to 1 if the graph is Kuratowski\n */\nint is_kuratowski_subgraph(\n mbglIndex nverts, mbglIndex *ja, mbglIndex *ia,\n int *is_ksubgraph)\n{\n using namespace boost;\n using namespace yasmic;\n\n typedef simple_csr_matrix crs_graph;\n typedef upper_triangle_edge_filter filter;\n typedef filtered_graph fgraph;\n assert(is_ksubgraph);\n crs_graph g(nverts, nverts, ia[nverts], ia, ja, NULL);\n filter f(g);\n fgraph fg(g,f);\n graph_traits::edge_iterator ei, eiend;\n boost::tie(ei,eiend)= edges(fg);\n bool is_k= is_kuratowski_subgraph(g, ei, eiend, get(vertex_index,g));\n if (is_k) { *is_ksubgraph = 1; } else { *is_ksubgraph = 0; }\n return (0);\n}\n\n/** Test if a given set of positions is a straight line drawing of the graph.\n * This function uses a bucket-sort, and so large positions may cause out\n * of memory errors.\n *\n * @param nverts the number of vertices in the graph\n * @param ja the connectivity for each vertex\n * @param ia the row connectivity points into ja\n * @param X The set of positions. These are rounded to size_t variables and so\n * all the elements of X must be positive.\n * @param is_sldrawing set to 1 if the positions are a straight line drawing,\n * otherwise set to 0\n */\nint is_straight_line_drawing(\n mbglIndex nverts, mbglIndex *ja, mbglIndex *ia,\n double *X, int *is_sldrawing)\n{\n using namespace boost;\n using namespace yasmic;\n\n typedef simple_csr_matrix crs_graph;\n crs_graph g(nverts, nverts, ia[nverts], ia, ja, NULL);\n assert(is_sldrawing);\n // copy the layout from positions\n std::vector > position_vec(nverts);\n mbglIndex n = num_vertices(g);\n for (mbglIndex i = 0; i\nvoid copy_crs_to_graph(\n mbglIndex nverts, mbglIndex *ja, mbglIndex *ia,\n Graph& g)\n{\n using namespace boost;\n using namespace yasmic;\n typedef simple_csr_matrix crs_graph;\n crs_graph g_in(nverts, nverts, ia[nverts], ia, ja, NULL);\n //typename property_map::type vi(get(vertex_index, g));\n //for (mbglIndex i=0; i::vertex_iterator vi, vi_end;\n typename graph_traits::out_edge_iterator ei, ei_end;\n for (tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) {\n for (tie(ei, ei_end) = out_edges(*vi, g_in); ei != ei_end; ++ei) {\n if (source(*ei,g_in) < target(*ei,g_in)) {\n add_edge(source(*ei,g_in),target(*ei,g_in),g);\n }\n }\n }\n}\n\n/** Add an edge and record all edges we added\n * EdgeSrcOutIterator - the type of the out iterator for the source vertex\n * in the new edge pair\n * EdgeDstOutIterator - the type of the out iterator for the destination vertex\n * in the new edge pair\n * TODO Make this function update the edge_index parameter too! This will avoid\n * O(E) work in a few cases.\n */\ntemplate \nstruct record_add_edge_visitor {\n EdgeSrcOutIterator soi, soi_end;\n EdgeDstOutIterator doi, doi_end;\n mbglIndex* count; // incremented for each additional edge\n\n record_add_edge_visitor(EdgeSrcOutIterator soi_, EdgeSrcOutIterator soi_end_,\n EdgeDstOutIterator doi_, EdgeDstOutIterator doi_end_, mbglIndex* count_)\n : soi(soi_), soi_end(soi_end_), doi(doi_), doi_end(doi_end_), count(count_)\n {}\n\n template \n void visit_vertex_pair(Vertex u, Vertex v, Graph& g) {\n add_edge(u,v,g);\n assert(soi != soi_end);\n assert(doi != doi_end);\n *soi = u;\n *doi = v;\n ++doi;\n ++soi;\n (*count)++;\n }\n};\n\n/** Helper to abstract the details of the triangulation */\ntemplate \nint triangulate_bgl_graph(\n Graph& g, int make_conn, int make_biconnected, int make_maximal,\n RecordAddEdgeVisitor add_edge_visitor)\n{\n using namespace boost;\n typedef std::vector< std::vector<\n typename graph_traits::edge_descriptor > >\n embedding_storage_t;\n typedef boost::iterator_property_map\n < typename embedding_storage_t::iterator,\n typename property_map::type\n >\n embedding_t;\n\n if (make_conn) {\n make_connected(g, get(vertex_index,g), add_edge_visitor);\n }\n if (make_biconnected || make_maximal) {\n typename property_map::type e_index = get(edge_index, g);\n typename graph_traits::edges_size_type edge_count = 0;\n typename graph_traits::edge_iterator ei, ei_end;\n\n // compute a planar embedding\n embedding_storage_t embedding_storage(num_vertices(g));\n embedding_t embedding(embedding_storage.begin(), get(vertex_index,g));\n\n if (make_biconnected) {\n // compute the edge index\n edge_count = 0;\n for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {\n put(e_index, *ei, edge_count++);\n }\n // compute a planar embedding\n if (boyer_myrvold_planarity_test(boyer_myrvold_params::graph = g,\n boyer_myrvold_params::embedding =\n embedding\n )\n ) {\n make_biconnected_planar(g, embedding, get(edge_index,g),\n add_edge_visitor);\n } else {\n return 1;\n }\n }\n if (make_maximal) {\n // compute the edge index\n edge_count = 0;\n for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {\n put(e_index, *ei, edge_count++);\n }\n // compute a planar embedding\n if (boyer_myrvold_planarity_test(boyer_myrvold_params::graph = g,\n boyer_myrvold_params::embedding =\n embedding\n )\n ) {\n make_maximal_planar(g, embedding, get(vertex_index,g),\n get(edge_index,g), add_edge_visitor);\n } else {\n return 1;\n }\n }\n }\n return 0;\n}\n\n\n/** Compute extra edges that are needed for a straight line embedding.\n *\n * @param nverts the number of vertices in the graph\n * @param ja the connectivity for each vertex\n * @param ia the row connectivity points into ja\n * @param make_connected if set (!=0), compute edges to make a single\n * connected component\n * @param make_biconnected If set (!=0), compute edges to make a single\n * biconnected component (requires a planar input graph). If only this\n * parameter is set, then we assume the graph is already connected.\n * @param make_maximal If set (!=0), compute edges to make the maximal\n * planar graph (requires a planar input graph). If only this\n * parameter is set, then we assume the graph is already biconnected.\n * @param i source of all edges added in the triangulation,\n * length max(3*nverts-6,6)\n * @param j dest of all edges added in the triangulation,\n * length max(3*nverts-6,6)\n * @param nedges the number of edges in i and j actually used\n */\nint triangulate_graph(\n mbglIndex nverts, mbglIndex *ja, mbglIndex *ia,\n int make_connected, int make_biconnected, int make_maximal,\n mbglIndex *i, mbglIndex *j, mbglIndex* nedges /* extra edges */)\n{\n using namespace boost;\n typedef adjacency_list\n < vecS, vecS, undirectedS, no_property,\n property > graph;\n assert(i != NULL); assert(j != NULL); assert(nedges != NULL);\n *nedges = 0;\n size_t endedges= nverts>4 ? 3*nverts-6 : 6;\n record_add_edge_visitor add_edge_visitor(\n i, i+endedges, j, j+endedges, nedges);\n graph g(nverts);\n copy_crs_to_graph(nverts, ja, ia, g);\n return triangulate_bgl_graph(\n g, make_connected, make_biconnected, make_maximal, add_edge_visitor);\n}\n\n/** Abstract some details between the csr_graph and the adjacency_list graph\n * for the straight line drawing\n */\ntemplate \nint chrobak_payne_straight_line_drawing_on_maximal_graph(const Graph& g,\n int just_ordering,\n mbglIndex *p, /* ordering permutation */\n mbglDegreeType *X)\n{\n using namespace boost;\n typedef std::vector< std::vector<\n typename graph_traits::edge_descriptor > >\n embedding_storage_t;\n typedef boost::iterator_property_map\n < typename embedding_storage_t::iterator,\n typename property_map::type\n >\n embedding_t;\n\n embedding_storage_t embedding_storage(num_vertices(g));\n embedding_t embedding(embedding_storage.begin(), get(vertex_index,g));\n\n if (boyer_myrvold_planarity_test(boyer_myrvold_params::graph = g,\n boyer_myrvold_params::embedding =\n embedding\n )\n ) {\n // do nothing, the graph is planar\n } else {\n return 1;\n }\n // TODO convert this to use p directly\n mbglIndex n = num_vertices(g);\n assert(n == 0 || p);\n std::vector< typename graph_traits::vertex_descriptor > ordering;\n planar_canonical_ordering(g, embedding,\n std::back_inserter(ordering), get(vertex_index,g));\n\n if (just_ordering == 0) {\n typedef simple_point coord_t;\n typedef std::vector< coord_t > straight_line_drawing_storage_t;\n typedef boost::iterator_property_map\n < straight_line_drawing_storage_t::iterator,\n typename property_map::type\n >\n straight_line_drawing_t;\n\n assert(n == 0 || X);\n // compute the straight line embedding\n straight_line_drawing_storage_t straight_line_drawing_storage\n (num_vertices(g));\n straight_line_drawing_t straight_line_drawing\n (straight_line_drawing_storage.begin(),\n get(vertex_index,g)\n );\n if (n == 2) {\n straight_line_drawing_storage[0].x = 0;\n straight_line_drawing_storage[0].y = 0;\n straight_line_drawing_storage[1].x = 1;\n straight_line_drawing_storage[1].y = 0;\n } else {\n chrobak_payne_straight_line_drawing(g,\n embedding,\n ordering.begin(),\n ordering.end(),\n straight_line_drawing\n );\n }\n // copy all the data\n for (mbglIndex i= 0; i crs_graph;\n crs_graph g(nverts, nverts, ia[nverts], ia, ja, NULL);\n if (nedges) { *nedges = 0; } // already maximal\n return chrobak_payne_straight_line_drawing_on_maximal_graph(g,\n just_ordering, p, X);\n } else {\n typedef adjacency_list\n < vecS, vecS, undirectedS, no_property,\n property > graph;\n graph g(nverts);\n copy_crs_to_graph(nverts, ja, ia, g);\n int rval=0;\n if (i != NULL && j != NULL && nedges != NULL) {\n *nedges = 0;\n size_t endedges= nverts>4 ? 3*nverts-6 : 6;\n record_add_edge_visitor add_edge_visitor(\n i, i+endedges, j, j+endedges, nedges);\n rval= triangulate_bgl_graph(g, 1, 1, 1, add_edge_visitor);\n } else {\n mbglIndex cval1= 0;\n mbglIndex extra_edges= 0;\n typedef yasmic::constant_iterator dummy_iterator;\n dummy_iterator di(&cval1);\n record_add_edge_visitor add_edge_visitor(\n di, di, di, di, &extra_edges);\n rval= triangulate_bgl_graph(g, 1, 1, 1, add_edge_visitor);\n }\n if (rval != 0) { return rval; } // return on error\n return chrobak_payne_straight_line_drawing_on_maximal_graph(g,\n just_ordering, p, X);\n }\n}\n\n\n\n\n\n", "meta": {"hexsha": "89a0caf19b3c456fa5c651d163492b9425494ab8", "size": 20701, "ext": "cc", "lang": "C++", "max_stars_repo_path": "2A/Graphes/TPs/matlab_bgl/libmbgl/planar.cc", "max_stars_repo_name": "anajmedd/ENSEEIHT-Projects", "max_stars_repo_head_hexsha": "e4077fe8882ae35be52e53f29a3a988a0d6f83f0", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 47.0, "max_stars_repo_stars_event_min_datetime": "2016-07-25T00:48:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-17T09:19:03.000Z", "max_issues_repo_path": "2A/Graphes/TPs/matlab_bgl/libmbgl/planar.cc", "max_issues_repo_name": "anajmedd/ENSEEIHT-Projects", "max_issues_repo_head_hexsha": "e4077fe8882ae35be52e53f29a3a988a0d6f83f0", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2016-09-17T19:40:46.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-07T06:49:02.000Z", "max_forks_repo_path": "2A/Graphes/TPs/matlab_bgl/libmbgl/planar.cc", "max_forks_repo_name": "anajmedd/ENSEEIHT-Projects", "max_forks_repo_head_hexsha": "e4077fe8882ae35be52e53f29a3a988a0d6f83f0", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 35.0, "max_forks_repo_forks_event_min_datetime": "2016-07-21T09:13:15.000Z", "max_forks_repo_forks_event_max_datetime": "2019-05-13T14:11:37.000Z", "avg_line_length": 35.5077186964, "max_line_length": 83, "alphanum_fraction": 0.6696294865, "num_tokens": 5654, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867777396212, "lm_q2_score": 0.6791786926816161, "lm_q1q2_score": 0.5421114522209476}} {"text": "#include \n\n#include \n\n#include \n\nusing namespace Ubpa;\n\nusing namespace std;\nusing namespace Eigen;\n \nMinSurf::MinSurf(Ptr triMesh)\n\t: heMesh(make_shared>())\n{\n\tInit(triMesh);\n}\n\nvoid MinSurf::Clear() {\n\theMesh->Clear();\n\ttriMesh = nullptr;\n}\n\nbool MinSurf::Init(Ptr triMesh) {\n\tClear();\n\n\tif (triMesh == nullptr)\n\t\treturn true;\n\n\tif (triMesh->GetType() == TriMesh::INVALID) {\n\t\tprintf(\"ERROR::MinSurf::Init:\\n\"\n\t\t\t\"\\t\"\"trimesh is invalid\\n\");\n\t\treturn false;\n\t}\n\n\t// init half-edge structure\n\tsize_t nV = triMesh->GetPositions().size();\n\tvector> triangles;\n\ttriangles.reserve(triMesh->GetTriangles().size());\n\tfor (auto triangle : triMesh->GetTriangles())\n\t\ttriangles.push_back({ triangle->idx[0], triangle->idx[1], triangle->idx[2] });\n\theMesh->Reserve(nV);\n\theMesh->Init(triangles);\n\n\tif (!heMesh->IsTriMesh() || !heMesh->HaveBoundary()) {\n\t\tprintf(\"ERROR::MinSurf::Init:\\n\"\n\t\t\t\"\\t\"\"trimesh is not a triangle mesh or hasn't a boundaries\\n\");\n\t\theMesh->Clear();\n\t\treturn false;\n\t}\n\n\t// triangle mesh's positions -> half-edge structure's positions\n\tfor (int i = 0; i < nV; i++) {\n\t\tauto v = heMesh->Vertices().at(i);\n\t\tv->pos = triMesh->GetPositions()[i].cast_to();\n\t}\n\n\tthis->triMesh = triMesh;\n\treturn true;\n}\n\nbool MinSurf::Run() {\n\tif (heMesh->IsEmpty() || !triMesh) {\n\t\tprintf(\"ERROR::MinSurf::Run\\n\"\n\t\t\t\"\\t\"\"heMesh->IsEmpty() || !triMesh\\n\");\n\t\treturn false;\n\t}\n\n\tMinimize();\n\n\t// half-edge structure -> triangle mesh\n\tsize_t nV = heMesh->NumVertices();\n\tsize_t nF = heMesh->NumPolygons();\n\tvector positions;\n\tvector indice;\n\tpositions.reserve(nV);\n\tindice.reserve(3 * nF);\n\tfor (auto v : heMesh->Vertices())\n\t\tpositions.push_back(v->pos.cast_to());\n\tfor (auto f : heMesh->Polygons()) { // f is triangle\n\t\tfor (auto v : f->BoundaryVertice()) // vertices of the triangle\n\t\t\tindice.push_back(static_cast(heMesh->Index(v)));\n\t}\n\n\ttriMesh->Init(indice, positions);\n\n\treturn true;\n}\n\nvoid MinSurf::Minimize() {\n\t// TODO\n\tauto bound = heMesh->Boundaries();\n\tvector bound_idx;\n\t//get the index of the boundary\n\tfor (auto& ver : bound)\n\t{\n\t\tfor (auto p_v : ver)\n\t\t{\n\t\t\tbound_idx.push_back(heMesh->Index(p_v->Pair()->End()));\n\t\t}\n\t}\n\t//sort\n\tbound_idx.erase(std::unique(bound_idx.begin(), bound_idx.end()), bound_idx.end());\n\tstd::sort(bound_idx.begin(), bound_idx.end());\n\tconst auto& v = heMesh->Vertices();\n\n\tconst auto mat_size = v.size() - bound_idx.size();\n\tSparseMatrix mat(mat_size, mat_size);\n\t//set matrix\n\tMatrixX3d right = Eigen::MatrixX3d::Zero(mat_size, 3);\n\n\tusing std::cout;\n\t//get the matrix\n\tfor (auto vert : v)\n\t{\n\t\tint index = find_idx(bound_idx, heMesh->Index(vert));\n\t\tif (index != -1) //if the vertex is not in the boundary\n\t\t{\n\t\t\tauto adj_v = vert->AdjVertices(); //get the adjvertexs\n\t\t\tdouble degree = adj_v.size();\n\t\t\tif (index >= mat_size)\n\t\t\t{\n\t\t\t\tcout << \"index=\" << index << \"mat_size=\" << mat_size << endl;\n\t\t\t\tsystem(\"pause\");\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tmat.coeffRef(index, index) ++;\n\t\t\t}\n\t\t\tfor (auto v : adj_v)\n\t\t\t{\n\t\t\t\tint row_idx = find_idx(bound_idx, heMesh->Index(v));\n\t\t\t\tif (row_idx == -1)\n\t\t\t\t{\n\t\t\t\t\tfor (int i = 0; i < 3; i++)\n\t\t\t\t\t{\n\t\t\t\t\t\tright(index, i) += v->pos[i] / degree;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tif (index >= mat_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tcout << \"index:\" << index << endl;\n\t\t\t\t\t\tsystem(\"pause\");\n\t\t\t\t\t}\n\t\t\t\t\telse\tif (row_idx >= mat_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tcout << \"row_index:\" << row_idx << endl;\n\t\t\t\t\t\tsystem(\"pause\");\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t{\n\t\t\t\t\t\tmat.coeffRef(index, row_idx) -= 1 / degree;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t//solve matrix\n\tSparseLU> solver;\n\tsolver.compute(mat);\n\n\tif (solver.info() != Success)\n\t{\n\t\tcerr << \"Unable to decompose the matrix\" << endl;\n\t}\n\n\tauto result = solver.solve(right);\n\t//set vertex\n\tfor (auto vert : v)\n\t{\n\t\tint idx = find_idx(bound_idx, heMesh->Index(vert));\n\t\tif (idx != -1)\n\t\t{\n\t\t\tfor (int i = 0; i < 3; i++)\n\t\t\t{\n\t\t\t\tvert->pos[i] = result(idx, i);\n\t\t\t}\n\t\t}\n\t}\n}\n\n//return the index of the vertex in the matrix above\nconst int MinSurf::find_idx(std::vector& vec, int idx)\n{\n\tint N = vec.size();\n\tif (idx < vec[0]) return idx;\n\tif (idx > vec[N - 1]) return idx - N ;\n\tfor (int i = 0; i < N; i++)\n\t{\n\t\tif (idx == vec[i]) return -1;\n\t\tif (idx < vec[i])\n\t\t{\n\t\t\treturn idx - i;\n\t\t}\n\t}\n}\n\n", "meta": {"hexsha": "1f3f3e94be54ab87e3093d6d6f0d1e5cd06a38c3", "size": 4360, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Homeworks/4_MinSurfMeshPara/project/src/Engine/MeshEdit/MinSurf.cpp", "max_stars_repo_name": "Qinxin-Yan/USTC_CG-1", "max_stars_repo_head_hexsha": "80dc240bea879f000196986b98efcd0bbf8dec34", "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/4_MinSurfMeshPara/project/src/Engine/MeshEdit/MinSurf.cpp", "max_issues_repo_name": "Qinxin-Yan/USTC_CG-1", "max_issues_repo_head_hexsha": "80dc240bea879f000196986b98efcd0bbf8dec34", "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/4_MinSurfMeshPara/project/src/Engine/MeshEdit/MinSurf.cpp", "max_forks_repo_name": "Qinxin-Yan/USTC_CG-1", "max_forks_repo_head_hexsha": "80dc240bea879f000196986b98efcd0bbf8dec34", "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": 21.9095477387, "max_line_length": 83, "alphanum_fraction": 0.6128440367, "num_tokens": 1371, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624789529375, "lm_q2_score": 0.6926419958239132, "lm_q1q2_score": 0.542104901478454}} {"text": "/*\n * This is part of the fl library, a C++ Bayesian filtering library\n * (https://github.com/filtering-library)\n *\n * Copyright (c) 2015 Max Planck Society,\n * \t\t\t\t Autonomous Motion Department,\n * \t\t\t Institute for Intelligent Systems\n *\n * This Source Code Form is subject to the terms of the MIT License (MIT).\n * A copy of the license can be found in the LICENSE file distributed with this\n * source code.\n */\n\n/**\n * \\file t_distribution.hpp\n * \\date August 2015\n * \\author Jan Issac (jan.issac@gmail.com)\n * \\author Cristina Garcia Cifuentes (c.garciacifuentes@gmail.com)\n */\n\n#pragma once\n\n\n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace fl\n{\n\n/**\n * \\ingroup distributions\n *\n * \\brief TDistribution represents a multivariate student's t-distribution\n * \\f$t_\\nu(\\mu, \\Sigma)\\f$, where \\f$\\nu \\in \\mathbb{R} \\f$ is the\n * degree-of-freedom, \\f$\\mu\\in \\mathbb{R}^n\\f$ the distribution location and\n * \\f$\\Sigma \\in \\mathbb{R}^{n\\times n} \\f$ the scaling or covariance matrix.\n */\ntemplate \nclass TDistribution\n : public Moments,\n public Evaluation,\n public StandardGaussianMapping<\n Variate,\n JoinSizes::Value, 1>::Value>\n{\nprivate:\n typedef StandardGaussianMapping<\n Variate,\n JoinSizes::Value, 1>::Value\n > StdGaussianMappingBase;\n\npublic:\n /**\n * \\brief Second moment matrix type, i.e covariance matrix\n */\n typedef typename Moments::SecondMoment SecondMoment;\n\n /**\n * \\brief Represents the StandardGaussianMapping standard variate type which\n * is of the same dimension as the \\c TDistribution \\c Variate. The\n * StandardVariate type is used to sample from a standard normal\n * Gaussian and map it to this \\c TDistribution\n */\n typedef typename StdGaussianMappingBase::StandardVariate StandardVariate;\n\npublic:\n /**\n * \\brief Creates a dynamic or fixed size t-distribution.\n *\n * \\param degrees_of_freedom\n * t-distribution degree-of-freedom\n * \\param dimension Dimension of the distribution. The default is defined by\n * the dimension of the variable type \\em Vector. If the\n * size of the Variate at compile time is fixed, this will\n * be adapted. For dynamic-sized Variable the dimension is\n * initialized to 0.\n */\n explicit TDistribution(Real degrees_of_freedom,\n int dim = DimensionOf())\n : StdGaussianMappingBase(dim + 1),\n chi2_(degrees_of_freedom),\n normal_(dim)\n {\n static_assert(Variate::SizeAtCompileTime != 0,\n \"Illegal static dimension\");\n\n normal_.set_standard();\n }\n\n /**\n * \\brief Overridable default destructor\n */\n virtual ~TDistribution() noexcept { }\n\n /**\n * \\brief Returns a t-distribution sample of the type \\c Variate determined\n * by mapping a standard normal sample into the t-distribution sample space\n *\n * \\param sample Standard normal sample\n *\n * \\throws See Gaussian::map_standard_normal\n */\n Variate map_standard_normal(const StandardVariate& sample) const override\n {\n assert(sample.size() == dimension() + 1);\n\n Real u = chi2_.map_standard_normal(sample.bottomRows(1)(0));\n Variate n = normal_.map_standard_normal(sample.topRows(dimension()));\n\n // rvo\n Variate v = location() + std::sqrt(degrees_of_freedom() / u) * n;\n return v;\n }\n\n /**\n * \\brief Returns the log. probability of the given sample \\c variate\n *\n * Evaluates the t-distribution pdf\n *\n * \\f$ t_\\nu(\\mu, \\Sigma) = \\frac{\\Gamma\\left[(\\nu+p)/2\\right]}\n * {\\Gamma(\\nu/2)\n * \\nu^{p/2}\\pi^{p/2}\n * \\left|{\\boldsymbol\\Sigma}\\right|^{1/2}\n * \\left[1 +\n * \\frac{1}{\\nu}\n * ({\\mathbf x}-{\\boldsymbol\\mu})^T\n * {\\boldsymbol\\Sigma}^{-1}\n * ({\\mathbf x}-{\\boldsymbol\\mu})\\right]^{(\\nu+p)/2}} \\f$\n *\n * at location \\f${\\mathbf x}\\f$\n *\n *\n * \\param variate sample which should be evaluated\n *\n * \\throws See Gaussian::has_full_rank()\n */\n Real log_probability(const Variate& x) const override\n {\n return cached_log_pdf_.log_probability(*this, x);\n }\n\n /**\n * \\brief Returns the Gaussian variate dimension\n */\n virtual int dimension() const\n {\n return normal_.dimension();\n }\n\n /**\n * \\brief Returns a const reference to the t-distribution location (mean)\n */\n const Variate& mean() const override\n {\n return location();\n }\n\n /**\n * \\brief Returns a const reference to t-distribution scaling matrix\n * (covariance matrix)\n *\n * \\throws See Gaussian::covariance()\n */\n const SecondMoment& covariance() const override\n {\n return normal_.covariance();\n }\n\n /**\n * \\brief Returns the const reference to t-distribution location (mean)\n */\n virtual const Variate& location() const\n {\n return normal_.mean();\n }\n\n /**\n * \\brief Returns the t-distribution degree-of-freedom\n */\n virtual Real degrees_of_freedom() const\n {\n return chi2_.degrees_of_freedom();\n }\n\n /**\n * \\brief Changes the dimension of the dynamic-size t-distribution and sets\n * it to a standard distribution with zero mean and identity covariance.\n *\n * \\param new_dimension New dimension of the t-distribution\n *\n * \\throws ResizingFixedSizeEntityException\n * see standard_variate_dimension(int)\n */\n virtual void dimension(int new_dimension)\n {\n StdGaussianMappingBase::standard_variate_dimension(new_dimension + 1);\n normal_.dimension(new_dimension);\n cached_log_pdf_.flag_dirty();\n }\n\n /**\n * \\brief Sets the distribution location\n *\n * \\param location New t-distribution mean\n *\n * \\throws WrongSizeException\n */\n virtual void location(const Variate& new_location) noexcept\n {\n normal_.mean(new_location);\n cached_log_pdf_.flag_dirty();\n }\n\n /**\n * \\brief Sets the covariance matrix\n *\n * \\param covariance New covariance matrix\n *\n * \\throws WrongSizeException\n */\n\n virtual void scaling_matrix(const SecondMoment& scaling_matrix)\n {\n normal_.covariance(scaling_matrix);\n cached_log_pdf_.flag_dirty();\n }\n\n /**\n * \\brief Sets t-distribution degree-of-freedom\n */\n virtual void degrees_of_freedom(Real dof)\n {\n chi2_.degrees_of_freedom(dof);\n cached_log_pdf_.flag_dirty();\n }\n\nprotected:\n /** \\cond internal */\n\n /**\n * \\brief \\f$\\chi^2\\f$ distribution used to generate samples of the\n * t-distribution\n */\n ChiSquared chi2_;\n\n /**\n * \\brief \\f${\\cal N}(\\boldmath{0}, \\Sigma)\\f$ Gaussian distribution used\n * to generate samples of the t-distribution\n */\n Gaussian normal_;\n\n /** \\endcond */\n\n\nprivate:\n class CachedLogPdf\n {\n public:\n CachedLogPdf()\n : dirty_(true)\n { }\n\n /**\n * Evaluates the t-distribution pdf at a given position \\c x\n */\n Real log_probability(\n const TDistribution& t_distr, const Variate& x)\n {\n if (dirty_) update(t_distr);\n\n Variate z = x - t_distr.location();\n Real dof = t_distr.degrees_of_freedom();\n\n Real quad_term = (z.transpose() * t_distr.normal_.precision() * z);\n Real ln_term = std::log(Real(1) + quad_term / dof);\n\n return const_term_ - const_factor_ * ln_term;\n }\n\n void flag_dirty() { dirty_ = true; }\n\n private:\n void update(const TDistribution& t_distr)\n {\n Real half = Real(1)/Real(2);\n Real dim = t_distr.dimension();\n Real dof = t_distr.degrees_of_freedom();\n const_term_ =\n boost::math::lgamma(half * (dof + dim))\n - boost::math::lgamma(half * dof)\n - half * (dim * std::log(M_PI * dof))\n - half * (std::log(t_distr.normal_.covariance_determinant()));\n\n const_factor_ = half * (dof + dim);\n\n dirty_ = false;\n }\n\n bool dirty_;\n Real const_factor_;\n Real const_term_;\n };\n\n friend class CachedLogPdf;\n\n mutable CachedLogPdf cached_log_pdf_;\n};\n\n}\n", "meta": {"hexsha": "d51b1886e15635a56c7d652d1b34a3ad5abbd670", "size": 9114, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/fl/distribution/t_distribution.hpp", "max_stars_repo_name": "aeolusbot-tommyliu/fl", "max_stars_repo_head_hexsha": "a50d0c9620a8f86e0cd14a5e22ee0f022d00bd02", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 17.0, "max_stars_repo_stars_event_min_datetime": "2015-07-03T06:53:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-15T20:55:12.000Z", "max_issues_repo_path": "include/fl/distribution/t_distribution.hpp", "max_issues_repo_name": "aeolusbot-tommyliu/fl", "max_issues_repo_head_hexsha": "a50d0c9620a8f86e0cd14a5e22ee0f022d00bd02", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2015-02-20T12:48:17.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-18T08:45:13.000Z", "max_forks_repo_path": "include/fl/distribution/t_distribution.hpp", "max_forks_repo_name": "aeolusbot-tommyliu/fl", "max_forks_repo_head_hexsha": "a50d0c9620a8f86e0cd14a5e22ee0f022d00bd02", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 15.0, "max_forks_repo_forks_event_min_datetime": "2015-02-20T11:34:14.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-15T20:55:13.000Z", "avg_line_length": 28.3925233645, "max_line_length": 80, "alphanum_fraction": 0.6020408163, "num_tokens": 2175, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8558511322604133, "lm_q2_score": 0.6334102705979902, "lm_q1q2_score": 0.5421048972766647}} {"text": "/**\n *@file main.cpp\n */\n\n#include \n#include \n#include \"time.h\"\n#include \"Solver.h\"\n\n/**\n * @mainpage Calcul et tracé de l'Equation de Schrödinger non relativiste dépendant du temps\n * \n * ## Equation de Schrödinger non relativiste dépendant du temps\n * \n * \\f[ i\\hbar\\frac{\\partial}{\\partial t}\\psi(x,y,t) = \\hat{\\mathcal{H}}_{(x,y)}\\psi(x,y,t) \\f]\n * avec l'opérateur Hamiltonien 2D :\n\\f[\\hat{\\mathcal{H}}_{(x,y)}\\equiv \\frac{\\hat{p}_{(x)}^2}{2m} + \\frac{\\hat{p}_{(y)}^2}{2m} + \\hat{V}(x,y),\\f]\net la quantité de mouvement :\n\\f[\\forall u \\in \\{x,y\\},\\hspace{5mm}\\hat{p}_{(u)}\\equiv -i\\hbar\\frac{\\partial}{\\partial u}.\\f]\nConstantes:\n* \\f$\\hbar\\f$ est la **constante de Planck réduite**\n\\f[\\hbar \\equiv 6.582119514\\times10^{−22}\\,\\textrm{MeV.s}\\f]\n* \\f$m\\f$ est la **masse du neutron**\n\\f[m\\equiv 939.5654133\\,\\textrm{MeV/c}^2\\f]\n* \\f$i\\f$ est le **nombre imaginaire** \\f$i^2=-1\\f$\n */\n\n/**\n *La fonction principale\n *\n *Cette fonction a pour but de calculer les données nécessaires pour tracer les grraphes\n *\n *@return la fonction créer des fichier .txt et retourne 0\n */\n\nint main()\n{\n arma::mat A = arma::zeros(2,2);\n arma::mat B = arma::ones(2,2);\n arma::cx_mat C1 = arma::cx_mat(A,B);\n arma::cx_mat C2 = arma::cx_mat(B,A);\n\n Solver s = Solver(C1, A, 1, 1, 0.1, 0.1,0.1);\n std::cout<< s.ftcs() <\n#include \n#include \n\n#include \"bond.h\"\n#include \"constants.h\"\n\n\nEigen::MatrixXd calculate_forces(const std::vector>& bonds,\n const Eigen::MatrixXd& positions) {\n //! Calculate the forces on each atom\n //! uses Newton's third law in that each force has an equal and opposite reaction\n /*! \n *! \\param[in] bonds a vector of polymorphic bonds between two atoms which will be used to calculate forces. Must have a force virtual method\n *! \\param[in] positions the positions, used by the bonds to calculate forces\n */\n Eigen::MatrixXd forces = Eigen::MatrixXd::Zero(positions.rows(), positions.cols());\n for (const auto& bond : bonds) {\n const Eigen::VectorXd bond_force = bond->force(positions);\n forces.row(bond->atoms[0]) -= bond_force;\n forces.row(bond->atoms[1]) += bond_force;\n }\n return forces;\n}\n\nEigen::MatrixXd calculate_accelerations(const std::vector>& bonds,\n const Eigen::MatrixXd& positions,\n const Eigen::MatrixXd& masses) {\n //! Calculate the forces on each atom\n //! uses Newton's third law in that each force has an equal and opposite reaction\n /*! \n *! \\param[in] bonds a vector of polymorphic bonds between two atoms which will be used to calculate forces. Must have a force virtual method\n *! \\param[in] positions the positions, used by the bonds to calculate forces\n */\n Eigen::MatrixXd accelerations = calculate_forces(bonds, positions);\n for (int i = 0; i < accelerations.rows(); ++i) {\n accelerations.row(i) /= masses(i);\n }\n return accelerations;\n}\n\n\n\nEigen::MatrixXd velocity_verlet(Eigen::MatrixXd& positions, Eigen::MatrixXd& velocities,\n Eigen::MatrixXd& accelerations, const Eigen::VectorXd& masses,\n const double dt, const std::vector>& bonds) {\n //! Solve Newton's laws of motion numerically by stepping forwards a small timestep.\n //! Solve $ F = m a $ numerically in increments of $ \\delta t $. Use the equations\n //! $ x = x + v * \\delta t + 0.5 * a * \\delta t^2 $\n //! $ a_new = F / m $\n //! $ v = v + 0.5 * (a_new + a_old) $\n /*! \n *! \\param[in] positions an array of particle positions which we will mutate\n *! \\param[in] velocities an array of particle velocities which we will mutate\n *! \\param[in] accelerations an array of particle accelerations which we will mutate\n *! \\param[in] masses an array of particle masses\n *! \\param[in] dt the timestep, which should be at least 1/10 of the period of the shortest bond frequency\n *! \\param[in] bonds an array of bonds which will be used to calculate forces\n *! \\return new_positions the new updated positions\n */\n positions += (velocities * dt) + (accelerations * dt * dt / 2.0);\n \n // F = ma, therefore a = F/m\n Eigen::MatrixXd new_accelerations = calculate_accelerations(bonds, positions, masses);\n velocities += (accelerations + new_accelerations) * dt / 2.0;\n accelerations = new_accelerations;\n return positions;\n}\n\nvoid excite_bond(const std::unique_ptr& bond, Eigen::MatrixXd& positions, const Eigen::MatrixXd& masses,\n const double excitement_factor) {\n //! Excite a single bond by stretching it by the excitement factor.\n //! For the bond, replace the position of the atoms to be exactly along the bond\n //! vector, with the distance between them being (equilibrium distance * excitement factor).\n //! Preserves the centre of mass of this bond.\n /*! \n *! \\param[in] bond a bond object to excite\n *! \\param[in] positions a mutable array of positions, which we will change\n *! \\param[in] excitement_factor the multiple of the equilibrium bond length to set the new bond length to\n */\n const Eigen::VectorXd old_com = (masses(bond->atoms[0]) * positions.row(bond->atoms[0]) + masses(bond->atoms[1]) * positions.row(bond->atoms[1])) / (masses(bond->atoms[0]) + masses(bond->atoms[1]));\n const Eigen::VectorXd displacement_vector\n = bond->rail * bond->equilibrium_distance * excitement_factor * -1;\n const Eigen::VectorXd old_position = positions.row(bond->atoms[0]);\n positions.row(bond->atoms[1]) = old_position + displacement_vector;\n const Eigen::VectorXd new_com = (masses(bond->atoms[0]) * positions.row(bond->atoms[0]) + masses(bond->atoms[1]) * positions.row(bond->atoms[1])) / (masses(bond->atoms[0]) + masses(bond->atoms[1]));\n \n // Reset the centre of mass.\n const Eigen::VectorXd com_offset = new_com - old_com;\n positions.row(bond->atoms[0]) -= com_offset;\n positions.row(bond->atoms[1]) -= com_offset; \n}\n\n", "meta": {"hexsha": "b937db1f273a0c6bb9507bd084abb79180b89ab2", "size": 4860, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/velocity_verlet.cpp", "max_stars_repo_name": "Matt-HJ-Bailey/Constrained-MD", "max_stars_repo_head_hexsha": "3897a5f97272772ea03f953414df779aed844216", "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/velocity_verlet.cpp", "max_issues_repo_name": "Matt-HJ-Bailey/Constrained-MD", "max_issues_repo_head_hexsha": "3897a5f97272772ea03f953414df779aed844216", "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/velocity_verlet.cpp", "max_forks_repo_name": "Matt-HJ-Bailey/Constrained-MD", "max_forks_repo_head_hexsha": "3897a5f97272772ea03f953414df779aed844216", "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": 50.625, "max_line_length": 202, "alphanum_fraction": 0.6580246914, "num_tokens": 1179, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624789529376, "lm_q2_score": 0.6926419831347361, "lm_q1q2_score": 0.5421048915471114}} {"text": "//--------------------------------------------------------\n// OpenNero : Random\n// random number generator\n// January 26, 2007\n//--------------------------------------------------------\n\n#include \"core/Common.h\"\n#include \n#include \n#include \"Random.h\"\n#include \n\nnamespace OpenNero \n{ \n using namespace boost;\n\n RandomNumberGenerator::RandomNumberGenerator() : _randomness() {\n }\n\n RandomNumberGenerator::RandomNumberGenerator( const boost::uint32_t& seed ) : _randomness(seed)\n {\n }\n \n template \n Result generate(boost::mt19937& gen, const Result& max)\n {\n Distribution dist(0, max);\n boost::variate_generator vg(gen, dist);\n return vg();\n }\n\n uint32_t RandomNumberGenerator::randI() const \n {\n return generate, uint32_t>(_randomness, 1);\n }\n \n uint32_t RandomNumberGenerator::randI(const uint32_t& n) const \n {\n return generate, uint32_t>(_randomness, n);\n }\n\n float32_t RandomNumberGenerator::randF() const\n {\n return generate, float32_t>(_randomness, 1);\n }\n\n float32_t RandomNumberGenerator::randF(const float32_t& n) const\n {\n return generate, float32_t>(_randomness, n);\n }\n\n double RandomNumberGenerator::randD() const\n {\n return generate, float32_t>(_randomness, 1);\n }\n \n double RandomNumberGenerator::randD(const double& n) const\n {\n return generate, double>(_randomness, n);\n }\n \n /// normal real number with mean and variance\n float32_t RandomNumberGenerator::normalF(const float32_t& mu, const float32_t& sigma) const\n {\n normal_distribution dist(mu, sigma);\n boost::variate_generator > vg(_randomness, dist);\n return vg();\n }\n\n /// normal real number with mean and variance\n double RandomNumberGenerator::normalD(const double& mu, const double& sigma) const\n {\n normal_distribution dist(mu, sigma);\n boost::variate_generator > vg(_randomness, dist);\n return vg();\n }\n\n RandomNumberGenerator RANDOM(55555); // random number generator with default seed\n \n /// set random seed\n void setRandomSeed( const boost::uint32_t& seed )\n {\n RANDOM.seed(seed);\n }\n \n} //end OpenNero\n", "meta": {"hexsha": "be40ed2e9fcf9c7ce2d81c0e234aaac4a24af5fa", "size": 2659, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "source/math/Random.cpp", "max_stars_repo_name": "SummitChen/opennero", "max_stars_repo_head_hexsha": "1bb1ba083cf2576e09bb7cfeac013d6940a47afe", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 215.0, "max_stars_repo_stars_event_min_datetime": "2015-08-26T19:41:28.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-19T13:23:17.000Z", "max_issues_repo_path": "source/math/Random.cpp", "max_issues_repo_name": "SummitChen/opennero", "max_issues_repo_head_hexsha": "1bb1ba083cf2576e09bb7cfeac013d6940a47afe", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2015-11-03T19:40:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-10-15T11:19:32.000Z", "max_forks_repo_path": "source/math/Random.cpp", "max_forks_repo_name": "SummitChen/opennero", "max_forks_repo_head_hexsha": "1bb1ba083cf2576e09bb7cfeac013d6940a47afe", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 56.0, "max_forks_repo_forks_event_min_datetime": "2015-08-26T19:42:05.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-26T16:45:41.000Z", "avg_line_length": 30.5632183908, "max_line_length": 105, "alphanum_fraction": 0.6378337721, "num_tokens": 623, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624789529375, "lm_q2_score": 0.6926419831347361, "lm_q1q2_score": 0.5421048915471113}} {"text": "#include \n#include \n#include \n#include \n#include \n\n#ifdef TOPPRA_OPT_MSGPACK\n#include \n#endif\n\nnamespace toppra {\n\nMatrix differentiateCoefficients(const Matrix &coefficients) {\n Matrix deriv(coefficients.rows(), coefficients.cols());\n deriv.setZero();\n for (size_t i = 1; i < coefficients.rows(); i++) {\n deriv.row(i) = coefficients.row(i - 1) * (coefficients.rows() - i);\n }\n return deriv;\n}\n\nPiecewisePolyPath::PiecewisePolyPath(const Matrices & coefficients,\n std::vector breakpoints)\n : GeometricPath (coefficients[0].cols()),\n m_coefficients(coefficients), m_breakpoints(std::move(breakpoints)),\n m_degree(coefficients[0].rows() - 1) {\n\n checkInputArgs();\n computeDerivativesCoefficients();\n}\n\nPiecewisePolyPath::PiecewisePolyPath(const Vectors &positions, const Vector ×,\n const std::array &bc_type) {\n // Prepare input\n checkInputArgs(positions, times, bc_type);\n Matrices coefficients(times.size() - 1);\n computeCubicSplineCoefficients(positions, times, bc_type, coefficients);\n std::vector breakpoints (times.data(), times.data() + times.size());\n *this = PiecewisePolyPath(coefficients, breakpoints);\n}\n\nvoid PiecewisePolyPath::computeCubicSplineCoefficients(const Vectors &positions, const Vector ×,\n const std::array &bc_type, Matrices &coefficients) {\n // h(i) = t(i+1) - t(i)\n Vector h (times.rows() - 1);\n for (size_t i = 0; i < h.rows(); i++){\n h(i) = times(i + 1) - times(i);\n }\n\n // Construct the tri-diagonal matrix A based on spline continuity criteria\n Matrix A = Matrix::Zero(times.rows(), times.rows());\n for (size_t i = 1; i < A.rows() - 1; i++) {\n A.row(i).segment(i - 1, 3) << h(i - 1), 2 * (h(i - 1) + h(i)), h(i);\n }\n\n // Construct B based on spline continuity criteria\n Vectors B (positions.at(0).rows());\n for (size_t i = 0; i < B.size(); i++) {\n B[i].resize(times.rows());\n for (size_t j = 1; j < A.rows() - 1; j++) {\n B[i](j) = 3 * (positions[j + 1](i) - positions[j](i)) / h(j) -\n 3 * (positions[j](i) - positions[j - 1](i)) / h(j - 1);\n }\n }\n\n // Insert boundary conditions to A and B\n if (bc_type[0].order == 1) {\n A.row(0).segment(0, 2) << 2 * h(0), h(0);\n for (size_t i = 0; i < B.size(); i++) {\n B[i](0) = 3 * (positions[1](i) - positions[0](i)) / h(0) - 3 * bc_type[0].values(i);\n }\n }\n else if (bc_type[0].order == 2) {\n A(0, 0) = 2;\n for (size_t i = 0; i < B.size(); i++) {\n B[i](0) = bc_type[0].values(i);\n }\n }\n\n if (bc_type[1].order == 1) {\n A.row(A.rows() - 1).segment(A.cols() - 2, 2) << h(h.rows() - 1), 2 * h(h.rows() - 1);\n for (size_t i = 0; i < B.size(); i++) {\n B[i](B[i].rows() - 1) =\n 3 * bc_type[1].values(i) -\n 3 * (positions[positions.size() - 1](i) - positions[positions.size() - 2](i)) / h(h.rows() - 1);\n }\n }\n else if (bc_type[1].order == 2) {\n A(A.rows() - 1, A.cols() - 1) = 2;\n for (size_t i = 0; i < B.size(); i++) {\n B[i](B[i].rows() - 1) = bc_type[1].values(i);\n }\n }\n\n // Solve AX = B\n Vectors X (positions[0].rows());\n for (size_t i = 0; i < X.size(); i++) {\n X[i].resize(times.rows());\n X[i] = A.colPivHouseholderQr().solve(B[i]);\n }\n\n // Insert spline coefficients\n for (size_t i = 0; i < coefficients.size() ; i++) {\n coefficients[i].resize(4, positions[0].rows());\n for (size_t j = 0; j < coefficients[i].cols(); j++) {\n coefficients[i](0, j) = (X[j](i + 1) - X[j](i)) / (3 * h(i));\n coefficients[i](1, j) = X[j](i);\n coefficients[i](2, j) = (positions[i + 1](j) - positions[i](j)) / h(i) -\n h(i) / 3 * (2 * X[j](i) + X[j](i + 1));\n coefficients[i](3, j) = positions[i](j);\n }\n }\n}\n\nBound PiecewisePolyPath::pathInterval() const {\n Bound v;\n v << m_breakpoints.front(), m_breakpoints.back();\n return v;\n};\n\nVector PiecewisePolyPath::eval_single(value_type pos, int order) const {\n assert(order < 3 && order >= 0);\n Vector v(m_dof);\n v.setZero();\n size_t seg_index = findSegmentIndex(pos);\n auto coeff = getCoefficient(seg_index, order);\n for (int power = 0; power < m_degree + 1; power++) {\n v += coeff.row(power) *\n pow(pos - m_breakpoints[seg_index], m_degree - power);\n }\n return v;\n}\n\n// Not the most efficient implementation. Coefficients are\n// recomputed. Should be refactored.\nVectors PiecewisePolyPath::eval(const Vector &positions, int order) const {\n assert(order < 3 && order >= 0);\n Vectors outputs;\n outputs.resize(positions.size());\n for (size_t i = 0; i < positions.size(); i++) {\n outputs[i] = eval_single(positions(i), order);\n }\n return outputs;\n}\n\nsize_t PiecewisePolyPath::findSegmentIndex(value_type pos) const {\n if (pos > m_breakpoints[m_breakpoints.size()-1] || pos < m_breakpoints[0]) {\n std::ostringstream oss;\n oss << \"Position \" << pos << \" is outside of range [ \" << m_breakpoints[0]\n << \", \" << m_breakpoints[m_breakpoints.size()-1] << ']';\n throw std::runtime_error(oss.str());\n }\n auto it = std::upper_bound(m_breakpoints.begin(), m_breakpoints.end(), pos);\n auto idx = std::distance(m_breakpoints.begin(), it)-1;\n return std::min(static_cast(std::max(idx, long{0})), m_coefficients.size() - 1);\n}\n\nvoid PiecewisePolyPath::checkInputArgs() {\n assert(m_coefficients[0].cols() == m_dof);\n assert(m_coefficients[0].rows() == (m_degree + 1));\n if ((1 + m_coefficients.size()) != m_breakpoints.size()) {\n throw std::runtime_error(\n \"Number of breakpoints must equals number of segments plus 1.\");\n }\n for (size_t seg_index = 0; seg_index < m_coefficients.size(); seg_index++) {\n if (m_breakpoints[seg_index] >= m_breakpoints[seg_index + 1]) {\n throw std::runtime_error(\"Require strictly increasing breakpoints\");\n }\n }\n}\n\nvoid PiecewisePolyPath::checkInputArgs(const Vectors &positions, const Vector ×,\n const std::array &bc_type) {\n if (positions.size() != times.rows()) {\n throw std::runtime_error(\"The length of 'positions' doesn't match the length of 'times'.\");\n }\n if (times.rows() < 2) {\n throw std::runtime_error(\"'times' must contain at least 2 elements.\");\n }\n for (size_t i = 1; i < positions.size(); i++) {\n if (positions[i].rows() != positions[i - 1].rows()) {\n throw std::runtime_error(\"The number of elements in each position has to be equal.\");\n }\n }\n Vector dtimes (times.rows() - 1);\n for (size_t i = 1; i < times.rows(); i++) {\n dtimes(i - 1) = times(i) - times(i - 1);\n if (dtimes(i - 1) <= 0) {\n throw std::runtime_error(\"'times' must be a strictly increasing sequence.\");\n }\n }\n\n // Validate boundary conditions\n int expected_deriv_size = positions[0].size();\n for (const BoundaryCond &bc: bc_type) {\n if (bc.order != 1 && bc.order != 2) {\n throw std::runtime_error(\"The specified derivative order must be 1 or 2.\");\n }\n if (bc.values.size() != expected_deriv_size) {\n throw std::runtime_error(\n \"`deriv_value` size \" + std::to_string(bc.values.size()) + \" is not the expected one \" +\n std::to_string(expected_deriv_size) + \".\");\n }\n }\n}\n\nvoid PiecewisePolyPath::computeDerivativesCoefficients() {\n m_coefficients_1.reserve(m_coefficients.size());\n m_coefficients_2.reserve(m_coefficients.size());\n for (size_t seg_index = 0; seg_index < m_coefficients.size(); seg_index++) {\n m_coefficients_1.push_back(\n differentiateCoefficients(m_coefficients[seg_index]));\n m_coefficients_2.push_back(\n differentiateCoefficients(m_coefficients_1[seg_index]));\n }\n}\n\nconst Matrix &PiecewisePolyPath::getCoefficient(int seg_index, int order) const {\n if (order == 0) {\n return m_coefficients.at(seg_index);\n } else if (order == 1) {\n return m_coefficients_1.at(seg_index);\n } else if (order == 2) {\n return m_coefficients_2.at(seg_index);\n } else {\n return m_coefficients_2.at(seg_index);\n }\n}\n\nvoid PiecewisePolyPath::serialize(std::ostream &O) const {\n#ifdef TOPPRA_OPT_MSGPACK\n MatricesData allraw;\n allraw.reserve(m_coefficients.size());\n for (const auto &c : m_coefficients) {\n MatrixData raw{c.rows(), c.cols(), {c.data(), c.data() + c.size()}};\n allraw.push_back(raw);\n }\n msgpack::pack(O, allraw);\n msgpack::pack(O, m_breakpoints);\n#endif\n}\n\nvoid PiecewisePolyPath::deserialize(std::istream &I) {\n#ifdef TOPPRA_OPT_MSGPACK\n std::stringstream buffer;\n buffer << I.rdbuf();\n std::size_t offset = 0;\n\n auto oh = msgpack::unpack(buffer.str().data(), buffer.str().size(), offset);\n auto obj = oh.get();\n TOPPRA_LOG_DEBUG(obj << \"at offset:=\" << offset << \"/\" << buffer.str().size());\n MatricesData x;\n toppra::Matrices new_coefficients;\n obj.convert(x);\n for (auto const &y : x) {\n int nrow, ncol;\n nrow = std::get<0>(y);\n ncol = std::get<1>(y);\n std::vector mdata = std::get<2>(y);\n toppra::Matrix m(nrow, ncol);\n for (size_t i = 0; i < mdata.size(); i++) m(i) = mdata[i];\n TOPPRA_LOG_DEBUG(nrow << ncol << mdata.size() << m);\n new_coefficients.push_back(m);\n }\n\n reset();\n m_coefficients = new_coefficients;\n oh = msgpack::unpack(buffer.str().data(), buffer.str().size(), offset);\n obj = oh.get();\n TOPPRA_LOG_DEBUG(obj << \"at offset:=\" << offset << \"/\" << buffer.str().size());\n assert(offset == buffer.str().size());\n obj.convert(m_breakpoints);\n\n TOPPRA_LOG_DEBUG(\"degree: \" << m_degree);\n m_dof = new_coefficients[0].cols();\n m_degree = new_coefficients[0].rows() - 1;\n checkInputArgs();\n computeDerivativesCoefficients();\n#endif\n}\n\nvoid PiecewisePolyPath::reset() {\n m_breakpoints.clear();\n m_coefficients.clear();\n m_coefficients_1.clear();\n m_coefficients_2.clear();\n}\n\nvoid PiecewisePolyPath::initAsHermite(const Vectors &positions,\n const Vectors &velocities,\n const std::vector times) {\n reset();\n assert(positions.size() == times.size());\n assert(velocities.size() == times.size());\n TOPPRA_LOG_DEBUG(\"Constructing new Hermite polynomial\");\n m_configSize = m_dof = positions[0].size();\n m_degree = 3; // cubic spline\n m_breakpoints = times;\n for (std::size_t i = 0; i < times.size() - 1; i++) {\n TOPPRA_LOG_DEBUG(\"Processing segment index: \" << i << \"/\" << times.size() - 1);\n Matrix c(4, m_dof);\n auto dt = times[i + 1] - times[i];\n assert(dt > 0);\n // ... after some derivations\n c.row(3) = positions.at(i);\n c.row(2) = velocities.at(i);\n c.row(0) = (velocities.at(i + 1).transpose() * dt -\n 2 * positions.at(i + 1).transpose() + c.row(2) * dt + 2 * c.row(3)) /\n pow(dt, 3);\n c.row(1) = (velocities.at(i + 1).transpose() - c.row(2) - 3 * c.row(0) * dt * dt) /\n (2 * dt);\n m_coefficients.push_back(c);\n }\n checkInputArgs();\n computeDerivativesCoefficients();\n}\n\nPiecewisePolyPath PiecewisePolyPath::constructHermite(\n const Vectors &positions, const Vectors &velocities,\n const std::vector times) {\n PiecewisePolyPath path;\n path.initAsHermite(positions, velocities, times);\n return path;\n}\n\n} // namespace toppra\n", "meta": {"hexsha": "287f606d31f3efafe727f0bdb029d6b07e6820eb", "size": 11646, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "cpp/src/toppra/geometric_path/piecewise_poly_path.cpp", "max_stars_repo_name": "ahoarau/toppra", "max_stars_repo_head_hexsha": "6076effd175ad975c67d01f97d979778076134a4", "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": "cpp/src/toppra/geometric_path/piecewise_poly_path.cpp", "max_issues_repo_name": "ahoarau/toppra", "max_issues_repo_head_hexsha": "6076effd175ad975c67d01f97d979778076134a4", "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": "cpp/src/toppra/geometric_path/piecewise_poly_path.cpp", "max_forks_repo_name": "ahoarau/toppra", "max_forks_repo_head_hexsha": "6076effd175ad975c67d01f97d979778076134a4", "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": 35.6146788991, "max_line_length": 116, "alphanum_fraction": 0.6002060793, "num_tokens": 3379, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624688140726, "lm_q2_score": 0.6926419704455589, "lm_q1q2_score": 0.542104874593165}} {"text": "/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */\n\n/*!\n Copyright (C) 2006 Allen Kuo\n\n This file is part of QuantLib, a free-software/open-source library\n for financial quantitative analysts and developers - http://quantlib.org/\n\n QuantLib is free software: you can redistribute it and/or modify it\n under the terms of the QuantLib license. You should have received a\n copy of the license along with this program; if not, please email\n . The license is also available online at\n .\n\n This program is distributed in the hope that it will be useful, but WITHOUT\n ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n FOR A PARTICULAR PURPOSE. See the license for more details.\n*/\n\n/* a Repo calculation done using the FixedRateBondForward class\n cf. aaBondFwd() repo example at\n http://www.fincad.com/support/developerFunc/mathref/BFWD.htm\n\n This repo is set up to use the repo rate to do all discounting\n (including the underlying bond income). Forward delivery price is\n also obtained using this repo rate. All this is done by supplying\n the FixedRateBondForward constructor with a flat repo\n YieldTermStructure.\n*/\n\n// the only header you need to use QuantLib\n#include \n\n#ifdef BOOST_MSVC\n/* Uncomment the following lines to unmask floating-point\n exceptions. Warning: unpredictable results can arise...\n\n See http://www.wilmott.com/messageview.cfm?catid=10&threadid=9481\n Is there anyone with a definitive word about this?\n*/\n// #include \n// namespace { unsigned int u = _controlfp(_EM_INEXACT, _MCW_EM); }\n#endif\n\n#include \n#include \n\nusing namespace std;\nusing namespace QuantLib;\n\n#if defined(QL_ENABLE_SESSIONS)\nnamespace QuantLib {\n\n Integer sessionId() { return 0; }\n\n}\n#endif\n\nint main(int, char* []) {\n\n try {\n\n boost::timer timer;\n std::cout << std::endl;\n\n Date repoSettlementDate(14,February,2000);;\n Date repoDeliveryDate(15,August,2000);\n Rate repoRate = 0.05;\n DayCounter repoDayCountConvention = Actual360();\n Integer repoSettlementDays = 0;\n Compounding repoCompounding = Simple;\n Frequency repoCompoundFreq = Annual;\n\n // assume a ten year bond- this is irrelevant\n Date bondIssueDate(15,September,1995);\n Date bondDatedDate(15,September,1995);\n Date bondMaturityDate(15,September,2005);\n Real bondCoupon = 0.08;\n Frequency bondCouponFrequency = Semiannual;\n // unknown what calendar fincad is using\n Calendar bondCalendar = NullCalendar();\n DayCounter bondDayCountConvention = Thirty360(Thirty360::BondBasis);\n // unknown what fincad is using. this may affect accrued calculation\n Integer bondSettlementDays = 0;\n BusinessDayConvention bondBusinessDayConvention = Unadjusted;\n Real bondCleanPrice = 89.97693786;\n Real bondRedemption = 100.0;\n Real faceAmount = 100.0;\n\n\n Settings::instance().evaluationDate() = repoSettlementDate;\n\n RelinkableHandle bondCurve;\n bondCurve.linkTo(boost::shared_ptr(\n new FlatForward(repoSettlementDate,\n .01, // dummy rate\n bondDayCountConvention,\n Compounded,\n bondCouponFrequency)));\n\n /*\n boost::shared_ptr bond(\n new FixedRateBond(faceAmount,\n bondIssueDate,\n bondDatedDate,\n bondMaturityDate,\n bondSettlementDays,\n std::vector(1,bondCoupon),\n bondCouponFrequency,\n bondCalendar,\n bondDayCountConvention,\n bondBusinessDayConvention,\n bondBusinessDayConvention,\n bondRedemption,\n bondCurve));\n */\n\n Schedule bondSchedule(bondDatedDate, bondMaturityDate,\n Period(bondCouponFrequency),\n bondCalendar,bondBusinessDayConvention,\n bondBusinessDayConvention,\n DateGeneration::Backward,false);\n boost::shared_ptr bond(\n new FixedRateBond(bondSettlementDays,\n faceAmount,\n bondSchedule,\n std::vector(1,bondCoupon),\n bondDayCountConvention,\n bondBusinessDayConvention,\n bondRedemption,\n bondIssueDate));\n bond->setPricingEngine(boost::shared_ptr(\n new DiscountingBondEngine(bondCurve)));\n\n bondCurve.linkTo(boost::shared_ptr (\n new FlatForward(repoSettlementDate,\n bond->yield(bondCleanPrice,\n bondDayCountConvention,\n Compounded,\n bondCouponFrequency),\n bondDayCountConvention,\n Compounded,\n bondCouponFrequency)));\n\n Position::Type fwdType = Position::Long;\n double dummyStrike = 91.5745;\n\n RelinkableHandle repoCurve;\n repoCurve.linkTo(boost::shared_ptr (\n new FlatForward(repoSettlementDate,\n repoRate,\n repoDayCountConvention,\n repoCompounding,\n repoCompoundFreq)));\n\n\n FixedRateBondForward bondFwd(repoSettlementDate,\n repoDeliveryDate,\n fwdType,\n dummyStrike,\n repoSettlementDays,\n repoDayCountConvention,\n bondCalendar,\n bondBusinessDayConvention,\n bond,\n repoCurve,\n repoCurve);\n\n\n cout << \"Underlying bond clean price: \"\n << bond->cleanPrice()\n << endl;\n cout << \"Underlying bond dirty price: \"\n << bond->dirtyPrice()\n << endl;\n cout << \"Underlying bond accrued at settlement: \"\n << bond->accruedAmount(repoSettlementDate)\n << endl;\n cout << \"Underlying bond accrued at delivery: \"\n << bond->accruedAmount(repoDeliveryDate)\n << endl;\n cout << \"Underlying bond spot income: \"\n << bondFwd.spotIncome(repoCurve)\n << endl;\n cout << \"Underlying bond fwd income: \"\n << bondFwd.spotIncome(repoCurve)/\n repoCurve->discount(repoDeliveryDate)\n << endl;\n cout << \"Repo strike: \"\n << dummyStrike\n << endl;\n cout << \"Repo NPV: \"\n << bondFwd.NPV()\n << endl;\n cout << \"Repo clean forward price: \"\n << bondFwd.cleanForwardPrice()\n << endl;\n cout << \"Repo dirty forward price: \"\n << bondFwd.forwardPrice()\n << endl;\n cout << \"Repo implied yield: \"\n << bondFwd.impliedYield(bond->dirtyPrice(),\n dummyStrike,\n repoSettlementDate,\n repoCompounding,\n repoDayCountConvention)\n << endl;\n cout << \"Market repo rate: \"\n << repoCurve->zeroRate(repoDeliveryDate,\n repoDayCountConvention,\n repoCompounding,\n repoCompoundFreq)\n << endl\n << endl;\n\n cout << \"Compare with example given at \\n\"\n << \"http://www.fincad.com/support/developerFunc/mathref/BFWD.htm\"\n << endl;\n cout << \"Clean forward price = 88.2408\"\n << endl\n << endl;\n cout << \"In that example, it is unknown what bond calendar they are\\n\"\n << \"using, as well as settlement Days. For that reason, I have\\n\"\n << \"made the simplest possible assumptions here: NullCalendar\\n\"\n << \"and 0 settlement days.\"\n << endl;\n\n\n double seconds = timer.elapsed();\n Integer hours = int(seconds/3600);\n seconds -= hours * 3600;\n Integer minutes = int(seconds/60);\n seconds -= minutes * 60;\n cout << \" \\nRun completed in \";\n if (hours > 0)\n cout << hours << \" h \";\n if (hours > 0 || minutes > 0)\n cout << minutes << \" m \";\n cout << fixed << setprecision(0)\n << seconds << \" s\\n\" << endl;\n\n return 0;\n\n } catch (exception& e) {\n cerr << e.what() << endl;\n return 1;\n } catch (...) {\n cerr << \"unknown error\" << endl;\n return 1;\n }\n}\n\n", "meta": {"hexsha": "0e8efecf389841b0795771e0a61cb69d2bb174de", "size": 10164, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "QuantLib/Examples/Repo/Repo.cpp", "max_stars_repo_name": "txu2014/quantlib", "max_stars_repo_head_hexsha": "95c7d94906c30d0c3c4e0758a2ebfe2a62b075ec", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2016-09-13T22:40:22.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-18T12:51:41.000Z", "max_issues_repo_path": "QuantLib/Examples/Repo/Repo.cpp", "max_issues_repo_name": "txu2014/quantlib", "max_issues_repo_head_hexsha": "95c7d94906c30d0c3c4e0758a2ebfe2a62b075ec", "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": "QuantLib/Examples/Repo/Repo.cpp", "max_forks_repo_name": "txu2014/quantlib", "max_forks_repo_head_hexsha": "95c7d94906c30d0c3c4e0758a2ebfe2a62b075ec", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-06-27T19:25:30.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-27T19:25:30.000Z", "avg_line_length": 40.1739130435, "max_line_length": 79, "alphanum_fraction": 0.5008854782, "num_tokens": 1867, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972751232809, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.5419113976193944}} {"text": "#include \"neohookean_material.h\"\n#include \"main.h\"\n#include \"utils.h\"\n\n#include \n#include \n\nusing namespace materials;\n\ntemplate \nT CompressibleNeohookeanMaterial::EnergyDensity(\n const MatrixDimT& F) const {\n const T I1 = (F.transpose() * F).trace();\n const T J = F.determinant();\n if (J <= 0) {\n throw NumericalError{\"J <= 0 in CompressibleNeohookeanMaterial\"};\n }\n const T log_J = log(J);\n const T mu = Super::mu();\n const T lambda = Super::lambda();\n return mu / 2.0 * (I1 - dim) - mu * log_J + lambda / 2.0 * log_J * log_J;\n}\n\ntemplate \ntypename CompressibleNeohookeanMaterial::MatrixDimT\nCompressibleNeohookeanMaterial::StressTensor(\n const MatrixDimT& F) const {\n const T J = F.determinant();\n if (J <= 0) {\n throw NumericalError{\"J <= 0 in CompressibleNeohookeanMaterial\"};\n }\n const MatrixDimT F_inv_trans = F.inverse().transpose();\n const T mu = Super::mu();\n const T lambda = Super::lambda();\n return mu * (F - F_inv_trans) + lambda * log(J) * F_inv_trans;\n}\n\ntemplate \ntypename CompressibleNeohookeanMaterial::MatrixDimT\nCompressibleNeohookeanMaterial::StressDifferential(\n const MatrixDimT& F, const MatrixDimT& dF) const {\n throw std::runtime_error{\"not implemented\"};\n}\n\ntemplate \ntypename CompressibleNeohookeanMaterial::MatrixDim2T\nCompressibleNeohookeanMaterial::StressDifferential(\n const MatrixDimT& F) const {\n const Td mu = Super::mu();\n const Td lambda = Super::lambda();\n\n using Vec = Eigen::Matrix;\n using Vec2 = Eigen::Matrix;\n Eigen::JacobiSVD svd{F,\n Eigen::ComputeFullU | Eigen::ComputeFullV};\n Vec S = svd.singularValues();\n MatrixDimT U = svd.matrixU(), V = svd.matrixV(), A;\n\n // construct the matrix A\n Td I3 = S(0) * S(1) * S(2), Adia = lambda * (1 - std::log(I3)) + mu;\n for (int i = 0; i < 3; ++i) {\n A(i, i) = Adia / (S(i) * S(i)) + mu;\n for (int j = i + 1; j < 3; ++j) {\n A(i, j) = A(j, i) = lambda / (S(i) * S(j));\n }\n }\n\n Vec2 eigs;\n Eigen::SelfAdjointEigenSolver eigensolver{A};\n cf_assert(eigensolver.info() == Eigen::Success);\n Eigen::Map{eigs.data()} = eigensolver.eigenvalues();\n\n {\n Td eig6tmp = lambda * log(I3) - mu;\n#define SET(t, i, j) eigs[t + 3] = eig6tmp / (S(i) * S(j)) + mu\n SET(0, 0, 1);\n SET(1, 1, 2);\n SET(2, 0, 2);\n eig6tmp = -eig6tmp;\n SET(3, 0, 1);\n SET(4, 1, 2);\n SET(5, 0, 2);\n#undef SET\n }\n\n MatrixDimT D0, D1, D2, T[6];\n D0.noalias() = U.col(0) * V.col(0).transpose();\n D1.noalias() = U.col(1) * V.col(1).transpose();\n D2.noalias() = U.col(2) * V.col(2).transpose();\n auto compute_Q_first3 = [&](MatrixDimT& Q, int i) {\n auto& evec = eigensolver.eigenvectors();\n Td z0 = evec(0, i), z1 = evec(1, i), z2 = evec(2, i);\n Q = z0 * D0 + z1 * D1 + z2 * D2;\n };\n T[0] << 0, -1, 0, 1, 0, 0, 0, 0, 0;\n T[1] << 0, 0, 0, 0, 0, 1, 0, -1, 0;\n T[2] << 0, 0, 1, 0, 0, 0, -1, 0, 0;\n T[3] << 0, 1, 0, 1, 0, 0, 0, 0, 0;\n T[4] << 0, 0, 0, 0, 0, 1, 0, 1, 0;\n T[5] << 0, 0, 1, 0, 0, 0, 1, 0, 0;\n\n MatrixDimT Q;\n MatrixDim2T H;\n H.setZero();\n int nr_pos = 0;\n for (int i = 0; i < 9; ++i) {\n if (baseline::g_hessian_proj && eigs[i] < 0) {\n continue;\n }\n ++nr_pos;\n if (i < 3) {\n compute_Q_first3(Q, i);\n } else {\n Q.noalias() = U * T[i - 3] * V.transpose() * std::sqrt(0.5);\n }\n Eigen::Map qf{Q.data()};\n H.noalias() += qf * qf.transpose() * eigs[i];\n }\n cf_assert(nr_pos);\n return H;\n}\n\ntemplate \nT IncompressibleNeohookeanMaterial::EnergyDensity(\n const MatrixDimT& F) const {\n const T Ic = (F.transpose() * F).trace();\n const T J = F.determinant();\n if (J <= 0) {\n throw NumericalError{\"J <= 0 in IncompressibleNeohookeanMaterial\"};\n }\n const T mu = Super::mu();\n const T k = Super::bulk_modulus();\n return mu / T(2) * (std::pow(J, T(-2.0 / 3.0)) * Ic - 3) +\n k / T(2) * (J - 1) * (J - 1);\n}\n\ntemplate \ntypename IncompressibleNeohookeanMaterial::MatrixDimT\nIncompressibleNeohookeanMaterial::StressTensor(\n const MatrixDimT& F) const {\n const T J = F.determinant();\n if (J <= 0) {\n throw NumericalError{\"J <= 0 in IncompressibleNeohookeanMaterial\"};\n }\n const T Ic = (F.transpose() * F).trace();\n const MatrixDimT F_inv_trans = F.inverse().transpose();\n const T mu = Super::mu();\n const T k = Super::bulk_modulus();\n return (F - F_inv_trans * (Ic / T(3))) * (mu * std::pow(J, T(-2.0 / 3.0))) +\n F_inv_trans * (k * J * (J - 1));\n}\n\ntemplate \ntypename IncompressibleNeohookeanMaterial::MatrixDimT\nIncompressibleNeohookeanMaterial::StressDifferential(\n const MatrixDimT& F, const MatrixDimT& dF) const {\n throw std::runtime_error{\"not implemented\"};\n}\n\ntemplate \ntypename IncompressibleNeohookeanMaterial::MatrixDim2T\nIncompressibleNeohookeanMaterial::StressDifferential(\n const MatrixDimT& F) const {\n const Td mu = Super::mu();\n const Td k = Super::bulk_modulus();\n\n using Vec = Eigen::Matrix;\n using Vec2 = Eigen::Matrix;\n Eigen::JacobiSVD svd{F,\n Eigen::ComputeFullU | Eigen::ComputeFullV};\n Vec S = svd.singularValues();\n MatrixDimT U = svd.matrixU(), V = svd.matrixV(), A;\n\n // construct the matrix A\n auto sqr = [](Td x) { return x * x; };\n Td I3 = S(0) * S(1) * S(2), I3_83 = std::pow(I3, Td(8.0 / 3)),\n I3_53 = std::pow(I3, Td(5.0 / 3)),\n S2[3] = {sqr(S(0)), sqr(S(1)), sqr(S(2))}, I2 = S2[0] + S2[1] + S2[2];\n for (int i = 0; i < 3; ++i) {\n int o0 = i == 0 ? 1 : 0, o1 = i == 2 ? 1 : 2;\n A(i, i) = S2[o0] * S2[o1] *\n (9 * I3_83 * k + mu * (2 * S2[i] + 5 * (S2[o0] + S2[o1]))) /\n (9 * I3_83);\n for (int j = i + 1; j < 3; ++j) {\n A(i, j) = A(j, i) =\n S(3 - i - j) *\n (9 * k * (I3_83 * 2 - I3_53) +\n mu * 2 * (S2[3 - i - j] - 2 * S2[i] - 2 * S2[j])) /\n (9 * I3_53);\n }\n }\n\n Vec2 eigs;\n Eigen::SelfAdjointEigenSolver eigensolver{A};\n cf_assert(eigensolver.info() == Eigen::Success);\n Eigen::Map{eigs.data()} = eigensolver.eigenvalues();\n\n {\n Td eig6tmp = I3_53 * 3 * k * (I3 - 1) - I2 * mu;\n#define SET(t, i, j) \\\n eigs[t + 3] = (eig6tmp + 3 * mu * S(i) * S(j)) * S(3 - i - j) / (3 * I3_53)\n SET(0, 0, 1);\n SET(1, 1, 2);\n SET(2, 0, 2);\n eig6tmp = -eig6tmp;\n SET(3, 0, 1);\n SET(4, 1, 2);\n SET(5, 0, 2);\n#undef SET\n }\n\n MatrixDimT D0, D1, D2, T[6];\n D0.noalias() = U.col(0) * V.col(0).transpose();\n D1.noalias() = U.col(1) * V.col(1).transpose();\n D2.noalias() = U.col(2) * V.col(2).transpose();\n auto compute_Q_first3 = [&](MatrixDimT& Q, int i) {\n auto& evec = eigensolver.eigenvectors();\n Td z0 = evec(0, i), z1 = evec(1, i), z2 = evec(2, i);\n Q = z0 * D0 + z1 * D1 + z2 * D2;\n };\n T[0] << 0, -1, 0, 1, 0, 0, 0, 0, 0;\n T[1] << 0, 0, 0, 0, 0, 1, 0, -1, 0;\n T[2] << 0, 0, 1, 0, 0, 0, -1, 0, 0;\n T[3] << 0, 1, 0, 1, 0, 0, 0, 0, 0;\n T[4] << 0, 0, 0, 0, 0, 1, 0, 1, 0;\n T[5] << 0, 0, 1, 0, 0, 0, 1, 0, 0;\n\n MatrixDimT Q;\n MatrixDim2T H;\n H.setZero();\n int nr_pos = 0;\n for (int i = 0; i < 9; ++i) {\n if (baseline::g_hessian_proj && eigs[i] < 0) {\n continue;\n }\n ++nr_pos;\n if (i < 3) {\n compute_Q_first3(Q, i);\n } else {\n Q.noalias() = U * T[i - 3] * V.transpose() * std::sqrt(0.5);\n }\n Eigen::Map qf{Q.data()};\n H.noalias() += qf * qf.transpose() * eigs[i];\n }\n cf_assert(nr_pos);\n return H;\n}\n\ntemplate class materials::CompressibleNeohookeanMaterial<3, double>;\ntemplate class materials::IncompressibleNeohookeanMaterial<3, double>;\n", "meta": {"hexsha": "cfe1a8f09cc549a587ccd26cccaacae0edbc9d30", "size": 8445, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "fea/baseline/neohookean_material.cpp", "max_stars_repo_name": "jia-kai/SANM", "max_stars_repo_head_hexsha": "2673ac476b3d2978a52bf47bc12d3402ea20f211", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 25.0, "max_stars_repo_stars_event_min_datetime": "2021-05-19T09:27:52.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-22T15:22:05.000Z", "max_issues_repo_path": "fea/baseline/neohookean_material.cpp", "max_issues_repo_name": "jia-kai/SANM", "max_issues_repo_head_hexsha": "2673ac476b3d2978a52bf47bc12d3402ea20f211", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-09-03T05:31:47.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-05T01:37:42.000Z", "max_forks_repo_path": "fea/baseline/neohookean_material.cpp", "max_forks_repo_name": "jia-kai/SANM", "max_forks_repo_head_hexsha": "2673ac476b3d2978a52bf47bc12d3402ea20f211", "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": 33.6454183267, "max_line_length": 80, "alphanum_fraction": 0.52776791, "num_tokens": 3170, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970811069351, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.5417675877628756}} {"text": "#include \n#include \n#include \n#include \n#include \"mex.h\"\n\nconst std::complex i1(0.0, 1.0);\ntypedef Eigen::Matrix Matrix2x3d;\n\nEigen::Matrix3cd T;\nEigen::Vector3cd aux_states(0, 0, 0);\nEigen::Matrix3d F;\nEigen::Matrix3d V;\nMatrix2x3d J;\nstd::complex dmdT1;\nstd::complex dmdT2;\nstd::complex dmdM0;\n\n \n\nvoid update_T(double a, double p)\n{\n T(0,0) = pow(cos(a/2),2);\n T(0,1) = pow(sin(a/2),2)*(cos(2*p)+1.0*i1*sin(2*p));\n T(0,2) = sin(a)*(sin(p)-1.0*i1*cos(p));\n T(1,0) = std::conj(T(0,1));\n T(1,1) = T(0,0);\n T(1,2) = std::conj(T(0,2));\n T(2,0) = -0.5*sin(a)*(sin(p)+1.0*i1*cos(p));\n T(2,1) = std::conj(T(2,0));\n T(2,2) = cos(a);\n}\n\nvoid add2FIM()\n{\n J(0,0) = dmdT1.real();\n J(1,0) = dmdT1.imag();\n J(0,1) = dmdT2.real();\n J(1,1) = dmdT2.imag(); \n J(0,2) = dmdM0.real();\n J(1,2) = dmdM0.imag(); \n F += J.transpose() * J;\n}\n\nvoid EPG_GRE_efficiency(double *f, double *N, double *FA, double *RF, double *TR, double *TE, double *T1, double *T2)\n{\n int n = (int) N[0];\n\n //max order of EPG simulation\n int KMAX = n;\n if(n>25){KMAX = 25;}\n\n ///// MEMORY ALLOCATION\t\n double E1;\n double E2;\n double E2_TE;\n double dEdT1;\n double dEdT2;\n double dEdT2_TE;\n double Tacq = 0.0;\n\n // fisher information matrix\n F.setZero();\n\n // signal vectors\n Eigen::VectorXcd Fplus(KMAX);\n Fplus.setZero();\n Eigen::VectorXcd Fminus(KMAX);\n Fminus.setZero();\n Eigen::VectorXcd Z(KMAX);\n Z.setZero();\n Eigen::VectorXcd prev_Fplus(KMAX);\n prev_Fplus.setZero();\n Eigen::VectorXcd prev_Fminus(KMAX);\n prev_Fminus.setZero();\n Eigen::VectorXcd prev_Z(KMAX);\n prev_Z.setZero();\n\n // for CRLB calculation\n Eigen::VectorXcd Fplus_dOdT1(KMAX);\n Fplus_dOdT1.setZero();\n Eigen::VectorXcd Fminus_dOdT1(KMAX);\n Fminus_dOdT1.setZero(); \n Eigen::VectorXcd Z_dOdT1(KMAX);\n Z_dOdT1.setZero();\n Eigen::VectorXcd prev_Fplus_dOdT1(KMAX);\n prev_Fplus_dOdT1.setZero();\n Eigen::VectorXcd prev_Fminus_dOdT1(KMAX);\n prev_Fminus_dOdT1.setZero();\n Eigen::VectorXcd prev_Z_dOdT1(KMAX);\n prev_Z_dOdT1.setZero();\n \n Eigen::VectorXcd Fplus_dOdT2(KMAX);\n Fplus_dOdT2.setZero();\n Eigen::VectorXcd Fminus_dOdT2(KMAX);\n Fminus_dOdT2.setZero(); \n Eigen::VectorXcd Z_dOdT2(KMAX);\n Z_dOdT2.setZero();\n Eigen::VectorXcd prev_Fplus_dOdT2(KMAX);\n prev_Fplus_dOdT2.setZero();\n Eigen::VectorXcd prev_Fminus_dOdT2(KMAX);\n prev_Fminus_dOdT2.setZero();\n Eigen::VectorXcd prev_Z_dOdT2(KMAX);\n prev_Z_dOdT2.setZero();\n \n Eigen::VectorXcd Fplus_dOdM0(KMAX);\n Fplus_dOdM0.setZero();\n Eigen::VectorXcd Fminus_dOdM0(KMAX);\n Fminus_dOdM0.setZero(); \n Eigen::VectorXcd Z_dOdM0(KMAX);\n Z_dOdM0.setZero();\n Eigen::VectorXcd prev_Fplus_dOdM0(KMAX);\n prev_Fplus_dOdM0.setZero();\n Eigen::VectorXcd prev_Fminus_dOdM0(KMAX);\n prev_Fminus_dOdM0.setZero();\n Eigen::VectorXcd prev_Z_dOdM0(KMAX);\n prev_Z_dOdM0.setZero(); \n\n /////CRLB SIMULATION\n Z(0) = 1.0 + 0.0*i1;\n Z_dOdM0(0) = 1.0 + 0.0*i1;\n \n //simulate the sequence\n for (int j=0; j0; k--)\n {\n Fplus(k) = Fplus(k-1); \n Fplus_dOdT1(k) = Fplus_dOdT1(k-1); \n Fplus_dOdT2(k) = Fplus_dOdT2(k-1); \n Fplus_dOdM0(k) = Fplus_dOdM0(k-1);\n }\n \tFplus(0) = std::conj(Fminus(1));\n Fplus_dOdT1(0) = std::conj(Fminus_dOdT1(1));\n Fplus_dOdT2(0) = std::conj(Fminus_dOdT2(1)); \n Fplus_dOdM0(0) = std::conj(Fminus_dOdM0(1));\n \tfor (int k=0; k<(std::min(KMAX-1,j)); k++)\n { \n Fminus(k) = Fminus(k+1); \n Fminus_dOdT1(k) = Fminus_dOdT1(k+1); \n Fminus_dOdT2(k) = Fminus_dOdT2(k+1);\n Fminus_dOdM0(k) = Fminus_dOdM0(k+1);\n\n }\n \tFminus(std::min(KMAX-1,j)) = 0.0 + 0.0*i1;\n\t\tFminus_dOdT1(std::min(KMAX-1,j)) = 0.0 + 0.0*i1;\n Fminus_dOdT2(std::min(KMAX-1,j)) = 0.0 + 0.0*i1;\n\t\tFminus_dOdM0(std::min(KMAX-1,j)) = 0.0 + 0.0*i1; \n }\n\n V = F.inverse();\n\n double sq_eta_T1 = pow(T1[0],2.0) / (V(0,0) * Tacq); \n double sq_eta_T2 = pow(T2[0],2.0) / (V(1,1) * Tacq); \n\n if(sq_eta_T1>1e6 || sq_eta_T2>1e6 || sq_eta_T1<0 || sq_eta_T2<0){\n f[0] = 1e6;\n }\n else{\n f[0] = 1.0/sq_eta_T1 + 1.0/sq_eta_T2; \n } \n\n}\n\nvoid mexFunction(int nlhs, mxArray *plhs[], int rhs, const mxArray *prhs[])\n{\n /* Declare arrays necessary to compute signals */ \n double *N;\n double *FA; \n double *RF; \n double *TR; \n double *TE;\n double *T1;\n double *T2;\n\n double *f;\n\n /* Check for proper number of arguments */\n \n /* Create pointers to the inputs */\n N = mxGetPr(prhs[0]);\n FA = mxGetPr(prhs[1]); \n RF = mxGetPr(prhs[2]); \n TR = mxGetPr(prhs[3]);\n TE = mxGetPr(prhs[4]);\n T1 = mxGetPr(prhs[5]); \n T2 = mxGetPr(prhs[6]);\n\n /* Create pointers to the outputs */\n plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);\n \n // Check this link to see how to return complex arrays:\n // http://matlab.izmiran.ru/help/techdoc/matlab_external/ch04cre9.html\n f = mxGetPr(plhs[0]);\n \n /* Call the computational routine */\n EPG_GRE_efficiency(f, N, FA, RF, TR, TE, T1, T2);\n\n\n}\n\n\n\n\n", "meta": {"hexsha": "4fcdb7748d6a73efda37bd49e5fba4f8970d72d4", "size": 8207, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "library/cppEPG_GRE_efficiency.cpp", "max_stars_repo_name": "mriphysics/qMRI_efficiency", "max_stars_repo_head_hexsha": "f311785041939e0e278e4c9c4ae7dbe54d31f9d7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2020-05-05T16:00:04.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-19T01:59:23.000Z", "max_issues_repo_path": "library/cppEPG_GRE_efficiency.cpp", "max_issues_repo_name": "mriphysics/qMRI_efficiency", "max_issues_repo_head_hexsha": "f311785041939e0e278e4c9c4ae7dbe54d31f9d7", "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": "library/cppEPG_GRE_efficiency.cpp", "max_forks_repo_name": "mriphysics/qMRI_efficiency", "max_forks_repo_head_hexsha": "f311785041939e0e278e4c9c4ae7dbe54d31f9d7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-12-17T04:47:33.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-17T04:47:33.000Z", "avg_line_length": 28.4965277778, "max_line_length": 117, "alphanum_fraction": 0.546972097, "num_tokens": 3114, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970779778825, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.5417675858382334}} {"text": "#ifndef TRIUMF_BNMR_SLR_MOD_STR_EXP_HPP\n#define TRIUMF_BNMR_SLR_MOD_STR_EXP_HPP\n\n#include \n#include \n#include \n\n// TRIUMF: Canada's particle accelerator centre\nnamespace triumf {\n\n// β-detected nuclear magnetic resonance (β-NMR)\nnamespace bnmr {\n\n// spin-lattice relaxation (SLR)\nnamespace slr {\n\n/// pulsed modified stretched exponential integral (from 0 to time_p)\n/// https://doi.org/10.1006/jmra.1996.0029\ntemplate \nT pulsed_mod_str_exp_integral(T time, T time_p, T nuclear_lifetime,\n T slr_rate_initial, T slr_rate, T beta) {\n // do some conversions for consistency with Eqs. (4) to (7).\n T tau_0 = 1.0 / slr_rate_initial;\n T tau_d = 1.0 / slr_rate;\n T tau_c = std::pow(tau_d * std::pow(tau_0, -1.0 / beta), beta / (beta - 1.0));\n\n // integrand for the numeric integral\n auto integrand = [=](T t_p) {\n return std::exp(-(time - t_p) / nuclear_lifetime) *\n std::exp(-((time - t_p) / tau_0) *\n std::pow(1.0 + ((time - t_p) / tau_c), beta - 1.0));\n };\n // create the integrator for tanh-sinh quadrature\n static boost::math::quadrature::tanh_sinh integrator;\n // evaluate the integral from 0 to time_p\n T Q = integrator.integrate(integrand, 0.0, time_p);\n return Q;\n}\n\n/// pulsed modified stretched exponential\n/// https://doi.org/10.1006/jmra.1996.0029\ntemplate \nT pulsed_mod_str_exp(T time, T nuclear_lifetime, T pulse_length, T asymmetry,\n T slr_rate_initial, T slr_rate, T beta) {\n if (time == 0.0) {\n return asymmetry;\n } else if (time > 0.0 and time <= pulse_length) {\n return asymmetry *\n pulsed_mod_str_exp_integral(time, time, nuclear_lifetime,\n slr_rate_initial, slr_rate, beta) /\n normalization(time, nuclear_lifetime);\n } else if (time > pulse_length) {\n return (asymmetry *\n pulsed_mod_str_exp_integral(time, pulse_length, nuclear_lifetime,\n slr_rate_initial, slr_rate, beta) /\n normalization(pulse_length, nuclear_lifetime)) /\n std::exp(-(time - pulse_length) / nuclear_lifetime);\n } else {\n return 0.0;\n }\n}\n\n/// pulsed modified stretched exponential (ROOT)\n/// https://doi.org/10.1006/jmra.1996.0029\ntemplate T pulsed_mod_str_exp(const T *x, const T *par) {\n return pulsed_mod_str_exp(*x, par[0], par[1], par[2], par[3], par[4],\n par[5]);\n}\n\n} // namespace slr\n\n} // namespace bnmr\n\n} // namespace triumf\n\n#endif // TRIUMF_BNMR_SLR_MOD_STR_EXP_HPP", "meta": {"hexsha": "1409dd7a27b92647d68082f76ec2873652104abc", "size": 2693, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/triumf/bnmr/slr/mod_str_exp.hpp", "max_stars_repo_name": "rmlmcfadden/triumfpp", "max_stars_repo_head_hexsha": "da3911cdf1b0ee4600d27999d484f9a1bdb89b91", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/triumf/bnmr/slr/mod_str_exp.hpp", "max_issues_repo_name": "rmlmcfadden/triumfpp", "max_issues_repo_head_hexsha": "da3911cdf1b0ee4600d27999d484f9a1bdb89b91", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/triumf/bnmr/slr/mod_str_exp.hpp", "max_forks_repo_name": "rmlmcfadden/triumfpp", "max_forks_repo_head_hexsha": "da3911cdf1b0ee4600d27999d484f9a1bdb89b91", "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": 35.4342105263, "max_line_length": 80, "alphanum_fraction": 0.6435202377, "num_tokens": 774, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970779778824, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.5417675858382333}} {"text": "/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */\n\n/*\n Copyright (C) 2014 Jose Aparicio\n\n This file is part of QuantLib, a free-software/open-source library\n for financial quantitative analysts and developers - http://quantlib.org/\n\n QuantLib is free software: you can redistribute it and/or modify it\n under the terms of the QuantLib license. You should have received a\n copy of the license along with this program; if not, please email\n . The license is also available online at\n .\n\n This program is distributed in the hope that it will be useful, but WITHOUT\n ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n FOR A PARTICULAR PURPOSE. See the license for more details.\n*/\n\n#include \n#include \n#include \n#include \n\nnamespace QuantLib {\n\n TCopulaPolicy::TCopulaPolicy(\n const std::vector >& factorWeights, \n const initTraits& vals)\n {\n for(Size iFactor=0; iFactor 2, \n \"Non finite variance T in latent model.\");\n\n distributions_.push_back(boost::math::students_t_distribution<>(\n vals.tOrders[iFactor]));\n // inverses T variaces used in normalization of the random factors\n // For low values of the T order this number is very close to zero \n // and it enters the expresions dividing them, which introduces \n // numerical errors.\n varianceFactors_.push_back(std::sqrt(\n (vals.tOrders[iFactor]-2.)/vals.tOrders[iFactor]));\n }\n\n for(Size iLVar=0; iLVar normFactorWeights;\n for(Size iFactor=0; iFactor > \n TCopulaPolicy::allFactorCumulInverter(\n const std::vector& probs) const \n {\n #if defined(QL_EXTRA_SAFETY_CHECKS)\n QL_REQUIRE(probs.size()-latentVarsCumul_.size() \n == distributions_.size()-1, \n \"Incompatible sample and latent model sizes\");\n #endif\n\n std::vector result(probs.size());\n Size indexSystemic = 0;\n std::transform(probs.begin(), probs.begin() + varianceFactors_.size()-1,\n result.begin(), \n bind(&TCopulaPolicy::inverseCumulativeDensity, \n this, _1, indexSystemic++));\n std::transform(probs.begin() + varianceFactors_.size()-1, probs.end(),\n result.begin()+ varianceFactors_.size()-1,\n boost::bind(&TCopulaPolicy::inverseCumulativeZ, this, _1));\n return result;\n }\n\n}\n", "meta": {"hexsha": "0f5121336568016b80d1b1973873685372f1a904", "size": 4128, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ql/experimental/math/tcopulapolicy.cpp", "max_stars_repo_name": "grandtiger/quantlib", "max_stars_repo_head_hexsha": "4cf3d80ffc071ae74f026bb25fbb1dd9093e6301", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 41.0, "max_stars_repo_stars_event_min_datetime": "2016-03-19T02:31:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-20T13:23:20.000Z", "max_issues_repo_path": "ql/experimental/math/tcopulapolicy.cpp", "max_issues_repo_name": "grandtiger/quantlib", "max_issues_repo_head_hexsha": "4cf3d80ffc071ae74f026bb25fbb1dd9093e6301", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2020-07-17T18:49:22.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-17T18:49:22.000Z", "max_forks_repo_path": "ql/experimental/math/tcopulapolicy.cpp", "max_forks_repo_name": "grandtiger/quantlib", "max_forks_repo_head_hexsha": "4cf3d80ffc071ae74f026bb25fbb1dd9093e6301", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 22.0, "max_forks_repo_forks_event_min_datetime": "2016-03-17T14:14:36.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-28T10:33:19.000Z", "avg_line_length": 43.0, "max_line_length": 80, "alphanum_fraction": 0.6359011628, "num_tokens": 932, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970654616711, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.5417675781396637}} {"text": "#include \"MultilevelSpline.h\"\n#include \nnamespace DPhy\n{\nSpline::\nSpline(std::vector knots, double end) {\n\tmEnd = end;\n\tmKnots = knots;\n\tmNC_idxs.clear();\n\n\n}\nSpline::\nSpline(double knot_interval, double end) {\n\tmEnd = end;\n\tmKnots.clear();\n\tfor(int i = 0; i < end; i+= knot_interval) {\n\t\tmKnots.push_back(i);\n\t}\n\n\tmNC_idxs.clear();\n\n}\nvoid\nSpline:: \nSetKnots(std::vector knots) {\n\tmKnots = knots;\n}\nvoid\nSpline:: \nSetKnots(double knot_interval) {\n\tmKnots.clear();\n\tfor(int i = 0; i < mEnd; i+= knot_interval) {\n\t\tmKnots.push_back(i);\n\t}\n\n}\ndouble \nSpline::\nB(int idx, double t) {\n\tif(idx == 0) {\n\t\treturn 1.0 / 6 * pow(1 - t, 3);\n\t} else if (idx == 1) {\n\t\treturn 1.0 / 6 * (3 * pow(t, 3) - 6 * pow(t, 2) + 4);\n\t} else if (idx == 2) {\n\t\treturn 1.0 / 6 * (-3 * pow(t, 3) + 3 * pow(t, 2) + 3 * t + 1);\n\t} else {\n\t\treturn 1.0 / 6 * pow(t, 3);\n\t}\n}\nvoid\nSpline::\nApproximate(std::vector> motion, std::vector idxs, bool circular) {\n\tint length = mKnots.size();\n\tEigen::MatrixXd P(motion.size(), idxs.size());\n\tEigen::MatrixXd C(length+3, idxs.size());\n\n\tif(circular) {\n\t\tEigen::MatrixXd M(length, motion.size());\n\n\t\tM.setZero();\n\n\t\tint count = 0;\n\t\tfor(int i = 0; i < motion.size(); i++) {\n\t\t\tfor(int j = 0; j < idxs.size(); j++) {\n\t\t\t\tP(i, j) = (motion[i].first)[idxs[j]];\n\t\t\t}\n\t\t\tif(count + 1 < mKnots.size() && motion[i].second >= mKnots[count + 1]) {\n\t\t\t\tcount += 1;\n\t\t\t}\n\t\t\tdouble interval = mKnots[ (count + 1) % length ] - mKnots[count];\n\t\t\tif(interval < 0)\n\t\t\t\tinterval += mEnd;\n\t\t\tdouble f = (motion[i].second - mKnots[count]) / interval;\n\t\t\tM((count - 1 + length) % length, i) = B(0, f);\n\t\t\tM(count, i) = B(1, f);\n\t\t\tM((count + 1) % length, i) = B(2, f);\n\t\t\tM((count + 2) % length, i) = B(3, f);\n\t\t}\t\n\t\t\n\t\tEigen::MatrixXd Mt = M.transpose();\n\t\tauto solver = Mt.bdcSvd(Eigen::ComputeThinU | Eigen::ComputeThinV);\n\n\t\tfor(int i = 0; i < P.cols(); i++) {\n\t\t\tEigen::VectorXd cp = solver.solve(P.col(i));\n\t\t\tC.block(1, i, length, 1) = cp;\n\t\t\tC(0, i) = cp(cp.rows()-1);\n\t\t\tC(length+1, i) = cp(0);\n\t\t\tC(length+2, i) = cp(1);\n\t\t}\n\t} else {\n\t\tEigen::MatrixXd M(length+3, motion.size());\n\n\t\tM.setZero();\n\n\t\tint count = 0;\n\t\tfor(int i = 0; i < motion.size(); i++) {\n\t\t\tfor(int j = 0; j < idxs.size(); j++) {\n\t\t\t\tP(i, j) = (motion[i].first)[idxs[j]];\n\t\t\t}\t\t\t\n\t\t\tif(count + 1 < mKnots.size() && motion[i].second >= mKnots[count + 1]) {\n\t\t\t\tcount += 1;\n\t\t\t}\n\n\t\t\tdouble interval;\n\t\t\tif(count + 1 >= mKnots.size())\n\t\t\t\tinterval = mEnd - mKnots[count];\n\t\t\telse\n\t\t\t\tinterval = mKnots[count + 1] - mKnots[count];\n\t\t\tdouble f = (motion[i].second - mKnots[count]) / interval;\n\n\t\t\tM((count - 1) + 1, i) = B(0, f);\n\t\t\tM(count + 1, i) = B(1, f);\n\t\t\tM((count + 1) + 1, i) = B(2, f);\n\t\t\t\n\t\t\tif((count + 2) + 1 < M.rows())\n\t\t\t\tM((count + 2) + 1, i) = B(3, f);\n\t\t}\t\n\t\t\n\t\tEigen::MatrixXd Mt = M.transpose();\n\t\tauto solver = Mt.bdcSvd(Eigen::ComputeThinU | Eigen::ComputeThinV);\n\n\t\tfor(int i = 0; i < P.cols(); i++) {\n\t\t\tEigen::VectorXd cp = solver.solve(P.col(i));\n\t\t\tC.block(0, i, length + 3, 1) = cp;\n\t\t}\n\t}\n\n\tfor(int i = 0; i < C.rows(); i++) {\n\t\tfor(int j = 0; j < idxs.size(); j++) {\n\t\t\tmControlPoints[i][idxs[j]] = C(i, j);\n\t\t}\n\t}\n}\nvoid\nSpline::\nApproximate(std::vector> motion) {\n\tmControlPoints.clear();\n\n\tint dof = motion[0].first.rows();\n\n\tfor(int i = 0; i < mKnots.size()+3; i++) {\n\t\tEigen::VectorXd cp(dof);\n\t\tcp.setZero();\n\t\tmControlPoints.push_back(cp);\n\t}\n\tint count = 0;\n\tstd::vector C_idxs;\n\n\tfor(int i = 0; i < dof; i++) {\n\t\tif(mNC_idxs.size() == 0 || i != mNC_idxs[count]) {\n\t\t\tC_idxs.push_back(i);\n\t\t} else if(count + 1 < mNC_idxs.size()) {\n\t\t\tcount += 1;\n\t\t}\n\t}\n\n\tthis->Approximate(motion, C_idxs, true);\n\tthis->Approximate(motion, mNC_idxs, false);\n\n}\n\nEigen::VectorXd \nSpline::\nGetPosition(double t) {\n\n\tint length = mKnots.size();\n\tint dof = mControlPoints[0].rows();\n\tEigen::VectorXd p(dof);\n\tp.setZero();\n\tint knot = 0;\n\n\tfor(int i = length - 1; i >= 0; i--) {\n\t\tif(t > mKnots[i]) {\n\t\t\tknot = i;\n\t\t\tbreak;\n\t\t}\n\t}\n\tint nc_count = 0;\n\tdouble knot_interval_c;\n\tdouble knot_interval_nc;\n\tif(knot + 1 >= mKnots.size()) {\n\t\tknot_interval_c = mKnots[0] + mEnd - mKnots[knot];\n\t\tknot_interval_nc = mEnd - mKnots[knot];\n\t} else {\n\t\tknot_interval_c = mKnots[knot + 1] - mKnots[knot];\n\t\tknot_interval_nc = knot_interval_c;\n\t}\n\tdouble t_c = (t - mKnots[knot]) / knot_interval_c;\n\tdouble t_nc = (t - mKnots[knot]) / knot_interval_nc;\n\n\tbool circular = true;\n\tfor(int i = 0; i < dof; i++) {\n\t\tif(mNC_idxs.size() > nc_count && i == mNC_idxs[nc_count]) {\n\t\t\tcircular = false;\n\t\t\tnc_count += 1;\n\t\t} \n\t\tfor(int j = -1; j < 3; j++) {\n\t\t\tint cp_idx = knot + j + 1; \n\t\t\tif(circular)\n\t\t\t\tp(i) += this->B(j+1, t_c) * mControlPoints[cp_idx](i);\n\t\t\telse\n\t\t\t\tp(i) += this->B(j+1, t_nc) * mControlPoints[cp_idx](i);\n\t\t}\n\t}\n\n\treturn p;\n\n}\nvoid\nSpline::\nSave(std::string path) {\n\n\tstd::ofstream ofs(path);\n\n\tofs << mKnots.size() << std::endl;\n\tfor(auto t: mKnots) {\n\t\tofs << t << std::endl;\n\t}\n\tfor(auto t: mControlPoints) {\n\t\tofs << t.transpose() << std::endl;\n\t}\n\tstd::cout << \"saved spline to \" << path << std::endl;\n\tofs.close();\n}\nMultilevelSpline::\nMultilevelSpline(int level, double end) {\n\tmNumLevels = level;\n\tmEnd = end;\t\n\tfor(int i = 0; i < mNumLevels; i++) {\n\t\tSpline* s = new Spline(1, mEnd);\n\t\tmSplines.push_back(s);\n\t}\n}\nMultilevelSpline::\nMultilevelSpline(int level, double end, std::vector nc_idx) {\n\tmNumLevels = level;\n\tmEnd = end;\n\tint count = 0;\n\tfor(int i = 0; i < mNumLevels; i++) {\n\t\tSpline* s = new Spline(1, mEnd);\n\t\ts->SetNonCircular(nc_idx);\n\t\tmSplines.push_back(s);\n\t}\n}\nMultilevelSpline::\n~MultilevelSpline(){\t\n\twhile(!mSplines.empty()){\n\t\tSpline* s = mSplines.back();\n\t\tmSplines.pop_back();\n\n\t\tdelete s;\n\t}\t\n}\nvoid\nMultilevelSpline::\nSetKnots(int i, std::vector knots) {\n\tmSplines[i]->SetKnots(knots);\n}\nvoid\nMultilevelSpline::\nSetKnots(int i, double knot_interval) {\n\tmSplines[i]->SetKnots(knot_interval);\n}\nvoid \nMultilevelSpline::\nSetControlPoints(int i, std::vector cps) {\n\tmSplines[i]->SetControlPoints(cps);\n}\nstd::vector \nMultilevelSpline::\nGetControlPoints(int i) {\n\treturn mSplines[i]->GetControlPoints();\n}\nvoid\nMultilevelSpline::\nConvertMotionToSpline(std::vector> motion) {\n\tfor(int i = 0; i < mNumLevels; i++) {\n\t\tif(i == 0)\n\t\t{\n\t\t\tmSplines[i]->Approximate(motion);\n\t\t}\n\t\telse {\n\t\t\tstd::vector> displacement;\t\n\t\t\tfor(int j = 0; j < motion.size(); j++) {\n\t\t\t\tEigen::VectorXd p = mSplines[i-1]->GetPosition(motion[j].second);\n\t\t\t\tdisplacement.push_back(std::pair(motion[j].first - p, motion[j].second));\n\t\t\t}\n\t\t\tmSplines[i]->Approximate(displacement);\n\t\t}\n\t}\n}\nstd::vector \nMultilevelSpline::\nConvertSplineToMotion() {\n\tstd::vector motion;\n\t\n\tint dof = mSplines[0]->GetPosition(0).rows();\n\n\tfor(int i = 0; i < mEnd; i++) {\n\t\tmotion.push_back(Eigen::VectorXd::Zero(dof));\n\t}\n\n\tfor(int i = 0; i < mNumLevels; i++) {\n\t\tfor(int j = 0; j < mEnd; j++) {\n\t\t\tmotion[j] += mSplines[i]->GetPosition(j);\n\t\t}\n\t}\n\n\treturn motion;\n}\n}", "meta": {"hexsha": "f4e2e04499559bfbe7ba3ec471d80ad8ff298962", "size": 7115, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "sim/MultilevelSpline.cpp", "max_stars_repo_name": "snumrl/CAR", "max_stars_repo_head_hexsha": "af2ef26860bae56c42df71df0de4682d4898f380", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2022-01-28T08:47:27.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T10:56:21.000Z", "max_issues_repo_path": "sim/MultilevelSpline.cpp", "max_issues_repo_name": "snumrl/CAR", "max_issues_repo_head_hexsha": "af2ef26860bae56c42df71df0de4682d4898f380", "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": "sim/MultilevelSpline.cpp", "max_forks_repo_name": "snumrl/CAR", "max_forks_repo_head_hexsha": "af2ef26860bae56c42df71df0de4682d4898f380", "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": 22.8044871795, "max_line_length": 106, "alphanum_fraction": 0.5952213633, "num_tokens": 2559, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8652240756264638, "lm_q2_score": 0.6261241772283034, "lm_q1q2_score": 0.541737712469739}} {"text": "/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n * Filename : algorithms.cpp *\n * Project : Planewalker - Schnorr-Euchner sphere decoder simulation for space-time lattice codes *\n * Authors : Pasi Pyrrö, Oliver Gnilke *\n * Version : 1.0 *\n * Copyright : Aalto University ~ School of Science ~ Department of Mathematics and Systems Analysis *\n * Date : 9.1.2017 *\n * Language : C++ (2011 or newer standard) *\n * Description : All custom mathematical algorithms not found in Armadillo or STL are collected here *\n * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */\n\n#define ARMA_NO_DEBUG /* disable Armadillo bound checks for addiotional speed */\n#define FPLLL_WITH_ZDOUBLE\n#define FPLLL_WITH_LONG_DOUBLE\n\n#include \n#include /* linear algebra library */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/* library for LLL reduction (optional) */\n#ifdef USE_LLL\n#include \n#endif\n/* required packages to install:\n * libmpfr-dev\n * libgmp-dev\n */\n\n#include \"algorithms.hpp\"\n#include \"misc.hpp\"\n\nusing namespace std;\nusing namespace arma;\n\n/* Signum function for schorr-euchnerr sphere decoder (sesd) \n * ---------------------------------------------------------\n * Note that sesd_sign(0) = -1\n */\nint sesd_sign(double x) {\n return (x <= 0) ? -1 : 1;\n}\n\n\n/* compute greatest common divisor of a and b\n * credits go to: https://codereview.stackexchange.com/a/66735\n */\nint gcd(int a, int b) {\n return b == 0 ? a : gcd(b, a % b);\n}\n\n/* Rounds x to nearest integer in S\n * --------------------------------\n * E.g. let S = 4-PAM and x = 1.8 then \n * nearest_symbol(1.8) = 3\n * cf. round(1.8) = 2\n */\ndouble nearest_symbol(double x, const vector &S){\n double min = 10e6;\n double d = 0.0;\n double nearest = 0.0;\n\n for (const int symbol : S) {\n d = fabs(x - symbol);\n if (d < min) {\n nearest = symbol;\n min = d;\n }\n }\n return nearest;\n}\n\ndouble nearest_symbol_floor(double x, const vector &S){\n\n // for (const int symbol : S) {\n // if (symbol < x) {\n // return symbol;\n // }\n // }\n for (int i = S.size()-1; i >= 0; i--) {\n if (S[i] <= x) {\n return S[i];\n }\n }\n // return S[S.size()-1];\n return S[0];\n}\n\ndouble nearest_symbol_ceil(double x, const vector &S){\n\n for (auto i = 0u; i < S.size()-1; i++) {\n if (S[i] >= x) {\n return S[i];\n }\n }\n return S[S.size()-1];\n}\n\n/* A simple heuristic function based on the idea that the volume of the hypersphere divided by the volume of the fundamental region of the lattice \n * should roughly equal to the number of lattice points inside the hypersphere\n * i.e. this function estimates the squared radius required for the hypersphere in order to have 2^s codewords (lattice points) inside it\n * (for q-PAM we need to multiply the generator matrix by 2 to get the correct volume for the fundamental region)\n */\ndouble estimate_squared_radius(const mat &G, int s){\n int n = params[\"no_of_matrices\"];\n double pi = 3.1415926535897;\n // cout << \"lattice constant: \" << to_string(sqrt(det(4*G.t()*G))) << endl;\n // cout << \"volume of the sphere: \" << to_string(pow(pi, n/2.0)*pow(dparams[\"spherical_shaping_max_power\"], n/2)/tgamma(n/2.0 + 1.0)) << endl;\n\n /* The basic idea: 2^s = vol(Sphere(R))/vol(Lambda) \n * --> Solve for R when s and Lambda (G) are given\n */\n\n /* This algorithm uses this equation for the volume of the n-ball: \n * https://en.wikipedia.org/wiki/Volume_of_an_n-ball\n */\n return pow(pow(2.0, s)*tgamma(n/2.0 + 1.0)*sqrt(det(4*G.t()*G))*pow(pi, n/-2.0), 2.0/n);\n}\n\n/* Generates a new symbolset where elements are between given lower and upper bounds */\nvector slice_symbset(const vector &S, double lb, double ub){\n vector retval;\n for (const int q : S){\n if (lb <= (double)q && (double)q <= ub) {\n retval.push_back(q);\n }\n }\n return retval;\n}\n\n/* Takes the squared Frobenius norm from a complex matrix A */\ndouble frob_norm_squared(const cx_mat &A){\n double sum = 0;\n for (auto i = 0u; i < A.n_rows; i++)\n for (auto j = 0u; j < A.n_cols; j++)\n sum += norm(A(i,j)); \n return sum;\n}\n\n/* Makes sure the upper triangular matrix R has only positive diagonal elements */\nvoid process_qr(mat &Q, mat &R){\n for (auto i = 0u; i < R.n_cols; i++){\n if (R(i,i) < 0.0){\n // R.col(i) *= -1;\n // Q.row(i) *= -1;\n R.row(i) *= -1;\n Q.col(i) *= -1;\n }\n }\n}\n\n/* Create the lattice generator matrix G out of basis matrices B_i\n * i.e. G = vec(B_i), i = 1,...,k\n */\ncx_mat create_generator_matrix(const vector &bases){\n int m = params[\"no_of_transmit_antennas\"];\n int t = params[\"time_slots\"];\n int k = params[\"no_of_matrices\"];\n cx_mat G(k, m*t);\n for(int i = 0; i < k; i++){\n G.row(i) = vectorise(bases[i], 1);\n }\n return G.st();\n}\n\n\n/***** DEPRECATED *****\n * Use \n * G_real = to_real_matrix(create_generator_matrix(bases));\n * instead \n **********************/\n\n/* Create the real valued lattice generator matrix G out of basis matrices */\n// mat create_real_generator_matrix(const vector &bases){\n// int m = params[\"no_of_transmit_antennas\"];\n// int t = params[\"time_slots\"];\n// int k = params[\"no_of_matrices\"];\n// mat G(2*m*t,k);\n// for(int i = 0; i < k; i++){ \n// G.col(i) = to_real_vector(bases[i]);\n// }\n// return G;\n// }\n\n\n/* Inverse of the create_generator_matrix() function \n * Useful for generating basis matrix files in conjunction with\n * output_complex_matrix()\n * See main.cpp for an example of this use case\n */\nvector generator_to_bases(const cx_mat &G){\n int m = params[\"no_of_transmit_antennas\"];\n int t = params[\"time_slots\"];\n int idx = 0;\n\n vector bases;\n cx_mat X(m, t);\n cx_vec col(m*t);\n\n for (auto i = 0u; i < G.n_cols; i++){\n X.zeros();\n col = G.col(i);\n for (int j = 0; j < m; j++){\n for (int s = 0; s < t; s++){\n X(j,s) = col[idx];\n idx++;\n }\n }\n idx = 0;\n bases.push_back(X);\n }\n return bases;\n}\n\n/* Vectorizes a complex matrix A to real vector (each row is concatenated) */\nvec to_real_vector(const cx_mat &A, bool row_wise){\n vec a(2*A.n_elem); \n // as the imaginary parts are now independent real elements in the vector,\n // we need to double the number of elements in the returned vector\n int index = 0;\n if (row_wise){\n for (auto i = 0u; i < A.n_rows; i++){\n for (auto j = 0u; j < A.n_cols; j++){\n auto z = A(i,j);\n a[index++] = z.real();\n a[index++] = z.imag();\n }\n }\n } else { /* concatenate columns instead */\n for (auto i = 0u; i < A.n_cols; i++){\n for (auto j = 0u; j < A.n_rows; j++){\n auto z = A(j,i);\n a[index++] = z.real();\n a[index++] = z.imag();\n }\n }\n }\n return a;\n}\n\n/* Converts a complex matrix A to its real representation */\nmat to_real_matrix(const cx_mat &A){\n mat B(2*A.n_rows, A.n_cols);\n for(auto i = 0u; i < A.n_cols; i++){ \n B.col(i) = to_real_vector(A.col(i));\n }\n return B;\n}\n\n/* Converts a real matrix constructed out of a complex matrix back to complex */\ncx_mat to_complex_matrix(const mat &A){\n if (A.n_rows % 2 != 0){\n log_msg(\"to_complex_matrix: the input matrix needs to have an even number of rows!\", \"Error\");\n exit(1);\n }\n\n cx_mat B(A.n_rows/2, A.n_cols);\n // int index = 0;\n for (auto j = 0u; j < A.n_cols; j++){\n for (auto i = 0u; i < B.n_rows; i++){\n B(i,j) = complex(A(2*i,j), A(2*i+1,j));\n }\n // index = 0;\n }\n return B;\n}\n\n/* generates a random n x m 'full' complex matrix from normal distribution */\ncx_mat create_random_matrix(int n, int m, double mean, double variance){\n normal_distribution distr(mean, sqrt(variance));\n cx_mat A(n,m);\n return A.imbue([&]() { /* Armadillo magic with lambda function */\n return complex(distr(mersenne_twister), distr(mersenne_twister));\n });\n}\n\n/* generates a random n x n diagonal complex matrix from normal distribution \n * Used for generating the SISO channel matrix\n */\ncx_mat create_random_diag_matrix(int n, double mean, double variance){\n normal_distribution distr(mean, sqrt(variance));\n cx_vec diag(n);\n cx_mat A(n,n);\n\n A.zeros();\n diag.imbue([&]() { /* Armadillo magic with lambda function */\n return complex(distr(mersenne_twister), 0.0);\n });\n A.diag() = diag;\n return A;\n}\n\n/* Creates q-PAM symbol set (integer vector) \n * q is usually some power of two, i.e. q = 2, 4, 8, 16...\n * Example: 4-PAM = {-3, -1, 1, 3}\n */\nvector create_symbolset(int q){\n vector symbset(q);\n for (int u = 0; u < q; u++) {\n symbset[u] = 2*u - q + 1;\n }\n return symbset; \n}\n\n/* Calculates all possible combinations of elements for code vector _a_\n given the set of feasible symbols (element values)\n Used for generating the whole codebook, rarely needed though */\nvoid combinations(parallel_set< vector > &comblist, const vector &symbset, vector comb, int dim){\n comblist.par_insert(comb);\n if (dim >= 0){\n #pragma omp parallel \n {\n vector new_comb = comb;\n #pragma omp for\n for (size_t i = 0; i < symbset.size(); i++){\n new_comb[dim] = symbset[i];\n combinations(comblist, symbset, new_comb, dim-1);\n }\n }\n }\n}\n\n/* Helper function for above combinations algorithm */\nset< vector > comb_wrapper(const vector &symbset, int vector_len){\n parallel_set< vector > comblist;\n vector init(vector_len);\n for (int i = 0; i < vector_len; i++)\n init[i] = symbset[0];\n combinations(comblist, symbset, init, vector_len-1);\n return comblist;\n}\n\n/* Creates a random codeword from basis matrices B_i and symbolset x-PAM */\npair, cx_mat> create_random_codeword(const vector &bases, const vector &symbolset){\n int m = params[\"no_of_transmit_antennas\"];\n int t = params[\"time_slots\"];\n int k = params[\"no_of_matrices\"];\n int q = params[\"x-PAM\"];\n int random_index = 0;\n\n cx_mat X(m, t);\n vector coeffs(k);\n X.zeros();\n\n uniform_int_distribution dist(0, q-1);\n\n for (int i = 0; i < k; i++) {\n random_index = dist(mersenne_twister);\n coeffs[i] = symbolset[random_index];\n X = X + symbolset[random_index]*bases[i];\n }\n\n return make_pair(coeffs, X); \n}\n\n/* Attempts to take account the probability bias when picking vector coefficients uniform randomly \n from hyperplane intervals within a hypersphere */\n// vector create_unbiased_subset(const mat &R, const vector &subset, vec xt,\n// vec ener, vec curr, double radius, int i){\n// if (i <= 0) return subset; /* can't perform lookahead for the lowest dimension */\n\n// vector unbiased_subset; //, delta_vec;\n// unbiased_subset.reserve(4*subset.size());\n\n// double xiener = 0.0;\n// int ub = 0, lb = 0, delta = 0; //, delta_sum = 0, bias_correction_amount = 0;\n// int k = params[\"no_of_matrices\"];\n\n// // cout << i << endl;\n// // cout << vec2str(xt, xt.size()) << endl;\n// // cout << vec2str(ener, ener.size()) << endl;\n// // cout << vec2str(curr, curr.size()) << endl << endl;\n\n// for (const int elem : subset) {\n// xt[i] = elem;\n// xiener = pow(R(i,i)*xt[i] + curr[i], 2);\n\n// for (int j = i; j < k; j++)\n// curr[i-1] += xt[j]*R(i-1,j);\n// ener[i-1] = ener[i] + xiener;\n\n// lb = nearest_symbol_ceil(-(sqrt(radius - ener[i-1]) + curr[i-1])/R(i-1,i-1), subset);\n// ub = nearest_symbol_floor((sqrt(radius - ener[i-1]) - curr[i-1])/R(i-1,i-1), subset);\n// delta = (ub - lb)/2 + 1;\n\n// // cout << lb << \", \" << ub << \", \" << delta << endl;\n\n// for (int d = 0; d < delta; d++)\n// unbiased_subset.push_back(elem);\n// // delta_vec.push_back(delta);\n// // delta_sum += delta;\n// }\n// // cout << vec2str(xt, xt.size()) << endl;\n// // cout << vec2str(ener, ener.size()) << endl;\n// // cout << vec2str(curr, curr.size()) << endl << endl;\n// // cout << endl;\n\n// // for (auto j = 0u; j < subset.size(); j++){\n// // bias_correction_amount = delta_sum/gcd(delta_sum, delta_vec[j]);\n// // for (int s = 0; s < bias_correction_amount; s++)\n// // unbiased_subset.push_back(subset[j]);\n// // }\n// // cout << vec2str(unbiased_subset, unbiased_subset.size()) << endl << endl;\n// return unbiased_subset;\n// }\n\n\n/* Attempts to pick q-PAM coefficients which correspond to large subhyperspheres more often \n This should eliminate some the bias present (picking border points too often) in naive uniform random picking */\nint unbiased_random_select(const mat &R, const vector &subset, vec xt,\n vec ener, vec curr, double radius, int i){\n if (i <= 0) return 0; /* can't perform lookahead for the lowest dimension */\n\n vector unbiased_subset, feasible_coeffs;\n vector radiuses;\n vector> intervals;\n unbiased_subset.reserve(4*subset.size());\n radiuses.reserve(subset.size());\n intervals.reserve(subset.size());\n feasible_coeffs.reserve(subset.size());\n\n double xiener = 0.0, radius_sum = 0.0, r = 0.0, numer = 0.0, ub = 0, lb = 0;\n int k = params[\"no_of_matrices\"];\n\n /* calculate subsphere radiuses for each coefficient */\n for (auto j = 0u; j < subset.size(); j++) {\n xt[i] = subset[j];\n xiener = pow(R(i,i)*xt[i] + curr[i], 2);\n r = radius - xiener - ener[i];\n if (r > 0){ /* We don't want negative radiuses, do we? */\n r = pow(r, k-1);\n radiuses.push_back(r);\n radius_sum += r;\n feasible_coeffs.push_back(subset[j]);\n }\n }\n\n /* Calculate intervals from [0,1] for each coefficient */\n for (auto j = 0u; j < radiuses.size(); j++) {\n lb = numer/radius_sum;\n ub = (numer+radiuses[j])/radius_sum;\n intervals.push_back(make_pair(lb, ub));\n numer += radiuses[j];\n }\n\n // intervals.back().second = 1.0;\n\n // cout << vec2str(radiuses, radiuses.size()) << endl;\n // cout << vec2str(feasible_coeffs, feasible_coeffs.size()) << endl;\n // cout << vec2str(intervals, intervals.size()) << endl << endl;\n // cout << endl;\n\n // uniform_real_distribution dist(0.0, 1.0);\n double X = uniform_real_dist(mersenne_twister);\n // cout << X << endl << endl;\n\n /* Select the coefficient from distribution created earlier (weights large radiuses) */\n for (auto j = 0u; j < feasible_coeffs.size(); j++) {\n // cout << \"[\" << intervals[j].first << \", \" << intervals[j].second << \"]\" << endl;\n if (intervals[j].first <= X && X <= intervals[j].second)\n return feasible_coeffs[j];\n }\n // cout << \"------\" << endl;\n \n return 0;\n}\n\n/* Creates a random codeword from basis matrices B_i and symbolset x-PAM within given radius (spherical shaping) */\npair, cx_mat> create_random_spherical_codeword(const vector &bases, const mat &R, const vector &S, double radius){\n int m = params[\"no_of_transmit_antennas\"];\n int t = params[\"time_slots\"];\n int k = params[\"no_of_matrices\"];\n\n cx_mat X(m, t);\n vector coeffs(k), subset;\n X.zeros();\n\n vec xt(k), curr(k), ener(k);\n xt.zeros(); curr.zeros(); ener.zeros();\n int i = k-1;\n double xiener = 0.0;\n double lb = 0.0; // lower bound\n double ub = 0.0; // upper bound\n\n // radius = sqrt(radius);\n\n /* Randomly pick each component of the codeword and check if it's still within the energy bound in each dimension */\n while (i >= 0){\n lb = -(sqrt(radius - ener[i]) + curr[i])/R(i,i);\n ub = (sqrt(radius - ener[i]) - curr[i])/R(i,i);\n // uniform_real_distribution xirange(lb, ub);\n // xt[i] = nearest_symbol(xirange(mersenne_twister), S); // probability bias fix this\n subset = slice_symbset(S, lb, ub);\n // if (i >= k-10 /*max(k-13, 3)*/ && !subset.empty())\n // subset = create_unbiased_subset(R, subset, xt, ener, curr, radius, i);\n\n if (subset.empty()) { /* No lattice points are within energy bounds in this dimension */\n i = k-1;\n xt.zeros(); curr.zeros(); ener.zeros();\n continue;\n }\n \n // if (i > 0)\n // xt[i] = unbiased_random_select(R, subset, xt, ener, curr, radius, i);\n // else\n xt[i] = pick_uniform(subset);\n\n if (xt[i] == 0) {\n // cout << \"something went wrong\" << endl;\n i = k-1;\n xt.zeros(); curr.zeros(); ener.zeros();\n continue;\n }\n\n xiener = pow(R(i,i)*xt[i] + curr[i], 2);\n\n // if (xiener + ener[i] < radius + 1e-6) { \n if (i > 0) { \n for (int j = i; j < k; j++)\n curr[i-1] += xt[j]*R(i-1,j);\n ener[i-1] = ener[i] + xiener; \n } \n i--;\n // } else { /* we're outside the energy bound, start over */\n // log_msg(\"test!\", \"Error\");\n // i = k-1;\n // xt.zeros(); curr.zeros(); ener.zeros();\n // }\n }\n coeffs = conv_to>::from(xt);\n for (int i = 0; i < k; i++) {\n X = X + coeffs[i]*bases[i];\n }\n return make_pair(coeffs, X);\n}\n\n/* Creates a codebook from basis matrices B_i and symbolset x-PAM within given radius (spherical shaping) */\n// vector, cx_mat>> create_spherical_codebook(const vector &bases, const mat &R, const vector &S, double radius){\nvector, cx_mat>> create_spherical_codebook(const vector &bases, const mat &R, const vector &S, \n double radius, vec xt, int dim, double dist) {\n int m = params[\"no_of_transmit_antennas\"];\n int t = params[\"time_slots\"];\n int k = params[\"no_of_matrices\"];\n\n cx_mat X(m, t, fill::zeros);\n vector coeffs(k); //, subset;\n vector,cx_mat>> codebook, part;\n\n // vec xt(k), curr(k), ener(k), indices(k);\n // xt.zeros(); curr.zeros(); ener.zeros(); indices.zeros();\n // int i = k-1;\n int i = dim-1;\n double xidist = 0;\n // double xiener = 0.0;\n // double lb = 0.0; // lower bound\n // double ub = 0.0; // upper bound\n // bool nextlevel = true;\n\n // while (true) {\n // if (nextlevel) {\n // lb = -(sqrt(radius - ener[i]) + curr[i])/R(i,i);\n // ub = (sqrt(radius - ener[i]) - curr[i])/R(i,i);\n // subset = slice_symbset(S, lb, ub);\n // if (subset.empty()) { /* No lattice points are within energy bounds in this dimension */\n // cout << \"empty interval!\" << endl;\n // if (i == k - 1) break;\n // else {\n // indices[i] = 0;\n // // indices[i+1]++;\n // i++;\n // continue;\n // }\n // }\n // nextlevel = false;\n // }\n // xt[i] = subset[indices[i]];\n\n // xiener = pow(R(i,i)*xt[i] + curr[i], 2);\n\n // cout << i << \": \" << vec2str(xt, k) << \", xiener = \" << xiener + ener[i] << \" interval: [\" << lb << \", \" << ub << \"], xt[i] = \" << xt[i] << endl;\n // cout << \"subset: \" << vec2str(subset, subset.size()) << endl;\n\n // // if (xiener + ener[i] < radius + 1e-6) { \n // if (i > 0) {\n // curr[i-1] = 0; \n // for (int j = i; j < k; j++)\n // curr[i-1] += xt[j]*R(i-1,j);\n // ener[i-1] = ener[i] + xiener; \n // i--;\n // nextlevel = true;\n // cout << \"lowering dimension!\" << endl;\n // // continue; \n // } else {\n // coeffs = conv_to>::from(xt);\n // X.zeros();\n // for (int i = 0; i < k; i++) {\n // X = X + coeffs[i]*bases[i];\n // }\n // cout << \"found point!\" << endl;\n // codebook.push_back(make_pair(coeffs, X));\n // } \n // // }\n // if (indices[i] >= subset.size() - 1){\n // cout << \"subset clear!\" << endl;\n // if (i == k - 1) break;\n // else {\n // indices[i] = 0;\n // // indices[i+1]++;\n // i++;\n // nextlevel = true;\n // }\n // } else indices[i]++; \n // }\n // return codebook;\n\n // #pragma omp parallel for\n for (auto j = 0u; j < S.size(); j++) {\n vec tmp = xt;\n tmp[i] = S[j];\n xidist = pow(dot(R.row(i).subvec(i, k-1), tmp.subvec(i, k-1)), 2) + dist;\n if (xidist <= radius) {\n if (i > 0) {\n part = create_spherical_codebook(bases, R, S, radius, tmp, dim-1, xidist);\n codebook.insert(codebook.end(), part.begin(), part.end());\n } else {\n coeffs = conv_to>::from(tmp);\n X.zeros();\n for (int s = 0; s < k; s++) {\n X = X + coeffs[s]*bases[s];\n }\n // cout << vec2str(coeffs, k) << endl;\n codebook.push_back(make_pair(coeffs, X));\n }\n }\n }\n return codebook;\n}\n\n\n/* Creates a codebook (set of X matrices) from basis matrices B_i and symbolset q-PAM */\nvector,cx_mat>> create_codebook(const vector &bases, const mat &R, const vector &symbolset){\n int m = params[\"no_of_transmit_antennas\"];\n int t = params[\"time_slots\"];\n int k = params[\"no_of_matrices\"];\n int cs = dparams[\"codebook_size\"];\n int samples = params[\"energy_estimation_samples\"];\n double P = dparams[\"spherical_shaping_max_power\"];\n\n vector,cx_mat>> codebook;\n pair,cx_mat> code;\n vector tmp;\n cx_mat X(m, t);\n X.zeros();\n \n if(samples > 0){\n for (int j = 0; j < samples; j++){\n if (P > 0)\n code = create_random_spherical_codeword(bases, R, symbolset, P);\n else\n code = create_random_codeword(bases, symbolset);\n codebook.push_back(code);\n }\n } else {\n if (P > 0)\n return create_spherical_codebook(bases, R, symbolset, P, vec(k, fill::zeros), k, 0);\n\n if (cs > 1e6)\n log_msg(\"create_codebook: Generating a codebook of size \" + to_string(cs) + \", this can be really slow!\", \"Warning\");\n\n /* all possible combinations of code words */\n auto c = comb_wrapper(symbolset, k);\n\n // log_msg(\"All possible data vector combinations:\");\n for (const auto &symbols : c){\n X.zeros();\n for (int i = 0; i < k; i++)\n X = X + symbols[i]*bases[i];\n // log_msg(vec2str(symbols, symbols.size()));\n // if (frob_norm_squared(X) > P + 1e-6 && P > 0) continue;\n codebook.push_back(make_pair(symbols, X));\n }\n }\n return codebook;\n}\n\n/* Computes the average and maximum energy of given codebook X */\npair code_energy(const vector,cx_mat>> &X){\n double sum = 0, max = 0, tmp = 0, average = 0;\n int cs = (int) X.size();\n\n for (int i = 0; i < cs; i++){\n tmp = frob_norm_squared(X[i].second);\n sum += tmp;\n if (tmp > max)\n max = tmp;\n }\n average = sum / cs;\n return make_pair(average, max);\n}\n\n/* Returns the shortest lattice basis vector from the lattice generator matrix G*/\ncx_vec shortest_basis_vector(const cx_mat &G){\n cx_vec shortest(G.n_rows, fill::zeros);\n double len = 10e9;\n for (auto i = 0u; i < G.n_cols; i++){\n if (len > norm(G.col(i), 2)) {\n shortest = G.col(i);\n len = norm(shortest, 2);\n }\n }\n return shortest;\n}\n\n/* Check if x belongs to the right coset (when using coset encoding)\n * i.e. check if the difference vector sent_x - decoded_x belongs in \n * the given sublattice of the codebook carved out of lattice G_b\n */\nbool coset_check(const cx_mat &Gb, const cx_mat &invGe, const Col diff){\n cx_vec x = Gb*diff;\n cx_vec lambda = invGe*x;\n\n vec lambda_real = to_real_vector(lambda);\n \n /* check if lambda_real has only integer entries */\n for (const auto &l : lambda_real)\n if (fabs(l - round(l)) > 10e-5) /* tolerance */\n return false;\n\n return true;\n}\n\n/* calculates different rates related to the coset encoded block code */\ntuple code_rates(const cx_mat &Gb, const cx_mat &Ge){\n mat RGb = to_real_matrix(Gb);\n mat RGe = to_real_matrix(Ge);\n // cout << \"Vol(Ge): \" << sqrt(det(RGe.t()*RGe)) << endl;\n // cout << \"Vol(Gb): \" << sqrt(det(RGb.t()*RGb)) << endl;\n double r = log2(dparams[\"codebook_size\"]); // overall rate\n double rt = log2(sqrt(det(RGe.t()*RGe))/sqrt(det(RGb.t()*RGb))); // transmission rate\n double rc = r - rt; // confusion rate\n return make_tuple(r, rt, rc); \n}\n\n/* algorithm for counting the lattice points inside a _dim_ dimensional hypersphere of radius _radius_ \n * considers only a single radius, but probably faster than the function below thanks to parallelisation\n */\nint count_points(const mat &R, const vector &S, double radius, vec xt, int dim, double dist){\n\n int k = params[\"no_of_matrices\"];\n int i = dim - 1;\n\n vector counters(omp_get_max_threads());\n\n #pragma omp parallel for\n for (auto j = 0u; j < S.size(); j++) {\n vec tmp = xt;\n tmp[i] = S[j];\n double xidist = pow(dot(R.row(i).subvec(i, k-1), tmp.subvec(i, k-1)), 2) + dist;\n if (xidist <= radius) {\n if (i > 0) {\n counters[omp_get_thread_num()] += count_points(R, S, radius, tmp, dim-1, xidist);\n } else {\n counters[omp_get_thread_num()]++;\n }\n }\n }\n return accumulate(counters.begin(), counters.end(), 0);\n}\n\n\n/* algorithm for counting the lattice points inside a _dim_ dimensional hypersphere of radiuses r_1, r_2, ..., r_n */\nvector count_points_many_radiuses(const mat &R, const vector &S, vector radiuses, vec xt, int dim, double dist){\n\n int k = params[\"no_of_matrices\"];\n int i = dim - 1;\n\n vector counters(radiuses.size());\n\n for (auto j = 0u; j < S.size(); j++){\n vec tmp = xt;\n tmp[i] = S[j];\n double xidist = pow(dot(R.row(i).subvec(i, k-1), tmp.subvec(i, k-1)), 2) + dist;\n \n if (xidist <= radiuses[0]){\n if (i > 0){\n vector counts = count_points_many_radiuses(R, S, radiuses, tmp, dim-1, xidist);\n for (auto s = 0u; s < radiuses.size(); s++)\n counters[s] += counts[s];\n } else {\n for (auto k = 0u; k < radiuses.size(); k++){\n if (xidist <= radiuses[k])\n counters[k]++;\n }\n }\n } \n }\n return counters;\n}\n\n/* \n * Should return the LLL reduced (as close to orthogonal as possible) basis for lattice generated by G \n */\ncx_mat LLL_reduction(const cx_mat &G) {\n #ifdef USE_LLL\n\n mat G_real = to_real_matrix(G);\n\n // ZZ_mat fpG(G_real.n_rows, G_real.n_cols);\n // ZZ_mat fpG(G_real.n_cols, G_real.n_rows);\n FP_mat fpG(G_real.n_cols, G_real.n_rows);\n for (auto i = 0u; i < G_real.n_rows; i++) {\n for (auto j = 0u; j < G_real.n_cols; j++) {\n // fpG(i, j) = G_real(i, j);\n fpG(j, i) = G_real(i, j);\n }\n }\n cout << fpG << endl << endl;\n int status = lll_reduction(fpG, LLL_DEF_DELTA, LLL_DEF_ETA, LM_PROVED, FT_DEFAULT, 0, LLL_DEFAULT);\n if (status != RED_SUCCESS) {\n log_msg(\"LLL reduction failed!\", \"Error\"); //with error '\" + to_string(get_red_status_str(status)) + \"'\", \"Error\");\n exit(1);\n }\n cout << fpG << endl << endl;\n for (auto i = 0u; i < G_real.n_rows; i++) {\n for (auto j = 0u; j < G_real.n_cols; j++) {\n // G_real(i, j) = fpG(i, j).get_d();\n G_real(i, j) = fpG(j, i).get_d();\n }\n }\n cout << G_real << endl;\n return to_complex_matrix(G_real);\n\n #else /* Do nothing */\n\n return G;\n\n #endif\n}", "meta": {"hexsha": "368a0536963b859b643435c7b0667dee195ee203", "size": 29560, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/algorithms.cpp", "max_stars_repo_name": "Hyper5phere/sphere-decoder", "max_stars_repo_head_hexsha": "f84cbcb47314547150639bbed017e8e540d32ced", "max_stars_repo_licenses": ["Unlicense"], "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/algorithms.cpp", "max_issues_repo_name": "Hyper5phere/sphere-decoder", "max_issues_repo_head_hexsha": "f84cbcb47314547150639bbed017e8e540d32ced", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/algorithms.cpp", "max_forks_repo_name": "Hyper5phere/sphere-decoder", "max_forks_repo_head_hexsha": "f84cbcb47314547150639bbed017e8e540d32ced", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.0236966825, "max_line_length": 156, "alphanum_fraction": 0.5365020298, "num_tokens": 8102, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8056321889812554, "lm_q2_score": 0.6723317123102956, "lm_q1q2_score": 0.5416520691100591}} {"text": "#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#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef OPENMP\n#include \n#endif\n\nvoid Perform_Alpert_transform(boost::numeric::ublas::vector f, std::vector ki, int J,int dir, boost::numeric::ublas::vector& w, std::list > > Uj, std::list > part, std::vector G);\nvoid Compute_Uj(std::vector >p, std::vector ki, int &J, std::list > > &Uj, std::list > &part, std::vector &G);\nvoid Optimal_Alpert_transform(boost::numeric::ublas::vector f, std::vector >p, std::vector ki, int J, boost::numeric::ublas::vector& w, std::list > > Uj, std::list > part, std::vector G, double NRMSE, double &R, double mx, double mn, double mxg, double mng, double alpha);", "meta": {"hexsha": "d4054b70339140e4511409ece8f7c90606b527b7", "size": 1825, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "swinzip-v2.0/src/Alpert/Alpert_Transform.hpp", "max_stars_repo_name": "msalloum80/SWinzip", "max_stars_repo_head_hexsha": "5d43e9f11776d513218b891683b7aa00b36fae23", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-05-17T07:58:23.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-17T07:58:23.000Z", "max_issues_repo_path": "swinzip-v2.5/src/Alpert/Alpert_Transform.hpp", "max_issues_repo_name": "msalloum80/SWinzip", "max_issues_repo_head_hexsha": "5d43e9f11776d513218b891683b7aa00b36fae23", "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": "swinzip-v2.5/src/Alpert/Alpert_Transform.hpp", "max_forks_repo_name": "msalloum80/SWinzip", "max_forks_repo_head_hexsha": "5d43e9f11776d513218b891683b7aa00b36fae23", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-05-05T20:18:25.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-05T20:18:25.000Z", "avg_line_length": 60.8333333333, "max_line_length": 419, "alphanum_fraction": 0.7495890411, "num_tokens": 521, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8056321889812553, "lm_q2_score": 0.6723317123102955, "lm_q1q2_score": 0.541652069110059}} {"text": "//\n// Created by jachu on 27.02.18.\n//\n\n#include \n\n#include \n\n#include \n\n#include \"PlaneEstimator.hpp\"\n\nusing namespace std;\n\nPlaneEstimator::PlaneEstimator() {\n\n}\n\nPlaneEstimator::PlaneEstimator(const Eigen::MatrixXd &pts) {\n init(pts);\n}\n\nPlaneEstimator::PlaneEstimator(const Eigen::Vector3d &icentroid,\n const Eigen::Matrix3d &icovar,\n int inpts)\n{\n init(icentroid,\n icovar,\n inpts);\n}\n\nvoid PlaneEstimator::init(const Eigen::MatrixXd &pts) {\n Eigen::Vector3d icentroid;\n Eigen::Matrix3d icovar;\n compCentroidAndCovar(pts, icentroid, icovar);\n init(icentroid, icovar, pts.cols());\n}\n\nvoid\nPlaneEstimator::init(const Eigen::Vector3d &icentroid, const Eigen::Matrix3d &icovar, int inpts) {\n centroid = icentroid;\n covar = icovar;\n npts = inpts;\n compPlaneParams(centroid,\n covar,\n evecs,\n evals,\n planeEq);\n}\n\nvoid\nPlaneEstimator::update(const Eigen::Vector3d &ucentroid, const Eigen::Matrix3d &ucovar, int unpts) {\n// cout << \"centroid = \" << centroid.transpose() << endl;\n// cout << \"covar = \" << covar << endl;\n// cout << \"npts = \" << npts << endl;\n// cout << \"ucentroid = \" << ucentroid.transpose() << endl;\n// cout << \"ucovar = \" << ucovar << endl;\n// cout << \"unpts = \" << unpts << endl;\n \n updateCentroidAndCovar(centroid,\n covar,\n npts,\n ucentroid,\n ucovar,\n unpts,\n centroid,\n covar,\n npts);\n \n// cout << \"centroid = \" << centroid.transpose() << endl;\n// cout << \"covar = \" << covar << endl;\n// cout << \"npts = \" << npts << endl;\n \n static constexpr int ptsLimit = 500000;\n if(npts > ptsLimit){\n double scale = (double)npts/ptsLimit;\n covar /= scale;\n npts = ptsLimit;\n }\n// cout << \"centroid = \" << centroid.transpose() << endl;\n// cout << \"covar = \" << covar << endl;\n// cout << \"npts = \" << npts << endl;\n \n compPlaneParams(centroid,\n covar,\n evecs,\n evals,\n planeEq);\n}\n\ndouble PlaneEstimator::distance(const PlaneEstimator &other) const {\n const Eigen::Vector3d ¢roid1 = centroid;\n const Eigen::Vector3d ¢roid2 = other.centroid;\n Eigen::Matrix3d covar1 = covar / npts;\n Eigen::Matrix3d covar2 = other.covar / other.npts;\n int npts1 = npts;\n int npts2 = other.npts;\n \n// cout << \"centroid1 = \" << centroid1.transpose() << endl;\n// cout << \"covar1 = \" << covar1 << endl;\n// cout << \"centroid2 = \" << centroid2.transpose() << endl;\n// cout << \"covar2 = \" << covar2 << endl;\n//\n// Eigen::Vector3d centrDiff = centroid1 - centroid2;\n// Eigen::Matrix3d infComb = (covar1 + covar2).inverse();\n// Eigen::Matrix3d covarProd = covar1 * infComb * covar2;\n// Eigen::Vector3d meanProd = covar2 * infComb * centroid1 +\n// covar1 * infComb * centroid2;\n// double detVal = (2*M_PI*(covar1 + covar2)).determinant();\n// double expVal = -0.5 * centrDiff.transpose() * infComb * centrDiff;\n// double normFactor = 1.0 / sqrt(detVal) * exp(expVal);\n// cout << \"detVal = \" << detVal << endl;\n// cout << \"expVal = \" << -2.0*expVal << endl;\n// cout << \"normFactor = \" << normFactor << endl;\n// cout << \"dist = \" << 1.0/normFactor << endl;\n \n Eigen::Vector3d centrDiff = centroid1 - centroid2;\n // covariance of the second plane relative to the centroid of the first plane\n Eigen::Matrix3d relCovar = covar2 + (centrDiff * centrDiff.transpose());\n \n const Eigen::Vector3d &normal = evecs.col(2);\n double varNorm = normal.transpose() * relCovar * normal;\n// cout << \"covar2 = \" << covar2 << endl;\n// cout << \"relCovar = \" << relCovar << endl;\n// cout << \"normal = \" << normal.transpose() << endl;\n// cout << \"varNorm = \" << varNorm << endl;\n return varNorm;\n}\n\nvoid PlaneEstimator::compCentroidAndCovar(const Eigen::MatrixXd &pts,\n Eigen::Vector3d ¢roid,\n Eigen::Matrix3d &covar)\n{\n Eigen::Vector4d mean = Eigen::Vector4d::Zero();\n for(int i = 0; i < pts.cols(); ++i){\n mean += pts.col(i);\n }\n mean /= pts.cols();\n \n centroid = mean.head<3>();\n \n Eigen::MatrixXd demeanPts = pts;\n for(int i = 0; i < demeanPts.cols(); ++i){\n demeanPts.col(i) -= mean;\n }\n \n covar = demeanPts.topRows<3>() * demeanPts.topRows<3>().transpose();\n}\n\nvoid PlaneEstimator::compPlaneParams(const Eigen::Vector3d centroid,\n const Eigen::Matrix3d &covar,\n Eigen::Matrix3d &evecs,\n Eigen::Vector3d &evals,\n Eigen::Vector4d &planeEq)\n{\n Eigen::SelfAdjointEigenSolver evd(covar);\n \n for(int i = 0; i < 3; ++i){\n evecs.col(i) = evd.eigenvectors().col(2 - i);\n evals(i) = evd.eigenvalues()(2 - i);\n }\n \n planeEq.head<3>() = evecs.col(2).cast();\n // distance is the dot product of normal and point lying on the plane\n planeEq(3) = -planeEq.head<3>().dot(centroid);\n}\n\nvoid PlaneEstimator::transform(const Vector7d &transform) {\n g2o::SE3Quat transformSE3Quat(transform);\n Eigen::Matrix4d transformMat = transformSE3Quat.to_homogeneous_matrix();\n Eigen::Matrix3d R = transformMat.block<3, 3>(0, 0);\n Eigen::Vector3d t = transformMat.block<3, 1>(0, 3);\n Eigen::Matrix4d Tinvt = transformMat.inverse();\n Tinvt.transposeInPlace();\n \n // Eigen::Vector3d centroid;\n centroid = R * centroid + t;\n \n // Eigen::Matrix3d covar;\n covar = R * covar * R.transpose();\n \n // Eigen::Matrix3d evecs;\n evecs = R * evecs;\n \n // Eigen::Vector3d evals;\n // no need to transform\n \n // Eigen::Vector4d planeEq;\n planeEq = Tinvt * planeEq;\n \n // int npts;\n // no need to transform\n}\n\nvoid PlaneEstimator::updateCentroidAndCovar(const Eigen::Vector3d ¢roid1,\n const Eigen::Matrix3d &covar1,\n const int &npts1,\n const Eigen::Vector3d ¢roid2,\n const Eigen::Matrix3d &covar2,\n const int &npts2,\n Eigen::Vector3d &ocentroid,\n Eigen::Matrix3d &ocovar,\n int &onpts)\n{\n ocentroid = (npts1 * centroid1 + npts2 * centroid2)/(npts1 + npts2);\n Eigen::Vector3d centrDiff = centroid1 - centroid2;\n double fact = ((double)npts1 * npts2)/(npts1 + npts2);\n// cout << \"(npts1 * npts2)/(npts1 + npts2) = \" << fact << endl;\n// cout << \"(centrDiff * centrDiff.transpose()) = \" << (centrDiff * centrDiff.transpose()) << endl;\n ocovar = covar1 + covar2 + fact*(centrDiff * centrDiff.transpose());\n onpts = npts1 + npts2;\n}\n", "meta": {"hexsha": "3c53407b1f36b61e713f6915520aa818b0bac746", "size": 7359, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/PlaneEstimator.cpp", "max_stars_repo_name": "richard5635/PlaneLoc", "max_stars_repo_head_hexsha": "aab6637124b1b99ad726a94e9f6762dddf3716b5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 22.0, "max_stars_repo_stars_event_min_datetime": "2017-08-29T06:22:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-29T07:42:31.000Z", "max_issues_repo_path": "src/PlaneEstimator.cpp", "max_issues_repo_name": "richard5635/PlaneLoc", "max_issues_repo_head_hexsha": "aab6637124b1b99ad726a94e9f6762dddf3716b5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2019-03-26T06:10:18.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-26T01:59:41.000Z", "max_forks_repo_path": "src/PlaneEstimator.cpp", "max_forks_repo_name": "richard5635/PlaneLoc", "max_forks_repo_head_hexsha": "aab6637124b1b99ad726a94e9f6762dddf3716b5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2018-04-24T08:49:01.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-15T07:56:58.000Z", "avg_line_length": 34.5492957746, "max_line_length": 102, "alphanum_fraction": 0.533632287, "num_tokens": 1995, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8056321889812553, "lm_q2_score": 0.6723316860482763, "lm_q1q2_score": 0.541652047952531}} {"text": "// Software License for MTL\n// \n// Copyright (c) 2007 The Trustees of Indiana University.\n// 2008 Dresden University of Technology and the Trustees of Indiana University.\n// 2010 SimuNova UG (haftungsbeschränkt), www.simunova.com.\n// All rights reserved.\n// Authors: Peter Gottschling and Andrew Lumsdaine\n// \n// This file is part of the Matrix Template Library\n// \n// See also license.mtl.txt in the distribution.\n\n#ifndef MTL_REDUCTION_FUNCTORS_INCLUDE\n#define MTL_REDUCTION_FUNCTORS_INCLUDE\n\n#include \n#include \n#include \n\nnamespace mtl { namespace vector {\n\nstruct one_norm_functor\n{\n template \n static inline void init(Value& value)\n {\n\tusing math::zero;\n\tvalue= zero(value);\n }\n\n template \n static inline void update(Value& value, const Element& x)\n { \n\tusing std::abs;\n\tvalue+= abs(x);\n }\n\n template \n static inline void finish(Value& value, const Value& value2)\n {\n\tvalue+= value2;\n }\n\n template \n static inline Value post_reduction(const Value& value)\n {\n\treturn value;\n }\n};\n\n\n// sub-optimal if abs is not needed\nstruct two_norm_functor\n{\n template \n static inline void init(Value& value)\n {\n\tusing math::zero;\n\tvalue= zero(value);\n }\n\n template \n static inline void update(Value& value, const Element& x)\n { \n\tusing mtl::squared_abs;\n\tvalue+= squared_abs(x);\n }\n\n template \n static inline void finish(Value& value, const Value& value2)\n {\n\tvalue+= value2;\n }\n\n // After reduction compute square root\n template \n static inline Value post_reduction(const Value& value)\n {\n\tusing std::sqrt;\n\treturn sqrt(value);\n }\n};\n\n// same as two-norm without the root at the end\nstruct unary_dot_functor\n : two_norm_functor\n{\n template \n static inline Value post_reduction(const Value& value)\n {\n\treturn value;\n }\n};\n\nstruct infinity_norm_functor\n{\n template \n static inline void init(Value& value)\n {\n\tusing math::zero;\n\tvalue= zero(value);\n }\n\n template \n static inline void update(Value& value, const Element& x)\n { \n\tusing std::abs; using std::max;\n\tvalue= max(value, Value(abs(x)));\n }\n\n template \n static inline void finish(Value& value, const Value& value2)\n {\n\tusing std::abs; using std::max;\n\tvalue= max(value, Value(abs(value2)));\n }\n\n template \n static inline Value post_reduction(const Value& value)\n {\n\treturn value;\n }\n};\n\n\nstruct sum_functor\n{\n template \n static inline void init(Value& value)\n {\n\tusing math::zero;\n\tvalue= zero(value);\n }\n\n template \n static inline void update(Value& value, const Element& x)\n { \n\tvalue+= x;\n }\n\n template \n static inline void finish(Value& value, const Value& value2)\n {\n\tvalue+= value2;\n }\n\n template \n static inline Value post_reduction(const Value& value)\n {\n\treturn value;\n }\n};\n\n\nstruct product_functor\n{\n template \n static inline void init(Value& value)\n {\n\tusing math::one;\n\tvalue= one(value);\n }\n\n template \n static inline void update(Value& value, const Element& x)\n { \n\tvalue*= x;\n }\n\n template \n static inline void finish(Value& value, const Value& value2)\n {\n\tvalue*= value2;\n }\n\n template \n static inline Value post_reduction(const Value& value)\n {\n\treturn value;\n }\n};\n\n\nstruct max_functor\n{\n template \n static inline void init(Value& value)\n {\n\tusing math::identity; \n\tvalue= math::identity(math::max(), value); // ADL doesn't work here in g++ 4.4\n }\n\n template \n static inline void update(Value& value, const Element& x)\n { \n\tvalue= math::max()(value, x);\n }\n\n template \n static inline void finish(Value& value, const Value& value2)\n {\n\tvalue= math::max()(value, value2);\n }\n\n template \n static inline Value post_reduction(const Value& value)\n {\n\treturn value;\n }\n};\n\n\nstruct min_functor\n{\n template \n static inline void init(Value& value)\n {\n\tusing math::identity; \n\tvalue= math::identity(math::min(), value); // ADL doesn't work here in g++ 4.4\n }\n\n template \n static inline void update(Value& value, const Element& x)\n { \n\tvalue= math::min()(value, x);\n }\n\n template \n static inline void finish(Value& value, const Value& value2)\n {\n\tvalue= math::min()(value, value2);\n }\n\n template \n static inline Value post_reduction(const Value& value)\n {\n\treturn value;\n }\n};\n\n\n}} // namespace mtl::vector\n\n#endif // MTL_REDUCTION_FUNCTORS_INCLUDE\n", "meta": {"hexsha": "c4f3d09502d2fedd820a6e260edaf7893ceb2b6c", "size": 5230, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "lib/mtl4/boost/numeric/mtl/vector/reduction_functors.hpp", "max_stars_repo_name": "spraetor/amdis2", "max_stars_repo_head_hexsha": "53c45c81a65752a8fafbb54f9ae6724a86639dcd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2018-07-04T16:44:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-03T07:26:27.000Z", "max_issues_repo_path": "lib/mtl4/boost/numeric/mtl/vector/reduction_functors.hpp", "max_issues_repo_name": "spraetor/amdis2", "max_issues_repo_head_hexsha": "53c45c81a65752a8fafbb54f9ae6724a86639dcd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/mtl4/boost/numeric/mtl/vector/reduction_functors.hpp", "max_forks_repo_name": "spraetor/amdis2", "max_forks_repo_head_hexsha": "53c45c81a65752a8fafbb54f9ae6724a86639dcd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.3469387755, "max_line_length": 94, "alphanum_fraction": 0.6638623327, "num_tokens": 1243, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833841649232, "lm_q2_score": 0.6992544335934766, "lm_q1q2_score": 0.5416308655651617}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace arma;\nusing namespace std;\nusing json = nlohmann::json;\n\nnamespace hsmm {\n\n // TODO: Make sure there is not any bias here.\n int sampleFromCategorical(rowvec pmf) {\n rowvec prefixsum(pmf);\n for(int i = 1; i < pmf.n_elem; i++)\n prefixsum(i) += prefixsum(i - 1);\n assert(abs(prefixsum(pmf.n_elem - 1) - 1.0) < 1e-7);\n return lower_bound(prefixsum.begin(), prefixsum.end(), randu()) -\n prefixsum.begin();\n }\n\n /**\n * HSMM implementation.\n */\n HSMM::HSMM(shared_ptr emission, mat transition,\n vec pi, mat duration, int min_duration) : emission_(emission),\n duration_learning_choice_(\"histogram\"), debug_(false),\n learning_transitions_(true), learning_pi_(true) {\n nstates_ = emission_->getNumberStates();\n ndurations_ = duration.n_cols;\n min_duration_ = min_duration;\n assert(min_duration_ >= 1);\n assert(nstates_ >= 1);\n assert(ndurations_ >= 1);\n setDuration(duration);\n setPi(pi);\n setTransition(transition);\n mat default_dirichlet_parameters = ones(nstates_, ndurations_);\n setDurationDirichletPrior(default_dirichlet_parameters);\n }\n\n HSMM::HSMM(shared_ptr emission, int nstates, int ndurations,\n int min_duration) : HSMM(emission,\n ones(nstates, nstates) * (1.0/nstates),\n ones(nstates) * (1.0/nstates),\n ones(nstates, ndurations) * (1.0/ndurations), min_duration)\n {}\n\n void HSMM::setDuration(mat duration) {\n assert(duration.n_rows == nstates_);\n assert(duration.n_cols == ndurations_);\n duration_ = duration;\n }\n\n void HSMM::setEmission(shared_ptr emission) {\n assert(emission->getNumberStates() == nstates_);\n emission_ = emission;\n }\n\n void HSMM::setPi(vec pi) {\n assert(pi.n_elem == nstates_);\n pi_ = pi;\n }\n\n void HSMM::setTransition(mat transition) {\n assert(transition.n_rows == transition.n_cols);\n assert(transition.n_rows == nstates_);\n transition_ = transition;\n }\n\n void HSMM::setPiFromLabels(field seqs) {\n vec new_pi(nstates_, fill::zeros);\n for(auto& s: seqs)\n new_pi(s(0))++;\n new_pi = new_pi / accu(new_pi);\n setPi(new_pi);\n }\n\n void HSMM::setTransitionFromLabels(field seqs) {\n mat new_transition(nstates_, nstates_, fill::zeros);\n for(auto& s: seqs) {\n const ivec& hs = computeViterbiStateDurationSequenceFromLabels(\n s).first;\n for(int i = 0; i < hs.n_elem - 1; i++)\n new_transition(hs(i), hs(i + 1))++;\n }\n for(int i = 0; i < nstates_; i++) {\n auto row = new_transition.row(i);\n new_transition.row(i) = row / accu(row);\n }\n setTransition(new_transition);\n }\n\n void HSMM::setDurationFromLabels(field seqs) {\n mat new_duration(nstates_, ndurations_, fill::zeros);\n for(auto& s: seqs) {\n pair p = computeViterbiStateDurationSequenceFromLabels(\n s);\n const ivec& hs = p.first;\n const ivec& dur = p.second;\n for(int i = 0; i < dur.n_elem; i++) {\n if (hs(i) 1.0 - 1e-7);\n dirichlet_alphas_ = alphas;\n }\n\n void HSMM::setDurationLearningChoice(string choice) {\n duration_learning_choice_ = choice;\n }\n\n field HSMM::sampleSegments(int nsegments, ivec& hiddenStates,\n ivec& hiddenDurations) {\n assert(nsegments >= 1);\n\n // Generating states sequence.\n ivec states(nsegments);\n states(0) = sampleFromCategorical(pi_.t());\n for(int i = 1; i < nsegments; i++) {\n rowvec nstateDist = transition_.row(states(i - 1));\n states(i) = sampleFromCategorical(nstateDist);\n }\n\n // Generating durations from states.\n int sampleSequenceLength = 0;\n ivec durations(nsegments);\n for(int i = 0; i < nsegments; i++) {\n int currentDuration = sampleFromCategorical(\n duration_.row(states(i))) + min_duration_;\n durations(i) = currentDuration;\n sampleSequenceLength += currentDuration;\n }\n\n // Generating samples\n field samples(sampleSequenceLength);\n int idx = 0;\n for(int i = 0; i < nsegments; i++) {\n field currSample = emission_->sampleFromState(\n states(i), durations(i));\n samples.rows(idx, idx + durations(i) - 1) = currSample;\n idx += durations(i);\n }\n hiddenStates = states;\n hiddenDurations = durations;\n return samples;\n }\n\n field> HSMM::sampleMultipleSequences(int nsequences,\n int nsegments, field& seqsHiddenStates,\n field& seqsHiddenDurations) {\n field> mobs(nsequences);\n field seqsHS(nsequences);\n field seqsDur(nsequences);\n for(int s = 0; s < nsequences; s++) {\n ivec hs, dur;\n mobs(s) = sampleSegments(nsegments, hs, dur);\n seqsHS(s) = hs;\n seqsDur(s) = dur;\n }\n seqsHiddenStates = seqsHS;\n seqsHiddenDurations = seqsDur;\n return mobs;\n }\n\n void HSMM::init_params_from_data(const field> &mobs) {\n emission_->init_params_from_data(min_duration_, ndurations_, mobs);\n }\n\n bool HSMM::fit(field> mobs, field mobserved_segments,\n int max_iter, double tol) {\n\n // Array initializations.\n int nseq = mobs.n_elem;\n assert(nseq >= 1 && nseq == mobserved_segments.n_elem);\n field malpha(nseq);\n field mbeta(nseq);\n field malpha_s(nseq);\n field mbeta_s(nseq);\n field mbeta_s_0(nseq);\n field meta(nseq);\n field mzeta(nseq);\n for(int i = 0; i < nseq; i++) {\n int nobs = mobs(i).n_elem;\n assert(nobs >= min_duration_);\n malpha(i) = zeros(nstates_, nobs);\n mbeta(i) = zeros(nstates_, nobs);\n malpha_s(i) = zeros(nstates_, nobs);\n mbeta_s(i) = zeros(nstates_, nobs);\n mbeta_s_0(i) = zeros(nstates_);\n meta(i) = zeros(nstates_, ndurations_, nobs);\n mzeta(i) = zeros(nstates_, nstates_, nobs - 1);\n }\n\n mat log_estimated_transition = log(transition_);\n vec log_estimated_pi = log(pi_);\n mat log_estimated_duration = log(duration_);\n double marginal_llikelihood = -datum::inf;\n bool convergence_reached = false;\n for(int i = 0; i < max_iter && !convergence_reached; i++) {\n for(int s = 0; s < nseq; s++) {\n const field& obs = mobs(s);\n const Labels& observed_segments = mobserved_segments(s);\n\n // Assertions if labels are provided.\n if (!observed_segments.empty()) {\n for(const auto &segment : observed_segments.getLabels())\n assert(segment.getDuration() >= min_duration_ &&\n segment.getDuration() < min_duration_ +\n ndurations_);\n int start_time = observed_segments.getFirstSegment(\n ).getStartingTime();\n int end_time = observed_segments.getLastSegment(\n ).getEndingTime();\n if (start_time > 0)\n assert(start_time >= min_duration_);\n if (end_time < obs.n_elem - 1)\n assert(obs.n_elem - end_time > min_duration_);\n }\n\n mat& alpha = malpha(s);\n mat& beta = mbeta(s);\n mat& alpha_s = malpha_s(s);\n mat& beta_s = mbeta_s(s);\n vec& beta_s_0 = mbeta_s_0(s);\n cube& eta = meta(s);\n cube& zeta = mzeta(s);\n\n // Recomputing the emission likelihoods.\n cube logpdf = computeEmissionsLogLikelihood(obs);\n\n logsFB(log_estimated_transition, log_estimated_pi,\n log_estimated_duration, logpdf, observed_segments,\n alpha, beta, alpha_s, beta_s, beta_s_0, eta, zeta,\n min_duration_, obs.n_elem);\n }\n vec sequences_llikelihood(nseq);\n for(int s = 0; s < nseq; s++) {\n int nobs = mobs(s).n_elem;\n\n // Computing the marginal likelihood (aka observation\n // likelihood).\n sequences_llikelihood(s) = logsumexp(malpha(s).col(nobs - 1));\n }\n double current_llikelihood = sum(sequences_llikelihood);\n cout << \"EM iteration \" << i << \" marginal log-likelihood: \" <<\n current_llikelihood << \". Diff: \" <<\n current_llikelihood - marginal_llikelihood << endl;\n if (current_llikelihood < marginal_llikelihood)\n cout << \"Warning: The log-likelihood decreased probably due\" <<\n \" to numerical errors.\" << endl;\n if (current_llikelihood - marginal_llikelihood < tol) {\n convergence_reached = true;\n marginal_llikelihood = current_llikelihood;\n break;\n }\n marginal_llikelihood = current_llikelihood;\n\n // M step.\n // Lower bound before M step.\n double lb_pi, lb_transition, lb_duration;\n if (debug_) {\n lb_pi = lower_bound_term_pi(meta, log_estimated_pi);\n lb_transition = lower_bound_term_transition(mzeta,\n log_estimated_transition);\n lb_duration = lower_bound_term_duration(meta,\n log_estimated_duration);\n }\n\n mat tmp_transition(log_estimated_transition);\n for(int i = 0; i < nstates_; i++) {\n vector den;\n for(int j = 0; j < nstates_; j++) {\n vector num;\n for(int s = 0; s < nseq; s++) {\n const cube& zeta = mzeta(s);\n for(int t = 0; t < mobs(s).n_elem - 1; t++) {\n num.push_back(zeta(i, j, t));\n den.push_back(zeta(i, j, t));\n }\n }\n vec num_v(num);\n if (num_v.n_elem > 0)\n tmp_transition(i, j) = logsumexp(num_v);\n }\n vec den_v(den);\n if (den_v.n_elem > 0) {\n double denominator = logsumexp(den_v);\n\n // Handling the case when the transition probability is 0.\n if (denominator != -datum::inf) {\n for(int j = 0; j < nstates_; j++)\n tmp_transition(i, j) -= denominator;\n }\n }\n }\n if (learning_transitions_)\n log_estimated_transition = tmp_transition;\n\n // Reestimating the initial state pmf.\n vec tmp_pi(size(pi_), fill::zeros);\n for(const cube& eta : meta) {\n vec current_log_estimated_pi(nstates_);\n for(int i = 0; i < nstates_; i++) {\n vector terms;\n for(int d = 0; d < ndurations_; d++)\n terms.push_back(eta(i, d, min_duration_ + d - 1));\n vec vterms(terms);\n current_log_estimated_pi(i) = logsumexp(vterms);\n }\n vec current_pi = exp(current_log_estimated_pi);\n assert(abs(sum(current_pi) - 1) < 1e-7);\n tmp_pi += current_pi;\n }\n if (learning_pi_)\n log_estimated_pi = log(tmp_pi / nseq);\n\n // Reestimating durations.\n // D(j, d) represents the expected number of times that state\n // j is visited with duration d (non-normalized).\n mat D(size(duration_), fill::zeros);\n for(int i = 0; i < nstates_; i++) {\n vector den;\n for(int d = 0; d < ndurations_; d++) {\n vector ts;\n for(int s = 0; s < nseq; s++) {\n int nobs = mobs(s).n_rows;\n const cube& eta = meta(s);\n for(int t = 0; t < nobs; t++) {\n ts.push_back(eta(i, d, t));\n den.push_back(eta(i, d, t));\n }\n }\n\n // Taking into account the Dirichlet prior.\n double log_alpha_minus_one = log(dirichlet_alphas_(\n i, d) - 1);\n ts.push_back(log_alpha_minus_one);\n den.push_back(log_alpha_minus_one);\n\n vec ts_v(ts);\n D(i, d) = logsumexp(ts_v);\n }\n vec den_v(den);\n double denominator = logsumexp(den_v);\n\n // Handling the case when the transition probability mass is 0.\n if (denominator != -datum::inf) {\n for(int d = 0; d < ndurations_; d++)\n D(i, d) -= denominator;\n }\n }\n if (!duration_learning_choice_.compare(\"histogram\"))\n log_estimated_duration = D;\n else if (!duration_learning_choice_.compare(\"momentmatching\"))\n log_estimated_duration = gaussianMomentMatching(D);\n else if (duration_learning_choice_.compare(\"nodur\")) {\n cout << \"Duration learning not supported or invalid.\" << endl;\n assert(false);\n }\n\n // Lower bound after M step.\n if (debug_) {\n double lb_pi_after = lower_bound_term_pi(meta, log_estimated_pi);\n double lb_transition_after = lower_bound_term_transition(mzeta,\n log_estimated_transition);\n double lb_duration_after = lower_bound_term_duration(meta,\n log_estimated_duration);\n cout << \"Diff lower bound before and after M step\" << endl;\n cout << \"pi: \" << lb_pi_after - lb_pi << endl;\n cout << \"transition: \" << lb_transition_after - lb_transition << endl;\n cout << \"duration: \" << lb_duration_after - lb_duration << endl;\n assert(lb_pi_after - lb_pi > -tol);\n assert(lb_transition_after - lb_transition > -tol);\n assert(lb_duration_after - lb_duration > -tol);\n }\n\n // Reestimating emissions.\n // NOTE: the rest of the HSMM parameters are updated out of\n // this loop.\n emission_->reestimate(min_duration_, meta, mobs);\n }\n\n cout << \"Stopped because of \" << ((convergence_reached) ?\n \"convergence.\" : \"max iter.\") << endl;\n\n // Updating the model parameters.\n setTransition(exp(log_estimated_transition));\n setPi(exp(log_estimated_pi));\n setDuration(exp(log_estimated_duration));\n return convergence_reached;\n }\n\n bool HSMM::fit(field> mobs, int max_iter, double tol) {\n field mobserved_segments(mobs.n_elem); // empty.\n return fit(mobs, mobserved_segments, max_iter, tol);\n }\n\n double HSMM::loglikelihood(const field>& mobs) {\n field no_labels(mobs.n_elem); // empty.\n return loglikelihood(mobs, no_labels);\n }\n\n // TODO: make this a const function.\n double HSMM::loglikelihood(const field>& mobs,\n const field& labels) {\n int nseq = mobs.n_elem;\n assert(nseq >= 1);\n double ll = 0.0;\n for(int i = 0; i < nseq; i++) {\n const field& obs = mobs(i);\n int nobs = obs.n_elem;\n mat alpha = zeros(nstates_, nobs);\n mat beta = zeros(nstates_, nobs);\n mat alpha_s = zeros(nstates_, nobs);\n mat beta_s = zeros(nstates_, nobs);\n vec beta_s_0 = zeros(nstates_);\n cube eta = zeros(nstates_, ndurations_, nobs);\n cube zeta = zeros(nstates_, nstates_, nobs - 1);\n cube logpdf = computeEmissionsLogLikelihood(obs);\n mat ltransition = log(transition_);\n vec lpi = log(pi_);\n mat ldur = log(duration_);\n logsFB(ltransition, lpi, ldur, logpdf, labels(i), alpha, beta,\n alpha_s, beta_s, beta_s_0, eta, zeta, min_duration_, nobs);\n ll += logsumexp(alpha.col(nobs - 1));\n }\n return ll;\n }\n\n // Computes the likelihoods w.r.t. the emission model.\n cube HSMM::computeEmissionsLikelihood(const field& obs) {\n return emission_->likelihoodCube(min_duration_, ndurations_, obs);\n }\n\n // Computes the loglikelihoods w.r.t. the emission model.\n cube HSMM::computeEmissionsLogLikelihood(const field& obs) {\n return emission_->loglikelihoodCube(min_duration_, ndurations_,\n obs);\n }\n\n // Returns a json representation of the model.\n nlohmann::json HSMM::to_stream() const {\n nlohmann::json ret;\n ret[\"nstates\"] = nstates_;\n ret[\"min_duration\"] = min_duration_;\n ret[\"ndurations\"] = ndurations_;\n ret[\"initial_pmf\"] = pi_;\n ret[\"emission_params\"] = emission_->to_stream();\n\n // Taking care of the serialization of armadillo matrices.\n vector> transition_v, duration_v;\n for(int i = 0; i < nstates_; i++) {\n transition_v.push_back(conv_to>::from(\n transition_.row(i)));\n duration_v.push_back(conv_to>::from(\n duration_.row(i)));\n }\n ret[\"transition\"] = transition_v;\n ret[\"duration\"] = duration_v;\n return ret;\n }\n\n // Reads the parameters from a json file.\n void HSMM::from_stream(const nlohmann::json ¶ms) {\n nstates_ = params.at(\"nstates\");\n min_duration_ = params.at(\"min_duration\");\n ndurations_ = params.at(\"ndurations\");\n const nlohmann::json& emission_params = params.at(\"emission_params\");\n emission_->from_stream(emission_params);\n\n // Parsing the armadillo matrices (transition, pi, duration).\n vector initial_pmf_v = params.at(\"initial_pmf\");\n vector> transition_v = params.at(\"transition\");\n vector> duration_v = params.at(\"duration\");\n vec pi = conv_to::from(initial_pmf_v);\n mat transition = zeros(nstates_, nstates_);\n mat duration = zeros(nstates_, ndurations_);\n for(int i = 0; i < nstates_; i++) {\n transition.row(i) = conv_to::from(transition_v.at(i));\n duration.row(i) = conv_to::from(duration_v.at(i));\n }\n setPi(pi);\n setTransition(transition);\n setDuration(duration);\n }\n\n pair HSMM::computeViterbiStateDurationSequenceFromLabels(\n ivec seq) {\n assert(seq.n_elem > 0);\n int last_state = seq(0);\n int current_dur = 1;\n vector hs, dur;\n for(int i = 1; i < seq.n_elem; i++) {\n if (seq(i) == last_state)\n current_dur++;\n else {\n hs.push_back(last_state);\n dur.push_back(current_dur);\n last_state = seq(i);\n current_dur = 1;\n }\n }\n hs.push_back(last_state);\n dur.push_back(current_dur);\n ivec hs_v = conv_to::from(hs);\n ivec dur_v = conv_to::from(dur);\n return make_pair(hs_v, dur_v);\n }\n\n mat HSMM::gaussianMomentMatching(mat duration) const {\n duration = exp(duration);\n mat ret = zeros(size(duration));\n for(int i = 0; i < duration.n_rows; i++) {\n double mean = 0;\n for(int j = 0; j < duration.n_cols; j++)\n mean += j * duration(i, j);\n double var = 0;\n for(int j = 0; j < duration.n_cols; j++)\n var += (j - mean) * (j - mean) * duration(i, j);\n for(int j = 0; j < duration.n_cols; j++) {\n double tmp = (j - mean);\n tmp = (tmp * tmp) / var;\n tmp = -0.5 * tmp;\n tmp = exp(tmp);\n ret(i, j) = tmp;\n }\n\n // Renormalizing.\n ret.row(i) = ret.row(i) / sum(ret.row(i));\n }\n return log(ret);\n }\n\n // Debugging functions.\n double HSMM::lower_bound_term_transition(const field& zetas,\n const mat& log_transition) const {\n double ret = 0;\n for(const cube& zeta : zetas)\n for(int i = 0; i < nstates_; i++)\n for(int j = 0; j < nstates_; j++)\n for(int t = 0; t < zeta.n_slices; t++)\n if (log_transition(i, j) > -datum::inf)\n ret += exp(zeta(i, j, t)) * log_transition(i, j);\n return ret;\n }\n\n double HSMM::lower_bound_term_pi(const field& etas,\n const vec& log_pi) const {\n double ret = 0;\n for(const cube& eta : etas)\n for(int i = 0; i < nstates_; i++)\n for(int d = 0; d < ndurations_; d++)\n if (log_pi(i) > -datum::inf)\n ret += exp(eta(i, d, min_duration_ + d - 1)) *\n log_pi(i);\n return ret;\n }\n\n double HSMM::lower_bound_term_duration(const field& etas,\n const mat& log_duration) const {\n double ret = 0;\n for(const cube& eta : etas)\n for(int i = 0; i < nstates_; i++)\n for(int d = 0; d < ndurations_; d++)\n for(int t = 0; t < eta.n_slices; t++)\n if (log_duration(i, d) > -datum::inf)\n ret += exp(eta(i, d, t)) * log_duration(i, d);\n return ret;\n }\n\n\n /*\n * Online HSMM implementation\n */\n OnlineHSMM::OnlineHSMM(shared_ptr emission,\n mat transition, vec pi, mat duration, int min_duration) : HSMM(\n static_pointer_cast(emission), transition,\n pi, duration, min_duration),\n last_log_posterior_(ndurations_, min_duration_ + ndurations_,\n nstates_) {}\n\n shared_ptr OnlineHSMM::getOnlineEmission(\n ) const {\n return static_pointer_cast(emission_);\n }\n\n void OnlineHSMM::addNewObservation(const mat& obs) {\n if (observations_.empty())\n alpha_posteriors_.push_back(log(pi_));\n observations_.push_back(obs);\n mat log_duration = log(duration_);\n mat log_transition = log(transition_);\n last_log_posterior_.fill(-datum::inf);\n vector normalization_terms;\n for(int d = min_duration_; d < min_duration_ + ndurations_; d++) {\n for(int s = 0; s < d; s++) {\n\n // Making sure the offset is consistent with the number of\n // observations so far.\n if (s >= observations_.size())\n break;\n\n // Building the current segment. Notice that it is padded with\n // empty matrices.\n field current_segment(d);\n for(int idx = s, obs_idx = observations_.size()-1; idx >= 0;\n idx--, obs_idx--) {\n current_segment(idx) = observations_[obs_idx];\n }\n const vec& relevant_alpha_posterior = alpha_posteriors_.at(\n alpha_posteriors_.size() - 1 - s);\n for(int i = 0; i < nstates_; i++) {\n double log_pdf_seg = emission_->loglikelihood(i,\n current_segment) + log_duration(i,d-min_duration_);\n double log_unnormalized_value = log_pdf_seg +\n relevant_alpha_posterior(i);\n last_log_posterior_(d - min_duration_, s, i) =\n log_unnormalized_value;\n normalization_terms.push_back(log_unnormalized_value);\n }\n }\n }\n\n // Normalizing the current joint posterior.\n last_normalization_c_ = logsumexp(normalization_terms);\n assert(last_normalization_c_ > -datum::inf);\n last_log_posterior_ -= last_normalization_c_;\n\n // Computing the marginal posterior over the next hidden state assuming\n // there is a change point right after the current input observation.\n vec current_marginal_posterior(nstates_);\n for(int i = 0; i < nstates_; i++) {\n vector terms;\n for(int j = 0; j < nstates_; j++) {\n for(int dur = 0; dur < ndurations_; dur++) {\n double term = last_log_posterior_(dur,\n min_duration_ + dur - 1, j) + log_transition(j, i);\n terms.push_back(term);\n }\n }\n current_marginal_posterior(i) = logsumexp(terms);\n }\n\n // Pushing back the computed posterior. NOTE: it isn't a pmf.\n alpha_posteriors_.push_back(current_marginal_posterior);\n }\n\n void OnlineHSMM::sampleFromPosterior(int & dur, int & offset,\n int & hs) const {\n dur = offset = hs = -1;\n cube current_posterior = exp(last_log_posterior_);\n int nrows = current_posterior.n_rows;\n int ncols = current_posterior.n_cols;\n int nslices = current_posterior.n_slices;\n double accum = 0.0;\n double usample = randu();\n int found = 0;\n mat sample;\n for(int i = 0; i < nslices; i++) {\n for(int d = 0; d < nrows; d++) {\n for(int s = 0; s < ncols; s++) {\n double naccum = accum + current_posterior(d, s, i);\n if (accum < usample && usample < naccum) {\n found++;\n dur = d;\n offset = s;\n hs = i;\n }\n accum = naccum;\n }\n }\n }\n assert(found == 1);\n assert(abs(accum - 1.0) < 1e-7);\n return;\n }\n\n field OnlineHSMM::sampleNextObservations(int nobs) const {\n assert(!observations_.empty()); // TODO: handle empty observations.\n\n // Sampling a triplet (d,s,i) from the current posterior.\n int d, s, i;\n sampleFromPosterior(d, s, i);\n if (debug_) {\n cout << \"Posterior sample (\" << d << \", \" << s << \", \" <<\n i << \")\" << endl;\n }\n field last_obs(s + 1);\n int tam = observations_.size();\n for(int j = s, idx = tam - 1; j >= 0; j--, idx--)\n last_obs(j) = observations_.at(idx);\n field ret(nobs);\n int idx = 0;\n field seg;\n int curr_state;\n if (s == min_duration_ + d - 1) {\n\n // Handling the case when there is a transition\n // right after the current observation. Sampling\n // next state and duration.\n int next_state = sampleFromCategorical(\n transition_.row(i));\n int next_duration = sampleFromCategorical(\n duration_.row(next_state)) + min_duration_;\n seg = getOnlineEmission()->sampleFirstSegmentObsGivenLastSegment(\n next_state, next_duration, last_obs, i);\n curr_state = next_state;\n for(int j = 0; j < seg.n_elem && idx < ret.n_elem; j++)\n ret(idx++) = seg(j);\n }\n else {\n seg = getOnlineEmission()->sampleNextObsGivenPastObs(i,\n min_duration_ + d, last_obs);\n curr_state = i;\n field suffix = seg.rows(last_obs.n_elem, seg.n_elem - 1);\n idx = appendToField(ret, idx, suffix);\n }\n\n while(idx < ret.n_elem) {\n int next_state = sampleFromCategorical(transition_.row(\n curr_state));\n int next_duration = sampleFromCategorical(duration_.row(\n next_state)) + min_duration_;\n if (debug_) {\n cout << \"Next state and dur: \" << next_state << \" \" <<\n next_duration << endl;\n }\n seg = getOnlineEmission()->sampleFirstSegmentObsGivenLastSegment(\n next_state, next_duration, seg, curr_state);\n curr_state = next_state;\n idx = appendToField(ret, idx, seg);\n }\n assert(idx == nobs);\n return ret;\n }\n\n void OnlineHSMM::printTopKFromPosterior(int k) const {\n cube current_posterior = exp(last_log_posterior_);\n set> pq;\n for(int d = 0; d < ndurations_; d++)\n for(int s = 0; s < min_duration_ + d; s++)\n for(int i = 0; i < nstates_; i++) {\n double p = current_posterior(d, s, i);\n string str = \"(\" + to_string(d) + \", \" + to_string(s) +\n \", \" + to_string(i) + \")\";\n pq.insert(make_pair(p, str));\n if (pq.size() > k)\n pq.erase(pq.begin());\n }\n for(auto p: pq)\n cout << p.first << \" \" << p.second << endl;\n }\n\n vec OnlineHSMM::getStateMarginal() const {\n cube current_posterior = exp(last_log_posterior_);\n mat tmp = sum(current_posterior, 0);\n vec ret = vectorise(sum(tmp, 0));\n assert(abs(sum(ret) - 1.0) < 1e-7);\n assert(ret.n_elem == nstates_);\n return ret;\n }\n\n // TODO: the output len shoud be actually min_duration_ + ndurations_ - 1.\n vec OnlineHSMM::getRunlengthMarginal() const {\n cube current_posterior = exp(last_log_posterior_);\n mat tmp = sum(current_posterior, 0);\n vec ret = vectorise(sum(tmp, 1));\n assert(abs(sum(ret) - 1.0) < 1e-7);\n assert(ret.n_elem == min_duration_ + ndurations_);\n return ret;\n }\n\n vec OnlineHSMM::getDurationMarginal() const {\n cube current_posterior = exp(last_log_posterior_);\n mat tmp = sum(current_posterior, 2);\n vec ret = vectorise(sum(tmp, 1));\n assert(abs(sum(ret) - 1.0) < 1e-7);\n assert(ret.n_elem == ndurations_);\n return ret;\n }\n\n vec OnlineHSMM::getResidualTimeMarginal() const {\n cube current_posterior = exp(last_log_posterior_);\n mat tmp = sum(current_posterior, 2);\n vec ret(min_duration_ + ndurations_, fill::zeros);\n for(int d = 0; d < ndurations_; d++) {\n for(int r = 0; r < min_duration_ + ndurations_; r++) {\n if (r < min_duration_ + d) {\n int residual_time = min_duration_ + d - r - 1;\n ret(residual_time) += tmp(d, r);\n }\n }\n }\n assert(abs(sum(ret) - 1.0) < 1e-7);\n return ret;\n }\n\n vec OnlineHSMM::getImplicitDurationMarginal() const {\n cube current_posterior = exp(last_log_posterior_);\n mat runlength_state_posterior = sum(current_posterior, 0);\n\n vec ret(ndurations_, fill::zeros);\n mat dur_suffix_sum = getDurationSuffixSum();\n for(int i = 0; i < nstates_; i++) {\n for(int r = 0; r < min_duration_ + ndurations_; r++) {\n for(int d = 0; d < ndurations_; d++) {\n if (r < min_duration_ + d) {\n double value = runlength_state_posterior(r, i) *\n duration_(i, d) /\n dur_suffix_sum(i, max(0,r - min_duration_+ 1));\n ret(d) += value;\n }\n }\n }\n }\n assert(abs(sum(ret) - 1.0) < 1e-7);\n return ret;\n }\n\n vec OnlineHSMM::getImplicitResidualTimeMarginal() const {\n cube current_posterior = exp(last_log_posterior_);\n mat duration_runlength_posterior = sum(current_posterior, 2);\n vec ret(min_duration_ + ndurations_, fill::zeros);\n for(int r = 0; r < min_duration_ + ndurations_; r++) {\n for(int d = 0; d < ndurations_; d++) {\n int current_dur = min_duration_ + d;\n if (r < current_dur)\n ret(current_dur-r-1) += duration_runlength_posterior(d,r);\n }\n }\n assert(abs(sum(ret) - 1.0) < 1e-7);\n return ret;\n }\n\n double OnlineHSMM::getLastOneStepAheadLoglikelihood() const {\n assert(observations_.size() > 0);\n return last_normalization_c_;\n }\n\n // TODO: This could be cached.\n mat OnlineHSMM::getDurationSuffixSum() const {\n mat suffix_sum(duration_);\n for(int i = suffix_sum.n_cols - 2; i >= 0; i--)\n suffix_sum.col(i) += suffix_sum.col(i + 1);\n return suffix_sum;\n }\n\n int OnlineHSMM::appendToField(field ¤t_obs, int idx,\n const field new_obs) const {\n for(int j = 0; j < new_obs.n_elem && idx < current_obs.n_elem; j++)\n current_obs(idx++) = new_obs(j);\n return idx;\n }\n\n\n /*\n * Online OnlineHSMMRunlengthBased implementation. The emission doesn't\n * take into account the total segment duration.\n */\n OnlineHSMMRunlengthBased::OnlineHSMMRunlengthBased(\n shared_ptr emission,\n mat transition, vec pi, mat duration, int min_duration) : HSMM(\n static_pointer_cast(emission), transition,\n pi, duration, min_duration),\n last_posterior_(min_duration + duration.n_cols - 1, pi.n_elem),\n last_residualtime_posterior_(min_duration + duration.n_cols - 1,\n pi.n_elem) {\n init();\n }\n\n OnlineHSMMRunlengthBased::OnlineHSMMRunlengthBased(\n shared_ptr emission,\n int nstates, int ndurations, int min_duration) : HSMM(\n static_pointer_cast(emission), nstates,\n ndurations, min_duration),\n last_posterior_(min_duration + ndurations - 1, nstates),\n last_residualtime_posterior_(min_duration + ndurations - 1,\n nstates) {\n init();\n }\n\n void OnlineHSMMRunlengthBased::init() {\n last_posterior_.zeros();\n last_residualtime_posterior_.zeros();\n observations_.clear();\n }\n\n shared_ptr\n OnlineHSMMRunlengthBased::getOnlineDurationAgnosticEmission(\n ) const {\n return static_pointer_cast(\n emission_);\n }\n\n void OnlineHSMMRunlengthBased::addNewObservation(const mat& obs) {\n observations_.push_back(obs);\n mat new_posterior(size(last_posterior_), fill::zeros);\n mat new_residualtime_posterior(size(last_residualtime_posterior_),\n fill::zeros);\n int max_duration = min_duration_ + ndurations_ - 1;\n mat hazard = getHazardFunction_();\n if (observations_.size() == 1) {\n\n // Base case.\n for(int i = 0; i < nstates_; i++)\n new_posterior(0, i) = pi_(i) * exp(loglikelihood_(i, obs));\n\n // Residential time base case.\n for(int i = 0; i < nstates_; i++) {\n double tmp = pi_(i) * exp(loglikelihood_(i, obs));\n for(int d = 0; d < ndurations_; d++)\n new_residualtime_posterior(min_duration_ + d - 1, i) =\n tmp * duration_(i, d);\n }\n }\n else {\n\n // Runlength posterior updates.\n for(int r = 0; r < max_duration; r++) {\n\n // Segment transition.\n for(int i = 0; i < nstates_; i++) {\n if (!is_finite(hazard(i, r)))\n continue;\n for(int j = 0; j < nstates_; j++) {\n new_posterior(0, j) += hazard(i, r)*transition_(i, j) *\n exp(loglikelihood_(j, obs)) * last_posterior_(r, i);\n }\n }\n\n // Segment continuation.\n if (r + 1 < max_duration) {\n for(int i = 0; i < nstates_; i++)\n if (is_finite(hazard(i, r))) {\n new_posterior(r + 1, i) = last_posterior_(r, i) *\n (1 - hazard(i, r)) *\n exp(loglikelihood_(i, obs));\n }\n }\n }\n\n // Residualtime posterior updates.\n // Segment continuation.\n for(int r = 1; r < max_duration; r++)\n for(int i = 0; i < nstates_; i++)\n new_residualtime_posterior(r - 1, i) = exp(loglikelihood_(\n i, obs)) * last_residualtime_posterior_(r, i);\n\n // Segment transition\n vec prob_of_transition_to(nstates_, fill::zeros);\n for(int i = 0; i < nstates_; i++)\n for(int j = 0; j < nstates_; j++)\n prob_of_transition_to(i) += transition_(j, i) *\n last_residualtime_posterior_(0, j);\n\n for(int i = 0; i < nstates_; i++)\n for(int d = 0; d < ndurations_; d++)\n new_residualtime_posterior(min_duration_ + d - 1, i) +=\n prob_of_transition_to(i) *\n exp(loglikelihood_(i, obs)) * duration_(i, d);\n }\n\n // Normalizing the current posteriors.\n new_posterior = new_posterior / accu(new_posterior);\n new_residualtime_posterior = new_residualtime_posterior /\n accu(new_residualtime_posterior);\n\n assert(abs(accu(new_posterior) - 1.0) < 1e-7);\n assert(abs(accu(new_residualtime_posterior) - 1.0) < 1e-7);\n last_posterior_ = new_posterior;\n last_residualtime_posterior_ = new_residualtime_posterior;\n return;\n }\n\n vec OnlineHSMMRunlengthBased::getRunlengthMarginal() const {\n vec marginal = conv_to::from(sum(last_posterior_, 1));\n assert(abs(accu(marginal) - 1.0) < 1e-7);\n assert(marginal.n_elem == min_duration_ + ndurations_ - 1);\n return marginal;\n }\n\n vec OnlineHSMMRunlengthBased::getStateMarginal() const {\n vec marginal = conv_to::from(sum(last_posterior_, 0));\n assert(abs(accu(marginal) - 1.0) < 1e-7);\n assert(marginal.n_elem == nstates_);\n return marginal;\n }\n\n vec OnlineHSMMRunlengthBased::getResidualTimeMarginal() const {\n vec marginal = conv_to::from(sum(last_residualtime_posterior_,\n 1));\n assert(abs(accu(marginal) - 1.0) < 1e-7);\n assert(marginal.n_elem == min_duration_ + ndurations_ - 1);\n return marginal;\n }\n\n vec OnlineHSMMRunlengthBased::getStateMarginal2() const {\n vec marginal = conv_to::from(sum(last_residualtime_posterior_,\n 0));\n assert(abs(accu(marginal) - 1.0) < 1e-7);\n assert(marginal.n_elem == nstates_);\n return marginal;\n }\n\n double OnlineHSMMRunlengthBased::oneStepAheadLoglikelihood(\n const arma::mat& obs) const {\n if (observations_.size() == 0) {\n vec ret(nstates_);\n for(int i = 0; i < nstates_; i++)\n ret(i) = loglikelihood_(i, obs) + log(pi_(i));\n return logsumexp(ret);\n }\n int max_duration = min_duration_ + ndurations_ - 1;\n mat hazard = getHazardFunction_();\n vector v;\n for(int r = 0; r < max_duration; r++) {\n\n // Segment transition.\n for(int i = 0; i < nstates_; i++)\n if (is_finite(hazard(i, r)))\n for(int j = 0; j < nstates_; j++)\n v.push_back(log(last_posterior_(r, i)) + log(\n hazard(i, r)) + log(transition_(i, j)) +\n loglikelihood_(j, obs));\n\n // Segment continuation.\n if (r > 0) {\n for(int i = 0; i < nstates_; i++)\n if (is_finite(hazard(i, r - 1)))\n v.push_back(log(last_posterior_(r - 1, i)) +\n loglikelihood_(i, obs) + log(1 - hazard(i, r - 1)));\n }\n }\n vec ret = conv_to::from(v);\n return logsumexp(ret);\n }\n\n double OnlineHSMMRunlengthBased::oneStepAheadLoglikelihood2(\n const arma::mat& obs) const {\n if (observations_.size() == 0) {\n vec ret(nstates_);\n for(int i = 0; i < nstates_; i++)\n ret(i) = loglikelihood_(i, obs) + log(pi_(i));\n return logsumexp(ret);\n }\n int max_duration = min_duration_ + ndurations_ - 1;\n mat hazard = getHazardFunction_();\n vector v;\n\n // Segment continuation.\n for(int r = 1; r < max_duration; r++)\n for(int i = 0; i < nstates_; i++)\n v.push_back(log(last_residualtime_posterior_(r, i)) +\n loglikelihood_(i, obs));\n\n // Segment transition. Notice that the next bit is not log scaled.\n vec prob_of_transition_to(nstates_, fill::zeros);\n for(int i = 0; i < nstates_; i++)\n for(int j = 0; j < nstates_; j++)\n prob_of_transition_to(i) += transition_(j, i) *\n last_residualtime_posterior_(0, j);\n for(int i = 0; i < nstates_; i++)\n v.push_back(log(prob_of_transition_to(i)) + loglikelihood_(i, obs));\n vec ret = conv_to::from(v);\n return logsumexp(ret);\n }\n\n double OnlineHSMMRunlengthBased::loglikelihood_(int state,\n const mat& obs) const {\n\n // TODO: assuming for now that the input can be converted into a vec.\n vec obs_v = conv_to::from(obs);\n getOnlineDurationAgnosticEmission()->loglikelihood(state, obs_v);\n }\n\n mat OnlineHSMMRunlengthBased::getDurationSuffixSum_() const {\n mat suffix_sum(duration_);\n for(int i = suffix_sum.n_cols - 2; i >= 0; i--)\n suffix_sum.col(i) += suffix_sum.col(i + 1);\n return suffix_sum;\n }\n\n mat OnlineHSMMRunlengthBased::getHazardFunction_() const {\n mat suffix_sum = getDurationSuffixSum_();\n mat hazard = duration_ / suffix_sum;\n if (min_duration_ > 1)\n hazard = join_horiz(zeros(nstates_,min_duration_ -1), hazard);\n assert(hazard.n_rows == nstates_ && hazard.n_cols == min_duration_\n + ndurations_ - 1);\n return hazard;\n }\n\n};\n", "meta": {"hexsha": "b447cf223c9dd0db95f9fee8d22185c4f8770df4", "size": 44693, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/HSMM.cpp", "max_stars_repo_name": "DiegoAE/BOSD", "max_stars_repo_head_hexsha": "a7ce88462c64c540ba2922d16eb6f7eba8055b47", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 19.0, "max_stars_repo_stars_event_min_datetime": "2019-05-03T05:31:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-08T18:14:31.000Z", "max_issues_repo_path": "src/HSMM.cpp", "max_issues_repo_name": "DiegoAE/BOSD", "max_issues_repo_head_hexsha": "a7ce88462c64c540ba2922d16eb6f7eba8055b47", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2019-02-14T15:29:34.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-04T10:14:54.000Z", "max_forks_repo_path": "src/HSMM.cpp", "max_forks_repo_name": "DiegoAE/BOSD", "max_forks_repo_head_hexsha": "a7ce88462c64c540ba2922d16eb6f7eba8055b47", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-07-01T07:44:09.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-01T07:44:09.000Z", "avg_line_length": 39.9044642857, "max_line_length": 86, "alphanum_fraction": 0.5310898798, "num_tokens": 10493, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314617436728, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.5414591106922302}} {"text": "#include \n#include \n#include \n\nint main()\n{\n\tEigen::Vector3f acc, acc_result;\n\n\tEigen::Matrix3f rot_x, rot_y, rot_z;\n\trot_x = Eigen::AngleAxisf(0.1, Eigen::Vector3f(1.0, 0.0, 0.0));\n\trot_y = Eigen::AngleAxisf(0.1, Eigen::Vector3f(0.0, 1.0, 0.0));\n\trot_z = Eigen::AngleAxisf(0.1, Eigen::Vector3f(0.0, 0.0, 1.0));\n\n\tacc_result = ( rot_z * (rot_y * (rot_x * acc)));\n\n\tstd::cout << acc_result << std::endl;\n\n\treturn 0;\n}\n", "meta": {"hexsha": "5028332fb4f3d5f9b1c3bdf4edffab0bcfcc1aad", "size": 456, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "c++/eigen/angle_axis.cpp", "max_stars_repo_name": "RyuYamamoto/sandbox", "max_stars_repo_head_hexsha": "799f32f92eea944c8d467cccd24f8bd4cd80a9d3", "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": "c++/eigen/angle_axis.cpp", "max_issues_repo_name": "RyuYamamoto/sandbox", "max_issues_repo_head_hexsha": "799f32f92eea944c8d467cccd24f8bd4cd80a9d3", "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": "c++/eigen/angle_axis.cpp", "max_forks_repo_name": "RyuYamamoto/sandbox", "max_forks_repo_head_hexsha": "799f32f92eea944c8d467cccd24f8bd4cd80a9d3", "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": 22.8, "max_line_length": 64, "alphanum_fraction": 0.6469298246, "num_tokens": 182, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.849971175657575, "lm_q2_score": 0.6370307806984444, "lm_q1q2_score": 0.5414578016003196}} {"text": "#pragma once\n\n#include \n\n#include \n#include \n\n#include \"../piecewise_polynomial.hpp\"\n#include \"spline.hpp\"\n\nnamespace irlib {\n //template\n //reutrn\n template T const_pi();\n\n template<>\n inline mpfr::mpreal const_pi() {\n return mpfr::const_pi();\n }\n\n template<>\n inline double const_pi() {\n return M_PI;\n }\n\n inline std::complex my_exp(const mpreal& z_img) {\n return std::complex(\n mpfr::cos(z_img), mpfr::sin(z_img)\n );\n }\n\n template\n std::vector >\n composite_gauss_legendre_nodes(\n const std::vector §ion_edges,\n const std::vector > &nodes\n ) {\n int num_sec = section_edges.size() - 1;\n int num_local_nodes = nodes.size();\n\n std::vector > all_nodes(num_sec * num_local_nodes);\n for (int s = 0; s < num_sec; ++s) {\n auto a = section_edges[s];\n auto b = section_edges[s + 1];\n for (int n = 0; n < num_local_nodes; ++n) {\n mp_type x = a + ((b - a) / mp_type(2)) * (nodes[n].first + mp_type(1));\n mp_type w = ((b - a) / mp_type(2)) * nodes[n].second;\n all_nodes[s * num_local_nodes + n] = std::make_pair(x, w);\n }\n }\n return all_nodes;\n };\n\n template\n Ty integrate_gauss_legendre(const std::vector& section_edges, const F& f, int num_local_nodes) {\n std::vector> nodes = detail::gauss_legendre_nodes(num_local_nodes);\n auto nodes_x = composite_gauss_legendre_nodes(section_edges, nodes);\n Ty r = 0;\n for (int n=0; n(nodes_x[n].first)) * static_cast(nodes_x[n].second);\n }\n return r;\n };\n\n /**\n * Compute Matrix representation of a given Kernel\n * @tparam Scalar\n * @tparam K\n * @param kernel\n * @param section_edges_x\n * @param section_edges_y\n * @param num_local_nodes\n * @param num_local_poly\n * @return Matrix representation\n */\n template\n Eigen::Matrix\n matrix_rep(const K &kernel,\n const std::vector §ion_edges_x,\n const std::vector §ion_edges_y,\n int num_local_nodes,\n int num_local_poly) {\n\n using mpreal_matrix_type = Eigen::Matrix;\n using matrix_type = Eigen::Matrix;\n\n int num_sec_x = section_edges_x.size() - 1;\n int num_sec_y = section_edges_y.size() - 1;\n\n // nodes for Gauss-Legendre integration\n std::vector> nodes = detail::gauss_legendre_nodes(num_local_nodes);\n auto nodes_x = composite_gauss_legendre_nodes(section_edges_x, nodes);\n auto nodes_y = composite_gauss_legendre_nodes(section_edges_y, nodes);\n\n std::vector phi_x(num_sec_x);\n for (int s = 0; s < num_sec_x; ++s) {\n phi_x[s] = mpreal_matrix_type(num_local_poly, num_local_nodes);\n for (int n = 0; n < num_local_nodes; ++n) {\n for (int l = 0; l < num_local_poly; ++l) {\n auto leg_val = normalized_legendre_p(l, nodes[n].first);\n phi_x[s](l, n) = detail::sqrt(mpreal(2) / (section_edges_x[s + 1] - section_edges_x[s])) * leg_val *\n nodes_x[s * num_local_nodes + n].second;\n }\n }\n }\n\n std::vector phi_y(num_sec_y);\n for (int s = 0; s < num_sec_y; ++s) {\n phi_y[s] = mpreal_matrix_type(num_local_poly, num_local_nodes);\n for (int n = 0; n < num_local_nodes; ++n) {\n for (int l = 0; l < num_local_poly; ++l) {\n auto leg_val = normalized_legendre_p(l, nodes[n].first);\n phi_y[s](l, n) = detail::sqrt(mpreal(\"2\") / (section_edges_y[s + 1] - section_edges_y[s])) * leg_val *\n nodes_y[s * num_local_nodes + n].second;\n }\n }\n }\n\n matrix_type K_mat(num_sec_x * num_local_poly, num_sec_y * num_local_poly);\n for (int s2 = 0; s2 < num_sec_y; ++s2) {\n for (int s = 0; s < num_sec_x; ++s) {\n\n mpreal_matrix_type K_nn(num_local_nodes, num_local_nodes);\n for (int n = 0; n < num_local_nodes; ++n) {\n for (int n2 = 0; n2 < num_local_nodes; ++n2) {\n K_nn(n, n2) = kernel(static_cast(nodes_x[s * num_local_nodes + n].first),\n static_cast(nodes_y[s2 * num_local_nodes + n2].first)\n );\n }\n }\n\n // phi_x(l, n) * K_nn(n, n2) * phi_y(l2, n2)^T\n mpreal_matrix_type r = phi_x[s] * K_nn * phi_y[s2].transpose();\n\n for (int l2 = 0; l2 < num_local_poly; ++l2) {\n for (int l = 0; l < num_local_poly; ++l) {\n K_mat(num_local_poly * s + l, num_local_poly * s2 + l2) = static_cast(r(l, l2));\n }\n }\n }\n }\n\n return K_mat;\n }\n\n /**\n * Estimate absolute errors in ulx and vly by computing the residual of the integral equation\n * r(x) = u(x) - s^{-1} int_0^1 K(x,y) v(y) dy\n * This returns an estimate of max_x |r(x)|\n * @tparam K\n * @param ux defined on [0, 1]\n * @param vy defined on [0, 1]\n * @param kernel a function of (x, y)\n * @return residual for ux\n */\n template\n double estimate_residual(const piecewise_polynomial& ux, const piecewise_polynomial& vy, T s, const K& kernel, int num_local_nodes) {\n auto section_edges_x = ux.section_edges();\n auto section_edges_y = vy.section_edges();\n\n auto local_nodes = detail::gauss_legendre_nodes(num_local_nodes);\n auto nodes_y = composite_gauss_legendre_nodes(section_edges_y, local_nodes);\n\n std::vector sampling_points(section_edges_x);\n for (int i=0; i < section_edges_x.size()-1; ++i) {\n auto dx = section_edges_x[i+1]-section_edges_x[i];\n sampling_points.push_back(0.25*dx + section_edges_x[i]);\n sampling_points.push_back(0.50*dx + section_edges_x[i]);\n sampling_points.push_back(0.75*dx + section_edges_x[i]);\n }\n\n // Now we compute residual for u_l(x)\n double residual_x = 0.0;\n for (auto i = 0; i < section_edges_x.size()-1; ++i) {\n auto x = (section_edges_x[i+1] + section_edges_x[i])/2;\n mpfr::mpreal sum(0);\n for (int n=0; n < nodes_y.size(); ++n) {\n auto y = nodes_y[n].first;\n auto w = nodes_y[n].second;\n sum += w * kernel(x,y) * vy.compute_value(y);\n }\n auto diff = mpfr::abs(sum/s - ux.compute_value(x));\n residual_x = std::max(residual_x, static_cast(diff));\n }\n\n return residual_x;\n }\n\n template\n void check_SVD(const MatrixXmp& Kmat_even, const SVD& svd_even) {\n MatrixXmp S(svd_even.matrixU().cols(), svd_even.matrixV().cols());\n MatrixXmp invS(svd_even.matrixU().cols(), svd_even.matrixV().cols());\n S.setZero();\n invS.setZero();\n for (int l=0; l\n std::tuple<\n std::vector,\n std::vector>,\n std::vector>\n >\n generate_ir_basis_functions_impl(\n const KernelType &kernel,\n int max_dim,\n double sv_cutoff,\n int num_local_poly,\n int num_nodes_gauss_legendre,\n const std::vector §ion_edges_x,\n const std::vector §ion_edges_y,\n std::vector &residual_x,\n std::vector &residual_y,\n std::pair& r_int_eq,\n bool verbose\n ) throw(std::runtime_error) {\n using vector_t = Eigen::Matrix;\n using matrix_t = Eigen::Matrix;\n using mp_vector_t = Eigen::Matrix;\n using mp_matrix_t = Eigen::Matrix;\n\n if (num_local_poly < 2) {\n throw std::runtime_error(\"num_local_poly < 2! : \" + std::to_string(num_local_poly));\n }\n\n // Compute Kernel matrix and do SVD for even/odd sector\n if (verbose) {\n std::cout << \" Constructing kernel matrix for even sector ... \" << std::flush;\n }\n auto kernel_even = [&](const mpreal &x, const mpreal &y) { return kernel(x, y) + kernel(x, -y); };\n auto Kmat_even = irlib::matrix_rep(\n kernel_even, section_edges_x, section_edges_y, num_nodes_gauss_legendre, num_local_poly\n );\n if (verbose) {\n std::cout << \" done \" << std::endl;\n std::cout << \" SVD kernel matrix for even sector ... \" << std::flush;\n }\n Eigen::BDCSVD svd_even(Kmat_even, Eigen::ComputeThinU | Eigen::ComputeThinV);\n if (verbose) {\n std::cout << \" done \" << std::endl;\n std::cout << \" Constructing kernel matrix for odd sector ... \" << std::flush;\n }\n auto kernel_odd = [&](const mpreal &x, const mpreal &y) { return kernel(x, y) - kernel(x, -y); };\n auto Kmat_odd = irlib::matrix_rep(\n kernel_odd, section_edges_x, section_edges_y, num_nodes_gauss_legendre, num_local_poly\n );\n if (verbose) {\n std::cout << \" done \" << std::endl;\n std::cout << \" SVD kernel matrix for odd sector ... \" << std::flush;\n }\n Eigen::BDCSVD svd_odd(Kmat_odd, Eigen::ComputeThinU | Eigen::ComputeThinV);\n if (verbose) {\n std::cout << \" done \" << std::endl;\n }\n\n // Pick up singular values and basis functions larger than cutoff\n std::vector sv;\n std::vector Uvec, Vvec;\n auto s0 = svd_even.singularValues()[0];\n for (int i = 0; i < svd_even.singularValues().size(); ++i) {\n if (sv.size() == max_dim || svd_even.singularValues()[i] / s0 < sv_cutoff) {\n break;\n }\n sv.push_back(svd_even.singularValues()[i]);\n Uvec.push_back(svd_even.matrixU().col(i));\n Vvec.push_back(svd_even.matrixV().col(i));\n if (sv.size() == max_dim || svd_odd.singularValues()[i] / s0 < sv_cutoff) {\n break;\n }\n sv.push_back(svd_odd.singularValues()[i]);\n Uvec.push_back(svd_odd.matrixU().col(i));\n Vvec.push_back(svd_odd.matrixV().col(i));\n }\n assert(sv.size() <= max_dim);\n\n // Check if singular values are in decreasing order\n for (int l = 0; l < sv.size() - 1; ++l) {\n if (sv[l] < sv[l + 1]) {\n throw std::runtime_error(\n \"Singular values are not in decreasing order. This may be due to numerical round erros. You may ask for fewer basis functions!\");\n }\n }\n\n // Construct basis functions\n std::vector> deriv_xm1 = normalized_legendre_p_derivatives(num_local_poly, mpreal(\"-1\"));\n std::vector inv_factorial;\n inv_factorial.push_back(mpreal(1));\n for (int l = 1; l < num_local_poly; ++l) {\n inv_factorial.push_back(inv_factorial.back() / mpreal(l));\n }\n\n auto gen_pp = [&](const std::vector §ion_edges, const std::vector &vectors) {\n std::vector> pp;\n\n int ns_pp = section_edges.size() - 1;\n for (int v = 0; v < vectors.size(); ++v) {\n Eigen::Matrix coeff(ns_pp, num_local_poly);\n coeff.setZero();\n int parity = v % 2 == 0 ? 1 : -1;\n // loop over sections in [0, 1]\n for (int s = 0; s < section_edges.size() - 1; ++s) {\n // loop over normalized Legendre polynomials\n for (int l = 0; l < num_local_poly; ++l) {\n mpreal coeff2 = mpreal(1)/mpfr::sqrt(section_edges[s + 1] - section_edges[s]);\n // loop over the orders of derivatives\n for (int d = 0; d < num_local_poly; ++d) {\n mpreal tmp = inv_factorial[d] * coeff2 * vectors[v][s * num_local_poly + l] * deriv_xm1[l][d];\n coeff(s, d) += tmp;\n coeff2 *= mpreal(2)/(section_edges[s + 1] - section_edges[s]);\n }\n }\n }\n pp.push_back(piecewise_polynomial(section_edges.size() - 1, section_edges, coeff));\n }\n\n return pp;\n };\n\n auto u_basis_pp = gen_pp(section_edges_x, Uvec);\n auto v_basis_pp = gen_pp(section_edges_y, Vvec);\n\n for (int i = 0; i < u_basis_pp.size(); ++i) {\n if (u_basis_pp[i].compute_value(1) < 0) {\n u_basis_pp[i] = mpreal(-1.0) * u_basis_pp[i];\n v_basis_pp[i] = mpreal(-1.0) * v_basis_pp[i];\n }\n }\n\n if (u_basis_pp.size()%2 == 1) {\n r_int_eq.first = estimate_residual(u_basis_pp.back(), v_basis_pp.back(), sv.back(), kernel_even, num_nodes_gauss_legendre);\n auto k_yx = [&](mpreal y, mpreal x) {return kernel_even(x,y);};\n r_int_eq.second = estimate_residual(v_basis_pp.back(), u_basis_pp.back(), sv.back(), k_yx, num_nodes_gauss_legendre);\n } else {\n r_int_eq.first = estimate_residual(u_basis_pp.back(), v_basis_pp.back(), sv.back(), kernel_odd, num_nodes_gauss_legendre);\n auto k_yx = [&](mpreal y, mpreal x) {return kernel_odd(x,y);};\n r_int_eq.second = estimate_residual(v_basis_pp.back(), u_basis_pp.back(), sv.back(), k_yx, num_nodes_gauss_legendre);\n }\n\n\n residual_x.resize(section_edges_x.size() - 1);\n residual_y.resize(section_edges_y.size() - 1);\n //std::fill(residual_x.begin(), residual_x.end(), 0.0);\n ////std::fill(residual_y.begin(), residual_y.end(), 0.0);\n\n {\n auto l = Uvec.size() -1;\n for (int s = 0; s < residual_x.size(); ++s) {\n double dx = static_cast(section_edges_x[s+1]-section_edges_x[s]);\n double a_diff = static_cast(Uvec[l](s * num_local_poly + num_local_poly - 1)) * std::sqrt((2.*l+1)/dx);\n residual_x[s] = std::abs(a_diff);\n }\n for (int s = 0; s < residual_y.size(); ++s) {\n double dy = static_cast(section_edges_y[s+1]-section_edges_y[s]);\n double a_diff = static_cast(Vvec[l](s * num_local_poly + num_local_poly - 1)) * std::sqrt((2.*l+1)/dy);\n residual_y[s] = std::abs(a_diff);\n }\n }\n\n return std::make_tuple(sv, u_basis_pp, v_basis_pp);\n }\n\n template\n std::tuple<\n std::vector,\n std::vector>,\n std::vector>\n >\n generate_ir_basis_functions(\n const KernelType &kernel,\n int max_dim,\n double sv_cutoff = 1e-12,\n bool verbose = false,\n double r_tol = 1e-6,\n int num_local_poly = 10,\n int num_nodes_gauss_legendre = 24\n ) throw(std::runtime_error) {\n using vector_t = Eigen::Matrix;\n // Compute approximate positions of nodes of the highest basis function in the even sector\n std::vector nodes_x, nodes_y;\n if (verbose){\n std::cout << \"Computing approximate positions of zeros... \";\n std::tie(nodes_x, nodes_y) = compute_approximate_nodes_even_sector(kernel, 500, std::max(1e-12, sv_cutoff));\n std::cout << \"Done\" << std::endl;\n }\n\n auto gen_section_edges = [](const std::vector &nodes) {\n std::vector section_edges;\n section_edges.push_back(0);\n for (int i = 0; i < nodes.size(); ++i) {\n section_edges.push_back(static_cast(nodes[i]));\n }\n section_edges.push_back(1);\n return section_edges;\n };\n\n auto u = [](const std::vector §ion_edges,\n std::vector &residual, double eps) {\n std::vector section_edges_new(section_edges);\n for (int s = 0; s < section_edges.size() - 1; ++s) {\n if (residual[s] > eps) {\n section_edges_new.push_back(\n (section_edges[s] + section_edges[s + 1]) / 2\n );\n }\n }\n std::sort(section_edges_new.begin(), section_edges_new.end());\n return section_edges_new;\n };\n\n std::vector section_edges_x = gen_section_edges(nodes_x);\n std::vector section_edges_y = gen_section_edges(nodes_y);\n\n int ite = 0;\n\n // Sections are split recursively until convergence is reached.\n while (true) {\n if (verbose) {\n std::cout << \"Iteration \" << ite+1 << \" : \" << section_edges_x.size()-1 << \" sections for x, \" << section_edges_y.size()-1 << \" sections for y.\" << std::endl;\n }\n std::vector residual_x, residual_y;\n std::pair r_int_eq;\n auto r = generate_ir_basis_functions_impl(kernel, max_dim, sv_cutoff, num_local_poly, num_nodes_gauss_legendre,\n section_edges_x,\n section_edges_y,\n residual_x,\n residual_y,\n r_int_eq,\n verbose\n );\n int ns = section_edges_x.size() + section_edges_y.size();\n\n int dim = std::get<1>(r).size();\n\n auto a_tol_x = r_tol * std::abs(\n static_cast(std::get<1>(r).back().compute_value(1))\n );\n auto a_tol_y = r_tol * std::max(\n std::abs(static_cast(std::get<2>(r)[2*(dim/2)-1].compute_value(1))),\n std::abs(static_cast(std::get<2>(r)[2*(dim/2)-1].compute_value(0)))\n );\n\n section_edges_x = u(section_edges_x, residual_x, a_tol_x);\n section_edges_y = u(section_edges_y, residual_y, a_tol_y);\n\n if (verbose) {\n std::cout << \"Iteration \" << ite+1 << \" : found \" << std::get<1>(r).size() << \" basis functions. \" << std::endl;\n std::cout << \"Iteration \" << ite+1 << \" : max_x |u_l(x) - s_l^{-1} dy int_{-1}^1 K(x,y) v_l(y)| = \" << r_int_eq.first << \" for largest l.\" << std::endl;\n std::cout << \"Iteration \" << ite+1 << \" : max_y |v_l(y) - s_l^{-1} dx int_{-1}^1 K(x,y) u_l(x)| = \" << r_int_eq.second << \" for largest l.\" << std::endl;\n std::cout << \"Iteration \" << ite+1 << \" : residual estimated by expansion coefficients for x = \" << *std::max_element(residual_x.begin(),residual_x.end()) << std::endl;\n std::cout << \"Iteration \" << ite+1 << \" : residual estimated by expansion coefficients for y = \" << *std::max_element(residual_y.begin(),residual_y.end()) << std::endl;\n }\n\n if (section_edges_x.size() + section_edges_y.size() == ns) {\n return r;\n }\n\n ite += 1;\n }\n\n };\n\n template\n inline std::vector linspace(T minval, T maxval, int N, bool include_last_point = true) {\n int end = include_last_point ? N : N-1;\n std::vector r(end);\n for (int i = 0; i < end; ++i) {\n r[i] = i * (maxval - minval) / (N - T(1)) + minval;\n }\n return r;\n }\n\n\n\n template\n piecewise_polynomial construct_piecewise_polynomial_cspline(\n const std::vector &x_array, const std::vector &y_array) {\n const int n_points = x_array.size();\n const int n_section = n_points - 1;\n\n Eigen::Matrix coeff(n_section, 4);\n\n // Cubic spline interpolation\n tk::spline spline;\n spline.set_points(x_array, y_array);\n\n // Construct piecewise_polynomial\n for (int s = 0; s < n_section; ++s) {\n for (int p = 0; p < 4; ++p) {\n coeff(s, p) = spline.get_coeff(s, p);\n }\n }\n return piecewise_polynomial(n_section, x_array, coeff);\n };\n\n /**\n * Find all zeros of a piecewise polynomial defined on (0,1)\n * @tparam T\n * @tparam Tx\n * @param p\n * @param delta tolerance\n * @return\n */\n template\n std::vector find_zeros(\n const piecewise_polynomial& p,\n Tx delta\n ) {\n int N = 10000;\n Tx de_cutoff = 3.0;\n\n std::vector tx_vec = linspace(0.0, de_cutoff, N);\n std::vector x_vec(N), zeros;\n for (int i = 0; i < N; ++i) {\n x_vec[i] = tanh(0.5 * const_pi() * sinh(tx_vec[i]));\n }\n\n for (int i = 0; i < N-1; ++i) {\n if (p.compute_value(x_vec[i]) * p.compute_value(x_vec[i+1]) < 0) {\n Tx x_left = x_vec[i];\n T p_left = p.compute_value(x_vec[i]);\n\n Tx x_right = x_vec[i+1];\n T p_right = p.compute_value(x_vec[i+1]);\n\n while (x_right-x_left > delta) {\n Tx x_mid = (x_left+x_right)/2;\n if (p_left * p.compute_value(x_mid) > 0) {\n x_left = x_mid;\n } else {\n x_right = x_mid;\n }\n }\n zeros.push_back((x_left+x_right)/2);\n }\n }\n\n return zeros;\n };\n\n template\n std::vector > cspline_approximation(\n const std::vector >& basis_vectors,\n double r_tol\n ) {\n std::vector > basis_vectors_cspline;\n\n\n // Determine sampling points\n std::set x_set{0.0, 1.0};\n int largest_even_l = 2*((basis_vectors.size()-1)/2);\n std::vector zeros = find_zeros(basis_vectors[largest_even_l], static_cast(1e-10));\n std::copy(zeros.begin(), zeros.end(), std::inserter(x_set, x_set.begin()));\n std::vector x(x_set.size());\n std::vector y(x_set.size());\n while (true) {\n // construct cubic spline interpolation of the highest-l basis function\n int index = 0;\n x.resize(x_set.size());\n y.resize(x_set.size());\n for (auto it=x_set.begin(); it != x_set.end(); ++it) {\n x[index] = *it;\n y[index] = basis_vectors.back().compute_value(*it);\n ++ index;\n }\n auto cspline = construct_piecewise_polynomial_cspline(x, y);\n\n // check convergence\n for (int i=0; i < x.size()-1; ++i) {\n auto x_mid = (x[i]+x[i+1])/2;\n auto diff = std::abs(static_cast(\n (cspline.compute_value(x_mid)-basis_vectors.back().compute_value(x_mid))/\n basis_vectors.back().compute_value(1)\n ));\n if (diff > r_tol) {\n //std::cout << \"add \" << x_mid << \" \" << diff << std::endl;\n x_set.insert(x_mid);\n }\n }\n\n if (x_set.size() == x.size()) {\n break;\n }\n }\n\n int Nx = x.size();\n\n // construct cspline approximation one by one\n for (int l=0; l < basis_vectors.size(); ++l) {\n for (int ix=0; ix(x, y));\n }\n\n return basis_vectors_cspline;\n };\n\n //Compute nodes (zeros) of Legendre polynomials\n inline std::vector compute_legendre_nodes(int l) {\n double eps = 1e-10;\n if (l > 200) {\n throw std::runtime_error(\"l > 200 in compute_legendre_nodes\");\n }\n\n std::vector nodes;\n\n auto leg_diff = [](int l, double x) {\n return l * (x * legendre_p(l, x) - legendre_p(l - 1, x)) / (x * x - 1);\n };\n\n //i-th zero\n for (int i = 0; i < l / 2; i++) {\n //initial guess\n double x = std::cos(M_PI * (i + 1 - 0.25) / (l + 0.5));\n\n //Newton-Raphson iteration\n while (true) {\n double leg = legendre_p(l, x);\n double x_new = x - 0.1 * leg / leg_diff(l, x);\n if (std::abs(x_new - x) < eps && std::abs(leg) < eps) {\n break;\n }\n x = x_new;\n }\n\n nodes.push_back(x);\n nodes.push_back(-x);\n }\n\n if (l % 2 == 1) {\n nodes.push_back(0.0);\n }\n\n std::sort(nodes.begin(), nodes.end());\n\n return nodes;\n }\n\n //AVOID USING BOOST_TYPEOF\n template\n struct result_of_overlap {\n typedef std::complex value;\n };\n\n template<>\n struct result_of_overlap {\n typedef double value;\n };\n\n /// Construct piecewise polynomials representing exponential functions: exp(i w_i x)\n template\n void construct_exp_functions_coeff(\n const std::vector &w,\n const std::vector §ion_edges,\n int k,\n Eigen::Tensor, 3> &coeffs) {\n const int N = section_edges.size() - 1;\n\n std::complex z;\n coeffs = Eigen::Tensor,3>(w.size(), N, k + 1);\n\n std::vector pre_factor(k + 1);\n pre_factor[0] = 1.0;\n for (int j = 1; j < k + 1; ++j) {\n pre_factor[j] = pre_factor[j - 1] / j;\n }\n\n for (int n = 0; n < w.size(); ++n) {\n auto z = std::complex(0.0, w[n]);\n for (int section = 0; section < N; ++section) {\n auto x = section_edges[section];\n std::complex exp0 = std::exp(z * (x + 1));\n std::complex z_power = T(1);\n for (int j = 0; j < k + 1; ++j) {\n coeffs(n, section, j) = exp0 * z_power * pre_factor[j];\n z_power *= z;\n }\n }\n }\n }\n\n/**\n * Compute \\int_x0^x1 dx exp(i w (x+1)) (x-x0)^k\n * for k=0, 1, ..., K+1. x1 = x0+dx.\n**/\n template\n void compute_Ik(T x0, T dx, T w, int K, std::vector >& Ik) {\n auto x1 = x0 + dx;\n auto iw = std::complex(0.0, w);\n auto exp0 = exp(iw*(x0+1));\n auto exp1 = exp(iw*(x1+1));\n auto exp10 = exp(iw*(x1-x0));\n Ik[0] = (exp1 - exp0)/iw;\n //Ik[0] = (exp10 - 1) * exp0 /iw;\n\n auto dx_k = dx;\n for (int k=1; k(k) * Ik[k-1])/iw;\n dx_k *= dx;\n }\n }\n\n\n/**\n * Compute integral of exponential functions and given piecewise polynomials\n * \\int dx exp(i w_i (x+1)) p_j(x),\n * where w_i are given real double objects and p_j are piecewise polynomials.\n * @tparam T scalar type of piecewise polynomials\n * @param w vector of w_i in ascending order\n * @param statis Statistics (fermion or boson)\n * @param p vector of piecewise polynomials.\n * @param results computed results\n */\n template\n void compute_integral_with_exp(\n const std::vector &w,\n const std::vector > &pp_func,\n Eigen::Tensor, 2> &Tnl\n ) {\n typedef std::complex dcomplex;\n typedef piecewise_polynomial,Tx> pp_type;\n typedef Eigen::Matrix, Eigen::Dynamic, Eigen::Dynamic> ex_matrix_t;\n typedef Eigen::Tensor, 2> tensor_t;\n\n T pi = const_pi();\n\n //order of polynomials used for representing exponential functions internally.\n const int k_iw = 16;//for debug\n const int k = pp_func[0].order();\n const int n_section = pp_func[0].num_sections();\n\n std::vector > Ik(k+1);\n\n for (int l = 0; l < pp_func.size(); ++l) {\n if (k != pp_func[l].order()) {\n throw std::runtime_error(\n \"Error in compute_transformation_matrix_to_matsubara: basis functions must be pieacewise polynomials of the same order\");\n }\n if (pp_func[l].section_edge(0) != 0 || pp_func[l].section_edge(n_section) != 1) {\n throw std::runtime_error(\"Piecewise polynomials must be defined on [0,1]\");\n }\n }\n\n const int n_iw = w.size();\n const int n_max = n_iw - 1;\n\n for (int i = 0; i < w.size() - 1; ++i) {\n if (w[i] > w[i + 1]) {\n throw std::runtime_error(\"w must be give in ascending order.\");\n }\n }\n\n //Use Taylor expansion for exp(i w_n tau) for w_n*dx < cutoff*M_PI\n const double cutoff = 0.1;\n\n Eigen::Tensor,3> exp_coeffs(w.size(), n_section, k_iw + 1);\n construct_exp_functions_coeff(w, pp_func[0].section_edges(), k_iw, exp_coeffs);\n\n ex_matrix_t left_mid_matrix(n_iw, k + 1);\n ex_matrix_t left_matrix(n_iw, k_iw + 1);\n ex_matrix_t mid_matrix(k_iw + 1, k + 1);\n ex_matrix_t right_matrix(k + 1, pp_func.size());\n ex_matrix_t r(n_iw, pp_func.size());\n r.setZero();\n\n std::vector dx_power(k + k_iw + 2);\n\n for (int s = 0; s < n_section; ++s) {\n auto x0 = pp_func[0].section_edge(s);\n T dx = static_cast(pp_func[0].section_edge(s + 1) - pp_func[0].section_edge(s));\n left_mid_matrix.setZero();\n\n dx_power[0] = 1.0;\n for (int p = 1; p < dx_power.size(); ++p) {\n dx_power[p] = dx * dx_power[p - 1];\n }\n\n //Use Taylor expansion for exp(i w_n tau) for w_n*dx < cutoff*M_PI\n auto w_max_cs = cutoff * pi / dx;\n int n_max_cs = -1;\n for (int i = 0; i < w.size(); ++i) {\n if (w[i] <= w_max_cs) {\n n_max_cs = i;\n }\n }\n\n //Use Taylor expansion\n if (n_max_cs >= 0) {\n for (int p = 0; p < k_iw + 1; ++p) {\n for (int p2 = 0; p2 < k + 1; ++p2) {\n mid_matrix(p, p2) = dx_power[p + p2 + 1] / (p + p2 + 1.0);\n }\n }\n\n for (int n = 0; n < n_max_cs + 1; ++n) {\n for (int p = 0; p < k_iw + 1; ++p) {\n left_matrix(n, p) = exp_coeffs(n,s,p);\n }\n }\n\n left_mid_matrix.block(0, 0, n_max_cs + 1, k + 1) =\n left_matrix.block(0, 0, n_max_cs + 1, k_iw + 1) * mid_matrix;\n }\n\n //Otherwise, compute the overlap exactly\n for (int n = std::max(n_max_cs + 1, 0); n <= n_max; ++n) {\n compute_Ik(x0, dx, w[n], k, Ik);\n for (int i=0; i(pp_func[l].coefficient(s, p2));\n }\n }\n\n r += left_mid_matrix * right_matrix;\n }\n\n Tnl = tensor_t(n_iw, pp_func.size());\n for (int n = 0; n < n_iw; ++n) {\n for (int l = 0; l < pp_func.size(); ++l) {\n Tnl(n, l) = r(n, l);\n }\n }\n }\n\n\n /**\n * Compute a transformation matrix from a give orthogonal basis set to Matsubara freq.\n * @tparam T scalar type\n * @tparam Tx scalar type for x in [-1,1]\n * @param n_vec indices of Matsubara frequqneices for which matrix elements will be computed (in strictly ascending order).\n * The Matsubara basis functions look like exp(i PI * (n[i]+1/2)) for fermions, exp(i PI * n[i]) for bosons.\n * @param bf_src orthogonal basis functions on [-1,1]. They must be piecewise polynomials of the same order. Piecewise polynomial representations on [0,1] must be provided.\n * Basis functions u_l(x) are assumed to be even or odd for even l and odd l, respectively.\n * @param Tnl computed transformation matrix, results are cast into double\n */\n template\n void compute_transformation_matrix_to_matsubara(\n const std::vector &n_vec,\n irlib::statistics::statistics_type statis,\n const std::vector > &bf_src,\n Eigen::Tensor, 2> &Tnl\n ) {\n typedef std::complex dcomplex;\n typedef Eigen::Matrix, Eigen::Dynamic, Eigen::Dynamic> matrix_t;\n typedef Eigen::Tensor, 2> tensor_t;\n\n int Nl = bf_src.size();\n auto pi = const_pi();\n\n if (n_vec.size() == 0) {\n return;\n }\n\n for (int i = 0; i < n_vec.size() - 1; ++i) {\n if (n_vec[i] > n_vec[i + 1]) {\n throw std::runtime_error(\"n_vec must be in strictly ascending order!\");\n }\n }\n\n if (n_vec[0] < 0) {\n throw std::runtime_error(\"n_vec cannot be negative!\");\n }\n\n long offset = (statis == statistics::FERMIONIC ? 1 : 0);\n\n // compute tails\n int sign_s = (statis == statistics::FERMIONIC ? -1 : 1);\n // even number close to (bf_src[0].order()/2\n int num_tail = std::min(2*(bf_src[0].order()/2), 4);\n if (num_tail < 4) {\n throw std::runtime_error(\"num_tail < 4.\");\n }\n Eigen::Matrix,Eigen::Dynamic,Eigen::Dynamic> tails(bf_src.size(), num_tail);\n const std::complex zi(0.0, 1.0);\n for (int l=0; l((sign_s - sign_lm) * bf_src[l].derivative(1, m));\n ztmp *= zi;\n }\n }\n\n // Determine for which Matsubara frequencies tail is used\n // Store those indices in ovec\n std::vector num_low_freq(Nl);\n double eps = 1e-8;\n for (int l=0; l ovec;\n std::transform(n_vec.begin(), last, std::back_inserter(ovec), [&](long n){return 2*n+offset;});\n\n // Compute Tnl\n Eigen::Tensor, 2> Tnl_low_freq;\n compute_Tbar_ol(ovec, bf_src, Tnl_low_freq);\n Tnl = Eigen::Tensor,2>(n_vec.size(), bf_src.size());\n Tnl.setZero();\n for(int l=0; l\n void compute_Tbar_ol(\n const std::vector &o_vec,\n const std::vector> &bf_src,\n Eigen::Tensor, 2> &Tbar_ol\n ) {\n typedef std::complex dcomplex;\n typedef Eigen::Matrix, Eigen::Dynamic, Eigen::Dynamic> matrix_t;\n typedef Eigen::Tensor, 2> tensor_t;\n\n if (o_vec.size() == 0) {\n return;\n }\n\n for (int i = 0; i < o_vec.size() - 1; ++i) {\n if (o_vec[i] > o_vec[i + 1]) {\n throw std::runtime_error(\"o must be given in strictly ascending order!\");\n }\n }\n\n std::vector w;\n std::transform(o_vec.begin(), o_vec.end(), std::back_inserter(w), [](long o) { return 0.5 * M_PI * o; });\n\n compute_integral_with_exp(w, bf_src, Tbar_ol);\n\n for (int l=0; l(0.0, 2 * Tbar_ol(i,l).imag());\n }\n }\n }\n\n std::vector inv_norm(bf_src.size());\n for (int l = 0; l < bf_src.size(); ++l) {\n inv_norm[l] = 1. / sqrt(2*bf_src[l].overlap(bf_src[l]));\n }\n for (int n = 0; n < w.size(); ++n) {\n for (int l = 0; l < bf_src.size(); ++l) {\n Tbar_ol(n, l) *= inv_norm[l] * sqrt(static_cast(0.5));\n }\n }\n }\n\n\n /**\n * Find approximate positions of nodes for the even singular vectors with the lowest singular value larger than a cutoff\n * @tparam Kernel kernel type\n * @param knl Kernel object\n * @param N Number of points for discretizing the kernel\n * @param cutoff_singular_values smallest relative singular value\n * @return positions of nodes\n */\n template\n std::pair,std::vector>\n compute_approximate_nodes_even_sector(const Kernel &knl, int N, double cutoff_singular_values) {\n typedef Eigen::Matrix matrix_t;\n\n double de_cutoff = 2.5;\n\n //DE mesh for x\n std::vector tx_vec = linspace(0.0, de_cutoff, N);\n std::vector weight_x(N), x_vec(N);\n for (int i = 0; i < N; ++i) {\n x_vec[i] = std::tanh(0.5 * M_PI * std::sinh(tx_vec[i]));\n //sqrt of the weight of DE formula\n weight_x[i] =\n std::sqrt(0.5 * M_PI * std::cosh(tx_vec[i])) / std::cosh(0.5 * M_PI * std::sinh(tx_vec[i]));\n }\n\n //DE mesh for y\n std::vector ty_vec = linspace(-de_cutoff, 0.0, N);\n std::vector y_vec(N), weight_y(N);\n for (int i = 0; i < N; ++i) {\n y_vec[i] = std::tanh(0.5 * M_PI * std::sinh(ty_vec[i])) + 1.0;\n //sqrt of the weight of DE formula\n weight_y[i] =\n std::sqrt(0.5 * M_PI * std::cosh(ty_vec[i])) / std::cosh(0.5 * M_PI * std::sinh(ty_vec[i]));\n }\n\n matrix_t K(N, N);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n K(i, j) = weight_x[i] * static_cast(knl(x_vec[i], y_vec[j]) + knl(x_vec[i], -y_vec[j])) *\n weight_y[j];\n }\n }\n\n //Perform SVD\n Eigen::BDCSVD svd(K, Eigen::ComputeFullU | Eigen::ComputeFullV);\n const Eigen::VectorXd& svalues = svd.singularValues();\n const matrix_t& U = svd.matrixU();\n const matrix_t& V = svd.matrixV();\n\n //Count non-zero SV\n int dim = N;\n for (int i = 1; i < N; ++i) {\n if (std::abs(svalues(i) / svalues(0)) < cutoff_singular_values) {\n dim = i;\n break;\n }\n }\n\n //find nodes\n std::vector nodes_x, nodes_y;\n for (int i = 0; i < N - 1; ++i) {\n if (U(i, dim - 1) * U(i + 1, dim - 1) < 0.0) {\n nodes_x.push_back(0.5 * (x_vec[i] + x_vec[i + 1]));\n }\n if (V(i, dim - 1) * V(i+1, dim - 1) < 0.0) {\n nodes_y.push_back(0.5 * (y_vec[i] + y_vec[i + 1]));\n }\n }\n\n if (nodes_x.size() != dim - 1 || nodes_y.size() != dim - 1) {\n std::cerr << \"The number of nodes for x is \" << nodes_x.size() << \" , which is different from l \" << dim-1 << std::endl;\n std::cerr << \"The number of nodes for y is \" << nodes_y.size() << \" , which is different from l \" << dim-1 << std::endl;\n for (auto n : nodes_y) {\n std::cout << n << std::endl;\n }\n throw std::runtime_error(\"The number of nodes is wrong.\");\n }\n\n return std::make_pair(nodes_x, nodes_y);\n }\n\n/**\n * Compute \\int_{-1}^1 dx exp(i w x) p(x)\n**/\n/*\n inline std::vector>\n compute_Tnl_impl(const std::vector>& p,\n std::vector& w_vec,\n int digits) {\n auto prec_bak = mpfr::mpreal::get_default_prec();\n\n mpfr::mpreal::set_default_prec(mpfr::digits2bits(digits));\n\n int num_local_nodes = 24;\n auto local_nodes = detail::gauss_legendre_nodes(num_local_nodes);\n std::vector section_edges = p.section_edges();\n auto global_nodes = composite_gauss_legendre_nodes(section_edges, local_nodes);\n auto n_local_nodes = local_nodes.size();\n\n std::vector values(global_nodes.size());\n for (int n=0; n deriv_values_left(num_sections*n_poly), deriv_values_left(num_sections*n_poly);\n for (int s=0; s> result(w_vec.size());\n for (int i=0; i < w_vec.size(); ++i) {\n result[i] = 0;\n\n for (int s = 0; s < p.num_sections(); ++s) {\n mpreal x0 = p.section_edge(s);\n mpreal x1 = p.section_edge(s+1);\n\n if (w * (x1-x0) < 0.1 * const_pi()){\n std::complex tmp(0);\n for (int n = 0; n < n_local_nodes; ++n) {\n tmp += values(s*n_local_nodes + n) * my_exp(w*x_smpl) * global_nodes[s*n_local_nodes + n].second;\n }\n result[i] += tmp;\n } else {\n std::complex Jk(0, 0);\n std::complex iw(0, w);\n std::complex exp0 = my_exp(w*x0);\n std::complex exp_tmp = my_exp(w*(x1-x0));\n\n //p contains x^0, x^1, xj^2, ..., x^K (K = p.order())\n for (int k=p.order(); k >= 0; --k) {\n mpreal f0 = deriv_values_left[k + s*n_poly];\n mpreal f1 = deriv_values_right[k + s*n_poly];\n Jk = ((exp_tmp * f1 - f0) * exp0 - Jk)/iw;\n }\n result[i] += Jk;\n }\n }\n\n if (even) {\n result[i] = mpfr::sqrt(2) * result[i].real() * my_exp(w);\n } else {\n result[i] = mpfr::sqrt(2) * std::complex(0, result[i].imag()) * my_exp(w);\n }\n }\n\n mpfr::mpreal::set_default_prec(prec_bak);\n\n return result;\n }\n */\n\n\n inline std::complex compute_Tnl_tail(const piecewise_polynomial& p,\n mpreal w,\n bool l_even,\n irlib::statistics::statistics_type s,\n int num_deriv) {\n int sign_s = (s == irlib::statistics::BOSONIC ? 1 : -1);\n\n if (w == 0.0) {\n throw std::runtime_error(\"Error zero frequency\");\n }\n\n std::complex result(0);\n std::complex fact(0, 1/w);\n std::complex coeff(fact);\n int sign_l = l_even ? 1 : -1;\n for (int m = 0; m < num_deriv; ++m) {\n int sign_m = m%2 == 0 ? 1 : -1;\n int sign_lm = sign_l * sign_m;\n result += -static_cast(sign_s) * coeff * static_cast(1 - sign_s * sign_lm) * p.derivative(1, m);\n coeff *= fact;\n }\n\n return result/mpfr::sqrt(2);\n }\n\n/**\n * Compute \\int_{-1}^1 dx exp(i w x) p(x)\n**/\n inline std::complex compute_Tnl_impl(const piecewise_polynomial& p, bool even,\n irlib::statistics::statistics_type s, mpreal w,\n int digits_A = 30, int digits_B = 30) {\n auto prec_bak = mpfr::mpreal::get_default_prec();\n\n int num_local_nodes = 24;\n auto local_nodes = detail::gauss_legendre_nodes(num_local_nodes);\n std::vector section_edges = p.section_edges();\n auto global_nodes = composite_gauss_legendre_nodes(section_edges, local_nodes);\n auto n_local_nodes = local_nodes.size();\n\n std::complex result(0);\n for (int s = 0; s < p.num_sections(); ++s) {\n mpreal x0 = p.section_edge(s);\n mpreal x1 = p.section_edge(s+1);\n\n if (w * (x1-x0) < 0.1 * const_pi()){\n // using low-frequency formula (Gauss-Legendre quadrature)\n mpfr::mpreal::set_default_prec(mpfr::digits2bits(digits_A));\n std::complex tmp(0);\n for (int n = 0; n < n_local_nodes; ++n) {\n auto x_smpl = global_nodes[s*n_local_nodes + n].first;\n tmp += p.compute_value(x_smpl) * my_exp(w*x_smpl) * global_nodes[s*n_local_nodes + n].second;\n }\n result += tmp;\n } else {\n // using low-frequency formula (Gauss-Legendre quadrature)\n mpfr::mpreal::set_default_prec(mpfr::digits2bits(digits_B));\n std::complex Jk(0, 0);\n std::complex iw(0, w);\n std::complex exp0 = my_exp(w*x0);\n std::complex exp_tmp = my_exp(w*(x1-x0));\n\n //p contains x^0, x^1, xj^2, ..., x^K (K = p.order())\n for (int k=p.order(); k >= 0; --k) {\n mpreal f0 = p.derivative(x0, k, s);\n mpreal f1 = p.derivative(x1, k, s);\n Jk = ((exp_tmp * f1 - f0) * exp0 - Jk)/iw;\n }\n result += Jk;\n }\n }\n\n if (even) {\n result = mpfr::sqrt(2) * result.real() * my_exp(w);\n } else {\n result = mpfr::sqrt(2) * std::complex(0, result.imag()) * my_exp(w);\n }\n\n // replace with tail\n if (w != 0.0) {\n int num_deriv = p.order()+1;\n auto tail_full = compute_Tnl_tail(p, w, even, s, num_deriv);\n auto tail_two_less = compute_Tnl_tail(p, w, even, s, num_deriv-2);\n if (std::abs((tail_full-tail_two_less)/tail_full) < 1e-12) {\n result = tail_full;\n }\n }\n\n mpfr::mpreal::set_default_prec(prec_bak);\n\n return result;\n }\n\n}\n", "meta": {"hexsha": "cb6ef93bcc9e993dc4de8034e2c174c35c784b0c", "size": 51351, "ext": "ipp", "lang": "C++", "max_stars_repo_path": "c++/include/irlib/detail/basis_impl.ipp", "max_stars_repo_name": "dombrno/irlib", "max_stars_repo_head_hexsha": "c081ac6af6d0f80424e6f3651f02ce5028942e0e", "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": "c++/include/irlib/detail/basis_impl.ipp", "max_issues_repo_name": "dombrno/irlib", "max_issues_repo_head_hexsha": "c081ac6af6d0f80424e6f3651f02ce5028942e0e", "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": "c++/include/irlib/detail/basis_impl.ipp", "max_forks_repo_name": "dombrno/irlib", "max_forks_repo_head_hexsha": "c081ac6af6d0f80424e6f3651f02ce5028942e0e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.6901743265, "max_line_length": 184, "alphanum_fraction": 0.5223656793, "num_tokens": 13792, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8596637612961506, "lm_q2_score": 0.6297746004557471, "lm_q1q2_score": 0.541394401796568}} {"text": "#include \n#include \n#include \n#include \n#include \n\nnamespace\n{\n inline Eigen::Matrix3d convert_vector_to_cross_operator(const Eigen::Vector3d& vec)\n {\n Eigen::Matrix3d mat = Eigen::Matrix3d::Zero();\n mat(0, 1) = + vec(2);\n mat(0, 2) = - vec(1);\n mat(1, 0) = - vec(2);\n mat(1, 2) = + vec(0);\n mat(2, 0) = + vec(1);\n mat(2, 1) = - vec(0);\n return mat;\n };\n\n inline double calculateCotTheta(const Eigen::Vector3d& x, const Eigen::Vector3d& y)\n {\n const double cos_theta = x.dot(y);\n const double sin_theta = x.cross(y).norm();\n return cos_theta / sin_theta;\n }\n\n template\n void projectPositions(const double C,\n const Eigen::Matrix& grad_C,\n const Eigen::Matrix& inv_M,\n const double stiffness,\n std::vector>& particles)\n {\n // Skip if the gradient is sufficiently small\n if (grad_C.isApprox(Eigen::Matrix::Zero())) { return; }\n\n // Calculate $s$\n const double s = C / (grad_C.transpose() * inv_M.asDiagonal() * grad_C);\n\n // Calculate $\\Delta x$\n const Eigen::Matrix delta_x = - s * inv_M.asDiagonal() * grad_C;\n assert(!delta_x.hasNaN());\n\n // Update predicted positions\n for (unsigned int j = 0; j < Num; ++ j)\n {\n particles[j]->p += stiffness * delta_x.segment(3 * j, 3);\n }\n }\n\n template\n Eigen::Matrix constructInverseMassMatrix(const std::vector>& particles)\n {\n Eigen::Matrix inv_M;\n for (unsigned int j = 0; j < Num; ++ j)\n {\n inv_M(j * 3 + 0) = particles[j]->w;\n inv_M(j * 3 + 1) = particles[j]->w;\n inv_M(j * 3 + 2) = particles[j]->w;\n }\n return inv_M;\n }\n}\n\nelasty::BendingConstraint::BendingConstraint(const std::shared_ptr p_0,\n const std::shared_ptr p_1,\n const std::shared_ptr p_2,\n const std::shared_ptr p_3,\n const double stiffness,\n const double dihedral_angle) :\nConstraint(std::vector>{ p_0, p_1, p_2, p_3 }, stiffness),\nm_dihedral_angle(dihedral_angle)\n{\n}\n\nvoid elasty::BendingConstraint::projectParticles()\n{\n const double C = calculateValue();\n\n Eigen::Matrix grad_C;\n calculateGrad(grad_C.data());\n\n projectPositions<4>(C, grad_C, m_inv_M, m_stiffness, m_particles);\n}\n\ndouble elasty::BendingConstraint::calculateValue()\n{\n const Eigen::Vector3d& x_0 = m_particles[0]->p;\n const Eigen::Vector3d& x_1 = m_particles[1]->p;\n const Eigen::Vector3d& x_2 = m_particles[2]->p;\n const Eigen::Vector3d& x_3 = m_particles[3]->p;\n\n const Eigen::Vector3d p_10 = x_1 - x_0;\n const Eigen::Vector3d p_20 = x_2 - x_0;\n const Eigen::Vector3d p_30 = x_3 - x_0;\n\n const Eigen::Vector3d n_0 = p_10.cross(p_20).normalized();\n const Eigen::Vector3d n_1 = p_10.cross(p_30).normalized();\n\n assert(!n_0.hasNaN());\n assert(!n_1.hasNaN());\n\n const double current_dihedral_angle = std::acos(std::min(+ 1.0, std::max(- 1.0, n_0.dot(n_1))));\n\n assert(!std::isnan(current_dihedral_angle));\n\n return current_dihedral_angle - m_dihedral_angle;\n}\n\nvoid elasty::BendingConstraint::calculateGrad(double* grad_C)\n{\n const Eigen::Vector3d& x_0 = m_particles[0]->p;\n const Eigen::Vector3d& x_1 = m_particles[1]->p;\n const Eigen::Vector3d& x_2 = m_particles[2]->p;\n const Eigen::Vector3d& x_3 = m_particles[3]->p;\n\n // Assuming that p_0 = [ 0, 0, 0 ]^T without loss of generality\n const Eigen::Vector3d p_1 = x_1 - x_0;\n const Eigen::Vector3d p_2 = x_2 - x_0;\n const Eigen::Vector3d p_3 = x_3 - x_0;\n\n const Eigen::Vector3d p_1_cross_p_2 = p_1.cross(p_2);\n const Eigen::Vector3d p_1_cross_p_3 = p_1.cross(p_3);\n\n const Eigen::Vector3d n_0 = p_1_cross_p_2.normalized();\n const Eigen::Vector3d n_1 = p_1_cross_p_3.normalized();\n\n const double d = n_0.dot(n_1);\n\n // If the dihedral angle is sufficiently small, return zeros\n constexpr double epsilon = 1e-12;\n if (std::abs(d) - 1.0 < epsilon)\n {\n std::fill(grad_C, grad_C + 12, 0.0);\n return;\n }\n\n const double common_coeff = - 1.0 / std::sqrt(1.0 - d * d);\n\n auto calculate_gradient_of_normalized_cross_product_wrt_p_1 = [](const Eigen::Vector3d& p_1,\n const Eigen::Vector3d& p_2,\n const Eigen::Vector3d& n)\n -> Eigen::Matrix3d\n {\n return + (1.0 / p_1.cross(p_2).norm()) * (- convert_vector_to_cross_operator(p_2) + n * (n.cross(p_2)).transpose());\n };\n\n auto calculate_gradient_of_normalized_cross_product_wrt_p_2 = [](const Eigen::Vector3d& p_1,\n const Eigen::Vector3d& p_2,\n const Eigen::Vector3d& n)\n -> Eigen::Matrix3d\n {\n return - (1.0 / p_1.cross(p_2).norm()) * (- convert_vector_to_cross_operator(p_1) + n * (n.cross(p_1)).transpose());\n };\n\n const Eigen::Vector3d grad_C_wrt_p_1 = common_coeff * (calculate_gradient_of_normalized_cross_product_wrt_p_1(n_0, p_1, p_2).transpose() * n_1 + calculate_gradient_of_normalized_cross_product_wrt_p_1(n_1, p_1, p_3).transpose() * n_0);\n const Eigen::Vector3d grad_C_wrt_p_2 = common_coeff * calculate_gradient_of_normalized_cross_product_wrt_p_2(n_0, p_1, p_2).transpose() * n_1;\n const Eigen::Vector3d grad_C_wrt_p_3 = common_coeff * calculate_gradient_of_normalized_cross_product_wrt_p_2(n_1, p_1, p_3).transpose() * n_0;\n const Eigen::Vector3d grad_C_wrt_p_0 = - grad_C_wrt_p_1 - grad_C_wrt_p_2 - grad_C_wrt_p_3;\n\n std::memcpy(grad_C + (3 * 0), grad_C_wrt_p_0.data(), sizeof(double) * 3);\n std::memcpy(grad_C + (3 * 1), grad_C_wrt_p_1.data(), sizeof(double) * 3);\n std::memcpy(grad_C + (3 * 2), grad_C_wrt_p_2.data(), sizeof(double) * 3);\n std::memcpy(grad_C + (3 * 3), grad_C_wrt_p_3.data(), sizeof(double) * 3);\n}\n\nelasty::DistanceConstraint::DistanceConstraint(const std::shared_ptr p_0,\n const std::shared_ptr p_1,\n const double stiffness,\n const double d) :\nConstraint(std::vector>{ p_0, p_1 }, stiffness),\nm_inv_M(constructInverseMassMatrix<2>(m_particles)),\nm_d(d)\n{\n assert(d >= 0.0);\n}\n\nvoid elasty::DistanceConstraint::projectParticles()\n{\n const double C = calculateValue();\n\n Eigen::Matrix grad_C;\n calculateGrad(grad_C.data());\n\n projectPositions<2>(C, grad_C, m_inv_M, m_stiffness, m_particles);\n}\n\ndouble elasty::DistanceConstraint::calculateValue()\n{\n const Eigen::Vector3d& x_0 = m_particles[0]->p;\n const Eigen::Vector3d& x_1 = m_particles[1]->p;\n\n return (x_0 - x_1).norm() - m_d;\n}\n\nvoid elasty::DistanceConstraint::calculateGrad(double* grad_C)\n{\n const Eigen::Vector3d& x_0 = m_particles[0]->p;\n const Eigen::Vector3d& x_1 = m_particles[1]->p;\n\n Eigen::Vector3d n = (x_0 - x_1).normalized();\n\n if (n.hasNaN()) { n = Eigen::Vector3d::Random(3).normalized(); }\n\n grad_C[0] = + n(0);\n grad_C[1] = + n(1);\n grad_C[2] = + n(2);\n grad_C[3] = - n(0);\n grad_C[4] = - n(1);\n grad_C[5] = - n(2);\n}\n\nelasty::EnvironmentalCollisionConstraint::EnvironmentalCollisionConstraint(const std::shared_ptr p_0,\n const double stiffness,\n const Eigen::Vector3d& n,\n const double d) :\nConstraint(std::vector>{ p_0 }, stiffness),\nm_inv_M(constructInverseMassMatrix<1>(m_particles)),\nm_n(n),\nm_d(d)\n{\n}\n\nvoid elasty::EnvironmentalCollisionConstraint::projectParticles()\n{\n const double C = calculateValue();\n\n if (C >= 0.0) { return; }\n\n Eigen::Vector3d grad_C;\n calculateGrad(grad_C.data());\n\n projectPositions<1>(C, grad_C, m_inv_M, m_stiffness, m_particles);\n}\n\ndouble elasty::EnvironmentalCollisionConstraint::calculateValue()\n{\n const Eigen::Vector3d& x = m_particles[0]->p;\n return m_n.transpose() * x - m_d;\n}\n\nvoid elasty::EnvironmentalCollisionConstraint::calculateGrad(double* grad_C)\n{\n std::memcpy(grad_C, m_n.data(), sizeof(double) * 3);\n}\n\nelasty::FixedPointConstraint::FixedPointConstraint(const std::shared_ptr p_0,\n const double stiffness,\n const Eigen::Vector3d& point) :\nConstraint(std::vector>{ p_0 }, stiffness),\nm_inv_M(constructInverseMassMatrix<1>(m_particles)),\nm_point(point)\n{\n}\n\nvoid elasty::FixedPointConstraint::projectParticles()\n{\n const double C = calculateValue();\n\n Eigen::Vector3d grad_C;\n calculateGrad(grad_C.data());\n\n projectPositions<1>(C, grad_C, m_inv_M, m_stiffness, m_particles);\n}\n\ndouble elasty::FixedPointConstraint::calculateValue()\n{\n const Eigen::Vector3d& x = m_particles[0]->p;\n return (x - m_point).norm();\n}\n\nvoid elasty::FixedPointConstraint::calculateGrad(double* grad_C)\n{\n const Eigen::Vector3d& x = m_particles[0]->p;\n const Eigen::Vector3d n = (x - m_point).normalized();\n\n if (n.hasNaN()) { std::fill(grad_C, grad_C + 3, 0.0); }\n\n std::memcpy(grad_C, n.data(), sizeof(double) * 3);\n}\n\nelasty::IsometricBendingConstraint::IsometricBendingConstraint(const std::shared_ptr p_0,\n const std::shared_ptr p_1,\n const std::shared_ptr p_2,\n const std::shared_ptr p_3,\n const double stiffness) :\nConstraint(std::vector>{ p_0, p_1, p_2, p_3 }, stiffness),\nm_inv_M(constructInverseMassMatrix<4>(m_particles))\n{\n const Eigen::Vector3d& x_0 = p_0->x;\n const Eigen::Vector3d& x_1 = p_1->x;\n const Eigen::Vector3d& x_2 = p_2->x;\n const Eigen::Vector3d& x_3 = p_3->x;\n\n const Eigen::Vector3d e0 = x_1 - x_0;\n const Eigen::Vector3d e1 = x_2 - x_1;\n const Eigen::Vector3d e2 = x_0 - x_2;\n const Eigen::Vector3d e3 = x_3 - x_0;\n const Eigen::Vector3d e4 = x_1 - x_3;\n\n const double cot_01 = calculateCotTheta(e0, - e1);\n const double cot_02 = calculateCotTheta(e0, - e2);\n const double cot_03 = calculateCotTheta(e0, e3);\n const double cot_04 = calculateCotTheta(e0, e4);\n\n const Eigen::Vector4d K = Eigen::Vector4d(cot_01 + cot_04, cot_02 + cot_03, - cot_01 - cot_02, - cot_03 - cot_04);\n\n const double A_0 = 0.5 * e0.cross(e1).norm();\n const double A_1 = 0.5 * e0.cross(e3).norm();\n\n m_Q = (3.0 / (A_0 + A_1)) * K * K.transpose();\n}\n\nvoid elasty::IsometricBendingConstraint::projectParticles()\n{\n const double C = calculateValue();\n\n Eigen::Matrix grad_C;\n calculateGrad(grad_C.data());\n\n projectPositions<4>(C, grad_C, m_inv_M, m_stiffness, m_particles);\n}\n\ndouble elasty::IsometricBendingConstraint::calculateValue()\n{\n double sum = 0.0;\n for (unsigned int i = 0; i < 4; ++ i)\n {\n for (unsigned int j = 0; j < 4; ++ j)\n {\n sum += m_Q(i, j) * double(m_particles[i]->p.transpose() * m_particles[j]->p);\n }\n }\n return 0.5 * sum;\n}\n\nvoid elasty::IsometricBendingConstraint::calculateGrad(double* grad_C)\n{\n for (unsigned int i = 0; i < 4; ++ i)\n {\n Eigen::Vector3d sum = Eigen::Vector3d::Zero();\n for (unsigned int j = 0; j < 4; ++ j)\n {\n sum += m_Q(i, j) * m_particles[j]->p;\n }\n std::memcpy(grad_C + (3 * i), sum.data(), sizeof(double) * 3);\n }\n}\n", "meta": {"hexsha": "1b7ca6e27a1940cf99fb875535663143321fbc3f", "size": 12588, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/constraint.cpp", "max_stars_repo_name": "0x0c/elasty", "max_stars_repo_head_hexsha": "3995cacbefa8d7f39249e9f75fa291828e2e7c2d", "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/constraint.cpp", "max_issues_repo_name": "0x0c/elasty", "max_issues_repo_head_hexsha": "3995cacbefa8d7f39249e9f75fa291828e2e7c2d", "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/constraint.cpp", "max_forks_repo_name": "0x0c/elasty", "max_forks_repo_head_hexsha": "3995cacbefa8d7f39249e9f75fa291828e2e7c2d", "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": 35.9657142857, "max_line_length": 238, "alphanum_fraction": 0.5887353035, "num_tokens": 3594, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8596637505099168, "lm_q2_score": 0.6297746074044134, "lm_q1q2_score": 0.5413944009771885}} {"text": "#include \"problem_generator.h\"\n\n#include \n#include \n#include \n#include \n\nnamespace poselib {\n\nstatic const double kPI = 3.14159265358979323846;\n\ndouble CalibPoseValidator::compute_pose_error(const AbsolutePoseProblemInstance &instance, const CameraPose &pose,\n double scale) {\n return (instance.pose_gt.R() - pose.R()).norm() + (instance.pose_gt.t - pose.t).norm() +\n std::abs(instance.scale_gt - scale);\n}\ndouble CalibPoseValidator::compute_pose_error(const RelativePoseProblemInstance &instance, const CameraPose &pose) {\n return (instance.pose_gt.R() - pose.R()).norm() + (instance.pose_gt.t - pose.t).norm();\n}\n\nbool CalibPoseValidator::is_valid(const AbsolutePoseProblemInstance &instance, const CameraPose &pose, double scale,\n double tol) {\n\n // Point to point correspondences\n // alpha * p + lambda*x = R*X + t\n for (int i = 0; i < instance.x_point_.size(); ++i) {\n double err = 1.0 - std::abs(instance.x_point_[i].dot(\n (pose.R() * instance.X_point_[i] + pose.t - scale * instance.p_point_[i]).normalized()));\n if (err > tol)\n return false;\n }\n\n // Point to Line correspondences\n // alpha * p + lambda * x = R*(X + mu*V) + t\n for (int i = 0; i < instance.x_line_.size(); ++i) {\n // lambda * x - mu * R*V = R*X + t - alpha * p\n // x.cross(R*V).dot(R*X+t-alpha.p) = 0\n Eigen::Vector3d X = pose.R() * instance.X_line_[i] + pose.t - scale * instance.p_line_[i];\n double err = instance.x_line_[i].cross(pose.R() * instance.V_line_[i]).normalized().dot(X);\n\n if (err > tol)\n return false;\n }\n\n // Line to point correspondences\n // l'*(R*X + t - alpha*p) = 0\n for (int i = 0; i < instance.l_line_point_.size(); ++i) {\n\n Eigen::Vector3d X = pose.R() * instance.X_line_point_[i] + pose.t - scale * instance.p_line_point_[i];\n\n double err = std::abs(instance.l_line_point_[i].dot(X.normalized()));\n if (err > tol)\n return false;\n }\n\n // Line to line correspondences\n // l'*(R*(X + mu*V) + t - alpha*p) = 0\n for (int i = 0; i < instance.l_line_line_.size(); ++i) {\n\n Eigen::Vector3d X = pose.R() * instance.X_line_line_[i] + pose.t - scale * instance.p_line_line_[i];\n Eigen::Vector3d V = pose.R() * instance.V_line_line_[i];\n\n double err = std::abs(instance.l_line_line_[i].dot(X.normalized())) +\n std::abs(instance.l_line_line_[i].dot(V.normalized()));\n if (err > tol)\n return false;\n }\n\n return true;\n}\n\nbool CalibPoseValidator::is_valid(const RelativePoseProblemInstance &instance, const CameraPose &pose, double tol) {\n if ((pose.R().transpose() * pose.R() - Eigen::Matrix3d::Identity()).norm() > tol)\n return false;\n\n // Point to point correspondences\n // R * (alpha * p1 + lambda1 * x1) + t = alpha * p2 + lambda2 * x2\n //\n // cross(R*x1, x2)' * (alpha * p2 - t - alpha * R*p1) = 0\n for (int i = 0; i < instance.x1_.size(); ++i) {\n double err = std::abs(instance.x2_[i]\n .cross(pose.R() * instance.x1_[i])\n .normalized()\n .dot(pose.R() * instance.p1_[i] + pose.t - instance.p2_[i]));\n if (err > tol)\n return false;\n }\n\n return true;\n}\n\ndouble HomographyValidator::compute_pose_error(const RelativePoseProblemInstance &instance, const Eigen::Matrix3d &H) {\n double err1 = (H.normalized() - instance.H_gt.normalized()).norm();\n double err2 = (H.normalized() + instance.H_gt.normalized()).norm();\n return std::min(err1, err2);\n}\n\nbool HomographyValidator::is_valid(const RelativePoseProblemInstance &instance, const Eigen::Matrix3d &H, double tol) {\n\n for (int i = 0; i < instance.x1_.size(); ++i) {\n Eigen::Vector3d z = H * instance.x1_[i];\n double err = 1.0 - std::abs(z.normalized().dot(instance.x2_[i].normalized()));\n if (err > tol)\n return false;\n }\n\n return true;\n}\n\ndouble UnknownFocalValidator::compute_pose_error(const AbsolutePoseProblemInstance &instance, const CameraPose &pose,\n double focal) {\n return (instance.pose_gt.R() - pose.R()).norm() + (instance.pose_gt.t - pose.t).norm() +\n std::abs(instance.focal_gt - focal);\n}\n\nbool UnknownFocalValidator::is_valid(const AbsolutePoseProblemInstance &instance, const CameraPose &pose, double focal,\n double tol) {\n if ((pose.R().transpose() * pose.R() - Eigen::Matrix3d::Identity()).norm() > tol)\n return false;\n\n if (focal < 0)\n return false;\n\n Eigen::Matrix3d Kinv;\n Kinv.setIdentity();\n Kinv(2, 2) = focal;\n // lambda*diag(1,1,alpha)*x = R*X + t\n for (int i = 0; i < instance.x_point_.size(); ++i) {\n double err = 1.0 - std::abs((Kinv * instance.x_point_[i])\n .normalized()\n .dot((pose.R() * instance.X_point_[i] + pose.t).normalized()));\n if (err > tol)\n return false;\n }\n\n return true;\n}\n\ndouble RadialPoseValidator::compute_pose_error(const AbsolutePoseProblemInstance &instance, const CameraPose &pose,\n double scale) {\n // Only compute up to sign for radial cameras\n\n double err1 = (instance.pose_gt.R().topRows(2) - pose.R().topRows(2)).norm() +\n (instance.pose_gt.t.topRows(2) - pose.t.topRows(2)).norm();\n double err2 = (instance.pose_gt.R().topRows(2) + pose.R().topRows(2)).norm() +\n (instance.pose_gt.t.topRows(2) + pose.t.topRows(2)).norm();\n\n return std::min(err1, err2);\n}\n\nbool RadialPoseValidator::is_valid(const AbsolutePoseProblemInstance &instance, const CameraPose &pose, double scale,\n double tol) {\n if ((pose.R().transpose() * pose.R() - Eigen::Matrix3d::Identity()).norm() > tol)\n return false;\n\n // Point to point correspondences -- Convert these to line correspondences\n // alpha * p + lambda*x = R*X + t\n for (int i = 0; i < instance.x_point_.size(); ++i) {\n Eigen::Vector3d radial_line{-instance.x_point_[i](1), instance.x_point_[i](0), 0.0};\n Eigen::Vector3d X = pose.R() * instance.X_point_[i] + pose.t;\n double err = std::abs(radial_line.dot(X.normalized()));\n if (err > tol)\n return false;\n }\n\n // Line to point correspondences\n // l'*(R*X + t) = 0\n for (int i = 0; i < instance.l_line_point_.size(); ++i) {\n Eigen::Vector3d X = pose.R() * instance.X_line_point_[i] + pose.t;\n\n double err = std::abs(instance.l_line_point_[i].dot(X.normalized()));\n if (err > tol)\n return false;\n }\n\n return true;\n}\n\nvoid set_random_pose(CameraPose &pose, bool upright, bool planar) {\n if (upright) {\n Eigen::Vector2d r;\n r.setRandom().normalize();\n Eigen::Matrix3d R;\n R << r(0), 0.0, r(1), 0.0, 1.0, 0.0, -r(1), 0.0, r(0); // y-gravity\n // pose.R << r(0), r(1), 0.0, -r(1), r(0), 0.0, 0.0, 0.0, 1.0; // z-gravity\n pose.q = rotmat_to_quat(R);\n } else {\n pose.q = Eigen::Quaternion::UnitRandom().coeffs();\n }\n pose.t.setRandom();\n if (planar) {\n pose.t.y() = 0;\n }\n}\n\nvoid generate_abspose_problems(int n_problems, std::vector *problem_instances,\n const ProblemOptions &options) {\n problem_instances->clear();\n problem_instances->reserve(n_problems);\n\n double fov_scale = std::tan(options.camera_fov_ / 2.0 * kPI / 180.0);\n\n // Random generators\n std::default_random_engine random_engine;\n std::uniform_real_distribution depth_gen(options.min_depth_, options.max_depth_);\n std::uniform_real_distribution coord_gen(-fov_scale, fov_scale);\n std::uniform_real_distribution scale_gen(options.min_scale_, options.max_scale_);\n std::uniform_real_distribution focal_gen(options.min_focal_, options.max_focal_);\n std::normal_distribution direction_gen(0.0, 1.0);\n std::normal_distribution offset_gen(0.0, 1.0);\n\n for (int i = 0; i < n_problems; ++i) {\n AbsolutePoseProblemInstance instance;\n set_random_pose(instance.pose_gt, options.upright_, options.planar_);\n\n if (options.unknown_scale_) {\n instance.scale_gt = scale_gen(random_engine);\n }\n if (options.unknown_focal_) {\n instance.focal_gt = focal_gen(random_engine);\n }\n\n // Point to point correspondences\n instance.x_point_.reserve(options.n_point_point_);\n instance.X_point_.reserve(options.n_point_point_);\n instance.p_point_.reserve(options.n_point_point_);\n for (int j = 0; j < options.n_point_point_; ++j) {\n\n Eigen::Vector3d p{0.0, 0.0, 0.0};\n Eigen::Vector3d x{coord_gen(random_engine), coord_gen(random_engine), 1.0};\n x.normalize();\n Eigen::Vector3d X;\n\n if (options.generalized_) {\n p << offset_gen(random_engine), offset_gen(random_engine), offset_gen(random_engine);\n }\n\n X = instance.scale_gt * p + x * depth_gen(random_engine);\n\n X = instance.pose_gt.R().transpose() * (X - instance.pose_gt.t);\n\n if (options.unknown_focal_) {\n x.block<2, 1>(0, 0) *= instance.focal_gt;\n x.normalize();\n }\n\n instance.x_point_.push_back(x);\n instance.X_point_.push_back(X);\n instance.p_point_.push_back(p);\n }\n\n // This generates instances where the same 3D point is observed twice in a generalized camera\n // This is degenerate case for the 3Q3 based gp3p/gp4ps solver unless specifically handled.\n if (options.generalized_ && options.generalized_duplicate_obs_) {\n std::vector ind = {0, 1, 2, 3};\n assert(options.n_point_point_ >= 4);\n\n std::random_shuffle(ind.begin(), ind.end());\n instance.X_point_[ind[1]] = instance.X_point_[ind[0]];\n instance.x_point_[ind[1]] = (instance.pose_gt.R() * instance.X_point_[ind[0]] + instance.pose_gt.t -\n instance.scale_gt * instance.p_point_[ind[1]])\n .normalized();\n }\n\n // Point to line correspondences\n instance.x_line_.reserve(options.n_point_line_);\n instance.X_line_.reserve(options.n_point_line_);\n instance.V_line_.reserve(options.n_point_line_);\n instance.p_line_.reserve(options.n_point_line_);\n for (int j = 0; j < options.n_point_line_; ++j) {\n Eigen::Vector3d p{0.0, 0.0, 0.0};\n Eigen::Vector3d x{coord_gen(random_engine), coord_gen(random_engine), 1.0};\n x.normalize();\n Eigen::Vector3d X;\n\n if (options.generalized_) {\n p << offset_gen(random_engine), offset_gen(random_engine), offset_gen(random_engine);\n }\n X = instance.scale_gt * p + x * depth_gen(random_engine);\n X = instance.pose_gt.R().transpose() * (X - instance.pose_gt.t);\n\n Eigen::Vector3d V{direction_gen(random_engine), direction_gen(random_engine), direction_gen(random_engine)};\n V.normalize();\n\n // Translate X such that X.dot(V) = 0\n X = X - V.dot(X) * V;\n\n if (options.unknown_focal_) {\n // TODO implement this.\n }\n\n instance.x_line_.push_back(x);\n instance.X_line_.push_back(X);\n instance.V_line_.push_back(V);\n instance.p_line_.push_back(p);\n }\n\n // Line to point correspondences\n instance.l_line_point_.reserve(options.n_line_point_);\n instance.X_line_point_.reserve(options.n_line_point_);\n instance.p_line_point_.reserve(options.n_line_point_);\n for (int j = 0; j < options.n_line_point_; ++j) {\n Eigen::Vector3d p{0.0, 0.0, 0.0};\n Eigen::Vector3d x{coord_gen(random_engine), coord_gen(random_engine), 1.0};\n x.normalize();\n Eigen::Vector3d X;\n\n if (options.generalized_) {\n p << offset_gen(random_engine), offset_gen(random_engine), offset_gen(random_engine);\n }\n X = instance.scale_gt * p + x * depth_gen(random_engine);\n X = instance.pose_gt.R().transpose() * (X - instance.pose_gt.t);\n\n // Cross product with random vector to generate line\n Eigen::Vector3d l;\n if (options.radial_lines_) {\n // Line passing through image center\n l = x.cross(Eigen::Vector3d{0.0, 0.0, 1.0});\n } else {\n // Random line\n l = x.cross(Eigen::Vector3d(direction_gen(random_engine), direction_gen(random_engine),\n direction_gen(random_engine)));\n }\n\n l.normalize();\n\n if (options.unknown_focal_) {\n // TODO implement this.\n }\n\n instance.l_line_point_.push_back(l);\n instance.X_line_point_.push_back(X);\n instance.p_line_point_.push_back(p);\n }\n\n // Line to line correspondences\n instance.l_line_line_.reserve(options.n_line_line_);\n instance.X_line_line_.reserve(options.n_line_line_);\n instance.V_line_line_.reserve(options.n_line_line_);\n instance.p_line_line_.reserve(options.n_line_line_);\n for (int j = 0; j < options.n_line_line_; ++j) {\n Eigen::Vector3d p{0.0, 0.0, 0.0};\n Eigen::Vector3d x{coord_gen(random_engine), coord_gen(random_engine), 1.0};\n x.normalize();\n Eigen::Vector3d X;\n\n if (options.generalized_) {\n p << offset_gen(random_engine), offset_gen(random_engine), offset_gen(random_engine);\n }\n X = instance.scale_gt * p + x * depth_gen(random_engine);\n X = instance.pose_gt.R().transpose() * (X - instance.pose_gt.t);\n\n Eigen::Vector3d V{direction_gen(random_engine), direction_gen(random_engine), direction_gen(random_engine)};\n V.normalize();\n\n // Translate X such that X.dot(V) = 0\n X = X - V.dot(X) * V;\n\n Eigen::Vector3d l = x.cross(instance.pose_gt.R() * V);\n l.normalize();\n\n if (options.unknown_focal_) {\n // TODO implement this.\n }\n\n instance.l_line_line_.push_back(l);\n instance.X_line_line_.push_back(X);\n instance.V_line_line_.push_back(V);\n instance.p_line_line_.push_back(p);\n }\n\n problem_instances->push_back(instance);\n }\n}\n\nvoid generate_relpose_problems(int n_problems, std::vector *problem_instances,\n const ProblemOptions &options) {\n problem_instances->clear();\n problem_instances->reserve(n_problems);\n\n double fov_scale = std::tan(options.camera_fov_ / 2.0 * kPI / 180.0);\n\n // Random generators\n std::default_random_engine random_engine;\n std::uniform_real_distribution depth_gen(options.min_depth_, options.max_depth_);\n std::uniform_real_distribution coord_gen(-fov_scale, fov_scale);\n std::uniform_real_distribution scale_gen(options.min_scale_, options.max_scale_);\n std::uniform_real_distribution focal_gen(options.min_focal_, options.max_focal_);\n std::normal_distribution direction_gen(0.0, 1.0);\n std::normal_distribution offset_gen(0.0, 1.0);\n\n for (int i = 0; i < n_problems; ++i) {\n RelativePoseProblemInstance instance;\n set_random_pose(instance.pose_gt, options.upright_, options.planar_);\n\n if (options.unknown_scale_) {\n instance.scale_gt = scale_gen(random_engine);\n }\n if (options.unknown_focal_) {\n instance.focal_gt = focal_gen(random_engine);\n }\n\n if (!options.generalized_) {\n instance.pose_gt.t.normalize();\n }\n\n // Point to point correspondences\n instance.p1_.reserve(options.n_point_point_);\n instance.x1_.reserve(options.n_point_point_);\n instance.p2_.reserve(options.n_point_point_);\n instance.x2_.reserve(options.n_point_point_);\n\n for (int j = 0; j < options.n_point_point_; ++j) {\n\n Eigen::Vector3d p1{0.0, 0.0, 0.0};\n Eigen::Vector3d p2{0.0, 0.0, 0.0};\n Eigen::Vector3d x1{coord_gen(random_engine), coord_gen(random_engine), 1.0};\n x1.normalize();\n Eigen::Vector3d X;\n\n if (options.generalized_) {\n p1 << offset_gen(random_engine), offset_gen(random_engine), offset_gen(random_engine);\n p2 << offset_gen(random_engine), offset_gen(random_engine), offset_gen(random_engine);\n\n if (j > 0 && j < options.generalized_first_cam_obs_) {\n p1 = instance.p1_[0];\n p2 = instance.p2_[0];\n }\n }\n\n X = instance.scale_gt * p1 + x1 * depth_gen(random_engine);\n // Map into second image\n X = instance.pose_gt.R() * X + instance.pose_gt.t;\n\n Eigen::Vector3d x2 = (X - instance.scale_gt * p2).normalized();\n\n if (options.unknown_focal_) {\n // NYI\n assert(false);\n }\n\n // TODO: ensure FoV of second cameras as well...\n\n instance.p1_.push_back(p1);\n instance.x1_.push_back(x1);\n instance.p2_.push_back(p2);\n instance.x2_.push_back(x2);\n }\n\n problem_instances->push_back(instance);\n }\n}\n\nvoid generate_homography_problems(int n_problems, std::vector *problem_instances,\n const ProblemOptions &options) {\n problem_instances->clear();\n problem_instances->reserve(n_problems);\n\n double fov_scale = std::tan(options.camera_fov_ / 2.0 * kPI / 180.0);\n\n // Random generators\n std::default_random_engine random_engine;\n std::uniform_real_distribution depth_gen(options.min_depth_, options.max_depth_);\n std::uniform_real_distribution coord_gen(-fov_scale, fov_scale);\n std::uniform_real_distribution scale_gen(options.min_scale_, options.max_scale_);\n std::uniform_real_distribution focal_gen(options.min_focal_, options.max_focal_);\n std::normal_distribution direction_gen(0.0, 1.0);\n std::normal_distribution offset_gen(0.0, 1.0);\n\n while (problem_instances->size() < n_problems) {\n RelativePoseProblemInstance instance;\n set_random_pose(instance.pose_gt, options.upright_, options.planar_);\n\n if (options.unknown_scale_) {\n instance.scale_gt = scale_gen(random_engine);\n }\n if (options.unknown_focal_) {\n instance.focal_gt = focal_gen(random_engine);\n }\n\n if (!options.generalized_) {\n instance.pose_gt.t.normalize();\n }\n\n // Point to point correspondences\n instance.x1_.reserve(options.n_point_point_);\n instance.x2_.reserve(options.n_point_point_);\n\n // Generate plane\n Eigen::Vector3d n;\n n << direction_gen(random_engine), direction_gen(random_engine), direction_gen(random_engine);\n n.normalize();\n\n // Choose depth of plane such that center point of image 1 is at depth d\n double d_center = depth_gen(random_engine);\n double alpha = d_center / n(2);\n // plane is n'*X = alpha\n\n // ground truth homography\n instance.H_gt = alpha * instance.pose_gt.R() + instance.pose_gt.t * n.transpose();\n\n bool failed_instance = false;\n for (int j = 0; j < options.n_point_point_; ++j) {\n bool point_okay = false;\n for (int trials = 0; trials < 10; ++trials) {\n Eigen::Vector3d x1{coord_gen(random_engine), coord_gen(random_engine), 1.0};\n x1.normalize();\n Eigen::Vector3d X;\n\n // compute depth\n double lambda = alpha / n.dot(x1);\n X = x1 * lambda;\n // Map into second image\n X = instance.pose_gt.R() * X + instance.pose_gt.t;\n\n Eigen::Vector3d x2 = X.normalized();\n\n // Check cheirality\n if (x2(2) < 0 || lambda < 0) {\n // try to generate another point\n continue;\n }\n\n // Check FoV of second camera\n Eigen::Vector2d x2h = x2.hnormalized();\n if (x2h(0) < -fov_scale || x2h(0) > fov_scale || x2h(1) < -fov_scale || x2h(1) > fov_scale) {\n // try to generate another point\n continue;\n }\n\n if (options.generalized_) {\n // NYI\n assert(false);\n }\n if (options.unknown_focal_) {\n // NYI\n assert(false);\n }\n\n instance.x1_.push_back(x1);\n instance.x2_.push_back(x2);\n point_okay = true;\n break;\n }\n if (!point_okay) {\n failed_instance = true;\n break;\n }\n }\n if (failed_instance) {\n continue;\n }\n\n problem_instances->push_back(instance);\n }\n}\n\n}; // namespace poselib\n", "meta": {"hexsha": "206a0ed9bb4d9955630a81a62774fe34864bddf0", "size": 21842, "ext": "cc", "lang": "C++", "max_stars_repo_path": "benchmark/problem_generator.cc", "max_stars_repo_name": "MikhailTerekhov/PoseLib", "max_stars_repo_head_hexsha": "8f1a2d92c3955bc1e2ce455d4009f9df98ceb697", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2022-03-28T12:12:59.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T12:12:59.000Z", "max_issues_repo_path": "benchmark/problem_generator.cc", "max_issues_repo_name": "wuyuanmm/PoseLib", "max_issues_repo_head_hexsha": "35cf8989ddbe721209e8d314eaa94447ab2bd504", "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": "benchmark/problem_generator.cc", "max_forks_repo_name": "wuyuanmm/PoseLib", "max_forks_repo_head_hexsha": "35cf8989ddbe721209e8d314eaa94447ab2bd504", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.0733452594, "max_line_length": 120, "alphanum_fraction": 0.5820895522, "num_tokens": 5234, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8596637469145054, "lm_q2_score": 0.6297746074044134, "lm_q1q2_score": 0.5413943987128896}} {"text": "#ifndef HOPS_DIKINPROPOSAL_HPP\n#define HOPS_DIKINPROPOSAL_HPP\n\n#include \n#include \"DikinEllipsoidCalculator.hpp\"\n#include \"../../RandomNumberGenerator/RandomNumberGenerator.hpp\"\n#include \n\nnamespace hops {\n template\n class DikinProposal {\n public:\n using StateType = VectorType;\n\n /**\n * @brief Constructs Gaussian Dikin proposal mechanism on polytope defined as Ax stateCholeskyOfDikinEllipsoid;\n Eigen::Matrix proposalCholeskyOfDikinEllipsoid;\n\n typename MatrixType::Scalar stepSize = 0.075; // value from dikin walk publication\n typename MatrixType::Scalar geometricFactor;\n typename MatrixType::Scalar covarianceFactor;\n constexpr static typename MatrixType::Scalar boundaryCushion = 0;\n\n std::normal_distribution normalDistribution{0., 1.};\n DikinEllipsoidCalculator dikinEllipsoidCalculator;\n };\n\n template\n DikinProposal::DikinProposal(MatrixType A,\n VectorType b,\n VectorType currentState) :\n A(std::move(A)),\n b(std::move(b)),\n dikinEllipsoidCalculator(this->A, this->b) {\n setStepSize(1.);\n setState(std::move(currentState));\n proposal = state;\n }\n\n template\n void DikinProposal::propose(RandomNumberGenerator &randomNumberGenerator) {\n for (long i = 0; i < proposal.rows(); ++i) {\n proposal(i) = normalDistribution(randomNumberGenerator);\n }\n proposal = state + covarianceFactor *\n stateCholeskyOfDikinEllipsoid.template triangularView().solve(proposal);\n }\n\n template\n void DikinProposal::acceptProposal() {\n state.swap(proposal);\n stateCholeskyOfDikinEllipsoid = std::move(proposalCholeskyOfDikinEllipsoid);\n stateLogSqrtDeterminant = proposalLogSqrtDeterminant;\n }\n\n template\n typename MatrixType::Scalar\n DikinProposal::computeLogAcceptanceProbability() {\n bool isProposalInteriorPoint = ((A * proposal - b).array() < -boundaryCushion).all();\n if (!isProposalInteriorPoint) {\n return -std::numeric_limits::infinity();\n }\n\n auto choleskyResult = dikinEllipsoidCalculator.computeCholeskyFactorOfDikinEllipsoid(proposal);\n if (!choleskyResult.first) {\n return -std::numeric_limits::infinity();\n }\n proposalCholeskyOfDikinEllipsoid = std::move(choleskyResult.second);\n\n proposalLogSqrtDeterminant = proposalCholeskyOfDikinEllipsoid.diagonal().array().log().sum();\n VectorType stateDifference = state - proposal;\n\n return proposalLogSqrtDeterminant\n - stateLogSqrtDeterminant\n + geometricFactor * ((stateCholeskyOfDikinEllipsoid * stateDifference).squaredNorm()\n - (proposalCholeskyOfDikinEllipsoid * stateDifference).squaredNorm()\n );\n }\n\n template\n typename DikinProposal::StateType\n DikinProposal::getState() const {\n return state;\n }\n\n template\n void DikinProposal::setState(StateType newState) {\n state.swap(newState);\n auto choleskyResult = dikinEllipsoidCalculator.computeCholeskyFactorOfDikinEllipsoid(state);\n if (!choleskyResult.first) {\n throw std::runtime_error(\"Could not compute cholesky factorization for newState.\");\n }\n stateCholeskyOfDikinEllipsoid = std::move(choleskyResult.second);\n stateLogSqrtDeterminant = stateCholeskyOfDikinEllipsoid.diagonal().array().log().sum();\n }\n\n template\n typename DikinProposal::StateType\n DikinProposal::getProposal() const {\n return proposal;\n }\n\n template\n typename MatrixType::Scalar DikinProposal::getStepSize() const {\n return stepSize;\n }\n\n template\n void DikinProposal::setStepSize(typename MatrixType::Scalar newStepSize) {\n stepSize = newStepSize;\n geometricFactor = A.cols() / (2 * stepSize);\n covarianceFactor = std::sqrt(stepSize / A.cols());\n }\n\n template\n std::string DikinProposal::getName() {\n return \"Dikin Walk\";\n }\n}\n\n#endif //HOPS_DIKINPROPOSAL_HPP\n", "meta": {"hexsha": "4497eab320a60008549b234893de2e93c8d9a4ea", "size": 6120, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/hops/MarkovChain/Proposal/DikinProposal.hpp", "max_stars_repo_name": "modsim/hops", "max_stars_repo_head_hexsha": "4285dd75a07dd844295440a0756b3ba25f5819ac", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2020-11-26T05:13:03.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-12T02:08:40.000Z", "max_issues_repo_path": "include/hops/MarkovChain/Proposal/DikinProposal.hpp", "max_issues_repo_name": "modsim/hops", "max_issues_repo_head_hexsha": "4285dd75a07dd844295440a0756b3ba25f5819ac", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-02-20T23:16:34.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-20T23:16:34.000Z", "max_forks_repo_path": "include/hops/MarkovChain/Proposal/DikinProposal.hpp", "max_forks_repo_name": "modsim/hops", "max_forks_repo_head_hexsha": "4285dd75a07dd844295440a0756b3ba25f5819ac", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.4838709677, "max_line_length": 116, "alphanum_fraction": 0.6825163399, "num_tokens": 1373, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430645886583, "lm_q2_score": 0.6513548511303336, "lm_q1q2_score": 0.5413690671031548}} {"text": "#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \"SpaceAdaptiveSolver.hpp\"\r\n#include \"TriDiagMatrix.hpp\"\r\n#include \"MassMatrix.hpp\"\r\n#include \"StiffnessMatrix.hpp\"\r\n#include \r\n#include \r\n#include \r\nusing namespace std;\r\nusing namespace boost::math::quadrature;\r\n\r\nvoid AdaptiveSolver::SetTolerances(const double refineby, const double coarsenby)\r\n{\r\n tolerance = refineby;\r\n coarseningtol = coarsenby;\r\n}\r\n\r\nvoid AdaptiveSolver::AdaptiveSolve()\r\n{\r\nmpsmesh.PrintSpaceNodes();\r\nmpcurrenTimeStep = 0;\r\nmpcurrentMeshIndex = 0;\r\noldmesh.CopySpaceMesh(mpsmesh);\r\n\r\n//AnalyticSolutionVec();\r\n//mpPreviousSolution = mpAnalyticSolution;\r\nmppde->InitialCondition(mpsmesh, mpPreviousSolution);\r\nstiff.SetParameters(k_0, k_L, mpa);\r\n\r\nint m = mptmesh.NumberOfTimeSteps();\r\nfor(int j = 0; jFirstBoundary(mptmesh.ReadTimeStep(mpcurrenTimeStep));\r\ng_L =mppde->SecondBoundary(mptmesh.ReadTimeStep(mpcurrenTimeStep));\r\nBuildRHS();\r\nBuiltbrVec();\r\nVectorTimesScalar( br, mptmesh.ReadTimeMesh(mpcurrentMeshIndex) );\r\n\r\nAddVectors( br, mpRHS, mpRHS );\r\n\r\nLHS.MatrixSolver( mpRHS, mpx );\r\n\r\noldmesh.CopySpaceMesh(mpsmesh);\r\nmpsmesh.PrintSpaceNodes();\r\n\r\nmpPreviousSolution = mpx;\r\n\r\n BuildGradientVec(mpx, mpsmesh, FEMGradient);\r\n GradientRecoveryFunction( mpsmesh, FEMGradient, GradientRecovery );\r\n BuildErrorEstimate();\r\n PrintVector(ErrorEstimate);\r\n\r\n\r\n\r\n\r\n SaveRefinementNodes(mpNodeToInsert);\r\n PrintVector(mpNodeToInsert);\r\n\r\n if(ErrorEstimate.size()>3)\r\n {\r\n std::cout<< ErrorEstimate.size()<<\"\\n\";\r\n SaveIntervalsForCoarsening();\r\n mpsmesh.CoarsenIntervals(NodesForRemoval);\r\n }\r\n else\r\n {\r\n NodesForRemoval.clear();\r\n }\r\n\r\n mpsmesh.InsertArray( mpNodeToInsert );\r\n}\r\n std::cout<tolerance)\r\n {\r\n intervalsForRefinement.push_back(i);\r\n }\r\n }\r\n}\r\n\r\nvoid AdaptiveSolver::SaveRefinementNodes( std::vector& Nodes_to_insert )\r\n{\r\n Nodes_to_insert.clear();\r\n double midpoint;\r\n for(int i=0; itolerance)\r\n {\r\n midpoint = 0.5*(mpsmesh.ReadSpaceNode(i)+mpsmesh.ReadSpaceNode(i+1));\r\n Nodes_to_insert.push_back(midpoint);\r\n }\r\n }\r\n}\r\n\r\nvoid AdaptiveSolver::BuildRHS()\r\n{\r\nmpRHS.clear();\r\nstd::vector intervals;\r\n\r\nrefinedsmesh.CommonMesh(mpsmesh, oldmesh);\r\n\r\ndouble integral;\r\nrefinedsmesh.Range(mpsmesh.ReadSpaceNode(0), mpsmesh.ReadSpaceNode(1), intervals);\r\n for(int j = 0; j::integrate(SolutionWithBasis, lowerlimit, upperlimit);\r\n}\r\n\r\nvoid AdaptiveSolver::UnitTest()\r\n{\r\nmpsmesh.GenerateUniformMesh(1,4);\r\noldmesh.GenerateUniformMesh(1, 4);\r\nmpPreviousSolution = {1,2,2,1};\r\n\r\n\r\nBuildRHS();\r\n\r\nMassMatrix test;\r\ntest.BuildGeneralMassMatrix(mpsmesh);\r\ntest.MatrixVectorMultiplier( mpPreviousSolution, mpRHS );\r\nPrintVector(mpRHS);\r\n\r\nmpsmesh.RemoveSpaceNode(1);\r\nmpsmesh.PrintSpaceNodes();\r\n\r\nBuildRHS();\r\n}\r\n\r\n//void AdaptiveSolver::SaveIntervalsForCoarsening2()\r\n//{\r\n// NodesForRemoval.clear();\r\n// for(int i=0; i\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace\n{\n\tclass Gaussian\n\t{\n\t\tstatic const double log2pi;\n\n\t\tsize_t n_;\n\t\tEigen::VectorXd mean_;\n\t\tEigen::MatrixXd covariance_;\n\t\tEigen::MatrixXd invCovariance_;\n\t\tdouble logdet_;\n\t\tEigen::LLT cholesky_;\n\n\t\tEigen::VectorXd tmp_;\n\n\t\tEIGEN_MAKE_ALIGNED_OPERATOR_NEW\n\t\t\n\tpublic:\n\t\tGaussian(const Eigen::VectorXd& mean, const Eigen::MatrixXd& cov)\n\t\t\t: n_(mean.size()), mean_(mean), covariance_(cov), logdet_(0)\n\t\t{\n\t\t\tinvCovariance_.resizeLike(covariance_);\n\t\t\tcomputeDetInv();\n\t\t}\n\t\tvoid computeDetInv()\n\t\t{\n\t\t\tbool invertible = true;\n\t\t\tdouble det;\n\t\t\tif (n_ == 1) {\n\t\t\t\tcovariance_.block<1, 1>(0, 0).computeInverseAndDetWithCheck(invCovariance_, det, invertible);\n\t\t\t\tlogdet_ = std::log(det);\n\t\t\t}\n\t\t\telse if (n_ == 2) {\n\t\t\t\tcovariance_.block<2, 2>(0, 0).computeInverseAndDetWithCheck(invCovariance_, det, invertible);\n\t\t\t\tlogdet_ = std::log(det);\n\t\t\t}\n\t\t\telse if (n_ == 3) {\n\t\t\t\tcovariance_.block<3, 3>(0, 0).computeInverseAndDetWithCheck(invCovariance_, det, invertible);\n\t\t\t\tlogdet_ = std::log(det);\n\t\t\t}\n\t\t\telse if (n_ == 4) {\n\t\t\t\tcovariance_.block<4, 4>(0, 0).computeInverseAndDetWithCheck(invCovariance_, det, invertible);\n\t\t\t\tlogdet_ = std::log(det);\n\t\t\t}\n\t\t\telse {\n\t\t\t\tcholesky_.compute(covariance_);\n\t\t\t\tinvertible = cholesky_.info() == Eigen::Success;\n\t\t\t\t//https://gist.github.com/redpony/fc8a0db6b20f7b1a3f23#gistcomment-2277286\n\t\t\t\tlogdet_ = cholesky_.matrixL().toDenseMatrix().diagonal().array().log().sum();\n\t\t\t}\n\t\t\tif (!invertible)\n\t\t\t{\n\t\t\t\tstd::cerr << \"Covariance is singular, re-initialize with the identity matrix\" << std::endl;\n\t\t\t\tcovariance_.setIdentity(n_, n_);\n\t\t\t\tinvCovariance_.setIdentity(n_, n_);\n\t\t\t\tlogdet_ = 0; // log(det(In))=log(1)=0\n\t\t\t}\n\t\t}\n\t\t//Returns the log-probability of x in this gaussian\n\t\tdouble logP(const Eigen::VectorXd& x)\n\t\t{\n\t\t\ttmp_ = x - mean_;\n\t\t\tdouble alpha;\n\t\t\tif (n_ <= 4)\n\t\t\t\talpha = tmp_.dot(invCovariance_*tmp_);\n\t\t\telse\n\t\t\t\talpha = tmp_.dot(cholesky_.solve(tmp_));\n\t\t\treturn -0.5 * (alpha + n_*log2pi + logdet_);\n\t\t}\n\t\t//getter+setter\n\t\tconst Eigen::VectorXd& mean() const { return mean_; }\n\t\tEigen::VectorXd& mean() { return mean_; }\n\t\tconst Eigen::MatrixXd& cov() const { return covariance_; }\n\t\tEigen::MatrixXd& cov() { return covariance_; }\n\n\t\tfriend std::ostream& operator<<(std::ostream& o, const Gaussian& g)\n\t\t{\n\t\t\to << \"Mean: \" << g.mean().transpose() << \"\\n\"\n\t\t\t\t<< \"Cov:\\n\" << g.cov();\n\t\t\treturn o;\n\t\t}\n\t};\n\tconst double Gaussian::log2pi = 1.8378770664093454835606594728112f;\n\n\ttemplate\n\tScalar LSE(const Eigen::MatrixBase& vec)\n\t{\n\t\tScalar m = vec.maxCoeff();\n\t\treturn m + std::log((vec.array() - m).exp().sum());\n\t}\n\n}\n\nvoid benchmark_Eigen(\n\tconst std::string& pointsFile,\n\tconst std::string& settingsFile,\n\tint numIterations,\n Json::Object& returnValues)\n{\n //load settings and points\n\tint dimension, components, numPoints;\n\tEigen::MatrixXd points;\n\tstd::vector logWeights;\n\tstd::vector gaussians;\n\t{ //points\n\t\tstd::ifstream in(pointsFile);\n\t\tin >> dimension >> components >> numPoints;\n\t\tpoints.resize(dimension, numPoints);\n\t\tfloat dummy; //skip ground truth\n\t\tfor (int i = 0; i < components * (1 + dimension + dimension * dimension); ++i) in >> dummy;\n\t\tfor (int i = 0; i < numPoints; ++i) { //read points\n\t\t\tEigen::VectorXd p(dimension);\n\t\t\tfor (int d = 0; d < dimension; ++d) in >> p[d];\n\t\t\tpoints.col(i) = p;\n\t\t}\n\t}\n\t{ //initial settings\n\t\tstd::ifstream in(settingsFile);\n\t\tint dummy;\n\t\tin >> dimension >> components >> dummy;\n\t\tlogWeights.resize(components);\n\t\tgaussians.reserve(components);\n\t\tEigen::VectorXd mean(dimension);\n\t\tEigen::MatrixXd cov(dimension, dimension);\n\t\tfor (int i=0; i> weight;\n\t\t\tlogWeights[i] = std::log(weight);\n\t\t\tfor (int x = 0; x < dimension; ++x) in >> mean[x];\n\t\t\tfor (int x = 0; x < dimension; ++x)\n\t\t\t\tfor (int y = 0; y < dimension; ++y)\n\t\t\t\t\tin >> cov(x, y);\n\t\t\tgaussians.emplace_back(mean, cov);\n\t\t}\n\t}\n\n#ifndef NDEBUG\n\tfor (int k = 0; k < components; ++k)\n\t{\n\t\tstd::cout << \"\\nComponent \" << k\n\t\t\t<< \"\\nWeight: \" << std::exp(logWeights[k])\n\t\t\t<< \"\\n\" << gaussians[k] << std::endl;\n\t}\n#endif\n\n\t//temporary memory\n\tEigen::MatrixXd logW(numPoints, components);\n\n\t//run EM (fixed number of iterations)\n\tstd::cout << \"Run EM algorithm\" << std::endl;\n\tstd::chrono::time_point start;\n\tdouble logLikeliehoodAccum;\n\tfor (int iter=0; iter < numIterations; ++iter)\n\t{\n\t\t//half of the iterations for warm up\n\t\tif (iter==numIterations/2) start = std::chrono::steady_clock::now();\n\n#ifndef NDEBUG\n\t\tstd::cout << \" Iteration \" << iter << std::endl;\n#endif\n\n\t\t//Precomputation\n#pragma omp parallel for\n\t\tfor (int i = 0; i < components; ++i)\n\t\t\tgaussians[i].computeDetInv();\n\n\t\t//E-Step\n\t\tlogLikeliehoodAccum = 0;\n\t\tfor (int i=0; i log-likelihood: \" << logLikeliehoodAccum << \"\\n\";\n#endif\n\t}\n#ifdef NDEBUG\n\tstd::cout << \" -> log-likelihood: \" << logLikeliehoodAccum << \"\\n\";\n#endif\n\n\tauto finish = std::chrono::steady_clock::now();\n\tdouble elapsed = std::chrono::duration_cast<\n\t\tstd::chrono::duration>(finish - start).count() * 1000 * 2; //*2 for warm up\n\tstd::cout << \" Done in \" << elapsed << \"ms\" << std::endl;\n\n\t//save results\n\treturnValues.Insert(std::make_pair(\"Time\", elapsed));\n\treturnValues.Insert(std::make_pair(\"LogLikelihood\", logLikeliehoodAccum));\n\tJson::Array comData;\n\tfor (int k=0; k // for std::shuffle\n#include // for std::int32_t\n#include // for std::sqrt\n#ifdef _MSC_VER\n\t#include // for std::format\n#endif\n#include // for std::ofstream\n#include // for std::cout\n#include // for std::begin, std::ostream_iterator\n#include // for std::map\n#include // for std::mt19937\n#include // for std::unordered_map\n#include // for std::make_pair, std::move\n#include // for std::vector\n#include // for std::valarray\n#include // for boost::algorithm::iota\n#ifndef _MSC_VER\n\t#include // for boost::format\n#endif\n#include // for boost::find, boost::max_element, boost::transform\n#include // for tbb::concurrent_vector\n#include // for tbb::parallel_for\n\nnamespace {\n //! A global variable (constant expression).\n /*!\n 列のサイズ\n */\n static auto constexpr COLUMN = 5ULL;\n\n //! A global variable (constant expression).\n /*!\n 行のサイズ\n */\n static auto constexpr ROW = 5ULL;\n\n //! A global variable (constant expression).\n /*!\n ビンゴボードのマス数\n */\n static auto constexpr BOARDSIZE = ROW * COLUMN;\n\n //! A global variable (constant expression).\n /*!\n モンテカルロシミュレーションの試行回数\n */\n static auto constexpr MCMAX = 1000000U;\n\n //! A global variable (constant expression).\n /*!\n 行・列の総数\n */\n static auto constexpr ROWCOLUMN = ROW + COLUMN;\n\n //! A typedef.\n /*!\n そのマスに書かれてある番号と、そのマスが当たったかどうかを示すフラグのstd::pair\n */\n using mypair = std::pair;\n\n //! A typedef.\n /*!\n 数字と数字のstd::pair\n */\n using mypair2 = std::pair;\n\n //! A typedef.\n /*!\n (n + 1)個目の行・列が埋まったときの分布を格納するためのmapの型\n */\n using mymap = std::map;\n \n\t//! A function.\n\t/*!\n\t\t(n + 1)個目の行・列またはマスが埋まったときの平均試行回数、埋まっているマスまたは行・列の平均個数を求める\n\t\t\\param mcresult モンテカルロ・シミュレーションの結果が格納された二次元可変長配列\n\t\t\\param size 行・列またはマスの総数\n\t\t\\return (n + 1)個目の行・列が埋まったときの平均試行回数、埋まっているマスの平均個数が格納された可変長配列のstd::pair\n\t*/\n\tstd::pair< std::valarray, std::valarray > eval_average(tbb::concurrent_vector< std::vector > const & mcresult, std::size_t size);\n\n\t//! A function.\n\t/*!\n\t\t(n + 1)個目の行・列が埋まったときの中央値を求める\n\t\t\\param (n + 1)個目の数値n\n\t\t\\param mcresult モンテカルロ・シミュレーションの結果が格納された二次元可変長配列\n\t\t\\return (n + 1)個目の行・列が埋まったときの中央値\n\t*/\n\tstd::int32_t eval_median(tbb::concurrent_vector< std::vector > const & mcresult, std::int32_t n);\n\n\t//! A function.\n\t/*!\n\t\t(n + 1)個目の行・列が埋まったときの最頻値と分布を求める\n\t\t\\param (n + 1)個目の数値n\n\t\t\\param mcresult モンテカルロ・シミュレーションの結果が格納された二次元可変長配列\n\t\t\\return (n + 1)個目の行・列が埋まったときの最頻値と分布のstd::pair\n\t*/\n\tstd::pair > eval_mode(tbb::concurrent_vector< std::vector > const & mcresult, std::int32_t n);\n\n\t//! A function.\n\t/*!\n\t\t(n + 1)個目の行・列が埋まったときの標準偏差を求める\n\t\t\\param avgten (n + 1)個目の行・列が埋まったときの平均試行回数\n\t\t\\param (n + 1)個目の数値n\n\t\t\\param mcresult モンテカルロ・シミュレーションの結果が格納された二次元可変長配列\n\t\t\\return (n + 1)個目の行・列が埋まったときの標準偏差\n\t*/\n\tdouble eval_std_deviation(double avg, tbb::concurrent_vector< std::vector > const & mcresult, std::int32_t n);\n\n //! A function.\n /*!\n ビンゴボードを生成する\n \\return ビンゴボードが格納された可変長配列\n */\n auto makeboard();\n\n#ifdef _CHECK_PARALELL_PERFORM\n //! A function.\n /*!\n モンテカルロ・シミュレーションを行う\n \\return モンテカルロ・シミュレーションの結果が格納された二次元可変長配列\n */\n\tstd::pair >, std::vector< std::vector > > montecarlo();\n#endif\n\n //! A function.\n /*!\n モンテカルロ・シミュレーションの実装\n \\param mr 自作乱数クラスのオブジェクト\n \\return モンテカルロ法の結果が格納された可変長配列\n */\n\ttemplate \n\tstd::pair, std::vector > montecarloImpl(MyRandom & mr);\n\n //! A function.\n /*!\n モンテカルロ・シミュレーションをTBBで並列化して行う\n \\return モンテカルロ・シミュレーションの結果が格納された二次元可変長配列\n */\n\tstd::pair >, tbb::concurrent_vector< std::vector > > montecarloTBB();\n\n //! A function.\n /*!\n (n + 1)個目の行・列が埋まったときの分布をcsvファイルに出力する\n\t\t\\param distmap (n + 1)個目の行・列が埋まったときの分布\n\t\t\\param filename ファイル名\n */\n void outputcsv(mymap const & distmap, std::string const & filename);\n}\n\nint main()\n{\n checkpoint::CheckPoint cp;\n\n cp.checkpoint(\"処理開始\", __LINE__);\n\n#ifdef _CHECK_PARALELL_PERFORM\n // モンテカルロ・シミュレーションの結果を代入\n auto const mcresult(montecarlo());\n\n cp.checkpoint(\"並列化無効\", __LINE__);\n#endif \n\t\n // TBBで並列化したモンテカルロ・シミュレーションの結果を代入\n auto const mcresult2(montecarloTBB());\n\n cp.checkpoint(\"並列化有効\", __LINE__);\n\n auto const [trialavg, fillavg] = eval_average(mcresult2.first, ROWCOLUMN);\n\n for (auto n = 0U; n < ROWCOLUMN; n++) {\n\t\tauto const [mode, distmap] = eval_mode(mcresult2.first, n);\n#ifdef _MSC_VER\n\t\toutputcsv(distmap, std::format(\"result/distribution_{:d}個目.csv\", n + 1));\n\n std::cout \n\t\t\t<< std::format(\"ビンゴ{:d}個目に必要な平均試行回数：{:.1f}回, 効率：{:.1f}(回/個), \", n + 1, trialavg[n], trialavg[n] / static_cast(n + 1))\n\t\t\t<< std::format(\"中央値：{:d}回, 最頻値：{:d}回, 標準偏差：{:.1f}, \", eval_median(mcresult2.first, n), mode, eval_std_deviation(trialavg[n], mcresult2.first, n))\n\t\t\t<< std::format(\"埋まっているマスの平均個数：{:.1f}個\\n\", fillavg[n]);\n#else\n outputcsv(distmap, (boost::format(\"result/distribution_%d個目.csv\") % (n + 1)).str());\n\n std::cout\n << boost::format(\"ビンゴ%d個目に必要な平均試行回数：%.1f回, 効率：%.1f(回/個), \")\n % (n + 1)\n % trialavg[n]\n % (trialavg[n] / static_cast(n + 1))\n << boost::format(\"中央値：%d回, 最頻値：%d回, 標準偏差：%.1f, \")\n % eval_median(mcresult2.first, n)\n % mode\n % eval_std_deviation(trialavg[n], mcresult2.first, n)\n << boost::format(\"埋まっているマスの平均個数：%.1f個\\n\")\n % fillavg[n];\n#endif\n }\n\n\tauto const [trialavg2, fillavg2] = eval_average(mcresult2.second, BOARDSIZE);\n\n\tfor (auto n = 0U; n < BOARDSIZE; n++) {\n\t\tauto const [mode, distmap] = eval_mode(mcresult2.second, n);\n#ifdef _MSC_VER\n outputcsv(distmap, std::format(\"result/distribution2_{:d}個目.csv\", n + 1));\n\n std::cout\n << std::format(\"{:d}個目のマスに必要な平均試行回数：{:.1f}回, 効率：{:.1f}(回/個), \", n + 1, trialavg2[n], trialavg2[n] / static_cast(n + 1))\n << std::format(\"中央値：{:d}回, 最頻値：{:d}回, 標準偏差：{:.1f}, \", eval_median(mcresult2.second, n), mode, eval_std_deviation(trialavg2[n], mcresult2.second, n))\n << std::format(\"埋まっている行・列の平均個数：{:.1f}個\\n\", fillavg2[n]);\n#else\n\t\toutputcsv(distmap, (boost::format(\"result/distribution2_%d個目.csv\") % (n + 1)).str());\n\n\t\tstd::cout\n\t\t\t<< boost::format(\"%d個目のマスに必要な平均試行回数：%.1f回, 効率：%.1f(回/個), \")\n\t\t\t% (n + 1)\n\t\t\t% trialavg2[n]\n\t\t\t% (trialavg2[n] / static_cast(n + 1))\n\t\t\t<< boost::format(\"中央値：%d回, 最頻値：%d回, 標準偏差：%.1f, \")\n\t\t\t% eval_median(mcresult2.second, n)\n\t\t\t% mode\n\t\t\t% eval_std_deviation(trialavg2[n], mcresult2.second, n)\n\t\t\t<< boost::format(\"埋まっている行・列の平均個数：%.1f個\\n\")\n\t\t\t% fillavg2[n];\n#endif\n\t}\n\n cp.checkpoint(\"それ以外の処理\", __LINE__);\n\n cp.checkpoint_print();\n\n\tgoexit::goexit();\n\n return 0;\n}\n\nnamespace {\n std::pair< std::valarray, std::valarray > eval_average(tbb::concurrent_vector< std::vector > const & mcresult, std::size_t size)\n {\n // モンテカルロ・シミュレーションの平均試行回数の結果を格納した可変長配列\n std::valarray trialavg(size);\n\n // モンテカルロ・シミュレーションのn回目の試行で、埋まっているマスの数を格納した可変長配列\n std::valarray fillavg(size);\n\n // 行・列の総数分繰り返す\n for (auto n = 0U; n < size; n++) {\n // 総和を0で初期化\n auto trialsum = 0;\n auto fillsum = 0;\n\n // 試行回数分繰り返す\n for (auto j = 0U; j < MCMAX; j++) {\n // j回目の結果を加える\n trialsum += mcresult[j][n].first;\n fillsum += mcresult[j][n].second;\n }\n\n // 平均を算出してn行・列目のtrialavg、fillavgに代入\n trialavg[n] = static_cast(trialsum) / static_cast(MCMAX);\n fillavg[n] = static_cast(fillsum) / static_cast(MCMAX);\n }\n\n return std::make_pair(std::move(trialavg), std::move(fillavg));\n }\n\n\tstd::int32_t eval_median(tbb::concurrent_vector< std::vector > const & mcresult, std::int32_t n)\n\t{\n\t\t// 中央値を求めるために必要な可変長配列\n\t\tstd::vector medtmp(MCMAX);\n\n\t\t// 中央値を求めるために必要な可変長配列を、モンテカルロ法の結果から生成\n\t\tboost::transform(\n\t\t\tmcresult,\n\t\t\tmedtmp.begin(),\n\t\t\t[n](auto const & res) { return res[n].first; });\n\n\t\t// 中央値を求めるためにソートする\n\t\tboost::sort(medtmp);\n\n\t\t// 中央値を求める\n\t\tif constexpr (MCMAX % 2) {\n\t\t\t// 要素が奇数個なら中央の要素を返す\n\t\t\treturn medtmp[(MCMAX - 1) / 2];\n\t\t}\n\t\telse {\n\t\t\t// 要素が偶数個なら中央二つの平均を返す\n\t\t\treturn (medtmp[(MCMAX / 2) - 1] + medtmp[MCMAX / 2]) / 2;\n\t\t}\n\t}\n\n\tstd::pair eval_mode(tbb::concurrent_vector< std::vector > const & mcresult, std::int32_t n)\n\t{\n\t\t// (n + 1)個目の行・列が埋まったときの分布\n\t\tstd::unordered_map distmap;\n\n\t\t// distmapを埋める\n\t\tfor (auto const & res : mcresult) {\n\t\t\t// (n + 1)個目の行・列が埋まったときの回数をkeyとする\n\t\t\tauto const key = res[n].first;\n\n\t\t\t// keyが存在するかどうか\n\t\t\tauto itr = distmap.find(key);\n\t\t\tif (itr == distmap.end()) {\n\t\t\t\t// keyが存在しなかったので、そのキーでハッシュを拡張（値1）\n\t\t\t\tdistmap.emplace(key, 1);\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// keyが指す値を更新\n\t\t\t\titr->second++;\n\t\t\t}\n\t\t}\n\n\t\t// 最頻値を探索\n\t\tauto const mode = boost::max_element(\n\t\t\tdistmap,\n\t\t\t[](auto const & p1, auto const & p2) { return p1.second < p2.second; })->first;\n\n\t\t// 最頻値と(n + 1)個目の行・列が埋まったときの分布をpairにして返す\n\t\treturn std::make_pair(mode, mymap(distmap.begin(), distmap.end()));\n\t}\n\n\tdouble eval_std_deviation(double avg, tbb::concurrent_vector< std::vector > const & mcresult, std::int32_t n)\n\t{\n\t\t// 標準偏差を求めるために必要な可変長配列\n\t\tstd::valarray devtmp(MCMAX);\n\n\t\t// 標準偏差の計算\n\t\tboost::transform(\n\t\t\tmcresult,\n\t\t\tstd::begin(devtmp),\n\t\t\t[avg, n](auto const & res) {\n\t\t\tauto const val = static_cast(res[n].first);\n\t\t\treturn (val - avg) * (val - avg);\n\t\t});\n\n\t\t// 標準偏差を求める\n\t\treturn std::sqrt(devtmp.sum() / static_cast(MCMAX));\n\t}\n\n auto makeboard()\n {\n // 仮のビンゴボードを生成\n std::vector boardtmp(BOARDSIZE);\n\n // 仮のビンゴボードに1～25の数字を代入\n boost::algorithm::iota(boardtmp, 1);\n\n // 仮のビンゴボードの数字をシャッフル\n std::shuffle(boardtmp.begin(), boardtmp.end(), std::mt19937());\n\n // ビンゴボードを生成\n std::vector board(BOARDSIZE);\n\n // 仮のビンゴボードからビンゴボードを生成する\n boost::transform(\n boardtmp,\n board.begin(),\n [](auto n) { return std::make_pair(n, false); });\n\n // ビンゴボードを返す\n return board;\n }\n\n#ifdef _CHECK_PARALELL_PERFORM\n\tstd::pair >, std::vector< std::vector > > montecarlo()\n {\n // モンテカルロ・シミュレーションの結果を格納するための二次元可変長配列\n\t\tstd::pair >, std::vector< std::vector > > mcresult;\n\n\t\t// MCMAX個の容量を確保\n\t\tmcresult.first.reserve(MCMAX);\n\t\tmcresult.second.reserve(MCMAX);\n\n#ifdef HAVE_SSE2\n\t\t// 自作乱数クラスを初期化\n\t\tmyrandom::MyRandSfmt mr(1, BOARDSIZE);\n#else\n\t\t// 自作乱数クラスを初期化\n\t\tmyrandom::MyRand mr(1, BOARDSIZE);\n#endif\n // 試行回数分繰り返す\n for (auto n = 0U; n < MCMAX; n++) {\n\t\t\t// モンテカルロ・シミュレーションの結果を代入\n\t\t\tauto const [resf, ress] = montecarloImpl(mr);\n\t\t\tmcresult.first.emplace_back(resf);\n\t\t\tmcresult.second.emplace_back(ress);\n }\n\n // モンテカルロ・シミュレーションの結果を返す\n return mcresult;\n }\n#endif\n\n\ttemplate \n\tstd::pair, std::vector > montecarloImpl(MyRandom & mr)\n {\n // ビンゴボードを生成\n auto board(makeboard());\n\n // その行・列が既に埋まっているかどうかを格納する可変長配列\n // ROWCOLUMN個の要素をfalseで初期化\n std::vector rcfill(ROWCOLUMN, false);\n\n // 行・列が埋まるまでに要した回数と、その時点で埋まったマスを格納した\n // 可変長配列\n std::vector fillnum;\n\n\t\t// (n + 1)個目のマスが埋まったときの回数と、その時点で埋まった行・列を格納した\n // 可変長配列\n\t\tstd::vector fillnum2;\n\n // ROWCOLUMN個の容量を確保\n fillnum.reserve(ROWCOLUMN);\n\n // その時点で埋まっているマスを計算するためのラムダ式\n auto const sum = [](auto const & vec) {\n auto cnt = 0;\n for (auto & e : vec) {\n if (e.second) {\n cnt++;\n }\n }\n\n return cnt;\n };\n\n // 無限ループ\n for (auto n = 1; ; n++) {\n // 乱数で得た数字で、かつまだ当たってないマスを検索\n auto itr = boost::find(board, std::make_pair(mr.myrand(), false));\n\n // そのようなマスがあった\n if (itr != board.end()) {\n // そのマスは当たったとし、フラグをtrueにする\n itr->second = true;\n }\n // そのようなマスがなかった\n else {\n //ループ続行\n continue;\n }\n\n // 各行・列が埋まったかどうかをチェック\n for (auto j = 0U; j < ROW; j++) {\n // 各行が埋まったかどうかのフラグ\n auto rowflag = true;\n\n // 各行が埋まったかどうかをチェック\n for (auto k = 0U; k < COLUMN; k++) {\n rowflag &= board[COLUMN * j + k].second;\n }\n\n // 行の処理\n if (rowflag &&\n // その行は既に埋まっているかどうか\n !rcfill[j]) {\n // その行は埋まったとして、フラグをtrueにする\n rcfill[j] = true;\n\n // 要した試行回数と、その時点で埋まったマスの数を格納\n fillnum.emplace_back(n, sum(board));\n }\n\n // 各列が埋まったかどうかのフラグ\n auto columnflag = true;\n\n // 各列が埋まったかどうかをチェック \n for (auto k = 0U; k < ROW; k++) {\n columnflag &= board[j + COLUMN * k].second;\n }\n\n // 列の処理\n if (columnflag &&\n // その列は既に埋まっているかどうか\n !rcfill[j + ROW]) {\n\n // その列は埋まったとして、フラグをtrueにする\n rcfill[j + ROW] = true;\n\n // 要した試行回数と、その時点で埋まったマスの数を格納\n fillnum.emplace_back(n, sum(board));\n }\n }\n\n\t\t\t// 要した試行回数と、その時点で埋まっている行・列の数を格納\n\t\t\tfillnum2.emplace_back(n, static_cast(fillnum.size()));\n\n // 全ての行・列が埋まったかどうか\n if (fillnum.size() == ROWCOLUMN) {\n // 埋まったのでループ脱出\n break;\n }\n }\n\n // 要した試行関数の可変長配列を返す\n return std::make_pair(std::move(fillnum), std::move(fillnum2));\n }\n\n std::pair >, tbb::concurrent_vector< std::vector > > montecarloTBB()\n {\n // モンテカルロ・シミュレーションの結果を格納するための二次元可変長配列\n // 複数のスレッドが同時にアクセスする可能性があるためtbb::concurrent_vectorを使う\n std::pair >, tbb::concurrent_vector< std::vector > > mcresult;\n\n // MCMAX個の容量を確保\n mcresult.first.reserve(MCMAX);\n\t\tmcresult.second.reserve(MCMAX);\n\n // MCMAX回のループを並列化して実行\n tbb::parallel_for(\n 0U,\n MCMAX,\n 1U,\n [&mcresult](auto) {\n\n#ifdef HAVE_SSE2\n\t\t\t// 自作乱数クラスを初期化\n\t\t\tmyrandom::MyRandSfmt mr(1, BOARDSIZE);\n#else\n\t\t\t// 自作乱数クラスを初期化\n\t\t\tmyrandom::MyRand mr(1, BOARDSIZE);\n#endif\n\n // モンテカルロ・シミュレーションの結果を代入\n\t\t\tauto const [resf, ress] = montecarloImpl(mr);\n mcresult.first.emplace_back(resf);\n\t\t\tmcresult.second.emplace_back(ress);\n });\n\n // モンテカルロ・シミュレーションの結果を返す\n return mcresult;\n }\n\n void outputcsv(mymap const & distmap, std::string const & filename)\n {\n std::ofstream ofs(filename);\n\n boost::transform(\n distmap,\n std::ostream_iterator(ofs, \"\\n\"),\n#ifdef _MSC_VER\n [](auto const& p) { return std::format(\"{:d},{:d}\", p.first, p.second); });\n#else\n [](auto const & p) { return (boost::format(\"%d,%d\") % p.first % p.second).str(); });\n#endif\n }\n}\n\n", "meta": {"hexsha": "e637c3460bb7d6195ea9565389ad340ce3186de7", "size": 16706, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/mabinogi_roulette_MC/mabinogi_roulette_mc.cpp", "max_stars_repo_name": "dc1394/mabinogi_roulette_MC", "max_stars_repo_head_hexsha": "0494666ae6bea8d5f266a4a4948a4d255721c1b5", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/mabinogi_roulette_MC/mabinogi_roulette_mc.cpp", "max_issues_repo_name": "dc1394/mabinogi_roulette_MC", "max_issues_repo_head_hexsha": "0494666ae6bea8d5f266a4a4948a4d255721c1b5", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/mabinogi_roulette_MC/mabinogi_roulette_mc.cpp", "max_forks_repo_name": "dc1394/mabinogi_roulette_MC", "max_forks_repo_head_hexsha": "0494666ae6bea8d5f266a4a4948a4d255721c1b5", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.7789661319, "max_line_length": 160, "alphanum_fraction": 0.5755417215, "num_tokens": 6838, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7931059511841119, "lm_q2_score": 0.6825737279551494, "lm_q1q2_score": 0.541353285763154}} {"text": "////////////////////////////////////////////////////////////////////////////////\n// MIT License\n//\n// Copyright (c) 2017 Jonas Spenger\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n////////////////////////////////////////////////////////////////////////////////\n//\n// This is a modified (see below) version of the SAX algorithm proposed in:\n// Lin, Jessica, et al. \"A symbolic representation of time series, with\n// implications for streaming algorithms.\" Proceedings of the 8th ACM SIGMOD\n// workshop on Research issues in data mining and knowledge discovery. ACM,\n// 2003.\n//\n// This implementation (MSAX) differs from the original SAX in two aspects.\n// (1) The time series is normalized by normalizing each point to the\n// neighbouring #windowsize points. That is, for each point we subtract\n// the moving average and divide by the moving standard deviation (with\n// a moving window of size windowsize). In the original SAX algorithm,\n// each subsequence is normalized.\n// (2) Because the entire time series is normalized, this implementation\n// outputs just one symbolic sequence, that represents the entire time\n// series. In comparison to the original SAX, which outputs a symbolic\n// sequence for every subsequence of the time series (of size windowsize),\n// resulting in more than one symbolic sequences.\n//\n// To use this include file and run msax::run() with following parameters:\n// timeSeries: the time series (a container / vector)\n// alphabetSize: the size of the alphabet\n// frameSize: the size of a frame that gets transformed to one symbol, the\n// dimensionality reduction so to speak\n// windowSize: the size of the moving window used for the normalization\n//\n////////////////////////////////////////////////////////////////////////////////\n\n\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace msax {\n\ntemplate \nstd::vector run(const T& timeSeries,\n size_t alphabetSize,\n size_t frameSize,\n size_t windowSize) {\n\n\n //////////////////////////////////////////////////////////////////////////////\n // Normalize the time series\n //////////////////////////////////////////////////////////////////////////////\n\n T normalizedTimeSeries(timeSeries.size());\n\n // accumulator for calculating moving variance and moving average\n boost::accumulators::accumulator_set\n >\n accumulator(boost::accumulators::tag::rolling_window::window_size = windowSize);\n\n // calculate the mean and variance for first windowsize elements\n for (size_t i = 0; i < windowSize; ++i) {\n accumulator(timeSeries[i]);\n }\n // calculate the normalized values for the first windowsize / 2 elements\n for (size_t i = 0; i < windowSize / 2; ++i) {\n normalizedTimeSeries[i] = (timeSeries[i] - boost::accumulators::rolling_mean(accumulator))\n / std::sqrt(boost::accumulators::rolling_variance(accumulator));\n }\n // calculate normalized values for windowsize/2 to timeSeries.size - (windowSize + 1) / 2 values\n for (size_t i = windowSize; i < timeSeries.size(); ++i) {\n accumulator(timeSeries[i]);\n size_t j = i - (windowSize + 1) / 2;\n normalizedTimeSeries[j] = (timeSeries[j] - boost::accumulators::rolling_mean(accumulator))\n / std::sqrt(boost::accumulators::rolling_variance(accumulator));\n }\n // calculate normalized values for the last (windowSize + 1) / 2 values\n for (size_t i = timeSeries.size() - (windowSize + 1) / 2; i < timeSeries.size(); ++i) {\n normalizedTimeSeries[i] = (timeSeries[i] - boost::accumulators::rolling_mean(accumulator))\n / std::sqrt(boost::accumulators::rolling_variance(accumulator));\n }\n\n\n //////////////////////////////////////////////////////////////////////////////\n // Perform PAA (Piecewise Aggregate Approximation)\n //////////////////////////////////////////////////////////////////////////////\n\n T paaTimeSeries((normalizedTimeSeries.size() - 1) / frameSize + 1);\n\n for (size_t i = 0; i < paaTimeSeries.size(); ++i) {\n double mean = 0.0;\n\n if (i == paaTimeSeries.size() - 1) {\n for (size_t j = i * frameSize; j < normalizedTimeSeries.size(); ++j) {\n mean += normalizedTimeSeries[j];\n }\n mean = mean / ((double)(normalizedTimeSeries.size() - i * frameSize));\n } else {\n for (size_t j = i * frameSize; j < (i+1) * frameSize; ++j) {\n mean += normalizedTimeSeries[j];\n }\n mean = mean / ((double)frameSize);\n }\n paaTimeSeries[i] = mean;\n }\n\n\n //////////////////////////////////////////////////////////////////////////////\n // Calculate breakpoints\n //////////////////////////////////////////////////////////////////////////////\n\n std::vector breakpoints(alphabetSize - 1);\n boost::math::normal stdNormDist(0.0, 1.0); // standard normal distribution\n for (size_t i = 1; i < alphabetSize; ++i) {\n double q = quantile(stdNormDist, ((double) i) / ((double) alphabetSize));\n breakpoints[i-1] = q;\n }\n\n\n //////////////////////////////////////////////////////////////////////////////\n // Discretize\n //////////////////////////////////////////////////////////////////////////////\n\n std::vector output(paaTimeSeries.size());\n // for each element of paaTimeSeries, map it to the corresponding symbol\n // as defined by the breakpoints, if breakpoints[i] < value < breakpoints[i+1],\n // then map it to symbol nom i+1\n for (size_t i = 0; i < output.size(); ++i) {\n for (size_t j = 0; j < breakpoints.size(); ++j) {\n output[i] = breakpoints.size();\n if (paaTimeSeries[i] < breakpoints[j]) {\n output[i] = j;\n break;\n }\n }\n }\n\n return output;\n} // run()\n\n} // namespace msax\n", "meta": {"hexsha": "4c54aa234a09952f218250b97c13f1420da1b6bc", "size": 7118, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/msax.hpp", "max_stars_repo_name": "spengerj/MSAX", "max_stars_repo_head_hexsha": "aacdd3ab3d9bdbe282962727f93cd4ca114973b9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-01-22T03:37:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-22T03:37:22.000Z", "max_issues_repo_path": "src/msax.hpp", "max_issues_repo_name": "spengerj/MSAX", "max_issues_repo_head_hexsha": "aacdd3ab3d9bdbe282962727f93cd4ca114973b9", "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/msax.hpp", "max_forks_repo_name": "spengerj/MSAX", "max_forks_repo_head_hexsha": "aacdd3ab3d9bdbe282962727f93cd4ca114973b9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.1393939394, "max_line_length": 98, "alphanum_fraction": 0.6050856982, "num_tokens": 1568, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7931059414036511, "lm_q2_score": 0.6825737344123242, "lm_q1q2_score": 0.541353284208492}} {"text": "/*\n * statistics_ext.cc\n *\n * Copyright (C) 2013 Diamond Light Source\n *\n * Author: James Parkhurst\n *\n * This code is distributed under the BSD license, a copy of which is\n * included in the root directory of this package.\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace dials { namespace algorithms { namespace boost_python {\n\n using namespace boost::python;\n\n template \n RealType kolmogorov_smirnov_one_sided_cdf(std::size_t n, RealType x) {\n return cdf(kolmogorov_smirnov_one_sided_distribution(n), x);\n }\n\n template \n RealType kolmogorov_smirnov_two_sided_cdf(std::size_t n, RealType x) {\n return cdf(kolmogorov_smirnov_two_sided_distribution(),\n x * std::sqrt((double)n));\n }\n\n // template \n // RealType kolmogorov_smirnov_one_sided_pdf(std::size_t n, RealType x) {\n // return pdf(kolmogorov_smirnov_one_sided_distribution(n), x);\n //}\n\n template \n boost::python::tuple kolmogorov_smirnov_test_standard_normal(\n const af::const_ref &data,\n std::string type) {\n // Get the enumeration\n KSType etype = TwoSided;\n if (type.compare(\"less\") == 0) {\n etype = Less;\n } else if (type.compare(\"greater\") == 0) {\n etype = Greater;\n } else {\n DIALS_ASSERT(type.compare(\"two_sided\") == 0);\n }\n\n // Perform the test\n std::pair result =\n kolmogorov_smirnov_test(boost::math::normal_distribution(0, 1),\n data.begin(),\n data.end(),\n etype);\n return boost::python::make_tuple(result.first, result.second);\n }\n\n BOOST_PYTHON_MODULE(dials_algorithms_statistics_ext) {\n def(\"kolmogorov_smirnov_one_sided_cdf\", &kolmogorov_smirnov_one_sided_cdf);\n def(\"kolmogorov_smirnov_two_sided_cdf\", &kolmogorov_smirnov_two_sided_cdf);\n // def(\"kolmogorov_smirnov_one_sided_pdf\",\n // &kolmogorov_smirnov_one_sided_pdf);\n def(\"kolmogorov_smirnov_test_standard_normal\",\n &kolmogorov_smirnov_test_standard_normal,\n (arg(\"data\"), arg(\"type\") = \"two_sided\"));\n\n def(\"poisson_expected_max_counts\", &poisson_expected_max_counts);\n\n def(\"spearman_correlation_coefficient\", &spearman_correlation_coefficient);\n def(\"pearson_correlation_coefficient\", &pearson_correlation_coefficient);\n\n class_(\"BinnedGMMSingle1DFixedMean\", no_init)\n .def(init &,\n const af::const_ref &,\n const af::const_ref &,\n double,\n double,\n double,\n std::size_t>())\n .def(\"max_iter\", &BinnedGMMSingle1DFixedMean::max_iter)\n .def(\"num_iter\", &BinnedGMMSingle1DFixedMean::num_iter)\n .def(\"epsilon\", &BinnedGMMSingle1DFixedMean::epsilon)\n .def(\"mu\", &BinnedGMMSingle1DFixedMean::mu)\n .def(\"sigma\", &BinnedGMMSingle1DFixedMean::sigma);\n\n class_(\"BinnedGMMSingle1D\", no_init)\n .def(init &,\n const af::const_ref &,\n const af::const_ref &,\n double,\n double,\n double,\n std::size_t>())\n .def(\"max_iter\", &BinnedGMMSingle1D::max_iter)\n .def(\"num_iter\", &BinnedGMMSingle1D::num_iter)\n .def(\"epsilon\", &BinnedGMMSingle1D::epsilon)\n .def(\"mu\", &BinnedGMMSingle1D::mu)\n .def(\"sigma\", &BinnedGMMSingle1D::sigma);\n }\n\n}}} // namespace dials::algorithms::boost_python\n", "meta": {"hexsha": "fece0b5f97181b63fea6f5f0ab9f00fa5b9595dc", "size": 4205, "ext": "cc", "lang": "C++", "max_stars_repo_path": "algorithms/statistics/boost_python/statistics_ext.cc", "max_stars_repo_name": "TiankunZhou/dials", "max_stars_repo_head_hexsha": "bd5c95b73c442cceb1c61b1690fd4562acf4e337", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 58.0, "max_stars_repo_stars_event_min_datetime": "2015-10-15T09:28:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T20:09:38.000Z", "max_issues_repo_path": "algorithms/statistics/boost_python/statistics_ext.cc", "max_issues_repo_name": "TiankunZhou/dials", "max_issues_repo_head_hexsha": "bd5c95b73c442cceb1c61b1690fd4562acf4e337", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1741.0, "max_issues_repo_issues_event_min_datetime": "2015-11-24T08:17:02.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T15:46:42.000Z", "max_forks_repo_path": "algorithms/statistics/boost_python/statistics_ext.cc", "max_forks_repo_name": "TiankunZhou/dials", "max_forks_repo_head_hexsha": "bd5c95b73c442cceb1c61b1690fd4562acf4e337", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 45.0, "max_forks_repo_forks_event_min_datetime": "2015-10-14T13:44:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T14:45:56.000Z", "avg_line_length": 38.5779816514, "max_line_length": 87, "alphanum_fraction": 0.6832342449, "num_tokens": 1168, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.793105941403651, "lm_q2_score": 0.6825737279551494, "lm_q1q2_score": 0.5413532790872683}} {"text": "#include \n#include \n\nusing namespace std;\nusing namespace arma;\n\nint main()\n{\n arma::mat output;\n arma::mat input;\n\n input = arma::zeros(16, 1);\n input(0) = 1.5;\n input(1) = 2.0;\n input(2) = 2.3;\n input(3) = 2.2;\n input(4) = 1.7;\n input(5) = 2.1;\n input(6) = 1.9;\n input(7) = 2.1;\n input(8) = 1.4;\n input(9) = 1.8;\n input(10) = 1.5;\n input(11) = 1.6;\n input(12) = 1.3;\n input(13) = 1.6;\n input(14) = 1.4;\n input(15) = 1.7;\n\n //input = arma::mat(\"1.5 2.0 2.3 2.2 1.7 2.1 1.9 2.1 1.4 1.8 1.5 1.6 1.3 1.6 1.4 1.7\").t();\n\n cout << \"-------------------------------------\" << endl;\n cout << \"INPUT : \" << endl;\n cout << \"Input shape : \"<< input.n_rows << \" \" << input.n_cols << endl;\n cout << \"Input (Transposed view) : \" << input.t() << endl;\n cout << \"-------------------------------------\" << endl;\n\n const size_t kernelWidth = 2;\n const size_t kernelHeight = 2;\n const size_t strideWidth = 2;\n const size_t strideHeight = 2;\n const bool floor = true;\n size_t inSize = 0;\n size_t outSize = 0;\n bool reset = false;\n size_t inputWidth = 0;\n size_t inputHeight = 0;\n size_t outputWidth = 0;\n size_t outputHeight = 0;\n bool deterministic = false;\n size_t offset = 0;\n size_t batchSize = 0;\n\n inputHeight = 4;\n inputWidth = 4;\n batchSize = input.n_cols;\n inSize = input.n_elem / (inputWidth * inputHeight * batchSize);\n\n // cube(ptr_aux_mem, n_rows, n_cols, n_slices, copy_aux_mem = true, strict = false)\n arma::cube inputTemp = arma::cube(const_cast(input).memptr(),\n inputWidth, inputHeight, batchSize * inSize, false, false);\n\n cout << \"inputTemp BEFORE POOLING: \" << endl;\n cout << \"inputTemp shape : \"<< inputTemp.n_rows << \" \" << inputTemp.n_cols << endl;\n cout << \"Num slices : \" << inputTemp.n_slices << endl;\n cout << inputTemp << endl;\n cout << \"-------------------------------------\" << endl;\n\n outputWidth = std::floor(((inputWidth - (double) kernelWidth) / (double) strideWidth) + 1);\n outputHeight = std::floor(((inputHeight - (double) kernelHeight) / (double) strideHeight) + 1);\n offset = 0;\n\n arma::cube outputTemp = arma::zeros(outputWidth, outputHeight, batchSize * inSize);\n\n cout << \"outputTemp BEFORE POOLING: \" << endl;\n cout << \"outputTemp shape : \"<< outputTemp.n_rows << \" \" << outputTemp.n_cols << endl;\n cout << outputTemp << endl;\n cout << \"-------------------------------------\" << endl;\n\n std::vector poolingIndices;\n poolingIndices.push_back(outputTemp);\n\n arma::Mat indices;\n arma::Col indicesCol;\n\n size_t elements = inputWidth * inputHeight;\n indicesCol = arma::linspace >(0, (elements - 1), elements);\n indices = arma::Mat(indicesCol.memptr(), inputWidth, inputHeight);\n reset = true;\n\n cout << \"All parameters of layer : \" << endl;\n cout << \"kernelWidth : \" << kernelWidth << endl;\n cout << \"kernelHeight : \" << kernelHeight << endl;\n cout << \"strideWidth : \" << strideWidth << endl;\n cout << \"strideHeight : \" << strideHeight << endl;\n cout << \"inputWidth : \" << inputWidth << endl;\n cout << \"inputHeight : \" << inputHeight << endl;\n cout << \"outputWidth : \" << outputWidth << endl;\n cout << \"outputHeight : \" << outputHeight << endl;\n cout << \"batchSize : \" << batchSize << endl;\n cout << \"inSize : \" << inSize << endl;\n cout << \"outSize : \" << batchSize * inSize << endl;\n cout << \"offset : \" << offset << endl;\n cout << \"-------------------------------------\" << endl;\n\n cout << \"Calculations done inside (reset) conditional statement : \" << endl;\n cout << \"indicesCol : \" << endl;\n cout << \"indicesCol shape : \"<< indicesCol.n_rows << \" \" << indicesCol.n_cols << endl;\n cout << \"indicesCol (Transposed view) : \" << indicesCol.t() << endl;\n cout << \"indices : \" << endl;\n cout << \"indices shape : \"<< indices.n_rows << \" \" << indices.n_cols << endl;\n cout << indices << endl;\n cout << \"-------------------------------------\" << endl;\n\n for (size_t s = 0; s < inputTemp.n_slices; s++)\n {\n // PoolingOperation(inputTemp.slice(s), outputTemp.slice(s),poolingIndices.back().slice(s));\n\n const arma::mat& in = inputTemp.slice(s);\n arma::mat& out = outputTemp.slice(s);\n arma::mat& poolIndexes = poolingIndices.back().slice(s);\n\n cout << \"poolingIndices FOR SLICE \" << s << \" BEFORE POOLING: \" << endl;\n cout << poolingIndices.back().slice(s)<< endl;\n cout << \"-------------------------------------\" << endl;\n\n cout << \"POOLING OPERATIONS START NOW.\" << endl;\n cout << \"-------------------------------------\" << endl;\n\n size_t x = 0;\n for (size_t j = 0, colidx = 0; j < out.n_cols; ++j, colidx += strideHeight)\n {\n size_t y = 0;\n for (size_t i = 0, rowidx = 0; i < out.n_rows; ++i, rowidx += strideWidth)\n {\n\n arma::mat subInput = in(\n arma::span(rowidx, rowidx + kernelWidth - 1 - offset),\n arma::span(colidx, colidx + kernelHeight - 1 - offset)\n );\n\n // const size_t idx = pooling.Pooling(subInput);\n const size_t idx = arma::as_scalar(arma::find(subInput.max() == subInput, 1));\n out(i, j) = subInput(idx);\n\n\n arma::Mat subIndices = indices(\n arma::span(rowidx, rowidx + kernelWidth - 1 - offset),\n arma::span(colidx, colidx + kernelHeight - 1 - offset)\n );\n\n poolIndexes(i, j) = subIndices(idx);\n\n cout << \"COUNTER (\" << x << \", \" << y << \") CALCULATIONS : \" << endl;\n cout << \"subInput : \" << endl;\n cout << subInput << endl;\n cout << \"subIndices : \" << endl;\n cout << subIndices << endl;\n cout << \"idx : \" << idx << endl;\n cout << \"subInput(idx) : \" << endl;\n cout << subInput(idx) << endl;\n cout << \"subIndices(idx) : \" << endl;\n cout << subIndices(idx) << endl;\n cout << \"-------------------------------------\" << endl;\n y++;\n }\n x++;\n }\n\n cout << \"POOLING OPERATIONS END NOW.\" << endl;\n cout << \"-------------------------------------\" << endl;\n\n cout << \"poolingIndices FOR SLICE \" << s << \" POST POOLING: \" << endl;\n cout << poolingIndices.back().slice(s)<< endl;\n cout << \"-------------------------------------\" << endl;\n\n }\n\n cout << \"inputTemp AFTER POOLING: \" << endl;\n cout << \"inputTemp shape : \"<< inputTemp.n_rows << \" \" << inputTemp.n_cols << endl;\n cout << \"Num slices : \" << inputTemp.n_slices << endl;\n cout << inputTemp << endl;\n cout << \"-------------------------------------\" << endl;\n\n cout << \"outputTemp AFTER POOLING: \" << endl;\n cout << \"outputTemp shape : \"<< outputTemp.n_rows << \" \" << outputTemp.n_cols << endl;\n cout << outputTemp << endl;\n cout << \"-------------------------------------\" << endl;\n\n output = arma::mat(outputTemp.memptr(), outputTemp.n_elem / batchSize, batchSize);\n outputWidth = outputTemp.n_rows;\n outputHeight = outputTemp.n_cols;\n outSize = batchSize * inSize;\n\n cout << \"OUTPUT : \" << endl;\n cout << \"Output shape : \"<< output.n_rows << \" \" << output.n_cols << endl;\n cout << \"Output (Transposed view) : \" << output.t() << endl;\n cout << \"-------------------------------------\" << endl;\n\n\n cout << \"-------------------------------------\" << endl;\n cout << \"PSEUDO BACKWARD : \" << endl;\n cout << \"-------------------------------------\" << endl;\n\n arma::cube gTemp;\n gTemp = arma::zeros(inputTemp.n_rows, inputTemp.n_cols, inputTemp.n_slices);\n\n arma::cube mappedError;\n mappedError = arma::ones(outputWidth, outputHeight, outSize);\n\n for (size_t s = 0; s < mappedError.n_slices; s++)\n {\n //Unpooling(mappedError.slice(s), gTemp.slice(s), poolingIndices.back().slice(s));\n\n const arma::mat& error = mappedError.slice(s);\n arma::mat& out = gTemp.slice(s);\n arma::mat& poIdx = poolingIndices.back().slice(s);\n\n for (size_t i = 0; i < poIdx.n_elem; ++i)\n {\n out(poIdx(i)) += error(i);\n }\n\n cout << \"OUTPUT : \" << endl;\n cout << \"Output shape : \"<< out.n_rows << \" \" << out.n_cols << endl;\n cout << \"Output (Transposed view) : \" << endl << out << endl;\n cout << \"-------------------------------------\" << endl;\n }\n\n\n cout << \"-------------------------------------\" << endl;\n cout << \"UNPOOLING : \" << endl;\n cout << \"-------------------------------------\" << endl;\n\n // Output of MaxPool is the input for UnPooling.\n input = arma::zeros(4, 1);\n input(0) = 2.1;\n input(1) = 2.3;\n input(2) = 1.8;\n input(3) = 1.7;\n\n cout << \"-------------------------------------\" << endl;\n cout << \"INPUT FOR UNPOOLING: \" << endl;\n cout << \"Input shape : \"<< input.n_rows << \" \" << input.n_cols << endl;\n cout << \"Input (Transposed view) : \" << input.t() << endl;\n cout << \"-------------------------------------\" << endl;\n\n inSize = 0;\n outSize = 0;\n reset = false;\n inputWidth = 0;\n inputHeight = 0;\n outputWidth = 0;\n outputHeight = 0;\n batchSize = 0;\n\n inputHeight = 2;\n inputWidth = 2;\n batchSize = input.n_cols;\n inSize = input.n_elem / (inputWidth * inputHeight * batchSize);\n\n // cube(ptr_aux_mem, n_rows, n_cols, n_slices, copy_aux_mem = true, strict = false)\n inputTemp = arma::cube(const_cast(input).memptr(),\n inputWidth, inputHeight, batchSize * inSize, false, false);\n\n cout << \"inputTemp BEFORE UNPOOLING: \" << endl;\n cout << \"inputTemp shape : \"<< inputTemp.n_rows << \" \" << inputTemp.n_cols << endl;\n cout << \"Num slices : \" << inputTemp.n_slices << endl;\n cout << inputTemp << endl;\n cout << \"-------------------------------------\" << endl;\n\n outputWidth = (inputWidth - 1) * strideWidth + kernelWidth;\n outputHeight = (inputHeight - 1) * strideHeight + kernelHeight;\n outSize = batchSize * inSize;\n outputTemp = arma::zeros(outputWidth, outputHeight,\n outSize);\n\n cout << \"outputTemp BEFORE UNPOOLING: \" << endl;\n cout << \"outputTemp shape : \"<< outputTemp.n_rows << \" \" << outputTemp.n_cols << endl;\n cout << outputTemp << endl;\n cout << \"-------------------------------------\" << endl;\n\n for (size_t s = 0; s < inputTemp.n_slices; s++)\n {\n // Unpooling(inputTemp.slice(s), outputTemp.slice(s), poolingIndices.back().slice(s));\n const arma::mat& IN = inputTemp.slice(s);\n arma::mat& OUT = outputTemp.slice(s);\n arma::mat& INDICES = poolingIndices.back().slice(s);\n\n for (size_t i = 0; i < INDICES.n_elem; ++i)\n {\n OUT(INDICES(i)) += IN(i);\n }\n\n cout << \"OUTPUT : \" << endl;\n cout << \"Output shape : \"<< OUT.n_rows << \" \" << OUT.n_cols << endl;\n cout << \"Output : \" << endl << OUT << endl;\n cout << \"-------------------------------------\" << endl;\n }\n\n cout << \"inputTemp AFTER UNPOOLING: \" << endl;\n cout << \"inputTemp shape : \"<< inputTemp.n_rows << \" \" << inputTemp.n_cols << endl;\n cout << \"Num slices : \" << inputTemp.n_slices << endl;\n cout << inputTemp << endl;\n cout << \"-------------------------------------\" << endl;\n\n cout << \"outputTemp AFTER UNPOOLING: \" << endl;\n cout << \"outputTemp shape : \"<< outputTemp.n_rows << \" \" << outputTemp.n_cols << endl;\n cout << outputTemp << endl;\n cout << \"-------------------------------------\" << endl;\n\n cout << \"-------------------------------------\" << endl;\n cout << \"UNPOOLING BACKWARD (PROOF OF CONCEPT): \" << endl;\n cout << \"-------------------------------------\" << endl;\n\n arma::mat L;\n L = arma::zeros(16, 1);\n L(0) = 1;\n L(1) = 2;\n L(2) = 3;\n L(3) = 4;\n L(4) = 5;\n L(5) = 6;\n L(6) = 7;\n L(7) = 8;\n L(8) = 9;\n L(9) = 10;\n L(10) = 11;\n L(11) = 12;\n L(12) = 13;\n L(13) = 14;\n L(14) = 15;\n L(15) = 16;\n\n mappedError = arma::cube(const_cast(L).memptr(), outputWidth, outputHeight, outSize, false, false);\n gTemp = arma::zeros(inputWidth, inputHeight, outSize);\n\n for (size_t s = 0; s < gTemp.n_slices; s++)\n {\n arma::mat& gySlice = mappedError.slice(s);\n arma::mat& gSlice = gTemp.slice(s);\n arma::mat& idxs = poolingIndices.back().slice(s);\n\n cout << \"gySlice: \" << endl;\n cout << \"gy shape : \"<< gySlice.n_rows << \" \" << gySlice.n_cols << endl;\n cout << gySlice << endl;\n cout << \"-------------------------------------\" << endl;\n\n cout << \"gTempSlice BEFORE: \" << endl;\n cout << \"g shape : \"<< gSlice.n_rows << \" \" << gSlice.n_cols << endl;\n cout << gSlice << endl;\n cout << \"-------------------------------------\" << endl;\n\n for (size_t i = 0, j = 0; i < idxs.n_elem; ++i, ++j)\n {\n gSlice(j) = gySlice(idxs(i));\n }\n\n cout << \"gTempSlice AFTER: \" << endl;\n cout << \"g shape : \"<< gSlice.n_rows << \" \" << gSlice.n_cols << endl;\n cout << gSlice << endl;\n cout << \"-------------------------------------\" << endl;\n }\n\n arma::mat g = arma::mat(gTemp.memptr(), gTemp.n_elem / batchSize, batchSize);\n cout << \"g: \" << endl;\n cout << \"g shape : \"<< g.n_rows << \" \" << g.n_cols << endl;\n cout << g << endl;\n cout << \"-------------------------------------\" << endl;\n\n return 0;\n}\n", "meta": {"hexsha": "c21fe445305c99f8896e5cf111b8cefe63c15bd2", "size": 12941, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "unpool/test.cpp", "max_stars_repo_name": "iamshnoo/mlpack-testing", "max_stars_repo_head_hexsha": "43f9fde18afc7f1e6d54c0a2bd59709c103eed55", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "unpool/test.cpp", "max_issues_repo_name": "iamshnoo/mlpack-testing", "max_issues_repo_head_hexsha": "43f9fde18afc7f1e6d54c0a2bd59709c103eed55", "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": "unpool/test.cpp", "max_forks_repo_name": "iamshnoo/mlpack-testing", "max_forks_repo_head_hexsha": "43f9fde18afc7f1e6d54c0a2bd59709c103eed55", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.6943699732, "max_line_length": 114, "alphanum_fraction": 0.5187388919, "num_tokens": 3802, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891305219503, "lm_q2_score": 0.658417500561683, "lm_q1q2_score": 0.5413437123072459}} {"text": "#include \"itkImage.h\"\n#include \"itkImageFileReader.h\"\n#include \"itkImageFileWriter.h\"\n#include \"vnl/vnl_matrix_ref.h\"\n#include \"vnl/vnl_matrix.h\"\n#include \"itkNumericTraits.h\"\n\n#include \"tkdCmdParser.h\"\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n/**\n * (Relative) Betweenness centrality.\n */\ntemplate< class DirectedProperty = boost::undirectedS >\nclass BC\n{\npublic:\n\n\ttypedef double PixelType;\n\n\ttypedef boost::property< boost::vertex_index_t, unsigned int, boost::property< boost::vertex_centrality_t, PixelType > > VertexPropertyType;\n\ttypedef boost::property< boost::edge_weight_t, PixelType, boost::property< boost::edge_centrality_t, PixelType > > EdgePropertyType;\n\ttypedef boost::adjacency_matrix< DirectedProperty, VertexPropertyType, EdgePropertyType > GraphMatrixType;\n\n\ttypedef itk::Image< PixelType, 2 > ImageType;\n\ttypedef vnl_matrix_ref< PixelType > DataMatrixType;\n\ttypedef vnl_vector< PixelType > VectorType;\n\n\t/**\n\t * Run.\n\t */\n\tvoid Run( const std::string& filename, PixelType lowerThreshold, PixelType upperThreshold, const std::string& outputFileName,\n\t\t\tbool relative, bool dominance )\n\t{\n\t\ttypedef itk::ImageFileReader< ImageType > ReaderType;\n\t\ttypename ReaderType::Pointer reader = ReaderType::New();\n\t\treader->SetFileName( filename.c_str() );\n\t\treader->Update();\n\n\t\ttypename ImageType::Pointer image = reader->GetOutput();\n\t\treader = 0;\n\n\t\tPixelType* buffer = image->GetPixelContainer()->GetBufferPointer();\n\t\ttypename ImageType::RegionType region = image->GetLargestPossibleRegion();\n\t\ttypename ImageType::SizeType size = region.GetSize();\n\t\tint rows = size[0];\n\t\tint cols = size[1];\n\n\t\tDataMatrixType data( rows, cols, buffer );\n\n\t\ttypename ImageType::Pointer output = ImageType::New();\n\t\toutput->CopyInformation( image );\n\t\toutput->SetRegions( image->GetLargestPossibleRegion() );\n\t\toutput->Allocate();\n\t\toutput->FillBuffer( 0 );\n\n\t\tDataMatrixType distance( rows, cols, output->GetPixelContainer()->GetBufferPointer() );\n\n\t\tGraphMatrixType g( rows );\n\n\t\t/* TEST List -> weighted version works, and indeed lower values are shorter paths,\n\t\tGraphMatrixType g( 5 );\n\t\tboost::add_edge( 0, 1, EdgePropertyType( 1.0 ), g );\n\t\tboost::add_edge( 1, 4, EdgePropertyType( 0.2 ), g );\n\t\tboost::add_edge( 4, 3, EdgePropertyType( 0.3 ), g );\n\t\tboost::add_edge( 0, 2, EdgePropertyType( 1.0 ), g );\n\t\tboost::add_edge( 2, 3, EdgePropertyType( 1.0 ), g );\n\t\t*/\n\n\t\tconst bool isUndirected = typeid(DirectedProperty) == typeid(boost::undirectedS);\n\t\tfor ( int i = 0; i < rows; ++i )\n\t\t{\n\t\t\tint start = isUndirected ? i + 1 : 0;\n\t\t\tfor ( int j = start; j < cols; ++j )\n\t\t\t{\n\t\t\t\tif ( i == j )\n\t\t\t\t{\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tPixelType weight = data( i, j );\n\n\t\t\t\tif ( weight <= upperThreshold && weight > 0 && weight > lowerThreshold )\n\t\t\t\t{\n\t\t\t\t\t// bc makes use of fwsp, so invert weight (correlation coefficients ...)\n\t\t\t\t\tboost::add_edge( i, j, EdgePropertyType( 1.0 / weight ), g );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tVectorType centrality( boost::num_vertices( g ) );\n\t\ttypename boost::graph_traits< GraphMatrixType >::vertex_iterator vi, vi_end;\n\n\t\tboost::brandes_betweenness_centrality( g,\n\t\t\t\tcentrality_map( boost::get( boost::vertex_centrality, g ) ).\n\t\t\t\tedge_centrality_map( boost::get( boost::edge_centrality, g ) ).\n\t\t\t\tweight_map( boost::get(\n\t\t\t\t\t\tboost::edge_weight, g ) ) );\n\n\t\tif ( !relative )\n\t\t{\n\t\t\ttypename boost::property_map< GraphMatrixType, boost::vertex_centrality_t >::type b = boost::get( boost::vertex_centrality, g );\n\n\t\t\tfor ( tie( vi, vi_end ) = vertices( g ); vi != vi_end; ++vi )\n\t\t\t\tcentrality[*vi] = b[*vi];\n\t\t}\n\t\telse\n\t\t{\n\t\t\tboost::relative_betweenness_centrality( g, boost::get( boost::vertex_centrality, g ) );\n\t\t\ttypename boost::property_map< GraphMatrixType, boost::vertex_centrality_t >::type r = boost::get( boost::vertex_centrality, g );\n\n\t\t\tfor ( boost::tie( vi, vi_end ) = vertices( g ); vi != vi_end; ++vi )\n\t\t\t\tcentrality[*vi] = r[*vi];\n\n\t\t\t// Central point dominance is correct if and only if betweenness centrality is relative!\n\t\t\tif ( dominance )\n\t\t\t{\n\t\t\t\tdouble dominance = boost::central_point_dominance( g, boost::get( boost::vertex_centrality, g ) );\n\t\t\t\tstd::cout << \"Dominance,\" << dominance << std::endl;\n\t\t\t}\n\t\t}\n\n\t\tWriteVectorToFile( outputFileName, centrality );\n\t}\n\n\t/**\n\t * Write vector to filename.\n\t */\n\tvoid WriteVectorToFile( const std::string& outputFileName, const VectorType& V )\n\t{\n\t\tstd::ofstream out( outputFileName.c_str() );\n\n\t\tif ( out.fail() )\n\t\t{\n\t\t\tstd::cerr << \"*** ERROR ***: Not able to write to: \" << outputFileName << \"!\" << std::endl;\n\t\t\texit( EXIT_FAILURE );\n\t\t}\n\n\t\tfor ( unsigned int i = 0; i < V.size(); i++ )\n\t\t\tout << V[i] << std::endl;\n\n\t\tout.close();\n\t}\n};\n\n/**\n * Betweenness centrality.\n */\nint main( int argc, char ** argv )\n{\n\ttkd::CmdParser p( \"betweenness centrality\", \"Calculate betweenness centrality measure for all vertices\" );\n\n\tstd::string inputFileName;\n\tstd::string outputFileName;\n\n\tfloat lowerThreshold = 0;\n\tfloat upperThreshold = 1.0;\n\tbool isUndirected = true;\n\tbool relative = true;\n\tbool dominance = false;\n\n\tp.AddArgument( inputFileName, \"input\" ) ->AddAlias( \"i\" ) ->SetDescription( \"Input image: 2D adjacency matrix\" ) ->SetRequired( true );\n\n\tp.AddArgument( upperThreshold, \"threshold\" ) ->AddAlias( \"thu\" ) ->AddAlias( \"t\" ) ->SetDescription(\n\t\t\t\"Threshold; only include paths with weight in (0, threshold] (default: 1.0)\" );\n\n\tp.AddArgument( lowerThreshold, \"threshold-lower\" ) ->AddAlias( \"thl\" ) ->SetDescription(\n\t\t\t\"Lower threshold; only include paths with weight > threshold (default: 0)\" );\n\n\tp.AddArgument( outputFileName, \"output\" ) ->AddAlias( \"o\" ) ->SetDescription(\n\t\t\t\"Output image: List with (relative) betweenness centralities per vertex\" ) ->SetRequired( true );\n\n\tp.AddArgument( isUndirected, \"undirected\" ) ->AddAlias( \"u\" ) ->SetDescription(\n\t\t\t\"Input is a symmetric matrix representing an undirected graph [default: true]\" );\n\n\tp.AddArgument( relative, \"relative\" ) ->AddAlias( \"r\" ) ->SetDescription( \"Relative betweenness centrality algorithm [default: true]\" );\n\n\tp.AddArgument( dominance, \"dominance\" ) ->AddAlias( \"d\" ) ->SetDescription( \"Print central point dominance [relative only, default: false]\" );\n\n\tif ( !p.Parse( argc, argv ) )\n\t{\n\t\tp.PrintUsage( std::cout );\n\t\treturn -1;\n\t}\n\n\tif ( isUndirected )\n\t{\n\t\tBC< boost::undirectedS > bc;\n\t\tbc.Run( inputFileName, lowerThreshold, upperThreshold, outputFileName, relative, dominance );\n\t} else\n\t{\n\t\tBC< boost::directedS > bc;\n\t\tbc.Run( inputFileName, lowerThreshold, upperThreshold, outputFileName, relative, dominance );\n\t}\n\n\treturn EXIT_SUCCESS;\n}\n\n", "meta": {"hexsha": "367fd9c6e1d8c49e3e76af9f34b993a8056890e5", "size": 6800, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/graphs/betweenness.cpp", "max_stars_repo_name": "wmotte/toolkid", "max_stars_repo_head_hexsha": "2a8f82e1492c9efccde9a4935ce3019df1c68cde", "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/graphs/betweenness.cpp", "max_issues_repo_name": "wmotte/toolkid", "max_issues_repo_head_hexsha": "2a8f82e1492c9efccde9a4935ce3019df1c68cde", "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/graphs/betweenness.cpp", "max_forks_repo_name": "wmotte/toolkid", "max_forks_repo_head_hexsha": "2a8f82e1492c9efccde9a4935ce3019df1c68cde", "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.5358851675, "max_line_length": 143, "alphanum_fraction": 0.6891176471, "num_tokens": 1899, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.822189121808099, "lm_q2_score": 0.6584175072643413, "lm_q1q2_score": 0.5413437120807465}} {"text": "\n// Copyright (c) 2007, 2008 libmv authors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n// IN THE SOFTWARE.\n\n// This file is part of OpenMVG, an Open Multiple View Geometry C++ library.\n\n// Copyright (c) 2012, 2013 Pierre MOULON.\n\n// This Source Code Form is subject to the terms of the Mozilla Public\n// License, v. 2.0. If a copy of the MPL was not distributed with this\n// file, You can obtain one at http://mozilla.org/MPL/2.0/.\n\n#include \"openMVG/numeric/numeric.h\"\n\n#include \n\n#include \n\nnamespace openMVG {\n\nMat3 CrossProductMatrix(const Vec3 &x) {\n Mat3 X;\n X << 0, -x(2), x(1),\n x(2), 0, -x(0),\n -x(1), x(0), 0;\n return X;\n}\n\nMat3 RotationAroundX(double angle) {\n return Eigen::AngleAxisd(angle, Vec3::UnitX()).toRotationMatrix();\n}\n\nMat3 RotationAroundY(double angle) {\n return Eigen::AngleAxisd(angle, Vec3::UnitY()).toRotationMatrix();\n}\n\nMat3 RotationAroundZ(double angle) {\n return Eigen::AngleAxisd(angle, Vec3::UnitZ()).toRotationMatrix();\n}\n\ndouble getRotationMagnitude(const Mat3 & R2) {\n const Mat3 R1 = Mat3::Identity();\n double cos_theta = (R1.array() * R2.array()).sum() / 3.0;\n cos_theta = clamp(cos_theta, -1.0, 1.0);\n return std::acos(cos_theta);\n}\n\nMat3 LookAt(const Vec3 ¢er, const Vec3 & up) {\n Vec3 zc = center.normalized();\n Vec3 xc = up.cross(zc).normalized();\n Vec3 yc = zc.cross(xc);\n Mat3 R;\n R.row(0) = xc;\n R.row(1) = yc;\n R.row(2) = zc;\n return R;\n}\n\n//eyePosition3D is a XYZ position. This is where you are (your eye is).\n//center3D is the XYZ position where you want to look at.\n//upVector3D is a XYZ normalized vector. Quite often 0.0, 1.0, 0.0\n\nMat3 LookAt2(const Vec3 &eyePosition3D,\n const Vec3 ¢er3D,\n const Vec3 &upVector3D )\n{\n Vec3 forward, side, up;\n Mat3 matrix2, resultMatrix;\n //------------------\n forward = center3D - eyePosition3D;\n forward.normalize();\n //------------------\n //Side = forward x up\n //ComputeNormalOfPlane(side, forward, upVector3D);\n side[0]=(forward[1]*upVector3D[2])-(forward[2]*upVector3D[1]);\n side[1]=(forward[2]*upVector3D[0])-(forward[0]*upVector3D[2]);\n side[2]=(forward[0]*upVector3D[1])-(forward[1]*upVector3D[0]);\n side.normalize();\n //------------------\n //Recompute up as: up = side x forward\n //ComputeNormalOfPlane(up, side, forward);\n up[0]=(side[1]*forward[2])-(side[2]*forward[1]);\n up[1]=(side[2]*forward[0])-(side[0]*forward[2]);\n up[2]=(side[0]*forward[1])-(side[1]*forward[0]);\n\n //------------------\n matrix2(0) = side[0];\n matrix2(1) = side[1];\n matrix2(2) = side[2];\n //------------------\n matrix2(3) = up[0];\n matrix2(4) = up[1];\n matrix2(5) = up[2];\n //------------------\n matrix2(6) = -forward[0];\n matrix2(7) = -forward[1];\n matrix2(8) = -forward[2];\n\n return matrix2;\n}\n\nvoid MeanAndVarianceAlongRows(const Mat &A,\n Vec *mean_pointer,\n Vec *variance_pointer) {\n const Mat::Index n = A.rows();\n const double m = static_cast(A.cols());\n (*mean_pointer) = Vec::Zero(n);\n (*variance_pointer) = Vec::Zero(n);\n\n for (Mat::Index i = 0; i < n; ++i) {\n (*mean_pointer)(i) += A.row(i).array().sum();\n (*variance_pointer)(i) += (A.row(i).array() * A.row(i).array()).array().sum();\n }\n (*mean_pointer) /= m;\n for (Mat::Index i = 0; i < n; ++i) {\n (*variance_pointer)(i) = (*variance_pointer)(i) / m - Square((*mean_pointer)(i));\n }\n}\n\nbool exportMatToTextFile(const Mat & mat, const std::string & filename,\n const std::string & sPrefix)\n{\n bool bOk = false;\n std::ofstream outfile;\n outfile.open(filename.c_str(), std::ios_base::out);\n if (outfile.is_open()) {\n outfile << sPrefix << \"=[\" << std::endl;\n for (int j=0; j < mat.rows(); ++j) {\n for (int i=0; i < mat.cols(); ++i) {\n outfile << mat(j,i) << \" \";\n }\n outfile << \";\\n\";\n }\n outfile << \"];\";\n bOk = true;\n }\n outfile.close();\n return bOk;\n}\n\n} // namespace openMVG\n", "meta": {"hexsha": "61b4d015bbb095f4e4324350ad17f4f21a07ec21", "size": 4900, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "pose_refinement/SA-LMPE/ba/openMVG/numeric/numeric.cpp", "max_stars_repo_name": "Aurelio93/satellite-pose-estimation", "max_stars_repo_head_hexsha": "46957a9bc9f204d468f8fe3150593b3db0f0726a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 90.0, "max_stars_repo_stars_event_min_datetime": "2019-05-19T03:48:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-02T15:20:49.000Z", "max_issues_repo_path": "pose_refinement/SA-LMPE/ba/openMVG/numeric/numeric.cpp", "max_issues_repo_name": "Aurelio93/satellite-pose-estimation", "max_issues_repo_head_hexsha": "46957a9bc9f204d468f8fe3150593b3db0f0726a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 11.0, "max_issues_repo_issues_event_min_datetime": "2019-05-22T07:45:46.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-20T01:48:26.000Z", "max_forks_repo_path": "pose_refinement/SA-LMPE/ba/openMVG/numeric/numeric.cpp", "max_forks_repo_name": "Aurelio93/satellite-pose-estimation", "max_forks_repo_head_hexsha": "46957a9bc9f204d468f8fe3150593b3db0f0726a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 18.0, "max_forks_repo_forks_event_min_datetime": "2019-05-19T03:48:32.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-29T18:19:16.000Z", "avg_line_length": 30.8176100629, "max_line_length": 85, "alphanum_fraction": 0.6416326531, "num_tokens": 1485, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7634837527911057, "lm_q2_score": 0.7090191399336402, "lm_q1q2_score": 0.5413245937572577}} {"text": "/*\n [auto_generated]\n boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp\n\n [begin_description]\n tba.\n [end_description]\n\n Copyright 2009-2012 Karsten Ahnert\n Copyright 2009-2012 Mario Mulansky\n\n Distributed under the Boost Software License, Version 1.0.\n (See accompanying file LICENSE_1_0.txt or\n copy at http://www.boost.org/LICENSE_1_0.txt)\n*/\n\n\n#ifndef BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_RKN_SB3A_M4_MCLACHLAN_HPP_DEFINED\n#define BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_RKN_SB3A_M4_MCLACHLAN_HPP_DEFINED\n\n#include \n#include \n#include \n\n#include \n\n\nnamespace boost {\nnamespace numeric {\nnamespace odeint {\n\n#ifndef DOXYGEN_SKIP\nnamespace detail {\nnamespace symplectic_rkn_sb3a_m4_mclachlan {\n\n /*\n exp( a1 t A ) exp( b1 t B )\n exp( a2 t A ) exp( b2 t B )\n exp( a3 t A )\n exp( b2 t B ) exp( a2 t A )\n exp( b1 t B ) exp( a1 t A )\n */\n\n\n\n template< class Value >\n struct coef_a_type : public boost::array< Value , 5 >\n {\n coef_a_type( void )\n {\n using std::sqrt;\n\n Value z = sqrt( static_cast< Value >( 7 ) / static_cast< Value >( 8 ) ) / static_cast< Value >( 3 );\n (*this)[0] = static_cast< Value >( 1 ) / static_cast< Value >( 2 ) - z ;\n (*this)[1] = static_cast< Value >( -1 ) / static_cast< Value >( 3 ) + z ;\n (*this)[2] = static_cast< Value >( 2 ) / static_cast< Value >( 3 );\n (*this)[3] = (*this)[1];\n (*this)[4] = (*this)[0];\n }\n };\n\n template< class Value >\n struct coef_b_type : public boost::array< Value , 5 >\n {\n coef_b_type( void )\n {\n (*this)[0] = static_cast< Value >( 1 );\n (*this)[1] = static_cast< Value >( -1 ) / static_cast< Value >( 2 );\n (*this)[2] = (*this)[1];\n (*this)[3] = (*this)[0];\n (*this)[4] = static_cast< Value >( 0 );\n }\n };\n\n} // namespace symplectic_rkn_sb3a_m4_mclachlan\n} // namespace detail\n#endif // DOXYGEN_SKIP\n\n\n\n\ntemplate<\n class Coor ,\n class Momentum = Coor ,\n class Value = double ,\n class CoorDeriv = Coor ,\n class MomentumDeriv = Coor ,\n class Time = Value ,\n class Algebra = typename algebra_dispatcher< Coor >::algebra_type ,\n class Operations = typename operations_dispatcher< Coor >::operations_type ,\n class Resizer = initially_resizer\n >\n#ifndef DOXYGEN_SKIP\nclass symplectic_rkn_sb3a_m4_mclachlan :\n public symplectic_nystroem_stepper_base\n<\n 5 , 4 ,\n Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer\n >\n#else\nclass symplectic_rkn_sb3a_m4_mclachlan : public symplectic_nystroem_stepper_base\n#endif\n{\npublic:\n#ifndef DOXYGEN_SKIP\n typedef symplectic_nystroem_stepper_base\n <\n 5 , 4 ,\n Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer\n > stepper_base_type;\n#endif\n typedef typename stepper_base_type::algebra_type algebra_type;\n typedef typename stepper_base_type::value_type value_type;\n\n\n symplectic_rkn_sb3a_m4_mclachlan( const algebra_type &algebra = algebra_type() )\n : stepper_base_type(\n detail::symplectic_rkn_sb3a_m4_mclachlan::coef_a_type< value_type >() ,\n detail::symplectic_rkn_sb3a_m4_mclachlan::coef_b_type< value_type >() ,\n algebra )\n { }\n};\n\n\n/***************** DOXYGEN ***************/\n\n/**\n * \\class symplectic_rkn_sb3a_m4_mclachlan\n * \\brief Implementation of the symmetric B3A Runge-Kutta Nystroem method of fifth order.\n *\n * The method is of fourth order and has five stages. It is described HERE. This method can be used\n * with multiprecision types since the coefficients are defined analytically.\n *\n * ToDo: add reference to paper.\n *\n * \\tparam Order The order of the stepper.\n * \\tparam Coor The type representing the coordinates q.\n * \\tparam Momentum The type representing the coordinates p.\n * \\tparam Value The basic value type. Should be something like float, double or a high-precision type.\n * \\tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.\n * \\tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.\n * \\tparam Time The type representing the time t.\n * \\tparam Algebra The algebra.\n * \\tparam Operations The operations.\n * \\tparam Resizer The resizer policy.\n */\n\n /**\n * \\fn symplectic_rkn_sb3a_m4_mclachlan::symplectic_rkn_sb3a_m4_mclachlan( const algebra_type &algebra )\n * \\brief Constructs the symplectic_rkn_sb3a_m4_mclachlan. This constructor can be used as a default\n * constructor if the algebra has a default constructor.\n * \\param algebra A copy of algebra is made and stored inside explicit_stepper_base.\n */\n\n} // namespace odeint\n} // namespace numeric\n} // namespace boost\n\n\n#endif // BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_RKN_SB3A_M4_MCLACHLAN_HPP_DEFINED\n", "meta": {"hexsha": "1b9756cc1ad80dbec6be0f0e57addd21b3fbf560", "size": 5120, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "Externals/Boost/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp", "max_stars_repo_name": "MINATILO/packing-generation", "max_stars_repo_head_hexsha": "4d4f5d037e0687b57178602b989431e82a5c8b96", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 79.0, "max_stars_repo_stars_event_min_datetime": "2015-08-23T12:05:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T16:39:56.000Z", "max_issues_repo_path": "Externals/Boost/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp", "max_issues_repo_name": "MINATILO/packing-generation", "max_issues_repo_head_hexsha": "4d4f5d037e0687b57178602b989431e82a5c8b96", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 31.0, "max_issues_repo_issues_event_min_datetime": "2015-07-20T17:57:08.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-02T10:31:50.000Z", "max_forks_repo_path": "Externals/Boost/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp", "max_forks_repo_name": "MINATILO/packing-generation", "max_forks_repo_head_hexsha": "4d4f5d037e0687b57178602b989431e82a5c8b96", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 36.0, "max_forks_repo_forks_event_min_datetime": "2015-10-14T02:43:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-18T12:51:03.000Z", "avg_line_length": 31.801242236, "max_line_length": 112, "alphanum_fraction": 0.680078125, "num_tokens": 1410, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.785308580887758, "lm_q2_score": 0.6893056231680121, "lm_q1q2_score": 0.5413176207280233}} {"text": "/* Copyright (c) 2015, Julian Straub , Randi Cabezas \n * Licensed under the MIT license. See the license file LICENSE.\n */\n \n\n#pragma once\n#include \n#include \n#include \n#include \n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace Eigen;\nusing std::cout;\nusing std::endl; \nusing boost::shared_ptr;\nusing std::vector; \n\ntemplate\nclass DirNaiveBayes : public DpMM{\n\npublic:\n DirNaiveBayes(const Dir, T>& alpha, const boost::shared_ptr >& theta);\n DirNaiveBayes(const Dir, T>& alpha, const vector > >&thetas);\n virtual ~DirNaiveBayes();\n\n virtual void initialize(const vector< Matrix >&x);\n virtual void initialize(const boost::shared_ptr >&cld)\n {cout<<\"not supported\"<& logLikes);\n\n Matrix getCounts();\n\n virtual void inferAll(uint32_t nIter, bool verbose=false);\n virtual void dump(std::ofstream& fOutMeans, std::ofstream& fOutCovs); \n\nprotected: \n uint32_t K_;\n Dir, T> dir_;\n Cat pi_;\n#ifdef CUDA\n SamplerGpu* sampler_;\n#else \n Sampler* sampler_;\n#endif\n Matrix pdfs_;\n// Cat cat_;\n vector > > thetas_;\n\n vector > x_;\n VectorXu z_;\n};\n\n// --------------------------------------- impl -------------------------------\n\n\ntemplate\nDirNaiveBayes::DirNaiveBayes(const Dir,T>& alpha, const boost::shared_ptr >& theta) :\n K_(alpha.K_), dir_(alpha), pi_(dir_.sample()) //cat_(dir_.sample()),\n{\n// init the parameters\n cout<<\"[DirNaiveBayes::DirNaiveBayes] creating thetas (you only gave me one)\"< >(theta->copy()));\n};\n\n\ntemplate\nDirNaiveBayes::DirNaiveBayes(const Dir,T>& alpha, \n const vector > >& thetas) :\n K_(alpha.K_), dir_(alpha), pi_(dir_.sample()), //cat_(dir_.sample()),\n thetas_(thetas)\n{};\n\n\ntemplate\nDirNaiveBayes::~DirNaiveBayes()\n{\n if (sampler_ != NULL) delete sampler_;\n};\n\ntemplate \nMatrix DirNaiveBayes::getCounts()\n{\n return counts(z_,K_);\n};\n\n\ntemplate\nvoid DirNaiveBayes::initialize(const vector< Matrix > &x)\n{\n cout<<\"init\"<(uint32_t(x.size()),K_,dir_.pRndGen_);\n#else \n sampler_ = new Sampler(dir_.pRndGen_);\n#endif\n\n#pragma omp parallel for\n for(int32_t k=0; kposterior(x_,z_,k);\n};\n\ntemplate\nvoid DirNaiveBayes::sampleLabels()\n{\n // obtain posterior categorical under labels\n pi_ = dir_.posterior(z_).sample();\n// cout<logLikelihood(x_[i],w);\n\t\t}\n }\n// cout<sampleDiscPdf(pdfs_,z_);\n};\n\n\ntemplate\nvoid DirNaiveBayes::sampleParameters()\n{\n#pragma omp parallel for \n for(int32_t k=0; kposterior(x_,z_,k);\n// cout<<\"k:\"<print();\n }\n};\n\n\ntemplate\nT DirNaiveBayes::logJoint(bool verbose)\n{\n T logJoint = dir_.logPdf(pi_);\n if(verbose)\n \tcout<<\"log p(pi)=\"< \";\n\n#pragma omp parallel for reduction(+:logJoint) \n for (int32_t k=0; klogPdfUnderPrior();\n\tif(verbose)\n\t\tcout<<\"log p(pi)*p(theta)=\"< \";\n\n#pragma omp parallel for reduction(+:logJoint) \n for (int32_t i=0; ilogLikelihood(x_[i],w);\n if(verbose)\n \tcout<<\"log p(phi)*p(theta)*p(x|z,theta)=\"<\nMatrixXu DirNaiveBayes::mostLikelyInds(uint32_t n, Matrix& logLikes)\n{\n MatrixXu inds = MatrixXu::Zero(n,K_);\n logLikes = Matrix::Ones(n,K_);\n logLikes *= -99999.0;\n \n#pragma omp parallel for \n for (int32_t k=0; klogLikelihood(x_[i]);\n for (uint32_t j=0; jj; --l)\n {\n logLikes(l,k) = logLikes(l-1,k);\n inds(l,k) = inds(l-1,k);\n }\n logLikes(j,k) = logLike;\n inds(j,k) = i;\n// cout<<\"after update \"< out(n,K_*2);\n// out<(),inds.cast();\n// cout<\nvoid DirNaiveBayes::inferAll(uint32_t nIter, bool verbose)\n{ \n if(verbose){\n \tcout<<\"[DirNaiveBayes::inferALL] ------ inferingALL (nIter=\" << nIter << \") ------\"<labels().transpose()<sampleLabels();\n this->sampleParameters();\n if(verbose){\n\t\tcout << \"[\" << std::setw(3)<< std::setfill('0') << t <<\"] label: \" \n \t<< this->labels().transpose()\n \t<< \" [joint= \" << std::setw(6) << this->logJoint(false) << \"]\"<< endl;\n }\n }\n}\n\n\ntemplate \nvoid DirNaiveBayes::dump(std::ofstream& fOutMeans, std::ofstream& fOutCovs)\n{\n\tcout << \"dumping naiveBayes\" << endl; \n\tcout << \"doc index: \" << endl; \n\tcout << this->labels().transpose() << endl; \n\n\tcout << \"printing cluster params: \" << endl; \n\tcout << K_ << endl;\n\tfor(uint32_t k=0; kprint();\n\t}\n\n\tcout << \"printing mixture params: \" << endl;\n\tpi_.print();\n\n\n}\n", "meta": {"hexsha": "3b87ee4fee86e8bc6dc79187adf10dec5d579f26", "size": 7497, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/dpMM/dirNaiveBayes.hpp", "max_stars_repo_name": "jstraub/dpMM", "max_stars_repo_head_hexsha": "538c432d5f98c040d5c1adb072e545e38f97fc69", "max_stars_repo_licenses": ["MIT-feh"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2015-04-27T15:14:01.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-18T00:19:18.000Z", "max_issues_repo_path": "include/dpMM/dirNaiveBayes.hpp", "max_issues_repo_name": "jstraub/dpMM", "max_issues_repo_head_hexsha": "538c432d5f98c040d5c1adb072e545e38f97fc69", "max_issues_repo_licenses": ["MIT-feh"], "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/dpMM/dirNaiveBayes.hpp", "max_forks_repo_name": "jstraub/dpMM", "max_forks_repo_head_hexsha": "538c432d5f98c040d5c1adb072e545e38f97fc69", "max_forks_repo_licenses": ["MIT-feh"], "max_forks_count": 6.0, "max_forks_repo_forks_event_min_datetime": "2015-07-02T12:46:20.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T04:39:30.000Z", "avg_line_length": 26.585106383, "max_line_length": 120, "alphanum_fraction": 0.6217153528, "num_tokens": 2296, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7853085708384736, "lm_q2_score": 0.6893056231680122, "lm_q1q2_score": 0.5413176138009952}} {"text": "/*! \\file demo_2d_uncertainty.cpp\n \\brief Demonstration of some 2D plot features.\n \\details including showing values with uncertainty information as 'plus minus', confidence intervals and degrees of freedom estimates.\n*/\n\n// Copyright Jacob Voytko 2007\n// Copyright Paul A. Bristow 2007, 2008, 2009, 2021\n\n// Use, modification and distribution are subject to the\n// Boost Software License, Version 1.0.\n// (See accompanying file LICENSE_1_0.txt\n// or copy at http://www.boost.org/LICENSE_1_0.txt)\n\n// This file is written to be included from a Quickbook .qbk document.\n// It can be compiled by the C++ compiler, and run. Any output can\n// also be added here as comment or included or pasted in elsewhere.\n// Caution: this file contains Quickbook markup as well as code\n// and comments: don't change any of the special comment markups!\n\n//[demo_2d_uncertainty_1\n\n/*`First we need some includes to use Boost.SVG_Plot, and C++ Standard Library:\n*/\n\n#include \n// using namespace boost::svg;\n\n//#include // Only needed for showing ALL the many settings used.\n//using boost::svg::show_2d_plot_settings;\n//void boost::svg::show_2d_plot_settings(svg_2d_plot&);\n\n#include \n// using boost::svg::detail::pair; operator<<\n\n#include \n//#include \n\n#include \n\n#include \n// using std::copy;\n//#include \n\n#include \n //using std::map;\n //using std::multimap;\n\n#include \n //using std::pair;\n //using std::make_pair;\n\n#include \n// using std::vector;\n\n#include \n// using std::sqrt;\n\n#include \n //using std::cout;\n //using std::endl;\n //using std::scientific;\n //using std::hex;\n //using std::ios;\n //using std::boolalpha;\n#include \n// Using std::setw;\n// using std::setprecision;\n\n#include \n// using std::ostream_iterator;\n\n//] [/demo_2d_uncertainty_1]\n\n enum side\n { //! \\enum side Where axis labels go.\n left_side = -1,\n on_axis = 0,\n right_side = +1,\n bottom_side = -1,\n top_side = +1,\n };\n\nint main()\n{\n using std::pair;\n using std::make_pair;\n using std::vector;\n using std::map;\n using std::multimap;\n using std::cout;\n using std::endl;\n using std::scientific;\n using std::hex;\n using std::ios;\n using std::boolalpha;\n using std::sqrt;\n\n using namespace boost::svg;\n using boost::svg::detail::operator<<;\n\n\n try\n {\n//[demo_2d_uncertainty_2\n\n/*`STL map is used as the container for our two data-series,\nand pairs of values and their uncertainty information\n(approximately standard deviation and degrees of freedom)\nare inserted using push_back. Since this is a 2-D plot\nthe order of data values is important.\n*/\n typedef unc uncun; // Uncertain Uncorrelated (the normal case).\n\n using boost::svg::detail::operator<<;\n using std::ostream_iterator;\n\n setUncDefaults(std::cout); // Initialize for uncertain types.\n\n //setPlusminusSds(2); // cout.iword(plusminusSdsIndex);\n\n // Create pair for fundamental type double that is implicitly exact with no uncertainty information.\n pair double_pair; // double X and Y pair.\n double_pair = make_pair(double(-2.234), double(-8.76)); // Construct and then echo the data values thus:\n std::cout << double_pair.first << \", \" << double_pair.second << std::endl; // make_pair(double(-2.234), double(-8.76)) = -2.234, -8.76\n // But it is more convenient to use a specialization of operator<< for `std::pair` to show both:\n std::cout << \"make_pair(double(-2.234), double(-8.76)) = \" << double_pair << std::endl;\n // make_pair(double(-2.234), double(-8.76)) = -2.234, -8.76\n\n // Or, more informatively, use an uncertain type `uncun` that holds explicit uncertainty information\n // (standard-deviation, degrees of freedom and so can compute confidence internals).\n\n uncun ux(2.0, 0.5F, 7); // For an X-value.\n //uncun ux(1.03, 0.56F, 7); // For an X-value.\n // Using the `uncun operator<<` provided we can output all the details of the uncertain value.\n std::cout << scientific << plusminus << addlimits << adddegfree << std::setw(20) << std::left\n << \"ux = \" << ux << std::endl; // 1.2 +/-0.56 <0.82, 1.64> (7)\n\n uncun uy(4.0, 0.5F, 9); // For a Y-value.\n// uncun uy(3.45, 0.67F, 9); // For a Y-value.\n std::cout << \"uy = \" << uy << std::endl; // 3.5 +/-0.67 <3.01, 3.89> (9)\n\n // Now we make a pair of X and Y uncertain values:\n pair mp1 = make_pair(ux, uy); // X & Y pair of two uncertain values.\n // Echo both X and Y-values and add all the uncertainty information, standard deviation and degrees of freedom :\n std::cout << \"mp1 = \"<< mp1 << std::endl; // 1.2 +/-0.56 <0.82, 1.64> (7), 3.5 +/-0.67 <3.01, 3.89> (9)\n\n std::map data1; // Container for X & Y pairs of data-point values.\n data1.insert(mp1); // Insert 1st pair of X & Y.\n //data1.insert(make_pair(uncun(3.9, 0.01F, 8), uncun(1.1, 0.1F, 18))); // and add another X&Y-pair\n data1.insert(make_pair(uncun(3.9, 0.01F, 8), uncun(1.1, 0.2F, 18))); // and add another X&Y-pair\n data1.insert(make_pair(uncun(-2.234, 0.1F, 7), uncun(-5.76, 0.4F, 9))); // and a third pair.\n\n /*\n`Make very sure you don't forget either uncun(...) like this\n`data1.insert(make_pair((-2.234, 0.12F, 7),(-8.76, 0.56F, 9)));`\nbecause, by the bizarre operation of the comma operator, the result will be an integer!\nSo you will astonished to find that the values will be the *pair of degrees of freedom, (7, 9)*\nand the other parts of uncun will be undefined!\n\nEcho the values input, correctly rounded using the uncertainy and degrees of freedom:\n */\n std::cout << data1.size() << \" XY data pairs:\" << std::endl;\n std::copy(data1.begin(), data1.end(), ostream_iterator >(std::cout, \"\\n\"));\n std::cout << std::endl;\n\n /*\n 3 XY data pairs:\n -2.23 +/-0.030 <-2.26, -2.21> (7), -8.8 +/-0.90 <-9.35, -8.17> (9)\n 1.2 +/-0.56 <0.82, 1.64> (7), 3.5 +/-0.67 <3.01, 3.89> (9)\n 4.1 +/-0.40 <3.82, 4.38> (8), 3.1 +/-0.30 <2.96, 3.24> (18)\n */\n\n svg_2d_plot my_plot; // Construct an empty plot.\n\n /*`If you can be confident that the data set(s) only contains normal, valid data,\n so none are 'at limits' - too big or too small to be meaningful, infinite or NaN (NotANumber),\n then these checks can be skipped (for speed).\n An instrument or operator input might be known to provide only normal data.\n For this example, we know this is true, so override the default autoscale_check_limits(true).\n */\n my_plot.autoscale_check_limits(false);\n /*`The default is autoscale_plusminus(3.) so that confidence ellipses\n at 1, 2 and 3 (uncertainty nominally standard deviations)\n are all within the plot window,\n but if you are less interested in seeing the 2 and 3 ellipses,\n you could risk the outer edges spilling over the borders\n by reducing autoscale_plusminus, for example, to 1.5, down to zero.\n */\n //my_plot.autoscale_plusminus(1.5); // default is 3.\n // my_plot.confidence(0.01); // Change from default 0.05 to 0.01 for 99% confidence.\n\n /*`Use data set `data` to autoscale. (You can use a different data set to scale from the one you chose to plot).\n */\n //my_plot.xy_autoscale(data1); // But may display data point value labels illegibly outside the plot frame or image.\n // Specifying the X- and Y-axes explicitly is usually best.\n\n //my_plot.confidence(0.01); // Optionally use an alpha of 0.01 (99%) rather than default of 0.05 (95%) for culculation of confidence interval.\n\n //my_plot.plusminus_sds(2.); // Optionally display uncertainty multiplied by a factor of two instead of default one.\n\n my_plot\n // X values settings:\n .x_label(\"times (sec)\")\n .x_range(-3, +10)\n //.x_values_on(true) // Show X-values next to each point. Triggers a warning if also write .xy_values_on(true)\n // SVG_plot warning : x_values_on has overwritten xy_values_on!\n\n //! \\note Essential use of Unicode space &\\#x00A0; in all strings - ANSI space has no effect!\n //.x_decor(\"t \", \", \", \"sec\") // Keep all on one line using X-separator does NOT start with a newline.\n .x_decor(\"g \", \"\\n\", \"sec\") // Split X and Y onto two lines because X-separator *does* start with newline.\n // .x_decor(\"after t \", \"\\ntravels\", \"sec\") // Split X and Y onto two lines because X-separator *does* start with newline,\n // and add some descriptive text too.\n // .x_values_rotation(backdown) // Not good.\n // .x_values_rotation(downward) // \n .x_values_rotation(uphill)\n //.x_values_rotation(steepup) // \n // .x_values_rotation(horizontal) // Lines up vertically, but shifted too high???\n // .x_values_rotation(upward) // \n // .x_values_rotation(rightward) // \n .x_values_font_size(10) // Bigger than default.\n .x_values_font_family(\"Times New Roman\") // Serif font just to show difference from sans-serif used for Y value-labels.\n .x_major_grid_on(true)\n .y_major_grid_on(true)\n .x_major_interval(1)\n .y_major_interval(1)\n\n .x_plusminus_color(red) // Show plus/minus +/- uncertainty data-point value-label in red.\n .x_plusminus_on(true) // Show plus/minus +/- uncertainty with data-point value-labels, for example \"2.1 +/- 0.001\"\n\n // Y values settings:\n .y_label(\"distance (km)\")\n .y_range(-10., +10.) // But may be over-written by x and or y-autoscale below.\n //.y_values_on(true) // Show Y values next to each point.\n // SVG_plot warning : xy_values_on has overwritten y_values_on!\n\n // .y_values_rotation(downhill) // is ignored if both X and Y-values are shown on line below.\n .y_values_font_family(\"Arial\") // Sans serif different from X-values font just to show effect.\n .y_values_font_size(8) // Smaller than default.\n .y_decor(\"y=\", \"\", \" km\")\n // .y_decor(\"         d  \", \" \", \" km\")\n// .y_decor(\"   time = \", \" \", \" sec\")\n // Note: a few padding spaces are used to get Y-value-labels to lie more nearly under X-value-labels.\n // This is only necessary when value-labels are not horizontal.\n // y_prefix \"   \" 3 spaces.\n // y_separator \" time =\" space before word time.\n // y_suffix \" sec\" space before word sec.\n\n .y_plusminus_on(true) // Show plus/minus +/- uncertainty with data-point value-labels, for example \"2.1 +/- 0.001\"\n .y_plusminus_color(magenta) // Show plus/minus +/- uncertainty in magenta.\n\n .y_addlimits_on(true) // Show plus/minus +/- confidence limits for data-point value-labels.\n .y_addlimits_color(darkgreen) // Show +/- in darkgreen, for example: \"+/- 0.03\".\n\n .y_df_on(true) // Show degrees of freedom (usually observations -1) for data-points.\n .y_df_color(green) // Show degrees of freedom in green, for examples: \"11\").\n\n .xy_values_on(true) // Show both X-values and Y-values next to each point.\n // IS needed if both .x_values_on(true) and .y_values_on(true) specified.\n // .xy_autoscale(data1) // may result in value-labels running off the plot and image.\n // .y_values_alignment(align_style::left_align)\n //.x_values_alignment(align_style::right_align) // By default, set by code #L2881 switch statement depending on rotation.\n\n /*`The default uncertainty ellipse colors (that apply to both X and Y axes)\n can be changed thus:\n */\n .one_sd_color(lightblue) // Color of ellipse for one standard deviation (about 66% probability).\n .two_sd_color(svg_color(200, 230, 255)) // Color of ellipse for two standard deviation (~95%).\n .three_sd_color(svg_color(230, 240, 255)) // Color of ellipse for two standard deviation (~99%).\n ; // my_plot\n\n// my_plot.plot(data1, \"data1\").shape(unc_ellipse).fill_color(lightyellow).stroke_color(magenta);\n my_plot.plot(data1, \"data1\").shape(unc_ellipse).fill_color(blue).stroke_color(magenta);\n // TODO the uncertainty ellipses are now not showing anything useful for 2D but OK for 1D??? :-(\n\n my_plot.write(\"./demo_2d_uncertainty\");\n\n std::cout << \"confidence alpha \" << my_plot.confidence() <<\", plusminus sd multiplier = \" << my_plot.plusminus_sds() << std::endl;\n\n // show_2d_plot_settings(my_plot); // Needs #include \n\n //] [/demo_2d_uncertainty_2]\n\n }\n catch (const std::exception& e)\n {\n std::cout <<\n \"\\n\"\"Message from thrown exception was:\\n \" << e.what() << std::endl;\n }\n return 0;\n} // int main()\n\n/*\n\nOutput :\n\n ------ Build started: Project: demo_2d_uncertainty, Configuration: Debug Win32 ------\n unc.cpp\n unc_print.cpp\n unc_read.cpp\n demo_2d_uncertainty.cpp\n Generating Code...\n demo_2d_uncertainty.vcxproj -> J:\\Cpp\\SVG\\Debug\\demo_2d_uncertainty.exe\n make_pair(double(-2.234), double(-8.76)) = -2.234, -8.76\n make_pair(double(-2.234), double(-8.76)) = -2.234, -8.76\n ux = 1.2\n 1.2, 3.5\n 3 XY data pairs:\n -2.23, -8.8\n 1.2, 3.5\n 4.10, 3.100\n\n No limits checks: x_min = -2.234, x_max = 4.1, y_min = -8.76, y_max = 3.45\n\n\n axes_on true\n background_border_width 2\n background_border_color RGB(255,255,0)\n background_color RGB(255,255,255)\n image_border_margin() 3\n image_border_width() 2\n coord_precision 3\n copyright_date\n copyright_holder\n description\n document_title \"\"\n x_size 500\n image y_size 400\n image_filename\n legend_on false\n legend_place 2\n legend_top_left -1, -1, legend_bottom_right -1, -1\n legend_background_color blank\n legend_border_color RGB(255,255,0)\n legend_color blank\n legend_title \"\"\n legend_title_font_size 14\n legend_font_weight\n legend_width 0\n legend_lines true\n limit points stroke color RGB(119,136,153)\n limit points fill color RGB(250,235,215)\n license_on false\n license_reproduction permits\n license_distribution permits\n license_attribution requires\n license_commercialuse permits\n plot_background_color RGB(255,255,255)\n plot_border_color RGB(119,136,153)\n plot_border_width 2\n plot_window_on true\n plot_window_x 92.6, 474\n plot_window_x_left 92.6\n plot_window_x_right 474\n plot_window_y 8, 341\n plot_window_y_top 8\n plot_window_y_bottom 341\n title_on false\n title \"\"\n title_color blank\n title_font_alignment 2\n title_font_decoration\n title_font_family Verdana\n title_font_rotation 0\n title_font_size 18\n title_font_stretch\n title_font_style\n title_font_weight\n x_values_on false\n x_values_font_size 16\n x_values_font_family Times New Roman\n x_values_precision 3\n x_values_ioflags 200 IOS format flags (0x200) dec.\n y_values_precision 3\n y_values_font_size() 3\n y_values_ioflags 200 IOS format flags (0x200) dec.\n y_values_color blank\n y_values_font_family() Arial\n y_values_font_size() 12\n x_max 5\n x_min -3\n x_autoscale true\n y_autoscale true\n xy_autoscale true\n x_autoscale_check_limits false\n x_axis_on true\n x_axis_color() RGB(0,0,0)\n x_axis_label_color blank\n x_values_color blank\n x_axis_width 1\n x_label_on true\n x_label \"times (sec)\"\n x_label_color blank\n x_label_font_family Verdana\n x_label_font_size 14\n x_label_units\n x_label_units_on false\n x_major_labels_side left\n x_major_label_rotation 0\n x_major_grid_color RGB(200,220,255)\n x_major_grid_on false\n x_major_grid_width 1\n x_major_interval 1\n x_major_tick 1\n x_major_tick_color RGB(0,0,0)\n x_major_tick_length 5\n x_major_tick_width 2\n x_minor_interval 0\n x_minor_tick_color RGB(0,0,0)\n x_minor_tick_length 2\n x_minor_tick_width 1\n x_minor_grid_on false\n x_minor_grid_color RGB(200,220,255)\n x_minor_grid_width 0.5\n x_range() -3, 5\n x_num_minor_ticks 4\n x_ticks_down_on true\n x_ticks_up_on false\n x_ticks_on_window_or_axis bottom\n y_axis_position y_axis_position intersects X axis (X range includes zero)\n x_axis_position x_axis_position intersects Y axis (Y range includes zero)\n x_plusminus_on true\n x_plusminus_color RGB(0,255,255)\n x_df_on true\n x_df_color RGB(255,0,255)\n x_prefix\n x_separator\n x_suffix\n xy_values_on true\n y_label_on \"true\"\n y_label_axis distance (km)\n y_axis_color RGB(0,0,0)\n y_axis_label_color blank\n y_axis_on true\n axes_on true\n y_axis_value_color RGB(0,0,0)\n y_axis_width 1\n y_label distance (km)\n y_label_color blank\n y_label_font_family Verdana\n y_label_font_size 14\n y_label_on true\n y_label_units\n y_label_units_on false\n y_label_width 0\n y_major_grid_on false\n y_major_grid_color RGB(200,220,255)\n y_major_grid_width 1\n y_major_interval 2.5\n y_major_labels_side bottom\n y_major_label_rotation 0\n y_major_tick_color RGB(0,0,0)\n y_major_tick_length 5\n y_major_tick_width 2\n y_minor_grid_on false\n y_minor_grid_color RGB(200,220,255)\n y_minor_grid_width 0.5\n y_minor_interval 0\n y_minor_tick_color RGB(0,0,0)\n y_minor_tick_length 2\n y_minor_tick_width 1\n y_range() -10, 5\n y_num_minor_ticks\n y_ticks_left_on true\n y_ticks_right_on false\n y_ticks_on_window_or_axis left\n y_max 5\n y_min -10\n y_values_on false\n y_plusminus_on true\n y_plusminus_color RGB(255,0,0)\n y_df_on true\n y_df_color RGB(0,128,0)\n y_prefix \"   \"\n y_separator \"time = \"\n y_suffix \" sec\"\n data lines width 2\n========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========\n\n\n\n\n\n\n\n*/\n", "meta": {"hexsha": "0fcff4d341162db985aa6873db249407f5f6955c", "size": 17222, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "example/demo_2d_uncertainty.cpp", "max_stars_repo_name": "pabristow/svg_plot", "max_stars_repo_head_hexsha": "59e06b752acc252498e0ddff560b01fb951cb909", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 24.0, "max_stars_repo_stars_event_min_datetime": "2016-03-09T03:23:06.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-12T14:02:07.000Z", "max_issues_repo_path": "example/demo_2d_uncertainty.cpp", "max_issues_repo_name": "pabristow/svg_plot", "max_issues_repo_head_hexsha": "59e06b752acc252498e0ddff560b01fb951cb909", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 11.0, "max_issues_repo_issues_event_min_datetime": "2018-03-05T14:39:48.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-22T09:00:33.000Z", "max_forks_repo_path": "example/demo_2d_uncertainty.cpp", "max_forks_repo_name": "pabristow/svg_plot", "max_forks_repo_head_hexsha": "59e06b752acc252498e0ddff560b01fb951cb909", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 10.0, "max_forks_repo_forks_event_min_datetime": "2016-11-04T14:36:04.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-17T08:12:03.000Z", "avg_line_length": 35.4362139918, "max_line_length": 145, "alphanum_fraction": 0.7042736035, "num_tokens": 5254, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6893056040203135, "lm_q2_score": 0.7853085859124002, "lm_q1q2_score": 0.5413176091546852}} {"text": "#include \"xpbd/neohookean_elasticity_constraint.h\"\n\n#include \n#include \n\nnamespace xpbd {\n\nneohookean_elasticity_constraint_t::neohookean_elasticity_constraint_t(\n std::initializer_list indices,\n positions_type const& p,\n scalar_type young_modulus,\n scalar_type poisson_ratio,\n scalar_type const alpha)\n : base_type(indices, alpha), V0_{0.}, DmInv_{}, mu_{}, lambda_{}\n{\n assert(indices.size() == 4u);\n\n auto const v1 = this->indices().at(0);\n auto const v2 = this->indices().at(1);\n auto const v3 = this->indices().at(2);\n auto const v4 = this->indices().at(3);\n\n auto const p1 = p.row(v1);\n auto const p2 = p.row(v2);\n auto const p3 = p.row(v3);\n auto const p4 = p.row(v4);\n\n Eigen::Matrix3d Dm;\n Dm.col(0) = (p1 - p4).transpose();\n Dm.col(1) = (p2 - p4).transpose();\n Dm.col(2) = (p3 - p4).transpose();\n\n V0_ = (1. / 6.) * Dm.determinant();\n DmInv_ = Dm.inverse();\n mu_ = (young_modulus) / (2. * (1 + poisson_ratio));\n lambda_ = (young_modulus * poisson_ratio) / ((1 + poisson_ratio) * (1 - 2 * poisson_ratio));\n}\n\nvoid neohookean_elasticity_constraint_t::project(\n positions_type& p,\n masses_type const& m,\n scalar_type& lagrange,\n scalar_type const dt) const\n{\n auto const v1 = this->indices().at(0);\n auto const v2 = this->indices().at(1);\n auto const v3 = this->indices().at(2);\n auto const v4 = this->indices().at(3);\n\n auto const p1 = p.row(v1);\n auto const p2 = p.row(v2);\n auto const p3 = p.row(v3);\n auto const p4 = p.row(v4);\n\n auto const w1 = 1. / m(v1);\n auto const w2 = 1. / m(v2);\n auto const w3 = 1. / m(v3);\n auto const w4 = 1. / m(v4);\n\n auto const Vsigned = signed_volume(p);\n bool const is_V_positive = Vsigned >= 0.;\n bool const is_V0_positive = V0_ >= 0.;\n bool const is_tet_inverted =\n (is_V_positive && !is_V0_positive) || (!is_V_positive && is_V0_positive);\n\n Eigen::Matrix3d Ds;\n Ds.col(0) = (p1 - p4).transpose();\n Ds.col(1) = (p2 - p4).transpose();\n Ds.col(2) = (p3 - p4).transpose();\n\n Eigen::Matrix3d const F = Ds * DmInv_;\n Eigen::Matrix3d const I = Eigen::Matrix3d::Identity();\n\n scalar_type constexpr epsilon = 1e-20;\n\n Eigen::Matrix3d Piola;\n scalar_type psi{};\n\n // TODO: Implement correct inversion handling described in\n // Irving, Geoffrey, Joseph Teran, and Ronald Fedkiw. \"Invertible finite elements for robust\n // simulation of large deformation.\" Proceedings of the 2004 ACM SIGGRAPH/Eurographics symposium\n // on Computer animation. 2004.\n if (is_tet_inverted)\n {\n Eigen::JacobiSVD UFhatV(F, Eigen::ComputeFullU | Eigen::ComputeFullV);\n Eigen::Vector3d const Fsigma = UFhatV.singularValues();\n Eigen::Matrix3d Fhat;\n Fhat.setZero();\n Fhat(0, 0) = Fsigma(0);\n Fhat(1, 1) = Fsigma(1);\n Fhat(2, 2) = Fsigma(2);\n\n Eigen::Matrix3d U = UFhatV.matrixU();\n Eigen::Matrix3d const V = UFhatV.matrixV();\n\n auto smallest_element_idx = 0;\n if (Fsigma(0) < Fsigma(1) && Fsigma(0) < Fsigma(2))\n smallest_element_idx = 0;\n if (Fsigma(1) < Fsigma(0) && Fsigma(1) < Fsigma(2))\n smallest_element_idx = 1;\n if (Fsigma(2) < Fsigma(0) && Fsigma(2) < Fsigma(1))\n smallest_element_idx = 2;\n\n Fhat(smallest_element_idx, smallest_element_idx) =\n -Fhat(smallest_element_idx, smallest_element_idx);\n U.col(smallest_element_idx) = -U.col(smallest_element_idx);\n\n // stress reaches maximum at 58% compression\n scalar_type constexpr min_singular_value = 0.577;\n Fhat(0, 0) = std::min(Fhat(0, 0), min_singular_value);\n Fhat(1, 1) = std::min(Fhat(1, 1), min_singular_value);\n Fhat(2, 2) = std::min(Fhat(2, 2), min_singular_value);\n\n Eigen::Matrix3d const Fprime = U * Fhat * V.transpose();\n Eigen::Matrix3d const F2 = Fprime.transpose() * Fprime;\n Eigen::Matrix3d const Finv = Fprime.inverse();\n Eigen::Matrix3d const FinvT = Finv.transpose();\n scalar_type const I1 = F2.trace();\n scalar_type const J = Fprime.determinant();\n\n scalar_type const logJ = std::log(J);\n // psi(I1, J) = (mu/2)*(I1 - 3) - mu*log(J) + (lambda/2)*log^2(J)\n psi = static_cast(0.5) * mu_ * (I1 - static_cast(3.)) -\n mu_ * logJ + static_cast(0.5) * lambda_ * logJ * logJ;\n // P(F) = mu*(F - mu*F^-T) + lambda*log(J)*F^-T\n Piola = mu_ * (Fprime - mu_ * FinvT) + lambda_ * logJ * FinvT;\n }\n else\n {\n Eigen::Matrix3d const F2 = F.transpose() * F;\n Eigen::Matrix3d const Finv = F.inverse();\n Eigen::Matrix3d const FinvT = Finv.transpose();\n scalar_type const I1 = F2.trace();\n scalar_type const J = F.determinant();\n\n scalar_type const logJ = std::log(J);\n // psi(I1, J) = (mu/2)*(I1 - 3) - mu*log(J) + (lambda/2)*log^2(J)\n psi = static_cast(0.5) * mu_ * (I1 - static_cast(3.)) -\n mu_ * logJ + static_cast(0.5) * lambda_ * logJ * logJ;\n // P(F) = mu*(F - mu*F^-T) + lambda*log(J)*F^-T\n Piola = mu_ * (F - mu_ * FinvT) + lambda_ * logJ * FinvT;\n }\n\n // H is the negative gradient of the elastic potential\n scalar_type const V0 = std::abs(V0_);\n Eigen::Matrix3d const H = -V0 * Piola * DmInv_.transpose();\n Eigen::Vector3d const f1 = H.col(0);\n Eigen::Vector3d const f2 = H.col(1);\n Eigen::Vector3d const f3 = H.col(2);\n Eigen::Vector3d const f4 = -(f1 + f2 + f3);\n\n // clang-format off\n auto const weighted_sum_of_gradients =\n w1 * f1.squaredNorm() +\n w2 * f2.squaredNorm() +\n w3 * f3.squaredNorm() +\n w4 * f4.squaredNorm();\n // clang-format on\n\n if (weighted_sum_of_gradients < epsilon)\n return;\n\n scalar_type const C = V0 * psi;\n scalar_type const alpha_tilde = alpha_ / (dt * dt);\n scalar_type const delta_lagrange =\n -(C + alpha_tilde * lagrange) / (weighted_sum_of_gradients + alpha_tilde);\n\n lagrange += delta_lagrange;\n // because f = - grad(potential), then grad(potential) = -f and thus grad(C) = -f\n p.row(v1) += w1 * -f1 * delta_lagrange;\n p.row(v2) += w2 * -f2 * delta_lagrange;\n p.row(v3) += w3 * -f3 * delta_lagrange;\n p.row(v4) += w4 * -f4 * delta_lagrange;\n}\n\nneohookean_elasticity_constraint_t::scalar_type\nneohookean_elasticity_constraint_t::signed_volume(positions_type const& V) const\n{\n Eigen::RowVector3d const p1 = V.row(indices()[0]);\n Eigen::RowVector3d const p2 = V.row(indices()[1]);\n Eigen::RowVector3d const p3 = V.row(indices()[2]);\n Eigen::RowVector3d const p4 = V.row(indices()[3]);\n\n Eigen::Matrix3d Ds;\n Ds.col(0) = (p1 - p4).transpose();\n Ds.col(1) = (p2 - p4).transpose();\n Ds.col(2) = (p3 - p4).transpose();\n auto const vol = (1. / 6.) * Ds.determinant();\n return vol;\n}\n\n} // namespace xpbd", "meta": {"hexsha": "1a2b50dc088eeca612d406316866d1530169ca59", "size": 7208, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/xpbd/neohookean_elasticity_constraint.cpp", "max_stars_repo_name": "Q-Minh/position-based-dynamics", "max_stars_repo_head_hexsha": "23fcf93bddd5daf425cdc3443da05760cc1343ec", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 20.0, "max_stars_repo_stars_event_min_datetime": "2021-02-28T23:41:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T06:30:58.000Z", "max_issues_repo_path": "src/xpbd/neohookean_elasticity_constraint.cpp", "max_issues_repo_name": "Q-Minh/position-based-dynamics", "max_issues_repo_head_hexsha": "23fcf93bddd5daf425cdc3443da05760cc1343ec", "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": "src/xpbd/neohookean_elasticity_constraint.cpp", "max_forks_repo_name": "Q-Minh/position-based-dynamics", "max_forks_repo_head_hexsha": "23fcf93bddd5daf425cdc3443da05760cc1343ec", "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": 37.5416666667, "max_line_length": 100, "alphanum_fraction": 0.5910099889, "num_tokens": 2284, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835493924954, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5412247544247625}} {"text": "#include \"mesh_components.hpp\"\n#include \"plane3d.hpp\"\n#include \n#include \n#include \n#include \n#include \n\nusing namespace Eigen;\nusing namespace std;\n\nTetrahedron::Tetrahedron(const int _id, const vector> _vertices, const double _weight, const int _label){\n id = _id;\n vertices = _vertices;\n weight = _weight;\n label = _label;\n //cout << vertices[0].get().Vec() << endl;\n\n Vector3d v0 = vertices[0].get().Vec();\n Vector3d v1 = vertices[1].get().Vec();\n Vector3d v2 = vertices[2].get().Vec();\n Vector3d v3 = vertices[3].get().Vec();\n\n //array faceCentroid = {(v0[0] + v1[0] + v2[0]) / 3, (v0[1] + v1[1] + v2[1]) / 3, (v0[2] + v1[2] + v2[2]) / 3};\n\n //Vector3f pt3 = vertices[3]->Vec();\n\n sphereCenter = { (v0[0] + v1[0] + v2[0] + v3[0])/4, (v0[1] + v1[1] + v2[1] + v3[1])/4, (v0[2] + v1[2] + v2[2] + v3[2])/4};\n\n double r0 = sqrt( pow(sphereCenter[0]-v0[0], 2) + pow(sphereCenter[1]-v0[1], 2) + pow(sphereCenter[2]-v0[2], 2));\n\n double r1 = sqrt( pow(sphereCenter[0]-v1[0], 2) + pow(sphereCenter[1]-v1[1], 2) + pow(sphereCenter[2]-v1[2], 2));\n\n double r2 = sqrt( pow(sphereCenter[0]-v2[0], 2) + pow(sphereCenter[1]-v2[1], 2) + pow(sphereCenter[2]-v2[2], 2));\n\n double r3 = sqrt( pow(sphereCenter[0]-v3[0], 2) + pow(sphereCenter[1]-v3[1], 2) + pow(sphereCenter[2]-v3[2], 2));\n\n double radii [4] = {r0, r1, r2, r3};\n\n double r = r0;\n\n for(int i=1; i<4; ++i){\n\t//float tmp_r = ;\n\tif (radii[i] > r){\n\t r = radii[i];\n\t}\n }\n\n sphereRadius = r;\n}\n\nvoid Tetrahedron::addNeighbor(unsigned long int neighborId){\n neighbors.push_back(neighborId);\n}\n\nFace::Face(const vector> _vertices, unsigned long int _tetId){\n vertices = _vertices;\n tetId=_tetId;\n}\n\nbool Tetrahedron::contains(const array pt_target){\n if (sqrt( pow(pt_target[0] - sphereCenter[0], 2) + pow(pt_target[1] - sphereCenter[1], 2) + pow(pt_target[2] - sphereCenter[2], 2)) < sphereRadius){\n /*cout << pt_target[0] << endl;\n cout << pt_target[1] << endl;\n cout << pt_target[2] << endl;\n cout << \"HERE\" << endl;*/\n\n\tVector3d pt0 = {vertices[0].get().Vec()};\n\tVector3d pt1 = {vertices[1].get().Vec()};\n\tVector3d pt2 = {vertices[2].get().Vec()};\n\tVector3d pt3 = {vertices[3].get().Vec()};\n\n\t/*cout << \"pt0\" << endl;\n\tcout << pt0 << endl;\n\tcout << \"pt1\" << endl;\n\tcout << pt1 << endl;\n\tcout << \"pt2\" << endl;\n\tcout << pt2 << endl;\n\tcout << \"pt3\" << endl;\n\tcout << pt3 << endl;*/\n\n\tMatrix4d m0;\n\tMatrix4d m1;\n\tMatrix4d m2;\n\tMatrix4d m3;\n\tMatrix4d m4;\n\n\tm0 << pt0[0], pt0[1], pt0[2], 1,\n\t pt1[0], pt1[1], pt1[2], 1,\n\t pt2[0], pt2[1], pt2[2], 1,\n\t pt3[0], pt3[1], pt3[2], 1;\n\n\tdouble d0 = m0.determinant();\n\n\tm1 << pt_target[0], pt_target[1], pt_target[2], 1,\n\t pt1[0], pt1[1], pt1[2], 1,\n\t pt2[0], pt2[1], pt2[2], 1,\n\t pt3[0], pt3[1], pt3[2], 1;\n\n\tdouble d1 = m1.determinant();\n\n\tm2 << pt0[0], pt0[1], pt0[2], 1,\n\t pt_target[0], pt_target[1], pt_target[2], 1,\n\t pt2[0], pt2[1], pt2[2], 1,\n\t pt3[0], pt3[1], pt3[2], 1;\n\n\tdouble d2 = m2.determinant();\n\n\tm3 << pt0[0], pt0[1], pt0[2], 1,\n\t pt1[0], pt1[1], pt1[2], 1,\n\t pt_target[0], pt_target[1], pt_target[2], 1,\n\t pt3[0], pt3[1], pt3[2], 1;\n\n\tdouble d3 = m3.determinant();\n\n\tm4 << pt0[0], pt0[1], pt0[2], 1,\n\t pt1[0], pt1[1], pt1[2], 1,\n\t pt2[0], pt2[1], pt2[2], 1,\n\t pt_target[0], pt_target[1], pt_target[2], 1;\n\n\tdouble d4 = m4.determinant();\n\n\t/*cout << d0 << endl;\n\tcout << d1 << endl;\n\tcout << d2 << endl;\n\tcout << d3 << endl;\n\tcout << d4 << endl;*/\n\n\treturn (d0<0 && d1<0 && d2<0 && d3<0 && d4<0) || (d0>0 && d1>0 && d2>0 && d3>0 && d4>0);\n }\n return false;\n}\n\n\nvector> Tetrahedron::intersectsPlane(Plane3d plane){\n vector> intersectionPoints;\n\n for(int i=0; i<4; ++i){\n\tVector3d v0 = vertices[i].get().Vec();\n\tif(plane.containsPoint(v0)){\n\t array v0Pt = {v0[0], v0[1], v0[2]};\n\t intersectionPoints.push_back(v0Pt);\n\t} \n\telse {\n\t for(int j=i+1; j<4; ++j){\n\t\tVector3d v1 = vertices[j].get().Vec();\n\t\tif(plane.intersectsEdge(v0, v1)){\n\t\t intersectionPoints.push_back(plane.findIntersection(v0,v1));\n\t\t}\n\t }\n\t}\n }\n\n if(intersectionPoints.size()==4){\n\tintersectionPoints = {intersectionPoints[0], intersectionPoints[1], intersectionPoints[3], intersectionPoints[2]};\n }\n\n\n return intersectionPoints;\n\n}\n\nbool Face::intersectsPlane(Plane3d plane){\n Vector3d v0 = vertices[0].get().Vec();\n Vector3d v1 = vertices[1].get().Vec();\n Vector3d v2 = vertices[2].get().Vec();\n\n return (plane.intersectsEdge(v0, v1) || plane.intersectsEdge(v1, v2) || plane.intersectsEdge(v0, v2));\n}\n\n\nunsigned long int Tetrahedron::Id(){\n return id;\n}\n\nvector Tetrahedron::Neighbors(){\n return neighbors;\n}\n\nvector> Tetrahedron::Vertices(){\n return vertices;\n}\n\ndouble Tetrahedron::Weight(){\n return weight;\n}\n\nint Tetrahedron::Label(){\n return label;\n}\n\nunsigned long int Face::TetId(){\n return tetId;\n}\n\nvector> Face::Vertices(){\n return vertices;\n}\n\nVertex3d::Vertex3d(array _vec) {\n //vec = _vec;\n vec << _vec[0], _vec[1], _vec[2];\n}\n\n\nVector3d Vertex3d::Vec(){\n return vec;\n}\n\n", "meta": {"hexsha": "19f8e0b222b4808739f0362404481430f10a6044", "size": 5374, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/mesh_components.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/mesh_components.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/mesh_components.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": 25.5904761905, "max_line_length": 152, "alphanum_fraction": 0.5874581317, "num_tokens": 1994, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835371034369, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5412247464639323}} {"text": "#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\n#include \n\n#include \n#include \n\n#include \"BayesC_distributions.h\"\n#include \"Sampling_functions.hpp\"\n\nusing namespace std;\nusing namespace Eigen;\nnamespace po = boost::program_options;\n\nvoid ReadFromFile(std::vector &x, const std::string &file_name)\n{\n\tstd::ifstream read_file(file_name);\n\tassert(read_file.is_open());\n\n\tstd::copy(std::istream_iterator(read_file), std::istream_iterator(),\n\t\t\tstd::back_inserter(x));\n\n\tread_file.close();\n}\n\n\nint main(int argc, char *argv[])\n{\n\n\tpo::options_description desc(\"Options\");\n\tdesc.add_options()\n\t\t(\"M\", po::value()->required(), \"No. of simulated markers\")\n\t\t(\"N\", po::value()->required(), \"No. of simulated individuals\")\n\t\t(\"iter\", po::value()->default_value(5000), \"No. of Gibbs iterations\")\n\t\t(\"pNZ\", po::value()->default_value(0.5), \"Proportion nonzero (simulations)\")\n\t\t(\"h2\", po::value()->default_value(0.6), \"Heritability (simulations)\")\n\t\t(\"input\", po::value()->default_value(\"none\"),\"Input filename\")\n\t\t(\"out\", po::value()->default_value(\"BayesC_out\"),\"Output filename\")\n\t;\n\n\t//clock starts\n\tstd::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();\n\n\t//map variables\n\tpo::variables_map vm;\n\tpo::store(po::parse_command_line(argc,argv,desc),vm);\n\tpo::notify(vm);\n\n\tint M=vm[\"M\"].as();\n\tint N=vm[\"N\"].as();\n\tint iter=vm[\"iter\"].as();\n\n\tstring input=vm[\"input\"].as();\n\tstring output=vm[\"out\"].as();\n\n\tMatrixXd X(N,M);\n\tVectorXd Y(N);\n\n\t//beta coefficients\n\tVectorXd beta_true(M);\n\tbeta_true.setZero();\n\n\tint i,j,k,l,m=0;\n\n\t//Was an input matrix given?\n\n\tif (input!=\"none\"){ //Either read input tables for X and Y\n\t\tifstream f1(input+\".X\");\n\t\t//f1 >> m >> n;\n\t\tfor (int i = 0; i < N; i++)\n\t\t{\n\t\t\tfor (int j = 0; j < M; j++)\n\t\t\t{\n\t\t\t\tf1 >> X(i,j);\n\t\t\t\t//cout< Y_in;\n\t\tReadFromFile(Y_in, input+\".Y\");\n\t\tdouble* ptr_Y = &Y_in[0];\n\t\tEigen::Map Y1(ptr_Y, Y_in.size());\n\t\tcout<<\"finished reading vector Y!\"<();\n\t\tdouble pNZ=vm[\"pNZ\"].as();\n\t\tdouble sigmaY_true=1;\n\n\t\tint MT=pNZ*M;\n\n\t\t//Fill Genotype matrix\n\t\tfor (i=0;i markerI;\n\tfor (int i=0; i (end1 - begin).count()*1e-9 <<\" seconds\"< (end2 - begin).count()*1e-9 <<\" seconds\"<\n\n// Headers for basic PETSc functions\n#include \n\n// Headers for basic SAMRAI objects\n#include \n#include \n#include \n#include \n\n// Headers for basic libMesh objects\n#include \n#include \n#include \n#include \n#include \n#include \n\n// Headers for application-specific algorithm/data structure objects\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 \n\n// Set up application namespace declarations\n#include \n\n// Elasticity model data.\nnamespace ModelData\n{\n// Coordinate mapping function.\nvoid\ncoordinate_mapping_function(libMesh::Point& X, const libMesh::Point& s, void* /*ctx*/)\n{\n X(0) = s(0) + 0.6;\n X(1) = s(1) + 0.5;\n#if (NDIM == 3)\n X(2) = s(2) + 0.5;\n#endif\n return;\n} // coordinate_mapping_function\n\n// Stress tensor functions.\nstatic double c1_s = 0.05;\nstatic double p0_s = 0.0;\nstatic double beta_s = 0.0;\nvoid\nPK1_dev_stress_function(TensorValue& PP,\n const TensorValue& FF,\n const libMesh::Point& /*X*/,\n const libMesh::Point& /*s*/,\n Elem* const /*elem*/,\n const vector*>& /*var_data*/,\n const vector >*>& /*grad_var_data*/,\n double /*time*/,\n void* /*ctx*/)\n{\n PP = 2.0 * c1_s * FF;\n return;\n} // PK1_dev_stress_function\n\nvoid\nPK1_dil_stress_function(TensorValue& PP,\n const TensorValue& FF,\n const libMesh::Point& /*X*/,\n const libMesh::Point& /*s*/,\n Elem* const /*elem*/,\n const vector*>& /*var_data*/,\n const vector >*>& /*grad_var_data*/,\n double /*time*/,\n void* /*ctx*/)\n{\n PP = 2.0 * (-p0_s + beta_s * log(FF.det())) * tensor_inverse_transpose(FF, NDIM);\n return;\n} // PK1_dil_stress_function\n} // namespace ModelData\nusing namespace ModelData;\n\n// Function prototypes\nvoid output_data(Pointer > patch_hierarchy,\n Pointer navier_stokes_integrator,\n MeshBase& mesh,\n EquationSystems* equation_systems,\n const int iteration_num,\n const double loop_time,\n const string& data_dump_dirname);\n\n/*******************************************************************************\n * For each run, the input filename and restart information (if needed) must *\n * be given on the command line. For non-restarted case, command line is: *\n * *\n * executable *\n * *\n * For restarted run, command line is: *\n * *\n * executable *\n * *\n *******************************************************************************/\n\nint\nmain(int argc, char* argv[])\n{\n // Initialize IBAMR and libraries. Deinitialization is handled by this object as well.\n IBTKInit ibtk_init(argc, argv, MPI_COMM_WORLD);\n const LibMeshInit& init = ibtk_init.getLibMeshInit();\n\n { // cleanup dynamically allocated objects prior to shutdown\n\n // Parse command line options, set some standard options from the input\n // file, initialize the restart database (if this is a restarted run),\n // and enable file logging.\n Pointer app_initializer = new AppInitializer(argc, argv, \"IB.log\");\n Pointer input_db = app_initializer->getInputDatabase();\n\n // Get various standard options set in the input file.\n const bool dump_viz_data = app_initializer->dumpVizData();\n const int viz_dump_interval = app_initializer->getVizDumpInterval();\n const bool uses_visit = dump_viz_data && app_initializer->getVisItDataWriter();\n#ifdef LIBMESH_HAVE_EXODUS_API\n const bool uses_exodus = dump_viz_data && !app_initializer->getExodusIIFilename().empty();\n#else\n const bool uses_exodus = false;\n if (!app_initializer->getExodusIIFilename().empty())\n {\n plog << \"WARNING: libMesh was compiled without Exodus support, so no \"\n << \"Exodus output will be written in this program.\\n\";\n }\n#endif\n const string exodus_filename = app_initializer->getExodusIIFilename();\n\n const bool dump_restart_data = app_initializer->dumpRestartData();\n const int restart_dump_interval = app_initializer->getRestartDumpInterval();\n const string restart_dump_dirname = app_initializer->getRestartDumpDirectory();\n const string restart_read_dirname = app_initializer->getRestartReadDirectory();\n const int restart_restore_num = app_initializer->getRestartRestoreNumber();\n\n const bool dump_postproc_data = app_initializer->dumpPostProcessingData();\n const int postproc_data_dump_interval = app_initializer->getPostProcessingDataDumpInterval();\n const string postproc_data_dump_dirname = app_initializer->getPostProcessingDataDumpDirectory();\n if (dump_postproc_data && (postproc_data_dump_interval > 0) && !postproc_data_dump_dirname.empty())\n {\n Utilities::recursiveMkdir(postproc_data_dump_dirname);\n }\n\n const bool dump_timer_data = app_initializer->dumpTimerData();\n const int timer_dump_interval = app_initializer->getTimerDumpInterval();\n\n // Create a simple FE mesh.\n ReplicatedMesh mesh(init.comm(), NDIM);\n const double dx = input_db->getDouble(\"DX\");\n const double ds = input_db->getDouble(\"MFAC\") * dx;\n string elem_type = input_db->getString(\"ELEM_TYPE\");\n const double R = 0.2;\n if (NDIM == 2 && (elem_type == \"TRI3\" || elem_type == \"TRI6\"))\n {\n#ifdef LIBMESH_HAVE_TRIANGLE\n const int num_circum_nodes = ceil(2.0 * M_PI * R / ds);\n for (int k = 0; k < num_circum_nodes; ++k)\n {\n const double theta = 2.0 * M_PI * static_cast(k) / static_cast(num_circum_nodes);\n mesh.add_point(libMesh::Point(R * cos(theta), R * sin(theta)));\n }\n TriangleInterface triangle(mesh);\n triangle.triangulation_type() = TriangleInterface::GENERATE_CONVEX_HULL;\n triangle.elem_type() = Utility::string_to_enum(elem_type);\n triangle.desired_area() = 1.5 * sqrt(3.0) / 4.0 * ds * ds;\n triangle.insert_extra_points() = true;\n triangle.smooth_after_generating() = true;\n triangle.triangulate();\n#else\n TBOX_ERROR(\"ERROR: libMesh appears to have been configured without support for Triangle,\\n\"\n << \" but Triangle is required for TRI3 or TRI6 elements.\\n\");\n#endif\n }\n else\n {\n // NOTE: number of segments along boundary is 4*2^r.\n const double num_circum_segments = 2.0 * M_PI * R / ds;\n const int r = log2(0.25 * num_circum_segments);\n MeshTools::Generation::build_sphere(mesh, R, r, Utility::string_to_enum(elem_type));\n }\n\n // Ensure nodes on the surface are on the analytic boundary.\n MeshBase::element_iterator el_end = mesh.elements_end();\n for (MeshBase::element_iterator el = mesh.elements_begin(); el != el_end; ++el)\n {\n Elem* const elem = *el;\n for (unsigned int side = 0; side < elem->n_sides(); ++side)\n {\n const bool at_mesh_bdry = !elem->neighbor_ptr(side);\n if (!at_mesh_bdry) continue;\n for (unsigned int k = 0; k < elem->n_nodes(); ++k)\n {\n if (!elem->is_node_on_side(k, side)) continue;\n Node& n = elem->node_ref(k);\n n = R * n.unit();\n }\n }\n }\n mesh.prepare_for_use();\n\n c1_s = input_db->getDouble(\"C1_S\");\n p0_s = input_db->getDouble(\"P0_S\");\n beta_s = input_db->getDouble(\"BETA_S\");\n\n // Create major algorithm and data objects that comprise the\n // application. These objects are configured from the input database\n // and, if this is a restarted run, from the restart database.\n Pointer > grid_geometry = new CartesianGridGeometry(\n \"CartesianGeometry\", app_initializer->getComponentDatabase(\"CartesianGeometry\"));\n Pointer > patch_hierarchy = new PatchHierarchy(\"PatchHierarchy\", grid_geometry);\n Pointer > load_balancer =\n new LoadBalancer(\"LoadBalancer\", app_initializer->getComponentDatabase(\"LoadBalancer\"));\n Pointer > box_generator = new BergerRigoutsos();\n\n Pointer navier_stokes_integrator;\n const string solver_type = app_initializer->getComponentDatabase(\"Main\")->getString(\"solver_type\");\n if (solver_type == \"STAGGERED\")\n {\n navier_stokes_integrator = new INSStaggeredHierarchyIntegrator(\n \"INSStaggeredHierarchyIntegrator\",\n app_initializer->getComponentDatabase(\"INSStaggeredHierarchyIntegrator\"));\n }\n else if (solver_type == \"COLLOCATED\")\n {\n navier_stokes_integrator = new INSCollocatedHierarchyIntegrator(\n \"INSCollocatedHierarchyIntegrator\",\n app_initializer->getComponentDatabase(\"INSCollocatedHierarchyIntegrator\"));\n }\n else\n {\n TBOX_ERROR(\"Unsupported solver type: \" << solver_type << \"\\n\"\n << \"Valid options are: COLLOCATED, STAGGERED\");\n }\n Pointer ib_method_ops =\n new IBFEMethod(\"IBFEMethod\",\n app_initializer->getComponentDatabase(\"IBFEMethod\"),\n &mesh,\n app_initializer->getComponentDatabase(\"GriddingAlgorithm\")->getInteger(\"max_levels\"),\n /*register_for_restart*/ true,\n restart_read_dirname,\n restart_restore_num);\n Pointer time_integrator =\n new IBExplicitHierarchyIntegrator(\"IBHierarchyIntegrator\",\n app_initializer->getComponentDatabase(\"IBHierarchyIntegrator\"),\n ib_method_ops,\n navier_stokes_integrator);\n time_integrator->registerLoadBalancer(load_balancer);\n\n Pointer > error_detector =\n new StandardTagAndInitialize(\"StandardTagAndInitialize\",\n time_integrator,\n app_initializer->getComponentDatabase(\"StandardTagAndInitialize\"));\n Pointer > gridding_algorithm =\n new GriddingAlgorithm(\"GriddingAlgorithm\",\n app_initializer->getComponentDatabase(\"GriddingAlgorithm\"),\n error_detector,\n box_generator,\n load_balancer);\n\n // Configure the IBFE solver.\n ib_method_ops->registerInitialCoordinateMappingFunction(coordinate_mapping_function);\n IBFEMethod::PK1StressFcnData PK1_dev_stress_data(PK1_dev_stress_function);\n IBFEMethod::PK1StressFcnData PK1_dil_stress_data(PK1_dil_stress_function);\n PK1_dev_stress_data.quad_order =\n Utility::string_to_enum(input_db->getStringWithDefault(\"PK1_DEV_QUAD_ORDER\", \"THIRD\"));\n PK1_dil_stress_data.quad_order =\n Utility::string_to_enum(input_db->getStringWithDefault(\"PK1_DIL_QUAD_ORDER\", \"FIRST\"));\n ib_method_ops->registerPK1StressFunction(PK1_dev_stress_data);\n ib_method_ops->registerPK1StressFunction(PK1_dil_stress_data);\n if (input_db->getBoolWithDefault(\"ELIMINATE_PRESSURE_JUMPS\", false))\n {\n ib_method_ops->registerStressNormalizationPart();\n }\n ib_method_ops->initializeFEEquationSystems();\n EquationSystems* equation_systems = ib_method_ops->getFEDataManager()->getEquationSystems();\n\n // Set up post processor to recover computed stresses.\n ib_method_ops->initializeFEEquationSystems();\n FEDataManager* fe_data_manager = ib_method_ops->getFEDataManager();\n\n Pointer ib_post_processor =\n new IBFECentroidPostProcessor(\"IBFEPostProcessor\", fe_data_manager);\n\n ib_post_processor->registerTensorVariable(\"FF\", MONOMIAL, CONSTANT, IBFEPostProcessor::FF_fcn);\n\n pair PK1_dev_stress_fcn_data(PK1_dev_stress_function, static_cast(NULL));\n ib_post_processor->registerTensorVariable(\"sigma_dev\",\n MONOMIAL,\n CONSTANT,\n IBFEPostProcessor::cauchy_stress_from_PK1_stress_fcn,\n vector(),\n &PK1_dev_stress_fcn_data);\n\n pair PK1_dil_stress_fcn_data(PK1_dil_stress_function, static_cast(NULL));\n ib_post_processor->registerTensorVariable(\"sigma_dil\",\n MONOMIAL,\n CONSTANT,\n IBFEPostProcessor::cauchy_stress_from_PK1_stress_fcn,\n vector(),\n &PK1_dil_stress_fcn_data);\n\n Pointer > p_var = navier_stokes_integrator->getPressureVariable();\n Pointer p_current_ctx = navier_stokes_integrator->getCurrentContext();\n HierarchyGhostCellInterpolation::InterpolationTransactionComponent p_ghostfill(\n /*data_idx*/ -1, \"LINEAR_REFINE\", /*use_cf_bdry_interpolation*/ false, \"CONSERVATIVE_COARSEN\", \"LINEAR\");\n FEDataManager::InterpSpec p_interp_spec(\"PIECEWISE_LINEAR\",\n QGAUSS,\n FIFTH,\n /*use_adaptive_quadrature*/ false,\n /*point_density*/ 2.0,\n /*use_consistent_mass_matrix*/ true,\n /*use_nodal_quadrature*/ false,\n /*allow_rules_with_negative_weights*/ false);\n ib_post_processor->registerInterpolatedScalarEulerianVariable(\n \"p_f\", LAGRANGE, FIRST, p_var, p_current_ctx, p_ghostfill, p_interp_spec);\n\n // Create Eulerian initial condition specification objects.\n if (input_db->keyExists(\"VelocityInitialConditions\"))\n {\n Pointer u_init = new muParserCartGridFunction(\n \"u_init\", app_initializer->getComponentDatabase(\"VelocityInitialConditions\"), grid_geometry);\n navier_stokes_integrator->registerVelocityInitialConditions(u_init);\n }\n\n if (input_db->keyExists(\"PressureInitialConditions\"))\n {\n Pointer p_init = new muParserCartGridFunction(\n \"p_init\", app_initializer->getComponentDatabase(\"PressureInitialConditions\"), grid_geometry);\n navier_stokes_integrator->registerPressureInitialConditions(p_init);\n }\n\n // Create Eulerian boundary condition specification objects (when necessary).\n const IntVector& periodic_shift = grid_geometry->getPeriodicShift();\n vector*> u_bc_coefs(NDIM);\n if (periodic_shift.min() > 0)\n {\n for (unsigned int d = 0; d < NDIM; ++d)\n {\n u_bc_coefs[d] = NULL;\n }\n }\n else\n {\n for (unsigned int d = 0; d < NDIM; ++d)\n {\n const std::string bc_coefs_name = \"u_bc_coefs_\" + std::to_string(d);\n\n const std::string bc_coefs_db_name = \"VelocityBcCoefs_\" + std::to_string(d);\n\n u_bc_coefs[d] = new muParserRobinBcCoefs(\n bc_coefs_name, app_initializer->getComponentDatabase(bc_coefs_db_name), grid_geometry);\n }\n navier_stokes_integrator->registerPhysicalBoundaryConditions(u_bc_coefs);\n }\n\n // Create Eulerian body force function specification objects.\n if (input_db->keyExists(\"ForcingFunction\"))\n {\n Pointer f_fcn = new muParserCartGridFunction(\n \"f_fcn\", app_initializer->getComponentDatabase(\"ForcingFunction\"), grid_geometry);\n time_integrator->registerBodyForceFunction(f_fcn);\n }\n\n // Set up visualization plot file writers.\n Pointer > visit_data_writer = app_initializer->getVisItDataWriter();\n if (uses_visit)\n {\n time_integrator->registerVisItDataWriter(visit_data_writer);\n visit_data_writer->registerPlotQuantity(\"workload\", \"SCALAR\", time_integrator->getWorkloadDataIndex());\n }\n std::unique_ptr exodus_io(uses_exodus ? new ExodusII_IO(mesh) : NULL);\n\n // Check to see if this is a restarted run to append current exodus files\n if (uses_exodus)\n {\n const bool from_restart = RestartManager::getManager()->isFromRestart();\n exodus_io->append(from_restart);\n }\n\n // Initialize hierarchy configuration and data on all patches.\n ib_method_ops->initializeFEData();\n if (ib_post_processor) ib_post_processor->initializeFEData();\n time_integrator->initializePatchHierarchy(patch_hierarchy, gridding_algorithm);\n\n // Deallocate initialization objects.\n app_initializer.setNull();\n\n // Print the input database contents to the log file.\n plog << \"Input database:\\n\";\n input_db->printClassData(plog);\n\n // Write out initial visualization data.\n int iteration_num = time_integrator->getIntegratorStep();\n double loop_time = time_integrator->getIntegratorTime();\n if (dump_viz_data)\n {\n pout << \"\\n\\nWriting visualization files...\\n\\n\";\n if (uses_visit)\n {\n const System& position_system = equation_systems->get_system(IBFEMethod::COORDS_SYSTEM_NAME);\n time_integrator->setupPlotData();\n visit_data_writer->writePlotData(patch_hierarchy, iteration_num, loop_time);\n if (NDIM < 3)\n {\n IBTK::BoxPartitioner partitioner(*patch_hierarchy, position_system);\n partitioner.writePartitioning(\"patch-part-\" + std::to_string(iteration_num) + \".txt\");\n // Write partitioning data from libMesh.\n IBTK::write_node_partitioning(\"node-part-\" + std::to_string(iteration_num) + \".txt\",\n position_system);\n }\n }\n if (uses_exodus)\n {\n if (ib_post_processor) ib_post_processor->postProcessData(loop_time);\n exodus_io->write_timestep(\n exodus_filename, *equation_systems, iteration_num / viz_dump_interval + 1, loop_time);\n }\n }\n\n // Open streams to save volume of structure.\n ofstream volume_stream;\n if (IBTK_MPI::getRank() == 0)\n {\n volume_stream.open(\"volume.curve\", ios_base::out | ios_base::trunc);\n }\n\n // Main time step loop.\n double loop_time_end = time_integrator->getEndTime();\n double dt = 0.0;\n while (!IBTK::rel_equal_eps(loop_time, loop_time_end) && time_integrator->stepsRemaining())\n {\n iteration_num = time_integrator->getIntegratorStep();\n loop_time = time_integrator->getIntegratorTime();\n\n pout << \"\\n\";\n pout << \"+++++++++++++++++++++++++++++++++++++++++++++++++++\\n\";\n pout << \"At beginning of timestep # \" << iteration_num << \"\\n\";\n pout << \"Simulation time is \" << loop_time << \"\\n\";\n\n dt = time_integrator->getMaximumTimeStepSize();\n time_integrator->advanceHierarchy(dt);\n loop_time += dt;\n\n pout << \"\\n\";\n pout << \"At end of timestep # \" << iteration_num << \"\\n\";\n pout << \"Simulation time is \" << loop_time << \"\\n\";\n pout << \"+++++++++++++++++++++++++++++++++++++++++++++++++++\\n\";\n pout << \"\\n\";\n\n // At specified intervals, write visualization and restart files,\n // print out timer data, and store hierarchy data for post\n // processing.\n iteration_num += 1;\n const bool last_step = !time_integrator->stepsRemaining();\n if (dump_viz_data && (iteration_num % viz_dump_interval == 0 || last_step))\n {\n pout << \"\\nWriting visualization files...\\n\\n\";\n if (uses_visit)\n {\n const System& position_system = equation_systems->get_system(IBFEMethod::COORDS_SYSTEM_NAME);\n time_integrator->setupPlotData();\n visit_data_writer->writePlotData(patch_hierarchy, iteration_num, loop_time);\n if (NDIM < 3)\n {\n IBTK::BoxPartitioner partitioner(*patch_hierarchy, position_system);\n partitioner.writePartitioning(\"patch-part-\" + std::to_string(iteration_num) + \".txt\");\n IBTK::write_node_partitioning(\"node-part-\" + std::to_string(iteration_num) + \".txt\",\n position_system);\n }\n }\n if (uses_exodus)\n {\n if (ib_post_processor) ib_post_processor->postProcessData(loop_time);\n exodus_io->write_timestep(\n exodus_filename, *equation_systems, iteration_num / viz_dump_interval + 1, loop_time);\n }\n }\n if (dump_restart_data && (iteration_num % restart_dump_interval == 0 || last_step))\n {\n pout << \"\\nWriting restart files...\\n\\n\";\n RestartManager::getManager()->writeRestartFile(restart_dump_dirname, iteration_num);\n ib_method_ops->writeFEDataToRestartFile(restart_dump_dirname, iteration_num);\n }\n if (dump_timer_data && (iteration_num % timer_dump_interval == 0 || last_step))\n {\n pout << \"\\nWriting timer data...\\n\\n\";\n TimerManager::getManager()->print(plog);\n }\n if (dump_postproc_data && (iteration_num % postproc_data_dump_interval == 0 || last_step))\n {\n output_data(patch_hierarchy,\n navier_stokes_integrator,\n mesh,\n equation_systems,\n iteration_num,\n loop_time,\n postproc_data_dump_dirname);\n }\n\n // Compute the volume of the structure.\n double J_integral = 0.0;\n System& X_system = equation_systems->get_system(IBFEMethod::COORDS_SYSTEM_NAME);\n NumericVector* X_vec = X_system.solution.get();\n NumericVector* X_ghost_vec = X_system.current_local_solution.get();\n copy_and_synch(*X_vec, *X_ghost_vec);\n DofMap& X_dof_map = X_system.get_dof_map();\n vector > X_dof_indices(NDIM);\n std::unique_ptr fe(FEBase::build(NDIM, X_dof_map.variable_type(0)));\n std::unique_ptr qrule = QBase::build(QGAUSS, NDIM, FIFTH);\n fe->attach_quadrature_rule(qrule.get());\n const vector& JxW = fe->get_JxW();\n const vector > >& dphi = fe->get_dphi();\n TensorValue FF;\n boost::multi_array X_node;\n const auto el_begin = mesh.active_local_elements_begin();\n const auto el_end = mesh.active_local_elements_end();\n for (auto el_it = el_begin; el_it != el_end; ++el_it)\n {\n const auto elem = *el_it;\n fe->reinit(elem);\n for (unsigned int d = 0; d < NDIM; ++d)\n {\n X_dof_map.dof_indices(elem, X_dof_indices[d], d);\n }\n const int n_qp = qrule->n_points();\n get_values_for_interpolation(X_node, *X_ghost_vec, X_dof_indices);\n for (int qp = 0; qp < n_qp; ++qp)\n {\n jacobian(FF, qp, X_node, dphi);\n J_integral += abs(FF.det()) * JxW[qp];\n }\n }\n J_integral = IBTK_MPI::sumReduction(J_integral);\n if (IBTK_MPI::getRank() == 0)\n {\n volume_stream.precision(12);\n volume_stream.setf(ios::fixed, ios::floatfield);\n volume_stream << loop_time << \" \" << J_integral << endl;\n }\n }\n\n // Close the logging streams.\n if (IBTK_MPI::getRank() == 0)\n {\n volume_stream.close();\n }\n\n // Cleanup Eulerian boundary condition specification objects (when\n // necessary).\n for (unsigned int d = 0; d < NDIM; ++d) delete u_bc_coefs[d];\n\n } // cleanup dynamically allocated objects prior to shutdown\n} // main\n\nvoid\noutput_data(Pointer > patch_hierarchy,\n Pointer navier_stokes_integrator,\n MeshBase& mesh,\n EquationSystems* equation_systems,\n const int iteration_num,\n const double loop_time,\n const string& data_dump_dirname)\n{\n plog << \"writing hierarchy data at iteration \" << iteration_num << \" to disk\" << endl;\n plog << \"simulation time is \" << loop_time << endl;\n\n // Write Cartesian data.\n string file_name = data_dump_dirname + \"/\" + \"hier_data.\";\n char temp_buf[128];\n sprintf(temp_buf, \"%05d.samrai.%05d\", iteration_num, IBTK_MPI::getRank());\n file_name += temp_buf;\n Pointer hier_db = new HDFDatabase(\"hier_db\");\n hier_db->create(file_name);\n VariableDatabase* var_db = VariableDatabase::getDatabase();\n ComponentSelector hier_data;\n hier_data.setFlag(var_db->mapVariableAndContextToIndex(navier_stokes_integrator->getVelocityVariable(),\n navier_stokes_integrator->getCurrentContext()));\n hier_data.setFlag(var_db->mapVariableAndContextToIndex(navier_stokes_integrator->getPressureVariable(),\n navier_stokes_integrator->getCurrentContext()));\n patch_hierarchy->putToDatabase(hier_db->putDatabase(\"PatchHierarchy\"), hier_data);\n hier_db->putDouble(\"loop_time\", loop_time);\n hier_db->putInteger(\"iteration_num\", iteration_num);\n hier_db->close();\n\n // Write Lagrangian data.\n file_name = data_dump_dirname + \"/\" + \"fe_mesh.\";\n sprintf(temp_buf, \"%05d\", iteration_num);\n file_name += temp_buf;\n file_name += \".xda\";\n mesh.write(file_name);\n file_name = data_dump_dirname + \"/\" + \"fe_equation_systems.\";\n sprintf(temp_buf, \"%05d\", iteration_num);\n file_name += temp_buf;\n equation_systems->write(file_name, (EquationSystems::WRITE_DATA | EquationSystems::WRITE_ADDITIONAL_DATA));\n return;\n} // output_data\n", "meta": {"hexsha": "b4ee26ff227058d5d1408febd2608c5331d4aff1", "size": 29944, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/IBFE/explicit/ex4/example.cpp", "max_stars_repo_name": "colegruninger97/IBAMR", "max_stars_repo_head_hexsha": "0f9b9b95533022571cc1a9972c42d8fc3f9d2a18", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/IBFE/explicit/ex4/example.cpp", "max_issues_repo_name": "colegruninger97/IBAMR", "max_issues_repo_head_hexsha": "0f9b9b95533022571cc1a9972c42d8fc3f9d2a18", "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": "examples/IBFE/explicit/ex4/example.cpp", "max_forks_repo_name": "colegruninger97/IBAMR", "max_forks_repo_head_hexsha": "0f9b9b95533022571cc1a9972c42d8fc3f9d2a18", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.9871794872, "max_line_length": 119, "alphanum_fraction": 0.5849251937, "num_tokens": 6322, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744761936437, "lm_q2_score": 0.6619228691808011, "lm_q1q2_score": 0.5411712430510872}} {"text": "/* \n * Copyright (c) 2009 Carnegie Mellon University. \n * All rights reserved.\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,\n * software distributed under the License is distributed on an \"AS\n * IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n *\n * For more about this software visit:\n *\n * http://www.graphlab.ml.cmu.edu\n *\n */\n\n\n/**\n *\n * \\brief This application is almost identical to LBP structured\n * prediction except that it generates an artificial field for every\n * vertex enabling the studying of distributed LBP on various graph\n * structures without the need for actual data. \n *\n *\n * Technical Explanation\n * ========================\n *\n * This application creates a pair-wise Markov Random Field with\n * Ising-Potts edge factors and then uses residual loopy belief\n * propagation to compute posterior belief estimates for each vertex.\n *\n *\n * \\author Joseph Gonzalez\n */\n\n\n#include \n#include \n#include \n#include \n#include \n\n\n#include \n#include \"eigen_serialization.hpp\"\n\n\n\n#include \n#include \n\n\n\n\n/**\n * \\brief Eigen library vectors are used to store factor in _LOG\n * SPACE_.\n */\ntypedef Eigen::VectorXd factor_type;\n\n/**\n * \\brief The Ising smoothing parameter which controls the coupling\n * between adjacent predictions in the graph. Larger values imply\n * greater smoothing (stronger coupling). \n *\n * \\code\n * edge_factor(xi, xj) = exp( (xi == xj)? 0 : -SMOOTHING * edge_weight ); \n * \\endcode\n *\n * Not that the default edge weight is 1 however the graph file can\n * contain an additional edge weight column which allows per edge\n * control of the smoothing parameter.\n *\n * This parameter is set as a command line argument.\n */\ndouble SMOOTHING = 2;\n\n\ndouble FIELD = 2;\nsize_t NSTATES = 5;\n\n/**\n * \\brief The Damping parameter which helps ensure stable convergence.\n * Larger damping values lead to slower but more stable convergence.\n *\n * Currently damping is implemented in log-space in the following\n * equation:\n *\n * \\code\n * log(new_message) = DAMPING * log(old_message) + \n * (1-DAMPING) * log(new_message);\n * \\endcode\n *\n * This parameter is set as a command line argument.\n */\ndouble DAMPING = 0.1;\n\n/**\n * \\brief The convergence threshold for each message. Smaller values\n * imply tighter convergence but slower execution.\n *\n *\n * The algorithm convergence when:\n * \n * \\code\n * sum(abs(log(old_message) - log(new_message))) < TOLERANCE\n * \\endcode\n *\n * The parameter is set as a command line argument\n */\ndouble TOLERANCE = 0.01;\n\n\n\nbool USE_CACHE = false;\n\n\n/**\n * Make a synthetic node potential\n */\nfactor_type make_node_potential(size_t vid) {\n // const size_t obs = vid % NSTATES;\n const size_t obs = 0;\n factor_type factor;\n factor.setZero(NSTATES);\n if(vid % 101 < 1) {\n for(size_t i = 0; i < NSTATES; ++i) {\n factor(i) = (i == obs)? 0 : -FIELD;\n }\n } \n return factor;\n}\n\n/**\n * \\brief The vertex data contains the vertex potential as well as the\n * current belief estimate and represents a random variable in the\n * Markov Random Field.\n *\n * The vertex potential represents the prior and is obtained from the\n * vertex prior file (stored in log form).\n *\n * The belief represents the current posterior estimate.\n */\nstruct vertex_data {\n factor_type belief;\n void load(graphlab::iarchive& arc) { arc >> belief; }\n void save(graphlab::oarchive& arc) const { arc << belief; }\n}; // end of vertex_data\n\n\n/**\n * \\brief The edge data represents an edge in the Markov Random Field\n * and contains the loopy belief propagation message in both\n * directions along that edge as well as the old message in each\n * direction. In addition each edge contains the weight parameter\n * used to set edge specific smoothing (default value is 1).\n */\nclass edge_data {\n /**\n * \\brief We store old and new messages in both directions as an\n * array of messages. The particular message index is then computed\n * using the \\ref message_idx function.\n */\n factor_type messages_[4];\n /**\n * \\brief The weight associated with the edge (used to scale the\n * smoothing parameter)\n */\n double weight_;\n /**\n * \\brief The function used to compute the message index in the edge\n * message array.\n */\n size_t message_idx(size_t source_id, size_t target_id, bool is_new) {\n return size_t(source_id < target_id) + 2 * size_t(is_new);\n }\n\npublic:\n\n edge_data(const double w = 1) : weight_(w) { }\n const double& weight() const { return weight_; }\n\n /**\n * \\brief Get the new message value from source_id to target_id\n */\n factor_type& message(size_t source_id, size_t target_id) { \n return messages_[message_idx(source_id, target_id, true)];\n }\n /**\n * \\brief Get the old message value from source_id to target_id\n */\n factor_type& old_message(size_t source_id, size_t target_id) { \n return messages_[message_idx(source_id, target_id, false)];\n }\n\n /**\n * \\brief Set the old message value equal to the new message value\n */\n void update_old(size_t source_id, size_t target_id) { \n old_message(source_id, target_id) = message(source_id, target_id);\n }\n \n /**\n * \\brief Initialize the edge data with source and target having the\n * appropriate number of states.\n *\n * \\param source_id the vertex id of the source\n * \\param nsource the number of states the source vertex takes\n * \\param target_id the vertex id of the target\n * \\param ntarget the number of states the target vertex takes\n */\n void initialize(size_t source_id, size_t nsource, size_t target_id, size_t ntarget) {\n ASSERT_GT(nsource, 0); ASSERT_GT(ntarget, 0);\n message(source_id, target_id).setZero(ntarget);\n old_message(source_id, target_id).setZero(ntarget);\n message(target_id, source_id).setZero(nsource);\n old_message(target_id, source_id).setZero(nsource);\n }\n void save(graphlab::oarchive& arc) const {\n for(size_t i = 0; i < 4; ++i) arc << messages_[i];\n arc << weight_;\n }\n void load(graphlab::iarchive& arc) {\n for(size_t i = 0; i < 4; ++i) arc >> messages_[i];\n arc >> weight_;\n }\n}; // End of edge data\n\n\n\n/**\n * \\brief The graph type used to store the Markov Random Field with\n * vertex data containing node potentials and beliefs and edge data\n * containing messages and weights.\n */\ntypedef graphlab::distributed_graph graph_type;\n\n\n\n\n\n\n/** \n * \\brief The Loopy Belief Propagation Vertex Program which computes\n * the product of the inbound messages during the gather phase,\n * updates the belief during the apply phase, and then computes the\n * new out-bound messages during the scatter phase.\n *\n * Since the gather phase is computing the product of the inbound\n * messages and the messages are stored in log form the resulting sum\n * operation is actually a vector sum and so the gather type is simply\n * the factor type and the operator+= operation for the factor type is\n * sufficient.\n *\n */\nstruct bp_vertex_program : \n public graphlab::ivertex_program< graph_type, factor_type,\n graphlab::messages::sum_priority >,\n public graphlab::IS_POD_TYPE {\n\n /**\n * \\brief Since the MRF is undirected we will use all edges for gather and\n * scatter\n */\n edge_dir_type gather_edges(icontext_type& context,\n const vertex_type& vertex) const { \n return graphlab::ALL_EDGES; \n }; // end of gather_edges \n\n /**\n * \\brief Update the old message to be the new message and collect the\n * message value.\n */\n factor_type gather(icontext_type& context, const vertex_type& vertex, \n edge_type& edge) const {\n const vertex_type other_vertex = get_other_vertex(edge, vertex);\n edge_data& edata = edge.data();\n // Update the old message with the value of the new Message. We\n // then receive the old message during gather and then compute the\n // \"cavity\" during scatter (again using the old message).\n edata.update_old(other_vertex.id(), vertex.id());\n const factor_type& recv_message = \n edata.old_message(other_vertex.id(), vertex.id());\n return recv_message;\n\n }; // end of gather function\n\n /**\n * \\brief Multiply message product by node potential and update the\n * belief.\n */\n void apply(icontext_type& context, vertex_type& vertex, \n const factor_type& total) {\n // If we have no neighbors than the belief is equal to the\n // potential so simply update the belief\n if(vertex.num_in_edges() + vertex.num_out_edges() == 0) {\n vertex.data().belief = make_node_potential(vertex.id());\n } else {\n vertex_data& vdata = vertex.data();\n // Multiply (add in log space) the potential to compute the belief\n vdata.belief = make_node_potential(vertex.id()) + total;\n ASSERT_GT(vdata.belief.size(), 0);\n // Rescale the belief to ensure numerical stability. (This is\n // essentially normalization in log-space.)\n vdata.belief.array() -= vdata.belief.maxCoeff();\n }\n }; // end of apply\n\n /**\n * \\brief Since the MRF is undirected we will use all edges for gather and\n * scatter\n */\n edge_dir_type scatter_edges(icontext_type& context,\n const vertex_type& vertex) const { \n return graphlab::ALL_EDGES; \n }; // end of scatter edges\n\n /**\n * \\brief Compute new message value for each edge.\n */\n void scatter(icontext_type& context, const vertex_type& vertex, \n edge_type& edge) const { \n const vertex_type other_vertex = get_other_vertex(edge, vertex);\n edge_data& edata = edge.data();\n // Divide (subtract in log space) out of the belief the old in\n // message to construct the cavity\n const factor_type& old_in_message = \n edata.old_message(other_vertex.id(), vertex.id());\n ASSERT_EQ(old_in_message.size(), vertex.data().belief.size());\n factor_type cavity = vertex.data().belief - old_in_message;\n // compute the new message by convolving with the Ising-Potts Edge\n // factor.\n factor_type& new_out_message = \n edata.message(vertex.id(), other_vertex.id());\n // Make a backup of the last sent message which we will use to\n // maintain the cache\n const factor_type last_sent_message = new_out_message;\n const factor_type& last_recv_message = \n edata.old_message(vertex.id(), other_vertex.id());\n convolve(cavity, edata.weight(), new_out_message);\n // Renormalize (done in log space)\n new_out_message.array() -= new_out_message.maxCoeff();\n // // Apply damping to the message to stabilize convergence.\n new_out_message = DAMPING * last_sent_message + \n (1-DAMPING) * new_out_message;\n // Compute message residual\n const double residual = \n (new_out_message - last_recv_message).cwiseAbs().sum();\n if(USE_CACHE) {\n // context.clear_gather_cache(other_vertex);\n context.post_delta(other_vertex, new_out_message - last_sent_message);\n edata.update_old(vertex.id(), other_vertex.id());\n }\n // Schedule the adjacent vertex\n if(residual > TOLERANCE) context.signal(other_vertex, residual);\n }; // end of scatter\n\nprivate:\n\n /**\n * \\brief Compute the convolution of the cavity with the Ising-Potts\n * edge potential and store the result in the message\n *\n * \\param cavity the belief minus the in-bound message\n * \\param weight the edge weight used to scale the smoothing parameter\n * \\param [out] message The message in which to store the result of\n * the convolution.\n */\n inline void convolve(const factor_type& cavity, const double& weight, \n factor_type& message) const {\n for(int i = 0; i < message.size(); ++i) {\n double sum = 0;\n for(int j = 0; j < cavity.size(); ++j) {\n sum += std::exp( cavity(j) + ( i == j? 0 : -(SMOOTHING*weight) ) ); \n }\n // To try and ensure numerical stability we do not allow\n // messages to underflow in log-space\n message(i) = (sum > 0)? std::log(sum) : \n std::numeric_limits::min();\n }\n } // end of convolve\n \n /**\n * \\brief Given an edge and a vertex return the other vertex along\n * that edge. \n */\n inline vertex_type get_other_vertex(edge_type& edge, \n const vertex_type& vertex) const {\n return vertex.id() == edge.source().id()? edge.target() : edge.source();\n }; // end of other_vertex\n\n}; // end of class bp_vertex_program\n\n\n\n\n \n\n\n\n\n\n/**\n * \\brief The edge data loader is used by the GraphLab graph loading\n * API to parse lines in the edge data file. \n */\nbool edge_loader(graph_type& graph, const std::string& fname, \n const std::string& line) {\n ASSERT_FALSE(line.empty()); \n namespace qi = boost::spirit::qi;\n namespace ascii = boost::spirit::ascii;\n namespace phoenix = boost::phoenix;\n graphlab::vertex_id_type source(-1), target(-1);\n double weight = 1;\n const bool success = qi::phrase_parse\n (line.begin(), line.end(), \n // Begin grammar\n (\n qi::ulong_[phoenix::ref(source) = qi::_1] >> -qi::char_(',') \n >> qi::ulong_[phoenix::ref(target) = qi::_1] >> \n -(-qi::char_(',') >> qi::double_[phoenix::ref(weight) = qi::_1])\n )\n ,\n // End grammar\n ascii::space);\n if(!success) return false;\n if(source == target) return true;\n else {\n graph.add_edge(source, target, edge_data(weight));\n return true;\n }\n} // end of edge loader\n\n\n\n/**\n * \\brief The edge initializer is used to allocate the messages along\n * each edge based on the number of states of the source and target\n * vertex.\n */\nvoid edge_initializer(graph_type::edge_type& edge) {\n edge_data& edata = edge.data();\n const graphlab::vertex_id_type source_id = edge.source().id();\n const size_t nsource = NSTATES;\n const graphlab::vertex_id_type target_id = edge.target().id();\n const size_t ntarget = NSTATES;\n edata.initialize(source_id, nsource, target_id, ntarget);\n} // end of edge initializer\n\n\n\n\n/**\n * \\brief The belief prediction saver is used to save the belief\n * predictions for each vertex.\n */\nstruct belief_prediction_saver {\n typedef graph_type::vertex_type vertex_type;\n typedef graph_type::edge_type edge_type;\n std::string save_vertex(const vertex_type& vertex) const {\n std::stringstream strm;\n strm << vertex.id() << '\\t';\n factor_type pred = vertex.data().belief;\n double sum = 0;\n for(int i = 0; i < pred.size(); ++i) \n sum += (pred(i) = std::exp(pred(i)));\n pred.array() /= sum;\n for(int i = 0; i < pred.size(); ++i) \n strm << pred(i) << (i+1 < pred.size()? '\\t' : '\\n');\n return strm.str();\n }\n std::string save_edge(const edge_type& edge) const {\n return \"\"; // nop\n }\n}; // end of belief_prediction_saver\n\n\n/**\n * \\brief The MAP prediction saver is used to save the map estimated\n * for each vertex. The MAP estimate is the most likely assignment\n */\nstruct map_prediction_saver {\n typedef graph_type::vertex_type vertex_type;\n typedef graph_type::edge_type edge_type;\n std::string save_vertex(const vertex_type& vertex) const {\n std::stringstream strm;\n size_t prediction = 0;\n vertex.data().belief.maxCoeff(&prediction);\n strm << vertex.id() << '\\t' << prediction << '\\n';\n return strm.str();\n }\n std::string save_edge(const edge_type& edge) const {\n return \"\"; // nop\n }\n}; // end of map prediction_saver\n\n\n\n\n\nint main(int argc, char** argv) {\n global_logger().set_log_level(LOG_INFO);\n global_logger().set_log_to_console(true);\n ///! Initialize control plain using mpi\n graphlab::mpi_tools::init(argc, argv);\n graphlab::distributed_control dc;\n // Parse command line options -----------------------------------------------\n // \\todo update description string\n const std::string description = \"Structure prediction solver\";\n graphlab::command_line_options clopts(description);\n \n std::string graph_dir;\n std::string output_dir = \"pred\";\n std::string exec_type = \"async\";\n std::string format = \"tsv\";\n bool map = false;\n clopts.attach_option(\"graph\", graph_dir,\n \"The directory containing the adjacency graph\");\n clopts.add_positional(\"graph\"); \n clopts.attach_option(\"field\", FIELD, \n \"The background field used to construct the node potentials\");\n clopts.attach_option(\"nstates\", NSTATES, \n \"The number of states for each variable\");\n clopts.attach_option(\"cache\", USE_CACHE, \"use gather caching\");\n clopts.attach_option(\"output\", output_dir,\n \"The directory in which to save the predictions\");\n clopts.attach_option(\"format\", format, \"The graph file format.\");\n clopts.add_positional(\"output\");\n clopts.attach_option(\"smoothing\", SMOOTHING,\n \"The amount of smoothing (larger = more)\");\n clopts.attach_option(\"damping\", DAMPING,\n \"The amount of damping (0 -> no damping and 1 -> no progress)\");\n clopts.attach_option(\"tol\", TOLERANCE,\n \"The tolerance level for convergence.\");\n clopts.attach_option(\"map\", map,\n \"Return maximizing assignment instead of the posterior distribution.\");\n clopts.attach_option(\"engine\", exec_type,\n \"The type of engine to use {async, sync}.\");\n if(!clopts.parse(argc, argv)) {\n graphlab::mpi_tools::finalize();\n return clopts.is_set(\"help\")? EXIT_SUCCESS : EXIT_FAILURE;\n }\n\n clopts.get_engine_args().set_option(\"use_cache\", USE_CACHE);\n\n if(graph_dir.empty()) {\n logstream(LOG_ERROR) << \"No graph was provided.\" << std::endl;\n return EXIT_FAILURE;\n }\n\n // Start the webserver\n graphlab::launch_metric_server();\n\n ///! load the graph\n graph_type graph(dc, clopts); \n\n\n ///! load the graph\n graph.load_format(graph_dir, format);\n graph.finalize();\n dc.cout() << \"Initializing edge data\" << std::endl;\n graph.transform_edges(edge_initializer);\n\n typedef graphlab::omni_engine engine_type;\n engine_type engine(dc, graph, exec_type, clopts);\n engine.signal_all();\n graphlab::timer timer;\n dc.cout() << \"Running engine\" << std::endl;\n engine.start(); \n const double runtime = timer.current_time();\n dc.cout() \n << \"----------------------------------------------------------\" << std::endl\n << \"Final Runtime (seconds): \" << runtime \n << std::endl\n << \"Updates executed: \" << engine.num_updates() << std::endl\n << \"Update Rate (updates/second): \" \n << engine.num_updates() / runtime << std::endl;\n \n \n std::cout << \"Saving predictions\" << std::endl;\n const bool gzip_output = false;\n const bool save_vertices = true;\n const bool save_edges = false;\n const size_t threads_per_machine = 2;\n if(map) {\n graph.save(output_dir, map_prediction_saver(),\n gzip_output, save_vertices, \n save_edges, threads_per_machine);\n } else { \n graph.save(output_dir, belief_prediction_saver(),\n gzip_output, save_vertices, \n save_edges, threads_per_machine);\n }\n\n\n \n // graphlab::stop_metric_server_on_eof();\n graphlab::stop_metric_server();\n graphlab::mpi_tools::finalize();\n return EXIT_SUCCESS;\n\n\n} // end of main\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "0f5fdf11398341b222c5caf87fe3b0b03b740777", "size": 19767, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "toolkits/graphical_models/profile_lbp_synthetic.cpp", "max_stars_repo_name": "coreyp1/graphlab", "max_stars_repo_head_hexsha": "637be90021c5f83ab7833ca15c48e76039057969", "max_stars_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_stars_count": 8.0, "max_stars_repo_stars_event_min_datetime": "2017-11-19T11:46:55.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-08T22:45:55.000Z", "max_issues_repo_path": "toolkits/graphical_models/profile_lbp_synthetic.cpp", "max_issues_repo_name": "coreyp1/graphlab", "max_issues_repo_head_hexsha": "637be90021c5f83ab7833ca15c48e76039057969", "max_issues_repo_licenses": ["ECL-2.0", "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": "toolkits/graphical_models/profile_lbp_synthetic.cpp", "max_forks_repo_name": "coreyp1/graphlab", "max_forks_repo_head_hexsha": "637be90021c5f83ab7833ca15c48e76039057969", "max_forks_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2015-12-15T12:12:23.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-16T16:48:40.000Z", "avg_line_length": 31.2768987342, "max_line_length": 94, "alphanum_fraction": 0.6673749178, "num_tokens": 4760, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744584140003, "lm_q2_score": 0.6619228825191872, "lm_q1q2_score": 0.5411712421874584}} {"text": "/*\n * Copyright (c) 2008--2011, Universitaet Bremen\n * All rights reserved.\n *\n * Author: Christoph Hertzberg \n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of the Universitaet Bremen nor the names of its\n * contributors may be used to endorse or promote products derived\n * from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS\n * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE\n * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,\n * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,\n * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\n * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n */\n/**\n * @file mtk/types/SOn.hpp\n * @brief Standard Orthogonal Groups i.e.\\ rotatation groups.\n */\n#ifndef SON_H_\n#define SON_H_\n\n\n#include \"vect.hpp\"\n#include \"../src/mtkmath.hpp\"\n\n#include \n\nnamespace MTK {\n\n\n/**\n * Two-dimensional orientations represented as scalar.\n * There is no guarantee that the representing scalar is within any interval,\n * but the result of boxminus will always have magnitude @f$\\le\\pi @f$.\n */\ntemplate\nstruct SO2 : public Eigen::Rotation2D<_scalar> {\n\tenum {DOF = 1, DIM = 2};\n\t\n\ttypedef _scalar scalar;\n\ttypedef Eigen::Rotation2D base;\n\ttypedef vect vect_type;\n\t\n\t//using base::operator=;\n\t\n\t//! Construct from angle\n\tSO2(const scalar& angle = 0) : base(angle) {\t}\n\t\n\t//! Construct from Eigen::Rotation2D\n\tSO2(const base& src) : base(src) {}\n\t\n\t/**\n\t * Construct from 2D vector.\n\t * Resulting orientation will rotate the first unit vector to point to vec.\n\t */\n\tSO2(const vect_type &vec) : base(atan2(vec[1], vec[0])) {};\n\t\n\t\n\t//! Calculate @c this->inverse() * @c r\n\tSO2 operator%(const base &r) const {\n\t\treturn base::inverse() * r;\n\t}\n\n\t//! Calculate @c this->inverse() * @c r\n\ttemplate\n\tvect_type operator%(const Eigen::MatrixBase &vec) const {\n\t\treturn base::inverse() * vec;\n\t}\n\t\n\t//! Calculate @c *this * @c r.inverse()\n\tSO2 operator/(const SO2 &r) const {\n\t\treturn *this * r.inverse();\n\t}\n\t\n\t//! Gets the angle as scalar.\n\toperator scalar() const {\n\t\treturn base::angle();\n\t}\n\t\n\t//! @name Manifold requirements\n\t//{\n\tvoid boxplus(MTK::vectview vec, scalar scale=1) {\n\t\tbase::angle() += scale * vec[0];\n\t}\n\tvoid boxminus(MTK::vectview res, const SO2& other) const {\n\t\tres[0] = MTK::normalize(base::angle() - other.angle(), scalar(MTK::pi));\n\t}\n\t//}\n\t\n\tfriend std::istream& operator>>(std::istream &is, SO2& ang){\n\t\treturn is >> ang.angle();\n\t}\n\n};\n\n\n/**\n * Three-dimensional orientations represented as Quaternion.\n * It is assumed that the internal Quaternion always stays normalized,\n * should this not be the case, call inherited member function @c normalize().\n */\ntemplate\nstruct SO3 : public Eigen::Quaternion<_scalar, Options> {\n\tenum {DOF = 3, DIM = 3};\n\ttypedef _scalar scalar_type;\n\ttypedef Eigen::Quaternion base;\n\ttypedef Eigen::Quaternion Quaternion;\n\ttypedef vect vectorized_type;\n\t\n\t//using base::operator=;\n\t\n\t//! Calculate @c this->inverse() * @c r\n\ttemplate EIGEN_STRONG_INLINE \n\tQuaternion operator%(const Eigen::QuaternionBase &r) const {\n\t\treturn base::conjugate() * r;\n\t}\n\t\n\t//! Calculate @c this->inverse() * @c r\n\ttemplate\n\tvectorized_type operator%(const Eigen::MatrixBase &vec) const {\n\t\treturn base::conjugate() * vec;\n\t}\n\t\n\t//! Calculate @c this * @c r.conjugate()\n\ttemplate EIGEN_STRONG_INLINE \n\tQuaternion operator/(const Eigen::QuaternionBase &r) const {\n\t\treturn *this * r.conjugate();\n\t}\n\t\n\t/**\n\t * Construct from real part and three imaginary parts.\n\t * Quaternion is normalized after construction.\n\t */\n\tSO3(const scalar_type& w, const scalar_type& x, const scalar_type& y, const scalar_type& z) : base(w, x, y, z) {\n\t\tbase::normalize();\n\t}\n\t\n\t/**\n\t * Construct from Eigen::Quaternion.\n\t * @note Non-normalized input may result result in spurious behavior.\n\t */\n\tSO3(const base& src = base::Identity()) : base(src) {}\n\t\n\t/**\n\t * Construct from rotation matrix.\n\t * @note Invalid rotation matrices may lead to spurious behavior.\n\t */\n\ttemplate\n\tSO3(const Eigen::MatrixBase& matrix) : base(matrix) {}\n\t\n\t/**\n\t * Construct from arbitrary rotation type.\n\t * @note Invalid rotation matrices may lead to spurious behavior.\n\t */\n\ttemplate\n\tSO3(const Eigen::RotationBase& rotation) : base(rotation.derived()) {}\n\t\n\t//! @name Manifold requirements\n\t//{\n\tSO3 operator+(const vectorized_type& vec) const {\n\t\tSO3 delta = exp(vec);\n\t\treturn delta * *this;\n\t}\n\n void operator+=(const vectorized_type& vec) {\n *this = *this + vec;\n }\n\n\tauto operator-(const SO3& other) const {\n\t\treturn SO3::log(*this * other.conjugate());\n\t}\n\t//}\n\t\n\tfriend std::ostream& operator<<(std::ostream &os, const SO3& q){\n\t\treturn os << q.coeffs().transpose() << \" \";\n\t}\n\tfriend std::istream& operator>>(std::istream &is, SO3& q){\n\t\tvect<4,scalar_type> coeffs;\n\t\tis >> coeffs;\n\t\tq.coeffs() = coeffs.normalized();\n\t\treturn is;\n\t}\n\t\n\t//! @name Helper functions\n\t//{\n\t/**\n\t * Calculate the exponential map. In matrix terms this would correspond \n\t * to the Rodrigues formula.\n\t */\n\t// FIXME vectview<> can't be constructed from every MatrixBase<>, use const Vector3x& as workaround\n//\tstatic SO3 exp(MTK::vectview dvec, scalar scale = 1){\n\tstatic SO3 exp(const Eigen::Matrix& dvec, scalar_type scale = 1){\n\t\tSO3 res;\n\t\tres.w() = MTK::exp(res.vec(), dvec, scalar_type(scale / 2));\n\t\treturn res;\n\t}\n\t/**\n\t * Calculate the inverse of @c exp.\n\t * Only guarantees that exp(log(x)) == x \n\t */\n\tstatic typename base::Vector3 log(const SO3 &orient){\n\t\ttypename base::Vector3 res;\n\t\tMTK::log(res, orient.w(), orient.vec(), scalar_type(2), true);\n\t\treturn res;\n\t}\n\t//}\n};\n\nnamespace internal {\ntemplate\nstruct UnalignedType >{\n\ttypedef SO2 type;\n};\n\ntemplate\nstruct UnalignedType >{\n\ttypedef SO3 type;\n};\n\n} // namespace internal\n\n\n} // namespace MTK\n\n#endif /*SON_H_*/\n\n", "meta": {"hexsha": "8048b6d02f65aa7e91c291643f6dbdbe32b96fb3", "size": 7548, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "examples/slam_and_orientation/mtk/types/SOn.hpp", "max_stars_repo_name": "mfkiwl/ADEKF", "max_stars_repo_head_hexsha": "178092b7585b0f311ed7889820704e74dab12bd1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 90.0, "max_stars_repo_stars_event_min_datetime": "2021-01-04T11:04:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-23T01:43:07.000Z", "max_issues_repo_path": "examples/slam_and_orientation/mtk/types/SOn.hpp", "max_issues_repo_name": "mfkiwl/ADEKF", "max_issues_repo_head_hexsha": "178092b7585b0f311ed7889820704e74dab12bd1", "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": "examples/slam_and_orientation/mtk/types/SOn.hpp", "max_forks_repo_name": "mfkiwl/ADEKF", "max_forks_repo_head_hexsha": "178092b7585b0f311ed7889820704e74dab12bd1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11.0, "max_forks_repo_forks_event_min_datetime": "2021-04-26T09:18:07.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-23T01:43:10.000Z", "avg_line_length": 30.6829268293, "max_line_length": 113, "alphanum_fraction": 0.6963434022, "num_tokens": 1976, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7401743735019595, "lm_q2_score": 0.7310585669110202, "lm_q1q2_score": 0.5411108167566047}} {"text": "#include \r\n#include \r\n\r\nusing namespace Eigen;\r\n\r\n// [circulant_func]\r\ntemplate\r\nclass circulant_functor {\r\n const ArgType &m_vec;\r\npublic:\r\n circulant_functor(const ArgType& arg) : m_vec(arg) {}\r\n\r\n const typename ArgType::Scalar& operator() (Index row, Index col) const {\r\n Index index = row - col;\r\n if (index < 0) index += m_vec.size();\r\n return m_vec(index);\r\n }\r\n};\r\n// [circulant_func]\r\n\r\n// [square]\r\ntemplate\r\nstruct circulant_helper {\r\n typedef Matrix MatrixType;\r\n};\r\n// [square]\r\n\r\n// [makeCirculant]\r\ntemplate \r\nCwiseNullaryOp, typename circulant_helper::MatrixType>\r\nmakeCirculant(const Eigen::MatrixBase& arg)\r\n{\r\n typedef typename circulant_helper::MatrixType MatrixType;\r\n return MatrixType::NullaryExpr(arg.size(), arg.size(), circulant_functor(arg.derived()));\r\n}\r\n// [makeCirculant]\r\n\r\n// [main]\r\nint main()\r\n{\r\n Eigen::VectorXd vec(4);\r\n vec << 1, 2, 4, 8;\r\n Eigen::MatrixXd mat;\r\n mat = makeCirculant(vec);\r\n std::cout << mat << std::endl;\r\n}\r\n// [main]\r\n", "meta": {"hexsha": "f633af217cf721f0f116bee8c6503f0f455edc9c", "size": 1372, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "packages/eigen-eigen-323c052e1731/doc/examples/make_circulant2.cpp", "max_stars_repo_name": "k4rth33k/dnnc-operators", "max_stars_repo_head_hexsha": "a7fe3f1240c12b3438558def71fbfcd4520446c3", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2019-08-16T14:35:17.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-11T23:59:22.000Z", "max_issues_repo_path": "packages/eigen-eigen-323c052e1731/doc/examples/make_circulant2.cpp", "max_issues_repo_name": "k4rth33k/dnnc-operators", "max_issues_repo_head_hexsha": "a7fe3f1240c12b3438558def71fbfcd4520446c3", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-08-12T04:38:14.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-04T16:32:13.000Z", "max_forks_repo_path": "packages/eigen-eigen-323c052e1731/doc/examples/make_circulant2.cpp", "max_forks_repo_name": "k4rth33k/dnnc-operators", "max_forks_repo_head_hexsha": "a7fe3f1240c12b3438558def71fbfcd4520446c3", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2019-08-15T13:29:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-09T17:08:04.000Z", "avg_line_length": 25.8867924528, "max_line_length": 101, "alphanum_fraction": 0.6501457726, "num_tokens": 351, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7310585786300049, "lm_q2_score": 0.7401743505760728, "lm_q1q2_score": 0.5411108086705307}} {"text": "#include \n#include \n#include \"generalprimary.h\"\n#include \"primarynumber.h\"\n#include \"primaryvariable.h\"\n#include \"servicecontainer.h\"\n#include \"primaryfunction.h\"\n#include \"primaryexpression.h\"\n\n\n\ndouble compile_time_expression_structure::generalPrimary::value(double prime) const\n{\n if (isFactorial)\n {\n if (prime<0.0)\n throw std::logic_error(\"factorial applied to neg. value\");\n using boost::numeric_cast;\n unsigned int uif = numeric_cast(prime);\n double duif = numeric_cast(uif);\n if (prime-duif > std::numeric_limits::min())\n throw std::logic_error(\"factorial applied to not integer value\");\n return boost::math::factorial(uif);\n }\n else\n { \n return prime;\n }\n}\n\nstd::unique_ptr\ncompile_time_expression_structure::generalPrimary::createPrimary\n(compile_time_expression_structure::serviceContainer& sc)\n{\n Token t {sc.pop()};\n std::unique_ptr gp{nullptr};\n switch (t.kind) {\n case TokenKind::number:\n {\n gp = std::make_unique(t.value);\n break;\n }\n case TokenKind::variable:\n {\n // first find in constants\n auto gcit {global_constants_id.find(t.name)};\n if (gcit == cend(global_constants_id))\n {\n auto vit {global_variables_id.find(t.name)};\n if (vit == cend(global_variables_id))\n throw std::logic_error(\"undefined variable literal \" + t.name);\n // not constant\n gp = std::make_unique(vit->second, sc);\n break;\n }\n auto cit = global_constants.find(gcit->second);\n if (cit == cend(global_constants))\n throw std::logic_error(\"undefined symbolic literal\");\n const double Value = cit->second;\n gp = std::make_unique(Value);\n break;\n }\n case TokenKind::function:\n {\n auto gfidIt {global_functions_id.find(t.name)};\n if (gfidIt == cend(global_functions_id))\n throw std::logic_error(\"unknown function name\");\n gp = std::make_unique(gfidIt->second, sc);\n break;\n }\n case TokenKind::bracket_left0:\n// case TokenKind::bracket_left1:\n {\n gp = std::make_unique(sc);\n //double d {expression(ist)};\n Token t2 {sc.pop()};\n if (t2.kind != TokenKind::bracket_right0)\n throw std::logic_error(\"bracket_right expected\");\n break;\n }\n// case TokenKind::bracket_left1:\n// {\n// double d {expression()};\n// t = ts.pop();\n// if (t.kind != TokenKind::bracket_right1)\n// throw std::logic_error(\"bracket_right expected\");\n// result = d;\n// break;\n// }\n default:\n throw std::logic_error(\"primary is expected\");\n }\n\n Token tp {sc.pop()};\n if (tp.kind == TokenKind::factorial)\n {\n gp->setFactorial(true);\n }\n else {\n sc.push(tp);\n }\n return gp;\n}\n\n\n", "meta": {"hexsha": "2c25be79f83215982400193e187f2575e14cfbbb", "size": 3396, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ctexpression/generalprimary.cpp", "max_stars_repo_name": "vega1986/wcalc_expression_parser", "max_stars_repo_head_hexsha": "e9645a5fa8086c4108ce4dc1f3ad7da3cead6480", "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": "ctexpression/generalprimary.cpp", "max_issues_repo_name": "vega1986/wcalc_expression_parser", "max_issues_repo_head_hexsha": "e9645a5fa8086c4108ce4dc1f3ad7da3cead6480", "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": "ctexpression/generalprimary.cpp", "max_forks_repo_name": "vega1986/wcalc_expression_parser", "max_forks_repo_head_hexsha": "e9645a5fa8086c4108ce4dc1f3ad7da3cead6480", "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.0377358491, "max_line_length": 83, "alphanum_fraction": 0.5736160188, "num_tokens": 741, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920116079209, "lm_q2_score": 0.6757646075489392, "lm_q1q2_score": 0.5410793229917973}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing complex = std::complex;\nconstexpr double PI = 3.14159'26535'89793'23846'26433'83279'50288;\n\nstd::uint8_t colu(double t0) {\n double t = std::fmod(std::fmod(t0, 3.0) + 3.0, 3.0);\n if (t < 2) {\n return static_cast(\n std::lround((1 - std::cos(t * PI)) * (255 / 2.0)));\n } else {\n return 0;\n }\n}\n\ncv::Vec3b color(double t0) {\n double t = t0;\n return {colu(t), colu(t + 1), colu(t + 2)};\n}\n\ndouble abslog(double x) {\n if (x == 0) {\n return 0;\n }\n auto l = std::log(std::abs(x) + 1);\n auto sign = x < 0 ? -1 : 1;\n return l * sign;\n}\n\nclass mandel_maker {\n cv::Vec3d pix_at(double x, double y) {\n complex z{0.0, 0.0};\n auto c = complex{x, y};\n std::vector points;\n points.reserve(rep);\n constexpr double LIMIT = 20;\n for (int ix = 0; ix < rep; ++ix) {\n z = z*z*z/(std::abs(z)+1e-10)+c;\n if (LIMIT < std::abs(z)) {\n return {static_cast(ix), std::arg(z), std::abs(z)};\n }\n points.emplace_back(cv::Point2f(abslog(real(z)), abslog(imag(z))));\n }\n std::vector hull;\n cv::convexHull(points, hull);\n auto area = cv::contourArea(hull);\n return {-1, std::arg(z), area};\n }\n int rep;\n int w, h;\n double x0, dx;\n double y0, dy;\n\npublic:\n explicit mandel_maker(int rep_, int w_, int h_, double x0_, double x1_,\n double y0_)\n : rep(rep_), w(w_), h(h_), x0(x0_), dx((x1_ - x0_) / w_), y0(y0_),\n dy((x1_ - x0_) * h_ / w_ / h_) {}\n cv::Mat make() {\n cv::Mat im = cv::Mat::zeros(w, h, CV_64FC3);\n#pragma omp parallel for\n for (int iy = 0; iy < h; ++iy) {\n double y = y0 + dy * iy;\n for (int ix = 0; ix < w; ++ix) {\n double x = x0 + ix * dx;\n auto col = pix_at(x, y);\n im.at(iy, ix) = col;\n }\n }\n return im;\n }\n};\n\ncv::Rect2d rect(char const *cmd) {\n double w0 = 1 << 5;\n cv::Rect2d r(-w0 / 2, -w0 / 2, w0, w0);\n for (; *cmd; ++cmd) {\n if (*cmd=='s'){\n auto w = r.width;\n auto h = r.height;\n auto dw = w/10;\n auto dh = h/10;\n r = cv::Rect2d( r.x+dw, r.y+dh, w-dw*2, h-dh*2 );\n continue;\n }\n double w = r.width / 2;\n double h = r.height / 2;\n double x, y;\n int c = *cmd - '0';\n switch (c % 3) {\n case 0:\n x = r.x;\n break;\n case 1:\n x = r.x + w / 2;\n break;\n case 2:\n x = r.x + w;\n break;\n }\n switch (c / 3) {\n case 0:\n y = r.y;\n break;\n case 1:\n y = r.y + h / 2;\n break;\n case 2:\n y = r.y + h;\n break;\n }\n r = cv::Rect2d(x, y, w, h);\n }\n return r;\n}\n\nvoid save_image(char const *filename, cv::Mat const &im) {\n cv::FileStorage fs(filename, cv::FileStorage::WRITE);\n fs << \"image\" << im;\n}\n\nstd::pair find_minmax(cv::Mat const &im) {\n int min = INT32_MAX;\n int max = INT32_MIN;\n auto end = im.end();\n for (auto it = im.begin(); it != end; ++it) {\n int32_t col = *it;\n if (col < 0) {\n continue;\n }\n if (col < min) {\n min = col;\n }\n if (max < col) {\n max = col;\n }\n }\n return {min, max};\n}\n\ncv::Mat colorize(cv::Mat const &src) {\n cv::Mat dest = cv::Mat::zeros(src.rows, src.cols, CV_8UC3);\n#pragma omp parallel for\n for (int y = 0; y < src.rows; ++y) {\n for (int x = 0; x < src.cols; ++x) {\n auto col{src.at(y, x)};\n if (col[0] < 0) {\n // auto c0 = color((col[2]*0.1 + col[1] / (PI * 2) * 3 + 3) * 3) / 2;\n auto c0 = color(std::log(col[2]));\n dest.at(y, x) = c0 / 2;\n } else {\n auto c0 = cv::Vec3b{255, 255, 255} - color(col[1] / (PI * 2) * 3 + 3);\n auto c1 = cv::Vec3b{255, 255, 255} - color(col[0] * 0.006 + 1);\n constexpr double W = 0.2;\n dest.at(y, x) = c0 * W + c1 * (1 - W);\n }\n }\n }\n return dest;\n}\n\nnamespace po = boost::program_options;\n\npo::options_description calc_options() {\n po::options_description desc(\"calc options\");\n desc.add_options() //\n (\"help\", \"produce help message\") //\n (\"size,s\", po::value()->default_value(60), \"size in mm\") //\n (\"dpi,d\", po::value()->default_value(96), \"DPI\") //\n (\"rep,r\", po::value()->default_value(1000), \"repeat count\") //\n (\"pos,p\", po::value()->default_value(\"\"), \"position\") //\n ;\n return desc;\n}\n\npo::options_description col_options() {\n po::options_description desc(\"col options\");\n desc.add_options() //\n (\"help\", \"produce help message\") //\n (\"infile,i\", po::value()->default_value(\"data/hoge.yaml\"),\n \"input yaml file\") //\n (\"outfile,o\", po::value()->default_value(\"data/hoge.png\"),\n \"output image file\") //\n ;\n return desc;\n}\n\nint calc(int argc, char const *argv[]) {\n auto desc = calc_options();\n try {\n po::variables_map vm;\n po::store(po::parse_command_line(argc, argv, desc), vm);\n if (vm.count(\"help\")) {\n std::cout << desc << \"\\n\";\n return 0;\n }\n double realsize = vm[\"size\"].as();\n double dpi = vm[\"dpi\"].as();\n auto pix = lround(realsize / 25.4 * dpi);\n omp_set_num_threads(16);\n int rep = vm[\"rep\"].as();\n cv::Rect2d rc = rect(vm[\"pos\"].as().c_str());\n auto mm = mandel_maker(rep, pix, pix, rc.x, rc.br().x, rc.y);\n cv::Mat im = mm.make();\n cv::imwrite(\"data/hoge.png\", colorize(im));\n save_image(\"data/hoge.yaml\", im);\n return 0;\n } catch (po::error &e) {\n std::cout << e.what() << std::endl;\n return 0;\n }\n}\n\nint colorize(int argc, char const *argv[]) {\n auto desc = col_options();\n try {\n po::variables_map vm;\n po::store(po::parse_command_line(argc, argv, desc), vm);\n if (vm.count(\"help\")) {\n std::cout << desc << \"\\n\";\n return 0;\n }\n auto infile = vm[\"infile\"].as();\n auto outfile = vm[\"outfile\"].as();\n std::cout << infile << \", \" << outfile << \"\\n\";\n\n cv::FileStorage fs(infile, cv::FileStorage::READ);\n cv::Mat im;\n fs[\"image\"] >> im;\n cv::imwrite(outfile, colorize(im));\n return 0;\n } catch (po::error &e) {\n std::cout << e.what() << std::endl;\n return 0;\n }\n}\nvoid show_help() {\n std::cout << calc_options() << \"\\n\" << col_options() << \"\\n\";\n}\n\nint main(int argc, char const *argv[]) {\n if (argc < 2) {\n show_help();\n return 0;\n }\n auto cmd = std::string(argv[1]);\n if (cmd == \"calc\") {\n return calc(argc - 1, argv + 1);\n } else if (cmd == \"col\") {\n return colorize(argc - 1, argv + 1);\n } else {\n show_help();\n return 0;\n }\n}\n", "meta": {"hexsha": "625e2db4c12d3e8b027343859894b640275b186d", "size": 6897, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/m0.cpp", "max_stars_repo_name": "nabetani/mandel", "max_stars_repo_head_hexsha": "70b286fc1b96e9471bde9ddddacb96f640b9c313", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/m0.cpp", "max_issues_repo_name": "nabetani/mandel", "max_issues_repo_head_hexsha": "70b286fc1b96e9471bde9ddddacb96f640b9c313", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/m0.cpp", "max_forks_repo_name": "nabetani/mandel", "max_forks_repo_head_hexsha": "70b286fc1b96e9471bde9ddddacb96f640b9c313", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.3244274809, "max_line_length": 78, "alphanum_fraction": 0.5173263738, "num_tokens": 2308, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673359709795, "lm_q2_score": 0.665410558746814, "lm_q1q2_score": 0.5408905082154837}} {"text": "#define NOMINMAX\n#include \"interactions.hpp\"\n#include \"vsh_translation.hpp\"\n#include \"indices.hpp\"\n#include \n#include \n#include \n\nusing std::complex;\nusing namespace std::complex_literals;\n\nusing Eigen::Vector3d;\n\nComplexVector matrix_vector_product(const Ref& A, const Ref& x) {\n int size = x.size();\n ComplexVector ret(size);\n#pragma omp parallel for\n for (int i = 0; i < size; i++) {\n ret(i) = A.row(i)*x;\n }\n\n return ret;\n}\n\ncomplex dot_product(const Ref& x, const Ref& y) {\n int size = x.size();\n double real_part = 0;\n double imag_part = 0;\n#pragma omp parallel for reduction(+:real_part,imag_part)\n for (int i = 0; i < size; i++) {\n real_part += x(i).real()*y(i).real() + x(i).imag()*y(i).imag();\n imag_part += x(i).real()*y(i).imag() - x(i).imag()*y(i).real();\n }\n\n return std::complex(real_part, imag_part);\n}\n\nComplexVector bicgstab(const Ref& A, const Ref& b,\n int maxiter, double tolerance) {\n\n int size = b.size();\n\n // step 1\n ComplexVector x_prev = b;\n ComplexVector r_prev = b - matrix_vector_product(A, x_prev);\n\n double error = (r_prev).norm();\n if (error < tolerance)\n return x_prev;\n\n // step 2\n ComplexVector r_hat = r_prev;\n\n // step 3\n complex rho_prev = 1;\n complex alpha = 1;\n complex w_prev = 1;\n\n // step 4\n ComplexVector v_prev = ComplexVector::Zero(size);\n ComplexVector p_prev = ComplexVector::Zero(size);\n\n // step 5\n int current_iteration = 1;\n\n while (true) {\n //complex rho_i = r_hat.dot(r_prev);\n complex rho_i = dot_product(r_hat, r_prev);\n complex beta = (rho_i/rho_prev)*(alpha/w_prev);\n ComplexVector pi = r_prev + beta*(p_prev - w_prev*v_prev);\n ComplexVector vi = matrix_vector_product(A, pi);\n\n //alpha = rho_i/r_hat.dot(vi);\n alpha = rho_i/dot_product(r_hat, vi);\n ComplexVector h = x_prev + alpha*pi;\n\n ComplexVector s = r_prev - alpha*vi;\n ComplexVector t = matrix_vector_product(A, s);\n //complex w_i = t.dot(s)/t.dot(t);\n complex w_i = dot_product(t,s)/dot_product(t,t);\n ComplexVector xi = h + w_i*s;\n ComplexVector ri = s - w_i*t;\n\n error = ri.norm();\n if (error < tolerance || current_iteration > maxiter)\n return xi;\n\n x_prev = xi;\n r_prev = ri;\n rho_prev = rho_i;\n v_prev = vi;\n p_prev = pi;\n w_prev = w_i;\n\n current_iteration += 1;\n }\n}\n\nComplexVector solve_linear_system(const Ref& agg_tmatrix,\n const Ref& p_src, solver method) {\n\n ComplexMatrix interaction_matrix = agg_tmatrix;\n for (int i = 0; i < interaction_matrix.cols(); i++)\n interaction_matrix(i,i) += 1;\n \n switch (method) {\n case solver::exact: // TODO: implment\n default:\n case solver::bicgstab:\n //Eigen::BiCGSTAB solver;\n //solver.setTolerance(1e-5);\n //solver.compute(interaction_matrix);\n //return solver.solveWithGuess(p_src, p_src);\n return bicgstab(interaction_matrix, p_src);\n }\n}\n\nComplexMatrix sphere_aggregate_tmatrix(const Ref& positions,\n const Ref& mie, double k) {\n\n int lmax = mie.cols()/2;\n int rmax = lmax_to_rmax(lmax);\n int Nparticles = positions.rows();\n int size = 2*rmax*Nparticles;\n\n ComplexMatrix agg_tmatrix = ComplexMatrix::Zero(size, size);\n\n if (Nparticles == 1)\n return agg_tmatrix;\n \n int N = Nparticles*(Nparticles-1)/2;\n Array ivals(N);\n Array jvals(N);\n int counter = 0;\n\n for (int i = 0; i < Nparticles; i++) {\n for (int j = i+1; j < Nparticles; j++) {\n ivals(counter) = i;\n jvals(counter) = j;\n counter += 1;\n }\n }\n \n auto vsh_precompute = create_vsh_cache_map(lmax);\n\n #pragma omp parallel for\n for (int ij = 0; ij < N; ij++) {\n int i = ivals(ij);\n int j = jvals(ij);\n\n Vector3d dji = positions.row(i) - positions.row(j);\n\n double rad = dji.norm();\n double theta = acos(dji(2)/rad);\n double phi = atan2(dji(1), dji(0));\n\n vsh_translation_insert_pair(agg_tmatrix, mie, i, j, rad, theta, phi, k, vsh_precompute);\n } \n\n return agg_tmatrix;\n}\n\nComplexMatrix particle_aggregate_tmatrix(const Ref& positions,\n const tmatrix_t& tmatrix, double k) {\n\n int rmax = tmatrix.dimensions()[1]/2;\n int lmax = rmax_to_lmax(rmax);\n\n int Nparticles = positions.rows();\n int size = 2*rmax*Nparticles;\n\n ComplexMatrix agg_tmatrix = ComplexMatrix::Zero(size, size);\n\n if (Nparticles == 1)\n return agg_tmatrix;\n \n int N = Nparticles*(Nparticles-1)/2;\n Array ivals(N);\n Array jvals(N);\n int counter = 0;\n\n for (int i = 0; i < Nparticles; i++) {\n for (int j = i+1; j < Nparticles; j++) {\n ivals(counter) = i;\n jvals(counter) = j;\n counter += 1;\n }\n }\n \n auto vsh_precompute = create_vsh_cache_map(lmax);\n\n #pragma omp parallel for\n for (int ij = 0; ij < N; ij++) {\n int i = ivals(ij);\n int j = jvals(ij);\n\n Vector3d dji = positions.row(i) - positions.row(j);\n\n double rad = dji.norm();\n double theta = acos(dji(2)/rad);\n double phi = atan2(dji(1), dji(0));\n\n vsh_translation_insert_pair(agg_tmatrix, tmatrix, i, j, rad, theta, phi, k, vsh_precompute);\n } \n\n return agg_tmatrix;\n}\n\nComplexMatrix reflection_matrix_nia(const Ref& positions,\n const Ref& mie, double k, complex reflection, double z) {\n\n int lmax = mie.cols()/2;\n int rmax = lmax_to_rmax(lmax);\n int Nparticles = positions.rows();\n int size = 2*rmax*Nparticles;\n\n ComplexMatrix R_matrix = ComplexMatrix::Zero(size, size);\n \n for (int i = 0; i < Nparticles; i++) {\n Vector3d pi = positions.row(i);\n pi(2) -= 2*(pi(2) - z);\n for (int j = 0; j < Nparticles; j++) {\n Vector3d pj = positions.row(j);\n Vector3d dji = pi - pj;\n\n double rad = dji.norm();\n double theta = acos(dji(2)/rad);\n double phi = atan2(dji(1), dji(0));\n\n for (int n = 1; n < lmax+1; n++) {\n for (int m = -n; m < n+1; m++) {\n for (int v = 1; v < lmax+1; v++) {\n for (int u = -v; u < v+1; u++) {\n auto transfer = vsh_translation(m, n, u, v, rad, theta, phi, k, vsh_mode::outgoing);\n for (int a = 0; a < 2; a++) {\n for (int b = 0; b < 2; b++) {\n complex factor = -reflection*pow(-1, m + n + a + 1);\n complex val = transfer[(a+b)%2];\n int idx = i*(2*rmax) + a*(rmax) + n*(n+2) - n + m - 1;\n int idy = j*(2*rmax) + b*(rmax) + v*(v+2) - v + u - 1;\n R_matrix(idx, idy) = factor*val*mie(j, b*lmax + v-1);\n } \n } \n } \n } \n } \n } \n } \n } \n\n return R_matrix;\n}\n\n", "meta": {"hexsha": "6bd022da96438c206619f268e1af56ab6c3bcd3b", "size": 7658, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "cpp/src/interactions.cpp", "max_stars_repo_name": "johnaparker/MiePy", "max_stars_repo_head_hexsha": "5c5bb5a07c8ab79e9e2a9fc79fb9779e690147be", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2016-05-30T06:45:29.000Z", "max_stars_repo_stars_event_max_datetime": "2017-08-30T19:58:56.000Z", "max_issues_repo_path": "cpp/src/interactions.cpp", "max_issues_repo_name": "johnaparker/MiePy", "max_issues_repo_head_hexsha": "5c5bb5a07c8ab79e9e2a9fc79fb9779e690147be", "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": "cpp/src/interactions.cpp", "max_forks_repo_name": "johnaparker/MiePy", "max_forks_repo_head_hexsha": "5c5bb5a07c8ab79e9e2a9fc79fb9779e690147be", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2016-12-13T02:05:31.000Z", "max_forks_repo_forks_event_max_datetime": "2018-03-23T07:11:30.000Z", "avg_line_length": 30.1496062992, "max_line_length": 112, "alphanum_fraction": 0.5507965526, "num_tokens": 2082, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8539127566694178, "lm_q2_score": 0.63341027059799, "lm_q1q2_score": 0.5408771102690515}} {"text": "/* Copyright (c) 2015, Julian Straub \n * Licensed under the MIT license. See the license file LICENSE.\n */\n \n\n#pragma once\n\n#include \n#include \n#include \n#include \n\n#include \n\n#include \n#include \n\nusing namespace Eigen;\nusing std::min;\nusing std::max;\nusing std::cout;\nusing std::endl;\n\n#ifdef BOOST_OLD\nusing boost::mt19937;\n#else\nusing boost::mt19937;\n#endif\n\n\n// TODO Template needs fixing - probably just remove\ntemplate \nclass Sphere\n{\npublic:\n Sphere(uint32_t D) : D_(D), north_(Matrix::Zero(D))\n {north_(D_-1) = 1.0;};\n \n //assumes north is size D and last entry is 1\n Sphere(Matrix north) : D_(north.rows()), north_(north)\n {};\n virtual ~Sphere() {};\n\n /* \n * normal in tangent space around p rotate to the north pole\n * -> the last dimension will always be 0\n * -> return only first 2 dims\n */\n virtual Matrix Log_p_north(const Matrix& p, \n const Matrix& q) const;\n /* \n * rotate points x in tangent plane around north pole down to p\n */\n Matrix rotate_north2p(const Matrix& p, \n const Matrix& xNorth) const;\n\n /* rotate points x in tangent plane around p to north pole and\n * return 2D coordinates */\n Matrix rotate_p2north(const Matrix& p, \n const Matrix& x) const;\n void rotate_p2north( const Matrix& ps, \n const Matrix& x, Matrix& xNorth,\n const VectorXu& z, uint32_t K) const;\n void rotate_p2north(const Matrix& p, \n const Matrix& x_p, Matrix& xNorth,\n const VectorXu& z, uint32_t k) const;\n\n\n /* compute rotation from TpS^2 to north pole on sphere */\n Matrix north_R_TpS2(const Matrix& p) const;\n\n /* compute logarithm map from sphere to T_pS */\n Matrix Log_p(const Matrix& p, \n const Matrix& q) const;\n Matrix Log_p_single(const Matrix& p, \n const Matrix& q) const;\n /* compute logarithm map from sphere to T_pS skips points where w_i==0 */\n Matrix Log_p(const Matrix& p, \n const Matrix& q, const Matrix& w) const;\n /* compute logmap for q where z_i ==k; leaves other x_i untouched */\n void Log_p(const Matrix& p, \n const Matrix& q, const VectorXu& z, uint32_t k,\n Matrix& x, uint32_t zDivider=1) const;\n /* compute logarithm map from sphere to T_pS around several points p \n * indicated by labels z; fill in matrix x */\n void Log_ps(const Matrix& p, \n const Matrix& q, const VectorXu& z, \n Matrix& x) const;\n\n /* compute exponential map from T_pS to sphere */\n Matrix Exp_p(const Matrix& p, \n const Matrix& x) const;\n Matrix Exp_p_single(const Matrix& p, \n const Matrix& x) const;\n\n Matrix sampleUnif(mt19937* pRndGen);\n \n // http://en.wikipedia.org/wiki/N-sphere\n // http://keisan.casio.com/exec/system/1223381019\n T logSurfaceArea() const {\n return (LOG_2+0.5*D_*LOG_PI - boost::math::lgamma(0.5*D_));};\n\n uint32_t D() const {return D_;};\n const Matrix& north() const {return north_;};\nprotected:\n\n T invSincDot(T dot) const;\n\n //static const double MIN_DOT = -0.95;\n //static const double MAX_DOT = 0.95;\n static double const MIN_DOT;\n static double const MAX_DOT;\n uint32_t D_; // dimension of ambient space; sphere is D-1 dimensional.\n Matrix north_;\n};\n\n/* rotation from point A to B; percentage specifies how far the rotation will \n * bring us towards B [0,1] */\ntemplate\ninline Matrix rotationFromAtoB(const Matrix& a,\n const Matrix& b, T percentage=1.0)\n{\n assert(b.size() == a.size());\n\n uint32_t D_ = b.size();\n Matrix bRa(D_,D_);\n \n T dot = b.transpose()*a;\n ASSERT(fabs(dot) <=1.0, \"a=\"< \"<(-1.0),min(static_cast(1.0),dot));\n// cout << \"dot=\"< just put identity\n bRa = Matrix::Identity(D_,D_);\n// bRa(0,0) = cos(percentage*PI);\n// bRa(1,1) = cos(percentage*PI);\n// bRa(0,1) = -sin(percentage*PI);\n// bRa(1,0) = sin(percentage*PI);\n }else if(fabs(dot +1.) <1e-6) \n {\n // direction does not matter since points are on opposing sides of sphere\n // -> pick one and rotate by percentage;\n bRa = -Matrix::Identity(D_,D_);\n bRa(0,0) = cos(percentage*PI*0.5);\n bRa(1,1) = cos(percentage*PI*0.5);\n bRa(0,1) = -sin(percentage*PI*0.5);\n bRa(1,0) = sin(percentage*PI*0.5);\n }else{\n T alpha = acos(dot) * percentage;\n// cout << \"alpha=\"< c(D_);\n c = a - b*dot;\n ASSERT(c.norm() >1e-5, \"c=\"< A = b*c.transpose() - c*b.transpose();\n\n\tMatrix temp = b*b.transpose() + c*c.transpose(); \n\tT temp2 = cos(alpha)-1.; \n bRa = Matrix::Identity(D_,D_) + sin(alpha)*A + \n (temp2)*(temp);\n }\n return bRa;\n}\n\n", "meta": {"hexsha": "5d0b57548e9c4a2602b3a45f9974d3be63dc5968", "size": 5767, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/dpMM/sphere.hpp", "max_stars_repo_name": "jstraub/dpMM", "max_stars_repo_head_hexsha": "538c432d5f98c040d5c1adb072e545e38f97fc69", "max_stars_repo_licenses": ["MIT-feh"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2015-04-27T15:14:01.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-18T00:19:18.000Z", "max_issues_repo_path": "include/dpMM/sphere.hpp", "max_issues_repo_name": "jstraub/dpMM", "max_issues_repo_head_hexsha": "538c432d5f98c040d5c1adb072e545e38f97fc69", "max_issues_repo_licenses": ["MIT-feh"], "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/dpMM/sphere.hpp", "max_forks_repo_name": "jstraub/dpMM", "max_forks_repo_head_hexsha": "538c432d5f98c040d5c1adb072e545e38f97fc69", "max_forks_repo_licenses": ["MIT-feh"], "max_forks_count": 6.0, "max_forks_repo_forks_event_min_datetime": "2015-07-02T12:46:20.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T04:39:30.000Z", "avg_line_length": 34.124260355, "max_line_length": 79, "alphanum_fraction": 0.6597884515, "num_tokens": 1766, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461389817407016, "lm_q2_score": 0.7248702702332475, "lm_q1q2_score": 0.5408539653259424}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"ANN.cpp\"\n\n\nusing namespace Eigen;\n\nMatrixXd getTril(MatrixXd& mat) {\n\tMatrixXd tril = mat.triangularView();\n\tfor (int i = 0; i < tril.rows(); i++)\n\t\ttril(i,i) = 0;\n\treturn tril;\n}\n\nvoid appendVec2Mat(MatrixXd& mat, VectorXd vec) {\n\tmat.conservativeResize(mat.rows(), mat.cols()+1);\n\tmat.col(mat.cols()-1) = vec;\n}\n\nVectorXd StdVec2Eigen(std::vector vec){\n VectorXd outvec(vec.size());\n for(int i=0;i EigenVec2Std(VectorXd vec){\n std::vector outvec(vec.rows(),0.0);\n for(int i=0;i temperature = nnet.ComputeANN(EigenVec2Std(input));\n\t// \tVectorXd output(10);\n\t// \tfor(int i=0;i<10;i++){\n\t// \t\toutput(i)=\t0.5*(0.15*temperature[3*i] + \n\t// \t\t\t\t\t0.85*temperature[3*i+1] + \n\t// \t\t\t\t\t0.85*temperature[3*i+2] + \n\t// \t\t\t\t\t0.15*temperature[3*i+3]);\n\t// \t}\n\t// \treturn output;\n\t// }\n \tVectorXd evalANN(VectorXd input){\n \t\tstd::vector temperature = nnet.ComputeANN(EigenVec2Std(input));\n\t\tVectorXd output(20);\n\t\tfor(int i=0;i<10;i++){\n\t\t\toutput(2 * i) = (temperature[3*i] + temperature[3*i + 1]) * 0.015 / 2 + \n\t\t\t(1.5 * temperature[3*i + 1] + 0.5 * temperature[3*i + 2]) * 0.035 / 2;\n\t\t\toutput(2 * i) /= 0.05;\n\t\t\toutput(2 * i + 1) = (temperature[3*i + 2] + temperature[3*i + 3]) * 0.015 / 2 + \n\t\t\t(0.5 * temperature[3*i + 1] + 1.5 * temperature[3*i + 2]) * 0.035 / 2;\n\t\t\toutput(2*i + 1) /= 0.05;\n\t\t}\n\t\treturn output;\n\t}\n\tvoid eval(double& f, VectorXd& g, VectorXd input){\n\t\tVectorXd output = evalANN(input);\n\t\t// std::cout << output << std::endl;\n\t\tint n = input.rows();\n\t\tf = (output - target).dot(output - target);\n\t\tVectorXd gradient = VectorXd::Constant(n,0.0);\n\t\tdouble delta = 0.01;\n\t\t// std::cout << \"BP\\n\";\n\t\tfor (int i = 0; i < n; i++) {\n\t\t\tVectorXd d_input = VectorXd::Constant(n,0.0);\n\t\t\td_input(i) = delta;\n\t\t\tVectorXd temp_output1 = evalANN(input + d_input);\n\t\t\tVectorXd temp_output2 = evalANN(input - d_input);\n\t\t\tgradient(i) = (temp_output1 - target).dot(temp_output1 - target) - \n\t\t\t\t\t\t\t(temp_output2 - target).dot(temp_output2 - target);\n\t\t\tgradient(i) /= 2*delta;\n\t\t}\n\t\tg = gradient;\n\t}\nprivate:\n\tANN nnet;\n\tVectorXd target;\n};\n\n\nvoid quickSort(std::vector& arr, std::vector& indices, int left, int right) {\n\tint i = left, j = right;\n\tdouble pivot = arr[(left + right) / 2];\n\t/*partition*/\n\twhile (i <= j) {\n\t\twhile (arr[i] < pivot)\n\t\t\ti++;\n\t\twhile (arr[j] > pivot)\n\t\t\tj--;\n\t\tif (i <= j) {\n\t\t\tdouble tmp_v = arr[i];\n\t\t\tint tmp_i = indices[i];\n\t\t\tarr[i] = arr[j];\n\t\t\tindices[i] = indices[j];\n\t\t\tarr[j] = tmp_v;\n\t\t\tindices[j] = tmp_i;\n\t\t\ti++;\n\t\t\tj--;\n\t\t}\n\t}\n\t/*recursion*/\n\tif (left < j)\n\t\tquickSort(arr, indices, left, j);\n\tif (i < right)\n\t\tquickSort(arr, indices, i, right);\n}\n\nstruct LBFGSBParam{\n\tint m;\n\tint max_iters;\n\tdouble tol;\n\tbool display;\n\tbool xhistory;\n};\n\nstruct BPOutput{\n\tVectorXd t;\n\tVectorXd d;\n\tstd::vector F;\n};\n\nstruct CauchyOutput{\n\tVectorXd xc;\n\tVectorXd c;\n};\n\nstruct SubspaceMinOutput{\n\tVectorXd xbar;\n\tbool line_search_flag;\n};\n\n\nstruct LBFGSB_Output {\n\tVectorXd x;\n\tdouble obj;\n};\n\nclass LBFGSB{\npublic:\n\tLBFGSBParam param;\n\tLBFGSB_Output solve(ObjFunc& obj, VectorXd x0, VectorXd l, VectorXd u, LBFGSBParam params);\nprivate:\n\tdouble f;\n\tVectorXd g;\n\tdouble getOptimality(VectorXd x, VectorXd g, VectorXd l, VectorXd u);\n\tBPOutput getBreakpoints(VectorXd x, VectorXd g, VectorXd l, VectorXd u);\n\tCauchyOutput getCauchyPoint(VectorXd x, VectorXd g, VectorXd l, VectorXd u,\n\t\t\t\t\t\t\t\tdouble theta, MatrixXd W, MatrixXd M);\n\tdouble findAlpha(VectorXd l, VectorXd u, VectorXd xc, VectorXd du, \n\t\t\t\t\tstd::vector free_vars_idx);\n\tSubspaceMinOutput subspaceMin(VectorXd x, VectorXd g, VectorXd l, VectorXd u,\n\t\t\t\t\t\tVectorXd xc, VectorXd c, double theta, MatrixXd W, MatrixXd M);\n\tdouble strongWolfe(ObjFunc& obj, VectorXd x0, double f0, VectorXd g0, VectorXd p);\n\tdouble alphaZoom(ObjFunc& obj, VectorXd x0, double f0, VectorXd g0, VectorXd p,\n\t\t\t\t\tdouble alpha_lo, double alpha_hi);\n};\n\ndouble LBFGSB::getOptimality(VectorXd x, VectorXd g, VectorXd l, VectorXd u){\n\tVectorXd projected_g = x - g;\n\tfor(int i = 0; i < x.rows(); i++) {\n\t\tif (projected_g(i) < l(i))\n\t\t\tprojected_g(i) = l(i);\n\t\telse if (projected_g(i) > u(i))\n\t\t\tprojected_g(i) = u(i);\n\t}\n\tprojected_g = projected_g - x;\n\treturn projected_g.cwiseAbs().maxCoeff();\n}\n\nBPOutput LBFGSB::getBreakpoints(VectorXd x, VectorXd g, VectorXd l, VectorXd u){\n\tint nn = x.rows();\n\tVectorXd t = VectorXd::Constant(nn,0.0);\n\tVectorXd d = -g;\n\tfor (int i = 0; i < nn; i++) {\n\t\tif (g(i) < 0)\n\t\t\tt(i) = (x(i) - u(i)) / g(i);\n\t\telse if (g(i) > 0) \n\t\t\tt(i) = (x(i) - l(i)) / g(i);\n\t\telse\n\t\t\tt(i) = DBL_MAX;\n\t\tif (t(i) < DBL_EPSILON)\n\t\t\td(i) = 0.0;\n\t}\n\t// Sort elements of t and store indices in F\n\tstd::vector Fvec(nn, 0);\n\tstd::vector tvec(nn,0.0);\n\tfor (int i = 0; i < nn; i++){\n\t\ttvec[i] = t(i);\n\t\tFvec[i] = i;\n\t\t// std::cout << tvec[i] << \" \" << Fvec[i] < 0)\n\t\t\tbreak;\n\t}\n\tint b = bpout.F[i];\n\tdouble t = bpout.t(b);\n\tdouble dt = t - t_old;\n\t//std::cout << \"BP2\" << std::endl;\n\n\twhile ( (dt_min > dt) && (i < x.rows()) ) {\n\t\tif (bpout.d(b) > 0)\n\t\t\txc(b) = u(b);\n\t\telse if (bpout.d(b) < 0)\n\t\t\txc(b) = l(b);\n\t\t//std::cout << \"BP3\" << std::endl;\n\t\tdouble zb = xc(b) - x(b);\n\t\tc = c + dt * p;\n\t\tdouble gb = g(b);\n\t\tVectorXd wbt = W.row(b);\n\t\tfp += dt * fpp + gb * gb + theta * gb * zb - gb * wbt.dot(M * c);\n\t\tfpp -= theta * gb * gb - 2.0 * gb * wbt.dot(M * p) - gb * gb * wbt.dot(M * wbt);\n\t\tfpp = std::max(DBL_EPSILON * fpp0, fpp);\n\t\tp += gb * wbt;\n\t\tbpout.d(b) = 0.0;\n\t\tdt_min = -fp / fpp;\n\t\tt_old = t;\n\t\ti++;\n\t\tif (i < x.rows()){\n\t\t\tb = bpout.F[i];\n\t\t\tt = bpout.t(b);\n\t\t\tdt = t - t_old;\n\t\t}\n\t}\n\t// Perform final updates\n\tdt_min = std::max(dt_min, 0.0);\n\tt_old = t_old + dt_min;\n\tfor (int j = 0; j < xc.rows(); j++) {\n\t\tint idx = bpout.F[j];\n\t\txc(idx) += t_old * bpout.d(idx);\n\t}\n\tc += dt_min * p;\n\n\tCauchyOutput cpout;\n\tcpout.c = c;\n\tcpout.xc = xc;\n\treturn cpout;\n}\n\ndouble LBFGSB::findAlpha(VectorXd l, VectorXd u, VectorXd xc, VectorXd du, \n\t\t\t\tstd::vector free_vars_idx) {\n\t// INPUTS:\n\t// l: [n,1] lower bound constraint vector.\n\t// u: [n,1] upper bound constraint vector.\n\t// xc: [n,1] generalized Cauchy point.\n\t// du: [num_free_vars,1] solution of unconstrained minimization.\n\t// OUTPUTS:\n\t// alpha_star: positive scaling parameter.\n\tdouble alpha_star = 1;\n\tint n = free_vars_idx.size();\n\tfor (int i = 0; i < n; i++) {\n\t\tint idx = free_vars_idx[i];\n\t\tif (du(i) > 0)\n\t\t\talpha_star = std::min(alpha_star, (u(idx) - xc(idx)) / du(i));\n\t\telse\n\t\t\talpha_star = std::min(alpha_star, (l(idx) - xc(idx)) / du(i));\n\t}\n\treturn alpha_star;\n}\n\n\nSubspaceMinOutput LBFGSB::subspaceMin(VectorXd x, VectorXd g, VectorXd l, VectorXd u,\n\t\t\t\t\t\t\t\tVectorXd xc, VectorXd c, double theta, MatrixXd W, MatrixXd M){\n\tSubspaceMinOutput subminout;\n\tsubminout.line_search_flag = true;\n\n\tint n = x.rows();\n\tstd::vector free_vars_idx;\n\tstd::vector Z;\n\tfor (int i = 0; i < xc.rows(); i++) {\n\t\tif ((xc(i) != u(i)) && (xc(i) != l(i))) {\n\t\t\tfree_vars_idx.push_back(i);\n\t\t\tVectorXd unit = VectorXd::Constant(n,0);\n\t\t\tunit(i) = 1;\n\t\t\tZ.push_back(unit);\n\t\t}\n\t}\n\n\tint num_free_vars = free_vars_idx.size();\n\tif (num_free_vars == 0) {\n\t\tsubminout.xbar = xc;\n\t\tsubminout.line_search_flag = false;\n\t\treturn subminout;\n\t}\n\n\tMatrixXd ZZ = MatrixXd::Zero(n, num_free_vars);\n\tfor (int i = 0; i < num_free_vars; i++)\n\t\tZZ.col(i) = Z[i];\n\n\t// compute the reduced gradient of mk restricted to free variables\n\tMatrixXd WTZ = W.transpose() * ZZ;\n\tVectorXd rr = g + theta * (xc - x) - W*M*c;\n\tVectorXd r = VectorXd::Constant(num_free_vars, 0.0);\n\tfor (int i = 0; i < num_free_vars; i++)\n\t\tr(i) = rr(free_vars_idx[i]);\n\n\t// form intermediate variables\n\tdouble invtheata = 1.0 / theta;\n\tVectorXd v = M * WTZ * r;\n\tMatrixXd N = invtheata * WTZ * WTZ.transpose();\n\tint N_size = N.rows();\n\tN = MatrixXd::Identity(N_size, N_size) - M * N;\n\tv = N.inverse() * v;\n\tVectorXd du = -invtheata * r - invtheata * invtheata * WTZ.transpose()*v;\n\n\t// find alpha star\n\tdouble alpha_star = findAlpha(l, u, xc, du, free_vars_idx);\n\tVectorXd d_star = alpha_star * du;\n\tsubminout.xbar = xc;\n\tfor (int i = 0; i < num_free_vars; i++) {\n\t\tint idx = free_vars_idx[i];\n\t\tsubminout.xbar(idx) += d_star(i);\n\t}\n\treturn subminout;\n}\n\n\ndouble LBFGSB::strongWolfe(ObjFunc& obj, VectorXd x0, double f0, VectorXd g0, VectorXd p){\n\tdouble alpha; // return value;\n\tdouble c1 = 1e-4;\n\tdouble c2 = 0.9;\n\tdouble alpha_max = 2.5;\n\tdouble alpha_im1 = 0;\n\tdouble alpha_i = 1;\n\tdouble f_im1 = f0;\n\tdouble dphi0 = g0.dot(p);\n\tint i = 0;\n\tint max_iters = 20;\n\tVectorXd x;\n\tdouble f_i;\n\tVectorXd g_i;\n\t// search for alpha that satisfies strong Wolfe conditions\n\twhile (true) {\n\t\tx = x0 + alpha_i * p;\n\t\tobj.eval(f_i, g_i, x);\n\t\tif ((f_i > f0 + c1 * dphi0) || ( (i > 1) && (f_i >= f_im1) )) {\n\t\t\talpha = alphaZoom(obj, x0, f0, g0, p, alpha_im1, alpha_i);\n\t\t\tbreak;\n\t\t}\n\t\tdouble dphi = g_i.dot(p);\n\t\tif (fabs(dphi) <= -c2 * dphi0) {\n\t\t\talpha = alpha_i;\n\t\t\tbreak;\n\t\t}\n\t\tif (dphi >= 0) {\n\t\t\talpha = alphaZoom(obj, x0, f0, g0, p, alpha_i, alpha_im1);\n\t\t\tbreak;\n\t\t}\n\n\t\t// update\n\t\talpha_im1 = alpha_i;\n\t\tf_im1 = f_i;\n\t\talpha_i += 0.8 * (alpha_max - alpha_i);\n\n\t\tif (i > max_iters) {\n\t\t\talpha = alpha_i;\n\t\t\tbreak;\n\t\t}\n\t\ti++;\n\t}\n\treturn alpha;\n}\n\n\ndouble LBFGSB::alphaZoom(ObjFunc& obj, VectorXd x0, double f0, VectorXd g0, VectorXd p,\n\t\t\t\tdouble alpha_lo, double alpha_hi) {\n\tdouble alpha; // return value\n\tdouble c1 = 1e-4;\n\tdouble c2 = 0.9;\n\tint i = 0;\n\tint max_iters = 20;\n\tdouble dphi0 = g0.dot(p);\n\tdouble alpha_i;\n\tVectorXd x;\n\tdouble f_i;\n\tVectorXd g_i;\n\n\twhile (true) {\n\t\talpha_i = 0.5 * (alpha_lo + alpha_hi);\n\t\talpha = alpha_i;\n\t\tx = x0 + alpha_lo * p;\n\t\tobj.eval(f_i, g_i, x);\n\t\tVectorXd x_lo = x0 + alpha_lo * p;\n\t\tdouble f_lo;\n\t\tVectorXd dummy_g;\n\t\tobj.eval(f_lo, dummy_g, x_lo);\n\t\tif ( (f_i > f0 + c1 * alpha_i * dphi0) || (f_i >= f_lo) )\n\t\t\talpha_hi = alpha_i;\n\t\telse {\n\t\t\tdouble dphi = g_i.dot(p);\n\t\t\tif (fabs(dphi) <= -c2 * dphi0) {\n\t\t\t\talpha = alpha_i;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (dphi * (alpha_hi - alpha_lo) >= 0) {\n\t\t\t\talpha_hi = alpha_lo;\n\t\t\t}\n\t\t\talpha_lo = alpha_i;\n\t\t}\n\t\ti++;\n\t\tif (i > max_iters) {\n\t\t\talpha = alpha_i;\n\t\t\tbreak;\n\t\t}\n\t}\n\treturn alpha;\n}\n\nLBFGSB_Output LBFGSB::solve(ObjFunc& obj, VectorXd x0, VectorXd l, \n\t\t\t\t\t\t\tVectorXd u, LBFGSBParam params) {\n\t\n int rank=0;\n rank=MPI::COMM_WORLD.Get_rank();\n\n\tint n = x0.rows();\n\tMatrixXd Y(n,0);\n\tMatrixXd S(n,0);\n\tMatrixXd W = MatrixXd::Zero(n,1);\n\tMatrixXd M = MatrixXd::Zero(1,1);\n\tdouble theta = 1;\n\n\t// initialize obj vars\n\tVectorXd x = x0;\n\tdouble f;\n\tVectorXd g;\n\tobj.eval(f, g, x);\n\tint k = 0;\n\tdouble opt;\n\n\tif (params.display && rank == 0) {\n\t\tstd::cout << \"iter\\t\\tf(x)\\t\\toptimality\\n\";\n\t\tstd::cout << \"-------------------------------------\\n\";\n\t\topt = getOptimality(x, g, l, u);\n\t\tstd::cout << k << \"\\t\\t\" << f << \"\\t\\t\" << opt << \"\\t\\t\" << std::endl;\n\t}\n\n\tMatrixXd xhist(n,0);\n\t//std::cout << \"BP0\" << std::endl;\n\tif (params.xhistory) {\n\t\tappendVec2Mat(xhist, x0);\n\t}\n\n\tVectorXd x_old;\n\tVectorXd g_old;\n\tVectorXd y;\n\tVectorXd s;\n\twhile ((getOptimality(x, g, l, u) > params.tol) && (k < params.max_iters) ) {\n\t\tx_old = x;\n\t\tg_old = g;\n\t\t//std::cout << \"BP01\" << std::endl;\n\n\t\tCauchyOutput cpout = getCauchyPoint(x, g, l, u, theta, W, M);\n\t\tVectorXd xc = cpout.xc;\n\t\tVectorXd c = cpout.c;\n\t\t// std::cout << \"xc = \" << std::endl;\n\t\t// std::cout << xc << std::endl;\n\t\t// std::cout << \"c = \" << std::endl;\n\t\t// std::cout << c << std::endl;\n\t\t// std::cout << \"BP1\" << std::endl;\n\t\tSubspaceMinOutput subminout = subspaceMin(x, g, l, u, xc, c, theta, W, M);\n\t\t//std::cout << \"BP2\" << std::endl;\n\n\t\tVectorXd xbar = subminout.xbar;\n\t\tbool line_search_flag = subminout.line_search_flag;\n\n\t\tdouble alpha = 1.0;\n\t\tif (line_search_flag) {\n\t\t\talpha = strongWolfe(obj, x, f, g, xbar - x);\n\t\t}\n\t\tx += alpha * (xbar - x);\n\t\t//std::cout << \"BP3\" << std::endl;\n\n\t\t// update LBFGS data structures\n\t\tobj.eval(f, g, x);\n\t\ty = g - g_old;\n\t\ts = x - x_old;\n\t\tdouble curv = fabs(s.dot(y));\n\t\tif (curv < DBL_EPSILON) {\n\t\t\tif (params.display && rank == 0) {\n \t\t\tstd::cout << (\" warning: negative curvature detected\\n\");\n \t\t\tstd::cout << (\" skipping L-BFGS update\\n\");\n \t\t}\t\n \t\tk++;\n \t\tcontinue;\t\t\n\t\t}\n\n\t\tif (Y.cols() < params.m) {\n\t\t\tappendVec2Mat(Y, y);\n\t\t\tappendVec2Mat(S, s);\n\t\t} else {\n\t\t\tY.block(0, 0, n, params.m - 1) = Y.block(0, 1, n, params.m - 1);\n\t\t\tS.block(0, 0, n, params.m - 1) = S.block(0, 1, n, params.m - 1);\n\t\t\tY.col(params.m - 1) = y;\n\t\t\tS.col(params.m - 1) = s;\n\t\t}\n\t\t//std::cout << \"BP4\" << std::endl;\n\t\ttheta = y.dot(y) / y.dot(s);\n\t\t//std::cout << \"BP401\" << std::endl;\n\t\tMatrixXd temp = Y;\n\t\t//std::cout << \"BP402\" << std::endl;\n\t\ttemp.conservativeResize(temp.rows(), temp.cols()+S.cols());\n\t\ttemp.block(0, Y.cols(), S.rows(), S.cols()) = theta * S;\n\t\t//std::cout << \"BP403\" << std::endl;\n\t\tW = temp;\n\t\t//std::cout << W << std::endl;\n\t\t//std::cout << \"BP41\" << std::endl;\n\t\tMatrixXd A = S.transpose() * Y;\n\t\tMatrixXd L = getTril(A);\n\t\tMatrixXd D = -1 * A.diagonal().asDiagonal();\n\t\tint D_size = D.rows();\n\t\tint L_size = L.rows();\n\n\t\t//std::cout << \"BP42\" << std::endl;\n\n\t\tMatrixXd MM(D_size + L_size, D_size + L_size);\n\t\tMM.block(0, 0, D_size, D_size) = D;\n\t\tMM.block(0, D_size, D_size, L_size) = L.transpose();\n\t\tMM.block(D_size, 0, L_size, D_size) = L;\n\t\tMM.block(D_size, D_size, L_size, L_size) = theta * S.transpose() * S;\n\t\t//std::cout << \"BP43\" << std::endl;\n\t\tM = MM.inverse();\n\t\t//std::cout << \"BP5\" << std::endl;\n\t\t// update the iteration\n\t\tk++;\n\t\tif (params.xhistory) {\n\t\t\tappendVec2Mat(xhist, x);\n\t\t}\n\t\tif (params.display && rank == 0) {\n\t\t\topt = getOptimality(x, g, l, u);\n\t\t\tstd::cout << k << \"\\t\\t\" << f << \"\\t\\t\" << opt << \"\\t\\t\" << std::endl;\n\t\t}\n\t}\n\tif (k == params.max_iters && params.display && rank == 0) {\n\t\tstd::cout << \" warning: maximum number of iterations reached\\n\";\n\t}\n\n\tif (getOptimality(x,g,l,u) < params.tol && params.display && rank == 0) {\n\t\tstd::cout << \" stopping because convergence tolerance met!\\n\";\n\t}\n\n\tLBFGSB_Output out;\n\tout.x = x;\n\tout.obj = f;\n\treturn out;\n}\n\n\n//705.023 701.723 697.852 691.804 692.91 667.241 667.139 672.044 674.512 680.647\n\n\n// int main(int argc, char** argv){\n// \tVectorXd x(10);\n// \tx = VectorXd::Constant(10,150);\n// \tVectorXd l = VectorXd::Constant(10,0.0);\n// \tVectorXd u = VectorXd::Constant(10,420.0);\n\n// \tLBFGSBParam params;\n// \tparams.m = 10;\n// \tparams.tol = 1e-2;\n// \tparams.max_iters = 50;\n// \tparams.display = true;\n// \tparams.xhistory = false;\n\n// \tObjFunc obj;\n// \tobj.init();\n// \tVectorXd base = VectorXd::Constant(10,673);\n// \tVectorXd increment(10);\n// \tincrement << 40, 40, 40, 40, 40, 20, 20, 20, 20, 20;\n// \tobj.setTarget(base + increment);\n// \t// obj.target << 50, 30, 60, 50, 60, 70, 1, 90, 50, 50;\n// \tLBFGSB opt;\n// \tstd::cout << \"starting to solve\\n\";\n// \tx = opt.solve(obj, x, l, u, params);\n// \tstd::cout << x.transpose() << std::endl;\n\n// \tVectorXd output = obj.evalANN(x);\n// \tstd::cout << (output - base).transpose() << std::endl;\n\n\t\n// \t// LBFGSB optimizer;\n// \t// // double opt = optimizer.getOptimality(x,g,l,u);\n// \t// // BPOutput bpout = optimizer.getBreakpoints(x,g,l,u);\n// \t// // std::cout<\n#include \n#include \n#include\n\ntypedef std::chrono::high_resolution_clock Clock;\ntypedef std::vector stdv;\n\nint main(){\n /*\n ==============\n | main |\n ==============\n \n Tests different methods for computing tensor multiplications and reports the \n relative speeds.\n */\n\n //Deformation measures\n double J = 1.2;\n Matrix_3x3 F;\n Matrix_3x3 chi;\n\n //Stress measures\n Vector_9 PK2_voigt;\n Vector_9 SIGMA_voigt;\n Vector_27 M_voigt;\n\n Vector_9 cauchy_voigt;\n Vector_9 s_voigt;\n Vector_27 m_voigt;\n\n //PK2 Jacobians\n Matrix_9x9 dPK2dF;\n Matrix_9x9 dPK2dchi;\n Matrix_9x27 dPK2dgrad_chi;\n\n //SIGMA Jacobians\n Matrix_9x9 dSIGMAdF;\n Matrix_9x9 dSIGMAdchi;\n Matrix_9x27 dSIGMAdgrad_chi;\n\n //Higher order stress Jacobians\n Matrix_27x9 dMdF;\n Matrix_27x9 dMdchi;\n Matrix_27x27 dMdgrad_chi;\n\n //Cauchy jacobians\n Matrix_9x9 dcauchydF;\n Matrix_9x9 dcauchydchi;\n Matrix_9x27 dcauchydgrad_chi;\n\n //s Jacobians\n Matrix_9x9 dsdF;\n Matrix_9x9 dsdchi;\n Matrix_9x27 dsdgrad_chi;\n\n //m Jacobians\n Matrix_27x9 dmdF;\n Matrix_27x9 dmdchi;\n Matrix_27x27 dmdgrad_chi;\n\n //Set random values\n F = Matrix_3x3::Random();\n chi = Matrix_3x3::Random();\n\n PK2_voigt = Vector_9::Random();\n SIGMA_voigt = Vector_9::Random();\n M_voigt = Vector_27::Random();\n\n cauchy_voigt = Vector_9::Random();\n s_voigt = Vector_9::Random();\n m_voigt = Vector_27::Random();\n\n dPK2dF = Matrix_9x9::Random();\n dPK2dchi = Matrix_9x9::Random();\n dPK2dgrad_chi = Matrix_9x27::Random();\n\n dSIGMAdF = Matrix_9x9::Random();\n dSIGMAdchi = Matrix_9x9::Random();\n dSIGMAdgrad_chi = Matrix_9x27::Random();\n\n dMdF = Matrix_27x9::Random();\n dMdchi = Matrix_27x9::Random();\n dMdgrad_chi = Matrix_27x27::Random();\n\n int n = 10000;\n\n auto t0 = Clock::now();\n auto t1 = Clock::now();\n \n t0 = Clock::now();\n for (int _n=0; _n(t1 - t0).count()/((double)n) << \"\\n\";\n\n t0 = Clock::now();\n for (int _n = 0; _n(t1 - t0).count()/((double)n) << \"\\n\";\n\n t0 = Clock::now();\n for (int _n = 0; _n(t1 - t0).count()/((double)n) << \"\\n\";\n\n\n return 1;\n}\n", "meta": {"hexsha": "078c51b39fcd8a384a50e3187ec108d0a34b93d2", "size": 3567, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/cpp/efficiency_tests/tensor_multiplication.cpp", "max_stars_repo_name": "lanl/tardigrade-micromorphic-element", "max_stars_repo_head_hexsha": "dafc66df8a308e9fef8af4907de902464b84302b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/cpp/efficiency_tests/tensor_multiplication.cpp", "max_issues_repo_name": "lanl/tardigrade-micromorphic-element", "max_issues_repo_head_hexsha": "dafc66df8a308e9fef8af4907de902464b84302b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/cpp/efficiency_tests/tensor_multiplication.cpp", "max_forks_repo_name": "lanl/tardigrade-micromorphic-element", "max_forks_repo_head_hexsha": "dafc66df8a308e9fef8af4907de902464b84302b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.3095238095, "max_line_length": 138, "alphanum_fraction": 0.6002242781, "num_tokens": 1214, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8688267694452331, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.5408093298391476}} {"text": "#ifndef MODULE_OPTIMIZER_HPP\r\n#define MODULE_OPTIMIZER_HPP\r\n\r\n#define _USE_MATH_DEFINES\r\n#define M_PI 3.14159265358979323846\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \"main.h\"\r\n#include \"utility/io/uart.hpp\"\r\n#include \"utility/math/saturation.hpp\"\r\n\r\nnamespace module {\r\nnamespace MPC {\r\n namespace AdaptiveMPC {\r\n\r\n class Optimizer {\r\n public:\r\n Optimizer(int ch_max);\r\n\r\n template \r\n float ProcessModel(const T& model,\r\n int mode,\r\n std::vector& states,\r\n std::vector& setpoint,\r\n std::vector& input_states,\r\n std::vector& output_states) {\r\n\r\n utility::io::debug.out(\"Process model mode %d\\n\", mode);\r\n\r\n // Given a control action, select the correct model matrix, from that linearize the model about the\r\n // current state point. Calculate the next state vector. Call the control error function and return the\r\n // errors\r\n Eigen::Matrix A_mat;\r\n\r\n if (mode == 1) {\r\n // Negative\r\n Linearise(model,\r\n states,\r\n -dotV_a(states[2], model.P_a, model.muscle1),\r\n dotV_a(model.P_t, states[3], model.muscle2),\r\n -dotV_a_P_m1(states[2], model.P_a, model.muscle1, mode),\r\n dotV_a_P_m2(model.P_t, states[3], model.muscle2, mode),\r\n A_mat);\r\n }\r\n else if (mode == 2) {\r\n // Positive\r\n Linearise(model,\r\n states,\r\n dotV_a(model.P_t, states[2], model.muscle1),\r\n -dotV_a(states[3], model.P_a, model.muscle2),\r\n dotV_a_P_m1(model.P_t, states[2], model.muscle1, mode),\r\n -dotV_a_P_m2(states[3], model.P_a, model.muscle2, mode),\r\n A_mat);\r\n }\r\n else if (mode == 3) {\r\n // No move\r\n Linearise(model,\r\n states,\r\n dotV_a(model.P_t, states[2], model.muscle1),\r\n dotV_a(model.P_t, states[3], model.muscle2),\r\n dotV_a_P_m1(model.P_t, states[2], model.muscle1, mode),\r\n dotV_a_P_m2(model.P_t, states[3], model.muscle2, mode),\r\n A_mat);\r\n }\r\n else {\r\n Error_Handler();\r\n }\r\n\r\n utility::io::debug.out(\"A mat\\n\");\r\n utility::io::debug.out(\r\n \"%.2f\\t %.2f\\t %.2f\\t %.2f\\n\", A_mat(0, 0), A_mat(0, 1), A_mat(0, 2), A_mat(0, 3));\r\n utility::io::debug.out(\r\n \"%.2f\\t %.2f\\t %.2f\\t %.2f\\n\", A_mat(1, 0), A_mat(1, 1), A_mat(1, 2), A_mat(1, 3));\r\n utility::io::debug.out(\r\n \"%.2f\\t %.2f\\t %.2f\\t %.2f\\n\", A_mat(2, 0), A_mat(2, 1), A_mat(2, 2), A_mat(2, 3));\r\n utility::io::debug.out(\r\n \"%.2f\\t %.2f\\t %.2f\\t %.2f\\n\", A_mat(3, 0), A_mat(3, 1), A_mat(3, 2), A_mat(3, 3));\r\n\r\n float Sampling_time2 = 0.05; // 0.01 T_s\r\n\r\n Eigen::Matrix x_state(input_states[0], input_states[1], input_states[2], input_states[3]);\r\n\r\n Eigen::Matrix x_states_update =\r\n (Eigen::Matrix::Identity() + Sampling_time2 * A_mat) * x_state;\r\n\r\n output_states.push_back(\r\n utility::math::sat(x_states_update(0, 0), std::make_pair(M_PI / 2.0, -M_PI / 2.0)));\r\n output_states.push_back(utility::math::sat(x_states_update(1, 0), std::make_pair(10, -10)));\r\n output_states.push_back(utility::math::sat(x_states_update(2, 0), std::make_pair(413685, 0)));\r\n output_states.push_back(utility::math::sat(x_states_update(3, 0), std::make_pair(413685, 0)));\r\n\r\n return (ControlError(setpoint, output_states));\r\n }\r\n\r\n float ControlError(std::vector& setpoint, std::vector& output_states) {\r\n\r\n // Do the math to find the relative errors (state, input)\r\n\r\n std::vector state_error = {setpoint[0] - output_states[0],\r\n setpoint[1] - output_states[1],\r\n setpoint[2] - output_states[2],\r\n setpoint[3] - output_states[3]};\r\n\r\n std::vector::const_iterator i = output_states.begin();\r\n std::vector::const_iterator j = setpoint.begin();\r\n std::vector::const_iterator k = state_error.begin();\r\n utility::io::debug.out(\"%f\\t - %f\\t = %f\\n\", *j, *i, *k);\r\n i++;\r\n j++;\r\n k++;\r\n utility::io::debug.out(\"%f\\t - %f\\t = %f\\n\", *j, *i, *k);\r\n i++;\r\n j++;\r\n k++;\r\n utility::io::debug.out(\"%f\\t - %f\\t = %f\\n\", *j, *i, *k);\r\n i++;\r\n j++;\r\n k++;\r\n utility::io::debug.out(\"%f\\t - %f\\t = %f\\n\", *j, *i, *k);\r\n // TODO Fix\r\n Eigen::Matrix x_error(state_error[0], state_error[1], state_error[2], state_error[3]);\r\n return (x_error.transpose() * state_weight * x_error);\r\n }\r\n\r\n template \r\n float dotV_a(float P_1, float P_2, const T& m) {\r\n float b = m.critical_ratio;\r\n float C = m.sonic_conductance;\r\n float A = C * std::sqrt(m.T_0 / m.T_1);\r\n float P_b = P_2 / P_1 - b;\r\n float b_1 = 1 - b;\r\n float P_bsqrt = std::sqrt(1 - (P_b / b_1) * (P_b / b_1));\r\n\r\n if (P_2 / P_1 > b) {\r\n return std::isinf(P_1 * A * P_bsqrt) ? 0 : P_1 * A * P_bsqrt;\r\n }\r\n return std::isinf(P_1 * A) ? 0 : P_1 * A;\r\n }\r\n\r\n template \r\n float dotV_a_P_m1(float P_1, float P_2, const T& m, int mode) {\r\n float b = m.critical_ratio;\r\n float C = m.sonic_conductance;\r\n float A = C * std::sqrt(m.T_0 / m.T_1);\r\n float P_b = P_2 / P_1 - b;\r\n float i = A * P_b;\r\n float b_1 = 1 - b;\r\n float P_bsqrt = std::sqrt(1 - (P_b / b_1) * (P_b / b_1));\r\n\r\n if (mode == 2 || mode == 3) {\r\n // P_2 == P_m1\r\n if (P_2 / P_1 > b) {\r\n return std::isinf(-(i / (b_1 * b_1 * P_bsqrt))) ? 0 : -(i / (b_1 * b_1 * P_bsqrt));\r\n }\r\n return 0;\r\n }\r\n else {\r\n // P_1 == P_m1\r\n if (P_2 / P_1 > b) {\r\n return std::isinf(A * P_bsqrt + (i * P_2 / (b_1 * b_1 * P_1 * P_bsqrt)))\r\n ? 0\r\n : A * P_bsqrt + (i * P_2 / (b_1 * b_1 * P_1 * P_bsqrt));\r\n }\r\n\r\n return std::isinf(C * std::sqrt(m.T_0 / m.T_1)) ? 0 : C * std::sqrt(m.T_0 / m.T_1);\r\n }\r\n return 0;\r\n }\r\n\r\n template \r\n float dotV_a_P_m2(float P_1, float P_2, const T& m, int mode) {\r\n float b = m.critical_ratio;\r\n float C = m.sonic_conductance;\r\n float A = C * std::sqrt(m.T_0 / m.T_1);\r\n float P_b = P_2 / P_1 - b;\r\n float i = A * P_b;\r\n float b_1 = 1 - b;\r\n float P_bsqrt = std::sqrt(1 - (P_b / b_1) * (P_b / b_1));\r\n\r\n if (mode == 1 || mode == 3) {\r\n // P_2 == P_m2\r\n if (P_2 / P_1 > b) {\r\n // utility::io::debug.out(\"dotV_a_P_m2 mode 13 >\\n\");\r\n return std::isinf(-i / (b_1 * b_1 * P_bsqrt)) ? 0 : -i / (b_1 * b_1 * P_bsqrt);\r\n }\r\n // utility::io::debug.out(\"dotV_a_P_m2 mode 13 <\\n\");\r\n return 0;\r\n }\r\n else {\r\n // P_1 == P_m2\r\n if (P_2 / P_1 > b) {\r\n // utility::io::debug.out(\"dotV_a_P_m2 mode 2 >\\n\");\r\n return std::isinf(A * P_bsqrt + ((P_2 * i) / (b_1 * b_1 * P_1 * P_bsqrt)))\r\n ? 0\r\n : A * P_bsqrt + ((P_2 * i) / (b_1 * b_1 * P_1 * P_bsqrt));\r\n }\r\n\r\n // utility::io::debug.out(\"dotV_a_P_m2 mode 2 <\\n\");\r\n return std::isinf(C * std::sqrt(m.T_0 / m.T_1)) ? 0 : C * std::sqrt(m.T_0 / m.T_1);\r\n }\r\n return 0;\r\n }\r\n\r\n template \r\n void Linearise(const T& m,\r\n std::vector& states,\r\n float dotV_a1,\r\n float dotV_a2,\r\n float ddotV_a1,\r\n float ddotV_a2,\r\n Eigen::Matrix& A_mat) {\r\n\r\n float L_10 = m.muscle1.L_0;\r\n float L_20 = m.muscle2.L_0;\r\n float k_10 = m.muscle1.K_0;\r\n float k_20 = m.muscle2.K_0;\r\n float y = states[0];\r\n float dy = states[1];\r\n float P_m1 = states[2];\r\n float P_m2 = states[3];\r\n float P_a = m.P_a;\r\n float a1 = m.muscle1.muscle_coefficients[0];\r\n float b1 = m.muscle1.muscle_coefficients[1];\r\n float c1 = m.muscle1.muscle_coefficients[2];\r\n float d1 = m.muscle1.muscle_coefficients[3];\r\n float a2 = m.muscle2.muscle_coefficients[0];\r\n float b2 = m.muscle2.muscle_coefficients[1];\r\n float c2 = m.muscle2.muscle_coefficients[2];\r\n float d2 = m.muscle2.muscle_coefficients[3];\r\n auto F_ce1 = m.muscle1.F_ce;\r\n auto F_ce2 = m.muscle2.F_ce;\r\n float R1 = m.muscle1.damping_coefficient;\r\n float R2 = m.muscle2.damping_coefficient;\r\n float mass = m.mass;\r\n\r\n Eigen::Matrix P_ce1;\r\n Eigen::Matrix P_ce2;\r\n Eigen::Matrix dP_ce1;\r\n Eigen::Matrix dP_ce2;\r\n\r\n Eigen::Matrix k_ce1;\r\n Eigen::Matrix k_ce2;\r\n Eigen::Matrix dk_ce1;\r\n Eigen::Matrix dk_ce2;\r\n\r\n float F_s1;\r\n float F_s2;\r\n float F_d1;\r\n float F_d2;\r\n float V_m1;\r\n float V_m2;\r\n float dV_m1;\r\n float dV_m2;\r\n float dotV_m1;\r\n float dotV_m2;\r\n float ddotV_m1;\r\n float ddotV_m2;\r\n float ddotV_m1_dV_m1;\r\n float ddotV_m2_dV_m2;\r\n\r\n /* clang-format off */\r\n\r\n float k1 = k_10 + y / L_10;\r\n float k2 = k_20 - y / L_20;\r\n float dotk1 = k_10 + dy / L_10;\r\n float dotk2 = k_20 - dy / L_20;\r\n\r\n P_ce1 << 1, \r\n P_m1, \r\n (P_m1 * P_m1), \r\n (P_m1 * P_m1 * P_m1), \r\n (P_m1 * P_m1 * P_m1 * P_m1), \r\n (P_m1 * P_m1 * P_m1 * P_m1 * P_m1);\r\n P_ce2 << 1, \r\n P_m2, \r\n (P_m2 * P_m2), \r\n (P_m2 * P_m2 * P_m2), \r\n (P_m2 * P_m2 * P_m2 * P_m2), \r\n (P_m2 * P_m2 * P_m2 * P_m2 * P_m2);\r\n dP_ce1 << 0, \r\n 1, \r\n (2 * P_m1), \r\n (3 * P_m1 * P_m1), \r\n (4 * P_m1 * P_m1 * P_m1), \r\n (5 * P_m1 * P_m1 * P_m1 * P_m1);\r\n dP_ce2 << 0, \r\n 1, \r\n (2 * P_m2), \r\n (3 * P_m2 * P_m2), \r\n (4 * P_m2 * P_m2 * P_m2),\r\n (5 * P_m2 * P_m2 * P_m2 * P_m2);\r\n\r\n\r\n k_ce1 << 1, \r\n k1, \r\n (k1 * k1), \r\n (k1 * k1 * k1), \r\n (k1 * k1 * k1 * k1), \r\n (k1 * k1 * k1 * k1 * k1);\r\n k_ce2 << 1, \r\n k2, \r\n (k2 * k2), \r\n (k2 * k2 * k2), \r\n (k2 * k2 * k2 * k2), \r\n (k2 * k2 * k2 * k2 * k2);\r\n dk_ce1 << 0, \r\n (1 / L_10), \r\n (2 * k1 / L_10), \r\n (3 * k1 * k1 / L_10), \r\n (4 * k1 * k1 * k1 / L_10),\r\n (5 * k1 * k1 * k1 * k1 / L_10);\r\n dk_ce2 << 0, \r\n (-1 / L_20),\r\n (-2 * k2 / L_20), \r\n (-3 * k2 * k2 / L_20),\r\n (-4 * k2 * k2 * k2 / L_20),\r\n (-5 * k2 * k2 * k2 * k2 / L_20);\r\n\r\n /******************************************************************************************************/\r\n /********************************************** Column 1 **********************************************/\r\n /******************************************************************************************************/\r\n\r\n /********************************************* Lin_mat_0_0 ********************************************/\r\n float Lin_mat_0_0 = 0;\r\n /********************************************* Lin_mat_1_0 ********************************************/\r\n\r\n // Calculate our first spring force\r\n F_s1 = dk_ce1 * F_ce1 * P_ce1;\r\n\r\n // Calculate our second spring force\r\n F_s2 = dk_ce2 * F_ce2 * P_ce2;\r\n\r\n float Lin_mat_1_0 = (-F_s2 - F_s1) / mass;\r\n\r\n /********************************************* Lin_mat_2_0 ********************************************/\r\n dV_m1 = (3 * a1 * k1 * k1 + 2 * b1 * k1 + c1) / L_10;\r\n ddotV_m1_dV_m1 =\r\n ((a1 * k1 * k1 * k1 + b1 * k1 * k1 + c1 * k1 + d1) \r\n * (6 * a1 * k1 * dotk1 + 2 * b1 * dotk1)\r\n - (3 * a1 * k1 * k1 * dotk1 + 2 * b1 * k1 * dotk1 + c1 * dotk1) \r\n * (3 * a1 * k1 * k1 * dotk1 + 2 * b1 * k1 * dotk1 + c1 * dotk1))\r\n / (L_10 * (a1 * k1 * k1 * k1 + b1 * k1 * k1 + c1 * k1 + d1)\r\n * (a1 * k1 * k1 * k1 + b1 * k1 * k1 + c1 * k1 + d1));\r\n\r\n float Lin_mat_2_0 = (P_a * dotV_a1 / dV_m1) - (P_m1 * ddotV_m1_dV_m1);\r\n /********************************************* Lin_mat_3_0 ********************************************/\r\n dV_m2 = (3 * a2 * k2 * k2 + 2 * b2 * k2 + c2) / L_20;\r\n ddotV_m2_dV_m2 =\r\n ((a2 * k2 * k2 * k2 + b2 * k2 * k2 + c2 * k2 + d2) \r\n * (6 * a2 * k2 * dotk2 + 2 * b2 * dotk2)\r\n - (3 * a2 * k2 * k2 * dotk2 + 2 * b2 * k2 * dotk2 + c2 * dotk2) \r\n * (3 * a2 * k2 * k2 * dotk2 + 2 * b2 * k2 * dotk2 + c2 * dotk2))\r\n / (L_20 * (a2 * k2 * k2 * k2 + b2 * k2 * k2 + c2 * k2 + d2)\r\n * (a2 * k2 * k2 * k2 + b2 * k2 * k2 + c2 * k2 + d2));\r\n\r\n float Lin_mat_3_0 = (P_a * dotV_a2 / dV_m2) - (P_m2 * ddotV_m2_dV_m2);\r\n /******************************************************************************************************/\r\n /********************************************** Column 2 **********************************************/\r\n /******************************************************************************************************/\r\n\r\n /********************************************* Lin_mat_0_1 ********************************************/\r\n float Lin_mat_0_1 = 1;\r\n /********************************************* Lin_mat_1_1 ********************************************/\r\n F_d1 = -R1 * P_m1 / L_10;\r\n F_d2 = -R2 * P_m2 / L_20;\r\n\r\n float Lin_mat_1_1 = (-F_d2 - F_d1) / mass;\r\n /********************************************* Lin_mat_2_1 ********************************************/\r\n V_m1 = (a1 * k1 * k1 * k1) + (b1 * k1 * k1) + (c1 * k1) + d1;\r\n ddotV_m1 = (3 * a1 * k1 * k1 + 2 * b1 * k1 + c1) / L_10;\r\n\r\n float Lin_mat_2_1 = -P_m1 * ddotV_m1 / V_m1;\r\n /********************************************* Lin_mat_3_1 ********************************************/\r\n V_m2 = (a2 * k2 * k2 * k2) + (b2 * k2 * k2) + (c2 * k2) + d2;\r\n ddotV_m2 = (3 * a2 * k2 * k2 + 2 * b2 * k2 + c2) / L_20;\r\n\r\n float Lin_mat_3_1 = -P_m2 * ddotV_m2 / V_m2;\r\n /******************************************************************************************************/\r\n /********************************************** Column 3 **********************************************/\r\n /******************************************************************************************************/\r\n\r\n /********************************************* Lin_mat_0_2 ********************************************/\r\n float Lin_mat_0_2 = 0;\r\n /********************************************* Lin_mat_1_2 ********************************************/\r\n F_s1 = k_ce1 * F_ce1 * dP_ce1;\r\n F_d1 = -R1 * dotk1;\r\n\r\n utility::io::debug.out(\"F_s1 = %f\\nk_ce1 = %f\\n F_ce1 = %f\\n dP_ce1 = %f\\n\\n\", F_s1, k_ce1, F_ce1, dP_ce1);\r\n utility::io::debug.out(\"F_d1 = %f\\n -R1 = %f\\n dotk1 = %f\\n\", F_d1, -R1, dotk1);\r\n \r\n // TODO This is incorrect, but i don't know any better\r\n float Lin_mat_1_2 = (F_s1 + F_d1) / mass;\r\n /********************************************* Lin_mat_2_2 ********************************************/\r\n dotV_m1 = (3 * a1 * k1 * k1 * dotk1 + 2 * b1 * k1 * dotk1 + c1 * dotk1) ;\r\n V_m1 = (a1 * k1 * k1 * k1) + (b1 * k1 * k1) + (c1 * k1) + d1;\r\n\r\n float Lin_mat_2_2 = (P_a * ddotV_a1 - dotV_m1) / V_m1 + 0.34;\r\n\r\n /********************************************* Lin_mat_3_2 ********************************************/\r\n float Lin_mat_3_2 = 0;\r\n /******************************************************************************************************/\r\n /********************************************** Column 4 **********************************************/\r\n /******************************************************************************************************/\r\n\r\n /********************************************* Lin_mat_0_3 ********************************************/\r\n float Lin_mat_0_3 = 0;\r\n /********************************************* Lin_mat_1_3 ********************************************/\r\n F_s2 = k_ce2 * F_ce2 * dP_ce2;\r\n F_d2 = -R2 * dotk2;\r\n\r\n utility::io::debug.out(\"F_s2 = %f\\nk_ce2 = %f\\n F_ce2 = %f\\n dP_ce2 = %f\\n\\n\", F_s2, k_ce2, F_ce2, dP_ce2);\r\n utility::io::debug.out(\"F_d2 = %f\\n -R2 = %f\\n dotk2 = %f\\n\", F_d2, -R2, dotk2);\r\n \r\n float Lin_mat_1_3 = (-F_s2 - F_d2) / mass;\r\n /********************************************* Lin_mat_2_3 ********************************************/\r\n float Lin_mat_2_3 = 0;\r\n /********************************************* Lin_mat_3_3 ********************************************/\r\n dotV_m2 = (3 * a2 * k2 * k2 * dotk2 + 2 * b2 * k2 * dotk2 + c2 * dotk2) ;\r\n V_m2 = (a2 * k2 * k2 * k2) + (b2 * k2 * k2) + (c2 * k2) + d2;\r\n \r\n float Lin_mat_3_3 = (P_a * ddotV_a2 - dotV_m2) / V_m2 + 0.34;\r\n\r\n A_mat << Lin_mat_0_0, Lin_mat_0_1, Lin_mat_0_2, Lin_mat_0_3, \r\n Lin_mat_1_0, Lin_mat_1_1, Lin_mat_1_2, Lin_mat_1_3, \r\n Lin_mat_2_0, Lin_mat_2_1, Lin_mat_2_2, Lin_mat_2_3, \r\n Lin_mat_3_0, Lin_mat_3_1, Lin_mat_3_2, Lin_mat_3_3;\r\n /* clang-format on */\r\n }\r\n\r\n template \r\n std::pair FirstLayer(const T& m, std::vector& states, std::vector& setpoint) {\r\n // Increment the depth (control horizon itt)\r\n // for (std::vector::const_iterator i = states.begin(); i != states.end(); ++i) {\r\n // utility::io::debug.out(\"%f \", *i);\r\n // }\r\n // utility::io::debug.out(\"\\n\");\r\n\r\n ch_itt = 1;\r\n\r\n // Remove our previous results\r\n cost_result.clear();\r\n\r\n // Create a cost for each root\r\n float cost_root_1;\r\n float cost_root_2;\r\n float cost_root_3;\r\n\r\n // Create a output state vector for each process\r\n std::vector output_states_1;\r\n std::vector output_states_2;\r\n std::vector output_states_3;\r\n\r\n // Calculate the result of performing each action and add the result error to the cost vector\r\n cost_root_1 = ProcessModel(m, 1, states, setpoint, states, output_states_1);\r\n cost_root_2 = ProcessModel(m, 2, states, setpoint, states, output_states_2);\r\n cost_root_3 = ProcessModel(m, 3, states, setpoint, states, output_states_3);\r\n // utility::io::debug.out(\"output_states_1\\n\");\r\n // for (std::vector::const_iterator i = output_states_1.begin(); i != output_states_1.end(); ++i)\r\n // {\r\n // utility::io::debug.out(\"%f \", *i);\r\n // }\r\n // utility::io::debug.out(\"\\n\");\r\n // utility::io::debug.out(\"output_states_2\\n\");\r\n // for (std::vector::const_iterator i = output_states_2.begin(); i != output_states_2.end(); ++i)\r\n // {\r\n // utility::io::debug.out(\"%f \", *i);\r\n // }\r\n // utility::io::debug.out(\"\\n\");\r\n // utility::io::debug.out(\"output_states_3\\n\");\r\n // for (std::vector::const_iterator i = output_states_3.begin(); i != output_states_3.end(); ++i)\r\n // {\r\n // utility::io::debug.out(\"%f \", *i);\r\n // }\r\n // utility::io::debug.out(\"\\n\");\r\n\r\n // Decide if the next layer is the last or not\r\n if (ch_itt >= ch_max - 1) {\r\n // Must be on our last layer\r\n FinalLayer(m, states, setpoint, output_states_1, 1, cost_root_1);\r\n FinalLayer(m, states, setpoint, output_states_2, 2, cost_root_2);\r\n FinalLayer(m, states, setpoint, output_states_3, 3, cost_root_3);\r\n }\r\n else {\r\n // Not our last layer lets add a general layer\r\n AddLayer(m, states, setpoint, output_states_1, 1, cost_root_1);\r\n AddLayer(m, states, setpoint, output_states_2, 2, cost_root_2);\r\n AddLayer(m, states, setpoint, output_states_3, 3, cost_root_3);\r\n }\r\n\r\n\r\n // Now look through the cost_result vector and pick the lowest cost to perform the root action\r\n auto result = *std::min_element(cost_result.cbegin(),\r\n cost_result.cend(),\r\n [](const auto& lhs, const auto& rhs) { return lhs.first < rhs.first; });\r\n utility::io::debug.out(\"Cost results\\n\");\r\n for (const auto& p : cost_result) {\r\n utility::io::debug.out(\"Mode %d, cost %f\\n\", p.second, p.first);\r\n }\r\n utility::io::debug.out(\"\\n\");\r\n\r\n if (result.second == 1) {\r\n utility::io::debug.out(\"Optimizer result mode1, %f\\n\", result.first);\r\n return (std::make_pair(true, false));\r\n }\r\n else if (result.second == 2) {\r\n utility::io::debug.out(\"Optimizer result mode2, %f\\n\", result.first);\r\n return (std::make_pair(false, true));\r\n }\r\n else if (result.second == 3) {\r\n utility::io::debug.out(\"Optimizer result mode3, %f\\n\", result.first);\r\n return (std::make_pair(false, false));\r\n }\r\n utility::io::debug.out(\"Optimizer failed\\n\");\r\n return (std::make_pair(false, false));\r\n }\r\n\r\n template \r\n void AddLayer(const T& m,\r\n std::vector& states,\r\n std::vector& setpoint,\r\n std::vector& input_states,\r\n int root,\r\n float cost) {\r\n // We're somewhere in the middle of our recursion\r\n ch_itt += 1;\r\n\r\n // Create a output state vector for each process\r\n std::vector output_states_1;\r\n std::vector output_states_2;\r\n std::vector output_states_3;\r\n\r\n // Calculate the result of performing each action and add the result error to the cost vector\r\n float cost1 = cost + ProcessModel(m, 1, states, setpoint, input_states, output_states_1);\r\n float cost2 = cost + ProcessModel(m, 2, states, setpoint, input_states, output_states_2);\r\n float cost3 = cost + ProcessModel(m, 3, states, setpoint, input_states, output_states_3);\r\n\r\n // Decide if the next layer is the last or not\r\n if (ch_itt >= ch_max - 1) {\r\n // Must be on our last layer\r\n FinalLayer(m, states, setpoint, output_states_1, root, cost1);\r\n FinalLayer(m, states, setpoint, output_states_2, root, cost2);\r\n FinalLayer(m, states, setpoint, output_states_3, root, cost3);\r\n }\r\n else {\r\n // Not our last layer lets add a general layer\r\n AddLayer(m, states, setpoint, output_states_1, root, cost1);\r\n AddLayer(m, states, setpoint, output_states_2, root, cost2);\r\n AddLayer(m, states, setpoint, output_states_3, root, cost3);\r\n }\r\n\r\n // As we're leaving a level, decrement the itterator\r\n ch_itt -= 1;\r\n }\r\n\r\n template \r\n void FinalLayer(const T& m,\r\n std::vector& states,\r\n std::vector& setpoint,\r\n std::vector& input_states,\r\n const int& root,\r\n float cost) {\r\n // We're on or last layer, let's calculate the result append the cost and root\r\n\r\n // utility::io::debug.out(\"input_states\\n\");\r\n // for (std::vector::const_iterator i = input_states.begin(); i != input_states.end(); ++i) {\r\n // utility::io::debug.out(\"%f \", *i);\r\n // }\r\n // utility::io::debug.out(\"\\n\");\r\n\r\n // TODO This isn't needed on the last layer\r\n // Create a output state vector for each process\r\n std::vector output_states_1;\r\n std::vector output_states_2;\r\n std::vector output_states_3;\r\n\r\n // Calculate the result of performing each action and add the result error to the cost vector\r\n float cost1 = cost + ProcessModel(m, 1, states, setpoint, input_states, output_states_1);\r\n float cost2 = cost + ProcessModel(m, 2, states, setpoint, input_states, output_states_2);\r\n float cost3 = cost + ProcessModel(m, 3, states, setpoint, input_states, output_states_3);\r\n\r\n // utility::io::debug.out(\"Final Mode %d, Cost1 %f\\n\", root, cost1 - cost);\r\n // utility::io::debug.out(\"Final Mode %d, Cost2 %f\\n\", root, cost2 - cost);\r\n // utility::io::debug.out(\"Final Mode %d, Cost3 %f\\n\", root, cost3 - cost);\r\n\r\n // Tally the cost and append it to the cost function list for each final cost\r\n cost_result.push_back(std::pair(cost1, root));\r\n cost_result.push_back(std::pair(cost2, root));\r\n cost_result.push_back(std::pair(cost3, root));\r\n }\r\n\r\n private:\r\n int ch_itt;\r\n const int ch_max;\r\n std::vector> cost_result;\r\n Eigen::Matrix state_weight;\r\n };\r\n\r\n extern Optimizer optimizer1;\r\n } // namespace AdaptiveMPC\r\n} // namespace MPC\r\n} // namespace module\r\n\r\n#endif // MODULE_OPTIMIZER_HPP", "meta": {"hexsha": "cefc2e6fc1e09bcf971e0780980bab64f058cee7", "size": 30983, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/module/MPC/AdaptiveMPC/Optimizer.hpp", "max_stars_repo_name": "tayloryoung6396/FYP", "max_stars_repo_head_hexsha": "3ad6589fa67f89d5522510aeea7cfa433530d398", "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/module/MPC/AdaptiveMPC/Optimizer.hpp", "max_issues_repo_name": "tayloryoung6396/FYP", "max_issues_repo_head_hexsha": "3ad6589fa67f89d5522510aeea7cfa433530d398", "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/module/MPC/AdaptiveMPC/Optimizer.hpp", "max_forks_repo_name": "tayloryoung6396/FYP", "max_forks_repo_head_hexsha": "3ad6589fa67f89d5522510aeea7cfa433530d398", "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": 50.9588815789, "max_line_length": 124, "alphanum_fraction": 0.3807894652, "num_tokens": 7659, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.879146780175245, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.5407525077018461}} {"text": "#include \n//#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace QuantLib;\n\nvoid testingBlackScholesCalculator() {\n\n Real S0 = 100.0;\n Real K = 105.0;\n Real rd = 0.034;\n Real rf = 0.021;\n Real tau = 0.5;\n Real vol = 0.177;\n\n Real domDisc = std::exp(-rd*tau);\n Real forDisc = std::exp(-rf*tau);\n Real stdDev = vol*std::sqrt(tau);\n\n boost::shared_ptr vanillaPayoffPut(new PlainVanillaPayoff(Option::Put, K));\n boost::shared_ptr aonPayoffCall(new AssetOrNothingPayoff(Option::Call, K));\n\n BlackScholesCalculator vanillaPutPricer(vanillaPayoffPut, S0, forDisc, stdDev, domDisc);\n BlackScholesCalculator aonCallPricer(aonPayoffCall, S0, forDisc, stdDev, domDisc);\n\n cout << \"------------- Vanilla VAlues -----------------\" << endl;\n cout << \"Value: \" << vanillaPutPricer.value() << endl;\n\n\n}\n\n\n\nint main(void) {\n\n testingBlackScholesCalculator();\n return 0;\n}\n\n", "meta": {"hexsha": "3c8e64e9043861ce6c308f6d03244aa2b3121256", "size": 1052, "ext": "cc", "lang": "C++", "max_stars_repo_path": "quantlib/bls.cc", "max_stars_repo_name": "guoxiaoyong/simple-useful", "max_stars_repo_head_hexsha": "63f483250cc5e96ef112aac7499ab9e3a35572a8", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "quantlib/bls.cc", "max_issues_repo_name": "guoxiaoyong/simple-useful", "max_issues_repo_head_hexsha": "63f483250cc5e96ef112aac7499ab9e3a35572a8", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "quantlib/bls.cc", "max_forks_repo_name": "guoxiaoyong/simple-useful", "max_forks_repo_head_hexsha": "63f483250cc5e96ef112aac7499ab9e3a35572a8", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.4651162791, "max_line_length": 101, "alphanum_fraction": 0.6653992395, "num_tokens": 318, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8438950947024556, "lm_q2_score": 0.640635868562172, "lm_q1q2_score": 0.5406294669700641}} {"text": "#ifndef CALIBRATOR_MODELS_SHORTRATE_TWOFACTORMODELS_GENERALG2_HPP\n#define CALIBRATOR_MODELS_SHORTRATE_TWOFACTORMODELS_GENERALG2_HPP\n\n#include \n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\nnamespace HJCALIBRATOR\n{\n\t//! Two-additive-factor gaussian model class\n\t/*! This class implements a two-additive-factor model defined by\n\t\\f[\n\tdr_t = \\varphi(t) + x_t + y_t\n\t\\f]\n\twhere \\f$ x_t \\f$ and \\f$ y_t \\f$ are defined by\n\t\\f[\n\tdx_t = -a x_t dt + \\sigma dW^1_t, x_0 = 0\n\t\\f]\n\t\\f[\n\tdy_t = -b y_t dt + \\sigma dW^2_t, y_0 = 0\n\t\\f]\n\tand \\f$ dW^1_t dW^2_t = \\rho dt \\f$.\n\n\t\\bug This class was not tested enough to guarantee\n\tits functionality.\n\n\t\\todo Tree implementation\n\n\t\\ingroup shortrate\n\t*/\n\tclass GeneralizedG2 : public TwoFactorModel, public AffineModel, public TermStructureConsistentModel\n\t{\n\t\tclass Dynamics;\n\n\t\tshared_ptr dynamics_;\n\n\tpublic:\n\t\tGeneralizedG2( shared_ptr dynamics,\n\t\t\t\t\t Real integralSignificance = 10, \n\t\t\t\t\t shared_ptr integrator = boost::make_shared( GaussKronrodAdaptive( 1.e-8, 10000 ) ) );\n\t\tvirtual ~GeneralizedG2() {}\n\n\t\t// TwoFactorModel virtual override\n\t\tshared_ptr tree( const TimeGrid& grid ) const override\n\t\t{\n\t\t\t// todo\n\t\t\treturn shared_ptr();\n\t\t};\n\n\t\tshared_ptr dynamics() const;\n\n\t\tvirtual DiscountFactor discount( Time t ) const override\n\t\t{\n\t\t\treturn termStructure()->discount( t );\n\t\t}\n\n\t\tvirtual Real discountBond( Time now,\n\t\t\t\t\t\t\t\t Time maturity,\n\t\t\t\t\t\t\t\t Array factors ) const;\n\n\t\tvirtual Real discountBondOption( Option::Type type,\n\t\t\t\t\t\t\t\t\t\t Real strike,\n\t\t\t\t\t\t\t\t\t\t Time maturity,\n\t\t\t\t\t\t\t\t\t\t Time bondMaturity ) const override;\n\n\t\tvirtual Real discountBondOption( Option::Type type, Real strike,\n\t\t\t\t\t\t\t\t\t\t Time maturity, Time bondStart,\n\t\t\t\t\t\t\t\t\t\t Time bondMaturity ) const override;\n\n\t\tvirtual Real swaption( const Swaption::arguments& arg, Real strike ) const;\n\n\t\tParameter a() const { return a_; }\n\t\tParameter b() const { return b_; }\n\t\tParameter sigma() const { return sigma_; }\n\t\tParameter eta() const { return eta_; }\n\t\tParameter rho() const { return rho_; }\n\n\tprotected:\n\t\t// CalibratedModel virtual override\n\t\tvirtual void generateArguments() override;\n\n\t\tReal A( Time t, Time T ) const;\n\n\t\tParameter& a_;\n\t\tParameter& sigma_;\n\t\tParameter& b_;\n\t\tParameter& eta_;\n\t\tParameter& rho_;\n\n\t\tReal integralSignificance_;\n\n\t\tshared_ptr integrator_;\n\t};\n\n\t//! Short-rate dynamics in the time-dependent Hull-White model\n\t/*! The short-rate follows an time-dependent Hull-White process */\n\tclass GeneralizedG2::Dynamics : public TwoFactorModel::ShortRateDynamics {\n\tpublic:\n\t\tDynamics( const shared_ptr dynamics )\n\t\t\t: ShortRateDynamics( shared_ptr( new GeneralizedOrnsteinUhlenbeckProcess( dynamics->a( 0 ), dynamics->sigma( 0 ) ) ),\n\t\t\t\t\t\t\t\t shared_ptr( new GeneralizedOrnsteinUhlenbeckProcess( dynamics->a( 1 ), dynamics->sigma( 1 ) ) ),\n\t\t\t\t\t\t\t\t dynamics->rho( 0, 1 )(0.0) )\n\t\t\t, dynamics_( dynamics )\n\t\t{}\n\n\t\tvirtual Real shortRate( Time t, Real x, Real y ) const {\n\t\t\treturn x + y + dynamics_->phi( t );\n\t\t}\n\n\t\tshared_ptr dynamics_;\n\t};\n\n\t// inline definitions\n\tinline shared_ptr\tGeneralizedG2::dynamics() const\n\t{\n\t\treturn shared_ptr( new Dynamics( dynamics_ ) );\n\t}\n}\n#endif // !CALIBRATOR_MODELS_SHORTRATE_TWOFACTORMODELS_GENERALG2_HPP", "meta": {"hexsha": "68c0307016ee8815db95fffa9e75b41153109734", "size": 3799, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "calibrator/calibrator/models/shortrate/twofactormodels/generalg2.hpp", "max_stars_repo_name": "hanjin-kim/gaussian-n-factor", "max_stars_repo_head_hexsha": "0865fa115094e1f7f8e968eb8f7f123c2cc26c9f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2019-02-25T05:59:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-27T04:10:19.000Z", "max_issues_repo_path": "sources/calibrator/calibrator/models/shortrate/twofactormodels/generalg2.hpp", "max_issues_repo_name": "hanjin-kim/gaussian-n-factor", "max_issues_repo_head_hexsha": "0865fa115094e1f7f8e968eb8f7f123c2cc26c9f", "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": "sources/calibrator/calibrator/models/shortrate/twofactormodels/generalg2.hpp", "max_forks_repo_name": "hanjin-kim/gaussian-n-factor", "max_forks_repo_head_hexsha": "0865fa115094e1f7f8e968eb8f7f123c2cc26c9f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-07-27T04:10:42.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-27T04:10:42.000Z", "avg_line_length": 30.1507936508, "max_line_length": 141, "alphanum_fraction": 0.7246643854, "num_tokens": 1060, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8438951064805861, "lm_q2_score": 0.640635854839898, "lm_q1q2_score": 0.540629462935397}} {"text": "//\n// Created by Robert Schmoltzi on 19.05.21.\n//\n\n#include \"SpiAlgo.h\"\n#include \n\nstatic GeneralizedRfAlgo::Scalar aSmallerB(const size_t a, const size_t b, const size_t n) {\n\treturn GeneralizedRfAlgo::factorials.lg_unrooted_dbl_fact_fast(static_cast(n)) -\n\t GeneralizedRfAlgo::factorials.lg_rooted_dbl_fact_fast(static_cast(b)) -\n\t GeneralizedRfAlgo::factorials.lg_rooted_dbl_fact_fast(static_cast(n - a)) +\n\t GeneralizedRfAlgo::factorials.lg_rooted_dbl_fact_fast(static_cast(b - a + 1));\n}\n\n// Input: |A1|, |A2|, |X|\n// Called if splits overlap\n// Output:\n// if(S1 == S2):\n// - lg_root(|A1|) - lg_root(|B1|) + lg_unroot(|X|) [ <=> h(S1)]\n// else: // Let S1 be the greater split\n// - lg_root(|A1|) - lg_root(|B2|) + lg_root(|A1| - |A2| + 1) + lg_unroot(|X|) [ <=> h(S1,S2)]\nGeneralizedRfAlgo::Scalar SpiAlgo::one_overlap(const size_t a, const size_t b, const size_t n) {\n\tif (a == b) {\n\t\treturn GeneralizedRfAlgo::factorials.lg_unrooted_dbl_fact_fast(static_cast(n)) -\n\t\t GeneralizedRfAlgo::factorials.lg_rooted_dbl_fact_fast(static_cast(a)) -\n\t\t GeneralizedRfAlgo::factorials.lg_rooted_dbl_fact_fast(static_cast(n - a));\n\t}\n\tif (a < b) {\n\t\treturn aSmallerB(a, b, n);\n\t}\n\n\treturn GeneralizedRfAlgo::factorials.lg_unrooted_dbl_fact_fast(static_cast(n)) -\n\t GeneralizedRfAlgo::factorials.lg_rooted_dbl_fact_fast(static_cast(a)) -\n\t GeneralizedRfAlgo::factorials.lg_rooted_dbl_fact_fast(static_cast(n - b)) +\n\t GeneralizedRfAlgo::factorials.lg_rooted_dbl_fact_fast(static_cast(a - b + 1));\n}\n\n// Input: |A1|, |B2|, |X|\n// Called if splits overlap\n// Output:\n// if(S1 == S2):\n// - lg_root(|A2|) - lg_root(|B2|) + lg_unroot(|X|) [ <=> h(S1)]\n// else: // Let S1 be the greater split\n// - lg_root(|A1|) - lg_root(|B2|) + lg_root(|A1| - |A2| + 1) + lg_unroot(|X|) [ <=> h(S1,S2)]\nGeneralizedRfAlgo::Scalar\nSpiAlgo::one_overlap_notb(const size_t a, const size_t n_minus_b, const size_t n) {\n\tconst size_t b = n - n_minus_b;\n\tif (a == b) {\n\t\treturn GeneralizedRfAlgo::factorials.lg_unrooted_dbl_fact_fast(static_cast(n)) -\n\t\t GeneralizedRfAlgo::factorials.lg_rooted_dbl_fact_fast(static_cast(b)) -\n\t\t GeneralizedRfAlgo::factorials.lg_rooted_dbl_fact_fast(static_cast(n_minus_b));\n\t}\n\tif (a < b) {\n\t\treturn aSmallerB(a, b, n);\n\t}\n\treturn GeneralizedRfAlgo::factorials.lg_unrooted_dbl_fact_fast(static_cast(n)) -\n\t GeneralizedRfAlgo::factorials.lg_rooted_dbl_fact_fast(static_cast(a)) -\n\t GeneralizedRfAlgo::factorials.lg_rooted_dbl_fact_fast(static_cast(n_minus_b)) +\n\t GeneralizedRfAlgo::factorials.lg_rooted_dbl_fact_fast(static_cast(a - b + 1));\n}\n\n// Based on the implementation by Martin R. Smith, found at\n// https://github.com/ms609/TreeDist/blob/e05ab4c9e69c9548f066b2a7b256e35f7f92067d/src/tree_distance_functions.cpp\nGeneralizedRfAlgo::Scalar SpiAlgo::calc_split_score(const PllSplit &S1, const PllSplit &S2) {\n\t{\n\t\tbool found = false;\n\t\tfor (size_t i = 0; i != PllSplit::split_len; ++i) {\n\t\t\t// TODO: Time direct access vs vectorized Split-Methods (less iterations vs doing less\n\t\t\t// in each iteration)\n\t\t\tif ((~S1()[i] & S2()[i])) {\n\t\t\t\tfound = true;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (!found)\n\t\t\treturn one_overlap(S1.getPrecalcPopcnt(), S2.getPrecalcPopcnt(), taxa);\n\t}\n\t{\n\t\tbool found = false;\n\n\t\tfor (size_t i = 0; i != PllSplit::split_len; ++i) {\n\t\t\tif ((S1()[i] & ~S2()[i])) {\n\t\t\t\tfound = true;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (!found)\n\t\t\treturn one_overlap(S1.getPrecalcPopcnt(), S2.getPrecalcPopcnt(), taxa);\n\t}\n\tconst size_t bits_too_many = GeneralizedRfAlgo::bits_too_many(taxa);\n\tfor (size_t i = 0; i != PllSplit::split_len; ++i) {\n\t\tpll_split_base_t test = ~(S1()[i] | S2()[i]);\n\t\tif (i == PllSplit::split_len - 1 && bits_too_many) {\n\t\t\ttest &= (static_cast(~0) >> bits_too_many);\n\t\t}\n\t\tif (test) {\n\t\t\treturn 0;\n\t\t}\n\t}\n\treturn one_overlap_notb(S1.getPrecalcPopcnt(), S2.getPrecalcPopcnt(), taxa);\n}\nSpiAlgo::SpiAlgo(size_t split_len) : GeneralizedRfAlgo(split_len) {\n}\n\nRfAlgorithmInterface::Scalar SpiAlgo::calc_split_score(const PllSplit &S1) {\n\treturn S1.getHInfoContent();\n}\n\n// AB | DEFC\n// DEF | ABC --> ABC | DEF\n\n// ABC | DE\n// ADE | BC", "meta": {"hexsha": "d75290cb48429e7e95e8bf1ced5207ad735cae85", "size": 4325, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/rf/SpiAlgo.cpp", "max_stars_repo_name": "DoktorBotti/RF_Metrics", "max_stars_repo_head_hexsha": "07b65723939b536883373b755a052f511c1c4f90", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2021-08-03T07:54:56.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-18T02:23:49.000Z", "max_issues_repo_path": "src/rf/SpiAlgo.cpp", "max_issues_repo_name": "DoktorBotti/RF_Metrics", "max_issues_repo_head_hexsha": "07b65723939b536883373b755a052f511c1c4f90", "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/rf/SpiAlgo.cpp", "max_forks_repo_name": "DoktorBotti/RF_Metrics", "max_forks_repo_head_hexsha": "07b65723939b536883373b755a052f511c1c4f90", "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": 38.2743362832, "max_line_length": 114, "alphanum_fraction": 0.6830057803, "num_tokens": 1467, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8438950947024554, "lm_q2_score": 0.640635861701035, "lm_q1q2_score": 0.5406294611799841}} {"text": "#define DEBUG 1\n/**\n * File : F2.cpp\n * Author : Kazune Takahashi\n * Created : 10/7/2020, 7:10:56 PM\n * Powered by Visual Studio Code\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n// ----- boost -----\n#include \n#include \n#include \n// ----- AtCoder Library -----\n#include \n// ----- using directives and manipulations -----\nusing namespace std;\nusing boost::rational;\nusing boost::integer::gcd; // for C++14 or for cpp_int\nusing boost::integer::lcm; // for C++14 or for cpp_int\nusing boost::multiprecision::cpp_int;\nusing ll = long long;\nusing ld = long double;\ntemplate \nusing max_heap = priority_queue;\ntemplate \nusing min_heap = priority_queue, greater>;\n// ----- ch_max and ch_min -----\ntemplate \nbool ch_max(T &left, T right)\n{\n if (left < right)\n {\n left = right;\n return true;\n }\n return false;\n}\ntemplate \nbool ch_min(T &left, T right)\n{\n if (left > right)\n {\n left = right;\n return true;\n }\n return false;\n}\n// ----- mint -----\nusing mint = atcoder::modint1000000007;\n// using mint = atcoder::modint998244353;\n// using mint = atcoder::modint; // atcoder::modint::set_mod(xxx);\n// using mint = atcoder::static_modint<1000000009>;\n// using mint0 = dynamic_modint;\n// using mint1 = dynamic_modint;\nistream &operator>>(istream &is, mint &x)\n{\n ll t;\n is >> t;\n x = t;\n return is;\n}\nostream &operator<<(ostream &os, mint const &x)\n{\n return os << x.val();\n}\n// ----- Combination -----\ntemplate \nclass Combination\n{\npublic:\n constexpr static ll MAX_SIZE{3'000'010LL};\n // constexpr static ll MAX_SIZE{30'000'010LL}; // if 10^7 is needed\n vector inv, fact, factinv;\n Combination() : inv(MAX_SIZE), fact(MAX_SIZE), factinv(MAX_SIZE)\n {\n inv[1] = 1;\n for (auto i{2LL}; i < MAX_SIZE; i++)\n {\n inv[i] = (-inv[Mint::mod() % i]) * (Mint::mod() / i);\n }\n fact[0] = factinv[0] = 1;\n for (auto i{1LL}; i < MAX_SIZE; i++)\n {\n fact[i] = Mint(i) * fact[i - 1];\n factinv[i] = inv[i] * factinv[i - 1];\n }\n }\n Mint operator()(int n, int k)\n {\n if (n >= 0 && k >= 0 && n - k >= 0)\n {\n return fact[n] * factinv[k] * factinv[n - k];\n }\n return 0;\n }\n Mint catalan(int x, int y)\n {\n return (*this)(x + y, y) - (*this)(x + y, y - 1);\n }\n};\n// ----- for C++14 -----\nusing combination = Combination;\n// ----- for C++17 -----\ntemplate ::value>::type * = nullptr>\nsize_t popcount(T x) { return bitset<64>(x).count(); }\nsize_t popcount(string const &S) { return bitset<200010>{S}.count(); }\n// ----- Infty -----\ntemplate \nconstexpr T Infty() { return numeric_limits::max(); }\ntemplate \nconstexpr T mInfty() { return numeric_limits::min(); }\n// ----- FenwickTree -----\ntemplate \nclass FenwickTree : public atcoder::fenwick_tree\n{\npublic:\n using atcoder::fenwick_tree::fenwick_tree;\n\n FenwickTree(vector const &v) : FenwickTree(static_cast(v.size()))\n {\n for (auto i{size_t{0}}; i < v.size(); ++i)\n {\n atcoder::fenwick_tree::add(i, v[i]);\n }\n }\n\n T operator[](int i)\n {\n return atcoder::fenwick_tree::sum(i, i + 1);\n }\n};\n// ----- Math -----\nusing atcoder::floor_sum;\n// ----- UnionFind -----\nusing UnionFind = atcoder::dsu;\n// ----- MaxFlow -----\ntemplate \nclass MaxFlow : public atcoder::mf_graph\n{\npublic:\n using atcoder::mf_graph::mf_graph;\n\n int add_edge(int from, int to)\n {\n return atcoder::mf_graph::add_edge(from, to, Cap{1});\n }\n};\nostream &operator<<(ostream &os, typename atcoder::mf_graph::edge const &edge)\n{\n return os << \"from: \" << edge.from << \", to: \" << edge.to << \", cap: \" << edge.cap << \", flow: \" << edge.flow;\n}\n// ----- MinCostFlow -----\ntemplate \nclass MinCostFlow : public atcoder::mcf_graph\n{\nprivate:\n Cost infty;\n\npublic:\n using atcoder::mcf_graph::mcf_graph;\n\n MinCostFlow(int n, Cost infty = Cost{0}) : atcoder::mcf_graph::mcf_graph(n), infty{infty} {}\n\n int add_edge(int from, int to, Cap cap)\n {\n return atcoder::mcf_graph::add_edge(from, to, cap, Cost{0});\n }\n\n int add_edge(int from, int to, Cap cap, Cost cost)\n {\n return atcoder::mcf_graph::add_edge(from, to, cap, cost + infty);\n }\n\n pair flow(int s, int t)\n {\n return flow(s, t, std::numeric_limits::max());\n }\n\n pair flow(int s, int t, Cap flow_limit)\n {\n return slope(s, t, flow_limit).back();\n }\n\n vector> slope(int s, int t)\n {\n return slope(s, t, numeric_limits::max());\n }\n\n vector> slope(int s, int t, Cap flow_limit)\n {\n auto res{atcoder::mcf_graph::slope(s, t, flow_limit)};\n for (auto &[cap, cost] : res)\n {\n cost -= cap * infty;\n }\n return res;\n }\n\n typename atcoder::mcf_graph::edge get_edge(int i)\n {\n auto res{atcoder::mcf_graph::get_edge(i)};\n res.cost -= infty;\n return res;\n }\n\n vector::edge> edges()\n {\n auto res{atcoder::mcf_graph::edges()};\n for (auto &e : res)\n {\n e.cost -= infty;\n }\n return res;\n }\n};\nostream &operator<<(ostream &os, typename atcoder::mcf_graph::edge const &edge)\n{\n return os << \"from: \" << edge.from << \", to: \" << edge.to << \", cap: \" << edge.cap << \", flow: \" << edge.flow << \", cost: \" << edge.cost;\n}\n// ----- frequently used constexpr -----\n// constexpr double epsilon{1e-10};\n// constexpr ll infty{1'000'000'000'000'010LL}; // or\n// constexpr int infty{1'000'000'010};\n// constexpr int dx[4] = {1, 0, -1, 0};\n// constexpr int dy[4] = {0, 1, 0, -1};\n// ----- Yes() and No() -----\nvoid Yes()\n{\n cout << \"Yes\" << endl;\n exit(0);\n}\nvoid No()\n{\n cout << \"No\" << endl;\n exit(0);\n}\n\n// ----- Solve -----\n\nclass Solve\n{\n\npublic:\n Solve()\n {\n }\n\n void flush()\n {\n }\n\nprivate:\n};\n\n// ----- main() -----\n\n/*\nint main()\n{\n Solve solve;\n solve.flush();\n}\n*/\n\ncombination C;\n\nint main()\n{\n ll k;\n string s;\n cin >> k >> s;\n mint ans{0};\n ll y{static_cast(s.size())};\n for (auto x{0}; x <= k; ++x)\n {\n ans += C(y + k - x - 1, y - 1) * mint{26}.pow(x) * mint{25}.pow(k - x);\n }\n cout << ans << endl;\n}\n", "meta": {"hexsha": "a0a2772cb5798f25f9afac5ba7452224f4caafdf", "size": 6892, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "2020/0621_ABC171/F2.cpp", "max_stars_repo_name": "kazunetakahashi/atcoder", "max_stars_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2019-03-24T14:06:29.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-17T21:16:36.000Z", "max_issues_repo_path": "2020/0621_ABC171/F2.cpp", "max_issues_repo_name": "kazunetakahashi/atcoder", "max_issues_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "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": "2020/0621_ABC171/F2.cpp", "max_forks_repo_name": "kazunetakahashi/atcoder", "max_forks_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-07-22T17:27:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-22T17:27:09.000Z", "avg_line_length": 22.6710526316, "max_line_length": 139, "alphanum_fraction": 0.5993905978, "num_tokens": 2114, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.808067204308405, "lm_q2_score": 0.668880247169804, "lm_q1q2_score": 0.5405001913476184}} {"text": "#ifndef LEPP3_OBSTACLE_EVALUATOR_H_\n#define LEPP3_OBSTACLE_EVALUATOR_H_\n#include \n#include \n#include \n#include \"lepp3/FrameData.hpp\"\n#include \"lepp3/util/util.h\"\n/**\n * A class that computes the volume of a given model.\n * It is a `ModelVisitor` implementation and it assumes one model as input,\n * regardless of how many sub-parts the approximation has, a.k.a the\n * `CompositeModel`.\n *\n * The volume computation is done by creating a 3D grid around the model and\n * estimating how many points on the grid are occupied.\n */\nclass VolumeEstimator : public ModelVisitor {\npublic:\n VolumeEstimator()\n : num_splits_(0) {\n min_p_.x = std::numeric_limits::max();\n min_p_.y = std::numeric_limits::max();\n min_p_.z = std::numeric_limits::max();\n max_p_.x = std::numeric_limits::min();\n max_p_.y = std::numeric_limits::min();\n max_p_.z = std::numeric_limits::min();\n }\n /**\n * Implementation of the `ModelVisitor` interface. It will draw the given\n * sphere onto the `PCLVisualizer` to which it holds a reference.\n */\n void visitSphere(lepp::SphereModel& sphere);\n void visitCapsule(lepp::CapsuleModel& capsule);\n int getSplitCount() { return num_splits_; }\n /**\n * Estimates the volume of the approximated model. This is achieved by\n * creating a bounding box around the min/max points of the approximation and\n * subdivide the region into small grids.\n */\n int estimateVolume();\nprivate:\n /**\n * Checks if the current point on the 3D grid (a.k.a the bounding box around\n * the model) is inside the model.\n */\n bool isVoxelOccupied(double const& x, double const& y, double const& z);\n /**\n * Minimum/Maximum points of the bounding box surrounding the model.\n */\n Coordinate min_p_, max_p_;\n /**\n * Container to hold track of sphere models in a `CompositeModel`\n */\n std::vector spheres_;\n /**\n * Container to hold track of capsule models in a `CompositeModel`\n */\n std::vector capsules_;\n /**\n * Number of sub-models in this model. This determines how many split operations\n * have been executed\n */\n int num_splits_;\n};\nvoid VolumeEstimator::visitSphere(lepp::SphereModel& sphere) {\n ++num_splits_;\n // Store the current Sphere model.\n spheres_.push_back(sphere);\n Coordinate const center = sphere.center_point();\n double const max_x = center.x + sphere.radius();\n double const max_y = center.y + sphere.radius();\n double const max_z = center.z + sphere.radius();\n double const min_x = center.x - sphere.radius();\n double const min_y = center.y - sphere.radius();\n double const min_z = center.z - sphere.radius();\n max_p_.x = std::max(max_p_.x, max_x);\n max_p_.y = std::max(max_p_.y, max_y);\n max_p_.z = std::max(max_p_.z, max_z);\n min_p_.x = std::min(min_p_.x, min_x);\n min_p_.y = std::min(min_p_.y, min_y);\n min_p_.z = std::min(min_p_.z, min_z);\n double volume = 4/3*M_PI*sphere.radius()*sphere.radius()*sphere.radius();\n //std::cout << volume << std::endl;\n}\nvoid VolumeEstimator::visitCapsule(lepp::CapsuleModel& capsule) {\n ++num_splits_;\n // Store the current Capsule model.\n capsules_.push_back(capsule);\n Coordinate first = capsule.first();\n Coordinate second = capsule.second();\n double a = std::sqrt((first.x - second.x)*(first.x - second.x) + (first.y - second.y)*(first.y - second.y) + (first.z - second.z)*(first.z - second.z));\n double volume = M_PI*capsule.radius()*capsule.radius()*(4/3*capsule.radius() + a);\n //std::cout << volume << std::endl;\n Coordinate min, max;\n min.x = std::min(first.x, second.x);\n min.y = std::min(first.y, second.y);\n min.z = std::min(first.z, second.z);\n max.x = std::max(first.x, second.x);\n max.y = std::max(first.y, second.y);\n max.z = std::max(first.z, second.z);\n // Add the capsule radius to min/max\n min.x -= capsule.radius();\n min.y -= capsule.radius();\n min.z -= capsule.radius();\n max.x += capsule.radius();\n max.y += capsule.radius();\n max.z += capsule.radius();\n // Find the global min/max\n min_p_.x = std::min(min_p_.x, min.x);\n min_p_.y = std::min(min_p_.y, min.y);\n min_p_.z = std::min(min_p_.z, min.z);\n max_p_.x = std::max(max_p_.x, max.x);\n max_p_.y = std::max(max_p_.y, max.y);\n max_p_.z = std::max(max_p_.z, max.z);\n}\nbool VolumeEstimator::isVoxelOccupied(\n double const& x, double const& y, double const& z) {\n // Go through all spheres of the current model and check if the point is\n // inside one of them.\n {\n size_t sz = spheres_.size();\n for (size_t i=0; iaccept(estimator);\n // Compute the volume of the current model\n int vol = estimator.estimateVolume();\n //std::cout << \"Volume Tester \" << vol << std::endl;\n // Evaluate the approximation based on the reference information\n float ratio = -1;\n if (ref_volume_ != 0)\n ratio = vol / static_cast(ref_volume_);\n\n bool has_vel = false;\n boost::shared_ptr cm = boost::static_pointer_cast(model);\n for( auto& m : cm->models() )\n {\n boost::shared_ptr cmm = boost::static_pointer_cast(m);\n\n for ( auto& mm : cmm->models() )\n {\n std::cout << model->id() << \": \" << mm->velocity().x << \", \" \n << mm->velocity().y << \", \" << mm->velocity().z << std::endl;\n if (!std::isnan(mm->velocity().x) &&\n !std::isnan(mm->velocity().y) &&\n !std::isnan(mm->velocity().z))\n {\n\n // Save the current approximation information\n std::stringstream ss;\n ss << model->id() << \",\"\n << vol << \",\"\n << mm->velocity().x << \",\"\n << mm->velocity().y << \",\"\n << mm->velocity().z\n << std::endl;\n std::ofstream tf_fout;\n // open the file and add the current model evaluation to the end of it\n tf_fout.open(file_path_.c_str(), std::ofstream::app);\n tf_fout << ss.str();\n tf_fout.close();\n has_vel = true;\n break;\n }\n }\n }\n\n // if obstacle did not have a velocity estimate, log zero\n if (!has_vel)\n {\n std::ofstream tf_out;\n tf_out.open(file_path_.c_str(), std::ofstream::app);\n tf_out << model->id() << \",\"\n << vol << \",\"\n << \"0,0,0\"\n << std::endl;\n }\n\n return true;\n}\nvoid ObstacleEvaluator::updateFrame(FrameDataPtr frameData) {\n size_t sz = frameData->obstacles.size();\n for (size_t i=0; iobstacles[i]);\n double x = frameData->obstacles[i]->velocity().x;\n double y = frameData->obstacles[i]->velocity().y;\n double z = frameData->obstacles[i]->velocity().z;\n evaluate(frameData->obstacles[i], x, y, z);\n }\n}\n#endif // LEPP3_OBSTACLE_EVALUATOR_H_\n", "meta": {"hexsha": "5ec0b6c2e91111eb113ccdefe2735a8124ef3324", "size": 10125, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/lepp3/ObstacleEvaluator.hpp", "max_stars_repo_name": "am-lola/lepp3", "max_stars_repo_head_hexsha": "7f92ce61bccad984e18ce86da0d8a1b9c48feb65", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2017-01-16T10:41:56.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-09T09:13:30.000Z", "max_issues_repo_path": "src/lepp3/ObstacleEvaluator.hpp", "max_issues_repo_name": "am-lola/lepp3", "max_issues_repo_head_hexsha": "7f92ce61bccad984e18ce86da0d8a1b9c48feb65", "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/lepp3/ObstacleEvaluator.hpp", "max_forks_repo_name": "am-lola/lepp3", "max_forks_repo_head_hexsha": "7f92ce61bccad984e18ce86da0d8a1b9c48feb65", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2015-08-07T13:07:32.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-03T03:18:33.000Z", "avg_line_length": 34.0909090909, "max_line_length": 154, "alphanum_fraction": 0.633382716, "num_tokens": 2793, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.78793120560257, "lm_q2_score": 0.6859494550081925, "lm_q1q2_score": 0.540480981067031}} {"text": "/**\n * \\file miscellaneous-algorithms.hpp\n * \\author Mehdi Benallegue\n * \\date 2013\n * \\brief Gathers many kinds of algorithms\n *\n *\n *\n */\n\n#ifndef STATEOBSERVATIONTOOLSMISCELANEOUSALGORITHMS\n#define STATEOBSERVATIONTOOLSMISCELANEOUSALGORITHMS\n#include \n#include \n\n#include \n#include \n\nnamespace stateObservation\n{\nnamespace tools\n{\n\n/// computes the square of a value of any type\ntemplate\ninline T square(const T & x)\n{\n return T(x * x);\n}\n\n/// derivates any type with finite differences\ntemplate\ninline T derivate(const T & o1, const T & o2, double dt)\n{\n T o(o2 - o1);\n return o * (1 / dt);\n}\n\n/// gives the sign of a variable (1, 0 or -1)\ntemplate\ninline int signum(T x)\n{\n return (T(0) < x) - (x < T(0));\n}\n\ntemplate\ninline std::string toString(T val)\n{\n std::stringstream ss(\"\");\n ss << val;\n return ss.str();\n}\n\n/// @brief checks if the vector is already normalized or not\n///\n/// @param v the vector to normalize\n/// @return true the vector is normalized\n/// @return false The vector is not normalized\ninline bool checkIfNormalized(const Vector3 & v)\n{\n if(fabs(v.squaredNorm() - 1) > cst::epsilon1)\n {\n return false;\n }\n else\n {\n return true;\n }\n}\n\n/// @brief checks if the vector is already normalized or not\n///\n/// @param v the vector to normalize\n/// @param outputSquaredNorm the squared norm as an output\n/// @return true the vector is normalized\n/// @return false The vector is not normalized\ninline bool checkIfNormalized(const Vector3 & v, double & outputSquaredNorm)\n{\n outputSquaredNorm = v.squaredNorm();\n if(fabs(outputSquaredNorm - 1) > cst::epsilon1)\n {\n return false;\n }\n else\n {\n return true;\n }\n}\n\n/// @brief returns the value clamped between min and max\n///\n/// @tparam T The type of the scalar\n/// @param x the input value\n/// @param max the max value\n/// @param min the min value\n/// @return T the calmped value\ntemplate\ninline T clampScalar(const T & x, const T & max, const T & min)\n{\n if(x > max)\n {\n return max;\n }\n else\n {\n if(x < min)\n {\n return min;\n }\n else\n {\n return x;\n }\n }\n}\n\n/// @brief returns the value clamped between limit and -limit\n///\n/// @tparam T The type of the scalar\n/// @param x the input value\n/// @param limit is the maximum absolute value allowed, has to be positive\n/// @return T the clamped value\ntemplate\ninline T clampScalar(const T & x, const T & limit)\n{\n return clampScalar(x, limit, -limit);\n}\n\n/// @brief normalize the vector only if it is not normalized already. Useful if the vector is likely to be normalized\n///\n/// @param v the input vector\n/// @return Vector3\ninline Vector3 normalizedLazy(const Vector3 & v)\n{\n double squaredNorm;\n if(checkIfNormalized(v, squaredNorm))\n {\n return v;\n }\n else\n {\n return v / sqrt(squaredNorm);\n }\n}\n\n/// provides an acceleration giving a finite time convergence to zero\n/// the state is the position x and the derivative xd and the output is the\n/// acceleration. The gains kp, kv must be negative\ninline double STATE_OBSERVATION_DLLAPI finiteTimeAccControl(double x, double xd, double kp = -1, double kv = -1)\n{\n double sax = sqrt(fabs(x));\n double xdr = kp * signum(x) * sax;\n double y = xd - xdr;\n double ydr = -kv * signum(y) * sqrt(fabs(y));\n return ydr - kp * xd / (2 * sax);\n}\n\n/// sqme as the scalar version but for every member of the vector\ninline Vector STATE_OBSERVATION_DLLAPI finiteTimeAccControl(const Vector & x,\n const Vector & xd,\n double kp = -1,\n double kv = -1)\n{\n Vector xdd(x.size());\n for(Index i = 1; i < x.size(); ++i)\n {\n xdd(i) = finiteTimeAccControl(x(i), xd(i), kp, kv);\n }\n return xdd;\n}\n\nnamespace Detail\n{\ndouble constexpr sqrtNewtonRaphson(double x, double curr, double prev)\n{\n return curr == prev ? curr : sqrtNewtonRaphson(x, 0.5 * (curr + x / curr), curr);\n}\n} // namespace Detail\n\n/// @brief Constexpr version of the square root\n/// @details For a finite and non-negative value of \"x\", returns an approximation for the square root of \"x\"\n///-Otherwise, returns NaN\n///\n/// @param x\n/// @return double constexpr\ndouble constexpr sqrt(double x)\n{\n return x >= 0 && x < std::numeric_limits::infinity() ? Detail::sqrtNewtonRaphson(x, x, 0)\n : std::numeric_limits::quiet_NaN();\n}\n\n} // namespace tools\n\n} // namespace stateObservation\n\n#endif // STATEOBSERVATIONTOOLSMISCELANEOUSALGORITHMS\n", "meta": {"hexsha": "809bbd7c8ea1b900d4e5aa1fddfaa253e004d965", "size": 4847, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/state-observation/tools/miscellaneous-algorithms.hpp", "max_stars_repo_name": "mmurooka/state-observation", "max_stars_repo_head_hexsha": "4a6b8eb6fa841cf706a074132fb24b50e8534e35", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2018-11-01T16:10:48.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-09T00:03:46.000Z", "max_issues_repo_path": "include/state-observation/tools/miscellaneous-algorithms.hpp", "max_issues_repo_name": "mmurooka/state-observation", "max_issues_repo_head_hexsha": "4a6b8eb6fa841cf706a074132fb24b50e8534e35", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2019-10-18T09:06:23.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-26T04:22:09.000Z", "max_forks_repo_path": "include/state-observation/tools/miscellaneous-algorithms.hpp", "max_forks_repo_name": "mmurooka/state-observation", "max_forks_repo_head_hexsha": "4a6b8eb6fa841cf706a074132fb24b50e8534e35", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 6.0, "max_forks_repo_forks_event_min_datetime": "2018-06-19T09:00:17.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-11T06:14:51.000Z", "avg_line_length": 24.6040609137, "max_line_length": 117, "alphanum_fraction": 0.6300804621, "num_tokens": 1241, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125737597972, "lm_q2_score": 0.7185943985973772, "lm_q1q2_score": 0.5403920231785873}} {"text": "// ----------------------------------------------------------------------------\n// - Open3D: www.open3d.org -\n// ----------------------------------------------------------------------------\n// The MIT License (MIT)\n//\n// Copyright (c) 2018 www.open3d.org\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n// IN THE SOFTWARE.\n// ----------------------------------------------------------------------------\n\n#include \"open3d/utility/Eigen.h\"\n\n#include \n#include \n\n#include \"open3d/utility/Console.h\"\n\nnamespace open3d {\nnamespace utility {\n\n/// Function to solve Ax=b\nstd::tuple SolveLinearSystemPSD(\n const Eigen::MatrixXd &A,\n const Eigen::VectorXd &b,\n bool prefer_sparse /* = false */,\n bool check_symmetric /* = false */,\n bool check_det /* = false */,\n bool check_psd /* = false */) {\n // PSD implies symmetric\n check_symmetric = check_symmetric || check_psd;\n if (check_symmetric && !A.isApprox(A.transpose())) {\n LogWarning(\"check_symmetric failed, empty vector will be returned\");\n return std::make_tuple(false, Eigen::VectorXd::Zero(b.rows()));\n }\n\n if (check_det) {\n double det = A.determinant();\n if (fabs(det) < 1e-6 || std::isnan(det) || std::isinf(det)) {\n LogWarning(\"check_det failed, empty vector will be returned\");\n return std::make_tuple(false, Eigen::VectorXd::Zero(b.rows()));\n }\n }\n\n // Check PSD: https://stackoverflow.com/a/54569657/1255535\n if (check_psd) {\n Eigen::LLT A_llt(A);\n if (A_llt.info() == Eigen::NumericalIssue) {\n LogWarning(\"check_psd failed, empty vector will be returned\");\n return std::make_tuple(false, Eigen::VectorXd::Zero(b.rows()));\n }\n }\n\n Eigen::VectorXd x(b.size());\n\n if (prefer_sparse) {\n Eigen::SparseMatrix A_sparse = A.sparseView();\n // TODO: avoid deprecated API SimplicialCholesky\n Eigen::SimplicialCholesky> A_chol;\n A_chol.compute(A_sparse);\n if (A_chol.info() == Eigen::Success) {\n x = A_chol.solve(b);\n if (A_chol.info() == Eigen::Success) {\n // Both decompose and solve are successful\n return std::make_tuple(true, std::move(x));\n } else {\n LogWarning(\"Cholesky solve failed, switched to dense solver\");\n }\n } else {\n LogWarning(\"Cholesky decompose failed, switched to dense solver\");\n }\n }\n\n x = A.ldlt().solve(b);\n return std::make_tuple(true, std::move(x));\n}\n\nEigen::Matrix4d TransformVector6dToMatrix4d(const Eigen::Vector6d &input) {\n Eigen::Matrix4d output;\n output.setIdentity();\n output.block<3, 3>(0, 0) =\n (Eigen::AngleAxisd(input(2), Eigen::Vector3d::UnitZ()) *\n Eigen::AngleAxisd(input(1), Eigen::Vector3d::UnitY()) *\n Eigen::AngleAxisd(input(0), Eigen::Vector3d::UnitX()))\n .matrix();\n output.block<3, 1>(0, 3) = input.block<3, 1>(3, 0);\n return output;\n}\n\nEigen::Vector6d TransformMatrix4dToVector6d(const Eigen::Matrix4d &input) {\n Eigen::Vector6d output;\n Eigen::Matrix3d R = input.block<3, 3>(0, 0);\n double sy = sqrt(R(0, 0) * R(0, 0) + R(1, 0) * R(1, 0));\n if (!(sy < 1e-6)) {\n output(0) = atan2(R(2, 1), R(2, 2));\n output(1) = atan2(-R(2, 0), sy);\n output(2) = atan2(R(1, 0), R(0, 0));\n } else {\n output(0) = atan2(-R(1, 2), R(1, 1));\n output(1) = atan2(-R(2, 0), sy);\n output(2) = 0;\n }\n output.block<3, 1>(3, 0) = input.block<3, 1>(0, 3);\n return output;\n}\n\nstd::tuple SolveJacobianSystemAndObtainExtrinsicMatrix(\n const Eigen::Matrix6d &JTJ, const Eigen::Vector6d &JTr) {\n bool solution_exist;\n Eigen::Vector6d x;\n std::tie(solution_exist, x) = SolveLinearSystemPSD(JTJ, -JTr);\n\n if (solution_exist) {\n Eigen::Matrix4d extrinsic = TransformVector6dToMatrix4d(x);\n return std::make_tuple(solution_exist, std::move(extrinsic));\n }\n return std::make_tuple(false, Eigen::Matrix4d::Identity());\n}\n\nstd::tuple>\nSolveJacobianSystemAndObtainExtrinsicMatrixArray(const Eigen::MatrixXd &JTJ,\n const Eigen::VectorXd &JTr) {\n std::vector output_matrix_array;\n output_matrix_array.clear();\n if (JTJ.rows() != JTr.rows() || JTJ.cols() % 6 != 0) {\n LogWarning(\n \"[SolveJacobianSystemAndObtainExtrinsicMatrixArray] \"\n \"Unsupported matrix format.\");\n return std::make_tuple(false, std::move(output_matrix_array));\n }\n\n bool solution_exist;\n Eigen::VectorXd x;\n std::tie(solution_exist, x) = SolveLinearSystemPSD(JTJ, -JTr);\n\n if (solution_exist) {\n int nposes = (int)x.rows() / 6;\n for (int i = 0; i < nposes; i++) {\n Eigen::Matrix4d extrinsic =\n TransformVector6dToMatrix4d(x.block<6, 1>(i * 6, 0));\n output_matrix_array.push_back(extrinsic);\n }\n return std::make_tuple(solution_exist, std::move(output_matrix_array));\n } else {\n return std::make_tuple(false, std::move(output_matrix_array));\n }\n}\n\ntemplate \nstd::tuple ComputeJTJandJTr(\n std::function f,\n int iteration_num,\n bool verbose /*=true*/) {\n MatType JTJ;\n VecType JTr;\n double r2_sum = 0.0;\n JTJ.setZero();\n JTr.setZero();\n#pragma omp parallel\n {\n MatType JTJ_private;\n VecType JTr_private;\n double r2_sum_private = 0.0;\n JTJ_private.setZero();\n JTr_private.setZero();\n VecType J_r;\n double r;\n double w = 0.0;\n#pragma omp for nowait\n for (int i = 0; i < iteration_num; i++) {\n f(i, J_r, r, w);\n JTJ_private.noalias() += J_r * w * J_r.transpose();\n JTr_private.noalias() += J_r * w * r;\n r2_sum_private += r * r;\n }\n#pragma omp critical\n {\n JTJ += JTJ_private;\n JTr += JTr_private;\n r2_sum += r2_sum_private;\n }\n }\n if (verbose) {\n LogDebug(\"Residual : {:.2e} (# of elements : {:d})\",\n r2_sum / (double)iteration_num, iteration_num);\n }\n return std::make_tuple(std::move(JTJ), std::move(JTr), r2_sum);\n}\n\ntemplate \nstd::tuple ComputeJTJandJTr(\n std::function<\n void(int,\n std::vector> &,\n std::vector &)> f,\n int iteration_num,\n bool verbose /*=true*/) {\n MatType JTJ;\n VecType JTr;\n double r2_sum = 0.0;\n JTJ.setZero();\n JTr.setZero();\n#pragma omp parallel\n {\n MatType JTJ_private;\n VecType JTr_private;\n double r2_sum_private = 0.0;\n JTJ_private.setZero();\n JTr_private.setZero();\n std::vector r;\n std::vector> J_r;\n#pragma omp for nowait\n for (int i = 0; i < iteration_num; i++) {\n f(i, J_r, r);\n for (int j = 0; j < (int)r.size(); j++) {\n JTJ_private.noalias() += J_r[j] * J_r[j].transpose();\n JTr_private.noalias() += J_r[j] * r[j];\n r2_sum_private += r[j] * r[j];\n }\n }\n#pragma omp critical\n {\n JTJ += JTJ_private;\n JTr += JTr_private;\n r2_sum += r2_sum_private;\n }\n }\n if (verbose) {\n LogDebug(\"Residual : {:.2e} (# of elements : {:d})\",\n r2_sum / (double)iteration_num, iteration_num);\n }\n return std::make_tuple(std::move(JTJ), std::move(JTr), r2_sum);\n}\n\n// clang-format off\ntemplate std::tuple ComputeJTJandJTr(\n std::function f,\n int iteration_num, bool verbose);\n\ntemplate std::tuple ComputeJTJandJTr(\n std::function &,\n std::vector &)> f,\n int iteration_num, bool verbose);\n// clang-format on\n\nEigen::Matrix3d RotationMatrixX(double radians) {\n Eigen::Matrix3d rot;\n rot << 1, 0, 0, 0, std::cos(radians), -std::sin(radians), 0,\n std::sin(radians), std::cos(radians);\n return rot;\n}\n\nEigen::Matrix3d RotationMatrixY(double radians) {\n Eigen::Matrix3d rot;\n rot << std::cos(radians), 0, std::sin(radians), 0, 1, 0, -std::sin(radians),\n 0, std::cos(radians);\n return rot;\n}\n\nEigen::Matrix3d RotationMatrixZ(double radians) {\n Eigen::Matrix3d rot;\n rot << std::cos(radians), -std::sin(radians), 0, std::sin(radians),\n std::cos(radians), 0, 0, 0, 1;\n return rot;\n}\n\nEigen::Vector3uint8 ColorToUint8(const Eigen::Vector3d &color) {\n Eigen::Vector3uint8 rgb;\n for (int i = 0; i < 3; ++i) {\n rgb[i] = uint8_t(\n std::round(std::min(1., std::max(0., color(i))) * 255.));\n }\n return rgb;\n}\n\nEigen::Vector3d ColorToDouble(uint8_t r, uint8_t g, uint8_t b) {\n return Eigen::Vector3d(r, g, b) / 255.0;\n}\n\nEigen::Vector3d ColorToDouble(const Eigen::Vector3uint8 &rgb) {\n return ColorToDouble(rgb(0), rgb(1), rgb(2));\n}\n\ntemplate \nEigen::Matrix3d ComputeCovariance(const std::vector &points,\n const std::vector &indices) {\n Eigen::Matrix3d covariance;\n Eigen::Matrix cumulants;\n cumulants.setZero();\n for (const auto &idx : indices) {\n const Eigen::Vector3d &point = points[idx];\n cumulants(0) += point(0);\n cumulants(1) += point(1);\n cumulants(2) += point(2);\n cumulants(3) += point(0) * point(0);\n cumulants(4) += point(0) * point(1);\n cumulants(5) += point(0) * point(2);\n cumulants(6) += point(1) * point(1);\n cumulants(7) += point(1) * point(2);\n cumulants(8) += point(2) * point(2);\n }\n cumulants /= (double)indices.size();\n covariance(0, 0) = cumulants(3) - cumulants(0) * cumulants(0);\n covariance(1, 1) = cumulants(6) - cumulants(1) * cumulants(1);\n covariance(2, 2) = cumulants(8) - cumulants(2) * cumulants(2);\n covariance(0, 1) = cumulants(4) - cumulants(0) * cumulants(1);\n covariance(1, 0) = covariance(0, 1);\n covariance(0, 2) = cumulants(5) - cumulants(0) * cumulants(2);\n covariance(2, 0) = covariance(0, 2);\n covariance(1, 2) = cumulants(7) - cumulants(1) * cumulants(2);\n covariance(2, 1) = covariance(1, 2);\n return covariance;\n}\n\ntemplate \nstd::tuple ComputeMeanAndCovariance(\n const std::vector &points,\n const std::vector &indices) {\n Eigen::Vector3d mean;\n Eigen::Matrix3d covariance;\n Eigen::Matrix cumulants;\n cumulants.setZero();\n for (const auto &idx : indices) {\n const Eigen::Vector3d &point = points[idx];\n cumulants(0) += point(0);\n cumulants(1) += point(1);\n cumulants(2) += point(2);\n cumulants(3) += point(0) * point(0);\n cumulants(4) += point(0) * point(1);\n cumulants(5) += point(0) * point(2);\n cumulants(6) += point(1) * point(1);\n cumulants(7) += point(1) * point(2);\n cumulants(8) += point(2) * point(2);\n }\n cumulants /= (double)indices.size();\n mean(0) = cumulants(0);\n mean(1) = cumulants(1);\n mean(2) = cumulants(2);\n covariance(0, 0) = cumulants(3) - cumulants(0) * cumulants(0);\n covariance(1, 1) = cumulants(6) - cumulants(1) * cumulants(1);\n covariance(2, 2) = cumulants(8) - cumulants(2) * cumulants(2);\n covariance(0, 1) = cumulants(4) - cumulants(0) * cumulants(1);\n covariance(1, 0) = covariance(0, 1);\n covariance(0, 2) = cumulants(5) - cumulants(0) * cumulants(2);\n covariance(2, 0) = covariance(0, 2);\n covariance(1, 2) = cumulants(7) - cumulants(1) * cumulants(2);\n covariance(2, 1) = covariance(1, 2);\n return std::make_tuple(mean, covariance);\n}\n\ntemplate Eigen::Matrix3d ComputeCovariance(\n const std::vector &points,\n const std::vector &indices);\ntemplate std::tuple ComputeMeanAndCovariance(\n const std::vector &points,\n const std::vector &indices);\ntemplate Eigen::Matrix3d ComputeCovariance(\n const std::vector &points,\n const std::vector &indices);\ntemplate std::tuple ComputeMeanAndCovariance(\n const std::vector &points,\n const std::vector &indices);\n} // namespace utility\n} // namespace open3d\n", "meta": {"hexsha": "a7fa23e6a7467f0d43250da8f4513164ba7d743d", "size": 14240, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "cpp/open3d/utility/Eigen.cpp", "max_stars_repo_name": "JohanVer/Open3D", "max_stars_repo_head_hexsha": "8129a01cc0d51e17a0760b8dc4467700023a808c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2022-03-22T07:54:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T07:54:12.000Z", "max_issues_repo_path": "cpp/open3d/utility/Eigen.cpp", "max_issues_repo_name": "JohanVer/Open3D", "max_issues_repo_head_hexsha": "8129a01cc0d51e17a0760b8dc4467700023a808c", "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": "cpp/open3d/utility/Eigen.cpp", "max_forks_repo_name": "JohanVer/Open3D", "max_forks_repo_head_hexsha": "8129a01cc0d51e17a0760b8dc4467700023a808c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-03-31T15:27:11.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T15:27:11.000Z", "avg_line_length": 37.375328084, "max_line_length": 80, "alphanum_fraction": 0.5895365169, "num_tokens": 4089, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125848754472, "lm_q2_score": 0.718594386544335, "lm_q1q2_score": 0.5403920221021917}} {"text": "#pragma once\n\n#include \n#include \"roboy_communication_middleware/InverseKinematics.h\"\n#include \n#include \n#include \n#include \n#include \n#include \"common_utilities/CommonDefinitions.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"common_utilities/rviz_visualization.hpp\"\n\nusing namespace Eigen;\nusing namespace std;\n\nclass PaBiRoboyInverseKinematics:public rviz_visualization{\npublic:\n PaBiRoboyInverseKinematics();\n ~PaBiRoboyInverseKinematics(){};\n\n template\n _Matrix_Type_ pseudoInverse(const _Matrix_Type_ &a, double epsilon = std::numeric_limits::epsilon())\n {\n Eigen::JacobiSVD< _Matrix_Type_ > svd(a ,Eigen::ComputeThinU | Eigen::ComputeThinV);\n double tolerance = epsilon * std::max(a.cols(), a.rows()) *svd.singularValues().array().abs()(0);\n return svd.matrixV() * (svd.singularValues().array().abs() > tolerance).select(svd.singularValues().array().inverse(), 0).matrix().asDiagonal() * svd.matrixU().adjoint();\n }\n\n bool inverseKinematics(roboy_communication_middleware::InverseKinematics::Request &req,\n roboy_communication_middleware::InverseKinematics::Response &res);\n /**\n * Calculates the Jacobian of a lighthouse sensor\n * @param out 3x5 Matrix will be filled with the values\n * @param sensor for this sensor\n * @param ankle_left\n * @param ankle_right\n * @param theta0 knee_left angle\n * @param theta1 hip_left angle\n * @param theta2 hip_right angle\n * @param theta3 knee_right angle\n * @param phi angle of lower left leg wrt to inertial_frame.z\n */\n void Jacobian(double *out, int sensor, double ankle_left, double ankle_right, double theta0, double theta1, double theta2, double theta3, double phi);\n /**\n * forward kinematics of joints\n * @param out position\n * @param joint for this joint\n * @param ankle_x ankle_left position x\n * @param ankle_y ankle_left position y\n * @param theta0 knee_left angle\n * @param theta1 hip_left angle\n * @param theta2 hip_right angle\n * @param theta3 knee_right angle\n * @param phi angle of lower left leg wrt to inertial_frame.z\n */\n void joint_position(double *out, int joint, double ankle_x, double ankle_y, double theta0, double theta1, double theta2, double theta3, double phi);\n\n /**\n * forward kinematics of lighthouse sensors\n * @param out\n * @param sensor for this lighthouse sensor\n * @param ankle_x ankle_left position x\n * @param ankle_y ankle_left position y\n * @param theta0 knee_left angle\n * @param theta1 hip_left angle\n * @param theta2 hip_right angle\n * @param theta3 knee_right angle\n * @param phi angle of lower left leg wrt to inertial_frame.z\n */\n void lighthouse_sensor(double *out, int sensor, double ankle_x, double ankle_y, double phi, double theta0, double theta1, double theta2, double theta3);\n geometry_msgs::Vector3 lighthouse_sensor(int sensor, double ankle_x, double ankle_y, double phi, double theta0, double theta1, double theta2, double theta3);\n\n void visualize();\n\n enum JOINTS{\n ANKLE_LEFT = 0,\n KNEE_LEFT,\n HIP_LEFT,\n HIP_CENTER,\n HIP_RIGHT,\n KNEE_RIGHT,\n ANKLE_RIGHT,\n ANKLE_RIGHT_JACOBIAN = 9,\n };\nprivate:\n ros::NodeHandlePtr nh;\n ros::ServiceServer ik_srv;\n const double l1 = 0.34;\n const double l2 = 0.40;\n const double l3 = 0.18;\n const double error_threshold = 0.005, max_number_iterations = 100;\n boost::shared_ptr viewer;\n map initial_position, result_position;\n};\n\nint main(int argc, char* argv[]);\n\n", "meta": {"hexsha": "bac19b55ea7d938ab7b8df7b7bdd09cd77a60f11", "size": 4012, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/roboy_dynamics/PaBiRoboy_inverse_kinematics.hpp", "max_stars_repo_name": "Roboy/roboy_dynamics", "max_stars_repo_head_hexsha": "a0a0012bad28029d01b6aead507faeee4509dd62", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/roboy_dynamics/PaBiRoboy_inverse_kinematics.hpp", "max_issues_repo_name": "Roboy/roboy_dynamics", "max_issues_repo_head_hexsha": "a0a0012bad28029d01b6aead507faeee4509dd62", "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": "include/roboy_dynamics/PaBiRoboy_inverse_kinematics.hpp", "max_forks_repo_name": "Roboy/roboy_dynamics", "max_forks_repo_head_hexsha": "a0a0012bad28029d01b6aead507faeee4509dd62", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.8490566038, "max_line_length": 179, "alphanum_fraction": 0.6996510469, "num_tokens": 1025, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8947894520743981, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.5403918345899367}} {"text": "#include \"polyscope/polyscope.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"polyscope/messages.h\"\n#include \"polyscope/point_cloud.h\"\n#include \"polyscope/surface_mesh.h\"\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"../../include/CommonTools.h\"\n#include \"../../include/MeshLib/MeshConnectivity.h\"\n#include \"../../include/MeshLib/MeshUpsampling.h\"\n#include \"../../include/Visualization/PaintGeometry.h\"\n#include \"../../include/InterpolationScheme/VecFieldSplit.h\"\n#include \"../../include/Optimization/NewtonDescent.h\"\n#include \"../../include/Optimization/LinearConstrainedSolver.h\"\n#include \"../../include/IntrinsicFormula/InterpolateZvalsFromEdgeOmega.h\"\n#include \"../../include/DynamicInterpolation/ComputeZandZdot.h\"\n#include \"../../include/DynamicInterpolation/InterpolateKeyFrames.h\"\n//#include \"../../include/IntrinsicFormula/ComputeZdotFromEdgeOmega.h\"\n#include \"../../include/IntrinsicFormula/ComputeZdotFromHalfEdgeOmega.h\"\n//#include \"../../include/IntrinsicFormula/IntrinsicKeyFrameInterpolationFromEdge.h\"\n#include \"../../include/IntrinsicFormula/IntrinsicKeyFrameInterpolationFromHalfEdge.h\"\n#include \"../../include/IntrinsicFormula/KnoppelStripePattern.h\"\n\n\n\nEigen::MatrixXd triV, upsampledTriV;\nEigen::MatrixXi triF, upsampledTriF;\nMeshConnectivity triMesh, upsampledTriMesh;\nstd::vector> bary;\n\nEigen::MatrixXd sourceOmegaFields, tarOmegaFields;\nEigen::MatrixXd theoOmega, tarTheoOmega;\n\n\nstd::vector> sourceZvals, sourceTheoZVals, upsampledTheoZVals;\nstd::vector> tarZvals, tarTheoZVals, upsampledTarTheoZVals;\nstd::vector sourceTheoGradZvals, tarTheoGradZvals;\n\n\nstd::vector omegaList;\nstd::vector theoOmegaList;\nstd::vector>> zList;\nstd::vector>> theoZList;\n\nstd::vector phaseFieldsList;\nstd::vector ampFieldsList;\n\nstd::vector theoPhaseFieldsList;\nstd::vector theoAmpFieldsList;\n\n\nEigen::MatrixXd dataV;\nEigen::MatrixXi dataF;\nEigen::MatrixXd dataVec;\nEigen::MatrixXd curColor;\n\nint loopLevel = 1;\nbool isFixedSource = true;\nbool isFixedTar = true;\n\nbool isForceOptimize = false;\nbool isTwoTriangles = true;\n\nPaintGeometry mPaint;\n\nint numFrames = 2;\nint curFrame = 0;\n\nint singIndSource = 1, singIndSource1 = 1;\nint singIndTar = 1, singIndTar1 = 1;\nint numWavesSource = 2, numWaveTar = 4;\n\ndouble globalAmpMax = 1;\n\ndouble dragSpeed = 0.5;\n\ndouble triarea = 0.04;\n\nfloat vecratio = 0.1;\n\ndouble sourceCenter1x = 0, sourceCenter1y = 0, sourceCenter2x = 0.8, sourceCenter2y = -0.2, targetCenter1x = 0, targetCenter1y = 0, targetCenter2x = 0.3, targetCenter2y = -0.7;\ndouble sourceDirx = 1.0, sourceDiry = 0, targetDirx = 1, targetDiry = 0;\n\ndouble gradTol = 1e-6;\ndouble xTol = 0;\ndouble fTol = 0;\nint numIter = 1000;\nint quadOrder = 4;\n\n\nenum FunctionType {\n\tWhirlpool = 0,\n\tPlaneWave = 1,\n\tSummation = 2,\n\tYShape = 3,\n\tTwoWhirlPool = 4,\n};\n\nenum InitializationType{\n Random = 0,\n Linear = 1,\n Theoretical = 2\n};\n\nbool isUseUpMesh = false;\n\nFunctionType functionType = FunctionType::PlaneWave;\nFunctionType tarFunctionType = FunctionType::PlaneWave;\nInitializationType initializationType = InitializationType::Linear;\n\n\nvoid generateSquare(double length, double width, double triarea, Eigen::MatrixXd& irregularV, Eigen::MatrixXi& irregularF)\n{\n\tdouble area = length * width;\n\tint N = (0.25 * std::sqrt(area / triarea));\n\tN = N > 1 ? N : 1;\n\tdouble deltaX = length / (4.0 * N);\n\tdouble deltaY = width / (4.0 * N);\n\n\tEigen::MatrixXd planeV;\n\tEigen::MatrixXi planeE;\n\n//\tplaneV.resize(10, 2);\n//\tplaneE.resize(10, 2);\n\n//\tfor (int i = -2; i <= 2; i++)\n//\t{\n//\t\tplaneV.row(i + 2) << length / 4.0 * i, -width / 2.0;\n//\t}\n//\n//\tfor (int i = 2; i >= -2; i--)\n//\t{\n//\t\tplaneV.row(5 + 2 - i) << length / 4.0 * i, width / 2.0;\n//\t}\n//\n//\tfor (int i = 0; i < 10; i++)\n//\t{\n//\t\tplaneE.row(i) << i, (i + 1) % 10;\n//\t}\n\n\tint M = 2 * N + 1;\n\tplaneV.resize(4 * M - 4, 2);\n\tplaneE.resize(4 * M - 4, 2);\n\n\tfor (int i = 0; i < M; i++)\n\t{\n\t planeV.row(i) << -length / 2, i * width / (M - 1) - width / 2;\n\t}\n\tfor (int i = 1; i < M; i++)\n\t{\n\t planeV.row(M - 1 + i) << i * length / (M - 1)-length / 2, width / 2;\n\t}\n\tfor (int i = 1; i < M; i++)\n\t{\n\t planeV.row(2 * (M - 1) + i) << length / 2, width/2 - i * width / (M - 1);\n\t}\n\tfor (int i = 1; i < M - 1; i++)\n\t{\n\t planeV.row(3 * (M - 1) + i) << length / 2- i * length / (M - 1), - width / 2;\n\t}\n\n\tfor (int i = 0; i < 4 * (M - 1); i++)\n\t{\n\t planeE.row(i) << i, (i + 1) % (4 * (M - 1));\n\t}\n\n\tEigen::MatrixXd V2d;\n\tEigen::MatrixXi F;\n\tEigen::MatrixXi H(0, 2);\n\tstd::cout << triarea << std::endl;\n\t// Create an output string stream\n\tstd::ostringstream streamObj;\n\t//Add double to stream\n\tstreamObj << triarea;\n\tconst std::string flags = \"q20a\" + std::to_string(triarea);\n\n\tigl::triangle::triangulate(planeV, planeE, H, flags, V2d, F);\n\n\tif (isTwoTriangles)\n\t{\n\t\t/*V2d.resize(4, 3);\n\t\tV2d << -1, -1, 0,\n\t\t\t1, -1, 0,\n\t\t\t1, 1, 0,\n\t\t\t-1, 1, 0;\n\n\t\tF.resize(2, 3);\n\t\tF << 0, 1, 2,\n\t\t\t2, 3, 0;*/\n\n\t\tV2d.resize(3, 3);\n\t\tV2d << 0, 0, 0,\n\t\t\t1, 0, 0,\n\t\t\t0, 1, 0;\n\n\t\tF.resize(1, 3);\n\t\tF << 0, 1, 2;\n\t}\n\n\tirregularV.resize(V2d.rows(), 3);\n\tirregularV.setZero();\n\tirregularV.block(0, 0, irregularV.rows(), 2) = V2d.block(0, 0, irregularV.rows(), 2);\n\tirregularF = F;\n\tigl::writeOBJ(\"irregularPlane.obj\", irregularV, irregularF);\n}\n\n\nvoid generateWhirlPool(double centerx, double centery, Eigen::MatrixXd& w, std::vector>& z, int pow = 1, std::vector *gradZ = NULL, std::vector> *upsampledZ = NULL)\n{\n\tz.resize(triV.rows());\n\tw.resize(triV.rows(), 2);\n\tstd::cout << \"whirl pool center: \" << centerx << \", \" << centery << std::endl;\n\tbool isnegative = false;\n\tif(pow < 0)\n\t{\n\t isnegative = true;\n\t pow *= -1;\n\t}\n\n\tfor (int i = 0; i < z.size(); i++)\n\t{\n\t\tdouble x = triV(i, 0) - centerx;\n\t\tdouble y = triV(i, 1) - centery;\n\t\tdouble rsquare = x * x + y * y;\n\n\t\tif(isnegative)\n\t\t{\n\t\t z[i] = std::pow(std::complex(x, -y), pow);\n\n\t\t if (std::abs(std::sqrt(rsquare)) < 1e-10)\n\t\t w.row(i) << 0, 0;\n\t\t else\n\t\t w.row(i) << pow * y / rsquare, -pow * x / rsquare;\n\t\t}\n\t\telse\n\t\t{\n\t\t z[i] = std::pow(std::complex(x, y), pow);\n\n\t\t if (std::abs(std::sqrt(rsquare)) < 1e-10)\n\t\t w.row(i) << 0, 0;\n\t\t else\n\t\t //\t\t\tw.row(i) << -y / rsquare, x / rsquare;\n\t\t w.row(i) << -pow * y / rsquare, pow * x / rsquare;\n\t\t}\n\t}\n\n\tif(upsampledZ)\n\t{\n\t upsampledZ->resize(upsampledTriV.rows());\n\t for(int i = 0; i < upsampledZ->size(); i++)\n\t {\n\t double x = upsampledTriV(i, 0) - centerx;\n\t double y = upsampledTriV(i, 1) - centery;\n\t double rsquare = x * x + y * y;\n\n\t\t\tupsampledZ->at(i) = std::pow(std::complex(x, y), pow);\n\t\t\tif(isnegative)\n\t\t\t upsampledZ->at(i) = std::pow(std::complex(x, -y), pow);\n\t }\n\t}\n\tif(gradZ)\n\t{\n\t gradZ->resize(triV.rows());\n\t for(int i = 0; i < gradZ->size(); i++)\n\t {\n\t double x = upsampledTriV(i, 0) - centerx;\n\t double y = upsampledTriV(i, 1) - centery;\n\n\t Eigen::Vector2cd tmpGrad;\n\t tmpGrad << 1, std::complex(0, 1);\n\t if(isnegative)\n\t tmpGrad(1) *= -1;\n\n\t (*gradZ)[i] = std::pow(std::complex(x, y), pow - 1) * tmpGrad;\n\t (*gradZ)[i] *= pow;\n\n\t }\n\n\t}\n}\n\nvoid generatePlaneWave(Eigen::Vector2d v, Eigen::MatrixXd& w, std::vector>& z, std::vector *gradZ = NULL, std::vector> *upsampledZ = NULL)\n{\n z.resize(triV.rows());\n w.resize(triV.rows(), 2);\n std::cout << \"plane wave direction: \" << v.transpose() << std::endl;\n\n for (int i = 0; i < z.size(); i++)\n {\n double theta = v.dot(triV.row(i).segment<2>(0));\n double x = std::cos(theta);\n double y = std::sin(theta);\n z[i] = std::complex(x, y);\n w.row(i) = v;\n }\n\n if(upsampledZ)\n {\n upsampledZ->resize(upsampledTriV.rows());\n for(int i = 0; i < upsampledZ->size(); i++)\n {\n double theta = v.dot(upsampledTriV.row(i).segment<2>(0));\n double x = std::cos(theta);\n double y = std::sin(theta);\n upsampledZ->at(i) = std::complex(x, y);\n }\n }\n if(gradZ)\n {\n gradZ->resize(triV.rows());\n for(int i = 0; i < gradZ->size(); i++)\n {\n double theta = v.dot(triV.row(i).segment<2>(0));\n double x = std::cos(theta);\n double y = std::sin(theta);\n std::complex tmpZ = std::complex(x, y);\n std::complex I = std::complex(0, 1);\n\n (*gradZ)[i] << I * tmpZ * v(0), I * tmpZ * v(1);\n }\n\n }\n}\n\nvoid generatePeriodicWave(int waveNum, Eigen::MatrixXd& w, std::vector>& z, std::vector *gradZ = NULL, std::vector> *upsampledZ = NULL)\n{\n Eigen::Vector2d v(2 * M_PI * waveNum, 0);\n generatePlaneWave(v, w, z, gradZ, upsampledZ);\n}\n\nvoid generateTwoWhirlPool(double centerx0, double centery0, double centerx1, double centery1, Eigen::MatrixXd& w, std::vector>& z, int n0 = 1, int n1 = 1, std::vector *gradZ = NULL, std::vector>* upsampledZ = NULL)\n{\n\tEigen::MatrixXd w0, w1;\n\tstd::vector gradZ0, gradZ1;\n\tstd::vector> z0, z1, upsampledZ0, upsampledZ1;\n\n\tgenerateWhirlPool(centerx0, centery0, w0, z0, n0, gradZ ? &gradZ0 : NULL, upsampledZ ? &upsampledZ0 : NULL);\n\tgenerateWhirlPool(centerx1, centery1, w1, z1, n1, gradZ ? &gradZ1 : NULL, upsampledZ ? &upsampledZ1 : NULL);\n\n\tstd::cout << \"whirl pool center: \" << centerx0 << \", \" << centery0 << std::endl;\n\tstd::cout << \"whirl pool center: \" << centerx1 << \", \" << centery1 << std::endl;\n\n\tz.resize(triV.rows());\n\tw.resize(triV.rows(), 2);\n\n\tw = w0 + w1;\n\n\tfor (int i = 0; i < z.size(); i++)\n\t{\n\t\tz[i] = z0[i] * z1[i];\n\t}\n\n\tif (upsampledZ)\n\t{\n\t\tupsampledZ->resize(upsampledTriV.rows());\n\t\tfor (int i = 0; i < upsampledZ->size(); i++)\n\t\t{\n\t\t\tupsampledZ->at(i) = upsampledZ0[i] * upsampledZ1[i];\n\t\t}\n\t}\n\n\tif(gradZ)\n\t{\n\t *gradZ = gradZ0;\n\t for(int i = 0; i < gradZ0.size(); i++)\n\t {\n\t (*gradZ)[i] = z0[i] * gradZ1[i] + z1[i] * gradZ0[i];\n\t }\n\t}\n}\n\nvoid generatePlaneSumWhirl(double centerx, double centery, Eigen::Vector2d v, Eigen::MatrixXd& w, std::vector>& z, int pow = 1, std::vector *gradZ = NULL, std::vector> *upsampledZ = NULL)\n{\n z.resize(triV.rows());\n w.resize(triV.rows(), 2);\n std::cout << \"whirl pool center: \" << centerx << \", \" << centery << std::endl;\n std::cout << \"plane wave direction: \" << v.transpose() << std::endl;\n\n std::vector gradWZ, gradPZ;\n Eigen::MatrixXd whw, plw;\n std::vector> wz, pz, upWz, upPz;\n\n generatePlaneWave(v, plw, pz, gradZ ? &gradPZ : NULL, upsampledZ ? &upPz : NULL);\n generateWhirlPool(centerx, centery, whw, wz, pow, gradZ? &gradWZ : NULL, upsampledZ? &upWz : NULL);\n\n\n\n for (int i = 0; i < z.size(); i++)\n {\n z[i] = pz[i] * wz[i];\n w = plw + whw;\n }\n\n if(upsampledZ)\n {\n upsampledZ->resize(upsampledTriV.rows());\n\n for(int i = 0; i < upsampledZ->size(); i++)\n {\n (*upsampledZ)[i] = upPz[i] * upWz[i];\n }\n }\n\n if(gradZ)\n {\n *gradZ = gradWZ;\n for(int i = 0; i < gradWZ.size(); i++)\n {\n (*gradZ)[i] = pz[i] * gradWZ[i] + wz[i] * gradPZ[i];\n }\n }\n\n}\n\nvoid generateYshape(Eigen::Vector2d w1, Eigen::Vector2d w2, Eigen::MatrixXd &w, std::vector> &z, std::vector *gradZ = NULL, std::vector> *upsampledZ = NULL)\n{\n z.resize(triV.rows());\n w.resize(triV.rows(), 2);\n\n if(gradZ)\n gradZ->resize(triV.rows());\n\n std::cout << \"w1: \" << w1.transpose() << std::endl;\n std::cout << \"w2: \" << w2.transpose() << std::endl;\n\n Eigen::MatrixXd pw1, pw2;\n std::vector> pz1, pz2;\n std::vector gradPZ1, gradPZ2;\n std::vector> upsampledPZ1, upsampledPZ2;\n\n generatePlaneWave(w1, pw1, pz1, gradZ ? & gradPZ1 : NULL, upsampledZ? &upsampledPZ1 : NULL);\n generatePlaneWave(w2, pw2, pz2, gradZ ? & gradPZ2 : NULL, upsampledZ? &upsampledPZ2 : NULL);\n\n double ymax = triV.col(1).maxCoeff();\n double ymin = triV.col(1).minCoeff();\n\n for (int i = 0; i < z.size(); i++)\n {\n\n double weight = (triV(i, 1) - triV.col(1).minCoeff()) / (triV.col(1).maxCoeff() - triV.col(1).minCoeff());\n z[i] = (1 - weight) * pz1[i] + weight * pz2[i];\n Eigen::Vector2cd dz = (1 - weight) * gradPZ1[i] + weight * gradPZ2[i];\n if(gradZ)\n (*gradZ)[i] = dz;\n\n double wx = 0;\n double wy = 1 / (ymax - ymin);\n\n w.row(i) = (std::conj(z[i]) * dz).imag() / (std::abs(z[i]) * std::abs(z[i]));\n }\n\n if(upsampledZ)\n {\n upsampledZ->resize(upsampledTriV.rows());\n for(int i = 0; i < upsampledZ->size(); i++)\n {\n double theta = w1.dot(upsampledTriV.row(i).segment<2>(0));\n double x = std::cos(theta);\n double y = std::sin(theta);\n std::complex z1 = std::complex(x, y);\n\n theta = w2.dot(upsampledTriV.row(i).segment<2>(0));\n x = std::cos(theta);\n y = std::sin(theta);\n std::complex z2 = std::complex(x, y);\n\n double weight = (upsampledTriV(i, 1) - upsampledTriV.col(1).minCoeff()) / (upsampledTriV.col(1).maxCoeff() - upsampledTriV.col(1).minCoeff());\n upsampledZ->at(i) = (1 - weight) * z1 + weight * z2;\n }\n }\n}\n\nvoid initialization()\n{\n\tgenerateSquare(2.0, 2.0, triarea, triV, triF);\n\n\n\tEigen::SparseMatrix S;\n\tstd::vector facemap;\n\n\tmeshUpSampling(triV, triF, upsampledTriV, upsampledTriF, loopLevel, &S, &facemap, &bary);\n\tstd::cout << \"upsampling finished\" << std::endl;\n\n\ttriMesh = MeshConnectivity(triF);\n\tupsampledTriMesh = MeshConnectivity(upsampledTriF);\n\n std::cout << \"nverts: \" << triV.rows() << \", nedges: \" << triMesh.nEdges() << std::endl;\n}\n\n\nvoid generateValues(FunctionType funType, Eigen::MatrixXd &vecFields, std::vector> &zvalues, std::vector &gradZvals, std::vector> &upZvals, int singularityInd1 = 1, int singularityInd2 = 1, bool isFixedGenerator = false, double fixedx = 0, double fixedy = 0, Eigen::Vector2d fixedv = Eigen::Vector2d::Constant(1.0))\n{\n\tEigen::MatrixXd vertFields;\n\tif (funType == FunctionType::Whirlpool)\n\t{\n\t\tEigen::Vector2d center = Eigen::Vector2d::Random();\n\t\tif (isFixedGenerator)\n\t\t\tcenter << fixedx, fixedy;\n\t\tgenerateWhirlPool(center(0), center(1), vertFields, zvalues, singularityInd1, &gradZvals, &upZvals);\n\t}\n\telse if (funType == FunctionType::PlaneWave)\n\t{\n\t\tEigen::Vector2d v = Eigen::Vector2d::Random();\n\t\tif (isFixedGenerator)\n\t\t\tv = fixedv;\n\t\tgeneratePlaneWave(v, vertFields, zvalues, &gradZvals, &upZvals);\n\t}\n\telse if (funType == FunctionType::Summation)\n\t{\n\t\tEigen::Vector2d center = Eigen::Vector2d::Random();\n\t\tEigen::Vector2d v = Eigen::Vector2d::Random();\n\t\tif (isFixedGenerator)\n\t\t{\n\t\t\tv = fixedv;\n\t\t\tcenter << fixedx, fixedy;\n\t\t}\n\t\tgeneratePlaneSumWhirl(center(0), center(1), v, vertFields, zvalues, singularityInd1, &gradZvals, &upZvals);\n\t}\n\telse if (funType == FunctionType::YShape)\n\t{\n\t\tEigen::Vector2d w1(1, 0);\n\t\tEigen::Vector2d w2(1, 0);\n\n\t\tw1(0) = 2 * 3.1415926;\n\t\tw2(0) = 4 * 3.1415926;\n\t\tgenerateYshape(w1, w2, vertFields, zvalues, &gradZvals, &upZvals);\n\t}\n\telse if (funType == FunctionType::TwoWhirlPool)\n\t{\n\t\tEigen::Vector2d center0 = Eigen::Vector2d::Random();\n\t\tEigen::Vector2d center1 = Eigen::Vector2d::Random();\n\t\tif (isFixedGenerator)\n\t\t{\n\t\t\tcenter0 << fixedx, fixedy;\n\t\t\tcenter1 << 0.8, -0.3;\n\t\t}\n\t\tgenerateTwoWhirlPool(center0(0), center0(1), center1(0), center1(1), vertFields, zvalues, singularityInd1, singularityInd2, &gradZvals, &upZvals);\n\t}\n\tEigen::MatrixXd vertFields3D(triV.rows(), 3);\n\tvertFields3D.block(0, 0, triV.rows(), 2) = vertFields;\n\tvertFields3D.col(2).setZero();\n\n\tvecFields = vertexVec2IntrinsicHalfEdgeVec(vertFields3D, triV, MeshConnectivity(triF));\n}\n\n// TODO: remove this\nEigen::MatrixXd vertexVec2IntrinsicHalfEdgeVec2D(const Eigen::MatrixXd& v, const Eigen::MatrixXd& pos, const MeshConnectivity& mesh, std::vector> &T)\n{\n int nedges = mesh.nEdges();\n Eigen::MatrixXd edgeOmega(nedges, 2);\n T.clear();\n\n for (int i = 0; i < nedges; i++)\n {\n int vid0 = mesh.edgeVertex(i, 0);\n int vid1 = mesh.edgeVertex(i, 1);\n\n Eigen::Vector2d e = (pos.row(vid1) - pos.row(vid0)).segment(0, 2);\n edgeOmega(i, 0) = v.row(vid0).dot(e);\n edgeOmega(i, 1) = -v.row(vid1).dot(e);\n\n T.push_back({2 * i, 2 * vid0, e(0)});\n T.push_back({2 * i, 2 * vid0 + 1, e(1)});\n\n T.push_back({2 * i + 1, 2 * vid1, -e(0)});\n T.push_back({2 * i + 1, 2 * vid1 + 1, -e(1)});\n }\n return edgeOmega;\n}\n\nvoid solveKeyFrames(const Eigen::MatrixXd& sourceVec, const Eigen::MatrixXd& tarVec, const std::vector>& sourceZvals, const std::vector>& tarZvals, const int numKeyFrames, std::vector& wFrames, std::vector>>& zFrames)\n{\n\tEigen::VectorXd faceArea;\n\tigl::doublearea(triV, triF, faceArea);\n\tfaceArea /= 2;\n\tIntrinsicFormula::IntrinsicKeyFrameInterpolationFromHalfEdge interpModel = IntrinsicFormula::IntrinsicKeyFrameInterpolationFromHalfEdge(MeshConnectivity(triF), faceArea, numFrames, quadOrder, sourceZvals, sourceVec, tarZvals, tarVec);\n\tEigen::VectorXd x;\n\tinterpModel.convertList2Variable(x); // linear initialization\n\n std::vector> testzvals;\n Eigen::MatrixXd cotEntries;\n igl::cotmatrix_entries(triV, triF, cotEntries);\n IntrinsicFormula::roundVertexZvalsFromHalfEdgeOmega(triMesh, sourceVec, faceArea, cotEntries, triV.rows(), testzvals);\n IntrinsicFormula::testRoundingEnergy(triMesh, sourceVec, faceArea, cotEntries, triV.rows(), testzvals);\n\tfor (auto& z : testzvals)\n\t{\n\t\tEigen::Vector2d rndvec;\n\t\trndvec.setRandom();\n\t\tz = std::complex(rndvec(0), rndvec(1));\n\t}\n\tIntrinsicFormula::testRoundingEnergy(triMesh, sourceVec, faceArea, cotEntries, triV.rows(), testzvals);\n\n\t//interpModel.testEnergy(x);\n\t//\t\tstd::cout << \"starting energy: \" << interpModel.computeEnergy(x) << std::endl;\n\tif (initializationType == InitializationType::Theoretical)\n\t{\n\t\tinterpModel.setwzLists(theoZList, theoOmegaList);\n\t\tinterpModel.convertList2Variable(x);\n\t}\n\telse if (initializationType == InitializationType::Random)\n\t{\n\t\tx.setRandom();\n\t\tinterpModel.convertVariable2List(x);\n\t\tinterpModel.convertList2Variable(x);\n\t}\n\telse\n\t{\n\t\t// do nothing, since it is initialized as the linear interpolation.\n\t}\n\n\tauto initWFrames = interpModel.getWList();\n\tauto initZFrames = interpModel.getVertValsList();\n\tif (isForceOptimize)\n\t{\n\t\tauto funVal = [&](const Eigen::VectorXd& x, Eigen::VectorXd* grad, Eigen::SparseMatrix* hess, bool isProj) {\n\t\t\tEigen::VectorXd deriv;\n\t\t\tEigen::SparseMatrix H;\n\t\t\tdouble E = interpModel.computeEnergy(x, grad ? &deriv : NULL, hess ? &H : NULL, isProj);\n\n\t\t\tif (grad)\n\t\t\t{\n\t\t\t\t(*grad) = deriv;\n\t\t\t}\n\n\t\t\tif (hess)\n\t\t\t{\n\t\t\t\t(*hess) = H;\n\t\t\t}\n\n\t\t\treturn E;\n\t\t};\n\t\tauto maxStep = [&](const Eigen::VectorXd& x, const Eigen::VectorXd& dir) {\n\t\t\treturn 1.0;\n\t\t};\n\n\t\tauto getVecNorm = [&](const Eigen::VectorXd& x, double& znorm, double& wnorm) {\n\t\t\tinterpModel.getComponentNorm(x, znorm, wnorm);\n\t\t};\n\n\n\n\t\tOptSolver::testFuncGradHessian(funVal, x);\n\n\t\tauto x0 = x;\n\t\tOptSolver::newtonSolver(funVal, maxStep, x, numIter, gradTol, xTol, fTol, true, getVecNorm);\n\t\tstd::cout << \"before optimization: \" << x0.norm() << \", after optimization: \" << x.norm() << \", difference: \" << (x - x0).norm() << std::endl;\n\t\tstd::cout << \"x norm: \" << x.norm() << std::endl;\n\n\t\t/*Eigen::VectorXd deriv;\n\t\tEigen::SparseMatrix H;\n\t\tdouble E = interpModel.computeEnergy(x, &deriv, &H, false);\n\n\t\tstd::cout << deriv.norm() << std::endl;*/\n\t\t//std::cout << \"hessian: \\n\" << H.toDense() << std::endl;\n\n\t\t/*Eigen::SelfAdjointEigenSolver es;\n\t\tes.compute(H.toDense());\n\t\tEigen::VectorXd evals = es.eigenvalues();\n\t\tstd::cout << \"evals: \" << evals.transpose() << std::endl;*/\n\n\t}\n\tinterpModel.convertVariable2List(x);\n\n\twFrames = interpModel.getWList();\n\tzFrames = interpModel.getVertValsList();\n\n\tfor (int i = 0; i < wFrames.size() - 1; i++)\n\t{\n\t\tdouble zdotNorm = interpModel._zdotModel.computeZdotIntegration(zFrames[i], wFrames[i], zFrames[i + 1], wFrames[i + 1], NULL, NULL);\n\n\t\tdouble initZdotNorm = interpModel._zdotModel.computeZdotIntegration(initZFrames[i], initWFrames[i], initZFrames[i + 1], initWFrames[i + 1], NULL, NULL);\n\n\t\tstd::cout << \"frame \" << i << \", before optimization: ||zdot||^2: \" << initZdotNorm << \", after optimization, ||zdot||^2 = \" << zdotNorm << std::endl;\n\t}\n\n\n}\n\nvoid updateMagnitudePhase(const std::vector& wFrames, const std::vector>>& zFrames, std::vector& magList, std::vector& phaseList)\n{\n\tstd::vector>> interpZList(wFrames.size());\n\tmagList.resize(wFrames.size());\n\tphaseList.resize(wFrames.size());\n\n\tMeshConnectivity mesh(triF);\n\n\tauto computeMagPhase = [&](const tbb::blocked_range& range) {\n\t\tfor (uint32_t i = range.begin(); i < range.end(); ++i)\n\t\t{\n\t\t\tinterpZList[i] = IntrinsicFormula::upsamplingZvals(mesh, zFrames[i], wFrames[i], bary);\n\t\t\tmagList[i].setZero(interpZList[i].size());\n\t\t\tphaseList[i].setZero(interpZList[i].size());\n\n\t\t\tfor (int j = 0; j < magList[i].size(); j++)\n\t\t\t{\n\t\t\t\tmagList[i](j) = std::abs(interpZList[i][j]);\n\t\t\t\tphaseList[i](j) = std::arg(interpZList[i][j]);\n\t\t\t}\n\t\t}\n\t};\n\n\ttbb::blocked_range rangex(0u, (uint32_t)interpZList.size(), GRAIN_SIZE);\n\ttbb::parallel_for(rangex, computeMagPhase);\n}\n\nvoid updateTheoMagnitudePhase(const std::vector>& sourceZvals, const std::vector>& tarZvals,\n const std::vector& sourceGradZvals, const std::vector& tarGradZvals,\n const std::vector>& upSourceZvals, const std::vector>& upTarZvals,\n const int num, std::vector& magList, std::vector& phaseList, // upsampled information\n std::vector& wList, std::vector>> &zvalList // raw information\n )\n{\n\tmagList.resize(num + 2);\n\tphaseList.resize(num + 2);\n\twList.resize(num + 2);\n\tzvalList.resize(num + 2);\n\n\tdouble dt = 1.0 / (num + 1);\n\n\tauto computeMagPhase = [&](const tbb::blocked_range& range) {\n\t\tfor (uint32_t i = range.begin(); i < range.end(); ++i)\n\t\t{\n\t\t\tdouble w = i * dt;\n\t\t\tmagList[i].setZero(upSourceZvals.size());\n\t\t\tphaseList[i].setZero(upSourceZvals.size());\n\t\t\tfor (int j = 0; j < upSourceZvals.size(); j++)\n\t\t\t{\n\t\t\t std::complex z = (1 - w) * upSourceZvals[j] + w * upTarZvals[j];\n\t\t\t magList[i][j] = std::abs(z);\n\t\t\t phaseList[i][j] = std::arg(z);\n\t\t\t}\n\t\t\tEigen::MatrixXd vertOmega = Eigen::MatrixXd::Zero(sourceZvals.size(), 3);\n\t\t\tzvalList[i].resize(sourceZvals.size());\n\n\t\t\tfor(int j = 0; j < sourceZvals.size(); j++)\n\t\t\t{\n\t\t\t Eigen::Vector2cd gradf = (1 - w) * sourceGradZvals[j] + w * tarGradZvals[j];\n\t\t\t std::complex fbar = (1 - w) * std::conj(sourceZvals[j]) + w * std::conj(tarZvals[j]);\n\n\t\t\t\tvertOmega.row(j).segment<2>(0) = ((gradf * fbar) / (std::abs(fbar) * std::abs(fbar))).imag();\n\t\t\t zvalList[i][j] = (1 - w) * sourceZvals[j] + w * tarZvals[j];\n\t\t\t}\n\t\t\twList[i] = vertexVec2IntrinsicHalfEdgeVec(vertOmega, triV, triMesh);\n\t\t}\n\t};\n\n\ttbb::blocked_range rangex(0u, (uint32_t)(num + 2), GRAIN_SIZE);\n\ttbb::parallel_for(rangex, computeMagPhase);\n}\n\nvoid registerMeshByPart(const Eigen::MatrixXd& basePos, const Eigen::MatrixXi& baseF,\n\tconst Eigen::MatrixXd& upPos, const Eigen::MatrixXi& upF, const double& shifty, const double& ampMax,\n\tEigen::VectorXd ampVec, const Eigen::VectorXd& phaseVec,\n\tEigen::VectorXd theoAmpVec, const Eigen::VectorXd& theoPhaseVec,\n\tEigen::MatrixXd& renderV, Eigen::MatrixXi& renderF, Eigen::MatrixXd& renderColor)\n{\n\tint nverts = basePos.rows();\n\tint nfaces = baseF.rows();\n\n\tint nupverts = upPos.rows();\n\tint nupfaces = upF.rows();\n\n\tint ndataVerts = nverts + 4 * nupverts;\n\tint ndataFaces = nfaces + 4 * nupfaces;\n\t\n\trenderV.resize(ndataVerts, 3);\n\trenderF.resize(ndataFaces, 3);\n\trenderColor.setZero(ndataVerts, 3);\n\n\trenderColor.col(0).setConstant(1.0);\n\trenderColor.col(1).setConstant(1.0);\n\trenderColor.col(2).setConstant(1.0);\n\n\tint curVerts = 0;\n\tint curFaces = 0;\n\n\tEigen::VectorXd normalizedAmp = ampVec / ampMax, normalizedTheoAmp = theoAmpVec / ampMax;\n\n\n\tEigen::MatrixXd shiftV = basePos;\n\tshiftV.col(0).setConstant(0);\n\tshiftV.col(1).setConstant(shifty);\n\tshiftV.col(2).setConstant(0);\n\n\trenderV.block(0, 0, nverts, 3) = basePos - shiftV;\n\trenderF.block(0, 0, nfaces, 3) = baseF;\n\tcurVerts += nverts; \n\tcurFaces += nfaces;\n\n\tdouble shiftx = 1.5 * (basePos.col(0).maxCoeff() - basePos.col(0).minCoeff());\n\n\tshiftV = upPos;\n\tshiftV.col(0).setConstant(shiftx);\n\tshiftV.col(1).setConstant(shifty);\n\tshiftV.col(2).setConstant(0);\n\n\n\tEigen::MatrixXi shiftF = upF;\n\tshiftF.setConstant(curVerts);\n\n\t// interpolated phase\n\trenderV.block(curVerts, 0, nupverts, 3) = upPos - shiftV;\n\trenderF.block(curFaces, 0, nupfaces, 3) = upF + shiftF;\n\n\tmPaint.setNormalization(false);\n\tEigen::MatrixXd phiColor = mPaint.paintPhi(phaseVec);\n\trenderColor.block(curVerts, 0, nupverts, 3) = phiColor;\n\n\tcurVerts += nupverts;\n\tcurFaces += nupfaces;\n\t\n\t// interpolated amp\n\tshiftF.setConstant(curVerts);\n\tshiftV.col(0).setConstant(2 * shiftx);\n\trenderV.block(curVerts, 0, nupverts, 3) = upPos - shiftV;\n\trenderF.block(curFaces, 0, nupfaces, 3) = upF + shiftF;\n\n\tmPaint.setNormalization(false);\n\tEigen::MatrixXd ampColor = mPaint.paintAmplitude(ampVec / globalAmpMax);\n\trenderColor.block(curVerts, 0, nupverts, 3) = ampColor;\n\n\tcurVerts += nupverts;\n\tcurFaces += nupfaces;\n\n\t// theoretical phase\n\tshiftF.setConstant(curVerts);\n\tshiftV.col(0).setConstant(3 * shiftx);\n\trenderV.block(curVerts, 0, nupverts, 3) = upPos - shiftV;\n\trenderF.block(curFaces, 0, nupfaces, 3) = upF + shiftF;\n\n\tmPaint.setNormalization(false);\n\tphiColor = mPaint.paintPhi(theoPhaseVec);\n\trenderColor.block(curVerts, 0, nupverts, 3) = phiColor;\n\n\tcurVerts += nupverts;\n\tcurFaces += nupfaces;\n\n\t// theoretical amp\n\tshiftF.setConstant(curVerts);\n\tshiftV.col(0).setConstant(4 * shiftx);\n\trenderV.block(curVerts, 0, nupverts, 3) = upPos - shiftV;\n\trenderF.block(curFaces, 0, nupfaces, 3) = upF + shiftF;\n\n\tmPaint.setNormalization(false);\n\tampColor = mPaint.paintAmplitude(theoAmpVec / globalAmpMax);\n\trenderColor.block(curVerts, 0, nupverts, 3) = ampColor;\n\n}\n\nvoid registerMesh(int frameId)\n{\n\tEigen::MatrixXd sourceP, tarP, interpP;\n\tEigen::MatrixXi sourceF, tarF, interpF;\n\tEigen::MatrixXd sourceColor, tarColor, interpColor;\n\n\tdouble shiftx = 1.5 * (triV.col(0).maxCoeff() - triV.col(0).minCoeff());\n\tdouble shifty = 1.5 * (triV.col(1).maxCoeff() - triV.col(1).minCoeff());\n\tint totalfames = ampFieldsList.size();\n\tregisterMeshByPart(triV, triF, upsampledTriV, upsampledTriF, 0, globalAmpMax, ampFieldsList[0], phaseFieldsList[0], theoAmpFieldsList[0], theoPhaseFieldsList[0], sourceP, sourceF, sourceColor);\n\tregisterMeshByPart(triV, triF, upsampledTriV, upsampledTriF, shifty, globalAmpMax, ampFieldsList[totalfames - 1], phaseFieldsList[totalfames - 1], theoAmpFieldsList[totalfames - 1], theoPhaseFieldsList[totalfames - 1], tarP, tarF, tarColor);\n\tregisterMeshByPart(triV, triF, upsampledTriV, upsampledTriF, 2 * shifty, globalAmpMax, ampFieldsList[frameId], phaseFieldsList[frameId], theoAmpFieldsList[frameId], theoPhaseFieldsList[frameId], interpP, interpF, interpColor);\n\n\t\n\tEigen::MatrixXi shifF = sourceF;\n\n\tint nPartVerts = sourceP.rows();\n\tint nPartFaces = sourceF.rows();\n\tint nverts = triV.rows();\n\tint nfaces = triF.rows();\n\n\n\tdataV.setZero(3 * nPartVerts + nverts, 3);\n\tcurColor.setZero(3 * nPartVerts + nverts, 3);\n\tdataF.setZero(3 * nPartFaces + nfaces, 3);\n\n\tshifF.setConstant(nPartVerts);\n\n\tdataV.block(0, 0, nPartVerts, 3) = sourceP;\n\tcurColor.block(0, 0, nPartVerts, 3) = sourceColor;\n\tdataF.block(0, 0, nPartFaces, 3) = sourceF;\n\n\tdataV.block(nPartVerts, 0, nPartVerts, 3) = tarP;\n\tcurColor.block(nPartVerts, 0, nPartVerts, 3) = tarColor;\n\tdataF.block(nPartFaces, 0, nPartFaces, 3) = tarF + shifF;\n\n\tdataV.block(nPartVerts * 2, 0, nPartVerts, 3) = interpP;\n\tcurColor.block(nPartVerts * 2, 0, nPartVerts, 3) = interpColor;\n\tdataF.block(nPartFaces * 2, 0, nPartFaces, 3) = interpF + 2 * shifF;\n\n\tEigen::MatrixXd shiftV = triV;\n\tshiftV.col(0).setConstant(shiftx);\n\tshiftV.col(1).setConstant(-2 * shifty);\n\tshiftV.col(2).setZero();\n\n\tshifF = triF;\n\tshifF.setConstant(3 * nPartVerts);\n\n\tdataV.block(nPartVerts * 3, 0, nverts, 3) = triV + shiftV;\n\tcurColor.block(nPartVerts * 3, 0, nverts, 3).setConstant(1.0);\n\tdataF.block(nPartFaces * 3, 0, nfaces, 3) = triF + shifF;\n\n\tpolyscope::registerSurfaceMesh(\"input mesh\", dataV, dataF);\n\n}\n\nvoid updateFieldsInView(int frameId)\n{\n\tregisterMesh(frameId);\n\tpolyscope::getSurfaceMesh(\"input mesh\")->addVertexColorQuantity(\"VertexColor\", curColor);\n\tpolyscope::getSurfaceMesh(\"input mesh\")->getQuantity(\"VertexColor\")->setEnabled(true);\n\n\t/*polyscope::getSurfaceMesh(\"input mesh\")->addVertexVectorQuantity(\"vertex vector field\", dataVec * vecratio, polyscope::VectorType::AMBIENT);\n\tpolyscope::getSurfaceMesh(\"input mesh\")->getQuantity(\"vertex vector field\")->setEnabled(true);*/\n}\n\n\nvoid callback() {\n\tImGui::PushItemWidth(100);\n\tif (ImGui::Button(\"Reset\", ImVec2(-1, 0)))\n\t{\n\t\tcurFrame = 0;\n\t\tupdateFieldsInView(curFrame);\n\t}\n\t\n\tif (ImGui::InputDouble(\"triangle area\", &triarea))\n\t{\n\t\tif (triarea > 0)\n\t\t\tinitialization();\n\t}\n\tif (ImGui::Checkbox(\"Two Triangle Mesh\", &isTwoTriangles))\n\t{\n\t\tinitialization();\n\t}\n\tif (ImGui::InputInt(\"upsampled times\", &loopLevel))\n\t{\n\t\tif (loopLevel >= 0)\n\t\t\tinitialization();\n\t}\n\n\tif (ImGui::CollapsingHeader(\"source Vector Fields Info\", ImGuiTreeNodeFlags_DefaultOpen))\n\t{\n\t\tif (ImGui::Combo(\"source vec types\", (int*)&functionType, \"Whirl pool\\0plane wave\\0sum\\0Y shape\\0Two Whirl Pool\\0Periodic\\0\\0\")) {}\n\t\tif (ImGui::Checkbox(\"Fixed source center and dir\", &isFixedSource)) {}\n\n\t\tif (ImGui::CollapsingHeader(\"source whirl pool Info\"))\n\t\t{\n\t\t if (ImGui::InputInt(\"source singularity index 1\", &singIndSource)){}\n\t\t if (ImGui::InputDouble(\"source center 1 x: \", &sourceCenter1x)) {}\n\t\t ImGui::SameLine();\n\t\t if (ImGui::InputDouble(\"source center 1 y: \", &sourceCenter1y)) {}\n\n\t\t if (ImGui::InputInt(\"source singularity index 2\", &singIndSource1)){}\n\t\t if (ImGui::InputDouble(\"source center 2 x: \", &sourceCenter2x)) {}\n\t\t ImGui::SameLine();\n\t\t if (ImGui::InputDouble(\"source center 2 y: \", &sourceCenter2y)) {}\n\t\t}\n\n\t\tif (ImGui::CollapsingHeader(\"source plane wave Info\"))\n\t\t{\n\t\t if (ImGui::InputInt(\"source num waves\", &numWavesSource)){}\n\t\t if (ImGui::InputDouble(\"source dir x: \", &sourceDirx)) {}\n\t\t ImGui::SameLine();\n\t\t if (ImGui::InputDouble(\"source dir y: \", &sourceDiry)) {}\n\t\t}\n\n\t}\n\tif (ImGui::CollapsingHeader(\"target Vector Fields Info\", ImGuiTreeNodeFlags_DefaultOpen))\n\t{\n\t\tif (ImGui::Combo(\"target vec types\", (int*)&tarFunctionType, \"Whirl pool\\0plane wave\\0sum\\0Y shape\\0Two Whirl Pool\\0Periodic\\0\\0\")) {}\n\n\t\tif (ImGui::Checkbox(\"Fixed target center and dir\", &isFixedTar)) {}\n\t\tif (ImGui::CollapsingHeader(\"target whirl pool Info\"))\n\t\t{\n\t\t if (ImGui::InputInt(\"target singularity index 1\", &singIndTar)) {}\n\t\t if (ImGui::InputDouble(\"target center 1 x: \", &targetCenter1x)) {}\n\t\t ImGui::SameLine();\n\t\t if (ImGui::InputDouble(\"target center 1 y: \", &targetCenter1y)) {}\n\n\t\t if (ImGui::InputInt(\"target singularity index 2\", &singIndTar1)) {}\n\t\t if (ImGui::InputDouble(\"target center 2 x: \", &targetCenter2x)) {}\n\t\t ImGui::SameLine();\n\t\t if (ImGui::InputDouble(\"target center 2 y: \", &targetCenter2y)) {}\n\t\t}\n\n\t\tif (ImGui::CollapsingHeader(\"target plane wave Info\"))\n\t\t{\n\t\t if (ImGui::InputInt(\"target num waves\", &numWaveTar)){}\n\t\t if (ImGui::InputDouble(\"target dir x: \", &sourceDirx)) {}\n\t\t ImGui::SameLine();\n\t\t if (ImGui::InputDouble(\"target dir y: \", &sourceDiry)) {}\n\t\t}\n\n\n\t}\n\n\tif (ImGui::InputInt(\"num of frames\", &numFrames))\n\t{\n\t\tif (numFrames <= 0)\n\t\t\tnumFrames = 10;\n\t}\n\n\tif (ImGui::InputDouble(\"drag speed\", &dragSpeed))\n\t{\n\t\tif (dragSpeed <= 0)\n\t\t\tdragSpeed = 0.5;\n\t}\n\n\tif (ImGui::DragInt(\"current frame\", &curFrame, dragSpeed, 0, numFrames + 1))\n\t{\n\t\tupdateFieldsInView(curFrame);\n\t}\n\tif (ImGui::DragFloat(\"vec ratio\", &(vecratio), 0.005, 0, 1))\n\t{\n\t\tupdateFieldsInView(curFrame);\n\t}\n\tif (ImGui::CollapsingHeader(\"optimzation parameters\", ImGuiTreeNodeFlags_DefaultOpen))\n\t{\n\t\tif (ImGui::InputInt(\"num iterations\", &numIter))\n\t\t{\n\t\t\tif (numIter < 0)\n\t\t\t\tnumIter = 1000;\n\t\t}\n\t\tif (ImGui::InputDouble(\"grad tol\", &gradTol))\n\t\t{\n\t\t\tif (gradTol < 0)\n\t\t\t\tgradTol = 1e-6;\n\t\t}\n\t\tif (ImGui::InputDouble(\"x tol\", &xTol))\n\t\t{\n\t\t\tif (xTol < 0)\n\t\t\t\txTol = 0;\n\t\t}\n\t\tif (ImGui::InputDouble(\"f tol\", &fTol))\n\t\t{\n\t\t\tif (fTol < 0)\n\t\t\t\tfTol = 0;\n\t\t}\n\t\tif (ImGui::InputInt(\"quad order\", &quadOrder))\n\t\t{\n\t\t if (quadOrder <= 0 || quadOrder > 20)\n\t\t quadOrder = 4;\n\t\t}\n\t\tImGui::Checkbox(\"use upsampled mesh\", &isUseUpMesh);\n\n\t}\n\tif (ImGui::Combo(\"initialization types\", (int*)&initializationType, \"Random\\0Linear\\0Theoretical\\0\")) {}\n\n\tImGui::Checkbox(\"Try Optimization\", &isForceOptimize);\n\n\tif (ImGui::Button(\"update values\", ImVec2(-1, 0)))\n\t{\n\t\tdouble fixedx = 0;\n\t\tdouble fixedy = 0;\n\t\tEigen::Vector2d fixedv(1, 0);\n\t\t// source vector fields\n\t\tif(isFixedSource)\n\t\t{\n\t\t fixedx = sourceCenter1x;\n\t\t fixedy = sourceCenter1y;\n\t\t fixedv << sourceDirx, sourceDiry;\n\t\t fixedv *= numWavesSource * 2 * M_PI;\n\t\t}\n\t\tgenerateValues(functionType, sourceOmegaFields, sourceZvals, sourceTheoGradZvals, upsampledTheoZVals, singIndSource, singIndSource1, isFixedSource, fixedx, fixedy, fixedv);\n\t\t/*std::cout << \"triV: \\n\" << triV << std::endl;\n\n\t\tstd::cout << fixedv.transpose() << std::endl;\n\t\tfor (int i = 0; i < sourceOmegaFields.rows(); i++)\n\t\t{\n\t\t\tstd::cout << \"edge id: \" << i << \", vid: \" << triMesh.edgeVertex(i, 0) << \", zval: \" << sourceZvals[triMesh.edgeVertex(i, 0)] << \", \" << triMesh.edgeVertex(i, 1) << \" \" << sourceZvals[triMesh.edgeVertex(i, 1)] << \", w: \" << sourceOmegaFields(i) << std::endl;\n\t\t}*/\n\t\t\n\n\t\tif(isFixedTar)\n\t\t{\n\t\t fixedx = targetCenter1x;\n\t\t fixedy = targetCenter1y;\n\t\t fixedv << targetDirx, targetDiry;\n\t\t fixedv *= numWaveTar * 2 * M_PI;\n\t\t}\n\t\t// target vector fields\n\t\tgenerateValues(tarFunctionType, tarOmegaFields, tarZvals, tarTheoGradZvals, upsampledTarTheoZVals, singIndTar, singIndTar1, isFixedTar, fixedx, fixedy, fixedv);\n\n\t\t// update the theoretic ones\n\t\tupdateTheoMagnitudePhase(sourceZvals, tarZvals, sourceTheoGradZvals, tarTheoGradZvals, upsampledTheoZVals, upsampledTarTheoZVals, numFrames, theoAmpFieldsList, theoPhaseFieldsList, theoOmegaList, theoZList);\n\n\t\t// solve for the path from source to target\n\t\tsolveKeyFrames(sourceOmegaFields, tarOmegaFields, sourceZvals, tarZvals, numFrames, omegaList, zList);\n\t\t// get interploated amp and phase frames\n\t\tupdateMagnitudePhase(omegaList, zList, ampFieldsList, phaseFieldsList);\n\n\t\t// update amp max\n\t\tif (theoAmpFieldsList.size() > 0)\n\t\t{\n\t\t\tglobalAmpMax = theoAmpFieldsList[0].maxCoeff();\n\t\t\tfor (int i = 0; i < theoAmpFieldsList.size(); i++)\n\t\t\t{\n\t\t\t\tglobalAmpMax = std::max(theoAmpFieldsList[i].maxCoeff(), globalAmpMax);\n\t\t\t\tglobalAmpMax = std::max(ampFieldsList[i].maxCoeff(), globalAmpMax);\n\t\t\t}\n\t\t}\n\t\t\n\t\tupdateFieldsInView(curFrame);\n\t\t\t\n\t}\n\n\tImGui::PopItemWidth();\n}\n\n\n\n\nint main(int argc, char** argv)\n{\n\tinitialization();\n//\n//\tEigen::MatrixXd testV(3, 3);\n//\ttestV << 0, 0, 0,\n//\t\t1, 0, 0,\n//\t\t0, 1, 0;\n//\tEigen::MatrixXi testF(1, 3);\n//\ttestF << 0, 1, 2;\n//\n//\tMeshConnectivity testMesh(testF);\n//\n//\tEigen::MatrixXd testw(3, 3), testw1;\n//\ttestw << 1, -1, 0,\n//\t\t1, 2, 0,\n//\t\t-1, 0, 0;\n//\n//\ttestw1 = testw;\n//\ttestw1.block<3, 2>(0, 0).setRandom();\n//\n//\tEigen::Vector3d testbary;\n//\tstd::vector> testZvals(3), testZvals1(3);\n//\ttestZvals[0] = std::complex(0.1, 0.8);\n//\ttestZvals[1] = std::complex(0.7, 0.3);\n//\ttestZvals[2] = std::complex(0.34, 7.8);\n//\n//\ttestZvals1[0] = std::complex(0.5, 0.6);\n//\ttestZvals1[1] = std::complex(0.7, 0.4);\n//\ttestZvals1[2] = std::complex(0.4, 0.8);\n//\n//\n//\tEigen::Matrix edgew = vertexVec2IntrinsicHalfEdgeVec(testw, testV, testMesh);\n//\tEigen::Matrix edgew1 = vertexVec2IntrinsicHalfEdgeVec(testw1, testV, testMesh);\n//\n//\tfor (int i = 0; i < 3; i++)\n//\t{\n//\t int eid = testMesh.faceEdge(0, i);\n//\t\tstd::cout << \"eid: \" << eid << \", v0: \" << testMesh.edgeVertex(eid, 0) << \", v1: \" << testMesh.edgeVertex(eid, 1) << std::endl;\n//\t\tstd::cout << \"edge w: \" << edgew.row(eid) << std::endl;\n//\t}\n//\tint testqid = 3;\n//\tComputeZandZdot preModel(testV, testF, 4);\n//\ttestbary << 1 - preModel.getQuadPts()[testqid].u - preModel.getQuadPts()[testqid].v, preModel.getQuadPts()[testqid].u, preModel.getQuadPts()[testqid].v;\n//\n//\tEigen::VectorXd testFaceArea;\n//\tigl::doublearea(testV, testF, testFaceArea);\n//\ttestFaceArea /= 2;\n//\tIntrinsicFormula::ComputeZdotFromHalfEdgeOmega zdotmodel1(MeshConnectivity(testF), testFaceArea, 4, 0.1);\n//\n//\tdouble zdotnorm = zdotmodel1.computeZdotIntegration(testZvals, edgew, testZvals1, edgew1, NULL, NULL);\n//\tdouble zdotnorm1 = preModel.zDotSquareIntegration(testw.block<3, 2>(0, 0), testw1.block<3, 2>(0, 0), testZvals, testZvals1, 0.1, NULL, NULL);\n//\n//\tstd::cout << \"zdot: \" << zdotnorm << \", \" << \"zdot1: \" << zdotnorm1 << std::endl;\n//\n//\tIntrinsicFormula::IntrinsicKeyFrameInterpolationFromHalfEdge halfEdgeFormula(testMesh, testFaceArea, 50, 4, testZvals, edgew, testZvals1, edgew1);\n//\tEigen::VectorXd x;\n//\thalfEdgeFormula.convertList2Variable(x);\n//\tzdotnorm = halfEdgeFormula.computeEnergy(x);\n//\n//\tEigen::MatrixXd uptestV;\n//\tEigen::MatrixXi uptestF;\n//\n//\tstd::vector> testBary;\n// meshUpSampling(testV, testF, uptestV, uptestF, 2, NULL, NULL, &testBary);\n//\n// InterpolateKeyFrames interpModelTest(testV, testF, uptestV, uptestF, testBary, testw.block<3, 2>(0, 0), testw1.block<3, 2>(0, 0), testZvals, testZvals1, 50, 4, false);\n// interpModelTest.convertList2Variable(x);\n// zdotnorm1 = interpModelTest.computeEnergy(x);\n\n// std::cout << \"zdot: \" << zdotnorm << \", \" << \"zdot1: \" << zdotnorm1 << std::endl;\n//\tIntrinsicFormula::testZvalsFromHalfEdgeOmega(testbary, testZvals, edgew);\n//\tEigen::VectorXd faceArea;\n//\n//\tigl::doublearea(triV, triF, faceArea);\n//\tstd::vector> testZvals0(triV.rows()), testZvals1(triV.rows());\n//\tfor (int i = 0; i < triV.rows(); i++)\n//\t{\n//\t\tEigen::Vector2d randvec;\n//\t\trandvec.setRandom();\n//\t\ttestZvals0[i] = std::complex(randvec(0), randvec(1));\n//\n//\t\trandvec.setRandom();\n//\t\ttestZvals1[i] = std::complex(randvec(0), randvec(1));\n//\t}\n//\tEigen::MatrixXd edgew0, edgew1;\n//\tedgew0.setRandom(triMesh.nEdges(), 2);\n//\tedgew1.setRandom(triMesh.nEdges(), 2);\n//\n//\tIntrinsicFormula::ComputeZdotFromHalfEdgeOmega testmodel(triMesh, faceArea, 4, 1);\n//\ttestmodel.testZdotIntegrationPerface(testZvals0, edgew0, testZvals1, edgew1, 0);\n//\n//\tIntrinsicFormula::IntrinsicKeyFrameInterpolationFromHalfEdge halfedgemodel(triMesh, faceArea, 3, 4, testZvals0, edgew0, testZvals1, edgew1);\n//\tEigen::VectorXd testx;\n//\thalfedgemodel.convertList2Variable(testx);\n//\thalfedgemodel.testEnergy(testx);\n\n\t// Options\n polyscope::options::autocenterStructures = true;\n polyscope::view::windowWidth = 1024;\n polyscope::view::windowHeight = 1024;\n\n // Initialize polyscope\n polyscope::init();\n\n\n // Register the mesh with Polyscope\n polyscope::registerSurfaceMesh(\"input mesh\", triV, triF);\n\n\n\n // Add the callback\n polyscope::state::userCallback = callback;\n\n polyscope::options::groundPlaneHeightFactor = 0.25; // adjust the plane height\n // Show the gui\n polyscope::show();\n\n return 0;\n}", "meta": {"hexsha": "c52acf41de4d511dcd0151aa4a4a6e6a52fe8f41", "size": 41302, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "app/viewer2d/main.cpp", "max_stars_repo_name": "csyzzkdcz/PhaseInterpolation_polyscope", "max_stars_repo_head_hexsha": "4833a569f9eca1c222f7cdfd8e4aae3f03d8ad0b", "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": "app/viewer2d/main.cpp", "max_issues_repo_name": "csyzzkdcz/PhaseInterpolation_polyscope", "max_issues_repo_head_hexsha": "4833a569f9eca1c222f7cdfd8e4aae3f03d8ad0b", "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": "app/viewer2d/main.cpp", "max_forks_repo_name": "csyzzkdcz/PhaseInterpolation_polyscope", "max_forks_repo_head_hexsha": "4833a569f9eca1c222f7cdfd8e4aae3f03d8ad0b", "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.9099601594, "max_line_length": 375, "alphanum_fraction": 0.6506706697, "num_tokens": 13688, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802264851919, "lm_q2_score": 0.7025300698514777, "lm_q1q2_score": 0.5403019852340322}} {"text": "//==================================================================================================\n/*!\n @file\n\n @copyright 2016 NumScale SAS\n\n Distributed under the Boost Software License, Version 1.0.\n (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)\n*/\n//==================================================================================================\n#ifndef BOOST_SIMD_ARCH_COMMON_SCALAR_FUNCTION_TENPOWER_HPP_INCLUDED\n#define BOOST_SIMD_ARCH_COMMON_SCALAR_FUNCTION_TENPOWER_HPP_INCLUDED\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost { namespace simd { namespace ext\n{\n namespace bd = boost::dispatch;\n BOOST_DISPATCH_OVERLOAD ( tenpower_\n , (typename A0)\n , bd::cpu_\n , bd::scalar_< bd::int_ >\n )\n {\n using result_t = bd::as_floating_t;\n BOOST_FORCEINLINE result_t operator() ( A0 exp) const BOOST_NOEXCEPT\n {\n\n result_t result = One();\n result_t base = Ten();\n auto neg = is_ltz(exp);\n exp = boost::simd::abs(exp);\n while(exp)\n {\n if (is_odd(exp)) result *= base;\n exp >>= 1;\n base = sqr(base);\n }\n return neg ? rec(result) : result;\n }\n };\n\n BOOST_DISPATCH_OVERLOAD ( tenpower_\n , (typename A0)\n , bd::cpu_\n , bd::scalar_< bd::uint_ >\n )\n {\n using result_t = bd::as_floating_t;\n BOOST_FORCEINLINE result_t operator() ( A0 exp) const BOOST_NOEXCEPT\n {\n result_t result = One();\n result_t base = Ten();\n while(exp)\n {\n if (is_odd(exp)) result *= base;\n exp >>= 1;\n base = sqr(base);\n }\n return result;\n }\n };\n} } }\n\n\n#endif\n", "meta": {"hexsha": "0e61b51f3f310be0be5f49527034863e1bf215e4", "size": 2293, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "third_party/boost/simd/arch/common/scalar/function/tenpower.hpp", "max_stars_repo_name": "xmar/pythran", "max_stars_repo_head_hexsha": "dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2018-02-20T11:21:12.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-12T13:45:09.000Z", "max_issues_repo_path": "third_party/boost/simd/arch/common/scalar/function/tenpower.hpp", "max_issues_repo_name": "xmar/pythran", "max_issues_repo_head_hexsha": "dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "third_party/boost/simd/arch/common/scalar/function/tenpower.hpp", "max_forks_repo_name": "xmar/pythran", "max_forks_repo_head_hexsha": "dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2017-11-17T15:30:36.000Z", "max_forks_repo_forks_event_max_datetime": "2018-03-01T02:06:25.000Z", "avg_line_length": 29.7792207792, "max_line_length": 100, "alphanum_fraction": 0.5455734845, "num_tokens": 518, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802370707283, "lm_q2_score": 0.702530051167069, "lm_q1q2_score": 0.5403019783008803}} {"text": "#pragma once\n\n#include \n#include \n\nnamespace calotypes\n{\n\n/*! \\brief Boost-based reservoir sampling implementation. Best used when sampling\n * a medium subset. */\ntemplate\nvoid ReservoirSampling( unsigned int numItems, unsigned int subsetSize,\n\t\t\t\t\t\tstd::vector& inds, Engine& engine )\n{\n\tinds.resize( subsetSize );\n\tfor( unsigned int i = 0; i < subsetSize; i++ )\n\t{\n\t\tinds[i] = i;\n\t}\n\t\n\tfor( unsigned int i = subsetSize; i < numItems; i++ )\n\t{\n\t\tboost::random::uniform_int_distribution<> dist( 0, i ); // i inclusive\n\t\tunsigned int j = (unsigned int) dist( engine );\n\t\tstd::cout << \"j: \" << j << \" \";\n\t\tif( j < subsetSize )\n\t\t{\n\t\t\tinds[j] = i;\n\t\t}\n\t}\n\tstd::cout << std::endl;\n}\n\t\n/*! \\brief Boost-based brute force sampling implementation. Best used when\n * sampling a small subset. */\ntemplate\nvoid BitmapSampling( unsigned int numItems, unsigned int subsetSize,\n\t\t\t\t\t std::vector& inds, Engine& engine )\n{\n\tinds.resize( subsetSize );\n\t\n\tstd::vector bitmap( numItems, false );\n\tunsigned int count = 0;\n\tboost::random::uniform_int_distribution<> dist( 0, numItems - 1 );\n\twhile( count < subsetSize )\n\t{\n\t\tunsigned int j = (unsigned int) dist( engine );\n\t\tif( bitmap[j] ) { continue; }\n\t\tbitmap[j] = true;\n\t\tinds[count] = j;\n\t\tcount++;\n\t}\n\t\n}\n\t\n} // end namespace calotypes\n", "meta": {"hexsha": "6446d26b802712ac5a574bfffdacc83c09a62efd", "size": 1421, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/calotypes/SubsetSamplers.hpp", "max_stars_repo_name": "Humhu/calotypes", "max_stars_repo_head_hexsha": "a05a809b3b27983332c24d8fb04cb71f47e96763", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-01-18T14:59:39.000Z", "max_stars_repo_stars_event_max_datetime": "2019-01-18T14:59:39.000Z", "max_issues_repo_path": "include/calotypes/SubsetSamplers.hpp", "max_issues_repo_name": "Humhu/calotypes", "max_issues_repo_head_hexsha": "a05a809b3b27983332c24d8fb04cb71f47e96763", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/calotypes/SubsetSamplers.hpp", "max_forks_repo_name": "Humhu/calotypes", "max_forks_repo_head_hexsha": "a05a809b3b27983332c24d8fb04cb71f47e96763", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.9298245614, "max_line_length": 81, "alphanum_fraction": 0.6713581985, "num_tokens": 380, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802264851919, "lm_q2_score": 0.7025300573952052, "lm_q1q2_score": 0.5403019756541593}} {"text": "#include \n#include \nusing namespace boost::multiprecision;\nusing namespace std;\nint main()\n{\n int t;\n cin >> t;\n while (t--)\n {\n int n;\n cpp_int fact = 1;\n cin >> n;\n while (n != 0)\n {\n fact *= n--;\n }\n cout << fact << endl;\n }\n return 0;\n}", "meta": {"hexsha": "537c6bb7d88c2534bdc72eca1853c6ca0d801c72", "size": 367, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Practice Programs/small_factorials1.cpp", "max_stars_repo_name": "SR-Sunny-Raj/CPP_Language_Programs", "max_stars_repo_head_hexsha": "3e10a365187f70cc473c5b62155ff51dc12e38b8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2021-02-04T17:59:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-29T17:21:42.000Z", "max_issues_repo_path": "Practice Programs/small_factorials1.cpp", "max_issues_repo_name": "SR-Sunny-Raj/CPP_Language_Programs", "max_issues_repo_head_hexsha": "3e10a365187f70cc473c5b62155ff51dc12e38b8", "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": "Practice Programs/small_factorials1.cpp", "max_forks_repo_name": "SR-Sunny-Raj/CPP_Language_Programs", "max_forks_repo_head_hexsha": "3e10a365187f70cc473c5b62155ff51dc12e38b8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2021-10-02T14:38:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-05T06:19:22.000Z", "avg_line_length": 17.4761904762, "max_line_length": 43, "alphanum_fraction": 0.4741144414, "num_tokens": 97, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7799929002541067, "lm_q2_score": 0.6926419894793248, "lm_q1q2_score": 0.540255834211753}} {"text": "#ifndef HAMILTONIANS_XYZNNNSTO2_HPP\n#define HAMILTONIANS_XYZNNNSTO2_HPP\n#include \n#include \n\n/* Stoquastic for |a|, |b| > 1*/\nclass XYZNNNSto2\n{\nprivate:\n\tint n_;\n\tdouble a_;\n\tdouble b_;\n\tconstexpr static double J1 = -1.0;\n\tconstexpr static double J2 = -1.0;\npublic:\n\n\tXYZNNNSto2(int n, double a, double b)\n\t\t: n_(n), a_(a), b_(b)\n\t{\n\t}\n\n\tnlohmann::json params() const\n\t{\n\t\treturn nlohmann::json\n\t\t{\n\t\t\t{\"name\", \"XYZNNNSto2\"},\n\t\t\t{\"n\", n_},\n\t\t\t{\"a\", a_},\n\t\t\t{\"b\", b_}\n\t\t};\n\t}\n\t\n\ttemplate\n\ttypename State::Scalar operator()(const State& smp) const\n\t{\n\t\ttypename State::Scalar s = 0.0;\n\t\t//Nearest-neighbor\n\t\tfor(int i = 0; i < n_; i++)\n\t\t{\n\t\t\tdouble yysign = -smp.sigmaAt(i)*smp.sigmaAt((i+1)%n_);\n\t\t\ts += -J1*b_*yysign; //zz\n\t\t\ts += J1*(a_+1.0*yysign)*smp.ratio(i, (i+1)%n_); //xx+yy\n\t\t}\n\t\t//Next-nearest-neighbor\n\t\tfor(int i = 0; i < n_; i++)\n\t\t{\n\t\t\tdouble yysign = -smp.sigmaAt(i)*smp.sigmaAt((i+2)%n_);\n\t\t\ts += -J2*a_*yysign; //zz\n\t\t\ts += J2*(b_+1.0*yysign)*smp.ratio(i, (i+2)%n_); //xx+yy\n\t\t}\n\t\treturn s;\n\t}\n\t\n\tstd::map operator()(uint32_t col) const\n\t{\n\t\tstd::map m;\n\t\tfor(int i = 0; i < n_; i++)\n\t\t{\n\t\t\tint b1 = (col >> i) & 1;\n\t\t\tint b2 = (col >> ((i+1)%n_)) & 1;\n\t\t\tint sgn = (1-2*b1)*(1-2*b2);\n\t\t\tlong long int x = (1 << i) | (1 << ((i+1)%(n_)));\n\t\t\tm[col ^ x] += J1*(a_ - 1.0*sgn);\n\t\t\tm[col] += J1*b_*sgn;\n\t\t}\n\t\tfor(int i = 0; i < n_; i++)\n\t\t{\n\t\t\tint b1 = (col >> i) & 1;\n\t\t\tint b2 = (col >> ((i+2)%n_)) & 1;\n\t\t\tint sgn = (1-2*b1)*(1-2*b2);\n\t\t\tlong long int x = (1 << i) | (1 << ((i+2)%(n_)));\n\t\t\tm[col ^ x] += J2*(b_ - sgn*1.0);\n\t\t\tm[col] += J2*a_*sgn;\n\t\t}\n\t\treturn m;\n\t}\n};\n#endif//HAMILTONIANS_XYZNNNSTO2_HPP\n", "meta": {"hexsha": "d37a995e7494f0dbd527273a3a12efb74406d6f1", "size": 1703, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "Yannq/Hamiltonians/XYZSto2.hpp", "max_stars_repo_name": "cecri/yannq", "max_stars_repo_head_hexsha": "b78c1f86a255059f06b34dd5e538449e7261d0ee", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Yannq/Hamiltonians/XYZSto2.hpp", "max_issues_repo_name": "cecri/yannq", "max_issues_repo_head_hexsha": "b78c1f86a255059f06b34dd5e538449e7261d0ee", "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": "Yannq/Hamiltonians/XYZSto2.hpp", "max_forks_repo_name": "cecri/yannq", "max_forks_repo_head_hexsha": "b78c1f86a255059f06b34dd5e538449e7261d0ee", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.5569620253, "max_line_length": 58, "alphanum_fraction": 0.5408103347, "num_tokens": 759, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577681049901037, "lm_q2_score": 0.6297746143530797, "lm_q1q2_score": 0.5402005775245146}} {"text": "// Boost.Geometry (aka GGL, Generic Geometry Library)\n\n// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.\n\n// Use, modification and distribution is subject to the Boost Software License,\n// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_LINE_LINE_INTERSECTION_HPP\n#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_LINE_LINE_INTERSECTION_HPP\n\n\n#include \n\nnamespace boost { namespace geometry\n{\n\n\n#ifndef DOXYGEN_NO_DETAIL\nnamespace detail { namespace buffer\n{\n\n\n// TODO: once change this to proper strategy\n// It is different from current segment intersection because these are not segments but lines\n// If we have the Line concept, we can create a strategy\ntemplate \nstruct line_line_intersection\n{\n template \n static inline A det(A const& a, B const& b, C const& c, D const& d)\n {\n return a * d - b * c;\n }\n\n static inline bool apply(Line1 const& line1, Line2 const& line2, Point& p)\n {\n // See http://mathworld.wolfram.com/Line-LineIntersection.html\n typedef typename coordinate_type::type coordinate_type;\n coordinate_type x1 = get<0,0>(line1), y1 = get<0,1>(line1);\n coordinate_type x2 = get<1,0>(line1), y2 = get<1,1>(line1);\n coordinate_type x3 = get<0,0>(line2), y3 = get<0,1>(line2);\n coordinate_type x4 = get<1,0>(line2), y4 = get<1,1>(line2);\n\n coordinate_type denominator = det(x1 - x2, y1 - y2, x3 - x4, y3 - y4);\n\n // TODO: use something else then denominator (sides?) to determine this.\n\n // If denominator is zero, segments are parallel.\n // We have context information, so know that it should then\n // be the case that line1.p2 == line2.p1, and that is the\n // intersection point.\n if (geometry::math::equals(denominator, 0.0))\n {\n set<0>(p, x2);\n set<1>(p, y2);\n return false;\n }\n\n coordinate_type d1 = det(x1, y1, x2, y2);\n coordinate_type d2 = det(x3, y3, x4, y4);\n coordinate_type px = det(d1, x1 - x2, d2, x3 - x4) / denominator;\n coordinate_type py = det(d1, y1 - y2, d2, y3 - y4) / denominator;\n\n set<0>(p, px);\n set<1>(p, py);\n\n#ifdef BOOST_GEOMETRY_DEBUG_BUFFER\n if (geometry::math::abs(denominator) < 1.0e-7)\n {\n std::cout << \"small \" << denominator << std::endl;\n }\n#endif\n return geometry::math::abs(denominator) > 1.0e-7;\n }\n};\n\n\n}} // namespace detail::buffer\n#endif // DOXYGEN_NO_DETAIL\n\n\n}} // namespace boost::geometry\n\n\n#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_LINE_LINE_INTERSECTION_HPP\n", "meta": {"hexsha": "d01c75877dd9c3733924f27c481bbb0ddbb09c4a", "size": 2843, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "boost/geometry/extensions/algorithms/buffer/line_line_intersection.hpp", "max_stars_repo_name": "ballisticwhisper/boost", "max_stars_repo_head_hexsha": "f72119ab640b564c4b983bd457457046b52af9ee", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2015-01-02T14:24:56.000Z", "max_stars_repo_stars_event_max_datetime": "2015-01-02T14:25:17.000Z", "max_issues_repo_path": "boost/geometry/extensions/algorithms/buffer/line_line_intersection.hpp", "max_issues_repo_name": "ballisticwhisper/boost", "max_issues_repo_head_hexsha": "f72119ab640b564c4b983bd457457046b52af9ee", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2019-01-13T23:45:51.000Z", "max_issues_repo_issues_event_max_datetime": "2019-02-03T08:13:26.000Z", "max_forks_repo_path": "boost/geometry/extensions/algorithms/buffer/line_line_intersection.hpp", "max_forks_repo_name": "ballisticwhisper/boost", "max_forks_repo_head_hexsha": "f72119ab640b564c4b983bd457457046b52af9ee", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2016-05-29T13:41:15.000Z", "max_forks_repo_forks_event_max_datetime": "2016-05-29T13:41:15.000Z", "avg_line_length": 32.6781609195, "max_line_length": 93, "alphanum_fraction": 0.6577558917, "num_tokens": 781, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677660619633, "lm_q2_score": 0.6370308082623217, "lm_q1q2_score": 0.5401815913948479}} {"text": "#ifndef mesh_reader\n#define mesh_reader\n\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace Eigen;\ntypedef Matrix MatrixXi;\n\nnamespace mesh\n{\n\n MatrixXd read_vertices(std::string location)\n {\n /* index # is vertix id, contains x and y\n coordinate respectively of vertix, and\n a flag, 1 if boundary point 0 if not */\n std::ifstream infile(location);\n std::string line;\n double a, b, c, d, line_nb = 0;\n std::getline(infile, line);\n std::istringstream iss(line);\n iss >> a >> b >> c;\n int nb_nodes = a;\n MatrixXd vertices(nb_nodes, 3);\n while (std::getline(infile, line))\n {\n std::istringstream iss(line);\n if (iss >> a >> b >> c >> d)\n {\n vertices(line_nb, 0) = b/1000.;\n vertices(line_nb, 1) = c/1000.;\n vertices(line_nb, 2) = d;\n }\n else\n {\n break;\n }\n line_nb += 1;\n }\n return vertices;\n }\n\n MatrixXd read_triangles(MatrixXd& vertices,std::string location)\n {\n /* index # is triangle id, contains\n the 3 vertix id's of the corner nodes and\n the area of the triangle, calculated using\n the vertices matrix */\n std::ifstream infile(location);\n std::string line;\n int a, b, c, d, line_nb = 0;\n std::getline(infile, line);\n std::istringstream iss(line);\n iss >> a >> b >> c;\n int nb_triangles = a;\n MatrixXd triangles(nb_triangles, 4);\n while (std::getline(infile, line))\n {\n std::istringstream iss(line);\n if (iss >> a >> b >> c >> d)\n {\n triangles(line_nb, 0) = b-1;\n triangles(line_nb, 1) = c-1;\n triangles(line_nb, 2) = d-1;\n triangles(line_nb, 3) = 0.5*fabs(vertices(b-1, 0)*(vertices(c-1, 1) - vertices(d-1, 1)) +\n vertices(c-1, 0)*(vertices(d-1, 1) - vertices(b-1, 1)) +\n vertices(d-1, 0)*(vertices(b-1, 1) - vertices(c-1, 1)));\n }\n else\n {\n break;\n }\n line_nb += 1;\n }\n return triangles;\n }\n\n MatrixXi read_boundaries(MatrixXd& vertices,std::string location) {\n /* index # is triangle id, contains\n the 3 vertix id's of the corner nodes and\n the area of the triangle, calculated using\n the vertices matrix */\n std::ifstream infile(location);\n std::string line;\n int a, b, c, d, count = 0;\n std::getline(infile, line);\n std::getline(infile, line);\n std::istringstream iss(line);\n iss >> a >> b;\n int nb_boundaries = a;\n MatrixXi boundaries(nb_boundaries, 2);\n while (std::getline(infile, line))\n {\n std::istringstream iss(line);\n if (iss >> a >> b >> c >> d)\n {\n if (vertices(b-1, 0) != 0 || vertices(c-1, 0) != 0) {\n boundaries(count, 0) = b-1;\n boundaries(count, 1) = c-1;\n count += 1;\n }\n }\n else\n {\n break;\n }\n }\n\n MatrixXi boundaries_red(count, 2);\n boundaries_red = boundaries.block(0,0,count,2);\n return boundaries_red;\n }\n\n void write_result(VectorXd& u,VectorXd& v)\n {\n std::ofstream output_u;\n std::ofstream output_v;\n output_u.open(\"../mesh/result_u.out\");\n output_u << u;\n output_v.open(\"../mesh/result_v.out\");\n output_v << v;\n output_u.close();\n output_v.close();\n }\n\n}\n\n\n#endif\n", "meta": {"hexsha": "098ccec42002214b273287e714375e5fcde57598", "size": 3850, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "cpp/mesh_reader_eigen.hpp", "max_stars_repo_name": "PieterAppeltans/ProjectWIT", "max_stars_repo_head_hexsha": "081e2537e2e9d9b92e50fdca2cb44039db5ffa59", "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": "cpp/mesh_reader_eigen.hpp", "max_issues_repo_name": "PieterAppeltans/ProjectWIT", "max_issues_repo_head_hexsha": "081e2537e2e9d9b92e50fdca2cb44039db5ffa59", "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": "cpp/mesh_reader_eigen.hpp", "max_forks_repo_name": "PieterAppeltans/ProjectWIT", "max_forks_repo_head_hexsha": "081e2537e2e9d9b92e50fdca2cb44039db5ffa59", "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": 28.3088235294, "max_line_length": 105, "alphanum_fraction": 0.4963636364, "num_tokens": 944, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677506936878, "lm_q2_score": 0.6370307944803832, "lm_q1q2_score": 0.5401815699181435}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"image_ppm.h\"\n#include \n#include \n\nusing namespace std;\nusing namespace Eigen;\n\ntypedef Matrix MatrixImg;\ntypedef Matrix TempMatrixImg;\ntypedef Vector ImgLine;\ntypedef Vector TempImgLine;\n//typedef Matrix FlattenedImages;\n\n\n\nunsigned char max(u_char a, u_char b){\n if (ab) return b;\n else return a;\n}\n\n\ndouble max(double a, double b){\n if (ab) return b;\n else return a;\n}\n\n\n\n\nvector projectOnEigenSpace(vector eigenfaces, TempImgLine imToProj,int K){\n vector res = vector();\n for (int i=0;i eigenfaces;\n int K =100; int nH;int nW;\n for (int i=0; i projs = projectOnEigenSpace(eigenfaces,fixLine,K);\n double sum=0.0;\n for (int i=0;i\n#include \n#include \n#include \n\nnamespace stan {\nnamespace math {\n\n/**\n *\n \\f[\n \\mbox{bessel\\_first\\_kind}(v, x) =\n \\begin{cases}\n J_v(x) & \\mbox{if } -\\infty\\leq x \\leq \\infty \\\\[6pt]\n \\textrm{error} & \\mbox{if } x = \\textrm{NaN}\n \\end{cases}\n \\f]\n\n \\f[\n \\frac{\\partial\\, \\mbox{bessel\\_first\\_kind}(v, x)}{\\partial x} =\n \\begin{cases}\n \\frac{\\partial\\, J_v(x)}{\\partial x} & \\mbox{if } -\\infty\\leq x\\leq \\infty\n \\\\[6pt] \\textrm{error} & \\mbox{if } x = \\textrm{NaN} \\end{cases} \\f]\n\n \\f[\n J_v(x)=\\left(\\frac{1}{2}x\\right)^v\n \\sum_{k=0}^\\infty \\frac{\\left(-\\frac{1}{4}x^2\\right)^k}{k!\\, \\Gamma(v+k+1)}\n \\f]\n\n \\f[\n \\frac{\\partial \\, J_v(x)}{\\partial x} = \\frac{v}{x}J_v(x)-J_{v+1}(x)\n \\f]\n *\n */\ntemplate * = nullptr>\ninline T2 bessel_first_kind(int v, const T2 z) {\n check_not_nan(\"bessel_first_kind\", \"z\", z);\n return boost::math::cyl_bessel_j(v, z);\n}\n\n/**\n * Enables the vectorised application of the bessel first kind function, when\n * the first and/or second arguments are containers.\n *\n * @tparam T1 type of first input\n * @tparam T2 type of second input\n * @param a First input\n * @param b Second input\n * @return Bessel first kind function applied to the two inputs.\n */\ntemplate * = nullptr,\n require_not_var_matrix_t* = nullptr>\ninline auto bessel_first_kind(const T1& a, const T2& b) {\n return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {\n return bessel_first_kind(c, d);\n });\n}\n\n} // namespace math\n} // namespace stan\n#endif\n", "meta": {"hexsha": "706960afed3469a86db4c99092f51ab186902007", "size": 1861, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "stan/math/prim/fun/bessel_first_kind.hpp", "max_stars_repo_name": "LaudateCorpus1/math", "max_stars_repo_head_hexsha": "990a66b3cccd27a5fd48626360bb91093a48278b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "stan/math/prim/fun/bessel_first_kind.hpp", "max_issues_repo_name": "LaudateCorpus1/math", "max_issues_repo_head_hexsha": "990a66b3cccd27a5fd48626360bb91093a48278b", "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": "stan/math/prim/fun/bessel_first_kind.hpp", "max_forks_repo_name": "LaudateCorpus1/math", "max_forks_repo_head_hexsha": "990a66b3cccd27a5fd48626360bb91093a48278b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.6307692308, "max_line_length": 79, "alphanum_fraction": 0.6577109081, "num_tokens": 639, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031738057795403, "lm_q2_score": 0.6723316991792861, "lm_q1q2_score": 0.5399992095760523}} {"text": "// SPDX-License-Identifier: MIT\n// Copyright (c) 2019-2021 Thomas Vanderbruggen \n\n#ifndef SCICPP_POLYNOMIALS_POLYNOMIAL\n#define SCICPP_POLYNOMIALS_POLYNOMIAL\n\n#include \"scicpp/core/equal.hpp\"\n#include \"scicpp/core/functional.hpp\"\n#include \"scicpp/core/macros.hpp\"\n#include \"scicpp/core/meta.hpp\"\n#include \"scicpp/core/numeric.hpp\"\n#include \"scicpp/linalg/solve.hpp\"\n#include \"scicpp/linalg/utils.hpp\"\n#include \"scicpp/signal/convolve.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#include \n\nnamespace scicpp::polynomial {\n\n//---------------------------------------------------------------------------------\n// Polyval\n//---------------------------------------------------------------------------------\n\ntemplate \nauto polyval(T &&x, const Array &coeffs) {\n if constexpr (meta::is_iterable_v) {\n return map([&](auto v) { return polyval(v, coeffs); },\n std::forward(x));\n } else {\n using scalar_t = std::remove_reference_t;\n static_assert(std::is_same_v);\n\n // https://en.wikipedia.org/wiki/Horner%27s_method\n auto res = scalar_t{0};\n\n std::for_each(coeffs.crbegin(), coeffs.crend(), [&](auto c) {\n res = std::fma(res, x, c);\n });\n\n return res;\n }\n}\n\n//---------------------------------------------------------------------------------\n// polyadd\n//---------------------------------------------------------------------------------\n\nnamespace detail {\n\ntemplate \nvoid add_arrays(const U &P1, const V &P2, W &P) {\n using T = typename U::value_type;\n static_assert(std::is_same_v);\n static_assert(std::is_same_v);\n\n if (P1.size() <= P2.size()) {\n scicpp_require(P.size() >= P2.size());\n std::transform(\n P1.cbegin(), P1.cend(), P2.cbegin(), P.begin(), std::plus());\n std::copy(P2.cbegin() + int(P1.size()),\n P2.cend(),\n P.begin() + int(P1.size()));\n } else {\n scicpp_require(P.size() >= P1.size());\n std::transform(\n P2.cbegin(), P2.cend(), P1.cbegin(), P.begin(), std::plus());\n std::copy(P1.cbegin() + int(P2.size()),\n P1.cend(),\n P.begin() + int(P2.size()));\n }\n}\n\n} // namespace detail\n\ntemplate \nauto polyadd(const std::array &P1, const std::array &P2) {\n std::array N ? M : N)> P{};\n detail::add_arrays(P1, P2, P);\n return P;\n}\n\ntemplate \nauto polyadd(const std::vector &P1, const std::vector &P2) {\n std::vector P(P1.size() > P2.size() ? P1.size() : P2.size());\n detail::add_arrays(P1, P2, P);\n return P;\n}\n\n//---------------------------------------------------------------------------------\n// polysub\n//---------------------------------------------------------------------------------\n\nnamespace detail {\n\ntemplate \nvoid sub_arrays(const U &P1, const V &P2, W &P) {\n using T = typename U::value_type;\n static_assert(std::is_same_v);\n static_assert(std::is_same_v);\n\n if (P1.size() <= P2.size()) {\n scicpp_require(P.size() >= P2.size());\n std::transform(\n P1.cbegin(), P1.cend(), P2.cbegin(), P.begin(), std::minus());\n std::transform(P2.cbegin() + int(P1.size()),\n P2.cend(),\n P.begin() + int(P1.size()),\n [](auto v) { return -v; });\n } else {\n scicpp_require(P.size() >= P1.size());\n std::transform(P2.cbegin(),\n P2.cend(),\n P1.cbegin(),\n P.begin(),\n [](auto v2, auto v1) { return v1 - v2; });\n std::copy(P1.cbegin() + int(P2.size()),\n P1.cend(),\n P.begin() + int(P2.size()));\n }\n}\n\n} // namespace detail\n\ntemplate \nauto polysub(const std::array &P1, const std::array &P2) {\n std::array N ? M : N)> P{};\n detail::sub_arrays(P1, P2, P);\n return P;\n}\n\ntemplate \nauto polysub(const std::vector &P1, const std::vector &P2) {\n std::vector P(P1.size() > P2.size() ? P1.size() : P2.size());\n detail::sub_arrays(P1, P2, P);\n return P;\n}\n\n//---------------------------------------------------------------------------------\n// polymul\n//---------------------------------------------------------------------------------\n\ntemplate \nauto polymul(const U &P1, const V &P2) {\n return signal::convolve(P1, P2);\n}\n\n// Specialization for the default convolution method\ntemplate \nauto polymul(const U &P1, const V &P2) {\n return polymul(P1, P2);\n}\n\n//---------------------------------------------------------------------------------\n// polydiv\n//---------------------------------------------------------------------------------\n\nnamespace detail {\n\n// https://stackoverflow.com/questions/44770632/fft-division-for-fast-polynomial-division\n// http://web.cs.iastate.edu/~cs577/handouts/polydivide.pdf\n\ntemplate \nconstexpr auto polydiv_impl(const U &u, const V &v) {\n using T = typename U::value_type;\n static_assert(std::is_same_v);\n\n auto tmp(u);\n const auto m = signed_size_t(u.size()) - 1;\n const auto n = signed_size_t(v.size()) - 1;\n const auto scale = T{1} / v[std::size_t(n)];\n\n for (signed_size_t k = m - n; k >= 0; --k) {\n const auto d = scale * tmp[std::size_t(n + k)];\n\n for (signed_size_t j = n + k - 1; j >= k; --j) {\n tmp[std::size_t(j)] -= d * v[std::size_t(j - k)];\n }\n }\n\n return tmp;\n}\n\n} // namespace detail\n\ntemplate \nconstexpr auto polydiv(const std::array &u, const std::array &v) {\n static_assert(M > 0);\n static_assert(N > 0);\n\n if constexpr (N == 1) {\n using namespace scicpp::operators;\n return std::make_tuple(u / v[0], std::array{});\n } else if constexpr (M < N) {\n return std::make_tuple(std::array{}, u);\n } else {\n const auto tmp = detail::polydiv_impl(u, v);\n\n std::array q{};\n std::array r{};\n std::move(tmp.begin(), tmp.begin() + r.size(), r.begin());\n std::move(tmp.begin() + r.size(), tmp.end(), q.begin());\n return std::make_tuple(q, r);\n }\n}\n\ntemplate \nauto polydiv(const std::vector &u, const std::vector &v) {\n scicpp_require(!u.empty());\n scicpp_require(!v.empty());\n\n if (v.size() == 1) {\n using namespace scicpp::operators;\n return std::make_tuple(u / v[0], std::vector(1, T{0}));\n }\n\n if (u.size() < v.size()) {\n return std::make_tuple(std::vector(1, T{0}), u);\n }\n\n const auto tmp = detail::polydiv_impl(u, v);\n const auto len = signed_size_t(v.size()) - 1;\n\n return std::make_tuple(\n std::vector(std::make_move_iterator(tmp.begin() + len),\n std::make_move_iterator(tmp.end())),\n std::vector(std::make_move_iterator(tmp.begin()),\n std::make_move_iterator(tmp.begin() + len)));\n}\n\n//---------------------------------------------------------------------------------\n// polymulx\n//---------------------------------------------------------------------------------\n\ntemplate \nauto polymulx(const std::array &P) {\n std::array res{};\n std::copy(P.cbegin(), P.cend(), res.begin() + 1);\n return res;\n}\n\ntemplate \nauto polymulx(const std::vector &P) {\n std::vector res(P.size() + 1);\n std::copy(P.cbegin(), P.cend(), res.begin() + 1);\n return res;\n}\n\ntemplate \nauto polymulx(std::vector &&P) {\n P.push_back(T{0});\n std::rotate(P.rbegin(), P.rbegin() + 1, P.rend());\n return std::move(P);\n}\n\n//---------------------------------------------------------------------------------\n// polypow\n//---------------------------------------------------------------------------------\n\n// https://en.wikipedia.org/wiki/Exponentiation_by_squaring\n// - Recursive implementation is used for fixed size arrays (std::array).\n// - Iterative implementation is used for dynamic size arrays (std::vector).\n\ntemplate \nauto polypow(const std::array &P) {\n // Return a std::array\n if constexpr (pow == 0) {\n return std::array{T{1}};\n } else if constexpr (pow == 1) {\n return std::array{P};\n } else {\n if constexpr (pow % 2 == 0) {\n return polypow(polymul(P, P));\n } else {\n return polymul(P, polypow<(pow - 1) / 2>(polymul(P, P)));\n }\n }\n}\n\ntemplate \nauto polypow(const std::vector &P, std::size_t pow) {\n if (pow == 0) {\n return std::vector(1, T{1});\n } else if (pow == 1) {\n return std::vector(P.cbegin(), P.cend());\n }\n\n std::vector x(P.cbegin(), P.cend());\n std::vector y(1, T(1));\n x.reserve(pow * (P.size() - 1) + 1);\n y.reserve(pow * (P.size() - 1) + 1);\n\n while (pow > 1) {\n if (pow % 2 == 1) {\n y = std::move(polymul(x, y));\n }\n\n pow = pow / 2;\n x = std::move(polymul(x, x));\n }\n\n return polymul(x, y);\n}\n\n// Specialization for the default convolution method (DIRECT)\ntemplate \nauto polypow(const std::vector &P, std::size_t pow) {\n return polypow(P, pow);\n}\n\n//---------------------------------------------------------------------------------\n// polyder\n//---------------------------------------------------------------------------------\n\nnamespace detail {\n\ntemplate \nconstexpr auto polyder_once(const std::array &P) {\n static_assert(N >= 1);\n std::array res{};\n\n for (std::size_t i = 0; i < res.size(); ++i) {\n res[i] = T(N - 1 - i) * P[i];\n }\n\n return res;\n}\n\ntemplate \nvoid polyder_once(std::vector &P) {\n scicpp_require(P.size() >= 1);\n const auto N = P.size();\n\n for (std::size_t i = 0; i < (N - 1); ++i) {\n P[i] *= T(N - 1 - i);\n }\n\n P.resize(N - 1);\n}\n\n} // namespace detail\n\ntemplate \nconstexpr auto polyder(const std::array &P) {\n static_assert(m >= 0);\n\n if constexpr (m == 0) {\n return std::array{P};\n } else if constexpr (m >= N) {\n return std::array{};\n } else {\n return polyder(detail::polyder_once(P));\n }\n}\n\ntemplate \nconstexpr auto polyder(const std::array &P) {\n return polyder<1>(P);\n}\n\ntemplate \nauto polyder(const std::vector &P, signed_size_t m = 1) {\n scicpp_require(m >= 0);\n\n if (m == 0) {\n return std::vector(P);\n }\n\n if (m >= int(P.size())) {\n return std::vector(0);\n }\n\n std::vector res(P);\n\n while (m--) {\n detail::polyder_once(res);\n }\n\n return res;\n}\n\n//---------------------------------------------------------------------------------\n// polyint\n//---------------------------------------------------------------------------------\n\nnamespace detail {\n\ntemplate \nconstexpr auto polyint_once(const std::array &P) {\n std::array res{};\n\n for (std::size_t i = 0; i < N; ++i) {\n res[i + 1] = P[i] / T(i + 1);\n }\n\n return res;\n}\n\ntemplate \nvoid polyint_once(std::vector &P) {\n const auto N = P.size();\n P.resize(N + 1);\n\n for (signed_size_t i = signed_size_t(N) - 1; i >= 0; --i) {\n P[std::size_t(i) + 1] = P[std::size_t(i)] / T(i + 1);\n }\n\n P[0] = T{0};\n}\n\n} // namespace detail\n\ntemplate \nconstexpr auto polyint(const std::array &P) {\n static_assert(N > 0);\n static_assert(m >= 0);\n\n if constexpr (m == 0) {\n return std::array{P};\n } else {\n return polyint(detail::polyint_once(P));\n }\n}\n\ntemplate \nconstexpr auto polyint(const std::array &P) {\n return polyint<1>(P);\n}\n\ntemplate \nauto polyint(const std::vector &P, signed_size_t m = 1) {\n scicpp_require(P.size() > 0);\n scicpp_require(m >= 0);\n\n if (m == 0) {\n return std::vector(P);\n }\n\n std::vector res(P);\n res.reserve(P.size() + std::size_t(m));\n\n while (m--) {\n detail::polyint_once(res);\n }\n\n return res;\n}\n\n//---------------------------------------------------------------------------------\n// polycompanion\n//---------------------------------------------------------------------------------\n\ntemplate \nauto polycompanion(const std::array &P) {\n constexpr int deg = N - 1;\n Eigen::Matrix res{};\n res.setZero();\n res.diagonal(-1).setOnes();\n res.col(deg - 1) = -linalg::to_eigen_array(P) / P[deg];\n return res;\n}\n\ntemplate \nauto polycompanion(const std::vector &P) {\n const int deg = int(P.size()) - 1;\n Eigen::Matrix res(deg, deg);\n res.setZero();\n res.diagonal(-1).setOnes();\n res.col(deg - 1) = -linalg::to_eigen_matrix(P, deg) / P[std::size_t(deg)];\n return res;\n}\n\n//---------------------------------------------------------------------------------\n// polyroots\n//---------------------------------------------------------------------------------\n\ntemplate \nauto polyroots(const Array &P) {\n return linalg::to_std_container(polycompanion(P).eigenvalues());\n}\n\n//---------------------------------------------------------------------------------\n// polyvander\n//---------------------------------------------------------------------------------\n\nnamespace detail {\n\ntemplate \nvoid polyvander_filler(Matrix &res, const Vector &x) {\n static_assert(meta::is_eigen_matrix_v);\n\n res.col(0).setOnes();\n res.col(1) = linalg::to_eigen_array(x);\n\n for (int i = 2; i < res.cols(); ++i) {\n res.col(i) = res.col(i - 1).array() * res.col(1).array();\n }\n}\n\n} // namespace detail\n\ntemplate \nauto polyvander(const std::array &x) {\n Eigen::Matrix res{};\n detail::polyvander_filler(res, x);\n return res;\n}\n\ntemplate \nauto polyvander(const std::vector &x, int deg) {\n Eigen::Matrix res(int(x.size()),\n deg + 1);\n detail::polyvander_filler(res, x);\n return res;\n}\n\n//---------------------------------------------------------------------------------\n// polyfit\n//---------------------------------------------------------------------------------\n\ntemplate \nauto polyfit(const std::array &x, const std::array &y) {\n return linalg::lstsq(polyvander(x), y);\n}\n\ntemplate \nauto polyfit(const std::vector &x, const std::vector &y, int deg) {\n return linalg::lstsq(polyvander(x, deg), y);\n}\n\n//---------------------------------------------------------------------------------\n// polytrim\n//---------------------------------------------------------------------------------\n\ntemplate \nvoid polytrim(std::vector &P, T tol = T{0}) {\n P.erase(\n std::find_if(P.crbegin(), P.crend(), [=](auto c) { return c > tol; })\n .base(),\n P.end());\n\n if (P.empty()) {\n P.push_back(T{0});\n }\n}\n\n//---------------------------------------------------------------------------------\n// Polynomial class\n//---------------------------------------------------------------------------------\n\ntemplate \nclass Polynomial {\n public:\n using value_type = typename std::vector::value_type;\n using size_type = typename std::vector::size_type;\n\n explicit Polynomial(size_type deg) : m_coef(deg + 1, T{0}) {}\n\n explicit Polynomial(const std::vector &coef) : m_coef(coef) {}\n explicit Polynomial(std::vector &&coef) : m_coef(std::move(coef)) {}\n\n template \n explicit Polynomial(const std::array &coef)\n : m_coef(coef.cbegin(), coef.cend()) {}\n\n template \n Polynomial(Iterator first, Iterator last) : m_coef(first, last) {}\n\n Polynomial(std::initializer_list l)\n : Polynomial(std::begin(l), std::end(l)) {}\n\n size_type degree() const { return m_coef.size() - 1; }\n\n const auto &data() const { return m_coef; }\n\n void mulx() { m_coef = polymulx(std::move(m_coef)); }\n\n void trim(T tol = T(0)) { polytrim(m_coef, tol); }\n\n T operator()(T x) const { return polyval(x, m_coef); }\n\n void reserve(size_type n_coefs) { m_coef.reserve(n_coefs); }\n\n Polynomial &operator+=(const Polynomial &rhs) {\n if (rhs.degree() > this->degree()) {\n const long old_size = long(m_coef.size());\n m_coef.resize(rhs.degree() + 1);\n std::transform(rhs.m_coef.begin(),\n rhs.m_coef.begin() + old_size,\n m_coef.begin(),\n m_coef.begin(),\n std::plus());\n std::copy(rhs.m_coef.begin() + old_size,\n rhs.m_coef.end(),\n m_coef.begin() + old_size);\n } else {\n std::transform(rhs.m_coef.begin(),\n rhs.m_coef.end(),\n m_coef.begin(),\n m_coef.begin(),\n std::plus());\n }\n\n return *this;\n }\n\n Polynomial &operator-=(const Polynomial &rhs) {\n if (rhs.degree() > this->degree()) {\n const auto old_size = m_coef.size();\n m_coef.resize(rhs.degree() + 1);\n\n for (size_type i = 0; i < old_size; ++i) {\n m_coef[i] -= rhs.m_coef[i];\n }\n\n for (size_type i = old_size; i < m_coef.size(); ++i) {\n m_coef[i] = -rhs.m_coef[i];\n }\n } else {\n for (size_type i = 0; i < rhs.degree() + 1; ++i) {\n m_coef[i] -= rhs.m_coef[i];\n }\n }\n\n return *this;\n }\n\n Polynomial &operator*=(T scalar) {\n for (auto &c : m_coef) {\n c *= scalar;\n }\n\n return *this;\n }\n\n Polynomial &operator*=(const Polynomial &rhs) {\n m_coef = std::move(polymul(m_coef, rhs.m_coef));\n return *this;\n }\n\n Polynomial operator+(const Polynomial &rhs) const {\n auto tmp(*this);\n tmp += rhs;\n return tmp;\n }\n\n Polynomial operator-(const Polynomial &rhs) const {\n auto tmp(*this);\n tmp -= rhs;\n return tmp;\n }\n\n Polynomial operator*(const Polynomial &rhs) const {\n auto tmp(*this);\n tmp *= rhs;\n return tmp;\n }\n\n bool scicpp_pure operator==(const Polynomial &rhs) const {\n return m_coef == rhs.m_coef;\n }\n\n bool scicpp_pure operator!=(const Polynomial &rhs) const {\n return m_coef != rhs.m_coef;\n }\n\n template \n bool is_approx(const Polynomial &rhs) const {\n return almost_equal(m_coef, rhs.m_coef);\n }\n\n private:\n std::vector m_coef;\n\n}; // class Polynomial\n\ntemplate \nPolynomial operator*(const Polynomial &P, T scalar) {\n auto tmp(P);\n tmp *= scalar;\n return tmp;\n}\n\ntemplate \nPolynomial operator*(T scalar, const Polynomial &P) {\n return P * scalar;\n}\n\n//---------------------------------------------------------------------------------\n// polyfromroots\n//---------------------------------------------------------------------------------\n\n// https://stackoverflow.com/questions/33594384/find-the-coefficients-of-the-polynomial-given-its-roots\ntemplate \nauto polyfromroots(const Array &roots) {\n using T = typename Array::value_type;\n\n auto P = Polynomial({T{1}});\n auto P_ = Polynomial({T{1}});\n P.reserve(roots.size() + 1);\n P_.reserve(roots.size());\n\n for (const auto &r : roots) {\n P_ = P * r;\n P.mulx();\n P -= P_;\n }\n\n return P;\n}\n\n} // namespace scicpp::polynomial\n\n#endif // SCICPP_POLYNOMIALS_POLYNOMIAL", "meta": {"hexsha": "da1ced961f25475777fdd3ae9dce344a95bd2c43", "size": 20952, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "scicpp/polynomials/polynomial.hpp", "max_stars_repo_name": "tvanderbruggen/SciCpp", "max_stars_repo_head_hexsha": "09408506c8d0b49ca5dadb8cd1f3cb4db41c8c46", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2021-08-02T09:03:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-17T11:58:05.000Z", "max_issues_repo_path": "scicpp/polynomials/polynomial.hpp", "max_issues_repo_name": "tvanderbruggen/SciCpp", "max_issues_repo_head_hexsha": "09408506c8d0b49ca5dadb8cd1f3cb4db41c8c46", "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": "scicpp/polynomials/polynomial.hpp", "max_forks_repo_name": "tvanderbruggen/SciCpp", "max_forks_repo_head_hexsha": "09408506c8d0b49ca5dadb8cd1f3cb4db41c8c46", "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": 28.8993103448, "max_line_length": 103, "alphanum_fraction": 0.4906930126, "num_tokens": 5363, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619350028204, "lm_q2_score": 0.6548947357776795, "lm_q1q2_score": 0.5399357810824265}} {"text": "/*******************************************************************************\n *\n * Standard domain of numerical congruences extended with bitwise\n * operations.\n *\n * Author: Alexandre C. D. Wimmers (alexandre.c.wimmers@nasa.gov)\n *\n * Contributors: Jorge A. Navas (jorge.a.navaslaserna@nasa.gov)\n *\n * Notices:\n *\n * Copyright (c) 2011 United States Government as represented by the\n * Administrator of the National Aeronautics and Space Administration.\n * All Rights Reserved.\n *\n * Disclaimers:\n *\n * No Warranty: THE SUBJECT SOFTWARE IS PROVIDED \"AS IS\" WITHOUT ANY WARRANTY OF\n * ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED\n * TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO SPECIFICATIONS,\n * ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,\n * OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE\n * ERROR FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO\n * THE SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER, CONSTITUTE AN\n * ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT OF ANY RESULTS,\n * RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY OTHER APPLICATIONS\n * RESULTING FROM USE OF THE SUBJECT SOFTWARE. FURTHER, GOVERNMENT AGENCY\n * DISCLAIMS ALL WARRANTIES AND LIABILITIES REGARDING THIRD-PARTY SOFTWARE,\n * IF PRESENT IN THE ORIGINAL SOFTWARE, AND DISTRIBUTES IT \"AS IS.\"\n *\n * Waiver and Indemnity: RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS AGAINST\n * THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL\n * AS ANY PRIOR RECIPIENT. IF RECIPIENT'S USE OF THE SUBJECT SOFTWARE RESULTS\n * IN ANY LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARISING FROM SUCH\n * USE, INCLUDING ANY DAMAGES FROM PRODUCTS BASED ON, OR RESULTING FROM,\n * RECIPIENT'S USE OF THE SUBJECT SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD\n * HARMLESS THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS,\n * AS WELL AS ANY PRIOR RECIPIENT, TO THE EXTENT PERMITTED BY LAW.\n * RECIPIENT'S SOLE REMEDY FOR ANY SUCH MATTER SHALL BE THE IMMEDIATE,\n * UNILATERAL TERMINATION OF THIS AGREEMENT.\n *\n ******************************************************************************/\n\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nnamespace ikos {\n\ntemplate class congruence {\n using interval_t = interval;\n\npublic:\n using congruence_t = congruence;\n\nprivate:\n bool _is_bottom;\n\n /// A congruence is denoted by aZ + b, where b \\in Z and a \\in N.\n /// The abstract state aZ + b represents all numbers that are\n /// congruent to b modulo a.\n Number _a; // modulo\n Number _b; // remainder\n\n // Notes about the % operator\n //\n // The semantics of r = n % d is to set r to \"n mod d\". The sign of\n // the d is ignored and r is always non-negative.\n //\n // We assume that n % d (also n /d) raises a runtime error if d==0.\n\n void normalize(void) {\n // Set to standard form: 0 <= b < a for a != 0\n if (_a != 0) {\n _b = _b % _a;\n }\n }\n\n // if true then top (1Z + 0) else bottom\n congruence(bool b) : _is_bottom(!b), _a(1), _b(0) {}\n\n congruence(int n) : _is_bottom(false), _a(0), _b(n) {}\n\n congruence(Number a, Number b) : _is_bottom(false), _a(a), _b(b) {\n normalize();\n }\n\n Number abs(Number x) const { return x < 0 ? -x : x; }\n\n Number max(Number x, Number y) const { return x.operator<=(y) ? y : x; }\n\n Number min(Number x, Number y) const { return x.operator<(y) ? x : y; }\n\n Number gcd(Number x, Number y, Number z) const { return gcd(x, gcd(y, z)); }\n // Not to be called explicitly outside of gcd\n Number gcd_helper(Number x, Number y) const {\n return (y == 0) ? x : gcd_helper(y, x % y);\n }\n Number gcd(Number x, Number y) const { return gcd_helper(abs(x), abs(y)); }\n\n Number lcm(Number x, Number y) const {\n Number tmp = gcd(x, y);\n return abs(x * y) / tmp;\n }\n\n bool is_zero() const { return !is_bottom() && _a == 0 && _b == 0; }\n\n bool all_ones() const { return !is_bottom() && _a == 0 && _b == -1; }\n\n interval_t to_interval() const {\n assert(singleton());\n return interval_t(*(singleton()));\n }\n\npublic:\n static congruence_t top() { return congruence(true); }\n\n static congruence_t bottom() { return congruence(false); }\n\n congruence() : _is_bottom(false), _a(1), _b(0) {}\n\n congruence(Number n) : _is_bottom(false), _a(0), _b(n) {}\n\n congruence(const congruence_t &o)\n : _is_bottom(o._is_bottom), _a(o._a), _b(o._b) {}\n\n congruence_t operator=(congruence_t o) {\n _is_bottom = o._is_bottom;\n _a = o._a;\n _b = o._b;\n return *this;\n }\n\n bool is_bottom() const { return _is_bottom; }\n\n bool is_top() const { return _a == 1; }\n\n boost::optional singleton() const {\n if (!this->is_bottom() && _a == 0) {\n return boost::optional(_b);\n } else {\n return boost::optional();\n }\n }\n\n Number get_modulo() const { return _a; }\n\n Number get_remainder() const { return _b; }\n\n bool operator==(congruence_t o) const {\n return (is_bottom() == o.is_bottom() && _a == o._a && _b == o._b);\n }\n\n bool operator!=(congruence_t x) const { return !this->operator==(x); }\n\n /** Lattice Operations **/\n\n bool operator<=(const congruence_t &o) const {\n if (is_bottom()) {\n return true;\n } else if (o.is_bottom()) {\n return false;\n } else if (_a == 0 && o._a == 0) {\n return (_b == o._b);\n } else if (_a == 0) {\n if ((_b % o._a) == (o._b % o._a)) {\n return true;\n }\n } else if (o._a == 0) {\n if (_b % _a == (o._b % _a)) {\n return false;\n }\n }\n return (_a % o._a == 0) && (_b % o._a == o._b % o._a);\n }\n\n congruence_t operator|(congruence_t o) {\n if (is_bottom()) {\n return o;\n } else if (o.is_bottom()) {\n return *this;\n } else if (is_top() || o.is_top()) {\n return top();\n } else {\n return congruence_t(gcd(_a, o._a, abs(_b - o._b)), min(_b, o._b));\n }\n }\n\n congruence_t operator&(congruence_t o) {\n if (is_bottom() || o.is_bottom()) {\n return bottom();\n }\n\n // lcm has meaning only if both a and o.a are not 0\n if (_a == 0 && o._a == 0) {\n if (_b == o._b) {\n return *this;\n } else {\n return bottom();\n }\n } else if (_a == 0) {\n // b & a'Z + b' iff \\exists k such that a'*k + b' = b iff ((b - b') %a' ==\n // 0)\n if ((_b - o._b) % o._a == 0) {\n return *this;\n } else {\n return bottom();\n }\n } else if (o._a == 0) {\n // aZ+b & b' iff \\exists k such that a*k+b = b' iff ((b'-b %a) == 0)\n if ((o._b - _b) % _a == 0) {\n return o;\n } else {\n return bottom();\n }\n } else {\n // pre: a and o.a != 0\n Number x = gcd(_a, o._a);\n if (_b % x == (o._b % x)) {\n // the part max(b,o.b) needs to be verified. What we really\n // want is to find b'' such that\n // 1) b'' % lcm(a,a') == b % lcm(a,a'), and\n // 2) b'' % lcm(a,a') == b' % lcm(a,a').\n // An algorithm for that is provided in Granger'89.\n return congruence_t(lcm(_a, o._a), max(_b, o._b));\n } else {\n return congruence_t::bottom();\n }\n }\n }\n\n congruence_t operator||(congruence_t o) {\n // Equivalent to join, domain is flat\n return *this | o;\n }\n\n congruence_t operator&&(congruence_t o) {\n // Simply refines top element\n return (is_top()) ? o : *this;\n }\n\n /** Arithmetic Operators **/\n\n congruence_t operator+(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else\n return congruence_t(gcd(_a, o._a), _b + o._b);\n }\n\n congruence_t operator-(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else\n return congruence_t(gcd(_a, o._a), _b - o._b);\n }\n\n congruence_t operator-() {\n if (this->is_bottom() || this->is_top())\n return *this;\n else\n return congruence_t(_a, -_b + _a);\n }\n\n congruence_t operator*(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if ((this->is_top() || o.is_top()) && _a != 0 && o._a != 0)\n return congruence_t::top();\n else\n return congruence_t(gcd(_a * o._a, _a * o._b, o._a * _b), _b * o._b);\n }\n\n // signed division\n congruence_t operator/(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (o == congruence(0))\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n\n /*\n aZ+b / 0Z+b':\n if b'|a then (a/b')Z + b/b'\n else top\n */\n if (o._a == 0) {\n if (_a % o._b == 0)\n return congruence_t(_a / o._b, _b / o._b);\n else\n return congruence_t::top();\n }\n\n /*\n 0Z+b / a'Z+b':\n if N>0 (b div N)Z + 0\n else 0Z + 0\n\n where N = a'((b-b') div a') + b'\n */\n if (_a == 0) {\n Number n(o._a * (((_b - o._b) / o._a) + o._b));\n if (n > 0) {\n return congruence_t(_b / n, 0);\n } else {\n return congruence_t(0, 0);\n }\n }\n\n /*\n General case: no singleton\n */\n return congruence_t::top();\n }\n }\n\n // signed remainder operator\n congruence_t operator%(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (o == congruence(0))\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n /*\n aZ+b mod 0Z+b':\n if b'|a then (a/b')Z + b/b'\n else top\n */\n if (o._a == 0) {\n if (_a % o._b == 0) {\n return congruence_t(0, _b % o._b);\n } else {\n return congruence_t(gcd(_a, o._b), _b);\n }\n }\n\n /*\n 0Z+b mod a'Z+b':\n if N<=0 then 0Z+b\n if (b div N) == 1 then gcd(b',a')Z + b\n if (b div N) >= 2 then N(b div N)Z + b\n\n where N = a'((b-b') div a') + b'\n */\n if (_a == 0) {\n Number n(o._a * (((_b - o._b) / o._a) + o._b));\n if (n <= 0) {\n return congruence_t(_a, _b);\n } else if (_b == n) {\n return congruence_t(gcd(o._b, o._a), _b);\n } else if ((_b / n) >= 2) {\n return congruence_t(_b, _b);\n } else {\n CRAB_ERROR(\"unreachable\");\n }\n }\n\n /*\n general case: no singleton\n */\n return congruence_t(gcd(_a, o._a, o._b), _b);\n }\n }\n\n /**\n Bitwise operators.\n They are very imprecise because we ignore bitwidth.\n\n Bitwise operation can be implemented more precisely based on\n Stefan Bygde's paper: Static WCET analysis based on abstract\n interpretation and counting of elements, Vasteras : School of\n Innovation, Design and Engineering, Malardalen University (2010).\n **/\n\n congruence_t And(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n if (is_zero() || o.is_zero()) {\n return congruence_t(0);\n } else if (all_ones()) {\n return o;\n } else if (o.all_ones()) {\n return *this;\n } else if (_a == 0 && o._a == 0) {\n return congruence_t(_b & o._b);\n } else {\n return top();\n }\n }\n }\n\n congruence_t Or(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n if (all_ones() || o.all_ones()) {\n return congruence_t(-1);\n } else if (is_zero()) {\n return o;\n } else if (o.is_zero()) {\n return *this;\n } else if (_a == 0 && o._a == 0) {\n return congruence_t(_b | o._b);\n } else {\n return top();\n }\n }\n }\n\n congruence_t Xor(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n if (is_zero()) {\n return o;\n } else if (o.is_zero()) {\n return *this;\n } else if (_a == 0 && o._a == 0) {\n return congruence_t(_b ^ o._b);\n } else {\n return top();\n }\n }\n }\n\n congruence_t Shl(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n\n if (o._a == 0) { // singleton\n\n if (o._b < 0) {\n return bottom();\n }\n\n // aZ + b << 0Z + b' = (a*2^b')Z + b*2^b'\n Number x = Number(1) << o._b;\n return congruence_t(_a * x, _b * x);\n } else {\n\n Number x = Number(1) << o._b;\n Number y = Number(1) << o._a;\n // aZ + b << a'Z + b' = (gcd(a, b * (2^a' - 1)))*(2^b')Z + b*(2^b')\n return congruence_t(gcd(_a, _b * (y - 1)) * x, _b * x);\n }\n }\n }\n\n congruence_t AShr(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n\n if (o._a == 0) { // singleton\n // aZ + b >> 0Z + b'\n if (o._b < 0) {\n return congruence_t::bottom();\n }\n }\n\n if (singleton() && o.singleton()) {\n interval_t res = to_interval().AShr(o.to_interval());\n if (boost::optional n = res.singleton()) {\n return congruence(*n);\n }\n }\n\n return congruence_t::top();\n }\n }\n\n congruence_t LShr(congruence_t o) {\n if (this->is_bottom() || o.is_bottom())\n return congruence_t::bottom();\n else if (this->is_top() || o.is_top())\n return congruence_t::top();\n else {\n\n if (o._a == 0) {\n // aZ + b >> 0Z + b'\n if (o._b < 0) {\n return congruence_t::bottom();\n }\n }\n\n if (singleton() && o.singleton()) {\n interval_t res = to_interval().LShr(o.to_interval());\n if (boost::optional n = res.singleton()) {\n return congruence(*n);\n }\n }\n\n return congruence_t::top();\n }\n }\n\n // division and remainder operations\n\n congruence_t SDiv(congruence_t x) { return this->operator/(x); }\n\n congruence_t UDiv(congruence_t x) { return congruence_t::top(); }\n\n congruence_t SRem(congruence_t x) { return this->operator%(x); }\n\n congruence_t URem(congruence_t x) { return congruence_t::top(); }\n\n void write(crab::crab_os &o) const {\n if (is_bottom()) {\n o << \"_|_\";\n return;\n }\n\n if (_a == 0) {\n o << _b;\n return;\n }\n\n o << _a << \"Z+\" << _b;\n }\n}; // end class congruence\n\ntemplate \ninline crab::crab_os &operator<<(crab::crab_os &o,\n const congruence &c) {\n c.write(o);\n return o;\n}\n\ntemplate \ninline congruence operator+(Number c, congruence x) {\n return congruence(c) + x;\n}\n\ntemplate \ninline congruence operator+(congruence x, Number c) {\n return x + congruence(c);\n}\n\ntemplate \ninline congruence operator*(Number c, congruence x) {\n return congruence(c) * x;\n}\n\ntemplate \ninline congruence operator*(congruence x, Number c) {\n return x * congruence(c);\n}\n\ntemplate \ninline congruence operator/(Number c, congruence x) {\n return congruence(c) / x;\n}\n\ntemplate \ninline congruence operator/(congruence x, Number c) {\n return x / congruence(c);\n}\n\ntemplate \ninline congruence operator-(Number c, congruence x) {\n return congruence(c) - x;\n}\n\ntemplate \ninline congruence operator-(congruence x, Number c) {\n return x - congruence(c);\n}\n\ntemplate \nclass equality_congruence_solver {\n // TODO: check correctness of the solver. Granger provides a sound\n // and more precise solver for equality linear congruences (see\n // Theorem 4.4).\nprivate:\n using congruence_t = congruence;\n using variable_t = crab::variable;\n using linear_expression_t = linear_expression;\n using linear_constraint_t = linear_constraint;\n using linear_constraint_system_t =\n linear_constraint_system;\n\n using cst_table_t = std::vector;\n using variable_set_t = std::set;\n\n std::size_t m_max_cycles;\n bool m_is_contradiction;\n cst_table_t m_cst_table;\n variable_set_t m_refined_variables;\n std::size_t m_op_count;\n\nprivate:\n bool refine(const variable_t &v, congruence_t i, CongruenceCollection &env) {\n congruence_t old_i = env[v];\n congruence_t new_i = old_i & i;\n if (new_i.is_bottom()) {\n return true;\n }\n if (old_i != new_i) {\n env.set(v, new_i);\n m_refined_variables.insert(v);\n ++(m_op_count);\n }\n return false;\n }\n\n congruence_t compute_residual(const linear_constraint_t &cst,\n const variable_t &pivot,\n CongruenceCollection &env) {\n congruence_t residual(cst.constant());\n for (auto kv : cst) {\n const variable_t &v = kv.second;\n if (!(v == pivot)) {\n residual = residual - (kv.first * env[v]);\n ++(m_op_count);\n }\n }\n return residual;\n }\n\n bool propagate(const linear_constraint_t &cst, CongruenceCollection &env) {\n for (auto kv : cst) {\n Number c = kv.first;\n const variable_t &pivot = kv.second;\n congruence_t rhs = compute_residual(cst, pivot, env) / congruence_t(c);\n\n if (cst.is_equality()) {\n if (refine(pivot, rhs, env)) {\n return true;\n }\n } else if (cst.is_inequality() || cst.is_strict_inequality()) {\n // Inequations (>=, <=, >, and <) do not work well with\n // congruences because for any number n there is always x and y\n // \\in gamma(aZ+b) such that n < x and n > y.\n //\n // The only cases we can catch is when all the expressions\n // are constants. We do not bother because any product\n // with intervals or constants should get those cases.\n continue;\n } else {\n // TODO: cst is a disequation\n }\n }\n return false;\n }\n\n bool solve_system(CongruenceCollection &env) {\n std::size_t cycle = 0;\n do {\n ++cycle;\n m_refined_variables.clear();\n for (const linear_constraint_t &cst : m_cst_table) {\n if (propagate(cst, env)) {\n return true;\n }\n }\n } while (m_refined_variables.size() > 0 && cycle <= m_max_cycles);\n return false;\n }\n\npublic:\n equality_congruence_solver(const linear_constraint_system_t &csts,\n std::size_t max_cycles)\n : m_max_cycles(max_cycles), m_is_contradiction(false) {\n for (auto const &cst : csts) {\n if (cst.is_contradiction()) {\n m_is_contradiction = true;\n return;\n } else if (cst.is_tautology()) {\n continue;\n } else {\n m_cst_table.push_back(cst);\n }\n }\n }\n\n void run(CongruenceCollection &env) {\n if (m_is_contradiction) {\n env.set_to_bottom();\n } else {\n if (solve_system(env)) {\n env.set_to_bottom();\n }\n }\n }\n\n}; // class equality_congruence_solver\n\ntemplate \nclass congruence_domain final : public crab::domains::abstract_domain_api<\n congruence_domain> {\npublic:\n using congruence_t = congruence;\n\nprivate:\n // note that this is assuming that all variables have the same bit\n // width which is unrealistic.\n using congruence_domain_t = congruence_domain;\n using abstract_domain_t =\n crab::domains::abstract_domain_api;\n\npublic:\n using typename abstract_domain_t::disjunctive_linear_constraint_system_t;\n using typename abstract_domain_t::interval_t;\n using typename abstract_domain_t::linear_constraint_system_t;\n using typename abstract_domain_t::linear_constraint_t;\n using typename abstract_domain_t::linear_expression_t;\n using typename abstract_domain_t::variable_or_constant_t;\n using typename abstract_domain_t::variable_t;\n using typename abstract_domain_t::variable_vector_t;\n using typename abstract_domain_t::variable_or_constant_vector_t; \n using number_t = Number;\n using varname_t = VariableName;\n using typename abstract_domain_t::reference_constraint_t;\n\nprivate:\n using separate_domain_t = separate_domain;\n using solver_t =\n equality_congruence_solver;\n\npublic:\n using iterator = typename separate_domain_t::iterator;\n\nprivate:\n separate_domain_t _env;\n\nprivate:\n congruence_domain(separate_domain_t env) : _env(env) {}\n\npublic:\n congruence_domain_t make_top() const override {\n return congruence_domain_t(separate_domain_t::top());\n }\n\n congruence_domain_t make_bottom() const override {\n return congruence_domain_t(separate_domain_t::bottom());\n }\n\n void set_to_top() override {\n congruence_domain abs(separate_domain_t::top());\n std::swap(*this, abs);\n }\n\n void set_to_bottom() override {\n congruence_domain abs(separate_domain_t::bottom());\n std::swap(*this, abs);\n }\n\n congruence_domain() : _env(separate_domain_t::top()) {}\n\n congruence_domain(const congruence_domain_t &e) : _env(e._env) {\n crab::CrabStats::count(domain_name() + \".count.copy\");\n crab::ScopedCrabStats __st__(domain_name() + \".copy\");\n }\n\n congruence_domain_t &operator=(const congruence_domain_t &o) {\n crab::CrabStats::count(domain_name() + \".count.copy\");\n crab::ScopedCrabStats __st__(domain_name() + \".copy\");\n if (this != &o)\n this->_env = o._env;\n return *this;\n }\n\n iterator begin() { return this->_env.begin(); }\n\n iterator end() { return this->_env.end(); }\n\n bool is_bottom() const override { return this->_env.is_bottom(); }\n\n bool is_top() const override { return this->_env.is_top(); }\n\n bool operator<=(const congruence_domain_t &e) const override {\n crab::CrabStats::count(domain_name() + \".count.leq\");\n crab::ScopedCrabStats __st__(domain_name() + \".leq\");\n return this->_env <= e._env;\n }\n\n void operator|=(const congruence_domain_t &e) override {\n crab::CrabStats::count(domain_name() + \".count.join\");\n crab::ScopedCrabStats __st__(domain_name() + \".join\");\n this->_env = this->_env | e._env;\n }\n\n congruence_domain_t operator|(const congruence_domain_t &e) const override {\n crab::CrabStats::count(domain_name() + \".count.join\");\n crab::ScopedCrabStats __st__(domain_name() + \".join\");\n return this->_env | e._env;\n }\n\n congruence_domain_t operator&(const congruence_domain_t &e) const override {\n crab::CrabStats::count(domain_name() + \".count.meet\");\n crab::ScopedCrabStats __st__(domain_name() + \".meet\");\n return this->_env & e._env;\n }\n\n congruence_domain_t operator||(const congruence_domain_t &e) const override {\n crab::CrabStats::count(domain_name() + \".count.widening\");\n crab::ScopedCrabStats __st__(domain_name() + \".widening\");\n return this->_env || e._env;\n }\n\n congruence_domain_t widening_thresholds(\n const congruence_domain_t &other,\n const crab::iterators::thresholds &) const override {\n return (*this || other);\n }\n\n congruence_domain_t operator&&(const congruence_domain_t &e) const override {\n crab::CrabStats::count(domain_name() + \".count.narrowing\");\n crab::ScopedCrabStats __st__(domain_name() + \".narrowing\");\n return this->_env && e._env;\n }\n\n void set(const variable_t &v, congruence_t i) {\n crab::CrabStats::count(domain_name() + \".count.assign\");\n crab::ScopedCrabStats __st__(domain_name() + \".assign\");\n this->_env.set(v, i);\n }\n\n void set(const variable_t &v, number_t n) {\n crab::CrabStats::count(domain_name() + \".count.assign\");\n crab::ScopedCrabStats __st__(domain_name() + \".assign\");\n this->_env.set(v, congruence_t(n));\n }\n\n void operator-=(const variable_t &v) override {\n crab::CrabStats::count(domain_name() + \".count.forget\");\n crab::ScopedCrabStats __st__(domain_name() + \".forget\");\n this->_env -= v;\n }\n\n virtual interval_t operator[](const variable_t &v) override {\n CRAB_WARN(domain_name(), \"::operator[] not implemented\");\n return interval_t::top();\n }\n\n congruence_t to_congruence(const variable_t &v) { return this->_env[v]; }\n\n congruence_t to_congruence(const linear_expression_t &expr) {\n congruence_t r(expr.constant());\n for (auto kv : expr) {\n congruence_t c(kv.first);\n r = r + (c * to_congruence(kv.second));\n }\n return r;\n }\n\n void operator+=(const linear_constraint_system_t &csts) override {\n crab::CrabStats::count(domain_name() + \".count.add_constraints\");\n crab::ScopedCrabStats __st__(domain_name() + \".add_constraints\");\n const std::size_t threshold = 10;\n if (!this->is_bottom()) {\n solver_t solver(csts, threshold);\n solver.run(this->_env);\n }\n }\n\n void assign(const variable_t &x, const linear_expression_t &e) override {\n crab::CrabStats::count(domain_name() + \".count.assign\");\n crab::ScopedCrabStats __st__(domain_name() + \".assign\");\n\n congruence_t r = e.constant();\n for (auto kv : e) {\n r = r + (kv.first * this->_env[kv.second]);\n }\n this->_env.set(x, r);\n }\n\n void apply(crab::domains::arith_operation_t op, const variable_t &x,\n const variable_t &y, const variable_t &z) override {\n crab::CrabStats::count(domain_name() + \".count.apply\");\n crab::ScopedCrabStats __st__(domain_name() + \".apply\");\n\n congruence_t yi = this->_env[y];\n congruence_t zi = this->_env[z];\n congruence_t xi = congruence_t::bottom();\n\n switch (op) {\n case crab::domains::OP_ADDITION:\n xi = yi + zi;\n break;\n case crab::domains::OP_SUBTRACTION:\n xi = yi - zi;\n break;\n case crab::domains::OP_MULTIPLICATION:\n xi = yi * zi;\n break;\n case crab::domains::OP_SDIV:\n xi = yi / zi;\n break;\n case crab::domains::OP_UDIV:\n xi = yi.UDiv(zi);\n break;\n case crab::domains::OP_SREM:\n xi = yi.SRem(zi);\n break;\n case crab::domains::OP_UREM:\n xi = yi.URem(zi);\n break;\n default:\n CRAB_ERROR(\"Operation \", op, \" not supported\");\n }\n this->_env.set(x, xi);\n }\n\n void apply(crab::domains::arith_operation_t op, const variable_t &x,\n const variable_t &y, number_t k) override {\n crab::CrabStats::count(domain_name() + \".count.apply\");\n crab::ScopedCrabStats __st__(domain_name() + \".apply\");\n\n congruence_t yi = this->_env[y];\n congruence_t zi(k);\n congruence_t xi = congruence_t::bottom();\n\n switch (op) {\n case crab::domains::OP_ADDITION:\n xi = yi + zi;\n break;\n case crab::domains::OP_SUBTRACTION:\n xi = yi - zi;\n break;\n case crab::domains::OP_MULTIPLICATION:\n xi = yi * zi;\n break;\n case crab::domains::OP_SDIV:\n xi = yi / zi;\n break;\n case crab::domains::OP_UDIV:\n xi = yi.UDiv(zi);\n break;\n case crab::domains::OP_SREM:\n xi = yi.SRem(zi);\n break;\n case crab::domains::OP_UREM:\n xi = yi.URem(zi);\n break;\n default:\n CRAB_ERROR(\"Operation \", op, \" not supported\");\n }\n this->_env.set(x, xi);\n }\n\n // backward operations\n void backward_assign(const variable_t &x, const linear_expression_t &e,\n const congruence_domain_t &inv) override {\n crab::CrabStats::count(domain_name() + \".count.backward_assign\");\n crab::ScopedCrabStats __st__(domain_name() + \".backward_assign\");\n\n crab::domains::BackwardAssignOps::assign(*this, x, e,\n inv);\n }\n\n void backward_apply(crab::domains::arith_operation_t op, const variable_t &x,\n const variable_t &y, number_t z,\n const congruence_domain_t &inv) override {\n crab::CrabStats::count(domain_name() + \".count.backward_apply\");\n crab::ScopedCrabStats __st__(domain_name() + \".backward_apply\");\n\n crab::domains::BackwardAssignOps::apply(*this, op, x,\n y, z, inv);\n }\n\n void backward_apply(crab::domains::arith_operation_t op, const variable_t &x,\n const variable_t &y, const variable_t &z,\n const congruence_domain_t &inv) override {\n crab::CrabStats::count(domain_name() + \".count.backward_apply\");\n crab::ScopedCrabStats __st__(domain_name() + \".backward_apply\");\n\n crab::domains::BackwardAssignOps::apply(*this, op, x,\n y, z, inv);\n }\n\n // cast operations\n\n void apply(crab::domains::int_conv_operation_t /*op*/, const variable_t &dst,\n const variable_t &src) override {\n // ignore widths\n assign(dst, src);\n }\n\n // bitwise operations\n\n void apply(crab::domains::bitwise_operation_t op, const variable_t &x,\n const variable_t &y, const variable_t &z) override {\n crab::CrabStats::count(domain_name() + \".count.apply\");\n crab::ScopedCrabStats __st__(domain_name() + \".apply\");\n\n congruence_t yi = this->_env[y];\n congruence_t zi = this->_env[z];\n congruence_t xi = congruence_t::bottom();\n\n switch (op) {\n case crab::domains::OP_AND: {\n xi = yi.And(zi);\n break;\n }\n case crab::domains::OP_OR: {\n xi = yi.Or(zi);\n break;\n }\n case crab::domains::OP_XOR: {\n xi = yi.Xor(zi);\n break;\n }\n case crab::domains::OP_SHL: {\n xi = yi.Shl(zi);\n break;\n }\n case crab::domains::OP_LSHR: {\n xi = yi.LShr(zi);\n break;\n }\n case crab::domains::OP_ASHR: {\n xi = yi.AShr(zi);\n break;\n }\n default: { CRAB_ERROR(\"unreachable\"); }\n }\n this->_env.set(x, xi);\n }\n\n void apply(crab::domains::bitwise_operation_t op, const variable_t &x,\n const variable_t &y, number_t k) override {\n crab::CrabStats::count(domain_name() + \".count.apply\");\n crab::ScopedCrabStats __st__(domain_name() + \".apply\");\n\n congruence_t yi = this->_env[y];\n congruence_t zi(k);\n congruence_t xi = congruence_t::bottom();\n\n switch (op) {\n case crab::domains::OP_AND: {\n xi = yi.And(zi);\n break;\n }\n case crab::domains::OP_OR: {\n xi = yi.Or(zi);\n break;\n }\n case crab::domains::OP_XOR: {\n xi = yi.Xor(zi);\n break;\n }\n case crab::domains::OP_SHL: {\n xi = yi.Shl(zi);\n break;\n }\n case crab::domains::OP_LSHR: {\n xi = yi.LShr(zi);\n break;\n }\n case crab::domains::OP_ASHR: {\n xi = yi.AShr(zi);\n break;\n }\n default: { CRAB_ERROR(\"unreachable\"); }\n }\n this->_env.set(x, xi);\n }\n\n DEFAULT_SELECT(congruence_domain_t)\n \n /// congruence_domain implements only standard abstract operations\n /// of a numerical domain so it is intended to be used as a leaf\n /// domain in the hierarchy of domains.\n BOOL_OPERATIONS_NOT_IMPLEMENTED(congruence_domain_t)\n ARRAY_OPERATIONS_NOT_IMPLEMENTED(congruence_domain_t)\n REGION_AND_REFERENCE_OPERATIONS_NOT_IMPLEMENTED(congruence_domain_t)\n \n void forget(const variable_vector_t &variables) override {\n if (is_bottom() || is_top()) {\n return;\n }\n for (variable_t var : variables) {\n this->operator-=(var);\n }\n }\n\n void project(const variable_vector_t &variables) override {\n crab::CrabStats::count(domain_name() + \".count.project\");\n crab::ScopedCrabStats __st__(domain_name() + \".project\");\n\n _env.project(variables);\n }\n\n void expand(const variable_t &x, const variable_t &new_x) override {\n crab::CrabStats::count(domain_name() + \".count.expand\");\n crab::ScopedCrabStats __st__(domain_name() + \".expand\");\n\n if (is_bottom() || is_top()) {\n return;\n }\n\n set(new_x, this->_env[x]);\n }\n\n void normalize() override {}\n\n void minimize() override {}\n\n void rename(const variable_vector_t &from,\n const variable_vector_t &to) override {\n crab::CrabStats::count(domain_name() + \".count.rename\");\n crab::ScopedCrabStats __st__(domain_name() + \".rename\");\n\n _env.rename(from, to);\n }\n\n /* begin intrinsics operations */\n void intrinsic(std::string name,\n\t\t const variable_or_constant_vector_t &inputs,\n const variable_vector_t &outputs) override {\n CRAB_WARN(\"Intrinsics \", name, \" not implemented by \", domain_name());\n }\n\n void backward_intrinsic(std::string name,\n\t\t\t const variable_or_constant_vector_t &inputs,\n const variable_vector_t &outputs,\n const congruence_domain_t &invariant) override {\n CRAB_WARN(\"Intrinsics \", name, \" not implemented by \", domain_name());\n }\n /* end intrinsics operations */\n\n void write(crab::crab_os &o) const override {\n crab::CrabStats::count(domain_name() + \".count.write\");\n crab::ScopedCrabStats __st__(domain_name() + \".write\");\n\n this->_env.write(o);\n }\n\n linear_constraint_system_t to_linear_constraint_system() const override {\n crab::CrabStats::count(domain_name() +\n \".count.to_linear_constraint_system\");\n crab::ScopedCrabStats __st__(domain_name() +\n \".to_linear_constraint_system\");\n\n linear_constraint_system_t csts;\n if (is_bottom()) {\n csts += linear_constraint_t::get_false();\n return csts;\n }\n\n for (iterator it = this->_env.begin(); it != this->_env.end(); ++it) {\n const variable_t &v = it->first;\n congruence_t c = it->second;\n boost::optional n = c.singleton();\n if (n) {\n csts += (v == *n);\n }\n }\n return csts;\n }\n\n disjunctive_linear_constraint_system_t\n to_disjunctive_linear_constraint_system() const override {\n auto lin_csts = to_linear_constraint_system();\n if (lin_csts.is_false()) {\n return disjunctive_linear_constraint_system_t(true /*is_false*/);\n } else if (lin_csts.is_true()) {\n return disjunctive_linear_constraint_system_t(false /*is_false*/);\n } else {\n return disjunctive_linear_constraint_system_t(lin_csts);\n }\n }\n\n std::string domain_name() const override { return \"Congruences\"; }\n\n}; // class congruence_domain\n\n} // namespace ikos\n\nnamespace crab {\nnamespace domains {\n\ntemplate \nstruct abstract_domain_traits> {\n using number_t = Number;\n using varname_t = VariableName;\n};\n\n} // namespace domains\n} // namespace crab\n", "meta": {"hexsha": "2fa97a3c72c7137fca0e717a16d984dc72727249", "size": 35730, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/crab/domains/congruences.hpp", "max_stars_repo_name": "LinerSu/crab", "max_stars_repo_head_hexsha": "8f3516f4b4765f4a093bb3c3a94ac2daa174130c", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 152.0, "max_stars_repo_stars_event_min_datetime": "2016-02-28T06:04:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T10:44:56.000Z", "max_issues_repo_path": "include/crab/domains/congruences.hpp", "max_issues_repo_name": "LinerSu/crab", "max_issues_repo_head_hexsha": "8f3516f4b4765f4a093bb3c3a94ac2daa174130c", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 43.0, "max_issues_repo_issues_event_min_datetime": "2017-07-03T06:25:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-23T21:09:32.000Z", "max_forks_repo_path": "include/crab/domains/congruences.hpp", "max_forks_repo_name": "LinerSu/crab", "max_forks_repo_head_hexsha": "8f3516f4b4765f4a093bb3c3a94ac2daa174130c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 28.0, "max_forks_repo_forks_event_min_datetime": "2015-11-22T15:51:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-30T00:46:57.000Z", "avg_line_length": 29.5289256198, "max_line_length": 80, "alphanum_fraction": 0.6056255248, "num_tokens": 10068, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619350028204, "lm_q2_score": 0.6548947290421275, "lm_q1q2_score": 0.5399357755292202}} {"text": "#define DEBUG 1\n/**\n * File : E.cpp\n * Author : Kazune Takahashi\n * Created : 6/2/2020, 12:34:10 PM\n * Powered by Visual Studio Code\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n// ----- boost -----\n#include \n#include \n// ----- using directives and manipulations -----\nusing namespace std;\nusing boost::rational;\nusing boost::multiprecision::cpp_int;\nusing ll = long long;\ntemplate \nusing max_heap = priority_queue;\ntemplate \nusing min_heap = priority_queue, greater>;\n// ----- constexpr for Mint and Combination -----\nconstexpr ll MOD{1000000007LL};\n// constexpr ll MOD{998244353LL}; // be careful\nconstexpr ll MAX_SIZE{3000010LL};\n// constexpr ll MAX_SIZE{30000010LL}; // if 10^7 is needed\n// ----- ch_max and ch_min -----\ntemplate \nvoid ch_max(T &left, T right)\n{\n if (left < right)\n {\n left = right;\n }\n}\ntemplate \nvoid ch_min(T &left, T right)\n{\n if (left > right)\n {\n left = right;\n }\n}\n// ----- Mint -----\ntemplate \nclass Mint\n{\npublic:\n ll x;\n Mint() : x{0LL} {}\n Mint(ll x) : x{(x % MOD + MOD) % MOD} {}\n Mint operator-() const { return x ? MOD - x : 0; }\n Mint &operator+=(const Mint &a)\n {\n if ((x += a.x) >= MOD)\n {\n x -= MOD;\n }\n return *this;\n }\n Mint &operator-=(const Mint &a) { return *this += -a; }\n Mint &operator++() { return *this += 1; }\n Mint operator++(int)\n {\n Mint tmp{*this};\n ++*this;\n return tmp;\n }\n Mint &operator--() { return *this -= 1; }\n Mint operator--(int)\n {\n Mint tmp{*this};\n --*this;\n return tmp;\n }\n Mint &operator*=(const Mint &a)\n {\n (x *= a.x) %= MOD;\n return *this;\n }\n Mint &operator/=(const Mint &a)\n {\n Mint b{a};\n return *this *= b.power(MOD - 2);\n }\n Mint operator+(const Mint &a) const { return Mint(*this) += a; }\n Mint operator-(const Mint &a) const { return Mint(*this) -= a; }\n Mint operator*(const Mint &a) const { return Mint(*this) *= a; }\n Mint operator/(const Mint &a) const { return Mint(*this) /= a; }\n bool operator<(const Mint &a) const { return x < a.x; }\n bool operator<=(const Mint &a) const { return x <= a.x; }\n bool operator>(const Mint &a) const { return x > a.x; }\n bool operator>=(const Mint &a) const { return x >= a.x; }\n bool operator==(const Mint &a) const { return x == a.x; }\n bool operator!=(const Mint &a) const { return !(*this == a); }\n const Mint power(ll N)\n {\n if (N == 0)\n {\n return 1;\n }\n else if (N % 2 == 1)\n {\n return *this * power(N - 1);\n }\n else\n {\n Mint half = power(N / 2);\n return half * half;\n }\n }\n};\ntemplate \nMint operator+(ll lhs, const Mint &rhs)\n{\n return rhs + lhs;\n}\ntemplate \nMint operator-(ll lhs, const Mint &rhs)\n{\n return -rhs + lhs;\n}\ntemplate \nMint operator*(ll lhs, const Mint &rhs)\n{\n return rhs * lhs;\n}\ntemplate \nMint operator/(ll lhs, const Mint &rhs)\n{\n return Mint{lhs} / rhs;\n}\ntemplate \nistream &operator>>(istream &stream, Mint &a)\n{\n return stream >> a.x;\n}\ntemplate \nostream &operator<<(ostream &stream, const Mint &a)\n{\n return stream << a.x;\n}\n// ----- Combination -----\ntemplate \nclass Combination\n{\npublic:\n vector> inv, fact, factinv;\n Combination() : inv(MAX_SIZE), fact(MAX_SIZE), factinv(MAX_SIZE)\n {\n inv[1] = 1;\n for (auto i = 2LL; i < MAX_SIZE; i++)\n {\n inv[i] = (-inv[MOD % i]) * (MOD / i);\n }\n fact[0] = factinv[0] = 1;\n for (auto i = 1LL; i < MAX_SIZE; i++)\n {\n fact[i] = Mint(i) * fact[i - 1];\n factinv[i] = inv[i] * factinv[i - 1];\n }\n }\n Mint operator()(int n, int k)\n {\n if (n >= 0 && k >= 0 && n - k >= 0)\n {\n return fact[n] * factinv[k] * factinv[n - k];\n }\n return 0;\n }\n Mint catalan(int x, int y)\n {\n return (*this)(x + y, y) - (*this)(x + y, y - 1);\n }\n};\n// ----- for C++14 -----\nusing mint = Mint;\nusing combination = Combination;\ntemplate \nT gcd(T x, T y) { return y ? gcd(y, x % y) : x; }\ntemplate \nT lcm(T x, T y) { return x / gcd(x, y) * y; }\n// ----- for C++17 -----\ntemplate \nint popcount(T x) // C++20\n{\n int ans{0};\n while (x != 0)\n {\n ans += x & 1;\n x >>= 1;\n }\n return ans;\n}\n// ----- frequently used constexpr -----\n// constexpr double epsilon{1e-10};\nconstexpr ll infty{1000000000000000LL}; // or\n// constexpr int infty{1'000'000'010};\n// constexpr int dx[4] = {1, 0, -1, 0};\n// constexpr int dy[4] = {0, 1, 0, -1};\n// ----- Yes() and No() -----\nvoid Yes()\n{\n cout << \"Yes\" << endl;\n exit(0);\n}\nvoid No()\n{\n cout << \"No\" << endl;\n exit(0);\n}\n// ----- main() -----\n\nstruct Edge\n{\n bool valid;\n int src, dst;\n ll cost;\n\n Edge() {}\n Edge(int src, int dst, ll cost) : valid{true}, src{src}, dst{dst}, cost{cost} {}\n\n void added_edge(vector> &V)\n {\n V[src].push_back(dst);\n }\n\n void added_rev(vector> &V)\n {\n V[dst].push_back(src);\n }\n};\n\nclass Solve\n{\n int N, M;\n ll P;\n vector E;\n\npublic:\n Solve(int N, int M) : N{N}, M{M}, E(M)\n {\n cin >> P;\n for (auto i = 0; i < M; ++i)\n {\n int A, B;\n ll C;\n cin >> A >> B >> C;\n --A;\n --B;\n E[i] = Edge(A, B, P - C);\n }\n }\n\n void flush()\n {\n determine_validness();\n cout << bf() << endl;\n }\n\nprivate:\n ll bf()\n {\n vector D(N, infty);\n D[0] = 0;\n bool updated{false};\n for (auto t = 0; t < N + 2; ++t)\n {\n updated = false;\n for (auto const &e : E)\n {\n if (!e.valid)\n {\n continue;\n }\n auto tmp{D[e.src] + e.cost};\n if (D[e.dst] > tmp)\n {\n D[e.dst] = tmp;\n updated = true;\n }\n }\n if (!updated)\n {\n return max(0LL, -D[N - 1]);\n }\n if (t == N + 1)\n {\n return -1;\n }\n }\n assert(false);\n return -2;\n }\n\n void determine_validness()\n {\n auto table{valid_vertexes()};\n for (auto &e : E)\n {\n if (!(table[e.src] && table[e.dst]))\n {\n e.valid = false;\n }\n#if DEBUG == 1\n else\n {\n cerr << \"src: \" << e.src << \", dst: \" << e.dst << \", cost: \" << e.cost << endl;\n }\n#endif\n }\n }\n\n vector valid_vertexes()\n {\n vector> V(N);\n for (auto i = 0; i < M; ++i)\n {\n E[i].added_edge(V);\n }\n vector X(N, false);\n dfs(V, X, 0);\n vector> W(N);\n for (auto i = 0; i < M; ++i)\n {\n E[i].added_rev(W);\n }\n vector Y(N, false);\n dfs(W, Y, N - 1);\n vector res(N, false);\n for (auto i = 0; i < N; ++i)\n {\n res[i] = X[i] && Y[i];\n }\n return res;\n }\n\n void dfs(vector> const &V, vector &visited, int src, int parent = -1)\n {\n visited[src] = true;\n for (auto dst : V[src])\n {\n if (dst != parent && !visited[dst])\n {\n dfs(V, visited, dst, src);\n }\n }\n }\n};\n\nint main()\n{\n int N, M;\n cin >> N >> M;\n Solve solve(N, M);\n solve.flush();\n}\n", "meta": {"hexsha": "ff5ddc05815092e72eedc567caf8c27525a959e9", "size": 7585, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "2019/0810_ABC137/E.cpp", "max_stars_repo_name": "kazunetakahashi/atcoder", "max_stars_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2019-03-24T14:06:29.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-17T21:16:36.000Z", "max_issues_repo_path": "2019/0810_ABC137/E.cpp", "max_issues_repo_name": "kazunetakahashi/atcoder", "max_issues_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "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": "2019/0810_ABC137/E.cpp", "max_forks_repo_name": "kazunetakahashi/atcoder", "max_forks_repo_head_hexsha": "16ce65829ccc180260b19316e276c2fcf6606c53", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-07-22T17:27:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-22T17:27:09.000Z", "avg_line_length": 20.0131926121, "max_line_length": 89, "alphanum_fraction": 0.5278839815, "num_tokens": 2439, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619134371954, "lm_q2_score": 0.6548947290421275, "lm_q1q2_score": 0.5399357614060061}} {"text": "//\n// robust_pose_pnp.cpp\n//\n// Manolis Lourakis (lourakis **at** ics forth gr), February 2022\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \n#include \"robust_pose_pnp.h\"\n\n#undef ROBUST_POSE_PNP_DEBUG // enables some sample size checks\n\nnamespace robust_pose_pnp {\n\nPoseEstimator::PoseEstimator(const std::vector *_3dpoints, const std::vector *_projections,\n int samplesz, int nm_samplesz) {\n _3dpoints_ = _3dpoints;\n _projections_ = _projections;\n\n set_sample_sizes(samplesz, nm_samplesz);\n}\n\n// Robustly solves for camera pose lambda*x = R*X+t with lambda > 0.\n// Inlier and outlier indices are optionally returned (in increasing order) in idxInliers & idxOutliers.\n// Returns 0 if successful, zero otherwise\nint PoseEstimator::ransacfit(int miniter, int maxiter, double inlPcent, double outlThresh, robust_pose_pnp::Matrix34d& best_pose, std::vector *idxInliers, std::vector *idxOutliers) const {\n ransac_lib::LORansacOptions options;\n\n options.min_num_iterations_ = (unsigned int)miniter;\n options.max_num_iterations_ = (unsigned int)maxiter;\n // make sure that min_num_iterations_ are at least as many as predicted for the given outlier ratio and sample size\n options.min_num_iterations_ = ransac_lib::utils::NumRequiredIterations(inlPcent, 1.0-0.99, samplesz_, options.min_num_iterations_, options.max_num_iterations_);\n options.squared_inlier_threshold_ = outlThresh * outlThresh;\n options.final_least_squares_ = true;\n\n // additional params with their defaults\n //options.min_sample_multiplicator_ = 7;\n //options.num_lsq_iterations_ = 4;\n //options.num_lo_steps_ = 10;\n\n#if 0\n std::random_device rand_dev;\n options.random_seed_ = rand_dev();\n#endif\n\n ransac_lib::LocallyOptimizedMSAC >,\n robust_pose_pnp::PoseEstimator>\n lomsac;\n ransac_lib::RansacStatistics ransac_stats;\n\n//std::cout << \"... running LOMSAC\" << std::endl;\n int num_inliers = lomsac.EstimateModel(options, *this, &best_pose, &ransac_stats);\n\n int npts = _3dpoints_->size();\n int num_outliers = npts - num_inliers;\n\n if (idxInliers != nullptr) {\n idxInliers->clear();\n idxInliers->resize(num_inliers);\n\n for (int i=0; iclear();\n idxOutliers->resize(num_outliers);\n\n // num_inliers == ransac_stats.inlier_indices.size()\n std::vector isoutl(npts, 1);\n for (int i=0; i& sample,\n std::vector > *poses) const {\n const int nsample = sample.size();\n//std::cout<< \"in solve \"< points(nsample);\n std::vector projections(nsample);\n\n for(int i=0; iwghts(nsample, 1.0);\n sqpnp::PnPSolver solver(points, projections, wghts, params);\n\n if(solver.IsValid()){\n solver.Solve();\n\n poses->resize(solver.NumberOfSolutions());\n for (int i = 0; i < solver.NumberOfSolutions(); i++)\n {\n const sqpnp::SQPSolution *sol = solver.SolutionPtr(i);\n\n// std::cout << \"\\nSolution \" << i << \":\\n\";\n// std::cout << *sol << std::endl;\n// std::cout << \" Average squared projection error : \" << solver.AverageSquaredProjectionErrors().at(i) << std::endl;\n\n (*poses)[i].block<3,3>(0,0) = Eigen::Map >( sol->r_hat.data() );\n (*poses)[i].block<3,1>(0,3) = Eigen::Map >( sol->t.data() );\n }\n }\n else return 0;\n\n return solver.NumberOfSolutions();\n}\n\n#else\n// this uses directly the correspondences using the weights: 1 for those in sample, 0 for the rest\nint PoseEstimator::sqpnp_solve(const std::vector& sample,\n std::vector > *poses) const {\n const int npts = _3dpoints_->size();\n const int nsample = sample.size();\n//std::cout<< \"in solve \"<wghts(npts, 0.0);\n for(int i=0; iresize(solver.NumberOfSolutions());\n for (int i = 0; i < solver.NumberOfSolutions(); i++)\n {\n const sqpnp::SQPSolution *sol = solver.SolutionPtr(i);\n\n// std::cout << \"\\nSolution \" << i << \":\\n\";\n// std::cout << *sol << std::endl;\n// std::cout << \" Average squared projection error : \" << solver.AverageSquaredProjectionErrors().at(i) << std::endl;\n\n (*poses)[i].block<3,3>(0,0) = Eigen::Map >( sol->r_hat.data() );\n (*poses)[i].block<3,1>(0,3) = Eigen::Map >( sol->t.data() );\n }\n }\n else return 0;\n\n return solver.NumberOfSolutions();\n}\n#endif\n\n// minimal solver with SQPnP\nint PoseEstimator::MinimalSolver(const std::vector& sample,\n std::vector > *poses) const {\n\n //const int npts = sample.size();\n //std::cout<< \"in minimal solver (sqpnp) \"<clear();\n\n#ifdef ROBUST_POSE_PNP_DEBUG\n if (npts < samplesz_) return 0;\n#endif\n\n return PoseEstimator::sqpnp_solve(sample, poses);\n}\n\n\n// non minimal solver with SQPnP\nint PoseEstimator::NonMinimalSolver(const std::vector& sample,\n robust_pose_pnp::Matrix34d *pose) const {\n const int npts = sample.size();\n//std::cout<< \"in non minimal solver \"< > poses;\n\n int n = PoseEstimator::sqpnp_solve(sample, &poses);\n\n if (n > 1) std::cerr << \"More than one solution in PoseEstimator::NonMinimalSolver()!\\n\" << std::flush;\n\n if (n > 0) *pose = poses[0];\n\n return n > 0;\n}\n\n// Evaluates the pose on the i-th point pair.\ndouble PoseEstimator::EvaluateModelOnPoint(const robust_pose_pnp::Matrix34d& pose,\n int i) const {\n const sqpnp::_Point& xyz = (*_3dpoints_)[i];\n\n#if 0\n double Xc = pose(0, 0)*xyz.vector[0] + pose(0, 1)*xyz.vector[1] + pose(0, 2)*xyz.vector[2] + pose(0, 3),\n Yc = pose(1, 0)*xyz.vector[0] + pose(1, 1)*xyz.vector[1] + pose(1, 2)*xyz.vector[2] + pose(1, 3),\n inv_Zc = 1./ ( pose(2, 0)*xyz.vector[0] + pose(2, 1)*xyz.vector[1] + pose(2, 2)*xyz.vector[2] + pose(2, 3) );\n\n#else\n Eigen::Vector3d prod = pose.block<3,3>(0,0) * xyz.vector + pose.block<3,1>(0,3);\n double Xc = prod(0),\n Yc = prod(1),\n inv_Zc = 1./ prod(2);\n\n\n double dx = Xc*inv_Zc - (*_projections_)[i].vector[0];\n double dy = Yc*inv_Zc - (*_projections_)[i].vector[1];\n#endif\n\n return dx*dx + dy*dy;\n}\n\n} // namespace robust_pose_pnp\n", "meta": {"hexsha": "c8f630f9418b3f7e6e84986d35c3e0a795b31a84", "size": 8653, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/robust/robust_pose_pnp.cpp", "max_stars_repo_name": "oppenfuture/sqpnp", "max_stars_repo_head_hexsha": "e102e85d049b09fe9bfcced75016ddd7da8881c3", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/robust/robust_pose_pnp.cpp", "max_issues_repo_name": "oppenfuture/sqpnp", "max_issues_repo_head_hexsha": "e102e85d049b09fe9bfcced75016ddd7da8881c3", "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": "examples/robust/robust_pose_pnp.cpp", "max_forks_repo_name": "oppenfuture/sqpnp", "max_forks_repo_head_hexsha": "e102e85d049b09fe9bfcced75016ddd7da8881c3", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.032388664, "max_line_length": 198, "alphanum_fraction": 0.6558419045, "num_tokens": 2615, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8289388167733099, "lm_q2_score": 0.6513548714339144, "lm_q1q2_score": 0.5399333364259604}} {"text": "\n/*\n * Mod_p.cpp\n *\n * Created on: 15.09.2010\n * Author: stephaniebayer\n */\n\n#include \"Mod_p.h\"\n\n\n#include \"G_q.h\"\nextern G_q G;\n\n#include \nNTL_CLIENT\n\n\nMod_p::Mod_p() {\n\t// TODO Auto-generated constructor stub\n\n}\n\n//Creates an instance which belongs to Z_p\nMod_p::Mod_p(long p){\n\n\tmod = to_ZZ(p);\n}\n\n\n//Creates an instance which belongs to Z_p\nMod_p::Mod_p(ZZ p){\n\n\tmod = p;\n}\n\n\n//Creates an instance which belongs to Z_p with value v\nMod_p::Mod_p(long v, long p){\n\n\tmod = to_ZZ(p);\n\tval = to_ZZ(v) % mod;\n}\n\n//Creates an instance which belongs to Z_p with value v\nMod_p::Mod_p(ZZ v, long p){\n\n\tmod = to_ZZ(p);\n\tval = v % mod;\n}\n\n\n//Creates an instance which belongs to Z_p with value v\nMod_p::Mod_p(long v, ZZ p){\n\n\tmod = p;\n\tval = to_ZZ(v) % mod;\n}\n\n\n//Creates an instance which belongs to Z_p with value v\nMod_p::Mod_p(ZZ v, ZZ p){\n\n\tmod = p;\n\tval = v % mod;\n}\n\n\nMod_p::~Mod_p() {\n\t// TODO Auto-generated destructor stub\n}\n\n\n//Changes the modular value p\nvoid Mod_p::set_mod(long p){\n\n\tmod = to_ZZ(p);\n}\n\n//Changes the modular value p\nvoid Mod_p::set_mod(ZZ p){\n\n\tmod = p;\n}\n\n//Sets or changes the value val\nvoid Mod_p::set_val(long v){\n\tif (mod ==0)\n\t\tcout << \"Please set a value for the modulus p\" << endl;\n\telse\n\t\tval = to_ZZ(v)% mod;\n}\n\n//Sets or changes the value val\nvoid Mod_p::set_val(ZZ p){\n\n\tif (mod ==0)\n\t\t\tcout << \"Please set a value for the modulus p\" << endl;\n\telse\n\t\tval = p % mod;\n}\n\n//Returns the modular value\nZZ Mod_p::get_mod() const{\n\n\treturn mod;\n}\n\n//returns the value of the instance\nZZ Mod_p::get_val() const{\n\n\treturn val;\n}\n\n\n//Assigment operator\nvoid Mod_p::operator =(const Mod_p& el){\n\n\tmod = el.get_mod();\n\tval = el.get_val();\n}\n\n//Addition\nMod_p Mod_p::operator +(const Mod_p& el) const{\n\tZZ temp;\n\tif (mod != el.get_mod())\n\t{\t\tcout <<\"It is not possible to add these elements\" << endl;\n\t\t\treturn Mod_p(0,1);}\n\telse\n\t{\n\t\ttemp = AddMod(val, el.get_val(),mod);\n\t\treturn Mod_p(temp, mod);}\n}\n\n//Subtraction\nMod_p Mod_p::operator -(const Mod_p& el) const{\n\tZZ temp;\n\tif (mod != el.get_mod())\n\t{\t\tcout <<\"It is not possible to subtract these elements\" << endl;\n\t\t\treturn Mod_p(0,1);}\n\telse\n\t{\n\t\ttemp = SubMod(val , el.get_val(),mod);\n\t\treturn Mod_p(temp, mod);}\n}\n\n//Unary plus\nMod_p Mod_p::operator +() const{\n\n\treturn Mod_p(val, mod);\n\n}\n\n//Unary Minus\nMod_p Mod_p::operator -() const{\n\n\tZZ temp;\n\ttemp = -val % mod;\n\treturn Mod_p(temp, mod);\n\n}\n\n//Multiplication\nMod_p Mod_p::operator *(const Mod_p& el) const{\n\n\tZZ temp;\n\tif (mod != el.get_mod())\n\t{\t\tcout <<\"It is not possible to multiply these elements\" << endl;\n\t\t\treturn Mod_p(0,1);}\n\telse\n\t{\n\t\ttemp = MulMod(val,el.get_val(),mod);\n\t\t\treturn Mod_p(temp, mod);}\n}\n\n//Division\nMod_p Mod_p::operator /(const Mod_p& el) const{\n\n\tZZ temp;\n\tif (mod != el.get_mod())\n\t{\t\tcout <<\"It is not possible to divide these elements\" << endl;\n\t\t\treturn Mod_p(0,1);}\n\telse\n\t{\n\t\ttemp = val*InvMod(el.get_val(), mod) ;\n\t\t\treturn Mod_p(temp, mod);}\n}\n\n//Increment prefix\nMod_p& Mod_p::operator ++(){\n\n\t++val;\n\treturn *this;\n}\n\n//Increment suffix\nMod_p Mod_p::operator ++(int){\n\n Mod_p temp = *this;\n ++val;\n return temp;\n\n\n}\n\n//Decrement prefix\nMod_p& Mod_p::operator --(){\n\n\t--val;\n\treturn *this;\n}\n\n//Decrement suffix\nMod_p Mod_p::operator --(int){\n\n Mod_p temp = *this;\n --val;\n return temp;\n\n\n}\n\n//Equal to\nbool Mod_p::operator ==(const Mod_p& el) const{\n\n\tif (mod == el.get_mod())\n\t{\n\t\tif (val == el.get_val())\n\t\t{\n\t\t\treturn true;\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn false;\n\t\t}\n\t}\n\telse\n\t{\n\t\treturn false;\n\t}\n}\n\n//Not equal to\nbool Mod_p::operator !=(const Mod_p& el) const{\n\n\tif (mod != el.get_mod())\n\t{\n\n\t\treturn true;\n\n\t}\n\telse\n\t{\n\t\tif (val != el.get_val())\n\t\t{\n\t\t\treturn true;\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn false;\n\t\t}\n\t}\n}\n\n//Smaller\nbool Mod_p::operator <(const Mod_p& el) const{\n\n\tif (mod != el.get_mod())\n\t{\n\t\tcout << \"It is not possible to compare to elements with different modulus\" << endl;\n\t\treturn false;\n\n\t}\n\telse\n\t{\n\t\tif (val < el.get_val())\n\t\t{\n\t\t\treturn true;\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn false;\n\t\t}\n\t}\n}\n\n//Bigger\nbool Mod_p::operator >(const Mod_p& el) const{\n\n\tif (mod != el.get_mod())\n\t{\n\t\tcout << \"It is not possible to compare to elements with different modulus\" << endl;\n\t\treturn false;\n\n\t}\n\telse\n\t{\n\t\tif (val > el.get_val())\n\t\t{\n\t\t\treturn true;\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn false;\n\t\t}\n\t}\n}\n\n// Smaller equal\nbool Mod_p::operator <=(const Mod_p& el) const{\n\n\tif (mod != el.get_mod())\n\t{\n\t\tcout << \"It is not possible to compare to elements with different modulus\" << endl;\n\t\treturn false;\n\n\t}\n\telse\n\t{\n\t\tif (val <=el.get_val())\n\t\t{\n\t\t\treturn true;\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn false;\n\t\t}\n\t}\n}\n\n//Bigger equal\nbool Mod_p::operator >=(const Mod_p& el) const{\n\n\tif (mod != el.get_mod())\n\t{\n\t\tcout << \"It is not possible to compare to elements with different modulus\" << endl;\n\t\treturn false;\n\n\t}\n\telse\n\t{\n\t\tif (val >=el.get_val())\n\t\t{\n\t\t\treturn true;\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn false;\n\t\t}\n\t}\n}\n\n//Addition assignment\nMod_p& Mod_p::operator +=(const Mod_p& el){\n\n\tif (mod != el.get_mod())\n\t{\n\t\tcout << \"It is not possible to add these elements\" << endl;\n\t\treturn *this;\n\t}\n\telse\n\t{\n\t\tval = AddMod(val, el.get_val(), mod);\n\t\treturn *this;\n\t}\n}\n\n//Subtraction assignment\nMod_p& Mod_p::operator -=(const Mod_p& el){\n\n\tif (mod != el.get_mod())\n\t{\n\t\tcout << \"It is not possible to add these elements\" << endl;\n\t\treturn *this;\n\t}\n\telse\n\t{\n\t\tval = SubMod(val, el.get_val(), mod);\n\t\treturn *this;\n\t}\n}\n\n//Multiplication assignment\nMod_p& Mod_p::operator *=(const Mod_p& el){\n\n\tif (mod != el.get_mod())\n\t{\n\t\tcout << \"It is not possible to add these elements\" << endl;\n\t\treturn *this;\n\t}\n\telse\n\t{\n\t\tval = MulMod(val, el.get_val(),mod);\n\t\treturn *this;\n\t}\n}\n\n\n//Division assignment\nMod_p& Mod_p::operator /=(const Mod_p& el){\n\n\tif (mod != el.get_mod())\n\t{\n\t\tcout << \"It is not possible to add these elements\" << endl;\n\t\treturn *this;\n\t}\n\telse\n\t{\n\t\tval = MulMod(val,InvMod(el.get_val(),mod), mod);\n\t\treturn *this;\n\t}\n}\n\n//Output operator, output format is val (modular mod)\nostream& operator <<(ostream& os , const Mod_p &b){\n\n\treturn os << b.get_val();\n}\n\n//Input operator,\nistream& operator>>(istream& is, Mod_p &b){\n\tZZ val, mod;\n\n\tis>>val;\n\n\tmod = G.get_mod();\n\tb = Mod_p(val, mod);\n\treturn is;\n}\n\n\n//Returns the inverse modular p of the element\nMod_p Mod_p::inv(){\n\n\tZZ temp;\n\ttemp = InvMod(val,mod);\n\treturn Mod_p(temp,mod);\n}\n\n//Returns the inverse modular p of the element el\nMod_p Mod_p::inv(const Mod_p& el){\n\tZZ temp;\n\tZZ mod=el.get_mod();\n\ttemp = InvMod(el.get_val(),mod);\n\treturn Mod_p(temp, mod);\n\n}\n\nvoid Mod_p::inv(Mod_p&a, const Mod_p& el){\n\tZZ temp;\n\tZZ mod=el.get_mod();\n\tInvMod(temp, el.get_val(),mod);\n\ta= Mod_p(temp, mod);\n\n}\n\n//Multiplication functions\nvoid Mod_p::mult(Mod_p& a , const Mod_p& b, const Mod_p& c){\n\tZZ temp;\n\tZZ mod=b.get_mod();\n\tMulMod(temp,b.get_val(), c.get_val(),mod);\n\ta= Mod_p(temp,mod);\n}\n\n\n//exponentiation functions\nMod_p Mod_p::expo(const long e){\n\n\tZZ temp;\n\ttemp = PowerMod(val,e,mod);\n\treturn Mod_p(temp,mod);\n}\n\nMod_p Mod_p::expo(Mod_p& a, long e){\n\n\tZZ temp;\n\tZZ mod=a.get_mod();\n\ttemp = PowerMod(a.get_val(),e,mod);\n\treturn Mod_p(temp,mod);\n}\n\nvoid Mod_p::expo(Mod_p& a ,const Mod_p& b,const long e){\n\tZZ temp;\n\tZZ mod=b.get_mod();\n\tPowerMod(temp, b.get_val(),e,mod);\n\ta= Mod_p(temp,mod);\n}\n\nvoid Mod_p::expo(Mod_p& a , const Mod_p& b, const ZZ e){\n\tZZ temp;\n\tZZ mod=b.get_mod();\n\tPowerMod(temp, b.get_val(), e, mod);\n\ta= Mod_p(temp,mod);\n}\n\nMod_p Mod_p::expo(const ZZ e){\n\n\tZZ temp;\n\tPowerMod(temp, val,e, mod);\n\treturn Mod_p(temp,mod);\n}\n\nMod_p Mod_p::expo( Mod_p& a, ZZ e){\n\n\tZZ temp;\n\tZZ mod=a.get_mod();\n\ttemp = PowerMod(a.get_val(),e,mod);\n\treturn Mod_p(temp,a.mod);\n}\n\n", "meta": {"hexsha": "2896cbeef7c289f12ae887380d86805ca53d4683", "size": 7615, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/Mod_p.cpp", "max_stars_repo_name": "3for/verifiable-shuffle", "max_stars_repo_head_hexsha": "73f92b41bbe76eee4ef8ad35e6ccf7e83acef28b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2018-01-11T14:06:41.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-27T08:28:26.000Z", "max_issues_repo_path": "src/Mod_p.cpp", "max_issues_repo_name": "3for/verifiable-shuffle", "max_issues_repo_head_hexsha": "73f92b41bbe76eee4ef8ad35e6ccf7e83acef28b", "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/Mod_p.cpp", "max_forks_repo_name": "3for/verifiable-shuffle", "max_forks_repo_head_hexsha": "73f92b41bbe76eee4ef8ad35e6ccf7e83acef28b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-04-13T06:11:06.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-03T15:21:49.000Z", "avg_line_length": 14.9021526419, "max_line_length": 85, "alphanum_fraction": 0.6231122784, "num_tokens": 2394, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8289388252252041, "lm_q2_score": 0.6513548511303338, "lm_q1q2_score": 0.5399333251007166}} {"text": "\n#include \n#include \n#include \n\n#include \n\n#include \"convex_nmf.hpp\"\n#include \"progress_reporter.hpp\"\n#include \"projections.hpp\"\n\nnamespace convexnmf {\n\nvoid ConvexNMF::SetSparsifierType(const std::string &type_name, bool verbose) {\n\n if (type_name == \"L2\") {\n if (verbose)\n std::cout << \"Set Sparsifier to L2.\" << std::endl;\n sparsifier_type = SparsifierType::L2;\n } else if (type_name == \"LInfty\") {\n if (verbose)\n std::cout << \"Set Sparsifier to LInfty.\" << std::endl;\n sparsifier_type = SparsifierType::LInfty;\n } else {\n std::string current_setting = sparsifier_type == SparsifierType::L2 ? \"L2\" : \"LInfty\";\n std::cout << \"Sparsifier type not recognized so not set, choose either 'L2' or 'LInfty'.\";\n std::cout << \" Currently set to \" + current_setting + \" \\n\";\n }\n}\n\nConvexNMFResults ConvexNMF::Fit(const MatrixRef &X, Scalar lambda) {\n // TODO: Can move this to the Python front end.\n int N = X.cols();\n Matrix W_init = Matrix::Identity(N, N);\n return Fit(X, lambda, W_init);\n}\n\nConvexNMFResults ConvexNMF::Fit(const MatrixRef &X, Scalar lambda, const MatrixRef &W_init) {\n\n ConvexNMFProgressReporter reporter;\n auto sparsifier = RowSparsifier::Create(sparsifier_type);\n // W Update set up\n int N = X.cols();\n int T = X.rows();\n\n Matrix XTXplusDeltaId = X.transpose() * X + rho * Matrix::Identity(N, N);\n Matrix XTX = X.transpose() * X;\n\n std::cout << \"Factoring .... \";\n Eigen::LLT cholesky_solver;\n cholesky_solver.compute(XTXplusDeltaId);\n std::cout << \"Done. \\n\";\n\n // Set up W, Z, U\n const Scalar sqrt_size = static_cast(std::sqrt(N * N));\n Matrix W = W_init;\n Matrix Z_1 = W_init, Z_2 = W_init, Z_3 = W_init;\n Matrix Y_1 = Matrix::Identity(N, N), Y_2 = Matrix::Identity(N, N), Y_3 = Matrix::Identity(N, N);\n\n if (report_progress) {\n reporter.PrintHeader();\n }\n\n for (int iteration = 1; iteration <= max_iterations; ++iteration) {\n // Updates\n\n Matrix previous_average = (Z_1 + Z_2 + Z_3) / 3.0; // Used in monitoring convergence.\n\n Z_1 = cholesky_solver.solve(XTX + rho * W - Y_1);\n Z_2 = sparsifier->Evaluate(W - Y_2 / rho, lambda, rho);\n Z_3 = (W - Y_3 / rho).cwiseMax(0.0);\n\n W = (Z_1 + Z_2 + Z_3 + (Y_1 + Y_2 + Y_3) / rho) / 3.0;\n\n Y_1 = Y_1 + rho * (Z_1 - W);\n Y_2 = Y_2 + rho * (Z_2 - W);\n Y_3 = Y_3 + rho * (Z_3 - W);\n\n // check primal and dual residual\n Scalar primal_squared =\n (W - Z_1).squaredNorm() + (W - Z_2).squaredNorm() + (W - Z_3).squaredNorm();\n Scalar primal = std::sqrt(primal_squared);\n\n Matrix current_average = (Z_1 + Z_2 + Z_3) / 3.0;\n Scalar dual = 3.0 * rho * (current_average - previous_average).norm();\n\n Scalar z_norm = std::sqrt(Z_1.squaredNorm() + Z_2.squaredNorm() + Z_3.squaredNorm());\n Scalar primal_tol = std::sqrt(3.0) * abs_tolerance * sqrt_size +\n relative_tolerance * std::max(3 * W.norm(), z_norm);\n Scalar dual_tol = abs_tolerance * sqrt_size + relative_tolerance * (Y_1 + Y_2 + Y_3).norm();\n\n if (report_progress && (iteration % iteration_to_print == 0)) {\n reporter.PrintStatistics(iteration, primal, primal_tol, dual, dual_tol);\n }\n if ((primal < primal_tol) && (dual < dual_tol)) {\n\n ConvexNMFResults results{W, primal, dual, true};\n if (report_progress) {\n reporter.PrintConverged(iteration, primal, primal_tol, dual, dual_tol);\n }\n return results;\n } else if (iteration == max_iterations) {\n ConvexNMFResults results{W, primal, dual, false};\n if (report_progress) {\n reporter.PrintHitMaxIterations(iteration, primal, primal_tol, dual, dual_tol);\n }\n return results;\n }\n }\n}\n\n} // namespace convexnmf\n", "meta": {"hexsha": "23bfb806e11bbaf369d495f6ba36fedeaa27a41f", "size": 4058, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/convex_nmf.cpp", "max_stars_repo_name": "miketoastmacneil/cvxnmf", "max_stars_repo_head_hexsha": "86011cf202406b7ee10ce618e433bcf82454ec73", "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/convex_nmf.cpp", "max_issues_repo_name": "miketoastmacneil/cvxnmf", "max_issues_repo_head_hexsha": "86011cf202406b7ee10ce618e433bcf82454ec73", "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/convex_nmf.cpp", "max_forks_repo_name": "miketoastmacneil/cvxnmf", "max_forks_repo_head_hexsha": "86011cf202406b7ee10ce618e433bcf82454ec73", "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": 35.9115044248, "max_line_length": 100, "alphanum_fraction": 0.5889600789, "num_tokens": 1172, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8289387914176259, "lm_q2_score": 0.6513548646660542, "lm_q1q2_score": 0.5399333143002703}} {"text": "/* Boost libs/numeric/odeint/performance/openmp/osc_chain_1d_system.hpp\n\n Copyright 2013 Karsten Ahnert\n Copyright 2013 Mario Mulansky\n Copyright 2013 Pascal Germroth\n\n stronlgy nonlinear hamiltonian lattice\n\n Distributed under the Boost Software License, Version 1.0.\n(See accompanying file LICENSE_1_0.txt or\n copy at http://www.boost.org/LICENSE_1_0.txt)\n */\n\n#ifndef SYSTEM_HPP\n#define SYSTEM_HPP\n\n#include \n#include \n#include \n\n#include \n\n#include \n#include \n\nnamespace checked_math {\n inline double pow( double x , double y )\n {\n if( x==0.0 )\n // 0**y = 0, don't care for y = 0 or NaN\n return 0.0;\n using std::pow;\n using std::abs;\n return pow( abs(x) , y );\n }\n}\n\ndouble signed_pow( double x , double k )\n{\n using boost::math::sign;\n return checked_math::pow( x , k ) * sign(x);\n}\n\nstruct osc_chain {\n\n const double m_kap, m_lam;\n\n osc_chain( const double kap , const double lam )\n : m_kap( kap ) , m_lam( lam )\n { }\n\n // Simple case with openmp_range_algebra\n void operator()( const std::vector &q ,\n std::vector &dpdt ) const\n {\n const size_t N = q.size();\n double coupling_lr = 0;\n size_t last_i = N;\n #pragma omp parallel for firstprivate(coupling_lr, last_i) lastprivate(coupling_lr) schedule(runtime)\n for(size_t i = 0 ; i < N - 1 ; ++i)\n {\n if(i > 0 && i != last_i + 1)\n coupling_lr = signed_pow( q[i-1]-q[i] , m_lam-1 );\n dpdt[i] = -signed_pow( q[i] , m_kap-1 ) + coupling_lr;\n coupling_lr = signed_pow( q[i] - q[i+1] , m_lam-1 );\n dpdt[i] -= coupling_lr;\n last_i = i;\n }\n dpdt[N-1] = -signed_pow( q[N-1] , m_kap-1 ) + coupling_lr;\n }\n\n // Split case with openmp_algebra\n void operator()( const boost::numeric::odeint::openmp_state &q ,\n boost::numeric::odeint::openmp_state &dpdt ) const\n {\n const size_t M = q.size();\n #pragma omp parallel for schedule(runtime)\n for(size_t i = 0 ; i < M ; ++i)\n {\n const std::vector &_q = q[i];\n std::vector &_dpdt = dpdt[i];\n const size_t N = q[i].size();\n double coupling_lr = 0;\n if(i > 0) coupling_lr = signed_pow( q[i-1].back() - _q[0] , m_lam-1 );\n for(size_t j = 0 ; j < N-1 ; ++j)\n {\n _dpdt[j] = -signed_pow( _q[j] , m_kap-1 ) + coupling_lr;\n coupling_lr = signed_pow( _q[j] - _q[j+1] , m_lam-1 );\n _dpdt[j] -= coupling_lr;\n }\n _dpdt[N-1] = -signed_pow( _q[N-1] , m_kap-1 ) + coupling_lr;\n if(i + 1 < M) _dpdt[N-1] -= signed_pow( _q[N-1] - q[i+1].front() , m_lam-1 );\n }\n }\n\n};\n\n#endif\n", "meta": {"hexsha": "d9a6c222d64a8f126d9f86f297187ab93c435ada", "size": 2986, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "boost/boost_1_56_0/libs/numeric/odeint/performance/openmp/osc_chain_1d_system.hpp", "max_stars_repo_name": "cooparation/caffe-android", "max_stars_repo_head_hexsha": "cd91078d1f298c74fca4c242531989d64a32ba03", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 85.0, "max_stars_repo_stars_event_min_datetime": "2015-02-08T20:36:17.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-14T20:38:31.000Z", "max_issues_repo_path": "boost/boost_1_56_0/libs/numeric/odeint/performance/openmp/osc_chain_1d_system.hpp", "max_issues_repo_name": "cooparation/caffe-android", "max_issues_repo_head_hexsha": "cd91078d1f298c74fca4c242531989d64a32ba03", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 61.0, "max_issues_repo_issues_event_min_datetime": "2015-05-27T11:20:11.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-20T15:06:21.000Z", "max_forks_repo_path": "boost/boost_1_56_0/libs/numeric/odeint/performance/openmp/osc_chain_1d_system.hpp", "max_forks_repo_name": "cooparation/caffe-android", "max_forks_repo_head_hexsha": "cd91078d1f298c74fca4c242531989d64a32ba03", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 27.0, "max_forks_repo_forks_event_min_datetime": "2015-01-28T16:33:30.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-12T05:04:39.000Z", "avg_line_length": 30.1616161616, "max_line_length": 109, "alphanum_fraction": 0.5562625586, "num_tokens": 876, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8289387998695209, "lm_q2_score": 0.6513548578981939, "lm_q1q2_score": 0.5399333141953112}} {"text": "#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing Sophus::SE3;\nusing Sophus::SO3;\n\n/************************************************\n * 本程序演示如何用 gtsam 进行位姿图优化\n * sphere.g2o 是人工生成的一个 Pose graph，我们来优化它。\n * 与 g2o 相似，在 gtsam 中添加的是因子，相当于误差\n * **********************************************/\n\nint main(int argc, char** argv) {\n if (argc != 2) {\n cout << \"Usage: pose_graph_gtsam sphere.g2o\" << endl;\n return 1;\n }\n ifstream fin(argv[1]);\n if (!fin) {\n cout << \"file \" << argv[1] << \" does not exist.\" << endl;\n return 1;\n }\n\n gtsam::NonlinearFactorGraph::shared_ptr graph(\n new gtsam::NonlinearFactorGraph); // gtsam的因子图\n gtsam::Values::shared_ptr initial(new gtsam::Values); // 初始值\n // 从g2o文件中读取节点和边的信息\n int cntVertex = 0, cntEdge = 0;\n cout << \"reading from g2o file\" << endl;\n\n while (!fin.eof()) {\n string tag;\n fin >> tag;\n if (tag == \"VERTEX_SE3:QUAT\") {\n // 顶点\n gtsam::Key id;\n fin >> id;\n double data[7];\n for (int i = 0; i < 7; i++) fin >> data[i];\n // 转换至gtsam的Pose3\n gtsam::Rot3 R =\n gtsam::Rot3::Quaternion(data[6], data[3], data[4], data[5]);\n gtsam::Point3 t(data[0], data[1], data[2]);\n initial->insert(id, gtsam::Pose3(R, t)); // 添加初始值\n cntVertex++;\n } else if (tag == \"EDGE_SE3:QUAT\") {\n // 边，对应到因子图中的因子\n gtsam::Matrix m = gtsam::I_6x6; // 信息矩阵\n gtsam::Key id1, id2;\n fin >> id1 >> id2;\n double data[7];\n for (int i = 0; i < 7; i++) fin >> data[i];\n gtsam::Rot3 R =\n gtsam::Rot3::Quaternion(data[6], data[3], data[4], data[5]);\n gtsam::Point3 t(data[0], data[1], data[2]);\n for (int i = 0; i < 6; i++)\n for (int j = i; j < 6; j++) {\n double mij;\n fin >> mij;\n m(i, j) = mij;\n m(j, i) = mij;\n }\n\n // g2o的信息矩阵定义方式与gtsam不同，这里对它进行修改\n gtsam::Matrix mgtsam = gtsam::I_6x6;\n mgtsam.block<3, 3>(0, 0) = m.block<3, 3>(3, 3); // cov rotation\n mgtsam.block<3, 3>(3, 3) = m.block<3, 3>(0, 0); // cov translation\n mgtsam.block<3, 3>(0, 3) = m.block<3, 3>(0, 3); // off diagonal\n mgtsam.block<3, 3>(3, 0) = m.block<3, 3>(3, 0); // off diagonal\n\n gtsam::SharedNoiseModel model =\n gtsam::noiseModel::Gaussian::Information(mgtsam); // 高斯噪声模型\n gtsam::NonlinearFactor::shared_ptr factor(\n new gtsam::BetweenFactor(id1, id2, gtsam::Pose3(R, t),\n model) // 添加一个因子\n );\n graph->push_back(factor);\n cntEdge++;\n }\n if (!fin.good()) break;\n }\n\n cout << \"read total \" << cntVertex << \" vertices, \" << cntEdge << \" edges.\"\n << endl;\n // 固定第一个顶点，在gtsam中相当于添加一个先验因子\n gtsam::NonlinearFactorGraph graphWithPrior = *graph;\n gtsam::noiseModel::Diagonal::shared_ptr priorModel =\n gtsam::noiseModel::Diagonal::Variances(\n (gtsam::Vector(6) << 1e-6, 1e-6, 1e-6, 1e-6, 1e-6, 1e-6).finished());\n gtsam::Key firstKey = 0;\n for (const gtsam::Values::ConstKeyValuePair& key_value : *initial) {\n cout << \"Adding prior to g2o file \" << endl;\n graphWithPrior.add(gtsam::PriorFactor(\n key_value.key, key_value.value.cast(), priorModel));\n break;\n }\n\n // 开始因子图优化，配置优化选项\n cout << \"optimizing the factor graph\" << endl;\n // 我们使用 LM 优化\n gtsam::LevenbergMarquardtParams params_lm;\n params_lm.setVerbosity(\"ERROR\");\n params_lm.setMaxIterations(20);\n params_lm.setLinearSolverType(\"MULTIFRONTAL_QR\");\n gtsam::LevenbergMarquardtOptimizer optimizer_LM(graphWithPrior, *initial,\n params_lm);\n\n // 你可以尝试下 GN\n // gtsam::GaussNewtonParams params_gn;\n // params_gn.setVerbosity(\"ERROR\");\n // params_gn.setMaxIterations(20);\n // params_gn.setLinearSolverType(\"MULTIFRONTAL_QR\");\n // gtsam::GaussNewtonOptimizer optimizer ( graphWithPrior, *initial, params_gn\n // );\n\n gtsam::Values result = optimizer_LM.optimize();\n cout << \"Optimization complete\" << endl;\n cout << \"initial error: \" << graph->error(*initial) << endl;\n cout << \"final error: \" << graph->error(result) << endl;\n\n cout << \"done. write to g2o ... \" << endl;\n // 写入 g2o 文件，同样伪装成 g2o 中的顶点和边，以便用 g2o_viewer 查看。\n // 顶点咯\n ofstream fout(\"result_gtsam.g2o\");\n for (const gtsam::Values::ConstKeyValuePair& key_value : result) {\n gtsam::Pose3 pose = key_value.value.cast();\n gtsam::Point3 p = pose.translation();\n gtsam::Quaternion q = pose.rotation().toQuaternion();\n fout << \"VERTEX_SE3:QUAT \" << key_value.key << \" \" << p.x() << \" \" << p.y()\n << \" \" << p.z() << \" \" << q.x() << \" \" << q.y() << \" \" << q.z() << \" \"\n << q.w() << \" \" << endl;\n }\n // 边咯\n for (gtsam::NonlinearFactor::shared_ptr factor : *graph) {\n gtsam::BetweenFactor::shared_ptr f =\n dynamic_pointer_cast>(factor);\n if (f) {\n gtsam::SharedNoiseModel model = f->noiseModel();\n gtsam::noiseModel::Gaussian::shared_ptr gaussianModel =\n dynamic_pointer_cast(model);\n if (gaussianModel) {\n // write the edge information\n gtsam::Matrix info =\n gaussianModel->R().transpose() * gaussianModel->R();\n gtsam::Pose3 pose = f->measured();\n gtsam::Point3 p = pose.translation();\n gtsam::Quaternion q = pose.rotation().toQuaternion();\n fout << \"EDGE_SE3:QUAT \" << f->key1() << \" \" << f->key2() << \" \"\n << p.x() << \" \" << p.y() << \" \" << p.z() << \" \" << q.x() << \" \"\n << q.y() << \" \" << q.z() << \" \" << q.w() << \" \";\n gtsam::Matrix infoG2o = gtsam::I_6x6;\n infoG2o.block(0, 0, 3, 3) = info.block(3, 3, 3, 3); // cov translation\n infoG2o.block(3, 3, 3, 3) = info.block(0, 0, 3, 3); // cov rotation\n infoG2o.block(0, 3, 3, 3) = info.block(0, 3, 3, 3); // off diagonal\n infoG2o.block(3, 0, 3, 3) = info.block(3, 0, 3, 3); // off diagonal\n for (int i = 0; i < 6; i++)\n for (int j = i; j < 6; j++) {\n fout << infoG2o(i, j) << \" \";\n }\n fout << endl;\n }\n }\n }\n fout.close();\n cout << \"done.\" << endl;\n}\n", "meta": {"hexsha": "4e1d3409666b61e65bd7d015eb372680a4bfa7bf", "size": 6524, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ch11/pose_graph_gtsam.cpp", "max_stars_repo_name": "duyanwei/slambook", "max_stars_repo_head_hexsha": "0e257f885d7b31ef6272311c49ce4654d690ef97", "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": "ch11/pose_graph_gtsam.cpp", "max_issues_repo_name": "duyanwei/slambook", "max_issues_repo_head_hexsha": "0e257f885d7b31ef6272311c49ce4654d690ef97", "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": "ch11/pose_graph_gtsam.cpp", "max_forks_repo_name": "duyanwei/slambook", "max_forks_repo_head_hexsha": "0e257f885d7b31ef6272311c49ce4654d690ef97", "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.4469273743, "max_line_length": 80, "alphanum_fraction": 0.5571735132, "num_tokens": 2323, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933359135361, "lm_q2_score": 0.6584175139669997, "lm_q1q2_score": 0.5398321319503006}} {"text": "#include \n#include \n\n#include \nnamespace ba = boost::adaptors;\n\n#include \n#include \n#include \n#include \n#include \n\nnamespace d = dionysus;\n\n#include \n\n//typedef d::Z2Field K;\ntypedef d::ZpField<> K;\ntypedef d::Simplex<> Simplex;\ntypedef d::Filtration Filtration;\n//typedef d::ZigzagFiltration Filtration;\ntypedef d::ZigzagPersistence Persistence;\n\ntypedef typename Persistence::Index Index;\ntypedef typename Filtration::Cell Cell;\ntypedef d::ChainEntry CellChainEntry;\ntypedef d::ChainEntry ChainEntry;\n\n\nint main()\n{\n K k(11);\n Filtration filtration { Simplex{0}, Simplex{1}, Simplex{2}, Simplex{0,1}, Simplex{0,2}, Simplex{1,2}, Simplex{0,1,2} };\n Persistence persistence(k);\n\n unsigned op = 0;\n for(auto& c : filtration)\n {\n fmt::print(\"[{}] Adding: {} : {}\\n\", op++, c, boost::distance(c.boundary(persistence.field())));\n Index pair = persistence.add(c.boundary(persistence.field()) |\n ba::transformed([&filtration](const CellChainEntry& e)\n { return ChainEntry(e.element(), filtration.index(e.index())); }));\n //if (pair != persistence.unpaired())\n // std::cout << \"[\" << pair << \" - \" << i << \"]\" << std::endl;\n //++i;\n }\n\n for (int i = 6; i >= 0; --i)\n {\n fmt::print(\"[{}] Removing: {}\\n\", op++, i);\n Index pair = persistence.remove(i);\n if (pair == Persistence::unpaired())\n fmt::print(\"Birth\\n\");\n else\n fmt::print(\"Death: {}\\n\", pair);\n }\n}\n", "meta": {"hexsha": "c1de4eeea74c5a518852944fb99c5e0ebd5be106", "size": 1994, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/filtration/zigzag-filtration-persistence.cpp", "max_stars_repo_name": "dlm/dionysus", "max_stars_repo_head_hexsha": "f7768668c6820adb1d49db291270ae3a99e14d18", "max_stars_repo_licenses": ["BSD-3-Clause-LBNL"], "max_stars_count": 114.0, "max_stars_repo_stars_event_min_datetime": "2017-07-19T21:43:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T07:54:11.000Z", "max_issues_repo_path": "examples/filtration/zigzag-filtration-persistence.cpp", "max_issues_repo_name": "dlm/dionysus", "max_issues_repo_head_hexsha": "f7768668c6820adb1d49db291270ae3a99e14d18", "max_issues_repo_licenses": ["BSD-3-Clause-LBNL"], "max_issues_count": 50.0, "max_issues_repo_issues_event_min_datetime": "2017-07-19T21:39:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-02T17:40:19.000Z", "max_forks_repo_path": "examples/filtration/zigzag-filtration-persistence.cpp", "max_forks_repo_name": "dlm/dionysus", "max_forks_repo_head_hexsha": "f7768668c6820adb1d49db291270ae3a99e14d18", "max_forks_repo_licenses": ["BSD-3-Clause-LBNL"], "max_forks_count": 27.0, "max_forks_repo_forks_event_min_datetime": "2017-08-17T17:11:49.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-21T09:59:57.000Z", "avg_line_length": 34.3793103448, "max_line_length": 128, "alphanum_fraction": 0.5260782347, "num_tokens": 502, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933447152498, "lm_q2_score": 0.658417487156366, "lm_q1q2_score": 0.539832115763643}} {"text": "#include \n// #include \n#include \n#include \n\n\ntemplate< typename matrix_type, typename vector_type, typename left_precon_type, \n\t typename right_precon_type, typename iter_type >\nvoid test_solver(const matrix_type& A, vector_type& x, const vector_type& b, \n\t const left_precon_type& L, const right_precon_type& R, iter_type& iter)\n{\n itl::bicg(A, x, b, L, iter); // GEHT NICHT!\n itl::bicgstab(A, x, b, L, iter);\n itl::bicgstab_2(A, x, b, L, iter);\n itl::bicgstab_ell(A, x, b, L, R, iter, 3);\n itl::cg(A, x, b, L, R, iter);\n itl::cgs(A, x, b, L, iter);\n itl::gmres(A, x, b, L, R, iter, 30);\n itl::qmr(A, x, b, L, R, iter);\n itl::idr_s(A, x, b, L, R, iter,3);\n itl::tfqmr(A, x, b, L, R, iter);\n}\n\ntemplate< typename matrix_type, typename vector_type >\nint trans_test(const matrix_type& A, vector_type& x, const vector_type& b)\n{\n using namespace mtl;\n using namespace itl;\n \n typedef mat::transposed_view trans_matrix_type;\n trans_matrix_type B(A);\n \n // Create an ILU(0) preconditioner\n pc::ilu_0 \tP0(A);\n pc::ilu_0\tP1(B);\n \n pc::identity\t\tId0(A);\n pc::identity \tId1(B);\n \n // Termination criterion: r < 1e-6 * b or N iterations\n noisy_iteration iter(b, 500, 1.e-6);\n \n test_solver(A, x, b, P0, Id0, iter);\n test_solver(A, x, b, P1, Id1, iter); // GEHT NICHT!\n test_solver(B, x, b, P0, Id0, iter);\n test_solver(B, x, b, P1, Id1, iter); // GEHT NICHT!\n\n return 0;\n}\n\nint main(// int argc, char* argv[]\n\t ) \n{\n using namespace mtl;\n\n // mtl::par::environment env(argc, argv);\n\n const int size = 10, N = size * size;\n // typedef mat::distributed > matrix_type;\n typedef compressed2D matrix_type;\n matrix_type A;\n laplacian_setup(A, size, size);\n \n mtl::dense_vector x(N, 1.0), b;\n \n b= A * x;\n x= 0;\n \n int error_code = trans_test(A, x, b);\n \n return error_code;\n}\n", "meta": {"hexsha": "94886206f28d3e0f303654a84260ad935f523fff", "size": 2191, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libs/numeric/itl/test/trans_trans_solver_test.cpp", "max_stars_repo_name": "lit-uriy/mtl4-mirror", "max_stars_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_stars_repo_licenses": ["MTLL"], "max_stars_count": 24.0, "max_stars_repo_stars_event_min_datetime": "2019-03-26T15:25:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T10:00:45.000Z", "max_issues_repo_path": "libs/numeric/itl/test/trans_trans_solver_test.cpp", "max_issues_repo_name": "lit-uriy/mtl4-mirror", "max_issues_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_issues_repo_licenses": ["MTLL"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2020-04-17T12:35:32.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-03T15:46:25.000Z", "max_forks_repo_path": "libs/numeric/itl/test/trans_trans_solver_test.cpp", "max_forks_repo_name": "lit-uriy/mtl4-mirror", "max_forks_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_forks_repo_licenses": ["MTLL"], "max_forks_count": 10.0, "max_forks_repo_forks_event_min_datetime": "2019-12-01T13:40:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-14T08:39:54.000Z", "avg_line_length": 30.0136986301, "max_line_length": 81, "alphanum_fraction": 0.6042902784, "num_tokens": 718, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933359135361, "lm_q2_score": 0.658417487156366, "lm_q1q2_score": 0.5398321099684408}} {"text": "////////////////////////////////////////////////////////////////////////////////////////////////////\n// This file is part of CosmoScout VR //\n// and may be used under the terms of the MIT license. See the LICENSE file for details. //\n// Copyright: (c) 2019 German Aerospace Center (DLR) //\n////////////////////////////////////////////////////////////////////////////////////////////////////\n\n#ifndef CS_UTILS_CONVERSIONS_HPP\n#define CS_UTILS_CONVERSIONS_HPP\n\n#include \"cs_utils_export.hpp\"\n\n#include \n#include \n\n#include \n#include \n\n/// This namespace contains utility functions for converting numbers between different units of\n/// measuring.\nnamespace cs::utils::convert {\n\ntemplate \nT lightyearsToMeters(T lightyears) {\n return lightyears * 9460730472580800.0;\n}\n\ntemplate \nT metersToLightyears(T meters) {\n return meters / 9460730472580800.0;\n}\n\n/// Converts AU to meters. One AU is equivalent to the average distance between the Earth and the\n///// Sun.\ntemplate \nT astronomicalUnitsToMeters(T astronomicalUnits) {\n return astronomicalUnits * 149597870700.0;\n}\n\n/// Converts meters to AU. One AU is equivalent to the average distance between the Earth and the\n/// Sun.\ntemplate \nT metersToAstronomicalUnits(T meters) {\n return meters / 149597870700.0;\n}\n\ntemplate \nT toRadians(T degrees) {\n return degrees * glm::pi() / 180.0;\n}\n\ntemplate \nT toDegrees(T radians) {\n return radians * 180.0 / glm::pi();\n}\n\n/// Transform cartesian (x,y,z) coordinates to geodetic (lng, lat, height above surface)\n/// coordinates.\nCS_UTILS_EXPORT glm::dvec3 toLngLatHeight(\n glm::dvec3 const& cartesian, double radiusE, double radiusP);\n\n/// Transform geodetic coordinates (lng, lat) LngLat and elevation height to cartesian (x,y,z)\n/// coordinates for an ellipsoid of equatorial radius radiusE and polar radius radiusP. Height is an\n/// offset along the normal of the ellipsoid at (lng, lat).\nCS_UTILS_EXPORT glm::dvec3 toCartesian(\n glm::dvec2 const& lngLat, double radiusE, double radiusP, double height = 0.0);\n\n/// Convert latitudes.\nCS_UTILS_EXPORT double geocentricToGeodetic(double lat, double radiusE, double radiusP);\nCS_UTILS_EXPORT double geocentricToParametric(double lat, double radiusE, double radiusP);\nCS_UTILS_EXPORT double geodeticToGeocentric(double lat, double radiusE, double radiusP);\nCS_UTILS_EXPORT double geodeticToParametric(double lat, double radiusE, double radiusP);\nCS_UTILS_EXPORT double parametricToGeocentric(double lat, double radiusE, double radiusP);\nCS_UTILS_EXPORT double parametricToGeodetic(double lat, double radiusE, double radiusP);\n\n/// Returns the normal vector (unit length) to the ellipsoid with equatorial radius radiusE and\n/// polar radius radiusP at geodetic coordinates (lng, lat) LngLat.\nCS_UTILS_EXPORT glm::dvec3 lngLatToNormal(glm::dvec2 const& lngLat, double radiusE, double radiusP);\n\n/// Returns the geodetic coordinates (lng, lat) for a given normal vector.\nCS_UTILS_EXPORT glm::dvec2 normalToLngLat(glm::dvec3 const& normal, double radiusE, double radiusP);\n\n/// Convert boost::posix_time::ptime to spice time, which is defined by the\n/// Barycentric Dynamical Time.\nCS_UTILS_EXPORT double toSpiceTime(boost::posix_time::ptime const& tIn);\n\n/// Convert a time string to spice time, which is defined by the Barycentric Dynamical Time.\nCS_UTILS_EXPORT double toSpiceTime(std::string const& tIn);\n\n/// Convert time in seconds since 2000-01-01 12:00:00.000 to boost::posix_time::ptime. Be\n/// aware, that fractional seconds will be truncated. //DocTODO\nCS_UTILS_EXPORT boost::posix_time::ptime toBoostTime(double tIn);\n\n} // namespace cs::utils::convert\n\n#endif // CS_UTILS_CONVERSIONS_HPP\n", "meta": {"hexsha": "e5e597dd6e347fa3f1d7c3e54fff223aec3a3423", "size": 3968, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/cs-utils/convert.hpp", "max_stars_repo_name": "bernstein/cosmoscout-vr", "max_stars_repo_head_hexsha": "4243384a0f96853dc12fc8e9d5862c9c37f7cadf", "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/cs-utils/convert.hpp", "max_issues_repo_name": "bernstein/cosmoscout-vr", "max_issues_repo_head_hexsha": "4243384a0f96853dc12fc8e9d5862c9c37f7cadf", "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/cs-utils/convert.hpp", "max_forks_repo_name": "bernstein/cosmoscout-vr", "max_forks_repo_head_hexsha": "4243384a0f96853dc12fc8e9d5862c9c37f7cadf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.3333333333, "max_line_length": 100, "alphanum_fraction": 0.7111895161, "num_tokens": 941, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8333246118695629, "lm_q2_score": 0.6477982043529715, "lm_q1q2_score": 0.5398261872122397}} {"text": "// C++ code to wrap some Boost functions and be able to use them in C.\n\n#include \n#include \"common_factor.h\"\n\nint boost_gcd (int a, int b) {\n return boost::integer::gcd(a, b);\n}\n\nint boost_lcm (int a, int b) {\n return boost::integer::lcm(a, b);\n}\n", "meta": {"hexsha": "b6f76b878dec86d636da1bb6276db7ff30fe43b7", "size": 294, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Boost-common-factor/C_wrapper/common_factor.cpp", "max_stars_repo_name": "spainisnotequal/cffi-play", "max_stars_repo_head_hexsha": "02407c428052cd1c135a5c7c14d4b71a7fa9d41e", "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": "Boost-common-factor/C_wrapper/common_factor.cpp", "max_issues_repo_name": "spainisnotequal/cffi-play", "max_issues_repo_head_hexsha": "02407c428052cd1c135a5c7c14d4b71a7fa9d41e", "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": "Boost-common-factor/C_wrapper/common_factor.cpp", "max_forks_repo_name": "spainisnotequal/cffi-play", "max_forks_repo_head_hexsha": "02407c428052cd1c135a5c7c14d4b71a7fa9d41e", "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": 22.6153846154, "max_line_length": 70, "alphanum_fraction": 0.6530612245, "num_tokens": 82, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8333245870332531, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5398261824558196}} {"text": "/*\n * \n * Copyright (c) Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003\n *\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n * http://www.boost.org/LICENSE_1_0.txt)\n *\n * KF acknowledges the support of the Faculty of Civil Engineering, \n * University of Zagreb, Croatia.\n *\n */\n\n#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEES_HPP\n#define BOOST_NUMERIC_BINDINGS_LAPACK_GEES_HPP\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK \n# include \n# include \n#endif \n\n\nnamespace boost { namespace numeric { namespace bindings { \n\n namespace lapack {\n\n ///////////////////////////////////////////////////////////////////\n //\n // Schur factorization of general matrix.\n // \n ///////////////////////////////////////////////////////////////////\n\n /* \n * gees() computes a Schur factorization of an N-by-N matrix A.\n *\n * The Schur decomposition is A = U S * herm(U) where U is a\n * unitary matrix and S is upper triangular. The eigenvalues of A\n * are on the main diagonal of S. If A is real, S is in pseudo\n * upper triangular form.\n *\n * Workspace is organized following the arguments in the calling sequence.\n * optimal_workspace() : for optimizing use of blas 3 kernels\n * minimal_workspace() : minimum size of workarrays, but does not allow for optimization\n * of blas 3 kernels\n * workspace( work ) for real matrices where work is a real array with\n * vector_size( work ) >= 3*matrix_size1( a )\n * workspace( work, rwork ) for complex matrices where work is a complex\n * array with vector_size( work ) >= 2*matrix_size1( a )\n * and rwork is a real array with\n * vector_size( rwork ) >= matrix_size1( a ).\n */ \n\n namespace detail {\n inline \n void gees (char const jobvs, char const sort, logical_t* select, int const n,\n float* a, int const lda, int& sdim, traits::complex_f* w,\n float* vs, int const ldvs, float* work, int const lwork,\n bool* bwork, int& info) \n {\n traits::detail::array wr(n);\n traits::detail::array wi(n);\n LAPACK_SGEES (&jobvs, &sort, select, &n, a, &lda, &sdim,\n traits::vector_storage(wr), traits::vector_storage(wi),\n vs, &ldvs, work, &lwork, bwork, &info);\n traits::detail::interlace(traits::vector_storage(wr),\n traits::vector_storage(wr)+n,\n traits::vector_storage(wi),\n w);\n }\n\n\n inline \n void gees (char const jobvs, char const sort, logical_t* select, int const n,\n double* a, int const lda, int& sdim, traits::complex_d* w,\n double* vs, int const ldvs, double* work, int const lwork,\n bool* bwork, int& info) \n {\n traits::detail::array wr(n);\n traits::detail::array wi(n);\n LAPACK_DGEES (&jobvs, &sort, select, &n, a, &lda, &sdim,\n traits::vector_storage(wr), traits::vector_storage(wi),\n vs, &ldvs, work, &lwork, bwork, &info);\n traits::detail::interlace(traits::vector_storage(wr),\n traits::vector_storage(wr)+n,\n traits::vector_storage(wi),\n w);\n }\n\n\n inline \n void gees (char const jobvs, char const sort, logical_t* select, int const n,\n traits::complex_f* a, int const lda, int& sdim, traits::complex_f* w,\n traits::complex_f* vs, int const ldvs,\n traits::complex_f* work, int lwork, float* rwork, bool* bwork,\n int& info) \n {\n LAPACK_CGEES (&jobvs, &sort, select, &n, traits::complex_ptr(a), &lda, &sdim,\n traits::complex_ptr(w), traits::complex_ptr (vs), &ldvs,\n traits::complex_ptr(work), &lwork, rwork, bwork, &info);\n }\n\n\n inline \n void gees (char const jobvs, char const sort, logical_t* select, int const n,\n traits::complex_d* a, int const lda, int& sdim, traits::complex_d* w,\n traits::complex_d* vs, int const ldvs,\n traits::complex_d* work, int lwork, double* rwork, bool* bwork,\n int& info) \n {\n LAPACK_ZGEES (&jobvs, &sort, select, &n, traits::complex_ptr(a), &lda, &sdim,\n traits::complex_ptr(w), traits::complex_ptr(vs), &ldvs,\n traits::complex_ptr(work), &lwork, rwork, bwork, &info);\n }\n\n } \n\n\n namespace detail {\n /// Compute Schur factorization, passing one work array.\n template \n inline\n int gees (char jobvs, MatrA& a, EigVal& w, SchVec& vs, Work& work) {\n\n#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK \n BOOST_STATIC_ASSERT((boost::is_same<\n typename traits::matrix_traits::matrix_structure, \n traits::general_t\n >::value)); \n BOOST_STATIC_ASSERT((boost::is_same<\n typename traits::matrix_traits::matrix_structure, \n traits::general_t\n >::value)); \n#endif \n\n typedef typename MatrA::value_type value_type ;\n\n int const n = traits::matrix_size1 (a);\n assert (n == traits::matrix_size2 (a)); \n assert (n == traits::matrix_size1 (vs)); \n assert (n == traits::matrix_size2 (vs)); \n assert (n == traits::vector_size (w)); \n assert (3*n <= traits::vector_size (work)); \n\n logical_t* select=0;\n bool* bwork=0;\n\n int info, sdim; \n detail::gees (jobvs, 'N', select, n,\n traits::matrix_storage (a), \n traits::leading_dimension (a),\n sdim,\n traits::vector_storage (w),\n traits::matrix_storage (vs),\n traits::leading_dimension (vs),\n\t\t traits::vector_storage( work ),\n\t\t traits::vector_size( work ),\n bwork, info);\n\t return info ;\n } // gees()\n\n\n /// Compute Schur factorization, passing two work arrays.\n template \n inline\n int gees (char jobvs, MatrA& a, EigVal& w, SchVec& vs,\n\t\t Work& work, RWork& rwork) {\n\n#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK \n BOOST_STATIC_ASSERT((boost::is_same<\n typename traits::matrix_traits::matrix_structure, \n traits::general_t\n >::value)); \n BOOST_STATIC_ASSERT((boost::is_same<\n typename traits::matrix_traits::matrix_structure, \n traits::general_t\n >::value)); \n#endif \n\n typedef typename MatrA::value_type value_type ;\n\n int const n = traits::matrix_size1 (a);\n assert (n == traits::matrix_size2 (a)); \n assert (n == traits::matrix_size1 (vs)); \n assert (n == traits::matrix_size2 (vs)); \n assert (n == traits::vector_size (w)); \n assert (2*n <= traits::vector_size (work)); \n assert (n <= traits::vector_size (rwork)); \n\n logical_t* select=0;\n bool* bwork=0;\n\n int info, sdim; \n detail::gees (jobvs, 'N', select, n,\n traits::matrix_storage (a), \n traits::leading_dimension (a),\n sdim,\n traits::vector_storage (w),\n traits::matrix_storage (vs),\n traits::leading_dimension (vs),\n\t\t traits::vector_storage( work ),\n\t\t traits::vector_size( work ),\n\t\t traits::vector_storage( rwork ),\n bwork, info);\n\t return info ;\n } // gees()\n\n\n /// Compute Schur factorization, depending on whether we have one or\n /// two workspace arrays. N= the number of workspace arrays.\n template \n struct Gees {};\n\n\n template <>\n struct Gees< 2 > {\n template \n inline\n int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, optimal_workspace ) const {\n typedef typename MatrA::value_type value_type ;\n typedef typename traits::type_traits< value_type >::real_type real_type ;\n\n int n = traits::matrix_size1( a );\n\n traits::detail::array work( 2*n );\n traits::detail::array rwork( n );\n\n return gees( jobvs, a, w, vs, work, rwork );\n } // gees()\n\n template \n inline\n int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, minimal_workspace ) const {\n typedef typename MatrA::value_type value_type ;\n typedef typename traits::type_traits< value_type >::real_type real_type ;\n\n int n = traits::matrix_size1( a );\n\n traits::detail::array work( 2*n );\n traits::detail::array rwork( n );\n\n return gees( jobvs, a, w, vs, work, rwork );\n } // gees()\n\n /// Compute Schur factorization, passing workspace2 as workspace\n template \n inline\n int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, workspace2& workspace ) const {\n return gees( jobvs, a, w, vs, workspace.w_, workspace.wr_ );\n } // gees()\n }; // Gees<2>\n\n\n template <>\n struct Gees< 1 > {\n template \n inline\n int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, optimal_workspace ) const {\n typedef typename MatrA::value_type value_type ;\n typedef typename traits::type_traits< value_type >::real_type real_type ;\n\n int n = traits::matrix_size1( a );\n\n traits::detail::array work( 3*n );\n\n return gees( jobvs, a, w, vs, work );\n } // gees()\n\n template \n inline\n int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, minimal_workspace ) const {\n typedef typename MatrA::value_type value_type ;\n typedef typename traits::type_traits< value_type >::real_type real_type ;\n\n int n = traits::matrix_size1( a );\n\n traits::detail::array work( 3*n );\n\n return gees( jobvs, a, w, vs, work );\n } // gees()\n\n /// Compute Schur factorization, passing workspace1 as workspace\n template \n inline\n int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, detail::workspace1 workspace ) const {\n return gees( jobvs, a, w, vs, workspace.w_ );\n } // gees()\n }; // Gees<1>\n\n } // namespace detail\n\n\n /// Compute Schur factorization with Schur vectors.\n ///\n /// Workspace can be the following :\n /// optimal_workspace() : for optimizing use of blas 3 kernels\n /// minimal_workspace() : minimum size of workarrays, but does not allow for optimization\n /// of blas 3 kernels\n /// workspace( real_work ) for real matrices where\n /// vector_size( real_work ) >= 3*matrix_size1( a )\n /// workspace( complex_work, real_work ) for complex matrices where\n /// vector_size( complex_work ) >= 2*matrix_size1( a )\n /// and vector_size( real_work ) >= matrix_size1( a ).\n template \n inline\n int gees (MatrA& a, EigVal& e, SchVec& vs, Workspace workspace ) {\n return detail::Gees< n_workspace_args::value>()\n ( 'V', a, e, vs, workspace );\n } // gees()\n\n\n // Compute Schur factorization without Schur vectors.\n ///\n /// Workspace can be the following :\n /// optimal_workspace() : for optimizing use of blas 3 kernels\n /// minimal_workspace() : minimum size of workarrays, but does not allow for optimization\n /// of blas 3 kernels\n /// workspace( real_work ) for real matrices where\n /// vector_size( real_work ) >= 3*matrix_size1( a )\n /// workspace( complex_work, real_work ) for complex matrices where\n /// vector_size( complex_work ) >= 2*matrix_size1( a )\n /// and vector_size( real_work ) >= matrix_size1( a ).\n template \n inline\n int gees (MatrA& a, EigVal& e, Workspace workspace) {\n return detail::Gees< n_workspace_args::value>()\n ('N', a, e, a, workspace );\n }\n\n }\n\n}}}\n\n#endif \n", "meta": {"hexsha": "b772e30d05c646320359e7baa3fa0d413ffa5bfe", "size": 13997, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "boost/numeric/bindings/lapack/gees.hpp", "max_stars_repo_name": "inducer/boost-numeric-bindings", "max_stars_repo_head_hexsha": "1f994e8a2e161cddb6577eacc76b7bc358701cbe", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2015-11-13T16:40:57.000Z", "max_stars_repo_stars_event_max_datetime": "2017-09-15T15:37:19.000Z", "max_issues_repo_path": "openrave/plugins/include/boost/numeric/bindings/lapack/gees.hpp", "max_issues_repo_name": "jdsika/holy", "max_issues_repo_head_hexsha": "a2ac55fa1751a3a8038cf61d29b95005f36d6264", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2016-06-13T01:29:51.000Z", "max_issues_repo_issues_event_max_datetime": "2016-06-14T00:38:27.000Z", "max_forks_repo_path": "openrave/plugins/include/boost/numeric/bindings/lapack/gees.hpp", "max_forks_repo_name": "jdsika/holy", "max_forks_repo_head_hexsha": "a2ac55fa1751a3a8038cf61d29b95005f36d6264", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-05-05T20:18:25.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-05T20:18:25.000Z", "avg_line_length": 40.8075801749, "max_line_length": 115, "alphanum_fraction": 0.5620490105, "num_tokens": 3322, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8333245870332531, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5398261824558196}} {"text": "#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\nusing namespace boost::python;\nnamespace xfel{\n\nnamespace xes { namespace example {\n class gaussian_fit_inheriting_from_non_linear_ls: public scitbx::lstbx::normal_equations::non_linear_ls {\n\n public:\n gaussian_fit_inheriting_from_non_linear_ls(int n_parameters):\n scitbx::lstbx::normal_equations::non_linear_ls(n_parameters),\n jacobian_one_row(n_parameters)\n {}\n\n void set_cpp_data(scitbx::af::shared x,\n scitbx::af::shared y,\n double const& g,\n double const& s) {\n free_x=x, free_y=y, gain_to_sigma=g, sigmafac=s; sigmafac_sq=s*s;\n residual_terms_0 = std::vector(x.size());\n residual_terms_1 = std::vector(x.size());\n residuals = scitbx::af::shared(x.size());\n }\n\n void access_cpp_build_up_directly(bool objective_only, scitbx::af::shared current_values) {\n fvec_callable(current_values);\n if (objective_only) {\n add_residuals(residuals.const_ref(), scitbx::af::shared().const_ref());\n }else{\n // add one of the normal equations for each observation\n for (int ix = 0; ix < free_x.size(); ++ix) {\n /*\n z_mean = current_values[0]\n z_ampl = current_values[1]\n z_sigm = current_values[2]\n o_ampl = current_values[3]\n o_mean = z_mean + z_sigm * GAIN_TO_SIGMA\n o_sigm = z_sigm * SIGMAFAC\n # leaving out small cross terms where one-photon peak influences\n # derivatives with respect to z_mean and z_sigm.\n # XXX not accounting for charge sharing at all\n */\n double udiff = free_x[ix] - current_values[0];\n double Afactor = udiff/(current_values[2] * current_values[2]);\n double Sfactor = Afactor * udiff/current_values[2];\n jacobian_one_row[0] = ( residual_terms_0[ix] * Afactor );\n jacobian_one_row[1] = ( residual_terms_0[ix] / current_values[1] );\n jacobian_one_row[2] = ( residual_terms_0[ix] * Sfactor );\n jacobian_one_row[3] = ( residual_terms_1[ix] / current_values[3] );\n\n add_equation(residuals[ix], jacobian_one_row.const_ref(), 1.);\n }\n }\n }\n\n void\n fvec_callable(scitbx::af::shared ¤t_values) {\n /*\n z_mean = current_values[0]\n z_ampl = current_values[1]\n z_sigm = current_values[2]\n o_ampl = current_values[3]\n o_mean = z_mean + z_sigm * GAIN_TO_SIGMA\n o_sigm = z_sigm * SIGMAFAC\n\n # model minus obs\n # sqrt2pi_inv = 1./math.sqrt(2.*math.pi)\n # the gaussian function is sqrt2pi_inv * exp( - (x-mean)**2 / (2.*(sigma**2)))/sigma\n # take off the coefficient sqrt2pi_inv / sigma, use ampl\n */\n\n for (int ix = 0; ix < free_x.size(); ++ix) {\n double model=0;\n //zero-photon Gaussian\n double diff = free_x[ix] - current_values[0];\n residual_terms_0[ix] = (\n current_values[1] * std::exp( - (diff*diff) / (2. * current_values[2] * current_values[2])));\n model += residual_terms_0[ix];\n\n //one-photon Gaussian\n diff = free_x[ix] - ( current_values[0] + current_values[2] * gain_to_sigma );\n residual_terms_1[ix] = (\n current_values[3] * std::exp( - (diff*diff) / (2. * current_values[2] * current_values[2] * sigmafac_sq)));\n model += residual_terms_1[ix];\n\n //terms = [\n //ampl * flex.exp(-flex.pow2(free_x - mean) / (2.*sigm*sigm))\n //for mean,ampl,sigm in [(z_mean,z_ampl,z_sigm),(o_mean,o_ampl,o_sigm)]]\n //#print \"residual\", math.sqrt(flex.sum((model-free_y)*(model-free_y)))\n residuals[ix] = ( model - free_y[ix] );\n }\n }\n\n private:\n scitbx::af::shared free_x, free_y, jacobian_one_row, residuals;\n double gain_to_sigma, sigmafac, sigmafac_sq;\n std::vector residual_terms_0, residual_terms_1;\n\n };\n\n class gaussian_3fit_inheriting_from_non_linear_ls: public scitbx::lstbx::normal_equations::non_linear_ls {\n\n public:\n gaussian_3fit_inheriting_from_non_linear_ls(int n_parameters):\n scitbx::lstbx::normal_equations::non_linear_ls(n_parameters),\n jacobian_one_row(n_parameters)\n {}\n\n void set_cpp_data(scitbx::af::shared const& val,\n scitbx::af::shared const& x,\n scitbx::af::shared const& y) {\n free_x=x, free_y=y;\n residual_terms_0 = std::vector(x.size());\n residual_terms_1 = std::vector(x.size());\n residual_terms_2 = std::vector(x.size());\n residuals = scitbx::af::shared(x.size());\n constants = val;\n }\n\n void access_cpp_build_up_directly(bool objective_only, scitbx::af::shared current_values) {\n\n fvec_callable(current_values);\n\n if (objective_only) {\n\n add_residuals(residuals.const_ref(), scitbx::af::shared().const_ref());\n }else{\n // add one of the normal equations for each observation\n for (int ix = 0; ix < free_x.size(); ++ix) {\n /*\n z_mean = current_values[0]\n z_ampl = current_values[1]\n z_sigm = current_values[2]\n inelast_mean = zmean + zsigm * constants[0]\n inelast_ampl = current_values[3]\n inelast_sigm = (constants[0]/constants[1])*(elast_sigm[5] - zsigm[2])+zsigm[2]\n elast_mean = z_mean + z_sigm * constants[1]\n elast_ampl = current_values[4]\n elast_sigm = current_values[5]\n # leaving out small cross terms where one-photon peak influences\n # derivatives with respect to z_mean and z_sigm.\n # XXX not accounting for charge sharing or 2-photon peak\n */\n double udiff = free_x[ix] - current_values[0];\n double Afactor = udiff/(current_values[2] * current_values[2]);\n double Sfactor = Afactor * udiff/current_values[2];\n jacobian_one_row[0] = ( residual_terms_0[ix] * Afactor );\n jacobian_one_row[1] = ( residual_terms_0[ix] / current_values[1] );\n jacobian_one_row[2] = ( residual_terms_0[ix] * Sfactor );\n jacobian_one_row[3] = ( residual_terms_1[ix] / current_values[3] );\n jacobian_one_row[4] = ( residual_terms_2[ix] / current_values[4] );\n double udiff3 = free_x[ix] - (current_values[0] + current_values[2] * constants[1]);\n double Afactor3 = udiff3/(current_values[5] * current_values[5]);\n double Sfactor3 = Afactor3 * udiff3/current_values[5];\n jacobian_one_row[5] = ( residual_terms_2[ix] * Sfactor3 );\n\n add_equation(residuals[ix], jacobian_one_row.const_ref(), 1.);\n }\n }\n\n }\n\n void\n fvec_callable(scitbx::af::shared ¤t_values) {\n /*\n # model minus obs\n # sqrt2pi_inv = 1./math.sqrt(2.*math.pi)\n # the gaussian function is sqrt2pi_inv * exp( - (x-mean)**2 / (2.*(sigma**2)))/sigma\n # take off the coefficient sqrt2pi_inv / sigma, use ampl\n */\n\n\n for (int ix = 0; ix < free_x.size(); ++ix) {\n double model=0;\n\n\n //zero-photon Gaussian\n double diff = free_x[ix] - current_values[0];\n residual_terms_0[ix] = (\n current_values[1] * std::exp( - (diff*diff) / (2. * current_values[2] * current_values[2])));\n model += residual_terms_0[ix];\n\n //inelastic-photon Gaussian\n {\n double pmean = current_values[0] + current_values[2] * constants[0];\n diff = free_x[ix] - pmean;\n double psigma = (constants[0]/constants[1])*(current_values[5] - current_values[2])+current_values[2];\n residual_terms_1[ix] = (\n current_values[3] * std::exp( - (diff*diff) / (2. * psigma * psigma)));\n model += residual_terms_1[ix];\n }\n\n //elastic-photon Gaussian\n {\n double pmean = current_values[0] + current_values[2] * constants[1];\n diff = free_x[ix] - pmean;\n double psigma = current_values[5];\n residual_terms_2[ix] = (\n current_values[4] * std::exp( - (diff*diff) / (2. * psigma * psigma)));\n model += residual_terms_2[ix];\n }\n\n //terms = [\n //ampl * flex.exp(-flex.pow2(free_x - mean) / (2.*sigm*sigm))\n //for mean,ampl,sigm in [(z_mean,z_ampl,z_sigm),(o_mean,o_ampl,o_sigm)]]\n //#print \"residual\", math.sqrt(flex.sum((model-free_y)*(model-free_y)))\n residuals[ix] = ( model - free_y[ix] );\n }\n }\n\n private:\n scitbx::af::shared free_x, free_y, jacobian_one_row, residuals;\n scitbx::af::shared constants;\n double gain_to_sigma, sigmafac, sigmafac_sq;\n std::vector residual_terms_0, residual_terms_1, residual_terms_2;\n\n };\n\n}} //xes::example\n\nnamespace boost_python { namespace {\n\n void\n xes_ext_init_module() {\n using namespace boost::python;\n\n typedef return_value_policy rbv;\n typedef default_call_policies dcp;\n typedef xes::example::gaussian_fit_inheriting_from_non_linear_ls wt;\n typedef xes::example::gaussian_3fit_inheriting_from_non_linear_ls wt3;\n\n class_ > >(\n \"gaussian_fit_inheriting_from_non_linear_ls\", no_init)\n .def(init(arg(\"n_parameters\")))\n .def(\"access_cpp_build_up_directly\",&wt::access_cpp_build_up_directly,\n (arg(\"objective_only\"),arg(\"current_values\")))\n .def(\"set_cpp_data\",&wt::set_cpp_data,\n (arg(\"free_x\"),arg(\"free_y\"),arg(\"gain_to_sigma\"),arg(\"sigmafac\")))\n ;\n class_ > >(\n \"gaussian_3fit_inheriting_from_non_linear_ls\", no_init)\n .def(init(arg(\"n_parameters\")))\n .def(\"access_cpp_build_up_directly\",&wt3::access_cpp_build_up_directly,\n (arg(\"objective_only\"),arg(\"current_values\")))\n .def(\"set_cpp_data\",&wt3::set_cpp_data,\n (arg(\"constants\"),arg(\"free_x\"),arg(\"free_y\")))\n ;\n }\n\n}\n}} // namespace xfel::boost_python::\n\nBOOST_PYTHON_MODULE(xes_ext)\n{\n xfel::boost_python::xes_ext_init_module();\n\n}\n", "meta": {"hexsha": "86dcad1138e0c9c6feda591019c12a8457d501f2", "size": 11256, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "xfel/vonHamos/xes_ext.cpp", "max_stars_repo_name": "rimmartin/cctbx_project", "max_stars_repo_head_hexsha": "644090f9432d9afc22cfb542fc3ab78ca8e15e5d", "max_stars_repo_licenses": ["BSD-3-Clause-LBNL"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2021-03-18T12:31:57.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T06:27:06.000Z", "max_issues_repo_path": "xfel/vonHamos/xes_ext.cpp", "max_issues_repo_name": "rimmartin/cctbx_project", "max_issues_repo_head_hexsha": "644090f9432d9afc22cfb542fc3ab78ca8e15e5d", "max_issues_repo_licenses": ["BSD-3-Clause-LBNL"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "xfel/vonHamos/xes_ext.cpp", "max_forks_repo_name": "rimmartin/cctbx_project", "max_forks_repo_head_hexsha": "644090f9432d9afc22cfb542fc3ab78ca8e15e5d", "max_forks_repo_licenses": ["BSD-3-Clause-LBNL"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-03-26T12:52:30.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-26T12:52:30.000Z", "avg_line_length": 41.3823529412, "max_line_length": 119, "alphanum_fraction": 0.6024342573, "num_tokens": 2910, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8333245870332531, "lm_q2_score": 0.6477982043529715, "lm_q1q2_score": 0.5398261711233229}} {"text": "#ifndef GUARD_PERM_GROUP_H\n#define GUARD_PERM_GROUP_H\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \"bsgs.hpp\"\n#include \"perm.hpp\"\n#include \"perm_set.hpp\"\n#include \"timeout.hpp\"\n#include \"util.hpp\"\n\nnamespace mpsym\n{\n\nnamespace internal\n{\n\nclass Orbit;\nclass OrbitPartition;\n\nclass BlockSystem;\n\nclass PermGroup\n{\n friend std::ostream &operator<<(std::ostream &os, PermGroup const &pg);\n\npublic:\n using value_type = Perm;\n using const_reference = Perm const &;\n\n class const_iterator : public util::Iterator\n {\n public:\n const_iterator() : _end(true) {};\n const_iterator(PermGroup const &pg);\n\n bool operator==(const_iterator const &rhs) const override;\n\n PermSet const &factors() const\n { return _current_factors; }\n\n private:\n reference current() override;\n void next() override;\n\n std::vector _state;\n bool _trivial;\n bool _end;\n\n std::vector _transversals;\n Perm _current;\n bool _current_valid;\n PermSet _current_factors;\n };\n\n explicit PermGroup(unsigned degree = 1)\n : _bsgs(degree),\n _order(1)\n {}\n\n explicit PermGroup(BSGS const &bsgs)\n : _bsgs(bsgs),\n _order(bsgs.order())\n {}\n\n PermGroup(PermSet const &generators)\n : PermGroup(generators.degree(), generators)\n {}\n\n PermGroup(unsigned degree, PermSet const &generators);\n\n static PermGroup symmetric(unsigned degree);\n static PermGroup cyclic(unsigned degree);\n static PermGroup dihedral(unsigned degree);\n\n template\n static PermGroup direct_product(IT first,\n IT last,\n BSGSOptions const *bsgs_options_ = nullptr,\n timeout::flag aborted = timeout::unset())\n {\n assert(std::distance(first, last) > 0);\n\n // direct product degree\n unsigned dp_degree = 0u;\n\n for (auto it = first; it != last; ++it)\n dp_degree += it->degree();\n\n // direct product order\n auto dp_order(direct_product_order(first, last));\n\n // direct product generators\n unsigned d = 0u;\n\n PermSet dp_generators;\n for (auto it = first; it != last; ++it) {\n for (Perm const &perm : it->generators())\n dp_generators.insert(perm.shifted(d).extended(dp_degree));\n\n d += it->degree();\n }\n\n // construct direct product\n auto bsgs_options(BSGSOptions::fill_defaults(bsgs_options_));\n bsgs_options.schreier_sims_random_known_order = dp_order;\n\n return PermGroup(BSGS(dp_degree, dp_generators, &bsgs_options, aborted));\n }\n\n template\n static BSGS::order_type direct_product_order(IT first, IT last)\n {\n BSGS::order_type dp_order = 1u;\n\n for (auto it = first; it != last; ++it)\n dp_order *= it->order();\n\n return dp_order;\n }\n\n static PermSet wreath_product_generators(PermGroup const &lhs,\n PermGroup const &rhs);\n\n static PermGroup wreath_product(PermGroup const &lhs,\n PermGroup const &rhs,\n BSGSOptions const *bsgs_options = nullptr,\n timeout::flag aborted = timeout::unset());\n\n static BSGS::order_type wreath_product_order(PermGroup const &lhs,\n PermGroup const &rhs);\n\n bool operator==(PermGroup const &rhs) const;\n bool operator!=(PermGroup const &rhs) const;\n\n const_iterator begin() const { return const_iterator(*this); }\n const_iterator end() const { return const_iterator(); }\n\n PermSet generators() const { return _bsgs.strong_generators(); }\n\n BSGS &bsgs() { return _bsgs; }\n BSGS const &bsgs() const { return _bsgs; }\n\n unsigned degree() const { return _bsgs.degree(); }\n BSGS::order_type order() const { return _order; }\n\n unsigned smallest_moved_point() const\n { return generators().smallest_moved_point(); }\n\n unsigned largest_moved_point() const\n { return generators().largest_moved_point(); }\n\n std::vector support() const\n { return generators().support(); }\n\n bool is_trivial() const { return _bsgs.base_empty(); }\n bool is_symmetric() const;\n bool is_shifted_symmetric() const;\n bool is_transitive() const;\n\n bool contains_element(Perm const &perm) const;\n Perm random_element() const;\n\n std::vector disjoint_decomposition(\n bool complete = true, bool disjoint_orbit_optimization = false) const;\n\n std::vector wreath_decomposition() const;\n\nprivate:\n static boost::multiprecision::cpp_int symmetric_order(unsigned deg)\n {\n boost::multiprecision::cpp_int ret(1);\n for (unsigned i = deg; i > 0u; --i)\n ret *= i;\n\n return ret;\n }\n\n // complete disjoint decomposition\n bool disjoint_decomp_orbits_dependent(\n Orbit const &orbit1,\n Orbit const &orbit2) const;\n\n void disjoint_decomp_generate_dependency_classes(\n OrbitPartition &orbits) const;\n\n static bool disjoint_decomp_restricted_subgroups(\n OrbitPartition const &orbit_split,\n PermGroup const &perm_group,\n std::pair &restricted_subgroups);\n\n static std::vector disjoint_decomp_join_results(\n std::vector const &res1,\n std::vector const &res2);\n\n static std::vector disjoint_decomp_complete_recursive(\n OrbitPartition const &orbits,\n PermGroup const &perm_group);\n\n std::vector disjoint_decomp_complete(\n bool disjoint_orbit_optimization = true) const;\n\n // incomplete disjoint decomposition\n struct MovedSet : public std::vector\n {\n void init(Perm const &perm);\n bool equivalent(MovedSet const &other) const;\n void extend(MovedSet const &other);\n };\n\n struct EquivalenceClass\n {\n EquivalenceClass(Perm const &init, MovedSet const &moved)\n : generators({init}),\n moved(moved),\n merged(false)\n {}\n\n PermSet generators;\n MovedSet moved;\n bool merged;\n };\n\n std::vector disjoint_decomp_find_equivalence_classes() const;\n\n void disjoint_decomp_merge_equivalence_classes(\n std::vector &equivalence_classes) const;\n\n std::vector disjoint_decomp_incomplete() const;\n\n // wreath decomposition\n std::vector wreath_decomp_find_stabilizers(\n BlockSystem const &block_system,\n PermGroup const &block_permuter) const;\n\n PermSet wreath_decomp_construct_block_permuter_image(\n BlockSystem const &block_system,\n PermGroup const &block_permuter) const;\n\n bool wreath_decomp_reconstruct_block_permuter(\n BlockSystem const &block_system,\n PermGroup const &block_permuter,\n PermSet const &block_permuter_image) const;\n\n BSGS _bsgs;\n BSGS::order_type _order;\n};\n\nstd::ostream &operator<<(std::ostream &os, PermGroup const &pg);\n\n} // namespace internal\n\n} // namespace mpsym\n\n#endif // GUARD_PERM_GROUP_H\n", "meta": {"hexsha": "e6ca6a8da16988c753578335e133975aec19934f", "size": 6931, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/perm_group.hpp", "max_stars_repo_name": "goens/TUD_computational_group_theory", "max_stars_repo_head_hexsha": "3f4703cae1ac049089db23eafc321e8daca2d99d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2018-09-10T09:31:17.000Z", "max_stars_repo_stars_event_max_datetime": "2018-10-14T15:19:20.000Z", "max_issues_repo_path": "include/perm_group.hpp", "max_issues_repo_name": "goens/TUD_computational_group_theory", "max_issues_repo_head_hexsha": "3f4703cae1ac049089db23eafc321e8daca2d99d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7.0, "max_issues_repo_issues_event_min_datetime": "2020-06-11T07:25:08.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-19T09:07:50.000Z", "max_forks_repo_path": "include/perm_group.hpp", "max_forks_repo_name": "goens/TUD_computational_group_theory", "max_forks_repo_head_hexsha": "3f4703cae1ac049089db23eafc321e8daca2d99d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-09-10T19:31:57.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-09T13:17:50.000Z", "avg_line_length": 26.4541984733, "max_line_length": 81, "alphanum_fraction": 0.6890780551, "num_tokens": 1691, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7577943712746404, "lm_q2_score": 0.7122321903471563, "lm_q1q2_score": 0.5397255448856834}} {"text": "#pragma once\n#ifndef CANNON_RAY_FILTER_H\n#define CANNON_RAY_FILTER_H\n\n/*!\n * \\file cannon/ray/filter.hpp\n * File containing class definitions for Film reconstruction filters.\n */\n\n#include \n\nusing namespace Eigen;\n\nnamespace cannon {\n namespace ray {\n\n /*!\n * \\brief Abstract base class representing a reconstruction filter for\n * integrating image samples.\n */\n class Filter {\n public:\n\n /*!\n * \\brief Constructor taking a radius for this filter.\n */\n Filter(const Vector2d& radius) : radius_(radius), inv_radius_(1.0 /\n radius.x(), 1.0 / radius.y()) {}\n\n /*!\n * \\brief Get the value of this filter at the input point. The filter\n * is assumed to be centered at the origin, so the input point should\n * be with respect to the actual filter position.\n *\n * \\param p The point to evaluate the filter for.\n *\n * \\returns The value of this filter at the point.\n */\n virtual double evaluate(const Vector2d& p) const = 0;\n\n /*!\n * \\brief Destructor.\n */\n virtual ~Filter() {}\n\n public:\n const Vector2d radius_; //!< Radius of this filter\n const Vector2d inv_radius_; //!< 1 / radius, speeds up math\n\n };\n\n /*!\n * \\brief Class representing the most basic image reconstruction filter,\n * the Box Filter.\n */\n class BoxFilter : public Filter {\n public:\n\n /*!\n * \\brief Constructor taking the radius of this filter.\n */\n BoxFilter(const Vector2d& radius) : Filter(radius) {}\n\n /*!\n * \\brief Destructor.\n */\n virtual ~BoxFilter() {}\n\n /*!\n * \\brief Inherited from Filter.\n */\n virtual double evaluate(const Vector2d& /*p*/) const override {\n return 1.0;\n }\n };\n\n /*!\n * \\brief Class representing a triangle filter, which is not much better\n * than a box filter.\n */\n class TriangleFilter : public Filter {\n public:\n\n /*!\n * \\brief Constructor taking the radius of this filter.\n */\n TriangleFilter(const Vector2d& radius) : Filter(radius) {}\n\n /*!\n * \\brief Destructor.\n */\n virtual ~TriangleFilter() {}\n\n /*!\n * \\brief Inherited from Filter.\n */\n virtual double evaluate(const Vector2d& p) const override {\n return std::max(0.0, radius_.x() - std::abs(p.x())) *\n std::max(0.0, radius_.y() - std::abs(p.y()));\n }\n };\n\n /*!\n * \\brief Class representing a Gaussian filter. Reasonable for image\n * reconstruction.\n */\n class GaussianFilter : public Filter {\n public:\n\n /*!\n * \\brief Constructor taking the radius of this filter and rate of\n * Gaussian falloff.\n */\n GaussianFilter(const Vector2d &radius, double alpha)\n : Filter(radius), alpha_(alpha * radius.x()),\n exp_x_(std::exp(-alpha * radius.x() * radius.x())),\n exp_y_(std::exp(-alpha * radius.y() * radius.y())) {}\n\n /*!\n * \\brief Destructor.\n */\n virtual ~GaussianFilter() {}\n\n /*!\n * \\brief Inherited from Filter.\n */\n virtual double evaluate(const Vector2d& p) const override {\n return gaussian_(p.x(), exp_x_) * gaussian_(p.y(), exp_y_);\n }\n\n private:\n\n /*!\n * \\brief 1D Gaussian function, used to compute 2D Gaussian filter\n * value since this filter is separable.\n *\n * \\param d Distance from center of filter\n * \\param exp_v Constant term\n */\n double gaussian_(double d, double exp_v) const {\n return std::max(0.0, std::exp(-alpha_ * d * d) - exp_v);\n }\n\n\n const double alpha_; //!< Gaussian falloff rate\n const double exp_x_; //!< Cached constant term in x\n const double exp_y_; //!< Cached constant term in y\n };\n\n /*!\n * \\brief Class representing a Mitchell-Netravali filter. Reasonable for image\n * reconstruction.\n */\n class MitchellFilter : public Filter {\n public:\n\n /*!\n * \\brief Constructor taking the radius of this filter and\n * Mitchell-Netravali parameters B and C.\n */\n MitchellFilter(const Vector2d &radius, double b, double c)\n : Filter(radius), b_(b), c_(c) {}\n\n /*!\n * \\brief Destructor.\n */\n virtual ~MitchellFilter() {}\n\n /*!\n * \\brief Inherited from Filter.\n */\n virtual double evaluate(const Vector2d& p) const override {\n return mitchell_1d_(p.x() * inv_radius_.x()) * mitchell_1d_(p.y() * inv_radius_.y());\n }\n\n private:\n\n /*!\n * \\brief 1D Mitchell function, used to compute 2D Mitchell filter\n * value since this filter is separable.\n *\n * \\param x Scaled distance from center of filter\n */\n double mitchell_1d_(double x) const {\n x = std::abs(2 * x);\n\n if (x > 1)\n return ((-b_ - 6*c_) * x*x*x + (6*b_ + 30*c_) * x*x + \n (-12*b_ - 48*c_) * x + (8*b_ + 24*c_)) * (1.0 / 6.0);\n else\n return ((12 - 9*b_ - 6*c_) * x*x*x +\n (-18 + 12*b_ + 6*c_) * x*x +\n (6 - 2*b_)) * (1.0 / 6.0);\n }\n\n double b_;\n double c_;\n\n };\n\n\n } // namespace ray\n} // namespace cannon\n\n#endif /* ifndef CANNON_RAY_FILTER_H */\n", "meta": {"hexsha": "14286e469b5c8f47609b4ed8911cfe8321f97d05", "size": 5580, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "cannon/ray/filter.hpp", "max_stars_repo_name": "cannontwo/cannon", "max_stars_repo_head_hexsha": "4be79f3a6200d1a3cd26c28c8f2250dbdf08f267", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cannon/ray/filter.hpp", "max_issues_repo_name": "cannontwo/cannon", "max_issues_repo_head_hexsha": "4be79f3a6200d1a3cd26c28c8f2250dbdf08f267", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 46.0, "max_issues_repo_issues_event_min_datetime": "2021-01-12T23:03:52.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-01T17:29:01.000Z", "max_forks_repo_path": "cannon/ray/filter.hpp", "max_forks_repo_name": "cannontwo/cannon", "max_forks_repo_head_hexsha": "4be79f3a6200d1a3cd26c28c8f2250dbdf08f267", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.0873786408, "max_line_length": 95, "alphanum_fraction": 0.5326164875, "num_tokens": 1311, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7577943822145998, "lm_q2_score": 0.7122321781307374, "lm_q1q2_score": 0.539725543419941}} {"text": "//! [distance-all]\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\nint main(int argc, char** argv)\n{\n using namespace std::chrono;\n namespace bs = boost::simd;\n typedef float T;\n using pack_t = bs::pack;\n\n //! [distance-declare]\n std::size_t num_points = 1600000;\n std::vector> X(num_points);\n std::vector> Y(num_points);\n std::vector> distance0(num_points);\n std::vector> distance1(num_points);\n std::vector> distance2(num_points);\n std::vector> distance3(num_points);\n\n std::generate(X.begin(), X.end(),\n []() { return T(std::rand()) / std::numeric_limits::max(); });\n std::generate(Y.begin(), Y.end(),\n []() { return T(std::rand()) / std::numeric_limits::max(); });\n\n T refX = 0, refY = 0;\n //! [distance-declare]\n\n auto t0 = high_resolution_clock::now();\n //! [distance-scalar]\n for (int i = 0; i < num_points; ++i) {\n auto x = refX - X[i];\n auto y = refY - Y[i];\n distance0[i] = std::sqrt(x * x + y * y);\n }\n //! [distance-scalar]\n auto t1 = high_resolution_clock::now();\n std::cout << \" time scalar \" << duration_cast(t1 - t0).count() << std::endl;\n\n //! [distance-time]\n t0 = high_resolution_clock::now();\n //! [distance-calc]\n pack_t vrefX = pack_t(refX);\n pack_t vrefY = pack_t(refY);\n\n for (int i = 0; i < num_points; i += pack_t::static_size) {\n pack_t vX = bs::aligned_load(&X[i]);\n pack_t vY = bs::aligned_load(&Y[i]);\n pack_t res = bs::sqrt(bs::sqr(vrefX - vX) + bs::sqr(vrefY - vY));\n bs::aligned_store(res, &distance1[i]);\n }\n //! [distance-calc]\n t1 = high_resolution_clock::now();\n std::cout << \" time SIMD \" << duration_cast(t1 - t0).count() << std::endl;\n //! [distance-time]\n\n //! [distance-interleave]\n // The input vector contains interleaved X and Y data, i.e. x0, y0, x1, y1,\n // ..., xn, yn\n std::vector> interleaved_data(num_points * 2);\n for (int i = 0; i < num_points * 2; i += 2) {\n interleaved_data[i] = X[i / 2];\n interleaved_data[i + 1] = Y[i / 2];\n }\n t0 = high_resolution_clock::now();\n for (int i = 0; i < num_points * 2; i += pack_t::static_size * 2) {\n pack_t v0 = bs::aligned_load(&interleaved_data[i]);\n pack_t v1 = bs::aligned_load(&interleaved_data[i + pack_t::static_size]);\n\n auto V = bs::deinterleave(v0, v1);\n pack_t res = bs::sqrt(bs::sqr(vrefX - V[0]) + bs::sqr(vrefY - V[1]));\n bs::aligned_store(res, &distance2[i / 2]);\n }\n t1 = high_resolution_clock::now();\n //! [distance-interleave]\n std::cout << \" time SIMD de-interleave \" << duration_cast(t1 - t0).count()\n << std::endl;\n}\n//! [distance-all]\n", "meta": {"hexsha": "d250be8b300cab015923e0dcd3836d3611870ff3", "size": 3173, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "doc/examples/distance.cpp", "max_stars_repo_name": "TobiasLudwig/boost.simd", "max_stars_repo_head_hexsha": "c04d0cc56747188ddb9a128ccb5715dd3608dbc1", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2018-02-25T22:23:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-15T15:13:12.000Z", "max_issues_repo_path": "doc/examples/distance.cpp", "max_issues_repo_name": "dendisuhubdy/boost.simd", "max_issues_repo_head_hexsha": "7630b1c1ffbd0300c100885b89ff78c2d579a24c", "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": "doc/examples/distance.cpp", "max_forks_repo_name": "dendisuhubdy/boost.simd", "max_forks_repo_head_hexsha": "7630b1c1ffbd0300c100885b89ff78c2d579a24c", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2017-12-12T12:36:31.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-10T14:27:07.000Z", "avg_line_length": 34.8681318681, "max_line_length": 92, "alphanum_fraction": 0.6205483769, "num_tokens": 981, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718435083355187, "lm_q2_score": 0.6992544147913993, "lm_q1q2_score": 0.5397149807316937}} {"text": "/*\n bern_rat.cpp: multi-modular algorithm for computing Bernoulli numbers\n\n Copyright (C) 2008, 2009, David Harvey\n\n This file is part of the bernmm package (version 1.1).\n\n bernmm is released under a BSD-style license. See the README file in\n the source distribution for details.\n*/\n\n#include \n#include \n#include \n#include \n#include \n#include \"bern_modp_util.h\"\n#include \"bern_modp.h\"\n#include \"bern_rat.h\"\n\n#ifdef USE_THREADS\n#include \n#endif\n\n\nusing namespace std;\nusing namespace NTL;\n\n\nnamespace bernmm {\n\n\n/*\n Computes the denominator of B_k using Clausen/von Staudt.\n*/\nvoid bern_den(mpz_t res, long k, const PrimeTable& table)\n{\n mpz_set_ui(res, 1);\n\n // loop through factors of k\n for (long f = 1; f*f <= k; f++)\n {\n // if f divides k....\n if (k % f == 0)\n {\n // ... then both f + 1 and k/f + 1 are candidates for primes\n // dividing the denominator of B_k\n if (table.is_prime(f + 1))\n mpz_mul_ui(res, res, f + 1);\n\n if (f*f != k)\n if (table.is_prime(k/f + 1))\n mpz_mul_ui(res, res, k/f + 1);\n }\n }\n}\n\n\n// width of interval for each block\n#define BLOCK_SIZE 1000\n\n\n/*\n Represents that B_k is congruent to _residue_ modulo _modulus_.\n*/\nstruct Item\n{\n mpz_t modulus;\n mpz_t residue;\n\n Item()\n {\n mpz_init(modulus);\n mpz_init(residue);\n }\n\n ~Item()\n {\n mpz_clear(residue);\n mpz_clear(modulus);\n }\n};\n\n\n/*\n Items get sorted by modulus.\n*/\nstruct Item_cmp\n{\n bool operator()(const Item* x, const Item* y)\n {\n return mpz_cmp(x->modulus, y->modulus) < 0;\n }\n};\n\n\n/*\n Returns new Item that combines information from op1 and op2 via CRT.\n*/\nItem* CRT(Item* op1, Item* op2)\n{\n Item* res = new Item;\n\n // let n1, n2 be the moduli, and r1, r2 be the residues\n\n // res->modulus = t, where t = 0 mod n1, t = 1 mod n2\n mpz_invert(res->modulus, op1->modulus, op2->modulus);\n mpz_mul(res->modulus, res->modulus, op1->modulus);\n\n // res->residue = r2 - r1\n mpz_sub(res->residue, op2->residue, op1->residue);\n // res->residue = t * (r2 - r1)\n mpz_mul(res->residue, res->residue, res->modulus);\n // res->residue = r1 + t * (r2 - r1)\n mpz_add(res->residue, res->residue, op1->residue);\n // res->modulus = n1 * n2\n mpz_mul(res->modulus, op1->modulus, op2->modulus);\n // res->residue = r1 mod n1, r2 = mod n2\n mpz_mod(res->residue, res->residue, res->modulus);\n\n return res;\n}\n\n\nstruct State\n{\n long k;\n long bound; // only use primes less than this bound\n const PrimeTable* table;\n\n // index of block that should be processed next\n long next;\n\n std::set items;\n#ifdef USE_THREADS\n pthread_mutex_t lock;\n#endif\n\n State(long k, long bound, const PrimeTable& table)\n {\n this->k = k;\n this->bound = bound;\n this->next = 0;\n this->table = &table;\n#ifdef USE_THREADS\n pthread_mutex_init(&lock, NULL);\n#endif\n }\n\n ~State()\n {\n#ifdef USE_THREADS\n pthread_mutex_destroy(&lock);\n#endif\n }\n};\n\n\nvoid* worker(void* arg)\n{\n State& state = *((State*) arg);\n long k = state.k;\n\n#ifdef USE_THREADS\n pthread_mutex_lock(&state.lock);\n#endif\n\n while (1)\n {\n if (state.next * BLOCK_SIZE < state.bound)\n {\n // need to generate more modular data\n\n long next = state.next++;\n#ifdef USE_THREADS\n pthread_mutex_unlock(&state.lock);\n#endif\n\n Item* item = new Item;\n\n mpz_set_ui(item->modulus, 1);\n mpz_set_ui(item->residue, 0);\n\n for (long p = max(5, state.table->next_prime(next * BLOCK_SIZE));\n p < state.bound && p < (next+1) * BLOCK_SIZE;\n p = state.table->next_prime(p))\n {\n if (k % (p-1) == 0)\n continue;\n\n // compute B_k mod p\n long b = bern_modp(p, k);\n\n // CRT into running total\n long x = MulMod(SubMod(b, mpz_fdiv_ui(item->residue, p), p),\n InvMod(mpz_fdiv_ui(item->modulus, p), p), p);\n mpz_addmul_ui(item->residue, item->modulus, x);\n mpz_mul_ui(item->modulus, item->modulus, p);\n }\n\n#ifdef USE_THREADS\n pthread_mutex_lock(&state.lock);\n#endif\n state.items.insert(item);\n }\n else\n {\n // all modular data has been generated\n\n if (state.items.size() <= 1)\n {\n // no more CRTs for this thread to perform\n#ifdef USE_THREADS\n pthread_mutex_unlock(&state.lock);\n#endif\n return NULL;\n }\n\n // CRT two smallest items together\n Item* item1 = *(state.items.begin());\n state.items.erase(state.items.begin());\n Item* item2 = *(state.items.begin());\n state.items.erase(state.items.begin());\n#ifdef USE_THREADS\n pthread_mutex_unlock(&state.lock);\n#endif\n\n Item* item3 = CRT(item1, item2);\n delete item1;\n delete item2;\n\n#ifdef USE_THREADS\n pthread_mutex_lock(&state.lock);\n#endif\n state.items.insert(item3);\n }\n }\n}\n\n\nvoid bern_rat(mpq_t res, long k, int num_threads)\n{\n // special cases\n\n if (k == 0)\n {\n // B_0 = 1\n mpq_set_ui(res, 1, 1);\n return;\n }\n\n if (k == 1)\n {\n // B_1 = -1/2\n mpq_set_si(res, -1, 2);\n return;\n }\n\n if (k == 2)\n {\n // B_2 = 1/6\n mpq_set_si(res, 1, 6);\n return;\n }\n\n if (k & 1)\n {\n // B_k = 0 if k is odd\n mpq_set_ui(res, 0, 1);\n return;\n }\n\n if (num_threads <= 0)\n num_threads = 1;\n\n mpz_t num, den;\n mpz_init(num);\n mpz_init(den);\n\n const double log2 = 0.69314718055994528622676;\n const double invlog2 = 1.44269504088896340735992; // = 1/log(2)\n\n // compute preliminary prime bound and build prime table\n long bound1 = (long) max(37.0, ceil((k + 0.5) * log(k) * invlog2));\n PrimeTable table(bound1);\n\n // compute denominator of B_k\n bern_den(den, k, table);\n\n // compute number of bits we need to resolve the numerator\n long bits = (long) ceil((k + 0.5) * log(k) * invlog2 - 4.094 * k + 2.470\n + log(mpz_get_d(den)) * invlog2);\n\n // compute tighter prime bound\n // (note: we can safely get away with double-precision here. It would\n // only start being insufficient around k = 10^13 or so, which is totally\n // impractical at present.)\n double prod = 1.0;\n long prod_bits = 0;\n long p;\n for (p = 5; prod_bits < bits + 1; p = table.next_prime(p))\n {\n if (p >= NTL_SP_BOUND)\n abort(); // !!!!! not sure what else we can do here...\n if (k % (p-1) != 0)\n prod *= (double) p;\n int exp;\n prod = frexp(prod, &exp);\n prod_bits += exp;\n }\n long bound2 = p;\n\n State state(k, bound2, table);\n\n#ifdef USE_THREADS\n vector threads(num_threads - 1);\n\n pthread_attr_t attr;\n pthread_attr_init(&attr);\n#ifdef THREAD_STACK_SIZE\n pthread_attr_setstacksize(&attr, THREAD_STACK_SIZE * 1024);\n#endif\n\n // spawn worker threads to process blocks\n for (long i = 0; i < num_threads - 1; i++)\n pthread_create(&threads[i], &attr, worker, &state);\n#endif\n\n worker(&state); // make this thread a worker too\n\n#ifdef USE_THREADS\n for (long i = 0; i < num_threads - 1; i++)\n pthread_join(threads[i], NULL);\n#endif\n\n pthread_attr_destroy (&attr);\n\n // reconstruct B_k as a rational number\n Item* item = *(state.items.begin());\n mpz_mul(num, item->residue, den);\n mpz_mod(num, num, item->modulus);\n\n if (k % 4 == 0)\n {\n // B_k is negative\n mpz_sub(num, item->modulus, num);\n mpz_neg(num, num);\n }\n\n delete item;\n\n mpz_swap(num, mpq_numref(res));\n mpz_swap(den, mpq_denref(res));\n\n mpz_clear(num);\n mpz_clear(den);\n}\n\n\n\n}; // end namespace\n\n\n// end of file ================================================================\n", "meta": {"hexsha": "963cb173524e35950de4c54b3206c72b62e1d01c", "size": 7928, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/sage/rings/bernmm/bern_rat.cpp", "max_stars_repo_name": "bopopescu/sage", "max_stars_repo_head_hexsha": "2d495be78e0bdc7a0a635454290b27bb4f5f70f0", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 1742.0, "max_stars_repo_stars_event_min_datetime": "2015-01-04T07:06:13.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T11:32:52.000Z", "max_issues_repo_path": "src/sage/rings/bernmm/bern_rat.cpp", "max_issues_repo_name": "Ivo-Maffei/sage", "max_issues_repo_head_hexsha": "467fbc70a08b552b3de33d9065204ee9cbfb02c7", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 66.0, "max_issues_repo_issues_event_min_datetime": "2015-03-19T19:17:24.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-16T11:59:30.000Z", "max_forks_repo_path": "src/sage/rings/bernmm/bern_rat.cpp", "max_forks_repo_name": "dimpase/sage", "max_forks_repo_head_hexsha": "468f23815ade42a2192b0a9cd378de8fdc594dcd", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 495.0, "max_forks_repo_forks_event_min_datetime": "2015-01-10T10:23:18.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-24T22:06:11.000Z", "avg_line_length": 21.7205479452, "max_line_length": 79, "alphanum_fraction": 0.575554995, "num_tokens": 2282, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8519528132451417, "lm_q2_score": 0.6334102636778401, "lm_q1q2_score": 0.5396356560786829}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"field2d.h\"\n#include \"weno.h\"\n#include \"rk.h\"\n\n#include \n#include \nnamespace math = boost::math::constants;\nusing namespace boost::numeric;\n\nauto\npacman_factory ( double r , double alpha , double value=1.0 ) {\n return [=]( double x , double y ) {\n if ( ( x*x + y*y < r*r ) && ( (x<0.0) || (std::abs(y)>alpha*x) ) ) {\n return value;\n }\n return 0.0;\n };\n}\n#define SQ(X) ((X)*(X))\nauto\ngauss_factory ( double X0 , double Y0 , double tx , double ty ) {\n return [=]( double x , double y ) {\n return std::exp(-SQ(x-X0)/tx - SQ(y-Y0)/ty);\n };\n}\n#undef SQ\n\nint\nmain(int,char**)\n{\n std::size_t N = 100;\n double xmax = 5.0;\n std::size_t Nx=N,Ny=N;\n field2d f(boost::extents[Nx][Ny]);\n f.range.x_min = -xmax; f.range.x_max = xmax;\n f.range.y_min = -xmax; f.range.y_max = xmax;\n f.compute_steps();\n\n field2d g(boost::extents[Nx][Ny]);\n g.range = f.range;\n g.steps = f.steps;\n\n auto pacman = pacman_factory(1.0,0.5);\n auto gauss = gauss_factory(0.0,1.0,0.75,0.25);\n for ( auto i=0u ; i()*f.x(i)/xmax)*std::sin(2.*math::pi()*f.y(j)/xmax);\n //f[i][j] = std::cos(2.*math::pi()*f.x(i)/xmax);\n\n g[i][j] = f[i][j];\n }\n }\n ublas::vector E(2,0); E[0] = 0.1; E[1] = 0.1;\n\n //double dt= 1.3*f.steps.dx/(std::abs(E[0])+std::abs(E[1])+2.0*xmax);\n double dt= 1.3*f.steps.dx/(std::abs(E[0])+std::abs(E[1]));\n double Tf= 1.0; //.5*math::pi();\n\n\n auto save_f = [](field2d const& f,std::string filename) {\n std::ofstream of(filename);\n of << f << std::endl;\n of.close();\n };\n\n save_f(f,\"finit.dat\");\n save_f(g,\"ginit.dat\");\n\n\n\n auto Lij_f = [&](double tn , const field2d & u , std::size_t i, std::size_t j){\n return - (weno2d::weno_x( E[0]+u.y(j) ,u,i,j) + weno2d::weno_y( E[1]-u.x(i) ,u,i,j));\n };\n auto Lij_g = [&](double tn , const field2d & u , std::size_t i , std::size_t j){\n return - ( weno2d::weno_x( E[0]*std::cos(tn) - E[1]*std::sin(tn) ,u,i,j)\n + weno2d::weno_y( E[0]*std::sin(tn) + E[1]*std::cos(tn) ,u,i,j) );\n };\n\n std::cout << \"dt: \"<< dt << \"\\tNiter: \" << std::floor(Tf/dt) << \"\\n\";\n double current_time = 0.0;\n std::size_t i_iter = 0;\n while ( current_time < Tf ) {\n std::cout << \"[\" << std::setw(10) << current_time << \"] \\r\" << std::flush;\n\n f = rk33( Lij_f , current_time , f , dt );\n\n g = rk33( Lij_g , current_time , g , dt );\n\n ++i_iter;\n current_time += dt;\n if ( current_time+dt > Tf ) { dt = Tf - current_time; }\n }\n std::cout << \"[\" << std::setw(10) << current_time << \"]\" << std::endl;\n\n save_f(f,\"fend.dat\");\n save_f(g,\"gend.dat\");\n\n f = rotation(g,current_time);\n\n save_f(f,\"ffend.dat\");\n\n return 0;\n}\n", "meta": {"hexsha": "47e58b2f2c97899e59d8049d25637a053b3cb47b", "size": 3078, "ext": "cc", "lang": "C++", "max_stars_repo_path": "misc/test_trp/2d/filtre.cc", "max_stars_repo_name": "kivvix/draft", "max_stars_repo_head_hexsha": "33b605be27e556df061f856be8e84e5b3f49a219", "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": "misc/test_trp/2d/filtre.cc", "max_issues_repo_name": "kivvix/draft", "max_issues_repo_head_hexsha": "33b605be27e556df061f856be8e84e5b3f49a219", "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": "misc/test_trp/2d/filtre.cc", "max_forks_repo_name": "kivvix/draft", "max_forks_repo_head_hexsha": "33b605be27e556df061f856be8e84e5b3f49a219", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.2389380531, "max_line_length": 107, "alphanum_fraction": 0.5545808967, "num_tokens": 1122, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199795472731, "lm_q2_score": 0.6442251201477016, "lm_q1q2_score": 0.5396158319619574}} {"text": "#include \"../include/ScaramuzzaCamera.h\"\n#include \"../include/Utils.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nEigen::VectorXd polyfit(Eigen::VectorXd &xVec, Eigen::VectorXd &yVec,\n int poly_order)\n{\n assert(poly_order > 0);\n assert(xVec.size() > poly_order);\n assert(xVec.size() == yVec.size());\n\n Eigen::MatrixXd A(xVec.size(), poly_order + 1);\n Eigen::VectorXd B(xVec.size());\n\n for (int i = 0; i < xVec.size(); ++i)\n {\n const double x = xVec(i);\n const double y = yVec(i);\n\n double x_pow_k = 1.0;\n\n for (int k = 0; k <= poly_order; ++k)\n {\n A(i, k) = x_pow_k;\n x_pow_k *= x;\n }\n\n B(i) = y;\n }\n\n Eigen::JacobiSVD svd(\n A, Eigen::ComputeThinU | Eigen::ComputeThinV);\n Eigen::VectorXd x = svd.solve(B);\n\n return x;\n}\n\nOCAMCamera::Parameters::Parameters()\n : Camera::Parameters(SCARAMUZZA),\n m_C(0.0),\n m_D(0.0),\n m_E(0.0),\n m_center_x(0.0),\n m_center_y(0.0)\n{\n memset(m_poly, 0, sizeof(double) * SCARAMUZZA_POLY_SIZE);\n memset(m_inv_poly, 0, sizeof(double) * SCARAMUZZA_INV_POLY_SIZE);\n}\n\nbool OCAMCamera::Parameters::readFromYamlFile(const std::string &filename)\n{\n cv::FileStorage fs(filename, cv::FileStorage::READ);\n\n if (!fs.isOpened())\n {\n return false;\n }\n\n if (!fs[\"model_type\"].isNone())\n {\n std::string sModelType;\n fs[\"model_type\"] >> sModelType;\n\n if (!boost::iequals(sModelType, \"scaramuzza\"))\n {\n return false;\n }\n }\n\n m_modelType = SCARAMUZZA;\n fs[\"camera_name\"] >> m_cameraName;\n m_imageWidth = static_cast(fs[\"image_width\"]);\n m_imageHeight = static_cast(fs[\"image_height\"]);\n\n cv::FileNode n = fs[\"poly_parameters\"];\n for (int i = 0; i < SCARAMUZZA_POLY_SIZE; i++)\n m_poly[i] = static_cast(\n n[std::string(\"p\") + boost::lexical_cast(i)]);\n\n n = fs[\"inv_poly_parameters\"];\n for (int i = 0; i < SCARAMUZZA_INV_POLY_SIZE; i++)\n m_inv_poly[i] = static_cast(\n n[std::string(\"p\") + boost::lexical_cast(i)]);\n\n n = fs[\"affine_parameters\"];\n m_C = static_cast(n[\"ac\"]);\n m_D = static_cast(n[\"ad\"]);\n m_E = static_cast(n[\"ae\"]);\n\n m_center_x = static_cast(n[\"cx\"]);\n m_center_y = static_cast(n[\"cy\"]);\n\n return true;\n}\n\nvoid OCAMCamera::Parameters::writeToYamlFile(\n const std::string &filename) const\n{\n cv::FileStorage fs(filename, cv::FileStorage::WRITE);\n\n fs << \"model_type\"\n << \"scaramuzza\";\n fs << \"camera_name\" << m_cameraName;\n fs << \"image_width\" << m_imageWidth;\n fs << \"image_height\" << m_imageHeight;\n\n fs << \"poly_parameters\";\n fs << \"{\";\n for (int i = 0; i < SCARAMUZZA_POLY_SIZE; i++)\n fs << std::string(\"p\") + boost::lexical_cast(i) << m_poly[i];\n fs << \"}\";\n\n fs << \"inv_poly_parameters\";\n fs << \"{\";\n for (int i = 0; i < SCARAMUZZA_INV_POLY_SIZE; i++)\n fs << std::string(\"p\") + boost::lexical_cast(i)\n << m_inv_poly[i];\n fs << \"}\";\n\n fs << \"affine_parameters\";\n fs << \"{\"\n << \"ac\" << m_C << \"ad\" << m_D << \"ae\" << m_E << \"cx\" << m_center_x << \"cy\"\n << m_center_y << \"}\";\n\n fs.release();\n}\n\nOCAMCamera::Parameters &OCAMCamera::Parameters::operator=(\n const OCAMCamera::Parameters &other)\n{\n if (this != &other)\n {\n m_modelType = other.m_modelType;\n m_cameraName = other.m_cameraName;\n m_imageWidth = other.m_imageWidth;\n m_imageHeight = other.m_imageHeight;\n m_C = other.m_C;\n m_D = other.m_D;\n m_E = other.m_E;\n m_center_x = other.m_center_x;\n m_center_y = other.m_center_y;\n\n memcpy(m_poly, other.m_poly, sizeof(double) * SCARAMUZZA_POLY_SIZE);\n memcpy(m_inv_poly, other.m_inv_poly,\n sizeof(double) * SCARAMUZZA_INV_POLY_SIZE);\n }\n\n return *this;\n}\n\nstd::ostream &operator<<(std::ostream &out,\n const OCAMCamera::Parameters ¶ms)\n{\n out << \"Camera Parameters:\" << std::endl;\n out << \" model_type \"\n << \"scaramuzza\" << std::endl;\n out << \" camera_name \" << params.m_cameraName << std::endl;\n out << \" image_width \" << params.m_imageWidth << std::endl;\n out << \" image_height \" << params.m_imageHeight << std::endl;\n\n out << std::fixed << std::setprecision(10);\n\n out << \"Poly Parameters\" << std::endl;\n for (int i = 0; i < SCARAMUZZA_POLY_SIZE; i++)\n out << std::string(\"p\") + boost::lexical_cast(i) << \": \"\n << params.m_poly[i] << std::endl;\n\n out << \"Inverse Poly Parameters\" << std::endl;\n for (int i = 0; i < SCARAMUZZA_INV_POLY_SIZE; i++)\n out << std::string(\"p\") + boost::lexical_cast(i) << \": \"\n << params.m_inv_poly[i] << std::endl;\n\n out << \"Affine Parameters\" << std::endl;\n out << \" ac \" << params.m_C << std::endl\n << \" ad \" << params.m_D << std::endl\n << \" ae \" << params.m_E << std::endl;\n out << \" cx \" << params.m_center_x << std::endl\n << \" cy \" << params.m_center_y << std::endl;\n\n return out;\n}\n\nOCAMCamera::OCAMCamera() : m_inv_scale(0.0) {}\n\nOCAMCamera::OCAMCamera(const OCAMCamera::Parameters ¶ms)\n : mParameters(params)\n{\n m_inv_scale = 1.0 / (params.C() - params.D() * params.E());\n}\n\nCamera::ModelType OCAMCamera::modelType(void) const\n{\n return mParameters.modelType();\n}\n\nconst std::string &OCAMCamera::cameraName(void) const\n{\n return mParameters.cameraName();\n}\n\nint OCAMCamera::imageWidth(void) const { return mParameters.imageWidth(); }\n\nint OCAMCamera::imageHeight(void) const { return mParameters.imageHeight(); }\n\nvoid OCAMCamera::estimateIntrinsics(\n const cv::Size &boardSize,\n const std::vector> &objectPoints,\n const std::vector> &imagePoints)\n{\n // std::cout << \"OCAMCamera::estimateIntrinsics - NOT IMPLEMENTED\" <<\n // std::endl;\n // throw std::string(\"OCAMCamera::estimateIntrinsics - NOT IMPLEMENTED\");\n\n // Reference: Page 30 of\n // \" Scaramuzza, D. Omnidirectional Vision: from Calibration to Robot Motion\n // Estimation, ETH Zurich. Thesis no. 17635.\"\n // http://e-collection.library.ethz.ch/eserv/eth:30301/eth-30301-02.pdf\n // Matlab code: calibrate.m\n\n // First, estimate every image's extrinsics parameters\n std::vector RList;\n std::vector TList;\n\n RList.reserve(imagePoints.size());\n TList.reserve(imagePoints.size());\n\n // i-th image\n for (size_t image_index = 0; image_index < imagePoints.size();\n ++image_index)\n {\n const std::vector &objPts = objectPoints.at(image_index);\n const std::vector &imgPts = imagePoints.at(image_index);\n\n assert(objPts.size() == imgPts.size());\n assert(objPts.size() ==\n static_cast(boardSize.width * boardSize.height));\n\n Eigen::MatrixXd M(objPts.size(), 6);\n\n for (size_t corner_index = 0; corner_index < objPts.size();\n ++corner_index)\n {\n double X = objPts.at(corner_index).x;\n double Y = objPts.at(corner_index).y;\n assert(objPts.at(corner_index).z == 0.0);\n\n double u = imgPts.at(corner_index).x;\n double v = imgPts.at(corner_index).y;\n\n M(corner_index, 0) = -v * X;\n M(corner_index, 1) = -v * Y;\n M(corner_index, 2) = u * X;\n M(corner_index, 3) = u * Y;\n M(corner_index, 4) = -v;\n M(corner_index, 5) = u;\n }\n\n Eigen::JacobiSVD svd(\n M, Eigen::ComputeFullU | Eigen::ComputeFullV);\n assert(svd.matrixV().cols() == 6);\n Eigen::VectorXd h = -svd.matrixV().col(5);\n\n // scaled version of R and T\n const double sr11 = h(0);\n const double sr12 = h(1);\n const double sr21 = h(2);\n const double sr22 = h(3);\n const double st1 = h(4);\n const double st2 = h(5);\n\n const double AA = square(sr11 * sr12 + sr21 * sr22);\n const double BB = square(sr11) + square(sr21);\n const double CC = square(sr12) + square(sr22);\n\n const double sr32_squared_1 =\n (-(CC - BB) + sqrt(square(CC - BB) + 4.0 * AA)) / 2.0;\n const double sr32_squared_2 =\n (-(CC - BB) - sqrt(square(CC - BB) + 4.0 * AA)) / 2.0;\n\n // printf(\"rst = %.12f\\n\", sr32_squared_1*sr32_squared_1 +\n // (CC-BB)*sr32_squared_1 - AA);\n\n std::vector sr32_squared_values;\n if (sr32_squared_1 > 0)\n sr32_squared_values.push_back(sr32_squared_1);\n if (sr32_squared_2 > 0)\n sr32_squared_values.push_back(sr32_squared_2);\n assert(!sr32_squared_values.empty());\n\n std::vector sr32_values;\n std::vector sr31_values;\n for (auto sr32_squared : sr32_squared_values)\n {\n for (int sign = -1; sign <= 1; sign += 2)\n {\n const double sr32 = static_cast(sign) * std::sqrt(sr32_squared);\n sr32_values.push_back(sr32);\n if (sr32_squared == 0.0)\n {\n // sr31 can be calculated through norm equality,\n // but it has positive and negative posibilities\n // positive one\n sr31_values.push_back(std::sqrt(CC - BB));\n // negative one\n sr32_values.push_back(sr32);\n sr31_values.push_back(-std::sqrt(CC - BB));\n\n break; // skip the same situation\n }\n else\n {\n // sr31 can be calculated throught dot product == 0\n sr31_values.push_back(-(sr11 * sr12 + sr21 * sr22) / sr32);\n }\n }\n }\n\n // std::cout << \"h= \" << std::setprecision(12) << h.transpose() <<\n // std::endl;\n // std::cout << \"length: \" << sr32_values.size() << \" & \" <<\n // sr31_values.size() << std::endl;\n\n assert(!sr31_values.empty());\n assert(sr31_values.size() == sr32_values.size());\n\n std::vector H_values;\n for (size_t i = 0; i < sr31_values.size(); ++i)\n {\n const double sr31 = sr31_values.at(i);\n const double sr32 = sr32_values.at(i);\n const double lambda = 1.0 / sqrt(sr11 * sr11 + sr21 * sr21 + sr31 * sr31);\n Eigen::Matrix3d H;\n H.setZero();\n H(0, 0) = sr11;\n H(0, 1) = sr12;\n H(0, 2) = st1;\n H(1, 0) = sr21;\n H(1, 1) = sr22;\n H(1, 2) = st2;\n H(2, 0) = sr31;\n H(2, 1) = sr32;\n H(2, 2) = 0;\n\n H_values.push_back(lambda * H);\n H_values.push_back(-lambda * H);\n }\n\n for (auto &H : H_values)\n {\n // std::cout << \"H=\\n\" << H << std::endl;\n Eigen::Matrix3d R;\n R.col(0) = H.col(0);\n R.col(1) = H.col(1);\n R.col(2) = H.col(0).cross(H.col(1));\n // std::cout << \"R33 = \" << R(2,2) << std::endl;\n }\n\n std::vector H_candidates;\n\n for (auto &H : H_values)\n {\n Eigen::MatrixXd A_mat(2 * imagePoints.at(image_index).size(), 4);\n Eigen::VectorXd B_vec(2 * imagePoints.at(image_index).size());\n A_mat.setZero();\n B_vec.setZero();\n\n size_t line_index = 0;\n\n // iterate images\n const double &r11 = H(0, 0);\n const double &r12 = H(0, 1);\n // const double& r13 = H(0,2);\n const double &r21 = H(1, 0);\n const double &r22 = H(1, 1);\n // const double& r23 = H(1,2);\n const double &r31 = H(2, 0);\n const double &r32 = H(2, 1);\n // const double& r33 = H(2,2);\n const double &t1 = H(0);\n const double &t2 = H(1);\n\n // iterate chessboard corners in the image\n for (size_t j = 0; j < imagePoints.at(image_index).size(); ++j)\n {\n assert(line_index == 2 * j);\n\n const double &X = objectPoints.at(image_index).at(j).x;\n const double &Y = objectPoints.at(image_index).at(j).y;\n const double &u = imagePoints.at(image_index).at(j).x;\n const double &v = imagePoints.at(image_index).at(j).y;\n\n double A = r21 * X + r22 * Y + t2;\n double B = v * (r31 * X + r32 * Y);\n double C = r11 * X + r12 * Y + t1;\n double D = u * (r31 * X + r32 * Y);\n double rou = std::sqrt(u * u + v * v);\n\n A_mat(line_index + 0, 0) = A;\n A_mat(line_index + 1, 0) = C;\n A_mat(line_index + 0, 1) = A * rou;\n A_mat(line_index + 1, 1) = C * rou;\n A_mat(line_index + 0, 2) = A * rou * rou;\n A_mat(line_index + 1, 2) = C * rou * rou;\n\n A_mat(line_index + 0, 3) = -v;\n A_mat(line_index + 1, 3) = -u;\n B_vec(line_index + 0) = B;\n B_vec(line_index + 1) = D;\n\n line_index += 2;\n }\n\n assert(line_index == static_cast(A_mat.rows()));\n\n // pseudo-inverse for polynomial parameters and all t3s\n {\n Eigen::JacobiSVD svd(\n A_mat, Eigen::ComputeThinU | Eigen::ComputeThinV);\n\n Eigen::VectorXd x = svd.solve(B_vec);\n\n // std::cout << \"x(poly and t3) = \" << x << std::endl;\n\n if (x(2) > 0 && x(3) > 0)\n {\n H_candidates.push_back(H);\n }\n }\n }\n\n // printf(\"H_candidates.size()=%zu\\n\", H_candidates.size());\n assert(H_candidates.size() == 1);\n\n Eigen::Matrix3d &H = H_candidates.front();\n\n Eigen::Matrix3d R;\n R.col(0) = H.col(0);\n R.col(1) = H.col(1);\n R.col(2) = H.col(0).cross(H.col(1));\n\n Eigen::Vector3d T = H.col(2);\n RList.push_back(R);\n TList.push_back(T);\n\n // std::cout << \"#\" << image_index << \" frame\" << \" R =\" << R << \" \\nT = \"\n // << T.transpose() << std::endl;\n }\n\n // Second, estimate camera intrinsic parameters and all t3\n Eigen::MatrixXd A_mat(2 * imagePoints.size() * imagePoints.at(0).size(),\n SCARAMUZZA_POLY_SIZE - 1 + imagePoints.size());\n Eigen::VectorXd B_vec(2 * imagePoints.size() * imagePoints.at(0).size());\n A_mat.setZero();\n B_vec.setZero();\n\n size_t line_index = 0;\n\n // iterate images\n for (size_t i = 0; i < imagePoints.size(); ++i)\n {\n const double &r11 = RList.at(i)(0, 0);\n const double &r12 = RList.at(i)(0, 1);\n // const double& r13 = RList.at(i)(0,2);\n const double &r21 = RList.at(i)(1, 0);\n const double &r22 = RList.at(i)(1, 1);\n // const double& r23 = RList.at(i)(1,2);\n const double &r31 = RList.at(i)(2, 0);\n const double &r32 = RList.at(i)(2, 1);\n // const double& r33 = RList.at(i)(2,2);\n const double &t1 = TList.at(i)(0);\n const double &t2 = TList.at(i)(1);\n\n // iterate chessboard corners in the image\n for (size_t j = 0; j < imagePoints.at(i).size(); ++j)\n {\n assert(line_index == 2 * (i * imagePoints.at(0).size() + j));\n\n const double &X = objectPoints.at(i).at(j).x;\n const double &Y = objectPoints.at(i).at(j).y;\n const double &u = imagePoints.at(i).at(j).x;\n const double &v = imagePoints.at(i).at(j).y;\n\n double A = r21 * X + r22 * Y + t2;\n double B = v * (r31 * X + r32 * Y);\n double C = r11 * X + r12 * Y + t1;\n double D = u * (r31 * X + r32 * Y);\n double rou = std::sqrt(u * u + v * v);\n\n for (int k = 1; k <= SCARAMUZZA_POLY_SIZE - 1; ++k)\n {\n double pow_rou = 0.0;\n if (k == 1)\n {\n pow_rou = 1.0;\n }\n else\n {\n pow_rou = std::pow(rou, k);\n }\n\n A_mat(line_index + 0, k - 1) = A * pow_rou;\n A_mat(line_index + 1, k - 1) = C * pow_rou;\n }\n\n A_mat(line_index + 0, SCARAMUZZA_POLY_SIZE - 1 + i) = -v;\n A_mat(line_index + 1, SCARAMUZZA_POLY_SIZE - 1 + i) = -u;\n B_vec(line_index + 0) = B;\n B_vec(line_index + 1) = D;\n\n line_index += 2;\n }\n }\n\n assert(line_index == static_cast(A_mat.rows()));\n\n Eigen::Matrix poly_coeff;\n // pseudo-inverse for polynomial parameters and all t3s\n {\n Eigen::JacobiSVD svd(\n A_mat, Eigen::ComputeThinU | Eigen::ComputeThinV);\n\n Eigen::VectorXd x = svd.solve(B_vec);\n\n poly_coeff[0] = x(0);\n poly_coeff[1] = 0.0;\n for (int i = 1; i < poly_coeff.size() - 1; ++i)\n {\n poly_coeff[i + 1] = x(i);\n }\n assert(x.size() ==\n static_cast(SCARAMUZZA_POLY_SIZE - 1 + TList.size()));\n }\n\n Parameters params = getParameters();\n\n // Affine matrix A is constructed as [C D; E 1]\n params.C() = 1.0;\n params.D() = 0.0;\n params.E() = 0.0;\n\n params.center_x() = params.imageWidth() / 2.0;\n params.center_y() = params.imageHeight() / 2.0;\n\n for (size_t i = 0; i < SCARAMUZZA_POLY_SIZE; ++i)\n {\n params.poly(i) = poly_coeff[i];\n }\n\n // params.poly(0) = -216.9657476318;\n // params.poly(1) = 0.0;\n // params.poly(2) = 0.0017866911;\n // params.poly(3) = -0.0000019866;\n // params.poly(4) = 0.0000000077;\n\n // inv_poly\n {\n std::vector rou_vec;\n std::vector z_vec;\n for (double rou = 0.0;\n rou <= (params.imageWidth() + params.imageHeight()) / 2; rou += 0.1)\n {\n double rou_pow_k = 1.0;\n double z = 0.0;\n\n for (int k = 0; k < SCARAMUZZA_POLY_SIZE; k++)\n {\n z += rou_pow_k * params.poly(k);\n rou_pow_k *= rou;\n }\n\n rou_vec.push_back(rou);\n z_vec.push_back(z);\n }\n\n assert(rou_vec.size() == z_vec.size());\n Eigen::VectorXd xVec(rou_vec.size());\n Eigen::VectorXd yVec(rou_vec.size());\n\n for (size_t i = 0; i < rou_vec.size(); ++i)\n {\n xVec(i) = std::atan2(-z_vec.at(i), rou_vec.at(i));\n yVec(i) = rou_vec.at(i);\n }\n\n // use lower order poly to eliminate over-fitting cause by noisy/inaccurate\n // data\n const int poly_fit_order = 4;\n Eigen::VectorXd inv_poly_coeff = polyfit(xVec, yVec, poly_fit_order);\n\n for (int i = 0; i <= poly_fit_order; ++i)\n {\n params.inv_poly(i) = inv_poly_coeff(i);\n }\n }\n\n setParameters(params);\n\n std::cout << \"initial params:\\n\"\n << params << std::endl;\n}\n\n/**\n * \\brief Lifts a point from the image plane to the unit sphere\n *\n * \\param p image coordinates\n * \\param P coordinates of the point on the sphere\n */\nvoid OCAMCamera::liftSphere(const Eigen::Vector2d &p,\n Eigen::Vector3d &P) const\n{\n liftProjective(p, P);\n P.normalize();\n}\n\n/**\n * \\brief Lifts a point from the image plane to its projective ray\n *\n * \\param p image coordinates\n * \\param P coordinates of the projective ray\n */\nvoid OCAMCamera::liftProjective(const Eigen::Vector2d &p,\n Eigen::Vector3d &P) const\n{\n // Relative to Center\n Eigen::Vector2d xc(p[0] - mParameters.center_x(),\n p[1] - mParameters.center_y());\n\n // Affine Transformation\n // xc_a = inv(A) * xc;\n Eigen::Vector2d xc_a(\n m_inv_scale * (xc[0] - mParameters.D() * xc[1]),\n m_inv_scale * (-mParameters.E() * xc[0] + mParameters.C() * xc[1]));\n\n double phi = std::sqrt(xc_a[0] * xc_a[0] + xc_a[1] * xc_a[1]);\n double phi_i = 1.0;\n double z = 0.0;\n\n for (int i = 0; i < SCARAMUZZA_POLY_SIZE; i++)\n {\n z += phi_i * mParameters.poly(i);\n phi_i *= phi;\n }\n\n P << xc[0], xc[1], -z;\n}\n\n/**\n * \\brief Project a 3D point (\\a x,\\a y,\\a z) to the image plane in (\\a u,\\a v)\n *\n * \\param P 3D point coordinates\n * \\param p return value, contains the image point coordinates\n */\nvoid OCAMCamera::spaceToPlane(const Eigen::Vector3d &P,\n Eigen::Vector2d &p) const\n{\n double norm = std::sqrt(P[0] * P[0] + P[1] * P[1]);\n double theta = std::atan2(-P[2], norm);\n double rho = 0.0;\n double theta_i = 1.0;\n\n for (int i = 0; i < SCARAMUZZA_INV_POLY_SIZE; i++)\n {\n rho += theta_i * mParameters.inv_poly(i);\n theta_i *= theta;\n }\n\n double invNorm = 1.0 / norm;\n Eigen::Vector2d xn(P[0] * invNorm * rho, P[1] * invNorm * rho);\n\n p << xn[0] * mParameters.C() + xn[1] * mParameters.D() +\n mParameters.center_x(),\n xn[0] * mParameters.E() + xn[1] + mParameters.center_y();\n}\n\n/**\n * \\brief Projects an undistorted 2D point p_u to the image plane\n *\n * \\param p_u 2D point coordinates\n * \\return image point coordinates\n */\nvoid OCAMCamera::undistToPlane(const Eigen::Vector2d &p_u,\n Eigen::Vector2d &p) const\n{\n Eigen::Vector3d P(p_u[0], p_u[1], 1.0);\n spaceToPlane(P, p);\n}\n\n#if 0\nvoid\nOCAMCamera::initUndistortMap(cv::Mat& map1, cv::Mat& map2, double fScale) const\n{\n cv::Size imageSize(mParameters.imageWidth(), mParameters.imageHeight());\n\n cv::Mat mapX = cv::Mat::zeros(imageSize, CV_32F);\n cv::Mat mapY = cv::Mat::zeros(imageSize, CV_32F);\n\n for (int v = 0; v < imageSize.height; ++v)\n {\n for (int u = 0; u < imageSize.width; ++u)\n {\n double mx_u = m_inv_K11 / fScale * u + m_inv_K13 / fScale;\n double my_u = m_inv_K22 / fScale * v + m_inv_K23 / fScale;\n\n double xi = mParameters.xi();\n double d2 = mx_u * mx_u + my_u * my_u;\n\n Eigen::Vector3d P;\n P << mx_u, my_u, 1.0 - xi * (d2 + 1.0) / (xi + sqrt(1.0 + (1.0 - xi * xi) * d2));\n\n Eigen::Vector2d p;\n spaceToPlane(P, p);\n\n mapX.at(v,u) = p(0);\n mapY.at(v,u) = p(1);\n }\n }\n\n cv::convertMaps(mapX, mapY, map1, map2, CV_32FC1, false);\n}\n#endif\n\ncv::Mat OCAMCamera::initUndistortRectifyMap(cv::Mat &map1, cv::Mat &map2,\n float fx, float fy,\n cv::Size imageSize, float cx,\n float cy, cv::Mat rmat) const\n{\n if (imageSize == cv::Size(0, 0))\n {\n imageSize = cv::Size(mParameters.imageWidth(), mParameters.imageHeight());\n }\n\n cv::Mat mapX = cv::Mat::zeros(imageSize.height, imageSize.width, CV_32F);\n cv::Mat mapY = cv::Mat::zeros(imageSize.height, imageSize.width, CV_32F);\n\n Eigen::Matrix3f K_rect;\n\n K_rect << fx, 0, cx < 0 ? imageSize.width / 2 : cx, 0, fy,\n cy < 0 ? imageSize.height / 2 : cy, 0, 0, 1;\n\n if (fx < 0 || fy < 0)\n {\n throw std::string(std::string(__FUNCTION__) +\n \": Focal length must be specified\");\n }\n\n Eigen::Matrix3f K_rect_inv = K_rect.inverse();\n\n Eigen::Matrix3f R, R_inv;\n cv::cv2eigen(rmat, R);\n R_inv = R.inverse();\n\n for (int v = 0; v < imageSize.height; ++v)\n {\n for (int u = 0; u < imageSize.width; ++u)\n {\n Eigen::Vector3f xo;\n xo << u, v, 1;\n\n Eigen::Vector3f uo = R_inv * K_rect_inv * xo;\n\n Eigen::Vector2d p;\n spaceToPlane(uo.cast(), p);\n\n mapX.at(v, u) = p(0);\n mapY.at(v, u) = p(1);\n }\n }\n\n cv::convertMaps(mapX, mapY, map1, map2, CV_32FC1, false);\n\n cv::Mat K_rect_cv;\n cv::eigen2cv(K_rect, K_rect_cv);\n return K_rect_cv;\n}\n\nint OCAMCamera::parameterCount(void) const\n{\n return SCARAMUZZA_CAMERA_NUM_PARAMS;\n}\n\nconst OCAMCamera::Parameters &OCAMCamera::getParameters(void) const\n{\n return mParameters;\n}\n\nvoid OCAMCamera::setParameters(const OCAMCamera::Parameters ¶meters)\n{\n mParameters = parameters;\n\n m_inv_scale = 1.0 / (parameters.C() - parameters.D() * parameters.E());\n}\n\nvoid OCAMCamera::readParameters(const std::vector ¶meterVec)\n{\n if ((int)parameterVec.size() != parameterCount())\n {\n return;\n }\n\n Parameters params = getParameters();\n\n params.C() = parameterVec.at(0);\n params.D() = parameterVec.at(1);\n params.E() = parameterVec.at(2);\n params.center_x() = parameterVec.at(3);\n params.center_y() = parameterVec.at(4);\n for (int i = 0; i < SCARAMUZZA_POLY_SIZE; i++)\n params.poly(i) = parameterVec.at(5 + i);\n for (int i = 0; i < SCARAMUZZA_INV_POLY_SIZE; i++)\n params.inv_poly(i) = parameterVec.at(5 + SCARAMUZZA_POLY_SIZE + i);\n\n setParameters(params);\n}\n\nvoid OCAMCamera::writeParameters(std::vector ¶meterVec) const\n{\n parameterVec.resize(parameterCount());\n parameterVec.at(0) = mParameters.C();\n parameterVec.at(1) = mParameters.D();\n parameterVec.at(2) = mParameters.E();\n parameterVec.at(3) = mParameters.center_x();\n parameterVec.at(4) = mParameters.center_y();\n for (int i = 0; i < SCARAMUZZA_POLY_SIZE; i++)\n parameterVec.at(5 + i) = mParameters.poly(i);\n for (int i = 0; i < SCARAMUZZA_INV_POLY_SIZE; i++)\n parameterVec.at(5 + SCARAMUZZA_POLY_SIZE + i) = mParameters.inv_poly(i);\n}\n\nvoid OCAMCamera::writeParametersToYamlFile(const std::string &filename) const\n{\n mParameters.writeToYamlFile(filename);\n}\n\nstd::string OCAMCamera::parametersToString(void) const\n{\n std::ostringstream oss;\n oss << mParameters;\n\n return oss.str();\n}\n", "meta": {"hexsha": "8b3797f7a2919bcbec8655b15aca1f327187cf05", "size": 24419, "ext": "cc", "lang": "C++", "max_stars_repo_path": "camera_models/src/ScaramuzzaCamera.cc", "max_stars_repo_name": "daoran/CamLaserCalibraTool", "max_stars_repo_head_hexsha": "e3ba0c66e012989bec1411c4b4a41c0c150a324d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 400.0, "max_stars_repo_stars_event_min_datetime": "2018-12-14T09:36:19.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T05:14:37.000Z", "max_issues_repo_path": "camera_models/src/ScaramuzzaCamera.cc", "max_issues_repo_name": "chisyliu/CamLaserCalibraTool", "max_issues_repo_head_hexsha": "c2b72f8a6e50f2dfc863b393baefbb10c05c6c6d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 28.0, "max_issues_repo_issues_event_min_datetime": "2019-07-29T20:08:31.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-23T03:37:59.000Z", "max_forks_repo_path": "camera_models/src/ScaramuzzaCamera.cc", "max_forks_repo_name": "chisyliu/CamLaserCalibraTool", "max_forks_repo_head_hexsha": "c2b72f8a6e50f2dfc863b393baefbb10c05c6c6d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 158.0, "max_forks_repo_forks_event_min_datetime": "2018-12-14T10:30:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-12T03:14:10.000Z", "avg_line_length": 28.6607981221, "max_line_length": 93, "alphanum_fraction": 0.5835210287, "num_tokens": 7692, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199714402812, "lm_q2_score": 0.6442251064863697, "lm_q1q2_score": 0.539615815296225}} {"text": "#include \n#include \n#include \n#include \n\nusing namespace std;\n\ndouble dot(const Vector& v1, const Vector& v2){\n return v1.x()*v2.x() + v1.y()*v2.y() + v1.z()*v2.z();\n}\n\ndouble dot(const Point& v1, const Point& v2){\n return v1.x()*v2.x() + v1.y()*v2.y() + v1.z()*v2.z();\n}\n\ndouble dot(const Vector& v1, const Point& v2){\n return v1.x()*v2.x() + v1.y()*v2.y() + v1.z()*v2.z();\n}\n\ndouble dot(const Point& v1, const Vector& v2){\n return v1.x()*v2.x() + v1.y()*v2.y() + v1.z()*v2.z();\n}\n\nVector crossV(const Vector& v1, const Vector& v2){\n\n return Vector(v1.y()*v2.z() - v1.z()*v2.y(),\n v1.z()*v2.x() - v1.x()*v2.z(),\n v1.x()*v2.y() - v1.y()*v2.x());\n}\n\nVector crossV(const Point& v1, const Point& v2){\n\n return Vector(v1.y()*v2.z() - v1.z()*v2.y(),\n v1.z()*v2.x() - v1.x()*v2.z(),\n v1.x()*v2.y() - v1.y()*v2.x());\n}\n\nPoint crossP(const Vector& v1, const Vector& v2){\n\n return Point(v1.y()*v2.z() - v1.z()*v2.y(),\n v1.z()*v2.x() - v1.x()*v2.z(),\n v1.x()*v2.y() - v1.y()*v2.x());\n}\n\nPoint crossP(const Point& v1, const Point& v2){\n\n return Point(v1.y()*v2.z() - v1.z()*v2.y(),\n v1.z()*v2.x() - v1.x()*v2.z(),\n v1.x()*v2.y() - v1.y()*v2.x());\n}\n\nPoint neg(const Point& p){\n\n return Point(-p.x(), -p.y(), -p.z());\n}\n\n\n\nconst double polyhedronVolume(vector> polyhedron){\n\n double volume;\n for(auto const& facet : polyhedron){\n volume+= dot(facet.first[0], facet.second);\n }\n return volume/6;\n\n}\n\n\ndouble pointPlaneDistance(EPICK::Plane_3 plane, Point point){\n\n // implemented from: http://mathworld.wolfram.com/Point-PlaneDistance.html\n\n double dist = (plane.a()*point.x() + plane.b()*point.y() + plane.c()*point.z() + plane.d()) /\n std::sqrt(plane.a()*plane.a() + plane.b()*plane.b() + plane.c()*plane.c());\n\n return dist;\n}\n\n\n\n// Implementation of geometry visualized in Figure 9 in P. Labatut, J‐P. Pons,\n// and R. Keriven. \"Robust and efficient surface reconstruction from range\n// data.\" Computer graphics forum, 2009.\ndouble computeCosFacetCellAngle(const Delaunay& Dt,\n const Delaunay::Facet& facet) {\n if (Dt.is_infinite(facet.first)) {\n return 1.0;\n }\n\n const Triangle triangle = Dt.triangle(facet);\n\n const Vector facet_normal =\n CGAL::cross_product(triangle[1] - triangle[0], triangle[2] - triangle[0]);\n const double facet_normal_length_squared = facet_normal.squared_length();\n if (facet_normal_length_squared == 0.0) {\n return 0.5;\n }\n\n const Vector co_tangent = CGAL::circumcenter(Dt.tetrahedron(facet.first)) - triangle[0];\n const float co_tangent_length_squared = co_tangent.squared_length();\n if (co_tangent_length_squared == 0.0) {\n return 0.5;\n }\n\n return (facet_normal * co_tangent) /\n std::sqrt(facet_normal_length_squared * co_tangent_length_squared);\n}\n\n\ndouble computeFacetArea(const Delaunay& Dt,\n const Delaunay::Facet& facet){\n if(Dt.is_infinite(facet))\n return 0.0;\n else\n return sqrt(Dt.triangle(facet).squared_area());\n};\n\n\nconst Point barycenter(const Cell_handle& ch){\n double x = 0, y = 0, z = 0;\n for(int i = 0; i < 4; i++){\n x+=ch->vertex(i)->point().x();\n y+=ch->vertex(i)->point().y();\n z+=ch->vertex(i)->point().z();\n }\n return Point(x/4.0,y/4.0,z/4.0);\n}\n\n\n\n\n\nbool rayTriangleIntersection(const Point& rayOrigin,\n const Vector& rayVector,\n const Triangle& inTriangle,\n Point& outIntersectionPoint){\n\n // implemented after: https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm\n\n using namespace Eigen;\n const double EPSILON = 0.0000001;\n\n // init \"Eigen\" vectors\n Vector3d rayO(rayOrigin.x(), rayOrigin.y(), rayOrigin.z());\n Vector3d rayV(rayVector.x(), rayVector.y(), rayVector.z());\n\n Vector3d vertex0(inTriangle.vertex(0).x(), inTriangle.vertex(0).y(), inTriangle.vertex(0).z());\n Vector3d vertex1(inTriangle.vertex(1).x(), inTriangle.vertex(1).y(), inTriangle.vertex(1).z());\n Vector3d vertex2(inTriangle.vertex(2).x(), inTriangle.vertex(2).y(), inTriangle.vertex(2).z());\n\n Vector3d edge1, edge2, h, s, q;\n double a;\n edge1 = vertex1 - vertex0;\n edge2 = vertex2 - vertex0;\n\n h = rayV.cross(edge2);\n a = edge1.dot(h);\n if (a > -EPSILON && a < EPSILON)\n return false; // This ray is parallel to this triangle.\n double f = 1.0/a;\n s = rayO - vertex0;\n double u = f * s.dot(h); // barycentric coordinate u\n if (u < 0.0 || u > 1.0) // if u is not between 0 and 1, intersection point does not lie in triangle\n return false;\n q = s.cross(edge1);\n double v = f * rayV.dot(q); // barycentric coordinate v\n if (v < 0.0 || u + v > 1.0) // if v is not between 0 and 1, intersection point does not lie in triangle\n return false;\n // At this stage we can compute t to find out where the intersection point is on the line.\n double t = f * edge2.dot(q);\n if (t > EPSILON) // ray intersection\n {\n outIntersectionPoint = rayOrigin + rayVector * t;\n return true;\n }\n else // This means that there is a line intersection but not a ray intersection.\n return false;\n}\n\n\n", "meta": {"hexsha": "a17d9c22b706ae09aa222711a0bac4617911d154", "size": 5483, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/util/geometricOperations.cpp", "max_stars_repo_name": "raphaelsulzer/mesh-tools", "max_stars_repo_head_hexsha": "73150bec58813e2b9b750205807002a1c3f18884", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2022-02-24T03:39:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-24T03:39:05.000Z", "max_issues_repo_path": "src/util/geometricOperations.cpp", "max_issues_repo_name": "raphaelsulzer/mesh-tools", "max_issues_repo_head_hexsha": "73150bec58813e2b9b750205807002a1c3f18884", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2022-02-24T06:59:59.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-04T01:25:09.000Z", "max_forks_repo_path": "src/util/geometricOperations.cpp", "max_forks_repo_name": "raphaelsulzer/mesh-tools", "max_forks_repo_head_hexsha": "73150bec58813e2b9b750205807002a1c3f18884", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.1263736264, "max_line_length": 107, "alphanum_fraction": 0.592923582, "num_tokens": 1644, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199633332891, "lm_q2_score": 0.6442251064863697, "lm_q1q2_score": 0.5396158100734972}} {"text": "#include \"Classes.h\"\n#include \n#include \n#include \nusing namespace Eigen;\n\nPlaneProjection* Object3D::project3D(double projectionPlane[4]) {\n ///\n /// General Function to project the current 3D object onto the projection plane passed as parameter \"projectionPlane\"\n ///\n // cout << \"Check\"< projectedVertices(len); --------Remove\n bool checkinput=check3dobject();\n vector isHidden;\n vector isHiddenEdge;\n int len = vertices.size(); \n // Before anything else, make all faces cyclic\n for(int i = 0; i < this->faces.size(); i++) {\n // cout << \"Operating over \" << faces[i];\n faces[i] = getCyclicFace(faces[i]);\n // cout << \" Got this face: \" << faces[i] << endl;\n }\n // cout << \"Cyclic Faces: \";\n // for(int i = 0; i < this->faces.size(); i++) {\n // cout << faces[i];\n // }\n // cout << endl;\n // Iteration to find all the projected vertices\n for (int i = 0; i < len; i++) {\n projectedVertices.push_back(vertices[i].projectPoint(projectionPlane));\n }\n cout << \"vertices projected \"<