{"text": "/*******************************************************************************\n * This domain is a simplified version of the paper: \n * \n * \"A Partial-Order Approach to Array Content Analysis\" by \n * Gange, Navas, Schachte, Sondergaard, and Stuckey\n * available here http://arxiv.org/pdf/1408.1754v1.pdf.\n *\n * It reasons about array contents and the idea is to compute all the\n * feasible partial orderings between array indexes. It keeps a single\n * graph where vertices are the array indexes (potentially all scalar\n * variables) and edges are labelled with weights (that includes\n * scalar and array variables). An edge (i,j) with weight w denotes\n * that the property w holds for the all elements in the array between\n * [i,j).\n ******************************************************************************/\n\n/* Limitations:\n\n - The implementation is just a proof-of-concept so it is horribly\n inefficient. I have not tried to make it more efficient yet or\n ran even with real programs.\n - Assume all array accesses are aligned wrt to the size of the array\n element (e.g., if the size of the array element is 4 bytes then\n all array accesses must be multiple of 4).\n - Assume that the size of the array element is always\n 1. Therefore, if the array indexes are incremented or decremented\n by 2,4,... we will lose all the precision.\n\n FIXMEs:\n\n - Use AdaptGraph instead of boost::graph\n - Have a flag is_normalized and normalize only if the flag is false\n - Perform incremental Floyd-Warshall by keeping track of changed edges.\n - array_graph::widening is normalizing both operands. The first\n operand cannot be normalized.\n - perform common renaming before binary operations (join/widening/narrowing/meet)\n - Do no use shared_ptr because we are doing deep copies Use magic\n move semantics and also shared references with copy-on-write to\n avoid unnecessary copies.\n - etc.\n\n */\n\n#ifndef ARRAY_GRAPH_HPP\n#define ARRAY_GRAPH_HPP\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#include \n#include \n\nusing namespace std;\nusing namespace boost;\nusing namespace ikos;\n\nnamespace crab {\n\n namespace domains {\n\n /*\n A weighted array graph is a graph (V,E,L) where V is the set of\n vertices, E the edges and L is a label function: E -> W such that:\n - If there is an edge e from vertex i to j whose weight is not\n bottom (i.e., L(e) != bot) then it means that i < j.\n - It is possible one non-bottom edge from i to j and another\n non-bottom one from j to i. This means that both i < j and j < i\n are possible.\n - If the both edges from i to j and from j to i are bottom then it\n must be that (i>=j) && (j>=i) = (i==j)\n */\n template< typename VertexName, typename Weight, \n typename ScalarNumDomain, bool IsDistWeight >\n class array_graph: public writeable{\n \n typedef VertexName VertexNameKey;\n \n template < typename Any1, typename Any2, bool Any5> \n friend class array_graph_domain;\n \n typedef index_t key_t;\n typedef boost::shared_ptr VertexNamePtr;\n typedef boost::shared_ptr WeightPtr;\n struct graph_vertex_t { VertexNamePtr name; };\n struct graph_edge_t { WeightPtr weight; }; \n \n public:\n typedef array_graph array_graph_t;\n typedef boost::tuple edge_t;\n \n private:\n typedef adjacency_list graph_t;\n \n typedef typename graph_traits::edge_iterator edge_iterator;\n typedef typename graph_traits::vertex_iterator vertex_iterator;\n typedef typename graph_traits::edge_descriptor edge_descriptor_t;\n typedef typename graph_traits::vertex_descriptor vertex_descriptor_t;\n typedef typename graph_traits::out_edge_iterator out_edge_iterator; \n typedef typename graph_traits::in_edge_iterator in_edge_iterator; \n \n typedef typename ScalarNumDomain::linear_constraint_t linear_constraint_t;\n typedef typename ScalarNumDomain::variable_t variable_t;\n \n typedef boost::unordered_map vertex_map_t;\n \n typedef std::set vertex_names_set_t;\n \n typedef boost::shared_ptr graph_ptr;\n typedef boost::shared_ptr< vertex_map_t > vertex_map_ptr;\n typedef boost::shared_ptr< vertex_names_set_t > vertex_names_set_ptr;\n \n bool _is_bottom;\n graph_ptr _graph; \n vertex_map_ptr _vertex_map; //! map a VertexName to a graph vertex\n vertex_names_set_ptr _vertices_set;\n \n bool find_vertex_map (VertexName v) {\n return (_vertex_map->find(v.index()) != _vertex_map->end()); \n }\n \n void insert_vertex_map (VertexName key, vertex_descriptor_t value)\n {\n if (find_vertex_map(key))\n CRAB_ERROR (key,\" already in the vertex map\");\n \n _vertex_map->insert (make_pair(key.index(), value));\n _vertices_set->insert (key);\n }\n \n void remove_vertex_map (VertexName key)\n {\n _vertex_map->erase (key.index());\n _vertices_set->erase (key);\n }\n \n vertex_descriptor_t lookup_vertex_map (VertexName key) const\n {\n auto it = _vertex_map->find(key.index());\n if (it != _vertex_map->end())\n return it->second;\n \n CRAB_ERROR (\"No vertex with name \",key,\" found in the graph\");\n }\n \n // All methods that add new vertices should call this one.\n void add (vector vertices, vector edges) \n {\n for(auto v: vertices)\n {\n vertex_descriptor_t u = add_vertex(*_graph);\n (*_graph)[u].name = VertexNamePtr (new VertexName(v));\n insert_vertex_map(v, u);\n }\n \n for(auto e: edges)\n {\n vertex_descriptor_t u = lookup_vertex_map(e.template get<0>());\n vertex_descriptor_t v = lookup_vertex_map(e.template get<1>());\n edge_descriptor_t k; bool b;\n boost::tie(k,b) = add_edge(u, v, *_graph);\n if (!b)\n CRAB_ERROR (\"edge is already in the graph\");\n \n (*_graph)[k].weight = WeightPtr(new Weight(e.template get<2>()));\n }\n \n canonical();\n }\n \n // All methods that remove vertices should call this one.\n void remove (VertexName v)\n {\n if (!find_vertex_map (v)) return ;\n \n canonical(); \n vertex_descriptor_t u = lookup_vertex_map(v);\n \n // remove all in and out edges to/from u\n clear_vertex(u, *_graph);\n \n // remove the vertex\n remove_vertex(u, *_graph);\n remove_vertex_map(v);\n }\n \n ///////////////////////////////////////////////////////////////////////\n // For our canonical form, we would like to compute the greatest\n // fixed point to the set of inequalities:\n // \\forall i,j,k. G[i,j] \\subseteq G[i,k] \\cup G[k,j]\n // If the weight domain is distributive we can solve this set of\n // inequations by solving:\n // \\forall i,j,k. G[i,j] = G[i,j] \\cap G[i,k] \\cup G[k,j]\n // The Floyd-Warshall algorithm does exactly that.\n // Otherwise, we iterate the Floyd-Warshall algorithm until no change.\n ///////////////////////////////////////////////////////////////////////\n bool oneStep()\n {\n binary_join_op join;\n binary_meet_op meet;\n vertex_iterator ki, ke, ii, ie, ji, je;\n bool change = false;\n for (tie(ki, ke) = vertices(*_graph); ki != ke; ++ki)\n {\n for (tie(ii, ie) = vertices(*_graph); ii != ie; ++ii)\n {\n if (edge(*ii, *ki, *_graph).second)\n {\n for (tie(ji, je) = vertices(*_graph); ji != je; ++ji)\n {\n if (edge(*ii, *ji, (*_graph)).second && \n edge(*ki, *ji, (*_graph)).second) \n {\n auto e_ij = edge(*ii, *ji, (*_graph)).first;\n auto e_ik = edge(*ii, *ki, (*_graph)).first;\n auto e_kj = edge(*ki, *ji, (*_graph)).first;\n auto Old = (*_graph)[e_ij].weight;\n auto New = meet((*_graph)[e_ij].weight,\n (join((*_graph)[e_ik].weight,\n (*_graph)[e_kj].weight)));\n change |= (!(*Old <= *New && *New <= *Old));\n (*_graph)[e_ij].weight = New;\n }\n }\n }\n }\n }\n return change;\n }\n \n void canonical()\n {\n if (IsDistWeight)\n oneStep ();\n else\n {\n bool change = true;\n while (change)\n change = oneStep ();\n }\n }\n \n void insert_vertex (VertexName u, Weight val = Weight::top())\n {\n if (!is_bottom () && !find_vertex_map(u))\n {\n vector new_vertices;\n new_vertices.push_back(u);\n vector new_edges;\n vertex_iterator i, e;\n for (tie(i, e) = vertices(*_graph); i != e; ++i)\n {\n VertexNamePtr v = (*_graph)[*i].name;\n // add two edges in both directions\n new_edges.push_back(edge_t(u, *v, val));\n new_edges.push_back(edge_t(*v, u, val));\n }\n add(new_vertices, new_edges);\n }\n }\n \n template\n void insert_vertices(array_graph_t &g, Iterator begin, Iterator end)\n {\n for(;begin!=end;++begin)\n g.insert_vertex(begin->name());\n } \n \n // pre: caller must ensure the graph is in canonical form\n void set_incoming (const VertexName &v, const Weight &weight)\n {\n if (!is_bottom ())\n { \n vertex_descriptor_t u = lookup_vertex_map(v);\n in_edge_iterator in_it, in_et;\n for (tie(in_it, in_et) = in_edges(u, *_graph); in_it != in_et; ++in_it)\n (*_graph)[*in_it].weight = WeightPtr( new Weight(weight));\n }\n }\n \n // pre: caller must ensure the graph is in canonical form\n void set_outgoing (const VertexName &v, const Weight &weight)\n {\n if (!is_bottom ())\n {\n vertex_descriptor_t u = lookup_vertex_map(v);\n out_edge_iterator out_it, out_et;\n for (tie(out_it, out_et) = out_edges(u, *_graph); \n out_it != out_et; ++out_it)\n (*_graph)[*out_it].weight = WeightPtr( new Weight(weight));\n }\n }\n \n struct binary_join_op{\n WeightPtr operator()(WeightPtr w1, WeightPtr w2) {\n return WeightPtr(new Weight(*w1 | *w2));\n }\n };\n \n struct binary_meet_op{\n WeightPtr operator()(WeightPtr w1, WeightPtr w2) {\n return WeightPtr(new Weight(*w1 & *w2));\n }\n };\n \n struct binary_widening_op{\n WeightPtr operator()(WeightPtr w1, WeightPtr w2) {\n return WeightPtr(new Weight(*w1 || *w2));\n }\n };\n \n struct binary_narrowing_op{\n WeightPtr operator()(WeightPtr w1, WeightPtr w2) {\n return WeightPtr(new Weight(*w1 && *w2));\n }\n };\n \n \n template\n void pointwise_binop_helper (array_graph_t &g1, \n const array_graph_t &g2)\n {\n // pre: g1 and g2 have the same adjacency structure\n edge_iterator it_1, et_1;\n for(tie(it_1,et_1) = edges(*g1._graph); it_1 != et_1; ++it_1)\n {\n edge_descriptor_t e_1 = *it_1;\n vertex_descriptor_t u_1 = source(e_1, *g1._graph);\n vertex_descriptor_t v_1 = target(e_1, *g1._graph);\n VertexNamePtr u_name_1 = (*g1._graph)[u_1].name;\n VertexNamePtr v_name_1 = (*g1._graph)[v_1].name;\n WeightPtr weight_1 = (*g1._graph)[e_1].weight;\n vertex_descriptor_t u_2 = g2.lookup_vertex_map(*u_name_1);\n vertex_descriptor_t v_2 = g2.lookup_vertex_map(*v_name_1);\n if (edge(u_2, v_2, *g2._graph).second)\n {\n Op op;\n edge_descriptor_t e_2 = edge(u_2, v_2, *g2._graph).first;\n (*g1._graph)[e_1].weight = \n op((*g1._graph)[e_1].weight, (*g2._graph)[e_2].weight);\n }\n else\n CRAB_ERROR(\"unreachable\");\n } \n }\n \n template\n array_graph_t pointwise_binop (array_graph_t g1, \n array_graph_t g2)\n {\n g1.canonical();\n g2.canonical();\n \n // if (*(g1._vertices_set) != *(g2._vertices_set)){\n // set all_vs;\n // set_union(g1._vertices_set->begin(), g1._vertices_set->end(), \n // g2._vertices_set->begin(), g2._vertices_set->end(), inserter(all_vs, all_vs.end()));\n // vector new_g1, new_g2;\n // set_difference(all_vs.begin(), all_vs.end(),\n // g1._vertices_set->begin(), g1._vertices_set->end(), inserter(new_g1, new_g1.end()));\n // set_difference(all_vs.begin(), all_vs.end(),\n // g2._vertices_set->begin(), g2._vertices_set->end(), inserter(new_g2, new_g2.end()));\n // insert_vertices::iterator>(g1, new_g1.begin(), new_g1.end());\n // insert_vertices::iterator>(g2, new_g2.begin(), new_g2.end());\n // }\n \n // pre: g1 and g2 have the same set of vertices and edges at this\n // point\n pointwise_binop_helper(g1,g2);\n return g1;\n }\n \n array_graph(bool is_bot): \n _is_bottom(is_bot), \n _graph(new graph_t(0)), \n _vertex_map(new vertex_map_t()), \n _vertices_set(new vertex_names_set_t()) \n { }\n \n public:\n \n static array_graph_t bottom() { return array_graph(true); }\n \n static array_graph_t top() { return array_graph(false); }\n \n // Deep copy of the array graph\n array_graph(const array_graph_t &other): \n writeable(), \n _is_bottom(other._is_bottom), \n //_graph(new graph_t(*other._graph)),\n //_vertex_map(new vertex_map_t(*other._vertex_map)),\n //_vertices_set( new vertex_names_set_t(*other._vertices_set))\n _graph (new graph_t(0)),\n _vertex_map (new vertex_map_t()), \n _vertices_set (new vertex_names_set_t())\n {\n crab::CrabStats::count (\"Domain.count.copy\");\n crab::ScopedCrabStats __st__(\"Domain.copy\");\n\n if (!is_bottom ())\n {\n // copy vertices, _vertex_map and _vertices_set\n vertex_iterator i, e;\n for (tie(i, e) = vertices(*other._graph); i != e; ++i)\n {\n vertex_descriptor_t u = add_vertex(*_graph);\n VertexName u_name = *((*other._graph)[*i].name);\n (*_graph)[u].name = VertexNamePtr(new VertexName(u_name));\n insert_vertex_map(u_name, u);\n }\n \n // copy edges\n edge_iterator ie, ee;\n for(tie(ie,ee) = edges(*other._graph); ie != ee; ++ie)\n {\n VertexName u = *((*other._graph)[source(*ie, *other._graph)].name);\n VertexName v = *((*other._graph)[target(*ie, *other._graph)].name);\n Weight w = *((*other._graph)[*ie].weight);\n vertex_descriptor_t _u = lookup_vertex_map(u);\n vertex_descriptor_t _v = lookup_vertex_map(v);\n edge_descriptor_t _e; bool b;\n boost::tie(_e,b) = add_edge(_u, _v, *_graph);\n (*_graph)[_e].weight = WeightPtr(new Weight(w)); \n }\n }\n }\n \n array_graph_t& operator=(const array_graph_t &other)\n {\n crab::CrabStats::count (\"Domain.count.copy\");\n crab::ScopedCrabStats __st__(\"Domain.copy\");\n if (this != &other)\n {\n _is_bottom = other._is_bottom;\n _graph = other._graph;\n _vertex_map = other._vertex_map;\n _vertices_set = other._vertices_set;\n }\n return *this;\n }\n \n bool is_bottom() { return this->_is_bottom; }\n \n bool is_top() \n {\n if (this->is_bottom())\n return false;\n else\n {\n // FIXME: speedup this operation\n canonical();\n edge_iterator it, et;\n for(tie(it,et) = edges(*_graph); it != et; ++it)\n {\n edge_descriptor_t e = *it;\n if (!(*(*_graph)[e].weight).is_top ()) \n return false;\n }\n return true;\n }\n }\n \n void reduce(ScalarNumDomain scalar)\n {\n if (is_bottom ()) return;\n \n canonical();\n \n edge_iterator it, et;\n for(tie(it,et) = edges(*_graph); it != et; ++it)\n {\n edge_descriptor_t e = *it;\n VertexNamePtr u = (*_graph)[source(e, *_graph)].name;\n VertexNamePtr v = (*_graph)[target(e, *_graph)].name;\n ScalarNumDomain tmp(scalar);\n linear_constraint_t cst ( variable_t(*u) <= variable_t(*v) - 1);\n tmp += cst;\n if (tmp.is_bottom())\n (*_graph)[e].weight = WeightPtr(new Weight(Weight::bottom())); \n }\n \n canonical();\n }\n \n // Point-wise application of <= in the weight domain\n bool operator <=(array_graph_t other)\n {\n if (is_bottom()) \n return true;\n else if (other.is_bottom()) \n return false;\n else\n {\n canonical();\n other.canonical();\n edge_iterator it_1, et_1;\n edge_iterator it_2, et_2;\n for(tie(it_1,et_1) = edges(*_graph); it_1 != et_1; ++it_1)\n {\n edge_descriptor_t e_1 = *it_1;\n vertex_descriptor_t u_1 = source(e_1, *_graph);\n vertex_descriptor_t v_1 = target(e_1, *_graph);\n VertexNamePtr u_name_1 = (*_graph)[u_1].name;\n VertexNamePtr v_name_1 = (*_graph)[v_1].name;\n WeightPtr weight_1 = (*_graph)[e_1].weight;\n vertex_descriptor_t u_2 = other.lookup_vertex_map(*u_name_1);\n vertex_descriptor_t v_2 = other.lookup_vertex_map(*v_name_1);\n if (edge(u_2,v_2, *other._graph).second)\n {\n edge_descriptor_t e_2 = edge(u_2,v_2, *other._graph).first;\n WeightPtr weight_2 = (*other._graph)[e_2].weight;\n if (!(*weight_1 <= *weight_2))\n return false;\n }\n else\n CRAB_ERROR (\"operator<= with graphs with different adjacency structure\");\n }\n return true;\n }\n }\n \n bool operator==(array_graph_t other)\n {\n if (is_bottom()) return other.is_bottom();\n else\n return (*(_vertices_set) == *(other._vertices_set) && \n ( *this <= other && other <= *this));\n }\n \n void operator-=(VertexName v) \n {\n if (!is_bottom ()) \n remove (v);\n }\n\n void operator|=(array_graph_t other) {\n *this = *this | other;\n }\n \n // Point-wise join in the weight domain\n array_graph_t operator|(array_graph_t other)\n {\n if (is_bottom())\n return other;\n else if (other.is_bottom())\n return *this;\n else \n return pointwise_binop(*this, other);\n }\n \n // Point-wise widening in the weight domain\n array_graph_t operator||(array_graph_t other)\n {\n if (is_bottom())\n return other;\n else if (other.is_bottom())\n return *this;\n else \n return pointwise_binop(*this, other);\n }\n \n // Point-wise meet in the weight domain\n array_graph_t operator&(array_graph_t other)\n {\n if (this->is_bottom())\n return *this;\n else if (other.is_bottom())\n return other;\n else {\n return pointwise_binop(*this, other);\n }\n }\n \n // Point-wise narrowing in the weight domain\n array_graph_t operator&&(array_graph_t other)\n {\n if (this->is_bottom())\n return *this;\n else if (other.is_bottom())\n return other;\n else {\n return pointwise_binop(*this, other);\n }\n }\n \n void meet_weight (const VertexName &src, const VertexName &dest, \n Weight weight)\n {\n if (find_vertex_map(src) && find_vertex_map(dest))\n {\n vertex_descriptor_t u = lookup_vertex_map(src);\n vertex_descriptor_t v = lookup_vertex_map(dest);\n if (edge(u,v,*_graph).second) {\n edge_descriptor_t e = edge(u,v,*_graph).first;\n Weight meet = weight & (*(*_graph)[e].weight);\n (*_graph)[e].weight = WeightPtr(new Weight(meet));\n }\n else {\n vector vertices;\n vector edges;\n edges.push_back(edge_t(src,dest,weight));\n add(vertices,edges);\n }\n }\n }\n \n void set_weight (const VertexName &src, const VertexName &dest, \n Weight weight)\n {\n if (find_vertex_map(src) && find_vertex_map(dest))\n {\n vertex_descriptor_t u = lookup_vertex_map(src);\n vertex_descriptor_t v = lookup_vertex_map(dest);\n if (edge(u,v,*_graph).second) {\n edge_descriptor_t e = edge(u,v,*_graph).first;\n (*_graph)[e].weight = WeightPtr(new Weight(weight));\n }\n else {\n vector vertices;\n vector edges;\n edges.push_back(edge_t(src,dest,weight));\n add(vertices,edges);\n }\n }\n }\n \n Weight& get_weight (const VertexName &src, const VertexName &dest) \n {\n if (find_vertex_map(src) && find_vertex_map(dest))\n {\n vertex_descriptor_t u = lookup_vertex_map(src);\n vertex_descriptor_t v = lookup_vertex_map(dest);\n if (edge(u,v,*_graph).second)\n {\n edge_descriptor_t e = edge(u,v,*_graph).first;\n return *((*_graph)[e].weight);\n }\n }\n CRAB_ERROR (\"No edge found with given vertices\");\n }\n \n void write(crab_os& o) \n {\n if (is_bottom())\n o << \"_|_\";\n else\n {\n {\n vertex_iterator it, et;\n o << \"(V={\";\n for (tie(it, et) = vertices(*_graph); it != et; ++it){\n vertex_descriptor_t u = *it;\n VertexNamePtr u_name = (*_graph)[u].name; \n o << *u_name << \" \";\n }\n o << \"},\";\n }\n {\n edge_iterator it, et;\n o << \"E={\";\n for(tie(it,et) = edges(*_graph); it!= et; ++it)\n {\n edge_descriptor_t e = *it;\n vertex_descriptor_t u = source(e, *_graph);\n vertex_descriptor_t v = target(e, *_graph);\n VertexNamePtr u_name = (*_graph)[u].name;\n VertexNamePtr v_name = (*_graph)[v].name;\n WeightPtr weight = (*_graph)[e].weight;\n if (!weight->is_bottom())\n o << \"(\" << *u_name << \",\" << *v_name << \",\" << *weight << \") \";\n }\n o << \"})\";\n }\n }\n }\n }; // end class array_graph\n\n \n /*\n Reduced product of a scalar numerical domain with a weighted array\n graph.\n */\n template\n class array_graph_domain: \n public writeable, \n public numerical_domain,\n public bitwise_operators, \n public division_operators,\n public array_operators,\n public pointer_operators {\n\n template\n class merge_op_check_equal: public patricia_tree< Key, Value >::binary_op_t {\n boost::optional< Value > apply(Value x, Value y) {\n if (x == y) return x;\n else\n CRAB_ERROR(\"merging a key with two different values\");\n };\n bool default_is_absorbing() { return false; }\n }; \n \n template\n class merge_op_first: public patricia_tree< Key, Value >::binary_op_t {\n boost::optional< Value > apply(Value x, Value y) {\n return x;\n };\n bool default_is_absorbing() { return false; } \n }; \n \n template\n class merge_op_second: public patricia_tree< Key, Value >::binary_op_t { \n boost::optional< Value > apply(Value x, Value y) {\n return y;\n };\n bool default_is_absorbing() { return false; }\n }; \n \n template < typename Key, typename Value, \n typename MergeOp = merge_op_check_equal >\n class mergeable_map: public writeable {\n \n private:\n typedef patricia_tree< Key, Value > patricia_tree_t;\n typedef typename patricia_tree_t::binary_op_t binary_op_t;\n \n public:\n typedef mergeable_map< Key, Value > mergeable_map_t;\n typedef typename patricia_tree_t::iterator iterator;\n \n private:\n patricia_tree_t _tree;\n \n static patricia_tree_t do_union(patricia_tree_t t1, patricia_tree_t t2) {\n MergeOp o;\n t1.merge_with(t2, o);\n return t1;\n }\n \n mergeable_map(patricia_tree_t t): _tree(t) { }\n \n public:\n \n mergeable_map(): _tree(patricia_tree_t()) { }\n \n mergeable_map(const mergeable_map_t& e): writeable(), _tree(e._tree) { }\n \n mergeable_map_t& operator=(mergeable_map_t e) {\n _tree = e._tree;\n return *this;\n }\n \n iterator begin() { return _tree.begin(); }\n\n iterator end() { return _tree.end(); }\n\n std::size_t size(){ return _tree.size(); }\n\n void set(Key k, Value v) { _tree.insert(k, v); }\n\n mergeable_map_t& operator-=(Key k) {\n _tree.remove(k);\n return *this;\n } \n mergeable_map_t operator|(mergeable_map_t e) {\n mergeable_map_t u(do_union(_tree, e._tree));\n return u;\n }\n \n boost::optional operator[](Key k) { return _tree.lookup(k); }\n void clear() { _tree = patricia_tree_t(); }\n \n void write(crab_os& o) {\n o << \"{\";\n for (auto it = _tree.begin(); it != _tree.end(); ) {\n Key k = it->first;\n k.write(o);\n o << \" -> \";\n Value v = it->second;\n o << v;\n ++it;\n if (it != _tree.end()) {\n o << \"; \";\n }\n }\n o << \"}\";\n } \n }; // class mergeable_map\n \n public:\n typedef typename ScalarNumDomain::number_t Number;\n typedef typename ScalarNumDomain::varname_t VariableName;\n \n // WARNING: assumes ScalarNumDomain::number_t = WeightDomain::number_t and\n // ScalarNumDomain::varname_t = WeightDomain::varname_t\n using typename numerical_domain< Number, VariableName>::linear_expression_t;\n using typename numerical_domain< Number, VariableName>::linear_constraint_t;\n using typename numerical_domain< Number, VariableName>::linear_constraint_system_t;\n using typename numerical_domain< Number, VariableName>::variable_t;\n using typename numerical_domain< Number, VariableName>::number_t;\n using typename numerical_domain< Number, VariableName>::varname_t;\n typedef WeightDomain content_domain_t; \n typedef ScalarNumDomain index_domain_t; \n\n private:\n typedef array_graph< VariableName,WeightDomain,ScalarNumDomain,IsDistWeight> array_graph_t;\n typedef array_graph_domain array_graph_domain_t;\n \n typedef mergeable_map succ_index_map_t;\n typedef boost::shared_ptr< succ_index_map_t > succ_index_map_ptr;\n \n bool _is_bottom;\n ScalarNumDomain _scalar; \n array_graph_t _g; \n // for each array index i we keep track of a special index that\n // represent i+1\n succ_index_map_ptr _succ_idx_map;\n \n void abstract (VariableName v) \n {\n if (_g.find_vertex_map(v))\n {\n _g.set_incoming(v , WeightDomain::top());\n _g.set_outgoing(v , WeightDomain::top());\n optional succ_v = get_succ_idx(v);\n if (succ_v)\n {\n _g.set_incoming(*succ_v, WeightDomain::top());\n _g.set_outgoing(*succ_v, WeightDomain::top());\n }\n }\n }\n \n \n optional get_succ_idx (VariableName v) const\n {\n return (*_succ_idx_map)[v];\n }\n\n template \n VariableName add_variable (Number n, VariableFactory &vfac)\n {\n // FIXME: really big assumption that the variable factory\n // understands strings. For instance, this is not true if the\n // factory is created by Crab-llvm.\n VariableName var_n = vfac[\"#C\" + n.get_str()];\n\n if (n >= 0)\n {\n _g.insert_vertex(var_n);\n _scalar.assign(var_n, n);\n }\n return var_n;\n }\n\n void add_variable (VariableName v)\n {\n if (is_array_index(v))\n {\n /*assign to v_succ a fresh var must be always the same*/ \n VariableName v_succ = v.get_var_factory().get (v.index()); \n\n _g.insert_vertex (v);\n _g.insert_vertex (v_succ);\n _succ_idx_map->set (v, v_succ);\n \n /// FIXME: assume that the array element size is 1.\n\n // --- Enforce: i+ == i+1\n _scalar += linear_constraint_t( variable_t (v_succ) == variable_t(v) + 1);\n // needed if scalar domain is non-relational:\n _g.set_weight (v_succ,v,WeightDomain::bottom ());\n }\n }\n\n void meet_weight (VariableName i, VariableName j, WeightDomain w)\n {\n add_variable (i);\n add_variable (j);\n _g.meet_weight (i,j,w);\n reduce();\n }\n\n template \n void meet_weight (Number i, Number j, WeightDomain w, VariableFactory &vfac)\n {\n _g.meet_weight (add_variable (i, vfac),\n add_variable (j, vfac) ,\n w);\n reduce();\n }\n\n void meet_weight (Number i, VariableName j, WeightDomain w)\n {\n add_variable (j);\n _g.meet_weight (add_variable(i, j.get_var_factory ()),j,w);\n reduce();\n }\n\n void meet_weight (VariableName i, Number j, WeightDomain w)\n {\n add_variable(i);\n _g.meet_weight(i,add_variable(j, i.get_var_factory ()),w);\n reduce();\n }\n\n bool IsDefiniteOne (Number x) { \n return x == Number (1); \n }\n\n bool IsDefiniteOne (VariableName x) { \n auto n = _scalar [x].singleton ();\n if (n) return *n == Number (1); \n else return false;\n }\n \n // x := x op k \n // Most of the magic happens here.\n template\n void apply_helper (operation_t op, VariableName x, VarNum k) \n {\n if (is_bottom()) return;\n\n /// step 1: add x_old in the graph\n VariableName x_old = x.get_var_factory ().get (); /*fresh var*/ \n VariableName x_old_succ = x.get_var_factory ().get (); /*fresh var*/\n _g.insert_vertex(x_old);\n _g.insert_vertex(x_old_succ);\n _succ_idx_map->set(x_old, x_old_succ);\n\n /// --- Enforce the following relationships:\n /// { x_old = x, x_old+ = x+, x_old+ = x_old + 1} \n\n /// x_old = x\n _scalar.assign(x_old, linear_expression_t(x)); \n // needed if scalar domain is non-relational:\n // enforcing x_old = x\n _g.set_weight (x_old,x,WeightDomain::bottom ());\n _g.set_weight (x,x_old,WeightDomain::bottom ());\n\n /// x_old+ = x_old +1\n _scalar += linear_constraint_t(variable_t(x_old_succ) == variable_t(x_old) + 1); \n // needed if scalar domain is non-relational:\n // enforcing x_old+ < x_old is false\n _g.set_weight (x_old_succ,x_old,WeightDomain::bottom ());\n // enforcing x_old+ < x is false\n _g.set_weight (x_old_succ,x,WeightDomain::bottom ());\n\n /// x_old+ = x+\n optional x_succ = get_succ_idx(x);\n if (x_succ) {\n _scalar += linear_constraint_t( variable_t(x_old_succ) == variable_t(*x_succ)); \n // needed if scalar domain is non-relational:\n // enforcing x_old + = x+\n _g.set_weight (x_old_succ,*x_succ,WeightDomain::bottom ());\n _g.set_weight (*x_succ,x_old_succ,WeightDomain::bottom ());\n // enforcing x+ < x_old is false\n _g.set_weight (*x_succ,x_old,WeightDomain::bottom ());\n }\n // propagate the scalar constraints to the graph\n reduce();\n\n /// step 2: abstract all incoming/outgoing edges of x\n abstract(x);\n\n /// step 3: update the graph with the scalar domain after applying\n /// x = x op k.\n _scalar.apply(op, x, x, k); \n\n#if 1\n // This is not needed at all if the scalar domain is relational.\n // Otherwise, we would like to keep the relationship between\n // x_old+ and x. We do it in a completely adhoc way but at least\n // we cover common cases when the array is traversed forward or\n // backwards one element by one.\n if (op == OP_ADDITION && IsDefiniteOne (k)) {\n _g.set_weight (x,x_old_succ,WeightDomain::bottom ());\n _g.set_weight (x_old_succ,x,WeightDomain::bottom ()); \n }\n else if (op == OP_SUBTRACTION && IsDefiniteOne (k)) {\n _g.set_weight (x_old,*x_succ,WeightDomain::bottom ());\n _g.set_weight (*x_succ,x_old,WeightDomain::bottom ()); \n }\n#endif \n\n if (x_succ){\n _scalar -= *x_succ;\n /// --- Enforce x+ == x + 1 \n _scalar += linear_constraint_t(variable_t(*x_succ) == variable_t(x) + 1); \n // needed if scalar domain is non-relational:\n _g.set_weight (*x_succ,x,WeightDomain::bottom ());\n }\n\n /* { x = x op k, x+ = x+1} */\n reduce();\n\n /// step 4: delete x_old\n _g -= x_old;\n _g -= x_old_succ;\n (*_succ_idx_map) -= x_old;\n _scalar -= x_old;\n _scalar -= x_old_succ;\n\n //this->reduce();\n }\n\n //! In case we can statically determine which variables should be\n // considered array indexes. Note that any subset is sound but it\n // might be imprecise. By default we consider all.\n bool is_array_index(VariableName v) const { \n return true; \n }\n\n // model array reads: return the weight from the edge i to i+\n WeightDomain array_read (VariableName i) \n {\n if (is_bottom()) \n return WeightDomain::bottom();\n \n if (!is_array_index(i)) \n return WeightDomain::top();\n \n //this->reduce();\n optional i_succ = get_succ_idx(i);\n if (i_succ) \n return _g.get_weight(i, *i_succ);\n\n CRAB_ERROR (\"There is no successor index associated with \",i);\n }\n \n // model array writes\n void array_write (VariableName arr, VariableName i, WeightDomain w)\n {\n if (is_bottom()) return;\n //this->reduce();\n\n //--- strong update\n optional i_succ = get_succ_idx(i);\n if (!i_succ) \n CRAB_ERROR (\"There is no successor index associated with \",i);\n\n WeightDomain& old_w = _g.get_weight(i, *i_succ);\n old_w -= arr;\n _g.meet_weight(i, *i_succ, w);\n WeightDomain new_w = _g.get_weight(i, *i_succ);\n \n //--- weak update: \n // An edge (p,q) must be weakened if p <= i <= q and p < q\n typename array_graph_t::edge_iterator it, et;\n for(tie(it,et) = edges(*_g._graph); it!= et; ++it)\n {\n typename array_graph_t::edge_descriptor_t e = *it;\n typename array_graph_t::VertexNamePtr p = (*_g._graph)[source(e, *_g._graph)].name;\n typename array_graph_t::VertexNamePtr q = (*_g._graph)[target(e, *_g._graph)].name;\n typename array_graph_t::WeightPtr weight = (*_g._graph)[e].weight;\n if ( ((*p == i) && (*q == *i_succ)) || weight->is_bottom())\n continue;\n // p < q \n ScalarNumDomain tmp(_scalar);\n tmp += linear_constraint_t( variable_t(*p) <= variable_t(i)); \n tmp += linear_constraint_t( variable_t(*i_succ) <= variable_t(*q)); \n if (tmp.is_bottom())\n continue;\n // p <= i <= q and p < q\n typename array_graph_t::binary_join_op join;\n (*_g._graph)[e].weight = join (weight, \n typename array_graph_t::WeightPtr (new WeightDomain(new_w)));\n }\n _g.canonical();\n\n }\n \n void set_to_bottom()\n {\n _is_bottom = true;\n _scalar = ScalarNumDomain::bottom();\n _g = array_graph_t::bottom();\n _succ_idx_map->clear();\n }\n\n array_graph_domain(ScalarNumDomain scalar, \n array_graph_t g, \n succ_index_map_ptr map): \n writeable(), \n _is_bottom(false), \n _scalar(scalar), \n _g(g), \n _succ_idx_map(new succ_index_map_t(*map)) \n { \n if (_scalar.is_bottom() || _g.is_bottom())\n set_to_bottom();\n else\n reduce();\n }\n\n public:\n\n array_graph_domain(): \n writeable(), \n _is_bottom(false), \n _scalar(ScalarNumDomain::top()), \n _g(array_graph_t::top()), \n _succ_idx_map(new succ_index_map_t()) \n { }\n\n static array_graph_domain_t top() \n {\n return array_graph_domain(ScalarNumDomain::top(), \n array_graph_t::top(), \n succ_index_map_ptr(new succ_index_map_t()));\n }\n \n static array_graph_domain_t bottom() \n {\n return array_graph_domain(ScalarNumDomain::bottom(), \n array_graph_t::bottom(),\n succ_index_map_ptr(new succ_index_map_t()));\n }\n \n array_graph_domain(const array_graph_domain_t& other): \n writeable(), \n _is_bottom(other._is_bottom),\n _scalar(other._scalar) , \n _g(other._g), \n _succ_idx_map(new succ_index_map_t(*other._succ_idx_map))\n {\n crab::CrabStats::count (getDomainName() + \".count.copy\");\n crab::ScopedCrabStats __st__(getDomainName() + \".copy\");\n }\n \n array_graph_domain_t& operator=(array_graph_domain_t other) \n {\n crab::CrabStats::count (getDomainName() + \".count.copy\");\n crab::ScopedCrabStats __st__(getDomainName() + \".copy\");\n\n if (this != &other)\n {\n this->_is_bottom = other._is_bottom;\n this->_scalar = other._scalar;\n this->_g = other._g;\n this->_succ_idx_map = other._succ_idx_map;\n }\n return *this;\n }\n \n bool is_bottom() { return _is_bottom; }\n\n // --- top operation in the graph is expensive because we need to\n // traverse the whole graph and check each edge.\n // bool is_top() { return (_scalar.is_top() && _g.is_top()); }\n \n bool is_top() { return (_scalar.is_top()); }\n \n void reduce ()\n {\n crab::CrabStats::count (getDomainName() + \".count.reduce\");\n crab::ScopedCrabStats __st__(getDomainName() + \".reduce\");\n\n if (is_bottom ()) return; \n \n domain_traits::normalize(_scalar);\n\n if (_scalar.is_bottom() || _g.is_bottom())\n set_to_bottom();\n else\n _g.reduce(_scalar);\n }\n\n bool operator<=(array_graph_domain_t other) \n {\n crab::CrabStats::count (getDomainName() + \".count.leq\");\n crab::ScopedCrabStats __st__(getDomainName() + \".leq\");\n\n if (is_bottom ()) {\n return true;\n } else if (other.is_bottom ()) {\n return false;\n } else {\n return (_scalar <= other._scalar && _g <= other._g);\n }\n }\n\n void operator|=(array_graph_domain_t other) {\n *this = *this | other;\n }\n \n array_graph_domain_t operator|(array_graph_domain_t other) \n {\n crab::CrabStats::count (getDomainName() + \".count.join\");\n crab::ScopedCrabStats __st__(getDomainName() + \".join\");\n\n if (is_bottom ()) {\n return other;\n } else if (other.is_bottom ()) {\n return *this;\n } else {\n succ_index_map_ptr map(new succ_index_map_t(*(_succ_idx_map) | \n *(other._succ_idx_map)));\n return array_graph_domain_t(_scalar | other._scalar, \n _g | other._g, map); \n }\n }\n \n array_graph_domain_t operator&(array_graph_domain_t other) \n {\n crab::CrabStats::count (getDomainName() + \".count.meet\");\n crab::ScopedCrabStats __st__(getDomainName() + \".meet\");\n\n if (is_bottom () || other.is_bottom ()) {\n return bottom();\n } else {\n succ_index_map_ptr map(new succ_index_map_t(*(_succ_idx_map) | \n *(other._succ_idx_map)));\n return array_graph_domain_t(_scalar & other._scalar, \n _g & other._g, map);\n }\n }\n \n array_graph_domain_t operator||(array_graph_domain_t other) \n {\n crab::CrabStats::count (getDomainName() + \".count.widening\");\n crab::ScopedCrabStats __st__(getDomainName() + \".widening\");\n\n if (is_bottom ()) return other;\n else if (other.is_bottom ()) return *this;\n else \n {\n succ_index_map_ptr map (new succ_index_map_t(*(_succ_idx_map) | \n *(other._succ_idx_map)));\n array_graph_domain_t widen (_scalar || other._scalar, \n _g || other._g, map);\n CRAB_LOG(\"array-graph\" , crab::outs() << \"Widening: \" << *this<<\"\\n\";);\n return widen;\n }\n }\n\n template\n array_graph_domain_t widening_thresholds (array_graph_domain_t other, \n const Thresholds & /*ts*/) {\n return (*this || other);\n }\n \n array_graph_domain_t operator&& (array_graph_domain_t other) \n {\n crab::CrabStats::count (getDomainName() + \".count.narrowing\");\n crab::ScopedCrabStats __st__(getDomainName() + \".narrowing\");\n\n if (is_bottom ()|| other.is_bottom ()) \n return bottom();\n else \n {\n succ_index_map_ptr map (new succ_index_map_t(*(_succ_idx_map) | \n *(other._succ_idx_map)));\n return array_graph_domain_t (_scalar && other._scalar, \n _g && other._g, map);\n }\n }\n \n void operator-=(VariableName var)\n {\n crab::CrabStats::count (getDomainName() + \".count.forget\");\n crab::ScopedCrabStats __st__(getDomainName() + \".forget\");\n\n if (is_bottom ()) return;\n\n // scalar domain\n _scalar -= var;\n _g -= var;\n optional var_succ = get_succ_idx(var);\n if (var_succ) {\n _scalar -= *var_succ;\n _g -= *var_succ; \n (*_succ_idx_map) -= var;\n }\n\n // graph domain\n typename array_graph_t::edge_iterator it, et;\n for(tie(it,et) = edges(*(_g._graph)); it!= et; ++it) {\n auto e = *it;\n auto weight = (*(_g._graph))[e].weight;\n (*weight) -= var;\n } \n // this->reduce();\n }\n \n /////\n // Transfer functions\n /////\n\n void operator += (linear_constraint_system_t csts) \n {\n crab::CrabStats::count (getDomainName() + \".count.add_constraints\");\n crab::ScopedCrabStats __st__(getDomainName() + \".add_constraints\");\n\n if (is_bottom()) return;\n \n // graph domain: make sure that all the relevant variables\n // (included special \"0\") are inserted in the graph\n for (auto cst : csts) {\n // TODO\n //Number n = cst.expression().constant();\n //if (n == 0) add_variable(n, vfac);\n for (auto v : cst.variables())\n add_variable (v.name());\n }\n\n _scalar += csts;\n reduce();\n\n CRAB_LOG(\"array-graph\", \n crab::outs() << \"Assume(\"<< csts<< \") --- \"<< *this<<\"\\n\";);\n }\n\n void assign (VariableName x, linear_expression_t e) \n {\n crab::CrabStats::count (getDomainName() + \".count.assign\");\n crab::ScopedCrabStats __st__(getDomainName() + \".assign\");\n\n if (is_bottom()) return;\n\n if (optional y = e.get_variable())\n {\n if ((*y).name() == x) return;\n }\n\n // scalar domain\n _scalar.assign(x, e);\n \n // graph domain\n if (e.is_constant() && (e.constant() == 0))\n add_variable (e.constant(), x.get_var_factory ());\n\n if (_g.find_vertex_map(x))\n {\n abstract(x);\n // wrong results if we do not restore the relationship between x\n // and x+ in the scalar domain\n optional x_succ = get_succ_idx(x); \n if (x_succ){\n _scalar -= *x_succ;\n /// --- Enforce x+ == x+1\n _scalar += linear_constraint_t( variable_t(*x_succ) == variable_t(x) + 1); \n // needed if scalar domain is non-relational:\n _g.set_weight (*x_succ,x,WeightDomain::bottom ());\n }\n }\n else\n add_variable(x);\n \n reduce();\n\n CRAB_LOG(\"array-graph\", \n crab::outs() << \"Assign \"< \"<<*this<<\"\\n\";);\n }\n\n void apply (operation_t op, VariableName x, VariableName y, Number z) \n {\n crab::CrabStats::count (getDomainName() + \".count.apply\");\n crab::ScopedCrabStats __st__(getDomainName() + \".apply\");\n\n assign (x, linear_expression_t(y));\n apply_helper (op, x, z);\n\n CRAB_LOG(\"array-graph\",\n crab::outs() << \"Apply \"< \"<<*this<<\"\\n\";); \n }\n\n void apply(operation_t op, VariableName x, VariableName y, VariableName z) \n {\n crab::CrabStats::count (getDomainName() + \".count.apply\");\n crab::ScopedCrabStats __st__(getDomainName() + \".apply\");\n\n assign (x, linear_expression_t(y));\n apply_helper (op, x, z);\n\n CRAB_LOG(\"array-graph\", \n crab::outs() << \"Apply \"< \"<<*this<<\"\\n\";);\n }\n\n void apply(operation_t op, VariableName x, Number k) \n {\n crab::CrabStats::count (getDomainName() + \".count.apply\");\n crab::ScopedCrabStats __st__(getDomainName() + \".apply\");\n\n apply_helper (op, x, k);\n\n CRAB_LOG(\"array-graph\",\n crab::outs() << \"Apply \"< \"<<*this<<\"\\n\";);\n }\n\n\n // bitwise_operators_api\n void apply(conv_operation_t op, VariableName x, VariableName y, unsigned width) {\n assign (x, variable_t (y));\n }\n \n void apply(conv_operation_t op, VariableName x, Number k, unsigned width) {\n assign (x, k);\n }\n \n void apply(bitwise_operation_t op, VariableName x, VariableName y, VariableName z) {\n CRAB_WARN (\"bitwise operations not implemented in array_graph\");\n }\n \n void apply(bitwise_operation_t op, VariableName x, VariableName y, Number k) {\n CRAB_WARN (\"bitwise operations not implemented in array_graph\");\n }\n \n // division_operators_api\n void apply(div_operation_t op, VariableName x, VariableName y, VariableName z) {\n CRAB_WARN (\"division operations not implemented in array_graph\");\n }\n \n void apply(div_operation_t op, VariableName x, VariableName y, Number k) {\n CRAB_WARN (\"division operations not implemented in array_graph\");\n }\n\n // array_operators_api\n \n virtual void array_init (VariableName a, const vector &values) override {\n CRAB_WARN (\"array_graph_domain init not implemented\");\n }\n\n virtual void array_assume (VariableName a, \n boost::optional lb, boost::optional ub) override {\n CRAB_WARN (\"array_graph_domain assume not implemented\");\n }\n\n virtual void array_load (VariableName lhs, VariableName arr, VariableName idx, \n z_number /*bytes*/) override {\n crab::CrabStats::count (getDomainName() + \".count.load\");\n crab::ScopedCrabStats __st__(getDomainName() + \".load\");\n\n WeightDomain w = array_read (idx);\n // --- Simplification wrt Gange et.al.:\n // Only non-relational invariants are passed from the graph\n // domain to the scalar domain.\n // We use operator[] as the conversion function\n _scalar.set (lhs, w [arr]);\n\n CRAB_LOG(\"array-graph\",\n crab::outs() << \"Array read \"< \"\n << *this <<\"\\n\";); \n }\n\n virtual void array_store (VariableName arr, VariableName idx, linear_expression_t val,\n z_number /*n_bytes*/, bool /*is_singleton*/) override {\n\n crab::CrabStats::count (getDomainName() + \".count.store\");\n crab::ScopedCrabStats __st__(getDomainName() + \".store\");\n\n // --- Simplification wrt Gange et.al.:\n // Only non-relational invariants are passed from the scalar\n // domain to the graph domain.\n // We use operator[] as the conversion function\n WeightDomain w = WeightDomain::top ();\n if (val.is_constant ())\n w.assign (arr, val); \n else if (auto v = val.get_variable ()){\n w.set (arr, _scalar[(*v).name()]); \n }\n else {\n // If you see this warning you can switch to intervals.\n crab::outs() << \"Warning: scalar domain does not support assignments with arbitrary rhs.\\n\";\n }\n array_write (arr, idx, w);\n\n CRAB_LOG(\"array-graph\",\n crab::outs() << \"Array write \"< \"<< *this <<\"\\n\";);\n }\n \n void write(crab_os& o) \n {\n o << \"(\" ;\n#if 1\n // less verbose: remove the special variables i+ from the scalar\n // domain\n ScalarNumDomain inv (_scalar);\n for(auto p : *_succ_idx_map) {\n inv -= p.second;\n }\n o << inv;\n#else\n o << _scalar;\n#endif \n o << \",\" << _g;\n o << \")\";\n }\n\n linear_constraint_system_t to_linear_constraint_system (){\n CRAB_ERROR (\"array_graph: to_linear_constraint_system not implemented\");\n }\n\n static string getDomainName () {\n string name (\"ArrayGraph(\" + \n ScalarNumDomain::getDomainName () + \",\" + \n WeightDomain::getDomainName () +\n \")\");\n return name;\n }\n\n }; // end array_graph_domain\n\n\n }// namespace domain_traits\n\n} // namespace crab\n\n#endif \n", "meta": {"hexsha": "99534ac8b58de09eabef097fcf605840a3ee4f06", "size": 53747, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/crab/domains/array_graph.hpp", "max_stars_repo_name": "satbekmyrza/crab", "max_stars_repo_head_hexsha": "0f71d09f4fa872d6b02f225963c1a960977578f4", "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/array_graph.hpp", "max_issues_repo_name": "satbekmyrza/crab", "max_issues_repo_head_hexsha": "0f71d09f4fa872d6b02f225963c1a960977578f4", "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/array_graph.hpp", "max_forks_repo_name": "satbekmyrza/crab", "max_forks_repo_head_hexsha": "0f71d09f4fa872d6b02f225963c1a960977578f4", "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.3134034166, "max_line_length": 113, "alphanum_fraction": 0.5448490148, "num_tokens": 12650, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.76908023177796, "lm_q2_score": 0.5851011542032312, "lm_q1q2_score": 0.44998973128817293}} {"text": "#include \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\n#include \"tkdCmdParser.h\"\n\n#include // for sort\n#include // for pow and sqrt\n#include // for atan\n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"vnl_vector_to_std_vector.h\"\n#include \"std_vector_to_vnl_vector.h\"\n\nnamespace dki\n{\n\t/**\n\t * Calculate diffusion kurtosis maps from given input tensors.\n\t *\n\t * Modification to Tabesh et al: If eigenvalues are negative set them to 0!\n\t *\n\t */\n\tclass DkiMaps\n\t{\n\tpublic:\n\n\t\tstruct parameters\n\t\t{\n\t\t\tstd::string inputFileName;\n\t\t\tstd::string maskFileName;\n\t\t\tstd::string outputFileName;\n\t\t};\n\n\t\ttypedef double PixelType;\n\n\t\ttypedef itk::Image< PixelType, 4 > ImageType;\n\t\ttypedef itk::Image< PixelType, 3 > OutputImageType;\n\t\ttypedef itk::ImageFileReader< OutputImageType > MaskReaderType;\n\t\ttypedef itk::ImageFileReader< ImageType > ReaderType;\n\t\ttypedef itk::ImageLinearConstIteratorWithIndex< ImageType > ConstIterator4DType;\n\t\ttypedef itk::ImageLinearIteratorWithIndex< ImageType > Iterator4DType;\n\t\ttypedef itk::ImageRegionIteratorWithIndex< OutputImageType > Iterator3DType;\n\n\t\ttypedef itk::ImageRegionConstIteratorWithIndex< OutputImageType > ConstIterator3DType;\n\t\ttypedef itk::ImageFileWriter< OutputImageType > WriterType;\n\n\t\ttypedef vnl_vector< PixelType > VectorType;\n\t\ttypedef vnl_matrix< PixelType > MatrixType;\n\n\t\ttypedef std::pair< PixelType, VectorType > EigenType;\n\t\ttypedef std::vector< EigenType > EigenContainerType;\n\n\t\t/**\n\t\t * Constructor.\n\t\t */\n\t\tDkiMaps( const parameters& args )\n\t\t{\n\t\t\tSetInput( args.inputFileName );\n\t\t\tInitMask( args.maskFileName );\n\t\t\tAllocateOutput();\n\t\t\tInitGlobalIndices();\n\t\t\tCalculateMaps();\n\t\t\tWrite( args.outputFileName );\n\t\t}\n\n\tprotected:\n\n\t\tImageType::Pointer m_Input;\n\t\tOutputImageType::Pointer m_Mask;\n\n\n\t\t// dti maps\n\n\t\tOutputImageType::Pointer m_FA;\n\t\tOutputImageType::Pointer m_Trace;\n\t\tOutputImageType::Pointer m_Lradial;\n\t\tOutputImageType::Pointer m_Laxial;\n\n\t\t// dki maps\n\n\t\tOutputImageType::Pointer m_MK;\n\t\tOutputImageType::Pointer m_Kradial;\n\t\tOutputImageType::Pointer m_Kaxial;\n\n\t\t// indices\n\t\tVectorType m_kvec_to_table;\n\t\tMatrixType m_indices_w0000;\n\t\tMatrixType m_indices_w1111;\n\t\tMatrixType m_indices_w2222;\n\t\tMatrixType m_indices_w1122;\n\t\tMatrixType m_indices_w0022;\n\t\tMatrixType m_indices_w0011;\n\n\t\t/**\n\t\t * Init indices for Wtilda rotation.\n\t\t */\n\t\tvoid InitGlobalIndices()\n\t\t{\n\t\t\tMatrixType index_table = GetIndexTable();\n\t\t\tMatrixType kvec_indices = GetKvecIndices();\n\t\t\tm_kvec_to_table = GetKvec2Table( GetRowSort( index_table ), kvec_indices );\n\n\t\t\tm_indices_w0000 = GetIndicesW( 0, 0, 0, 0, index_table );\n\t\t\tm_indices_w1111 = GetIndicesW( 1, 1, 1, 1, index_table );\n\t\t\tm_indices_w2222 = GetIndicesW( 2, 2, 2, 2, index_table );\n\t\t\tm_indices_w1122 = GetIndicesW( 1, 1, 2, 2, index_table );\n\t\t\tm_indices_w0022 = GetIndicesW( 0, 0, 2, 2, index_table );\n\t\t\tm_indices_w0011 = GetIndicesW( 0, 0, 1, 1, index_table );\n\t\t}\n\n\t\t/**\n\t\t * DKI maps.\n\t\t */\n\t\tvoid CalculateMaps()\n\t\t{\n\t\t\tConstIterator4DType it( m_Input, m_Input->GetLargestPossibleRegion() );\n\t\t\tConstIterator3DType mit( m_Mask, m_Mask->GetLargestPossibleRegion() );\n\n\t\t\tIterator3DType itFA( m_FA, m_FA->GetLargestPossibleRegion() );\n\t\t\tIterator3DType itTrace( m_Trace, m_Trace->GetLargestPossibleRegion() );\n\t\t\tIterator3DType itLaxial( m_Laxial, m_Laxial->GetLargestPossibleRegion() );\n\t\t\tIterator3DType itLradial( m_Lradial, m_Lradial->GetLargestPossibleRegion() );\n\n\t\t\tIterator3DType itMK( m_MK, m_MK->GetLargestPossibleRegion() );\n\t\t\tIterator3DType itKaxial( m_Kaxial, m_Kaxial->GetLargestPossibleRegion() );\n\t\t\tIterator3DType itKradial( m_Kradial, m_Kradial->GetLargestPossibleRegion() );\n\n\t\t\tit.SetDirection( 3 );\n\t\t\tit.GoToBegin();\n\n\t\t\tmit.GoToBegin();\n\n\t\t\titFA.GoToBegin();\n\t\t\titTrace.GoToBegin();\n\t\t\titLaxial.GoToBegin();\n\t\t\titLradial.GoToBegin();\n\n\t\t\titMK.GoToBegin();\n\t\t\titKaxial.GoToBegin();\n\t\t\titKradial.GoToBegin();\n\n\t\t\tif ( m_Input->GetLargestPossibleRegion().GetSize()[3] < 21 )\n\t\t\t{\n\t\t\t\tstd::cerr << \"*** ERROR ***: input does not contain less than 21 tensor elements!\" << std::endl;\n\t\t\t\texit( EXIT_FAILURE );\n\t\t\t}\n\n\t\t\tunsigned int sliceIndex = 0;\n\n\t\t\t// for each voxel\n\n\t\t\twhile ( !it.IsAtEnd(), !mit.IsAtEnd() )\n\t\t\t{\n\t\t\t\tif ( mit.Get() != 0 )\n\t\t\t\t{\n\n\t\t\t\t\t// slice index\n\t\t\t\t\tif ( sliceIndex != it.GetIndex()[2] )\n\t\t\t\t\t{\n\t\t\t\t\t\tstd::cout << \"Processing slice: \" << sliceIndex << std::endl;\n\t\t\t\t\t\tsliceIndex = it.GetIndex()[2];\n\t\t\t\t\t}\n\n\t\t\t\t\tVectorType b( 6 );\n\t\t\t\t\tVectorType kvec( 15 );\n\n\t\t\t\t\twhile ( !it.IsAtEndOfLine() )\n\t\t\t\t\t{\n\t\t\t\t\t\tunsigned int i = ( it.GetIndex() )[3];\n\n\t\t\t\t\t\tif ( i < 6 )\n\t\t\t\t\t\t\tb( i ) = it.Get();\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tkvec( i - 6 ) = it.Get();\n\n\t\t\t\t\t\t++it;\n\t\t\t\t\t}\n\n\t\t\t\t\tMatrixType DT = GetDTITensor( b );\n\n\t\t\t\t\titFA.Set( GetFA( DT ) );\n\t\t\t\t\titTrace.Set( GetTrace( DT ) );\n\n\t\t\t\t\tEigenContainerType eig = GetEigenSystem( DT );\n\n\t\t\t\t\t// set negative eigenvalues to 0\n\n\t\t\t\t\tfor ( unsigned int i = 0; i < eig.size(); i++ )\n\t\t\t\t\t\tif ( eig.at( i ).first < 0 )\n\t\t\t\t\t\t\teig.at( i ).first = 0;\n\n\t\t\t\t\titLaxial.Set( eig.at( 0 ).first );\n\t\t\t\t\titLradial.Set( ( eig.at( 1 ).first + eig.at( 2 ).first ) / 2. );\n\n\t\t\t\t\ttry\n\t\t\t\t\t{\n\t\t\t\t\t\tVectorType kvec_scaled = kvec * ( 1. / std::pow( GetTrace( DT ), 2 ) );\n\t\t\t\t\t\tVectorType k = GetKurtosisValues( kvec_scaled, eig ); // TODO\n\t\t\t\t\t\titMK.Set( k( 0 ) );\n\t\t\t\t\t\titKaxial.Set( k( 1 ) );\n\t\t\t\t\t\titKradial.Set( k( 2 ) );\n\t\t\t\t\t} catch ( boost::math::evaluation_error e )\n\t\t\t\t\t{\n\t\t\t\t\t\t// convergence error, leave kurtosis output zero?\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// go to next voxel\n\n\t\t\t\tit.NextLine();\n\t\t\t\t++mit;\n\t\t\t\t++itFA;\n\t\t\t\t++itTrace;\n\t\t\t\t++itLaxial;\n\t\t\t\t++itLradial;\n\n\t\t\t\t++itMK;\n\t\t\t\t++itKaxial;\n\t\t\t\t++itKradial;\n\t\t\t}\n\t\t}\n\n\t\t// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n\n\t\t/**\n\t\t * Return eigenvalues and eigenvector sorted from l1 > l2 > l3.\n\t\t */\n\t\tEigenContainerType GetEigenSystem( const MatrixType& DT )\n\t\t{\n\t\t\tvnl_symmetric_eigensystem< PixelType > eig( DT );\n\n\t\t\tEigenContainerType container( 3 );\n\t\t\tcontainer.at( 0 ) = EigenType( eig.get_eigenvalue( 2 ), eig.get_eigenvector( 2 ) );\n\t\t\tcontainer.at( 1 ) = EigenType( eig.get_eigenvalue( 1 ), eig.get_eigenvector( 1 ) );\n\t\t\tcontainer.at( 2 ) = EigenType( eig.get_eigenvalue( 0 ), eig.get_eigenvector( 0 ) );\n\t\t\treturn container;\n\t\t}\n\t\t/**\n\t\t * Return sum eigenvalues.\n\t\t */\n\t\tPixelType GetTrace( const MatrixType& DT )\n\t\t{\n\t\t\treturn DT( 0, 0 ) + DT( 1, 1 ) + DT( 2, 2 );\n\t\t}\n\n\t\t/**\n\t\t * Return fractional anisotropy (FA).\n\t\t */\n\t\tPixelType GetFA( const MatrixType& DT )\n\t\t{\n\t\t\tPixelType isp = inner_product( DT, DT );\n\t\t\tif ( isp > 0.0 )\n\t\t\t{\n\t\t\t\tPixelType trace = GetTrace( DT );\n\t\t\t\tPixelType anisotropy = 3.0 * isp - trace * trace;\n\t\t\t\tPixelType fractionalAnisotropy = std::sqrt( anisotropy / ( 2.0 * isp ) );\n\t\t\t\treturn fractionalAnisotropy;\n\t\t\t}\n\t\t\treturn 0.0;\n\t\t}\n\n\t\t/**\n\t\t * Index table W sort.\n\t\t */\n\t\tMatrixType GetIndexTable()\n\t\t{\n\t\t\tMatrixType table( 81, 4 );\n\n\t\t\tunsigned int lin_idx = 0;\n\n\t\t\tfor ( unsigned int i = 0; i < 3; i++ )\n\t\t\t\tfor ( unsigned int j = 0; j < 3; j++ )\n\t\t\t\t\tfor ( unsigned int k = 0; k < 3; k++ )\n\t\t\t\t\t\tfor ( unsigned int l = 0; l < 3; l++ )\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tVectorType row( 4 );\n\t\t\t\t\t\t\trow( 0 ) = i;\n\t\t\t\t\t\t\trow( 1 ) = j;\n\t\t\t\t\t\t\trow( 2 ) = k;\n\t\t\t\t\t\t\trow( 3 ) = l;\n\t\t\t\t\t\t\ttable.set_row( lin_idx, row );\n\t\t\t\t\t\t\tlin_idx++;\n\t\t\t\t\t\t}\n\n\t\t\treturn table;\n\t\t}\n\n\t\t/**\n\t\t * Sort rows in matrix ('ascend' way).\n\t\t */\n\t\tMatrixType GetRowSort( const MatrixType& M )\n\t\t{\n\t\t\tMatrixType out( M );\n\n\t\t\tfor ( unsigned int r = 0; r < out.rows(); r++ )\n\t\t\t{\n\t\t\t\tstd::vector< PixelType > v = vnl_vector_to_std_vector( out.get_row( r ) );\n\t\t\t\tstd::sort( v.begin(), v.end() );\n\t\t\t\tout.set_row( r, std_vector_to_vnl_vector( v ) );\n\t\t\t}\n\n\t\t\treturn out;\n\t\t}\n\n\t\t/**\n\t\t * Return matching indices.\n\t\t */\n\t\tVectorType GetKvec2Table( const MatrixType& table, const MatrixType& kvec )\n\t\t{\n\t\t\tVectorType indices( table.rows(), 0 );\n\n\t\t\tfor ( unsigned int i = 0; i < table.rows(); i++ )\n\t\t\t{\n\t\t\t\tfor ( unsigned int j = 0; j < kvec.rows(); j++ )\n\t\t\t\t{\n\t\t\t\t\tif ( kvec.get_row( j ) == table.get_row( i ) )\n\t\t\t\t\t{\n\t\t\t\t\t\tindices( i ) = j;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn indices;\n\t\t}\n\n\t\t/**\n\t\t * Kvec:\n\t\t *\n\t\t * k1111 k2222 k3333\n\t\t * k1112 k1113 k1222\n\t\t * k2223 k1333 k2333\n\t\t * k1122 k1133 k2233\n\t\t * k1123 k1223 k1233\n\t\t */\n\t\tMatrixType GetKvecIndices()\n\t\t{\n\t\t\tMatrixType t( 15, 4 );\n\n\t\t\tPixelType data[60] =\n\t\t\t{ 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 1, 0, 0, 0, 2, 0, 1, 1, 1, 1, 1, 1, 2, 0, 2, 2, 2, 1, 2, 2, 2, 0, 0, 1, 1, 0, 0,\n\t\t\t\t\t2, 2, 1, 1, 2, 2, 0, 0, 1, 2, 0, 1, 1, 2, 0, 1, 2, 2 };\n\n\t\t\tt.set( data );\n\n\t\t\treturn t;\n\t\t}\n\n\t\t/**\n\t\t * Matlab sub2ind.\n\t\t */\n\t\tunsigned int sub2ind( unsigned int nrow, unsigned int x, unsigned int y )\n\t\t{\n\n\t\t\treturn ( x + y * nrow );\n\t\t}\n\n\t\t/**\n\t\t * Return W_ijkl in terms of indices.\n\t\t */\n\t\tMatrixType GetIndicesW( unsigned int i, unsigned int j, unsigned int k, unsigned int l, const MatrixType indices )\n\t\t{\n\t\t\tMatrixType W( 81, 4 );\n\n\t\t\tfor ( unsigned int r = 0; r < W.rows(); r++ )\n\t\t\t{\n\t\t\t\tW( r, 0 ) = sub2ind( 3, indices( r, 0 ), i );\n\t\t\t\tW( r, 1 ) = sub2ind( 3, indices( r, 1 ), j );\n\t\t\t\tW( r, 2 ) = sub2ind( 3, indices( r, 2 ), k );\n\t\t\t\tW( r, 3 ) = sub2ind( 3, indices( r, 3 ), l );\n\t\t\t}\n\n\t\t\treturn W;\n\t\t}\n\n\t\t/**\n\t\t * Resort kvec.\n\t\t */\n\t\tVectorType GetKvecExtended( const VectorType& kvec, const VectorType& indices )\n\t\t{\n\t\t\tVectorType out( indices.size(), 0 );\n\n\t\t\tfor ( unsigned int i = 0; i < out.size(); i++ )\n\t\t\t{\n\t\t\t\tout( i ) = kvec( indices( i ) );\n\t\t\t}\n\t\t\treturn out;\n\t\t}\n\n\t\t/**\n\t\t * Get column-wise vector of sorted eigen vectors.\n\t\t */\n\t\tVectorType EigenVectorsToStretchedFormat( const VectorType& e1, const VectorType& e2, const VectorType& e3 )\n\t\t{\n\t\t\tVectorType s( 9 );\n\t\t\ts( 0 ) = e1( 0 );\n\t\t\ts( 1 ) = e2( 0 );\n\t\t\ts( 2 ) = e3( 0 );\n\n\t\t\ts( 3 ) = e1( 1 );\n\t\t\ts( 4 ) = e2( 1 );\n\t\t\ts( 5 ) = e3( 1 );\n\n\t\t\ts( 6 ) = e1( 2 );\n\t\t\ts( 7 ) = e2( 2 );\n\t\t\ts( 8 ) = e3( 2 );\n\n\t\t\treturn s;\n\t\t}\n\n\t\t/**\n\t\t * Return W~, rotated in DT coordinates.\n\t\t */\n\t\tPixelType GetRotatedW( const MatrixType& indices, const EigenContainerType& eig, const VectorType& kvec )\n\t\t{\n\t\t\tVectorType V = EigenVectorsToStretchedFormat( eig.at( 0 ).second, eig.at( 1 ).second, eig.at( 2 ).second );\n\n\t\t\tVectorType col1( indices.rows() );\n\t\t\tVectorType col2( indices.rows() );\n\t\t\tVectorType col3( indices.rows() );\n\t\t\tVectorType col4( indices.rows() );\n\n\t\t\tfor ( unsigned int i = 0; i < col1.size(); i++ )\n\t\t\t{\n\t\t\t\tcol1( i ) = V( indices( i, 0 ) );\n\t\t\t\tcol2( i ) = V( indices( i, 1 ) );\n\t\t\t\tcol3( i ) = V( indices( i, 2 ) );\n\t\t\t\tcol4( i ) = V( indices( i, 3 ) );\n\t\t\t}\n\n\t\t\tVectorType tmp = element_product( element_product( col1, col2 ), element_product( col3, col4 ) );\n\n\t\t\treturn dot_product( tmp, kvec );\n\t\t}\n\n\t\t/**\n\t\t * Return MK, Kaxial and Kradial.\n\t\t *\n\t\t * Given eig\n\t\t * Given kvec (15 kurtosis parameters)\n\t\t */\n\t\tVectorType GetKurtosisValues( const VectorType kvec, const EigenContainerType& eig )\n\t\t{\n\t\t\tVectorType kvec_extended = GetKvecExtended( kvec, m_kvec_to_table );\n\n\t\t\tPixelType Wtilda_0000 = GetRotatedW( m_indices_w0000, eig, kvec_extended );\n\t\t\tPixelType Wtilda_0011 = GetRotatedW( m_indices_w0011, eig, kvec_extended );\n\t\t\tPixelType Wtilda_0022 = GetRotatedW( m_indices_w0022, eig, kvec_extended );\n\t\t\tPixelType Wtilda_1111 = GetRotatedW( m_indices_w1111, eig, kvec_extended );\n\t\t\tPixelType Wtilda_1122 = GetRotatedW( m_indices_w1122, eig, kvec_extended );\n\t\t\tPixelType Wtilda_2222 = GetRotatedW( m_indices_w2222, eig, kvec_extended );\n\n\t\t\tPixelType l1 = eig.at( 0 ).first;\n\t\t\tPixelType l2 = eig.at( 1 ).first;\n\t\t\tPixelType l3 = eig.at( 2 ).first;\n\n\t\t\tPixelType MK = F1( l1, l2, l3 ) * Wtilda_0000 + F1( l2, l1, l3 ) * Wtilda_1111 + F1( l3, l2, l1 ) * Wtilda_2222 + F2( l1, l2,\n\t\t\t\t\tl3 ) * Wtilda_1122 + F2( l2, l1, l3 ) * Wtilda_0022 + F2( l3, l2, l1 ) * Wtilda_0011;\n\n\t\t\tPixelType Kaxial = ( std::pow( l1 + l2 + l3, 2 ) / 9 * std::pow( l1, 2 ) ) * Wtilda_0000;\n\n\t\t\tPixelType Kradial = G1( l1, l2, l3 ) * Wtilda_1111 + G1( l1, l3, l2 ) * Wtilda_2222 + G2( l1, l2, l3 ) * Wtilda_1122;\n\n\t\t\tVectorType k( 3 );\n\t\t\tk( 0 ) = MK;\n\t\t\tk( 1 ) = Kaxial;\n\t\t\tk( 2 ) = Kradial;\n\n\t\t\treturn k;\n\t\t}\n\n\t\t/**\n\t\t * Eq (33) Tabesh et al.\n\t\t */\n\t\tPixelType G1( PixelType l1, PixelType l2, PixelType l3 )\n\t\t{\n\t\t\tif ( l2 != l3 )\n\t\t\t{\n\t\t\t\tPixelType a = std::pow( l1 + l2 + l3, 2 ) / 18 * l1 * std::pow( l2 - l3, 2 );\n\t\t\t\tPixelType b = 2 * l2 + ( std::pow( l3, 2 ) - 3 * l2 * l3 ) / std::sqrt( l2 * l3 );\n\n\t\t\t\treturn a * ( 2 * l2 + b );\n\t\t\t}\n\n\t\t\treturn std::pow( l1 + 2 * l2, 2 ) / std::pow( 24. * l2, 2 );\n\t\t}\n\n\t\t/**\n\t\t * Eq (34) Tabesh et al.\n\t\t */\n\t\tPixelType G2( PixelType l1, PixelType l2, PixelType l3 )\n\t\t{\n\t\t\tif ( l2 != l3 )\n\t\t\t{\n\t\t\t\tPixelType a = std::pow( l1 + l2 + l3, 2 ) / 3 * std::pow( l2 - l3, 2 );\n\t\t\t\tPixelType b = l2 + l3 / std::sqrt( l2 + l3 );\n\n\t\t\t\treturn a * ( b - 2 );\n\t\t\t}\n\n\t\t\treturn 6 * std::pow( l1 + 2 * l2, 2 ) / std::pow( 72 * l2, 2 );\n\t\t}\n\n\t\t/**\n\t\t * Eq (27) Tabesh et al.\n\t\t */\n\t\tPixelType F1( PixelType l1, PixelType l2, PixelType l3 )\n\t\t{\n\t\t\tif ( ( l1 == l2 ) && ( l2 == l3 ) )\n\t\t\t{\n\t\t\t\treturn 0.2;\n\t\t\t} else if ( l1 == l2 )\n\t\t\t{\n\t\t\t\treturn 0.5 * F2( l3, l1, l1 );\n\t\t\t} else if ( l1 == l3 )\n\t\t\t{\n\t\t\t\treturn 0.5 * F2( l2, l1, l1 );\n\t\t\t}\n\n\t\t\tPixelType a = std::pow( l1 + l2 + l3, 2 ) / 18 * ( l1 - l2 ) * ( l1 - l3 );\n\t\t\tPixelType b = std::sqrt( l2 * l3 ) / l1;\n\t\t\tPixelType c = boost::math::ellint_rf( l1 / l2, l1 / l3, 1. );\n\t\t\tPixelType d = ( 3 * std::pow( l1, 2 ) - l1 * l2 - l1 * l3 - l2 * l3 ) / 3 * l1 * std::sqrt( l2 * l3 );\n\t\t\tPixelType e = boost::math::ellint_rd( l1 / l2, l1 / l3, 1. );\n\n\t\t\treturn a * ( b * c + d * e - 1 );\n\t\t}\n\n\t\t/**\n\t\t * Eq (28) Tabesh et al.\n\t\t */\n\t\tPixelType F2( PixelType l1, PixelType l2, PixelType l3 )\n\t\t{\n\t\t\tif ( l2 != l3 )\n\t\t\t{\n\t\t\t\tPixelType a = std::pow( l1 + l2 + l3, 2 ) / ( 3 * std::pow( l2 - l3, 2 ) );\n\t\t\t\tPixelType b = ( l2 + l3 ) / std::sqrt( l2 * l3 );\n\t\t\t\tPixelType c = boost::math::ellint_rf( l1 / l2, l1 / l3, 1. );\n\t\t\t\tPixelType d = ( 2 * l1 - l2 + l3 ) / ( 3 * std::sqrt( l2 * l3 ) );\n\t\t\t\tPixelType e = boost::math::ellint_rd( l1 / l2, l1 / l3, 1. );\n\n\t\t\t\treturn a * ( b * c + d * e - 2 );\n\t\t\t} else if ( l1 != l3 )\n\t\t\t{\n\t\t\t\tPixelType a = std::pow( l1 + 2 * l3, 2 ) / std::pow( 144 * l3, 2 ) * std::pow( l1 - l3, 2 );\n\t\t\t\tPixelType b = l3 * ( l1 + 2 * l3 );\n\t\t\t\tPixelType c = 1 - ( l1 / l3 );\n\t\t\t\tPixelType d = l1 * ( l1 - 4 * l3 );\n\n\t\t\t\tc = std::sqrt( std::abs< PixelType >( c ) );\n\t\t\t\td = d * ( 1. / c ) * std::atan( c );\n\n\t\t\t\treturn 6 * a * ( b + d );\n\t\t\t}\n\n\t\t\treturn 6. / 15.;\n\t\t}\n\n\t\t/**\n\t\t * Return 2-rank DTI tensor.\n\t\t *\n\t\t * layout =>\n\t\t * \t\t| 0 1 2 |\n\t\t *\t | 1 3 4 |\n\t\t * | 2 4 5 |\n\t\t */\n\t\tMatrixType GetDTITensor( const VectorType& x )\n\t\t{\n\t\t\tMatrixType DT( 3, 3 );\n\n\t\t\t/*\n\t\t\t m_A_D( i, 0 ) = Gx * Gx;\n\t\t\t m_A_D( i, 1 ) = Gy * Gy;\n\t\t\t m_A_D( i, 2 ) = 2 * Gx * Gy;\n\t\t\t m_A_D( i, 3 ) = Gz * Gz;\n\t\t\t m_A_D( i, 4 ) = 2 * Gy * Gz;\n\t\t\t m_A_D( i, 5 ) = 2 * Gx * Gz;\n\t\t\t */\n\n\t\t\tDT( 0, 0 ) = x( 0 ); // x * x\n\t\t\tDT( 0, 1 ) = x( 2 );\n\t\t\tDT( 0, 2 ) = x( 5 );\n\n\t\t\tDT( 1, 0 ) = x( 2 );\n\t\t\tDT( 1, 1 ) = x( 1 ); // y * y\n\t\t\tDT( 1, 2 ) = x( 4 );\n\n\t\t\tDT( 2, 0 ) = x( 5 );\n\t\t\tDT( 2, 1 ) = x( 4 );\n\t\t\tDT( 2, 2 ) = x( 3 ); // z * z\n\n\t\t\treturn DT;\n\t\t}\n\n\t\t/**\n\t\t * Set input image.\n\t\t */\n\t\tvoid SetInput( const std::string& inputFileName )\n\t\t{\n\t\t\tif ( !inputFileName.empty() )\n\t\t\t{\n\t\t\t\tReaderType::Pointer reader = ReaderType::New();\n\t\t\t\treader->SetFileName( inputFileName );\n\t\t\t\treader->Update();\n\t\t\t\tm_Input = reader->GetOutput();\n\t\t\t} else\n\t\t\t{\n\t\t\t\tstd::cerr << \"Could not read input: \" << inputFileName << \"!\" << std::endl;\n\t\t\t\texit( EXIT_FAILURE );\n\t\t\t}\n\t\t}\n\n\t\t/**\n\t\t\t * Init mask if file given, else create empty mask from input file.\n\t\t\t */\n\t\t\tvoid InitMask( const std::string& maskFileName )\n\t\t\t{\n\t\t\t\tif ( !maskFileName.empty() )\n\t\t\t\t{\n\t\t\t\t\tMaskReaderType::Pointer reader = MaskReaderType::New();\n\t\t\t\t\treader->SetFileName( maskFileName );\n\t\t\t\t\treader->Update();\n\t\t\t\t\tm_Mask = reader->GetOutput();\n\t\t\t\t} else\n\t\t\t\t{\n\t\t\t\t\tOutputImageType::Pointer output = OutputImageType::New();\n\t\t\t\t\tOutputImageType::RegionType region3D;\n\t\t\t\t\tOutputImageType::IndexType index3D;\n\t\t\t\t\tOutputImageType::SizeType size3D;\n\t\t\t\t\tOutputImageType::SpacingType spacing3D;\n\t\t\t\t\tOutputImageType::PointType origin3D;\n\n\t\t\t\t\tImageType::RegionType region = m_Input->GetLargestPossibleRegion();\n\t\t\t\t\tImageType::SizeType size = region.GetSize();\n\t\t\t\t\tImageType::IndexType index = region.GetIndex();\n\t\t\t\t\tImageType::SpacingType spacing = m_Input->GetSpacing();\n\t\t\t\t\tImageType::PointType origin = m_Input->GetOrigin();\n\n\t\t\t\t\tsize3D[0] = size[0];\n\t\t\t\t\tsize3D[1] = size[1];\n\t\t\t\t\tsize3D[2] = size[2];\n\t\t\t\t\tindex3D[0] = index[0];\n\t\t\t\t\tindex3D[1] = index[1];\n\t\t\t\t\tindex3D[2] = index[2];\n\t\t\t\t\torigin3D[0] = origin[0];\n\t\t\t\t\torigin3D[1] = origin[1];\n\t\t\t\t\torigin3D[2] = origin[2];\n\t\t\t\t\tspacing3D[0] = spacing[0];\n\t\t\t\t\tspacing3D[1] = spacing[1];\n\t\t\t\t\tspacing3D[2] = spacing[2];\n\n\t\t\t\t\tregion3D.SetSize( size3D );\n\t\t\t\t\tregion3D.SetIndex( index3D );\n\n\t\t\t\t\t// set\n\t\t\t\t\toutput->SetRegions( region3D );\n\t\t\t\t\toutput->SetSpacing( spacing3D );\n\t\t\t\t\toutput->SetOrigin( origin3D );\n\t\t\t\t\toutput->Allocate();\n\t\t\t\t\toutput->FillBuffer( 1 );\n\n\t\t\t\t\tm_Mask = output;\n\t\t\t\t}\n\t\t\t}\n\n\t\t/**\n\t\t * Allocate all output images to 0.\n\t\t */\n\t\tvoid AllocateOutput()\n\t\t{\n\t\t\tOutputImageType::RegionType region3D;\n\t\t\tOutputImageType::IndexType index3D;\n\t\t\tOutputImageType::SizeType size3D;\n\t\t\tOutputImageType::SpacingType spacing3D;\n\t\t\tOutputImageType::PointType origin3D;\n\n\t\t\tImageType::RegionType region = m_Input->GetLargestPossibleRegion();\n\t\t\tImageType::SizeType size = region.GetSize();\n\t\t\tImageType::IndexType index = region.GetIndex();\n\t\t\tImageType::SpacingType spacing = m_Input->GetSpacing();\n\t\t\tImageType::PointType origin = m_Input->GetOrigin();\n\n\t\t\tsize3D[0] = size[0];\n\t\t\tsize3D[1] = size[1];\n\t\t\tsize3D[2] = size[2];\n\t\t\tindex3D[0] = index[0];\n\t\t\tindex3D[1] = index[1];\n\t\t\tindex3D[2] = index[2];\n\t\t\torigin3D[0] = origin[0];\n\t\t\torigin3D[1] = origin[1];\n\t\t\torigin3D[2] = origin[2];\n\t\t\tspacing3D[0] = spacing[0];\n\t\t\tspacing3D[1] = spacing[1];\n\t\t\tspacing3D[2] = spacing[2];\n\n\t\t\tregion3D.SetSize( size3D );\n\t\t\tregion3D.SetIndex( index3D );\n\n\t\t\t// create\n\t\t\tm_FA = OutputImageType::New();\n\t\t\tm_Trace = OutputImageType::New();\n\t\t\tm_Laxial = OutputImageType::New();\n\t\t\tm_Lradial = OutputImageType::New();\n\n\t\t\tm_MK = OutputImageType::New();\n\t\t\tm_Kaxial = OutputImageType::New();\n\t\t\tm_Kradial = OutputImageType::New();\n\n\t\t\t// set\n\t\t\tm_FA->SetRegions( region3D );\n\t\t\tm_FA->SetSpacing( spacing3D );\n\t\t\tm_FA->SetOrigin( origin3D );\n\t\t\tm_FA->Allocate();\n\t\t\tm_FA->FillBuffer( 0 );\n\n\t\t\tm_Trace->SetRegions( region3D );\n\t\t\tm_Trace->SetSpacing( spacing3D );\n\t\t\tm_Trace->SetOrigin( origin3D );\n\t\t\tm_Trace->Allocate();\n\t\t\tm_Trace->FillBuffer( 0 );\n\n\t\t\tm_Laxial->SetRegions( region3D );\n\t\t\tm_Laxial->SetSpacing( spacing3D );\n\t\t\tm_Laxial->SetOrigin( origin3D );\n\t\t\tm_Laxial->Allocate();\n\t\t\tm_Laxial->FillBuffer( 0 );\n\n\t\t\tm_Lradial->SetRegions( region3D );\n\t\t\tm_Lradial->SetSpacing( spacing3D );\n\t\t\tm_Lradial->SetOrigin( origin3D );\n\t\t\tm_Lradial->Allocate();\n\t\t\tm_Lradial->FillBuffer( 0 );\n\n\t\t\tm_MK->SetRegions( region3D );\n\t\t\tm_MK->SetSpacing( spacing3D );\n\t\t\tm_MK->SetOrigin( origin3D );\n\t\t\tm_MK->Allocate();\n\t\t\tm_MK->FillBuffer( 0 );\n\n\t\t\tm_Kaxial->SetRegions( region3D );\n\t\t\tm_Kaxial->SetSpacing( spacing3D );\n\t\t\tm_Kaxial->SetOrigin( origin3D );\n\t\t\tm_Kaxial->Allocate();\n\t\t\tm_Kaxial->FillBuffer( 0 );\n\n\t\t\tm_Kradial->SetRegions( region3D );\n\t\t\tm_Kradial->SetSpacing( spacing3D );\n\t\t\tm_Kradial->SetOrigin( origin3D );\n\t\t\tm_Kradial->Allocate();\n\t\t\tm_Kradial->FillBuffer( 0 );\n\t\t}\n\n\t\t/**\n\t\t * Write output images.\n\t\t */\n\t\tvoid Write( const std::string& outputFileName )\n\t\t{\n\t\t\t// Writer\n\t\t\tWriterType::Pointer writer = WriterType::New();\n\n\t\t\t// FA\n\t\t\twriter->SetFileName( ( outputFileName + std::string( \"_FA.nii.gz\" ) ).c_str() );\n\t\t\twriter->SetInput( m_FA );\n\t\t\twriter->Update();\n\n\t\t\t// Trace\n\t\t\twriter->SetFileName( ( outputFileName + std::string( \"_Trace.nii.gz\" ) ).c_str() );\n\t\t\twriter->SetInput( m_Trace );\n\t\t\twriter->Update();\n\n\t\t\t// L axial\n\t\t\twriter->SetFileName( ( outputFileName + std::string( \"_Laxial.nii.gz\" ) ).c_str() );\n\t\t\twriter->SetInput( m_Laxial );\n\t\t\twriter->Update();\n\n\t\t\t// L radial\n\t\t\twriter->SetFileName( ( outputFileName + std::string( \"_Lradial.nii.gz\" ) ).c_str() );\n\t\t\twriter->SetInput( m_Lradial );\n\t\t\twriter->Update();\n\n\t\t\t// MK\n\t\t\twriter->SetFileName( ( outputFileName + std::string( \"_MK.nii.gz\" ) ).c_str() );\n\t\t\twriter->SetInput( m_MK );\n\t\t\twriter->Update();\n\n\t\t\t// K axial\n\t\t\twriter->SetFileName( ( outputFileName + std::string( \"_Kaxial.nii.gz\" ) ).c_str() );\n\t\t\twriter->SetInput( m_Kaxial );\n\t\t\twriter->Update();\n\n\t\t\t// K radial\n\t\t\twriter->SetFileName( ( outputFileName + std::string( \"_Kradial.nii.gz\" ) ).c_str() );\n\t\t\twriter->SetInput( m_Kradial );\n\t\t\twriter->Update();\n\t\t}\n\n\t};\n\n} // end namespace dki\n\n\n/**\n * Create dki maps.\n */\nint main( int argc, char ** argv )\n{\n\ttkd::CmdParser p( argv[0], \"Create diffusion kurtosis maps.\" );\n\n\tdki::DkiMaps::parameters args;\n\n\tp.AddArgument( args.inputFileName, \"input\" ) ->AddAlias( \"i\" ) ->SetDescription( \"Input 4D image with 21 tensor elements\" ) ->SetRequired(\n\t\t\ttrue );\n\n\tp.AddArgument( args.outputFileName, \"output\" ) ->AddAlias( \"o\" ) ->SetDescription( \"Output filename base\" ) ->SetRequired( true );\n\n\tp.AddArgument( args.maskFileName, \"mask\" ) ->AddAlias( \"m\" ) ->SetDescription( \"Mask 3D image\" );\n\n\tif ( !p.Parse( argc, argv ) )\n\t{\n\t\tp.PrintUsage( std::cout );\n\t\treturn EXIT_FAILURE;\n\t}\n\n\tdki::DkiMaps maps( args );\n\n\treturn EXIT_SUCCESS;\n}\n\n", "meta": {"hexsha": "8537469d564d9caac2594c8383f7eb059ffd3573", "size": 21904, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/dkifit/dkimaps.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/dkifit/dkimaps.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/dkifit/dkimaps.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": 25.9526066351, "max_line_length": 139, "alphanum_fraction": 0.5967859752, "num_tokens": 7836, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802264851918, "lm_q2_score": 0.5851011542032313, "lm_q1q2_score": 0.44998972819136823}} {"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_CEIL_HPP_INCLUDED\n#define BOOST_SIMD_FUNCTION_CEIL_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 smallest integral representable value of\n its parameter type which is greater or equal to it.\n\n @par Header \n\n @par Notes\n\n - @c ceil is also used as parameter to pass to @ref div or @ref rem\n\n @par Decorators\n\n - std_ for floating entries call std::ceil\n\n @see floor, round, nearbyint, trunc, iceil\n\n @par Example:\n\n @snippet ceil.cpp ceil\n\n @par Possible output:\n\n @snippet ceil.txt ceil\n\n **/\n Value ceil(Value const& x);\n} }\n#endif\n\n#include \n#include \n\n#endif\n", "meta": {"hexsha": "fcdc43ad4ea14d6e37156ec1f8d3f2ba83726154", "size": 1231, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "third_party/boost/simd/function/ceil.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/ceil.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/ceil.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": 23.6730769231, "max_line_length": 100, "alphanum_fraction": 0.5946385053, "num_tokens": 264, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7185943805178139, "lm_q2_score": 0.6261241632752915, "lm_q1q2_score": 0.4499293052360427}} {"text": "#include \"IntegratorRect.hh\"\n\n#include \n#include \n\n#include \"TypesFunctions.hh\"\n\nusing namespace Eigen;\nusing namespace std;\n\nIntegratorRect::IntegratorRect(int order, const std::string& mode) : IntegratorBase(order)\n{\n init(mode);\n}\n\nIntegratorRect::IntegratorRect(size_t bins, int orders, double* edges, const std::string& mode) : IntegratorBase(bins, orders, edges)\n{\n init(mode);\n}\n\nIntegratorRect::IntegratorRect(size_t bins, int* orders, double* edges, const std::string& mode) : IntegratorBase(bins, orders, edges)\n{\n init(mode);\n}\n\nvoid IntegratorRect::init(const std::string& mode) {\n m_mode = mode;\n\n if(m_mode==\"left\"){\n m_rect_offset=-1;\n }\n else if(m_mode==\"center\"){\n m_rect_offset=0;\n }\n else if(m_mode==\"right\"){\n m_rect_offset=1;\n }\n else{\n throw std::runtime_error(\"invalid rectangular integration mode\");\n }\n\n init_sampler();\n}\n\nvoid IntegratorRect::sample(FunctionArgs& fargs){\n auto& rets=fargs.rets;\n rets[1].x = m_edges.cast();\n rets[2].x = 0.0;\n auto npoints=m_edges.size()-1;\n rets[3].x = 0.5*(m_edges.tail(npoints)+m_edges.head(npoints));\n\n auto& abscissa=rets[0].x;\n\n auto nbins=m_edges.size()-1;\n auto& binwidths=m_edges.tail(nbins) - m_edges.head(nbins);\n ArrayXd samplewidths=binwidths/m_orders.cast();\n\n ArrayXd low, high;\n switch(m_rect_offset){\n case -1: {\n low=m_edges.head(nbins);\n high=m_edges.tail(nbins)-samplewidths;\n break;\n }\n case 0: {\n ArrayXd offsetwidth=samplewidths*0.5;\n low=m_edges.head(nbins)+offsetwidth;\n high=m_edges.tail(nbins)-offsetwidth;\n break;\n }\n case 1: {\n samplewidths=binwidths/m_orders.cast();\n low=m_edges.head(nbins)+samplewidths;\n high=m_edges.tail(nbins);\n break;\n }\n }\n\n size_t offset=0;\n for (size_t i = 0; i < static_cast(m_orders.size()); ++i) {\n auto n=m_orders[i];\n if(n>1){\n abscissa.segment(offset, n)=ArrayXd::LinSpaced(n, low[i], high[i]);\n m_weights.segment(offset, n)=samplewidths[i];\n }\n else{\n abscissa[i]=low[i];\n m_weights[i]=binwidths[i];\n }\n offset+=n;\n }\n rets.untaint();\n rets.freeze();\n}\n", "meta": {"hexsha": "087faacd081e6ad7e5bcb66e0956db2ec4f09ba8", "size": 2190, "ext": "cc", "lang": "C++", "max_stars_repo_path": "transformations/integrator/IntegratorRect.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/integrator/IntegratorRect.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/integrator/IntegratorRect.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": 23.0526315789, "max_line_length": 134, "alphanum_fraction": 0.6552511416, "num_tokens": 641, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7401743735019594, "lm_q2_score": 0.6076631698328916, "lm_q1q2_score": 0.4497767060312753}} {"text": "//\n// Created by Hamza El-Kebir on 6/21/21.\n//\n\n#ifndef LODESTAR_SINGLETON_HPP\n#define LODESTAR_SINGLETON_HPP\n\n#include \n#include \n#include \"Lodestar/aux/CompileTimeQualifiers.hpp\"\n\n#include \"SetExpression.hpp\"\n#include \"SetUnion.hpp\"\n#include \"EmptySet.hpp\"\n#include \"SetComplement.hpp\"\n\nnamespace ls {\n namespace primitives {\n namespace sets {\n /**\n * @brief A singleton set.\n *\n * @brief A singleton contains a single element, represented by the vector \\c value_.\n *\n * @tparam TDimension The dimension of the singleton; if -1, it is dynamically sized.\n * @tparam TScalarType The scalar type.\n */\n template\n class Singleton : public SetExpression> {\n public:\n template\n friend\n class SetUnion;\n\n using Base = SetExpression>; //! Base class.\n using type = Singleton; //! Expression type.\n\n typedef Eigen::Matrix TDValue; //! Value typedef.\n\n /**\n * @brief Default constructor.\n */\n Singleton() : value_{TDValue::Zero()}\n {\n this->sEnum_ = SetEnum::Singleton;\n }\n\n /**\n * @brief Constructs a Singleton instance from a vector.\n *\n * @tparam TDerived Derived EigenBase class.\n *\n * @param value Singleton value.\n */\n template\n Singleton(const Eigen::EigenBase &value) : value_(value)\n {\n this->sEnum_ = SetEnum::Singleton;\n }\n\n /**\n * @brief Returns the singleton dimension.\n *\n * @details This specialization deals with the static case.\n *\n * @tparam T_TDimension Copy of \\c TDimension.\n *\n * @return Dimension of the singleton instance.\n */\n template\n int\n dimension(typename std::enable_if<(T_TDimension < 0)>::type * = nullptr) const\n {\n return T_TDimension;\n }\n\n /**\n * @brief Returns the singleton dimension.\n *\n * @details This specialization deals with the dynamic case.\n *\n * @tparam T_TDimension Copy of \\c TDimension.\n *\n * @return Dimension of the singleton instance.\n */\n template\n int\n dimension(typename std::enable_if<(T_TDimension >= 0)>::type * = nullptr) const\n {\n return value_.rows();\n }\n\n /**\n * @brief Changes the dimension of the singleton.\n *\n * @details This specialization raises a static assert since statically type Singleton instances cannot\n * be resized.\n *\n * @tparam T_TDimension Copy of \\c TDimension.\n *\n * @param dim New dimension.\n */\n template\n void\n setDimension(size_t dim, typename std::enable_if<(T_TDimension < 0)>::type * = nullptr)\n {\n static_assert(TDimension > -1, \"Cannot set dimension of statically sized singleton.\");\n }\n\n /**\n * @brief Changes the dimension of the singleton.\n *\n * @details This specialization conservatively resizes \\c value_.\n *\n * @tparam T_TDimension Copy of \\c TDimension.\n *\n * @param dim New dimension.\n */\n template\n void\n setDimension(size_t dim, typename std::enable_if<(T_TDimension >= 0)>::type * = nullptr)\n {\n value_.conservativeResize(dim);\n }\n\n /**\n * @brief Returns true if this expression contains \\c expr.\n *\n * @details This specialization handles a singleton expression of the same type.\n *\n * @tparam TExpression Type of the other expression.\n *\n * @param expr Expression to check containment of.\n * @param tol Numerical tolerance.\n *\n * @return True if this expression contains \\c expr, false otherwise.\n */\n template\n typename std::enable_if::value, bool>::type\n contains(const SetExpression &expr, double tol = 1e-6) const\n {\n return (value_ - static_cast(&expr)->value_).isMuchSmallerThan(tol);\n }\n\n /**\n * @brief Returns true if this expression contains \\c expr.\n *\n * @details This specialization handles all other cases.\n *\n * @tparam TExpression Type of the other expression.\n *\n * @param expr Expression to check containment of.\n * @param tol Numerical tolerance.\n *\n * @return False.\n */\n template\n typename std::enable_if::value, bool>::type\n contains(const SetExpression &expr, double tol = 1e-6) const\n {\n return false;\n }\n\n /**\n * @brief Checks if this expression is equal to \\expr.\n *\n * @details This specialization deals with singletons of the same type.\n *\n * @tparam TExpression Type of the other expression.\n *\n * @param expr Expression to check equality with.\n *\n * @return True if this expression is equal to \\c expr, false otherwise.\n */\n template\n typename std::enable_if::value, bool>::type\n operator==(const SetExpression &expr) const\n {\n return (value_ - static_cast(&expr)->value_).isMuchSmallerThan(1e-6);\n }\n\n // TODO: Add dynamic case.\n\n /**\n * @brief Checks if this expression is equal to \\expr.\n *\n * @details This specialization deals with all other cases.\n *\n * @tparam TExpression Type of the other expression.\n *\n * @param expr Expression to check equality with.\n *\n * @return False.\n */\n template\n typename std::enable_if::value, bool>::type\n operator==(const SetExpression &expr) const\n {\n return false;\n }\n\n /**\n * @brief Checks if this expression is not equal to \\expr.\n *\n * @details This specialization deals with singletons of the same type.\n *\n * @tparam TExpression Type of the other expression.\n *\n * @param expr Expression to check inequality with.\n *\n * @return True if this expression is not equal to \\c expr, false otherwise.\n */\n template\n typename std::enable_if::value, bool>::type\n operator!=(const SetExpression &expr) const\n {\n return !((value_ - static_cast(&expr)->value_).isMuchSmallerThan(1e-6));\n }\n\n /**\n * @brief Checks if this expression is not equal to \\expr.\n *\n * @details This specialization deals with all other cases.\n *\n * @tparam TExpression Type of the other expression.\n *\n * @param expr Expression to check inequality with.\n *\n * @return True.\n */\n template\n typename std::enable_if::value, bool>::type\n operator!=(const SetExpression &expr) const\n {\n return true;\n }\n\n /**\n * @brief Creates a union between this expression and another SetExpression.\n *\n * @tparam TExpression Type of the other expression.\n *\n * @param expr Expression to create a union with.\n *\n * @return Union.\n */\n template\n SetUnion unionize(const SetExpression &expr)\n {\n return SetUnion(*this, *static_cast(&expr));\n }\n\n /**\n * @brief Checks if this expression is a subset of \\c expr.\n *\n * @tparam TExpression Type of the other expression.\n *\n * @param expr Expression to check inclusion on.\n *\n * @return True if this expression is a subset of \\c expr, false otherwise.\n */\n template\n bool isSubset(const SetExpression &expr)\n {\n return static_cast(&expr)->contains(*this);\n }\n\n /**\n * @brief Checks if this expression is a superset of \\c expr.\n *\n * @tparam TExpression Type of the other expression.\n *\n * @param expr Expression to check subsumption on.\n *\n * @return True if this expression is a superset of \\c expr, false otherwise.\n */\n template\n bool isSuperset(const SetExpression &expr)\n {\n return contains(expr);\n }\n\n /**\n * @brief Returns true if the expression is the empty set.\n *\n * @note This always returns false, since a singleton always contains one element.\n *\n * @return False.\n */\n bool isEmpty() const\n {\n return false;\n }\n\n /**\n * @brief Computes the relative complement of this expression and \\c expr.\n *\n * @details The syntax is as follows:\n * \\code\n * // A \\ B\n * A.relComplement(B);\n * \\endcode\n *\n * @tparam TExpression Type of the other expression.\n *\n * @param expr Expression to take relative complement with.\n *\n * @return Relative complement.\n */\n template\n SetComplement relComplement(const SetExpression &expr)\n {\n return SetComplement(*this, *static_cast(&expr),\n isSubset(expr));\n }\n\n /**\n * @brief Returns signed distance to \\c p.\n *\n * @tparam TDerived Derived MatrixBase class.\n *\n * @param p A point.\n *\n * @return Signed distance.\n */\n template\n double sdf(Eigen::MatrixBase &p) const\n {\n p.resize(dimension());\n return (value_ - p).norm();\n }\n\n protected:\n TDValue value_; //! Singleton value.\n };\n }\n }\n}\n\n#endif //LODESTAR_SINGLETON_HPP\n", "meta": {"hexsha": "6764a70692af6d476de67d9f85a22fb279be470e", "size": 13459, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "Lodestar/primitives/sets/Singleton.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/sets/Singleton.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/sets/Singleton.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": 39.4692082111, "max_line_length": 119, "alphanum_fraction": 0.4695742626, "num_tokens": 2336, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6688802735722128, "lm_q2_score": 0.6723316926137812, "lm_q1q2_score": 0.4497094064867749}} {"text": "// Copyright Erik Lundin 2016.\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#include \n#include \n#include \n#include \n#include \n\n#include \"gausskruger.h\"\n\nusing namespace gausskruger;\nnamespace po = boost::program_options;\n\n#define EXE_NAME \"gausskruger\"\n\nclass ParameterProjection : public Projection\n{\npublic:\n ParameterProjection(double flattening, double equatorialRadius, double centralMeridian,\n double scale, double falseNorthing, double falseEasting) :\n mFlattening(flattening),\n mEquatorialRadius(equatorialRadius),\n mCentralMeridian(centralMeridian),\n mScale(scale),\n mFalseNorthing(falseNorthing),\n mFalseEasting(falseEasting) {}\n double flattening() { return mFlattening; }\n double equatorialRadius() { return mEquatorialRadius; }\n double centralMeridian() { return mCentralMeridian; }\n double scale() { return mScale; }\n double falseNorthing() { return mFalseNorthing; }\n double falseEasting() { return mFalseEasting; }\nprivate:\n double mFlattening;\n double mEquatorialRadius;\n double mCentralMeridian;\n double mScale;\n double mFalseNorthing;\n double mFalseEasting;\n};\n\nint main(int argc, char *argv[])\n{\n double inverseFlattening;\n double equatorialRadius;\n double centralMeridian;\n double scale;\n double falseNorthing;\n double falseEasting;\n std::vector coords;\n int nDecimals;\n\n try {\n // Projection parameters\n po::options_description projection_parameters(\"Projection parameters (mandatory)\");\n projection_parameters.add_options()\n (\"invflattening,i\", po::value(&inverseFlattening),\n \"inverse flattening of the ellipsoid\")\n (\"radius,a\", po::value(&equatorialRadius),\n \"equatorial radius, a.k.a. semi-major axis of the ellipsoid\")\n (\"meridian,m\", po::value(¢ralMeridian),\n \"longitude of the central meridian\")\n (\"scale,s\", po::value(&scale),\n \"scale factor along the central meridian\")\n (\"falsenorthing,n\", po::value(&falseNorthing),\n \"false northing\")\n (\"falseeasting,e\", po::value(&falseEasting),\n \"false easting\")\n ;\n\n // Options\n po::options_description options(\"Options\");\n options.add_options()\n (\"help,h\", \"print this help\")\n (\"decimals,d\", po::value(&nDecimals)->default_value(3), \"number of decimals\")\n (\"reverse,r\",\n \"reverse transformation (grid to geodetic), default is geodetic to grid\")\n ;\n\n // Positional parameters (input coordinates)\n po::options_description hidden_parameters;\n hidden_parameters.add_options()\n (\"coords\", po::value >(&coords))\n ;\n po::positional_options_description positional_parameters;\n positional_parameters.add(\"coords\", 2);\n\n // Store the parameters\n po::options_description all_parameters;\n all_parameters.add(options).add(projection_parameters).add(hidden_parameters);\n po::variables_map vm;\n po::store(po::command_line_parser(argc, argv).options(all_parameters).positional(positional_parameters).run(), vm);\n po::notify(vm);\n\n // Print help (if requested or no other options is given)\n po::options_description visible_parameters;\n visible_parameters.add(projection_parameters).add(options);\n if (argc == 1 || vm.count(\"help\")) {\n std::cout << \"Usage: \" << EXE_NAME << \" [options] latitude longitude\\n\"\n << \" \" << EXE_NAME << \" [options] -r northing easting\\n\"\n << visible_parameters << std::endl;\n return 1;\n }\n\n // Check for all mandatory parameters\n if (!(vm.count(\"invflattening\") && vm.count(\"radius\") && vm.count(\"meridian\") && vm.count(\"scale\")\n && vm.count(\"falsenorthing\") && vm.count(\"falseeasting\"))) {\n std::cout << \"Missing mandatory projection parameter(s)\" << std::endl;\n return 2;\n }\n if (coords.size() != 2) {\n std::cerr << \"Exactly two coordinate values have to be entered\" << std::endl;\n return 3;\n }\n\n // Set number of decimals in output\n std::cout.setf(std::ios::fixed);\n std::cout.precision(nDecimals);\n\n // Do the actual transformation\n ParameterProjection projection(1 / inverseFlattening, equatorialRadius,\n centralMeridian, scale, falseNorthing, falseEasting);\n if (vm.count(\"reverse\")) {\n double lat, lon;\n projection.gridToGeodetic(coords.at(0), coords.at(1), lat, lon);\n std::cout << std::fixed << \"Latitude: \" << lat << \"\\nLongitude: \" << lon << std::endl;\n } else {\n double northing, easting;\n projection.geodeticToGrid(coords.at(0), coords.at(1), northing, easting);\n std::cout << std::fixed << \"Northing: \" << northing << \"\\nEasting: \" << easting << std::endl;\n }\n } catch (std::exception& e) {\n std::cerr << \"Error: \" << e.what() << std::endl;\n return 4;\n }\n\n return 0;\n}\n", "meta": {"hexsha": "d3f367760a075458c95dfbee97cf31740ad1421a", "size": 5643, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "gausskruger_cli.cpp", "max_stars_repo_name": "f03el/gauss-kruger-cpp", "max_stars_repo_head_hexsha": "961236101d9d2e6feb5a48c2d8387def5bf78f01", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 9.0, "max_stars_repo_stars_event_min_datetime": "2016-02-19T08:05:17.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-08T04:59:34.000Z", "max_issues_repo_path": "gausskruger_cli.cpp", "max_issues_repo_name": "f03el/gauss-kruger-cpp", "max_issues_repo_head_hexsha": "961236101d9d2e6feb5a48c2d8387def5bf78f01", "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": "gausskruger_cli.cpp", "max_forks_repo_name": "f03el/gauss-kruger-cpp", "max_forks_repo_head_hexsha": "961236101d9d2e6feb5a48c2d8387def5bf78f01", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2019-02-05T16:33:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-21T00:55:28.000Z", "avg_line_length": 39.4615384615, "max_line_length": 123, "alphanum_fraction": 0.6037568669, "num_tokens": 1254, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7310585786300048, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.4496652533861533}} {"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/**\n * \\file\n * \\author Felix Lehmann\n */\n\n#ifndef ICC_0_PRECOND_HH\n#define ICC_0_PRECOND_HH\n\n#include \n#include \n\n#include \n\n#include \"dune/grid/common/grid.hh\"\n#include \"dune/istl/matrix.hh\"\n#include \"dune/istl/bcrsmatrix.hh\"\n#include \"dune/common/fmatrix.hh\"\n#include \"dune/common/fvector.hh\"\n#include \"dune/common/iteratorfacades.hh\"\n#include \"dune/istl/matrixindexset.hh\"\n\n#include \"dune/istl/preconditioners.hh\"\n\nnamespace Kaskade\n{\n\n/**\n * \\ingroup linalg\n * \n * Incomplete Cholesky factorization by algorithm from book \"Matrix Computations\" by Gene Golub & Charles van Loan\n *\n * algorith will create approximate cholesky factorization L by only using the sparsity pattern of A\n *\n * we will only touch the lower triangle of the matrix\n *\n * interface copied from iluprecond.hh\n *\n * iccprecond.hh (using TAUCS Incomplete Cholesky Decomposition) does the same (even faster),\n * if we set its droptolerance parameter sufficiently large\n *\n */\n\ntemplate \nclass ICC_0Preconditioner: public Dune::Preconditioner\n{\npublic:\n typedef typename Op::Domain Domain;\n typedef typename Op::Range Range;\n typedef typename Op::Scalar Scalar;\n\nprivate:\n typedef Dune::FieldMatrix BlockType;\n typedef Dune::BlockVector > CoeffVector ;\n typedef Dune::BCRSMatrix BCRS_Matrix;\n typedef typename BCRS_Matrix::ConstColIterator ColIter;\n \n BCRS_Matrix mL;\n std::vector > mEntries;\n // int const mChoice;\n public:\n static int const category = Dune::SolverCategory::sequential;\n ICC_0Preconditioner( Op& op );\n void pre (Domain&, Range&) {}\n void apply (Domain& x, Range const& y);\n void post (Domain&) {}\n};\n\n\ntemplate \nICC_0Preconditioner::ICC_0Preconditioner(Op& op)\n{\n std::unique_ptr mA = op.template getPointer();\n int N = (*mA).N();\n // create kind of column iterator for BCRS\n // and simultaneously read out the sparsity pattern of mA\n mEntries.resize(N);\n for(int i=0;i::iterator it = mEntries[k].begin(); it!=mEntries[k].end(); it++)\n mL[*it][k] /= mL[k][k];\n for(std::vector::iterator it = mEntries[k].begin(); it!=mEntries[k].end(); it++)\n {\n tmp = mL[*it][k];\n mL[*it][*it] -= (mL[*it][k])*(mL[*it][k]); // \"mEntries\" contains not diagonal indices\n for(std::vector::iterator it2 = mEntries[*it].begin(); it2!=mEntries[*it].end(); it2++)\n if( mL.exists(*it2,k) )\n\t mL[*it2][*it] -= mL[*it2][k]*tmp;\n }\n } \n}\n\ntemplate \nvoid ICC_0Preconditioner::apply(Domain& x, Range const& b)\n{\n int N = x.dim();\n \n CoeffVector &sol = boost::fusion::at_c<0>(x.data);\n CoeffVector const &rhs = boost::fusion::at_c<0>(b.data);\n // for forward substitution\n CoeffVector forward(N); forward = 0;\n \n double tmp;\n // forward substitution\n for(int i=0;i=0;i--)\n {\n tmp = forward[i];\n for(std::vector::iterator it = mEntries[i].begin();it!=mEntries[i].end();it++)\n tmp -= mL[*it][i]*sol[*it];\n sol[i] = tmp/mL[i][i]; \n }\n}\n} // namespace Kaskade\n#endif\n \n", "meta": {"hexsha": "822c9c5ae2891d292c5e2da30133cec6e005a5f0", "size": 5188, "ext": "hh", "lang": "C++", "max_stars_repo_path": "Kaskade/linalg/icc0precond.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/linalg/icc0precond.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/linalg/icc0precond.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": 33.4709677419, "max_line_length": 114, "alphanum_fraction": 0.5784502699, "num_tokens": 1509, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7634837635542924, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.4496072898748402}} {"text": "#ifndef __BOOST_GEOMETRY_DISSOLVE_H__\n#define __BOOST_GEOMETRY_DISSOLVE_H__\n\n/*\n * ----------------------------------------------------------------------------\n * \"THE BEER-WARE LICENSE\" (Revision 42):\n * Wouter van Kleunen wrote this file. As long as you retain this notice you\n * can do whatever you want with this stuff. If we meet some day, and you think\n * this stuff is worth it, you can buy me a beer in return. \n * ----------------------------------------------------------------------------\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace geometry {\n\nnamespace impl {\n\ntemplate\nstatic inline void result_combine(C &result, T &&new_element)\n{\n result.push_back(new_element);\n\n \tfor(std::size_t i = 0; i < result.size() - 1; ) {\n if(!boost::geometry::intersects(result[i], result.back())) {\n ++i;\n continue;\n }\n\n std::vector union_result;\n boost::geometry::union_(result[i], result.back(), union_result);\n\n if(union_result.size() != 1) {\n\t\t\t++i;\n\t\t\tcontinue;\n\t\t}\n\n \tresult.back() = std::move(union_result[0]);\n \tresult.erase(result.begin() + i);\n } \n}\n\nstruct pseudo_vertice_key\n{\n std::size_t index_1;\n double scale;\n std::size_t index_2;\n bool reroute;\n \n pseudo_vertice_key(std::size_t index_1 = 0, std::size_t index_2 = 0, double scale = 0.0, bool reroute = false)\n : index_1(index_1), scale(scale), index_2(index_2), reroute(reroute)\n { } \n};\n\nstruct compare_pseudo_vertice_key\n{\n bool operator()(pseudo_vertice_key const &a, pseudo_vertice_key const &b) const {\n if(a.index_1 < b.index_1) return true;\n if(a.index_1 > b.index_1) return false;\n if(a.scale < b.scale) return true;\n if(a.scale > b.scale) return false;\n if(a.index_2 > b.index_2) return true;\n if(a.index_2 < b.index_2) return false;\n if(a.reroute && !b.reroute) return true;\n if(!a.reroute && b.reroute) return false;\n\t\treturn false;\n }\n};\n\ntemplate>\nstruct pseudo_vertice\n{\n point_t p;\n pseudo_vertice_key link;\n \n pseudo_vertice(point_t p, pseudo_vertice_key link = pseudo_vertice_key()) \n : p(p), link(link)\n { } \n};\n\ntemplate<\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename ring_t = boost::geometry::model::ring\n\t>\nstatic inline void dissolve_find_intersections(\n\t\t\tring_t const &ring,\n\t\t\tstd::map, compare_pseudo_vertice_key> &pseudo_vertices,\n \t\tstd::set &start_keys)\n{\n\tif(ring.empty()) return;\n\n\tboost::geometry::index::rtree, std::size_t >, boost::geometry::index::quadratic<16>> index;\n\n\t// Generate all by-pass intersections in the graph\n\t// Generate a list of all by-pass intersections\n pseudo_vertices.emplace(pseudo_vertice_key(ring.size() - 1, ring.size() - 1, 0.0), ring.back()); \n for(std::size_t i = ring.size() - 1; i--; )\n {\n pseudo_vertices.emplace(pseudo_vertice_key(i, i, 0.0), ring[i]); \n\t\tboost::geometry::model::segment line_1(ring[i], ring[i + 1]);\n\n\t\tboost::geometry::index::query(\n\t\t\t\tindex, boost::geometry::index::intersects(line_1), \n\t\t\t\tboost::make_function_output_iterator([&](std::pair< boost::geometry::model::segment, std::size_t > const &iter) {\n\n\t\t\tauto const &line_2 = iter.first;\n\t\t\tauto j = iter.second;\n\t\t\t\n\t\t\tstd::vector output;\n\t\t\tboost::geometry::intersection(line_1, line_2, output);\n\n\t\t\tfor(auto const &p: output) {\n\t\t\t\tdouble scale_1 = boost::geometry::comparable_distance(p, ring[i]) / boost::geometry::comparable_distance(ring[i + 1], ring[i]);\n\t\t\t\tdouble scale_2 = boost::geometry::comparable_distance(p, ring[j]) / boost::geometry::comparable_distance(ring[j + 1], ring[j]);\n\t\t\t\tif(scale_1 < 1.0 && scale_2 < 1.0) {\n\t\t\t\t\tpseudo_vertice_key key_j(j, i, scale_2);\n\t\t\t\t\tpseudo_vertices.emplace(pseudo_vertice_key(i, j, scale_1, true), pseudo_vertice(p, key_j));\n\t\t\t\t\tpseudo_vertices.emplace(key_j, p);\n\t\t\t\t\tstart_keys.insert(key_j);\n\n\t\t\t\t\tpseudo_vertice_key key_i(i, j, scale_1);\n\t\t\t\t\tpseudo_vertices.emplace(pseudo_vertice_key(j, i, scale_2, true), pseudo_vertice(p, key_i));\n\t\t\t\t\tpseudo_vertices.emplace(key_i, p);\n\t\t\t\t\tstart_keys.insert(key_i);\n\t\t\t\t}\n\t\t\t} \n\t\t}));\n\n\t\tindex.insert(std::make_pair(boost::geometry::model::segment(ring[i], ring[i+1]), i));\n }\n}\n\n// Remove invalid points (NaN) from ring\ntemplate<\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename ring_t = boost::geometry::model::ring\n\t>\nstatic inline void correct_invalid(ring_t &ring)\n{\n\tfor(auto i = ring.begin(); i != ring.end(); ) {\n\t\tif(!boost::geometry::is_valid(*i))\n\t\t\ti = ring.erase(i);\n\t\telse\n\t\t\t++i;\n\t}\t\n}\n\n// Correct orientation of ring\ntemplate<\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename ring_t = boost::geometry::model::ring\n\t>\nstatic inline double correct_orientation(ring_t &ring, boost::geometry::order_selector order)\n{\n\tauto area = boost::geometry::area(ring);\n\tbool should_reverse =\n\t\t(order == boost::geometry::clockwise && area < 0) ||\n\t\t(order == boost::geometry::counterclockwise && area > 0);\n\n\tif(should_reverse) {\n\t\tstd::reverse(ring.begin(), ring.end());\n\t} \n\n\treturn area;\n}\n\n// Close ring if not closed\ntemplate<\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename ring_t = boost::geometry::model::ring\n\t>\nstatic inline void correct_close(ring_t &ring)\n{\n\t// Close ring if not closed\n\tif(!ring.empty() && !boost::geometry::equals(ring.back(), ring.front()))\n\t\tring.push_back(ring.front());\n\n}\n\ntemplate<\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename ring_t = boost::geometry::model::ring\n\t>\nstatic inline std::vector dissolve_generate_rings(\n\t\t\tstd::map, compare_pseudo_vertice_key> &pseudo_vertices,\n \t\tstd::set &start_keys, \n\t\t\tboost::geometry::order_selector order, double remove_spike_min_area = 0.0)\n{\n\tstd::vector result;\n\n\t// Generate all polygons by tracing all the intersections\n\t// Perform union to combine all polygons into single polygon again\n while(!start_keys.empty()) { \n\t\tring_t new_ring;\n \n\t\t// Store point in generated polygon\n\t\tauto push_point = [&new_ring](auto const &p) { \n if(new_ring.empty() || boost::geometry::comparable_distance(new_ring.back(), p) > 0)\n new_ring.push_back(p);\n\t\t};\n\n\t\tauto is_closed = [](ring_t &ring) {\n\t\t\tif(ring.size() < 2) return false;\n\t\t\tfor(std::size_t i = 0; i < ring.size() - 1; ++i) {\n\t\t\t\tif(boost::geometry::comparable_distance(ring[i], ring.back()) == 0) {\n\t\t\t\t\tring.erase(ring.begin(), ring.begin() + i);\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn false;\n\t\t};\n\n auto start_iter = pseudo_vertices.find(*start_keys.begin());\n auto i = start_iter;\n \n do {\n auto const &key = i->first;\n auto const &value = i->second;\n \n\t\t\t// Store the point in output polygon\n\t\t\tpush_point(value.p);\n \n start_keys.erase(key);\n if(key.reroute) {\n\t\t\t\t// Follow by-pass\n i = pseudo_vertices.find(value.link);\n\t\t\t} else {\n\t\t\t\t// Continu following original polygon\n ++i;\n if(i == pseudo_vertices.end())\n i = pseudo_vertices.begin();\n }\n\n\t\t\t// Repeat until back at starting point\n \t} while(!is_closed(new_ring));\n\n\t\t// Combine with already generated polygons\n\t\tauto area = boost::geometry::area(new_ring);\n\t\tif(std::abs(area) > remove_spike_min_area) {\n\t \tresult.push_back(std::move(new_ring));\n\t\t}\n \t}\n\n return result;\n}\n\ntemplate<\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename polygon_t = boost::geometry::model::polygon,\n\ttypename ring_t = boost::geometry::model::ring,\n\ttypename multi_polygon_t = boost::geometry::model::multi_polygon\n\t>\nstatic inline std::vector correct(ring_t const &ring, boost::geometry::order_selector order, double remove_spike_min_area = 0.0)\n{\n\tconstexpr std::size_t min_nodes = 3;\n\tif(ring.size() < min_nodes)\n\t\treturn std::vector();\n\n std::map, compare_pseudo_vertice_key> pseudo_vertices; \n std::set start_keys;\n\n\tring_t new_ring = ring;\n\n\t// Remove invalid coordinates\n\tcorrect_invalid(new_ring);\n\n\t// Close ring\n\tcorrect_close(new_ring);\n\n\t// Correct orientation\n\tcorrect_orientation(new_ring, order);\n\n\t// Detect self-intersection points\n\tdissolve_find_intersections(new_ring, pseudo_vertices, start_keys);\n\n\tif(start_keys.empty()) {\n\t\tif(std::abs(boost::geometry::area(new_ring)) > remove_spike_min_area) \n\t\t\treturn { new_ring };\n\t\telse\n\t\t\treturn { };\n\t}\n\n\treturn dissolve_generate_rings(pseudo_vertices, start_keys, order, remove_spike_min_area);\n}\n\ntemplate<\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename polygon_t = boost::geometry::model::polygon,\n\ttypename multi_polygon_t = boost::geometry::model::multi_polygon\n\t>\nstruct combine_non_zero_winding\n{\n\tinline void operator()(multi_polygon_t &combined_outers, multi_polygon_t &combined_inners, polygon_t &poly) \n\t{\n\t\tif(boost::geometry::area(poly) > 0)\n\t\t\tresult_combine(combined_outers, std::move(poly));\n\t\telse {\n\t\t\tstd::reverse(poly.outer().begin(), poly.outer().end());\n\t\t\tresult_combine(combined_inners, std::move(poly));\n\t\t}\n\t}\n};\n\ntemplate<\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename polygon_t = boost::geometry::model::polygon,\n\ttypename multi_polygon_t = boost::geometry::model::multi_polygon\n\t>\nstruct combine_odd_even\n{\n\tinline void operator()(multi_polygon_t &combined_outers, multi_polygon_t &combined_inners, polygon_t &poly) \n\t{\n\t\tif(boost::geometry::area(poly) < 0)\n\t\t\tstd::reverse(poly.outer().begin(), poly.outer().end());\n\n\t\tmulti_polygon_t result;\n\t\tboost::geometry::sym_difference(combined_outers, poly, result);\n\t\tcombined_outers = std::move(result);\n\t}\n};\n \ntemplate<\n\ttypename combine_function_t,\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename polygon_t = boost::geometry::model::polygon,\n\ttypename ring_t = boost::geometry::model::ring,\n\ttypename multi_polygon_t = boost::geometry::model::multi_polygon\n\t>\nstatic inline void correct(polygon_t const &input, multi_polygon_t &output, double remove_spike_min_area, combine_function_t combine)\n{\n\tauto order = boost::geometry::point_order::value;\n\tauto outer_rings = correct(input.outer(), order, remove_spike_min_area);\n\n\t// Calculate all outers and combine them if possible\n\tmulti_polygon_t combined_outers;\n\tmulti_polygon_t combined_inners;\n\n\tfor(auto &ring: outer_rings) {\n\t\tpolygon_t poly;\n\t\tpoly.outer() = std::move(ring);\n\t\tcombine(combined_outers, combined_inners, poly);\n\t}\n\n\t// Calculate all inners and combine them if possible\n\tfor(auto const &ring: input.inners()) {\n\t\tpolygon_t poly;\n\t\tpoly.outer() = std::move(ring);\n\n\t\tmulti_polygon_t new_inners;\n\t\tcorrect(poly, new_inners, remove_spike_min_area, combine);\n\n\t\tfor(auto &poly: new_inners) {\n\t\t\tresult_combine(combined_inners, std::move(poly));\n\t\t} \n\t}\n\n\t// Cut out all inners from all the outers\n\tboost::geometry::difference(combined_outers, combined_inners, output);\n}\n\ntemplate<\n\ttypename combine_function_t,\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename polygon_t = boost::geometry::model::polygon,\n\ttypename ring_t = boost::geometry::model::ring,\n\ttypename multi_polygon_t = boost::geometry::model::multi_polygon\n\t>\nstatic inline void correct(multi_polygon_t const &input, multi_polygon_t &output, double remove_spike_min_area, combine_function_t combine)\n{\n\tfor(auto const &polygon: input)\n\t{\n\t\tmulti_polygon_t new_polygons;\n\t\tcorrect(polygon, new_polygons, remove_spike_min_area, combine);\n\n\t\tfor(auto &new_polygon: new_polygons) \n\t\t\tresult_combine(output, std::move(new_polygon));\n\t}\n}\n\n}\n\ntemplate<\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename polygon_t = boost::geometry::model::polygon,\n\ttypename multi_polygon_t = boost::geometry::model::multi_polygon\n\t>\nstatic inline void correct(polygon_t const &input, multi_polygon_t &output, double remove_spike_min_area = 0.0)\n{\n\timpl::correct(input, output, remove_spike_min_area, impl::combine_non_zero_winding());\n}\n\ntemplate<\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename polygon_t = boost::geometry::model::polygon,\n\ttypename multi_polygon_t = boost::geometry::model::multi_polygon\n\t>\nstatic inline void correct_odd_even(polygon_t const &input, multi_polygon_t &output, double remove_spike_min_area = 0.0)\n{\n\timpl::correct(input, output, remove_spike_min_area, impl::combine_odd_even());\n}\n\n\ntemplate<\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename polygon_t = boost::geometry::model::polygon,\n\ttypename ring_t = boost::geometry::model::ring,\n\ttypename multi_polygon_t = boost::geometry::model::multi_polygon\n\t>\nstatic inline void correct(multi_polygon_t const &input, multi_polygon_t &output, double remove_spike_min_area = 0.0)\n{\n\timpl::correct(input, output, remove_spike_min_area, impl::combine_non_zero_winding());\n}\n\ntemplate<\n\ttypename point_t = boost::geometry::model::d2::point_xy, \n\ttypename polygon_t = boost::geometry::model::polygon,\n\ttypename ring_t = boost::geometry::model::ring,\n\ttypename multi_polygon_t = boost::geometry::model::multi_polygon\n\t>\nstatic inline void correct_odd_even(multi_polygon_t const &input, multi_polygon_t &output, double remove_spike_min_area = 0.0)\n{\n\timpl::correct(input, output, remove_spike_min_area, impl::combine_odd_even());\n}\n\n}\n\n#endif\n", "meta": {"hexsha": "7adb5d34e6d1d0274fba8c8784ce8efc7b54fc0d", "size": 14588, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/geometry/correct.hpp", "max_stars_repo_name": "typebrook/tilemaker", "max_stars_repo_head_hexsha": "a8185978a0fd53a5c61404a3ae0b16ef119e1413", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 815.0, "max_stars_repo_stars_event_min_datetime": "2015-06-29T13:39:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T09:35:53.000Z", "max_issues_repo_path": "include/geometry/correct.hpp", "max_issues_repo_name": "typebrook/tilemaker", "max_issues_repo_head_hexsha": "a8185978a0fd53a5c61404a3ae0b16ef119e1413", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 341.0, "max_issues_repo_issues_event_min_datetime": "2015-06-29T01:20:32.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T14:44:52.000Z", "max_forks_repo_path": "include/geometry/correct.hpp", "max_forks_repo_name": "typebrook/tilemaker", "max_forks_repo_head_hexsha": "a8185978a0fd53a5c61404a3ae0b16ef119e1413", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 165.0, "max_forks_repo_forks_event_min_datetime": "2015-06-29T07:58:02.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T12:38:06.000Z", "avg_line_length": 33.5356321839, "max_line_length": 144, "alphanum_fraction": 0.6989306279, "num_tokens": 3844, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7634837635542924, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.4496072898748402}} {"text": "#include \"distribution_mixture_models.hxx\"\n\n#include \n#include \n#include \n\n\nnamespace vmf_fitting\n{\n\ntemplate\nvoid ExpApproximation(Eigen::Array &vals)\n{\n // From http://spfrnd.de/posts/2018-03-10-fast-exponential.html\n // It is also implemented in the supplemental code of the Vorba paper about gaussian mixtures for path guiding.\n // Eigen also does it this way by default but with more precision.\n\n static_assert(std::numeric_limits::is_iec559);\n static_assert(sizeof(float) == sizeof(std::uint32_t));\n constexpr int N = N_;\n constexpr float log2_e = 1.4426950408889634f;\n // This polynomial gives less than 0.3% relative error.\n constexpr float poly_coeffs[3] = { 0.34271437f, 0.6496069f , 1.f + 0.0036554f };\n constexpr uint32_t exp_mask = 255u << 23u;\n\n using FloatVals = Eigen::Array;\n using IntVals = Eigen::Array;\n\n vals *= log2_e;\n\n // Notes:\n // floor() needs some fancy instructions sets to be vectorized. Compilation with -march=core2 is not enough. corei7-avx works.\n // Apparently my CPU has it\n // https://ark.intel.com/content/www/us/en/ark/products/52214/intel-core-i7-2600k-processor-8m-cache-up-to-3-80-ghz.html\n // See also the Eigen manual https://eigen.tuxfamily.org/dox/group__CoeffwiseMathFunctions.html\n auto floored = vals.floor().eval();\n const IntVals xi = floored.template cast();\n const FloatVals xf = vals - floored;\n \n vals = xf*(xf*poly_coeffs[0] + poly_coeffs[1]) + poly_coeffs[2];\n\n // memcpy does actually copy stuff :-(\n //std::uint32_t int_view[N];\n //std::memcpy(int_view, vals.data(), N*sizeof(float));\n\n // This is UB afaik. But every reasonable compiler should do the right thing ...\n std::uint32_t* int_view = reinterpret_cast(vals.data());\n\n // Should be auto-vectorized. Clang 9 in compiler explorer can do it!\n for (int i=0; i::is_iec559);\n static_assert(sizeof(float) == sizeof(std::uint32_t));\n\n constexpr float log2_e = 1.4426950408889634f;\n constexpr float poly_coeffs[3] = { 0.34271437f, 0.6496069f , 1.f + 0.0036554f };\n constexpr uint32_t exp_mask = 255u << 23u;\n\n x *= log2_e;\n\n const float floored = std::floor(x);\n const int xi = int(floored);\n const float xf = x - floored;\n\n const float mantisse = xf*(xf*poly_coeffs[0] + poly_coeffs[1]) + poly_coeffs[2];\n\n std::uint32_t int_view;\n std::memcpy(&int_view, &mantisse, sizeof(float));\n\n int_view = (int_view & ~exp_mask) | ((((xi + 127)) << 23) & exp_mask);\n\n float result;\n std::memcpy(&result, &int_view, sizeof(float));\n\n return result;\n}\n\n\n\n\ntemplate\ninline Eigen::Array ComponentPdfs(const VonMisesFischerMixture & mixture, const Eigen::Vector3f & pos) noexcept\n{\n const auto& k = mixture.concentrations;\n assert((k >= K_THRESHOLD).all() && (k <= K_THRESHOLD_MAX).all());\n auto t1 = (-2.f*k).eval();\n ExpApproximation(t1);\n //assert(t1.isFinite().all());\n const auto prefactors = (float(Pi)*2.f*(1.f - t1)).eval();\n //assert((prefactors > -0.1f).all());\n //assert((prefactors > 0.f).all());\n auto t2 = (k*((mixture.means.matrix() * pos).array() - 1.f)).eval();\n ExpApproximation(t2);\n //assert(t2.isFinite().all());\n const auto result = (k / prefactors * t2).eval();\n assert(result.isFinite().all() && (result >= 0.f).all());\n return result;\n}\n\n\ntemplate\nfloat Pdf(const VonMisesFischerMixture & mixture, const Eigen::Vector3f & pos) noexcept\n{\n const auto component_pdfs = ComponentPdfs(mixture, pos);\n return (component_pdfs * mixture.weights).sum();\n}\n\n\nEigen::Vector3f Sample(const Eigen::Vector3f& mu, float k, float r1, float r2) noexcept\n{\n assert (k >= K_THRESHOLD);\n assert (k <= K_THRESHOLD_MAX);\n const float vx = std::cos((float)(Pi*2.)*r1);\n const float vy = std::sin((float)(Pi*2.)*r1);\n // if (!std::isfinite(vx) || !std::isfinite(vy))\n // std::cerr << \"Oh noz vx or vy are non-finite! \" << vx << \", \" << vy << std::endl;\n const float w = 1.f + std::log(r2 + (1.f - r2)*ExpApproximation(-2.f*k)) / k;\n // if (!std::isfinite(w))\n // std::cerr << \"Oh noz w is not finite! \" << w << std::endl;\n const float tmp = 1.f - w * w;\n // if (tmp < 0.f)\n // std::cerr << \"Oh noz tmp is negative! \" << std::setprecision(std::numeric_limits::digits10 + 1) << tmp << std::endl;\n const float rho = std::sqrt(std::max(0.f, tmp));\n // if (!std::isfinite(rho))\n // std::cerr << \"Oh noz rho is not finite! \" << rho << \", \" << w << std::endl;\n Eigen::Vector3f x{\n rho*vx, rho*vy, w\n };\n Eigen::Matrix3f frame = OrthogonalSystemZAligned(mu);\n // if (!frame.array().isFinite().all())\n // std::cerr << \"Oh noz the frame is not finite! \" << frame << \", mu = \" << mu << std::endl;\n return frame * x;\n}\n\n\ntemplate\nEigen::Vector3f Sample(const VonMisesFischerMixture & mixture, std::array rs) noexcept\n{\n const int idx = TowerSampling(mixture.weights.data(), (float)rs[0]);\n return Sample(mixture.means.row(idx).matrix(), mixture.concentrations[idx], (float)rs[1], (float)rs[2]);\n}\n\n\ntemplate\nvoid InitializeForUnitSphere(VonMisesFischerMixture & mixture) noexcept\n{\n assert (\"!Not implemented!\");\n}\n\n\ntemplate<>\nvoid InitializeForUnitSphere<2>(VonMisesFischerMixture<2> & mixture) noexcept\n{\n using MoVMF = VonMisesFischerMixture<2>;\n mixture.means <<\n -1., 0., 0.,\n 1., 0., 0.;\n mixture.concentrations = MoVMF::ConcArray::Constant(0.1f);\n mixture.weights = typename MoVMF::WeightArray(1.f / MoVMF::NUM_COMPONENTS);\n}\n\n\ntemplate<>\nvoid InitializeForUnitSphere<8>(VonMisesFischerMixture<8> & mixture) noexcept\n{\n using MoVMF = VonMisesFischerMixture<8>;\n mixture.means <<\n 0.66778004,0.73539025,0.11519922,\n -0.9836298,-0.008926501,0.1799797,\n -0.14629413,-0.7809748,0.60718733,\n 0.49043104,0.04368747,-0.87038434,\n -0.10088497,0.42765132,0.8982965,\n -0.35999632,-0.6945797,-0.62286574,\n -0.43178025,0.7588791,-0.48751223,\n 0.860208,-0.47938251,0.17388113;\n mixture.concentrations = MoVMF::ConcArray::Constant(2.f);\n mixture.weights = typename MoVMF::WeightArray(1.f / MoVMF::NUM_COMPONENTS);\n}\n\ntemplate<>\nvoid InitializeForUnitSphere<16>(VonMisesFischerMixture<16> & mixture) noexcept\n{\n using MoVMF = VonMisesFischerMixture<16>;\n mixture.means <<\n 0.49468744,-0.1440351,-0.8570521,\n 0.36735174,-0.8573688,-0.36051556,\n -0.40503788,-0.48854542,-0.772831,\n -0.32770208,-0.12784185,0.9360917,\n -0.46322507,-0.8861626,-0.011769729,\n -0.933043,0.16280192,-0.32082137,\n -0.4759586,0.8746706,-0.09173246,\n -0.2931369,0.36415973,-0.8840013,\n -0.9006278,-0.24284472,0.360411,\n -0.32578856,0.650924,0.685682,\n 0.5459307,0.11810207,0.8294646,\n 0.9575066,0.22513846,-0.18026012,\n 0.84576833,-0.47598344,0.24107178,\n 0.47158864,0.8217275,0.31995004,\n 0.12246728,-0.77039504,0.6256942,\n 0.34670526,0.77106386,-0.5340936;\n mixture.concentrations = MoVMF::ConcArray::Constant(5.f); \n mixture.weights = typename MoVMF::WeightArray(1.f / MoVMF::NUM_COMPONENTS);\n}\n\n\ntemplate\nVonMisesFischerMixture Product(const VonMisesFischerMixture &m1, const VonMisesFischerMixture &m2) noexcept\n{\n static constexpr int NM = N*M;\n VonMisesFischerMixture result;\n for (int i=0; i::WeightArray exponentials1 = 1.f+incremental::eps - (-2.f*m1.concentrations ).exp();\n const typename VonMisesFischerMixture::WeightArray exponentials2 = 1.f+incremental::eps - (-2.f*m2.concentrations ).exp();\n const typename VonMisesFischerMixture::WeightArray exponentialsk = 1.f+incremental::eps - (-2.f*result.concentrations).exp();\n\n for (int i=0; i\nvoid Normalize(VonMisesFischerMixture &mixture) noexcept\n{\n const float wsum = mixture.weights.sum();\n if (unlikely(wsum <= 0.f))\n {\n // Case may happen due to underflow in calculations with exponentials\n mixture.weights.setConstant(1.f/N);\n }\n else\n {\n mixture.weights /= wsum;\n }\n}\n\n\nnamespace incremental\n{\n\ntemplate\nvoid UpdateStatistics(VonMisesFischerMixture &mixture, Data &dta, const Params ¶ms, const Eigen::Vector3f &x, float weight) noexcept;\n\ntemplate\nvoid MaximizationStep(VonMisesFischerMixture &mixture, const Data &dta, const Params ¶ms) noexcept;\n\ntemplate\nvoid Fit(VonMisesFischerMixture &mixture, Data &dta, const Params ¶ms, Span data, Span data_weights) noexcept\n{\n assert(data.size() == data_weights.size());\n assert(params.prior_mode != nullptr);\n \n for (int i=0; i{};\n dta.avg_weights = backup;\n }\n }\n}\n\n\ntemplate\nvoid UpdateStatistics(VonMisesFischerMixture & mixture, Data &fitdata, const Params ¶ms, const Eigen::Vector3f & x, float weight) noexcept\n{\n Eigen::Array responsibilities = mixture.weights * ComponentPdfs(mixture, x) + eps;\n responsibilities /= responsibilities.sum();\n\n#if 0\n if (fitdata.data_count_weights == 0)\n fitdata.avg_weights = weight;\n else\n fitdata.avg_weights = Lerp(fitdata.avg_weights, weight, (float)std::pow(double(fitdata.data_count_weights), -0.75));\n\n if (fitdata.data_count == 0)\n {\n fitdata.avg_responsibilities_unweighted = responsibilities;\n fitdata.avg_responsibilities = weight * responsibilities;\n fitdata.avg_positions = weight*(responsibilities.matrix()*x.transpose()).array();\n }\n else\n {\n // How much to \"trust\" new data.\n const float mix_factor = (float)std::pow(double(fitdata.data_count), -0.75f);\n fitdata.avg_responsibilities_unweighted += mix_factor*(responsibilities - fitdata.avg_responsibilities_unweighted);\n fitdata.avg_responsibilities += mix_factor*(weight*responsibilities - fitdata.avg_responsibilities);\n fitdata.avg_positions += mix_factor*(weight*(responsibilities.matrix()*x.transpose()).array() - fitdata.avg_positions);\n }\n ++fitdata.data_count;\n ++fitdata.data_count_weights;\n#else\n fitdata.avg_weights += weight;\n fitdata.avg_responsibilities_unweighted += responsibilities;\n fitdata.avg_responsibilities += weight * responsibilities;\n fitdata.avg_positions += weight*(responsibilities.matrix()*x.transpose()).array();\n#endif\n} \n\n\ntemplate\nvoid MaximizationStep(VonMisesFischerMixture & mixture, const Data &dta, const Params ¶ms) noexcept\n{\n\n const std::uint64_t unique_data_count = dta.avg_responsibilities.Count();\n for (int k = 0; k < VonMisesFischerMixture::NUM_COMPONENTS; ++k)\n {\n const float scaled_responsibilities = dta.avg_responsibilities()[k] / (dta.avg_weights() + eps);\n\n // The eps is there in case both of the former terms evaluate to zero!\n mixture.weights[k] = (params.prior_nu-1)/unique_data_count*params.prior_mode->weights[k] + scaled_responsibilities + eps;\n\n { // Posterior of mean.\n const float diminished_prior_factor = dta.avg_weights() * params.prior_tau / unique_data_count;\n mixture.means.row(k) = (diminished_prior_factor*params.prior_mode->means.row(k) + dta.avg_positions().row(k)) /\n (diminished_prior_factor + dta.avg_responsibilities()[k] + eps);\n float norm = mixture.means.row(k).matrix().norm();\n if (norm > eps)\n mixture.means.row(k) /= norm;\n else\n mixture.means.row(k).matrix() = Eigen::Vector3f{1.f, 0.f, 0.f};\n }\n\n {\n #if 1\n // Note: Don't use avg_responsibilities_unweighted[k]*avg_weights here. It computes the average position wrong\n // in a way that mean_cosine is way overestimated.\n const float mean_cosine = (1.f/(dta.avg_responsibilities()[k] + eps)) * dta.avg_positions().row(k).matrix().norm();\n const float conc_estimate = MeanCosineToConc(mean_cosine);\n const float diminished_alpha = params.prior_alpha/unique_data_count;\n const float post_conc = \n (params.prior_mode->concentrations[k]*diminished_alpha + conc_estimate) / (diminished_alpha + 1.f);\n mixture.concentrations[k] = post_conc;\n #endif\n\n #if 0\n // This does not do percievably better than the simpler code above!!\n // Here the prior is on the mean cosine, forcing me to go back and forth with the cosine-k-conversions.\n const float prior_cos = ConcToMeanCos(params.prior_mode->concentrations[k]);\n const float mean_cosine = (1.f/(dta.avg_responsibilities()[k] + eps)) * dta.avg_positions().row(k).matrix().norm();\n const float diminished_alpha = params.prior_alpha/unique_data_count;\n const float mean_cosine_post = (diminished_alpha*prior_cos + mean_cosine) / (diminished_alpha + 1.f);\n mixture.concentrations[k] = MeanCosineToConc(mean_cosine_post);\n #endif\n }\n }\n\n mixture.concentrations = mixture.concentrations.max(K_THRESHOLD).min(K_THRESHOLD_MAX).eval();\n\n assert(mixture.weights.sum() > 0.f);\n mixture.weights /= mixture.weights.sum();\n}\n\n\n} // namespace incremental\n\n} // namespace vmf_fitting\n\n\n#define INSTANTIATE_VonMisesFischerMixture(n) \\\n template void vmf_fitting::incremental::Fit(VonMisesFischerMixture &mixture, Data &fitdata, const Params ¶ms, Span data, Span data_weights) noexcept; \\\n template float vmf_fitting::Pdf(const VonMisesFischerMixture &mixture, const Eigen::Vector3f &pos) noexcept; \\\n template Eigen::Vector3f vmf_fitting::Sample(const VonMisesFischerMixture &mixture, std::array rs) noexcept; \\\n template void vmf_fitting::InitializeForUnitSphere(VonMisesFischerMixture &mixture) noexcept; \\\n template void vmf_fitting::Normalize(VonMisesFischerMixture &mixture) noexcept; \\\n template void vmf_fitting::ExpApproximation(Eigen::Array &vals);\n\nINSTANTIATE_VonMisesFischerMixture(2)\nINSTANTIATE_VonMisesFischerMixture(8)\nINSTANTIATE_VonMisesFischerMixture(16)\n\ntemplate vmf_fitting::VonMisesFischerMixture<16> vmf_fitting::Product(const vmf_fitting::VonMisesFischerMixture<2> &m1, const vmf_fitting::VonMisesFischerMixture<8> &m2) noexcept;", "meta": {"hexsha": "f8f2e9c68cf2db705cb0f8c939e7d680784308ad", "size": 15840, "ext": "cxx", "lang": "C++", "max_stars_repo_path": "src/distribution_mixture_models.cxx", "max_stars_repo_name": "DaWelter/NaiveTrace", "max_stars_repo_head_hexsha": "a904785a0e13c394b2c221bc918cddb41bc8b175", "max_stars_repo_licenses": ["FSFAP"], "max_stars_count": 16.0, "max_stars_repo_stars_event_min_datetime": "2018-04-25T08:14:14.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-29T06:19:16.000Z", "max_issues_repo_path": "src/distribution_mixture_models.cxx", "max_issues_repo_name": "DaWelter/NaiveTrace", "max_issues_repo_head_hexsha": "a904785a0e13c394b2c221bc918cddb41bc8b175", "max_issues_repo_licenses": ["FSFAP"], "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/distribution_mixture_models.cxx", "max_forks_repo_name": "DaWelter/NaiveTrace", "max_forks_repo_head_hexsha": "a904785a0e13c394b2c221bc918cddb41bc8b175", "max_forks_repo_licenses": ["FSFAP"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.8235294118, "max_line_length": 205, "alphanum_fraction": 0.6906565657, "num_tokens": 4868, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7634837635542924, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.4496072898748402}} {"text": "/* +---------------------------------------------------------------------------+\n | Mobile Robot Programming Toolkit (MRPT) |\n | http://www.mrpt.org/ |\n | |\n | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file |\n | See: http://www.mrpt.org/Authors - All rights reserved. |\n | Released under BSD License. See details in http://www.mrpt.org/License |\n +---------------------------------------------------------------------------+ */\n\n#include \"vision-precomp.h\" // Precompiled headers\n\n#include \n#include \n#include \n\n\n// Opencv 2.3 had a broken in Ubuntu 14.04 Trusty => Disable PNP classes\n#include \n\n#if MRPT_HAS_OPENCV && MRPT_OPENCV_VERSION_NUM<0x240\n#\tundef MRPT_HAS_OPENCV\n#\tdefine MRPT_HAS_OPENCV 0\n#endif\n\n#include \n\n#include // Eigen must be included first via MRPT to enable the plugin system\n#include \n#include \n\n#include \n#if MRPT_HAS_OPENCV\n#\tinclude \n#endif\n\n#include \"dls.h\"\n#include \"epnp.h\"\n#include \"upnp.h\"\n#include \"p3p.h\"\n#include \"ppnp.h\"\n#include \"posit.h\"\n#include \"lhm.h\"\n#include \"rpnp.h\"\n#include \"so3.h\"\n\nbool mrpt::vision::pnp::CPnP::dls(const Eigen::Ref obj_pts, const Eigen::Ref img_pts, int n, const Eigen::Ref cam_intrinsic, Eigen::Ref pose_mat){\n try{\n #if MRPT_HAS_OPENCV==1\n\n // Input 2d/3d correspondences and camera intrinsic matrix\n Eigen::MatrixXd cam_in_eig,img_pts_eig, obj_pts_eig;\n\n // Check for consistency of input matrix dimensions\n if (img_pts.rows() != obj_pts.rows() || img_pts.cols() !=obj_pts.cols())\n throw(2);\n else if (cam_intrinsic.rows()!=3 || cam_intrinsic.cols()!=3)\n throw(3);\n\n if(obj_pts.rows() < obj_pts.cols())\n {\n cam_in_eig=cam_intrinsic.transpose();\n img_pts_eig=img_pts.transpose().block(0,0,n,2);\n obj_pts_eig=obj_pts.transpose();\n }\n else\n {\n cam_in_eig=cam_intrinsic;\n img_pts_eig=img_pts.block(0,0,n,2);\n obj_pts_eig=obj_pts;\n }\n\n // Output pose\n Eigen::Matrix3d R_eig;\n Eigen::MatrixXd t_eig;\n\n // Compute pose\n cv::Mat cam_in_cv(3,3,CV_32F), img_pts_cv(2,n,CV_32F), obj_pts_cv(3,n,CV_32F), R_cv(3,3,CV_32F), t_cv(3,1,CV_32F);\n\n cv::eigen2cv(cam_in_eig, cam_in_cv);\n cv::eigen2cv(img_pts_eig, img_pts_cv);\n cv::eigen2cv(obj_pts_eig, obj_pts_cv);\n\n mrpt::vision::pnp::dls d(obj_pts_cv, img_pts_cv);\n bool ret = d.compute_pose(R_cv,t_cv);\n\n cv::cv2eigen(R_cv, R_eig);\n cv::cv2eigen(t_cv, t_eig);\n\n Eigen::Quaterniond q(R_eig);\n\n pose_mat << t_eig,q.vec();\n\n return ret;\n\n #else\n\t\tthrow(-1);\n #endif\n }\n catch(int e)\n {\n switch(e)\n {\n case -1: std::cout << \"Please install OpenCV for DLS-PnP\" << std::endl;\n case 2: std::cout << \"2d/3d correspondences mismatch\\n Check dimension of obj_pts and img_pts\" << std::endl;\n case 3: std::cout << \"Camera intrinsic matrix does not have 3x3 dimensions \" << std::endl;\n }\n return false;\n }\n}\n\nbool mrpt::vision::pnp::CPnP::epnp(const Eigen::Ref obj_pts, const Eigen::Ref img_pts, int n, const Eigen::Ref cam_intrinsic, Eigen::Ref pose_mat){\n try{\n #if MRPT_HAS_OPENCV==1\n\n // Input 2d/3d correspondences and camera intrinsic matrix\n Eigen::MatrixXd cam_in_eig,img_pts_eig, obj_pts_eig;\n\n // Check for consistency of input matrix dimensions\n if (img_pts.rows() != obj_pts.rows() || img_pts.cols() !=obj_pts.cols())\n throw(2);\n else if (cam_intrinsic.rows()!=3 || cam_intrinsic.cols()!=3)\n throw(3);\n\n if(obj_pts.rows() < obj_pts.cols())\n {\n cam_in_eig=cam_intrinsic.transpose();\n img_pts_eig=img_pts.transpose().block(0,0,n,2);\n obj_pts_eig=obj_pts.transpose();\n }\n else\n {\n cam_in_eig=cam_intrinsic;\n img_pts_eig=img_pts.block(0,0,n,2);\n obj_pts_eig=obj_pts;\n }\n\n // Output pose\n Eigen::Matrix3d R_eig;\n Eigen::MatrixXd t_eig;\n\n // Compute pose\n cv::Mat cam_in_cv(3,3,CV_32F), img_pts_cv(2,n,CV_32F), obj_pts_cv(3,n,CV_32F), R_cv, t_cv;\n\n cv::eigen2cv(cam_in_eig, cam_in_cv);\n cv::eigen2cv(img_pts_eig, img_pts_cv);\n cv::eigen2cv(obj_pts_eig, obj_pts_cv);\n\n mrpt::vision::pnp::epnp e(cam_in_cv, obj_pts_cv, img_pts_cv);\n e.compute_pose(R_cv,t_cv);\n\n cv::cv2eigen(R_cv, R_eig);\n cv::cv2eigen(t_cv, t_eig);\n\n Eigen::Quaterniond q(R_eig);\n\n pose_mat << t_eig,q.vec();\n\n return true;\n\n #else\n throw(-1);\n #endif\n }\n catch(int e){\n switch(e)\n {\n case -1: std::cout << \"Please install OpenCV for DLS-PnP\" << std::endl;\n case 2: std::cout << \"2d/3d correspondences mismatch\\n Check dimension of obj_pts and img_pts\" << std::endl;\n case 3: std::cout << \"Camera intrinsic matrix does not have 3x3 dimensions \" << std::endl;\n }\n return false;\n }\n}\n\nbool mrpt::vision::pnp::CPnP::upnp(const Eigen::Ref obj_pts, const Eigen::Ref img_pts, int n, const Eigen::Ref cam_intrinsic, Eigen::Ref pose_mat){\n try{\n #if MRPT_HAS_OPENCV==1\n\n // Input 2d/3d correspondences and camera intrinsic matrix\n Eigen::MatrixXd cam_in_eig,img_pts_eig, obj_pts_eig;\n\n // Check for consistency of input matrix dimensions\n if (img_pts.rows() != obj_pts.rows() || img_pts.cols() !=obj_pts.cols())\n throw(2);\n else if (cam_intrinsic.rows()!=3 || cam_intrinsic.cols()!=3)\n throw(3);\n\n if(obj_pts.rows() < obj_pts.cols())\n {\n cam_in_eig=cam_intrinsic.transpose();\n img_pts_eig=img_pts.transpose().block(0,0,n,2);\n obj_pts_eig=obj_pts.transpose();\n }\n else\n {\n cam_in_eig=cam_intrinsic;\n img_pts_eig=img_pts.block(0,0,n,2);\n obj_pts_eig=obj_pts;\n }\n\n // Output pose\n Eigen::Matrix3d R_eig;\n Eigen::MatrixXd t_eig;\n\n // Compute pose\n cv::Mat cam_in_cv(3,3,CV_32F), img_pts_cv(2,n,CV_32F), obj_pts_cv(3,n,CV_32F), R_cv, t_cv;\n\n cv::eigen2cv(cam_in_eig, cam_in_cv);\n cv::eigen2cv(img_pts_eig, img_pts_cv);\n cv::eigen2cv(obj_pts_eig, obj_pts_cv);\n\n mrpt::vision::pnp::upnp u(cam_in_cv, obj_pts_cv, img_pts_cv);\n u.compute_pose(R_cv,t_cv);\n\n cv::cv2eigen(R_cv, R_eig);\n cv::cv2eigen(t_cv, t_eig);\n\n Eigen::Quaterniond q(R_eig);\n\n pose_mat << t_eig,q.vec();\n\n return true;\n #else\n throw(-1);\n #endif\n }\n catch(int e)\n {\n switch(e)\n {\n case -1: std::cout << \"Please install OpenCV for DLS-PnP\" << std::endl;\n case 2: std::cout << \"2d/3d correspondences mismatch\\n Check dimension of obj_pts and img_pts\" << std::endl;\n case 3: std::cout << \"Camera intrinsic matrix does not have 3x3 dimensions \" << std::endl;\n }\n return false;\n }\n}\n\n\nbool mrpt::vision::pnp::CPnP::p3p(const Eigen::Ref obj_pts, const Eigen::Ref img_pts, int n, const Eigen::Ref cam_intrinsic, Eigen::Ref pose_mat){\n\n try{\n // Input 2d/3d correspondences and camera intrinsic matrix\n Eigen::MatrixXd cam_in_eig,img_pts_eig, obj_pts_eig;\n\n // Check for consistency of input matrix dimensions\n if (img_pts.rows() != obj_pts.rows() || img_pts.cols() !=obj_pts.cols())\n throw(2);\n else if (cam_intrinsic.rows()!=3 || cam_intrinsic.cols()!=3)\n throw(3);\n\n if(obj_pts.rows() < obj_pts.cols())\n {\n cam_in_eig=cam_intrinsic.transpose();\n img_pts_eig=img_pts.transpose().block(0,0,n,2);\n obj_pts_eig=obj_pts.transpose();\n }\n else\n {\n cam_in_eig=cam_intrinsic;\n img_pts_eig=img_pts.block(0,0,n,2);\n obj_pts_eig=obj_pts;\n }\n\n // Output pose\n Eigen::Matrix3d R;\n Eigen::Vector3d t;\n\n // Compute pose\n mrpt::vision::pnp::p3p p(cam_in_eig);\n bool ret = p.solve(R,t, obj_pts_eig, img_pts_eig);\n\n Eigen::Quaterniond q(R);\n\n pose_mat << t,q.vec();\n\n return ret;\n }\n catch(int e)\n {\n switch(e)\n {\n case 2: std::cout << \"2d/3d correspondences mismatch\\n Check dimension of obj_pts and img_pts\" << std::endl;\n case 3: std::cout << \"Camera intrinsic matrix does not have 3x3 dimensions \" << std::endl;\n }\n return false;\n }\n}\n\n\nbool mrpt::vision::pnp::CPnP::rpnp(const Eigen::Ref obj_pts, const Eigen::Ref img_pts, int n, const Eigen::Ref cam_intrinsic, Eigen::Ref pose_mat){\n try{\n // Input 2d/3d correspondences and camera intrinsic matrix\n Eigen::MatrixXd cam_in_eig,img_pts_eig, obj_pts_eig;\n\n // Check for consistency of input matrix dimensions\n if (img_pts.rows() != obj_pts.rows() || img_pts.cols() !=obj_pts.cols())\n throw(2);\n else if (cam_intrinsic.rows()!=3 || cam_intrinsic.cols()!=3)\n throw(3);\n\n if(obj_pts.rows() < obj_pts.cols())\n {\n cam_in_eig=cam_intrinsic.transpose();\n img_pts_eig=img_pts.transpose();\n obj_pts_eig=obj_pts.transpose();\n }\n else\n {\n cam_in_eig=cam_intrinsic;\n img_pts_eig=img_pts;\n obj_pts_eig=obj_pts;\n }\n\n // Output pose\n Eigen::Matrix3d R;\n Eigen::Vector3d t;\n\n // Compute pose\n mrpt::vision::pnp::rpnp r(obj_pts_eig, img_pts_eig, cam_in_eig, n);\n bool ret = r.compute_pose(R,t);\n\n Eigen::Quaterniond q(R);\n\n pose_mat << t,q.vec();\n\n return ret;\n }\n catch(int e)\n {\n switch(e)\n {\n case 2: std::cout << \"2d/3d correspondences mismatch\\n Check dimension of obj_pts and img_pts\" << std::endl;\n case 3: std::cout << \"Camera intrinsic matrix does not have 3x3 dimensions \" << std::endl;\n }\n return false;\n }\n}\n\nbool mrpt::vision::pnp::CPnP::ppnp(const Eigen::Ref obj_pts, const Eigen::Ref img_pts, int n, const Eigen::Ref cam_intrinsic, Eigen::Ref pose_mat)\n{\n\ttry{\n // Input 2d/3d correspondences and camera intrinsic matrix\n Eigen::MatrixXd cam_in_eig,img_pts_eig, obj_pts_eig;\n\n // Check for consistency of input matrix dimensions\n if (img_pts.rows() != obj_pts.rows() || img_pts.cols() !=obj_pts.cols())\n throw(2);\n else if (cam_intrinsic.rows()!=3 || cam_intrinsic.cols()!=3)\n throw(3);\n\n if(obj_pts.rows() < obj_pts.cols())\n {\n cam_in_eig=cam_intrinsic.transpose();\n img_pts_eig=img_pts.transpose();\n obj_pts_eig=obj_pts.transpose();\n }\n else\n {\n cam_in_eig=cam_intrinsic;\n img_pts_eig=img_pts;\n obj_pts_eig=obj_pts;\n }\n\n // Output pose\n Eigen::Matrix3d R;\n Eigen::Vector3d t;\n\n // Compute pose\n mrpt::vision::pnp::ppnp p(obj_pts_eig,img_pts_eig, cam_in_eig);\n\n bool ret = p.compute_pose(R,t,n);\n\n Eigen::Quaterniond q(R);\n\n pose_mat << t,q.vec();\n\n return ret;\n }\n catch(int e)\n {\n switch(e)\n {\n case 2: std::cout << \"2d/3d correspondences mismatch\\n Check dimension of obj_pts and img_pts\" << std::endl;\n case 3: std::cout << \"Camera intrinsic matrix does not have 3x3 dimensions \" << std::endl;\n }\n return false;\n }\n}\n\nbool mrpt::vision::pnp::CPnP::posit(const Eigen::Ref obj_pts, const Eigen::Ref img_pts, int n, const Eigen::Ref cam_intrinsic, Eigen::Ref pose_mat)\n{\n\ttry{\n // Input 2d/3d correspondences and camera intrinsic matrix\n Eigen::MatrixXd cam_in_eig,img_pts_eig, obj_pts_eig;\n\n // Check for consistency of input matrix dimensions\n if (img_pts.rows() != obj_pts.rows() || img_pts.cols() !=obj_pts.cols())\n throw(2);\n else if (cam_intrinsic.rows()!=3 || cam_intrinsic.cols()!=3)\n throw(3);\n\n if(obj_pts.rows() < obj_pts.cols())\n {\n cam_in_eig=cam_intrinsic.transpose();\n img_pts_eig=img_pts.transpose().block(0,0,n,2);\n obj_pts_eig=obj_pts.transpose();\n }\n else\n {\n cam_in_eig=cam_intrinsic;\n img_pts_eig=img_pts.block(0,0,n,2);\n obj_pts_eig=obj_pts;\n }\n\n // Output pose\n Eigen::Matrix3d R;\n Eigen::Vector3d t;\n\n // Compute pose\n mrpt::vision::pnp::posit p(obj_pts_eig,img_pts_eig, cam_in_eig, n);\n\n bool ret = p.compute_pose(R,t);\n\n Eigen::Quaterniond q(R);\n\n pose_mat << t,q.vec();\n\n return ret;\n }\n catch(int e)\n {\n switch(e)\n {\n case 2: std::cout << \"2d/3d correspondences mismatch\\n Check dimension of obj_pts and img_pts\" << std::endl;\n case 3: std::cout << \"Camera intrinsic matrix does not have 3x3 dimensions \" << std::endl;\n }\n return false;\n }\n\n}\n\nbool mrpt::vision::pnp::CPnP::lhm(const Eigen::Ref obj_pts, const Eigen::Ref img_pts, int n, const Eigen::Ref cam_intrinsic, Eigen::Ref pose_mat)\n{\n try{\n // Input 2d/3d correspondences and camera intrinsic matrix\n Eigen::MatrixXd cam_in_eig,img_pts_eig, obj_pts_eig;\n\n // Check for consistency of input matrix dimensions\n if (img_pts.rows() != obj_pts.rows() || img_pts.cols() !=obj_pts.cols())\n throw(2);\n else if (cam_intrinsic.rows()!=3 || cam_intrinsic.cols()!=3)\n throw(3);\n\n if(obj_pts.rows() < obj_pts.cols())\n {\n cam_in_eig=cam_intrinsic.transpose();\n img_pts_eig=img_pts.transpose();\n obj_pts_eig=obj_pts.transpose();\n }\n else\n {\n cam_in_eig=cam_intrinsic;\n img_pts_eig=img_pts;\n obj_pts_eig=obj_pts;\n }\n\n // Output pose\n Eigen::Matrix3d R;\n Eigen::Vector3d t;\n\n // Compute pose\n mrpt::vision::pnp::lhm l(obj_pts_eig, img_pts_eig, cam_intrinsic, n);\n\n bool ret = l.compute_pose(R,t);\n\n Eigen::Quaterniond q(R);\n\n pose_mat< obj_pts, const Eigen::Ref img_pts, int n, const Eigen::Ref cam_intrinsic, Eigen::Ref pose_mat)\n{\n try{\n // Input 2d/3d correspondences and camera intrinsic matrix\n Eigen::MatrixXd cam_in_eig,img_pts_eig, obj_pts_eig;\n\n // Check for consistency of input matrix dimensions\n if (img_pts.rows() != obj_pts.rows() || img_pts.cols() !=obj_pts.cols())\n throw(2);\n else if (cam_intrinsic.rows()!=3 || cam_intrinsic.cols()!=3)\n throw(3);\n\n if(obj_pts.rows() < obj_pts.cols())\n {\n cam_in_eig=cam_intrinsic.transpose();\n img_pts_eig=img_pts.transpose().block(0,0,n,2);\n obj_pts_eig=obj_pts.transpose();\n }\n else\n {\n cam_in_eig=cam_intrinsic;\n img_pts_eig=img_pts.block(0,0,n,2);\n obj_pts_eig=obj_pts;\n }\n\n // Output pose\n Eigen::Matrix3d R;\n Eigen::Vector3d t;\n\n // Compute pose\n mrpt::vision::pnp::p3p p(cam_in_eig);\n p.solve(R,t, obj_pts_eig, img_pts_eig);\n\n mrpt::vision::pnp::so3 s(obj_pts_eig, img_pts_eig, cam_in_eig, n);\n bool ret = s.compute_pose(R,t);\n\n Eigen::Quaterniond q(R);\n\n pose_mat<\n#include \n#include \n//#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\ntemplate struct synchronousPhaseFunctor {\n synchronousPhaseFunctor(T const &target, std::vector &voltages,\n std::vector &harmonicNumbers, float charge)\n : U0(target), volts(voltages), hs(harmonicNumbers), ch(charge) {}\n std::tuple operator()(T const &phi) {\n T volt1, volt2, volt3;\n T dvolt1, dvolt2, dvolt3;\n volt1 = ch * volts[0] * sin(phi);\n volt2 = ch * volts[1] * sin((hs[1] / hs[0]) * phi);\n volt3 = ch * volts[2] * sin((hs[2] / hs[0]) * phi);\n\n dvolt1 = ch * volts[0] * cos(phi);\n dvolt2 = ch * volts[1] * (hs[1] / hs[0]) * cos((hs[1] / hs[0]) * phi);\n dvolt3 = ch * volts[2] * (hs[2] / hs[0]) * cos((hs[2] / hs[0]) * phi);\n std::tuple out = {volt1 + volt2 + volt3 - U0,\n dvolt1 + dvolt2 + dvolt3};\n return out;\n }\n\nprivate:\n T U0;\n std::vector volts;\n std::vector hs;\n double ch;\n};\n\ntemplate \nT synchronousPhaseFunctorDeriv(T x, std::vector &voltages,\n std::vector &harmnumbers, double charge,\n T guess, T min, T max) {\n // return cube root of x using 1st derivative and Newton_Raphson.\n using namespace boost::math::tools;\n\n const int digits =\n std::numeric_limits::digits; // Maximum possible binary digits accuracy\n // for type T.\n int get_digits = static_cast(\n digits * 0.6); // Accuracy doubles with each step, so stop when we have\n // just over half the digits correct.\n const boost::uintmax_t maxit = 20;\n boost::uintmax_t it = maxit;\n T result = newton_raphson_iterate(\n synchronousPhaseFunctor(x, voltages, harmnumbers, charge), guess, min,\n max, get_digits, it);\n return result;\n}\ndouble pcoeff(double voltage, double angularFreq, double p0,\n double betaRelativistic, double charge) {\n return (angularFreq * voltage * charge) / (2.0 * pi * p0 * betaRelativistic);\n}\n\ndouble HamiltonianTripleRf(double tcoeff, std::vector &voltages,\n std::vector &harmonicNumbers,\n double phiSynchronous, double t, double delta,\n double omega0, double p0, double betaRelativistic,\n double charge) {\n double kinetic, potential1, potential2, potential3;\n kinetic = 0.5 * tcoeff * pow(delta, 2);\n\n std::printf(\"%-30s %16.8e\\n\", \"kinetic\", kinetic);\n potential1 = pcoeff(voltages[0], omega0, p0, betaRelativistic, charge) *\n (cos(harmonicNumbers[0] * omega0 * t) - cos(phiSynchronous) +\n (harmonicNumbers[0] * omega0 * t - phiSynchronous) *\n sin(phiSynchronous));\n std::printf(\"%-30s %16.8e\\n\", \"pcoeff0\",\n pcoeff(voltages[0], omega0, p0, betaRelativistic, charge));\n std::printf(\"%-30s %16.8e\\n\", \"phase0\", harmonicNumbers[0] * omega0 * t);\n std::printf(\"%-30s %16.8e\\n\", \"potential1\", potential1);\n\n potential2 =\n pcoeff(voltages[1], omega0, p0, betaRelativistic, charge) *\n (harmonicNumbers[0] / harmonicNumbers[1]) *\n (cos(harmonicNumbers[1] * omega0 * t) -\n cos(harmonicNumbers[1] * phiSynchronous / harmonicNumbers[0]) +\n (harmonicNumbers[1] * omega0 * t -\n harmonicNumbers[1] * phiSynchronous / harmonicNumbers[0]) *\n sin(harmonicNumbers[1] * phiSynchronous / harmonicNumbers[0]));\n\n potential3 =\n pcoeff(voltages[2], omega0, p0, betaRelativistic, charge) *\n (harmonicNumbers[0] / harmonicNumbers[2]) *\n (cos(harmonicNumbers[2] * omega0 * t) -\n cos(harmonicNumbers[2] * phiSynchronous / harmonicNumbers[0]) +\n (harmonicNumbers[2] * omega0 * t -\n harmonicNumbers[2] * phiSynchronous / harmonicNumbers[0]) *\n sin(harmonicNumbers[2] * phiSynchronous / harmonicNumbers[0]));\n\n return kinetic + potential1 + potential2 + potential3;\n};\n\ndouble synchrotronTune(std::map &twissheadermap,\n std::vector h, std::vector v) {\n double p0 = twissheadermap[\"PC\"] * 1.0e9;\n double phis = twissheadermap[\"phis\"];\n double charge = twissheadermap[\"CHARGE\"];\n double Omega2 =\n (h[0] * twissheadermap[\"eta\"] * charge) / (2.0 * pi * p0) *\n (v[0] * cos(phis) + v[1] * (h[1] / h[0]) * cos((h[1] / h[0]) * phis) +\n v[2] * (h[2] / h[0]) * cos((h[2] / h[0]) * phis));\n return sqrt(abs(Omega2));\n};\n\nint main() {\n string twissfilename = \"../src/b2_design_lattice_1996.twiss\";\n map twissheadermap;\n twissheadermap = GetTwissHeader(twissfilename);\n\n // rf settings\n std::vector h, v;\n h.push_back(400.0);\n v.push_back(-1.5e6);\n\n // bunch length\n double sigs = 0.005;\n // aatom\n double aatom = emass / pmass;\n // set energy loss per turn manually\n // TODO: implement radiation update of twiss\n twissheadermap[\"U0\"] = 174e3;\n // update twiss header with long parameters\n ste_longitudinal::updateTwissHeaderLong(twissheadermap, h, v, aatom, sigs);\n\n double energyLostPerTurn = 174000; // radation losses per turn per particle\n double acceleratorLength = 240.00839; // length in meter\n double gammar = twissheadermap[\"GAMMA\"]; // relativistic gamma\n // double eta = 0.0007038773471 -\n // 1 / pow(gammar, 2); // slip factor approx alpha - 1/ gammar**2\n double betar = twissheadermap[\"betar\"]; // relativistic beta\n double trev = twissheadermap[\"trev\"];\n double h0 = 400.0;\n double h1 = 400; // 1200.0;\n double h2 = 400; // 1400.0;\n double v0 = -1.5e6;\n double v1 = 0.0; // 20.0e6;\n double v2 = 0.0; // 17.14e6;\n double omega0 = (2 * pi) / trev;\n double p0 = 1.7e9;\n double charge = -1.0;\n std::vector hnumbers = {h0, h1, h2};\n std::vector voltages = {v0, v1, v2};\n\n double search1 =\n trev * h0 * omega0 /\n (8 * max(max(h0, h1), h2)); // give positive offset to find upstream\n // root and not downstream root\n double search2 = trev * h0 * omega0 / (8 * max(max(h0, h1), h2)) -\n trev * h0 * omega0 / min(min(h0, h1), h2);\n double searchWidth = trev * h0 * omega0 / (2 * max(max(h0, h1), h2));\n ste_output::cyan();\n std::printf(\"%-30s : %16.6f\\n\", \"Search1\", search1 / pi * 180);\n std::printf(\"%-30s : %16.6f\\n\", \"Search2\", search2 / pi * 180);\n std::printf(\"%-30s : %16.6f\\n\", \"Width\", searchWidth / pi * 180);\n ste_output::reset();\n\n double synchronousPhase0 = synchronousPhaseFunctorDeriv(\n energyLostPerTurn, voltages, hnumbers, charge, search1,\n search1 - searchWidth, search1 + searchWidth);\n double synchronousPhase1 = synchronousPhaseFunctorDeriv(\n energyLostPerTurn, voltages, hnumbers, charge, search2,\n search2 - searchWidth, search2 + searchWidth);\n\n ste_output::blue();\n std::printf(\"%-30s : %16.6f %16.6f %16.6e \\n\", \"synchronous phase\", search1,\n synchronousPhase0 / pi * 180, synchronousPhase0 / (h0 * omega0));\n std::printf(\"%-30s : %16.6f %16.6f %16.6e \\n\", \"synchronous phase\", search2,\n synchronousPhase1 / pi * 180, synchronousPhase1 / (h0 * omega0));\n ste_output::yellow();\n std::printf(\"%-30s : %16.6f %16.6f %16.6e\\n\", \"synchronous phase\", 173.0,\n twissheadermap[\"phis\"],\n twissheadermap[\"phis\"] / 180.0 * pi / (h0 * omega0));\n ste_output::reset();\n\n std::cout << \"Find next extremum of Hamiltonian\" << std::endl;\n\n double synchronousPhase0Next = synchronousPhaseFunctorDeriv(\n energyLostPerTurn, voltages, hnumbers, charge, search1 + searchWidth,\n search1 + searchWidth / 2, search1 + 2 * searchWidth);\n double synchronousPhase1Next = synchronousPhaseFunctorDeriv(\n energyLostPerTurn, voltages, hnumbers, charge, search2 + searchWidth,\n search2 + searchWidth / 2, search2 + 2 * searchWidth);\n\n ste_output::blue();\n std::printf(\"%-30s : %16.6f %16.6f %16.6e \\n\", \"synchronous phase next\",\n search1 + searchWidth, synchronousPhase0Next / pi * 180,\n synchronousPhase0Next / (h0 * omega0));\n std::printf(\"%-30s : %16.6f %16.6f %16.6e \\n\", \"synchronous phase next \",\n search2 + searchWidth, synchronousPhase1Next / pi * 180,\n synchronousPhase1Next / (h0 * omega0));\n ste_output::yellow();\n std::printf(\"%-30s : %16.6f\\n\", \"synchronous phase\", twissheadermap[\"phis\"]);\n ste_output::reset();\n\n std::printf(\"%s\", \"\\nHamiltonians\\n\");\n ste_output::blue();\n double tc = ste_longitudinal::tcoeff(twissheadermap, h0);\n double tcval = tc / (h0 * omega0);\n double ohammax = HamiltonianTripleRf(\n tcval, voltages, hnumbers, synchronousPhase1,\n synchronousPhase1Next / (h0 * omega0), 0.0, omega0, p0, betar, charge);\n double hammax =\n ste_longitudinal::Hamiltonian(twissheadermap, hnumbers, voltages, tc,\n synchronousPhase1Next / (h0 * omega0), 0.0);\n std::printf(\"%-30s : %16.6f \\n\", \"tcoeff\", tcval);\n std::printf(\"%-30s : %16.6f \\n\", \"ohammax\", ohammax);\n ste_output::yellow();\n std::printf(\"%-30s : %16.6f \\n\", \"hammax\", hammax);\n ste_output::reset();\n\n std::cout << \"Synchrotron tune : \"\n << synchrotronTune(twissheadermap, hnumbers, voltages) << std::endl;\n std::cout << \"Synchrotron tune (Hz): \"\n << synchrotronTune(twissheadermap, hnumbers, voltages) * omega0 /\n (2.0 * pi)\n << std::endl;\n std::printf(\"%-30s : %16.6f \\n\", \"syncTune\",\n synchrotronTune(twissheadermap, hnumbers, voltages));\n std::printf(\"%-30s : %16.6f \\n\", \"syncTune Hz\",\n synchrotronTune(twissheadermap, hnumbers, voltages) * omega0 /\n (2.0 * pi));\n ste_output::yellow();\n std::printf(\"%-30s : %16.6f \\n\", \"syncTune\", twissheadermap[\"qs\"]);\n std::printf(\"%-30s : %16.6f \\n\", \"syncTune Hz\",\n twissheadermap[\"qs\"] * omega0 / (2.0 * pi));\n ste_output::reset();\n\n std::printf(\"%16.6e %16.6e %16.6e %16.6e %16.6e\\n\", synchronousPhase0Next,\n synchronousPhase0,\n abs((synchronousPhase0Next - synchronousPhase0) / pi * 180.0), h0,\n omega0);\n std::printf(\"%-30s : %16.6e \\n\", \"tauhat\",\n abs((synchronousPhase0Next - synchronousPhase0) / (h0 * omega0)));\n ste_output::yellow();\n std::printf(\"%-30s : %16.6e \\n\", \"tauhat\", twissheadermap[\"tauhat\"]);\n std::printf(\"%-30s : %16.6e \\n\", \"tauhat\",\n (twissheadermap[\"phis\"] - (twissheadermap[\"phis\"] - 180.0)) /\n 180.0 * pi / (h0 * omega0));\n ste_output::reset();\n return 0;\n}", "meta": {"hexsha": "30808bd0ddc8a5566bf0959da3e8586ed013a953", "size": 10808, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "cpp/tests/src/origcodetest.cpp", "max_stars_repo_name": "tomerten/steibs", "max_stars_repo_head_hexsha": "8d4e994020dd17475ba1371e9c6f365c916828a0", "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/tests/src/origcodetest.cpp", "max_issues_repo_name": "tomerten/steibs", "max_issues_repo_head_hexsha": "8d4e994020dd17475ba1371e9c6f365c916828a0", "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/tests/src/origcodetest.cpp", "max_forks_repo_name": "tomerten/steibs", "max_forks_repo_head_hexsha": "8d4e994020dd17475ba1371e9c6f365c916828a0", "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.0597609562, "max_line_length": 80, "alphanum_fraction": 0.6098260548, "num_tokens": 3406, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789040926008, "lm_q2_score": 0.5544704649604273, "lm_q1q2_score": 0.4493866147928419}} {"text": "/* =========================================================================\n Copyright (c) 2010-2012, 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// *** System\n//\n#include \n\n//\n// *** Boost\n//\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n//\n// *** ViennaCL\n//\n//#define VIENNACL_DEBUG_ALL\n#define VIENNACL_HAVE_UBLAS 1\n#include \"viennacl/scalar.hpp\"\n#include \"viennacl/matrix.hpp\"\n#include \"viennacl/vector.hpp\"\n#include \"viennacl/linalg/prod.hpp\"\n#include \"viennacl/linalg/norm_2.hpp\"\n#include \"viennacl/linalg/direct_solve.hpp\"\n#include \"viennacl/linalg/lu.hpp\"\n#include \"examples/tutorial/Random.hpp\"\n\n//\n// -------------------------------------------------------------\n//\nusing namespace boost::numeric;\n//\n// -------------------------------------------------------------\n//\ntemplate \nScalarType diff(ScalarType & s1, viennacl::scalar & s2) \n{\n viennacl::backend::finish();\n if (s1 != s2)\n return (s1 - s2) / std::max(fabs(s1), fabs(s2));\n return 0;\n}\n\ntemplate \nScalarType diff(ublas::vector const & v1, VCLVectorType const & v2)\n{\n ublas::vector v2_cpu(v2.size());\n viennacl::backend::finish(); //workaround for a bug in APP SDK 2.7 on Trinity APUs (with Catalyst 12.8)\n viennacl::copy(v2.begin(), v2.end(), v2_cpu.begin());\n\n for (unsigned int i=0;i 0 )\n v2_cpu[i] = fabs(v2_cpu[i] - v1[i]) / std::max( fabs(v2_cpu[i]), fabs(v1[i]) );\n else\n v2_cpu[i] = 0.0;\n }\n\n return norm_inf(v2_cpu);\n}\n\ntemplate \nScalarType diff(ublas::matrix const & mat1, VCLMatrixType const & mat2)\n{\n ublas::matrix mat2_cpu(mat2.size1(), mat2.size2());\n viennacl::backend::finish(); //workaround for a bug in APP SDK 2.7 on Trinity APUs (with Catalyst 12.8)\n viennacl::copy(mat2, mat2_cpu);\n ScalarType ret = 0;\n ScalarType act = 0;\n\n for (unsigned int i = 0; i < mat2_cpu.size1(); ++i)\n {\n for (unsigned int j = 0; j < mat2_cpu.size2(); ++j)\n {\n act = fabs(mat2_cpu(i,j) - mat1(i,j)) / std::max( fabs(mat2_cpu(i, j)), fabs(mat1(i,j)) );\n if (act > ret)\n ret = act;\n }\n }\n //std::cout << ret << std::endl;\n return ret;\n}\n//\n// -------------------------------------------------------------\n//\n\ntemplate \nint test_prod_rank1(Epsilon const & epsilon,\n UblasMatrixType & ublas_m1, UblasVectorType & ublas_v1, UblasVectorType & ublas_v2, \n VCLMatrixType & vcl_m1, VCLVectorType1 & vcl_v1, VCLVectorType2 & vcl_v2)\n{\n int retval = EXIT_SUCCESS;\n \n // sync data:\n viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());\n viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());\n viennacl::copy(ublas_m1, vcl_m1);\n \n // -------------------------------------------------------------------------- \n std::cout << \"Rank 1 update\" << std::endl;\n \n ublas_m1 += ublas::outer_prod(ublas_v1, ublas_v2);\n vcl_m1 += viennacl::linalg::outer_prod(vcl_v1, vcl_v2);\n if( fabs(diff(ublas_m1, vcl_m1)) > epsilon )\n {\n std::cout << \"# Error at operation: rank 1 update\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_m1, vcl_m1)) << std::endl;\n return EXIT_FAILURE;\n }\n \n \n \n // -------------------------------------------------------------------------- \n std::cout << \"Scaled rank 1 update\" << std::endl;\n ublas_m1 += NumericT(4.2) * ublas::outer_prod(ublas_v1, ublas_v2);\n vcl_m1 += NumericT(2.1) * viennacl::linalg::outer_prod(vcl_v1, vcl_v2);\n vcl_m1 += viennacl::linalg::outer_prod(vcl_v1, vcl_v2) * NumericT(2.1); //check proper compilation\n if( fabs(diff(ublas_m1, vcl_m1)) > epsilon )\n {\n std::cout << \"# Error at operation: scaled rank 1 update\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_m1, vcl_m1)) << std::endl;\n return EXIT_FAILURE;\n }\n \n //reset vcl_matrix:\n viennacl::copy(ublas_m1, vcl_m1);\n \n // -------------------------------------------------------------------------- \n std::cout << \"Matrix-Vector product\" << std::endl;\n ublas_v1 = viennacl::linalg::prod(ublas_m1, ublas_v2);\n vcl_v1 = viennacl::linalg::prod(vcl_m1, vcl_v2);\n \n if( fabs(diff(ublas_v1, vcl_v1)) > epsilon )\n {\n std::cout << \"# Error at operation: matrix-vector product\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_v1, vcl_v1)) << std::endl;\n retval = EXIT_FAILURE;\n }\n // -------------------------------------------------------------------------- \n std::cout << \"Matrix-Vector product with scaled add\" << std::endl;\n NumericT alpha = static_cast(2.786);\n NumericT beta = static_cast(1.432);\n viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());\n viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());\n\n ublas_v1 = alpha * viennacl::linalg::prod(ublas_m1, ublas_v2) + beta * ublas_v1;\n vcl_v1 = alpha * viennacl::linalg::prod(vcl_m1, vcl_v2) + beta * vcl_v1;\n\n if( fabs(diff(ublas_v1, vcl_v1)) > epsilon )\n {\n std::cout << \"# Error at operation: matrix-vector product with scaled additions\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_v1, vcl_v1)) << std::endl;\n retval = EXIT_FAILURE;\n }\n // -------------------------------------------------------------------------- \n\n viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());\n viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());\n\n std::cout << \"Transposed Matrix-Vector product\" << std::endl;\n ublas_v2 = alpha * viennacl::linalg::prod(trans(ublas_m1), ublas_v1); \n vcl_v2 = alpha * viennacl::linalg::prod(trans(vcl_m1), vcl_v1);\n\n if( fabs(diff(ublas_v2, vcl_v2)) > epsilon )\n {\n std::cout << \"# Error at operation: transposed matrix-vector product\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_v2, vcl_v2)) << std::endl;\n retval = EXIT_FAILURE;\n }\n\n std::cout << \"Transposed Matrix-Vector product with scaled add\" << std::endl;\n ublas_v2 = alpha * viennacl::linalg::prod(trans(ublas_m1), ublas_v1) + beta * ublas_v2; \n vcl_v2 = alpha * viennacl::linalg::prod(trans(vcl_m1), vcl_v1) + beta * vcl_v2;\n\n if( fabs(diff(ublas_v2, vcl_v2)) > epsilon )\n {\n std::cout << \"# Error at operation: transposed matrix-vector product with scaled additions\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_v2, vcl_v2)) << std::endl;\n retval = EXIT_FAILURE;\n }\n // -------------------------------------------------------------------------- \n\n return retval;\n}\n\n\n\ntemplate \nint test_solve(Epsilon const & epsilon,\n UblasMatrixType & ublas_m1, UblasVectorType & ublas_v1,\n VCLMatrixType & vcl_m1, VCLVectorType1 & vcl_v1)\n{\n int retval = EXIT_SUCCESS;\n \n // sync data:\n //viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());\n viennacl::copy(ublas_v1, vcl_v1);\n viennacl::copy(ublas_m1, vcl_m1);\n\n /////////////////// test direct solvers ////////////////////////////\n \n //upper triangular:\n std::cout << \"Upper triangular solver\" << std::endl;\n ublas_v1 = ublas::solve(ublas_m1, ublas_v1, ublas::upper_tag());\n vcl_v1 = viennacl::linalg::solve(vcl_m1, vcl_v1, viennacl::linalg::upper_tag());\n if( fabs(diff(ublas_v1, vcl_v1)) > epsilon )\n {\n std::cout << \"# Error at operation: upper triangular solver\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_v1, vcl_v1)) << std::endl;\n retval = EXIT_FAILURE;\n }\n\n //upper unit triangular:\n std::cout << \"Upper unit triangular solver\" << std::endl;\n viennacl::copy(ublas_v1, vcl_v1);\n ublas_v1 = ublas::solve(ublas_m1, ublas_v1, ublas::unit_upper_tag());\n vcl_v1 = viennacl::linalg::solve(vcl_m1, vcl_v1, viennacl::linalg::unit_upper_tag());\n if( fabs(diff(ublas_v1, vcl_v1)) > epsilon )\n {\n std::cout << \"# Error at operation: unit upper triangular solver\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_v1, vcl_v1)) << std::endl;\n retval = EXIT_FAILURE;\n }\n\n //lower triangular:\n std::cout << \"Lower triangular solver\" << std::endl;\n viennacl::copy(ublas_v1, vcl_v1);\n ublas_v1 = ublas::solve(ublas_m1, ublas_v1, ublas::lower_tag());\n vcl_v1 = viennacl::linalg::solve(vcl_m1, vcl_v1, viennacl::linalg::lower_tag());\n if( fabs(diff(ublas_v1, vcl_v1)) > epsilon )\n {\n std::cout << \"# Error at operation: lower triangular solver\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_v1, vcl_v1)) << std::endl;\n retval = EXIT_FAILURE;\n }\n\n //lower unit triangular:\n std::cout << \"Lower unit triangular solver\" << std::endl;\n viennacl::copy(ublas_v1, vcl_v1);\n ublas_v1 = ublas::solve(ublas_m1, ublas_v1, ublas::unit_lower_tag());\n vcl_v1 = viennacl::linalg::solve(vcl_m1, vcl_v1, viennacl::linalg::unit_lower_tag());\n if( fabs(diff(ublas_v1, vcl_v1)) > epsilon )\n {\n std::cout << \"# Error at operation: unit lower triangular solver\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_v1, vcl_v1)) << std::endl;\n retval = EXIT_FAILURE;\n }\n\n\n\n\n\n //transposed upper triangular:\n std::cout << \"Transposed upper triangular solver\" << std::endl;\n viennacl::copy(ublas_v1, vcl_v1);\n ublas_v1 = ublas::solve(trans(ublas_m1), ublas_v1, ublas::upper_tag());\n vcl_v1 = viennacl::linalg::solve(trans(vcl_m1), vcl_v1, viennacl::linalg::upper_tag());\n if( fabs(diff(ublas_v1, vcl_v1)) > epsilon )\n {\n std::cout << \"# Error at operation: upper triangular solver\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_v1, vcl_v1)) << std::endl;\n retval = EXIT_FAILURE;\n }\n\n //transposed upper unit triangular:\n std::cout << \"Transposed unit upper triangular solver\" << std::endl;\n viennacl::copy(ublas_v1, vcl_v1);\n ublas_v1 = ublas::solve(trans(ublas_m1), ublas_v1, ublas::unit_upper_tag());\n vcl_v1 = viennacl::linalg::solve(trans(vcl_m1), vcl_v1, viennacl::linalg::unit_upper_tag());\n if( fabs(diff(ublas_v1, vcl_v1)) > epsilon )\n {\n std::cout << \"# Error at operation: unit upper triangular solver\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_v1, vcl_v1)) << std::endl;\n retval = EXIT_FAILURE;\n }\n\n //transposed lower triangular:\n std::cout << \"Transposed lower triangular solver\" << std::endl;\n viennacl::copy(ublas_v1, vcl_v1);\n ublas_v1 = ublas::solve(trans(ublas_m1), ublas_v1, ublas::lower_tag());\n vcl_v1 = viennacl::linalg::solve(trans(vcl_m1), vcl_v1, viennacl::linalg::lower_tag());\n if( fabs(diff(ublas_v1, vcl_v1)) > epsilon )\n {\n std::cout << \"# Error at operation: lower triangular solver\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_v1, vcl_v1)) << std::endl;\n retval = EXIT_FAILURE;\n }\n\n //transposed lower unit triangular:\n std::cout << \"Transposed unit lower triangular solver\" << std::endl;\n viennacl::copy(ublas_v1, vcl_v1);\n ublas_v1 = ublas::solve(trans(ublas_m1), ublas_v1, ublas::unit_lower_tag());\n vcl_v1 = viennacl::linalg::solve(trans(vcl_m1), vcl_v1, viennacl::linalg::unit_lower_tag());\n if( fabs(diff(ublas_v1, vcl_v1)) > epsilon )\n {\n std::cout << \"# Error at operation: unit lower triangular solver\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(ublas_v1, vcl_v1)) << std::endl;\n retval = EXIT_FAILURE;\n }\n \n return retval;\n}\n\n\n//\n// -------------------------------------------------------------\n//\ntemplate< typename NumericT, typename F, typename Epsilon >\nint test(Epsilon const& epsilon)\n{\n int retval = EXIT_SUCCESS;\n \n std::size_t num_rows = 141;\n std::size_t num_cols = 103;\n \n // -------------------------------------------------------------------------- \n ublas::vector ublas_v1(num_rows);\n for (std::size_t i = 0; i < ublas_v1.size(); ++i)\n ublas_v1(i) = random();\n ublas::vector ublas_v2 = ublas::scalar_vector(num_cols, NumericT(3.1415));\n\n \n ublas::matrix ublas_m1(ublas_v1.size(), ublas_v2.size());\n \n for (std::size_t i = 0; i < ublas_m1.size1(); ++i)\n for (std::size_t j = 0; j < ublas_m1.size2(); ++j)\n ublas_m1(i,j) = static_cast(0.1) * random();\n\n \n ublas::matrix ublas_m2(ublas_v1.size(), ublas_v1.size());\n \n for (std::size_t i = 0; i < ublas_m2.size1(); ++i)\n {\n for (std::size_t j = 0; j < ublas_m2.size2(); ++j)\n ublas_m2(i,j) = static_cast(-0.1) * random();\n ublas_m2(i, i) = static_cast(2) + random();\n }\n\n \n viennacl::vector vcl_v1_native(ublas_v1.size());\n viennacl::vector vcl_v1_large(4 * ublas_v1.size());\n viennacl::vector_range< viennacl::vector > vcl_v1_range(vcl_v1_large, viennacl::range(3, ublas_v1.size() + 3));\n viennacl::vector_slice< viennacl::vector > vcl_v1_slice(vcl_v1_large, viennacl::slice(2, 3, ublas_v1.size()));\n \n viennacl::vector vcl_v2_native(ublas_v2.size());\n viennacl::vector vcl_v2_large(4 * ublas_v2.size());\n viennacl::vector_range< viennacl::vector > vcl_v2_range(vcl_v2_large, viennacl::range(8, ublas_v2.size() + 8));\n viennacl::vector_slice< viennacl::vector > vcl_v2_slice(vcl_v2_large, viennacl::slice(6, 2, ublas_v2.size()));\n \n viennacl::matrix vcl_m1_native(ublas_m1.size1(), ublas_m1.size2());\n viennacl::matrix vcl_m1_large(4 * ublas_m1.size1(), 4 * ublas_m1.size2());\n viennacl::matrix_range< viennacl::matrix > vcl_m1_range(vcl_m1_large,\n viennacl::range(8, ublas_m1.size1() + 8),\n viennacl::range(ublas_m1.size2(), 2 * ublas_m1.size2()) );\n viennacl::matrix_slice< viennacl::matrix > vcl_m1_slice(vcl_m1_large,\n viennacl::slice(6, 2, ublas_m1.size1()),\n viennacl::slice(ublas_m1.size2(), 2, ublas_m1.size2()) );\n \n viennacl::matrix vcl_m2_native(ublas_m2.size1(), ublas_m2.size2());\n viennacl::matrix vcl_m2_large(4 * ublas_m2.size1(), 4 * ublas_m2.size2());\n viennacl::matrix_range< viennacl::matrix > vcl_m2_range(vcl_m2_large,\n viennacl::range(8, ublas_m2.size1() + 8),\n viennacl::range(ublas_m2.size2(), 2 * ublas_m2.size2()) );\n viennacl::matrix_slice< viennacl::matrix > vcl_m2_slice(vcl_m2_large,\n viennacl::slice(6, 2, ublas_m2.size1()),\n viennacl::slice(ublas_m2.size2(), 2, ublas_m2.size2()) );\n\n \n/* std::cout << \"Matrix resizing (to larger)\" << std::endl;\n matrix.resize(2*num_rows, 2*num_cols, true);\n for (unsigned int i = 0; i < matrix.size1(); ++i)\n {\n for (unsigned int j = (i epsilon )\n {\n std::cout << \"# Error at operation: matrix resize (to larger)\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(matrix, vcl_matrix)) << std::endl;\n return EXIT_FAILURE;\n }\n \n matrix(12, 14) = NumericT(1.9);\n matrix(19, 16) = NumericT(1.0);\n matrix (13, 15) = NumericT(-9);\n vcl_matrix(12, 14) = NumericT(1.9);\n vcl_matrix(19, 16) = NumericT(1.0);\n vcl_matrix (13, 15) = NumericT(-9);\n \n std::cout << \"Matrix resizing (to smaller)\" << std::endl;\n matrix.resize(result.size(), rhs.size(), true);\n vcl_matrix.resize(result.size(), rhs.size(), true);\n if( fabs(diff(matrix, vcl_matrix)) > epsilon )\n {\n std::cout << \"# Error at operation: matrix resize (to smaller)\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(matrix, vcl_matrix)) << std::endl;\n return EXIT_FAILURE;\n }\n */\n\n //\n // Run a bunch of tests for rank-1-updates, matrix-vector products\n //\n std::cout << \"------------ Testing rank-1-updates and matrix-vector products ------------------\" << std::endl;\n \n std::cout << \"* m = full, v1 = full, v2 = full\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_native, vcl_v1_native, vcl_v2_native);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = full, v1 = full, v2 = range\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_native, vcl_v1_native, vcl_v2_range);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = full, v1 = full, v2 = slice\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_native, vcl_v1_native, vcl_v2_slice);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n // v1 = range\n \n \n std::cout << \"* m = full, v1 = range, v2 = full\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_native, vcl_v1_range, vcl_v2_native);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = full, v1 = range, v2 = range\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_native, vcl_v1_range, vcl_v2_range);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = full, v1 = range, v2 = slice\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_native, vcl_v1_range, vcl_v2_slice);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n\n \n // v1 = slice\n \n std::cout << \"* m = full, v1 = slice, v2 = full\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_native, vcl_v1_slice, vcl_v2_native);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = full, v1 = slice, v2 = range\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_native, vcl_v1_slice, vcl_v2_range);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = full, v1 = slice, v2 = slice\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_native, vcl_v1_slice, vcl_v2_slice);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n ///////////////////////////// matrix_range\n \n std::cout << \"* m = range, v1 = full, v2 = full\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_range, vcl_v1_native, vcl_v2_native);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = range, v1 = full, v2 = range\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_range, vcl_v1_native, vcl_v2_range);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = range, v1 = full, v2 = slice\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_range, vcl_v1_native, vcl_v2_slice);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n // v1 = range\n \n \n std::cout << \"* m = range, v1 = range, v2 = full\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_range, vcl_v1_range, vcl_v2_native);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = range, v1 = range, v2 = range\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_range, vcl_v1_range, vcl_v2_range);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = range, v1 = range, v2 = slice\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_range, vcl_v1_range, vcl_v2_slice);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n\n \n // v1 = slice\n \n std::cout << \"* m = range, v1 = slice, v2 = full\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_range, vcl_v1_slice, vcl_v2_native);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = range, v1 = slice, v2 = range\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_range, vcl_v1_slice, vcl_v2_range);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = range, v1 = slice, v2 = slice\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_range, vcl_v1_slice, vcl_v2_slice);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n ///////////////////////////// matrix_slice\n\n std::cout << \"* m = slice, v1 = full, v2 = full\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_slice, vcl_v1_native, vcl_v2_native);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = slice, v1 = full, v2 = range\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_slice, vcl_v1_native, vcl_v2_range);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = slice, v1 = full, v2 = slice\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_slice, vcl_v1_native, vcl_v2_slice);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n // v1 = range\n \n \n std::cout << \"* m = slice, v1 = range, v2 = full\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_slice, vcl_v1_range, vcl_v2_native);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = slice, v1 = range, v2 = range\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_slice, vcl_v1_range, vcl_v2_range);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = slice, v1 = range, v2 = slice\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_slice, vcl_v1_range, vcl_v2_slice);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n\n \n // v1 = slice\n \n std::cout << \"* m = slice, v1 = slice, v2 = full\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_slice, vcl_v1_slice, vcl_v2_native);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = slice, v1 = slice, v2 = range\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_slice, vcl_v1_slice, vcl_v2_range);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n std::cout << \"* m = slice, v1 = slice, v2 = slice\" << std::endl;\n retval = test_prod_rank1(epsilon,\n ublas_m1, ublas_v1, ublas_v2,\n vcl_m1_slice, vcl_v1_slice, vcl_v2_slice);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n \n \n //\n // Testing triangular solve() routines\n //\n \n std::cout << \"------------ Testing triangular solves ------------------\" << std::endl;\n \n std::cout << \"* m = full, v1 = full\" << std::endl;\n retval = test_solve(epsilon,\n ublas_m2, ublas_v1,\n vcl_m2_native, vcl_v1_native);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n \n std::cout << \"* m = full, v1 = range\" << std::endl;\n retval = test_solve(epsilon,\n ublas_m2, ublas_v1,\n vcl_m2_native, vcl_v1_range);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n std::cout << \"* m = full, v1 = slice\" << std::endl;\n retval = test_solve(epsilon,\n ublas_m2, ublas_v1,\n vcl_m2_native, vcl_v1_slice);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n ///////// matrix_range\n \n \n std::cout << \"* m = range, v1 = full\" << std::endl;\n retval = test_solve(epsilon,\n ublas_m2, ublas_v1,\n vcl_m2_range, vcl_v1_native);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n \n std::cout << \"* m = range, v1 = range\" << std::endl;\n retval = test_solve(epsilon,\n ublas_m2, ublas_v1,\n vcl_m2_range, vcl_v1_range);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n std::cout << \"* m = range, v1 = slice\" << std::endl;\n retval = test_solve(epsilon,\n ublas_m2, ublas_v1,\n vcl_m2_range, vcl_v1_slice);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n //////// matrix_slice\n \n std::cout << \"* m = slice, v1 = full\" << std::endl;\n retval = test_solve(epsilon,\n ublas_m2, ublas_v1,\n vcl_m2_slice, vcl_v1_native);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n \n std::cout << \"* m = slice, v1 = range\" << std::endl;\n retval = test_solve(epsilon,\n ublas_m2, ublas_v1,\n vcl_m2_slice, vcl_v1_range);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n\n std::cout << \"* m = slice, v1 = slice\" << std::endl;\n retval = test_solve(epsilon,\n ublas_m2, ublas_v1,\n vcl_m2_slice, vcl_v1_slice);\n if (retval == EXIT_FAILURE)\n {\n std::cout << \" --- FAILED! ---\" << std::endl;\n return retval;\n }\n else\n std::cout << \" --- PASSED ---\" << std::endl;\n \n \n \n \n \n \n \n ////////////// Final test for full LU decomposition:\n \n //full solver:\n std::cout << \"Full solver\" << std::endl;\n unsigned int lu_dim = 100;\n ublas::matrix square_matrix(lu_dim, lu_dim);\n ublas::vector lu_rhs(lu_dim);\n viennacl::matrix vcl_square_matrix(lu_dim, lu_dim);\n viennacl::vector vcl_lu_rhs(lu_dim);\n\n for (std::size_t i=0; i(0.5) * random();\n\n //put some more weight on diagonal elements:\n for (std::size_t j=0; j(20.0) + random();\n lu_rhs(j) = random();\n }\n \n viennacl::copy(square_matrix, vcl_square_matrix);\n viennacl::copy(lu_rhs, vcl_lu_rhs);\n \n //ublas::\n ublas::lu_factorize(square_matrix);\n ublas::inplace_solve (square_matrix, lu_rhs, ublas::unit_lower_tag ());\n ublas::inplace_solve (square_matrix, lu_rhs, ublas::upper_tag ());\n\n // ViennaCL:\n viennacl::linalg::lu_factorize(vcl_square_matrix);\n //viennacl::copy(square_matrix, vcl_square_matrix);\n viennacl::linalg::lu_substitute(vcl_square_matrix, vcl_lu_rhs);\n\n if( fabs(diff(lu_rhs, vcl_lu_rhs)) > epsilon )\n {\n std::cout << \"# Error at operation: dense solver\" << std::endl;\n std::cout << \" diff: \" << fabs(diff(lu_rhs, vcl_lu_rhs)) << std::endl;\n retval = EXIT_FAILURE;\n }\n \n \n\n return retval;\n}\n//\n// -------------------------------------------------------------\n//\nint main()\n{\n std::cout << std::endl;\n std::cout << \"----------------------------------------------\" << std::endl;\n std::cout << \"----------------------------------------------\" << std::endl;\n std::cout << \"## Test :: Matrix\" << std::endl;\n std::cout << \"----------------------------------------------\" << std::endl;\n std::cout << \"----------------------------------------------\" << std::endl;\n std::cout << std::endl;\n\n int retval = EXIT_SUCCESS;\n\n std::cout << std::endl;\n std::cout << \"----------------------------------------------\" << std::endl;\n std::cout << std::endl;\n {\n typedef float NumericT;\n NumericT epsilon = NumericT(1.0E-3);\n std::cout << \"# Testing setup:\" << std::endl;\n std::cout << \" eps: \" << epsilon << std::endl;\n std::cout << \" numeric: float\" << std::endl;\n std::cout << \" layout: row-major\" << std::endl;\n retval = test(epsilon);\n if( retval == EXIT_SUCCESS )\n std::cout << \"# Test passed\" << std::endl;\n else\n return retval;\n }\n std::cout << std::endl;\n std::cout << \"----------------------------------------------\" << std::endl;\n std::cout << std::endl;\n {\n typedef float NumericT;\n NumericT epsilon = NumericT(1.0E-3);\n std::cout << \"# Testing setup:\" << std::endl;\n std::cout << \" eps: \" << epsilon << std::endl;\n std::cout << \" numeric: float\" << std::endl;\n std::cout << \" layout: column-major\" << std::endl;\n retval = test(epsilon);\n if( retval == EXIT_SUCCESS )\n std::cout << \"# Test passed\" << std::endl;\n else\n return retval;\n }\n std::cout << std::endl;\n std::cout << \"----------------------------------------------\" << std::endl;\n std::cout << std::endl;\n \n \n#ifdef VIENNACL_HAVE_OPENCL \n if( viennacl::ocl::current_device().double_support() )\n#endif\n {\n {\n typedef double NumericT;\n NumericT epsilon = 1.0E-11;\n std::cout << \"# Testing setup:\" << std::endl;\n std::cout << \" eps: \" << epsilon << std::endl;\n std::cout << \" numeric: double\" << std::endl;\n std::cout << \" layout: row-major\" << std::endl;\n retval = test(epsilon);\n if( retval == EXIT_SUCCESS )\n std::cout << \"# Test passed\" << std::endl;\n else\n return retval;\n }\n std::cout << std::endl;\n std::cout << \"----------------------------------------------\" << std::endl;\n std::cout << std::endl;\n {\n typedef double NumericT;\n NumericT epsilon = 1.0E-11;\n std::cout << \"# Testing setup:\" << std::endl;\n std::cout << \" eps: \" << epsilon << std::endl;\n std::cout << \" numeric: double\" << std::endl;\n std::cout << \" layout: column-major\" << std::endl;\n retval = test(epsilon);\n if( retval == EXIT_SUCCESS )\n std::cout << \"# Test passed\" << std::endl;\n else\n return retval;\n }\n std::cout << std::endl;\n std::cout << \"----------------------------------------------\" << std::endl;\n std::cout << std::endl;\n }\n \n std::cout << std::endl;\n std::cout << \"------- Test completed --------\" << std::endl;\n std::cout << std::endl;\n \n \n return retval;\n}\n", "meta": {"hexsha": "ce082781e261969bfaee8c758aa4e8ba09b6bbaf", "size": 38821, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "tests/src/matrix-vector.cpp", "max_stars_repo_name": "bollig/viennacl", "max_stars_repo_head_hexsha": "6dac70e558ed42abe63d8c5bfd08465aafeda859", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-09-21T08:33:10.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-21T08:33:10.000Z", "max_issues_repo_path": "tests/src/matrix-vector.cpp", "max_issues_repo_name": "bollig/viennacl", "max_issues_repo_head_hexsha": "6dac70e558ed42abe63d8c5bfd08465aafeda859", "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": "tests/src/matrix-vector.cpp", "max_forks_repo_name": "bollig/viennacl", "max_forks_repo_head_hexsha": "6dac70e558ed42abe63d8c5bfd08465aafeda859", "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.1461824953, "max_line_length": 130, "alphanum_fraction": 0.519924783, "num_tokens": 11206, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7217432182679956, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.44925580094257067}} {"text": "// Demonstrating the use of ranges built using istream_iterator with a custom stream operator\n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \n\n#include \"nmea.h\"\n\nint main() {\n using namespace std;\n\n string test(\"$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,,*47\");\n test += \"\\n$GPGGA,170834,4124.8963,N,08151.6838,W,1,05,1.5,280.2,M,-34.0,M,,,*59\";\n\n using namespace ranges::v3;\n istringstream ss(test);\n ranges::for_each(istream_range(ss),\n [](gga_t const& g) {\n cout << g << \"\\n\";\n });\n\n // produce a filtered range of Boost Geometry world coordinates using Range views\n using namespace boost::geometry;\n typedef model::point > coord_t;\n ss = istringstream(test); // reset stream\n auto construct_coord = [](gga_t const& g) {\n double lat_deg = floor(g.latitude / 100.0);\n if (g.lat_hemi == 'W') {\n lat_deg = -lat_deg;\n }\n double long_deg = floor(g.longitude / 100.0);\n if (g.lat_hemi == 'S') {\n long_deg = -long_deg;\n }\n return coord_t(lat_deg, long_deg);\n };\n auto coord_range =\n istream_range(ss) |\n ranges::view::remove_if([](gga_t const& g) {\n return g.dilution > 1.0;\n }) |\n ranges::view::transform(construct_coord);\n\n // print out resulting Geometry coordinates (only one passes dilution test)\n ranges::for_each(coord_range,\n [](coord_t const& pt) {\n std::cout << wkt(pt) << \"\\n\";\n });\n}\n", "meta": {"hexsha": "6a11acbc5e06ec80b8e9e9396102e0f511eac5eb", "size": 1761, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "custom_stream_operator.cpp", "max_stars_repo_name": "jefftrull/SequencesFromStreams", "max_stars_repo_head_hexsha": "44a903c5c4c322280053dd16fa47512bda87f6ec", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2017-11-14T12:04:07.000Z", "max_stars_repo_stars_event_max_datetime": "2017-11-14T12:04:07.000Z", "max_issues_repo_path": "custom_stream_operator.cpp", "max_issues_repo_name": "jefftrull/SequencesFromStreams", "max_issues_repo_head_hexsha": "44a903c5c4c322280053dd16fa47512bda87f6ec", "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": "custom_stream_operator.cpp", "max_forks_repo_name": "jefftrull/SequencesFromStreams", "max_forks_repo_head_hexsha": "44a903c5c4c322280053dd16fa47512bda87f6ec", "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.0181818182, "max_line_length": 93, "alphanum_fraction": 0.5684270301, "num_tokens": 469, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6859494678483918, "lm_q2_score": 0.6548947290421275, "lm_q1q2_score": 0.44922469088316413}} {"text": "/*!\n * Exact calculation of the overlap volume of spheres and mesh elements.\n * http://dx.doi.org/10.1016/j.jcp.2016.02.003\n *\n * Copyright (C) 2015-2017 Severin Strobl \n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see .\n */\n\n#ifndef OVERLAP_HPP\n#define OVERLAP_HPP\n\n// Eigen\n#include \n#include \n\n// C++\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// typedefs\ntypedef double scalar_t;\ntypedef Eigen::Matrix vector_t;\ntypedef Eigen::Matrix vector2_t;\n\n// Pretty-printing of Eigen matrices.\nstatic const Eigen::IOFormat pretty(\n Eigen::StreamPrecision, Eigen::DontAlignCols, \" \", \";\\n\", \"\", \"\", \"[\", \"]\");\n\n// constants\nconst scalar_t pi = scalar_t(4) * std::atan(scalar_t(1.0));\n\nnamespace detail {\n\nstatic const scalar_t tinyEpsilon(2 * std::numeric_limits::epsilon());\n\nstatic const scalar_t mediumEpsilon(1e2 * tinyEpsilon);\nstatic const scalar_t largeEpsilon(1e-10);\n\n// Robust calculation of the normal vector of a polygon using Newell's method\n// and a pre-calculated center.\n// Ref: Christer Ericson - Real-Time Collision Detection (2005)\ntemplate \ninline vector_t normalNewell(\n Iterator begin, Iterator end, const vector_t& center) {\n const size_t count = end - begin;\n vector_t n(vector_t::Zero());\n\n for (size_t i = 0; i < count; ++i)\n n += (*(begin + i) - center).cross(*(begin + ((i + 1) % count)) - center);\n\n scalar_t length = n.stableNorm();\n\n if (length)\n return n / length;\n else\n return n;\n}\n\n// This implementation of double_prec is based on:\n// T.J. Dekker, A floating-point technique for extending the available\n// precision, http://dx.doi.org/10.1007/BF01397083\n\ntemplate \nstruct double_prec_constant;\n\ntemplate <>\nstruct double_prec_constant {\n // Constant used to split double precision values:\n // 2^(24 - 24/2) + 1 = 2^12 + 1 = 4097\n static const uint32_t value = 4097;\n};\n\ntemplate <>\nstruct double_prec_constant {\n // Constant used to split double precision values:\n // 2^(53 - int(53/2)) + 1 = 2^27 + 1 = 134217729\n static const uint32_t value = 134217729;\n};\n\n// For GCC and Clang an attribute can be used to control the FP precision...\n#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && \\\n !defined(__INTEL_COMPILER)\n#define ENFORCE_EXACT_FPMATH_ATTR __attribute__((__target__(\"ieee-fp\")))\n#else\n#define ENFORCE_EXACT_FPMATH_ATTR\n#endif\n\n// ... whereas ICC requires a pragma.\n#if defined(__ICC) || defined(__INTEL_COMPILER)\n#define ENFORCE_EXACT_FPMATH_ATTR\n#define USE_EXACT_FPMATH_PRAGMA 1\n#endif\n\ntemplate \nclass double_prec;\n\ntemplate \ninline double_prec operator+(\n const double_prec& lhs,\n const double_prec& rhs) ENFORCE_EXACT_FPMATH_ATTR;\n\ntemplate \ninline double_prec operator-(\n const double_prec& lhs,\n const double_prec& rhs) ENFORCE_EXACT_FPMATH_ATTR;\n\ntemplate \ninline double_prec operator*(\n const double_prec& lhs,\n const double_prec& rhs) ENFORCE_EXACT_FPMATH_ATTR;\n\ntemplate \nclass double_prec {\n private:\n static const uint32_t c = detail::double_prec_constant::value;\n\n template \n friend double_prec operator+(\n const double_prec&, const double_prec&);\n\n template \n friend double_prec operator-(\n const double_prec&, const double_prec&);\n\n template \n friend double_prec operator*(\n const double_prec&, const double_prec&);\n\n public:\n inline double_prec() : h_(0), l_(0) {}\n\n // This constructor requires floating point operations in accordance\n // with IEEE754 to perform the proper splitting. To allow full\n // optimization of all other parts of the code, precise floating point\n // ops are only requested here. Unfortunately the way to do this is\n // extremely compiler dependent.\n inline double_prec(const T& val) ENFORCE_EXACT_FPMATH_ATTR : h_(0), l_(0) {\n#ifdef USE_EXACT_FPMATH_PRAGMA\n#pragma float_control(precise, on)\n#endif\n\n T p = val * T(c);\n h_ = (val - p) + p;\n l_ = val - h_;\n }\n\n private:\n inline explicit double_prec(const T& h, const T& l) : h_(h), l_(l) {}\n\n public:\n inline const T& high() const {\n return h_;\n }\n\n inline const T& low() const {\n return l_;\n }\n\n inline T value() const {\n return h_ + l_;\n }\n\n template \n inline TOther convert() const {\n return TOther(h_) + TOther(l_);\n }\n\n private:\n T h_;\n T l_;\n};\n\ntemplate \ninline double_prec operator+(\n const double_prec& lhs, const double_prec& rhs) {\n#ifdef USE_EXACT_FPMATH_PRAGMA\n#pragma float_control(precise, on)\n#endif\n\n T h = lhs.h_ + rhs.h_;\n T l = std::abs(lhs.h_) >= std::abs(rhs.h_)\n ? ((((lhs.h_ - h) + rhs.h_) + lhs.l_) + rhs.l_)\n : ((((rhs.h_ - h) + lhs.h_) + rhs.l_) + lhs.l_);\n\n T c = h + l;\n\n return double_prec(c, (h - c) + l);\n}\n\ntemplate \ninline double_prec operator-(\n const double_prec& lhs, const double_prec& rhs) {\n#ifdef USE_EXACT_FPMATH_PRAGMA\n#pragma float_control(precise, on)\n#endif\n\n T h = lhs.h_ - rhs.h_;\n T l = std::abs(lhs.h_) >= std::abs(rhs.h_)\n ? ((((lhs.h_ - h) - rhs.h_) - rhs.l_) + lhs.l_)\n : ((((-rhs.h_ - h) + lhs.h_) + lhs.l_) - rhs.l_);\n\n T c = h + l;\n\n return double_prec(c, (h - c) + l);\n}\n\ntemplate \ninline double_prec operator*(\n const double_prec& lhs, const double_prec& rhs) {\n#ifdef USE_EXACT_FPMATH_PRAGMA\n#pragma float_control(precise, on)\n#endif\n\n double_prec l(lhs.h_);\n double_prec r(rhs.h_);\n\n T p = l.h_ * r.h_;\n T q = l.h_ * r.l_ + l.l_ * r.h_;\n T v = p + q;\n\n double_prec c(v, ((p - v) + q) + l.l_ * r.l_);\n c.l_ = ((lhs.h_ + lhs.l_) * rhs.l_ + lhs.l_ * rhs.h_) + c.l_;\n T z = c.value();\n\n return double_prec(z, (c.h_ - z) + c.l_);\n}\n\n// Ref: J.R. Shewchuk - Lecture Notes on Geometric Robustness\n// http://www.cs.berkeley.edu/~jrs/meshpapers/robnotes.pdf\ninline scalar_t orient2D(\n const vector2_t& a, const vector2_t& b, const vector2_t& c) {\n typedef double_prec real_t;\n\n real_t a0(a[0]);\n real_t a1(a[1]);\n real_t b0(b[0]);\n real_t b1(b[1]);\n real_t c0(c[0]);\n real_t c1(c[1]);\n\n real_t result = (a0 - c0) * (b1 - c1) - (a1 - c1) * (b0 - c0);\n\n return result.convert();\n}\n\n// Numerically robust calculation of the normal of the triangle defined by\n// the points a, b, and c.\n// Ref: J.R. Shewchuk - Lecture Notes on Geometric Robustness\n// http://www.cs.berkeley.edu/~jrs/meshpapers/robnotes.pdf\ninline vector_t triangleNormal(\n const vector_t& a, const vector_t& b, const vector_t& c) {\n scalar_t xy = orient2D(\n vector2_t(a[0], a[1]), vector2_t(b[0], b[1]), vector2_t(c[0], c[1]));\n\n scalar_t yz = orient2D(\n vector2_t(a[1], a[2]), vector2_t(b[1], b[2]), vector2_t(c[1], c[2]));\n\n scalar_t zx = orient2D(\n vector2_t(a[2], a[0]), vector2_t(b[2], b[0]), vector2_t(c[2], c[0]));\n\n return vector_t(yz, zx, xy).normalized();\n}\n\n// Numerically robust routine to calculate the angle between normalized\n// vectors.\n// Ref: http://www.plunk.org/~hatch/rightway.php\ninline scalar_t angle(const vector_t& v0, const vector_t& v1) {\n if (v0.dot(v1) < scalar_t(0))\n return pi - scalar_t(2) * std::asin(scalar_t(0.5) * (v0 + v1).stableNorm());\n else\n return scalar_t(2) * std::asin(scalar_t(0.5) * (v0 - v1).stableNorm());\n}\n\ntemplate \ninline std::array gramSchmidt(\n const Eigen::MatrixBase& arg0,\n const Eigen::MatrixBase& arg1) {\n vector_t v0(arg0.normalized());\n vector_t v1(arg1);\n\n std::array result;\n result[0] = v0;\n result[1] = (v1 - v1.dot(v0) * v0).normalized();\n\n return result;\n}\n\ninline scalar_t clamp(\n scalar_t value, scalar_t min, scalar_t max, scalar_t limit) {\n assert(min <= max && limit >= scalar_t(0));\n\n value = (value < min && value > (min - limit)) ? min : value;\n value = (value > max && value < (max + limit)) ? max : value;\n\n return value;\n}\n\n} // namespace detail\n\nclass Transformation {\n public:\n Transformation(const vector_t& t, const scalar_t& s)\n : translation(t), scaling(s) {}\n\n vector_t translation;\n scalar_t scaling;\n};\n\ntemplate \nclass Polygon {\n private:\n static_assert(\n VertexCount >= 3 && VertexCount <= 4,\n \"Only triangles and quadrilateral are supported.\");\n\n public:\n static const size_t vertex_count = VertexCount;\n\n protected:\n Polygon() : vertices(), center(), normal(), area() {}\n\n template \n Polygon(const vector_t& v0, Types... verts)\n : vertices{{v0, verts...}}, center(), normal(), area() {\n center = scalar_t(1.0 / vertex_count) *\n std::accumulate(\n vertices.begin(), vertices.end(), vector_t::Zero().eval());\n\n // For a quadrilateral, Newell's method can be simplified\n // significantly.\n // Ref: Christer Ericson - Real-Time Collision Detection (2005)\n if (VertexCount == 4) {\n normal = ((vertices[2] - vertices[0]).cross(vertices[3] - vertices[1]))\n .normalized();\n } else {\n normal = detail::normalNewell(vertices.begin(), vertices.end(), center);\n }\n }\n\n void apply(const Transformation& t) {\n for (auto& v : vertices)\n v = t.scaling * (v + t.translation);\n\n center = t.scaling * (center + t.translation);\n }\n\n public:\n bool isPlanar(const scalar_t epsilon = detail::largeEpsilon) const {\n if (VertexCount == 3) return true;\n\n for (auto& v : vertices)\n if (std::abs(normal.dot(v - center)) > epsilon) return false;\n\n return true;\n }\n\n public:\n std::array vertices;\n vector_t center;\n vector_t normal;\n scalar_t area;\n};\n\nclass Triangle : public Polygon<3> {\n public:\n Triangle() : Polygon<3>() {}\n\n template \n Triangle(const vector_t& v0, Types... verts) : Polygon<3>(v0, verts...) {\n init();\n }\n\n void apply(const Transformation& t) {\n Polygon<3>::apply(t);\n init();\n }\n\n private:\n void init() {\n area = scalar_t(0.5) *\n ((vertices[1] - vertices[0]).cross(vertices[2] - vertices[0]))\n .stableNorm();\n }\n};\n\nclass Quadrilateral : public Polygon<4> {\n public:\n Quadrilateral() : Polygon<4>() {}\n\n template \n Quadrilateral(const vector_t& v0, Types... verts) : Polygon<4>(v0, verts...) {\n init();\n }\n\n void apply(const Transformation& t) {\n Polygon<4>::apply(t);\n init();\n }\n\n private:\n void init() {\n area = scalar_t(0.5) *\n (((vertices[1] - vertices[0]).cross(vertices[2] - vertices[0]))\n .stableNorm() +\n ((vertices[2] - vertices[0]).cross(vertices[3] - vertices[0]))\n .stableNorm());\n }\n};\n\n// Forward declarations of the mesh elements.\nclass Tetrahedron;\nclass Wedge;\nclass Hexahedron;\n\nnamespace detail {\n\n// Some tricks are required to keep this code header-only.\ntemplate \nstruct mappings;\n\ntemplate \nstruct mappings {\n // Map edges of a tetrahedron to vertices and faces.\n static const uint32_t edge_mapping[6][2][2];\n\n // Map vertices of a tetrahedron to edges and faces.\n // 0: local IDs of the edges intersecting at this vertex\n // 1: 0 if the edge is pointing away from the vertex, 1 otherwise\n // 2: faces joining at the vertex\n static const uint32_t vertex_mapping[4][3][3];\n\n // This mapping contains the three sets of the two edges for each of the\n // faces joining at a vertex. The indices are mapped to the local edge IDs\n // using the first value field of the 'vertex_mapping' table.\n static const uint32_t face_mapping[3][2];\n};\n\ntemplate \nconst uint32_t mappings::edge_mapping[6][2][2] = {\n {{0, 1}, {0, 1}}, {{1, 2}, {0, 2}}, {{2, 0}, {0, 3}},\n {{0, 3}, {1, 3}}, {{1, 3}, {1, 2}}, {{2, 3}, {2, 3}}};\n\ntemplate \nconst uint32_t mappings::vertex_mapping[4][3][3] = {\n {{0, 2, 3}, {0, 1, 0}, {0, 1, 3}},\n {{0, 1, 4}, {1, 0, 0}, {0, 1, 2}},\n {{1, 2, 5}, {1, 0, 0}, {0, 2, 3}},\n {{3, 4, 5}, {1, 1, 1}, {1, 3, 2}}};\n\ntemplate \nconst uint32_t mappings::face_mapping[3][2] = {\n {0, 1}, {0, 2}, {1, 2}};\n\ntypedef mappings tet_mappings;\n\n} // namespace detail\n\nclass Tetrahedron : public detail::tet_mappings {\n public:\n template \n Tetrahedron(const vector_t& v0, Types... verts)\n : vertices{{v0, verts...}}, faces(), center(), volume() {\n#ifndef NDEBUG\n // Make sure the ordering of the vertices is correct.\n assert(\n (vertices[1] - vertices[0])\n .cross(vertices[2] - vertices[0])\n .dot(vertices[3] - vertices[0]) >= scalar_t(0));\n#endif // NDEBUG\n\n init();\n }\n\n Tetrahedron(const std::array& verts)\n : vertices(verts), faces(), center(), volume() {\n init();\n }\n\n Tetrahedron()\n : vertices{{vector_t::Zero(), vector_t::Zero(), vector_t::Zero(), vector_t::Zero()}}\n , faces()\n , center()\n , volume() {}\n\n void apply(const Transformation& t) {\n for (auto& v : vertices)\n v = t.scaling * (v + t.translation);\n\n for (auto& f : faces)\n f.apply(t);\n\n center = scalar_t(0.25) *\n std::accumulate(\n vertices.begin(), vertices.end(), vector_t::Zero().eval());\n\n volume = calcVolume();\n }\n\n scalar_t surfaceArea() const {\n scalar_t area(0);\n for (const auto& f : faces)\n area += f.area;\n\n return area;\n }\n\n private:\n void init() {\n // 0: v2, v1, v0\n faces[0] = Triangle(vertices[2], vertices[1], vertices[0]);\n\n // 1: v0, v1, v3\n faces[1] = Triangle(vertices[0], vertices[1], vertices[3]);\n\n // 2: v1, v2, v3\n faces[2] = Triangle(vertices[1], vertices[2], vertices[3]);\n\n // 3: v2, v0, v3\n faces[3] = Triangle(vertices[2], vertices[0], vertices[3]);\n\n center = scalar_t(0.25) *\n std::accumulate(\n vertices.begin(), vertices.end(), vector_t::Zero().eval());\n\n volume = calcVolume();\n }\n\n scalar_t calcVolume() const {\n return scalar_t(1.0 / 6.0) *\n std::abs((vertices[0] - vertices[3])\n .dot((vertices[1] - vertices[3])\n .cross(vertices[2] - vertices[3])));\n }\n\n public:\n std::array vertices;\n std::array faces;\n vector_t center;\n scalar_t volume;\n};\n\nnamespace detail {\n\ntemplate \nstruct mappings {\n // Map edges of a wedge to vertices and faces.\n static const uint32_t edge_mapping[9][2][2];\n\n // Map vertices of a wedge to edges and faces.\n // 0: local IDs of the edges intersecting at this vertex\n // 1: 0 if the edge is pointing away from the vertex, 1 otherwise\n // 2: faces joining at the vertex\n static const uint32_t vertex_mapping[6][3][3];\n\n // This mapping contains the three sets of the two edges for each of the\n // faces joining at a vertex. The indices are mapped to the local edge IDs\n // using the first value field of the 'vertex_mapping' table.\n static const uint32_t face_mapping[3][2];\n};\n\ntemplate \nconst uint32_t mappings::edge_mapping[9][2][2] = {\n {{0, 1}, {0, 1}}, {{1, 2}, {0, 2}}, {{2, 0}, {0, 3}},\n {{0, 3}, {1, 3}}, {{1, 4}, {1, 2}}, {{2, 5}, {2, 3}},\n {{3, 4}, {1, 4}}, {{4, 5}, {2, 4}}, {{5, 3}, {3, 4}}};\n\ntemplate \nconst uint32_t mappings::vertex_mapping[6][3][3] = {\n {{0, 2, 3}, {0, 1, 0}, {0, 1, 3}}, {{0, 1, 4}, {1, 0, 0}, {0, 1, 2}},\n {{1, 2, 5}, {1, 0, 0}, {0, 2, 3}},\n\n {{3, 6, 8}, {1, 0, 1}, {1, 3, 4}}, {{4, 6, 7}, {1, 1, 0}, {1, 2, 4}},\n {{5, 7, 8}, {1, 1, 0}, {2, 3, 4}}};\n\ntemplate \nconst uint32_t mappings::face_mapping[3][2] = {\n {0, 1}, {0, 2}, {1, 2}};\n\ntypedef mappings wedge_mappings;\n\n} // namespace detail\n\nclass Wedge : public detail::wedge_mappings {\n public:\n template \n Wedge(const vector_t& v0, Types... verts)\n : vertices{{v0, verts...}}, faces(), center(), volume() {\n init();\n }\n\n Wedge(const std::array& verts)\n : vertices(verts), faces(), center(), volume() {\n init();\n }\n\n Wedge()\n : vertices{{vector_t::Zero(), vector_t::Zero(), vector_t::Zero(), vector_t::Zero(), vector_t::Zero(), vector_t::Zero()}}\n , faces()\n , center()\n , volume() {}\n\n void apply(const Transformation& t) {\n for (auto& v : vertices)\n v = t.scaling * (v + t.translation);\n\n for (auto& f : faces)\n f.apply(t);\n\n center = scalar_t(1.0 / 6.0) *\n std::accumulate(\n vertices.begin(), vertices.end(), vector_t::Zero().eval());\n\n volume = calcVolume();\n }\n\n scalar_t surfaceArea() const {\n scalar_t area(0);\n for (const auto& f : faces)\n area += f.area;\n\n return area;\n }\n\n private:\n void init() {\n // All faces of the wedge are stored as quadrilaterals, so an\n // additional point is inserted between v0 and v1.\n // 0: v2, v1, v0, v02\n faces[0] = Quadrilateral(\n vertices[2], vertices[1], vertices[0],\n scalar_t(0.5) * (vertices[0] + vertices[2]));\n\n // 1: v0, v1, v4, v3\n faces[1] =\n Quadrilateral(vertices[0], vertices[1], vertices[4], vertices[3]);\n\n // 2: v1, v2, v5, v4\n faces[2] =\n Quadrilateral(vertices[1], vertices[2], vertices[5], vertices[4]);\n\n // 3: v2, v0, v3, v5\n faces[3] =\n Quadrilateral(vertices[2], vertices[0], vertices[3], vertices[5]);\n\n // All faces of the wedge are stored as quadrilaterals, so an\n // additional point is inserted between v3 and v5.\n // 4: v3, v4, v5, v53\n faces[4] = Quadrilateral(\n vertices[3], vertices[4], vertices[5],\n scalar_t(0.5) * (vertices[5] + vertices[3]));\n\n center = scalar_t(1.0 / 6.0) *\n std::accumulate(\n vertices.begin(), vertices.end(), vector_t::Zero().eval());\n\n volume = calcVolume();\n }\n\n scalar_t calcVolume() const {\n // The wedge is treated as a degenerate hexahedron here by adding\n // two fake vertices v02 and v35.\n vector_t diagonal(vertices[5] - vertices[0]);\n\n return scalar_t(1.0 / 6.0) *\n (diagonal.dot(\n ((vertices[1] - vertices[0]).cross(vertices[2] - vertices[4])) +\n ((vertices[3] - vertices[0])\n .cross(\n vertices[4] -\n scalar_t(0.5) * (vertices[3] + vertices[5]))) +\n ((scalar_t(0.5) * (vertices[0] + vertices[2]) - vertices[0])\n .cross(\n scalar_t(0.5) * (vertices[3] + vertices[5]) -\n vertices[2]))));\n }\n\n public:\n std::array vertices;\n std::array faces;\n vector_t center;\n scalar_t volume;\n};\n\nnamespace detail {\n\ntemplate \nstruct mappings {\n // Map edges of a hexahedron to vertices and faces.\n static const uint32_t edge_mapping[12][2][2];\n\n // Map vertices of a hexahedron to edges and faces.\n // 0: local IDs of the edges intersecting at this vertex\n // 1: 0 if the edge is pointing away from the vertex, 1 otherwise\n // 2: faces joining at the vertex\n static const uint32_t vertex_mapping[8][3][3];\n\n // This mapping contains the three sets of the two edges for each of the\n // faces joining at a vertex. The indices are mapped to the local edge IDs\n // using the first value field of the 'vertex_mapping' table.\n static const uint32_t face_mapping[3][2];\n};\n\ntemplate \nconst uint32_t mappings::edge_mapping[12][2][2] = {\n {{0, 1}, {0, 1}}, {{1, 2}, {0, 2}}, {{2, 3}, {0, 3}}, {{3, 0}, {0, 4}},\n\n {{0, 4}, {1, 4}}, {{1, 5}, {1, 2}}, {{2, 6}, {2, 3}}, {{3, 7}, {3, 4}},\n\n {{4, 5}, {1, 5}}, {{5, 6}, {2, 5}}, {{6, 7}, {3, 5}}, {{7, 4}, {4, 5}}};\n\ntemplate \nconst uint32_t mappings::vertex_mapping[8][3][3] = {\n {{0, 3, 4}, {0, 1, 0}, {0, 1, 4}}, {{0, 1, 5}, {1, 0, 0}, {0, 1, 2}},\n {{1, 2, 6}, {1, 0, 0}, {0, 2, 3}}, {{2, 3, 7}, {1, 0, 0}, {0, 3, 4}},\n\n {{4, 8, 11}, {1, 0, 1}, {1, 4, 5}}, {{5, 8, 9}, {1, 1, 0}, {1, 2, 5}},\n {{6, 9, 10}, {1, 1, 0}, {2, 3, 5}}, {{7, 10, 11}, {1, 1, 0}, {3, 4, 5}}};\n\ntemplate \nconst uint32_t mappings::face_mapping[3][2] = {\n {0, 1}, {0, 2}, {1, 2}};\n\ntypedef mappings hex_mappings;\n\n} // namespace detail\n\nclass Hexahedron : public detail::hex_mappings {\n public:\n template \n Hexahedron(const vector_t& v0, Types... verts)\n : vertices{{v0, verts...}}, faces(), center(), volume() {\n init();\n }\n\n Hexahedron(const std::array& verts)\n : vertices(verts), faces(), center(), volume() {\n init();\n }\n\n void apply(const Transformation& t) {\n for (auto& v : vertices)\n v = t.scaling * (v + t.translation);\n\n for (auto& f : faces)\n f.apply(t);\n\n center = scalar_t(1.0 / 8.0) *\n std::accumulate(\n vertices.begin(), vertices.end(), vector_t::Zero().eval());\n\n volume = calcVolume();\n }\n\n scalar_t surfaceArea() const {\n scalar_t area(0);\n for (const auto& f : faces)\n area += f.area;\n\n return area;\n }\n\n private:\n void init() {\n // 0: v3, v2, v1, v0\n faces[0] =\n Quadrilateral(vertices[3], vertices[2], vertices[1], vertices[0]);\n\n // 1: v0, v1, v5, v4\n faces[1] =\n Quadrilateral(vertices[0], vertices[1], vertices[5], vertices[4]);\n\n // 2: v1, v2, v6, v5\n faces[2] =\n Quadrilateral(vertices[1], vertices[2], vertices[6], vertices[5]);\n\n // 3: v2, v3, v7, v6\n faces[3] =\n Quadrilateral(vertices[2], vertices[3], vertices[7], vertices[6]);\n\n // 4: v3, v0, v4, v7\n faces[4] =\n Quadrilateral(vertices[3], vertices[0], vertices[4], vertices[7]);\n\n // 5: v4, v5, v6, v7\n faces[5] =\n Quadrilateral(vertices[4], vertices[5], vertices[6], vertices[7]);\n\n center = scalar_t(1.0 / 8.0) *\n std::accumulate(\n vertices.begin(), vertices.end(), vector_t::Zero().eval());\n\n volume = calcVolume();\n }\n\n scalar_t calcVolume() const {\n vector_t diagonal(vertices[6] - vertices[0]);\n\n return scalar_t(1.0 / 6.0) *\n diagonal.dot(\n ((vertices[1] - vertices[0]).cross(vertices[2] - vertices[5])) +\n ((vertices[4] - vertices[0]).cross(vertices[5] - vertices[7])) +\n ((vertices[3] - vertices[0]).cross(vertices[7] - vertices[2])));\n }\n\n public:\n std::array vertices;\n std::array faces;\n vector_t center;\n scalar_t volume;\n};\n\nclass Sphere {\n public:\n Sphere(const vector_t& c, scalar_t r)\n : center(c), radius(r), volume(scalar_t(4.0 / 3.0 * pi) * r * r * r) {}\n\n scalar_t capVolume(scalar_t h) const {\n if (h <= scalar_t(0))\n return scalar_t(0);\n else if (h >= scalar_t(2) * radius)\n return volume;\n else\n return scalar_t(pi / 3.0) * h * h * (scalar_t(3) * radius - h);\n }\n\n scalar_t capSurfaceArea(scalar_t h) const {\n if (h <= scalar_t(0))\n return scalar_t(0);\n else if (h >= scalar_t(2) * radius)\n return surfaceArea();\n else\n return scalar_t(2 * pi) * radius * h;\n }\n\n scalar_t diskArea(scalar_t h) const {\n if (h <= scalar_t(0) || h >= scalar_t(2) * radius)\n return scalar_t(0);\n else\n return pi * h * (scalar_t(2) * radius - h);\n }\n\n scalar_t surfaceArea() const {\n return (scalar_t(4) * pi) * (radius * radius);\n }\n\n public:\n vector_t center;\n scalar_t radius;\n scalar_t volume;\n};\n\nclass Plane {\n public:\n Plane(const vector_t& c, const vector_t& n) : center(c), normal(n) {}\n\n public:\n vector_t center;\n vector_t normal;\n};\n\nclass AABB {\n public:\n AABB(\n const vector_t& minimum =\n vector_t::Constant(std::numeric_limits::infinity()),\n const vector_t& maximum =\n vector_t::Constant(-std::numeric_limits::infinity()))\n : min(minimum), max(maximum) {}\n\n bool intersects(const AABB& aabb) const {\n if ((min.array() > aabb.max.array()).any() ||\n (max.array() < aabb.min.array()).any())\n return false;\n\n return true;\n }\n\n AABB overlap(const AABB& aabb) const {\n return AABB(min.cwiseMax(aabb.min), max.cwiseMin(aabb.max));\n }\n\n bool contains(const vector_t& p) const {\n if ((p.array() < min.array()).any() || (p.array() > max.array()).any())\n return false;\n\n return true;\n }\n\n void include(const vector_t& point) {\n min = min.cwiseMin(point);\n max = max.cwiseMax(point);\n }\n\n template \n void include(const std::array& points) {\n for (const auto& p : points)\n include(p);\n }\n\n scalar_t volume() const {\n vector_t size(max - min);\n\n return size[0] * size[1] * size[2];\n }\n\n public:\n vector_t min, max;\n};\n\n// Decomposition of a tetrahedron into 4 tetrahedra.\ninline void decompose(\n const Tetrahedron& tet, std::array& tets) {\n tets[0] = Tetrahedron(\n tet.vertices[0], tet.vertices[1], tet.vertices[2], tet.center);\n\n tets[1] = Tetrahedron(\n tet.vertices[0], tet.vertices[1], tet.center, tet.vertices[3]);\n\n tets[2] = Tetrahedron(\n tet.vertices[1], tet.vertices[2], tet.center, tet.vertices[3]);\n\n tets[3] = Tetrahedron(\n tet.vertices[2], tet.vertices[0], tet.center, tet.vertices[3]);\n}\n\n// Decomposition of a hexahedron into 2 wedges.\ninline void decompose(const Hexahedron& hex, std::array& wedges) {\n wedges[0] = Wedge(\n hex.vertices[0], hex.vertices[1], hex.vertices[2], hex.vertices[4],\n hex.vertices[5], hex.vertices[6]);\n\n wedges[1] = Wedge(\n hex.vertices[0], hex.vertices[2], hex.vertices[3], hex.vertices[4],\n hex.vertices[6], hex.vertices[7]);\n}\n\n// Decomposition of a hexahedron into 5 tetrahedra.\ninline void decompose(const Hexahedron& hex, std::array& tets) {\n tets[0] = Tetrahedron(\n hex.vertices[0], hex.vertices[1], hex.vertices[2], hex.vertices[5]);\n\n tets[1] = Tetrahedron(\n hex.vertices[0], hex.vertices[2], hex.vertices[7], hex.vertices[5]);\n\n tets[2] = Tetrahedron(\n hex.vertices[0], hex.vertices[2], hex.vertices[3], hex.vertices[7]);\n\n tets[3] = Tetrahedron(\n hex.vertices[0], hex.vertices[5], hex.vertices[7], hex.vertices[4]);\n\n tets[4] = Tetrahedron(\n hex.vertices[2], hex.vertices[7], hex.vertices[5], hex.vertices[6]);\n}\n\n// Decomposition of a hexahedron into 6 tetrahedra.\ninline void decompose(const Hexahedron& hex, std::array& tets) {\n tets[0] = Tetrahedron(\n hex.vertices[0], hex.vertices[5], hex.vertices[7], hex.vertices[4]);\n\n tets[1] = Tetrahedron(\n hex.vertices[0], hex.vertices[1], hex.vertices[7], hex.vertices[5]);\n\n tets[2] = Tetrahedron(\n hex.vertices[1], hex.vertices[6], hex.vertices[7], hex.vertices[5]);\n\n tets[3] = Tetrahedron(\n hex.vertices[0], hex.vertices[7], hex.vertices[2], hex.vertices[3]);\n\n tets[4] = Tetrahedron(\n hex.vertices[0], hex.vertices[7], hex.vertices[1], hex.vertices[2]);\n\n tets[5] = Tetrahedron(\n hex.vertices[1], hex.vertices[7], hex.vertices[6], hex.vertices[2]);\n}\n\ninline bool contains(const Sphere& s, const vector_t& p) {\n return (s.center - p).squaredNorm() <= s.radius * s.radius;\n}\n\n// The (convex!) polygon is assumed to be planar, making this a 2D problem.\n// Check the projection of the point onto the plane of the polygon for\n// containment within the polygon.\ntemplate \nbool contains(const Polygon& poly, const vector_t& point) {\n const vector_t proj(\n point - poly.normal.dot(point - poly.center) * poly.normal);\n\n for (size_t n = 0; n < poly.vertices.size(); ++n) {\n const auto& v0 = poly.vertices[n];\n const auto& v1 = poly.vertices[(n + 1) % poly.vertices.size()];\n vector_t base(scalar_t(0.5) * (v0 + v1));\n vector_t edge(v1 - v0);\n\n // Note: Only the sign of the projection is of interest, so this vector\n // does not have to be normalized.\n vector_t dir(edge.cross(poly.normal));\n\n // Check whether the projection of the point lies inside of the\n // polygon.\n if (dir.dot(proj - base) > scalar_t(0)) return false;\n }\n\n return true;\n}\n\ninline bool contains(const Tetrahedron& tet, const vector_t& p) {\n for (const auto& f : tet.faces)\n if (f.normal.dot(p - f.center) > scalar_t(0)) return false;\n\n return true;\n}\n\ninline bool contains(const Wedge& wedge, const vector_t& p) {\n for (const auto& f : wedge.faces)\n if (f.normal.dot(p - f.center) > scalar_t(0)) return false;\n\n return true;\n}\n\ninline bool contains(const Hexahedron& hex, const vector_t& p) {\n for (const auto& f : hex.faces)\n if (f.normal.dot(p - f.center) > scalar_t(0)) return false;\n\n return true;\n}\n\ninline bool intersect(const Sphere& s, const Plane& p) {\n scalar_t proj = p.normal.dot(s.center - p.center);\n\n return proj * proj - s.radius * s.radius < scalar_t(0);\n}\n\ntemplate \ninline bool intersect(const Sphere& s, const Polygon& poly) {\n return intersect(s, Plane(poly.center, poly.normal)) &&\n contains(poly, s.center);\n}\n\ninline std::pair, size_t> lineSphereIntersection(\n const vector_t& origin, const vector_t& direction, const Sphere& s) {\n std::array solutions = {\n {std::numeric_limits::infinity(),\n std::numeric_limits::infinity()}};\n\n vector_t originRel(origin - s.center);\n scalar_t a = direction.squaredNorm();\n\n if (a == scalar_t(0)) return std::make_pair(solutions, 0);\n\n scalar_t b = scalar_t(2) * direction.dot(originRel);\n scalar_t c = originRel.squaredNorm() - s.radius * s.radius;\n\n scalar_t discriminant = b * b - scalar_t(4) * a * c;\n if (discriminant > scalar_t(0)) {\n // Two real roots.\n scalar_t q =\n scalar_t(-0.5) * (b + std::copysign(std::sqrt(discriminant), b));\n\n solutions[0] = q / a;\n solutions[1] = c / q;\n\n if (solutions[0] > solutions[1]) std::swap(solutions[0], solutions[1]);\n\n return std::make_pair(solutions, 2);\n } else if (std::abs(discriminant) == scalar_t(0)) {\n // Double real root.\n solutions[0] = (scalar_t(-0.5) * b) / a;\n solutions[1] = solutions[0];\n\n return std::make_pair(solutions, 1);\n } else {\n // No real roots.\n return std::make_pair(solutions, 0);\n }\n}\n\nnamespace detail {\n\n// Calculate the volume of a regularized spherical wedge defined by the radius,\n// the distance of the intersection point from the center of the sphere and the\n// angle.\ninline scalar_t regularizedWedge(scalar_t r, scalar_t d, scalar_t alpha) {\n#ifndef NDEBUG\n // Clamp slight deviations of the angle to valid range.\n if (alpha < scalar_t(0) && alpha > -detail::tinyEpsilon) alpha = scalar_t(0);\n\n if (alpha > scalar_t(0.5 * pi) && alpha < scalar_t(0.5 * pi) + tinyEpsilon)\n alpha = scalar_t(0.5 * pi);\n#endif\n\n // Check the parameters for validity (debug version only).\n assert(r > scalar_t(0));\n assert(d >= scalar_t(0) && d <= r);\n assert(alpha >= scalar_t(0) && alpha <= scalar_t(0.5 * pi));\n\n const scalar_t sinAlpha = std::sin(alpha);\n const scalar_t cosAlpha = std::cos(alpha);\n\n const scalar_t a = d * sinAlpha;\n const scalar_t b = std::sqrt(std::abs(r * r - d * d));\n const scalar_t c = d * cosAlpha;\n\n return scalar_t(1.0 / 3.0) * a * b * c +\n a * (scalar_t(1.0 / 3.0) * a * a - r * r) * std::atan2(b, c) +\n scalar_t(2.0 / 3.0) * r * r * r *\n std::atan2(sinAlpha * b, cosAlpha * r);\n}\n\n// Wrapper around the above function handling correctly handling the case of\n// alpha > pi/2 and negative z.\ninline scalar_t regularizedWedge(\n scalar_t r, scalar_t d, scalar_t alpha, scalar_t z) {\n if (z >= scalar_t(0)) {\n if (alpha > scalar_t(0.5 * pi)) {\n scalar_t h = r - z;\n\n return scalar_t(pi / 3.0) * h * h * (scalar_t(3) * r - h) -\n regularizedWedge(r, d, pi - alpha);\n } else {\n return regularizedWedge(r, d, alpha);\n }\n } else {\n scalar_t vHem = scalar_t(2.0 / 3.0 * pi) * r * r * r;\n\n if (alpha > scalar_t(0.5 * pi)) {\n return vHem - regularizedWedge(r, d, pi - alpha);\n } else {\n scalar_t h = r + z;\n scalar_t vCap = scalar_t(pi / 3.0) * h * h * (scalar_t(3) * r - h);\n\n return vHem - (vCap - regularizedWedge(r, d, alpha));\n }\n }\n}\n\n// Calculate the surface area of a regularized spherical wedge defined by the\n// radius, the distance of the intersection point from the center of the sphere\n// and the angle.\n// Ref: Gibson, K. D. & Scheraga, H. A.: Exact calculation of the volume and\n// surface area of fused hard-sphere molecules with unequal atomic radii,\n// Molecular Physics, 1987, 62, 1247-1265\ninline scalar_t regularizedWedgeArea(scalar_t r, scalar_t z, scalar_t alpha) {\n#ifndef NDEBUG\n // Clamp slight deviations of the angle to valid range.\n if (alpha < scalar_t(0) && alpha > -detail::tinyEpsilon) alpha = scalar_t(0);\n\n if (alpha > pi && alpha < pi + tinyEpsilon) alpha = pi;\n#endif\n\n // Check the parameters for validity (debug version only).\n assert(r > scalar_t(0));\n assert(z >= -r && z <= r);\n assert(alpha >= scalar_t(0) && alpha <= pi);\n\n if (alpha < tinyEpsilon || std::abs(r * r - z * z) <= tinyEpsilon)\n return scalar_t(0);\n\n const scalar_t sinAlpha = std::sin(alpha);\n const scalar_t cosAlpha = std::cos(alpha);\n const scalar_t factor = scalar_t(1) / std::sqrt(std::abs(r * r - z * z));\n\n // Clamp slight deviations of the argument to acos() to valid range.\n const scalar_t arg0 = clamp(\n r * cosAlpha * factor, scalar_t(-1), scalar_t(1), detail::tinyEpsilon);\n\n const scalar_t arg1 = clamp(\n (z * cosAlpha * factor) / sinAlpha, scalar_t(-1), scalar_t(1),\n detail::tinyEpsilon);\n\n // Check the argument to acos() for validity (debug version only).\n assert(scalar_t(-1) <= arg0 && arg0 <= scalar_t(1));\n assert(scalar_t(-1) <= arg1 && arg1 <= scalar_t(1));\n\n return scalar_t(2) * r * r * std::acos(arg0) -\n scalar_t(2) * r * z * std::acos(arg1);\n}\n\n} // namespace detail\n\n// Depending on the dimensionality, either the volume or external surface area\n// of the general wedge is computed.\ntemplate \ninline scalar_t generalWedge(\n const Sphere& s, const Plane& p0, const Plane& p1, const vector_t& d) {\n static_assert(\n Dim == 2 || Dim == 3, \"Invalid dimensionality, must be 2 or 3.\");\n\n scalar_t dist(d.stableNorm());\n\n if (dist < detail::tinyEpsilon) {\n // The wedge (almost) touches the center, the volume depends only on\n // the angle.\n scalar_t angle = pi - detail::angle(p0.normal, p1.normal);\n\n if (Dim == 2) {\n return scalar_t(2) * s.radius * s.radius * angle;\n } else {\n return scalar_t(2.0 / 3.0) * s.radius * s.radius * s.radius * angle;\n }\n }\n\n scalar_t s0 = d.dot(p0.normal);\n scalar_t s1 = d.dot(p1.normal);\n\n // Detect degenerated general spherical wedge that can be treated as\n // a regularized spherical wedge.\n if (std::abs(s0) < detail::tinyEpsilon ||\n std::abs(s1) < detail::tinyEpsilon) {\n scalar_t angle = pi - detail::angle(p0.normal, p1.normal);\n\n if (Dim == 2) {\n return detail::regularizedWedgeArea(\n s.radius, std::abs(s0) > std::abs(s1) ? s0 : s1, angle);\n } else {\n return detail::regularizedWedge(\n s.radius, dist, angle, std::abs(s0) > std::abs(s1) ? s0 : s1);\n }\n }\n\n vector_t dUnit(d * (scalar_t(1) / dist));\n if (dist < detail::largeEpsilon)\n dUnit = detail::gramSchmidt(p0.normal.cross(p1.normal), dUnit)[1];\n\n // Check the planes specify a valid setup (debug version only).\n assert(p0.normal.dot(p1.center - p0.center) <= scalar_t(0));\n assert(p1.normal.dot(p0.center - p1.center) <= scalar_t(0));\n\n // Calculate the angles between the vector from the sphere center\n // to the intersection line and the normal vectors of the two planes.\n scalar_t alpha0 = detail::angle(p0.normal, dUnit);\n scalar_t alpha1 = detail::angle(p1.normal, dUnit);\n\n scalar_t dir0 = dUnit.dot((s.center + d) - p0.center);\n scalar_t dir1 = dUnit.dot((s.center + d) - p1.center);\n\n if (s0 >= scalar_t(0) && s1 >= scalar_t(0)) {\n alpha0 = scalar_t(0.5 * pi) - std::copysign(alpha0, dir0);\n alpha1 = scalar_t(0.5 * pi) - std::copysign(alpha1, dir1);\n\n if (Dim == 2) {\n return detail::regularizedWedgeArea(s.radius, s0, alpha0) +\n detail::regularizedWedgeArea(s.radius, s1, alpha1);\n } else {\n return detail::regularizedWedge(s.radius, dist, alpha0, s0) +\n detail::regularizedWedge(s.radius, dist, alpha1, s1);\n }\n } else if (s0 < scalar_t(0) && s1 < scalar_t(0)) {\n alpha0 =\n scalar_t(0.5 * pi) + std::copysign(scalar_t(1), dir0) * (alpha0 - pi);\n\n alpha1 =\n scalar_t(0.5 * pi) + std::copysign(scalar_t(1), dir1) * (alpha1 - pi);\n\n if (Dim == 2) {\n return s.surfaceArea() -\n (detail::regularizedWedgeArea(s.radius, -s0, alpha0) +\n detail::regularizedWedgeArea(s.radius, -s1, alpha1));\n } else {\n return s.volume - (detail::regularizedWedge(s.radius, dist, alpha0, -s0) +\n detail::regularizedWedge(s.radius, dist, alpha1, -s1));\n }\n } else {\n alpha0 = scalar_t(0.5 * pi) -\n std::copysign(scalar_t(1), dir0 * s0) *\n (alpha0 - (s0 < scalar_t(0) ? pi : scalar_t(0)));\n\n alpha1 = scalar_t(0.5 * pi) -\n std::copysign(scalar_t(1), dir1 * s1) *\n (alpha1 - (s1 < scalar_t(0) ? pi : scalar_t(0)));\n\n if (Dim == 2) {\n scalar_t area0 =\n detail::regularizedWedgeArea(s.radius, std::abs(s0), alpha0);\n\n scalar_t area1 =\n detail::regularizedWedgeArea(s.radius, std::abs(s1), alpha1);\n\n return std::max(area0, area1) - std::min(area0, area1);\n } else {\n scalar_t volume0 =\n detail::regularizedWedge(s.radius, dist, alpha0, std::abs(s0));\n\n scalar_t volume1 =\n detail::regularizedWedge(s.radius, dist, alpha1, std::abs(s1));\n\n return std::max(volume0, volume1) - std::min(volume0, volume1);\n }\n }\n}\n\ntemplate \nstruct array_size;\n\ntemplate \nstruct array_size> {\n static constexpr size_t value() {\n return N;\n }\n};\n\ntemplate \nconstexpr size_t nrEdges() {\n return std::is_same::value\n ? 12\n : (std::is_same::value\n ? 9\n : (std::is_same::value ? 6 : -1));\n}\n\n// Workaround for the Intel compiler, as it does not yet support constexpr for\n// template arguments.\ntemplate \nstruct element_trait {\n static const size_t nrVertices =\n array_size::value();\n\n static const size_t nrFaces = array_size::value();\n};\n\n// Depending on the dimensionality, either the volume or external surface area\n// of the general wedge is computed.\ntemplate \nscalar_t generalWedge(\n const Sphere& sphere, const Element& element, size_t edge,\n const std::array, nrEdges()>&\n intersections) {\n static_assert(\n Dim == 2 || Dim == 3, \"Invalid dimensionality, must be 2 or 3.\");\n\n const auto& f0 = element.faces[Element::edge_mapping[edge][1][0]];\n const auto& f1 = element.faces[Element::edge_mapping[edge][1][1]];\n\n vector_t edgeCenter(\n scalar_t(0.5) * ((intersections[edge][0] +\n element.vertices[Element::edge_mapping[edge][0][0]]) +\n (intersections[edge][1] +\n element.vertices[Element::edge_mapping[edge][0][1]])));\n\n Plane p0(f0.center, f0.normal);\n Plane p1(f1.center, f1.normal);\n\n return generalWedge(sphere, p0, p1, edgeCenter - sphere.center);\n}\n\ntemplate \nscalar_t overlap(const Sphere& sOrig, const Element& elementOrig) {\n static_assert(\n std::is_same::value ||\n std::is_same::value ||\n std::is_same::value,\n \"Invalid element type detected.\");\n\n // Construct AABBs and perform a coarse overlap detection.\n AABB sAABB(\n sOrig.center - vector_t::Constant(sOrig.radius),\n sOrig.center + vector_t::Constant(sOrig.radius));\n\n AABB eAABB;\n eAABB.include(elementOrig.vertices);\n\n if (!sAABB.intersects(eAABB)) return scalar_t(0);\n\n // Use scaled and shifted versions of the sphere and the element.\n Transformation transformation(-sOrig.center, scalar_t(1) / sOrig.radius);\n\n Sphere s(vector_t::Zero(), scalar_t(1));\n\n Element element(elementOrig);\n element.apply(transformation);\n\n // Constants: Number of vertices and faces.\n static const size_t nrVertices = element_trait::nrVertices;\n static const size_t nrFaces = element_trait::nrFaces;\n\n size_t vOverlap = 0;\n // Check whether the vertices lie on or outside of the sphere.\n for (const auto& vertex : element.vertices)\n if ((s.center - vertex).squaredNorm() <= s.radius * s.radius) ++vOverlap;\n\n // Check for trivial case: All vertices inside of the sphere, resulting in\n // a full overlap.\n if (vOverlap == nrVertices) return elementOrig.volume;\n\n // Sanity check: All faces of the mesh element have to be planar.\n for (const auto& face : element.faces)\n if (!face.isPlanar())\n throw std::runtime_error(\"Non-planer face detected in element!\");\n\n // Sets of overlapping primitives.\n std::bitset vMarked;\n std::bitset()> eMarked;\n std::bitset fMarked;\n\n // Initial value: Volume of the full sphere.\n scalar_t result = s.volume;\n\n // The intersection points between the single edges and the sphere, this\n // is needed later on.\n std::array, nrEdges()> eIntersections;\n\n // Process all edges of the element.\n for (size_t n = 0; n < nrEdges(); ++n) {\n vector_t start(element.vertices[Element::edge_mapping[n][0][0]]);\n vector_t direction(\n element.vertices[Element::edge_mapping[n][0][1]] - start);\n\n auto solutions = lineSphereIntersection(start, direction, s);\n\n // No intersection between the edge and the sphere, where intersection\n // points close to the surface of the sphere are ignored.\n // Or:\n // The sphere cuts the edge twice, no vertex is inside of the\n // sphere, but the case of the edge only touching the sphere has to\n // be avoided.\n if (!solutions.second ||\n (solutions.first[0] >= scalar_t(1) - detail::mediumEpsilon) ||\n solutions.first[1] <= detail::mediumEpsilon ||\n (solutions.first[0] > scalar_t(0) && solutions.first[1] < scalar_t(1) &&\n (solutions.first[1] - solutions.first[0] < detail::largeEpsilon))) {\n continue;\n } else {\n vMarked[Element::edge_mapping[n][0][0]] =\n solutions.first[0] < scalar_t(0);\n\n vMarked[Element::edge_mapping[n][0][1]] =\n solutions.first[1] > scalar_t(1);\n }\n\n // Store the two intersection points of the edge with the sphere for\n // later usage.\n eIntersections[n][0] =\n solutions.first[0] * direction +\n (start - element.vertices[Element::edge_mapping[n][0][0]]);\n\n eIntersections[n][1] =\n solutions.first[1] * direction +\n (start - element.vertices[Element::edge_mapping[n][0][1]]);\n\n eMarked[n] = true;\n\n // If the edge is marked as having an overlap, the two faces forming it\n // have to be marked as well.\n fMarked[Element::edge_mapping[n][1][0]] = true;\n fMarked[Element::edge_mapping[n][1][1]] = true;\n }\n\n // Check whether the dependencies for a vertex intersection are fulfilled.\n for (size_t n = 0; n < nrVertices; ++n) {\n if (!vMarked[n]) continue;\n\n bool edgesValid = true;\n for (size_t eN = 0; eN < 3; ++eN) {\n size_t edgeId = Element::vertex_mapping[n][0][eN];\n edgesValid &= eMarked[edgeId];\n }\n\n // If not all three edges intersecting at this vertex where marked, the\n // sphere is only touching.\n if (!edgesValid) vMarked[n] = false;\n }\n\n // Process all faces of the element, ignoring the edges as those where\n // already checked above.\n for (size_t n = 0; n < nrFaces; ++n)\n if (intersect(s, element.faces[n])) fMarked[n] = true;\n\n // Trivial case: The center of the sphere overlaps the element, but the\n // sphere does not intersect any of the faces of the element, meaning the\n // sphere is completely contained within the element.\n if (!fMarked.count() && contains(element, s.center)) return sOrig.volume;\n\n // Spurious intersection: The initial intersection test was positive, but\n // the detailed checks revealed no overlap.\n if (!vMarked.count() && !eMarked.count() && !fMarked.count())\n return scalar_t(0);\n\n // Iterate over all the marked faces and subtract the volume of the cap cut\n // off by the plane.\n for (size_t n = 0; n < nrFaces; ++n) {\n if (!fMarked[n]) continue;\n\n const auto& f = element.faces[n];\n scalar_t dist = f.normal.dot(s.center - f.center);\n scalar_t vCap = s.capVolume(s.radius + dist);\n\n result -= vCap;\n }\n\n // Handle the edges and add back the volume subtracted twice above in the\n // processing of the faces.\n for (size_t n = 0; n < nrEdges(); ++n) {\n if (!eMarked[n]) continue;\n\n scalar_t edgeCorrection =\n generalWedge<3, Element>(s, element, n, eIntersections);\n\n result += edgeCorrection;\n }\n\n // Handle the vertices and subtract the volume added twice above in the\n // processing of the edges.\n for (size_t n = 0; n < nrVertices; ++n) {\n if (!vMarked[n]) continue;\n\n // Collect the points where the three edges intersecting at this\n // vertex intersect the sphere.\n // Both the relative and the absolute positions are required.\n std::array intersectionPointsRelative;\n std::array intersectionPoints;\n for (size_t e = 0; e < 3; ++e) {\n auto edgeIdx = Element::vertex_mapping[n][0][e];\n intersectionPointsRelative[e] =\n eIntersections[edgeIdx][Element::vertex_mapping[n][1][e]];\n\n intersectionPoints[e] =\n intersectionPointsRelative[e] + element.vertices[n];\n }\n\n // This triangle is constructed by hand to have more freedom of how\n // the normal vector is calculated.\n Triangle coneTria;\n coneTria.vertices = {\n {intersectionPoints[0], intersectionPoints[1], intersectionPoints[2]}};\n\n coneTria.center = scalar_t(1.0 / 3.0) * std::accumulate(\n intersectionPoints.begin(),\n intersectionPoints.end(),\n vector_t::Zero().eval());\n\n // Calculate the normal of the triangle defined by the intersection\n // points in relative coordinates to improve accuracy.\n // Also use double the normal precision to calculate this normal.\n coneTria.normal = detail::triangleNormal(\n intersectionPointsRelative[0], intersectionPointsRelative[1],\n intersectionPointsRelative[2]);\n\n // The area of this triangle is never needed, so it is set to an\n // invalid value.\n coneTria.area = std::numeric_limits::infinity();\n\n std::array, 3> distances;\n for (size_t i = 0; i < 3; ++i)\n distances[i] =\n std::make_pair(i, intersectionPointsRelative[i].squaredNorm());\n\n std::sort(\n distances.begin(), distances.end(),\n [](const std::pair& a,\n const std::pair& b) -> bool {\n return a.second < b.second;\n });\n\n if (distances[1].second < distances[2].second * detail::largeEpsilon) {\n // Use the general spherical wedge defined by the edge with the\n // non-degenerated intersection point and the normals of the\n // two faces forming it.\n scalar_t correction = generalWedge<3, Element>(\n s, element, Element::vertex_mapping[n][0][distances[2].first],\n eIntersections);\n\n result -= correction;\n\n continue;\n }\n\n scalar_t tipTetVolume =\n scalar_t(1.0 / 6.0) *\n std::abs(-intersectionPointsRelative[2].dot(\n (intersectionPointsRelative[0] - intersectionPointsRelative[2])\n .cross(\n intersectionPointsRelative[1] -\n intersectionPointsRelative[2])));\n\n // Make sure the normal points in the right direction i.e. away from\n // the center of the element.\n if (coneTria.normal.dot(element.center - coneTria.center) > scalar_t(0)) {\n coneTria.normal = -coneTria.normal;\n }\n\n Plane plane(coneTria.center, coneTria.normal);\n\n scalar_t dist = coneTria.normal.dot(s.center - coneTria.center);\n scalar_t capVolume = s.capVolume(s.radius + dist);\n\n // The cap volume is tiny, so the corrections will be even smaller.\n // There is no way to actually calculate them with reasonable\n // precision, so just the volume of the tetrahedron at the tip is\n // used.\n if (capVolume < detail::tinyEpsilon) {\n result -= tipTetVolume;\n continue;\n }\n\n // Calculate the volume of the three spherical segments between\n // the faces joining at the vertex and the plane through the\n // intersection points.\n scalar_t segmentVolume = 0;\n\n for (size_t e = 0; e < 3; ++e) {\n const auto& f = element.faces[Element::vertex_mapping[n][2][e]];\n uint32_t e0 = Element::face_mapping[e][0];\n uint32_t e1 = Element::face_mapping[e][1];\n\n vector_t center(\n scalar_t(0.5) * (intersectionPoints[e0] + intersectionPoints[e1]));\n\n scalar_t wedgeVolume = generalWedge<3>(\n s, plane, Plane(f.center, -f.normal), center - s.center);\n\n segmentVolume += wedgeVolume;\n }\n\n // Calculate the volume of the cone and clamp it to zero.\n scalar_t coneVolume =\n std::max(tipTetVolume + capVolume - segmentVolume, scalar_t(0));\n\n // Sanity check: detect negative cone volume.\n assert(coneVolume > -std::sqrt(detail::tinyEpsilon));\n\n result -= coneVolume;\n\n // Sanity check: detect negative intermediate result.\n assert(result > -std::sqrt(detail::tinyEpsilon));\n }\n\n // In case of different sized objects the error can become quite large,\n // so a relative limit is used.\n scalar_t maxOverlap = std::min(s.volume, element.volume);\n const scalar_t limit(\n std::sqrt(std::numeric_limits::epsilon()) * maxOverlap);\n\n // Clamp tiny negative volumes to zero.\n if (result < scalar_t(0) && result > -limit) return scalar_t(0);\n\n // Clamp results slightly too large.\n if (result > maxOverlap && result - maxOverlap < limit)\n return std::min(sOrig.volume, elementOrig.volume);\n\n // Perform a sanity check on the final result (debug version only).\n assert(result >= scalar_t(0) && result <= maxOverlap);\n\n // Scale the overlap volume back for the original objects.\n result = (result / s.volume) * sOrig.volume;\n\n return result;\n}\n\ntemplate \nscalar_t overlap(const Sphere& s, Iterator eBegin, Iterator eEnd) {\n scalar_t sum(0);\n\n for (Iterator it = eBegin; it != eEnd; ++it)\n sum += overlap(s, *it);\n\n return sum;\n}\n\n// Calculate the surface area of the sphere and the element that are contained\n// within the common or intersecting part of the geometries, respectively.\n// The returned array of size (N + 2), with N being the number of vertices,\n// holds (in this order):\n// - surface area of the region of the sphere intersecting the element\n// - for each face of the element: area contained within the sphere\n// - total surface area of the element intersecting the sphere\ntemplate <\n typename Element, size_t NrFaces = element_trait::nrFaces + 2>\nauto overlapArea(const Sphere& sOrig, const Element& elementOrig)\n -> std::array {\n static_assert(\n NrFaces == element_trait::nrFaces + 2,\n \"Invalid number of faces for the element provided.\");\n\n static_assert(\n std::is_same::value ||\n std::is_same::value ||\n std::is_same::value,\n \"Invalid element type detected.\");\n\n // Constants: Number of vertices and faces.\n static const size_t nrVertices = element_trait::nrVertices;\n static const size_t nrFaces = element_trait::nrFaces;\n\n // Initial value: Zero overlap.\n std::array result;\n result.fill(scalar_t(0));\n\n // Construct AABBs and perform a coarse overlap detection.\n AABB sAABB(\n sOrig.center - vector_t::Constant(sOrig.radius),\n sOrig.center + vector_t::Constant(sOrig.radius));\n\n AABB eAABB;\n eAABB.include(elementOrig.vertices);\n\n if (!sAABB.intersects(eAABB)) return result;\n\n // Use scaled and shifted versions of the sphere and the element.\n Transformation transformation(-sOrig.center, scalar_t(1) / sOrig.radius);\n\n Sphere s(vector_t::Zero(), scalar_t(1));\n\n Element element(elementOrig);\n element.apply(transformation);\n\n size_t vOverlap = 0;\n // Check whether the vertices lie on or outside of the sphere.\n for (const auto& vertex : element.vertices)\n if ((s.center - vertex).squaredNorm() <= s.radius * s.radius) ++vOverlap;\n\n // Check for trivial case: All vertices inside of the sphere, resulting in\n // a full coverage of all faces.\n if (vOverlap == nrVertices) {\n for (size_t n = 0; n < nrFaces; ++n) {\n result[n + 1] = elementOrig.faces[n].area;\n result[nrFaces + 1] += elementOrig.faces[n].area;\n }\n\n return result;\n }\n\n // Sanity check: All faces of the mesh element have to be planar.\n for (const auto& face : element.faces)\n if (!face.isPlanar())\n throw std::runtime_error(\"Non-planer face detected in element!\");\n\n // Sets of overlapping primitives.\n std::bitset vMarked;\n std::bitset()> eMarked;\n std::bitset fMarked;\n\n // The intersection points between the single edges and the sphere, this\n // is needed later on.\n std::array, nrEdges()> eIntersections;\n\n // Cache the squared radius of the disk formed by the intersection between\n // the planes defined by each face and the sphere.\n std::array intersectionRadiusSq;\n\n // Process all edges of the element.\n for (size_t n = 0; n < nrEdges(); ++n) {\n vector_t start(element.vertices[Element::edge_mapping[n][0][0]]);\n vector_t direction(\n element.vertices[Element::edge_mapping[n][0][1]] - start);\n\n auto solutions = lineSphereIntersection(start, direction, s);\n\n // No intersection between the edge and the sphere, where intersection\n // points close to the surface of the sphere are ignored.\n // Or:\n // The sphere cuts the edge twice, no vertex is inside of the\n // sphere, but the case of the edge only touching the sphere has to\n // be avoided.\n if (!solutions.second ||\n solutions.first[0] >= scalar_t(1) - detail::mediumEpsilon ||\n solutions.first[1] <= detail::mediumEpsilon ||\n (solutions.first[0] > scalar_t(0) && solutions.first[1] < scalar_t(1) &&\n solutions.first[1] - solutions.first[0] < detail::largeEpsilon)) {\n continue;\n } else {\n vMarked[Element::edge_mapping[n][0][0]] =\n solutions.first[0] < scalar_t(0);\n\n vMarked[Element::edge_mapping[n][0][1]] =\n solutions.first[1] > scalar_t(1);\n }\n\n // Store the two intersection points of the edge with the sphere for\n // later usage.\n eIntersections[n][0] =\n solutions.first[0] * direction +\n (start - element.vertices[Element::edge_mapping[n][0][0]]);\n\n eIntersections[n][1] =\n solutions.first[1] * direction +\n (start - element.vertices[Element::edge_mapping[n][0][1]]);\n\n eMarked[n] = true;\n\n // If the edge is marked as having an overlap, the two faces forming it\n // have to be marked as well.\n fMarked[Element::edge_mapping[n][1][0]] = true;\n fMarked[Element::edge_mapping[n][1][1]] = true;\n }\n\n // Check whether the dependencies for a vertex intersection are fulfilled.\n for (size_t n = 0; n < nrVertices; ++n) {\n if (!vMarked[n]) continue;\n\n bool edgesValid = true;\n for (size_t eN = 0; eN < 3; ++eN) {\n size_t edgeId = Element::vertex_mapping[n][0][eN];\n edgesValid &= eMarked[edgeId];\n }\n\n // If not all three edges intersecting at this vertex where marked, the\n // sphere is only touching.\n if (!edgesValid) vMarked[n] = false;\n }\n\n // Process all faces of the element, ignoring the edges as those where\n // already checked above.\n for (size_t n = 0; n < nrFaces; ++n)\n if (intersect(s, element.faces[n])) fMarked[n] = true;\n\n // Trivial case: The center of the sphere overlaps the element, but the\n // sphere does not intersect any of the faces of the element, meaning the\n // sphere is completely contained within the element.\n if (!fMarked.count() && contains(element, s.center)) {\n result[0] = sOrig.surfaceArea();\n\n return result;\n }\n\n // Spurious intersection: The initial intersection test was positive, but\n // the detailed checks revealed no overlap.\n if (!vMarked.count() && !eMarked.count() && !fMarked.count()) return result;\n\n // Initial value for the surface of the sphere: Surface area of the full\n // sphere.\n result[0] = s.surfaceArea();\n\n // Iterate over all the marked faces and calculate the area of the disk\n // defined by the plane as well as the cap surfaces.\n for (size_t n = 0; n < nrFaces; ++n) {\n if (!fMarked[n]) continue;\n\n const auto& f = element.faces[n];\n scalar_t dist = f.normal.dot(s.center - f.center);\n result[0] -= s.capSurfaceArea(s.radius + dist);\n result[n + 1] = s.diskArea(s.radius + dist);\n }\n\n // Handle the edges and subtract the area of the respective disk cut off by\n // the edge and add back the surface area of the spherical wedge defined\n // by the edge.\n for (size_t n = 0; n < nrEdges(); ++n) {\n if (!eMarked[n]) continue;\n\n result[0] += generalWedge<2, Element>(s, element, n, eIntersections);\n\n // The intersection points are relative to the vertices forming the\n // edge.\n const vector_t chord =\n ((element.vertices[Element::edge_mapping[n][0][0]] +\n eIntersections[n][0]) -\n (element.vertices[Element::edge_mapping[n][0][1]] +\n eIntersections[n][1]));\n\n const scalar_t chordLength = chord.stableNorm();\n\n // Each edge belongs to two faces, indexed via\n // Element::edge_mapping[n][1][{0,1}].\n for (size_t e = 0; e < 2; ++e) {\n const auto faceIdx = Element::edge_mapping[n][1][e];\n const auto& f = element.faces[faceIdx];\n\n // Height of the spherical cap cut off by the plane containing the\n // face.\n const scalar_t dist = f.normal.dot(s.center - f.center) + s.radius;\n intersectionRadiusSq[faceIdx] = dist * (scalar_t(2) * s.radius - dist);\n\n // Calculate the height of the triangular segment in the plane of\n // the base.\n const scalar_t factor = std::sqrt(std::max(\n scalar_t(0), intersectionRadiusSq[faceIdx] -\n scalar_t(0.25) * chordLength * chordLength));\n\n const scalar_t theta =\n scalar_t(2) * std::atan2(chordLength, scalar_t(2) * factor);\n\n scalar_t area = scalar_t(0.5) * intersectionRadiusSq[faceIdx] *\n (theta - std::sin(theta));\n\n // FIXME: Might not be necessary to use the center of the chord.\n const vector_t chordCenter =\n scalar_t(0.5) * ((element.vertices[Element::edge_mapping[n][0][0]] +\n eIntersections[n][0]) +\n (element.vertices[Element::edge_mapping[n][0][1]] +\n eIntersections[n][1]));\n\n const vector_t proj(\n s.center - f.normal.dot(s.center - f.center) * f.normal);\n\n // If the projected sphere center and the face center fall on\n // opposite sides of the edge, the area has to be inverted.\n if (chord.cross(proj - chordCenter)\n .dot(chord.cross(f.center - chordCenter)) < scalar_t(0)) {\n area = intersectionRadiusSq[faceIdx] * pi - area;\n }\n\n result[faceIdx + 1] -= area;\n }\n }\n\n // Handle the vertices and add the area subtracted twice above in the\n // processing of the edges.\n\n // First, handle the spherical surface area of the intersection.\n // This is to a large part code duplicated from the volume calculation.\n // TODO: Unify the area and volume calculation to remove duplicate code.\n for (size_t n = 0; n < nrVertices; ++n) {\n if (!vMarked[n]) continue;\n\n // Collect the points where the three edges intersecting at this\n // vertex intersect the sphere.\n // Both the relative and the absolute positions are required.\n std::array intersectionPointsRelative;\n std::array intersectionPoints;\n for (size_t e = 0; e < 3; ++e) {\n auto edgeIdx = Element::vertex_mapping[n][0][e];\n intersectionPointsRelative[e] =\n eIntersections[edgeIdx][Element::vertex_mapping[n][1][e]];\n\n intersectionPoints[e] =\n intersectionPointsRelative[e] + element.vertices[n];\n }\n\n // This triangle is constructed by hand to have more freedom of how\n // the normal vector is calculated.\n Triangle coneTria;\n coneTria.vertices = {\n {intersectionPoints[0], intersectionPoints[1], intersectionPoints[2]}};\n\n coneTria.center = scalar_t(1.0 / 3.0) * std::accumulate(\n intersectionPoints.begin(),\n intersectionPoints.end(),\n vector_t::Zero().eval());\n\n // Calculate the normal of the triangle defined by the intersection\n // points in relative coordinates to improve accuracy.\n // Also use double the normal precision to calculate this normal.\n coneTria.normal = detail::triangleNormal(\n intersectionPointsRelative[0], intersectionPointsRelative[1],\n intersectionPointsRelative[2]);\n\n // The area of this triangle is never needed, so it is set to an\n // invalid value.\n coneTria.area = std::numeric_limits::infinity();\n\n std::array, 3> distances;\n for (size_t i = 0; i < 3; ++i)\n distances[i] =\n std::make_pair(i, intersectionPointsRelative[i].squaredNorm());\n\n std::sort(\n distances.begin(), distances.end(),\n [](const std::pair& a,\n const std::pair& b) -> bool {\n return a.second < b.second;\n });\n\n if (distances[1].second < distances[2].second * detail::largeEpsilon) {\n // Use the general spherical wedge defined by the edge with the\n // non-degenerated intersection point and the normals of the\n // two faces forming it.\n scalar_t correction = generalWedge<2, Element>(\n s, element, Element::vertex_mapping[n][0][distances[2].first],\n eIntersections);\n\n result[0] -= correction;\n\n continue;\n }\n\n // Make sure the normal points in the right direction, i.e., away from\n // the center of the element.\n if (coneTria.normal.dot(element.center - coneTria.center) > scalar_t(0)) {\n coneTria.normal = -coneTria.normal;\n }\n\n Plane plane(coneTria.center, coneTria.normal);\n\n scalar_t dist = coneTria.normal.dot(s.center - coneTria.center);\n scalar_t capSurface = s.capSurfaceArea(s.radius + dist);\n\n // If cap surface area is small, the corrections will be even smaller.\n // There is no way to actually calculate them with reasonable\n // precision, so they are just ignored.\n if (capSurface < detail::largeEpsilon) continue;\n\n // Calculate the surface area of the three spherical segments between\n // the faces joining at the vertex and the plane through the\n // intersection points.\n scalar_t segmentSurface = 0;\n for (size_t e = 0; e < 3; ++e) {\n const auto& f = element.faces[Element::vertex_mapping[n][2][e]];\n uint32_t e0 = Element::face_mapping[e][0];\n uint32_t e1 = Element::face_mapping[e][1];\n\n vector_t center(\n scalar_t(0.5) * (intersectionPoints[e0] + intersectionPoints[e1]));\n\n segmentSurface += generalWedge<2>(\n s, plane, Plane(f.center, -f.normal), center - s.center);\n }\n\n // Calculate the surface area of the cone and clamp it to zero.\n scalar_t coneSurface = std::max(capSurface - segmentSurface, scalar_t(0));\n\n result[0] -= coneSurface;\n\n // Sanity checks: detect negative/excessively large intermediate\n // result.\n assert(result[0] > -std::sqrt(detail::tinyEpsilon));\n assert(result[0] < s.surfaceArea() + detail::tinyEpsilon);\n }\n\n // Second, correct the intersection area of the facets.\n for (size_t n = 0; n < nrVertices; ++n) {\n if (!vMarked[n]) continue;\n\n // Iterate over all the faces joining at this vertex.\n for (size_t f = 0; f < 3; ++f) {\n // Determine the two edges of this face intersecting at the\n // vertex.\n uint32_t e0 = Element::face_mapping[f][0];\n uint32_t e1 = Element::face_mapping[f][1];\n std::array edgeIndices = {\n {Element::vertex_mapping[n][0][e0],\n Element::vertex_mapping[n][0][e1]}};\n\n // Extract the (relative) intersection points of these edges with\n // the sphere furthest from the vertex.\n std::array intersectionPoints = {\n {eIntersections[edgeIndices[0]][Element::vertex_mapping[n][1][e0]],\n\n eIntersections[edgeIndices[1]][Element::vertex_mapping[n][1][e1]]}};\n\n // Together with the vertex, this determines the triangle\n // representing one part of the correction.\n const scalar_t triaArea =\n scalar_t(0.5) *\n (intersectionPoints[0].cross(intersectionPoints[1])).stableNorm();\n\n // The second component is the segment defined by the face and the\n // intersection points.\n const scalar_t chordLength =\n (intersectionPoints[0] - intersectionPoints[1]).stableNorm();\n\n const auto faceIdx = Element::vertex_mapping[n][2][f];\n\n // TODO: Cache theta for each edge.\n const scalar_t theta =\n scalar_t(2) *\n std::atan2(\n chordLength,\n scalar_t(2) * std::sqrt(std::max(\n scalar_t(0), intersectionRadiusSq[faceIdx] -\n scalar_t(0.25) * chordLength *\n chordLength)));\n\n scalar_t segmentArea = scalar_t(0.5) * intersectionRadiusSq[faceIdx] *\n (theta - std::sin(theta));\n\n // Determine if the (projected) center of the sphere lies within\n // the triangle or not. If not, the segment area has to be\n // corrected.\n const vector_t d(\n scalar_t(0.5) * (intersectionPoints[0] + intersectionPoints[1]));\n\n const auto& face = element.faces[faceIdx];\n const vector_t proj(\n s.center - face.normal.dot(s.center - face.center) * face.normal);\n\n if (d.dot((proj - element.vertices[n]) - d) > scalar_t(0)) {\n segmentArea = intersectionRadiusSq[faceIdx] * pi - segmentArea;\n }\n\n result[faceIdx + 1] += triaArea + segmentArea;\n\n // Sanity checks: detect excessively large intermediate result.\n assert(\n result[faceIdx + 1] <\n element.faces[faceIdx].area + std::sqrt(detail::largeEpsilon));\n }\n }\n\n // Scale the surface areas back for the original objects and clamp\n // values within reasonable limits.\n const scalar_t scaling = sOrig.radius / s.radius;\n const scalar_t sLimit(\n std::sqrt(std::numeric_limits::epsilon()) * s.surfaceArea());\n\n // As the precision of the area calculation deteriorates quickly with a\n // increasing size ratio between the element and the sphere, the precision\n // limit applied to the sphere is used as the lower limit for the facets.\n const scalar_t fLimit(std::max(\n sLimit, std::sqrt(std::numeric_limits::epsilon()) *\n element.surfaceArea()));\n\n // Sanity checks: detect negative/excessively large results for the\n // surface area of the facets.\n#ifndef NDEBUG\n for (size_t n = 0; n < nrFaces; ++n) {\n assert(result[n + 1] > -fLimit);\n assert(result[n + 1] <= element.faces[n].area + fLimit);\n }\n#endif // NDEBUG\n\n // Surface of the sphere.\n result[0] = detail::clamp(result[0], scalar_t(0), s.surfaceArea(), sLimit);\n result[0] *= (scaling * scaling);\n\n // Surface of the mesh element.\n for (size_t f = 0; f < nrFaces; ++f) {\n auto& value = result[f + 1];\n value = detail::clamp(value, scalar_t(0), element.faces[f].area, fLimit);\n\n value = value * (scaling * scaling);\n }\n\n result.back() =\n std::accumulate(result.begin() + 1, result.end() - 1, scalar_t(0));\n\n // Perform some more sanity checks on the final result (debug version\n // only).\n assert(scalar_t(0) <= result[0] && result[0] <= sOrig.surfaceArea());\n\n assert(\n scalar_t(0) <= result.back() &&\n result.back() <= elementOrig.surfaceArea());\n\n return result;\n}\n\n#endif // OVERLAP_HPP\n", "meta": {"hexsha": "5d499b29a9e8ca591334ea16fcab5be5b1297894", "size": 70257, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/overlap/overlap.hpp", "max_stars_repo_name": "ChristopherKotthoff/Aphros-with-GraphContraction", "max_stars_repo_head_hexsha": "18af982a50e350a8bf6979ae5bd25b2ef4d3792a", "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/overlap/overlap.hpp", "max_issues_repo_name": "ChristopherKotthoff/Aphros-with-GraphContraction", "max_issues_repo_head_hexsha": "18af982a50e350a8bf6979ae5bd25b2ef4d3792a", "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/overlap/overlap.hpp", "max_forks_repo_name": "ChristopherKotthoff/Aphros-with-GraphContraction", "max_forks_repo_head_hexsha": "18af982a50e350a8bf6979ae5bd25b2ef4d3792a", "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.7081005587, "max_line_length": 126, "alphanum_fraction": 0.6298731799, "num_tokens": 19756, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.685949442167993, "lm_q2_score": 0.6548947425132315, "lm_q1q2_score": 0.4492246833057026}} {"text": "//==============================================================================\n// Copyright 2003 - 2011 LASMEA UMR 6602 CNRS/Univ. Clermont II\n// Copyright 2009 - 2011 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_OPERATOR_FUNCTIONS_COMPLEX_GENERIC_MULTIPLIES_HPP_INCLUDED\n#define NT2_OPERATOR_FUNCTIONS_COMPLEX_GENERIC_MULTIPLIES_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#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost { namespace simd { namespace ext\n{\n // complex/complex\n BOOST_DISPATCH_IMPLEMENT ( multiplies_, tag::cpu_, (A0)\n , ((generic_< complex_< arithmetic_ > >))\n ((generic_< complex_< arithmetic_ > >))\n )\n {\n typedef A0 result_type;\n NT2_FUNCTOR_CALL_REPEAT(2)\n {\n typedef typename nt2::meta::as_real::type r_type;\n const r_type a = nt2::real(a0);\n const r_type b = nt2::imag(a0);\n const r_type c = nt2::real(a1);\n const r_type d = nt2::imag(a1);\n result_type r(fma(a,c,-b*d), fma(a,d,b*c));\n#ifndef BOOST_SIMD_NO_INVALIDS\n typedef typename meta::as_logical::type l_type;\n l_type test = is_finite(r);\n if (nt2::all(test)) return r;\n l_type cur = nt2::logical_andnot(is_real(a0), test);\n if (nt2::any(cur))\n {\n r = if_else(cur, nt2::multiplies(a, a1), r);\n test = logical_or(test, cur);\n if (nt2::all(test)) return r;\n }\n cur = nt2::logical_andnot(is_imag(a0), test);\n if (nt2::any(cur))\n {\n r = if_else(cur, nt2::mul_i(nt2::multiplies(b, a1)), r);\n test = logical_or(test, cur);\n if (nt2::all(test)) return r;\n }\n cur = nt2::logical_andnot(is_real(a1), test);\n if (nt2::any(cur))\n {\n r = if_else(cur, nt2::multiplies(c, a0), r);\n test = logical_or(test, cur);\n if (nt2::all(test)) return r;\n }\n cur = nt2::logical_andnot(is_imag(a1), test);\n if (nt2::any(cur))\n {\n r = if_else(cur, nt2::mul_i(nt2::multiplies(d, a0)), r);\n test = logical_or(test, cur);\n if (nt2::all(test)) return r;\n }\n #endif\n return r;\n }\n };\n\n // complex/real\n BOOST_DISPATCH_IMPLEMENT ( multiplies_, tag::cpu_, (A0)(A1)\n , ((generic_< arithmetic_ >))\n ((generic_< complex_< arithmetic_ > >))\n )\n {\n typedef A1 result_type;\n typedef A0 r_type;\n NT2_FUNCTOR_CALL(2)\n {\n r_type r = a0*nt2::real(a1);\n r_type i = a0*nt2::imag(a1);\n#ifndef BOOST_SIMD_NO_INVALIDS\n typename meta::as_logical::type is_real_a1 = is_real(a1);\n r = if_zero_else(logical_andnot(is_imag(a1), is_real_a1), r);\n i = if_zero_else(is_real_a1, i);\n#endif\n return result_type(r, i);\n }\n };\n\n BOOST_DISPATCH_IMPLEMENT ( multiplies_, tag::cpu_, (A0)(A1)\n , ((generic_< complex_< arithmetic_ > >))\n ((generic_< arithmetic_ >))\n )\n {\n typedef A0 result_type;\n NT2_FUNCTOR_CALL(2)\n {\n return nt2::multiplies(a1, a0);\n }\n };\n BOOST_DISPATCH_IMPLEMENT ( multiplies_, tag::cpu_, (A0)(A1)\n , ((generic_< dry_ < arithmetic_ > >))\n ((generic_< complex_< arithmetic_ > >))\n )\n {\n typedef A1 result_type;\n NT2_FUNCTOR_CALL(2)\n {\n return nt2::multiplies(nt2::real(a0), a1);\n }\n };\n BOOST_DISPATCH_IMPLEMENT ( multiplies_, tag::cpu_, (A0)(A1)\n , ((generic_< complex_< arithmetic_ > >))\n ((generic_< dry_ < arithmetic_ > >))\n )\n {\n typedef A0 result_type;\n NT2_FUNCTOR_CALL(2)\n {\n return nt2::multiplies(a0, nt2::real(a1));\n }\n };\n\n // dry/dry\n BOOST_DISPATCH_IMPLEMENT ( multiplies_, tag::cpu_, (A0)(A1)\n , ((generic_< dry_< arithmetic_ > >))\n ((generic_< dry_< arithmetic_ > >))\n )\n {\n typedef typename nt2::meta::as_dry::type result_type;\n NT2_FUNCTOR_CALL(2)\n {\n return bitwise_cast(nt2::real(a0)*nt2::real(a1));\n }\n };\n\n} } }\n\n#endif\n", "meta": {"hexsha": "406831fae281d348c0333b701baa37e80acfe58d", "size": 5936, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "modules/type/complex/base/include/nt2/operator/functions/complex/generic/multiplies.hpp", "max_stars_repo_name": "psiha/nt2", "max_stars_repo_head_hexsha": "5e829807f6b57b339ca1be918a6b60a2507c54d0", "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/type/complex/base/include/nt2/operator/functions/complex/generic/multiplies.hpp", "max_issues_repo_name": "psiha/nt2", "max_issues_repo_head_hexsha": "5e829807f6b57b339ca1be918a6b60a2507c54d0", "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/type/complex/base/include/nt2/operator/functions/complex/generic/multiplies.hpp", "max_forks_repo_name": "psiha/nt2", "max_forks_repo_head_hexsha": "5e829807f6b57b339ca1be918a6b60a2507c54d0", "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": 35.3333333333, "max_line_length": 80, "alphanum_fraction": 0.5813679245, "num_tokens": 1551, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7577943712746406, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.4491194134876732}} {"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_ACSCPI_HPP_INCLUDED\n#define BOOST_SIMD_FUNCTION_ACSCPI_HPP_INCLUDED\n\n#if defined(DOXYGEN_ONLY)\nnamespace boost { namespace simd\n{\n\n /*!\n\n @ingroup group-trigonometric\n Function object implementing acscpi capabilities\n\n inverse secant in degree: \\f$(1/\\pi) \\arcsin(1/x)\\f$.\n\n @par Semantic:\n\n For every parameter of floating type\n\n @code\n auto r = acscpi(x);\n @endcode\n\n\n @see acsc, acscd, asinpi, sinpi\n\n **/\n Value acscpi(Value const & v0);\n} }\n#endif\n\n#include \n#include \n\n#endif\n", "meta": {"hexsha": "9bf67c4d7d493c43479197679e77f820d87b5f37", "size": 1008, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "third_party/boost/simd/function/acscpi.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/acscpi.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/acscpi.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": 22.4, "max_line_length": 100, "alphanum_fraction": 0.5714285714, "num_tokens": 230, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311956428947, "lm_q2_score": 0.5698526514141571, "lm_q1q2_score": 0.4490046809690305}} {"text": "// #define R_BUILD\n#ifdef R_BUILD\n\n#include \n#include \n// [[Rcpp::depends(RcppEigen)]]\nusing namespace Rcpp;\n\n#else\n\n#include \n\n#include \"List.h\"\n\n#endif\n\n#include \n#include \n\n#include \"Algorithm.h\"\n#include \"AlgorithmGLM.h\"\n#include \"AlgorithmPCA.h\"\n#include \"utilities.h\"\n#include \"workflow.h\"\n\ntypedef Eigen::Triplet triplet;\n\nusing namespace Eigen;\nusing namespace std;\n\n// [[Rcpp::export]]\nList abessGLM_API(Eigen::MatrixXd x, Eigen::MatrixXd y, int n, int p, int normalize_type, Eigen::VectorXd weight,\n int algorithm_type, int model_type, int max_iter, int exchange_num, int path_type, bool is_warm_start,\n int ic_type, double ic_coef, int Kfold, Eigen::VectorXi sequence, Eigen::VectorXd lambda_seq,\n int s_min, int s_max, double lambda_min, double lambda_max, int nlambda, int screening_size,\n Eigen::VectorXi g_index, Eigen::VectorXi always_select, int primary_model_fit_max_iter,\n double primary_model_fit_epsilon, bool early_stop, bool approximate_Newton, int thread,\n bool covariance_update, bool sparse_matrix, int splicing_type, int sub_search,\n Eigen::VectorXi cv_fold_id, Eigen::VectorXi A_init) {\n#ifdef _OPENMP\n // Eigen::initParallel();\n int max_thread = omp_get_max_threads();\n if (thread == 0 || thread > max_thread) {\n thread = max_thread;\n }\n\n Eigen::setNbThreads(thread);\n omp_set_num_threads(thread);\n\n#endif\n int algorithm_list_size = max(thread, Kfold);\n vector *> algorithm_list_uni_dense(\n algorithm_list_size);\n vector *> algorithm_list_mul_dense(\n algorithm_list_size);\n vector> *>\n algorithm_list_uni_sparse(algorithm_list_size);\n vector> *>\n algorithm_list_mul_sparse(algorithm_list_size);\n\n for (int i = 0; i < algorithm_list_size; i++) {\n if (!sparse_matrix) {\n if (model_type == 1) {\n abessLm *temp = new abessLm(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->covariance_update = covariance_update;\n algorithm_list_uni_dense[i] = temp;\n } else if (model_type == 2) {\n abessLogistic *temp = new abessLogistic(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->approximate_Newton = approximate_Newton;\n algorithm_list_uni_dense[i] = temp;\n } else if (model_type == 3) {\n abessPoisson *temp = new abessPoisson(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->approximate_Newton = approximate_Newton;\n algorithm_list_uni_dense[i] = temp;\n } else if (model_type == 4) {\n abessCox *temp = new abessCox(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->approximate_Newton = approximate_Newton;\n algorithm_list_uni_dense[i] = temp;\n } else if (model_type == 5) {\n abessMLm *temp = new abessMLm(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->covariance_update = covariance_update;\n algorithm_list_mul_dense[i] = temp;\n } else if (model_type == 6) {\n abessMultinomial *temp = new abessMultinomial(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->approximate_Newton = approximate_Newton;\n algorithm_list_mul_dense[i] = temp;\n } else if (model_type == 8) {\n abessGamma *temp = new abessGamma(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->approximate_Newton = approximate_Newton;\n algorithm_list_uni_dense[i] = temp;\n } else if (model_type == 9) {\n abessOrdinal *temp = new abessOrdinal(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n algorithm_list_mul_dense[i] = temp;\n }\n } else {\n if (model_type == 1) {\n abessLm> *temp = new abessLm>(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->covariance_update = covariance_update;\n algorithm_list_uni_sparse[i] = temp;\n } else if (model_type == 2) {\n abessLogistic> *temp = new abessLogistic>(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->approximate_Newton = approximate_Newton;\n algorithm_list_uni_sparse[i] = temp;\n } else if (model_type == 3) {\n abessPoisson> *temp = new abessPoisson>(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->approximate_Newton = approximate_Newton;\n algorithm_list_uni_sparse[i] = temp;\n } else if (model_type == 4) {\n abessCox> *temp = new abessCox>(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->approximate_Newton = approximate_Newton;\n algorithm_list_uni_sparse[i] = temp;\n } else if (model_type == 5) {\n abessMLm> *temp = new abessMLm>(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->covariance_update = covariance_update;\n algorithm_list_mul_sparse[i] = temp;\n } else if (model_type == 6) {\n abessMultinomial> *temp = new abessMultinomial>(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->approximate_Newton = approximate_Newton;\n algorithm_list_mul_sparse[i] = temp;\n } else if (model_type == 8) {\n abessGamma> *temp = new abessGamma>(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->approximate_Newton = approximate_Newton;\n algorithm_list_uni_sparse[i] = temp;\n } else if (model_type == 9) {\n abessOrdinal> *temp = new abessOrdinal>(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n algorithm_list_mul_sparse[i] = temp;\n }\n }\n }\n\n // parameter list\n Parameters parameters(sequence, lambda_seq, s_min, s_max);\n\n List out_result;\n if (!sparse_matrix) {\n if (y.cols() == 1 && model_type != 5 && model_type != 6) {\n Eigen::VectorXd y_vec = y.col(0).eval();\n\n out_result = abessWorkflow(\n x, y_vec, n, p, normalize_type, weight, algorithm_type, path_type, is_warm_start, ic_type, ic_coef,\n Kfold, parameters, screening_size, g_index, early_stop, thread, sparse_matrix, cv_fold_id, A_init,\n algorithm_list_uni_dense);\n } else {\n out_result = abessWorkflow(\n x, y, n, p, normalize_type, weight, algorithm_type, path_type, is_warm_start, ic_type, ic_coef, Kfold,\n parameters, screening_size, g_index, early_stop, thread, sparse_matrix, cv_fold_id, A_init,\n algorithm_list_mul_dense);\n }\n } else {\n Eigen::SparseMatrix sparse_x(n, p);\n\n // std::vector tripletList;\n // tripletList.reserve(x.rows());\n // for (int i = 0; i < x.rows(); i++)\n // {\n // tripletList.push_back(triplet(int(x(i, 1)), int(x(i, 2)), x(i, 0)));\n // }\n // sparse_x.setFromTriplets(tripletList.begin(), tripletList.end());\n\n sparse_x.reserve(x.rows());\n for (int i = 0; i < x.rows(); i++) {\n sparse_x.insert(int(x(i, 1)), int(x(i, 2))) = x(i, 0);\n }\n sparse_x.makeCompressed();\n\n if (y.cols() == 1 && model_type != 5 && model_type != 6) {\n Eigen::VectorXd y_vec = y.col(0).eval();\n\n out_result = abessWorkflow>(\n sparse_x, y_vec, n, p, normalize_type, weight, algorithm_type, path_type, is_warm_start, ic_type,\n ic_coef, Kfold, parameters, screening_size, g_index, early_stop, thread, sparse_matrix, cv_fold_id,\n A_init, algorithm_list_uni_sparse);\n } else {\n out_result = abessWorkflow>(\n sparse_x, y, n, p, normalize_type, weight, algorithm_type, path_type, is_warm_start, ic_type, ic_coef,\n Kfold, parameters, screening_size, g_index, early_stop, thread, sparse_matrix, cv_fold_id, A_init,\n algorithm_list_mul_sparse);\n }\n }\n\n for (int i = 0; i < algorithm_list_size; i++) {\n delete algorithm_list_uni_dense[i];\n delete algorithm_list_mul_dense[i];\n delete algorithm_list_uni_sparse[i];\n delete algorithm_list_mul_sparse[i];\n }\n\n return out_result;\n};\n\n// [[Rcpp::export]]\nList abessPCA_API(Eigen::MatrixXd x, int n, int p, int normalize_type, Eigen::VectorXd weight, Eigen::MatrixXd sigma,\n int max_iter, int exchange_num, int path_type, bool is_warm_start, int ic_type, double ic_coef,\n int Kfold, Eigen::MatrixXi sequence, int s_min, int s_max, int screening_size,\n Eigen::VectorXi g_index, Eigen::VectorXi always_select, bool early_stop, int thread,\n bool sparse_matrix, int splicing_type, int sub_search, Eigen::VectorXi cv_fold_id, int pca_num,\n Eigen::VectorXi A_init) {\n /* this function for abessPCA only (model_type == 7) */\n\n#ifdef _OPENMP\n // Eigen::initParallel();\n int max_thread = omp_get_max_threads();\n if (thread == 0 || thread > max_thread) {\n thread = max_thread;\n }\n\n Eigen::setNbThreads(thread);\n omp_set_num_threads(thread);\n#endif\n int model_type = 7, algorithm_type = 6;\n Eigen::VectorXd lambda_seq = Eigen::VectorXd::Zero(1);\n int lambda_min = 0, lambda_max = 0, nlambda = 100;\n int primary_model_fit_max_iter = 1;\n double primary_model_fit_epsilon = 1e-3;\n int pca_n = -1;\n sub_search = 0;\n if (!sparse_matrix && n != x.rows()) {\n pca_n = n;\n n = x.rows();\n }\n Eigen::VectorXd y_vec = Eigen::VectorXd::Zero(n);\n\n //////////////////// function generate_algorithm_pointer() ////////////////////////////\n int algorithm_list_size = max(thread, Kfold);\n vector *> algorithm_list_uni_dense(\n algorithm_list_size);\n vector> *>\n algorithm_list_uni_sparse(algorithm_list_size);\n for (int i = 0; i < algorithm_list_size; i++) {\n if (!sparse_matrix) {\n abessPCA *temp = new abessPCA(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->is_cv = Kfold > 1;\n temp->pca_n = pca_n;\n temp->sigma = sigma;\n algorithm_list_uni_dense[i] = temp;\n } else {\n abessPCA> *temp = new abessPCA>(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->is_cv = Kfold > 1;\n temp->pca_n = pca_n;\n temp->sigma = sigma;\n algorithm_list_uni_sparse[i] = temp;\n }\n }\n\n // call `abessWorkflow` for result\n#ifdef R_BUILD\n List out_result(pca_num);\n#else\n List out_result;\n#endif\n List out_result_next;\n int num = 0;\n\n if (!sparse_matrix) {\n while (num++ < pca_num) {\n int pca_support_size_num = sequence.col(num - 1).sum();\n Eigen::VectorXi pca_support_size(pca_support_size_num);\n // map sequence matrix to support.size\n int non_zero_num = 0;\n for (int i = 0; i < sequence.rows(); i++) {\n if (sequence(i, num - 1) == 1) {\n pca_support_size(non_zero_num++) = i + 1;\n }\n }\n\n // parameter list\n Parameters parameters(pca_support_size, lambda_seq, s_min, s_max);\n\n out_result_next = abessWorkflow(\n x, y_vec, n, p, normalize_type, weight, algorithm_type, path_type, is_warm_start, ic_type, ic_coef,\n Kfold, parameters, screening_size, g_index, early_stop, thread, sparse_matrix, cv_fold_id, A_init,\n algorithm_list_uni_dense);\n Eigen::VectorXd beta_next;\n#ifdef R_BUILD\n beta_next = out_result_next[\"beta\"];\n#else\n out_result_next.get_value_by_name(\"beta\", beta_next);\n#endif\n if (num == 1) {\n#ifdef R_BUILD\n if (pca_num > 1) {\n out_result(0) = out_result_next;\n } else {\n out_result = out_result_next;\n }\n#else\n out_result = out_result_next;\n#endif\n } else {\n#ifdef R_BUILD\n // Eigen::MatrixXd beta_new(p, num);\n // Eigen::VectorXd temp = out_result[\"beta\"];\n // Eigen::Map temp2(temp.data(), p, num - 1);\n // beta_new << temp2, beta_next;\n // out_result[\"beta\"] = beta_new;\n out_result(num - 1) = out_result_next;\n#else\n out_result.combine_beta(beta_next);\n#endif\n }\n\n if (num < pca_num) {\n Eigen::MatrixXd temp = beta_next * beta_next.transpose();\n if (Kfold > 1) {\n x -= x * temp;\n } else {\n Eigen::MatrixXd temp1 = temp * sigma;\n sigma += temp1 * temp - temp1 - temp1.transpose();\n for (int i = 0; i < algorithm_list_size; i++) {\n abessPCA *pca_model =\n dynamic_cast *>(algorithm_list_uni_dense[i]);\n if (pca_model) {\n // cout << \"update Sigma\"<sigma = sigma;\n }\n }\n }\n }\n }\n } else {\n Eigen::SparseMatrix sparse_x(n, p);\n\n // std::vector tripletList;\n // tripletList.reserve(x.rows());\n // for (int i = 0; i < x.rows(); i++)\n // {\n // tripletList.push_back(triplet(int(x(i, 1)), int(x(i, 2)), x(i, 0)));\n // }\n // sparse_x.setFromTriplets(tripletList.begin(), tripletList.end());\n\n sparse_x.reserve(x.rows());\n for (int i = 0; i < x.rows(); i++) {\n sparse_x.insert(int(x(i, 1)), int(x(i, 2))) = x(i, 0);\n }\n sparse_x.makeCompressed();\n\n while (num++ < pca_num) {\n int pca_support_size_num = sequence.col(num - 1).sum();\n Eigen::VectorXi pca_support_size(pca_support_size_num);\n // map sequence matrix to support.size\n int non_zero_num = 0;\n for (int i = 0; i < sequence.rows(); i++) {\n if (sequence(i, num - 1) == 1) {\n pca_support_size(non_zero_num++) = i + 1;\n }\n }\n\n // parameter list\n Parameters parameters(pca_support_size, lambda_seq, s_min, s_max);\n\n out_result_next = abessWorkflow>(\n sparse_x, y_vec, n, p, normalize_type, weight, algorithm_type, path_type, is_warm_start, ic_type,\n ic_coef, Kfold, parameters, screening_size, g_index, early_stop, thread, sparse_matrix, cv_fold_id,\n A_init, algorithm_list_uni_sparse);\n Eigen::VectorXd beta_next;\n#ifdef R_BUILD\n beta_next = out_result_next[\"beta\"];\n#else\n out_result_next.get_value_by_name(\"beta\", beta_next);\n#endif\n if (num == 1) {\n#ifdef R_BUILD\n if (pca_num > 1) {\n out_result(0) = out_result_next;\n } else {\n out_result = out_result_next;\n }\n#else\n out_result = out_result_next;\n#endif\n } else {\n#ifdef R_BUILD\n // Eigen::MatrixXd beta_new(p, num);\n // Eigen::VectorXd temp = out_result[\"beta\"];\n // Eigen::Map temp2(temp.data(), p, num - 1);\n // beta_new << temp2, beta_next;\n // out_result[\"beta\"] = beta_new;\n out_result(num - 1) = out_result_next;\n#else\n out_result.combine_beta(beta_next);\n#endif\n }\n\n // update for next PCA\n if (num < pca_num) {\n Eigen::MatrixXd temp = beta_next * beta_next.transpose();\n if (Kfold > 1) {\n sparse_x = sparse_x - sparse_x * temp;\n } else {\n Eigen::MatrixXd temp1 = temp * sigma;\n sigma += temp1 * temp - temp1 - temp1.transpose();\n for (int i = 0; i < algorithm_list_size; i++) {\n abessPCA> *pca_model =\n dynamic_cast> *>(algorithm_list_uni_sparse[i]);\n if (pca_model) {\n // cout << \"update Sigma\"<sigma = sigma;\n }\n }\n }\n }\n }\n }\n\n for (int i = 0; i < algorithm_list_size; i++) {\n delete algorithm_list_uni_dense[i];\n delete algorithm_list_uni_sparse[i];\n }\n return out_result;\n};\n\n// [[Rcpp::export]]\nList abessRPCA_API(Eigen::MatrixXd x, int n, int p, int max_iter, int exchange_num, int path_type, bool is_warm_start,\n int ic_type, double ic_coef, Eigen::VectorXi sequence,\n Eigen::VectorXd lambda_seq, // rank of L\n int s_min, int s_max, double lambda_min, double lambda_max, int nlambda, int screening_size,\n int primary_model_fit_max_iter, double primary_model_fit_epsilon, Eigen::VectorXi g_index,\n Eigen::VectorXi always_select, bool early_stop, int thread, bool sparse_matrix, int splicing_type,\n int sub_search, Eigen::VectorXi A_init) {\n#ifdef _OPENMP\n // Eigen::initParallel();\n int max_thread = omp_get_max_threads();\n if (thread == 0 || thread > max_thread) {\n thread = max_thread;\n }\n\n Eigen::setNbThreads(thread);\n omp_set_num_threads(thread);\n\n#endif\n int model_type = 10, algorithm_type = 6;\n int Kfold = 1;\n int normalize_type = 0;\n Eigen::VectorXi cv_fold_id = Eigen::VectorXi::Zero(0);\n Eigen::VectorXd weight = Eigen::VectorXd::Ones(n);\n Eigen::VectorXd y_vec = Eigen::VectorXd::Zero(n);\n\n int algorithm_list_size = max(thread, Kfold);\n vector *> algorithm_list_uni_dense(\n algorithm_list_size);\n vector> *>\n algorithm_list_uni_sparse(algorithm_list_size);\n\n for (int i = 0; i < algorithm_list_size; i++) {\n if (!sparse_matrix) {\n abessRPCA *temp = new abessRPCA(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->r = lambda_seq(0);\n algorithm_list_uni_dense[i] = temp;\n } else {\n abessRPCA> *temp = new abessRPCA>(\n algorithm_type, model_type, max_iter, primary_model_fit_max_iter, primary_model_fit_epsilon,\n is_warm_start, exchange_num, always_select, splicing_type, sub_search);\n temp->r = lambda_seq(0);\n algorithm_list_uni_sparse[i] = temp;\n }\n }\n\n // parameter list\n Parameters parameters(sequence, lambda_seq, s_min, s_max);\n\n List out_result;\n if (!sparse_matrix) {\n out_result = abessWorkflow(\n x, y_vec, n, p, normalize_type, weight, algorithm_type, path_type, is_warm_start, ic_type, ic_coef, Kfold,\n parameters, screening_size, g_index, early_stop, thread, sparse_matrix, cv_fold_id, A_init,\n algorithm_list_uni_dense);\n\n } else {\n Eigen::SparseMatrix sparse_x(n, p);\n\n // std::vector tripletList;\n // tripletList.reserve(x.rows());\n // for (int i = 0; i < x.rows(); i++)\n // {\n // tripletList.push_back(triplet(int(x(i, 1)), int(x(i, 2)), x(i, 0)));\n // }\n // sparse_x.setFromTriplets(tripletList.begin(), tripletList.end());\n\n sparse_x.reserve(x.rows());\n for (int i = 0; i < x.rows(); i++) {\n sparse_x.insert(int(x(i, 1)), int(x(i, 2))) = x(i, 0);\n }\n sparse_x.makeCompressed();\n\n out_result = abessWorkflow>(\n sparse_x, y_vec, n, p, normalize_type, weight, algorithm_type, path_type, is_warm_start, ic_type, ic_coef,\n Kfold, parameters, screening_size, g_index, early_stop, thread, sparse_matrix, cv_fold_id, A_init,\n algorithm_list_uni_sparse);\n }\n\n for (int i = 0; i < algorithm_list_size; i++) {\n delete algorithm_list_uni_dense[i];\n delete algorithm_list_uni_sparse[i];\n }\n\n return out_result;\n}\n", "meta": {"hexsha": "c11084d47ca2ccdb6295a089c0b5d4155dac1702", "size": 25567, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/api.cpp", "max_stars_repo_name": "bbayukari/abess", "max_stars_repo_head_hexsha": "3b21b0a58cac6c1464ec9403ffbe4902fee7b890", "max_stars_repo_licenses": ["Intel"], "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/api.cpp", "max_issues_repo_name": "bbayukari/abess", "max_issues_repo_head_hexsha": "3b21b0a58cac6c1464ec9403ffbe4902fee7b890", "max_issues_repo_licenses": ["Intel"], "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/api.cpp", "max_forks_repo_name": "bbayukari/abess", "max_forks_repo_head_hexsha": "3b21b0a58cac6c1464ec9403ffbe4902fee7b890", "max_forks_repo_licenses": ["Intel"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.6996268657, "max_line_length": 120, "alphanum_fraction": 0.6041772597, "num_tokens": 5916, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624789529375, "lm_q2_score": 0.5736784074525096, "lm_q1q2_score": 0.4489965644985545}} {"text": "/**\n* \\file importance_sampling.cpp\n* \\brief main file for importance sampling method to infere the age of edges \nin a network.\n* \\author Guillaume St-Onge\n* \\version 1.0\n* \\date 08/11/2017\n*/\n\n#include \"DynamicNetwork.hpp\"\n#include \"auxiliaryFunctions.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace DynNet;\n\ntypedef boost::random::uniform_01<> uniform_01;\ntypedef boost::random::uniform_int_distribution<> uniform_int;\n\nconst unsigned int CALIBSIZE = 100;\nint main(int argc, char const *argv[])\n{\n\t//Parameters\n\tstring path = argv[1];\n\tdouble gamma = stod(argv[2]);\n\tdouble b = stod(argv[3]);\n\tunsigned int sampleSize = atoi(argv[4]);\n\tdouble seedExponent = stod(argv[5]);\n\tunsigned int seed;\n\tif (argc == 6)\n\t{\n\t\tseed = (unsigned int) std::chrono::high_resolution_clock::now().time_since_epoch().count();\n\t}\n\telse\n\t{\n\t\tseed = atoi(argv[6]);\n\t}\n\n\tunsigned int calibSize;\n\tif (sampleSize > CALIBSIZE)\n\t{\n\t\tcalibSize = CALIBSIZE;\n\t}\n\telse\n\t{\n\t\tcalibSize = sampleSize;\n\t}\n\tpair param(gamma,b);\n\n\t//Load edgeList\n\tvector edgeList = input_edgeList(path);\n\tsize_t M = edgeList.size();\n\n\t//Create unvarying maps associated to the observed network\n\tunordered_map > neighborMap;\n\tunordered_map degreeMap;\n\tedgeIntMap multiplicityMap;\n\tfor (int i = 0; i < edgeList.size(); ++i)\n\t{\n\t\t//edges are assume to be in ascending order\n\t\tneighborMap[edgeList[i].first].insert(edgeList[i].second);\n\t\tneighborMap[edgeList[i].second].insert(edgeList[i].first);\n\t\tif (multiplicityMap.find(edgeList[i]) == \n\t\t\tmultiplicityMap.end())\n\t\t{\n\t\t\tmultiplicityMap[edgeList[i]] = 1;\t\t\t\n\t\t}\n\t\telse\n\t\t{\n\t\t\tmultiplicityMap[edgeList[i]] += 1;\n\t\t}\n\t\tif (degreeMap.find(edgeList[i].first) != degreeMap.end())\n\t\t{\n\t\t\tdegreeMap[edgeList[i].first] += 1;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tdegreeMap[edgeList[i].first] = 1;\n\t\t}\n\t\tif (degreeMap.find(edgeList[i].second) != degreeMap.end())\n\t\t{\n\t\t\tdegreeMap[edgeList[i].second] += 1;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tdegreeMap[edgeList[i].second] = 1;\n\t\t}\n\t}\n\tsize_t N = degreeMap.size();\n\n\t//Initialize mean marginal estimation\n\tunordered_map< edge, vector, \n\t\tboost::hash > meanMarginalMap;\n\tfor (auto iter = multiplicityMap.begin(); iter != multiplicityMap.end(); \n\t\t++iter)\n\t{\n\t\tvector emptyVector(iter->second, 0.);\n\t\tmeanMarginalMap[iter->first] = emptyVector;\n\t}\n\tdouble effectiveWeightSum = 0.;\n\n\t/*=======================================\n\t\tCalibration of the mean logweight\n\t=======================================*/\n\n\tvector calibSample;\n\n\t//Initialize random number generator and seed distribution\n\tRNGType gen(seed);\n\tvector seedWeightVector;\n\tfor (auto iter = edgeList.begin(); iter != edgeList.end() ; ++iter)\n\t{\n\t\tif (iter->first == iter->second)\n\t\t{\n\t\t\tseedWeightVector.push_back(0.);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tseedWeightVector.push_back(pow(degreeMap[iter->first]\n\t\t\t\t*degreeMap[iter->second],seedExponent));\n\t\t}\n\t}\n\tboost::random::discrete_distribution seedDist(seedWeightVector.begin(),\n\t\tseedWeightVector.end());\n\n\t//Get calibrating sample\n\tfor (int n = 0; n < calibSize; ++n)\n\t{\n\t\t//Initialize dynamic network\n\t\tDynamicNetwork net(neighborMap, multiplicityMap);\n\n\t\t//choose a first random edge\n\t\tint seedIndex = seedDist(gen);\n\t\tedge seedEdge = edgeList[seedIndex];\n\t\tdouble seedInvWeight = 1/(seedWeightVector[seedIndex]);\n\t\tnet.init(seedEdge, seedInvWeight);\n\t\t//init degree norm\n\t\tdouble degreeNormalization = 2.; //initial loop are impossible\n\n\t\t//Reconstruct the network\n\t\twhile (net.get_reachableEdgeSet().size() > 0)\n\t\t{\n\t\t\tadd_edge(net, param, degreeNormalization, gen);\n\t\t}\n\t\tcalibSample.push_back(net);\n\t}\n\n\t//Determine mean logweight from calibration\n\tdouble meanLogweight = 0.;\n\tfor (int n = 0; n < calibSize; ++n)\n\t{\n\t\tmeanLogweight += calibSample[n].get_logweight();\t\n\t}\n\tmeanLogweight /= calibSize;\n\n\t//Estimate the mean marginal from the sample\n\tfor (int n = 0; n < calibSize; ++n)\n\t{\n\t\tupdate_meanMarginal(calibSample[n], meanMarginalMap, meanLogweight,\n\t\t\teffectiveWeightSum);\n\t}\n\tcalibSample.clear();\n\n\t/*=======================================\n\t Refining the mean marginal\n\t=======================================*/\n\n\tfor (int n = 0; n < sampleSize-calibSize; ++n)\n\t{\n\t\t//Initialize dynamic network\n\t\tDynamicNetwork net(neighborMap, multiplicityMap);\n\n\t\t//choose a first random edge\n\t\tint seedIndex = seedDist(gen);\n\t\tedge seedEdge = edgeList[seedIndex];\n\t\tdouble seedInvWeight = 1/(seedWeightVector[seedIndex]);\n\t\tnet.init(seedEdge, seedInvWeight);\n\t\t//init degree norm\n\t\tdouble degreeNormalization = 2.; //initial loop are impossible\n\n\t\t//Reconstruct the network\n\t\twhile (net.get_reachableEdgeSet().size() > 0)\n\t\t{\n\t\t\tadd_edge(net, param, degreeNormalization, gen);\n\t\t}\n\t\t\n\t\tupdate_meanMarginal(net, meanMarginalMap, meanLogweight,\n\t\t\teffectiveWeightSum);\n\t}\n\n\t/*=======================================\n\t \t\tOutput the data\n\t=======================================*/\n\tfor (auto iter = meanMarginalMap.begin(); iter != meanMarginalMap.end(); \n\t\t++iter)\n\t{\n\t\tdouble average = 0;\n\t\tfor (int i = 0; i < (iter->second).size(); ++i)\n\t\t{\n\t\t\taverage += (iter->second)[i]/effectiveWeightSum;\n\t\t}\n\t\tfor (int i = 0; i < (iter->second).size(); ++i)\n\t\t{\n\t\t\tcout << (iter->first).first << \" \" << (iter->first).second << \" \" << i << \" \";\n\t\t\tcout << average / double((iter->second).size()) << endl;\n\t\t}\n\t}\n\n\treturn 0;\n}", "meta": {"hexsha": "6b526978bb6cea400caed492b64c60b5552ca2c8", "size": 5562, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "tools/bins/importance_sampling_cpp/src/random_sampling_std.cpp", "max_stars_repo_name": "junipertcy/network-archaeology", "max_stars_repo_head_hexsha": "7cef0de7a388e8dde812e746d50470d167da8a9b", "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": "tools/bins/importance_sampling_cpp/src/random_sampling_std.cpp", "max_issues_repo_name": "junipertcy/network-archaeology", "max_issues_repo_head_hexsha": "7cef0de7a388e8dde812e746d50470d167da8a9b", "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": "tools/bins/importance_sampling_cpp/src/random_sampling_std.cpp", "max_forks_repo_name": "junipertcy/network-archaeology", "max_forks_repo_head_hexsha": "7cef0de7a388e8dde812e746d50470d167da8a9b", "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.6313364055, "max_line_length": 93, "alphanum_fraction": 0.6587558432, "num_tokens": 1585, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6893056167854461, "lm_q2_score": 0.6513548646660542, "lm_q1q2_score": 0.4489825667348353}} {"text": "/*\n * This source code is part of\n *\n * E R K A L E\n * -\n * DFT from Hel\n *\n * Written by Susi Lehtola, 2010-2011\n * Copyright (c) 2010-2011, Susi Lehtola\n *\n * This program is free software; you can redistribute it and/or\n * modify it under the terms of the GNU General Public License\n * as published by the Free Software Foundation; either version 2\n * of the License, or (at your option) any later version.\n */\n\n\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"obara-saika.h\"\n#include \"integrals.h\"\n#include \"mathf.h\"\n\n// For comparison against Huzinaga integrals\n//#define DEBUG\n\narma::mat overlap_int_os(double xa, double ya, double za, double zetaa, const std::vector & carta, double xb, double yb, double zb, double zetab, const std::vector & cartb) {\n // Compute shell of overlap integrals\n\n // Angular momenta of shells\n int am_a=carta[0].l+carta[0].m+carta[0].n;\n int am_b=cartb[0].l+cartb[0].m+cartb[0].n;\n\n // Returned matrix\n arma::mat S(carta.size(),cartb.size());\n S.zeros();\n\n // Get 1d overlaps\n arma::mat ox=overlap_ints_1d(xa,xb,zetaa,zetab,am_a,am_b);\n arma::mat oy=overlap_ints_1d(ya,yb,zetaa,zetab,am_a,am_b);\n arma::mat oz=overlap_ints_1d(za,zb,zetaa,zetab,am_a,am_b);\n\n int la, ma, na;\n int lb, mb, nb;\n double norma, normb;\n\n for(size_t i=0;i10*DBL_EPSILON*fabs(huz(i,j)))\n\tdiff++;\n\n if(diff==0)\n // printf(\"Computed shell of overlaps (%e,%e,%e)-(%e,%e,%e) with zeta=(%e,%e) and am=(%i,%i), the results match.\\n\",xa,ya,za,xb,yb,zb,zetaa,zetab,am_a,am_b);\n ;\n else\n for(size_t i=0;i10*DBL_EPSILON*fabs(huz(i,j))) {\n\t printf(\"Computed overlap (%e,%e,%e)-(%e,%e,%e) with zeta=(%e,%e) and am=(%i,%i,%i)-(%i,%i,%i)\\n\",xa,ya,za,xb,yb,zb,zetaa,zetab,la,ma,na,lb,mb,nb);\n\t printf(\"Huzinaga gives %e, OS gives %e.\\n\",huz(i,j),S(i,j));\n\t }\n\n#endif\n\n return S;\n}\n\nstd::vector overlap_int_pulay_os(double xa, double ya, double za, double zetaa, const std::vector & carta, double xb, double yb, double zb, double zetab, const std::vector & cartb) {\n // Compute shell of overlap integrals\n\n // Angular momenta of shells\n int am_a=carta[0].l+carta[0].m+carta[0].n;\n int am_b=cartb[0].l+cartb[0].m+cartb[0].n;\n\n // Returned matrix\n std::vector S(6);\n for(int ic=0;ic<6;ic++)\n S[ic].zeros(carta.size(),cartb.size());\n\n // Get 1d overlaps\n arma::mat ox=overlap_ints_1d(xa,xb,zetaa,zetab,am_a+1,am_b+1);\n arma::mat oy=overlap_ints_1d(ya,yb,zetaa,zetab,am_a+1,am_b+1);\n arma::mat oz=overlap_ints_1d(za,zb,zetaa,zetab,am_a+1,am_b+1);\n\n int la, ma, na;\n int lb, mb, nb;\n double norma, normb;\n\n for(size_t i=0;i0)\n\tS[0](i,j)-=la*ox(la-1,lb)*oy(ma,mb)*oz(na,nb);\n S[0](i,j)*=-norma*normb;\n\n S[1](i,j)=2*zetaa*ox(la,lb)*oy(ma+1,mb)*oz(na,nb);\n if(ma>0)\n\tS[1](i,j)-=ma*ox(la,lb)*oy(ma-1,mb)*oz(na,nb);\n S[1](i,j)*=-norma*normb;\n\n S[2](i,j)=2*zetaa*ox(la,lb)*oy(ma,mb)*oz(na+1,nb);\n if(na>0)\n\tS[2](i,j)-=na*ox(la,lb)*oy(ma,mb)*oz(na-1,nb);\n S[2](i,j)*=-norma*normb;\n\n // RHS derivatives\n S[3](i,j)=2*zetab*ox(la,lb+1)*oy(ma,mb)*oz(na,nb);\n if(lb>0)\n\tS[3](i,j)-=lb*ox(la,lb-1)*oy(ma,mb)*oz(na,nb);\n S[3](i,j)*=-norma*normb;\n\n S[4](i,j)=2*zetab*ox(la,lb)*oy(ma,mb+1)*oz(na,nb);\n if(mb>0)\n\tS[4](i,j)-=mb*ox(la,lb)*oy(ma,mb-1)*oz(na,nb);\n S[4](i,j)*=-norma*normb;\n\n S[5](i,j)=2*zetab*ox(la,lb)*oy(ma,mb)*oz(na,nb+1);\n if(nb>0)\n\tS[5](i,j)-=nb*ox(la,lb)*oy(ma,mb)*oz(na,nb-1);\n S[5](i,j)*=-norma*normb;\n }\n }\n\n return S;\n}\n\ndouble overlap_int_os(double xa, double ya, double za, double zetaa, int la, int ma, int na, double xb, double yb, double zb, double zetab, int lb, int mb, int nb) {\n return overlap_int_1d(xa,xb,zetaa,zetab,la,lb)*overlap_int_1d(ya,yb,zetaa,zetab,ma,mb)*overlap_int_1d(za,zb,zetaa,zetab,na,nb);\n}\n\ndouble overlap_int_1d(double xa, double xb, double zetaa, double zetab, int la, int lb) {\n return overlap_ints_1d(xa,xb,zetaa,zetab,la,lb)(la,lb);\n}\n\narma::mat overlap_ints_1d(double xa, double xb, double zetaa, double zetab, int la, int lb) {\n // In the following we assume la>lb.\n if(lb0 || lb>0) {\n\n // Generate integrals S_{0,j}\n S(0,1)=xpb*S(0,0);\n for(int j=1;j & carta, double xb, double yb, double zb, double zetab, const std::vector & cartb) {\n // Compute shell of kinetic energy integrals\n\n // Angular momenta of shells\n int am_a=carta[0].l+carta[0].m+carta[0].n;\n int am_b=cartb[0].l+cartb[0].m+cartb[0].n;\n\n // Returned matrix\n arma::mat T(carta.size(),cartb.size());\n\n // Get 1d overlap integrals\n arma::mat ox_arr=overlap_ints_1d(xa,xb,zetaa,zetab,am_a,am_b);\n arma::mat oy_arr=overlap_ints_1d(ya,yb,zetaa,zetab,am_a,am_b);\n arma::mat oz_arr=overlap_ints_1d(za,zb,zetaa,zetab,am_a,am_b);\n\n // Get kinetic energy integrals\n arma::mat kx_arr=derivative_ints_1d(xa,xb,zetaa,zetab,am_a,am_b,2);\n arma::mat ky_arr=derivative_ints_1d(ya,yb,zetaa,zetab,am_a,am_b,2);\n arma::mat kz_arr=derivative_ints_1d(za,zb,zetaa,zetab,am_a,am_b,2);\n\n double ox, oy, oz;\n double kx, ky, kz;\n\n int la, ma, na;\n int lb, mb, nb;\n\n double anorm, bnorm;\n\n for(size_t i=0;i10*DBL_EPSILON*fabs(huz(i,j)))\n\tdiff++;\n\n if(diff==0)\n // printf(\"Computed shell of KE (%e,%e,%e)-(%e,%e,%e) with zeta=(%e,%e) and am=(%i,%i), the results match.\\n\",xa,ya,za,xb,yb,zb,zetaa,zetab,am_a,am_b);\n ;\n else\n for(size_t i=0;i1000*DBL_EPSILON*fabs(huz(i,j))) {\n\t printf(\"Computed KE (%e,%e,%e)-(%e,%e,%e) with zeta=(%e,%e) and am=(%i,%i,%i)-(%i,%i,%i)\\n\",xa,ya,za,xb,yb,zb,zetaa,zetab,la,ma,na,lb,mb,nb);\n\t printf(\"Huzinaga gives %e, OS gives %e.\\n\",huz(i,j),T(i,j));\n\t }\n\n#endif\n\n return T;\n}\n\nstd::vector kinetic_int_pulay_os(double xa, double ya, double za, double zetaa, const std::vector & carta, double xb, double yb, double zb, double zetab, const std::vector & cartb) {\n // Compute shell of kinetic energy integrals\n\n // Angular momenta of shells\n int am_a=carta[0].l+carta[0].m+carta[0].n;\n int am_b=cartb[0].l+cartb[0].m+cartb[0].n;\n\n // Returned matrix\n std::vector T(6);\n for(int ic=0;ic<6;ic++)\n T[ic].zeros(carta.size(),cartb.size());\n\n // Get 1d overlap integrals\n arma::mat ox_arr=overlap_ints_1d(xa,xb,zetaa,zetab,am_a+1,am_b+1);\n arma::mat oy_arr=overlap_ints_1d(ya,yb,zetaa,zetab,am_a+1,am_b+1);\n arma::mat oz_arr=overlap_ints_1d(za,zb,zetaa,zetab,am_a+1,am_b+1);\n\n // Get kinetic energy integrals\n arma::mat kx_arr=derivative_ints_1d(xa,xb,zetaa,zetab,am_a+1,am_b+1,2);\n arma::mat ky_arr=derivative_ints_1d(ya,yb,zetaa,zetab,am_a+1,am_b+1,2);\n arma::mat kz_arr=derivative_ints_1d(za,zb,zetaa,zetab,am_a+1,am_b+1,2);\n\n int la, ma, na;\n int lb, mb, nb;\n\n double ox, oy, oz;\n double oxp, oyp, ozp;\n double oxm, oym, ozm;\n double kx, ky, kz;\n double kxp, kyp, kzp;\n double kxm, kym, kzm;\n\n double anorm, bnorm;\n\n for(size_t i=0;i0) {\n\t oxm=ox_arr(la-1,lb);\n\t kxm=kx_arr(la-1,lb);\n\t T[0](i,j)-=la*(kxm*oy*oz + oxm*ky*oz + oxm*oy*kz);\n\t}\n\tT[0](i,j)*=0.5*anorm*bnorm;\n }\n\n // LHS, derivative acting on y component\n {\n\tox=ox_arr(la,lb);\n\toyp=oy_arr(ma+1,mb);\n\toz=oz_arr(na,nb);\n\n\tkx=kx_arr(la,lb);\n\tkyp=ky_arr(ma+1,mb);\n\tkz=kz_arr(na,nb);\n\n\tT[1](i,j)= 2*zetaa*(kx*oyp*oz + ox*kyp*oz + ox*oyp*kz);\n\tif(ma>0) {\n\t oym=oy_arr(ma-1,mb);\n\t kym=ky_arr(ma-1,mb);\n\t T[1](i,j)-=ma*(kx*oym*oz + ox*kym*oz + ox*oym*kz);\n\t}\n\tT[1](i,j)*=0.5*anorm*bnorm;\n }\n\n // LHS, derivative acting on z component\n {\n\tox=ox_arr(la,lb);\n\toy=oy_arr(ma,mb);\n\tozp=oz_arr(na+1,nb);\n\n\tkx=kx_arr(la,lb);\n\tky=ky_arr(ma,mb);\n\tkzp=kz_arr(na+1,nb);\n\n\tT[2](i,j)= 2*zetaa*(kx*oy*ozp + ox*ky*ozp + ox*oy*kzp);\n\tif(na>0) {\n\t ozm=oz_arr(na-1,nb);\n\t kzm=kz_arr(na-1,nb);\n\t T[2](i,j)-=na*(kx*oy*ozm + ox*ky*ozm + ox*oy*kzm);\n\t}\n\tT[2](i,j)*=0.5*anorm*bnorm;\n }\n\n\n // RHS, derivative acting on x component\n {\n\toxp=ox_arr(la,lb+1);\n\toy=oy_arr(ma,mb);\n\toz=oz_arr(na,nb);\n\n\tkxp=kx_arr(la,lb+1);\n\tky=ky_arr(ma,mb);\n\tkz=kz_arr(na,nb);\n\n\tT[3](i,j)=2*zetab*(kxp*oy*oz + oxp*ky*oz + oxp*oy*kz);\n\tif(lb>0) {\n\t oxm=ox_arr(la,lb-1);\n\t kxm=kx_arr(la,lb-1);\n\t T[3](i,j)-=lb*(kxm*oy*oz + oxm*ky*oz + oxm*oy*kz);\n\t}\n\tT[3](i,j)*=0.5*anorm*bnorm;\n }\n\n // RHS, derivative acting on y component\n {\n\tox=ox_arr(la,lb);\n\toyp=oy_arr(ma,mb+1);\n\toz=oz_arr(na,nb);\n\n\tkx=kx_arr(la,lb);\n\tkyp=ky_arr(ma,mb+1);\n\tkz=kz_arr(na,nb);\n\n\tT[4](i,j)= 2*zetab*(kx*oyp*oz + ox*kyp*oz + ox*oyp*kz);\n\tif(mb>0) {\n\t oym=oy_arr(ma,mb-1);\n\t kym=ky_arr(ma,mb-1);\n\t T[4](i,j)-=mb*(kx*oym*oz + ox*kym*oz + ox*oym*kz);\n\t}\n\tT[4](i,j)*=0.5*anorm*bnorm;\n }\n\n // RHS, derivative acting on z component\n {\n\tox=ox_arr(la,lb);\n\toy=oy_arr(ma,mb);\n\tozp=oz_arr(na,nb+1);\n\n\tkx=kx_arr(la,lb);\n\tky=ky_arr(ma,mb);\n\tkzp=kz_arr(na,nb+1);\n\n\tT[5](i,j)= 2*zetab*(kx*oy*ozp + ox*ky*ozp + ox*oy*kzp);\n\tif(nb>0) {\n\t ozm=oz_arr(na,nb-1);\n\t kzm=kz_arr(na,nb-1);\n\t T[5](i,j)-=nb*(kx*oy*ozm + ox*ky*ozm + ox*oy*kzm);\n\t}\n\tT[5](i,j)*=0.5*anorm*bnorm;\n }\n\n }\n }\n\n return T;\n}\n\n\n// Compute kinetic energy integral of unnormalized primitives at r_A and r_B\ndouble kinetic_int_os(double xa, double ya, double za, double zetaa, int la, int ma, int na, double xb, double yb, double zb, double zetab, int lb, int mb, int nb) {\n\n // Kinetic energy contributions in x, y and z\n double kx, ky, kz;\n\n // Overlaps in x, y and z\n double ox, oy, oz;\n\n // Compute kinetic energy integrals\n // kx=kinetic_int_1d(xa,xb,zetaa,zetab,la,lb);\n // ky=kinetic_int_1d(ya,yb,zetaa,zetab,ma,mb);\n // kz=kinetic_int_1d(za,zb,zetaa,zetab,na,nb);\n kx=derivative_int_1d(xa,xb,zetaa,zetab,la,lb,2);\n ky=derivative_int_1d(ya,yb,zetaa,zetab,ma,mb,2);\n kz=derivative_int_1d(za,zb,zetaa,zetab,na,nb,2);\n\n // Compute overlap integrals\n ox=overlap_int_1d(xa,xb,zetaa,zetab,la,lb);\n oy=overlap_int_1d(ya,yb,zetaa,zetab,ma,mb);\n oz=overlap_int_1d(za,zb,zetaa,zetab,na,nb);\n\n\n#ifdef DEBUG\n // Check overlap\n double ov=ox*oy*oz;\n double hov=overlap_int(xa,ya,za,zetaa,la,ma,na,xb,yb,zb,zetab,lb,mb,nb);\n if(fabs(ov-hov)>10*DBL_EPSILON*fabs(hov)) {\n printf(\"Computed overlap integral (%e,%e,%e)-(%e,%e,%e) with zeta=(%e,%e) and am=(%i,%i,%i)-(%i,%i,%i)\\n\",xa,ya,za,xb,yb,zb,zetaa,zetab,la,ma,na,lb,mb,nb);\n printf(\"Huzinaga gives %e, OS gives %e.\\n\",hov,ov);\n printf(\"overlap\\t%e\\t%e\\t%e\\n\\n\",ox,oy,oz);\n }\n#endif\n\n // The result is\n return -0.5*(kx*oy*oz + ox*ky*oz + ox*oy*kz);\n}\n\n\n// Worker function for kinetic energy\ndouble kinetic_int_1d(double xa, double xb,double zetaa, double zetab, int la, int lb) {\n\n // In the following we assume la>lb.\n if(lb\n // using recursion relations\n // T_{i+1,j} = X_{PA} T_{i,j} + 1/2p * ( i*T_{i-1,j} + j*T_{i,j-1} ) + zetab/p * (2 * zetaa * S_{i+1,j} - i*S_{i-1,j})\n // T_{i,j+1} = X_{PB} T_{i,j} + 1/2p * ( i*T_{i-1,j} + j*T_{i,j-1} ) + zetaa/p * (2 * zetab * S_{i,j+1} - j*S_{i,j-1})\n // and the initial result\n // T_{00} = zetaa * (1 - 2*zetaa*(X_{PA}^2 + 1/2p)) * S_{00}\n\n arma::mat T(la+2,lb+1);\n T.zeros();\n\n // Initialize array\n T(0,0)=zetaa*(1.0 - 2.0*zetaa*(xpa*xpa + 0.5/p))*S(0,0);\n\n // Generate integrals T_{i,0}\n T(1,0)=xpa*T(0,0) + zetab/p*2.0*zetaa*S(1,0);\n for(int i=1;i<=la;i++) {\n T(i+1,0)=xpa*T(i,0) + 0.5/p*i*T(i-1,0) + zetab/p*(2.0*zetaa*S(i+1,0)-i*S(i-1,0));\n }\n\n if(lb>0) {\n T(0,1)=xpb*T(0,0) + zetaa/p*2.0*zetab*S(0,1);\n for(int j=1;jlb.\n if(lb D;\n\n // We compute the wanted matrix with\n // D^{e+1}_{i,j} = 2*zetaa*D^e_{i+1,j} - iD^e_{i-1,j}\n\n // The lowest order matrix is simply the ovelap matrix,\n // which we need to get in a big enough form\n D.push_back(overlap_ints_1d(xa,xb,zetaa,zetab,la+eval,lb));\n\n // Now, perform the recursion.\n for(int e=1;e<=eval;e++) {\n // Number of rows in the matrix of the current iteration\n int laval=la+eval-e;\n\n // Create matrix\n D.push_back(arma::mat(laval+1,lb+1));\n D[e].zeros();\n\n // Do recursion\n for(int j=0;j<=lb;j++) // i=0\n D[e](0,j)=2*zetaa*D[e-1](1,j);\n for(int i=1;i<=laval;i++)\n for(int j=0;j<=lb;j++)\n\tD[e](i,j)=2*zetaa*D[e-1](i+1,j)-i*D[e-1](i-1,j);\n }\n\n // Return result\n return D[eval].submat(0,0,la,lb);\n}\n\narma::mat nuclear_int_os(double xa, double ya, double za, double zetaa, const std::vector & carta, double xnuc, double ynuc, double znuc, double xb, double yb, double zb, double zetab, const std::vector & cartb) {\n // Compute shell of overlap integrals\n\n // Angular momenta of shells\n int am_a=carta[0].l+carta[0].m+carta[0].n;\n int am_b=cartb[0].l+cartb[0].m+cartb[0].n;\n\n // Compute the matrix\n arma::mat V=nuclear_ints_os(xa,ya,za,zetaa,am_a,xnuc,ynuc,znuc,xb,yb,zb,zetab,am_b);\n\n // Plug in the relative normalization factors\n for(size_t i=0;i 0) {\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) = PBz*ints(0,bind-Nbn,m)-PCz*ints(0,bind-Nbn,m+1);\n\n\t if (nb > 1) {\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) += o2g*(nb-1)*(ints(0,bind-2*Nbn,m)-ints(0,bind-2*Nbn,m+1));\n\t }\n\t}\n\n\telse if (mb > 0) {\n\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) = PBy*ints(0,bind-Nbm,m)-PCy*ints(0,bind-Nbm,m+1);\n\n\t if (mb > 1) {\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t\tints(0,bind,m) += o2g*(mb-1)*(ints(0,bind-2*Nbm,m)-ints(0,bind-2*Nbm,m+1));\n\t }\n\t}\n\n\telse if (lb > 0) {\n\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) = PBx*ints(0,bind-Nbl,m)-PCx*ints(0,bind-Nbl,m+1);\n\n\t if (lb > 1) {\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) += o2g*(lb-1)*(ints(0,bind-2*Nbl,m)-ints(0,bind-2*Nbl,m+1));\n\t }\n\n\t}\n\telse {\n\t ERROR_INFO();\n\t throw std::runtime_error(\"Something went haywire in the Obara-Saika nuclear attraction integral algorithm.\\n\");\n\t}\n }\n }\n\n // Now, increase the angular momentum of the left-hand side, too.\n\n // Loop over total angular momentum of RHS\n for(int lambdab=0;lambdab<=am_b;lambdab++)\n\n // Loop over the functions belonging to the shell\n for(int ii=0; ii<=lambdab; ii++) {\n int lb=lambdab - ii;\n for(int jj=0; jj<=ii; jj++) {\n\tint mb=ii - jj;\n\tint nb=jj;\n\n\t// RHS index is\n\tint bind = lb*Nbl + mb*Nbm + nb*Nbn;\n\n\t// Loop over total angular momentum of LHS\n\tfor(int lambdaa=1;lambdaa<=am_a;lambdaa++)\n\n\t // Loop over angular momentum of second shell\n\t for(int kk=0; kk<=lambdaa; kk++) {\n\t int la=lambdaa-kk;\n\n\t for(int ll=0; ll<=kk; ll++) {\n\t int ma=kk-ll;\n\t int na=ll;\n\n\t // LHS index is\n\t int aind = la*Nal + ma*Nam + na*Nan;\n\n\t if (na > 0) {\n\n\t\tfor(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t ints(aind,bind,m) = PAz*ints(aind-Nan,bind,m)-PCz*ints(aind-Nan,bind,m+1);\n\t\t}\n\n\t\tif (na > 1) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*(na-1)*(ints(aind-2*Nan,bind,m)-ints(aind-2*Nan,bind,m+1));\n\t\t}\n\n\t\tif (nb > 0) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*nb*(ints(aind-Nan,bind-Nbn,m)-ints(aind-Nan,bind-Nbn,m+1));\n\t\t}\n\n\t } else if (ma > 0) {\n\n\t\tfor(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t ints(aind,bind,m) = PAy*ints(aind-Nam,bind,m)-PCy*ints(aind-Nam,bind,m+1);\n\t\t}\n\n\t\tif (ma > 1) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*(ma-1)*(ints(aind-2*Nam,bind,m) - ints(aind-2*Nam,bind,m+1));\n\t\t}\n\n\t\tif (mb > 0) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*mb*(ints(aind-Nam,bind-Nbm,m) - ints(aind-Nam,bind-Nbm,m+1));\n\t\t}\n\n\t }\telse if (la > 0) {\n\n\t\tfor(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t ints(aind,bind,m) = PAx*ints(aind-Nal,bind,m)-PCx*ints(aind-Nal,bind,m+1);\n\t\t}\n\n\t\tif (la > 1) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*(la-1)*(ints(aind-2*Nal,bind,m) - ints(aind-2*Nal,bind,m+1));\n\t\t}\n\n\t\tif (lb > 0) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*lb*(ints(aind-Nal,bind-Nbl,m) - ints(aind-Nal,bind-Nbl,m+1));\n\t\t}\n\t }\n\t else {\n\t\tERROR_INFO();\n\t\tthrow std::runtime_error(\"Something went haywire in the Obara-Saika nuclear attraction integral algorithm.\\n\");\n\t }\n\t }\n\t }\n }\n }\n\n // Size of returned array\n int Na=(am_a+1)*(am_a+2)/2;\n int Nb=(am_b+1)*(am_b+2)/2;\n\n // Returned array\n arma::mat V(Na,Nb);\n V.zeros();\n\n // Fill in array\n int ia, ib;\n\n // Index of left basis function\n ia=0;\n\n\n // Loop over basis functions on this shell\n for(int ii=0; ii<=am_a; ii++) {\n int la=am_a - ii;\n for(int jj=0; jj<=ii; jj++) {\n int ma=ii - jj;\n int na=jj;\n\n // Index in worker array\n int aind=la*Nal+ma*Nam+na;\n\n // Index of right basis function\n ib=0;\n\n // Loop over angular momentum of second shell\n for(int kk=0; kk<=am_b; kk++) {\n\tint lb=am_b - kk;\n\n\tfor(int ll=0; ll<=kk; ll++) {\n\t int mb=kk-ll;\n\t int nb=ll;\n\n\t // Other index is\n\t int bind=lb*Nbl+mb*Nbm+nb;\n\n\t // Store result\n\t V(ia,ib)=-ints(aind,bind,0);\n\n\t // Increment index of basis function\n\t ib++;\n\t}\n }\n\n // Increment index of basis function\n ia++;\n }\n }\n\n#ifdef DEBUG\n // Compute Huzinaga integrals\n arma::mat huzint=V;\n huzint.zeros();\n\n int diff=0;\n\n ia=0;\n // Loop over basis functions on this shell\n for(int ii=0; ii<=am_a; ii++) {\n int ila=am_a - ii;\n for(int jj=0; jj<=ii; jj++) {\n int ima=ii - jj;\n int ina=jj;\n\n ib=0;\n // Loop over basis functions on this shell\n for(int kk=0; kk<=am_b; kk++) {\n\tint ilb=am_b - kk;\n\tfor(int ll=0; ll<=kk; ll++) {\n\t int imb=kk - ll;\n\t int inb=ll;\n\n\t huzint(ia,ib)=nuclear_int(xa,ya,za,zetaa,ila,ima,ina,xnuc,ynuc,znuc,xb,yb,zb,zetab,ilb,imb,inb);\n\n\t if(fabs(huzint(ia,ib)-V(ia,ib))>100*DBL_EPSILON*fabs(huzint(ia,ib)))\n\t diff++;\n\n\t ib++;\n\t}\n }\n\n ia++;\n }\n }\n\n if(diff==0)\n // printf(\"Computed NAI shell (%e,%e,%e) - (%e,%e,%e) with nucleus at (%e,%e,%e) and exponents %e and %e with am=(%i,%i), the results match.\\n\",xa,ya,za,xb,yb,zb,xnuc,ynuc,znuc,zetaa,zetab,am_a,am_b);\n ;\n else {\n ia=0;\n // Loop over basis functions on this shell\n for(int ii=0; ii<=am_a; ii++) {\n int ila=am_a - ii;\n for(int jj=0; jj<=ii; jj++) {\n\tint ima=ii - jj;\n\tint ina=jj;\n\n\tib=0;\n\t// Loop over basis functions on this shell\n\tfor(int kk=0; kk<=am_b; kk++) {\n\t int ilb=am_b - kk;\n\t for(int ll=0; ll<=kk; ll++) {\n\t int imb=kk - ll;\n\t int inb=ll;\n\n\t if(fabs(huzint(ia,ib)-V(ia,ib))>100*DBL_EPSILON*fabs(huzint(ia,ib))) {\n\t printf(\"Computed NAI shell (%e,%e,%e) - (%e,%e,%e) with nucleus at (%e,%e,%e) and exponents %e and %e.\\n\",xa,ya,za,xb,yb,zb,xnuc,ynuc,znuc,zetaa,zetab);\n\t printf(\"The result for the integral (%i,%i,%i)-(%i,%i,%i) is %e with Huzinaga, whereas %e with Obara-Saika; difference is %e.\\n\\n\",ila,ima,ina,ilb,imb,inb,huzint(ia,ib),V(ia,ib),huzint(ia,ib)-V(ia,ib));\n\t }\n\t ib++;\n\t }\n\t}\n\tia++;\n }\n }\n }\n\n /* printf(\"Obara-Saika shell of integrals:\\n\");\n\tV.print();\n\tprintf(\"Huzinaga shell of integrals:\\n\");\n\thuzint.print();\n\tprintf(\"\\n\");*/\n#endif\n\n return V;\n}\n\n\nstd::vector nuclear_int_pulay_os(double xa, double ya, double za, double zetaa, int amorig_a, double xnuc, double ynuc, double znuc, double xb, double yb, double zb, double zetab, int amorig_b) {\n\n // Compute coordinates of center\n const double zeta=zetaa+zetab;\n const double o2g=1/(2.0*zeta);\n\n const double xp=(zetaa*xa+zetab*xb)/zeta;\n const double yp=(zetaa*ya+zetab*yb)/zeta;\n const double zp=(zetaa*za+zetab*zb)/zeta;\n\n const double PAx=xp-xa;\n const double PAy=yp-ya;\n const double PAz=zp-za;\n\n const double PBx=xp-xb;\n const double PBy=yp-yb;\n const double PBz=zp-zb;\n\n const double PCx=xp-xnuc;\n const double PCy=yp-ynuc;\n const double PCz=zp-znuc;\n\n const double ABsq=(xa-xb)*(xa-xb) + (ya-yb)*(ya-yb) + (za-zb)*(za-zb);\n\n // Recursion formulas need am_a and am_b increased by one.\n int am_a=amorig_a+1;\n int am_b=amorig_b+1;\n\n // Sum of angular momenta\n const int mmax=am_a+am_b;\n\n const int size_a=(am_a+1)*(am_a+1)*am_a+1;\n const int size_b=(am_b+1)*(am_b+1)*am_b+1;\n\n // Work array for recursion formulas\n arma::cube ints(size_a,size_b,mmax+1);\n ints.zeros();\n\n // Helpers for computing indices on work array\n const int Nan = 1;\n const int Nam = am_a+1;\n const int Nal = Nam*Nam;\n\n const int Nbn = 1;\n const int Nbm = am_b+1;\n const int Nbl = Nbm*Nbm;\n\n // Argument of Boys' function\n const double boysarg=zeta*(PCx*PCx + PCy*PCy + PCz*PCz);\n // Evaluate Boys' function\n arma::vec bf;\n boysF_arr(mmax,boysarg,bf);\n\n // Constant prefactor for auxiliary integrals\n const double prefac=2.0*M_PI/zeta*exp(-zetaa*zetab*ABsq/zeta);\n\n // Initialize integral array (0_A | A(0) | 0_B)^(m)\n for(size_t m=0;m 0) {\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) = PBz*ints(0,bind-Nbn,m)-PCz*ints(0,bind-Nbn,m+1);\n\n\t if (nb > 1) {\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) += o2g*(nb-1)*(ints(0,bind-2*Nbn,m)-ints(0,bind-2*Nbn,m+1));\n\t }\n\t}\n\n\telse if (mb > 0) {\n\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) = PBy*ints(0,bind-Nbm,m)-PCy*ints(0,bind-Nbm,m+1);\n\n\t if (mb > 1) {\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t\tints(0,bind,m) += o2g*(mb-1)*(ints(0,bind-2*Nbm,m)-ints(0,bind-2*Nbm,m+1));\n\t }\n\t}\n\n\telse if (lb > 0) {\n\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) = PBx*ints(0,bind-Nbl,m)-PCx*ints(0,bind-Nbl,m+1);\n\n\t if (lb > 1) {\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) += o2g*(lb-1)*(ints(0,bind-2*Nbl,m)-ints(0,bind-2*Nbl,m+1));\n\t }\n\n\t}\n\telse {\n\t ERROR_INFO();\n\t throw std::runtime_error(\"Something went haywire in the Obara-Saika nuclear attraction integral algorithm.\\n\");\n\t}\n }\n }\n\n // Now, increase the angular momentum of the left-hand side, too.\n\n // Loop over total angular momentum of RHS\n for(int lambdab=0;lambdab<=am_b;lambdab++)\n\n // Loop over the functions belonging to the shell\n for(int ii=0; ii<=lambdab; ii++) {\n int lb=lambdab - ii;\n for(int jj=0; jj<=ii; jj++) {\n\tint mb=ii - jj;\n\tint nb=jj;\n\n\t// RHS index is\n\tint bind = lb*Nbl + mb*Nbm + nb*Nbn;\n\n\t// Loop over total angular momentum of LHS\n\tfor(int lambdaa=1;lambdaa<=am_a;lambdaa++)\n\n\t // Loop over angular momentum of second shell\n\t for(int kk=0; kk<=lambdaa; kk++) {\n\t int la=lambdaa-kk;\n\n\t for(int ll=0; ll<=kk; ll++) {\n\t int ma=kk-ll;\n\t int na=ll;\n\n\t // LHS index is\n\t int aind = la*Nal + ma*Nam + na*Nan;\n\n\t if (na > 0) {\n\n\t\tfor(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t ints(aind,bind,m) = PAz*ints(aind-Nan,bind,m)-PCz*ints(aind-Nan,bind,m+1);\n\t\t}\n\n\t\tif (na > 1) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*(na-1)*(ints(aind-2*Nan,bind,m)-ints(aind-2*Nan,bind,m+1));\n\t\t}\n\n\t\tif (nb > 0) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*nb*(ints(aind-Nan,bind-Nbn,m)-ints(aind-Nan,bind-Nbn,m+1));\n\t\t}\n\n\t } else if (ma > 0) {\n\n\t\tfor(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t ints(aind,bind,m) = PAy*ints(aind-Nam,bind,m)-PCy*ints(aind-Nam,bind,m+1);\n\t\t}\n\n\t\tif (ma > 1) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*(ma-1)*(ints(aind-2*Nam,bind,m) - ints(aind-2*Nam,bind,m+1));\n\t\t}\n\n\t\tif (mb > 0) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*mb*(ints(aind-Nam,bind-Nbm,m) - ints(aind-Nam,bind-Nbm,m+1));\n\t\t}\n\n\t }\telse if (la > 0) {\n\n\t\tfor(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t ints(aind,bind,m) = PAx*ints(aind-Nal,bind,m)-PCx*ints(aind-Nal,bind,m+1);\n\t\t}\n\n\t\tif (la > 1) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*(la-1)*(ints(aind-2*Nal,bind,m) - ints(aind-2*Nal,bind,m+1));\n\t\t}\n\n\t\tif (lb > 0) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*lb*(ints(aind-Nal,bind-Nbl,m) - ints(aind-Nal,bind-Nbl,m+1));\n\t\t}\n\t }\n\t else {\n\t\tERROR_INFO();\n\t\tthrow std::runtime_error(\"Something went haywire in the Obara-Saika nuclear attraction integral algorithm.\\n\");\n\t }\n\t }\n\t }\n }\n }\n\n // Size of returned array\n int Na=(amorig_a+1)*(amorig_a+2)/2;\n int Nb=(amorig_b+1)*(amorig_b+2)/2;\n\n // Returned array\n std::vector V(6);\n for(int ic=0;ic<6;ic++)\n V[ic].zeros(Na,Nb);\n\n // Fill in array\n int ia, ib;\n\n // Index of left basis function\n ia=0;\n\n // Loop over basis functions on this shell\n for(int ii=0; ii<=amorig_a; ii++) {\n int la=amorig_a - ii;\n for(int jj=0; jj<=ii; jj++) {\n int ma=ii - jj;\n int na=jj;\n\n // Index of right basis function\n ib=0;\n\n // Loop over angular momentum of second shell\n for(int kk=0; kk<=amorig_b; kk++) {\n\tint lb=amorig_b - kk;\n\n\tfor(int ll=0; ll<=kk; ll++) {\n\t int mb=kk-ll;\n\t int nb=ll;\n\n\t int aind=la*Nal+ma*Nam+na;\n\t // x\n\t int alpind=(la+1)*Nal+ma*Nam+na;\n\t int almind=(la-1)*Nal+ma*Nam+na;\n\t // y\n\t int ampind=la*Nal+(ma+1)*Nam+na;\n\t int ammind=la*Nal+(ma-1)*Nam+na;\n\t // z\n\t int anpind=la*Nal+ma*Nam+na+1;\n\t int anmind=la*Nal+ma*Nam+na-1;\n\n\t int bind=lb*Nbl+mb*Nbm+nb;\n\t // x\n\t int blpind=(lb+1)*Nbl+mb*Nbm+nb;\n\t int blmind=(lb-1)*Nbl+mb*Nbm+nb;\n\t // y\n\t int bmpind=lb*Nbl+(mb+1)*Nbm+nb;\n\t int bmmind=lb*Nbl+(mb-1)*Nbm+nb;\n\t // z\n\t int bnpind=lb*Nbl+mb*Nbm+nb+1;\n\t int bnmind=lb*Nbl+mb*Nbm+nb-1;\n\n\t // LHS, x\n\t V[0](ia,ib)=2*zetaa*ints(alpind,bind,0);\n\t if(la>0)\n\t V[0](ia,ib)-=la*ints(almind,bind,0);\n\t // LHS, y\n\t V[1](ia,ib)=2*zetaa*ints(ampind,bind,0);\n\t if(ma>0)\n\t V[1](ia,ib)-=ma*ints(ammind,bind,0);\n\t // LHS, z\n\t V[2](ia,ib)=2*zetaa*ints(anpind,bind,0);\n\t if(na>0)\n\t V[2](ia,ib)-=na*ints(anmind,bind,0);\n\n\t // RHS, x\n\t V[3](ia,ib)=2*zetab*ints(aind,blpind,0);\n\t if(lb>0)\n\t V[3](ia,ib)-=lb*ints(aind,blmind,0);\n\t // RHS, y\n\t V[4](ia,ib)=2*zetab*ints(aind,bmpind,0);\n\t if(mb>0)\n\t V[4](ia,ib)-=mb*ints(aind,bmmind,0);\n\t // RHS, z\n\t V[5](ia,ib)=2*zetab*ints(aind,bnpind,0);\n\t if(nb>0)\n\t V[5](ia,ib)-=nb*ints(aind,bnmind,0);\n\n\t // Increment index of basis function\n\t ib++;\n\t}\n }\n\n // Increment index of basis function\n ia++;\n }\n }\n\n return V;\n}\n\n\nstd::vector nuclear_int_pulay_os(double xa, double ya, double za, double zetaa, const std::vector & carta, double xnuc, double ynuc, double znuc, double xb, double yb, double zb, double zetab, const std::vector & cartb) {\n // Compute shell of overlap integrals\n\n // Angular momenta of shells\n int am_a=carta[0].l+carta[0].m+carta[0].n;\n int am_b=cartb[0].l+cartb[0].m+cartb[0].n;\n\n // Compute the matrix\n std::vector V=nuclear_int_pulay_os(xa,ya,za,zetaa,am_a,xnuc,ynuc,znuc,xb,yb,zb,zetab,am_b);\n\n // Plug in the relative normalization factors\n for(size_t i=0;i nuclear_int_ders_os(double xa, double ya, double za, double zetaa, int am_a, double xnuc, double ynuc, double znuc, double xb, double yb, double zb, double zetab, int am_b) {\n\n // Compute coordinates of center\n const double zeta=zetaa+zetab;\n const double o2g=1/(2.0*zeta);\n\n const double xp=(zetaa*xa+zetab*xb)/zeta;\n const double yp=(zetaa*ya+zetab*yb)/zeta;\n const double zp=(zetaa*za+zetab*zb)/zeta;\n\n const double PAx=xp-xa;\n const double PAy=yp-ya;\n const double PAz=zp-za;\n\n const double PBx=xp-xb;\n const double PBy=yp-yb;\n const double PBz=zp-zb;\n\n const double PCx=xp-xnuc;\n const double PCy=yp-ynuc;\n const double PCz=zp-znuc;\n\n const double ABsq=(xa-xb)*(xa-xb) + (ya-yb)*(ya-yb) + (za-zb)*(za-zb);\n\n // Sum of angular momenta\n const int mmax=am_a+am_b;\n\n const int size_a=(am_a+1)*(am_a+1)*am_a+1;\n const int size_b=(am_b+1)*(am_b+1)*am_b+1;\n\n // Work array for recursion formulas\n arma::cube ints(size_a,size_b,mmax+1);\n ints.zeros();\n\n arma::cube xint(size_a,size_b,mmax+1);\n xint.zeros();\n arma::cube yint(size_a,size_b,mmax+1);\n yint.zeros();\n arma::cube zint(size_a,size_b,mmax+1);\n zint.zeros();\n\n // Helpers for computing indices on work array\n const int Nan = 1;\n const int Nam = am_a+1;\n const int Nal = Nam*Nam;\n\n const int Nbn = 1;\n const int Nbm = am_b+1;\n const int Nbl = Nbm*Nbm;\n\n // Argument of Boys' function\n const double boysarg=zeta*(PCx*PCx + PCy*PCy + PCz*PCz);\n // Evaluate Boys' function\n arma::vec bf;\n boysF_arr(mmax+1,boysarg,bf);\n\n // Constant prefactor for auxiliary integrals\n const double prefac=2.0*M_PI/zeta*exp(-zetaa*zetab*ABsq/zeta);\n\n // Initialize integral array (0_A | A(0) | 0_B)^(m)\n for(int m=0;m<=mmax;m++)\n ints(0,0,m)=prefac*bf[m];\n // and (0_A | A(1) | 0_B)^(m)\n for(int m=0;m<=mmax;m++) {\n xint(0,0,m)=2.0*zeta*PCx*prefac*bf[m+1];\n yint(0,0,m)=2.0*zeta*PCy*prefac*bf[m+1];\n zint(0,0,m)=2.0*zeta*PCz*prefac*bf[m+1];\n }\n\n // Increase angular momentum on right hand side.\n\n // Loop over total angular momentum\n for(int lambdab=1;lambdab<=am_b;lambdab++)\n\n // Loop over angular momentum functions belonging to this shell\n for(int ii=0; ii<=lambdab; ii++) {\n int lb=lambdab - ii;\n for(int jj=0; jj<=ii; jj++) {\n\tint mb=ii - jj;\n\tint nb=jj;\n\n\t// Index in integrals table\n\tint bind = lb*Nbl+mb*Nbm+nb*Nbn;\n\n\tif (nb > 0) {\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) = PBz*ints(0,bind-Nbn,m)-PCz*ints(0,bind-Nbn,m+1);\n\t for(int m=0;m<=mmax-lambdab;m++) {\n\t xint(0,bind,m) = PBz*xint(0,bind-Nbn,m)-PCz*xint(0,bind-Nbn,m+1);\n\t yint(0,bind,m) = PBz*yint(0,bind-Nbn,m)-PCz*yint(0,bind-Nbn,m+1);\n\t zint(0,bind,m) = PBz*zint(0,bind-Nbn,m)-PCz*zint(0,bind-Nbn,m+1) + ints(0,bind-Nbn,m+1);\n\t }\n\n\t if (nb > 1) {\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) += o2g*(nb-1)*(ints(0,bind-2*Nbn,m)-ints(0,bind-2*Nbn,m+1));\n\t for(int m=0;m<=mmax-lambdab;m++) {\n\t xint(0,bind,m) += o2g*(nb-1)*(xint(0,bind-2*Nbn,m)-xint(0,bind-2*Nbn,m+1));\n\t yint(0,bind,m) += o2g*(nb-1)*(yint(0,bind-2*Nbn,m)-yint(0,bind-2*Nbn,m+1));\n\t zint(0,bind,m) += o2g*(nb-1)*(zint(0,bind-2*Nbn,m)-zint(0,bind-2*Nbn,m+1));\n\t }\n\t }\n\t}\n\n\telse if (mb > 0) {\n\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) = PBy*ints(0,bind-Nbm,m)-PCy*ints(0,bind-Nbm,m+1);\n\t for(int m=0;m<=mmax-lambdab;m++) {\n\t xint(0,bind,m) = PBy*xint(0,bind-Nbm,m)-PCy*xint(0,bind-Nbm,m+1);\n\t yint(0,bind,m) = PBy*yint(0,bind-Nbm,m)-PCy*yint(0,bind-Nbm,m+1) + ints(0,bind-Nbm,m+1);\n\t zint(0,bind,m) = PBy*zint(0,bind-Nbm,m)-PCy*zint(0,bind-Nbm,m+1);\n\t }\n\n\t if (mb > 1) {\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t\tints(0,bind,m) += o2g*(mb-1)*(ints(0,bind-2*Nbm,m)-ints(0,bind-2*Nbm,m+1));\n\t for(int m=0;m<=mmax-lambdab;m++) {\n\t\txint(0,bind,m) += o2g*(mb-1)*(xint(0,bind-2*Nbm,m)-xint(0,bind-2*Nbm,m+1));\n\t\tyint(0,bind,m) += o2g*(mb-1)*(yint(0,bind-2*Nbm,m)-yint(0,bind-2*Nbm,m+1));\n\t\tzint(0,bind,m) += o2g*(mb-1)*(zint(0,bind-2*Nbm,m)-zint(0,bind-2*Nbm,m+1));\n\t }\n\t }\n\t}\n\n\telse if (lb > 0) {\n\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) = PBx*ints(0,bind-Nbl,m)-PCx*ints(0,bind-Nbl,m+1);\n\t for(int m=0;m<=mmax-lambdab;m++) {\n\t xint(0,bind,m) = PBx*xint(0,bind-Nbl,m)-PCx*xint(0,bind-Nbl,m+1) + ints(0,bind-Nbl,m+1);\n\t yint(0,bind,m) = PBx*yint(0,bind-Nbl,m)-PCx*yint(0,bind-Nbl,m+1);\n\t zint(0,bind,m) = PBx*zint(0,bind-Nbl,m)-PCx*zint(0,bind-Nbl,m+1);\n\t }\n\n\t if (lb > 1) {\n\t for(int m=0;m<=mmax-lambdab;m++)\n\t ints(0,bind,m) += o2g*(lb-1)*(ints(0,bind-2*Nbl,m)-ints(0,bind-2*Nbl,m+1));\n\t for(int m=0;m<=mmax-lambdab;m++) {\n\t xint(0,bind,m) += o2g*(lb-1)*(xint(0,bind-2*Nbl,m)-xint(0,bind-2*Nbl,m+1));\n\t yint(0,bind,m) += o2g*(lb-1)*(yint(0,bind-2*Nbl,m)-yint(0,bind-2*Nbl,m+1));\n\t zint(0,bind,m) += o2g*(lb-1)*(zint(0,bind-2*Nbl,m)-zint(0,bind-2*Nbl,m+1));\n\t }\n\t }\n\n\t}\n\telse {\n\t ERROR_INFO();\n\t throw std::runtime_error(\"Something went haywire in the Obara-Saika nuclear attraction integral derivative algorithm.\\n\");\n\t}\n }\n }\n\n // Now, increase the angular momentum of the left-hand side, too.\n\n // Loop over total angular momentum of RHS\n for(int lambdab=0;lambdab<=am_b;lambdab++)\n\n // Loop over the functions belonging to the shell\n for(int ii=0; ii<=lambdab; ii++) {\n int lb=lambdab - ii;\n for(int jj=0; jj<=ii; jj++) {\n\tint mb=ii - jj;\n\tint nb=jj;\n\n\t// RHS index is\n\tint bind = lb*Nbl + mb*Nbm + nb*Nbn;\n\n\t// Loop over total angular momentum of LHS\n\tfor(int lambdaa=1;lambdaa<=am_a;lambdaa++)\n\n\t // Loop over angular momentum of second shell\n\t for(int kk=0; kk<=lambdaa; kk++) {\n\t int la=lambdaa-kk;\n\n\t for(int ll=0; ll<=kk; ll++) {\n\t int ma=kk-ll;\n\t int na=ll;\n\n\t // LHS index is\n\t int aind = la*Nal + ma*Nam + na*Nan;\n\n\t if (na > 0) {\n\t\tfor(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) = PAz*ints(aind-Nan,bind,m)-PCz*ints(aind-Nan,bind,m+1);\n\t\tfor(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t xint(aind,bind,m) = PAz*xint(aind-Nan,bind,m)-PCz*xint(aind-Nan,bind,m+1);\n\t\t yint(aind,bind,m) = PAz*yint(aind-Nan,bind,m)-PCz*yint(aind-Nan,bind,m+1);\n\t\t zint(aind,bind,m) = PAz*zint(aind-Nan,bind,m)-PCz*zint(aind-Nan,bind,m+1) + ints(aind-Nan,bind,m+1);\n\t\t}\n\n\t\tif (na > 1) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*(na-1)*(ints(aind-2*Nan,bind,m)-ints(aind-2*Nan,bind,m+1));\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t xint(aind,bind,m) += o2g*(na-1)*(xint(aind-2*Nan,bind,m)-xint(aind-2*Nan,bind,m+1));\n\t\t yint(aind,bind,m) += o2g*(na-1)*(yint(aind-2*Nan,bind,m)-yint(aind-2*Nan,bind,m+1));\n\t\t zint(aind,bind,m) += o2g*(na-1)*(zint(aind-2*Nan,bind,m)-zint(aind-2*Nan,bind,m+1));\n\t\t }\n\t\t}\n\n\t\tif (nb > 0) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*nb*(ints(aind-Nan,bind-Nbn,m)-ints(aind-Nan,bind-Nbn,m+1));\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t xint(aind,bind,m) += o2g*nb*(xint(aind-Nan,bind-Nbn,m)-xint(aind-Nan,bind-Nbn,m+1));\n\t\t yint(aind,bind,m) += o2g*nb*(yint(aind-Nan,bind-Nbn,m)-yint(aind-Nan,bind-Nbn,m+1));\n\t\t zint(aind,bind,m) += o2g*nb*(zint(aind-Nan,bind-Nbn,m)-zint(aind-Nan,bind-Nbn,m+1));\n\t\t }\n\t\t}\n\n\t } else if (ma > 0) {\n\n\t\tfor(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) = PAy*ints(aind-Nam,bind,m)-PCy*ints(aind-Nam,bind,m+1);\n\t\tfor(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t xint(aind,bind,m) = PAy*xint(aind-Nam,bind,m)-PCy*xint(aind-Nam,bind,m+1);\n\t\t yint(aind,bind,m) = PAy*yint(aind-Nam,bind,m)-PCy*yint(aind-Nam,bind,m+1) + ints(aind-Nam,bind,m+1);\n\t\t zint(aind,bind,m) = PAy*zint(aind-Nam,bind,m)-PCy*zint(aind-Nam,bind,m+1);\n\t\t}\n\n\t\tif (ma > 1) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*(ma-1)*(ints(aind-2*Nam,bind,m) - ints(aind-2*Nam,bind,m+1));\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t xint(aind,bind,m) += o2g*(ma-1)*(xint(aind-2*Nam,bind,m) - xint(aind-2*Nam,bind,m+1));\n\t\t yint(aind,bind,m) += o2g*(ma-1)*(yint(aind-2*Nam,bind,m) - yint(aind-2*Nam,bind,m+1));\n\t\t zint(aind,bind,m) += o2g*(ma-1)*(zint(aind-2*Nam,bind,m) - zint(aind-2*Nam,bind,m+1));\n\t\t }\n\t\t}\n\n\t\tif (mb > 0) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*mb*(ints(aind-Nam,bind-Nbm,m) - ints(aind-Nam,bind-Nbm,m+1));\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t xint(aind,bind,m) += o2g*mb*(xint(aind-Nam,bind-Nbm,m) - xint(aind-Nam,bind-Nbm,m+1));\n\t\t yint(aind,bind,m) += o2g*mb*(yint(aind-Nam,bind-Nbm,m) - yint(aind-Nam,bind-Nbm,m+1));\n\t\t zint(aind,bind,m) += o2g*mb*(zint(aind-Nam,bind-Nbm,m) - zint(aind-Nam,bind-Nbm,m+1));\n\t\t }\n\t\t}\n\n\t }\telse if (la > 0) {\n\n\t\tfor(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) = PAx*ints(aind-Nal,bind,m)-PCx*ints(aind-Nal,bind,m+1);\n\t\tfor(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t xint(aind,bind,m) = PAx*xint(aind-Nal,bind,m)-PCx*xint(aind-Nal,bind,m+1) + ints(aind-Nal,bind,m+1);\n\t\t yint(aind,bind,m) = PAx*yint(aind-Nal,bind,m)-PCx*yint(aind-Nal,bind,m+1);\n\t\t zint(aind,bind,m) = PAx*zint(aind-Nal,bind,m)-PCx*zint(aind-Nal,bind,m+1);\n\t\t}\n\n\t\tif (la > 1) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*(la-1)*(ints(aind-2*Nal,bind,m) - ints(aind-2*Nal,bind,m+1));\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t xint(aind,bind,m) += o2g*(la-1)*(xint(aind-2*Nal,bind,m) - xint(aind-2*Nal,bind,m+1));\n\t\t yint(aind,bind,m) += o2g*(la-1)*(yint(aind-2*Nal,bind,m) - yint(aind-2*Nal,bind,m+1));\n\t\t zint(aind,bind,m) += o2g*(la-1)*(zint(aind-2*Nal,bind,m) - zint(aind-2*Nal,bind,m+1));\n\t\t }\n\t\t}\n\n\t\tif (lb > 0) {\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++)\n\t\t ints(aind,bind,m) += o2g*lb*(ints(aind-Nal,bind-Nbl,m) - ints(aind-Nal,bind-Nbl,m+1));\n\t\t for(int m=0;m<=mmax-lambdaa-lambdab;m++) {\n\t\t xint(aind,bind,m) += o2g*lb*(xint(aind-Nal,bind-Nbl,m) - xint(aind-Nal,bind-Nbl,m+1));\n\t\t yint(aind,bind,m) += o2g*lb*(yint(aind-Nal,bind-Nbl,m) - yint(aind-Nal,bind-Nbl,m+1));\n\t\t zint(aind,bind,m) += o2g*lb*(zint(aind-Nal,bind-Nbl,m) - zint(aind-Nal,bind-Nbl,m+1));\n\t\t }\n\t\t}\n\t }\n\t else {\n\t\tERROR_INFO();\n\t\tthrow std::runtime_error(\"Something went haywire in the Obara-Saika nuclear attraction integral derivative algorithm.\\n\");\n\t }\n\t }\n\t }\n }\n }\n\n // Size of returned array\n int Na=(am_a+1)*(am_a+2)/2;\n int Nb=(am_b+1)*(am_b+2)/2;\n\n // Returned array\n std::vector V(3);\n for(int ic=0;ic<3;ic++)\n V[ic].zeros(Na,Nb);\n\n // Fill in array\n int ia, ib;\n\n // Index of left basis function\n ia=0;\n\n // Loop over basis functions on this shell\n for(int ii=0; ii<=am_a; ii++) {\n int la=am_a - ii;\n for(int jj=0; jj<=ii; jj++) {\n int ma=ii - jj;\n int na=jj;\n\n // Index in worker array\n int aind=la*Nal+ma*Nam+na;\n\n // Index of right basis function\n ib=0;\n\n // Loop over angular momentum of second shell\n for(int kk=0; kk<=am_b; kk++) {\n\tint lb=am_b - kk;\n\n\tfor(int ll=0; ll<=kk; ll++) {\n\t int mb=kk-ll;\n\t int nb=ll;\n\n\t // Other index is\n\t int bind=lb*Nbl+mb*Nbm+nb;\n\n\t // Store result\n\t V[0](ia,ib)=xint(aind,bind,0);\n\t V[1](ia,ib)=yint(aind,bind,0);\n\t V[2](ia,ib)=zint(aind,bind,0);\n\n\t // Increment index of basis function\n\t ib++;\n\t}\n }\n\n // Increment index of basis function\n ia++;\n }\n }\n\n#ifdef DEBUG\n // Compute Huzinaga integrals\n std::vector huzint(V);\n for(size_t ic=0;ic100*DBL_EPSILON*std::max(fabs(huzint[ic](ia,ib)),fabs(V[ic](ia,ib))))\n\t diff++;\n\n\t ib++;\n\t}\n }\n\n ia++;\n }\n }\n\n if(diff==0)\n // printf(\"Computed NAI shell (%e,%e,%e) - (%e,%e,%e) with nucleus at (%e,%e,%e) and exponents %e and %e with am=(%i,%i), the results match.\\n\",xa,ya,za,xb,yb,zb,xnuc,ynuc,znuc,zetaa,zetab,am_a,am_b);\n ;\n else {\n ia=0;\n // Loop over basis functions on this shell\n for(int ii=0; ii<=am_a; ii++) {\n int ila=am_a - ii;\n for(int jj=0; jj<=ii; jj++) {\n\tint ima=ii - jj;\n\tint ina=jj;\n\n\tib=0;\n\t// Loop over basis functions on this shell\n\tfor(int kk=0; kk<=am_b; kk++) {\n\t int ilb=am_b - kk;\n\t for(int ll=0; ll<=kk; ll++) {\n\t int imb=kk - ll;\n\t int inb=ll;\n\n\t for(int ic=0;ic<3;ic++)\n\t if(fabs(huzint[ic](ia,ib)-V[ic](ia,ib))>100*DBL_EPSILON*std::max(fabs(huzint[ic](ia,ib)),fabs(V[ic](ia,ib)))) {\n\t\tprintf(\"Computed NAI shell (%e,%e,%e) - (%e,%e,%e) with nucleus at (%e,%e,%e) and exponents %e and %e.\\n\",xa,ya,za,xb,yb,zb,xnuc,ynuc,znuc,zetaa,zetab);\n\t\tprintf(\"The result for the %i derivative (%i,%i,%i)-(%i,%i,%i) is %e with Huzinaga, whereas %e with Obara-Saika; difference is %e.\\n\\n\",(int) ic, ila,ima,ina,ilb,imb,inb,huzint[ic](ia,ib),V[ic](ia,ib),huzint[ic](ia,ib)-V[ic](ia,ib));\n\t }\n\t ib++;\n\t }\n\t}\n\tia++;\n }\n }\n }\n#endif\n\n\n return V;\n}\n\nstd::vector nuclear_int_ders_os(double xa, double ya, double za, double zetaa, const std::vector & carta, double xnuc, double ynuc, double znuc, double xb, double yb, double zb, double zetab, const std::vector & cartb) {\n // Compute shell of overlap integrals\n\n // Angular momenta of shells\n int am_a=carta[0].l+carta[0].m+carta[0].n;\n int am_b=cartb[0].l+cartb[0].m+cartb[0].n;\n\n // Compute the matrices\n std::vector V=nuclear_int_ders_os(xa,ya,za,zetaa,am_a,xnuc,ynuc,znuc,xb,yb,zb,zetab,am_b);\n\n // Plug in the relative normalization factors\n for(size_t i=0;i & carta, const std::vector & cartc, const std::vector & cartb) {\n\n // Angular momenta of shells\n const int am_a=carta[0].l+carta[0].m+carta[0].n;\n const int am_b=cartb[0].l+cartb[0].m+cartb[0].n;\n const int am_c=cartc[0].l+cartc[0].m+cartc[0].n;\n\n // printf(\"am_a = %i, am_b = %i, am_c = %i.\\n\",am_a,am_b,am_c);\n\n // Necessary size for work array\n const int size_a=(am_a+1)*(am_a+1)*am_a+1;\n const int size_c=(am_c+1)*(am_c+1)*am_c+1;\n const int size_b=(am_b+1)*(am_b+1)*am_b+1;\n\n // Work array for recursion formulas\n arma::cube ints(size_a,size_c,size_b);\n ints.zeros();\n\n // Helpers for computing indices on work array\n const int Nan = 1;\n const int Nam = am_a+1;\n const int Nal = Nam*Nam;\n\n const int Nbn = 1;\n const int Nbm = am_b+1;\n const int Nbl = Nbm*Nbm;\n\n const int Ncn = 1;\n const int Ncm = am_c+1;\n const int Ncl = Ncm*Ncm;\n\n // Reduced exponents\n double xi=zetaa*zetab/(zetaa+zetab);\n double zeta=zetaa+zetab;\n\n // r_ab\n double rabsq=(xa-xb)*(xa-xb)+(ya-yb)*(ya-yb)+(za-zb)*(za-zb);\n\n // P\n double px=(zetaa*xa+zetab*xb)/zeta;\n double py=(zetaa*ya+zetab*yb)/zeta;\n double pz=(zetaa*za+zetab*zb)/zeta;\n\n // r_pc\n double rpcsq=(px-xc)*(px-xc)+(py-yc)*(py-yc)+(pz-zc)*(pz-zc);\n\n // G\n double gx=(zeta*px+zetac*xc)/(zeta+zetac);\n double gy=(zeta*py+zetac*yc)/(zeta+zetac);\n double gz=(zeta*pz+zetac*zc)/(zeta+zetac);\n\n // GA\n double gax=gx-xa;\n double gay=gy-ya;\n double gaz=gz-za;\n // GB\n double gbx=gx-xb;\n double gby=gy-yb;\n double gbz=gz-zb;\n // GC\n double gcx=gx-xc;\n double gcy=gy-yc;\n double gcz=gz-zc;\n\n // Compute initial data.\n ints(0,0,0)=(M_PI/(zeta+zetac))*sqrt(M_PI/(zeta+zetac))*exp(-xi*rabsq - zeta*zetac/(zeta+zetac)*rpcsq);\n\n // Now am=(0,0,0). Increase LHS angular momentum.\n // Loop over total angular momentum\n for(int lambdaa=1;lambdaa<=am_a;lambdaa++)\n // Loop over angular momentum functions belonging to this shell\n for(int ii=0; ii<=lambdaa; ii++) {\n int la=lambdaa - ii;\n for(int jj=0; jj<=ii; jj++) {\n\tint ma=ii - jj;\n\tint na=jj;\n\n\t// Index in integrals table\n\tint aind = la*Nal+ma*Nam+na*Nan;\n\n\t// Compute integral\n\tif(la>0) {\n\n\t ints(aind,0,0)+=gax*ints(aind-Nal,0,0);\n\t if(la>1)\n\t ints(aind,0,0)+=0.5/(zeta+zetac)*(la-1)*ints(aind-2*Nal,0,0);\n\n\t} else if(ma>0) {\n\n\t ints(aind,0,0)+=gay*ints(aind-Nam,0,0);\n\t if(ma>1)\n\t ints(aind,0,0)+=0.5/(zeta+zetac)*(ma-1)*ints(aind-2*Nam,0,0);\n\n\t} else if(na>0) {\n\n\t ints(aind,0,0)+=gaz*ints(aind-Nan,0,0);\n\t if(na>1)\n\t ints(aind,0,0)+=0.5/(zeta+zetac)*(na-1)*ints(aind-2*Nan,0,0);\n\n\t}\n }\n }\n\n // Increase total angular momentum on right-hand side\n // Loop over total angular momentum of LHS\n for(int lambdaa=0;lambdaa<=am_a;lambdaa++)\n\n // Loop over angular momentum of second shell\n for(int kk=0; kk<=lambdaa; kk++) {\n int la=lambdaa-kk;\n\n for(int ll=0; ll<=kk; ll++) {\n\tint ma=kk-ll;\n\tint na=ll;\n\n\t// LHS index is\n\tint aind = la*Nal + ma*Nam + na*Nan;\n\n\t// Loop over total angular momentum of RHS\n\tfor(int lambdab=1;lambdab<=am_b;lambdab++)\n\n\t // Loop over the functions belonging to the shell\n\t for(int ii=0; ii<=lambdab; ii++) {\n\t int lb=lambdab - ii;\n\t for(int jj=0; jj<=ii; jj++) {\n\t int mb=ii - jj;\n\t int nb=jj;\n\n\t // RHS index is\n\t int bind = lb*Nbl + mb*Nbm + nb*Nbn;\n\n\t // Compute integral\n\t if(lb>0) {\n\n\t\tints(aind,0,bind)+=gbx*ints(aind,0,bind-Nbl);\n\t\tif(lb>1)\n\t\t ints(aind,0,bind)+=0.5/(zeta+zetac)*(lb-1)*ints(aind,0,bind-2*Nbl);\n\t\tif(la>0)\n\t\t ints(aind,0,bind)+=0.5/(zeta+zetac)*la*ints(aind-Nal,0,bind-Nbl);\n\n\t } else if(mb>0) {\n\n\t\tints(aind,0,bind)+=gby*ints(aind,0,bind-Nbm);\n\t\tif(mb>1)\n\t\t ints(aind,0,bind)+=0.5/(zeta+zetac)*(mb-1)*ints(aind,0,bind-2*Nbm);\n\t\tif(ma>0)\n\t\t ints(aind,0,bind)+=0.5/(zeta+zetac)*ma*ints(aind-Nam,0,bind-Nbm);\n\n\t } else if(nb>0) {\n\n\t\tints(aind,0,bind)+=gbz*ints(aind,0,bind-Nbn);\n\t\tif(nb>1)\n\t\t ints(aind,0,bind)+=0.5/(zeta+zetac)*(nb-1)*ints(aind,0,bind-2*Nbn);\n\t\tif(na>0)\n\t\t ints(aind,0,bind)+=0.5/(zeta+zetac)*na*ints(aind-Nan,0,bind-Nbn);\n\n\t } else {\n\t\tERROR_INFO();\n\t\tthrow std::runtime_error(\"Something went haywire in the Obara-Saika three-center overlap algorithm.\\n\");\n\t }\n\t }\n\t }\n }\n }\n\n // Finally, increase angular momentum in the middle\n // Loop over total angular momentum of LHS\n for(int lambdaa=0;lambdaa<=am_a;lambdaa++)\n\n // Loop over angular momentum of second shell\n for(int kk=0; kk<=lambdaa; kk++) {\n int la=lambdaa-kk;\n\n for(int ll=0; ll<=kk; ll++) {\n\tint ma=kk-ll;\n\tint na=ll;\n\n\t// LHS index is\n\tint aind = la*Nal + ma*Nam + na*Nan;\n\n\t// Loop over total angular momentum of RHS\n\tfor(int lambdab=0;lambdab<=am_b;lambdab++)\n\n\t // Loop over the functions belonging to the shell\n\t for(int ii=0; ii<=lambdab; ii++) {\n\t int lb=lambdab - ii;\n\t for(int jj=0; jj<=ii; jj++) {\n\t int mb=ii - jj;\n\t int nb=jj;\n\n\t // RHS index is\n\t int bind = lb*Nbl + mb*Nbm + nb*Nbn;\n\n\t // Loop over total angular momentum of middle\n\t for(int lambdac=1;lambdac<=am_c;lambdac++)\n\t\t// Loop over the functions belonging to the shell\n\t\tfor(int mm=0; mm<=lambdac; mm++) {\n\t\t int lc=lambdac - mm;\n\t\t for(int nn=0; nn<=mm; nn++) {\n\t\t int mc=mm - nn;\n\t\t int nc=nn;\n\n\t\t // RHS index is\n\t\t int cind = lc*Ncl + mc*Ncm + nc*Ncn;\n\n\t\t // Calculate integral\n\t\t if(lc>0) {\n\n\t\t ints(aind,cind,bind)+=gcx*ints(aind,cind-Ncl,bind);\n\t\t if(lc>1)\n\t\t\tints(aind,cind,bind)+=0.5/(zeta+zetac)*(lc-1)*ints(aind,cind-2*Ncl,bind);\n\t\t if(la>0)\n\t\t\tints(aind,cind,bind)+=0.5/(zeta+zetac)*la*ints(aind-Nal,cind-Ncl,bind);\n\t\t if(lb>0)\n\t\t\tints(aind,cind,bind)+=0.5/(zeta+zetac)*lb*ints(aind,cind-Ncl,bind-Nbl);\n\n\t\t } else if(mc>0) {\n\n\t\t ints(aind,cind,bind)+=gcy*ints(aind,cind-Ncm,bind);\n\t\t if(mc>1)\n\t\t\tints(aind,cind,bind)+=0.5/(zeta+zetac)*(mc-1)*ints(aind,cind-2*Ncm,bind);\n\t\t if(ma>0)\n\t\t\tints(aind,cind,bind)+=0.5/(zeta+zetac)*ma*ints(aind-Nam,cind-Ncm,bind);\n\t\t if(mb>0)\n\t\t\tints(aind,cind,bind)+=0.5/(zeta+zetac)*mb*ints(aind,cind-Ncm,bind-Nbm);\n\n\t\t } else if(nc>0) {\n\n\t\t ints(aind,cind,bind)+=gcz*ints(aind,cind-Ncn,bind);\n\t\t if(nc>1)\n\t\t\tints(aind,cind,bind)+=0.5/(zeta+zetac)*(nc-1)*ints(aind,cind-2*Ncn,bind);\n\t\t if(na>0)\n\t\t\tints(aind,cind,bind)+=0.5/(zeta+zetac)*na*ints(aind-Nan,cind-Ncn,bind);\n\t\t if(nb>0)\n\t\t\tints(aind,cind,bind)+=0.5/(zeta+zetac)*nb*ints(aind,cind-Ncn,bind-Nbn);\n\n\t\t } else {\n\t\t ERROR_INFO();\n\t\t throw std::runtime_error(\"Something went haywire in the Obara-Saika three-center overlap algorithm.\\n\");\n\t\t }\n\t\t }\n\t\t}\n\t }\n\t }\n }\n }\n\n // Size of returned array\n const int Na=carta.size();\n const int Nc=cartc.size();\n const int Nb=cartb.size();\n\n // Fill in returned array\n arma::cube S(Na,Nc,Nb);\n S.zeros();\n\n for(size_t i=0;i\n#include \n#include \n#include \n#include \n#include /* for realloc() and free() */\n#include /* for memset() */\n#include /* for errno */\n#include \"nlohmann/json.hpp\"\n#include \n#include \n#include \"Threadpool.hh\"\n\nusing namespace zmqpp;\nusing namespace arma;\nusing json = nlohmann::json;\n\nclass EWorker{\n private:\n mat r_ic;\n std::vector cov;\n mat regcov;\n mat mu;\n vec pivector;\n mat data;\n public:\n EWorker(std::vector> muvec,\n std::vector piv,\n std::vector> regcovvec,\n std::vector>> covvec,\n std::vector> xvec \n\n ){\n // int n_of_sources = data.size();\n // int n_of_data = data.at(0).size();\n int counter = 0;\n for (std::vector cmu: muvec){\n mu.insert_cols(counter, vec(cmu));\n counter++;\n }\n pivector = vec(piv);\n counter = 0;\n for (std::vector cregcov: regcovvec){\n regcov.insert_cols(counter, vec(cregcov));\n counter++;\n }\n counter = 0;\n int counter2 = 0;\n for (std::vector> covmatrix : covvec){\n mat temp;\n for(std::vectorcovmatrixrow: covmatrix){\n temp.insert_cols(counter,vec(covmatrixrow));\n counter++;\n }\n counter = 0;\n cov.insert(cov.begin() + counter2, temp);\n counter2++;\n }\n\n // cout<<\"MU:\\n-------------------\\n\"<temp(xvec.size());\n counter = 0;\n for(std::vector datarow : xvec){\n temp.at(counter)= datarow.at(i);\n counter++;\n }\n data.insert_cols(i, vec(temp));\n }\n // cout<<\"\\n-------------------\\n\";\n\n // cout<<\"DATA: \"< r(data.n_rows);\n double detco = det(co);\n double pic = pivector.at(i);\n double fraction = 1/sqrt(pow((2*datum::pi), mu.n_rows)* det(co));\n vec m(mu.colptr(i),mu.n_rows);\n\n \n for(int j = 0; j < datatranspose.n_cols; j++){\n \n vec datasubset(datatranspose.colptr(j), datatranspose.n_rows);\n mat delta = datasubset - m;\n mat deltatranspose = delta.t();\n double exparg = ((-0.5)*deltatranspose*inv(co)*delta).eval()(0,0);\n double eulerexp = exp(exparg);\n // cout<<\"First: \"<<(-0.5)*deltatranspose;\n // cout<<\"Second:\\n \"<> data) {\n\n// };\n\n// std::vector > obtenerVectorRIC() {\n // \"\"\"E Step\"\"\"\n // r_ic = np.zeros((len(self.X),len(self.cov)))\n // for m,co,p,r in zip(self.mu,self.cov,self.pi,range(len(r_ic[0]))):\n // co+=self.reg_cov\n // mn = multivariate_normal(mean=m,cov=co)\n // r_ic[:,r] = p*mn.pdf(self.X)/np.sum([pi_c*multivariate_normal(mean=mu_c,cov=cov_c).pdf(X) for pi_c,mu_c,cov_c in zip(self.pi,self.mu,self.cov+self.reg_cov)],axis=0)\n\n// }\n// };\n\n// std::vector > convertToVector(std::string npArray) {\n// std::vector vec;\n// vec.push_back(1);\n// std::vector > vecs;\n// vecs.push_back(vec);\n// return vecs;\n\n// }\nint main() {\n context ctx;\n zmqpp::message message;\n socket work(ctx, socket_type::pull);\n socket sink(ctx, socket_type::push);\n std::cout<<\"connecting\"< armadillotest{10,20,30};\n // mat hi(armadillotest);\n std::vector> mu = info[\"mu\"].get >> ();\n std::vector pi = info[\"pi\"].get >();\n std::vector> regcov = info[\"regcov\"].get >> ();\n std::vector>> cov = info[\"cov\"]\n .get >>> ();\n std::vector> x = info[\"x\"].get >> ();\n // std::cout<<\"mu: \"<> vectosend(x.size());\n for (int i=0; i>::from(r_ic.row(i));\n }\n cout<<\"R_IC:\\n-------------------\\n\";\n\n cout<> dataAsVector = convertToVector(message.get(0));\n // EWorker worker = EWorker(dataAsVector);\n // std::vector > ric = worker.obtenerVectorRIC();\n}\n", "meta": {"hexsha": "4a14a9b690b675565195b85fa44fed59009cc79b", "size": 7316, "ext": "cc", "lang": "C++", "max_stars_repo_path": "practicas/maximizacion_esperanza/worker.cc", "max_stars_repo_name": "mrfreedeer/Arquitectura-Cliente-Servidor", "max_stars_repo_head_hexsha": "aac90b50d150de29a2cee276050013f7bb826d72", "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": "practicas/maximizacion_esperanza/worker.cc", "max_issues_repo_name": "mrfreedeer/Arquitectura-Cliente-Servidor", "max_issues_repo_head_hexsha": "aac90b50d150de29a2cee276050013f7bb826d72", "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": "practicas/maximizacion_esperanza/worker.cc", "max_forks_repo_name": "mrfreedeer/Arquitectura-Cliente-Servidor", "max_forks_repo_head_hexsha": "aac90b50d150de29a2cee276050013f7bb826d72", "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.5145631068, "max_line_length": 175, "alphanum_fraction": 0.4767632586, "num_tokens": 1814, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972751232809, "lm_q2_score": 0.5156199157230157, "lm_q1q2_score": 0.4488972936277532}} {"text": "/********************************************************************************\n* This file is part of CinoLib *\n* Copyright(C) 2016: Marco Livesu *\n* *\n* The MIT License *\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 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 NON INFRINGEMENT. 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* Author(s): *\n* *\n* Marco Livesu (marco.livesu@gmail.com) *\n* http://pers.ge.imati.cnr.it/livesu/ *\n* *\n* Daniela Cabiddu *\n* http://www.imati.cnr.it/index.php/people/8-curricula/119-daniela-cabiddu *\n* *\n* Italian National Research Council (CNR) *\n* Institute for Applied Mathematics and Information Technologies (IMATI) *\n* Via de Marini, 6 *\n* 16149 Genoa, *\n* Italy *\n*********************************************************************************/\n#include \n#include \n#include \n\n// Most of this is coming from here:\n// http://www.boost.org/doc/libs/1_65_1/libs/polygon/doc/voronoi_diagram.htm\n// http://www.boost.org/doc/libs/1_65_0/libs/polygon/example/voronoi_basic_tutorial.cpp\n//\n#ifdef CINOLIB_USES_BOOST\n#include \n#include \n#include \n#include \n//\nusing boost::polygon::voronoi_builder;\nusing boost::polygon::voronoi_diagram;\nusing boost::polygon::voronoi_edge;\nusing boost::polygon::x;\nusing boost::polygon::y;\nusing boost::polygon::low;\nusing boost::polygon::high;\n//\nstruct polygon_point\n{\n int x;\n int y;\n polygon_point(int x, int y) : x(x), y(y) {}\n};\n//\nstruct polygon_segment\n{\n polygon_point p0;\n polygon_point p1;\n polygon_segment(int x1, int y1, int x2, int y2) : p0(x1, y1), p1(x2, y2) {}\n};\n//\ntemplate<>\nstruct boost::polygon::geometry_concept\n{\n typedef boost::polygon::point_concept type;\n};\n//\ntemplate<>\nstruct boost::polygon::point_traits\n{\n typedef int coordinate_type;\n static inline coordinate_type get(const polygon_point & point, orientation_2d orient)\n {\n return (orient == HORIZONTAL) ? point.x : point.y;\n }\n};\n//\ntemplate<>\nstruct boost::polygon::geometry_concept\n{\n typedef boost::polygon::segment_concept type;\n};\n//\ntemplate<>\nstruct boost::polygon::segment_traits\n{\n typedef int coordinate_type;\n typedef polygon_point point_type;\n\n static inline point_type get(const polygon_segment& segment, direction_1d dir)\n {\n return dir.to_int() ? segment.p1 : segment.p0;\n }\n};\n//\ntypedef boost::geometry::model::d2::point_xy BoostPoint;\ntypedef boost::geometry::model::polygon BoostPolygon;\n\n#endif // CINOLIB_USES_BOOST\n\nnamespace cinolib\n{\n\n#ifdef CINOLIB_USES_BOOST\n\nBoostPolygon make_boost_poly(const std::vector & poly)\n{\n BoostPolygon boost_poly;\n for(vec2d p : poly) boost::geometry::append(boost_poly, BoostPoint(p.x(), p.y()));\n boost::geometry::correct(boost_poly);\n return boost_poly;\n}\n\n//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::\n\nCINO_INLINE\nvoid polygon_maximum_inscribed_circle(const std::vector & poly,\n vec2d & center,\n double & radius)\n{\n radius = 0.0;\n center = vec2d(0,0);\n\n vec2d min( inf_double, inf_double);\n vec2d max(-inf_double, -inf_double);\n for(auto p : poly)\n {\n min = min.min(p);\n max = max.max(p);\n }\n\n double scale_factor;\n double diag = min.dist(max);\n\n if(diag >= 1.0) scale_factor = std::numeric_limits::max() / diag;\n else scale_factor = std::numeric_limits::max() * diag;\n\n scale_factor *= 0.5; // dumb attempt to stay on the safe side and avoid overflows...\n\n // Boost implementation of Generazlied Voronoi uses integer coordinates.\n // In order to achieve maximum precision I am scaling the polygon as much\n // as I can in order to minimize loss of precision during integer roundoff...\n\n std::vector segments;\n for(uint i=0; i vd;\n construct_voronoi(segments.begin(), segments.end(), &vd);\n\n BoostPolygon boost_poly = make_boost_poly(poly);\n for(auto it=vd.vertices().begin(); it!=vd.vertices().end(); ++it)\n {\n const voronoi_diagram::vertex_type &v = *it;\n const voronoi_diagram::edge_type *e = v.incident_edge();\n const voronoi_diagram::cell_type *c = e->cell();\n const polygon_segment &s = segments.at(c->source_index());\n\n // do not consider Voronoi vertices outside the polygon\n if (boost::geometry::within(BoostPoint(v.x()/scale_factor, v.y()/scale_factor), boost_poly))\n {\n // annoying wrap to vec3d (TODO: template cinolib::Segment to make it work in 2D too)\n vec3d beg(s.p0.x, s.p0.y, 0);\n vec3d end(s.p1.x, s.p1.y, 0);\n vec3d c3d(v.x(), v.y(), 0);\n cinolib::Segment tmp(beg,end);\n double d = tmp.dist_to_point(c3d);\n\n if (d > radius)\n {\n radius = d;\n center = vec2d(c3d); // will automatically drop z\n }\n }\n }\n\n radius /= scale_factor;\n center /= scale_factor;\n}\n\n//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::\n\nCINO_INLINE\nvoid polygon_maximum_inscribed_circle(const std::vector & poly, // will drop z component\n vec3d & center, // will have z=0\n double & radius)\n{\n std::vector poly_2d;\n for(auto p : poly) poly_2d.push_back(vec2d(p.x(), p.y()));\n\n vec2d center_2d;\n polygon_maximum_inscribed_circle(poly_2d, center_2d, radius);\n center = vec3d(center_2d.x(), center_2d.y(), 0);\n}\n\n#endif // CINOLIB_USES_BOOST\n\n}\n", "meta": {"hexsha": "f5069bb2fd7656d8e6b1ea74c04fbae57083e26c", "size": 8580, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "include/cinolib/polygon_maximum_inscribed_circle.cpp", "max_stars_repo_name": "bbrrck/cinolib", "max_stars_repo_head_hexsha": "c7cceefd041646e1e1113339e681e212a9bba7e7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-06-22T00:23:45.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-22T00:23:45.000Z", "max_issues_repo_path": "include/cinolib/polygon_maximum_inscribed_circle.cpp", "max_issues_repo_name": "snowfox1939/cinolib", "max_issues_repo_head_hexsha": "6017d9dd7461e7008df8198563d63526db3ed86a", "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/cinolib/polygon_maximum_inscribed_circle.cpp", "max_forks_repo_name": "snowfox1939/cinolib", "max_forks_repo_head_hexsha": "6017d9dd7461e7008df8198563d63526db3ed86a", "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.7222222222, "max_line_length": 100, "alphanum_fraction": 0.5257575758, "num_tokens": 1851, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998611746912, "lm_q2_score": 0.5774953651858118, "lm_q1q2_score": 0.4488870671879591}} {"text": "//\n// Created by jianping on 17-9-11.\n//\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n//image intrinsics\n//reference image r,t\n//source image r,t\n//https://github.com/opencv/opencv/blob/master/samples/cpp/stereo_match.cpp\n\n\n\n\nvoid saveXYZ(const char* filename, const cv::Mat& mat,float tx)\n{\n const double max_z = 10000;\n FILE* fp = fopen(filename, \"wt\");\n for(int y = 0; y < mat.rows; y++)\n {\n for(int x = 0; x < mat.cols; x++)\n {\n cv::Vec3f point = mat.at(y, x);\n if(fabs(fabs(point[2]) - max_z) < FLT_EPSILON || fabs(point[2]) > max_z) continue;\n fprintf(fp, \"%f %f %f\\n\", point[0], point[1], point[2]);\n }\n }\n fclose(fp);\n}\n\nvoid readParams(const std::string& intrinsicFile,\n Eigen::Matrix3d& K,\n Eigen::Matrix3d& C,\n Eigen::Vector3d& t)\n{\n std::ifstream ifs(intrinsicFile.c_str(),std::ios_base::in);\n char line[256];\n ifs.getline(line,256);\n sscanf(line,\"%lf %lf %lf\",&K(0,0),&K(0,1),&K(0,2));\n ifs.getline(line,256);\n sscanf(line,\"%lf %lf %lf\",&K(1,0),&K(1,1),&K(1,2));\n ifs.getline(line,256);\n sscanf(line,\"%lf %lf %lf\",&K(2,0),&K(2,1),&K(2,2));\n ifs.getline(line,256);//useless\n ifs.getline(line,256);\n sscanf(line,\"%lf %lf %lf\",&C(0,0),&C(0,1),&C(0,2));\n ifs.getline(line,256);\n sscanf(line,\"%lf %lf %lf\",&C(1,0),&C(1,1),&C(1,2));\n ifs.getline(line,256);\n sscanf(line,\"%lf %lf %lf\",&C(2,0),&C(2,1),&C(2,2));\n ifs.getline(line,256);\n sscanf(line,\"%lf %lf %lf\",&t(0),&t(1),&t(2));\n std::cout<\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \n#include \n\nnamespace openjij {\n namespace graph {\n\n /**\n * @brief two-body all-to-all interactions \n * The Hamiltonian is like\n * \\f[\n * H = \\sum_{i\n class Dense : public Graph{\n static_assert(std::is_floating_point::value, \"FloatType must be floating-point type.\");\n public:\n\n /**\n * @brief interaction type (Eigen)\n * The stored matrix has the following triangular form:\n *\n * \\f[\n * \\begin{pmatrix}\n * J_{0,0} & J_{0,1} & \\cdots & J_{0,N-1} & h_{0}\\\\\n * 0 & J_{1,1} & \\cdots & J_{1,N-1} & h_{1}\\\\\n * \\vdots & \\vdots & \\vdots & \\vdots & \\vdots \\\\\n * 0 & 0 & \\cdots & J_{N-1,N-1} & h_{N-1}\\\\\n * 0 & 0 & \\cdots & 0 & 1 \\\\\n * \\end{pmatrix}\n * \\f]\n */\n using Interactions = Eigen::Matrix;\n\n /**\n * @brief float type\n */\n using value_type = FloatType;\n \n private:\n\n /**\n * @brief interactions \n */\n Interactions _J;\n\n public:\n\n /**\n * @brief Dense constructor\n *\n * @param num_spins the number of spins\n */\n explicit Dense(std::size_t num_spins)\n : Graph(num_spins), _J(Interactions::Zero(num_spins+1, num_spins+1)){\n _J(num_spins, num_spins) = 1;\n }\n\n /**\n * @brief Dense constructor (from nlohmann::json)\n *\n * @param j JSON object this object must be a serialized object of dense BQM.\n */\n Dense(const json& j) : Dense(static_cast(j[\"num_variables\"])){\n //define bqm with ising variables\n auto bqm = json_parse(j);\n //interactions\n //for(auto&& elem : bqm.get_quadratic()){\n // const auto& key = elem.first;\n // const auto& val = elem.second;\n // J(key.first, key.second) += val;\n //}\n //local field\n //for(auto&& elem : bqm.get_linear()){\n // const auto& key = elem.first;\n // const auto& val = elem.second;\n // h(key) += val;\n //}\n // the above insertion is simplified as \n this->_J = bqm.interaction_matrix();\n }\n\n /**\n * @brief set interaction matrix from Eigen Matrix.\n *\n * @param interaction Eigen matrix\n */\n void set_interaction_matrix(const Interactions& interaction){\n if(interaction.rows() != interaction.cols()){\n std::runtime_error(\"interaction.rows() != interaction.cols()\");\n }\n\n if((size_t)interaction.rows() != get_num_spins() + 1){\n throw std::runtime_error(\"invalid matrix size.\");\n }\n\n //check if diagonal elements are zero\n for(size_t i=0; i<(size_t)(interaction.rows()-1); i++){\n if(interaction(i,i) != 0){\n throw std::runtime_error(\"The diagonal elements of interaction matrix must be zero.\");\n }\n }\n\n if(interaction(interaction.rows()-1,interaction.rows()-1) != 1){\n throw std::runtime_error(\"The right bottom element of interaction matrix must be unity.\");\n }\n\n _J = interaction.template selfadjointView();\n }\n\n\n /**\n * @brief Dense copy constructor\n */\n Dense(const Dense&) = default;\n\n /**\n * @brief Dense move constructor\n */\n Dense(Dense&&) = default;\n\n /**\n * @brief calculate total energy \n *\n * @param spins\n * @deprecated use energy(spins)\n *\n * @return corresponding energy\n */\n FloatType calc_energy(const Spins& spins) const{\n return this->energy(spins);\n }\n\n FloatType calc_energy(const Eigen::Matrix& spins) const{\n return this->energy(spins);\n }\n\n /**\n * @brief calculate total energy \n *\n * @param spins\n *\n * @return corresponding energy\n */\n FloatType energy(const Spins& spins) const{\n if(spins.size() != this->get_num_spins()){\n throw std::out_of_range(\"Out of range in energy in Dense graph.\");\n }\n\n using Vec = Eigen::Matrix;\n Vec s(get_num_spins()+1);\n for(size_t i=0; i()*s))(0,0)-1;\n }\n\n FloatType energy(const Eigen::Matrix& spins) const{\n graph::Spins temp_spins(get_num_spins());\n for(size_t i=0; i_J.template selfadjointView();\n }\n\n };\n } // namespace graph \n} // namespace openjij\n\n#endif\n", "meta": {"hexsha": "d66065c2e6a093ab65c7a6e46f19498a4121db7d", "size": 11130, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/graph/dense.hpp", "max_stars_repo_name": "OpenJij/OpenJij", "max_stars_repo_head_hexsha": "9ed58500ef47583bc472410d470bb2dd4bfec74a", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 61.0, "max_stars_repo_stars_event_min_datetime": "2019-01-05T13:37:10.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-11T02:11:08.000Z", "max_issues_repo_path": "src/graph/dense.hpp", "max_issues_repo_name": "OpenJij/OpenJij", "max_issues_repo_head_hexsha": "9ed58500ef47583bc472410d470bb2dd4bfec74a", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 79.0, "max_issues_repo_issues_event_min_datetime": "2019-01-29T09:55:20.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-19T04:06:20.000Z", "max_forks_repo_path": "src/graph/dense.hpp", "max_forks_repo_name": "OpenJij/OpenJij", "max_forks_repo_head_hexsha": "9ed58500ef47583bc472410d470bb2dd4bfec74a", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 21.0, "max_forks_repo_forks_event_min_datetime": "2019-01-07T07:55:10.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-08T14:27:23.000Z", "avg_line_length": 38.9160839161, "max_line_length": 123, "alphanum_fraction": 0.3907457323, "num_tokens": 2126, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8152324713956856, "lm_q2_score": 0.5506073655352404, "lm_q1q2_score": 0.44887300337396163}} {"text": "// Copyright (C) 2016 Kasper Kristensen\n// License: GPL-2\n\n#ifndef TINY_AD_H\n#define TINY_AD_H\n\n/* Standalone ? */\n#ifndef R_RCONFIG_H\n#include \n#include \n#define CSKIP(x) x\n#endif\n\n/* Select the vector class to use (Default: tiny_vec) */\n#if defined(TINY_AD_USE_STD_VALARRAY)\n#include \"tiny_valarray.hpp\"\n#define TINY_VECTOR(type,size) tiny_vector\n#elif defined(TINY_AD_USE_EIGEN_VEC)\n#include \n#define TINY_VECTOR(type,size) Eigen::Array\n#else\n#include \"tiny_vec.hpp\"\n#define TINY_VECTOR(type,size) tiny_vec\n#endif\n\nnamespace tiny_ad {\n template\n struct ad {\n Type value;\n Vector deriv;\n ad(){}\n ad(Type v, Vector d){value = v; deriv = d;}\n ad(double v) {value = v; deriv.setZero();}\n ad operator+ (const ad &other) const{\n return ad(value + other.value,\n\t\tderiv + other.deriv);\n }\n ad operator+ () const{\n return *this;\n }\n ad operator- (const ad &other) const{\n return ad(value - other.value,\n\t\tderiv - other.deriv);\n }\n ad operator- () const{\n return ad(-value, -deriv);\n }\n ad operator* (const ad &other) const{\n return ad(value * other.value,\n\t\tvalue * other.deriv +\n\t\tderiv * other.value);\n }\n ad operator/ (const ad &other) const{\n Type res = value / other.value;\n return ad(res,\n\t\t(deriv - res * other.deriv) /\n\t\tother.value );\n }\n /* Comparison operators */\n#define COMPARISON_OPERATOR(OP)\t\t\t\\\n template\t\t\t\\\n bool operator OP (const other &x) const{\t\\\n return (value OP x);\t\t\t\\\n }\n COMPARISON_OPERATOR(<)\n COMPARISON_OPERATOR(>)\n COMPARISON_OPERATOR(<=)\n COMPARISON_OPERATOR(>=)\n COMPARISON_OPERATOR(==)\n COMPARISON_OPERATOR(!=)\n#undef COMPARISON_OPERATOR\n /* Combine ad with other types (constants) */\n ad operator+ (const double &x) const{\n return ad(value + x, deriv);\n }\n ad operator- (const double &x) const{\n return ad(value - x, deriv);\n }\n ad operator* (const double &x) const{\n return ad(value * x, deriv * x);\n }\n ad operator/ (const double &x) const{\n return ad(value / x, deriv / x);\n }\n /* Note: 'this' and 'other' may point to the same object */\n ad& operator+=(const ad &other){\n value += other.value;\n deriv += other.deriv;\n return *this;\n }\n ad& operator-=(const ad &other){\n value -= other.value;\n deriv -= other.deriv;\n return *this;\n }\n ad& operator*=(const ad &other){\n if (this != &other) {\n\tderiv *= other.value;\n\tderiv += other.deriv * value;\n\tvalue *= other.value;\n } else {\n\tderiv *= value * 2.;\n\tvalue *= value;\n }\n return *this;\n }\n ad& operator/=(const ad &other){\n value /= other.value;\n deriv -= other.deriv * value;\n deriv /= other.value;\n return *this;\n }\n };\n /* Binary operators where a constant is first argument */\n template\n ad operator+ (const double &x, const ad &y) {\n return y + x;\n }\n template\n ad operator- (const double &x, const ad &y) {\n return -(y - x);\n }\n template\n ad operator* (const double &x, const ad &y) {\n return y * x;\n }\n template\n ad operator/ (const double &x, const ad &y) {\n T value = x / y.value;\n return ad(value, T(-value / y.value) * y.deriv);\n }\n /* Unary operators with trivial derivatives */\n#define UNARY_MATH_ZERO_DERIV(F)\t\t\\\n template\t\t\t\\\n double F (const ad &x){\t\t\t\\\n return F(x.value);\t\t\t\t\\\n }\n using ::floor; using ::ceil;\n using ::trunc; using ::round;\n UNARY_MATH_ZERO_DERIV(floor)\n UNARY_MATH_ZERO_DERIV(ceil)\n UNARY_MATH_ZERO_DERIV(trunc)\n UNARY_MATH_ZERO_DERIV(round)\n template\n double sign(const T &x){return (x > 0) - (x < 0);}\n bool isfinite(const double &x)CSKIP( {return std::isfinite(x);} )\n template\n bool isfinite(const ad &x){return isfinite(x.value);}\n#undef UNARY_MATH_ZERO_DERIV\n /* Unary operators with non-trivial derivatives */\n#define UNARY_MATH_DERIVATIVE(F,DF)\t\t\\\n template\t\t\t\\\n ad F (const ad &x){\t\t\\\n return ad(F (x.value),\t\t\\\n\t\t T(DF(x.value)) * x.deriv);\t\\\n }\n using ::exp; using ::log;\n using ::sin; using ::cos; using ::tan;\n using ::sinh; using ::cosh; using ::tanh;\n using ::sqrt; using ::fabs;\n template T D_tan(const T &x) {\n T y = cos(x); return 1. / (y * y);\n }\n template T D_tanh(const T &x) {\n T y = cosh(x); return 1. / (y * y);\n }\n UNARY_MATH_DERIVATIVE(exp, exp)\n UNARY_MATH_DERIVATIVE(log, 1.0/)\n UNARY_MATH_DERIVATIVE(sin, cos)\n UNARY_MATH_DERIVATIVE(cos, -sin)\n UNARY_MATH_DERIVATIVE(tan, D_tan)\n UNARY_MATH_DERIVATIVE(sinh, cosh)\n UNARY_MATH_DERIVATIVE(cosh, sinh)\n UNARY_MATH_DERIVATIVE(tanh, D_tanh)\n UNARY_MATH_DERIVATIVE(sqrt, 0.5/sqrt)\n UNARY_MATH_DERIVATIVE(fabs, sign)\n using ::expm1; using ::log1p;\n UNARY_MATH_DERIVATIVE(expm1, exp)\n template T D_log1p(const T &x) {return 1. / (x + 1.);}\n UNARY_MATH_DERIVATIVE(log1p, D_log1p)\n /* asin, acos, atan */\n using ::asin; using ::acos; using ::atan;\n template T D_asin(const T &x) {\n return 1. / sqrt(1. - x * x);\n }\n template T D_acos(const T &x) {\n return -1. / sqrt(1. - x * x);\n }\n template T D_atan(const T &x) {\n return 1. / (1. + x * x);\n }\n UNARY_MATH_DERIVATIVE(asin, D_asin)\n UNARY_MATH_DERIVATIVE(acos, D_acos)\n UNARY_MATH_DERIVATIVE(atan, D_atan)\n#undef UNARY_MATH_DERIVATIVE\n /* A few more ... */\n template\n ad pow (const ad &x, const ad &y){\n return exp(y * log(x));\n }\n using ::pow;\n template\n ad pow (const ad &x, const double &y){\n return ad (pow(x.value, y), // Note: x.value could be 0\n\t\t T( y * pow(x.value, y - 1.) ) * x.deriv);\n }\n /* Comparison operators where a constant is first argument */\n#define COMPARISON_OPERATOR_FLIP(OP1, OP2)\t\t\t\\\n template\t\t\t\t\t\\\n bool operator OP1 (const double &x, const ad &y) {\t\\\n return y OP2 x;\t\t\t\t\t\t\\\n }\n COMPARISON_OPERATOR_FLIP(<,>)\n COMPARISON_OPERATOR_FLIP(<=,>=)\n COMPARISON_OPERATOR_FLIP(>,<)\n COMPARISON_OPERATOR_FLIP(>=,<=)\n COMPARISON_OPERATOR_FLIP(==,==)\n COMPARISON_OPERATOR_FLIP(!=,!=)\n#undef COMPARISON_OPERATOR_FLIP\n /* Utility: Return the value of a tiny_ad type */\n double asDouble(double x) CSKIP( {return x;} )\n template\n double asDouble (const ad &x){\n return asDouble(x.value);\n }\n /* Utility: Return the max absolute value of all members of a\n tiny_ad type */\n double max_fabs(double x) CSKIP( {return fabs(x);} )\n template\n double max_fabs (const ad &x){\n double ans = max_fabs(x.value);\n for(int i=0; i ans ? tmp : ans);\n }\n return ans;\n }\n /* R-specific derivatives (rely on Rmath)*/\n#ifdef R_RCONFIG_H\n extern \"C\" {\n /* See 'R-API: entry points to C-code' (Writing R-extensions) */\n double\tRf_lgammafn(double);\n double\tRf_psigamma(double, double);\n }\n template\n double lgamma(const double &x) {\n return Rf_psigamma(x, deriv-1);\n }\n template<>\n double lgamma<0>(const double &x) CSKIP( {return Rf_lgammafn(x);} )\n double lgamma(const double &x) CSKIP( {return lgamma<0>(x);} )\n template\n ad lgamma (const ad &x){\n return ad (lgamma< deriv >(x.value),\n\t\t T(lgamma< deriv + 1 >(x.value)) * x.deriv);\n }\n template\n ad lgamma (const ad &x){\n return lgamma<0>(x);\n }\n#endif\n /* Print method */\n template\n std::ostream &operator<<(std::ostream &os, const ad &x) {\n os << \"{\";\n os << \" value=\" << x.value;\n os << \" deriv=\" << x.deriv;\n os << \"}\";\n return os;\n }\n\n /* Interface to higher order derivatives. Example:\n\n typedef tiny_ad::variable<3, 2> Float; // Track 3rd order derivs wrt. 2 parameters\n Float a (1.23, 0); // Let a = 1.23 have parameter index 0\n Float b (2.34, 1); // Let b = 2.34 have parameter index 1\n Float y = sin(a + b); // Run the algorithm\n y.getDeriv(); // Get all 3rd order derivatives\n */\n#define VARIABLE(order, nvar, scalartype) variable\n template\n struct variable : ad< VARIABLE(order-1, nvar, Double),\n\t\t\tTINY_VECTOR( VARIABLE(order-1, nvar, Double) , nvar) > {\n typedef ad< VARIABLE(order-1, nvar, Double),\n\t\tTINY_VECTOR(VARIABLE(order-1, nvar, Double), nvar) > Base;\n typedef variable Type;\n static const int result_size = nvar * Type::result_size;\n#define ___COMMON_CTORS___ \\\n variable() {} \\\n variable(Base x) : Base(x) {} \\\n variable(double x) : Base(x) {} \\\n variable(double x, int id) : Base(x) { \\\n setid(id); \\\n } \\\n template \\\n variable(variable x) { \\\n Base::value = x; Base::deriv.setZero(); \\\n } \\\n template \\\n variable(ad x) { \\\n Base::value = x; Base::deriv.setZero(); \\\n } \\\n template \\\n variable(variable x, int id) { \\\n Base::value = x; Base::deriv.setZero(); \\\n setid(id); \\\n } \\\n template \\\n variable(ad x, int id) { \\\n Base::value = x; Base::deriv.setZero(); \\\n setid(id); \\\n }\n ___COMMON_CTORS___\n void setid(int i0, int count = 0){\n this->value.setid(i0, count);\n this->deriv[i0].setid(i0, count + 1);\n }\n TINY_VECTOR(Double, result_size) getDeriv(){\n TINY_VECTOR(Double, result_size) ans;\n int stride = result_size / nvar;\n for(int i=0; ideriv[i].getDeriv();\n return ans;\n }\n };\n#undef VARIABLE\n template\n struct variable<1, nvar, Double> : ad{\n typedef ad Base;\n static const int result_size = nvar;\n ___COMMON_CTORS___\n void setid(int i0, int count = 0){\n if(count == 0)\n\tthis->deriv[i0] = 1.0;\n if(count == 1)\n\tthis->value = 1.0;\n }\n TINY_VECTOR(Double, nvar) getDeriv(){\n return this->deriv;\n }\n };\n#undef ___COMMON_CTORS___\n#undef TINY_VECTOR\n} // End namespace tiny_ad\n\n#endif\n", "meta": {"hexsha": "83fa9542ef2abd5f5918213484762dd2a67ebef1", "size": 11107, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "renv/library/R-4.1/x86_64-w64-mingw32/TMB/include/tiny_ad/tiny_ad/tiny_ad.hpp", "max_stars_repo_name": "rebeccagb/gtsummary", "max_stars_repo_head_hexsha": "04996e385acab0b76a9938378e8af87526117aef", "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": "renv/library/R-4.1/x86_64-w64-mingw32/TMB/include/tiny_ad/tiny_ad/tiny_ad.hpp", "max_issues_repo_name": "rebeccagb/gtsummary", "max_issues_repo_head_hexsha": "04996e385acab0b76a9938378e8af87526117aef", "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": "renv/library/R-4.1/x86_64-w64-mingw32/TMB/include/tiny_ad/tiny_ad/tiny_ad.hpp", "max_forks_repo_name": "rebeccagb/gtsummary", "max_forks_repo_head_hexsha": "04996e385acab0b76a9938378e8af87526117aef", "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.0086455331, "max_line_length": 87, "alphanum_fraction": 0.5867470964, "num_tokens": 3358, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7341195385342971, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.44882745210289016}} {"text": "/**\n * @file BooleanOperation.hpp\n * @author bwu\n * @brief Boolean operation for geometries\n * @version 0.1\n * @date 2022-02-22\n */\n#ifndef GENERIC_GEOMETRY_BOOLEANOPERATION_HPP\n#define GENERIC_GEOMETRY_BOOLEANOPERATION_HPP\n#include \"BoostPolygonRegister.hpp\"\n#include \"GeometryTraits.hpp\"\n#include \n#include \nnamespace generic {\nnamespace geometry {\n///@brief boolean operations of geometry\nnamespace boolean {\n\ntemplate \nusing PolygonSet2D = boost::polygon::polygon_set_data;\n\n/**\n * @brief Boolean OR (polygon set union) operation of two geometries\n * @param[in] g1 one of the input geometries, could be one of Triangle2D, Box2D, Polygon2D, PolygonWithHoles2D\n * @param[in] g2 one of the input geometries, could be one of Triangle2D, Box2D, Polygon2D, PolygonWithHoles2D\n * @param[out] results stl container with Polygon2D that hold the union result of two geometries\n */\ntemplate class container, \n template class allocator = std::allocator,\n typename std::enable_if::value &&\n traits::is_2d_surf_geom_t::value, bool>::type = true>\ninline void Unite(const geometry_t1 & g1, const geometry_t2 & g2, container, allocator > > & results)\n{\n using namespace boost::polygon::operators;\n PolygonSet2D polygonSet; \n polygonSet += g1;\n polygonSet += g2;\n results.clear();\n polygonSet.get(results);\n}\n\n/**\n * @brief Boolean OR (polygon set union) operation of a collection of geometries\n * @param[in] begin iterator to the beginning of the geometry collection\n * @param[in] end iterator to the ending of the geometry collection\n * @param[out] results stl container with Polygon2D that hold the union result of the collection of geometries\n */\ntemplate class container,\n template class allocator = std::allocator,\n typename std::enable_if::value_type>::value, bool>::type = true>\ninline void Unite(iterator begin, iterator end,\n container::value_type>,\n allocator::value_type> > > & results)\n{\n using namespace boost::polygon::operators;\n using coor_t = typename std::iterator_traits::value_type::coor_t;\n PolygonSet2D polygonSet;\n for(auto iter = begin; iter != end; ++iter) \n polygonSet += *iter;\n results.clear();\n polygonSet.get(results);\n}\n\n/**\n * @brief Boolean AND (polygon set intersection) operation of a two geometries\n * @param[in] g1 one of the input geometries, could be one of Triangle2D, Box2D, Polygon2D, PolygonWithHoles2D\n * @param[in] g2 one of the input geometries, could be one of Triangle2D, Box2D, Polygon2D, PolygonWithHoles2D\n * @param[out] results stl container with Polygon2D that hold the intersection result of two geometries\n */\ntemplate class container, \n template class allocator = std::allocator,\n typename std::enable_if::value &&\n traits::is_2d_surf_geom_t::value, bool>::type = true>\ninline void Intersect(const geometry_t1 & g1, const geometry_t2 & g2, container, allocator > > & results)\n{\n using namespace boost::polygon::operators;\n PolygonSet2D polygonSet; \n polygonSet += g1;\n polygonSet &= g2;\n results.clear();\n polygonSet.get(results);\n}\n\n/**\n * @brief Boolean AND (polygon set intersection) operation of two geometry sets\n * @param[in] begin1 iterator to the beginning of the geometry collection one\n * @param[in] end1 iterator to the ending of the geometry collection one\n * @param[in] begin2 iterator to the beginning of the geometry collection two\n * @param[in] end2 iterator to the ending of the geometry collection two\n * @param[out] results stl container with Polygon2D that hold the intersection result of two geometry sets\n */\ntemplate class container,\n template class allocator = std::allocator,\n typename std::enable_if::value_type>::value &&\n traits::is_2d_surf_geom_t::value_type>::value, bool>::type = true>\ninline void Intersect(iterator1 begin1, iterator1 end1, iterator2 begin2, iterator2 end2,\n container::value_type>,\n allocator::value_type> > > & results)\n{\n using namespace boost::polygon::operators;\n using coor_t = typename std::iterator_traits::value_type::coor_t;\n PolygonSet2D polygonSet1, polygonSet2;\n for(auto iter1 = begin1; iter1 != end1; ++iter1) \n polygonSet1 += *iter1;\n for(auto iter2 = begin2; iter2 != end2; ++iter2)\n polygonSet2 += *iter2;\n polygonSet1 *= polygonSet2;\n results.clear();\n polygonSet1.get(results);\n}\n\n/**\n * @brief Boolean SUBTRACT operation (polygon set difference) of two geometries\n * @param[in] g1 one of the input geometries, could be one of Triangle2D, Box2D, Polygon2D, PolygonWithHoles2D\n * @param[in] g2 one of the input geometries, could be one of Triangle2D, Box2D, Polygon2D, PolygonWithHoles2D\n * @param[out] results stl container with Polygon2D that hold the difference result of two geometries\n */\ntemplate class container, \n template class allocator = std::allocator,\n typename std::enable_if::value &&\n traits::is_2d_surf_geom_t::value, bool>::type = true>\ninline void Subtract(const geometry_t1 & g1, const geometry_t2 & g2, container, allocator > > & results)\n{\n using namespace boost::polygon::operators;\n PolygonSet2D polygonSet; \n polygonSet += g1;\n polygonSet -= g2;\n results.clear();\n polygonSet.get(results);\n}\n\n/**\n * @brief Boolean SUBTRACT operation (polygon set difference) of two geometry sets\n * @param[in] begin1 iterator to the beginning of the geometry collection one\n * @param[in] end1 iterator to the ending of the geometry collection one\n * @param[in] begin2 iterator to the beginning of the geometry collection two\n * @param[in] end2 iterator to the ending of the geometry collection two\n * @param[out] results stl container with Polygon2D that hold the difference result of two geometry sets\n */\ntemplate class container,\n template class allocator = std::allocator,\n typename std::enable_if::value_type>::value &&\n traits::is_2d_surf_geom_t::value_type>::value, bool>::type = true>\ninline void Subtract(iterator1 begin1, iterator1 end1, iterator2 begin2, iterator2 end2,\n container::value_type>,\n allocator::value_type> > > & results)\n{\n using namespace boost::polygon::operators;\n using coor_t = typename std::iterator_traits::value_type::coor_t;\n PolygonSet2D polygonSet;\n for(auto iter = begin1; iter != end1; ++iter) \n polygonSet += *iter;\n for(auto iter = begin2; iter != end2; ++iter)\n polygonSet -= *iter;\n results.clear();\n polygonSet.get(results);\n}\n\n/**\n * @brief Boolean XOR operation (polygon set disjoint-union) of two geometries\n * @param[in] g1 one of the input geometries, could be one of Triangle2D, Box2D, Polygon2D, PolygonWithHoles2D\n * @param[in] g2 one of the input geometries, could be one of Triangle2D, Box2D, Polygon2D, PolygonWithHoles2D\n * @param[out] results stl container with Polygon2D that hold the disjoint-union result of two geometries\n */\ntemplate class container, \n template class allocator = std::allocator,\n typename std::enable_if::value &&\n traits::is_2d_surf_geom_t::value, bool>::type = true>\ninline void Xor(const geometry_t1 & g1, const geometry_t2 & g2, container, allocator > > & results)\n{\n using namespace boost::polygon::operators;\n PolygonSet2D polygonSet; \n polygonSet += g1;\n polygonSet ^= g2;\n results.clear();\n polygonSet.get(results);\n}\n\n/**\n * @brief Boolean XOR operation (polygon set disjoint-union) of two geometry sets\n * @param[in] begin1 iterator to the beginning of the geometry collection one\n * @param[in] end1 iterator to the ending of the geometry collection one\n * @param[in] begin2 iterator to the beginning of the geometry collection two\n * @param[in] end2 iterator to the ending of the geometry collection two\n * @param[out] results stl container with Polygon2D that hold the disjoint-union result of two geometry sets\n */\ntemplate class container,\n template class allocator = std::allocator,\n typename std::enable_if::value_type>::value &&\n traits::is_2d_surf_geom_t::value_type>::value, bool>::type = true>\ninline void Xor(iterator1 begin1, iterator1 end1, iterator2 begin2, iterator2 end2,\n container::value_type>,\n allocator::value_type> > > & results)\n{\n using namespace boost::polygon::operators;\n using coor_t = typename std::iterator_traits::value_type::coor_t;\n PolygonSet2D polygonSet1, polygonSet2;\n for(auto iter1 = begin1; iter1 != end1; ++iter1) \n polygonSet1 += *iter1;\n for(auto iter2 = begin2; iter2 != end2; ++iter2)\n polygonSet2 += *iter2;\n polygonSet1 ^= polygonSet2;\n results.clear();\n polygonSet1.get(results);\n}\n\n} //namespace boolean\n} //namespace geometry\n} //namespace generic\n#endif//GENERIC_GEOMETRY_BOOLEANOPERATION_HPP", "meta": {"hexsha": "bfdc33d5383570351f402698a597e0d20ac87938", "size": 11375, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "geometry/BooleanOperation.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/BooleanOperation.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/BooleanOperation.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": 51.9406392694, "max_line_length": 157, "alphanum_fraction": 0.7163076923, "num_tokens": 2758, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7341195269001831, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.4488274449900026}} {"text": "// (C) Copyright John Maddock 2005.\r\n// (C) Copyright Henry S. Warren 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_TR1_RANDOM_HPP_INCLUDED\r\n# define BOOST_TR1_RANDOM_HPP_INCLUDED\r\n# include \r\n\r\n#ifdef BOOST_HAS_TR1_RANDOM\r\n# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)\r\n# include_next BOOST_TR1_HEADER(random)\r\n# else\r\n# include \r\n# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(random))\r\n# endif\r\n#else\r\n// Boost.Random:\r\n#include \r\n#ifndef __SUNPRO_CC\r\n // Sunpros linker complains if we so much as include this...\r\n# include \r\n#endif\r\n#include \r\n#include \r\n#include \r\n\r\nnamespace std { namespace tr1{\r\n\r\nusing ::boost::variate_generator;\r\n\r\ntemplate\r\nclass linear_congruential\r\n{\r\nprivate:\r\n typedef ::boost::random::linear_congruential impl_type;\r\npublic:\r\n // types\r\n typedef UIntType result_type;\r\n // parameter values\r\n BOOST_STATIC_CONSTANT(UIntType, multiplier = a);\r\n BOOST_STATIC_CONSTANT(UIntType, increment = c);\r\n BOOST_STATIC_CONSTANT(UIntType, modulus = m);\r\n // constructors and member function\r\n explicit linear_congruential(unsigned long x0 = 1)\r\n : m_gen(x0){}\r\n linear_congruential(const linear_congruential& that)\r\n : m_gen(that.m_gen){}\r\n template linear_congruential(Gen& g)\r\n {\r\n init1(g, ::boost::is_same());\r\n }\r\n void seed(unsigned long x0 = 1)\r\n { m_gen.seed(x0); }\r\n template void seed(Gen& g)\r\n { \r\n init2(g, ::boost::is_fundamental());\r\n }\r\n result_type min BOOST_PREVENT_MACRO_SUBSTITUTION() const\r\n { return (m_gen.min)(); }\r\n result_type max BOOST_PREVENT_MACRO_SUBSTITUTION() const\r\n { return (m_gen.max)(); }\r\n result_type operator()()\r\n {\r\n return m_gen(); \r\n }\r\n bool operator==(const linear_congruential& that)const\r\n { return m_gen == that.m_gen; }\r\n bool operator!=(const linear_congruential& that)const\r\n { return m_gen != that.m_gen; }\r\n\r\n#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))\r\n template\r\n friend std::basic_ostream&\r\n operator<<(std::basic_ostream& os,\r\n const linear_congruential& lcg)\r\n {\r\n return os << lcg.m_gen; \r\n }\r\n\r\n template\r\n friend std::basic_istream&\r\n operator>>(std::basic_istream& is,\r\n linear_congruential& lcg)\r\n {\r\n return is >> lcg.m_gen;\r\n }\r\n#endif\r\n\r\nprivate:\r\n template \r\n void init1(Gen& g, const ::boost::true_type&)\r\n {\r\n m_gen = g.m_gen;\r\n }\r\n template \r\n void init1(Gen& g, const ::boost::false_type&)\r\n {\r\n init2(g, ::boost::is_fundamental());\r\n }\r\n template \r\n void init2(Gen& g, const ::boost::true_type&)\r\n {\r\n m_gen.seed(static_cast(g));\r\n }\r\n template \r\n void init2(Gen& g, const ::boost::false_type&)\r\n {\r\n //typedef typename Gen::result_type gen_rt;\r\n boost::tr1_details::functor2iterator f1(g), f2;\r\n m_gen.seed(f1, f2);\r\n }\r\n impl_type m_gen;\r\n};\r\n\r\ntemplate\r\nclass mersenne_twister\r\n{\r\n typedef ::boost::random::mersenne_twister\r\n imp_type;\r\npublic:\r\n // types\r\n typedef UIntType result_type;\r\n // parameter values\r\n BOOST_STATIC_CONSTANT(int, word_size = w);\r\n BOOST_STATIC_CONSTANT(int, state_size = n);\r\n BOOST_STATIC_CONSTANT(int, shift_size = m);\r\n BOOST_STATIC_CONSTANT(int, mask_bits = r);\r\n BOOST_STATIC_CONSTANT(UIntType, parameter_a = a);\r\n BOOST_STATIC_CONSTANT(int, output_u = u);\r\n BOOST_STATIC_CONSTANT(int, output_s = s);\r\n BOOST_STATIC_CONSTANT(UIntType, output_b = b);\r\n BOOST_STATIC_CONSTANT(int, output_t = t);\r\n BOOST_STATIC_CONSTANT(UIntType, output_c = c);\r\n BOOST_STATIC_CONSTANT(int, output_l = l);\r\n // constructors and member function\r\n mersenne_twister(){}\r\n explicit mersenne_twister(unsigned long value)\r\n : m_gen(value == 0 ? 5489UL : value){}\r\n template mersenne_twister(Gen& g)\r\n {\r\n init1(g, ::boost::is_same());\r\n }\r\n void seed()\r\n { m_gen.seed(); }\r\n void seed(unsigned long value)\r\n { m_gen.seed(value == 0 ? 5489UL : value); }\r\n template void seed(Gen& g)\r\n { init2(g, ::boost::is_fundamental()); }\r\n result_type min BOOST_PREVENT_MACRO_SUBSTITUTION() const\r\n { return (m_gen.min)(); }\r\n result_type max BOOST_PREVENT_MACRO_SUBSTITUTION() const\r\n { return (m_gen.max)(); }\r\n result_type operator()()\r\n { return m_gen(); }\r\n bool operator==(const mersenne_twister& that)const\r\n { return m_gen == that.m_gen; }\r\n bool operator!=(const mersenne_twister& that)const\r\n { return m_gen != that.m_gen; }\r\n\r\n#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))\r\n template\r\n friend std::basic_ostream&\r\n operator<<(std::basic_ostream& os,\r\n const mersenne_twister& lcg)\r\n {\r\n return os << lcg.m_gen;\r\n }\r\n\r\n template\r\n friend std::basic_istream&\r\n operator>>(std::basic_istream& is,\r\n mersenne_twister& lcg)\r\n {\r\n return is >> lcg.m_gen;\r\n }\r\n#endif\r\nprivate:\r\n template \r\n void init1(Gen& g, const ::boost::true_type&)\r\n {\r\n m_gen = g.m_gen;\r\n }\r\n template \r\n void init1(Gen& g, const ::boost::false_type&)\r\n {\r\n init2(g, ::boost::is_fundamental());\r\n }\r\n template \r\n void init2(Gen& g, const ::boost::true_type&)\r\n {\r\n m_gen.seed(static_cast(g == 0 ? 4357UL : g));\r\n }\r\n template \r\n void init2(Gen& g, const ::boost::false_type&)\r\n {\r\n m_gen.seed(g);\r\n }\r\n imp_type m_gen;\r\n};\r\n\r\ntemplate\r\nclass subtract_with_carry\r\n{\r\npublic:\r\n // types\r\n typedef IntType result_type;\r\n // parameter values\r\n BOOST_STATIC_CONSTANT(IntType, modulus = m);\r\n BOOST_STATIC_CONSTANT(int, long_lag = r);\r\n BOOST_STATIC_CONSTANT(int, short_lag = s);\r\n\r\n // constructors and member function\r\n subtract_with_carry(){}\r\n explicit subtract_with_carry(unsigned long value)\r\n : m_gen(value == 0 ? 19780503UL : value){}\r\n template subtract_with_carry(Gen& g)\r\n { init1(g, ::boost::is_same >()); }\r\n void seed(unsigned long value = 19780503ul)\r\n { m_gen.seed(value == 0 ? 19780503UL : value); }\r\n template void seed(Gen& g)\r\n { init2(g, ::boost::is_fundamental()); }\r\n result_type min BOOST_PREVENT_MACRO_SUBSTITUTION() const\r\n { return (m_gen.min)(); }\r\n result_type max BOOST_PREVENT_MACRO_SUBSTITUTION() const\r\n { return (m_gen.max)(); }\r\n result_type operator()()\r\n { return m_gen(); }\r\n bool operator==(const subtract_with_carry& that)const\r\n { return m_gen == that.m_gen; }\r\n bool operator!=(const subtract_with_carry& that)const\r\n { return m_gen != that.m_gen; }\r\n\r\n#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))\r\n template\r\n friend std::basic_ostream&\r\n operator<<(std::basic_ostream& os,\r\n const subtract_with_carry& lcg)\r\n {\r\n return os << lcg.m_gen;\r\n }\r\n\r\n template\r\n friend std::basic_istream&\r\n operator>>(std::basic_istream& is,\r\n subtract_with_carry& lcg)\r\n {\r\n return is >> lcg.m_gen;\r\n }\r\n#endif\r\nprivate:\r\n template \r\n void init1(Gen& g, const ::boost::true_type&)\r\n {\r\n m_gen = g.m_gen;\r\n }\r\n template \r\n void init1(Gen& g, const ::boost::false_type&)\r\n {\r\n init2(g, ::boost::is_fundamental());\r\n }\r\n template \r\n void init2(Gen& g, const ::boost::true_type&)\r\n {\r\n m_gen.seed(static_cast(g == 0 ? 19780503UL : g));\r\n }\r\n template \r\n void init2(Gen& g, const ::boost::false_type&)\r\n {\r\n m_gen.seed(g);\r\n }\r\n ::boost::random::subtract_with_carry m_gen;\r\n};\r\n\r\ntemplate\r\nclass subtract_with_carry_01\r\n{\r\npublic:\r\n // types\r\n typedef RealType result_type;\r\n // parameter values\r\n BOOST_STATIC_CONSTANT(int, word_size = w);\r\n BOOST_STATIC_CONSTANT(int, long_lag = r);\r\n BOOST_STATIC_CONSTANT(int, short_lag = s);\r\n\r\n // constructors and member function\r\n subtract_with_carry_01(){}\r\n explicit subtract_with_carry_01(unsigned long value)\r\n : m_gen(value == 0 ? 19780503UL : value){}\r\n template subtract_with_carry_01(Gen& g)\r\n { init1(g, ::boost::is_same >()); }\r\n void seed(unsigned long value = 19780503UL)\r\n { m_gen.seed(value == 0 ? 19780503UL : value); }\r\n template void seed(Gen& g)\r\n { init2(g, ::boost::is_fundamental()); }\r\n result_type min BOOST_PREVENT_MACRO_SUBSTITUTION() const\r\n { return (m_gen.min)(); }\r\n result_type max BOOST_PREVENT_MACRO_SUBSTITUTION() const\r\n { return (m_gen.max)(); }\r\n result_type operator()()\r\n { return m_gen(); }\r\n bool operator==(const subtract_with_carry_01& that)const\r\n { return m_gen == that.m_gen; }\r\n bool operator!=(const subtract_with_carry_01& that)const\r\n { return m_gen != that.m_gen; }\r\n\r\n#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))\r\n template\r\n friend std::basic_ostream&\r\n operator<<(std::basic_ostream& os,\r\n const subtract_with_carry_01& lcg)\r\n {\r\n return os << lcg.m_gen;\r\n }\r\n\r\n template\r\n friend std::basic_istream&\r\n operator>>(std::basic_istream& is,\r\n subtract_with_carry_01& lcg)\r\n {\r\n return is >> lcg.m_gen;\r\n }\r\n#endif\r\nprivate:\r\n template \r\n void init1(Gen& g, const ::boost::true_type&)\r\n {\r\n m_gen = g.m_gen;\r\n }\r\n template \r\n void init1(Gen& g, const ::boost::false_type&)\r\n {\r\n init2(g, ::boost::is_fundamental());\r\n }\r\n template \r\n void init2(Gen& g, const ::boost::true_type&)\r\n {\r\n m_gen.seed(static_cast(g == 0 ? 19780503UL : g));\r\n }\r\n template \r\n void init2(Gen& g, const ::boost::false_type&)\r\n {\r\n //typedef typename Gen::result_type gen_rt;\r\n boost::tr1_details::functor2iterator f1(g), f2;\r\n m_gen.seed(f1, f2);\r\n }\r\n ::boost::random::subtract_with_carry_01 m_gen;\r\n};\r\n\r\nusing ::boost::random::discard_block;\r\n\r\ntemplate\r\nclass xor_combine\r\n{\r\npublic:\r\n // types\r\n typedef UniformRandomNumberGenerator1 base1_type;\r\n typedef UniformRandomNumberGenerator2 base2_type;\r\n typedef unsigned long result_type;\r\n // parameter values\r\n BOOST_STATIC_CONSTANT(int, shift1 = s1);\r\n BOOST_STATIC_CONSTANT(int, shift2 = s2);\r\n // constructors and member function\r\n xor_combine(){ init_minmax(); }\r\n xor_combine(const base1_type & rng1, const base2_type & rng2)\r\n : m_b1(rng1), m_b2(rng2) { init_minmax(); }\r\n xor_combine(unsigned long s)\r\n : m_b1(s), m_b2(s+1) { init_minmax(); }\r\n template xor_combine(Gen& g)\r\n { \r\n init_minmax(); \r\n init1(g, ::boost::is_same >());\r\n }\r\n void seed()\r\n {\r\n m_b1.seed();\r\n m_b2.seed();\r\n }\r\n void seed(unsigned long s)\r\n {\r\n m_b1.seed(s);\r\n m_b2.seed(s+1);\r\n }\r\n template void seed(Gen& g)\r\n {\r\n init2(g, ::boost::is_fundamental());\r\n }\r\n\r\n const base1_type& base1() const\r\n { return m_b1; }\r\n const base2_type& base2() const\r\n { return m_b2; }\r\n result_type min BOOST_PREVENT_MACRO_SUBSTITUTION() const\r\n { return m_min; }\r\n result_type max BOOST_PREVENT_MACRO_SUBSTITUTION() const\r\n { return m_max; }\r\n result_type operator()()\r\n { return (m_b1() << s1) ^ (m_b2() << s2); }\r\n\r\n bool operator == (const xor_combine& that)const\r\n { return (m_b1 == that.m_b1) && (m_b2 == that.m_b2); }\r\n bool operator != (const xor_combine& that)const\r\n { return !(*this == that); }\r\n\r\n#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))\r\n template\r\n friend std::basic_ostream&\r\n operator<<(std::basic_ostream& os,\r\n const xor_combine& lcg)\r\n {\r\n return os << lcg.m_b1 << \" \" << lcg.m_b2;\r\n }\r\n\r\n template\r\n friend std::basic_istream&\r\n operator>>(std::basic_istream& is,\r\n xor_combine& lcg)\r\n {\r\n return is >> lcg.m_b1 >> lcg.m_b2;\r\n }\r\n#endif\r\n\r\nprivate:\r\n void init_minmax();\r\n base1_type m_b1;\r\n base2_type m_b2;\r\n result_type m_min;\r\n result_type m_max;\r\n\r\n template \r\n void init1(Gen& g, const ::boost::true_type&)\r\n {\r\n m_b1 = g.m_b1;\r\n m_b2 = g.m_b2;\r\n }\r\n template \r\n void init1(Gen& g, const ::boost::false_type&)\r\n {\r\n init2(g, ::boost::is_fundamental());\r\n }\r\n template \r\n void init2(Gen& g, const ::boost::true_type&)\r\n {\r\n m_b1.seed(static_cast(g));\r\n m_b2.seed(static_cast(g));\r\n }\r\n template \r\n void init2(Gen& g, const ::boost::false_type&)\r\n {\r\n m_b1.seed(g);\r\n m_b2.seed(g);\r\n }\r\n};\r\n\r\ntemplate\r\nvoid xor_combine::init_minmax()\r\n{\r\n //\r\n // The following code is based on that given in \"Hacker's Delight\"\r\n // by Henry S. Warren, (Addison-Wesley, 2003), and at \r\n // http://www.hackersdelight.org/index.htm.\r\n // Used here by permission.\r\n //\r\n // calculation of minimum value:\r\n //\r\n result_type a = (m_b1.min)() << s1;\r\n result_type b = (m_b1.max)() << s1;\r\n result_type c = (m_b2.min)() << s2;\r\n result_type d = (m_b2.max)() << s2;\r\n result_type m, temp;\r\n\r\n m = 0x1uL << ((sizeof(result_type) * CHAR_BIT) - 1);\r\n while (m != 0) {\r\n if (~a & c & m) {\r\n temp = (a | m) & (static_cast(0u) - m);\r\n if (temp <= b) a = temp;\r\n }\r\n else if (a & ~c & m) {\r\n temp = (c | m) & (static_cast(0u) - m);\r\n if (temp <= d) c = temp;\r\n }\r\n m >>= 1;\r\n }\r\n m_min = a ^ c;\r\n\r\n //\r\n // calculation of maximum value:\r\n //\r\n if((((std::numeric_limits::max)() >> s1) < (m_b1.max)())\r\n || ((((std::numeric_limits::max)()) >> s2) < (m_b2.max)()))\r\n {\r\n m_max = (std::numeric_limits::max)();\r\n return;\r\n }\r\n a = (m_b1.min)() << s1;\r\n b = (m_b1.max)() << s1;\r\n c = (m_b2.min)() << s2;\r\n d = (m_b2.max)() << s2;\r\n\r\n m = 0x1uL << ((sizeof(result_type) * CHAR_BIT) - 1);\r\n\r\n while (m != 0) {\r\n if (b & d & m) {\r\n temp = (b - m) | (m - 1);\r\n if (temp >= a) b = temp;\r\n else {\r\n temp = (d - m) | (m - 1);\r\n if (temp >= c) d = temp;\r\n }\r\n }\r\n m = m >> 1;\r\n }\r\n m_max = b ^ d;\r\n}\r\n\r\ntypedef linear_congruential< ::boost::int32_t, 16807, 0, 2147483647> minstd_rand0;\r\ntypedef linear_congruential< ::boost::int32_t, 48271, 0, 2147483647> minstd_rand;\r\ntypedef mersenne_twister< ::boost::uint32_t, 32,624,397,31,0x9908b0df,11,7,0x9d2c5680,15,0xefc60000,18> mt19937;\r\ntypedef subtract_with_carry_01 ranlux_base_01;\r\ntypedef subtract_with_carry_01 ranlux64_base_01;\r\ntypedef discard_block, 223, 24> ranlux3;\r\ntypedef discard_block, 389, 24> ranlux4;\r\ntypedef discard_block, 223, 24> ranlux3_01;\r\ntypedef discard_block, 389, 24> ranlux4_01;\r\n\r\n#ifndef __SUNPRO_CC\r\nusing ::boost::random_device;\r\n#endif\r\nusing ::boost::uniform_int;\r\n\r\nclass bernoulli_distribution\r\n{\r\npublic:\r\n // types\r\n typedef int input_type;\r\n typedef bool result_type;\r\n // constructors and member function\r\n explicit bernoulli_distribution(double p = 0.5)\r\n : m_dist(p){}\r\n double p() const\r\n { return m_dist.p(); }\r\n void reset()\r\n { m_dist.reset(); }\r\n template\r\n result_type operator()(UniformRandomNumberGenerator& urng)\r\n {\r\n return m_dist(urng);\r\n }\r\n#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))\r\n template\r\n friend std::basic_ostream&\r\n operator<<(std::basic_ostream& os,\r\n const bernoulli_distribution& lcg)\r\n {\r\n return os << lcg.m_dist;\r\n }\r\n\r\n template\r\n friend std::basic_istream&\r\n operator>>(std::basic_istream& is,\r\n bernoulli_distribution& lcg)\r\n {\r\n return is >> lcg.m_dist;\r\n }\r\n#endif\r\n\r\nprivate:\r\n ::boost::bernoulli_distribution m_dist;\r\n};\r\n//using ::boost::bernoulli_distribution;\r\nusing ::boost::geometric_distribution;\r\nusing ::boost::poisson_distribution;\r\nusing ::boost::binomial_distribution;\r\nusing ::boost::uniform_real;\r\nusing ::boost::exponential_distribution;\r\nusing ::boost::normal_distribution;\r\nusing ::boost::gamma_distribution;\r\n\r\n} }\r\n\r\n#endif\r\n\r\n#endif\r\n\r\n", "meta": {"hexsha": "a1771aaef5c4b9bd2fb115392c1b93f04d9ba85c", "size": 18630, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "ios/Pods/boost-for-react-native/boost/tr1/random.hpp", "max_stars_repo_name": "rudylee/expo", "max_stars_repo_head_hexsha": "b3e65a7a5b205f14a3eb6cd6fa8d13c8d663b1cc", "max_stars_repo_licenses": ["Apache-2.0", "MIT"], "max_stars_count": 8805.0, "max_stars_repo_stars_event_min_datetime": "2015-11-03T00:52:29.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T22:30:03.000Z", "max_issues_repo_path": "ios/Pods/boost-for-react-native/boost/tr1/random.hpp", "max_issues_repo_name": "rudylee/expo", "max_issues_repo_head_hexsha": "b3e65a7a5b205f14a3eb6cd6fa8d13c8d663b1cc", "max_issues_repo_licenses": ["Apache-2.0", "MIT"], "max_issues_count": 14694.0, "max_issues_repo_issues_event_min_datetime": "2015-02-24T15:13:42.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T13:16:45.000Z", "max_forks_repo_path": "ios/Pods/boost-for-react-native/boost/tr1/random.hpp", "max_forks_repo_name": "rudylee/expo", "max_forks_repo_head_hexsha": "b3e65a7a5b205f14a3eb6cd6fa8d13c8d663b1cc", "max_forks_repo_licenses": ["Apache-2.0", "MIT"], "max_forks_count": 1329.0, "max_forks_repo_forks_event_min_datetime": "2015-11-03T20:25:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T18:10:38.000Z", "avg_line_length": 31.737649063, "max_line_length": 125, "alphanum_fraction": 0.642243693, "num_tokens": 5386, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7341195152660688, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.4488274378771148}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\nnamespace sm {\n \nnamespace random {\n \nclass Random\n{\n public:\n // http://www.boost.org/doc/libs/1_49_0/doc/html/boost_random/reference.html#boost_random.reference.generators\n typedef boost::mt19937 base_generator_type;\n\n base_generator_type _generator;\n // Define a uniform random number distribution which produces \"double\"\n // values between 0 and 1 (0 inclusive, 1 exclusive).\n boost::uniform_real<> _uni_dist;\n boost::variate_generator > _uniform;\n boost::normal_distribution<> _normal_dist;\n boost::variate_generator > _normal;\n\n Random() : _uni_dist(0.0,1.0), _uniform(_generator, _uni_dist), _normal_dist(), _normal(_generator, _normal_dist)\n {\n\t// 0\n }\n\n double normal()\n {\n\treturn _normal();\n }\n\n double uniform()\n {\n\treturn _uniform();\n }\n\n void seed(boost::uint64_t s)\n {\n _normal.engine().seed(s);\n _normal.distribution().reset();\n _uniform.engine().seed(s);\n _uniform.distribution().reset();\n }\n\n static Random & instance()\n {\n\tstatic Random random;\n\treturn random;\n }\n};\n\ndouble normal()\n{\n return Random::instance().normal();\n}\n\ndouble randn()\n{\n return Random::instance().normal();\n}\n\ndouble uniform()\n{\n return Random::instance().uniform();\n}\n\ndouble rand()\n{\n return Random::instance().uniform();\n}\n\ndouble randLU(double lowerBoundInclusive, double upperBoundExclusive)\n{\n return Random::instance().uniform() * (upperBoundExclusive - lowerBoundInclusive) + lowerBoundInclusive;\n}\n\nint randLUi(int lowerBoundInclusive, int upperBoundExclusive)\n{\n return (int)floor(Random::instance().uniform() * (upperBoundExclusive - lowerBoundInclusive)) + lowerBoundInclusive;\n}\n\nvoid seed(boost::uint64_t s)\n{\n Random::instance().seed(s);\n}\n\n \n} // namespace random\n\n} // namespace sm\n", "meta": {"hexsha": "6b9a5d21a1bb0d54790e01e5a5a452e5e67dce7f", "size": 2128, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Schweizer-Messer/sm_random/src/random.cpp", "max_stars_repo_name": "PushyamiKaveti/kalibr", "max_stars_repo_head_hexsha": "d8bdfc59ee666ef854012becc93571f96fe5d80c", "max_stars_repo_licenses": ["BSD-4-Clause"], "max_stars_count": 2690.0, "max_stars_repo_stars_event_min_datetime": "2015-01-07T03:50:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T20:27:01.000Z", "max_issues_repo_path": "Schweizer-Messer/sm_random/src/random.cpp", "max_issues_repo_name": "PushyamiKaveti/kalibr", "max_issues_repo_head_hexsha": "d8bdfc59ee666ef854012becc93571f96fe5d80c", "max_issues_repo_licenses": ["BSD-4-Clause"], "max_issues_count": 481.0, "max_issues_repo_issues_event_min_datetime": "2015-01-27T10:21:00.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T14:02:41.000Z", "max_forks_repo_path": "Schweizer-Messer/sm_random/src/random.cpp", "max_forks_repo_name": "PushyamiKaveti/kalibr", "max_forks_repo_head_hexsha": "d8bdfc59ee666ef854012becc93571f96fe5d80c", "max_forks_repo_licenses": ["BSD-4-Clause"], "max_forks_count": 1091.0, "max_forks_repo_forks_event_min_datetime": "2015-01-26T21:21:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T01:55:33.000Z", "avg_line_length": 21.9381443299, "max_line_length": 118, "alphanum_fraction": 0.725093985, "num_tokens": 521, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7341195152660687, "lm_q2_score": 0.611381973294151, "lm_q1q2_score": 0.44882743787711465}} {"text": "/* compile with g++ ... -l arprec */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\ntypedef mtl::dense2D mat_c;\n\nostream& operator<< (ostream& os, const mp_complex& c) {\n\treturn os << \"(\" << c.real << \", \" << c.imag << \")\";\n}\n\nint main() {\n\n\tmp::mp_init(102);\n\tcout.precision(30);\n\n\tmp_real x1,x2,x3,x4,x5,x6;\n\tx1 = mp_real(\"2e18\");\n\tx2 = mp_real(\"-1.34\");\n\tx3 = mp_real(\"1.6\");\n\tx4 = mp_real(3);\n\tx5 = mp_real(\"1.83e7\");\n\tx6 = mp_real(\"-4.234\");\n\tcout << \"x1 = \" << x1 << \"\\n\";\n\tcout << \"x2 = \" << x2 << \"\\n\";\n\tcout << \"x3 = \" << x3 << \"\\n\";\n\tcout << \"x4 = \" << x4 << \"\\n\";\n\tcout << \"x5 = \" << x5 << \"\\n\";\n\tcout << \"x6 = \" << x6 << \"\\n\";\n\tcout << \"---------------\\n\";\n\n\tmp_complex z1,z2,z3,z4,z5,z6;\n\tz1 = mp_complex(\"4e30\",\"3e30\");\n\tz2 = mp_complex(\"3\",\"-3.5\");\n\tz3 = z1+z2;\n\tz4 = sqrt(mp_complex(\"-4\",\"0\"));\n\tz5 = z2+z4;\n\tz6 = z2-z3+z1+z4;\n\tcout << \"z1 = \" << z1 << \"\\n\";\n\tcout << \"z2 = \" << z2 << \"\\n\";\n\tcout << \"z3 = \" << z3 << \"\\n\";\n\tcout << \"z4 = \" << z4 << \"\\n\";\n\tcout << \"z5 = \" << z5 << \"\\n\";\n\tcout << \"z6 = \" << z6 << \"\\n\";\n\tcout << \"---------------\\n\";\n\t{\n\tmtl::dense2D A(2,2),B(2,2),C(2,2),D(2,2);\n\tmtl::dense_vector b(2),x(2),r(2);\n\tA = x1,x2,\n\t x3,x4;\n\tb = x5,x6;\n\tcout << \"A = \\n\" << A;\n\tcout << \"b = \" << b << endl;\n\n\t// A = A*A;\t// Laufzeitfehler\n\tA*=A;\n\tcout << \"A = \\n\" << A;\n\tcout << \"A*A = \\n\" << A*A;\n\tB =A*A;\n\tcout << \"B = \\n\" << B;\n\tC = trans(A);\n\tcout << \"C = \\n\" << C;\n\tD = A;\n\n\tmtl::dense_vector p(2);\n\tlu(A,p);\n\tx = lu_apply(A,p,b);\n\tr = D*x-b;\n\tcout << \"Ax-b = \" << r << endl;\n\tcout << \"---------------\\n\";\n\t}\n\n\t{\n\tmtl::dense2D A(2,2),B(2,2),C(2,2),D(2,2);\n\tmtl::dense_vector b(2),x(2),r(2);\n \tA = z1,z2,\t\n \t z3,z4;\n\n\n\tb = z5,z6;\n\tcout << \"A = \\n\" << A;\n\tcout << \"b = \" << b << endl;\n\n\t// A = A*A;\t// Compilezeitfehler\n\t// A*=A;\t// Compilezeitfehler\n\tB =A*A;\t// Compilezeitfehler\n\tC = trans(A);\t// Compilezeitfehler\n\n\tD = A;\n\n\tmtl::dense_vector p(2);\n\tlu(A,p);\t// Compilezeitfehler\n\tx = lu_apply(A,p,b);\n\tr = D*x-b;\n \tcout << \"Ax-b = \" << r << endl;\n\tcout << \"---------------\\n\";\n\n\tcout << \"abs(A[0][0]) is \" << abs(A[0][0]) << '\\n';\n\t}\n\n\tmp::mp_finalize();\n\n}\n", "meta": {"hexsha": "1d762b92708db987a80a84d087599aedb9ead23c", "size": 2363, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libs/numeric/mtl/experimental/mp_mtl_kompatibilitaet.cpp", "max_stars_repo_name": "lit-uriy/mtl4-mirror", "max_stars_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_stars_repo_licenses": ["MTLL"], "max_stars_count": 24.0, "max_stars_repo_stars_event_min_datetime": "2019-03-26T15:25:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T10:00:45.000Z", "max_issues_repo_path": "libs/numeric/mtl/experimental/mp_mtl_kompatibilitaet.cpp", "max_issues_repo_name": "lit-uriy/mtl4-mirror", "max_issues_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_issues_repo_licenses": ["MTLL"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2020-04-17T12:35:32.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-03T15:46:25.000Z", "max_forks_repo_path": "libs/numeric/mtl/experimental/mp_mtl_kompatibilitaet.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": 21.2882882883, "max_line_length": 56, "alphanum_fraction": 0.4790520525, "num_tokens": 953, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.743168019989179, "lm_q2_score": 0.6039318337259584, "lm_q1q2_score": 0.4488228250785546}} {"text": "// (C) Copyright John Maddock 2006.\n// Use, modification and distribution are subject to the\n// Boost Software License, Version 1.0. (See accompanying file\n// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n\n#ifndef BOOST_MATH_TOOLS_REMEZ_HPP\n#define BOOST_MATH_TOOLS_REMEZ_HPP\n\n#ifdef _MSC_VER\n#pragma once\n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost{ namespace math{ namespace tools{\n\nnamespace detail{\n\n//\n// The error function: the difference between F(x) and\n// the current approximation. This is the function\n// for which we must find the extema.\n//\ntemplate \nstruct remez_error_function\n{\n typedef boost::function1 function_type;\npublic:\n remez_error_function(\n function_type f_, \n const polynomial& n, \n const polynomial& d, \n bool rel_err)\n : f(f_), numerator(n), denominator(d), rel_error(rel_err) {}\n\n T operator()(const T& z)const\n {\n T y = f(z);\n T abs = y - (numerator.evaluate(z) / denominator.evaluate(z));\n T err;\n if(rel_error)\n {\n if(y != 0)\n err = abs / fabs(y);\n else if(0 == abs)\n {\n // we must be at a root, or it's not recoverable:\n BOOST_ASSERT(0 == abs);\n err = 0;\n }\n else\n {\n // We have a divide by zero!\n // Lets assume that f(x) is zero as a result of\n // internal cancellation error that occurs as a result\n // of shifting a root at point z to the origin so that\n // the approximation can be \"pinned\" to pass through\n // the origin: in that case it really\n // won't matter what our approximation calculates here\n // as long as it's a small number, return the absolute error:\n err = abs;\n }\n }\n else\n err = abs;\n return err;\n }\nprivate:\n function_type f;\n polynomial numerator;\n polynomial denominator;\n bool rel_error;\n};\n//\n// This function adapts the error function so that it's minima\n// are the extema of the error function. We can find the minima\n// with standard techniques.\n//\ntemplate \nstruct remez_max_error_function\n{\n remez_max_error_function(const remez_error_function& f)\n : func(f) {}\n\n T operator()(const T& x)\n {\n BOOST_MATH_STD_USING\n return -fabs(func(x));\n }\nprivate:\n remez_error_function func;\n};\n\n} // detail\n\ntemplate \nclass remez_minimax\n{\npublic:\n typedef boost::function1 function_type;\n typedef boost::numeric::ublas::vector vector_type;\n typedef boost::numeric::ublas::matrix matrix_type;\n\n remez_minimax(function_type f, unsigned oN, unsigned oD, T a, T b, bool pin = true, bool rel_err = false, int sk = 0, int bits = 0);\n remez_minimax(function_type f, unsigned oN, unsigned oD, T a, T b, bool pin, bool rel_err, int sk, int bits, const vector_type& points);\n\n void reset(unsigned oN, unsigned oD, T a, T b, bool pin = true, bool rel_err = false, int sk = 0, int bits = 0);\n void reset(unsigned oN, unsigned oD, T a, T b, bool pin, bool rel_err, int sk, int bits, const vector_type& points);\n\n void set_brake(int b)\n {\n BOOST_ASSERT(b < 100);\n BOOST_ASSERT(b >= 0);\n m_brake = b;\n }\n\n T iterate();\n\n polynomial denominator()const;\n polynomial numerator()const;\n\n vector_type const& chebyshev_points()const\n {\n return control_points;\n }\n\n vector_type const& zero_points()const\n {\n return zeros;\n }\n\n T error_term()const\n {\n return solution[solution.size() - 1];\n }\n T max_error()const\n {\n return m_max_error;\n }\n T max_change()const\n {\n return m_max_change;\n }\n void rotate()\n {\n --orderN;\n ++orderD;\n }\n void rescale(T a, T b)\n {\n T scale = (b - a) / (max - min);\n for(unsigned i = 0; i < control_points.size(); ++i)\n {\n control_points[i] = (control_points[i] - min) * scale + a;\n }\n min = a;\n max = b;\n }\nprivate:\n\n void init_chebyshev();\n\n function_type func; // The function to approximate.\n vector_type control_points; // Current control points to be used for the next iteration.\n vector_type solution; // Solution from the last iteration contains all unknowns including the error term.\n vector_type zeros; // Location of points of zero error from last iteration, plus the two end points.\n vector_type maxima; // Location of maxima of the error function, actually contains the control points used for the last iteration.\n T m_max_error; // Maximum error found in last approximation.\n T m_max_change; // Maximum change in location of control points after last iteration.\n unsigned orderN; // Order of the numerator polynomial.\n unsigned orderD; // Order of the denominator polynomial.\n T min, max; // End points of the range to optimise over.\n bool rel_error; // If true optimise for relative not absolute error.\n bool pinned; // If true the approximation is \"pinned\" to go through the origin.\n unsigned unknowns; // Total number of unknowns.\n int m_precision; // Number of bits precision to which the zeros and maxima are found.\n T m_max_change_history[2]; // Past history of changes to control points.\n int m_brake; // amount to break by in percentage points.\n int m_skew; // amount to skew starting points by in percentage points: -100-100\n};\n\n#ifndef BRAKE\n#define BRAKE 0\n#endif\n#ifndef SKEW\n#define SKEW 0\n#endif\n\ntemplate \nvoid remez_minimax::init_chebyshev()\n{\n BOOST_MATH_STD_USING\n //\n // Fill in the zeros:\n //\n unsigned terms = pinned ? orderD + orderN : orderD + orderN + 1;\n\n for(unsigned i = 0; i < terms; ++i)\n {\n T cheb = cos((2 * terms - 1 - 2 * i) * constants::pi() / (2 * terms));\n cheb += 1;\n cheb /= 2;\n if(m_skew != 0)\n {\n T p = static_cast(200 + m_skew) / 200;\n cheb = pow(cheb, p);\n }\n cheb *= (max - min);\n cheb += min;\n zeros[i+1] = cheb;\n }\n zeros[0] = min;\n zeros[unknowns] = max;\n // perform a regular interpolation fit:\n matrix_type A(terms, terms);\n vector_type b(terms);\n // fill in the y values:\n for(unsigned i = 0; i < b.size(); ++i)\n {\n b[i] = func(zeros[i+1]);\n }\n // fill in powers of x evaluated at each of the control points:\n unsigned offsetN = pinned ? 0 : 1;\n unsigned offsetD = offsetN + orderN;\n unsigned maxorder = (std::max)(orderN, orderD);\n for(unsigned i = 0; i < b.size(); ++i)\n {\n T x0 = zeros[i+1];\n T x = x0;\n if(!pinned)\n A(i, 0) = 1;\n for(unsigned j = 0; j < maxorder; ++j)\n {\n if(j < orderN)\n A(i, j + offsetN) = x;\n if(j < orderD)\n {\n A(i, j + offsetD) = -x * b[i];\n }\n x *= x0;\n }\n }\n //\n // Now go ahead and solve the expression to get our solution:\n //\n vector_type l_solution = boost::math::tools::solve(A, b);\n // need to add a \"fake\" error term:\n l_solution.resize(unknowns);\n l_solution[unknowns-1] = 0;\n solution = l_solution;\n //\n // Now find all the extrema of the error function:\n //\n detail::remez_error_function Err(func, this->numerator(), this->denominator(), rel_error);\n detail::remez_max_error_function Ex(Err);\n m_max_error = 0;\n //int max_err_location = 0;\n for(unsigned i = 0; i < unknowns; ++i)\n {\n std::pair r = brent_find_minima(Ex, zeros[i], zeros[i+1], m_precision);\n maxima[i] = r.first;\n T rel_err = fabs(r.second);\n if(rel_err > m_max_error)\n {\n m_max_error = fabs(r.second);\n //max_err_location = i;\n }\n }\n control_points = maxima;\n}\n\ntemplate \nvoid remez_minimax::reset(\n unsigned oN, \n unsigned oD, \n T a, \n T b, \n bool pin, \n bool rel_err, \n int sk,\n int bits)\n{\n control_points = vector_type(oN + oD + (pin ? 1 : 2));\n solution = control_points;\n zeros = vector_type(oN + oD + (pin ? 2 : 3));\n maxima = control_points;\n orderN = oN;\n orderD = oD;\n rel_error = rel_err;\n pinned = pin;\n m_skew = sk;\n min = a;\n max = b;\n m_max_error = 0;\n unknowns = orderN + orderD + (pinned ? 1 : 2);\n // guess our initial control points:\n control_points[0] = min;\n control_points[unknowns - 1] = max;\n T interval = (max - min) / (unknowns - 1);\n T spot = min + interval;\n for(unsigned i = 1; i < control_points.size(); ++i)\n {\n control_points[i] = spot;\n spot += interval;\n }\n solution[unknowns - 1] = 0;\n m_max_error = 0;\n if(bits == 0)\n {\n // don't bother about more than float precision:\n m_precision = (std::min)(24, (boost::math::policies::digits >() / 2) - 2);\n }\n else\n {\n // can't be more accurate than half the bits of T:\n m_precision = (std::min)(bits, (boost::math::policies::digits >() / 2) - 2);\n }\n m_max_change_history[0] = m_max_change_history[1] = 1;\n init_chebyshev();\n // do one iteration whatever:\n //iterate();\n}\n\ntemplate \ninline remez_minimax::remez_minimax(\n typename remez_minimax::function_type f, \n unsigned oN, \n unsigned oD, \n T a, \n T b, \n bool pin, \n bool rel_err, \n int sk,\n int bits)\n : func(f) \n{\n m_brake = 0;\n reset(oN, oD, a, b, pin, rel_err, sk, bits);\n}\n\ntemplate \nvoid remez_minimax::reset(\n unsigned oN, \n unsigned oD, \n T a, \n T b, \n bool pin, \n bool rel_err, \n int sk,\n int bits,\n const vector_type& points)\n{\n control_points = vector_type(oN + oD + (pin ? 1 : 2));\n solution = control_points;\n zeros = vector_type(oN + oD + (pin ? 2 : 3));\n maxima = control_points;\n orderN = oN;\n orderD = oD;\n rel_error = rel_err;\n pinned = pin;\n m_skew = sk;\n min = a;\n max = b;\n m_max_error = 0;\n unknowns = orderN + orderD + (pinned ? 1 : 2);\n control_points = points;\n solution[unknowns - 1] = 0;\n m_max_error = 0;\n if(bits == 0)\n {\n // don't bother about more than float precision:\n m_precision = (std::min)(24, (boost::math::policies::digits >() / 2) - 2);\n }\n else\n {\n // can't be more accurate than half the bits of T:\n m_precision = (std::min)(bits, (boost::math::policies::digits >() / 2) - 2);\n }\n m_max_change_history[0] = m_max_change_history[1] = 1;\n // do one iteration whatever:\n //iterate();\n}\n\ntemplate \ninline remez_minimax::remez_minimax(\n typename remez_minimax::function_type f, \n unsigned oN, \n unsigned oD, \n T a, \n T b, \n bool pin, \n bool rel_err, \n int sk,\n int bits,\n const vector_type& points)\n : func(f)\n{\n m_brake = 0;\n reset(oN, oD, a, b, pin, rel_err, sk, bits, points);\n}\n\ntemplate \nT remez_minimax::iterate()\n{\n BOOST_MATH_STD_USING\n matrix_type A(unknowns, unknowns);\n vector_type b(unknowns);\n\n // fill in evaluation of f(x) at each of the control points:\n for(unsigned i = 0; i < b.size(); ++i)\n {\n // take care that none of our control points are at the origin:\n if(pinned && (control_points[i] == 0))\n {\n if(i)\n control_points[i] = control_points[i-1] / 3;\n else\n control_points[i] = control_points[i+1] / 3;\n }\n b[i] = func(control_points[i]);\n }\n\n T err_err;\n unsigned convergence_count = 0;\n do{\n // fill in powers of x evaluated at each of the control points:\n int sign = 1;\n unsigned offsetN = pinned ? 0 : 1;\n unsigned offsetD = offsetN + orderN;\n unsigned maxorder = (std::max)(orderN, orderD);\n T Elast = solution[unknowns - 1];\n\n for(unsigned i = 0; i < b.size(); ++i)\n {\n T x0 = control_points[i];\n T x = x0;\n if(!pinned)\n A(i, 0) = 1;\n for(unsigned j = 0; j < maxorder; ++j)\n {\n if(j < orderN)\n A(i, j + offsetN) = x;\n if(j < orderD)\n {\n T mult = rel_error ? T(b[i] - sign * fabs(b[i]) * Elast): T(b[i] - sign * Elast);\n A(i, j + offsetD) = -x * mult;\n }\n x *= x0;\n }\n // The last variable to be solved for is the error term, \n // sign changes with each control point:\n T E = rel_error ? T(sign * fabs(b[i])) : T(sign);\n A(i, unknowns - 1) = E;\n sign = -sign;\n }\n\n #ifdef BOOST_MATH_INSTRUMENT\n for(unsigned i = 0; i < b.size(); ++i)\n std::cout << b[i] << \" \";\n std::cout << \"\\n\\n\";\n for(unsigned i = 0; i < b.size(); ++i)\n {\n for(unsigned j = 0; j < b.size(); ++ j)\n std::cout << A(i, j) << \" \";\n std::cout << \"\\n\";\n }\n std::cout << std::endl;\n #endif\n //\n // Now go ahead and solve the expression to get our solution:\n //\n solution = boost::math::tools::solve(A, b);\n\n err_err = (Elast != 0) ? T(fabs((fabs(solution[unknowns-1]) - fabs(Elast)) / fabs(Elast))) : T(1);\n }while(orderD && (convergence_count++ < 80) && (err_err > 0.001));\n\n //\n // Perform a sanity check to verify that the solution to the equations\n // is not so much in error as to be useless. The matrix inversion can\n // be very close to singular, so this can be a real problem.\n //\n vector_type sanity = prod(A, solution);\n for(unsigned i = 0; i < b.size(); ++i)\n {\n T err = fabs((b[i] - sanity[i]) / fabs(b[i]));\n if(err > sqrt(epsilon()))\n {\n std::cerr << \"Sanity check failed: more than half the digits in the found solution are in error.\" << std::endl;\n }\n }\n\n //\n // Next comes another sanity check, we want to verify that all the control\n // points do actually alternate in sign, in practice we may have \n // additional roots in the error function that cause this to fail.\n // Failure here is always fatal: even though this code attempts to correct\n // the problem it usually only postpones the inevitable.\n //\n polynomial num, denom;\n num = this->numerator();\n denom = this->denominator();\n T e1 = b[0] - num.evaluate(control_points[0]) / denom.evaluate(control_points[0]);\n#ifdef BOOST_MATH_INSTRUMENT\n std::cout << e1;\n#endif\n for(unsigned i = 1; i < b.size(); ++i)\n {\n T e2 = b[i] - num.evaluate(control_points[i]) / denom.evaluate(control_points[i]);\n#ifdef BOOST_MATH_INSTRUMENT\n std::cout << \" \" << e2;\n#endif\n if(e2 * e1 > 0)\n {\n std::cerr << std::flush << \"Basic sanity check failed: Error term does not alternate in sign, non-recoverable error may follow...\" << std::endl;\n T perturbation = 0.05;\n do{\n T point = control_points[i] * (1 - perturbation) + control_points[i-1] * perturbation;\n e2 = func(point) - num.evaluate(point) / denom.evaluate(point);\n if(e2 * e1 < 0)\n {\n control_points[i] = point;\n break;\n }\n perturbation += 0.05;\n }while(perturbation < 0.8);\n\n if((e2 * e1 > 0) && (i + 1 < b.size()))\n {\n perturbation = 0.05;\n do{\n T point = control_points[i] * (1 - perturbation) + control_points[i+1] * perturbation;\n e2 = func(point) - num.evaluate(point) / denom.evaluate(point);\n if(e2 * e1 < 0)\n {\n control_points[i] = point;\n break;\n }\n perturbation += 0.05;\n }while(perturbation < 0.8);\n }\n\n }\n e1 = e2;\n }\n\n#ifdef BOOST_MATH_INSTRUMENT\n for(unsigned i = 0; i < solution.size(); ++i)\n std::cout << solution[i] << \" \";\n std::cout << std::endl << this->numerator() << std::endl;\n std::cout << this->denominator() << std::endl;\n std::cout << std::endl;\n#endif\n\n //\n // The next step is to find all the intervals in which our maxima\n // lie:\n //\n detail::remez_error_function Err(func, this->numerator(), this->denominator(), rel_error);\n zeros[0] = min;\n zeros[unknowns] = max;\n for(unsigned i = 1; i < control_points.size(); ++i)\n {\n eps_tolerance tol(m_precision);\n boost::uintmax_t max_iter = 1000;\n std::pair p = toms748_solve(\n Err, \n control_points[i-1], \n control_points[i], \n tol, \n max_iter);\n zeros[i] = (p.first + p.second) / 2;\n //zeros[i] = bisect(Err, control_points[i-1], control_points[i], m_precision);\n }\n //\n // Now find all the extrema of the error function:\n //\n detail::remez_max_error_function Ex(Err);\n m_max_error = 0;\n //int max_err_location = 0;\n for(unsigned i = 0; i < unknowns; ++i)\n {\n std::pair r = brent_find_minima(Ex, zeros[i], zeros[i+1], m_precision);\n maxima[i] = r.first;\n T rel_err = fabs(r.second);\n if(rel_err > m_max_error)\n {\n m_max_error = fabs(r.second);\n //max_err_location = i;\n }\n }\n //\n // Almost done now! we just need to set our control points\n // to the extrema, and calculate how much each point has changed\n // (this will be our termination condition):\n //\n swap(control_points, maxima);\n m_max_change = 0;\n //int max_change_location = 0;\n for(unsigned i = 0; i < unknowns; ++i)\n {\n control_points[i] = (control_points[i] * (100 - m_brake) + maxima[i] * m_brake) / 100;\n T change = fabs((control_points[i] - maxima[i]) / control_points[i]);\n#if 0\n if(change > m_max_change_history[1])\n {\n // divergence!!! try capping the change:\n std::cerr << \"Possible divergent step, change will be capped!!\" << std::endl;\n change = m_max_change_history[1];\n if(control_points[i] < maxima[i])\n control_points[i] = maxima[i] - change * maxima[i];\n else\n control_points[i] = maxima[i] + change * maxima[i];\n }\n#endif\n if(change > m_max_change)\n {\n m_max_change = change;\n //max_change_location = i;\n }\n }\n //\n // store max change information:\n //\n m_max_change_history[0] = m_max_change_history[1];\n m_max_change_history[1] = fabs(m_max_change);\n\n return m_max_change;\n}\n\ntemplate \npolynomial remez_minimax::numerator()const\n{\n boost::scoped_array a(new T[orderN + 1]);\n if(pinned)\n a[0] = 0;\n unsigned terms = pinned ? orderN : orderN + 1;\n for(unsigned i = 0; i < terms; ++i)\n a[pinned ? i+1 : i] = solution[i];\n return boost::math::tools::polynomial(&a[0], orderN);\n}\n\ntemplate \npolynomial remez_minimax::denominator()const\n{\n unsigned terms = orderD + 1;\n unsigned offsetD = pinned ? orderN : (orderN + 1);\n boost::scoped_array a(new T[terms]);\n a[0] = 1;\n for(unsigned i = 0; i < orderD; ++i)\n a[i+1] = solution[i + offsetD];\n return boost::math::tools::polynomial(&a[0], orderD);\n}\n\n\n}}} // namespaces\n\n#endif // BOOST_MATH_TOOLS_REMEZ_HPP\n\n\n\n", "meta": {"hexsha": "44a3412fc3a9fb6c57dabec36cfeda0e6d1a14cf", "size": 19802, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "libs/math/include_private/boost/math/tools/remez.hpp", "max_stars_repo_name": "cpp-pm/boost", "max_stars_repo_head_hexsha": "38c6c8c07f2fcc42d573b10807fef27ec14930f8", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 12278.0, "max_stars_repo_stars_event_min_datetime": "2015-01-29T17:11:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T21:12:00.000Z", "max_issues_repo_path": "libs/math/include_private/boost/math/tools/remez.hpp", "max_issues_repo_name": "cpp-pm/boost", "max_issues_repo_head_hexsha": "38c6c8c07f2fcc42d573b10807fef27ec14930f8", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 9469.0, "max_issues_repo_issues_event_min_datetime": "2015-01-30T05:33:07.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T16:17:21.000Z", "max_forks_repo_path": "libs/math/include_private/boost/math/tools/remez.hpp", "max_forks_repo_name": "cpp-pm/boost", "max_forks_repo_head_hexsha": "38c6c8c07f2fcc42d573b10807fef27ec14930f8", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 892.0, "max_forks_repo_forks_event_min_datetime": "2015-01-29T16:26:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-20T07:44:30.000Z", "avg_line_length": 29.6437125749, "max_line_length": 153, "alphanum_fraction": 0.5735279265, "num_tokens": 5556, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7431680086124811, "lm_q2_score": 0.6039318337259584, "lm_q1q2_score": 0.44882281820780456}} {"text": "// Copyright (c) 2015-2018, CNRS\n// Authors: Justin Carpentier \n\n#ifndef __multicontact_api_geometry_second_order_cone_hpp__\n#define __multicontact_api_geometry_second_order_cone_hpp__\n\n#include \n#include \n\n#include \"multicontact-api/geometry/fwd.hpp\"\n#include \"multicontact-api/serialization/archive.hpp\"\n#include \"multicontact-api/serialization/eigen-matrix.hpp\"\n\nnamespace multicontact_api {\nnamespace geometry {\n\ntemplate \nstruct SecondOrderCone : public serialization::Serializable > {\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n enum { dim = _dim, Options = _Options };\n typedef _Scalar Scalar;\n typedef Eigen::Matrix MatrixD;\n typedef Eigen::Matrix VectorD;\n typedef Eigen::DenseIndex DenseIndex;\n\n SecondOrderCone()\n : m_Q(MatrixD::Identity()), m_QPo(_dim, _dim), m_direction(VectorD::Zero()), m_Pd(_dim, _dim), m_Po(_dim, _dim) {\n m_direction[_dim - 1] = 1.;\n computeProjectors();\n }\n\n SecondOrderCone(const MatrixD& Q, const VectorD& direction)\n : m_Q(Q), m_QPo(_dim, _dim), m_direction(direction.normalized()), m_Pd(_dim, _dim), m_Po(_dim, _dim) {\n assert(direction.norm() >= Eigen::NumTraits::dummy_precision());\n assert((Q - Q.transpose()).isMuchSmallerThan(Q));\n computeProjectors();\n }\n\n ///\n /// \\brief Build a regular cone from a given friction coefficient and a direction.\n ///\n /// \\param mu Friction coefficient.\n /// \\param direction Direction of the cone.\n ///\n /// \\returns A second order cone.\n ///\n static SecondOrderCone RegularCone(const Scalar mu, const VectorD& direction) {\n assert(mu > 0 && \"The friction coefficient must be non-negative\");\n MatrixD Q(MatrixD::Zero());\n Q.diagonal().fill(1. / mu);\n\n return SecondOrderCone(Q, direction);\n }\n\n template \n bool operator==(const SecondOrderCone& other) const {\n return m_Q == other.m_Q && m_direction == other.m_direction;\n }\n\n template \n bool operator!=(const SecondOrderCone& other) const {\n return !(*this == other);\n }\n\n /// \\returns the value of lhs of the conic inequality\n Scalar lhsValue(const VectorD& point) const {\n // const VectorD x_Po(m_Po * point);\n return (m_QPo * point).norm();\n }\n\n /// \\returns the value of rhs of the conic inequality\n Scalar rhsValue(const VectorD& point) const { return m_direction.dot(point); }\n\n /// \\returns true if the point is inside the cone\n bool check(const VectorD& point) const { return check(point, 1.); }\n\n bool check(const VectorD& point, const Scalar factor) const { return lhsValue(point) <= factor * rhsValue(point); }\n\n /// \\returns the direction of the cone.\n const VectorD& direction() const { return m_direction; }\n void setDirection(const VectorD& direction) {\n assert(direction.norm() >= Eigen::NumTraits::dummy_precision());\n m_direction = direction.normalized();\n computeProjectors();\n }\n\n template \n bool isApprox(const SecondOrderCone& other,\n const Scalar& prec = Eigen::NumTraits::dummy_precision()) const {\n return m_direction.isApprox(other.m_direction, prec) && m_Q.isApprox(other.m_Q, prec);\n }\n\n /// \\returns the quadratic term of the lhs norm.\n const MatrixD& Q() const { return m_Q; }\n void setQ(const MatrixD& Q) {\n assert((Q - Q.transpose()).isMuchSmallerThan(Q));\n m_Q = Q;\n computeProjectors();\n }\n\n void disp(std::ostream& os) const {\n os << \"Q:\\n\" << m_Q << std::endl << \"direction: \" << m_direction.transpose() << std::endl;\n }\n\n friend std::ostream& operator<<(std::ostream& os, const SecondOrderCone& C) {\n C.disp(os);\n return os;\n }\n\n protected:\n inline void computeProjectors() {\n m_Pd = m_direction * m_direction.transpose();\n m_Po = MatrixD::Identity() - m_Pd;\n m_QPo.noalias() = m_Q * m_Po;\n }\n\n /// \\brief Cholesky decomposition matrix reprensenting the conic norm\n MatrixD m_Q;\n /// \\brief Cholesky decomposition projected on the orthogonal of m_direction\n MatrixD m_QPo;\n\n /// \\brief Direction of the cone\n VectorD m_direction;\n\n /// \\brief Projector along the direction of d\n MatrixD m_Pd;\n /// \\brief Projector orthogonal to d\n MatrixD m_Po;\n\n private:\n // Serialization of the class\n friend class boost::serialization::access;\n\n template \n void save(Archive& ar, const unsigned int /*version*/) const {\n ar& boost::serialization::make_nvp(\"quadratic_term\", m_Q);\n ar& boost::serialization::make_nvp(\"direction\", m_direction);\n }\n\n template \n void load(Archive& ar, const unsigned int /*version*/) {\n ar >> boost::serialization::make_nvp(\"quadratic_term\", m_Q);\n ar >> boost::serialization::make_nvp(\"direction\", m_direction);\n\n computeProjectors();\n }\n\n BOOST_SERIALIZATION_SPLIT_MEMBER()\n};\n\n} // namespace geometry\n} // namespace multicontact_api\n\n#endif // ifndef __multicontact_api_geometry_second_order_cone_hpp__\n", "meta": {"hexsha": "1d2edc4626406fed103a1aff0203f4e9a60ab97b", "size": 5112, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/multicontact-api/geometry/second-order-cone.hpp", "max_stars_repo_name": "nim65s/multicontact-api", "max_stars_repo_head_hexsha": "036b902deb2472bb22496a567e93a25a236a3e1e", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-11-23T11:55:53.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-23T11:55:53.000Z", "max_issues_repo_path": "include/multicontact-api/geometry/second-order-cone.hpp", "max_issues_repo_name": "nim65s/multicontact-api", "max_issues_repo_head_hexsha": "036b902deb2472bb22496a567e93a25a236a3e1e", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 14.0, "max_issues_repo_issues_event_min_datetime": "2020-03-13T13:28:23.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-25T12:23:27.000Z", "max_forks_repo_path": "include/multicontact-api/geometry/second-order-cone.hpp", "max_forks_repo_name": "nim65s/multicontact-api", "max_forks_repo_head_hexsha": "036b902deb2472bb22496a567e93a25a236a3e1e", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2019-08-02T13:52:06.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-10T06:53:58.000Z", "avg_line_length": 32.9806451613, "max_line_length": 119, "alphanum_fraction": 0.6971830986, "num_tokens": 1359, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7431680086124812, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.4488228182078045}} {"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_REC_HPP_INCLUDED\n#define BOOST_SIMD_FUNCTION_REC_HPP_INCLUDED\n\n#if defined(DOXYGEN_ONLY)\nnamespace boost { namespace simd\n{\n /*!\n @ingroup group-arithmetic\n Function object implementing rec capabilities\n\n Returns the inverse (reciprocal) of the entry.\n\n @par semantic:\n For any given value @c x of type @c T:\n\n @code\n T r = rec(x);\n @endcode\n\n The code is similar to:\n\n @code\n T r = T(1)/x;\n @endcode\n\n @par Note\n\n For integral typed entries the result is always in the set \\f$\\{0, \\pm1, Valmax \\}\\f$\n\n @par Decorators\n\n For floating types @c rec has several decorated variations\n\n\n - raw_ Many simd architectures provide an intrinsic that computes some bits of the inverse (at least 12)\n and don't care of denormals or limiting values. If it exists this is obtained by the raw_ decorator.\n As usual if it doesn't the plain rec is called.\n\n - with no decorators ensure 1ulp but still doesn't care of limiting value or denormals\n\n **/\n Value rec(Value const & v0);\n} }\n#endif\n\n#include \n#include \n\n#endif\n", "meta": {"hexsha": "fbe57965d075f0db508447c6ea8f880c3dc970e3", "size": 1577, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/boost/simd/function/rec.hpp", "max_stars_repo_name": "nickporubsky/boost-simd-clone", "max_stars_repo_head_hexsha": "b81dfcd9d6524a131ea714f1eebb5bb75adddcc7", "max_stars_repo_licenses": ["BSL-1.0"], "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": "include/boost/simd/function/rec.hpp", "max_issues_repo_name": "nickporubsky/boost-simd-clone", "max_issues_repo_head_hexsha": "b81dfcd9d6524a131ea714f1eebb5bb75adddcc7", "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/function/rec.hpp", "max_forks_repo_name": "nickporubsky/boost-simd-clone", "max_forks_repo_head_hexsha": "b81dfcd9d6524a131ea714f1eebb5bb75adddcc7", "max_forks_repo_licenses": ["BSL-1.0"], "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": 26.2833333333, "max_line_length": 112, "alphanum_fraction": 0.6068484464, "num_tokens": 352, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.743167997235783, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.4488228113370543}} {"text": "/**\n * @file\n * @copyright This code is licensed under the 3-clause BSD license.\\n\n * Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group.\\n\n * See LICENSE.txt for details.\n */\n#include \"DavidsonDiagonalizer.h\"\n#include \"../MathUtils.h\"\n#include \"DiagonalizerSettings.h\"\n#include \"PreconditionerEvaluator.h\"\n#include \"SubspaceOrthogonalizer.h\"\n#include \n#include \n\nnamespace Scine {\nnamespace Utils {\n\nNonOrthogonalDavidson::NonOrthogonalDavidson(int eigenvaluesToCompute, int totalDimension)\n : KrylovDiagonalizer(eigenvaluesToCompute, totalDimension) {\n}\n\nNonOrthogonalDavidson::~NonOrthogonalDavidson() = default;\n\nEigenContainer NonOrthogonalDavidson::eigenDecomposition(const Eigen::MatrixXd& projectedMatrix) const {\n auto algorithm = settings_->getString(gepAlgorithmForBalancedMethodOption);\n if (algorithm == \"standard\")\n return MathUtils::stabilizedGeneralizedEigendecomposition(\n projectedMatrix, basisOverlap_.selfadjointView());\n else if (algorithm == \"cholesky\")\n return MathUtils::stabilizedGeneralizedEigendecomposition(\n projectedMatrix, basisOverlap_.selfadjointView());\n else if (algorithm == \"simultaneous_diag\")\n return MathUtils::stabilizedGeneralizedEigendecomposition(\n projectedMatrix, basisOverlap_.selfadjointView());\n else\n throw InvalidDiagonalizerInputException(\"Algorithm \" + algorithm + \" not available for stable GEP solution.\");\n}\n\ninline void NonOrthogonalDavidson::onSigmaMatrixEvaluation(const Eigen::MatrixXd& projector) {\n decltype(basisOverlap_)::Index newCols = subspaceDimension_ - basisOverlap_.cols();\n basisOverlap_.conservativeResize(subspaceDimension_, subspaceDimension_);\n Eigen::MatrixXd rightCols = projector.rightCols(newCols);\n basisOverlap_.rightCols(newCols) = projector.transpose() * rightCols;\n}\n\ninline void NonOrthogonalDavidson::filterCorrectionVectors(const Eigen::MatrixXd& projector,\n Eigen::MatrixXd& newGuessVectors) const {\n double absNorm =\n std::abs(newGuessVectors.col(newGuessVectors.cols() - 1).transpose() * projector.col(projector.cols() - 1));\n if (absNorm > 1.0 - settings_->getDouble(correctionToleranceOption)) {\n newGuessVectors.col(newGuessVectors.cols() - 1) = residualVectors_.col(newGuessVectors.cols() - 1);\n }\n}\n\nvoid NonOrthogonalDavidson::callCollapserImpl() {\n guessVectors_ = subspaceCollapser_->getCollapsedNonOrthogonalSubspace();\n subspaceDimension_ = guessVectors_.cols();\n basisOverlap_.resize(0, 0);\n}\n\nOrthogonalDavidson::OrthogonalDavidson(int eigenvaluesToCompute, int totalDimension)\n : KrylovDiagonalizer(eigenvaluesToCompute, totalDimension) {\n}\n\nOrthogonalDavidson::~OrthogonalDavidson() = default;\n\ninline void OrthogonalDavidson::filterCorrectionVectors(const Eigen::MatrixXd& projector, Eigen::MatrixXd& newGuessVectors) const {\n Eigen::MatrixXd orthogonalizedCorrectionVector = newGuessVectors;\n Eigen::VectorXd correctionVectorsNorms = newGuessVectors.colwise().norm();\n\n int dimension = 0;\n double maxNorm = 0;\n Eigen::VectorXd maxNormOrthogonalizedVector;\n for (int i = 0; i < orthogonalizedCorrectionVector.cols(); ++i) {\n Eigen::VectorXd orthogonalizedVector;\n SubspaceOrthogonalizer::orthogonalizeToSubspace(orthogonalizedCorrectionVector.col(i), projector, orthogonalizedVector);\n\n double norm = orthogonalizedVector.norm() / correctionVectorsNorms(i);\n if (norm > maxNorm) {\n std::swap(norm, maxNorm);\n maxNormOrthogonalizedVector = orthogonalizedVector;\n }\n\n if (norm / correctionVectorsNorms(i) > settings_->getDouble(correctionToleranceOption)) {\n newGuessVectors.col(dimension++) = orthogonalizedVector;\n }\n }\n // Retain one at least if everything is thrown away, the one that corrects the most\n if (dimension == 0) {\n newGuessVectors.col(0) = maxNormOrthogonalizedVector;\n dimension = 1;\n }\n newGuessVectors.conservativeResize(Eigen::NoChange, dimension);\n}\n\ninline void OrthogonalDavidson::onIterationStart() {\n KrylovDiagonalizer::onIterationStart();\n SubspaceOrthogonalizer::qrOrthogonalize(guessVectors_, subspaceDimension_);\n guessVectors_.leftCols(subspaceDimension_).colwise().normalize();\n}\n\nEigenContainer OrthogonalDavidson::eigenDecomposition(const Eigen::MatrixXd& projectedMatrix) const {\n EigenContainer result;\n Eigen::SelfAdjointEigenSolver subspaceDiagonalizer(projectedMatrix);\n result.eigenVectors = subspaceDiagonalizer.eigenvectors();\n result.eigenValues = subspaceDiagonalizer.eigenvalues();\n return result;\n}\n\nvoid OrthogonalDavidson::callCollapserImpl() {\n guessVectors_ = subspaceCollapser_->getCollapsedOrthogonalSubspace();\n subspaceDimension_ = guessVectors_.cols();\n}\n} // namespace Utils\n} // namespace Scine\n", "meta": {"hexsha": "a9a789a10532633138b052db9155eaf107f55ee3", "size": 4989, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/Utils/Utils/Math/IterativeDiagonalizer/DavidsonDiagonalizer.cpp", "max_stars_repo_name": "qcscine/utilities", "max_stars_repo_head_hexsha": "493b8db45772b231bc0296535a09905b8e292f77", "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/Utils/Utils/Math/IterativeDiagonalizer/DavidsonDiagonalizer.cpp", "max_issues_repo_name": "qcscine/utilities", "max_issues_repo_head_hexsha": "493b8db45772b231bc0296535a09905b8e292f77", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2019-06-19T14:34:38.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-25T15:07:18.000Z", "max_forks_repo_path": "src/Utils/Utils/Math/IterativeDiagonalizer/DavidsonDiagonalizer.cpp", "max_forks_repo_name": "qcscine/utilities", "max_forks_repo_head_hexsha": "493b8db45772b231bc0296535a09905b8e292f77", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2019-06-14T16:44:19.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-19T20:48:19.000Z", "avg_line_length": 43.0086206897, "max_line_length": 131, "alphanum_fraction": 0.7700942073, "num_tokens": 1201, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867873410141, "lm_q2_score": 0.5621765008857982, "lm_q1q2_score": 0.448721855160648}} {"text": "#include \n#include \n#include \n#include \n\n\nusing namespace Eigen;\nusing namespace std;\n\n\nvoid mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])\n{\n \n mxArray *output_mex;\n \n double *tri_num, *obj_tri, *q_target;\n double *output;\n \n tri_num = mxGetPr(prhs[0]);\n obj_tri = mxGetPr(prhs[1]);\n q_target = mxGetPr(prhs[2]);\n \n int tri_n = tri_num[0];\n \n output_mex = plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);\n \n output = mxGetPr(output_mex);\n \n int tri[3];\n \n output[0] = 1;\n \n tri[0] = obj_tri[0] - 1; \n tri[1] = obj_tri[0 + tri_n] - 1; \n tri[2] = obj_tri[0 + 2 * tri_n] - 1; \n \n Vector3d va(q_target[2 * tri[0]], q_target[2 * tri[0] + 1], 0);\n Vector3d vb(q_target[2 * tri[1]], q_target[2 * tri[1] + 1], 0);\n Vector3d vc(q_target[2 * tri[2]], q_target[2 * tri[2] + 1], 0);\n \n Vector3d e1 = va - vb;\n Vector3d e2 = vc - vb;\n Vector3d flag = e1.cross(e2);\n \n for(int i = 0; i < tri_n; i++)\n { \n tri[0] = obj_tri[i] - 1; \n tri[1] = obj_tri[i + tri_n] - 1; \n tri[2] = obj_tri[i + 2 * tri_n] - 1; \n \n Vector3d va(q_target[2 * tri[0]], q_target[2 * tri[0] + 1], 0);\n Vector3d vb(q_target[2 * tri[1]], q_target[2 * tri[1] + 1], 0);\n Vector3d vc(q_target[2 * tri[2]], q_target[2 * tri[2] + 1], 0);\n \n Vector3d e1 = va - vb;\n Vector3d e2 = vc - vb;\n Vector3d f1 = e1.cross(e2);\n \n if(f1.dot(flag) < 0)\n {\n output[0] = 0;\n }\n }\n \n return;\n \n}", "meta": {"hexsha": "bf28c5a61b71300a507c774db2057b6945fdb26c", "size": 1627, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "code/2D/lib/mex/local_injectivity_check_mex.cpp", "max_stars_repo_name": "ErisZhang/BCQN", "max_stars_repo_head_hexsha": "6c103e0e173bb825e4207b282a0cba2ce5d10e24", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10.0, "max_stars_repo_stars_event_min_datetime": "2019-07-23T16:35:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-04T11:47:42.000Z", "max_issues_repo_path": "code/2D/lib/mex/local_injectivity_check_mex.cpp", "max_issues_repo_name": "ErisZhang/BCQN", "max_issues_repo_head_hexsha": "6c103e0e173bb825e4207b282a0cba2ce5d10e24", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2019-07-10T12:12:18.000Z", "max_issues_repo_issues_event_max_datetime": "2019-07-10T12:12:18.000Z", "max_forks_repo_path": "code/2D/lib/mex/local_injectivity_check_mex.cpp", "max_forks_repo_name": "ErisZhang/BCQN", "max_forks_repo_head_hexsha": "6c103e0e173bb825e4207b282a0cba2ce5d10e24", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2019-02-21T06:12:40.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-27T09:58:32.000Z", "avg_line_length": 24.2835820896, "max_line_length": 76, "alphanum_fraction": 0.5064535956, "num_tokens": 594, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867777396212, "lm_q2_score": 0.5621765008857981, "lm_q1q2_score": 0.44872184976297047}} {"text": "// Created by enenra on 19.11.2021.\n\n#ifndef KURSOVAYA_1_HEADER_HPP\n#define KURSOVAYA_1_HEADER_HPP\n\n#include \"nlohmann/json.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing json = nlohmann::json;\n\nsize_t power(std::string &X);\n\nsize_t number_degree(const size_t &val);\n\nint number_degree(const int &val);\n\nclass boolean {\nprivate:\n std::vector vec;\n\npublic:\n boolean()=default;\n\n explicit boolean(std::string &init) {\n for (size_t i = 0; i < init.size(); ++i) {\n if ((init[i] == '0') || (init[i] == '1')) {\n if (i == 0)\n if ((init[i + 1] == '0') || (init[i + 1] == '1')) {\n if (init[i] == '0')\n vec.push_back(0);\n else vec.push_back(1);\n }\n if ((i > 0) && (i < init.size() - 1))\n if ((init[i + 1] == '0') || (init[i + 1] == '1') || (init[i - 1] == '0') || (init[i - 1] == '1')) {\n if (init[i] == '0')\n vec.push_back(0);\n else vec.push_back(1);\n }\n if (i == init.size() - 1) {\n if ((init[i - 1] == '0') || (init[i - 1] == '1')) {\n if (init[i] == '0')\n vec.push_back(0);\n else vec.push_back(1);\n }\n }\n }\n }\n }\n\n boolean(int val, int deg) {\n for (int i = 0; i < deg; ++i)\n vec.push_back(0);\n while (deg > 0) {\n vec[deg - 1] = val % 2;\n val /= 2;\n --deg;\n }\n }\n\n ~boolean() = default;\n\n void push_back(int val) {\n vec.push_back(val);\n }\n\n bool empty() {\n if (vec.empty())\n return true;\n return false;\n }\n\n int degree() {\n int deg = 0;\n while (pow(2.0, deg) != vec.size())\n deg += 1;\n return deg;\n }\n\n boolean operator+=(boolean &r) {\n for (size_t i = 0; i < vec.size(); ++i)\n vec[i] ^= r.vec[i];\n return *this;\n }\n\n boolean operator*=(boolean &r) {\n for (size_t i = 0; i < vec.size(); ++i)\n vec[i] &= r.vec[i];\n return *this;\n }\n\n int &operator[](size_t &index) {\n return vec[index];\n }\n\n int &operator[](int index) {\n return vec[index];\n }\n\n size_t to_number() {\n size_t result = 0;\n for (size_t i = 0; i < vec.size(); ++i)\n result += vec[i] * pow(2.0, vec.size() - 1 - i);\n return result;\n }\n\n bool operator==(const boolean& r) const {\n if (vec.size() != r.vec.size())\n return false;\n else\n for (size_t i = 0; i < vec.size(); ++i)\n if (vec[i] != r.vec[i])\n return false;\n return true;\n }\n\n bool operator!=(const boolean &r) const {\n if (vec.size() != r.vec.size())\n return true;\n else\n for (size_t i = 0; i < vec.size(); ++i)\n if (vec[i] != r.vec[i])\n return true;\n return false;\n }\n};\n\nclass cryptalgorithm {\nprivate:\n std::string text;\n std::string cipher;\n std::vector keys;\n std::vector functions;\n\npublic:\n cryptalgorithm() = default;\n\n cryptalgorithm(std::string &t, std::string &c, std::vector &k, std::vector &f) {\n text = t;\n cipher = c;\n keys = k;\n functions = f;\n }\n\n ~cryptalgorithm() = default;\n\n\n void absolute_stability(std::ofstream &out) {\n out << '\\n' << \" - ANALYZING ABSOLUTE STABILITY:\" << '\\n';\n if (power(text) <= keys.size())\n out << '\\n' << \"Your algorithm is absolutely stable\" << '\\n';\n else out << '\\n' << \"Your algorithm is not absolutely stable\" << '\\n';\n out << '\\n';\n }\n\n void differential_attack(std::ofstream &out) {\n out << '\\n' << \" - DIFFERENTIAL ATTACK:\" << '\\n';\n if (functions.size() == 1) {\n out\n << \"Your algorithm does not cannot ba attacked with differential attack, or entered functions are incorrect\"\n << '\\n';\n out\n << \"Make sure. that, if Your encryption function is a permutation, You enter it as a system of coordinate boolean functions\"\n << '\\n';\n out << \"Boolean functions are entered as a vector of 0 and 1\" << '\\n';\n } else {\n std::vector system;\n for (auto &function: functions) {\n boolean f(function);\n if (!f.empty())\n system.push_back(f);\n }\n if (system.empty()) {\n out\n << \"Your algorithm does not cannot ba attacked with differential attack, or entered functions are incorrect\"\n << '\\n';\n out\n << \"Make sure. that, if Your encryption function is a permutation, You enter it as a system of coordinate boolean functions\"\n << '\\n';\n out << \"Boolean functions are entered as a vector of 0 and 1\" << '\\n';\n } else {\n unsigned int start = clock();\n int deg = system[0].degree();\n size_t n;\n if (text == \"ASCII\")\n n = 256;\n else n = text.size();\n auto **table = new size_t *[n];\n for (size_t k = 0; k < n; ++k) {\n table[k] = new size_t[n];\n boolean delta_x(k, deg);\n for (size_t i = 0; i < n; ++i) {\n boolean delta_y, y;\n for (auto &j: system)\n y.push_back(j[i]);\n boolean x(i, deg);\n x += delta_x;\n size_t index = x.to_number();\n for (auto &j: system)\n delta_y.push_back(j[index]);\n delta_y += y;\n size_t eq = delta_y.to_number();\n table[k][i] = eq;\n }\n std::vector v;\n for (size_t i = 0; i < n; ++i)\n v.push_back(0);\n for (size_t r = 0; r < n; ++r)\n v[table[k][r]] += 1;\n for (size_t i = 0; i < n; ++i)\n table[k][i] = v[i];\n }\n unsigned int end = clock();\n unsigned int time = end - start;\n // Вывод данных\n out << '\\n';\n for (size_t i = 0; i <= n; ++i) {\n for (size_t j = 0; j <= n; ++j) {\n if (i * j == 0) {\n if ((i == 0) && (j == 0))\n out << \"| \";\n if ((i == 0) && (j != 0)) {\n size_t val = j - 1;\n boolean output(val, deg);\n out << ' ';\n for (int k = 0; k < deg; ++k)\n out << output[k];\n }\n if ((i != 0) && (j == 0)) {\n size_t val = i - 1;\n boolean output(val, deg);\n out << \"| \";\n for (int k = 0; k < deg; ++k)\n out << output[k];\n }\n out << \" |\";\n } else {\n out << \" \" << table[i - 1][j - 1];\n for (size_t h = 0; h < deg - number_degree(table[i - 1][j - 1]); ++h)\n out << ' ';\n out << '|';\n }\n }\n out << '\\n';\n }\n out\n << '\\n'\n << \"Estimated time of analyzing given S-block to find most probable outcomes from certain entered text is \"\n << time << \" ns\" << '\\n';\n for (size_t i = 0; i < n; ++i)\n delete[] table[i];\n delete[] table;\n }\n }\n }\n\n void brute_force(std::ofstream &out) {\n out << '\\n' << \" - BRUTE FORCE ATTACK:\" << '\\n';\n size_t n;\n if (text == \"ASCII\")\n n = 256;\n else\n n = text.size();\n out << '\\n' << \"This attack is always very long and needs many resources, in your case it will take about \";\n out << n << \" factorial, multiplied by the time of one tact.\" << '\\n';\n }\n\n void linear_attack(std::ofstream &out) {\n out << '\\n' << \" - LINEAR ATTACK:\" << '\\n';\n if (functions.size() == 1) {\n out\n << \"Your algorithm does not cannot ba attacked with linear attack, or entered functions are incorrect\"\n << '\\n';\n out\n << \"Make sure. that, if Your encryption function is a permutation, You enter it as a system of coordinate boolean functions\"\n << '\\n';\n out << \"Boolean functions are entered as a vector of 0 and 1\" << '\\n';\n } else {\n std::vector system;\n for (auto &function: functions) {\n boolean f(function);\n if (!f.empty())\n system.push_back(f);\n }\n if (system.empty()) {\n out\n << \"Your algorithm does not cannot ba attacked with linear attack, or entered functions are incorrect\"\n << '\\n';\n out\n << \"Make sure. that, if Your encryption function is a permutation, You enter it as a system of coordinate boolean functions\"\n << '\\n';\n out << \"Boolean functions are entered as a vector of 0 and 1\" << '\\n';\n } else {\n unsigned int start = clock();\n size_t n, deg = system[0].degree();\n if (text == \"ASCII\")\n n = 256;\n else n = text.size();\n auto **table = new int *[n];\n for (size_t i = 0; i < n; ++i) {\n table[i] = new int[n];\n boolean x_linear(i, deg);\n for (size_t j = 0; j < n; ++j) {\n table[i][j] = 0;\n boolean y_linear(j, deg);\n for (size_t h = 0; h < n; ++h) {\n boolean alfa(h, deg);\n boolean beta;\n for (auto &k: system)\n beta.push_back(k[h]);\n alfa *= x_linear;\n beta *= y_linear;\n int x = 0, y = 0;\n for (size_t t = 0; t < deg; ++t) {\n x ^= alfa[t];\n y ^= beta[t];\n }\n if (x == y)\n table[i][j] += 1;\n }\n table[i][j] = table[i][j] - n / 2;\n }\n }\n unsigned int end = clock();\n unsigned int time = end - start;\n // Вывод данных\n out << '\\n';\n for (size_t i = 0; i <= n; ++i) {\n for (size_t j = 0; j <= n; ++j) {\n if (i * j == 0) {\n if ((i == 0) && (j == 0))\n out << \"| \";\n if ((i == 0) && (j != 0)) {\n size_t val = j - 1;\n boolean output(val, deg);\n out << ' ';\n for (size_t k = 0; k < deg; ++k)\n out << output[k];\n }\n if ((i != 0) && (j == 0)) {\n size_t val = i - 1;\n boolean output(val, deg);\n out << \"| \";\n for (size_t k = 0; k < deg; ++k)\n out << output[k];\n }\n out << \" |\";\n } else {\n if (table[i - 1][j - 1] > 0) {\n out << \" +\" << table[i - 1][j - 1];\n for (size_t h = 0; h < deg - number_degree(table[i - 1][j - 1]); ++h)\n out << ' ';\n out << '|';\n }\n if (table[i - 1][j - 1] == 0) {\n out << \" \" << table[i - 1][j - 1];\n for (size_t h = 0; h < deg - 1; ++h)\n out << ' ';\n out << '|';\n }\n if (table[i - 1][j - 1] < 0) {\n out << ' ' << table[i - 1][j - 1];\n for (size_t h = 0; h < deg - number_degree(table[i - 1][j - 1]); ++h)\n out << ' ';\n out << '|';\n }\n }\n }\n out << '\\n';\n }\n out\n << '\\n'\n << \"Estimated time to build needed approximations and analyse the probability of destabilization of given S-block is \"\n << time << \" ns\" << '\\n';\n for (size_t i = 0; i < n; ++i)\n delete[] table[i];\n delete[] table;\n }\n }\n }\n};\n\n#endif //KURSOVAYA_1_HEADER_HPP\n", "meta": {"hexsha": "807f5539bc2a98b81f7439a94aecb9105145cd94", "size": 14445, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/header.hpp", "max_stars_repo_name": "MikhailZarif/Kursovaya_1", "max_stars_repo_head_hexsha": "db4633dd16ee86a5c621a3a9e74c5d63ce7bf9a0", "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/header.hpp", "max_issues_repo_name": "MikhailZarif/Kursovaya_1", "max_issues_repo_head_hexsha": "db4633dd16ee86a5c621a3a9e74c5d63ce7bf9a0", "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/header.hpp", "max_forks_repo_name": "MikhailZarif/Kursovaya_1", "max_forks_repo_head_hexsha": "db4633dd16ee86a5c621a3a9e74c5d63ce7bf9a0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-12-25T15:57:27.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-25T15:57:27.000Z", "avg_line_length": 37.1336760925, "max_line_length": 148, "alphanum_fraction": 0.3463482174, "num_tokens": 3202, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6926419831347361, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.44869224235349775}} {"text": "/*====================================================================\n bouncingBallBenchmark.cc\n Copyright (c) 2019 Matthew Millard \n Licensed under the zlib license. See LICENSE for more details.\n *///=================================================================\n\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"csvtools.h\"\n\n#include \"ContactToolkit.h\"\n\n#include \n#include \n#include \n#include \n//using namespace std;\nusing namespace boost::numeric::odeint;\n\nusing namespace RigidBodyDynamics;\nusing namespace RigidBodyDynamics::Math;\n\n//====================================================================\n// Boost stuff\n//====================================================================\n\n\n\n\ntypedef std::vector< double > state_type;\ntypedef runge_kutta_cash_karp54< state_type > error_stepper_type;\ntypedef controlled_runge_kutta< error_stepper_type > controlled_stepper_type;\n\n\nclass rbdlToBoost {\n\n public:\n rbdlToBoost(Model* model,\n std::string &ballName,\n double ballRadius,\n Vector3d &pointOnPlane, \n Vector3d &planeNormal,\n double stiffness,\n double exponent,\n double damping,\n double staticFrictionSpeed,\n double staticFrictionCoefficient,\n double dynamicFrictionSpeed,\n double dynamicFrictionCoefficient,\n double viscousFrictionSlope,\n unsigned int numberOfWorkTermsInState\n ):model(model),r(ballRadius),r0P0(pointOnPlane),\n eN0(planeNormal),k(stiffness),p(exponent),beta(damping),\n staticFrictionSpeed(staticFrictionSpeed),\n staticFrictionCoefficient(staticFrictionCoefficient),\n dynamicFrictionSpeed(dynamicFrictionSpeed),\n dynamicFrictionCoefficient(dynamicFrictionCoefficient),\n viscousFrictionSlope(viscousFrictionSlope),\n numberOfWorkTermsInState(numberOfWorkTermsInState)\n {\n\n q = VectorNd::Zero(model->dof_count);\n qd = VectorNd::Zero(model->dof_count);\n qdd = VectorNd::Zero(model->dof_count);\n tau = VectorNd::Zero(model->dof_count);\n fext.resize(model->mBodies.size());\n for(unsigned int i=0; iGetBodyId(ballName.c_str());\n fK0n = Vector3dZero;\n tK0n = Vector3dZero;\n fK0t = Vector3dZero;\n tK0t = Vector3dZero;\n\n //1a. The regularized friction model is created and printed to file\n ContactToolkit::createRegularizedFrictionCoefficientCurve(\n staticFrictionSpeed, staticFrictionCoefficient,\n dynamicFrictionSpeed,dynamicFrictionCoefficient,\n viscousFrictionSlope,\"mu\",frictionCoefficientCurve);\n\n frictionCoefficientCurve.printCurveToCSVFile(\"../output/\",\n \"frictionCoefficientCurve\",0,dynamicFrictionSpeed*2);\n printf(\"Wrote: ../output/frictionCoefficentCurve.csv\\n\");\n\n //Set the velocity at which the relaxed method is used to compute\n //the direction vector of the tangential velocity of the contact\n //point\n veps = staticFrictionSpeed/100.0;\n\n //If veps is too small, we really might have problems\n assert(veps > std::sqrt(std::numeric_limits::epsilon()));\n\n\n }\n\n //1b. The state derivative for this model is called by Boost whenever the \n // code for the 'operator()' function is called\n void operator() (const state_type &x,\n state_type &dxdt, \n const double t){\n\n //1c. The state x is split into generalized positions (q), generalized\n // velocities (qdd). Here tau is set to 0 because we are not \n // applying any generlized forces: the ball contact/friction forces\n // are applied as external forces\n //q\n int j = 0;\n for(unsigned int i=0; iq_size; i++){ \n q[i] = double(x[j]);\n j++;\n }\n\n //qd\n for(unsigned int i=0; iqdot_size; i++){\n qd[i] = double(x[j]);\n j++;\n }\n\n //tau = 0\n for(unsigned int i=0; iqdot_size; i++){ \n tau[i] = 0;\n }\n\n //2a. To evaluate the contact forces we must see if the ball is interpenetrating\n // the ground. Outside of FEA modelling it is common to allow (non deforming)\n // geometry to intepenetrate and to use the interpenetration to compute\n // contact forces. Here we go with the simplest option and map the \n // depth of penetration to a contact force.\n r0B0 = CalcBodyToBaseCoordinates(*model,q,ballId,Vector3dZero,true);\n ContactToolkit::calcSpherePlaneContactPointPosition(r0B0,r,eN0,r0K0);\n\n //if the contact point is in the sphere compute contact data\n z = (r0K0-r0P0).dot(eN0);\n dz=0.; //this is zero until contact is made\n if( z < 0. ){\n\n //2b. If the sphere is in contact with the plane, we must get the position and\n //velocity of the contact point.\n\n //Get the point of contact resolved in the coordinates of the ball \n EB0 = CalcBodyWorldOrientation(*model,q,ballId,true);\n rBKB = EB0*(r0K0-r0B0);\n\n //Get the velocity of the point of contact\n v0K0 = CalcPointVelocity(*model,q,qd,ballId,rBKB,true);\n\n //Evaluate Hunt-Crossley Contact forces\n dz = (v0K0).dot(eN0); //assuming the plane is fixed.\n\n //2c. Now we can evaluate the contact forces using a Hunt-Crossley contact model\n // This is a popular contact model because it is numerically well behaved.\n // See the comments in ContactToolkit.h above the function definition\n // for calcHuntCrossleyContactForce for further details. \n ContactToolkit::calcHuntCrossleyContactForce(z,dz,k,p,beta,hcInfo);\n\n //2d. To apply this contact force as an external force in RBDL, we must first\n // transform it into a spatial wrench that is resolved in the Root frame.\n // Here we turn the scalar contact force into a vector, and then evaluate\n // the torque that this force vector produces about the Root frame \n fK0n = hcInfo.force*eN0;\n tK0n = VectorCrossMatrix(r0K0)*fK0n;\n\n //2e. Now we can use the tangential velocity of the contact point of the ball\n // to evaluate the coefficient of friction, and then the friction forces\n v0K0t = v0K0 - dz*eN0;\n ContactToolkit::calcTangentialVelocityDirection(v0K0t,veps,eT0);\n\n mu = frictionCoefficientCurve.calcValue(v0K0t.norm());\n\n //2f. As with the contact model we evaluate the force the friction model applies\n // to the ball and also the torque it generates about the ROOT frame \n fK0t = -mu*hcInfo.force*eT0;\n tK0t = VectorCrossMatrix(r0K0)*fK0t;\n\n //2g. The total wrench generated by the contact and friction models is applied to\n // the entry in the vector fext that corresponds to the ball. \n fext[ballId][0] = tK0n[0] + tK0t[0];\n fext[ballId][1] = tK0n[1] + tK0t[1];\n fext[ballId][2] = tK0n[2] + tK0t[2];\n\n fext[ballId][3] = fK0n[0] + fK0t[0];\n fext[ballId][4] = fK0n[1] + fK0t[1];\n fext[ballId][5] = fK0n[2] + fK0t[2];\n\n }else{\n //zero the entry of fext associated with the ball. \n fext[ballId]=SpatialVector::Zero();\n hcInfo.force = 0.;\n hcInfo.springForce = 0.;\n hcInfo.dampingForce = 0.; \n fK0n = Vector3dZero;\n tK0n = Vector3dZero;\n fK0t = Vector3dZero;\n tK0t = Vector3dZero;\n }\n\n //3a. Now the generalized accelerations of the ball can be computed\n ForwardDynamics(*model,q,qd,tau,qdd,&fext);\n\n //3b. The state derivative dxdt is now formed using qd, and qdd. The \n // derivatives of the work done by the contact and friction models \n // is also stored so that we can track the system energy of the \n // system through the simulation\n j = 0;\n for(unsigned int i = 0; i < model->q_size; i++){\n dxdt[j] = double(qd[i]);\n j++;\n }\n for(unsigned int i = 0; i < model->qdot_size; i++){\n dxdt[j] = double(qdd[i]);\n j++;\n }\n\n dworkN = hcInfo.force*dz;\n dxdt[j] = dworkN;\n j++;\n dxdt[j] = fK0t.dot(v0K0t);\n j++;\n assert((numberOfWorkTermsInState\n + model->q_size \n + model->qdot_size) == j);\n\n }\n\n /*\n Ascii Vector Notation:\n rBKB\n r: vector\n B: from the origin of the Ball frame\n K: to the contact point K\n B: expressed in the coordinates of the ball frame.\n EB0:\n E: rotation matrix\n B: to Frame B\n 0: from Frame 0\n eN0:\n e: unit vector\n N: Normal direction\n 0: expressed in the coordinates of the root frame (0)\n fK0\n f: force\n K: At point K\n 0: expressed in the coordinates of the root frame\n tK0\n t: torque\n K: At point K\n 0: expressed in the coordinates of the root frame\n\n */\n\n //Multibody Variables\n Model* model;\n VectorNd q, qd, qdd, tau; \n\n //Normal-Contact Model Working Variables\n unsigned int ballId;\n double z, dz; //pentration depth and velocity\n HuntCrossleyContactInfo hcInfo;\n std::vector< SpatialVector > fext;\n double dworkN, dworkT; //Work in the normal and tangential directions\n double mu; //Friction coefficient\n Matrix3d EB0; //Orientation of the ball expressed in the Root frame\n Vector3d r0B0; //Position of the ball\n Vector3d rBKB; //B : ball.\n Vector3d r0K0; //K : contact point\n Vector3d v0K0; //velocity of the contact point\n Vector3d v0K0t; //tangential velocity of the contact point\n Vector3d r0P0; //Origin of the plane\n Vector3d eN0; //Normal of the plane\n Vector3d eT0; //Tangental direction of the plane: in 2d this isn't necessary\n //here we compute it to show how this is done in a\n //numerically stable way in 3d.\n Vector3d fK0n, tK0n; //contact force and moment\n Vector3d fK0t, tK0t; //tangential friction force and moment\n\n //Normal Contact-Model Parameters\n double r; //ball radius\n double k; //stiffness\n double p; //exponential power on the spring compression\n double beta; //damping\n\n //Friction Model Parameters: see ContactToolkit \n // createRegularizedFrictionCoefficientCurve for details\n double staticFrictionSpeed;\n double staticFrictionCoefficient;\n double dynamicFrictionSpeed;\n double dynamicFrictionCoefficient;\n double viscousFrictionSlope;\n double veps; //Velocity at which the relaxed method is used to compute\n //the direction vector of the tangential velocity\n RigidBodyDynamics::Addons::Geometry\n ::SmoothSegmentedFunction frictionCoefficientCurve;\n\n unsigned int numberOfWorkTermsInState;\n\n};\n\nstruct pushBackStateAndTime\n{\n std::vector< state_type >& states;\n std::vector< double >& times;\n\n pushBackStateAndTime( std::vector< state_type > &states , \n std::vector< double > × )\n : states( states ) , times( times ) { }\n\n void operator()( const state_type &x , double t )\n {\n states.push_back( x );\n times.push_back( t );\n }\n};\n\nvoid f(const state_type &x, state_type &dxdt, const double t);\n\n/* Problem Constants */\nint main (int argc, char* argv[]) {\n rbdl_check_api_version (RBDL_API_VERSION);\n\n RigidBodyDynamics::Model model;\n\n std::string fileName(\"../model/ballPlaneContact.lua\");\n std::string ballName(\"Ball\");\n\n //0a. ballPlaneContact.lua model is read in\n if (!Addons::LuaModelReadFromFile(fileName.c_str(),&model)){\n std::cerr << \"Error loading LuaModel: \" << fileName << std::endl;\n abort();\n }\n\n //0b. Contact and friction parameters are set (more on these later)\n double radius = 0.5;\n Vector3d pointOnPlane = Vector3d(0.,0.,0.);\n Vector3d planeNormal = Vector3d(0.,0.,1.);\n\n //Hunt-Crossley contact terms. See\n // ContactToolkit::calcHuntCrossleyContactForce for details\n double exponent = 2.0; //The spring force will increase with the deflection squared.\n double stiffness = 9.81/pow(0.01,2.); //The ball will settle to 1cm penetration\n double damping = 0.1; //lightly damped \n\n //Friction model terms. See\n // ContactToolkit::createRegularizedFrictionCoefficientCurve for details\n double staticFrictionSpeed = 0.001;\n double staticFrictionCoefficient = 0.8;\n double dynamicFrictionSpeed = 0.01;\n double dynamicFrictionCoeffient = 0.6;\n double viscousFrictionSlope = 0.1;\n\n unsigned int numWorkTermsInState = 2; //1 normal work term\n //1 friction term\n\n\n VectorNd q, qd, x, tau;\n q.resize(model.dof_count);\n qd.resize(model.dof_count);\n tau.resize(model.dof_count);\n x.resize(model.dof_count*2);\n q.setZero();\n qd.setZero();\n x.setZero();\n tau.setZero();\n\n q[1] = 1.; //ball starts 1m off the ground\n qd[0]= 1.;\n\n for(unsigned int i=0; i > matrixData, matrixForceData;\n std::vector > matrixErrorData;\n std::vector< double > rowData(model.dof_count+1);\n std::vector< double > rowForceData(10);\n std::vector< double > rowErrorData(2);\n\n double a_x = 1.0 , a_dxdt = 1.0;\n controlled_stepper_type\n controlled_stepper(\n default_error_checker< double ,\n range_algebra ,\n default_operations >\n ( absTolVal , relTolVal , a_x , a_dxdt ) );\n\n double tp = 0;\n rowData[0] = 0;\n for(unsigned int z=0; z < model.dof_count; z++){\n rowData[z+1] = xState[z];\n }\n matrixData.push_back(rowData);\n\n SpatialVector fA0 = SpatialVector::Zero();\n for(unsigned int i=0; i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// Manhattan distance heuristic\ntemplate\nclass distance_heuristic: public boost::astar_heuristic {\npublic:\n\tdistance_heuristic(const unordered_set &goals, Graph graph) :\n\t\t\tm_graph(graph), m_goals(goals) {\n\t}\n\tCostType operator()(Vertex u) {\n\t\tCostType result = INFINITY;\n\t\tfor (Vertex m_goal : m_goals) {\n\t\t\tCostType dx = m_graph[m_goal].x - m_graph[u].x;\n\t\t\tCostType dy = m_graph[m_goal].y - m_graph[u].y;\n\t\t\tCostType dz = m_graph[m_goal].z - m_graph[u].z;\n\t\t\tCostType tmp = fabs(dx) + fabs(dy) + fabs(dz);\n\t\t\tif (tmp < result)\n\t\t\t\tresult = tmp;\n\t\t}\n\t\treturn result;\n\t}\nprivate:\n\tGraph m_graph;\n\tunordered_set m_goals;\n};\n\nstruct found_goal {\n\tVertex goal;\n};\n\nstruct astar_goal_visitor: public boost::default_astar_visitor {\n\tastar_goal_visitor(const unordered_set &goals) :\n\t\t\tm_goals(goals) {\n\t}\n\tvoid examine_vertex(Vertex u, const Graph &g) {\n\t\tif (m_goals.find(u) != m_goals.end()) {\n\t\t\tthrow found_goal( { u });\n\t\t}\n\t}\nprivate:\n\tunordered_set m_goals;\n\t// boost::unordered_map m_predecessor;\n};\n\nstd::pair> RoutingDB::a_star(Graph &graph3D,\n\t\tconst Vertex &s, const unordered_set &goals) const {\n\tusing namespace boost;\n\ttypedef boost::unordered_map pred_map;\n\tpred_map predecessor;\n\tboost::associative_property_map pred_pmap(predecessor);\n\n\ttypedef boost::unordered_map dist_map;\n\tdist_map distance;\n\tboost::associative_property_map dist_pmap(distance);\n\n\ttypedef boost::unordered_map cost_map;\n\tcost_map cost;\n\tboost::associative_property_map cost_pmap(cost);\n\n\ttypedef boost::unordered_map wt_map;\n\twt_map weight;\n\tEdgeIter e, eend;\n\tfor (tie(e, eend) = edges(graph3D); e != eend; ++e) {\n\t\tweight[*e] = graph3D[*e].weight;\n\t}\n\tGraph::out_edge_iterator oe, oeend;\n\ttie(oe, oeend) = out_edges(s, graph3D);\n\tboost::associative_property_map wt_pmap(weight);\n\n\tastar_goal_visitor visitor(goals);\n\n\tauto heur = distance_heuristic(goals, graph3D);\n\tvector vecPath;\n\ttry {\n\t\tVertexIter ui, ui_end;\n\t\tfor (boost::tie(ui, ui_end) = vertices(graph3D); ui != ui_end; ++ui) {\n\t\t\tput(dist_pmap, *ui, INFINITY);\n\t\t\tput(cost_pmap, *ui, INFINITY);\n\t\t\tput(pred_pmap, *ui, *ui);\n\t\t\tvisitor.initialize_vertex(*ui, graph3D);\n\t\t}\n\t\tput(dist_pmap, s, 0);\n\t\tput(cost_pmap, s, heur(s));\n\t\tboost::astar_search_no_init_tree(graph3D, s, heur,\n\t\t\t\tweight_map(wt_pmap).predecessor_map(pred_pmap).distance_map(\n\t\t\t\t\t\tdist_pmap).visitor(visitor));\n\t\t// printf(\"No feasible path.\\n\");\n\t\treturn make_pair(INFINITY, vecPath);\n\t} catch (found_goal &fg) {\n\t\t// Walk backwards from the goal through the predecessor chain adding\n\t\t// vertices to the solution path.\n\t\t//printf(\"Path found: \");\n\t\t//isFeasible = true;\n\t\tdouble wl = 0;\n\t\tfor (Vertex u = fg.goal; u != s; u = predecessor[u]) {\n\t\t\t//\tprintf(\"(%d,%d,%d)-\", graph3D[u].x, graph3D[u].y, graph3D[u].z);\n\t\t\t// auto r = edge(u, predecessor[u], graph3D);\n\t\t\t// assert(r.second);\n\t\t\tvecPath.push_back(u);\n\t\t\t//\tgraph3D[r.first].isPath = true;\n\t\t\t++wl;\n\t\t}\n\t\tvecPath.push_back(s);\n\t\t// printf(\"(%d,%d,%d)\\n\", graph3D[s].x, graph3D[s].y, graph3D[s].z);\n\t\t// cout << \"WL = \" << wl << endl;\n\t\treturn make_pair(wl, vecPath);\n\t}\n}\n\nunordered_set RoutingDB::build_goals(const Vpin &vp, const int xlLim,\n\t\tconst int xuLim, const int ylLim, const int yuLim,\n\t\tconst int zlLim) const {\n\tusing namespace boost;\n\tstd::unordered_set goals;\n\tint X = xuLim - xlLim + 1, Y = yuLim - ylLim + 1;\n\tfor (auto gv : vp.gnetGrids) {\n\t\tgoals.insert(\n\t\t\t\t(gv._z - zlLim) * Y * X + (gv._y - ylLim) * X\n\t\t\t\t\t\t+ (gv._x - xlLim));\n\t}\n\treturn goals;\n}\n\nGraph RoutingDB::build_graph(const size_t gnetId,\n\t\tconst std::unordered_set &bannedPts,\n\t\tconst int xlLim, const int xuLim, const int ylLim, const int yuLim,\n\t\tconst int zlLim, const int zuLim) const {\n\tusing namespace boost;\n\tGraph graph3D;\n\t// vector capacities;\n\t// vector locations;\n\t// boost::property_map::type edge_index_map = get(boost::edge_index, graph2D);\n\t// boost::property_map::type vertex_index_map = get(boost::vertex_index, graph2D);\n\tint X = xuLim - xlLim + 1, Y = yuLim - ylLim + 1;\n\tfor (int z = zlLim; z <= zuLim; ++z) {\n\t\tfor (int y = ylLim; y <= yuLim; ++y) {\n\t\t\tfor (int x = xlLim; x <= xuLim; ++x) {\n\t\t\t\tVertex v = add_vertex(graph3D);\n\t\t\t\tgraph3D[v].x = x;\n\t\t\t\tgraph3D[v].y = y;\n\t\t\t\tgraph3D[v].z = z;\n\t\t\t}\n\t\t}\n\t}\n\tint cap, dem, blk;\n\tbool vacant, banned;\n\tfor (int x = xlLim; x <= xuLim; ++x) {\n\t\tfor (int y = ylLim; y <= yuLim; ++y) {\n\t\t\tif (x > xlLim) {\n\t\t\t\tfor (int z = zlLim; z <= zuLim; ++z) {\n\t\t\t\t\tif (getRoutingDir(z) == H) {\n\t\t\t\t\t\tsize_t edgeId = findEdge(x - 1, y, z);\n\t\t\t\t\t\tcap = getEdgeCap(edgeId);\n\t\t\t\t\t\tdem = getEdgeDemand(edgeId);\n\t\t\t\t\t\tblk = getEdgeBlk(edgeId);\n\t\t\t\t\t\tvacant = _gnets[gnetId]._occupiedEdges.find(edgeId)\n\t\t\t\t\t\t\t\t== _gnets[gnetId]._occupiedEdges.end();\n\t\t\t\t\t\tbanned = (bannedPts.find(Gcell(x - 1, y, z))\n\t\t\t\t\t\t\t\t!= bannedPts.end()\n\t\t\t\t\t\t\t\t|| bannedPts.find(Gcell(x, y, z))\n\t\t\t\t\t\t\t\t\t\t!= bannedPts.end());\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcap = 0;\n\t\t\t\t\t\tdem = 0;\n\t\t\t\t\t\tblk = 0;\n\t\t\t\t\t\tvacant = false;\n\t\t\t\t\t\tbanned = false;\n\t\t\t\t\t}\n\t\t\t\t\tif (cap > dem + blk && vacant && !banned) {\n\t\t\t\t\t\tauto r = add_edge(\n\t\t\t\t\t\t\t\tvertex(\n\t\t\t\t\t\t\t\t\t\t(z - zlLim) * Y * X + (y - ylLim) * X\n\t\t\t\t\t\t\t\t\t\t\t\t+ (x - xlLim), graph3D),\n\t\t\t\t\t\t\t\tvertex(\n\t\t\t\t\t\t\t\t\t\t(z - zlLim) * Y * X + (y - ylLim) * X\n\t\t\t\t\t\t\t\t\t\t\t\t+ (x - 1 - xlLim), graph3D),\n\t\t\t\t\t\t\t\tgraph3D);\n\t\t\t\t\t\tassert(r.second);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (y > ylLim) {\n\t\t\t\tfor (int z = zlLim; z <= zuLim; ++z) {\n\t\t\t\t\tif (getRoutingDir(z) == V) {\n\t\t\t\t\t\tsize_t edgeId = findEdge(x, y - 1, z);\n\t\t\t\t\t\tcap = getEdgeCap(edgeId);\n\t\t\t\t\t\tdem = getEdgeDemand(edgeId);\n\t\t\t\t\t\tblk = getEdgeBlk(edgeId);\n\t\t\t\t\t\tvacant = _gnets[gnetId]._occupiedEdges.find(edgeId)\n\t\t\t\t\t\t\t\t== _gnets[gnetId]._occupiedEdges.end();\n\t\t\t\t\t\tbanned = (bannedPts.find(Gcell(x, y - 1, z))\n\t\t\t\t\t\t\t\t!= bannedPts.end()\n\t\t\t\t\t\t\t\t|| bannedPts.find(Gcell(x, y, z))\n\t\t\t\t\t\t\t\t\t\t!= bannedPts.end());\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcap = 0;\n\t\t\t\t\t\tdem = 0;\n\t\t\t\t\t\tblk = 0;\n\t\t\t\t\t\tvacant = false;\n\t\t\t\t\t\tbanned = false;\n\t\t\t\t\t}\n\t\t\t\t\tif (cap > dem + blk && vacant && !banned) {\n\t\t\t\t\t\tauto r = add_edge(\n\t\t\t\t\t\t\t\tvertex(\n\t\t\t\t\t\t\t\t\t\t(z - zlLim) * Y * X + (y - ylLim) * X\n\t\t\t\t\t\t\t\t\t\t\t\t+ (x - xlLim), graph3D),\n\t\t\t\t\t\t\t\tvertex(\n\t\t\t\t\t\t\t\t\t\t(z - zlLim) * Y * X\n\t\t\t\t\t\t\t\t\t\t\t\t+ (y - 1 - ylLim) * X\n\t\t\t\t\t\t\t\t\t\t\t\t+ (x - xlLim), graph3D),\n\t\t\t\t\t\t\t\tgraph3D);\n\t\t\t\t\t\tassert(r.second);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (int z = zlLim + 1; z <= zuLim; ++z) {\n\t\t\t\tsize_t viaId = findVia(x, y, z - 1);\n\t\t\t\tcap = getViaCap(viaId);\n\t\t\t\tdem = getViaDemand(viaId);\n\t\t\t\tvacant = _gnets[gnetId]._occupiedVias.find(viaId)\n\t\t\t\t\t\t== _gnets[gnetId]._occupiedVias.end();\n\t\t\t\tbanned = (bannedPts.find(Gcell(x, y, z - 1)) != bannedPts.end()\n\t\t\t\t\t\t|| bannedPts.find(Gcell(x, y, z)) != bannedPts.end());\n\t\t\t\tif (cap > dem && vacant && !banned) {\n\t\t\t\t\tauto r = add_edge(\n\t\t\t\t\t\t\tvertex(\n\t\t\t\t\t\t\t\t\t(z - zlLim) * Y * X + (y - ylLim) * X\n\t\t\t\t\t\t\t\t\t\t\t+ (x - xlLim), graph3D),\n\t\t\t\t\t\t\tvertex(\n\t\t\t\t\t\t\t\t\t(z - 1 - zlLim) * Y * X + (y - ylLim) * X\n\t\t\t\t\t\t\t\t\t\t\t+ (x - xlLim), graph3D), graph3D);\n\t\t\t\t\tassert(r.second);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn graph3D;\n}\n\nbool comp_x(Gcell i, Gcell j) {\n\treturn i._x < j._x;\n}\nbool comp_y(Gcell i, Gcell j) {\n\treturn i._y < j._y;\n}\n\nstd::tuple, vector, int,\n\t\tstd::unordered_set> RoutingDB::rerouteNet(\n\t\tconst Layout &layout, Vpin &vp,\n\t\tconst std::unordered_set &bannedPts,\n\t\tconst int zlLim, const int zuLim, const int maxMargin,\n\t\tconst bool singleMargin, const bool writeToDB, const bool updateRoot) {\n\t// Connect one v-pin to its remaining net\n\tusing namespace boost;\n\tauto terminals = vp.gnetVertices;\n\tstd::unordered_set addlBannedPts;\n\tterminals.insert(Gcell(vp.xCoord, vp.yCoord, vp.zCoord));\n\tint margin = singleMargin ? maxMargin : 0;\n\tint next_margin = 0;\n\tdouble wl = INFINITY;\n\tbool isFeasible = false;\n\tdouble minmhd = INFINITY;\n\tstd::pair> res;\n\tGraph g;\n\tstd::vector addedEdges, addedVias;\n\tint viaID = findVia(vp.xCoord, vp.yCoord, vp.zCoord);\n\tif (getViaDemand(viaID) >= getViaCap(viaID)) {\n\t\treturn make_tuple(wl, addedEdges, addedVias, margin, addlBannedPts); // infeasible\n\t}\n\t// add new vpin\n\t// addViaDemand(viaID);\n\t// addedVias.push_back(viaID);\n\twhile (margin <= maxMargin) {\n// cout << \"margin = \" << margin << endl;\n\t\tint xlLim = max(\n\t\t\t\tmin_element(terminals.begin(), terminals.end(), comp_x)->_x\n\t\t\t\t\t\t- margin, 0);\n\t\tint xuLim = min(\n\t\t\t\tmax_element(terminals.begin(), terminals.end(), comp_x)->_x\n\t\t\t\t\t\t+ margin, (int) layout._numTilesX - 1);\n\t\tint ylLim = max(\n\t\t\t\tmin_element(terminals.begin(), terminals.end(), comp_y)->_y\n\t\t\t\t\t\t- margin, 0);\n\t\tint yuLim = min(\n\t\t\t\tmax_element(terminals.begin(), terminals.end(), comp_y)->_y\n\t\t\t\t\t\t+ margin, (int) layout._numTilesY - 1);\n\t\tg = build_graph(vp.gnetID, bannedPts, xlLim, xuLim, ylLim, yuLim, zlLim,\n\t\t\t\tzuLim);\n\t\t/*for (auto v : g.m_vertices) {\n\t\t cerr << \"Vertex: \" << v.m_property.x << \" \"\n\t\t << v.m_property.y << \" \" << v.m_property.z << endl;\n\t\t }\n\t\t for (auto e : g.m_edges) {\n\t\t cerr << \"Edge: \" << g[e.m_source].id << \" \" << g[e.m_target].id\n\t\t << endl;\n\t\t }*/\n\n\t\tint X = xuLim - xlLim + 1, Y = yuLim - ylLim + 1;\n\t\tVertex start = (vp.zCoord - zlLim) * Y * X + (vp.yCoord - ylLim) * X\n\t\t\t\t+ (vp.xCoord - xlLim);\n\t\tstd::unordered_set goals = build_goals(vp, xlLim, xuLim, ylLim,\n\t\t\t\tyuLim, zlLim);\n\t\tif (minmhd == INFINITY) {\n\t\t\tfor (auto goal : goals) {\n\t\t\t\tdouble mhd = fabs(g[start].x - g[goal].x)\n\t\t\t\t\t\t+ fabs(g[start].y - g[goal].y)\n\t\t\t\t\t\t+ fabs(g[start].z - g[goal].z);\n\t\t\t\tif (mhd < minmhd)\n\t\t\t\t\tminmhd = mhd;\n\t\t\t}\n\t\t}\n\t\tres = a_star(g, start, goals);\n\t\tif (res.first < INFINITY) { // found a-star path\n\t\t\twl = res.first;\n// cout << \"wl = \" << wl << endl;\n\t\t\tisFeasible = true;\n\t\t\tnext_margin = std::max(next_margin,\n\t\t\t\t\tstd::min(maxMargin, (int) ((res.first - minmhd) / 2.0)));\n\t\t} else { // not found\n\t\t\tnext_margin = std::max(next_margin,\n\t\t\t\t\tstd::min(maxMargin, margin * 2 + 1));\n// cout << \"next_margin = \" << next_margin << endl;\n\t\t}\n\t\tif (next_margin > margin)\n\t\t\tmargin = next_margin;\n\t\telse\n\t\t\tbreak;\n\t}\n\tif (!isFeasible)\n\t\treturn make_tuple(INFINITY, addedEdges, addedVias, margin,\n\t\t\t\taddlBannedPts);\n\t// fill addedEdges / addedVias\n\tauto vecPath = res.second;\n\tif (writeToDB) {\n\t\tvp.wlToL1 += vecPath.size();\n\t}\n\tif (vecPath.size() > 0)\n\t\taddlBannedPts.insert(\n\t\t\t\tGcell(g[vecPath[0]].x, g[vecPath[0]].y, g[vecPath[0]].z));\n\tfor (int i = 1; i < static_cast(vecPath.size()); i++) {\n\t\taddlBannedPts.insert(\n\t\t\t\tGcell(g[vecPath[i]].x, g[vecPath[i]].y, g[vecPath[i]].z));\n\t\tif (g[vecPath[i]].z == g[vecPath[i - 1]].z) {\n\t\t\tif (_dirLayers[g[vecPath[i]].z] == H) {\n\t\t\t\tassert(g[vecPath[i]].y == g[vecPath[i - 1]].y);\n\t\t\t\tfor (int x = min(g[vecPath[i]].x, g[vecPath[i - 1]].x);\n\t\t\t\t\t\tx < max(g[vecPath[i]].x, g[vecPath[i - 1]].x); x++) {\n\t\t\t\t\tif (writeToDB) {\n\t\t\t\t\t\tint edgeId = findEdge(x, g[vecPath[i]].y,\n\t\t\t\t\t\t\t\tg[vecPath[i]].z);\n\t\t\t\t\t\tif (!(_gnets[vp.gnetID].findCleanEdge(edgeId))) {\n\t\t\t\t\t\t\t_gnets[vp.gnetID].setCleanEdge(edgeId,\n\t\t\t\t\t\t\t\t\t_edges[edgeId]);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (!(_gnets[vp.gnetID].findRUEdge(edgeId))) {\n\t\t\t\t\t\t\t_gnets[vp.gnetID].setRUEdge(edgeId, _edges[edgeId]);\n\t\t\t\t\t\t}\n\t\t\t\t\t\trestoreEdge(edgeId);\n\t\t\t\t\t\t_gnets[vp.gnetID]._occupiedEdges.insert(edgeId);\n\t\t\t\t\t\t_dirty = true;\n\t\t\t\t\t}\n\t\t\t\t\taddedEdges.push_back(\n\t\t\t\t\t\t\tfindEdge(x, g[vecPath[i]].y, g[vecPath[i]].z));\n\t\t\t\t}\n\t\t\t} else if (_dirLayers[g[vecPath[i]].z] == V) {\n\t\t\t\tassert(g[vecPath[i]].x == g[vecPath[i - 1]].x);\n\t\t\t\tfor (int y = min(g[vecPath[i]].y, g[vecPath[i - 1]].y);\n\t\t\t\t\t\ty < max(g[vecPath[i]].y, g[vecPath[i - 1]].y); y++) {\n\t\t\t\t\tif (writeToDB) {\n\t\t\t\t\t\tint edgeId = findEdge(g[vecPath[i]].x, y,\n\t\t\t\t\t\t\t\tg[vecPath[i]].z);\n\t\t\t\t\t\tif (!(_gnets[vp.gnetID].findCleanEdge(edgeId))) {\n\t\t\t\t\t\t\t_gnets[vp.gnetID].setCleanEdge(edgeId,\n\t\t\t\t\t\t\t\t\t_edges[edgeId]);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (!(_gnets[vp.gnetID].findRUEdge(edgeId))) {\n\t\t\t\t\t\t\t_gnets[vp.gnetID].setRUEdge(edgeId, _edges[edgeId]);\n\t\t\t\t\t\t}\n\t\t\t\t\t\trestoreEdge(edgeId);\n\t\t\t\t\t\t_gnets[vp.gnetID]._occupiedEdges.insert(edgeId);\n\t\t\t\t\t\t_dirty = true;\n\t\t\t\t\t}\n\t\t\t\t\taddedEdges.push_back(\n\t\t\t\t\t\t\tfindEdge(g[vecPath[i]].x, y, g[vecPath[i]].z));\n\t\t\t\t}\n\t\t\t} else\n\t\t\t\tassert(0);\n\t\t} else {\n\t\t\tassert(g[vecPath[i]].y == g[vecPath[i - 1]].y);\n\t\t\tassert(g[vecPath[i]].x == g[vecPath[i - 1]].x);\n\t\t\tfor (int z = min(g[vecPath[i]].z, g[vecPath[i - 1]].z);\n\t\t\t\t\tz < max(g[vecPath[i]].z, g[vecPath[i - 1]].z); z++) {\n\t\t\t\tif (writeToDB) {\n\t\t\t\t\tint viaId = findVia(g[vecPath[i]].x, g[vecPath[i]].y, z);\n\t\t\t\t\tif (!(_gnets[vp.gnetID].findCleanVia(viaId))) {\n\t\t\t\t\t\t_gnets[vp.gnetID].setCleanVia(viaId, _vias[viaId]);\n\t\t\t\t\t}\n\t\t\t\t\tif (!(_gnets[vp.gnetID].findRUVia(viaId))) {\n\t\t\t\t\t\t_gnets[vp.gnetID].setRUVia(viaId, _vias[viaId]);\n\t\t\t\t\t}\n\t\t\t\t\trestoreVia(viaId);\n\t\t\t\t\t_gnets[vp.gnetID]._occupiedVias.insert(viaId);\n\t\t\t\t\t_dirty = true;\n\t\t\t\t}\n\t\t\t\taddedVias.push_back(\n\t\t\t\t\t\tfindVia(g[vecPath[i]].x, g[vecPath[i]].y, z));\n\t\t\t}\n\t\t}\n\t}\n\tif (writeToDB) {\n\t\tauto &vecPath = res.second;\n\t\t// Erase points in the middle in the same direction along the path\n\t\tvector validPt;\n\t\tvalidPt.assign(vecPath.size(), true);\n\t\tchar prevDir = 0; // 0 = default, 1 = +x, 2 = -x, 3 = +y, 4 = -y, 5 = +z, 6 = -z, 7 = other\n\t\tif (vecPath.size() > 2) {\n\t\t\tfor (size_t i = 1; i < vecPath.size(); ++i) {\n\t\t\t\tif (g[vecPath[i]].x > g[vecPath[i - 1]].x\n\t\t\t\t\t\t&& g[vecPath[i]].y == g[vecPath[i - 1]].y\n\t\t\t\t\t\t&& g[vecPath[i]].z == g[vecPath[i - 1]].z) {\n\t\t\t\t\tif (prevDir == 1) {\n\t\t\t\t\t\tvalidPt[i - 1] = false;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tprevDir = 1;\n\t\t\t\t\t}\n\t\t\t\t} else if (g[vecPath[i]].x < g[vecPath[i - 1]].x\n\t\t\t\t\t\t&& g[vecPath[i]].y == g[vecPath[i - 1]].y\n\t\t\t\t\t\t&& g[vecPath[i]].z == g[vecPath[i - 1]].z) {\n\t\t\t\t\tif (prevDir == 2) {\n\t\t\t\t\t\tvalidPt[i - 1] = false;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tprevDir = 2;\n\t\t\t\t\t}\n\t\t\t\t} else if (g[vecPath[i]].x == g[vecPath[i - 1]].x\n\t\t\t\t\t\t&& g[vecPath[i]].y > g[vecPath[i - 1]].y\n\t\t\t\t\t\t&& g[vecPath[i]].z == g[vecPath[i - 1]].z) {\n\t\t\t\t\tif (prevDir == 3) {\n\t\t\t\t\t\tvalidPt[i - 1] = false;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tprevDir = 3;\n\t\t\t\t\t}\n\t\t\t\t} else if (g[vecPath[i]].x == g[vecPath[i - 1]].x\n\t\t\t\t\t\t&& g[vecPath[i]].y < g[vecPath[i - 1]].y\n\t\t\t\t\t\t&& g[vecPath[i]].z == g[vecPath[i - 1]].z) {\n\t\t\t\t\tif (prevDir == 4) {\n\t\t\t\t\t\tvalidPt[i - 1] = false;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tprevDir = 4;\n\t\t\t\t\t}\n\t\t\t\t} else if (g[vecPath[i]].x == g[vecPath[i - 1]].x\n\t\t\t\t\t\t&& g[vecPath[i]].y == g[vecPath[i - 1]].y\n\t\t\t\t\t\t&& g[vecPath[i]].z > g[vecPath[i - 1]].z) {\n\t\t\t\t\tif (prevDir == 5) {\n\t\t\t\t\t\t// validPt[i - 1] = false;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tprevDir = 5;\n\t\t\t\t\t}\n\t\t\t\t} else if (g[vecPath[i]].x == g[vecPath[i - 1]].x\n\t\t\t\t\t\t&& g[vecPath[i]].y == g[vecPath[i - 1]].y\n\t\t\t\t\t\t&& g[vecPath[i]].z < g[vecPath[i - 1]].z) {\n\t\t\t\t\tif (prevDir == 6) {\n\t\t\t\t\t\t// validPt[i - 1] = false;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tprevDir = 6;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tprevDir = 7;\n\t\t\t\t}\n\t\t\t}\n\t\t\tvector vecPath_tmp;\n\t\t\tfor (size_t i = 0; i < vecPath.size(); ++i) {\n\t\t\t\tif (validPt[i]) {\n\t\t\t\t\tvecPath_tmp.push_back(vecPath[i]);\n\t\t\t\t}\n\t\t\t}\n\t\t\tvecPath.swap(vecPath_tmp);\n\t\t}\n\t\tGnet &gnet = _gnets[vp.gnetID];\n\t\tgnet._gWires.reserve(gnet._gWires.size() + vecPath.size() + 1);\n\t\tint addedVertex = -1; // gWireID of the added vertex, -1 if n/a.\n\n\t\tvector::iterator gWireItr;\n// check if there is a removed vertex due to broken wires and if so, add it back\n\t\tif (updateRoot) { // this can happen only when updateRoot == true\n\t\t\tvector::iterator> rootItrs;\n\t\t\tfor (gWireItr = gnet._gWires.begin(); gWireItr < gnet._gWires.end();\n\t\t\t\t\t++gWireItr) {\n\t\t\t\tif (gWireItr->_pWireId == -1\n\t\t\t\t\t\t&& gWireItr != gnet._gWires.begin() + gnet._root) {\n\t\t\t\t\trootItrs.push_back(gWireItr);\n\t\t\t\t}\n\t\t\t}\n\t\t\tauto s = vp.gnetVertices;\n\t\t\tfor (auto gw : gnet._gWires) {\n//\tcout << gw._x << \" \" << gw._y << \" \" << gw._z << endl;\n\t\t\t\ts.erase(Gcell(gw._x, gw._y, gw._z));\n\t\t\t}\n//\t\tcout << \"s.size() = \" << s.size() << endl;\n\t\t\tif (s.size() > 1) {\n\t\t\t\tcout << s.size() << endl;\n\t\t\t\texit(-2);\n\t\t\t}\n\t\t\tif (s.size() == 1) { // have to make a new gWire that ALL roots (except gWire[0]) point to.\n\t\t\t\tgnet._gWires.push_back(\n\t\t\t\t\t\tGlobalWire(s.begin()->_x, s.begin()->_y, s.begin()->_z,\n\t\t\t\t\t\t\t\t-1, -1));\n\t\t\t\taddedVertex = gnet._gWires.size() - 1;\n\t\t\t\tfor (auto &rootItr : rootItrs) {\n\t\t\t\t\trootItr->_pWireId = addedVertex;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n// Identify goal type\n\t\tfor (gWireItr = gnet._gWires.begin(); gWireItr < gnet._gWires.end();\n\t\t\t\t++gWireItr) {\n\t\t\tif (gWireItr->_x == g[vecPath[0]].x\n\t\t\t\t\t&& gWireItr->_y == g[vecPath[0]].y\n\t\t\t\t\t&& gWireItr->_z == g[vecPath[0]].z) {\n\t\t\t\tbreak; // Case 0: goal is one of endpoints of a gWire\n\t\t\t}\n\t\t}\n\n\t\tif (gWireItr == gnet._gWires.end()) { // Case 1: goal in the middle of a gWire\n\t\t\tfor (gWireItr = gnet._gWires.begin(); gWireItr < gnet._gWires.end();\n\t\t\t\t\t++gWireItr) {\n\t\t\t\tif (gWireItr->_pWireId != -1) {\n\t\t\t\t\tint &x1 = gWireItr->_x, &y1 = gWireItr->_y, &z1 =\n\t\t\t\t\t\t\tgWireItr->_z;\n\t\t\t\t\tint &x2 = gnet._gWires[gWireItr->_pWireId]._x, &y2 =\n\t\t\t\t\t\t\tgnet._gWires[gWireItr->_pWireId]._y, &z2 =\n\t\t\t\t\t\t\tgnet._gWires[gWireItr->_pWireId]._z;\n\t\t\t\t\tint &x0 = g[vecPath[0]].x, &y0 = g[vecPath[0]].y, &z0 =\n\t\t\t\t\t\t\tg[vecPath[0]].z;\n\t\t\t\t\tif ((x1 != x2 && y0 == y1 && z0 == z1 && min(x1, x2) < x0\n\t\t\t\t\t\t\t&& x0 < max(x1, x2))\n\t\t\t\t\t\t\t|| (y1 != y2 && x0 == x1 && z0 == z1\n\t\t\t\t\t\t\t\t\t&& min(y1, y2) < y0 && y0 < max(y1, y2))\n\t\t\t\t\t\t\t|| (z1 != z2 && x0 == x1 && y0 == y1\n\t\t\t\t\t\t\t\t\t&& min(z1, z2) < z0 && z0 < max(z1, z2))) {\n\t\t\t\t\t\t// make a new gWire in the middle\n\t\t\t\t\t\tgnet._gWires.push_back(\n\t\t\t\t\t\t\t\tGlobalWire(x0, y0, z0, gWireItr->_pWireId, -1));\n\t\t\t\t\t\tgWireItr->_pWireId = gnet._gWires.size() - 1;\n\t\t\t\t\t\tgWireItr = gnet._gWires.end() - 1;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tassert(gWireItr < gnet._gWires.end());\n\t\tif (updateRoot) {\n// Mode 2: move the root, make the root point to the new vertex, update the root\n// search for all roots due to broken wires\n\t\t\tauto rootItr = gWireItr;\n\t\t\tvector gWireIDsToReverse;\n\t\t\tif (rootItr < gnet._gWires.end()) { // Case 0 or Case 1\n\t\t\t\twhile (rootItr->_pWireId != -1) {\n\t\t\t\t\tgWireIDsToReverse.push_back(rootItr - gnet._gWires.begin());\n\t\t\t\t\trootItr = gnet._gWires.begin() + rootItr->_pWireId;\n\t\t\t\t}\n\t\t\t\tgWireIDsToReverse.push_back(rootItr - gnet._gWires.begin());\n\t\t\t}\n\n\t\t\tgnet._gWires[gWireIDsToReverse[0]]._pWireId = -1;\n\t\t\tfor (auto itr = gWireIDsToReverse.begin() + 1;\n\t\t\t\t\titr < gWireIDsToReverse.end(); ++itr) {\n// Reverse the directions of each gWire\n\t\t\t\tgnet._gWires[(*itr)]._pWireId = *(itr - 1);\n\t\t\t}\n\t\t\tif (gnet._gWires[gnet._root]._pWireId != -1) {\n\t\t\t\tgnet._root = gWireIDsToReverse[0];\n\t\t\t\tcout << \" Root changed to: \" << gnet._root << endl;\n\t\t\t}\n// let the new gWire point to the last gwire in the list to reverse,\n// finishing the reversing process.\n//if (addedVertex != -1) {\n//\tgnet._gWires[addedVertex]._pWireId =\n//\t\t\t*(gWireIDsToReverse.end() - 1);\n//}\n\n// expose the new root and prepare for adding the new path.\n\t\t\tgWireItr = gnet._gWires.begin() + gWireIDsToReverse[0];\n\n\t\t\tfor (auto itr = vecPath.begin() + 1; itr < vecPath.end(); ++itr) {\n// Add edge (*itr, *(itr-1)) to DB (gnet/addEdgeDemand)\n\t\t\t\tgnet._gWires.push_back(\n\t\t\t\t\t\tGlobalWire(g[*itr].x, g[*itr].y, g[*itr].z, -1, -1));\n\t\t\t\tgWireItr->_pWireId = gnet._gWires.size() - 1;\n\t\t\t\tgWireItr = gnet._gWires.end() - 1;\n\t\t\t}\n\t\t} else {\n// Mode 1: make the new vertex point to the root, keep the root\n\t\t\tint pWireId = gWireItr - gnet._gWires.begin();\n\t\t\tfor (auto itr = vecPath.begin() + 1; itr < vecPath.end(); ++itr) {\n// Add edge (*itr, *(itr+1)) to DB (gnet/addEdgeDemand)\n\t\t\t\tgnet._gWires.push_back(\n\t\t\t\t\t\tGlobalWire(g[*itr].x, g[*itr].y, g[*itr].z, pWireId,\n\t\t\t\t\t\t\t\t-1));\n\t\t\t\tpWireId = gnet._gWires.size() - 1;\n\t\t\t}\n\t\t}\n\t}\n\treturn make_tuple(wl, addedEdges, addedVias, margin, addlBannedPts);\n}\n\nstd::tuple, vector, int> RoutingDB::rerouteNet(\n\t\tconst Layout &layout, const Vpin &vp1, const Vpin &vp2, const int zlLim,\n\t\tconst int zuLim, const int maxMargin, const bool singleMargin,\n\t\tconst bool writeToDB) {\n// Connect two v-pins\n\tusing namespace boost;\n\tint margin = singleMargin ? maxMargin : 0;\n\tint next_margin = 0;\n\tdouble wl = INFINITY;\n\tbool isFeasible = false;\n\tdouble minmhd = INFINITY;\n\tstd::pair> res;\n\tstd::vector addedEdges, addedVias;\n\tGraph g;\n\tstd::unordered_set bannedPts; // empty set\n\twhile (margin <= maxMargin) {\n// cout << \"[2vp] margin = \" << margin << endl;\n\t\tint xlLim = max(min(vp1.xCoord, vp2.xCoord) - margin, 0);\n\t\tint xuLim = min(max(vp1.xCoord, vp2.xCoord) + margin,\n\t\t\t\t(int) layout._numTilesX - 1);\n\t\tint ylLim = max(min(vp1.yCoord, vp2.yCoord) - margin, 0);\n\t\tint yuLim = min(max(vp1.yCoord, vp2.yCoord) + margin,\n\t\t\t\t(int) layout._numTilesY - 1);\n\t\tg = build_graph(vp1.gnetID, bannedPts, xlLim, xuLim, ylLim, yuLim,\n\t\t\t\tzlLim, zuLim);\n\t\tint X = xuLim - xlLim + 1, Y = yuLim - ylLim + 1;\n\t\tVertex start = (vp1.zCoord + 1 - zlLim) * Y * X\n\t\t\t\t+ (vp1.yCoord - ylLim) * X + (vp1.xCoord - xlLim);\n\t\tVertex goal = (vp2.zCoord + 1 - zlLim) * Y * X\n\t\t\t\t+ (vp2.yCoord - ylLim) * X + (vp2.xCoord - xlLim);\n\t\tif (minmhd == INFINITY) {\n\t\t\tminmhd = fabs(g[start].x - g[goal].x) + fabs(g[start].y - g[goal].y)\n\t\t\t\t\t+ fabs(g[start].z - g[goal].z);\n\t\t}\n\t\tstd::unordered_set goals = { goal };\n\t\tres = a_star(g, start, goals);\n\t\tif (res.first < INFINITY) { // found a-star path\n\t\t\twl = res.first;\n// cout << \"wl = \" << wl << endl;\n\t\t\tisFeasible = true;\n\t\t\tnext_margin = std::max(next_margin,\n\t\t\t\t\tstd::min(maxMargin, (int) ((res.first - minmhd) / 2.0)));\n\t\t} else { // not found\n\t\t\tnext_margin = std::max(next_margin,\n\t\t\t\t\tstd::min(maxMargin, margin * 2 + 1));\n// cout << \"next_margin = \" << next_margin << endl;\n\t\t}\n\t\tif (next_margin > margin)\n\t\t\tmargin = next_margin;\n\t\telse\n\t\t\tbreak;\n\t}\n\tif (!isFeasible)\n\t\treturn make_tuple(INFINITY, addedEdges, addedVias, margin);\n// add the new vpin\n\tif (writeToDB) {\n\t\tint viaId = findVia(vp1.xCoord, vp1.yCoord, vp1.zCoord);\n\t\tif (!(_gnets[vp1.gnetID].findCleanVia(viaId))) {\n\t\t\t_gnets[vp1.gnetID].setCleanVia(viaId, _vias[viaId]);\n\t\t}\n\t\tif (!(_gnets[vp1.gnetID].findRUVia(viaId))) {\n\t\t\t_gnets[vp1.gnetID].setRUVia(viaId, _vias[viaId]);\n\t\t}\n\t\trestoreVia(viaId);\n\t\t_dirty = true;\n\t}\n\taddedVias.push_back(findVia(vp1.xCoord, vp1.yCoord, vp1.zCoord));\n\n\tauto &vecPath = res.second;\n\t// Erase points in the middle in the same direction along the path\n\tvector validPt;\n\tvalidPt.assign(vecPath.size(), true);\n\tchar prevDir = 0; // 0 = default, 1 = +x, 2 = -x, 3 = +y, 4 = -y, 5 = +z, 6 = -z, 7 = other\n\tif (vecPath.size() > 2) {\n\t\tfor (size_t i = 1; i < vecPath.size(); ++i) {\n\t\t\tif (g[vecPath[i]].x > g[vecPath[i - 1]].x\n\t\t\t\t\t&& g[vecPath[i]].y == g[vecPath[i - 1]].y\n\t\t\t\t\t&& g[vecPath[i]].z == g[vecPath[i - 1]].z) {\n\t\t\t\tif (prevDir == 1) {\n\t\t\t\t\tvalidPt[i - 1] = false;\n\t\t\t\t} else {\n\t\t\t\t\tprevDir = 1;\n\t\t\t\t}\n\t\t\t} else if (g[vecPath[i]].x < g[vecPath[i - 1]].x\n\t\t\t\t\t&& g[vecPath[i]].y == g[vecPath[i - 1]].y\n\t\t\t\t\t&& g[vecPath[i]].z == g[vecPath[i - 1]].z) {\n\t\t\t\tif (prevDir == 2) {\n\t\t\t\t\tvalidPt[i - 1] = false;\n\t\t\t\t} else {\n\t\t\t\t\tprevDir = 2;\n\t\t\t\t}\n\t\t\t} else if (g[vecPath[i]].x == g[vecPath[i - 1]].x\n\t\t\t\t\t&& g[vecPath[i]].y > g[vecPath[i - 1]].y\n\t\t\t\t\t&& g[vecPath[i]].z == g[vecPath[i - 1]].z) {\n\t\t\t\tif (prevDir == 3) {\n\t\t\t\t\tvalidPt[i - 1] = false;\n\t\t\t\t} else {\n\t\t\t\t\tprevDir = 3;\n\t\t\t\t}\n\t\t\t} else if (g[vecPath[i]].x == g[vecPath[i - 1]].x\n\t\t\t\t\t&& g[vecPath[i]].y < g[vecPath[i - 1]].y\n\t\t\t\t\t&& g[vecPath[i]].z == g[vecPath[i - 1]].z) {\n\t\t\t\tif (prevDir == 4) {\n\t\t\t\t\tvalidPt[i - 1] = false;\n\t\t\t\t} else {\n\t\t\t\t\tprevDir = 4;\n\t\t\t\t}\n\t\t\t} else if (g[vecPath[i]].x == g[vecPath[i - 1]].x\n\t\t\t\t\t&& g[vecPath[i]].y == g[vecPath[i - 1]].y\n\t\t\t\t\t&& g[vecPath[i]].z > g[vecPath[i - 1]].z) {\n\t\t\t\tif (prevDir == 5) {\n\t\t\t\t\t// validPt[i - 1] = false;\n\t\t\t\t} else {\n\t\t\t\t\tprevDir = 5;\n\t\t\t\t}\n\t\t\t} else if (g[vecPath[i]].x == g[vecPath[i - 1]].x\n\t\t\t\t\t&& g[vecPath[i]].y == g[vecPath[i - 1]].y\n\t\t\t\t\t&& g[vecPath[i]].z < g[vecPath[i - 1]].z) {\n\t\t\t\tif (prevDir == 6) {\n\t\t\t\t\t// validPt[i - 1] = false;\n\t\t\t\t} else {\n\t\t\t\t\tprevDir = 6;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tprevDir = 7;\n\t\t\t}\n\t\t}\n\t\tvector vecPath_tmp;\n\t\tfor (size_t i = 0; i < vecPath.size(); ++i) {\n\t\t\tif (validPt[i]) {\n\t\t\t\tvecPath_tmp.push_back(vecPath[i]);\n\t\t\t}\n\t\t}\n\t\tvecPath.swap(vecPath_tmp);\n\t}\n\tfor (int i = 1; i < static_cast(vecPath.size()); i++) {\n\t\tif (g[vecPath[i]].z == g[vecPath[i - 1]].z) {\n\t\t\tif (_dirLayers[g[vecPath[i]].z] == H) {\n\t\t\t\tassert(g[vecPath[i]].y == g[vecPath[i - 1]].y);\n\t\t\t\tfor (int x = min(g[vecPath[i]].x, g[vecPath[i - 1]].x);\n\t\t\t\t\t\tx < max(g[vecPath[i]].x, g[vecPath[i - 1]].x); x++) {\n\t\t\t\t\tif (writeToDB) {\n\t\t\t\t\t\tint edgeId = findEdge(x, g[vecPath[i]].y,\n\t\t\t\t\t\t\t\tg[vecPath[i]].z);\n\t\t\t\t\t\tif (!(_gnets[vp1.gnetID].findCleanEdge(edgeId))) {\n\t\t\t\t\t\t\t_gnets[vp1.gnetID].setCleanEdge(edgeId,\n\t\t\t\t\t\t\t\t\t_edges[edgeId]);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (!(_gnets[vp1.gnetID].findRUEdge(edgeId))) {\n\t\t\t\t\t\t\t_gnets[vp1.gnetID].setRUEdge(edgeId,\n\t\t\t\t\t\t\t\t\t_edges[edgeId]);\n\t\t\t\t\t\t}\n\t\t\t\t\t\trestoreEdge(edgeId);\n\t\t\t\t\t\t_dirty = true;\n\t\t\t\t\t}\n\t\t\t\t\taddedEdges.push_back(\n\t\t\t\t\t\t\tfindEdge(x, g[vecPath[i]].y, g[vecPath[i]].z));\n\n\t\t\t\t}\n\t\t\t} else if (_dirLayers[g[vecPath[i]].z] == V) {\n\t\t\t\tassert(g[vecPath[i]].x == g[vecPath[i - 1]].x);\n\t\t\t\tfor (int y = min(g[vecPath[i]].y, g[vecPath[i - 1]].y);\n\t\t\t\t\t\ty < max(g[vecPath[i]].y, g[vecPath[i - 1]].y); y++) {\n\t\t\t\t\tif (writeToDB) {\n\t\t\t\t\t\tint edgeId = findEdge(g[vecPath[i]].x, y,\n\t\t\t\t\t\t\t\tg[vecPath[i]].z);\n\t\t\t\t\t\tif (!(_gnets[vp1.gnetID].findCleanEdge(edgeId))) {\n\t\t\t\t\t\t\t_gnets[vp1.gnetID].setCleanEdge(edgeId,\n\t\t\t\t\t\t\t\t\t_edges[edgeId]);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (!(_gnets[vp1.gnetID].findRUEdge(edgeId))) {\n\t\t\t\t\t\t\t_gnets[vp1.gnetID].setRUEdge(edgeId,\n\t\t\t\t\t\t\t\t\t_edges[edgeId]);\n\t\t\t\t\t\t}\n\t\t\t\t\t\trestoreEdge(edgeId);\n\t\t\t\t\t\t_dirty = true;\n\t\t\t\t\t}\n\t\t\t\t\taddedEdges.push_back(\n\t\t\t\t\t\t\tfindEdge(g[vecPath[i]].x, y, g[vecPath[i]].z));\n\t\t\t\t}\n\t\t\t} else\n\t\t\t\tassert(0);\n\t\t} else {\n\t\t\tassert(g[vecPath[i]].y == g[vecPath[i - 1]].y);\n\t\t\tassert(g[vecPath[i]].x == g[vecPath[i - 1]].x);\n\t\t\tfor (int z = min(g[vecPath[i]].z, g[vecPath[i - 1]].z);\n\t\t\t\t\tz < max(g[vecPath[i]].z, g[vecPath[i - 1]].z); z++) {\n\t\t\t\tif (writeToDB) {\n\t\t\t\t\tint viaId = findVia(g[vecPath[i]].x, g[vecPath[i]].y, z);\n\t\t\t\t\tif (!(_gnets[vp1.gnetID].findCleanVia(viaId))) {\n\t\t\t\t\t\t_gnets[vp1.gnetID].setCleanVia(viaId, _vias[viaId]);\n\t\t\t\t\t}\n\t\t\t\t\tif (!(_gnets[vp1.gnetID].findRUVia(viaId))) {\n\t\t\t\t\t\t_gnets[vp1.gnetID].setRUVia(viaId, _vias[viaId]);\n\t\t\t\t\t}\n\t\t\t\t\trestoreVia(findVia(g[vecPath[i]].x, g[vecPath[i]].y, z));\n\t\t\t\t\t_dirty = true;\n\t\t\t\t}\n\t\t\t\taddedVias.push_back(\n\t\t\t\t\t\tfindVia(g[vecPath[i]].x, g[vecPath[i]].y, z));\n\t\t\t}\n\t\t}\n\t}\n\tif (writeToDB) {\n\t\tauto vecPath = res.second;\n\t\tGnet &gnet = _gnets[vp1.gnetID];\n\t\tgnet._gWires.reserve(gnet._gWires.size() + vecPath.size());\n\t\tvector::iterator gWireItr1, gWireItr2;\n\t\t// start\n\t\tfor (gWireItr1 = gnet._gWires.begin(); gWireItr1 < gnet._gWires.end();\n\t\t\t\t++gWireItr1) {\n\t\t\tif (gWireItr1->_x == g[vecPath.back()].x\n\t\t\t\t\t&& gWireItr1->_y == g[vecPath.back()].y\n\t\t\t\t\t&& gWireItr1->_z == g[vecPath.back()].z - 1) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\t// goal\n\t\tfor (gWireItr2 = gnet._gWires.begin(); gWireItr2 < gnet._gWires.end();\n\t\t\t\t++gWireItr2) {\n\t\t\tif (gWireItr2->_x == g[vecPath[0]].x\n\t\t\t\t\t&& gWireItr2->_y == g[vecPath[0]].y\n\t\t\t\t\t&& gWireItr2->_z == g[vecPath[0]].z) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tassert((gWireItr1->_pWireId == -1) != (gWireItr2->_pWireId == -1));\n\t\tif (gWireItr2->_pWireId == -1) {\n// cout << \"Mode 2\" << endl;\n// Mode 2\n\t\t\tif (vecPath.size() == 1) {\n\t\t\t\tgWireItr2->_pWireId = gWireItr1 - gnet._gWires.begin();\n\t\t\t} else {\n\t\t\t\tfor (auto itr = vecPath.begin() + 1; itr < vecPath.end() - 1;\n\t\t\t\t\t\t++itr) {\n// Add edge (*itr, *(itr+1)) to DB (gnet/addEdgeDemand)\n\t\t\t\t\tgnet._gWires.push_back(\n\t\t\t\t\t\t\tGlobalWire(g[*itr].x, g[*itr].y, g[*itr].z, -1,\n\t\t\t\t\t\t\t\t\t-1));\n\t\t\t\t\tgWireItr2->_pWireId = gnet._gWires.size() - 1;\n\t\t\t\t\tgWireItr2 = gnet._gWires.end() - 1;\n\t\t\t\t}\n\t\t\t\tgnet._gWires.push_back(\n\t\t\t\t\t\tGlobalWire(g[vecPath.back()].x, g[vecPath.back()].y,\n\t\t\t\t\t\t\t\tg[vecPath.back()].z,\n\t\t\t\t\t\t\t\tgWireItr1 - gnet._gWires.begin(), -1));\n\t\t\t\tgWireItr2->_pWireId = gnet._gWires.size() - 1;\n\t\t\t}\n\t\t} else {\n// cout << \"Mode 1\" << endl;\n// Mode 1\n\t\t\tif (vecPath.size() == 1) {\n\t\t\t\tgWireItr1->_pWireId = gWireItr2 - gnet._gWires.begin();\n\t\t\t} else {\n\t\t\t\tstd::reverse(vecPath.begin(), vecPath.end());\n\t\t\t\tfor (auto itr = vecPath.begin(); itr < vecPath.end() - 2;\n\t\t\t\t\t\t++itr) {\n// Add edge (*itr, *(itr+1)) to DB (gnet/addEdgeDemand)\n\t\t\t\t\tgnet._gWires.push_back(\n\t\t\t\t\t\t\tGlobalWire(g[*itr].x, g[*itr].y, g[*itr].z, -1,\n\t\t\t\t\t\t\t\t\t-1));\n\t\t\t\t\tgWireItr1->_pWireId = gnet._gWires.size() - 1;\n\t\t\t\t\tgWireItr1 = gnet._gWires.end() - 1;\n\t\t\t\t}\n\t\t\t\tgnet._gWires.push_back(\n\t\t\t\t\t\tGlobalWire(g[vecPath[vecPath.size() - 2]].x,\n\t\t\t\t\t\t\t\tg[vecPath[vecPath.size() - 2]].y,\n\t\t\t\t\t\t\t\tg[vecPath[vecPath.size() - 2]].z,\n\t\t\t\t\t\t\t\tgWireItr2 - gnet._gWires.begin(), -1));\n\t\t\t\tgWireItr1->_pWireId = gnet._gWires.size() - 1;\n\t\t\t}\n\t\t}\n\t\trestoreNet(vp1.gnetID, gnet, _gnets[vp1.gnetID]._cleanEdges,\n\t\t\t\t_gnets[vp1.gnetID]._cleanVias, false);\n\t}\n\treturn make_tuple(wl + 1, addedEdges, addedVias, margin); // including WL of the new v-pin\n}\n\n", "meta": {"hexsha": "b98f7aaa0bab769052b5d60bd8f08f96b0ad63ae", "size": 29484, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "a_star.cpp", "max_stars_repo_name": "wei-zeng/ISPD11-bench-split", "max_stars_repo_head_hexsha": "ddee82dcdd704175ed78d43731016b49a5efaa87", "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": "a_star.cpp", "max_issues_repo_name": "wei-zeng/ISPD11-bench-split", "max_issues_repo_head_hexsha": "ddee82dcdd704175ed78d43731016b49a5efaa87", "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": "a_star.cpp", "max_forks_repo_name": "wei-zeng/ISPD11-bench-split", "max_forks_repo_head_hexsha": "ddee82dcdd704175ed78d43731016b49a5efaa87", "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": 33.0167973124, "max_line_length": 113, "alphanum_fraction": 0.5792294126, "num_tokens": 10810, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434978390747, "lm_q2_score": 0.5813030906443133, "lm_q1q2_score": 0.44867501078757144}} {"text": "/*\n * car_model_propagator.hpp\n *\n * Created on: Oct 30, 2018 22:52\n * Description:\n *\n * Copyright (c) 2018 Ruixiang Du (rdu)\n */\n\n#ifndef CAR_MODEL_PROPAGATOR_HPP\n#define CAR_MODEL_PROPAGATOR_HPP\n\n#include \n#include \n\n#include \n\n#include \"reachability/details/car_longitudinal_model.hpp\"\n\nnamespace robotnav {\nclass CarModelPropagator {\n public:\n CarLongitudinalModel::state_type Propagate(CarLongitudinalModel::state_type init_state,\n CarLongitudinalModel::control_type u, double t0,\n double tf, double dt) {\n double t = t0;\n CarLongitudinalModel::state_type x = init_state;\n\n while (t <= tf) {\n // integrator_(CarLongitudinalModel(u), x, t, dt);\n\n boost::numeric::odeint::integrate_const(\n boost::numeric::odeint::runge_kutta4<\n CarLongitudinalModel::state_type>(),\n CarLongitudinalModel(u), x, t, t+dt, dt/10.0);\n\n // add additional constraint to s, v: s >= s0, v >=0, v < v_max\n if (x[0] < init_state[0]) x[0] = init_state[0];\n if (x[1] < 0) x[1] = 0;\n if (x[1] > CarLongitudinalModel::v_max)\n x[1] = CarLongitudinalModel::v_max;\n }\n\n return x;\n }\n};\n} // namespace robotnav\n\n#endif /* CAR_MODEL_PROPAGATOR_HPP */\n", "meta": {"hexsha": "2191c6ea5421eac56471bc162db90ec9cccb8bae", "size": 1295, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/modules/planning/decision/reachability/include/reachability/details/car_model_propagator.hpp", "max_stars_repo_name": "rxdu/robotnav", "max_stars_repo_head_hexsha": "fb36ac4ae9372f027c41e7be526ac1e72f094051", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2020-12-02T09:16:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-04T06:36:42.000Z", "max_issues_repo_path": "src/modules/planning/decision/reachability/include/reachability/details/car_model_propagator.hpp", "max_issues_repo_name": "rxdu/robotnav", "max_issues_repo_head_hexsha": "fb36ac4ae9372f027c41e7be526ac1e72f094051", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-12-30T02:01:14.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-02T08:06:40.000Z", "max_forks_repo_path": "src/modules/planning/decision/reachability/include/reachability/details/car_model_propagator.hpp", "max_forks_repo_name": "rxdu/robotnav", "max_forks_repo_head_hexsha": "fb36ac4ae9372f027c41e7be526ac1e72f094051", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-12-02T09:16:15.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-15T03:06:48.000Z", "avg_line_length": 25.9, "max_line_length": 89, "alphanum_fraction": 0.6424710425, "num_tokens": 381, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434978390746, "lm_q2_score": 0.5813030906443133, "lm_q1q2_score": 0.4486750107875714}} {"text": "#include \"cpu/graph_proc.h\"\r\n\r\n#include \r\n#include \r\n#include //std::iota\r\n#include \r\n#include \r\n#include \r\n\r\n#include \r\n\r\nusing std::vector;\r\n\r\nnamespace graph_proc {\r\n\r\n py::array_t erode_mesh(const py::array_t& vertexPositions, const py::array_t& faceIndices, int nIterations, int minNeighbors) {\r\n int nVertices = vertexPositions.shape(0);\r\n int nFaces = faceIndices.shape(0);\r\n\r\n // Init output \r\n py::array_t nonErodedVertices = py::array_t({ nVertices, 1 });\r\n std::vector nonErodedVerticesVec(nVertices, false);\r\n \r\n // Init list of eroded face indices with original list\r\n std::vector erodedFaceIndicesVec;\r\n erodedFaceIndicesVec.reserve(nFaces);\r\n for (int FaceIdx = 0; FaceIdx < nFaces; ++FaceIdx) {\r\n Eigen::Vector3i face(*faceIndices.data(FaceIdx, 0), *faceIndices.data(FaceIdx, 1), *faceIndices.data(FaceIdx, 2));\r\n erodedFaceIndicesVec.push_back(face);\r\n }\r\n\r\n // Erode mesh for a total of nIterations\r\n for (int i = 0; i < nIterations; i++) {\r\n nFaces = erodedFaceIndicesVec.size();\r\n\r\n // We compute the number of neighboring vertices for each vertex.\r\n vector numNeighbors(nVertices, 0);\r\n for (int i = 0; i < nFaces; i++) {\r\n const auto& face = erodedFaceIndicesVec[i];\r\n numNeighbors[face[0]] += 1;\r\n numNeighbors[face[1]] += 1;\r\n numNeighbors[face[2]] += 1;\r\n }\r\n\r\n std::vector tmp;\r\n tmp.reserve(nFaces);\r\n\r\n for (int i = 0; i < nFaces; i++) {\r\n const auto& face = erodedFaceIndicesVec[i];\r\n if (numNeighbors[face[0]] >= minNeighbors && numNeighbors[face[1]] >= minNeighbors && numNeighbors[face[2]] >= minNeighbors) {\r\n tmp.push_back(face);\r\n }\r\n }\r\n\r\n // We kill the faces with border vertices.\r\n erodedFaceIndicesVec.clear();\r\n erodedFaceIndicesVec = std::move(tmp);\r\n }\r\n\r\n // Mark non isolated vertices as not eroded.\r\n nFaces = erodedFaceIndicesVec.size();\r\n\r\n for (int i = 0; i < nFaces; i++) {\r\n const auto& face = erodedFaceIndicesVec[i];\r\n nonErodedVerticesVec[face[0]] = true;\r\n nonErodedVerticesVec[face[1]] = true;\r\n nonErodedVerticesVec[face[2]] = true;\r\n }\r\n\r\n // Store into python array\r\n for (int i = 0; i < nVertices; i++) {\r\n *nonErodedVertices.mutable_data(i, 0) = nonErodedVerticesVec[i];\r\n }\r\n\r\n return nonErodedVertices;\r\n }\r\n\r\n int sample_nodes(\r\n const py::array_t& vertexPositions, const py::array_t& nonErodedVertices,\r\n py::array_t& nodePositions, py::array_t& nodeIndices, \r\n float nodeCoverage, \r\n const bool useOnlyNonErodedIndices=true, \r\n const bool randomShuffle=true\r\n ) {\r\n // assert(vertexPositions.ndim() == 2);\r\n\r\n float nodeCoverage2 = nodeCoverage * nodeCoverage;\r\n int nVertices = vertexPositions.shape(0);\r\n // assert(vertexPositions.shape(1) == 3);\r\n // assert(nodePositions.shape(0) == nVertices);\r\n // assert(nodePositions.shape(1) == 3);\r\n // assert(nodeIndices.shape(0) == nVertices);\r\n // assert(nodeIndices.shape(1) == 1);\r\n\r\n nodePositions.resize({ nVertices, 3 }, false);\r\n nodeIndices.resize({ nVertices, 1 }, false);\r\n\r\n // create list of shuffled indices\r\n std::vector shuffledVertices(nVertices);\r\n std::iota(std::begin(shuffledVertices), std::end(shuffledVertices), 0);\r\n\r\n if (randomShuffle) {\r\n std::default_random_engine re{std::random_device{}()};\r\n std::shuffle(std::begin(shuffledVertices), std::end(shuffledVertices), re);\r\n }\r\n\r\n std::vector nodePositionsVec;\r\n for (int vertexIdx : shuffledVertices) {\r\n // for (int vertexIdx = 0; vertexIdx < nVertices; ++vertexIdx) {\r\n Eigen::Vector3f point(*vertexPositions.data(vertexIdx, 0), *vertexPositions.data(vertexIdx, 1), *vertexPositions.data(vertexIdx, 2));\r\n\r\n if (useOnlyNonErodedIndices && !(*nonErodedVertices.data(vertexIdx))) {\r\n continue;\r\n }\r\n\r\n bool bIsNode = true;\r\n for (int nodeIdx = 0; nodeIdx < nodePositionsVec.size(); ++nodeIdx) {\r\n if ((point - nodePositionsVec[nodeIdx]).squaredNorm() <= nodeCoverage2) {\r\n bIsNode = false;\r\n break;\r\n }\r\n }\r\n\r\n if (bIsNode) {\r\n nodePositionsVec.push_back(point);\r\n int newNodeIdx = nodePositionsVec.size() - 1;\r\n *nodePositions.mutable_data(newNodeIdx, 0) = point.x();\r\n *nodePositions.mutable_data(newNodeIdx, 1) = point.y();\r\n *nodePositions.mutable_data(newNodeIdx, 2) = point.z();\r\n *nodeIndices.mutable_data(newNodeIdx, 0) = vertexIdx;\r\n }\r\n }\r\n\r\n return nodePositionsVec.size();\r\n }\r\n\r\n /**\r\n * Custom comparison operator for geodesic priority queue.\r\n */\r\n struct CustomCompare {\r\n bool operator()(const std::pair& left, const std::pair& right) {\r\n return left.second > right.second;\r\n }\r\n };\r\n\r\n inline float compute_anchor_weight(const Eigen::Vector3f& pointPosition, const Eigen::Vector3f& nodePosition, float nodeCoverage) {\r\n return std::exp(-(nodePosition - pointPosition).squaredNorm() / (2.f * nodeCoverage * nodeCoverage));\r\n }\r\n\r\n inline float compute_anchor_weight(float dist, float nodeCoverage) {\r\n return std::exp(- (dist * dist) / (2.f * nodeCoverage * nodeCoverage));\r\n }\r\n\r\n void compute_edges_geodesic(\r\n\t\tconst py::array_t& vertexPositions,\r\n\t\tconst py::array_t& validVertices, \r\n\t\tconst py::array_t& faceIndices, \r\n\t\tconst py::array_t& nodeIndices, \r\n\t\tconst int nMaxNeighbors, const float nodeCoverage,\r\n py::array_t& graphEdges,\r\n py::array_t& graphEdgesWeights,\r\n py::array_t& graphEdgesDistances,\r\n py::array_t& nodeToVertexDistances,\r\n const bool allow_only_valid_vertices,\r\n const bool enforce_total_num_neighbors\r\n\t) {\r\n\t\tint nVertices = vertexPositions.shape(0);\r\n\t\tint nFaces = faceIndices.shape(0);\r\n int nNodes = nodeIndices.shape(0);\r\n\r\n float maxInfluence = 2.f * nodeCoverage;\r\n\r\n // Preprocess vertex neighbors.\r\n\t\tvector> vertexNeighbors(nVertices);\r\n for (int faceIdx = 0; faceIdx < nFaces; faceIdx++) {\r\n for (int j = 0; j < 3; j++) {\r\n int v_idx = *faceIndices.data(faceIdx, j);\r\n \r\n for (int k = 0; k < 3; k++) {\r\n int n_idx = *faceIndices.data(faceIdx, k);\r\n \r\n if (v_idx == n_idx) continue;\r\n vertexNeighbors[v_idx].insert(n_idx);\r\n }\r\n }\r\n }\r\n\r\n\t\t// Compute inverse vertex -> node relationship.\r\n\t\tvector mapVertexToNode(nVertices, -1);\r\n\r\n\t\tfor (int nodeId = 0; nodeId < nNodes; nodeId++) {\r\n\t\t\tint vertexIdx = *nodeIndices.data(nodeId);\r\n\t\t\tif (vertexIdx >= 0) {\r\n\t\t\t\tmapVertexToNode[vertexIdx] = nodeId;\r\n\t\t\t}\r\n\t\t}\r\n\r\n // #pragma omp parallel for\r\n\t\tfor (int nodeId = 0; nodeId < nNodes; nodeId++) {\r\n\t\t\t// vertex queue\r\n std::priority_queue<\r\n\t\t\t\tstd::pair,\r\n\t\t\t\tvector>,\r\n\t\t\t\tCustomCompare\r\n\t\t\t> nextVerticesWithIds;\r\n\r\n\t\t\tstd::set visitedVertices;\r\n\r\n\t\t\t// Add node vertex as the first vertex to be visited.\r\n\t\t\tint nodeVertexIdx = *nodeIndices.data(nodeId);\r\n\t\t\tif (nodeVertexIdx < 0) continue;\r\n\t\t\tnextVerticesWithIds.push(std::make_pair(nodeVertexIdx, 0.f));\r\n\t\t\t\r\n\t\t\t// Traverse all neighbors in the monotonically increasing order.\r\n vector neighborNodeIds;\r\n vector neighborNodeWeights;\r\n vector neighborNodeDistances;\r\n\t\t\twhile (!nextVerticesWithIds.empty()) {\r\n\t\t\t\tauto nextVertex = nextVerticesWithIds.top();\r\n\t\t\t\tnextVerticesWithIds.pop();\r\n\r\n\t\t\t\tint nextVertexIdx = nextVertex.first;\r\n\t\t\t\tfloat nextVertexDist = nextVertex.second;\r\n\r\n\t\t\t\t// We skip the vertex, if it was already visited before.\r\n\t\t\t\tif (visitedVertices.find(nextVertexIdx) != visitedVertices.end()) continue;\r\n\r\n if (allow_only_valid_vertices && !*validVertices.data(nextVertexIdx)) {\r\n std::cout << \"compute_edges_geodesic:: ufff... we shouldn't be checking out this vertex\" << std::endl;\r\n exit(0);\r\n }\r\n\r\n\t\t\t\t// We check if the vertex is a node.\r\n\t\t\t\tint nextNodeId = mapVertexToNode[nextVertexIdx];\r\n\t\t\t\tif (nextNodeId >= 0 && nextNodeId != nodeId) {\r\n neighborNodeIds.push_back(nextNodeId);\r\n neighborNodeWeights.push_back(compute_anchor_weight(nextVertexDist, nodeCoverage));\r\n neighborNodeDistances.push_back(nextVertexDist);\r\n if (neighborNodeIds.size() >= nMaxNeighbors) break;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Note down the node-vertex distance.\r\n\t\t\t\t*nodeToVertexDistances.mutable_data(nodeId, nextVertexIdx) = nextVertexDist;\r\n\r\n\t\t\t\t// We visit the vertex, and check all his neighbors.\r\n\t\t\t\t// We add only valid vertices under a certain distance\r\n\t\t\t\tvisitedVertices.insert(nextVertexIdx);\r\n\t\t\t\tEigen::Vector3f nextVertexPos(*vertexPositions.data(nextVertexIdx, 0), *vertexPositions.data(nextVertexIdx, 1), *vertexPositions.data(nextVertexIdx, 2));\r\n\r\n\t\t\t\tconst auto& nextNeighbors = vertexNeighbors[nextVertexIdx];\r\n\t\t\t\tfor (int neighborIdx : nextNeighbors) {\r\n\r\n bool is_valid_vertex = *validVertices.data(neighborIdx); \r\n if (allow_only_valid_vertices && !is_valid_vertex) {\r\n continue;\r\n }\r\n\r\n\t\t\t\t\tEigen::Vector3f neighborVertexPos(*vertexPositions.data(neighborIdx, 0), *vertexPositions.data(neighborIdx, 1), *vertexPositions.data(neighborIdx, 2));\r\n\t\t\t\t\tfloat dist = nextVertexDist + (nextVertexPos - neighborVertexPos).norm();\r\n \r\n if (enforce_total_num_neighbors) {\r\n\t\t\t\t\t\tnextVerticesWithIds.push(std::make_pair(neighborIdx, dist));\r\n }\r\n\t\t\t\t\telse {\r\n // std::cout << dist << \" \" << maxInfluence << std::endl;\r\n if (dist <= maxInfluence) {\r\n\t\t\t\t\t\t nextVerticesWithIds.push(std::make_pair(neighborIdx, dist));\r\n\t\t\t\t\t }\r\n } \r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n // Store the nearest neighbors.\r\n int nNeighbors = neighborNodeIds.size();\r\n\r\n float weightSum = 0.f;\r\n for (int i = 0; i < nNeighbors; i++) {\r\n *graphEdges.mutable_data(nodeId, i) = neighborNodeIds[i];\r\n weightSum += neighborNodeWeights[i];\r\n }\r\n\r\n // Normalize weights\r\n if (weightSum > 0) {\r\n for (int i = 0; i < nNeighbors; i++) {\r\n *graphEdgesWeights.mutable_data(nodeId, i) = neighborNodeWeights[i] / weightSum;\r\n }\r\n }\r\n else if (nNeighbors > 0) {\r\n for (int i = 0; i < nNeighbors; i++) {\r\n *graphEdgesWeights.mutable_data(nodeId, i) = neighborNodeWeights[i] / nNeighbors;\r\n }\r\n }\r\n\r\n // Store edge distance.\r\n for (int i = 0; i < nNeighbors; i++) {\r\n *graphEdgesDistances.mutable_data(nodeId, i) = neighborNodeDistances[i];\r\n }\r\n\t\t}\r\n }\r\n\r\n py::array_t compute_edges_euclidean(const py::array_t& nodePositions, int nMaxNeighbors) {\r\n int nNodes = nodePositions.shape(0);\r\n\r\n py::array_t graphEdges = py::array_t({ nNodes, nMaxNeighbors });\r\n\r\n // Find nearest Euclidean neighbors for each node.\r\n for (int nodeId = 0; nodeId < nNodes; nodeId++) {\r\n Eigen::Vector3f nodePos(*nodePositions.data(nodeId, 0), *nodePositions.data(nodeId, 1), *nodePositions.data(nodeId, 2));\r\n\r\n // Keep only the k nearest Euclidean neighbors.\r\n std::list> nearestNodesWithSquaredDistances;\r\n\r\n for (int neighborId = 0; neighborId < nNodes; neighborId++) {\r\n if (neighborId == nodeId) continue;\r\n\r\n Eigen::Vector3f neighborPos(*nodePositions.data(neighborId, 0), *nodePositions.data(neighborId, 1), *nodePositions.data(neighborId, 2));\r\n\r\n float distance2 = (nodePos - neighborPos).squaredNorm();\r\n bool bInserted = false;\r\n for (auto it = nearestNodesWithSquaredDistances.begin(); it != nearestNodesWithSquaredDistances.end(); ++it) {\r\n // We insert the element at the first position where its distance is smaller than the other\r\n // element's distance, which enables us to always keep a sorted list of at most k nearest\r\n // neighbors.\r\n if (distance2 <= it->second) {\r\n it = nearestNodesWithSquaredDistances.insert(it, std::make_pair(neighborId, distance2));\r\n bInserted = true;\r\n break;\r\n }\r\n }\r\n\r\n if (!bInserted && nearestNodesWithSquaredDistances.size() < nMaxNeighbors) {\r\n nearestNodesWithSquaredDistances.emplace_back(std::make_pair(neighborId, distance2));\r\n }\r\n\r\n // We keep only the list of k nearest elements.\r\n if (bInserted && nearestNodesWithSquaredDistances.size() > nMaxNeighbors) {\r\n nearestNodesWithSquaredDistances.pop_back();\r\n }\r\n }\r\n \r\n // Store nearest neighbor ids.\r\n int idx = 0;\r\n for (auto it = nearestNodesWithSquaredDistances.begin(); it != nearestNodesWithSquaredDistances.end(); ++it) {\r\n int neighborId = it->first;\r\n *graphEdges.mutable_data(nodeId, idx) = neighborId;\r\n idx++;\r\n }\r\n\r\n for (idx = nearestNodesWithSquaredDistances.size(); idx < nMaxNeighbors; idx++) {\r\n *graphEdges.mutable_data(nodeId, idx) = -1;\r\n }\r\n }\r\n\r\n return graphEdges;\r\n }\r\n\r\n inline int traverse_neighbors(const std::vector>& node_neighbors, std::vector& cluster_ids, int cluster_id, int node_id) {\r\n if (cluster_ids[node_id] != -1) return 0;\r\n \r\n std::set active_node_indices;\r\n\r\n // Initialize with current node.\r\n int cluster_size = 0;\r\n active_node_indices.insert(node_id);\r\n\r\n // Process until we have no active nodes anymore.\r\n while (!active_node_indices.empty()) {\t\r\n int active_node_id = *active_node_indices.begin();\r\n active_node_indices.erase(active_node_indices.begin());\r\n\r\n if (cluster_ids[active_node_id] == -1) {\r\n cluster_ids[active_node_id] = cluster_id;\r\n ++cluster_size;\r\n }\r\n\r\n // Look if we need to process any of the neighbors\r\n for (const auto& n_idx : node_neighbors[active_node_id]) {\r\n if (cluster_ids[n_idx] == -1) {\t// If it doesn't have a cluster yet\r\n active_node_indices.insert(n_idx);\r\n }\r\n }\r\n }\r\n\r\n return cluster_size;\r\n }\r\n\r\n void node_and_edge_clean_up(const py::array_t& graph_edges, py::array_t& valid_nodes_mask) {\r\n int num_nodes = graph_edges.shape(0);\r\n int max_num_neighbors = graph_edges.shape(1);\r\n\r\n std::list removed_nodes;\r\n\r\n while (true) {\r\n int num_newly_removed_nodes = 0;\r\n\r\n for (int node_id = 0; node_id < num_nodes; ++node_id) {\r\n\r\n if (*valid_nodes_mask.data(node_id, 0) == false) {\r\n // if node has been already removed, continue\r\n continue;\r\n }\r\n\r\n int num_neighbors = 0;\r\n for (int i = 0; i < max_num_neighbors; ++i) {\r\n\r\n int neighbor_id = *graph_edges.data(node_id, i);\r\n \r\n // if neighboring node is -1, break, since by design 'graph_edges' has\r\n // the shape [2, 3, 6, -1, -1, -1, -1, -1]\r\n if (neighbor_id == -1) {\r\n break;\r\n }\r\n\r\n // if neighboring node has been marked as invalid, continue\r\n if (std::find(removed_nodes.begin(), removed_nodes.end(), neighbor_id) != removed_nodes.end()) {\r\n continue;\r\n }\r\n\r\n ++num_neighbors;\r\n }\r\n\r\n if (num_neighbors <= 1) {\r\n // remove node\r\n *valid_nodes_mask.mutable_data(node_id, 0) = false;\r\n removed_nodes.emplace_back(node_id);\r\n // std::cout << \"\\tremoving node_id \" << node_id << std::endl;\r\n ++num_newly_removed_nodes;\r\n }\r\n }\r\n\r\n // std::cout << \"num_newly_removed_nodes: \" << num_newly_removed_nodes << std::endl;\r\n\r\n if (num_newly_removed_nodes == 0) {\r\n break;\r\n }\r\n }\r\n }\r\n\r\n std::vector compute_clusters(\r\n const py::array_t graph_edges,\r\n py::array_t graph_clusters\r\n ) {\r\n int num_nodes = graph_edges.shape(0);\r\n int max_num_neighbors = graph_edges.shape(1);\r\n\r\n // convert graph_edges to a vector of sets\r\n std::vector> node_neighbors(num_nodes);\r\n\r\n for (int node_id = 0; node_id < num_nodes; ++node_id) {\r\n for (int neighbor_idx = 0; neighbor_idx < max_num_neighbors; ++neighbor_idx) {\r\n \r\n int neighbor_id = *graph_edges.data(node_id, neighbor_idx);\r\n \r\n if (neighbor_id == -1) {\r\n break;\r\n }\r\n\r\n node_neighbors[node_id].insert(neighbor_id);\r\n node_neighbors[neighbor_id].insert(node_id);\r\n }\r\n }\r\n\r\n std::vector cluster_ids(num_nodes, -1);\r\n std::vector clusters_size;\r\n\r\n int cluster_id = 0;\r\n for (int node_id = 0; node_id < num_nodes; ++node_id) {\r\n int cluster_size = traverse_neighbors(node_neighbors, cluster_ids, cluster_id, node_id);\r\n if (cluster_size > 0) {\r\n cluster_id++;\r\n clusters_size.push_back(cluster_size);\r\n }\r\n }\r\n\r\n for (int node_id = 0; node_id < num_nodes; ++node_id) {\r\n *graph_clusters.mutable_data(node_id, 0) = cluster_ids[node_id];\r\n }\r\n\r\n return clusters_size;\r\n } \r\n\r\n inline void compute_nearest_geodesic_nodes(\r\n const py::array_t& node_to_vertex_distance, \r\n const py::array_t& valid_nodes_mask,\r\n const int vertex_id, \r\n std::vector& nearest_geodesic_node_ids, \r\n std::vector& dist_to_nearest_geodesic_nodes\r\n ) {\r\n int num_nodes = node_to_vertex_distance.shape(0);\r\n\r\n std::map node_map;\r\n\r\n for (int n = 0; n < num_nodes; ++n) {\r\n\r\n // discard node if it was marked as invalid (due to not having enough neighbors)\r\n if (*valid_nodes_mask.data(n, 0) == false) {\r\n continue;\r\n }\r\n\r\n float dist = *node_to_vertex_distance.data(n, vertex_id);\r\n\r\n if (dist >= 0) {\r\n node_map.emplace(n, dist);\r\n }\r\n }\r\n\r\n // Sort the map by distance\r\n // Declaring the type of Predicate that accepts 2 pairs and return a bool\r\n typedef std::function, std::pair)> Comparator;\r\n \r\n // Defining a lambda function to compare two pairs. It will compare two pairs using second field\r\n Comparator comp_functor =\r\n [](std::pair node1 ,std::pair node2) {\r\n return node1.second < node2.second;\r\n };\r\n\r\n // Declaring a set that will store the pairs using above comparision logic\r\n std::set, Comparator> node_set(\r\n node_map.begin(), node_map.end(), comp_functor\r\n );\r\n\r\n for (auto n : node_set) {\r\n nearest_geodesic_node_ids.push_back(n.first);\r\n dist_to_nearest_geodesic_nodes.push_back(n.second);\r\n\r\n if (nearest_geodesic_node_ids.size() == GRAPH_K) {\r\n break;\r\n }\r\n }\r\n }\r\n\r\n void compute_pixel_anchors_geodesic(\r\n const py::array_t &node_to_vertex_distance, \r\n const py::array_t &valid_nodes_mask, \r\n const py::array_t &vertices,\r\n const py::array_t &vertex_pixels, \r\n py::array_t& pixel_anchors, \r\n py::array_t& pixel_weights,\r\n const int width, const int height,\r\n const float node_coverage\r\n ) {\r\n // Allocate graph node ids and corresponding skinning weights.\r\n // Initialize with invalid anchors.\r\n pixel_anchors.resize({ height, width, GRAPH_K }, false);\r\n pixel_weights.resize({ height, width, GRAPH_K }, false);\r\n\r\n for (int y = 0; y < height; y++) {\r\n for (int x = 0; x < width; x++) {\r\n for (int k = 0; k < GRAPH_K; k++) {\r\n *pixel_anchors.mutable_data(y, x, k) = -1;\r\n *pixel_weights.mutable_data(y, x, k) = 0.f;\r\n }\r\n }\r\n }\r\n\r\n int num_vertices = vertices.shape(0);\r\n\r\n for (int vertex_id = 0; vertex_id < num_vertices; vertex_id++) {\r\n // Get corresponding pixel location\r\n int u = *vertex_pixels.data(vertex_id, 0);\r\n int v = *vertex_pixels.data(vertex_id, 1);\r\n\r\n // Initialize some variables\r\n std::vector nearest_geodesic_node_ids;\r\n std::vector dist_to_nearest_geodesic_nodes;\r\n std::vector skinning_weights;\r\n\r\n nearest_geodesic_node_ids.reserve(GRAPH_K);\r\n dist_to_nearest_geodesic_nodes.reserve(GRAPH_K);\r\n skinning_weights.reserve(GRAPH_K);\r\n\r\n // Find closest geodesic nodes\r\n compute_nearest_geodesic_nodes(\r\n node_to_vertex_distance, valid_nodes_mask, vertex_id,\r\n nearest_geodesic_node_ids, dist_to_nearest_geodesic_nodes\r\n );\r\n\r\n int num_anchors = nearest_geodesic_node_ids.size();\r\n\r\n // Compute skinning weights.\r\n float weight_sum{ 0.f };\r\n for (int i = 0; i < num_anchors; ++i) {\r\n float geodesic_dist_to_node = dist_to_nearest_geodesic_nodes[i];\r\n\r\n float weight = compute_anchor_weight(geodesic_dist_to_node, node_coverage);\r\n weight_sum += weight;\r\n\r\n skinning_weights.push_back(weight);\r\n }\r\n\r\n // Normalize the skinning weights.\r\n if (weight_sum > 0) {\r\n for (int i = 0; i < num_anchors; i++)\r\n skinning_weights[i] /= weight_sum;\r\n }\r\n else if (num_anchors > 0) {\r\n for (int i = 0; i < num_anchors; i++)\r\n skinning_weights[i] = 1.f / num_anchors;\r\n }\r\n \r\n // Store the results.\r\n for (int i = 0; i < num_anchors; i++) {\r\n *pixel_anchors.mutable_data(v, u, i) = nearest_geodesic_node_ids[i];\r\n *pixel_weights.mutable_data(v, u, i) = skinning_weights[i];\r\n }\r\n }\r\n }\r\n\r\n void compute_pixel_anchors_euclidean(\r\n const py::array_t& graphNodes, \r\n const py::array_t& pointImage,\r\n float nodeCoverage,\r\n py::array_t& pixelAnchors, \r\n py::array_t& pixelWeights\r\n ) {\r\n int nNodes = graphNodes.shape(0);\r\n int width = pointImage.shape(2);\r\n int height = pointImage.shape(1);\r\n // int nChannels = pointImage.shape(0);\r\n\r\n // Allocate graph node ids and corresponding skinning weights.\r\n // Initialize with invalid anchors.\r\n pixelAnchors.resize({ height, width, GRAPH_K }, false);\r\n pixelWeights.resize({ height, width, GRAPH_K }, false);\r\n\r\n for (int y = 0; y < height; y++) {\r\n for (int x = 0; x < width; x++) {\r\n for (int k = 0; k < GRAPH_K; k++) {\r\n *pixelAnchors.mutable_data(y, x, k) = -1;\r\n *pixelWeights.mutable_data(y, x, k) = 0.f;\r\n }\r\n }\r\n }\r\n\r\n // Compute anchors for every pixel.\r\n #pragma omp parallel for\r\n for (int y = 0; y < height; y++) {\r\n for (int x = 0; x < width; x++) {\r\n // Query 3d pixel position.\r\n Eigen::Vector3f pixelPos(*pointImage.data(0, y, x), *pointImage.data(1, y, x), *pointImage.data(2, y, x));\r\n if (pixelPos.z() <= 0) continue;\r\n \r\n // Keep only the k nearest Euclidean neighbors.\r\n std::list> nearestNodesWithSquaredDistances;\r\n\r\n for (int nodeId = 0; nodeId < nNodes; nodeId++) {\r\n Eigen::Vector3f nodePos(*graphNodes.data(nodeId, 0), *graphNodes.data(nodeId, 1), *graphNodes.data(nodeId, 2));\r\n\r\n float distance2 = (pixelPos - nodePos).squaredNorm();\r\n bool bInserted = false;\r\n for (auto it = nearestNodesWithSquaredDistances.begin(); it != nearestNodesWithSquaredDistances.end(); ++it) {\r\n // We insert the element at the first position where its distance is smaller than the other\r\n // element's distance, which enables us to always keep a sorted list of at most k nearest\r\n // neighbors.\r\n if (distance2 <= it->second) {\r\n it = nearestNodesWithSquaredDistances.insert(it, std::make_pair(nodeId, distance2));\r\n bInserted = true;\r\n break;\r\n }\r\n }\r\n\r\n if (!bInserted && nearestNodesWithSquaredDistances.size() < GRAPH_K) {\r\n nearestNodesWithSquaredDistances.emplace_back(std::make_pair(nodeId, distance2));\r\n }\r\n\r\n // We keep only the list of k nearest elements.\r\n if (bInserted && nearestNodesWithSquaredDistances.size() > GRAPH_K) {\r\n nearestNodesWithSquaredDistances.pop_back();\r\n }\r\n }\r\n\r\n // Compute skinning weights.\r\n std::vector nearestEuclideanNodeIds;\r\n nearestEuclideanNodeIds.reserve(nearestNodesWithSquaredDistances.size());\r\n\r\n std::vector skinningWeights;\r\n skinningWeights.reserve(nearestNodesWithSquaredDistances.size());\r\n\r\n float weightSum{ 0.f };\r\n for (auto it = nearestNodesWithSquaredDistances.begin(); it != nearestNodesWithSquaredDistances.end(); ++it) {\r\n int nodeId = it->first;\r\n\r\n Eigen::Vector3f nodePos(*graphNodes.data(nodeId, 0), *graphNodes.data(nodeId, 1), *graphNodes.data(nodeId, 2));\r\n float weight = compute_anchor_weight(pixelPos, nodePos, nodeCoverage);\r\n weightSum += weight;\r\n\r\n nearestEuclideanNodeIds.push_back(nodeId);\r\n skinningWeights.push_back(weight);\r\n }\r\n\r\n // Normalize the skinning weights.\r\n int nAnchors = nearestEuclideanNodeIds.size();\r\n\r\n if (weightSum > 0) {\r\n for (int i = 0; i < nAnchors; i++)\tskinningWeights[i] /= weightSum;\r\n }\r\n else if (nAnchors > 0) {\r\n for (int i = 0; i < nAnchors; i++)\tskinningWeights[i] = 1.f / nAnchors;\r\n }\r\n \r\n // Store the results.\r\n for (int i = 0; i < nAnchors; i++) {\r\n *pixelAnchors.mutable_data(y, x, i) = nearestEuclideanNodeIds[i];\r\n *pixelWeights.mutable_data(y, x, i) = skinningWeights[i];\r\n }\r\n }\r\n }\r\n }\r\n\r\n void construct_regular_graph(\r\n const py::array_t& pointImage,\r\n int xNodes, int yNodes,\r\n float edgeThreshold,\r\n float maxPointToNodeDistance,\r\n float maxDepth,\r\n py::array_t& graphNodes, \r\n py::array_t& graphEdges, \r\n py::array_t& pixelAnchors, \r\n py::array_t& pixelWeights\r\n ) {\r\n int width = pointImage.shape(2);\r\n int height = pointImage.shape(1);\r\n int nChannels = pointImage.shape(0);\r\n\r\n float xStep = float(width - 1) / (xNodes - 1);\r\n float yStep = float(height - 1) / (yNodes - 1);\r\n\r\n // Sample graph nodes.\r\n // We need to maintain the mapping from all -> valid nodes ids.\r\n int nNodes = xNodes * yNodes;\r\n std::vector sampledNodeMapping(nNodes, -1);\r\n\r\n std::vector nodePositions;\r\n nodePositions.reserve(nNodes);\r\n\r\n int nodeId = 0;\r\n for (int y = 0; y < yNodes; y++) {\r\n for (int x = 0; x < xNodes; x++) {\r\n int nodeIdx = y * xNodes + x;\r\n\r\n // We use nearest neighbor interpolation for node position\r\n // computation.\r\n int xPixel = std::round(x * xStep); \r\n int yPixel = std::round(y * yStep);\r\n\r\n Eigen::Vector3f pixelPos(*pointImage.data(0, yPixel, xPixel), *pointImage.data(1, yPixel, xPixel), *pointImage.data(2, yPixel, xPixel));\r\n if (pixelPos.z() <= 0 || pixelPos.z() > maxDepth) continue;\r\n\r\n nodePositions.push_back(pixelPos);\r\n sampledNodeMapping[nodeIdx] = nodeId;\r\n nodeId++;\r\n }\r\n }\r\n int nSampledNodes = nodeId;\r\n\r\n // Compute graph edges using pixel-wise connectivity. Each node\r\n // is connected with at most 8 neighboring pixels.\r\n int numNeighbors = 8;\r\n float edgeThreshold2 = edgeThreshold * edgeThreshold;\r\n\r\n std::vector sampledNodeEdges(nSampledNodes * numNeighbors, -1);\r\n std::vector connectedNodes(nSampledNodes, false);\r\n\r\n int nConnectedNodes = 0;\r\n for (int y = 0; y < yNodes; y++) {\r\n for (int x = 0; x < xNodes; x++) {\r\n int nodeIdx = y * xNodes + x;\r\n int nodeId = sampledNodeMapping[nodeIdx];\r\n\r\n if (nodeId >= 0) {\r\n Eigen::Vector3f nodePosition = nodePositions[nodeId];\r\n\r\n int neighborCount = 0;\r\n for (int yDelta = -1; yDelta <= 1; yDelta++) {\r\n for (int xDelta = -1; xDelta <= 1; xDelta++) {\r\n int xNeighbor = x + xDelta;\r\n int yNeighbor = y + yDelta;\r\n if (xNeighbor < 0 || xNeighbor >= xNodes || yNeighbor < 0 || yNeighbor >= yNodes)\r\n continue;\r\n \r\n int neighborIdx = yNeighbor * xNodes + xNeighbor;\r\n \r\n if (neighborIdx == nodeIdx || neighborIdx < 0)\r\n continue;\r\n\r\n int neighborId = sampledNodeMapping[neighborIdx];\r\n if (neighborId >= 0) {\r\n Eigen::Vector3f neighborPosition = nodePositions[neighborId];\r\n\r\n if ((neighborPosition - nodePosition).squaredNorm() <= edgeThreshold2) {\r\n sampledNodeEdges[nodeId * numNeighbors + neighborCount] = neighborId;\r\n neighborCount++;\r\n }\r\n }\r\n }\r\n }\r\n\r\n for (int i = neighborCount; i < numNeighbors; i++) {\r\n sampledNodeEdges[nodeId * numNeighbors + i] = -1;\r\n }\r\n\r\n if (neighborCount > 0) {\r\n connectedNodes[nodeId] = true;\r\n nConnectedNodes += 1;\r\n }\r\n }\r\n }\r\n }\r\n\r\n // Filter out nodes with no edges.\r\n // After changing node ids the edge ids need to be changed as well.\r\n std::vector validNodeMapping(nSampledNodes, -1);\r\n\r\n graphNodes.resize({ nConnectedNodes, 3 }, false);\r\n graphEdges.resize({ nConnectedNodes, numNeighbors }, false);\r\n\r\n int validNodeId = 0;\r\n for (int y = 0; y < yNodes; y++) {\r\n for (int x = 0; x < xNodes; x++) {\r\n int nodeIdx = y * xNodes + x;\r\n int nodeId = sampledNodeMapping[nodeIdx];\r\n\r\n if (nodeId >= 0 && connectedNodes[nodeId]) {\r\n validNodeMapping[nodeId] = validNodeId;\r\n\r\n Eigen::Vector3f nodePosition = nodePositions[nodeId];\r\n *graphNodes.mutable_data(validNodeId, 0) = nodePosition.x();\r\n *graphNodes.mutable_data(validNodeId, 1) = nodePosition.y();\r\n *graphNodes.mutable_data(validNodeId, 2) = nodePosition.z();\r\n\r\n validNodeId++;\r\n }\r\n }\r\n }\r\n\r\n for (int y = 0; y < yNodes; y++) {\r\n for (int x = 0; x < xNodes; x++) {\r\n int nodeIdx = y * xNodes + x;\r\n int nodeId = sampledNodeMapping[nodeIdx];\r\n\r\n if (nodeId >= 0 && connectedNodes[nodeId]) {\r\n int validNodeId = validNodeMapping[nodeId];\r\n \r\n if (validNodeId >= 0) {\r\n for (int i = 0; i < numNeighbors; i++) {\r\n int sampledNeighborId = sampledNodeEdges[nodeId * numNeighbors + i];\r\n if (sampledNeighborId >= 0) {\r\n *graphEdges.mutable_data(validNodeId, i) = validNodeMapping[sampledNeighborId];\r\n }\r\n else {\r\n *graphEdges.mutable_data(validNodeId, i) = -1;\r\n }\r\n }\r\n }\r\n }\r\n }\r\n }\r\n\r\n // Compute pixel anchors and weights.\r\n pixelAnchors.resize({ height, width, 4 }, false);\r\n pixelWeights.resize({ height, width, 4 }, false);\r\n\r\n float maxPointToNodeDistance2 = maxPointToNodeDistance * maxPointToNodeDistance;\r\n\r\n for (int y = 0; y < height; y++) {\r\n for (int x = 0; x < width; x++) {\r\n // Initialize with invalid values. \r\n for (int k = 0; k < 4; k++) {\r\n *pixelAnchors.mutable_data(y, x, k) = -1;\r\n *pixelWeights.mutable_data(y, x, k) = 0.f;\r\n }\r\n \r\n // Compute 4 nearest nodes.\r\n float xNode = float(x) / xStep;\r\n float yNode = float(y) / yStep;\r\n\r\n int x0 = std::floor(xNode), x1 = x0 + 1;\r\n int y0 = std::floor(yNode), y1 = y0 + 1;\r\n\r\n // Check that all neighboring nodes are valid.\r\n if (x0 < 0 || x1 >= xNodes || y0 < 0 || y1 >= yNodes)\r\n continue;\r\n\r\n int sampledNode00 = sampledNodeMapping[y0 * xNodes + x0];\r\n int sampledNode01 = sampledNodeMapping[y1 * xNodes + x0];\r\n int sampledNode10 = sampledNodeMapping[y0 * xNodes + x1];\r\n int sampledNode11 = sampledNodeMapping[y1 * xNodes + x1];\r\n\r\n if (sampledNode00 < 0 || sampledNode01 < 0 || sampledNode10 < 0 || sampledNode11 < 0)\r\n continue;\r\n\r\n int validNode00 = validNodeMapping[sampledNode00];\r\n int validNode01 = validNodeMapping[sampledNode01];\r\n int validNode10 = validNodeMapping[sampledNode10];\r\n int validNode11 = validNodeMapping[sampledNode11];\r\n\r\n if (validNode00 < 0 || validNode01 < 0 || validNode10 < 0 || validNode11 < 0)\r\n continue;\r\n\r\n // Check that all nodes are close enough to the point.\r\n Eigen::Vector3f pixelPos(*pointImage.data(0, y, x), *pointImage.data(1, y, x), *pointImage.data(2, y, x));\r\n if (pixelPos.z() <= 0 || pixelPos.z() > maxDepth) continue;\r\n\r\n if ((pixelPos - nodePositions[sampledNode00]).squaredNorm() > maxPointToNodeDistance2 ||\r\n (pixelPos - nodePositions[sampledNode01]).squaredNorm() > maxPointToNodeDistance2 ||\r\n (pixelPos - nodePositions[sampledNode10]).squaredNorm() > maxPointToNodeDistance2 ||\r\n (pixelPos - nodePositions[sampledNode11]).squaredNorm() > maxPointToNodeDistance2\r\n ) {\r\n continue;\r\n }\r\n\r\n // Compute bilinear weights.\r\n float dx = xNode - x0;\r\n float dy = yNode - y0;\r\n\r\n float w00 = (1 - dx) * (1 - dy);\r\n float w01 = (1 - dx) * dy;\r\n float w10 = dx * (1 - dy);\r\n float w11 = dx * dy;\r\n \r\n *pixelAnchors.mutable_data(y, x, 0) = validNode00;\r\n *pixelWeights.mutable_data(y, x, 0) = w00;\r\n *pixelAnchors.mutable_data(y, x, 1) = validNode01;\r\n *pixelWeights.mutable_data(y, x, 1) = w01;\r\n *pixelAnchors.mutable_data(y, x, 2) = validNode10;\r\n *pixelWeights.mutable_data(y, x, 2) = w10;\r\n *pixelAnchors.mutable_data(y, x, 3) = validNode11;\r\n *pixelWeights.mutable_data(y, x, 3) = w11;\r\n }\r\n }\r\n }\r\n\r\n void update_pixel_anchors(\r\n const std::map& node_id_mapping,\r\n py::array_t& pixel_anchors\r\n ) {\r\n int height = pixel_anchors.shape(0);\r\n int width = pixel_anchors.shape(1);\r\n int num_anchors = pixel_anchors.shape(2);\r\n\r\n for (int y = 0; y < height; y++) {\r\n for (int x = 0; x < width; x++) {\r\n\r\n for (int a = 0; a < num_anchors; a++) {\r\n\r\n int current_anchor_id = *pixel_anchors.data(y, x, a);\r\n \r\n if (current_anchor_id != -1) {\r\n int mapped_anchor_id = node_id_mapping.at(current_anchor_id);\r\n\r\n // update anchor only if it would actually change something\r\n if (mapped_anchor_id != current_anchor_id) {\r\n *pixel_anchors.mutable_data(y, x, a) = mapped_anchor_id;\r\n }\r\n }\r\n }\r\n }\r\n }\r\n }\r\n\r\n} // namespace graph_proc", "meta": {"hexsha": "c97530799e53c3cddd6713fc794608a1c84de7e8", "size": 39872, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "csrc/cpu/graph_proc.cpp", "max_stars_repo_name": "erezposner/NeuralTracking", "max_stars_repo_head_hexsha": "df03e13ef627fad7a392fb969bd7c79da1887b39", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 139.0, "max_stars_repo_stars_event_min_datetime": "2020-10-21T22:28:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T18:22:41.000Z", "max_issues_repo_path": "csrc/cpu/graph_proc.cpp", "max_issues_repo_name": "erezposner/NeuralTracking", "max_issues_repo_head_hexsha": "df03e13ef627fad7a392fb969bd7c79da1887b39", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 10.0, "max_issues_repo_issues_event_min_datetime": "2020-10-26T09:18:49.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-14T07:59:42.000Z", "max_forks_repo_path": "csrc/cpu/graph_proc.cpp", "max_forks_repo_name": "erezposner/NeuralTracking", "max_forks_repo_head_hexsha": "df03e13ef627fad7a392fb969bd7c79da1887b39", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 26.0, "max_forks_repo_forks_event_min_datetime": "2020-10-22T01:18:37.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-13T00:50:13.000Z", "avg_line_length": 41.4901144641, "max_line_length": 158, "alphanum_fraction": 0.5271869984, "num_tokens": 8888, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7122321720225278, "lm_q2_score": 0.6297746213017459, "lm_q1q2_score": 0.44854574641440736}} {"text": "/*\r\nThis file is a part of Raman-Scattering-Code-Conversion.\r\n\r\n\r\nWritten by Siwan Li for the UQ School of Maths and Physics.\r\nCopyright (C) 2021-2022 Siwan Li\r\n\r\nThis source code form is subject to the terms of the MIT License.\r\nIf a copy of the MIT License was not distributed with this file,\r\nyou can obtain one at .\r\n\r\n\r\nThis code is used to calculate Raman scattering off of spheroids.\r\nNone of the code was included in the original SMARTIES package.\r\nMany functions are used to provide I/O support to the main function.\r\n*/\r\n\r\n#ifndef RAMAN_ELASTIC_SCATTERING_HPP\r\n#define RAMAN_ELASTIC_SCATTERING_HPP\r\n\r\n#include \"core.hpp\"\r\n#include \"smarties.hpp\"\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\nusing namespace Smarties;\r\nusing boost::lexical_cast;\r\nusing boost::bad_lexical_cast;\r\n\r\n/* Possible floating-point types used in calculations */\r\nenum CalcType {SINGLE, DOUBLE, QUAD, CUSTOM, NONE};\r\n\r\n/*\r\nControllable parameters that are used for calculations.\r\n_rm suffix denotes parameters used for excitation T-matrix,\r\nabsense of _rm suffix denotes parameters used for Raman T-matrix.\r\n*/\r\ntemplate \r\nstruct RamanParams {\r\n // Describes the minimum and maximum of the particle diameter\r\n Real dia_min = 1000;\r\n Real dia_max = 2000;\r\n\r\n int N_rad = 100; // Number of particle sizes to calculate for\r\n int N_theta_p = 19; // Number of particle orientations to calculate for\r\n Real phi_p = 0; // Angle of rotation of particle about the z semiaxis\r\n\r\n // Number of spherical coordinates used throughout the volume of the particle\r\n int N_r = 100;\r\n int N_theta = 320;\r\n int N_phi = 320;\r\n\r\n // Values of h used, where h = a/c. N_h is the number of h values\r\n int N_h = 1;\r\n Real h_min = static_cast(1.0)/3;\r\n Real h_max = static_cast(1.0)/3;\r\n\r\n // Incident light parameters. Used for stParams struct\r\n Real epsilon1 = 1;\r\n Real epsilon2 = pow(static_cast(1.35), 2);\r\n Real epsilon2_rm = pow(static_cast(1.344), 2);\r\n Real lambda = 355;\r\n Real lambda_rm = 403.7;\r\n\r\n // Used for stParams struct\r\n int Nb_theta = 1000;\r\n int Nb_theta_pst = 1;\r\n\r\n // Used for stOptions struct\r\n int delta = 0;\r\n\r\n // Vectors of all possible radii/theta/h values\r\n ArrayXr rad_var;\r\n ArrayXr theta_p_var;\r\n ArrayXr h_var;\r\n};\r\n\r\n// All non-template functions defined in raman_elastic_scattering.cpp\r\n\r\n/*\r\nGet the 2 types to be used for floating-point calculations from a text file.\r\nInputs:\r\n in_file_name: path of the text file which contains the calculation type\r\nOutput:\r\n String array of size 2 that specifies 2 calculation types.\r\n*/\r\nstd::array GetCalcType(string in_file_name);\r\n\r\n/*\r\nGet the value given for some parameter from a text file.\r\nInputs:\r\n in_file_name: path of the text file which contains the option\r\n option: The exact string of the specific option/parameter to look for\r\nOutput:\r\n The user-defined value given to the option, as a string\r\n*/\r\nstring GetOption(string in_file_name, string option);\r\n\r\n/*\r\nDetermine if it's okay to write calculation info to a file from an option in a text file.\r\nI.e. it checks the \"Print output to file:\" parameter.\r\nInputs:\r\n in_file_name: path of the text file which specifies if it's okay to write to output or not\r\nOutput:\r\n True if the file says \"yes\", i.e. it is okay, false otherwise\r\n*/\r\nbool CanWriteOutput(string in_file_name);\r\n\r\n/*\r\nDetermine number of CPUs to use from a text file. I.e. it checks the \"No. of CPUs\" parameter.\r\nInputs:\r\n in_file_name: path of the text file which specifies the number of CPUs.\r\nOutput:\r\n The number of CPUs that are allowed\r\n*/\r\nint GetNumCPUs(string in_file_name);\r\n\r\n/*\r\nDetermine number of threads to split the particle radii for from a text file.\r\nI.e. it checks the \"No. of CPUs to partition particle radii for:\" parameter.\r\nNote that any one of these threads can still fork into more threads if there are any available.\r\nInputs:\r\n in_file_name: path of the text file which specifies the number of CPUs.\r\nOutput:\r\n The number of CPUs to partition particle radii for\r\n*/\r\nint GetNumParticleCPUs(string in_file_name);\r\n\r\n/*\r\nPrints a string to both standard output (the terminal) and appends it to a text ilfe (if allowed).\r\nInputs:\r\n out_string: the string to print/write\r\n out_file_name: path of the text file to write to\r\n write_output: true enables writing to output, false disables it.\r\n*/\r\nvoid MultiPrint(string out_string, string out_file_name, bool write_output = false);\r\n\r\n/*\r\nConverts a string that's a fraction of two floats into a single float value\r\nThrows a bad_lexical_cast error if string can't be read or converted.\r\nInput:\r\n `frac` - must either be a floating-point literal, or two floating-point literals deliminated by a '/' character.\r\nOutput:\r\n the calculated value as a floating-point variable.\r\n*/\r\ntemplate \r\nReal Frac2Float(string frac) {\r\n Real output;\r\n size_t offset = frac.find(\"/\");\r\n if (offset == string::npos) {\r\n output = static_cast(lexical_cast(frac));\r\n return output;\r\n }\r\n output = static_cast(lexical_cast(frac.substr(0, offset)));\r\n output /= static_cast(lexical_cast(frac.substr(offset + 1)));\r\n return output;\r\n}\r\n\r\n/*\r\nCreates RamanParams struct by reading values from text file.\r\nThe file can be opened or unopened, but must not be modified during this function call.\r\nInputs:\r\n `in_file_name` - path to the file\r\nOutput:\r\n A unique pointer to a new RamanParams struct with member values based on the parameters given in `in_file_name`.\r\nDependencies:\r\n GetOption, Frac2Float\r\n*/\r\ntemplate \r\nunique_ptr> LoadParams(string in_file_name) {\r\n ifstream in_file;\r\n in_file.open(in_file_name, ios::in);\r\n if (!in_file.is_open())\r\n throw runtime_error(\"Error: cannot open \" + in_file_name);\r\n\r\n auto output = make_unique>();\r\n\r\n string line;\r\n // Lists all lines/options to check for. Options with floating-point values are listed first,\r\n // then options with integral values are checked.\r\n vector options {\r\n \"Minimum diameter:\", \"Maximum diameter:\", \"Particle phi:\", \"Minimum h:\", \"Maximum h:\",\r\n \"epsilon1:\", \"epsilon2:\", \"Raman epsilon2:\", \"lambda:\", \"Raman lambda:\",\r\n \"No. of particle radii:\", \"No. of particle thetas:\", \"No. of h ratios:\",\r\n \"No. of r-coordinates:\", \"No. of theta-coordinates:\", \"No. of phi-coordinates:\",\r\n \"Nb_theta:\", \"Nb_theta_pst:\", \"Delta:\"\r\n };\r\n std::array float_params = {\r\n output->dia_min, output->dia_max, output->phi_p, output->h_min, output->h_max,\r\n output->epsilon1, output->epsilon2, output->epsilon2_rm, output->lambda, output->lambda_rm\r\n };\r\n std::array int_params = {\r\n output->N_rad, output->N_theta_p, output->N_h, output->N_r, output->N_theta, output->N_phi,\r\n output->Nb_theta, output->Nb_theta_pst, output->delta\r\n };\r\n for (size_t i = 0; i < options.size(); i++) {\r\n string option = options[i];\r\n string value = GetOption(in_file_name, option);\r\n\r\n try {\r\n if (i < float_params.size())\r\n float_params[i] = Frac2Float(value);\r\n else if (i < float_params.size() + int_params.size())\r\n int_params[i - float_params.size()] = lexical_cast(value);\r\n } catch(bad_lexical_cast&) {\r\n cerr << \"Cannot read value of option \\\"\" << option << \"\\\". Using default value.\";\r\n }\r\n\r\n output->dia_min = float_params[0];\r\n output->dia_max = float_params[1];\r\n output->phi_p = float_params[2];\r\n output->h_min = float_params[3];\r\n output->h_max = float_params[4];\r\n output->epsilon1 = float_params[5];\r\n output->epsilon2 = float_params[6];\r\n output->epsilon2_rm = float_params[7];\r\n output->lambda = float_params[8];\r\n output->lambda_rm = float_params[9];\r\n output->N_rad = int_params[0];\r\n output->N_theta_p = int_params[1];\r\n output->N_h = int_params[2];\r\n output->N_r = int_params[3];\r\n output->N_theta = int_params[4];\r\n output->N_phi = int_params[5];\r\n output->Nb_theta = int_params[6];\r\n output->Nb_theta_pst = int_params[7];\r\n output->delta = int_params[8];\r\n }\r\n ArrayXr dia_var = ArrayXr::LinSpaced(output->N_rad, output->dia_min, output->dia_max);\r\n output->rad_var = dia_var/2;\r\n output->theta_p_var = ArrayXr::LinSpaced(output->N_theta_p, 0, mp_pi()/2);\r\n output->h_var = ArrayXr::LinSpaced(output->N_h, output->h_min, output->h_max);\r\n return output;\r\n}\r\n\r\n/*\r\nTakes a RamanParams struct and uses it to generate an stParams struct for use with SMARTIES functions.\r\nstParams member values are based on RamanParams member values, and on the radius and h value\r\nat rad_ind and h_ind of rad_var and h_var respectively.\r\nInputs:\r\n `raman_params` - unique pointer to a RamanParams struct\r\n `rad_ind` - the index of the entry to use in `raman_params`->rad_var\r\n `h_ind` - the index of the entry to use in `raman_params`->h_var\r\n `type` - the type of values the output struct should have. If it's \"rm\",\r\n then the values denote the parameters of the Raman T-matrix. Otherwise they denote the parameters\r\n of the excitation T-matrix.\r\nOutput:\r\n returns a unique pointer to a new stParams struct\r\nDependencies:\r\n mp_pi\r\n*/\r\ntemplate \r\nunique_ptr> Raman2SmartiesParams(\r\n const unique_ptr>& raman_params, int rad_ind, int h_ind, string type = string()) {\r\n auto params = make_unique>();\r\n params->epsilon1 = raman_params->epsilon1;\r\n params->lambda = ArrayXr(1);\r\n params->epsilon2 = ArrayXr(1);\r\n params->k1 = ArrayXr(1);\r\n params->s = ArrayXr(1);\r\n if (type == \"rm\") {\r\n params->lambda(0) = raman_params->lambda_rm;\r\n params->epsilon2(0) = raman_params->epsilon2_rm;\r\n params->k1(0) = 2*mp_pi() / raman_params->lambda_rm * sqrt(raman_params->epsilon1);\r\n params->s(0) = sqrt(raman_params->epsilon2_rm) / sqrt(raman_params->epsilon1);\r\n } else {\r\n params->lambda(0) = raman_params->lambda;\r\n params->epsilon2(0) = raman_params->epsilon2;\r\n params->k1(0) = 2*mp_pi() / raman_params->lambda * sqrt(raman_params->epsilon1);\r\n params->s(0) = sqrt(raman_params->epsilon2) / sqrt(raman_params->epsilon1);\r\n }\r\n params->Nb_theta = raman_params->Nb_theta;\r\n params->Nb_theta_pst = raman_params->Nb_theta_pst;\r\n\r\n Real h = raman_params->h_var(h_ind);\r\n Real radius = raman_params->rad_var(rad_ind);\r\n if (h > 1) {\r\n params->a = radius;\r\n params->c = radius / h;\r\n } else {\r\n params->a = radius * h;\r\n params->c = radius;\r\n }\r\n // The greater N is, the better the T-matrix converges.\r\n params->N = 6 + 2*static_cast(ceil(max(params->a, params->c)/40));\r\n return params;\r\n}\r\n\r\n/*\r\nAppends a stamp with time and parameter details of Raman scattering calculations at the end of a text file.\r\nFunction opens the file itself. It does not check for any errors.\r\n`Real1` and `Real2` are the two selectable calculation types used for Raman scattering calculations.\r\nDEV NOTE: Can make this into a non-template function using c++20 'concepts' keyword\r\nInputs:\r\n - out_file_name: text file to write stamp to\r\n - raman_params: unique pointer to a RamanParams struct containing the parameters to be written\r\nDependencies:\r\n - GetTypeName\r\n*/\r\ntemplate \r\nvoid CreateTimeStamp(string out_file_name, const unique_ptr>& raman_params) {\r\n string main_calc_type = GetTypeName();\r\n string second_calc_type = GetTypeName();\r\n\r\n ofstream out_file(out_file_name, ios::out | ios::app);\r\n auto sys_time = chrono::system_clock::now();\r\n time_t sys_time_date = chrono::system_clock::to_time_t(sys_time);\r\n out_file << \"Session began at system time: \" << ctime(&sys_time_date);\r\n out_file << \"Running RamanElasticScattering with type \" << main_calc_type;\r\n out_file << \" and \" << second_calc_type << endl;\r\n out_file.flush();\r\n out_file.close();\r\n}\r\n\r\n/*\r\nConverts an existing stTR struct containing entries of one type into a new stTR struct\r\nwith the same entries converted into another type. This could theoretically be\r\nimplemented as a template cast operator or template copy constructor.\r\n`From` is the entry type of the source struct and `To` is the entry type of the new struct.\r\nInputs:\r\n - st_TR_list: the source stTR struct, with entries of type `From`\r\nOutputs:\r\n - Returns a new stTR struct, with entries of type `To`.\r\nDependencies:\r\n mp_im_unit\r\n*/\r\ntemplate \r\nvector>> ConvertStTRList(const vector>>& st_TR_list) {\r\n vector>> output(st_TR_list.size());\r\n complex I = mp_im_unit();\r\n for (size_t i = 0; i < st_TR_list.size(); i++) {\r\n assert(st_TR_list[i]);\r\n assert(st_TR_list[i]->mat_list.size() == 2);\r\n assert(st_TR_list[i]->mat_list[0] == \"st_4M_T\");\r\n assert(st_TR_list[i]->mat_list[1] == \"st_4M_R\");\r\n output[i] = make_unique>();\r\n output[i]->mat_list = st_TR_list[i]->mat_list;\r\n\r\n // Direct casting from a complex type to a complex type containing a Boost MPFR type isn't supported.\r\n output[i]->st_4M_T_eo().M11 = st_TR_list[i]->st_4M_T_eo().M11.real().template cast() +\r\n I * st_TR_list[i]->st_4M_T_eo().M11.imag().template cast();\r\n output[i]->st_4M_T_eo().M12 = st_TR_list[i]->st_4M_T_eo().M12.real().template cast() +\r\n I * st_TR_list[i]->st_4M_T_eo().M12.imag().template cast();\r\n output[i]->st_4M_T_eo().M21 = st_TR_list[i]->st_4M_T_eo().M21.real().template cast() +\r\n I * st_TR_list[i]->st_4M_T_eo().M21.imag().template cast();\r\n output[i]->st_4M_T_eo().M22 = st_TR_list[i]->st_4M_T_eo().M22.real().template cast() +\r\n I * st_TR_list[i]->st_4M_T_eo().M22.imag().template cast();\r\n output[i]->st_4M_T_eo().m = st_TR_list[i]->st_4M_T_eo().m;\r\n output[i]->st_4M_T_eo().ind1 = st_TR_list[i]->st_4M_T_eo().ind1;\r\n output[i]->st_4M_T_eo().ind2 = st_TR_list[i]->st_4M_T_eo().ind2;\r\n\r\n output[i]->st_4M_T_oe().M11 = st_TR_list[i]->st_4M_T_oe().M11.real().template cast() +\r\n I * st_TR_list[i]->st_4M_T_oe().M11.imag().template cast();\r\n output[i]->st_4M_T_oe().M12 = st_TR_list[i]->st_4M_T_oe().M12.real().template cast() +\r\n I * st_TR_list[i]->st_4M_T_oe().M12.imag().template cast();\r\n output[i]->st_4M_T_oe().M21 = st_TR_list[i]->st_4M_T_oe().M21.real().template cast() +\r\n I * st_TR_list[i]->st_4M_T_oe().M21.imag().template cast();\r\n output[i]->st_4M_T_oe().M22 = st_TR_list[i]->st_4M_T_oe().M22.real().template cast() +\r\n I * st_TR_list[i]->st_4M_T_oe().M22.imag().template cast();\r\n output[i]->st_4M_T_oe().m = st_TR_list[i]->st_4M_T_oe().m;\r\n output[i]->st_4M_T_oe().ind1 = st_TR_list[i]->st_4M_T_oe().ind1;\r\n output[i]->st_4M_T_oe().ind2 = st_TR_list[i]->st_4M_T_oe().ind2;\r\n\r\n output[i]->st_4M_R_eo().M11 = st_TR_list[i]->st_4M_R_eo().M11.real().template cast() +\r\n I * st_TR_list[i]->st_4M_R_eo().M11.imag().template cast();\r\n output[i]->st_4M_R_eo().M12 = st_TR_list[i]->st_4M_R_eo().M12.real().template cast() +\r\n I * st_TR_list[i]->st_4M_R_eo().M12.imag().template cast();\r\n output[i]->st_4M_R_eo().M21 = st_TR_list[i]->st_4M_R_eo().M21.real().template cast() +\r\n I * st_TR_list[i]->st_4M_R_eo().M21.imag().template cast();\r\n output[i]->st_4M_R_eo().M22 = st_TR_list[i]->st_4M_R_eo().M22.real().template cast() +\r\n I * st_TR_list[i]->st_4M_R_eo().M22.imag().template cast();\r\n output[i]->st_4M_R_eo().m = st_TR_list[i]->st_4M_R_eo().m;\r\n output[i]->st_4M_R_eo().ind1 = st_TR_list[i]->st_4M_R_eo().ind1;\r\n output[i]->st_4M_R_eo().ind2 = st_TR_list[i]->st_4M_R_eo().ind2;\r\n\r\n output[i]->st_4M_R_oe().M11 = st_TR_list[i]->st_4M_R_oe().M11.real().template cast() +\r\n I * st_TR_list[i]->st_4M_R_oe().M11.imag().template cast();\r\n output[i]->st_4M_R_oe().M12 = st_TR_list[i]->st_4M_R_oe().M12.real().template cast() +\r\n I * st_TR_list[i]->st_4M_R_oe().M12.imag().template cast();\r\n output[i]->st_4M_R_oe().M21 = st_TR_list[i]->st_4M_R_oe().M21.real().template cast() +\r\n I * st_TR_list[i]->st_4M_R_oe().M21.imag().template cast();\r\n output[i]->st_4M_R_oe().M22 = st_TR_list[i]->st_4M_R_oe().M22.real().template cast() +\r\n I * st_TR_list[i]->st_4M_R_oe().M22.imag().template cast();\r\n output[i]->st_4M_R_oe().m = st_TR_list[i]->st_4M_R_oe().m;\r\n output[i]->st_4M_R_oe().ind1 = st_TR_list[i]->st_4M_R_oe().ind1;\r\n output[i]->st_4M_R_oe().ind2 = st_TR_list[i]->st_4M_R_oe().ind2;\r\n }\r\n return output;\r\n}\r\n\r\n/*\r\nPerforms calculations of the Raman scattering of light off of spheroids with multiprocessing.\r\nIf calculations are done for multiple spheroid radii, the calculations for each radii may be\r\nallocated to the threads using dynamic scheduling.\r\nThe parameters are based on some input file, the T-matrices are calculated using floating-point type `Real1`,\r\nand the field calculations are calculated using floating-point type `Real2`.\r\nIt then prints a summary of results to the standard output (terminal) and in a set of files in a given directory.\r\nEach thread prints its own calculations to its own output file, so each output file is named\r\nbased on the parameters on the number of the thread.\r\nInputs:\r\n - in_file_name: path to the file containing parameters for use in the Raman scattering calculations.\r\n Parameter details are given in the README file.\r\n - out_dir: directory to write output files to. If empty, output files are written to.\r\nDependencies:\r\n mp_pi, ArrayMap, TensorCast, TensorConj, LoadParams, CreateTimeStamp, MultiPrint,\r\n Raman2SmartiesParams, ConvertStTRList, slvForT, pstScatteringMatrixOA, vshMakeIncidentParams,\r\n rvhGetFieldCoefficients, pstMakeStructForField, vshEgenThetaAllPhi, vshEthetaForPhi\r\n*/\r\ntemplate \r\nvoid RamanElasticScattering(string in_file_name, string out_dir = \"\", int cpus = 1) {\r\n // Initialise all parameters and variables\r\n Real2 PI = mp_pi();\r\n\r\n unique_ptr> raman_params1 = LoadParams(in_file_name);\r\n unique_ptr> raman_params2 = LoadParams(in_file_name);\r\n bool write_output = (out_dir != \"\");\r\n\r\n Tensor3r sigma_yz(raman_params2->N_rad, raman_params2->N_h, raman_params2->N_theta_p);\r\n Tensor3r sigma_zy(raman_params2->N_rad, raman_params2->N_h, raman_params2->N_theta_p);\r\n Tensor3r sigma_zz(raman_params2->N_rad, raman_params2->N_h, raman_params2->N_theta_p);\r\n Tensor3r sigma_yy(raman_params2->N_rad, raman_params2->N_h, raman_params2->N_theta_p);\r\n ArrayXr C_sca = ArrayXr::Zero(raman_params1->N_rad);\r\n ArrayXr C_ext = ArrayXr::Zero(raman_params1->N_rad);\r\n ArrayXr C_abs = ArrayXr::Zero(raman_params1->N_rad);\r\n vector>> stSM_list(raman_params2->N_rad);\r\n\r\n auto options = make_unique();\r\n options->get_R = true; // Needed for near fields and will be overridden in any case\r\n options->delta = raman_params1->delta; // Use delta=-1 to estimate it automatically.\r\n options->NB = 0; // NB will be estimated automatically\r\n options->get_symmetric_T = false;\r\n Real2 phi_p = raman_params2->phi_p;\r\n\r\n int N_r = raman_params2->N_r;\r\n int N_theta = raman_params2->N_theta;\r\n int N_phi = raman_params2->N_phi;\r\n\r\n // Initialises a set regularly spaced theta coordinates that are used for internal field calculations\r\n RowArrayXr theta_surf = RowArrayXr::LinSpaced(N_theta, 0, PI);\r\n // Initialises a non-uniform set of N_r radii inside a unit ball\r\n // such that spherical shells between adjacent radii are equal volume\r\n ArrayXr r_surf_u = ArrayXr::LinSpaced(\r\n N_r, 1/static_cast(N_r), 1).pow(static_cast(1.0)/3);\r\n ArrayXXr r_mat_u = r_surf_u.replicate(1, N_theta);\r\n ArrayXXr theta_mat = theta_surf.replicate(N_r, 1);\r\n\r\n // Initialise output files\r\n if (write_output)\r\n std::filesystem::create_directory(out_dir);\r\n\r\n for (int h_ind = 0; h_ind < raman_params1->N_h; h_ind++) {\r\n // Split the iterations of the next for-loop among threads for parallel processing.\r\n #pragma omp parallel for num_threads(cpus) schedule(dynamic)\r\n for (int k = 0; k < raman_params1->N_rad; k++) {\r\n string out_file_name = out_dir + \"/a2c_\" + to_string(raman_params1->h_var(0)) +\r\n \"_to_\" + to_string(raman_params1->h_var(last)) + \"_dia_\" + to_string(raman_params1->dia_min) +\r\n \"_to_\" + to_string(raman_params1->dia_max) + \"_range_\" + to_string(omp_get_thread_num()) + \".txt\";\r\n if (write_output) {\r\n ofstream out_file(out_file_name, ios::out | ios::app);\r\n out_file << endl;\r\n if (!out_file.good()) {\r\n cerr << \"Warning: cannot create or open output file. Some output won't be written.\" << endl;\r\n out_file.close();\r\n write_output = false;\r\n }\r\n }\r\n if (write_output)\r\n CreateTimeStamp(out_file_name, raman_params1);\r\n stringstream out_stream;\r\n\r\n out_stream.precision(4);\r\n out_stream << \"aspect ratio \" << raman_params1->h_var(h_ind) << endl;\r\n MultiPrint(out_stream.str(), out_file_name, write_output);\r\n out_stream.str(string());\r\n\r\n unique_ptr> params1 = Raman2SmartiesParams(raman_params1, k, h_ind);\r\n unique_ptr> params_rm1 = Raman2SmartiesParams(raman_params1, k, h_ind, \"rm\");\r\n unique_ptr> params2 = Raman2SmartiesParams(raman_params2, k, h_ind);\r\n unique_ptr> params_rm2 = Raman2SmartiesParams(raman_params2, k, h_ind, \"rm\");\r\n Real2 a = params2->a;\r\n Real2 c = params2->c;\r\n\r\n int N = params2->N;\r\n // Initialises array of radii coordinates that are used for internal field calculations\r\n // by conforming r_mat_u to the spheroid shape. The ratios of radii along the same angle theta is kept invariant.\r\n ArrayXXr r_mat = a*c*r_mat_u/sqrt(pow(c, 2)*sin(theta_mat).pow(2) + pow(a, 2)*cos(theta_mat).pow(2));\r\n ArrayXXr d_theta = theta_mat(all, seq(1, last)) - theta_mat(all, seq(0, last - 1));\r\n ArrayXXr dr = r_mat(seq(1, last), all) - r_mat(seq(0, last - 1), all);\r\n ArrayXXr dt_dr = d_theta(seq(1, last), all) * dr(all, seq(1, last)); // Jacobian of the integral\r\n RowArrayXr r_row = r_mat.reshaped().transpose();\r\n RowArrayXr theta_row = theta_mat.reshaped().transpose();\r\n\r\n chrono::steady_clock::time_point begin, end;\r\n chrono::duration elapsed_seconds;\r\n\r\n // Calculating T-matrix for excitation\r\n begin = chrono::steady_clock::now();\r\n unique_ptr> T_mat = slvForT(params1, options);\r\n end = chrono::steady_clock::now();\r\n elapsed_seconds = end - begin;\r\n out_stream << elapsed_seconds.count() << endl;\r\n out_stream << \"T-matrix calculatred for excitation\" << endl;\r\n MultiPrint(out_stream.str(), out_file_name, write_output);\r\n out_stream.str(string());\r\n\r\n // Calculating T-matrix for Raman\r\n begin = chrono::steady_clock::now();\r\n unique_ptr> T_mat_rm = slvForT(params_rm1, options);\r\n end = chrono::steady_clock::now();\r\n elapsed_seconds = end - begin;\r\n out_stream << elapsed_seconds.count() << endl;\r\n out_stream << \"T-matrix calculatred for Raman\" << endl;\r\n MultiPrint(out_stream.str(), out_file_name, write_output);\r\n out_stream.str(string());\r\n\r\n // Converting variables to secondary calculation type\r\n vector>> st_TR_list = ConvertStTRList(T_mat->st_TR_list);\r\n vector>> st_TR_list_rm = ConvertStTRList(T_mat_rm->st_TR_list);\r\n\r\n C_sca(k) = T_mat->st_C_oa->C_sca(0); // st_C_oa->sca should only contain 1 element\r\n C_ext(k) = T_mat->st_C_oa->C_ext(0); // st_C_oa->ext should only contain 1 element\r\n C_abs(k) = T_mat->st_C_oa->C_abs(0); // st_C_oa->abs should only contain 1 element\r\n out_stream.precision(10);\r\n out_stream << \"C_sca \" << C_sca(k) << endl;\r\n out_stream << \"C_ext \" << C_ext(k) << endl;\r\n out_stream << \"C_abs \" << C_abs(k) << endl;\r\n MultiPrint(out_stream.str(), out_file_name, write_output);\r\n out_stream.str(string());\r\n\r\n // Calculating scattering matrix for 2 scattering angles 0 and pi\r\n stSM_list[k] = pstScatteringMatrixOA(st_TR_list, params2->lambda(0), static_cast(C_sca(k)));\r\n\r\n for (int t = 0; t < raman_params2->N_theta_p; t++) {\r\n begin = chrono::steady_clock::now();\r\n Real2 theta_p = raman_params2->theta_p_var(t);\r\n std::array new_dims = {N_r, N_theta, 3};\r\n ArrayXr phi_var = ArrayXr::LinSpaced(N_phi + 1, 0, 2*PI);\r\n\r\n // Calculate field at excitation wavelength\r\n Real2 alpha_p = 0; // Defines the orientation of the electric field, in the plane orthogonal to wavevector k.\r\n params2->inc_par = vshMakeIncidentParams(sIncType::GENERAL, N, theta_p, phi_p, alpha_p);\r\n // Internal field calculations for the incident field defined by stIncPar\r\n unique_ptr> st_abcdnm = rvhGetFieldCoefficients(N, st_TR_list, params2->inc_par);\r\n unique_ptr> st_res_E = pstMakeStructForField(st_abcdnm, params2);\r\n ArrayXXc c_nm = Map>(st_res_E->c_nm.transpose().data(), st_res_E->c_nm.size());\r\n ArrayXXc d_nm = Map>(st_res_E->d_nm.transpose().data(), st_res_E->d_nm.size());\r\n unique_ptr> st_E_surf = vshEgenThetaAllPhi(st_res_E->lambda, st_res_E->epsilon2,\r\n c_nm, d_nm, r_row, theta_row, sBessel::J);\r\n // The field is calculated for a set of phi, from 0 and 2*pi\r\n Tensor4c E_field_z(N_r, N_theta, N_phi + 1, 3);\r\n E_field_z.setZero();\r\n for (int m = 0; m <= N_phi; m++) {\r\n Real2 phi = phi_var(m);\r\n unique_ptr> st_E_for_phi = vshEthetaForPhi(st_E_surf, phi);\r\n long int dims[2] = {st_E_for_phi->E_r.cols(), 3*st_E_for_phi->E_r.rows()};\r\n ArrayXXc E_field_phi(dims[0], dims[1]);\r\n E_field_phi << st_E_for_phi->E_r.matrix().adjoint(),\r\n st_E_for_phi->E_t.matrix().adjoint(), st_E_for_phi->E_f.matrix().adjoint();\r\n E_field_z.chip(m, 2) = TensorCast(E_field_phi).reshape(new_dims);\r\n }\r\n\r\n alpha_p = PI/2; // Internal field calculations for different polarisation alpha_p\r\n params2->inc_par = vshMakeIncidentParams(sIncType::GENERAL, N, theta_p, phi_p, alpha_p);\r\n st_abcdnm = rvhGetFieldCoefficients(N, st_TR_list, params2->inc_par);\r\n st_res_E = pstMakeStructForField(st_abcdnm, params2);\r\n c_nm = Map>(st_res_E->c_nm.transpose().data(), st_res_E->c_nm.size());\r\n d_nm = Map>(st_res_E->d_nm.transpose().data(), st_res_E->d_nm.size());\r\n st_E_surf = vshEgenThetaAllPhi(st_res_E->lambda, st_res_E->epsilon2,\r\n c_nm, d_nm, r_row, theta_row, sBessel::J);\r\n // The field is calculated for a set of phi, from 0 and 2*pi\r\n Tensor4c E_field_y(N_r, N_theta, N_phi + 1, 3);\r\n E_field_y.setZero();\r\n for (int m = 0; m <= N_phi; m++) {\r\n Real2 phi = phi_var(m);\r\n unique_ptr> st_E_for_phi = vshEthetaForPhi(st_E_surf, phi);\r\n long int dims[2] = {st_E_for_phi->E_r.cols(), 3*st_E_for_phi->E_r.rows()};\r\n ArrayXXc E_field_phi(dims[0], dims[1]);\r\n E_field_phi << st_E_for_phi->E_r.matrix().adjoint(),\r\n st_E_for_phi->E_t.matrix().adjoint(), st_E_for_phi->E_f.matrix().adjoint();\r\n E_field_y.chip(m, 2) = TensorCast(E_field_phi).reshape(new_dims);\r\n }\r\n\r\n // Calculate field at Raman wavelength\r\n alpha_p = 0;\r\n params_rm2->inc_par = vshMakeIncidentParams(sIncType::GENERAL, N, theta_p, phi_p, alpha_p);\r\n st_abcdnm = rvhGetFieldCoefficients(N, st_TR_list_rm, params_rm2->inc_par);\r\n st_res_E = pstMakeStructForField(st_abcdnm, params_rm2);\r\n c_nm = Map>(st_res_E->c_nm.transpose().data(), st_res_E->c_nm.size());\r\n d_nm = Map>(st_res_E->d_nm.transpose().data(), st_res_E->d_nm.size());\r\n st_E_surf = vshEgenThetaAllPhi(st_res_E->lambda, st_res_E->epsilon2,\r\n c_nm, d_nm, r_row, theta_row, sBessel::J);\r\n // The field is calculated for a set of phi, from 0 and 2*pi\r\n Tensor4c E_field_rm_z(N_r, N_theta, N_phi + 1, 3);\r\n E_field_rm_z.setZero();\r\n for (int m = 0; m <= N_phi; m++) {\r\n Real2 phi = phi_var(m);\r\n unique_ptr> st_E_for_phi = vshEthetaForPhi(st_E_surf, phi);\r\n long int dims[2] = {st_E_for_phi->E_r.cols(), 3*st_E_for_phi->E_r.rows()};\r\n ArrayXXc E_field_phi(dims[0], dims[1]);\r\n E_field_phi << st_E_for_phi->E_r.matrix().adjoint(),\r\n st_E_for_phi->E_t.matrix().adjoint(), st_E_for_phi->E_f.matrix().adjoint();\r\n E_field_rm_z.chip(m, 2) = TensorCast(E_field_phi).reshape(new_dims);\r\n }\r\n\r\n alpha_p = PI/2;\r\n params_rm2->inc_par = vshMakeIncidentParams(sIncType::GENERAL, N, theta_p, phi_p, alpha_p);\r\n st_abcdnm = rvhGetFieldCoefficients(N, st_TR_list_rm, params_rm2->inc_par);\r\n st_res_E = pstMakeStructForField(st_abcdnm, params_rm2);\r\n c_nm = Map>(st_res_E->c_nm.transpose().data(), st_res_E->c_nm.size());\r\n d_nm = Map>(st_res_E->d_nm.transpose().data(), st_res_E->d_nm.size());\r\n st_E_surf = vshEgenThetaAllPhi(st_res_E->lambda, st_res_E->epsilon2,\r\n c_nm, d_nm, r_row, theta_row, sBessel::J);\r\n // The field is calculated for a set of phi, from 0 and 2*pi\r\n Tensor4c E_field_rm_y(N_r, N_theta, N_phi + 1, 3);\r\n E_field_rm_y.setZero();\r\n for (int m = 0; m <= N_phi; m++) {\r\n Real2 phi = phi_var(m);\r\n unique_ptr> st_E_for_phi = vshEthetaForPhi(st_E_surf, phi);\r\n long int dims[2] = {st_E_for_phi->E_r.cols(), 3*st_E_for_phi->E_r.rows()};\r\n ArrayXXc E_field_phi(dims[0], dims[1]);\r\n E_field_phi << st_E_for_phi->E_r.matrix().adjoint(),\r\n st_E_for_phi->E_t.matrix().adjoint(), st_E_for_phi->E_f.matrix().adjoint();\r\n E_field_rm_y.chip(m, 2) = TensorCast(E_field_phi).reshape(new_dims);\r\n }\r\n\r\n // Calculate scattering cross-sections\r\n std::array dim3 = {3}, dim2 = {2};\r\n Tensor M_tens = 2*PI/N_phi*(E_field_rm_z * TensorConj(E_field_z))\r\n .sum(dim3).abs().pow(static_cast(2.0)).sum(dim2);\r\n Map> M_mat = ArrayMap(M_tens);\r\n ArrayXXr F = M_mat * r_mat.pow(2) * sin(theta_mat);\r\n ArrayXXr intergrand = (F(seq(1, last), seq(1, last)) + F(seq(0, last - 1), seq(1, last)) +\r\n F(seq(1, last), seq(0, last - 1)) + F(seq(0, last - 1), seq(0, last - 1))) / 4 * dt_dr;\r\n sigma_zz(k, h_ind, t) = (intergrand).sum()/(PI*a*a*c*4/3);\r\n\r\n M_tens = 2*PI/N_phi*(E_field_rm_y * TensorConj(E_field_z))\r\n .sum(dim3).abs().pow(static_cast(2.0)).sum(dim2);\r\n M_mat = ArrayMap(M_tens);\r\n F = M_mat * r_mat.pow(2) * sin(theta_mat);\r\n intergrand = (F(seq(1, last), seq(1, last)) + F(seq(0, last - 1), seq(1, last)) +\r\n F(seq(1, last), seq(0, last - 1)) + F(seq(0, last - 1), seq(0, last - 1))) / 4 * dt_dr;\r\n sigma_yz(k, h_ind, t) = (intergrand).sum()/(PI*a*a*c*4/3);\r\n\r\n M_tens = 2*PI/N_phi*(E_field_rm_y * TensorConj(E_field_y))\r\n .sum(dim3).abs().pow(static_cast(2.0)).sum(dim2);\r\n M_mat = ArrayMap(M_tens);\r\n F = M_mat * r_mat.pow(2) * sin(theta_mat);\r\n intergrand = (F(seq(1, last), seq(1, last)) + F(seq(0, last - 1), seq(1, last)) +\r\n F(seq(1, last), seq(0, last - 1)) + F(seq(0, last - 1), seq(0, last - 1))) / 4 * dt_dr;\r\n sigma_yy(k, h_ind, t) = (intergrand).sum()/(PI*a*a*c*4/3);\r\n\r\n M_tens = 2*PI/N_phi*(E_field_rm_z * TensorConj(E_field_y))\r\n .sum(dim3).abs().pow(static_cast(2.0)).sum(dim2);\r\n M_mat = ArrayMap(M_tens);\r\n F = M_mat * r_mat.pow(2) * sin(theta_mat);\r\n intergrand = (F(seq(1, last), seq(1, last)) + F(seq(0, last - 1), seq(1, last)) +\r\n F(seq(1, last), seq(0, last - 1)) + F(seq(0, last - 1), seq(0, last - 1))) / 4 * dt_dr;\r\n sigma_zy(k, h_ind, t) = (intergrand).sum()/(PI*a*a*c*4/3);\r\n\r\n out_stream.precision(5);\r\n out_stream << \"max diameter = \" << max(a, c)*2e-3;\r\n out_stream.precision(10);\r\n out_stream << \" µm, theta = \" << theta_p * 180/PI << \" degrees\" << endl;\r\n out_stream.precision(11);\r\n out_stream << \"--- relative raman zz = \" << sigma_zz(k, h_ind, t) << endl;\r\n out_stream << \"--- relative raman yz = \" << sigma_yz(k, h_ind, t) << endl;\r\n out_stream << \"--- relative raman zy = \" << sigma_zy(k, h_ind, t) << endl;\r\n out_stream << \"--- relative raman yy = \" << sigma_yy(k, h_ind, t) << endl;\r\n\r\n end = chrono::steady_clock::now();\r\n elapsed_seconds = end - begin;\r\n out_stream << elapsed_seconds.count() << endl;\r\n\r\n MultiPrint(out_stream.str(), out_file_name, write_output);\r\n out_stream.str(string());\r\n }\r\n }\r\n }\r\n}\r\n\r\n#endif\r\n", "meta": {"hexsha": "ebcb02b9f48ea740367b50ee9289d7d1d8cc655d", "size": 33991, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/raman_elastic_scattering.hpp", "max_stars_repo_name": "Kirbologist/Raman-Scattering-Code-Conversion", "max_stars_repo_head_hexsha": "118a08238a2525f595c4b7d2b735dd37852fac6f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2022-01-09T12:41:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-09T12:41:22.000Z", "max_issues_repo_path": "src/raman_elastic_scattering.hpp", "max_issues_repo_name": "Kirbologist/Raman-Scattering-Code-Conversion", "max_issues_repo_head_hexsha": "118a08238a2525f595c4b7d2b735dd37852fac6f", "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/raman_elastic_scattering.hpp", "max_forks_repo_name": "Kirbologist/Raman-Scattering-Code-Conversion", "max_forks_repo_head_hexsha": "118a08238a2525f595c4b7d2b735dd37852fac6f", "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": 49.4774381368, "max_line_length": 120, "alphanum_fraction": 0.6658527257, "num_tokens": 9951, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125737597972, "lm_q2_score": 0.5964331462646255, "lm_q1q2_score": 0.4485252253981146}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \"cpp-btree/btree_map.h\"\n//---------------------------------------------------------------------------\ntypedef std::pair Coord;\ntypedef std::pair segCoord;\ntypedef btree::btree_map btree_map;\ntypedef btree::btree_map btree_map_segments;\n//---------------------------------------------------------------------------\nclass SplineEvaluation;\n//---------------------------------------------------------------------------\n/// A linear spline for evaluation\nclass SplineEvaluation \n{\n private:\n static const unsigned countOfBuckets = 2 + 1;\n static const unsigned limitSplineSize = 100000;\n int32_t offset;\n int32_t length;\n \n void transformSpline();\n double selfInterpolate(unsigned segment, double& x) const;\n unsigned searchLeft(int segment, double& x) const;\n unsigned searchRight(int segment, double& x) const;\n unsigned binarySearch(unsigned lower, unsigned upper, double& x) const;\n void changeIntoArray(long double** moveHere, boost::math::tools::polynomial poly);\n void convertValues();\n void splitSegmentSpline();\n public:\n static const unsigned polyGrade = 2;\n /// Constructor\n SplineEvaluation();\n /// Deconstructor\n ~SplineEvaluation();\n /// Constructor with the function\n SplineEvaluation(const std::vector& function, unsigned desiredSize, const unsigned useSplineMode, const unsigned searchMode, const unsigned testMode);\n /// Constructor with given data\n SplineEvaluation(unsigned size, const double* x, const double* y);\n\n void save(std::ofstream& file_out);\n void load(std::ifstream& file_in);\n \n unsigned size() const;\n unsigned findExactSegment(double segment, double& x) const;\n /// Return the approximate value of function(x)\n double evaluate(double& x) const;\n double hornerEvaluate(double& x) const;\n \n double splittedHornerEvaluate(double& x) const;\n double hornerEvaluateByBuckets(unsigned bucketIndex, double& x) const; \n\n double chebyshevEvaluate(double& x) const;\n double splittedChebyshevEvaluate(double& x) const;\n \n double mapEvaluate(double& x) const;\n std::map coordinates;\n \n double btreeEvaluate(double& x) const;\n btree_map* btreeMap;\n \n double btreeSegmentsEvaluate(double& x) const;\n btree_map_segments* btreeSegments;\n \n std::vector spline;\n /// Spline which has to be fitted\n std::vector segmentSpline;\n /// Fitted polynomial to the spline\n long double* poly;\n double* values;\n unsigned splineSize;\n \n std::vector* splineBuckets;\n long double **polyBuckets;\n double splittedPositions[countOfBuckets];\n __m128d saveLimits;\n \n /// Fit a polynomial to spline\n boost::math::tools::polynomial fitSpline(const std::vector& spline);\n};\n//---------------------------------------------------------------------------\n\n", "meta": {"hexsha": "a6c1d7aba9f9becb73e9b4a50d96f3fee7a3ec5f", "size": 3108, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "SplineEvaluation.hpp", "max_stars_repo_name": "stoianmihail/Planet", "max_stars_repo_head_hexsha": "c1869fbab7a57ca635830ea478d85070763aba9a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2020-09-13T11:39:44.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-11T19:45:00.000Z", "max_issues_repo_path": "SplineEvaluation.hpp", "max_issues_repo_name": "Alexie81/Planet", "max_issues_repo_head_hexsha": "c1869fbab7a57ca635830ea478d85070763aba9a", "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": "SplineEvaluation.hpp", "max_forks_repo_name": "Alexie81/Planet", "max_forks_repo_head_hexsha": "c1869fbab7a57ca635830ea478d85070763aba9a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-09-13T11:39:46.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-13T11:39:46.000Z", "avg_line_length": 36.5647058824, "max_line_length": 161, "alphanum_fraction": 0.6454311454, "num_tokens": 677, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125737597972, "lm_q2_score": 0.5964331462646255, "lm_q1q2_score": 0.4485252253981146}} {"text": "/*\n * convnn.cpp\n *\n */\n#include \n\n#include \n\n#include \"core/utils.h\"\n#include \"core/functions.h\"\n#include \"layers/contlayer.h\"\n#include \"layers/convlayer.h\"\n#include \"layers/fclayer.h\"\n#include \"layers/polllayer.h\"\n#include \"layers/smaxlayer.h\"\n\n#include \"cnn.h\"\n\nusing namespace std;\nusing namespace yann;\n\n\n////////////////////////////////////////////////////////////////////////////////////////////////\n//\n// ConvolutionalNetwork implementation\n//\nyann::ConvolutionalNetwork::ConvPollParams::ConvPollParams() :\n _output_frames_num(0),\n _conv_filter_size(0),\n _polling_mode(PollingLayer::PollMode_Avg),\n _polling_filter_size(0)\n{\n}\n\nvoid yann::ConvolutionalNetwork::append(unique_ptr & container,\n const MatrixSize & input_rows,\n const MatrixSize & input_cols,\n const MatrixSize & input_frames_num,\n const ConvPollParams & params)\n{\n YANN_CHECK(container);\n YANN_CHECK_GT(input_rows, 0);\n YANN_CHECK_GT(input_cols, 0);\n YANN_CHECK_GT(input_frames_num, 0);\n YANN_CHECK(input_frames_num == 1 || !params._mappings.empty());\n YANN_CHECK_GT(params._output_frames_num, 0 || !params._mappings.empty());\n YANN_CHECK_GT(params._conv_filter_size, 0);\n YANN_CHECK_GT(params._polling_filter_size, 0);\n\n // ConvolutionalLayer\n if(input_frames_num == 1) {\n auto conv_bcast_layer = ConvolutionalLayer::create_conv_bcast_layer(\n params._output_frames_num, // N output frames\n input_rows,\n input_cols,\n params._conv_filter_size,\n params._conv_activation_funtion\n );\n YANN_CHECK(conv_bcast_layer);\n container->append_layer(std::move(conv_bcast_layer));\n } else {\n YANN_CHECK(!params._mappings.empty());\n YANN_CHECK(params._output_frames_num == 0 || params._output_frames_num == params._mappings.size());\n\n auto conv_mapping_layer = make_unique(input_frames_num);\n YANN_CHECK(conv_mapping_layer);\n for(auto & layer_mappings : params._mappings) {\n auto conv_layer = make_unique(\n input_rows,\n input_cols,\n params._conv_filter_size);\n YANN_CHECK(conv_layer);\n\n if(params._conv_activation_funtion) {\n conv_layer->set_activation_function(params._conv_activation_funtion);\n }\n conv_mapping_layer->append_layer(std::move(conv_layer), layer_mappings);\n }\n container->append_layer(std::move(conv_mapping_layer));\n }\n\n // PollingLayer\n MatrixSize poll_input_rows = ConvolutionalLayer::get_conv_output_rows(input_rows, params._conv_filter_size);\n MatrixSize poll_input_cols = ConvolutionalLayer::get_conv_output_cols(input_cols, params._conv_filter_size);\n auto poll_layer = PollingLayer::create_poll_parallel_layer(\n params._output_frames_num,\n poll_input_rows,\n poll_input_cols,\n params._polling_filter_size,\n params._polling_mode,\n params._polling_activation_funtion);\n YANN_CHECK(poll_layer);\n container->append_layer(std::move(poll_layer));\n}\n\nunique_ptr yann::ConvolutionalNetwork::create(\n const MatrixSize & input_rows,\n const MatrixSize & input_cols,\n const ConvPollParams & params,\n const std::unique_ptr & fc_activation_funtion,\n const MatrixSize & output_size)\n{\n YANN_CHECK_GT(output_size, 0);\n\n auto container = make_unique();\n YANN_CHECK(container);\n\n // append one layer: we have 1 input frame\n append(container, input_rows, input_cols, 1, params);\n\n // FullyConnectedLayer\n auto fc_layer = make_unique(\n container->get_output_size(),\n output_size);\n YANN_CHECK(fc_layer);\n if(fc_activation_funtion) {\n fc_layer->set_activation_function(fc_activation_funtion);\n }\n container->append_layer(std::move(fc_layer));\n\n // done\n return container;\n}\n\nstd::unique_ptr yann::ConvolutionalNetwork::create(\n const MatrixSize & input_rows,\n const MatrixSize & input_cols,\n const ConvPollParams & params1,\n const ConvPollParams & params2,\n const std::unique_ptr & fc_activation_funtion,\n const MatrixSize & output_size)\n{\n YANN_CHECK_GT(output_size, 0);\n\n auto container = make_unique();\n YANN_CHECK(container);\n\n // append one layer: we have 1 input frame\n append(container, input_rows, input_cols, 1, params1);\n\n // append second layer: the output frames from first layer are our inputs\n MatrixSize poll1_input_rows = ConvolutionalLayer::get_conv_output_rows(input_rows, params1._conv_filter_size);\n MatrixSize poll1_input_cols = ConvolutionalLayer::get_conv_output_cols(input_cols, params1._conv_filter_size);\n MatrixSize conv2_input_rows = PollingLayer::get_output_rows(poll1_input_rows, params1._polling_filter_size);\n MatrixSize conv2_input_cols = PollingLayer::get_output_cols(poll1_input_cols, params1._polling_filter_size);\n append(container, conv2_input_rows, conv2_input_cols, params1._output_frames_num, params2);\n\n // FullyConnectedLayer\n auto fc_layer = make_unique(\n container->get_output_size(),\n output_size);\n YANN_CHECK(fc_layer);\n if(fc_activation_funtion) {\n fc_layer->set_activation_function(fc_activation_funtion);\n }\n container->append_layer(std::move(fc_layer));\n\n // done\n return container;\n}\n\nstd::unique_ptr yann::ConvolutionalNetwork::create_lenet1(\n const MatrixSize & input_rows,\n const MatrixSize & input_cols,\n PollingLayer::Mode polling_mode,\n const MatrixSize & fc_size,\n const MatrixSize & output_size,\n const std::unique_ptr & conv_activation_funtion,\n const std::unique_ptr & poll_activation_funtion,\n const std::unique_ptr & fc_activation_funtion)\n{\n // see http://yann.lecun.com/exdb/publis/pdf/lecun-90c.pdf\n ConvPollParams params1;\n params1._output_frames_num = 4;\n params1._conv_filter_size = 5;\n if(conv_activation_funtion) {\n params1._conv_activation_funtion = conv_activation_funtion->copy();\n }\n params1._polling_mode = polling_mode;\n params1._polling_filter_size = 2;\n if(poll_activation_funtion) {\n params1._polling_activation_funtion = poll_activation_funtion->copy();\n }\n\n ConvPollParams params2;\n params2._output_frames_num = 12;\n params2._conv_filter_size = 5;\n if(conv_activation_funtion) {\n params2._conv_activation_funtion = conv_activation_funtion->copy();\n }\n params2._polling_mode = polling_mode;\n params2._polling_filter_size = 2;\n if(poll_activation_funtion) {\n params2._polling_activation_funtion = poll_activation_funtion->copy();\n }\n params2._mappings.push_back({ 0 });\n params2._mappings.push_back({ 0, 1 });\n params2._mappings.push_back({ 0, 1 });\n params2._mappings.push_back({ 1 });\n params2._mappings.push_back({ 0, 1 });\n params2._mappings.push_back({ 0, 1 });\n params2._mappings.push_back({ 2 });\n params2._mappings.push_back({ 2, 3 });\n params2._mappings.push_back({ 2, 3 });\n params2._mappings.push_back({ 3 });\n params2._mappings.push_back({ 2, 3 });\n params2._mappings.push_back({ 2, 3 });\n\n auto container = create(\n input_rows, input_cols, params1, params2,\n fc_activation_funtion, fc_size > 0 ? fc_size : output_size);\n YANN_CHECK(container);\n\n // add one more FC layer if needed\n if(fc_size > 0) {\n auto fc_layer = make_unique(fc_size, output_size);\n YANN_CHECK(fc_layer);\n if(fc_activation_funtion) {\n fc_layer->set_activation_function(fc_activation_funtion);\n }\n container->append_layer(std::move(fc_layer));\n }\n\n // done\n return container;\n}\n\nstd::unique_ptr yann::ConvolutionalNetwork::create_boosted_lenet1(\n const MatrixSize & paths_num,\n const MatrixSize & input_rows,\n const MatrixSize & input_cols,\n PollingLayer::Mode polling_mode,\n const MatrixSize & fc_size,\n const MatrixSize & output_size,\n const std::unique_ptr & conv_activation_funtion,\n const std::unique_ptr & poll_activation_funtion,\n const std::unique_ptr & fc_activation_funtion)\n{\n // create N paths\n auto bcast_layer = make_unique();\n YANN_CHECK(bcast_layer);\n for(auto ii = paths_num; ii > 0; --ii) {\n auto path = create_lenet1(\n input_rows, input_cols, polling_mode,\n 0, fc_size, // don't create fc layer, we will add one for the merge\n conv_activation_funtion, poll_activation_funtion,\n fc_activation_funtion);\n YANN_CHECK(path);\n bcast_layer->append_layer(std::move(path));\n }\n\n // merge them together\n auto fc_layer = make_unique(paths_num * fc_size, output_size);\n YANN_CHECK(fc_layer);\n fc_layer->set_activation_function(fc_activation_funtion);\n\n // and finally create container\n auto container = make_unique();\n YANN_CHECK(container);\n container->append_layer(std::move(bcast_layer));\n container->append_layer(std::move(fc_layer));\n\n // done\n return container;\n}\n\nstd::unique_ptr yann::ConvolutionalNetwork::create_lenet5(\n const MatrixSize & input_rows,\n const MatrixSize & input_cols,\n PollingLayer::Mode polling_mode,\n const MatrixSize & fc1_size,\n const MatrixSize & fc2_size,\n const MatrixSize & output_size,\n const std::unique_ptr & conv_activation_funtion,\n const std::unique_ptr & poll_activation_funtion,\n const std::unique_ptr & fc_activation_funtion)\n{\n // see http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf\n ConvPollParams params1;\n params1._output_frames_num = 6;\n params1._conv_filter_size = 5;\n if(conv_activation_funtion) {\n params1._conv_activation_funtion = conv_activation_funtion->copy();\n }\n params1._polling_mode = polling_mode;\n params1._polling_filter_size = 2;\n if(poll_activation_funtion) {\n params1._polling_activation_funtion = poll_activation_funtion->copy();\n }\n\n ConvPollParams params2;\n params2._output_frames_num = 16;\n params2._conv_filter_size = 5;\n if(conv_activation_funtion) {\n params2._conv_activation_funtion = conv_activation_funtion->copy();\n }\n params2._polling_mode = polling_mode;\n params2._polling_filter_size = 2;\n if(poll_activation_funtion) {\n params2._polling_activation_funtion = poll_activation_funtion->copy();\n }\n params2._mappings.push_back({ 0, 1, 2 }); // 0\n params2._mappings.push_back({ 1, 2, 3 });\n params2._mappings.push_back({ 2, 3, 4 });\n params2._mappings.push_back({ 3, 4, 5 });\n params2._mappings.push_back({ 0, 4, 5 }); // 4\n params2._mappings.push_back({ 0, 1, 5 });\n params2._mappings.push_back({ 0, 1, 2, 3 });\n params2._mappings.push_back({ 1, 2, 3, 4 });\n params2._mappings.push_back({ 2, 3, 4, 5 }); // 8\n params2._mappings.push_back({ 0, 3, 4, 5 });\n params2._mappings.push_back({ 0, 1, 4, 5 });\n params2._mappings.push_back({ 0, 1, 2, 5 });\n params2._mappings.push_back({ 0, 1, 3, 4 }); // 12\n params2._mappings.push_back({ 1, 2, 4, 5 });\n params2._mappings.push_back({ 0, 2, 3, 5 });\n params2._mappings.push_back({ 0, 1, 2, 3, 4, 5 });\n\n auto container = create(input_rows, input_cols, params1, params2, fc_activation_funtion, fc1_size);\n YANN_CHECK(container);\n\n // add one more FC layer\n auto fc_layer1 = make_unique(fc1_size, fc2_size);\n YANN_CHECK(fc_layer1);\n if(fc_activation_funtion) {\n fc_layer1->set_activation_function(fc_activation_funtion);\n }\n container->append_layer(std::move(fc_layer1));\n\n // and one more FC layer\n auto fc_layer2 = make_unique(fc2_size, output_size);\n YANN_CHECK(fc_layer2);\n if(fc_activation_funtion) {\n fc_layer2->set_activation_function(fc_activation_funtion);\n }\n container->append_layer(std::move(fc_layer2));\n\n // done\n return container;\n}\n\n\n", "meta": {"hexsha": "c31be6bc1675f86feffcc59de0a2d07c1dbcf281", "size": 11914, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/networks/cnn.cpp", "max_stars_repo_name": "lsh123/yann", "max_stars_repo_head_hexsha": "4a12b7c1ee2d89d34772d647586b3018df6997db", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2019-08-22T18:14:44.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-01T10:25:07.000Z", "max_issues_repo_path": "src/networks/cnn.cpp", "max_issues_repo_name": "lsh123/yann", "max_issues_repo_head_hexsha": "4a12b7c1ee2d89d34772d647586b3018df6997db", "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/networks/cnn.cpp", "max_forks_repo_name": "lsh123/yann", "max_forks_repo_head_hexsha": "4a12b7c1ee2d89d34772d647586b3018df6997db", "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.7346938776, "max_line_length": 112, "alphanum_fraction": 0.7313244922, "num_tokens": 3201, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.766293653760418, "lm_q2_score": 0.5851011542032312, "lm_q1q2_score": 0.4483593012738318}} {"text": "#include \"stdafx.h\"\n#include \"NRSolver.h\"\n#include \"PrimitiveNetwork.h\"\n#include \"Exceptions.h\"\n#include \n#include \n\nusing Eigen::Triplet;\nusing Eigen::SparseLU;\nusing Eigen::SparseQR;\nusing Eigen::SparseMatrix;\n\nusing namespace std;\nusing namespace PowerSolutions::ObjectModel;\n\nnamespace PowerSolutions\n{\n\tnamespace PowerFlow\n\t{\n\n\t\tNRSolver::NRSolver()\n\t\t{ }\n\n\t\tNRSolver::~NRSolver()\n\t\t{ }\n\n\t\tvoid NRSolver::BeforeIterations()\n\t\t{\n\t\t\tassert(Block1EquationCount() == PQNodeCount + PVNodeCount);\n\t\t\tassert(EquationCount() == PQNodeCount * 2 + PVNodeCount);\n\t\t\t//PQ节点：[dP dQ] = J * [V theta]\n\t\t\t//PV节点：[dP] = J * [theta]\n\t\t\t// PQ/PV | PQ\n\t\t\t//Δy = [dP ... dP | dQ ... dQ] = ConstraintPower - CurrentPower\n\t\t\t//Δx = [theta ... theta | V ... V]\n\t\t\t// 分界线/起始索引：\n\t\t\t// H[0,0], N[NodeCount - 1, 0]\n\t\t\t//初始化矩阵维数\n\t\t\t//注意向量需要手动清零\n\t\t\tConstraintPowerInjection.resize(EquationCount());\n\t\t\tCurrentAnswer.resize(EquationCount());\n\t\t\tCorrectionAnswer.resize(EquationCount());\n\t\t\tPowerInjectionDeviation.resize(EquationCount());\n\t\t\t//估计雅可比矩阵非零元的数量\n\t\t\t//按照最不理想的情况来考虑雅可比矩阵的空间\n\t\t\tJocobianReservedValuesCount = 0;\n\t\t\tfor (int n = 0; n < Block1EquationCount(); n++)\n\t\t\t{\n\t\t\t\tauto& node = PNetwork->Nodes(n);\n\t\t\t\tJocobianReservedValuesCount += min(node.Degree() * 2, EquationCount());\n\t\t\t\tif (node.Type() == NodeType::PQNode)\n\t\t\t\t{\n\t\t\t\t\tJocobianReservedValuesCount += min(node.Degree() * 2, EquationCount());\n\t\t\t\t}\n\t\t\t}\n\t\t\tJocobian.resize(EquationCount(), EquationCount());\n\n\t\t\t//生成目标注入功率向量 y，以及迭代初值向量。\n\t\t\tfor (auto& node : PNetwork->Nodes())\n\t\t\t{\n\t\t\t\tif (node->Type() != NodeType::SlackNode)\n\t\t\t\t{\n\t\t\t\t\tint subIndex = Block1EquationCount() + node->SubIndex();\n\t\t\t\t\tConstraintPowerInjection(node->Index()) = node->ActivePowerInjection();\n\t\t\t\t\tCurrentAnswer(node->Index()) = arg(node->Bus()->InitialVoltage());\n\t\t\t\t\tif (node->Type() == NodeType::PQNode)\n\t\t\t\t\t{\n\t\t\t\t\t\tConstraintPowerInjection(subIndex) = node->ReactivePowerInjection();\n\t\t\t\t\t\tCurrentAnswer(subIndex) = abs(node->Bus()->InitialVoltage());\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\t_PS_TRACE(\"目标函数值 Y ==========\");\n\t\t\t_PS_TRACE(ConstraintPowerInjection);\n\t\t}\n\n\t\tpair NRSolver::EvalDeviation()\n\t\t{\n\t\t\tEvalPowerInjection();\n\t\t\t//注意，最小系数不一定是绝对值最小的系数\n\t\t\tint row;\n\t\t\tdouble dev;\n\t\t\tdev = PowerInjectionDeviation.cwiseAbs().maxCoeff(&row);\n\t\t\tif (row < Block1EquationCount())\n\t\t\t\treturn make_pair(&PNetwork->Nodes(row), dev);\n\t\t\telse\n\t\t\t\treturn make_pair(&PNetwork->PQNodes(row - Block1EquationCount()), dev);\n\t\t}\n\n\t\tbool NRSolver::OnIteration()\n\t\t{\n\t\t\tGenerateJacobian();\n\t\t\tif (!GenerateNextAnswer()) return false;\n\t\t\treturn true;\n\t\t}\n\n\t\tvoid NRSolver::AfterIterations()\n\t\t{\n\t\t\tfor (int i = 0; i < NodeCount; i++)\n\t\t\t\tUpdateNodeStatus(i);\n\t\t}\n\n\t\tinline double NRSolver::NodeVoltage(int NodeIndex)\n\t\t{\n\t\t\tauto& node = PNetwork->Nodes(NodeIndex);\n\t\t\tif (node.Type() == NodeType::PQNode)\n\t\t\t\treturn CurrentAnswer(Block1EquationCount() + node.SubIndex());\n\t\t\telse\n\t\t\t\treturn node.Voltage();\n\t\t}\n\n\t\tinline double NRSolver::NodeAngle(int NodeIndex)\n\t\t{\n\t\t\tassert(NodeIndex < NodeCount);\n\t\t\t//注意此处区分平衡节点。\n\t\t\treturn NodeIndex < NodeCount - 1 ? CurrentAnswer(NodeIndex) : 0;\n\t\t}\n\n\t\tvoid NRSolver::EvalPowerInjection()\n\t\t{\n\t\t\t//TODO 计入导纳矩阵可能的不对称性\n\t\t\t//计算各节点的实际注入功率，以及功率偏差 PowerInjectionDeviation\n\t\t\tPowerInjectionDeviation = ConstraintPowerInjection;\n\t\t\tfor (auto& node : PSolution->NodeStatus()) node.ClearPowerInjection();\n\t\t\t//遍历所有节点，包括平衡节点\n\t\t\t//此处使用 for 而非 for-each 是为了与数学表达保持一致\n\t\t\tauto &Admittance = PNetwork->Admittance;\n\t\t\tfor (int m = 0; m < NodeCount; m++)\n\t\t\t{\n\t\t\t\tauto &statusM = PSolution->NodeStatus(m);\n\t\t\t\tauto Um = NodeVoltage(m);\n\t\t\t\tauto thetaM = NodeAngle(m);\n\t\t\t\tint subM = Block1EquationCount() + statusM.SubIndex();\n\t\t\t\t//计算导纳矩阵中非对角元素对应的功率。\n\t\t\t\tfor (int n = m + 1; n < NodeCount; n++)\n\t\t\t\t{\n\t\t\t\t\t// 导纳矩阵是上三角矩阵，row < col\n\t\t\t\t\t// TODO 取消对导纳矩阵对称的假定（移相变压器）。\n\t\t\t\t\tcomplexd Y = Admittance.coeff(m, n);\n\t\t\t\t\tcomplexd Y1 = Admittance.coeff(n, m);\n\t\t\t\t\t//if (abs(Y) < 1e-10) continue;\n\t\t\t\t\tauto UmUn = Um * NodeVoltage(n);\n\t\t\t\t\tauto thetaMn = thetaM - NodeAngle(n);\n\t\t\t\t\tauto sinMn = sin(thetaMn);\n\t\t\t\t\tauto cosMn = cos(thetaMn);\n\t\t\t\t\tauto &statusN = PSolution->NodeStatus(n);\n\t\t\t\t\t//累计上一次迭代结果对应的注入功率\n\t\t\t\t\tstatusM.AddPowerInjections(UmUn * (Y.real() * cosMn + Y.imag() * sinMn),\n\t\t\t\t\t\tUmUn * (Y.real() * sinMn - Y.imag() * cosMn));\n\t\t\t\t\tstatusN.AddPowerInjections(UmUn * (Y1.real() * cosMn - Y1.imag() * sinMn),\n\t\t\t\t\t\tUmUn * (-Y1.real() * sinMn - Y1.imag() * cosMn));\n\t\t\t\t}\n\t\t\t\t//计算导纳矩阵中对角元素对应的功率。\n\t\t\t\tauto UmSqr = Um * Um;\n\t\t\t\tauto Y = Admittance.coeff(m, m);\n\t\t\t\tstatusM.AddPowerInjections(UmSqr * Y.real(), -UmSqr * Y.imag());\n\t\t\t\t//生成功率偏差向量 Δy'\n\t\t\t\tif (statusM.Type() != NodeType::SlackNode)\n\t\t\t\t{\n\t\t\t\t\tPowerInjectionDeviation(m) -= statusM.ActivePowerInjection();\n\t\t\t\t\tif (statusM.Type() == NodeType::PQNode)\n\t\t\t\t\t\tPowerInjectionDeviation(subM) -= statusM.ReactivePowerInjection();\n\t\t\t\t}\n\t\t\t}\n\t\t\t_PS_TRACE(\"平衡节点 ======\");\n\t\t\t_PS_TRACE(\"有功注入：\" << PSolution->NodeStatus(NodeCount - 1).ActivePowerInjection());\n\t\t\t_PS_TRACE(\"无功注入：\" << PSolution->NodeStatus(NodeCount - 1).ReactivePowerInjection());\n\t\t\t_PS_TRACE(\"偏差 deltaY ==========\");\n\t\t\t_PS_TRACE(PowerInjectionDeviation);\n\t\t}\n\t\t\n\t\tvoid NRSolver::GenerateJacobian()\n\t\t{\n\t\t\t//PQ节点：[dP dQ] = J * [V theta]\n\t\t\t//PV节点：[dP] = J * [theta]\n\t\t\t// PQ/PV PQ\n\t\t\t//Δy = [dP ... dP dQ ... dQ]\n\t\t\t//Δx = [theta ... theta V ... V]\n\t\t\t// / H | N \\\n\t\t\t//J = | --+-- |\n\t\t\t// \\ M | L /\n\t\t\t// 起始索引：（注意排除平衡节点）\n\t\t\t// H[0,0], N[NodeCount - 1, 0]\n\t\t\t// M[NodeCount - 1, 0], L[..., ...]\n\t\t\t// 对非对角元有\n\t\t\t// H = L\n\t\t\t// N = -M\n\t\t\tauto& Admittance = PNetwork->Admittance;\n\t\t\t// 雅可比矩阵非零元。\n\t\t\tvector> values;\n\t\t\tvalues.reserve(JocobianReservedValuesCount);\n\t\t\t// 建议使用 Triplet 构造矩阵，可以取得不错的性能，而且生成的矩阵是压缩过的。\n\t\t\tfor (int outer = 0; outer < Admittance.outerSize(); outer++)\n\t\t\t\tfor (SparseMatrix::InnerIterator it(Admittance, outer); it; ++it)\n\t\t\t\t{\n\t\t\t\t\tauto m = it.row();\n\t\t\t\t\tauto n = it.col();\n\t\t\t\t\t// 注意排除平衡节点\n\t\t\t\t\tif (m == NodeCount - 1 || n == NodeCount - 1) \n\t\t\t\t\t\tcontinue;\n\t\t\t\t\tauto& nodeM = PSolution->NodeStatus(m);\n\t\t\t\t\tauto Um = NodeVoltage(m);\n\t\t\t\t\tauto thetaM = NodeAngle(m);\n\t\t\t\t\tauto subM = Block1EquationCount() + nodeM.SubIndex();\n\t\t\t\t\t//计算非对角元素\n\t\t\t\t\tif (n > m)\n\t\t\t\t\t{\n\t\t\t\t\t\tcomplexd Ymn = it.value();\n\t\t\t\t\t\tcomplexd Ynm = it.value();\n\t\t\t\t\t\tdouble UmUn = Um * NodeVoltage(n);\n\t\t\t\t\t\tdouble thetaMn = thetaM - NodeAngle(n);\n\t\t\t\t\t\tdouble sinMn = sin(thetaMn);\n\t\t\t\t\t\tdouble cosMn = cos(thetaMn);\n\t\t\t\t\t\t//H(m,n)\n\t\t\t\t\t\tdouble H = -UmUn * (Ymn.real() * sinMn - Ymn.imag() * cosMn);\n\t\t\t\t\t\tvalues.emplace_back(m, n, H);\n\t\t\t\t\t\t//H(n,m)\n\t\t\t\t\t\tdouble Hp = UmUn * (Ynm.real() * sinMn + Ynm.imag() * cosMn);\n\t\t\t\t\t\tvalues.emplace_back(n, m, Hp);\n\t\t\t\t\t\t//i.e. H(n,m) = -UmUn * (-Y.real() * sinMn - Y.imag() * cosMn)\n\t\t\t\t\t\t//N\n\t\t\t\t\t\tdouble N = -UmUn * (Ymn.real() * cosMn + Ymn.imag() * sinMn);\n\t\t\t\t\t\tdouble Np = -UmUn * (Ynm.real() * cosMn - Ynm.imag() * sinMn);\n\t\t\t\t\t\t//cout << \"::\" << m << \",\" << n << \" = \" << Jocobian.insert(1, 0) << endl;\n\t\t\t\t\t\tauto& nodeN = PSolution->NodeStatus(n);\n\t\t\t\t\t\tint subN = Block1EquationCount() + nodeN.SubIndex();\n\t\t\t\t\t\tif (nodeM.Type() == NodeType::PQNode)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tif (nodeN.Type() == NodeType::PQNode)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t//PQ-PQ，子阵具有对称性\n\t\t\t\t\t\t\t\t// N\n\t\t\t\t\t\t\t\tvalues.emplace_back(m, subN, N);\n\t\t\t\t\t\t\t\tvalues.emplace_back(n, subM, Np);\n\t\t\t\t\t\t\t\t// M = -N\n\t\t\t\t\t\t\t\tvalues.emplace_back(subM, n, -N);\n\t\t\t\t\t\t\t\tvalues.emplace_back(subN, m, -Np);\n\t\t\t\t\t\t\t\t// L = H\n\t\t\t\t\t\t\t\tvalues.emplace_back(subM, subN, H);\n\t\t\t\t\t\t\t\tvalues.emplace_back(subN, subM, Hp);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\telse {\n\t\t\t\t\t\t\t\t//PQ-PV（m,n）\n\t\t\t\t\t\t\t\t// M = -N\n\t\t\t\t\t\t\t\tvalues.emplace_back(subM, n, -N);\n\t\t\t\t\t\t\t\t//PV-PQ（n,m）\n\t\t\t\t\t\t\t\t// N\n\t\t\t\t\t\t\t\tvalues.emplace_back(n, subM, Np);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\tif (nodeN.Type() == NodeType::PQNode)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t//PV-PQ（m,n）\n\t\t\t\t\t\t\t\t// N\n\t\t\t\t\t\t\t\tvalues.emplace_back(m, subN, N);\n\t\t\t\t\t\t\t\t//PQ-PV（n,m）\n\t\t\t\t\t\t\t\t// M\n\t\t\t\t\t\t\t\tvalues.emplace_back(subN, m, -Np);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\telse if (n == m)\n\t\t\t\t\t{\n\t\t\t\t\t\tcomplexd Y = it.value();\n\t\t\t\t\t\tdouble UmSqr = Um * Um;\n\t\t\t\t\t\t//计算对角元素\n\t\t\t\t\t\t//H\n\t\t\t\t\t\tvalues.emplace_back(m, m, UmSqr * Y.imag() + nodeM.ReactivePowerInjection());\n\t\t\t\t\t\tif (nodeM.Type() == NodeType::PQNode)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t//N\n\t\t\t\t\t\t\tvalues.emplace_back(m, subM, -UmSqr * Y.real() - nodeM.ActivePowerInjection());\n\t\t\t\t\t\t\t//M\n\t\t\t\t\t\t\tvalues.emplace_back(subM, m, UmSqr * Y.real() - nodeM.ActivePowerInjection());\n\t\t\t\t\t\t\t//L\n\t\t\t\t\t\t\tvalues.emplace_back(subM, subM, UmSqr * Y.imag() - nodeM.ReactivePowerInjection());\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\tJocobian.setFromTriplets(values.begin(), values.end());\n\t\t\t_PS_TRACE(\"雅可比矩阵 ==========\");\n\t\t\t_PS_TRACE(Jocobian);\n\t\t}\n\n\t\tbool NRSolver::GenerateNextAnswer()\n\t\t{\n\t\t\tSparseLU> solver;\n\t\t\t//求解矩阵方程\n\t\t\tJocobian.makeCompressed();\n\t\t\tsolver.compute(Jocobian);\n\t\t\tif (solver.info() != Eigen::Success) return false;\n\t\t\tCorrectionAnswer = solver.solve(PowerInjectionDeviation);\n\t\t\tif (solver.info() != Eigen::Success) return false;\n\t\t\t//计算新的结果\n\t\t\t//注意到 Δy = -J Δx\n\t\t\t//而此处实际解的方程组为 Δy' = J Δx\n\t\t\t//也就是说，Δy = -Δy'\n\t\t\t//Δx = [theta ... theta V ... V]\n\t\t\tCurrentAnswer.head(Block1EquationCount()) -= CorrectionAnswer.head(Block1EquationCount());\n\t\t\tCurrentAnswer.tail(Block2EquationCount()) -= CurrentAnswer.tail(Block2EquationCount()).cwiseProduct(CorrectionAnswer.tail(Block2EquationCount()));\n\t\t\t_PS_TRACE(\"当前解向量 ==========\");\n\t\t\t_PS_TRACE(CurrentAnswer);\n\t\t\treturn true;\n\t\t}\n\t}\n}\n", "meta": {"hexsha": "94340036d75ae60eb5be64fa1934febb6d0d0a0b", "size": 9461, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "PowerSolutions.PowerFlow/NRSolver.cpp", "max_stars_repo_name": "CXuesong/PowerFlowSolver", "max_stars_repo_head_hexsha": "20dc3a02fed7f78011949eaa99df546681f28683", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2020-09-02T07:43:12.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-11T22:54:57.000Z", "max_issues_repo_path": "PowerSolutions.PowerFlow/NRSolver.cpp", "max_issues_repo_name": "CXuesong/PowerFlowSolver", "max_issues_repo_head_hexsha": "20dc3a02fed7f78011949eaa99df546681f28683", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2020-09-02T07:44:58.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-05T15:54:44.000Z", "max_forks_repo_path": "PowerSolutions.PowerFlow/NRSolver.cpp", "max_forks_repo_name": "CXuesong/PowerFlowSolver", "max_forks_repo_head_hexsha": "20dc3a02fed7f78011949eaa99df546681f28683", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-01T03:11:19.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-04T16:05:55.000Z", "avg_line_length": 30.7175324675, "max_line_length": 149, "alphanum_fraction": 0.5978226403, "num_tokens": 3394, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7662936484231889, "lm_q2_score": 0.5851011542032312, "lm_q1q2_score": 0.4483592981510129}} {"text": "/***************************************************************************\n * Copyright (C) 2007 by Reed A. Cartwright *\n * reed@scit.us *\n * *\n * Permission is hereby granted, free of charge, to any person obtaining *\n * a copy of this software and associated documentation files (the *\n * \"Software\"), to deal in the Software without restriction, including *\n * without limitation the rights to use, copy, modify, merge, publish, *\n * distribute, sublicense, and/or sell copies of the Software, and to *\n * permit persons to whom the Software is furnished to do so, subject to *\n * the following conditions: *\n * *\n * The above copyright notice and this permission notice shall be *\n * included in all copies or substantial portions of the Software. *\n * *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, *\n * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *\n * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*\n * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR *\n * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, *\n * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR *\n * OTHER DEALINGS IN THE SOFTWARE. *\n ***************************************************************************/\n\n#ifdef HAVE_CONFIG_H\n#\tinclude \"config.h\"\n#endif\n\n#define _USE_MATH_DEFINES\n\n#include \n\n#include \n\n#include \"sample.h\"\n#include \"sample_k2p.h\"\n#include \"ccvector.h\"\n#include \"series.h\"\n#include \"invert_matrix.h\"\n#include \"table.h\"\n#include \"emdel.h\"\n\nusing namespace std;\n\nvoid sample_k2p_zeta::preallocate(size_t maxa, size_t maxd)\n{\n\tp.resize(maxa+1,maxd+1,0.0);\n}\n\nvoid sample_k2p_zeta::presample_step(const params_type ¶ms, const sequence &seq_a, const sequence &seq_d)\n{\n\tsize_t sz_max = std::max(sz_height, sz_width);\n\tsize_t sz_anc = seq_a.size();\n\tsize_t sz_dec = seq_d.size();\n\tsa = seq_a;\n\tsd = seq_d;\n\t\n\tconst model_type &model = get_model();\n\t\n\tp(0,0) = prob_scale;\n\t\n\tfor(size_t d = 1; d <= sz_dec; ++d) {\n\t\tp(0,d) = 0.0;\n\t\tfor(size_t k = d; k > 0; --k)\n\t\t\tp(0,d) += p(0,d-k)*model.p_indel_size[k];\n\t}\n\t\t\n\tfor(size_t a = 1; a <= sz_anc; ++a) {\n\t\tp(a,0) = 0.0;\n\t\tfor(size_t k = a; k > 0; --k)\n\t\t\tp(a,0) += p(a-k,0)*model.p_indel_size[k];\n\t}\n\n\tfor(size_t a=1;a<=sz_anc;++a) {\n\t\tfor(size_t d=1;d<= sz_dec;++d) {\n\t\t\tdouble pt = p(a-1,d-1)*model.p_substitution[sa[a-1]][sd[d-1]];\n\n\t\t\tfor(size_t k = d; k > 0; --k)\n\t\t\t\tpt += p(a,d-k)*model.p_indel_size[k];\n\t\t\tfor(size_t k = a; k > 0; --k)\n\t\t\t\tpt += p(a-k,d)*model.p_indel_size[k];\n\t\t\tp(a,d) = pt;\n\t\t}\n\t}\n}\n\nvoid sample_k2p_zeta::sample_once(std::string &seq_a, std::string &seq_d)\n{\n\tsize_t a = sa.size();\n\tsize_t d = sd.size();\n\tseq_a.clear();\n\tseq_d.clear();\n\t\n\tconst model_type &model = get_model();\n\t\n\twhile(a != 0 || d != 0) {\n\t\tdouble u = p(a,d)*myrand.uniform01();\n\t\tdouble t = (a > 0 && d > 0) ? p(a-1,d-1)*model.p_substitution[sa[a-1]][sd[d-1]] : 0.0;\n\t\tif(u < t) {\n\t\t\t// match\n\t\t\ta = a-1;\n\t\t\td = d-1;\n\t\t\tseq_a.append(1, ccNuc[sa[a]]);\n\t\t\tseq_d.append(1, ccNuc[sd[d]]);\n\t\t} else {\n\t\t\tfor(size_t k = 1; k <= a || k <= d; ++k) {\n\t\t\t\tif(k <= a) {\n\t\t\t\t\tt += p(a-k,d)*model.p_indel_size[k];\n\t\t\t\t\tif(u < t) {\n\t\t\t\t\t\t// gap in d\n\t\t\t\t\t\tseq_d.append(k, '-');\n\t\t\t\t\t\twhile(k--) seq_a.append(1, ccNuc[sa[--a]]);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif(k <= d)\n\t\t\t\t{\n\t\t\t\t\tt += p(a,d-k)*model.p_indel_size[k];\n\t\t\t\t\tif(u < t) {\n\t\t\t\t\t\t// gap in a\n\t\t\t\t\t\tseq_a.append(k, '-');\n\t\t\t\t\t\twhile(k--) seq_d.append(1, ccNuc[sd[--d]]);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t//seq_a.append(1,',');\n\t\t//seq_d.append(1,',');\n\t}\n\treverse(seq_a.begin(), seq_a.end());\n\treverse(seq_d.begin(), seq_d.end());\n}\n\nvoid sample_k2p_geo::preallocate(size_t maxa, size_t maxd)\n{\n\tp.resize(maxa+1,maxd+1,0.0);\n}\n\nvoid sample_k2p_geo::presample_step(const params_type ¶ms, const sequence &seq_a, const sequence &seq_d)\n{\n\tsize_t sz_max = std::max(sz_height, sz_width);\n\tsize_t sz_anc = seq_a.size();\n\tsize_t sz_dec = seq_d.size();\n\tsa = seq_a;\n\tsd = seq_d;\n\t\n\tconst model_type &model = get_model();\n\t\n\tdouble row_cache = 0.0;\n\tvector col_cache(sz_dec+1, 0.0);\n\t\n\tp(0,0) = prob_scale;\n\tfor(size_t d = 1; d <= sz_dec; ++d) {\n\t\trow_cache *= model.p_extend;\n\t\trow_cache += p(0,d-1)*model.p_open;\n\t\tp(0,d) = row_cache;\n\t}\n\t\n\trow_cache = 0.0;\n\tfor(size_t a = 1; a <= sz_anc; ++a) {\n\t\trow_cache *= model.p_extend;\n\t\trow_cache += p(a-1,0)*model.p_open;\n\t\tp(a,0) = row_cache;\n\t}\n\n\tfor(size_t a=1;a<=sz_anc;++a) {\n\t\trow_cache = 0.0;\n\t\tfor(size_t d=1;d<= sz_dec;++d) {\n\t\t\tdouble pt = p(a-1,d-1)*model.p_substitution[sa[a-1]][sd[d-1]];\n\t\t\trow_cache *= model.p_extend;\n\t\t\trow_cache += p(a,d-1)*model.p_open;\n\t\t\tpt += row_cache;\n\t\t\tcol_cache[d] *= model.p_extend;\n\t\t\tcol_cache[d] += p(a-1,d)*model.p_open;\n\t\t\tpt += col_cache[d];\n\t\t\tp(a,d) = pt;\n\t\t}\n\t}\n}\n\nvoid sample_k2p_geo::sample_once(std::string &seq_a, std::string &seq_d)\n{\n\tsize_t a = sa.size();\n\tsize_t d = sd.size();\n\tseq_a.clear();\n\tseq_d.clear();\n\t\n\tconst model_type &model = get_model();\n\t\n\twhile(a != 0 || d != 0) {\n\t\tdouble u = p(a,d)*myrand.uniform01();\n\t\tdouble t = (a > 0 && d > 0) ? p(a-1,d-1)*model.p_substitution[sa[a-1]][sd[d-1]] : 0.0;\n\t\tif(u < t) {\n\t\t\t// match\n\t\t\ta = a-1;\n\t\t\td = d-1;\n\t\t\tseq_a.append(1, ccNuc[sa[a]]);\n\t\t\tseq_d.append(1, ccNuc[sd[d]]);\n\t\t} else {\n\t\t\tfor(size_t k = 1; k <= a || k <= d; ++k) {\n\t\t\t\tif(k <= a) {\n\t\t\t\t\tt += p(a-k,d)*model.p_indel_size[k];\n\t\t\t\t\tif(u < t) {\n\t\t\t\t\t\t// gap in d\n\t\t\t\t\t\tseq_d.append(k, '-');\n\t\t\t\t\t\twhile(k--) seq_a.append(1, ccNuc[sa[--a]]);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif(k <= d)\n\t\t\t\t{\n\t\t\t\t\tt += p(a,d-k)*model.p_indel_size[k];\n\t\t\t\t\tif(u < t) {\n\t\t\t\t\t\t// gap in a\n\t\t\t\t\t\tseq_a.append(k, '-');\n\t\t\t\t\t\twhile(k--) seq_d.append(1, ccNuc[sd[--d]]);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t//seq_a.append(1,',');\n\t\t//seq_d.append(1,',');\n\t}\n\treverse(seq_a.begin(), seq_a.end());\n\treverse(seq_d.begin(), seq_d.end());\n}\n\n// Draw from Zipf distribution, with parameter a > 1.0\n// Devroye Luc (1986) Non-uniform random variate generation.\n// Springer-Verlag: Berlin. p551\ninline unsigned int rand_zipf(double a)\n{\n\tdouble b = pow(2.0, a-1.0);\n\tdouble x,t;\n\tdo {\n\t x = floor(pow(myrand.uniform01(), -1.0/(a-1.0)));\n\t t = pow(1.0+1.0/x, a-1.0);\n\t} while( myrand.uniform01()*x*(t-1.0)*b >= t*(b-1.0));\n\treturn (unsigned int)x;\n}\n\nconst char g_nuc[] = \"ACGT\";\nconst char g_nuc2[] = \"ACGT\" \"GTAC\" \"TGCA\" \"CATG\";\n\nvoid gen_sample_k2p_zeta::sample_once(std::string &seq_a, std::string &seq_d)\n{\n\tseq_a.clear();\n\tseq_d.clear();\n\t\n\tconst model_type &model = get_model();\n\tconst double z = get_params()[model_k2p_zeta::pZ];\n\twhile(1) {\n\t\tdouble p = myrand.uniform01();\n\t\tif(p < model.p_2h) {\n\t\t\t// M\n\t\t\tunsigned int x = myrand.uniform(4);\n\t\t\tseq_a.append(1, g_nuc[x]);\n\t\t\tp = myrand.uniform01();\n\t\t\tif(p < model.p_match) {\n\t\t\t\tseq_d.append(1, g_nuc2[x]);\n\t\t\t} else if(p < model.p_match+model.p_ts) {\n\t\t\t\tseq_d.append(1, g_nuc2[x+4]);\n\t\t\t} else if(p < 1.0 - 0.5*model.p_ts) {\n\t\t\t\tseq_d.append(1, g_nuc2[x+8]);\n\t\t\t} else {\n\t\t\t\tseq_d.append(1, g_nuc2[x+12]);\n\t\t\t}\n\t\t} else if(p < model.p_2h+model.p_2g) {\n\t\t\t// U\n\t\t\tunsigned int x;\n\t\t\tdo {\n\t\t\t\tx = rand_zipf(z);\n\t\t\t} while(x > nmax);\n\t\t\tseq_d.append(x, '-');\n\t\t\twhile(x--) {\n\t\t\t\tseq_a.append(1, g_nuc[myrand.uniform(4)]);\n\t\t\t}\n\t\t} else if(p < 1.0-model.p_end) {\n\t\t\t// V\n\t\t\tunsigned int x;\n\t\t\tdo {\n\t\t\t\tx = rand_zipf(z);\n\t\t\t} while(x > nmax);\n\t\t\tseq_a.append(x, '-');\n\t\t\twhile(x--) {\n\t\t\t\tseq_d.append(1, g_nuc[myrand.uniform(4)]);\n\t\t\t}\t\t\t\n\t\t} else {\n\t\t\t// E\n\t\t\tbreak;\n\t\t}\n\t}\n}\n\nvoid gen_sample_k2p_geo::sample_once(std::string &seq_a, std::string &seq_d)\n{\n\tseq_a.clear();\n\tseq_d.clear();\n\t\n\tconst model_type &model = get_model();\n\tconst double q = 1.0/get_params()[model_k2p_geo::pQ];\n\twhile(1) {\n\t\tdouble p = myrand.uniform01();\n\t\tif(p < model.p_2h) {\n\t\t\t// M\n\t\t\tunsigned int x = myrand.uniform(4);\n\t\t\tseq_a.append(1, g_nuc[x]);\n\t\t\tp = myrand.uniform01();\n\t\t\tif(p < model.p_match) {\n\t\t\t\tseq_d.append(1, g_nuc2[x]);\n\t\t\t} else if(p < model.p_match+model.p_ts) {\n\t\t\t\tseq_d.append(1, g_nuc2[x+4]);\n\t\t\t} else if(p < 1.0 - 0.5*model.p_ts) {\n\t\t\t\tseq_d.append(1, g_nuc2[x+8]);\n\t\t\t} else {\n\t\t\t\tseq_d.append(1, g_nuc2[x+12]);\n\t\t\t}\n\t\t} else if(p < model.p_2h+model.p_2g) {\n\t\t\t// U\n\t\t\tunsigned int x = myrand.geometric(q);\n\t\t\tseq_d.append(x, '-');\n\t\t\twhile(x--) {\n\t\t\t\tseq_a.append(1, g_nuc[myrand.uniform(4)]);\n\t\t\t}\n\t\t} else if(p < 1.0-model.p_end) {\n\t\t\t// V\n\t\t\tunsigned int x = myrand.geometric(q);\n\t\t\tseq_a.append(x, '-');\n\t\t\twhile(x--) {\n\t\t\t\tseq_d.append(1, g_nuc[myrand.uniform(4)]);\n\t\t\t}\n\t\t} else {\n\t\t\t// E\n\t\t\tbreak;\n\t\t}\n\t}\n}\n\n\n", "meta": {"hexsha": "c9c1aa4f19e6498de34a61175dd7cf8af1f60929", "size": 9006, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/sample.cpp", "max_stars_repo_name": "reedacartwright/emdel", "max_stars_repo_head_hexsha": "58ea9d4db89c4a1852ba5405ef73c2eca6539ce3", "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/sample.cpp", "max_issues_repo_name": "reedacartwright/emdel", "max_issues_repo_head_hexsha": "58ea9d4db89c4a1852ba5405ef73c2eca6539ce3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2020-12-03T16:50:15.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-23T22:51:19.000Z", "max_forks_repo_path": "src/sample.cpp", "max_forks_repo_name": "reedacartwright/emdel", "max_forks_repo_head_hexsha": "58ea9d4db89c4a1852ba5405ef73c2eca6539ce3", "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.3333333333, "max_line_length": 109, "alphanum_fraction": 0.5504108372, "num_tokens": 2977, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7662936324115011, "lm_q2_score": 0.5851011542032312, "lm_q1q2_score": 0.4483592887825558}} {"text": "/*\r\n * cg.cpp\r\n *\r\n * Author: H. Hofbauer (hhofbaue@cosy.sbg.ac.at), E. Pschernig (epschern@cosy.sbg.ac.at), P. Wild (pwild@cosy.sbg.ac.at)\r\n *\r\n * Generates an iris code from iris texture using complex gabor filters with different filter size and wavelength.\r\n *\r\n */\r\n#include \"version.h\"\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#include \r\n#include \r\n#ifndef M_PI\r\n#define M_PI 3.14159265358979323846\r\n#endif\r\n\r\nusing namespace std;\r\nusing namespace cv;\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\nint FILTER_HEIGHT=31;\r\n\r\n/*\r\n * Print command line usage for this program\r\n */\r\nvoid printUsage() {\r\n printVersion();\r\n\tprintf(\"+-----------------------------------------------------------------------------+\\n\");\r\n\tprintf(\"| cg - Iris-code generation (feature extraction) using complex gabor filters |\\n\");\r\n\tprintf(\"| with varying wavelengths. |\\n\");\r\n\tprintf(\"| |\\n\");\r\n\tprintf(\"| John Daugman. The importance of being random: statistical principles of |\\n\");\r\n\tprintf(\"| iris recognition. Pattern Recognition 36(2003) 279--291. |\\n\");\r\n\tprintf(\"| |\\n\");\r\n\tprintf(\"| MODES |\\n\");\r\n\tprintf(\"| |\\n\");\r\n printf(\"| (# 1) cg 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(\"| -m | inmaskfile | 1 | Y | noise pixelmask (0: noise, 255: noise-free) |\\n\");\r\n// printf(\"| | outmaskfile| | | code bitmask (0: noise, 1: noise-free, off) |\\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(\"| -pwl | wavelength | 1 | N | Base wavelength of the gabor filter in pixel. |\\n\");\r\n printf(\"| | | | | Size of base filter will then be 2*wl+1. |\\n\");\r\n printf(\"| | | | | (default 6) |\\n\");\r\n printf(\"| -pbp | borderpower| 1 | N | Remaining power of the gauss-part of the filter |\\n\");\r\n printf(\"| | | | | relative to the center (default 0.01). |\\n\");\r\n printf(\"| -psx | x-samples | 1 | N | Number of horizontal samples (default 256) |\\n\");\r\n printf(\"| -x | width | 1 | N | Width of input texture (default 512). |\\n\");\r\n printf(\"| -y | height | 1 | N | Height of input texture (default 64). |\\n\");\r\n printf(\"| | | | | |\\n\");\r\n printf(\"| -wf | | 1 | N | Write filterbank images |\\n\");\r\n printf(\"| -ws | | 1 | N | Write image sample with filtered versions |\\n\");\r\n printf(\"| -wp | | 1 | N | Write iris image with extraction points |\\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(\"| -i *.tiff -im ?1_mask.png -o ?1_code.png -om ?1_codemask.png -q -t |\\n\");\r\n printf(\"| |\\n\");\r\n printf(\"| AUTHORS |\\n\");\r\n printf(\"| |\\n\");\r\n printf(\"| Heinz Hofbauer (hhofbaue@cosy.sbg.ac.at) |\\n\");\r\n printf(\"| Elias Pschernig (epschern@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\r\n/** --------------- writerstuff for debugging/control --------------- **/\r\n\r\nvoid writeNormMatToFile(const Mat &what, const string &where, const string &txtmessage = \"\", bool write_sign=false){\r\n if( write_sign){\r\n Mat img = ( what >= 0);\r\n imwrite( where, img);\r\n } else {\r\n Mat img(what.rows, what.cols, CV_8U);\r\n normalize( what, img, 0, 255, NORM_MINMAX);\r\n imwrite( where, img);\r\n }\r\n if( !txtmessage.empty()) cout << txtmessage << \" file(\"< &extractionsequence, bool &writeagain){\r\n Mat pointoverlay = img.clone();\r\n for( vector::const_iterator eit = extractionsequence.begin(); eit != extractionsequence.end(); advance(eit, 1) )\r\n circle( pointoverlay, *eit, 1, Scalar(255,128,128));\r\n writeagain = false;\r\n imwrite( \"extractionpointlocation.png\", pointoverlay);\r\n cout << \"Extraction point locations written to: extractionpointlocation.png\"< &filterbank){\r\n for( vector::const_iterator it = filterbank.begin(); it != filterbank.end(); advance(it,1)){\r\n string filename = \"filter_\";\r\n int idx = distance( filterbank.begin(), it);\r\n if ( idx % 2 == 0 ) filename+=\"re\";\r\n else filename+=\"im\";\r\n filename += boost::lexical_cast(idx/2+1) + \"_wl\" + boost::lexical_cast((it->cols-1)/2);\r\n filename += \".png\";\r\n writeNormMatToFile( *it, filename);\r\n cout << \"filterbank written: \"<=0 && ext_height >= 0);\r\n int w = src.cols + ext_width;\r\n int woff = ext_width/2;\r\n int wrest = ext_width-woff;\r\n int h = src.rows + ext_height;\r\n int hoff = ext_height/2;\r\n int hrest = ext_height-hoff;\r\n\r\n Mat dst(h,w,src.type());\r\n copyMakeBorder( src, dst, hoff, hrest, woff, wrest, BORDER_WRAP);\r\n return dst;\r\n}\r\n\r\n\r\nvoid featureExtract(Mat &code, Mat &codeMask, const Mat &img, const Mat &mask, const vector &filterbank, const vector &extractionsequence, bool &write_samples){\r\n CV_Assert(code.size() == Size( filterbank.size() * extractionsequence.size()/8,1));\r\n CV_Assert(mask.empty() || codeMask.empty() || codeMask.size() == code.size());\r\n bool useMask = !mask.empty() && !codeMask.empty();\r\n\r\n int filter_w=0, filter_h=0;\r\n for( vector::const_iterator it=filterbank.begin(); it != filterbank.end(); advance(it,1)){\r\n if( it->cols > filter_w) filter_w = it->cols;\r\n if( it->rows > filter_h) filter_h = it->rows;\r\n }\r\n Mat extimg = extendByWrap( img, filter_w/* , filter_h */);\r\n Point extoff(filter_w/2, 0);\r\n\r\n vector filteredExtImg;\r\n for( unsigned int i=0; i < filterbank.size(); ++i){\r\n filteredExtImg.push_back(extimg.clone());\r\n filter2D(extimg, filteredExtImg[i], CV_32F, filterbank[i]);\r\n if( write_samples){\r\n writeNormMatToFile(filteredExtImg[i], \"filtered_ext_fb\"+boost::lexical_cast(i)+\".png\", \"sample written:\");\r\n writeNormMatToFile(filteredExtImg[i], \"filtered_ext_fb\"+boost::lexical_cast(i)+\"_bitmap.png\", \"sample written:\", true);\r\n }\r\n }\r\n if( write_samples) writeNormMatToFile(extimg, \"filtered_ext_orig.png\", \"sample written\");\r\n \r\n\r\n uchar *codeMaskData = NULL;\r\n\tif (useMask){\r\n codeMask.setTo(255);\r\n codeMaskData = codeMask.data;\r\n }\r\n\tcode.setTo(0);\r\n uchar * codeData = code.data;\r\n int bitpos = 0;\r\n float fval;\r\n for( vector::const_iterator fit = filteredExtImg.begin(); fit != filteredExtImg.end(); advance( fit, 1) ){\r\n for( vector::const_iterator eit = extractionsequence.begin(); eit != extractionsequence.end(); advance( eit,1) ){\r\n // true = 1 for sign, 0 is default\r\n fval = fit->at(*eit + extoff);\r\n if( fval >= 0) codeData[0] |= 1<<(7-bitpos);\r\n if( useMask ){\r\n if( ( fval*fval < 0.000000001 ) || // values are very small, discard as possible error\r\n ( codeMask.at(*eit) > 0 ) ) // texture is masked\r\n codeMaskData[0] &= 0xff ^ 1 << (7-bitpos);\r\n }\r\n bitpos++;\r\n if( bitpos == 8){\r\n codeData++;\r\n bitpos = 0;\r\n if (useMask) codeMaskData++;\r\n }\r\n }\r\n }\r\n write_samples = false; // only write one set \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(); std::advance(it,1)){\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 * 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\r\n/**\r\n * First filter ist square with width wl*2+1, for the other filter horizontal\r\n * wavelength increase by one octave for each filter. \r\n * A total of 8 filters are generated, 3 octaves from base with real and\r\n * imaginary parts of the complex gabor wavelet as separate filter.\r\n *\r\n * base_wavelength: Is the base wavelength of the underlying cosine/sine.\r\n * border_gauss_residual: Adjust gauss sigma such that this percentage of\r\n * central energy is left at the border.\r\n */\r\nvoid generateFilterbank( vector &filterbank, const int &base_wavelength, const float &border_gauss_residual, int max_octave=3){\r\n float amp = -1*M_PI;\r\n float borderfactor = sqrtf(amp/logf(border_gauss_residual));\r\n int hr = FILTER_HEIGHT; // height radius and filter height\r\n int h = 2*hr+1;\r\n float alpha = hr*borderfactor;\r\n\r\n for( int octave =0, wavelength = base_wavelength; octave <= max_octave; wavelength*=2, octave++){\r\n int wr = wavelength;\r\n int w = wr*2+1;\r\n float beta = wr*borderfactor;\r\n cout << \"generating filter for wavelength: \"<(y,x) = G*F_RE;\r\n filter_im.at(y,x) = G*F_IM;\r\n }\r\n filter_re -= sum(filter_re)[0]/(w*h); // correct for non/zero response of real filter\r\n filterbank.push_back(filter_re);\r\n filterbank.push_back(filter_im);\r\n }\r\n}\r\n\r\n\r\n/**\r\n * Specifies which points to use for the iris code, points are taken as given each point is taken from each filter, then the next point is taken.\r\n *\r\n * This function specifies and equally spaced grid for extraction\r\n *\r\n * grid_x: number of points in x-direction to extract\r\n *\r\n * returns the number of grouped points for a single angle\r\n */\r\nvoid generateExtractsequenceGrid( vector &extractsequence, const int &base_wavelength, const int &grid_x, const int size_x, const int size_y){\r\n int sample_x = (grid_x >= 1) ? grid_x : size_x/base_wavelength ;\r\n int sample_y = size_y/(FILTER_HEIGHT*2+1) ;\r\n int dx = size_x/sample_x; // horizontal equally spaced, image is rotationally extended for filtering\r\n float offy = FILTER_HEIGHT+0.5;\r\n float resty= size_y - 2.*offy;\r\n float dy = resty/(sample_y-1); // keep filter in image for vertical\r\n if (dy!=dy || sample_y == 1) dy=0; //NaN comparissons are always false or smaple_y ==1 ,i.e., dy = inf\r\n for( int y=0; y > cmd;\r\n\ttry {\r\n\t\tcmdRead(cmd,argc,argv);\r\n \tif (cmd.empty() || 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|-wf|-ws|-wp|-pwl|-pbp|-psx|-x|-y\");\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\tif (cmdGetOpt(cmd,\"-m\") != 0){\r\n\t\t\t\tcmdCheckOptSize(cmd,\"-m\",2);\r\n\t\t\t\timaskFiles = cmdGetPar(cmd,\"-m\", 0);\r\n\t\t\t\tomaskFiles = cmdGetPar(cmd,\"-m\", 1);\r\n\t\t\t}\r\n /** parmeters **/\r\n int base_wavelength = 6;\r\n\t\t\tif (cmdGetOpt(cmd,\"-pwl\") != 0){\r\n\t\t\t\tcmdCheckOptSize(cmd,\"-pwl\",1);\r\n\t\t\t\tbase_wavelength = cmdGetParInt(cmd,\"-pwl\", 0);\r\n\t\t\t}\r\n float border_gauss_residual = 0.01;\r\n\t\t\tif (cmdGetOpt(cmd,\"-pbp\") != 0){\r\n\t\t\t\tcmdCheckOptSize(cmd,\"-pbp\",1);\r\n\t\t\t\tborder_gauss_residual = cmdGetParFloat(cmd,\"-pbp\", 0);\r\n if( border_gauss_residual <= 0 || border_gauss_residual >= 1){\r\n cout << \"WARNING: Border power does not make much sense, reverting to 0.01\"< 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 vector filterbank;\r\n generateFilterbank( filterbank, base_wavelength, border_gauss_residual);\r\n if( write_filterbank) writeFilterbank(filterbank);\r\n vector extractsequence;\r\n generateExtractsequenceGrid( extractsequence, base_wavelength, grid_x, size_x, size_y);\r\n\t\t\tMat code (1,extractsequence.size()*filterbank.size()/8,CV_8UC1);\r\n cout << \"Code size (bytes): \"<< code.size()<::iterator inFile = files.begin(); inFile != files.end(); std::advance( inFile, 1), 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 if( write_points) writeExtractionsequence(img, extractsequence, write_points); // write_points is reset after one use\r\n\t\t\t\tCV_Assert(img.data != 0);\r\n\t\t\t\tCV_Assert(img.size() == Size(size_x,size_y));\r\n\t\t\t\tMat mask = Mat();\r\n\t\t\t\tif (!imaskFiles.empty()) {\r\n\t\t\t\t\tstring imaskfile;\r\n\t\t\t\t\tpatternFileRename(inFiles,imaskFiles,*inFile,imaskfile);\r\n\t\t\t\t\tif (!quiet) printf(\"Loading mask image '%s' ...\\n\", imaskfile.c_str());;\r\n\t\t\t\t\tmask = imread(imaskfile, CV_LOAD_IMAGE_GRAYSCALE);\r\n\t\t\t\t\tCV_Assert(mask.data != 0);\r\n\t\t\t\t\tCV_Assert(mask.size() == Size(size_x,size_y));\r\n\t\t\t\t}\r\n\t\t\t\tif (!quiet) printf(\"Creating iris-code ...\\n\");\r\n\r\n\t\t\t\t//featureExtract(code, codeMask, img, mask, m, n);\r\n\t\t\t\tfeatureExtract(code, codeMask, img, mask, filterbank, extractsequence, write_samples);\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,code)) CV_Error(CV_StsError,\"Could not save image '\" + outfile + \"'\");\r\n\t\t\t\tif (!imaskFiles.empty()) {\r\n\t\t\t\t\tstring omaskfile;\r\n\t\t\t\t\tpatternFileRename(inFiles,omaskFiles,*inFile,omaskfile);\r\n\t\t\t\t\tif (!quiet) printf(\"Storing code-mask '%s' ...\\n\", omaskfile.c_str());\r\n\t\t\t\t\tif (!imwrite(omaskfile,codeMask)) CV_Error(CV_StsError,\"Could not save image '\" + omaskfile + \"'\");\r\n\t\t\t\t}\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": "76e582701447cff1905e3c4679bf0b0dab83f52d", "size": 35339, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "cg.cpp", "max_stars_repo_name": "ngoclamvt123/usit-v2.2.0", "max_stars_repo_head_hexsha": "3b2d27b7096e44eb41c786b4497b296ffd5a1519", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2020-12-20T12:40:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-17T20:04:22.000Z", "max_issues_repo_path": "cg.cpp", "max_issues_repo_name": "ngoclamvt123/usit-v2.2.0", "max_issues_repo_head_hexsha": "3b2d27b7096e44eb41c786b4497b296ffd5a1519", "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": "cg.cpp", "max_forks_repo_name": "ngoclamvt123/usit-v2.2.0", "max_forks_repo_head_hexsha": "3b2d27b7096e44eb41c786b4497b296ffd5a1519", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2020-09-14T01:51:42.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-10T02:49:06.000Z", "avg_line_length": 42.7832929782, "max_line_length": 513, "alphanum_fraction": 0.5689464897, "num_tokens": 8819, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6959583250334526, "lm_q2_score": 0.6442251064863697, "lm_q1q2_score": 0.44835382605475144}} {"text": "/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */\n\n/*\n\n Copyright (C) 2016 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 stochasticcollocationinvcdf.hpp\n Stochastic collocation inverse cumulative distribution function\n*/\n\n#ifndef quantlib_stochastic_collation_inv_cdf_hpp\n#define quantlib_stochastic_collation_inv_cdf_hpp\n\n#include \n#include \n\n#include \n#include \n\nnamespace QuantLib {\n //! Stochastic collocation inverse cumulative distribution function\n\n /*! References:\n L.A. Grzelak, J.A.S. Witteveen, M.Suárez-Taboada, C.W. Oosterlee,\n The Stochastic Collocation Monte Carlo Sampler: Highly efficient\n sampling from “expensive” distributions\n http://papers.ssrn.com/sol3/papers.cfm?abstract_id=2529691\n */\n\n class StochasticCollocationInvCDF : public std::unary_function {\n public:\n StochasticCollocationInvCDF(\n const boost::function& invCDF,\n Size lagrangeOrder,\n Real pMax = Null(),\n Real pMin = Null());\n\n Real value(Real x) const;\n Real operator()(Real u) const;\n\n private:\n const Array x_;\n const Volatility sigma_;\n const Array y_;\n const LagrangeInterpolation interpl_;\n };\n}\n\n\n/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */\n\n/*\n\n Copyright (C) 2016 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 stochasticcollationcdf.cpp\n*/\n\n#include \n#include \n\nnamespace QuantLib {\n\n namespace {\n Disposable g(Real sigma, const Array& x,\n const boost::function& invCDF) {\n\n Array y(x.size());\n const CumulativeNormalDistribution normalCDF;\n\n for (Size i=0, n=x.size(); i < n; ++i) {\n y[i] = invCDF(normalCDF(x[i]/sigma));\n }\n\n return y;\n }\n }\n\n inline StochasticCollocationInvCDF::StochasticCollocationInvCDF(\n const boost::function& invCDF,\n Size lagrangeOrder, Real pMax, Real pMin)\n : x_(M_SQRT2*GaussHermiteIntegration(lagrangeOrder).x()),\n sigma_( (pMax != Null())\n ? x_.back() / InverseCumulativeNormal()(pMax)\n : (pMin != Null())\n ? x_.front() / InverseCumulativeNormal()(pMin)\n : 1.0),\n y_(g(sigma_, x_, invCDF)),\n interpl_(x_.begin(), x_.end(), y_.begin()) {\n }\n\n inline Real StochasticCollocationInvCDF::value(Real x) const {\n return interpl_(x*sigma_, true);\n }\n inline Real StochasticCollocationInvCDF::operator()(Real u) const {\n return value(InverseCumulativeNormal()(u));\n }\n}\n\n\n#endif", "meta": {"hexsha": "c124324a7d9ccf6bf9017a93852381e5a35de594", "size": 4250, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "ql/math/randomnumbers/stochasticcollocationinvcdf.hpp", "max_stars_repo_name": "markxio/Quantuccia", "max_stars_repo_head_hexsha": "ebe71a1b9c2a9ee7fc4ea918a9602f100316869d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 29.0, "max_stars_repo_stars_event_min_datetime": "2017-03-20T14:17:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-22T08:00:52.000Z", "max_issues_repo_path": "ql/math/randomnumbers/stochasticcollocationinvcdf.hpp", "max_issues_repo_name": "markxio/Quantuccia", "max_issues_repo_head_hexsha": "ebe71a1b9c2a9ee7fc4ea918a9602f100316869d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 10.0, "max_issues_repo_issues_event_min_datetime": "2017-04-02T14:34:07.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-13T05:31:12.000Z", "max_forks_repo_path": "ql/math/randomnumbers/stochasticcollocationinvcdf.hpp", "max_forks_repo_name": "markxio/Quantuccia", "max_forks_repo_head_hexsha": "ebe71a1b9c2a9ee7fc4ea918a9602f100316869d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 22.0, "max_forks_repo_forks_event_min_datetime": "2017-03-19T05:56:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-16T13:30:20.000Z", "avg_line_length": 32.9457364341, "max_line_length": 79, "alphanum_fraction": 0.6788235294, "num_tokens": 1004, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.819893335913536, "lm_q2_score": 0.5467381519846138, "lm_q1q2_score": 0.4482669673018669}} {"text": "/*\n * Author: Benoit Sklenard benoit.sklenard@cea.fr \n * \n * 3D Poisson solver.\n * Neumann and Dirichlet boundary conditions are supported and read from Kernel::Mesh class.\n *\n * Matrix operations rely on boost::numeric::ublas library. Atlas library should be more appropriate.\n *\n * Conjugate gradient is used to solve linear system Ax = b\n * Newton-Raphson method is used to get self-consistent Thomas-Fermi/Poisson solution\n *\n * Copyright 2014 IMDEA Materials Institute, Getafe, Madrid, Spain\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 \"kernel/Domain.h\" \n#include \"kernel/Mesh.h\"\n#include \"kernel/Constants.h\"\n\n#include \"io/Diagnostic.h\"\n#include \"io/ParameterManager.h\"\n#include \"io/FileParameters.h\"\n#include \"io/Parameters.h\"\n\n#include \"okmc/MobileParticleParam.h\"\n\n#include \"lkmc/LatticeDiamondParam.h\"\n\n#include \"FermiDirac.h\"\n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \"Poisson.h\"\n\nusing namespace Kernel;\nusing namespace boost::numeric;\nusing namespace Electrostatics;\n\n\nPoisson::Poisson(Tcl_Interp *pTcl, Domain *pDomain) {\n\tLOWMSG(\"Loading Poisson...\");\n\n\t_pDomain = pDomain;\n\t_pMesh = pDomain->_pMesh;\n\t_pTcl = pTcl;\n\n\t_T = 0;\n\n\t_nx = (_pMesh->getPeriodicX() ? _pMesh->getnx() - 1 : _pMesh->getnx());\n\t_ny = (_pMesh->getPeriodicY() ? _pMesh->getny() - 1 : _pMesh->getny());\n\t_nz = (_pMesh->getPeriodicZ() ? _pMesh->getnz() - 1 : _pMesh->getnz());\n\n\t_CG_tol = Domains::global()->getFileParameters()->getFloat(\"MC/Electrostatic/cg.tolerance\"); // 1e-6;\n\t_CG_maxIter = Domains::global()->getFileParameters()->getInt(\"MC/Electrostatic/cg.max.iteration\"); // 2000;\n\t_CG_verbose = Domains::global()->getFileParameters()->getInt(\"MC/Electrostatic/cg.verbose\");\n\n\t_NR_tol = Domains::global()->getFileParameters()->getFloat(\"MC/Electrostatic/newton.tolerance\"); // 1e-4;\n\t_NR_maxIter = Domains::global()->getFileParameters()->getInt(\"MC/Electrostatic/newton.max.iteration\"); // 50;\n\t_NR_verbose = Domains::global()->getFileParameters()->getInt(\"MC/Electrostatic/newton.verbose\");\n\n\t_FermiDirac = Domains::global()->getFileParameters()->getBool(\"MC/Electrostatic/FermiDirac\");\n\t_partialIonization = Domains::global()->getFileParameters()->getBool(\"MC/Electrostatic/partial.ionization\");\n\t_selfConsistentLKMC = Domains::global()->getFileParameters()->getBool(\"MC/Electrostatic/self.consistent.lkmc\");\n\n\t_Qe = ublas::zero_vector(_nx * _ny * _nz);\n\t_Qh = ublas::zero_vector(_nx * _ny * _nz);\n\t_Qokmc = ublas::zero_vector(_nx * _ny * _nz);\n\t_psi = ublas::zero_vector(_nx * _ny * _nz);\n\n\t_Qlkmc_M = ublas::zero_vector(_nx * _ny * _nz);\n\t_Qlkmc_P = ublas::zero_vector(_nx * _ny * _nz);\n\n\t_Eg = ublas::zero_vector(_nx * _ny * _nz);\n\t_Eg0 = ublas::zero_vector(_nx * _ny * _nz);\n\t_Nc = ublas::zero_vector(_nx * _ny * _nz);\n\t_Nv = ublas::zero_vector(_nx * _ny * _nz);\n\t_DEc = ublas::zero_vector(_nx * _ny * _nz);\n\t_DEv = ublas::zero_vector(_nx * _ny * _nz);\n\n\tconst IO::ParameterManager *pPM = Domains::global()->PM();\n\tconst OKMC::MobileParticleParam *pMPP = _pDomain->_pMPPar;\n\tconst LKMC::LatticeParam **pLP = _pDomain->_pLaPar;\n\n\tfor(M_TYPE mt = 0; mt < pPM->getNMaterials(); ++mt)\n\t{\n\t\t// OKMC\n\t\tfor(P_TYPE pt = 0; pt < pPM->getNParticles(); ++pt)\n\t\t{\n\t\t\tif(!pPM->isParticleDefined(pt, mt))\n\t\t\t\tcontinue;\n\t\t\tif (pMPP->_mapToGrid[mt][pt])\n\t\t\t\t_Nokmc[mt][pt] = ublas::zero_vector(_nx * _ny * _nz);\n\t\t}\n\t\t// LKMC\n\t\tif (pLP[mt] != NULL && pLP[mt]->_mapToGrid)\n\t\t\t_Nlkmc[mt] = ublas::zero_vector(_nx * _ny * _nz);\n\t}\n}\n\nPoisson::~Poisson() {\n}\n\nvoid Poisson::computeElectronicParameters(double TKelvin) {\n\n\tMeshNode ***pNode = _pMesh->getNodes();\n\tIO::FileParameters *pPar = Domains::global()->getFileParameters();\n\tIO::ParameterManager *pPM = Domains::global()->PM();\n\n\tfor (Kernel::M_TYPE mt = 0; mt < Domains::global()->PM()->getNMaterials(); ++mt) {\n\t\tstd::string path = pPM->getMaterialName(mt) + \"/ElectronicStructure\";\n\n\t\tif (!pPar->specified(path)) {\n\t\t\tWARNINGMSG(path << \" does not exist!\");\n\t\t\t_matParam[mt]._Nc = 0;\n\t\t\t_matParam[mt]._Nv = 0;\n\t\t\t_matParam[mt]._Eg = 0;\n\t\t\t_matParam[mt]._Eg0 = 0;\n\n\t\t\tcontinue ;\n\t\t}\n\t\tstd::string eDOSPath = path + \"/eDOSMass\";\n\t\tstd::string hDOSPath = path + \"/hDOSMass\";\n\t\tstd::string EgPath = path + \"/Bandgap\";\n\t\tstd::string EcDilatationalPath = path + \"/Ec.dilatational\";\n\t\tstd::string EvDilatationalPath = path + \"/Ev.dilatational\";\n\t\tstd::string EcDeviatoricPath = path + \"/Ec.deviatoric\";\n\t\tstd::string EvDeviatoricPath = path + \"/Ev.deviatoric\";\n\n\t\tstd::string T = boost::lexical_cast(_T);\n\t\tstd::string T0 = boost::lexical_cast(300);\n\n\t\tpPar->loadProcedure(_pTcl, eDOSPath, 1);\n\t\tpPar->loadProcedure(_pTcl, hDOSPath, 1);\n\t\tpPar->loadProcedure(_pTcl, EgPath, 1);\n\n\t\tdouble mdc = pPar->getFloatProc(_pTcl, eDOSPath, T);\n\t\tdouble mdv = pPar->getFloatProc(_pTcl, hDOSPath, T);\n\n\t\t_matParam[mt]._Nc = 2. * pow(M0 * mdc * KB * _T / (2 * M_PI * pow(PLANCK_BAR, 2)), 3./2.); // m3\n\t\t_matParam[mt]._Nv = 2. * pow(M0 * mdv * KB * _T / (2 * M_PI * pow(PLANCK_BAR, 2)), 3./2.); // m3\n\t\t_matParam[mt]._Eg = ELECTRONVOLT_TO_HARTREE(pPar->getFloatProc(_pTcl, EgPath, T)); // Ha\n\t\t_matParam[mt]._Eg0 = ELECTRONVOLT_TO_HARTREE(pPar->getFloatProc(_pTcl, EgPath, T0)); // Ha\n\n\t\tif (pPar->specified(EcDilatationalPath) && pPar->specified(EvDilatationalPath)) {\n\t\t\t_matParam[mt]._Dc = ublas::zero_vector(3);\n\t\t\t_matParam[mt]._Dcx = ublas::zero_vector(3);\n\t\t\t_matParam[mt]._Dcy = ublas::zero_vector(3);\n\t\t\t_matParam[mt]._Dcz = ublas::zero_vector(3);\n\t\t\t_matParam[mt]._Dv = ublas::zero_vector(2);\n\t\t\t_matParam[mt]._Dvb = ublas::zero_vector(2);\n\t\t\t_matParam[mt]._Dvd = ublas::zero_vector(2);\n\n\t\t\tstd::map Dc = pPar->getFloatMap(EcDilatationalPath);\n\t\t\tstd::map Dcx = pPar->getFloatMap(EcDeviatoricPath + \"(1)\");\n\t\t\tstd::map Dcy = pPar->getFloatMap(EcDeviatoricPath + \"(2)\");\n\t\t\tstd::map Dcz = pPar->getFloatMap(EcDeviatoricPath + \"(3)\");\n\n\t\t\tstd::map Dv = pPar->getFloatMap(EvDilatationalPath);\n\t\t\tstd::map Dvb = pPar->getFloatMap(EvDeviatoricPath + \"(1)\");\n\t\t\tstd::map Dvd = pPar->getFloatMap(EvDeviatoricPath + \"(2)\");\n\n\t\t\tfor (unsigned i = 0; i < 3; ++i) {\n\t\t\t\t_matParam[mt]._Dc(i) = Dc[boost::lexical_cast(i + 1)];\n\t\t\t\t_matParam[mt]._Dcx(i) = Dcx[boost::lexical_cast(i + 1)];\n\t\t\t\t_matParam[mt]._Dcy(i) = Dcy[boost::lexical_cast(i + 1)];\n\t\t\t\t_matParam[mt]._Dcz(i) = Dcz[boost::lexical_cast(i + 1)];\n\t\t\t}\n\n\t\t\tfor (unsigned i = 0; i < 2; ++i) {\n\t\t\t\t_matParam[mt]._Dv(i) = Dv[boost::lexical_cast(i + 1)];\n\t\t\t\t_matParam[mt]._Dvb(i) = Dvb[boost::lexical_cast(i + 1)];\n\t\t\t\t_matParam[mt]._Dvd(i) = Dvd[boost::lexical_cast(i + 1)];\n\t\t\t}\n\t\t\tLOWMSG(\"got stress data for \" << pPM->getMaterialName(mt));\n\t\t}\n\t}\n\n\t// initialize electronic parameters for the structure\n\tfor (unsigned ix = 0; ix < _nx; ++ix) {\n\t\tfor (unsigned iy = 0; iy < _ny; ++iy) {\n\t\t\tfor (unsigned iz = 0; iz < _nz; ++iz) {\n\t\t\t\tif (pNode[ix][iy][iz]._active) {\n\t\t\t\t\tconst unsigned idx = pNode[ix][iy][iz]._index;\n\n\t\t\t\t\t_Nc(idx) = pNode[ix][iy][iz]._volume * 1e-27 * getNc(&pNode[ix][iy][iz]);\n\t\t\t\t\t_Nv(idx) = pNode[ix][iy][iz]._volume * 1e-27 * getNv(&pNode[ix][iy][iz]);\n\n\t\t\t\t\t_Eg(idx) = getEg(&pNode[ix][iy][iz]);\n\t\t\t\t\t_Eg0(idx) = getEg0(&pNode[ix][iy][iz]);\n\n\t\t\t\t\tif (_Eg(pNode[ix][iy][iz]._index) <= 0. || _Eg0(pNode[ix][iy][iz]._index) <= 0.)\n\t\t\t\t\t\tERRORMSG(\"Poisson::computeElectronicParameters: band gap cannot be zero!\");\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nvoid Poisson::setFirstGuess() {\n\tMeshNode ***pNode = _pMesh->getNodes();\n\tconst IO::ParameterManager *pPM = Domains::global()->PM();\n\tconst OKMC::MobileParticleParam *pMPP = _pDomain->_pMPPar;\n\n\tfor (size_t ix = 0; ix < _nx; ++ix) {\n\t\tfor (size_t iy = 0; iy < _ny; ++iy) {\n\t\t\tfor (size_t iz = 0; iz < _nz; ++iz) {\n\t\t\t\tif (pNode[ix][iy][iz]._active) {\n\t\t\t\t\tconst unsigned i = pNode[ix][iy][iz]._index;\n\t\t\t\t\tdouble n = 0;\n\n\t\t\t\t\tfor(M_TYPE mt = 0; mt < pPM->getNMaterials(); ++mt)\n\t\t\t\t\t\tfor(P_TYPE pt = pPM->getNFamilies(); pt < pPM->getNParticles(); ++pt)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tP_TYPE fam = pPM->getFamily(pt);\n\t\t\t\t\t\t\tP_POS pos = pPM->getPPos(pt);\n\t\t\t\t\t\t\tif(fam == V_TYPE || fam == pPM->getMaterial(mt)._pt[0] || fam == pPM->getMaterial(mt)._pt[1] ||\n\t\t\t\t\t\t\t\tpos == POS_I || pos == POS_V)\n\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\tif(!_Nokmc[mt][pt].empty() && _Nokmc[mt][pt](i) > 0)\n\t\t\t\t\t\t\t\tn += pMPP->_state2charge[mt][pt][0]; //impurities and dopants only have state 0!\n\t\t\t\t\t\t}\n\n\t\t\t\t\tif (n > 0.)\n\t\t\t\t\t\t_psi(i) = 0.5 * getEg(&pNode[ix][iy][iz]);\n\t\t\t\t\telse if (n < 0.)\n\t\t\t\t\t\t_psi(i) = - 0.5 * getEg(&pNode[ix][iy][iz]);\n\t\t\t\t\telse\n\t\t\t\t\t\t_psi(pNode[ix][iy][iz]._index) = 0;\n\n\t\t\t\t\tfor(M_TYPE mt = 0; mt < pPM->getNMaterials(); ++mt) {\n\t\t\t\t\t\tif (!_Nlkmc[mt].empty() && _Nlkmc[mt](i) > 0) {\n\t\t\t\t\t\t\t_psi(i) = 0;\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}\n}\n\nvoid Poisson::setT(double T)\n{\n\tif (_T != T)\n\t{\n\t\t_T = T;\n\t\tMEDMSG(\"Building vector for OKMC particles...\");\n\t\tbuildOKMCVector();\n\n\t\tif (_selfConsistentLKMC)\n\t\t\tbuildLKMCVector();\n\n\t\tMEDMSG(\"Building Laplacian matrix...\");\n\t\tbuildLaplacianMatrix();\n\t\tcomputeElectronicParameters(T);\n\t\tsetFirstGuess();\n\t}\n}\n\nbool Poisson::compute() {\n\tMEDMSG(\"Building vector for OKMC particles...\");\n\tbuildOKMCVector();\n\n\tif (_selfConsistentLKMC)\n\t\tbuildLKMCVector();\n\n\tMEDMSG(\"Solving non-linear Poisson equation...\");\n\n\tif (! NewtonRaphson())\n\t\tERRORMSG(\"Poisson::NewtonRaphson did not converged!\");\n\n\tmap2Nodes();\n\tmap2Elements();\n\n\treturn true;\n}\n\ndouble Poisson::getDEc(MeshNode *pNode) {\n\tconst double kT = KB / Q * _T;\n\n\tstd::set s;\n\n\tdouble DEc = 0;\n\t_pMesh->getElementsFromNode(pNode, s);\n\n\tfor (std::set::const_iterator it = s.begin(); it != s.end(); ++it) {\n\t\tconst M_TYPE mt = (*it)->getMaterial();\n\n\t\t// ublas::vector DEci = ublas::zero_vector(3);\n\n\t\tdouble tmp = 0;\n\t\tfor (unsigned i = 0; i < 3; ++i) {\n\t\t\t// const ublas::vector E = (*it)->strain();\n\t\t\tublas::vector E = ublas::zero_vector(3);\n\n\t\t\tconst double Dc = (_matParam[mt]._Dc.size() > 0 ? _matParam[mt]._Dc(i) : 0);\n\t\t\tconst double Dcx = (_matParam[mt]._Dcx.size() > 0 ? _matParam[mt]._Dcx(i) : 0);\n\t\t\tconst double Dcy = (_matParam[mt]._Dcy.size() > 0 ? _matParam[mt]._Dcy(i) : 0);\n\t\t\tconst double Dcz = (_matParam[mt]._Dcz.size() > 0 ? _matParam[mt]._Dcz(i) : 0);\n\n\t\t\ttmp += exp(- (Dc * (E(0) + E(1) + E(2)) + Dcx * E(0) + Dcy * E(1) + Dcz * E(2))/ kT);\n\t\t}\n\n\t\tDEc += ELECTRONVOLT_TO_HARTREE(-kT * log(1./3. * tmp));\n\n\t\tif (Domains::global()->PM()->getMaterialName(mt) == \"Silicon\")\n\t\t\tLOWMSG(\"DEc:\" << DEc / static_cast(s.size()));\n\t}\n\n\treturn (DEc / static_cast(s.size()));\n}\n\ndouble Poisson::getNc(MeshNode *pNode) {\n\tstd::set s;\n\tdouble Nc = 0;\n\t_pMesh->getElementsFromNode(pNode, s);\n\n\tfor (std::set::const_iterator it = s.begin(); it != s.end(); ++it)\n\t\tNc += _matParam[(*it)->getMaterial()]._Nc;\n\n\treturn (Nc / static_cast(s.size()));\n}\n\ndouble Poisson::getNv(MeshNode *pNode) {\n\tstd::set s;\n\tdouble Nv = 0;\n\t_pMesh->getElementsFromNode(pNode, s);\n\n\tfor (std::set::const_iterator it = s.begin(); it != s.end(); ++it)\n\t\tNv += _matParam[(*it)->getMaterial()]._Nv;\n\n\treturn (Nv / static_cast(s.size()));\n}\n\ndouble Poisson::getEg(MeshNode *pNode) {\n\tstd::set s;\n\tdouble Eg = 0;\n\t_pMesh->getElementsFromNode(pNode, s);\n\n\tfor (std::set::const_iterator it = s.begin(); it != s.end(); ++it)\n\t\tEg += _matParam[(*it)->getMaterial()]._Eg;\n\n\treturn (Eg / static_cast(s.size()));\n}\n\ndouble Poisson::getEg0(MeshNode *pNode) {\n\tstd::set s;\n\tdouble Eg0 = 0;\n\t_pMesh->getElementsFromNode(pNode, s);\n\n\tfor (std::set::const_iterator it = s.begin(); it != s.end(); ++it)\n\t\tEg0 += _matParam[(*it)->getMaterial()]._Eg0;\n\n\treturn (Eg0 / static_cast(s.size()));\n}\n\n// OBSOLETE METHOD\n// Do NOT call!\n/* double Poisson::getLA(MeshNode *pNode) {\n\tdouble w = 0.;\n\n\tfor (std::map::iterator it = pNode->_mLA.begin(); it !=pNode->_mLA.end(); ++it)\n\t\tw += it->second;\n\n\treturn w;\n} */\n\nvoid Poisson::map2Nodes() {\n\tMeshNode ***pNode = _pMesh->getNodes();\n\n\tfor (unsigned ix = 0; ix < _nx; ++ix) {\n\t\tfor (unsigned iy = 0; iy < _ny; ++iy) {\n\t\t\tfor (unsigned iz = 0; iz < _nz; ++iz) {\n\t\t\t\tif (pNode[ix][iy][iz]._active) {\n\t\t\t\t\tpNode[ix][iy][iz]._V = HARTREE_TO_ELECTRONVOLT(_psi(pNode[ix][iy][iz]._index));\n\t\t\t\t\tpNode[ix][iy][iz]._Eg = HARTREE_TO_ELECTRONVOLT(_Eg(pNode[ix][iy][iz]._index));\n\t\t\t\t\tpNode[ix][iy][iz]._Eg0 = HARTREE_TO_ELECTRONVOLT(_Eg0(pNode[ix][iy][iz]._index));\n\t\t\t\t\tpNode[ix][iy][iz]._Ec = HARTREE_TO_ELECTRONVOLT(0.5 * getEg(&pNode[ix][iy][iz]) - _psi(pNode[ix][iy][iz]._index));\n\t\t\t\t\tpNode[ix][iy][iz]._Ev = HARTREE_TO_ELECTRONVOLT(- 0.5 * getEg(&pNode[ix][iy][iz]) - _psi(pNode[ix][iy][iz]._index));\n\t\t\t\t\tpNode[ix][iy][iz]._eDensity = _Qe(pNode[ix][iy][iz]._index) / (pNode[ix][iy][iz]._volume * 1e-21);\n\t\t\t\t\tpNode[ix][iy][iz]._hDensity = _Qh(pNode[ix][iy][iz]._index) / (pNode[ix][iy][iz]._volume * 1e-21);\n\n\t\t\t\t\t// pNode[ix][iy][iz]._N_okmc = _Qokmc(pNode[ix][iy][iz]._index) / (pNode[ix][iy][iz]._volume * 1e-27); // FIXME\n\n\t\t\t\t\tif (ix > 0 && ix < (_nx - 1) && iy > 0 && iy < (_ny - 1) && iz > 0 && iz < (_nz - 1)) {\n\t\t\t\t\t\tif (pNode[ix-1][iy][iz]._index < 0)\n\t\t\t\t\t\t\tcontinue ;\n\t\t\t\t\t\tif (pNode[ix+1][iy][iz]._index < 0)\n\t\t\t\t\t\t\tcontinue ;\n\t\t\t\t\t\tif (pNode[ix][iy-1][iz]._index < 0)\n\t\t\t\t\t\t\tcontinue ;\n\t\t\t\t\t\tif (pNode[ix][iy+1][iz]._index < 0)\n\t\t\t\t\t\t\tcontinue ;\n\t\t\t\t\t\tif (pNode[ix][iy][iz-1]._index < 0)\n\t\t\t\t\t\t\tcontinue ;\n\t\t\t\t\t\tif (pNode[ix][iy][iz+1]._index < 0)\n\t\t\t\t\t\t\tcontinue ;\n\n\t\t\t\t\t\tconst double dxp = pNode[ix+1][iy][iz]._coord._x - pNode[ix][iy][iz]._coord._x;\n\t\t\t\t\t\tconst double dxm = pNode[ix][iy][iz]._coord._x - pNode[ix-1][iy][iz]._coord._x;\n\t\t\t\t\t\tconst double dyp = pNode[ix][iy+1][iz]._coord._y - pNode[ix][iy][iz]._coord._y;\n\t\t\t\t\t\tconst double dym = pNode[ix][iy][iz]._coord._y - pNode[ix][iy-1][iz]._coord._y;\n\t\t\t\t\t\tconst double dzp = pNode[ix][iy][iz+1]._coord._z - pNode[ix][iy][iz]._coord._z;\n\t\t\t\t\t\tconst double dzm = pNode[ix][iy][iz]._coord._z - pNode[ix][iy][iz-1]._coord._z;\n\n\t\t\t\t\t\tconst double Vxp = HARTREE_TO_ELECTRONVOLT(_psi(pNode[ix+1][iy][iz]._index));\n\t\t\t\t\t\tconst double Vxm = HARTREE_TO_ELECTRONVOLT(_psi(pNode[ix-1][iy][iz]._index));\n\t\t\t\t\t\tconst double Vyp = HARTREE_TO_ELECTRONVOLT(_psi(pNode[ix][iy+1][iz]._index));\n\t\t\t\t\t\tconst double Vym = HARTREE_TO_ELECTRONVOLT(_psi(pNode[ix][iy-1][iz]._index));\n\t\t\t\t\t\tconst double Vzp = HARTREE_TO_ELECTRONVOLT(_psi(pNode[ix][iy][iz+1]._index));\n\t\t\t\t\t\tconst double Vzm = HARTREE_TO_ELECTRONVOLT(_psi(pNode[ix][iy][iz-1]._index));\n\n\t\t\t\t\t\tconst double V = HARTREE_TO_ELECTRONVOLT(_psi(pNode[ix][iy][iz]._index));\n\n\t\t\t\t\t\tpNode[ix][iy][iz]._E = ublas::zero_vector(3); // electric field in eV/nm\n\t\t\t\t\t\tpNode[ix][iy][iz]._E(0) = - 0.5 * ((Vxp - V) / dxp + (V - Vxm) / dxm);\n\t\t\t\t\t\tpNode[ix][iy][iz]._E(1) = - 0.5 * ((Vyp - V) / dyp + (V - Vym) / dym);\n\t\t\t\t\t\tpNode[ix][iy][iz]._E(2) = - 0.5 * ((Vzp - V) / dzp + (V - Vzm) / dzm);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nvoid Poisson::map2Elements() {\n\tfor(Kernel::Mesh::iterator it = _pMesh->begin(); it != _pMesh->end(); ++it)\n\t{\n\t\tstd::set s;\n\t\tconst M_TYPE mt = it->getMaterial();\n\n\t\t_pMesh->getNodesFromElement(&(*it), s);\n\n\t\tif (s.empty())\n\t\t\tERRORMSG(\"Poisson::map2Elements: cannot find nodes of element \" << it->getIndex());\n\n\t\tdouble V = 0;\n\t\tfor (std::set::const_iterator i = s.begin(); i != s.end(); ++i)\n\t\t\tV += (*i)->_V;\n\n\t\tit->electrostaticPotential() = V / static_cast(s.size());\n\t\tit->bandGap() = HARTREE_TO_ELECTRONVOLT(_matParam[mt]._Eg);\n\t}\n}\n\nbool Poisson::NewtonRaphson() {\n\tMeshNode ***pNode = _pMesh->getNodes();\n\tconst double kT = ELECTRONVOLT_TO_HARTREE(KB / Q * _T);\n\tconst IO::ParameterManager *pPM = Domains::global()->PM();\n\tconst OKMC::MobileParticleParam *pMPP = _pDomain->_pMPPar;\n\tbool ret = false;\n\n\tublas::vector deltaPsi = ublas::zero_vector(_nx * _ny * _nz);\n\tublas::vector err = ublas::zero_vector(_nx * _ny * _nz);\n\tublas::vector totCharge = ublas::zero_vector(_nx * _ny * _nz);\n\n\t// ublas::vector Qtmp = ublas::zero_vector(_nx * _ny * _nz);\n\n\tboost::timer t;\n\tt.restart();\n\n\tfor (size_t it = 0; it < _NR_maxIter; ++it) {\n\t\tublas::compressed_matrix J = _laplacian;\n\n\t\tfor (size_t ix = 0; ix < _nx; ++ix) {\n\t\t\tfor (size_t iy = 0; iy < _ny; ++iy) {\n\t\t\t\tfor (size_t iz = 0; iz < _nz; ++iz) {\n\t\t\t\t\tif (pNode[ix][iy][iz]._active) {\n\t\t\t\t\t\tconst size_t i = pNode[ix][iy][iz]._index;\n\n\t\t\t\t\t\tdouble dQe = 0.;\n\t\t\t\t\t\tdouble dQh = 0.;\n\t\t\t\t\t\tdouble dQokmc = 0;\n\t\t\t\t\t\tdouble dQlkmc_M = 0.;\n\t\t\t\t\t\tdouble dQlkmc_P = 0.;\n\n\t\t\t\t\t\tconst double Ef = 0;\n\t\t\t\t\t\tconst double CBM = 0.5 * _Eg(i) - _psi(i);\n\t\t\t\t\t\tconst double VBM = - 0.5 * _Eg(i) - _psi(i);\n\n\t\t\t\t\t\tconst double EfEc = Ef - CBM;\n\t\t\t\t\t\tconst double EvEf = VBM - Ef;\n\t\t\t\t\t\t// const double EfEc = _psi(i) - 0.5 * _Eg(i);\n\t\t\t\t\t\t// const double EvEf = - _psi(i) - 0.5 * _Eg(i);\n\n\t\t\t\t\t\t_Qokmc(i) = 0;\n\t\t\t\t\t\t_Qlkmc_M(i) = 0.;\n\t\t\t\t\t\t_Qlkmc_P(i) = 0.;\n\n\t\t\t\t\t\tif (_FermiDirac) {\n\t\t\t\t\t\t\tdQe = _Nc(i) / kT * FermiDirac::mhalf(EfEc / kT);\n\t\t\t\t\t\t\tdQh = - _Nv(i) / kT * FermiDirac::mhalf(EvEf / kT);\n\t\t\t\t\t\t\t_Qe(i) = _Nc(i) * FermiDirac::phalf(EfEc / kT);\n\t\t\t\t\t\t\t_Qh(i) = _Nv(i) * FermiDirac::phalf(EvEf / kT);\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\tdQe = _Nc(i) / kT * exp(EfEc / kT);\n\t\t\t\t\t\t\tdQh = - _Nv(i) / kT * exp(EvEf / kT);\n\t\t\t\t\t\t\t_Qe(i) = _Nc(i) * exp(EfEc / kT);\n\t\t\t\t\t\t\t_Qh(i) = _Nv(i) * exp(EvEf / kT);\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tfor(M_TYPE mt = 0; mt < pPM->getNMaterials(); ++mt)\n\t\t\t\t\t\t{// OKMC\n\t\t\t\t\t\t\tfor(P_TYPE pt = pPM->getNFamilies(); pt < pPM->getNParticles(); ++pt)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tP_TYPE fam = pPM->getFamily(pt);\n\t\t\t\t\t\t\t\tP_POS pos = pPM->getPPos(pt);\n\t\t\t\t\t\t\t\tif(fam == V_TYPE || fam == pPM->getMaterial(mt)._pt[0] || fam == pPM->getMaterial(mt)._pt[1] ||\n\t\t\t\t\t\t\t\t\t\tpos == POS_I || pos == POS_V)\n\t\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t\tif (! _Nokmc[mt][pt].empty() && _Nokmc[mt][pt](i) > 0)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tif (pMPP->_state2charge[mt][pt][0] == 1) { //DONOR\n\t\t\t\t\t\t\t\t\t\tif (_partialIonization) {\n\t\t\t\t\t\t\t\t\t\t\t// const double E = _psi(i) - 0.5 * _Eg(i) + _Eg(i) / _Eg0(i) * ELECTRONVOLT_TO_HARTREE(pMPP->_stateEnergy[mt][pt]);\n\t\t\t\t\t\t\t\t\t\t\tconst double E = Ef - (CBM - _Eg(i) / _Eg0(i) * ELECTRONVOLT_TO_HARTREE(pMPP->_stateEnergy[mt][pt]));\n\t\t\t\t\t\t\t\t\t\t\t_Qokmc(i) += _Nokmc[mt][pt](i) / (1. + pMPP->_stateDegeneracy[mt][pt] * exp(E / kT));\n\t\t\t\t\t\t\t\t\t\t\tdQokmc += - _Nokmc[mt][pt](i) * pMPP->_stateDegeneracy[mt][pt] / kT * exp(E / kT) / pow(1. + pMPP->_stateDegeneracy[mt][pt] * exp(E / kT), 2);\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\telse {\n\t\t\t\t\t\t\t\t\t\t\t_Qokmc(i) += _Nokmc[mt][pt](i);\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\telse if (pMPP->_state2charge[mt][pt][0] == -1) { //ACCEPTOR\n\t\t\t\t\t\t\t\t\t\tif (_partialIonization) {\n\t\t\t\t\t\t\t\t\t\t\t// const double E = - _psi(i) - 0.5 * _Eg(i) + _Eg(i) / _Eg0(i) * ELECTRONVOLT_TO_HARTREE(pMPP->_stateEnergy[mt][pt]);\n\t\t\t\t\t\t\t\t\t\t\tconst double E = (VBM + _Eg(i) / _Eg0(i) * ELECTRONVOLT_TO_HARTREE(pMPP->_stateEnergy[mt][pt])) - Ef;\n\t\t\t\t\t\t\t\t\t\t\t_Qokmc(i) -= _Nokmc[mt][pt](i) / (1. + pMPP->_stateDegeneracy[mt][pt] * exp(E / kT));\n\t\t\t\t\t\t\t\t\t\t\tdQokmc -= _Nokmc[mt][pt](i) * pMPP->_stateDegeneracy[mt][pt] / kT * exp(E / kT) / pow(1. + pMPP->_stateDegeneracy[mt][pt] * exp(E / kT), 2);\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\telse {\n\t\t\t\t\t\t\t\t\t\t\t_Qokmc(i) -= _Nokmc[mt][pt](i);\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// LKMC\n\t\t\t\t\t\t\t/*\n\t\t\t\t\t\t\tif (_selfConsistentGFLS && _Nlkmc[mt].empty() == false && _Nlkmc[mt](i) > 0.) {\n\t\t\t\t\t\t\t\tif (_pDomain->_pLat[mt]->getType() != LKMC::LatticeParam::DIAMOND_1) {\n\t\t\t\t\t\t\t\t\tERRORMSG(\"Poisson::NewtonRaphson does not support \" << pPM->getMaterialName(mt) << \" lattice.\");\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tLKMC::LatticeDiamondParam *pLDP = static_cast(_pDomain->_pLaPar[mt]);\n\n\t\t\t\t\t\t\t\tconst double E_lkmc_M = _psi(i) - 0.5 * _Eg(i) + _Eg(i) / _Eg0(i) * ELECTRONVOLT_TO_HARTREE(pLDP->_E_M0); // Ef - E(0,-)\n\t\t\t\t\t\t\t\tconst double E_lkmc_P = - _psi(i) - 0.5 * _Eg(i) + _Eg(i) / _Eg0(i) * ELECTRONVOLT_TO_HARTREE(pLDP->_E_P0); // E(+,0) - Ef\n\n\t\t\t\t\t\t\t\tconst double g_M = pLDP->_g_M;\n\t\t\t\t\t\t\t\tconst double g_0 = pLDP->_g_0;\n\t\t\t\t\t\t\t\tconst double g_P = pLDP->_g_P;\n\n\t\t\t\t\t\t\t\tdQlkmc_M += _Nc(i) / _Nlkmc[mt](i) * 1. / kT * g_M / g_0 * exp(E_lkmc_M / kT);\n\t\t\t\t\t\t\t\tdQlkmc_P += - _Nv(i) / _Nlkmc[mt](i) * 1. / kT * g_P / g_0 * exp(E_lkmc_P / kT);\n\t\t\t\t\t\t\t\t_Qlkmc_M(i) += _Nc(i) / _Nlkmc[mt](i) * g_M / g_0 * exp(E_lkmc_M / kT);\n\t\t\t\t\t\t\t\t_Qlkmc_P(i) += _Nv(i) / _Nlkmc[mt](i) * g_P / g_0 * exp(E_lkmc_P / kT);\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif (_selfConsistentGFLS2 && _Nlkmc[mt].empty() == false && _Nlkmc[mt](i) > 0.) {\n\t\t\t\t\t\t\t\tif (_pDomain->_pLat[mt]->getType() != LKMC::LatticeParam::DIAMOND_1) {\n\t\t\t\t\t\t\t\t\tERRORMSG(\"Poisson::NewtonRaphson does not support \" << pPM->getMaterialName(mt) << \" lattice.\");\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tLKMC::LatticeDiamondParam *pLDP = static_cast(_pDomain->_pLaPar[mt]);\n\n\t\t\t\t\t\t\t\t// const double Ef = 0;\n\t\t\t\t\t\t\t\t// const double VBM = - V - 0.5 * Eg;\n\n\t\t\t\t\t\t\t // Note: defect level scales with bandgap\n\t\t\t\t\t\t\t\tconst double E_lkmc_M = Ef - (VBM + _Eg(i) / _Eg0(i) * ELECTRONVOLT_TO_HARTREE(pLDP->_E_M0)); // Ef - E(0,-)\n\t\t\t\t\t\t\t\tconst double E_lkmc_P = (VBM + _Eg(i) / _Eg0(i) * ELECTRONVOLT_TO_HARTREE(pLDP->_E_P0)) - Ef; // Ef - E(0,-)\n\n\t\t\t\t\t\t\t\tconst double g_M = pLDP->_g_M;\n\t\t\t\t\t\t\t\tconst double g_0 = pLDP->_g_0;\n\t\t\t\t\t\t\t\tconst double g_P = pLDP->_g_P;\n\n\t\t\t\t\t\t\t\tconst double den_M = 1. + (g_0 / g_M) * exp( - E_lkmc_M / kT) + (g_P / g_M) * exp((E_lkmc_P - E_lkmc_M) / kT);\n\t\t\t\t\t\t\t\tconst double den_P = 1. + (g_0 / g_P) * exp( - E_lkmc_P / kT) + (g_M / g_P) * exp((E_lkmc_M - E_lkmc_P) / kT);\n\n\t\t\t\t\t\t\t\tdQlkmc_M += _Nlkmc[mt](i) * (1. / kT * (g_0 / g_M) * exp( - E_lkmc_M / kT) + 2. / kT * (g_P / g_M) * exp((E_lkmc_P - E_lkmc_M)/ kT)) / (den_M * den_M);\n\t\t\t\t\t\t\t\tdQlkmc_P += - _Nlkmc[mt](i) * (1. / kT * (g_0 / g_P) * exp( - E_lkmc_P / kT) + 2. / kT * (g_M / g_P) * exp((E_lkmc_M - E_lkmc_P)/ kT)) / (den_P * den_P);\n\t\t\t\t\t\t\t\t_Qlkmc_M(i) += _Nlkmc[mt](i) / den_M;\n\t\t\t\t\t\t\t\t_Qlkmc_P(i) += _Nlkmc[mt](i) / den_P;\n\t\t\t\t\t\t\t}*/\n\n\t\t\t\t\t\t\tif (_selfConsistentLKMC && _Nlkmc[mt].empty() == false && _Nlkmc[mt](i) > 0.) {\n\t\t\t\t\t\t\t\tif (_pDomain->_pLat[mt]->getType() != LKMC::LatticeParam::DIAMOND) {\n\t\t\t\t\t\t\t\t\tERRORMSG(\"Poisson::NewtonRaphson does not support \" << pPM->getMaterialName(mt) << \" lattice.\");\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tconst LKMC::LatticeDiamondParam *pLDP = static_cast(_pDomain->_pLaPar[mt]);\n\n\t\t\t\t\t\t\t\tconst double E_lkmc_M = _psi(i) - 0.5 * _Eg(i) + _Eg(i) / _Eg0(i) * ELECTRONVOLT_TO_HARTREE(pLDP->_E_M0); // Ef - E(0,-)\n\t\t\t\t\t\t\t\tconst double E_lkmc_P = - _psi(i) - 0.5 * _Eg(i) + _Eg(i) / _Eg0(i) * ELECTRONVOLT_TO_HARTREE(pLDP->_E_P0); // E(+,0) - Ef\n\n\t\t\t\t\t\t\t\tconst double g_M = pLDP->_g_M;\n\t\t\t\t\t\t\t\tconst double g_0 = pLDP->_g_0;\n\t\t\t\t\t\t\t\tconst double g_P = pLDP->_g_P;\n\n\t\t\t\t\t\t\t\tconst double den_M = 1. + (g_0 / g_M) * exp( - E_lkmc_M / kT) + (g_P / g_M) * exp((E_lkmc_P - E_lkmc_M) / kT);\n\t\t\t\t\t\t\t\tconst double den_P = 1. + (g_0 / g_P) * exp( - E_lkmc_P / kT) + (g_M / g_P) * exp((E_lkmc_M - E_lkmc_P) / kT);\n\n\t\t\t\t\t\t\t\tdQlkmc_M += _Nlkmc[mt](i) * (1. / kT * (g_0 / g_M) * exp( - E_lkmc_M / kT) + 2. / kT * (g_P / g_M) * exp((E_lkmc_P - E_lkmc_M)/ kT)) / (den_M * den_M);\n\t\t\t\t\t\t\t\tdQlkmc_P += - _Nlkmc[mt](i) * (1. / kT * (g_0 / g_P) * exp( - E_lkmc_P / kT) + 2. / kT * (g_M / g_P) * exp((E_lkmc_M - E_lkmc_P)/ kT)) / (den_P * den_P);\n\t\t\t\t\t\t\t\t_Qlkmc_M(i) += _Nlkmc[mt](i) / den_M;\n\t\t\t\t\t\t\t\t_Qlkmc_P(i) += _Nlkmc[mt](i) / den_P;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tJ(i,i) -= 4. * M_PI * (dQh - dQe + dQokmc + dQlkmc_P - dQlkmc_M);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tublas::noalias(totCharge) = _Qh - _Qe + _Qokmc + _Qeff + _Qlkmc_P - _Qlkmc_M;\n\t\tublas::noalias(err) = - ublas::prod(_laplacian, _psi) + 4 * M_PI * totCharge;\n\n\t\tif (ublas::norm_2(err) < _NR_tol) {\n\t\t\tret = true;\n\t\t\tif (_NR_verbose > 0)\n\t\t\t\tLOWMSG(\"Poisson::NewtonRaphson converged in \" << it << \" iterations (\" << t.elapsed() << \" s)\");\n\n\t\t\tbreak ;\n\t\t}\n\t\tif (_NR_verbose > 1)\n\t\t\tLOWMSG(\"Poisson::NewtonRaphson iteration \" << it << \" error= \" << ublas::norm_2(err) << \" (\" << t.elapsed() << \" s)\");\n\n\t\tdeltaPsi = ublas::zero_vector(_nx * _ny * _nz);\n\n\t\tif (! ConjugateGradient(J, deltaPsi, err))\n\t\t\tERRORMSG(\"Poisson::CG did not converged\");\n\n\t\t_psi += deltaPsi;\n\t}\n\n\treturn ret;\n}\n\nbool Poisson::ConjugateGradient(const ublas::compressed_matrix &A, ublas::vector &x, const ublas::vector &b) {\n\tboost::timer t;\n\tt.restart();\n\n\tublas::vector a;\n\n\tbool ret = false;\n\tublas::vector p = ublas::zero_vector(x.size());\n\tublas::vector r = ublas::zero_vector(x.size());\n\n\n\tublas::noalias(r) = b - ublas::prod(A, x);\n\tublas::noalias(p) = r;\n\n\tfor (size_t it = 0; it < _CG_maxIter; ++it) {\n\t\tif (ublas::norm_2(r) < _CG_tol) {\n\n\t\t\tif (_CG_verbose > 0)\n\t\t\t\tLOWMSG(\"Poisson::CG solved in \" << it << \" iterations (\" << t.elapsed() << \" s)\");\n\n\t\t\tret = true;\n\t\t\tbreak ;\n\t\t}\n\t\tif (_CG_verbose > 1) {\n\t\t\tLOWMSG(\"Poisson::CG iteration \" << it << \" error= \" << ublas::norm_2(r) << \" (\" << t.elapsed() << \" s)\");\n\t\t}\n\n\t\ta = ublas::zero_vector(x.size());\n\t\tublas::noalias(a) = ublas::prod(A, p);\n\n\t\tdouble lambda = ublas::inner_prod(r, p) / ublas::inner_prod(a, p);\n\n\t\tx += lambda * p;\n\t\tr -= lambda * a;\n\n\t\tp = r - (ublas::inner_prod(r, a) / ublas::inner_prod(a, p)) * p;\n\t}\n\n\treturn (ret);\n}\n\n// This method is for test purpose only\nvoid Poisson::testPN() {\n\tMeshNode ***pNode = _pMesh->getNodes();\n\n\tfor (size_t ix = 0; ix < _nx; ++ix)\n\t\tfor (size_t iy = 0; iy < _ny; ++iy)\n\t\t\tfor (size_t iz = 0; iz < _nz; ++iz)\n\t\t\t\tif (pNode[ix][iy][iz]._active) {\n\t\t\t\t\tif (ix < _nx / 2)\n\t\t\t\t\t\t_Qokmc(pNode[ix][iy][iz]._index) = .01;\n\t\t\t\t\telse\n\t\t\t\t\t\t_Qokmc(pNode[ix][iy][iz]._index) = -.005;\n\n\t\t\t\t\tif (ix == 0 || ix == _nx - 1 || iy == 0 || iy == _ny - 1 || iz == 0 || iz == _nz - 1)\n\t\t\t\t\t\t_Qokmc(pNode[ix][iy][iz]._index) *= .5;\n\t\t\t\t}\n}\n\nvoid Poisson::buildOKMCVector() {\n\tMeshNode ***pNode = _pMesh->getNodes();\n\tconst IO::ParameterManager *pPM = Domains::global()->PM();\n\n\tfor(M_TYPE mt = 0; mt < pPM->getNMaterials(); ++mt) {\n\t\tfor(P_TYPE pt = 0; pt < pPM->getNParticles(); ++pt) {\n\t\t\tif (!_Nokmc[mt][pt].empty()) {\n\t\t\t\t_Nokmc[mt][pt] = ublas::zero_vector(_nx * _ny * _nz);\n\t\t\t}\n\t\t}\n\t}\n\n\tfor (size_t ix = 0; ix < _nx; ++ix) {\n\t\tfor (size_t iy = 0; iy < _ny; ++iy) {\n\t\t\tfor (size_t iz = 0; iz < _nz; ++iz) {\n\t\t\t\tif (pNode[ix][iy][iz]._active && !pNode[ix][iy][iz]._mPart.empty()) {\n\t\t\t\t\tfor (std::map::const_iterator it = pNode[ix][iy][iz]._mPart.begin(); it != pNode[ix][iy][iz]._mPart.end(); ++it) {\n\t\t\t\t\t\tconst OKMC::Particle * pPart = it->first;\n\t\t\t\t\t\tconst M_TYPE mt = pPart->getElement()->getMaterial();\n\t\t\t\t\t\tconst P_TYPE pt = pPart->getPType();\n\t\t\t\t\t\tif(_Nokmc[mt][pt].empty()) //particle not mapped.\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t_Nokmc[mt][pt](pNode[ix][iy][iz]._index) += it->second;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nvoid Poisson::buildLKMCVector() {\n\tMeshNode ***pNode = _pMesh->getNodes();\n\tconst IO::ParameterManager *pPM = Domains::global()->PM();\n\n\tfor(M_TYPE mt = 0; mt < pPM->getNMaterials(); ++mt)\n\t\tif (!_Nlkmc[mt].empty())\n\t\t{\n\t\t\t_Nlkmc[mt] = ublas::zero_vector(_nx * _ny * _nz);\n\t\t\tfor (size_t ix = 0; ix < _nx; ++ix)\n\t\t\t\tfor (size_t iy = 0; iy < _ny; ++iy)\n\t\t\t\t\tfor (size_t iz = 0; iz < _nz; ++iz)\n\t\t\t\t\t\tif (pNode[ix][iy][iz]._active && !pNode[ix][iy][iz]._mLA.empty())\n\t\t\t\t\t\t\tfor (std::map::const_iterator it = pNode[ix][iy][iz]._mLA.begin(); it != pNode[ix][iy][iz]._mLA.end(); ++it)\n\t\t\t\t\t\t\t\tif (/*!it->first->getDefective() && */!it->first->getPerformed())\n\t\t\t\t\t\t\t\t\t_Nlkmc[mt](pNode[ix][iy][iz]._index) += it->second;\n\t\t}\n}\n\ndouble Poisson::getPermittivity(MeshNode *n1, MeshNode *n2, MeshNode *n3) {\n\tdouble eps = 0.;\n\n\tstd::set s1;\n\tstd::set s2;\n\tstd::set s3;\n\n\t_pMesh->getElementsFromNode(n1, s1);\n\t_pMesh->getElementsFromNode(n2, s2);\n\t_pMesh->getElementsFromNode(n3, s3);\n\n\tfor(std::set::const_iterator it = s1.begin(); it != s1.end(); ++it)\n\t\tif (s2.find(*it) != s2.end() && s3.find(*it) != s3.end()) {\n\t\t\t// eps = Domains::global()->PM()->getPermittivity((*it)->getMaterial());\n\t\t\teps = Domains::global()->PM()->getMaterial((*it)->getMaterial())._permittivity;\n\t\t\tbreak ;\n\t\t}\n\n\treturn eps;\n}\n\nvoid Poisson::buildLaplacianMatrix() {\n\tdouble dxm;\n\tdouble dxp;\n\tdouble dym;\n\tdouble dyp;\n\tdouble dzm;\n\tdouble dzp;\n\n\tMeshNode ***pNode = _pMesh->getNodes();\n\n\t_laplacian = ublas::compressed_matrix (_nx * _ny * _nz, _nx * _ny * _nz);\n\t_Qeff = ublas::zero_vector (_nx * _ny * _nz);\n\n\tfor (unsigned ix = 0; ix < _pMesh->getnx(); ++ix) {\n\t\tfor (unsigned iy = 0; iy < _pMesh->getny(); ++iy) {\n\t\t\tfor (unsigned iz = 0; iz < _pMesh->getnz(); ++iz) {\n\n\t\t\t\tif (pNode[ix][iy][iz]._active) {\n\t\t\t\t\tdouble a[6] = {};\n\n\t\t\t\t\tunsigned ixm = ix - 1;\n\t\t\t\t\tunsigned ixp = ix + 1;\n\t\t\t\t\tunsigned iym = iy - 1;\n\t\t\t\t\tunsigned iyp = iy + 1;\n\t\t\t\t\tunsigned izm = iz - 1;\n\t\t\t\t\tunsigned izp = iz + 1;\n\n\t\t\t\t\t// xm\n\t\t\t\t\tif (ix == 0) {\n\t\t\t\t\t\tixm = (_pMesh->getPeriodicX() ? _nx-1 : ix);\n\t\t\t\t\t\tdxm = (_pMesh->getPeriodicX() ? pNode[_nx][iy][iz]._coord._x - pNode[_nx-1][iy][iz]._coord._x : 0);\n\t\t\t\t\t} else\n\t\t\t\t\t\tdxm = pNode[ix][iy][iz]._coord._x - pNode[ixm][iy][iz]._coord._x;\n\t\t\t\t\t// xp\n\t\t\t\t\tif (ix == _nx - 1) {\n\t\t\t\t\t\tixp = (_pMesh->getPeriodicX() ? 0 : _nx-1);\n\t\t\t\t\t\tdxp = (_pMesh->getPeriodicX() ? pNode[_nx][iy][iz]._coord._x - pNode[_nx-1][iy][iz]._coord._x : 0);\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t\tdxp = pNode[ixp][iy][iz]._coord._x - pNode[ix][iy][iz]._coord._x;\n\t\t\t\t\t// ym\n\t\t\t\t\tif (iy == 0) {\n\t\t\t\t\t\tiym = (_pMesh->getPeriodicY() ? _ny-1 : iy);\n\t\t\t\t\t\tdym = (_pMesh->getPeriodicY() ? pNode[ix][_ny][iz]._coord._y - pNode[ix][_ny-1][iz]._coord._y : 0);\n\t\t\t\t\t} else\n\t\t\t\t\t\tdym = pNode[ix][iy][iz]._coord._y - pNode[ix][iym][iz]._coord._y;\n\t\t\t\t\t// yp\n\t\t\t\t\tif (iy == _ny - 1) {\n\t\t\t\t\t\tiyp = (_pMesh->getPeriodicY() ? 0 : _ny-1);\n\t\t\t\t\t\tdyp = (_pMesh->getPeriodicY() ? pNode[ix][_ny][iz]._coord._y - pNode[ix][_ny-1][iz]._coord._y : 0);\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t\tdyp = pNode[ix][iyp][iz]._coord._y - pNode[ix][iy][iz]._coord._y;\n\t\t\t\t\t// zm\n\t\t\t\t\tif (iz == 0) {\n\t\t\t\t\t\tizm = (_pMesh->getPeriodicZ() ? _nz-1 : iz);\n\t\t\t\t\t\tdzm = (_pMesh->getPeriodicZ() ? pNode[ix][iy][_nz]._coord._z - pNode[ix][iy][_nz-1]._coord._z : 0);\n\t\t\t\t\t} else\n\t\t\t\t\t\tdzm = pNode[ix][iy][iz]._coord._z - pNode[ix][iy][izm]._coord._z;\n\t\t\t\t\t// zp\n\t\t\t\t\tif (iz == _nz - 1) {\n\t\t\t\t\t\tizp = (_pMesh->getPeriodicZ() ? 0 : _nz-1);\n\t\t\t\t\t\tdzp = (_pMesh->getPeriodicZ() ? pNode[ix][iy][_nz]._coord._z - pNode[ix][iy][_nz-1]._coord._z : 0);\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t\tdzp = pNode[ix][iy][izp]._coord._z - pNode[ix][iy][iz]._coord._z;\n\n\n\t\t\t\t\tdxm /= BOHR_RADIUS * 1e9;\n\t\t\t\t\tdxp /= BOHR_RADIUS * 1e9;\n\t\t\t\t\tdym /= BOHR_RADIUS * 1e9;\n\t\t\t\t\tdyp /= BOHR_RADIUS * 1e9;\n\t\t\t\t\tdzm /= BOHR_RADIUS * 1e9;\n\t\t\t\t\tdzp /= BOHR_RADIUS * 1e9;\n\n\t\t\t\t\tif (ix != ixp) {\n\t\t\t\t\t\tconst double eps1 = getPermittivity(&pNode[ixp][iy][iz], &pNode[ix][iyp][iz], &pNode[ix][iy][izp]);\n\t\t\t\t\t\tconst double eps2 = getPermittivity(&pNode[ixp][iy][iz], &pNode[ix][iym][iz], &pNode[ix][iy][izp]);\n\t\t\t\t\t\tconst double eps3 = getPermittivity(&pNode[ixp][iy][iz], &pNode[ix][iyp][iz], &pNode[ix][iy][izm]);\n\t\t\t\t\t\tconst double eps4 = getPermittivity(&pNode[ixp][iy][iz], &pNode[ix][iym][iz], &pNode[ix][iy][izm]);\n\n\t\t\t\t\t\ta[0] = 1. / (4. * dxp) * (eps1 * dyp * dzp + eps2 * dym * dzp + eps3 * dyp * dzm + eps4 * dym * dzm);\n\t\t\t\t\t}\n\t\t\t\t\tif (ix != ixm) {\n\t\t\t\t\t\tconst double eps1 = getPermittivity(&pNode[ixm][iy][iz], &pNode[ix][iyp][iz], &pNode[ix][iy][izp]);\n\t\t\t\t\t\tconst double eps2 = getPermittivity(&pNode[ixm][iy][iz], &pNode[ix][iym][iz], &pNode[ix][iy][izp]);\n\t\t\t\t\t\tconst double eps3 = getPermittivity(&pNode[ixm][iy][iz], &pNode[ix][iyp][iz], &pNode[ix][iy][izm]);\n\t\t\t\t\t\tconst double eps4 = getPermittivity(&pNode[ixm][iy][iz], &pNode[ix][iym][iz], &pNode[ix][iy][izm]);\n\n\t\t\t\t\t\ta[1] = 1. / (4. * dxm) * (eps1 * dyp * dzp + eps2 * dym * dzp + eps3 * dyp * dzm + eps4 * dym * dzm);\n\t\t\t\t\t}\n\t\t\t\t\tif (iy != iyp) {\n\t\t\t\t\t\tconst double eps1 = getPermittivity(&pNode[ix][iyp][iz], &pNode[ixp][iy][iz], &pNode[ix][iy][izp]);\n\t\t\t\t\t\tconst double eps2 = getPermittivity(&pNode[ix][iyp][iz], &pNode[ixm][iy][iz], &pNode[ix][iy][izp]);\n\t\t\t\t\t\tconst double eps3 = getPermittivity(&pNode[ix][iyp][iz], &pNode[ixp][iy][iz], &pNode[ix][iy][izm]);\n\t\t\t\t\t\tconst double eps4 = getPermittivity(&pNode[ix][iyp][iz], &pNode[ixm][iy][iz], &pNode[ix][iy][izm]);\n\n\t\t\t\t\t\ta[2] = 1. / (4. * dyp) * (eps1 * dxp * dzp + eps2 * dxm * dzp + eps3 * dxp * dzm + eps4 * dxm * dzm);\n\t\t\t\t\t}\n\t\t\t\t\tif (iy != iym) {\n\t\t\t\t\t\tconst double eps1 = getPermittivity(&pNode[ix][iym][iz], &pNode[ixp][iy][iz], &pNode[ix][iy][izp]);\n\t\t\t\t\t\tconst double eps2 = getPermittivity(&pNode[ix][iym][iz], &pNode[ixm][iy][iz], &pNode[ix][iy][izp]);\n\t\t\t\t\t\tconst double eps3 = getPermittivity(&pNode[ix][iym][iz], &pNode[ixp][iy][iz], &pNode[ix][iy][izm]);\n\t\t\t\t\t\tconst double eps4 = getPermittivity(&pNode[ix][iym][iz], &pNode[ixm][iy][iz], &pNode[ix][iy][izm]);\n\n\t\t\t\t\t\ta[3] = 1. / (4. * dym) * (eps1 * dxp * dzp + eps2 * dxm * dzp + eps3 * dxp * dzm + eps4 * dxm * dzm);\n\t\t\t\t\t}\n\t\t\t\t\tif (iz != izp) {\n\t\t\t\t\t\tconst double eps1 = getPermittivity(&pNode[ix][iy][izp], &pNode[ixp][iy][iz], &pNode[ix][iyp][iz]);\n\t\t\t\t\t\tconst double eps2 = getPermittivity(&pNode[ix][iy][izp], &pNode[ixp][iy][iz], &pNode[ix][iym][iz]);\n\t\t\t\t\t\tconst double eps3 = getPermittivity(&pNode[ix][iy][izp], &pNode[ixm][iy][iz], &pNode[ix][iyp][iz]);\n\t\t\t\t\t\tconst double eps4 = getPermittivity(&pNode[ix][iy][izp], &pNode[ixm][iy][iz], &pNode[ix][iym][iz]);\n\n\t\t\t\t\t\ta[4] = 1. / (4. * dzp) * (eps1 * dyp * dxp + eps2 * dym * dxp + eps3 * dyp * dxm + eps4 * dym * dxm);\n\t\t\t\t\t}\n\t\t\t\t\tif (iz != izm) {\n\t\t\t\t\t\tconst double eps1 = getPermittivity(&pNode[ix][iy][izm], &pNode[ixp][iy][iz], &pNode[ix][iyp][iz]);\n\t\t\t\t\t\tconst double eps2 = getPermittivity(&pNode[ix][iy][izm], &pNode[ixp][iy][iz], &pNode[ix][iym][iz]);\n\t\t\t\t\t\tconst double eps3 = getPermittivity(&pNode[ix][iy][izm], &pNode[ixm][iy][iz], &pNode[ix][iyp][iz]);\n\t\t\t\t\t\tconst double eps4 = getPermittivity(&pNode[ix][iy][izm], &pNode[ixm][iy][iz], &pNode[ix][iym][iz]);\n\n\t\t\t\t\t\ta[5] = 1. / (4. * dzm) * (eps1 * dyp * dxp + eps2 * dym * dxp + eps3 * dyp * dxm + eps4 * dym * dxm);\n\t\t\t\t\t}\n\n\t\t\t\t\tif (!pNode[ixp][iy][iz]._active && _pMesh->isDirichletX())\n\t\t\t\t\t\t_Qeff(pNode[ix][iy][iz]._index) += a[0] * ELECTRONVOLT_TO_HARTREE(pNode[ixp][iy][iz]._V) / (4. * M_PI);\n\t\t\t\t\tif (!pNode[ixm][iy][iz]._active && _pMesh->isDirichletX())\n\t\t\t\t\t\t_Qeff(pNode[ix][iy][iz]._index) += a[1] * ELECTRONVOLT_TO_HARTREE(pNode[ixm][iy][iz]._V) / (4. * M_PI);\n\n\t\t\t\t\tif (!pNode[ix][iyp][iz]._active && _pMesh->isDirichletY())\n\t\t\t\t\t\t_Qeff(pNode[ix][iy][iz]._index) += a[2] * ELECTRONVOLT_TO_HARTREE(pNode[ix][iyp][iz]._V) / (4. * M_PI);\n\t\t\t\t\tif (!pNode[ix][iym][iz]._active && _pMesh->isDirichletY())\n\t\t\t\t\t\t_Qeff(pNode[ix][iy][iz]._index) += a[3] * ELECTRONVOLT_TO_HARTREE(pNode[ix][iym][iz]._V) / (4. * M_PI);\n\n\t\t\t\t\tif (!pNode[ix][iy][izm]._active && _pMesh->isDirichletZ())\n\t\t\t\t\t\t_Qeff(pNode[ix][iy][iz]._index) += a[4] * ELECTRONVOLT_TO_HARTREE(pNode[ix][iy][izp]._V) / (4. * M_PI);\n\t\t\t\t\tif (!pNode[ix][iy][izp]._active && _pMesh->isDirichletZ())\n\t\t\t\t\t\t_Qeff(pNode[ix][iy][iz]._index) += a[5] * ELECTRONVOLT_TO_HARTREE(pNode[ix][iy][izm]._V) / (4. * M_PI);\n\n\t\t\t\t\t_laplacian(pNode[ix][iy][iz]._index, pNode[ix][iy][iz]._index) = a[0] + a[1] + a[2] + a[3] + a[4] + a[5];\n\t\t\t\t\tif (ix != ixp)\n\t\t\t\t\t\t_laplacian(pNode[ix][iy][iz]._index, pNode[ixp][iy][iz]._index) = - a[0];\n\t\t\t\t\tif (ix != ixm)\n\t\t\t\t\t\t_laplacian(pNode[ix][iy][iz]._index, pNode[ixm][iy][iz]._index) = - a[1];\n\t\t\t\t\tif (iy != iyp)\n\t\t\t\t\t\t_laplacian(pNode[ix][iy][iz]._index, pNode[ix][iyp][iz]._index) = - a[2];\n\t\t\t\t\tif (iy != iym)\n\t\t\t\t\t\t_laplacian(pNode[ix][iy][iz]._index, pNode[ix][iym][iz]._index) = - a[3];\n\t\t\t\t\tif (iz != izp)\n\t\t\t\t\t\t_laplacian(pNode[ix][iy][iz]._index, pNode[ix][iy][izp]._index) = - a[4];\n\t\t\t\t\tif (iz != izm)\n\t\t\t\t\t\t_laplacian(pNode[ix][iy][iz]._index, pNode[ix][iy][izm]._index) = - a[5];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n", "meta": {"hexsha": "8ee94f4d55fc799f803b84c0a542228961bcd62b", "size": 37738, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/electrostatics/Poisson.cpp", "max_stars_repo_name": "imartinbragado/MMonCa", "max_stars_repo_head_hexsha": "126744a90253d7d7884c6dc7ec100db00a106a66", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2018-11-23T16:20:09.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-15T09:13:49.000Z", "max_issues_repo_path": "src/electrostatics/Poisson.cpp", "max_issues_repo_name": "Warmshawn/MMonCa", "max_issues_repo_head_hexsha": "df279c2103484e89898ff4e81b45fb9ad43bcb9e", "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/electrostatics/Poisson.cpp", "max_forks_repo_name": "Warmshawn/MMonCa", "max_forks_repo_head_hexsha": "df279c2103484e89898ff4e81b45fb9ad43bcb9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 6.0, "max_forks_repo_forks_event_min_datetime": "2020-12-04T03:28:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-09T10:38:14.000Z", "avg_line_length": 40.1041445271, "max_line_length": 164, "alphanum_fraction": 0.5793099793, "num_tokens": 13964, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.84997116805678, "lm_q2_score": 0.5273165233795671, "lm_q1q2_score": 0.448203841312571}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \"ID_Daw.h\"\n\n/*\nThis module uses IDDAW.cpp to find the energy of a set of interlayer dislocations\nIt can be built using setup_ID_DAW.py\nand tested using test_IDDAW.py\n\nhttps://dfm.io/posts/python-c-extensions/\n*/\n\n\nstatic char module_docstring[] =\n \"This module provides an interface for calculating the Continuum interlayer energy.\";\nstatic char Energyf_sp_docstring[] =\n \"Calculate the Energy of a set of interlayer Dislocations using Daw's formalism.\";\nstatic char visDuftot_docstring[] =\n \"Calculate the Distortion field of a set of interlayer Dislocations using Daw's formalism.\";\nstatic char visuftot_docstring[] =\n \"Calculate the in-plane displacement field of a set of interlayer Dislocations using Daw's formalism with stacking.\";\n\n\nstatic PyObject *IDDAW_Energyf_sp(PyObject *self, PyObject *args);\nstatic PyObject *IDDAW_visDuftot(PyObject *self, PyObject *args);\nstatic PyObject *IDDAW_visuftot(PyObject *self, PyObject *args);\n\nMatrixXd unpacklocbur(double* , int);\n\nstatic PyMethodDef module_methods[] = {\n {\"_Energyf_sp\", IDDAW_Energyf_sp, METH_VARARGS, Energyf_sp_docstring},\n {\"_visDuftot\", IDDAW_visDuftot, METH_VARARGS, visDuftot_docstring},\n {\"_visuftot\", IDDAW_visuftot, METH_VARARGS, visuftot_docstring},\n {NULL, NULL, 0, NULL}\n};\n\nPyMODINIT_FUNC init_IDDAW(void)\n{\n PyObject *m = Py_InitModule3(\"_IDDAW\", module_methods, module_docstring);\n if (m == NULL)\n return;\n\n /* Load `numpy` functionality. */\n import_array();\n}\n\n\nstatic PyObject *IDDAW_Energyf_sp(PyObject *self, PyObject *args)\n{\n double rc, kap, c33, z0, alpha;\n int ndisl, ndislout, pmax, qmax, ncoor;\n PyObject *Cijkl_obj, *Lxy_obj, *a1_obj, *a2_obj, *loc_obj, *burgers_obj, *fG1_obj, *fG2_obj, *locout_obj, *dirout_obj, *burgersout_obj, *rcout_obj, *M_obj, *X_obj;\n\n /* Parse the input tuple */\n if (!PyArg_ParseTuple(args, \"OOOOOOdiOOiiOOOOidddOiOd\", &Cijkl_obj, &Lxy_obj, &a1_obj, &a2_obj,\n &loc_obj, &burgers_obj, &rc, &ndisl, &fG1_obj, &fG2_obj, &pmax, &qmax,\n &locout_obj, &dirout_obj, &burgersout_obj, &rcout_obj, &ndislout, &kap, &c33, &z0, &M_obj, &ncoor, &X_obj, &alpha))\n return NULL;\n\n /* Interpret the input objects as numpy arrays. */\n PyObject *Cijkl_array = PyArray_FROM_OTF(Cijkl_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *Lxy_array = PyArray_FROM_OTF(Lxy_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *a1_array = PyArray_FROM_OTF(a1_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *a2_array = PyArray_FROM_OTF(a2_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *loc_array = PyArray_FROM_OTF(loc_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *burgers_array = PyArray_FROM_OTF(burgers_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *fG1_array = PyArray_FROM_OTF(fG1_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *fG2_array = PyArray_FROM_OTF(fG2_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *locout_array = PyArray_FROM_OTF(locout_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *dirout_array = PyArray_FROM_OTF(dirout_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *burgersout_array = PyArray_FROM_OTF(burgersout_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *rcout_array = PyArray_FROM_OTF(rcout_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *M_array = PyArray_FROM_OTF(M_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *X_array = PyArray_FROM_OTF(X_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n\n /* If that didn't work, throw an exception. */\n if (Cijkl_array == NULL || Lxy_array == NULL || a1_array == NULL ||\n a2_array == NULL || loc_array == NULL || burgers_array == NULL ||\n fG1_array == NULL || fG2_array == NULL || locout_array == NULL ||\n burgersout_array == NULL || dirout_array == NULL || M_array == NULL || X_array == NULL) {\n Py_XDECREF(Cijkl_array);\n Py_XDECREF(Lxy_array);\n Py_XDECREF(a1_array);\n Py_XDECREF(a2_array);\n Py_XDECREF(loc_array);\n Py_XDECREF(burgers_array);\n Py_XDECREF(fG1_array);\n Py_XDECREF(fG2_array);\n Py_XDECREF(locout_array);\n Py_XDECREF(dirout_array);\n Py_XDECREF(burgersout_array);\n Py_XDECREF(rcout_array);\n Py_XDECREF(M_array);\n Py_XDECREF(X_array);\n return NULL;\n }\n\n /* Get pointers to the data as C-types. */\n double *Cijklp = (double*)PyArray_DATA(Cijkl_array);\n double *Lxyp = (double*)PyArray_DATA(Lxy_array);\n double *a1p = (double*)PyArray_DATA(a1_array);\n double *a2p = (double*)PyArray_DATA(a2_array);\n double *locp = (double*)PyArray_DATA(loc_array);\n double *burgersp = (double*)PyArray_DATA(burgers_array);\n double *fG1p = (double*)PyArray_DATA(fG1_array);\n double *fG2p = (double*)PyArray_DATA(fG2_array);\n double *locoutp = (double*)PyArray_DATA(locout_array);\n double *diroutp = (double*)PyArray_DATA(dirout_array);\n double *burgersoutp = (double*)PyArray_DATA(burgersout_array);\n double *rcoutp = (double*)PyArray_DATA(rcout_array);\n double *Mp = (double*)PyArray_DATA(M_array);\n double *Xp = (double*)PyArray_DATA(X_array);\n\n cout << \"pmax\" << endl << pmax << endl;\n cout << \"qmax\" << endl << qmax << endl;\n\n //Convert Pointers into C Data Types\n MatrixXd C(2,8);\n C(0,0) = Cijklp[0]; C(0,1) = Cijklp[1]; C(0,2) = Cijklp[2]; C(0,3) = Cijklp[3];\n C(0,4) = Cijklp[4]; C(0,5) = Cijklp[5]; C(0,6) = Cijklp[6]; C(0,7) = Cijklp[7];\n C(1,0) = Cijklp[8]; C(1,1) = Cijklp[9]; C(1,2) = Cijklp[10]; C(1,3) = Cijklp[11];\n C(1,4) = Cijklp[12]; C(1,5) = Cijklp[13]; C(1,6) = Cijklp[14]; C(1,7) = Cijklp[15];\n \n MatrixXd burgers(ndisl,2);\n MatrixXd loc(ndisl,2);\n\n burgers = unpacklocbur(burgersp,ndisl);\n loc = unpacklocbur(locp,ndisl);\n\n MatrixXd burgersout(ndislout,2);\n MatrixXd locout(ndislout,2);\n MatrixXd dirout(ndislout,2);\n\n burgersout = unpacklocbur(burgersoutp,ndislout);\n locout = unpacklocbur(locoutp,ndislout);\n dirout = unpacklocbur(diroutp,ndislout);\n VectorXd rcout(2*ndislout);\n for (int k = 0; k<2*ndislout; k++){ \n rcout(k) = rcoutp[k];\n }\n\n Vector2d Lxy(Lxyp[0],Lxyp[1]);\n Vector2d a1(a1p[0],a1p[1]);\n Vector2d a2(a2p[0],a2p[1]);\n\n Vector2d M(Mp[0],Mp[1]);\n\n MatrixXd fG1 = Map >(fG1p,2*pmax+1,2*qmax+1);\n MatrixXd fG2 = Map >(fG2p,2*pmax+1,2*qmax+1);\n\n\n MatrixXd X = Map >(Xp,ncoor,2);\n\n /*\n cout << \"Cijkl\" << endl << C << endl;\n cout << \"kap\" << endl << kap << endl;\n cout << \"c33\" << endl << c33 << endl;\n cout << \"Lxy\" << endl << Lxy << endl;\n cout << \"a1\" << endl << a1 << endl;\n cout << \"a2\" << endl << a2 << endl;\n cout << \"fG1\" << endl << fG1 << endl;\n cout << \"fG2\" << endl << fG2 << endl;\n cout << \"loc\" << endl << loc << endl;\n cout << \"burgers\" << endl << burgers << endl;\n cout << \"rc\" << endl << rc << endl;\n cout << \"loc_out\" << endl << locout << endl;\n cout << \"dir_out\" << endl << dirout << endl;\n cout << \"burgers_out\" << endl << burgersout << endl;\n cout << \"rc_out\" << endl << rcout << endl;\n cout << \"pmax\" << endl << pmax << endl;\n cout << \"qmax\" << endl << qmax << endl;\n cout << \"z0\" << endl << z0 << endl;\n cout << \"M\" << endl << M << endl;\n */\n Vector3d res = energyf_sp(C, kap, c33, Lxy, a1, a2, fG1, fG2, loc, burgers, rc, locout, dirout, burgersout, rcout, pmax, qmax, z0, M, ncoor, X, alpha);\n\n //double value = res[0];\n double ret_array[3];\n ret_array[0] = res[0];\n ret_array[1] = res[1];\n ret_array[2] = res[2];\n\n\n\n /* Clean up. */\n Py_XDECREF(Cijkl_array);\n Py_XDECREF(Lxy_array);\n Py_XDECREF(a1_array);\n Py_XDECREF(a2_array);\n Py_XDECREF(loc_array);\n Py_XDECREF(burgers_array);\n Py_XDECREF(fG1_array);\n Py_XDECREF(fG2_array);\n Py_XDECREF(locout_array);\n Py_XDECREF(dirout_array);\n Py_XDECREF(burgersout_array);\n Py_XDECREF(rcout_array);\n Py_XDECREF(M_array);\n Py_XDECREF(X_array);\n\n npy_intp dims[1] = {3};\n PyObject *ret = PyArray_SimpleNew(1, dims, NPY_DOUBLE);\n memcpy(PyArray_DATA(ret), ret_array, sizeof(ret_array));\n\n /* Build the output tuple */\n //PyObject *ret = Py_BuildValue(\"d\", value);\n return ret;\n}\n\nstatic PyObject *IDDAW_visDuftot(PyObject *self, PyObject *args)\n{\n double rc, kap, c33, z0, alpha;\n int ndisl, ndislout, pmax, qmax, ncoor;\n PyObject *Cijkl_obj, *Lxy_obj, *a1_obj, *a2_obj, *loc_obj, *burgers_obj, *fG1_obj, *fG2_obj, *locout_obj, *dirout_obj, *burgersout_obj, *rcout_obj, *M_obj, *X_obj;\n\n /* Parse the input tuple */\n if (!PyArg_ParseTuple(args, \"OOOOOOdiOOiiOOOOidddOiOd\", &Cijkl_obj, &Lxy_obj, &a1_obj, &a2_obj,\n &loc_obj, &burgers_obj, &rc, &ndisl, &fG1_obj, &fG2_obj, &pmax, &qmax,\n &locout_obj, &dirout_obj, &burgersout_obj, &rcout_obj, &ndislout, &kap, &c33, &z0, &M_obj, &ncoor, &X_obj, &alpha))\n return NULL;\n\n /* Interpret the input objects as numpy arrays. */\n PyObject *Cijkl_array = PyArray_FROM_OTF(Cijkl_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *Lxy_array = PyArray_FROM_OTF(Lxy_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *a1_array = PyArray_FROM_OTF(a1_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *a2_array = PyArray_FROM_OTF(a2_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *loc_array = PyArray_FROM_OTF(loc_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *burgers_array = PyArray_FROM_OTF(burgers_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *fG1_array = PyArray_FROM_OTF(fG1_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *fG2_array = PyArray_FROM_OTF(fG2_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *locout_array = PyArray_FROM_OTF(locout_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *dirout_array = PyArray_FROM_OTF(dirout_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *burgersout_array = PyArray_FROM_OTF(burgersout_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *rcout_array = PyArray_FROM_OTF(rcout_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *M_array = PyArray_FROM_OTF(M_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *X_array = PyArray_FROM_OTF(X_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n\n /* If that didn't work, throw an exception. */\n if (Cijkl_array == NULL || Lxy_array == NULL || a1_array == NULL ||\n a2_array == NULL || loc_array == NULL || burgers_array == NULL ||\n fG1_array == NULL || fG2_array == NULL || locout_array == NULL ||\n burgersout_array == NULL || dirout_array == NULL || M_array == NULL || X_array == NULL) {\n Py_XDECREF(Cijkl_array);\n Py_XDECREF(Lxy_array);\n Py_XDECREF(a1_array);\n Py_XDECREF(a2_array);\n Py_XDECREF(loc_array);\n Py_XDECREF(burgers_array);\n Py_XDECREF(fG1_array);\n Py_XDECREF(fG2_array);\n Py_XDECREF(locout_array);\n Py_XDECREF(dirout_array);\n Py_XDECREF(burgersout_array);\n Py_XDECREF(rcout_array);\n Py_XDECREF(M_array);\n Py_XDECREF(X_array);\n return NULL;\n }\n\n /* Get pointers to the data as C-types. */\n double *Cijklp = (double*)PyArray_DATA(Cijkl_array);\n double *Lxyp = (double*)PyArray_DATA(Lxy_array);\n double *a1p = (double*)PyArray_DATA(a1_array);\n double *a2p = (double*)PyArray_DATA(a2_array);\n double *locp = (double*)PyArray_DATA(loc_array);\n double *burgersp = (double*)PyArray_DATA(burgers_array);\n double *fG1p = (double*)PyArray_DATA(fG1_array);\n double *fG2p = (double*)PyArray_DATA(fG2_array);\n double *locoutp = (double*)PyArray_DATA(locout_array);\n double *diroutp = (double*)PyArray_DATA(dirout_array);\n double *burgersoutp = (double*)PyArray_DATA(burgersout_array);\n double *rcoutp = (double*)PyArray_DATA(rcout_array);\n double *Mp = (double*)PyArray_DATA(M_array);\n double *Xp = (double*)PyArray_DATA(X_array);\n\n cout << \"pmax\" << endl << pmax << endl;\n cout << \"qmax\" << endl << qmax << endl;\n\n //Convert Pointers into C Data Types\n MatrixXd C(2,8);\n C(0,0) = Cijklp[0]; C(0,1) = Cijklp[1]; C(0,2) = Cijklp[2]; C(0,3) = Cijklp[3];\n C(0,4) = Cijklp[4]; C(0,5) = Cijklp[5]; C(0,6) = Cijklp[6]; C(0,7) = Cijklp[7];\n C(1,0) = Cijklp[8]; C(1,1) = Cijklp[9]; C(1,2) = Cijklp[10]; C(1,3) = Cijklp[11];\n C(1,4) = Cijklp[12]; C(1,5) = Cijklp[13]; C(1,6) = Cijklp[14]; C(1,7) = Cijklp[15];\n \n MatrixXd burgers(ndisl,2);\n MatrixXd loc(ndisl,2);\n\n burgers = unpacklocbur(burgersp,ndisl);\n loc = unpacklocbur(locp,ndisl);\n\n MatrixXd burgersout(ndislout,2);\n MatrixXd locout(ndislout,2);\n MatrixXd dirout(ndislout,2);\n\n burgersout = unpacklocbur(burgersoutp,ndislout);\n locout = unpacklocbur(locoutp,ndislout);\n dirout = unpacklocbur(diroutp,ndislout);\n VectorXd rcout(2*ndislout);\n for (int k = 0; k<2*ndislout; k++){ \n rcout(k) = rcoutp[k];\n }\n\n Vector2d Lxy(Lxyp[0],Lxyp[1]);\n Vector2d a1(a1p[0],a1p[1]);\n Vector2d a2(a2p[0],a2p[1]);\n\n Vector2d M(Mp[0],Mp[1]);\n\n MatrixXd fG1 = Map >(fG1p,2*pmax+1,2*qmax+1);\n MatrixXd fG2 = Map >(fG2p,2*pmax+1,2*qmax+1);\n\n\n MatrixXd X = Map >(Xp,ncoor,2);\n\n /*\n cout << \"Cijkl\" << endl << C << endl;\n cout << \"kap\" << endl << kap << endl;\n cout << \"c33\" << endl << c33 << endl;\n cout << \"Lxy\" << endl << Lxy << endl;\n cout << \"a1\" << endl << a1 << endl;\n cout << \"a2\" << endl << a2 << endl;\n cout << \"fG1\" << endl << fG1 << endl;\n cout << \"fG2\" << endl << fG2 << endl;\n cout << \"loc\" << endl << loc << endl;\n cout << \"burgers\" << endl << burgers << endl;\n cout << \"rc\" << endl << rc << endl;\n cout << \"loc_out\" << endl << locout << endl;\n cout << \"dir_out\" << endl << dirout << endl;\n cout << \"burgers_out\" << endl << burgersout << endl;\n cout << \"rc_out\" << endl << rcout << endl;\n cout << \"pmax\" << endl << pmax << endl;\n cout << \"qmax\" << endl << qmax << endl;\n cout << \"z0\" << endl << z0 << endl;\n cout << \"M\" << endl << M << endl;\n */\n MatrixXd res = visD_uftot(C, kap, c33, Lxy, a1, a2, fG1, fG2, loc, burgers, rc, locout, dirout, burgersout, rcout, pmax, qmax, z0, M, ncoor, X, alpha);\n\n //cout << \"Return: \" << res << endl;\n //double value = res[0];\n \n double ret_array[8*ncoor];\n\n for (int i = 0; i < ncoor; i++){\n for (int j = 0; j < 8; j++){\n ret_array[8*i+j] = res(i,j);\n }\n }\n\n\n\n /* Clean up. */\n Py_XDECREF(Cijkl_array);\n Py_XDECREF(Lxy_array);\n Py_XDECREF(a1_array);\n Py_XDECREF(a2_array);\n Py_XDECREF(loc_array);\n Py_XDECREF(burgers_array);\n Py_XDECREF(fG1_array);\n Py_XDECREF(fG2_array);\n Py_XDECREF(locout_array);\n Py_XDECREF(dirout_array);\n Py_XDECREF(burgersout_array);\n Py_XDECREF(rcout_array);\n Py_XDECREF(M_array);\n Py_XDECREF(X_array);\n\n //cout << \"Return: \" << ret_array << endl;\n\n npy_intp dims[1] = {8*ncoor};\n PyObject *ret = PyArray_SimpleNew(1, dims, NPY_DOUBLE);\n memcpy(PyArray_DATA(ret), ret_array, sizeof(ret_array));\n\n /* Build the output tuple */\n //PyObject *ret = Py_BuildValue(\"d\", value);\n return ret;\n}\n\nstatic PyObject *IDDAW_visuftot(PyObject *self, PyObject *args)\n{\n double rc, kap, c33, z0, alpha;\n int ndisl, ndislout, pmax, qmax, ncoor;\n PyObject *Cijkl_obj, *Lxy_obj, *a1_obj, *a2_obj, *loc_obj, *burgers_obj, *fG1_obj, *fG2_obj, *locout_obj, *dirout_obj, *burgersout_obj, *rcout_obj, *M_obj, *X_obj;\n\n /* Parse the input tuple */\n if (!PyArg_ParseTuple(args, \"OOOOOOdiOOiiOOOOidddOiOd\", &Cijkl_obj, &Lxy_obj, &a1_obj, &a2_obj,\n &loc_obj, &burgers_obj, &rc, &ndisl, &fG1_obj, &fG2_obj, &pmax, &qmax,\n &locout_obj, &dirout_obj, &burgersout_obj, &rcout_obj, &ndislout, &kap, &c33, &z0, &M_obj, &ncoor, &X_obj, &alpha))\n return NULL;\n\n /* Interpret the input objects as numpy arrays. */\n PyObject *Cijkl_array = PyArray_FROM_OTF(Cijkl_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *Lxy_array = PyArray_FROM_OTF(Lxy_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *a1_array = PyArray_FROM_OTF(a1_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *a2_array = PyArray_FROM_OTF(a2_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *loc_array = PyArray_FROM_OTF(loc_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *burgers_array = PyArray_FROM_OTF(burgers_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *fG1_array = PyArray_FROM_OTF(fG1_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *fG2_array = PyArray_FROM_OTF(fG2_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *locout_array = PyArray_FROM_OTF(locout_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *dirout_array = PyArray_FROM_OTF(dirout_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *burgersout_array = PyArray_FROM_OTF(burgersout_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *rcout_array = PyArray_FROM_OTF(rcout_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *M_array = PyArray_FROM_OTF(M_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n PyObject *X_array = PyArray_FROM_OTF(X_obj, NPY_DOUBLE, NPY_IN_ARRAY);\n\n /* If that didn't work, throw an exception. */\n if (Cijkl_array == NULL || Lxy_array == NULL || a1_array == NULL ||\n a2_array == NULL || loc_array == NULL || burgers_array == NULL ||\n fG1_array == NULL || fG2_array == NULL || locout_array == NULL ||\n burgersout_array == NULL || dirout_array == NULL || M_array == NULL || X_array == NULL) {\n Py_XDECREF(Cijkl_array);\n Py_XDECREF(Lxy_array);\n Py_XDECREF(a1_array);\n Py_XDECREF(a2_array);\n Py_XDECREF(loc_array);\n Py_XDECREF(burgers_array);\n Py_XDECREF(fG1_array);\n Py_XDECREF(fG2_array);\n Py_XDECREF(locout_array);\n Py_XDECREF(dirout_array);\n Py_XDECREF(burgersout_array);\n Py_XDECREF(rcout_array);\n Py_XDECREF(M_array);\n Py_XDECREF(X_array);\n return NULL;\n }\n\n /* Get pointers to the data as C-types. */\n double *Cijklp = (double*)PyArray_DATA(Cijkl_array);\n double *Lxyp = (double*)PyArray_DATA(Lxy_array);\n double *a1p = (double*)PyArray_DATA(a1_array);\n double *a2p = (double*)PyArray_DATA(a2_array);\n double *locp = (double*)PyArray_DATA(loc_array);\n double *burgersp = (double*)PyArray_DATA(burgers_array);\n double *fG1p = (double*)PyArray_DATA(fG1_array);\n double *fG2p = (double*)PyArray_DATA(fG2_array);\n double *locoutp = (double*)PyArray_DATA(locout_array);\n double *diroutp = (double*)PyArray_DATA(dirout_array);\n double *burgersoutp = (double*)PyArray_DATA(burgersout_array);\n double *rcoutp = (double*)PyArray_DATA(rcout_array);\n double *Mp = (double*)PyArray_DATA(M_array);\n double *Xp = (double*)PyArray_DATA(X_array);\n\n cout << \"pmax\" << endl << pmax << endl;\n cout << \"qmax\" << endl << qmax << endl;\n\n //Convert Pointers into C Data Types\n MatrixXd C(2,8);\n C(0,0) = Cijklp[0]; C(0,1) = Cijklp[1]; C(0,2) = Cijklp[2]; C(0,3) = Cijklp[3];\n C(0,4) = Cijklp[4]; C(0,5) = Cijklp[5]; C(0,6) = Cijklp[6]; C(0,7) = Cijklp[7];\n C(1,0) = Cijklp[8]; C(1,1) = Cijklp[9]; C(1,2) = Cijklp[10]; C(1,3) = Cijklp[11];\n C(1,4) = Cijklp[12]; C(1,5) = Cijklp[13]; C(1,6) = Cijklp[14]; C(1,7) = Cijklp[15];\n \n MatrixXd burgers(ndisl,2);\n MatrixXd loc(ndisl,2);\n\n burgers = unpacklocbur(burgersp,ndisl);\n loc = unpacklocbur(locp,ndisl);\n\n MatrixXd burgersout(ndislout,2);\n MatrixXd locout(ndislout,2);\n MatrixXd dirout(ndislout,2);\n\n burgersout = unpacklocbur(burgersoutp,ndislout);\n locout = unpacklocbur(locoutp,ndislout);\n dirout = unpacklocbur(diroutp,ndislout);\n VectorXd rcout(2*ndislout);\n for (int k = 0; k<2*ndislout; k++){ \n rcout(k) = rcoutp[k];\n }\n\n Vector2d Lxy(Lxyp[0],Lxyp[1]);\n Vector2d a1(a1p[0],a1p[1]);\n Vector2d a2(a2p[0],a2p[1]);\n\n Vector2d M(Mp[0],Mp[1]);\n\n MatrixXd fG1 = Map >(fG1p,2*pmax+1,2*qmax+1);\n MatrixXd fG2 = Map >(fG2p,2*pmax+1,2*qmax+1);\n\n\n MatrixXd X = Map >(Xp,ncoor,2);\n\n /*\n cout << \"Cijkl\" << endl << C << endl;\n cout << \"kap\" << endl << kap << endl;\n cout << \"c33\" << endl << c33 << endl;\n cout << \"Lxy\" << endl << Lxy << endl;\n cout << \"a1\" << endl << a1 << endl;\n cout << \"a2\" << endl << a2 << endl;\n cout << \"fG1\" << endl << fG1 << endl;\n cout << \"fG2\" << endl << fG2 << endl;\n cout << \"loc\" << endl << loc << endl;\n cout << \"burgers\" << endl << burgers << endl;\n cout << \"rc\" << endl << rc << endl;\n cout << \"loc_out\" << endl << locout << endl;\n cout << \"dir_out\" << endl << dirout << endl;\n cout << \"burgers_out\" << endl << burgersout << endl;\n \n cout << \"pmax\" << endl << pmax << endl;\n cout << \"qmax\" << endl << qmax << endl;\n cout << \"z0\" << endl << z0 << endl;\n cout << \"M\" << endl << M << endl;\n */\n cout << \"rc_out\" << endl << rcout << endl;\n MatrixXd res = visuftot(C, kap, c33, Lxy, a1, a2, fG1, fG2, loc, burgers, rc, locout, dirout, burgersout, rcout, pmax, qmax, z0, M, ncoor, X, alpha);\n\n //cout << \"Return: \" << res << endl;\n //double value = res[0];\n \n double ret_array[4*ncoor];\n\n for (int i = 0; i < ncoor; i++){\n for (int j = 0; j < 4; j++){\n ret_array[4*i+j] = res(i,j);\n }\n }\n\n\n\n /* Clean up. */\n Py_XDECREF(Cijkl_array);\n Py_XDECREF(Lxy_array);\n Py_XDECREF(a1_array);\n Py_XDECREF(a2_array);\n Py_XDECREF(loc_array);\n Py_XDECREF(burgers_array);\n Py_XDECREF(fG1_array);\n Py_XDECREF(fG2_array);\n Py_XDECREF(locout_array);\n Py_XDECREF(dirout_array);\n Py_XDECREF(burgersout_array);\n Py_XDECREF(rcout_array);\n Py_XDECREF(M_array);\n Py_XDECREF(X_array);\n\n //cout << \"Return: \" << ret_array << endl;\n\n npy_intp dims[1] = {4*ncoor};\n PyObject *ret = PyArray_SimpleNew(1, dims, NPY_DOUBLE);\n memcpy(PyArray_DATA(ret), ret_array, sizeof(ret_array));\n\n /* Build the output tuple */\n //PyObject *ret = Py_BuildValue(\"d\", value);\n return ret;\n}\n\n\nMatrixXd unpacklocbur(double* point, int ndisl){\n\tMatrixXd out(ndisl,2);\n\tfor (int i=0;i\n#include \n#include \"nsgen.h\"\n#include \"ring.h\"\n\nvoid print_poly (ZZX& f) {\n long d = deg(f);\n if (d == -1) {\n cout << \"0\" << endl;\n }\n else {\n for (long i = d; i >= 0; --i) {\n if (f[i] != 0)\n\tcout << f[i] << \"*\" << \"X^\" << i << \" + \";\n }\n cout << endl;\n }\n}\n\n/***********************************************************************/\nZZX ring::apply_conj (ZZX& a, long i) {\n long d = deg(a);\n if (d == -1) return ZZX(0);\n\n ZZX phi = (ZZX(INIT_MONO, mR)-1)/(ZZX(INIT_MONO, 1)-1);\n ZZX w = ZZX(0);\n \n for (long j = 0; j <= d; j++) {\n if (a[j] != 0) {\n long t = (j*i) % mR;\n ZZX z = ZZX(INIT_MONO, t);\n rem(z, z, phi);\n z *= ZZX(a[j]);\n w += z;\n }\n }\n \n return w;\n}\n\nZZX ring::trace (ZZX& w) {\n ZZX r = ZZX(0);\n\n for (long a = 0; a < dR; ++a) {\n ZZX v = apply_conj(w, GZ(a));\n r += v;\n }\n return r;\n}\n\nZZX ring::eta (long j) {\n ZZX z = ZZX(INIT_MONO, 1);\n ZZX phi = (ZZX(INIT_MONO, mR)-1)/(ZZX(INIT_MONO, 1)-1);\n\n long t = GofZ(j);\n ZZX w = ZZX(INIT_MONO, t); // w = X^t\n rem(w, w, phi);\n\n return trace(w);\n}\n\nZZ_pX ring::delta (long j) {\n return conv(eta(j) - dR);\n}\n\nZZ ring::scalar_quo (ZZX& a, ZZX& b, ZZ& p) {\n long d = max(deg(a), deg(b));\n a.SetLength(d+1);\n b.SetLength(d+1);\n\n // ZZ_pContext context;\n // context.save();\n ZZ_p::init(p);\n\n ZZ_pX a1, b1;\n a1.SetLength(d+1);\n a1 = conv(a);\n b1.SetLength(d+1);\n b1 = conv(b);\n \n long i;\n ZZ w;\n for (i = 0; i <= d; ++i) {\n if (GCD(b[i]%p, p) == 1) {\n w = (a[i] * InvMod(b[i]%p, p)) % p;\n break;\n }\n }\n\n // ZZ_pX c1 = conv(w) * b1;\n // if (c1 != a1) {\n // cout << \"Error: unexpected behaviour in scalar_quo\" << endl;\n // cout << \"i = \" << i << \", p = \" << p << endl;\n // // cout << \"a1 = \" << a1 << endl;\n // // cout << \"b1 = \" << b1 << endl;\n // // cout << \"c1 = \" << c1 << endl;\n // exit(-1);\n // }\n\n //context.restore();\n return w;\n}\n\n/***********************************************************************/\nZZ compose_integer (const ZZ& r1, const ZZ& q1, const ZZ& r2, const ZZ& q2) {\n ZZ a, b, c;\n XGCD(a, b, c, q1, q2); // 1 = a = b*q1 + c*q2\n ZZ w1 = c * q2;\n ZZ w2 = b * q1;\n return (r1*w1 + r2*w2) % (q1*q2);\n}\n\nvoid compose_vector (vec_ZZ& omega, vec_ZZ& omega1, ZZ& q1, vec_ZZ& omega2, ZZ& q2) {\n for (long i = 0; i < omega1.length(); i++)\n omega[i] = compose_integer(omega1[i], q1, omega2[i], q2);\n}\n\nvoid compose (ZZX& res, ring& rg, ZZX& res0, ZZ& q0, ZZX& res1, ZZ& q1) {\n vec_ZZ v0 = VectorCopy(res0, rg.mR-1);\n vec_ZZ v1 = VectorCopy(res1, rg.mR-1);\n vec_ZZ v; v.SetLength(rg.mR-1);\n compose_vector(v, v0, q0, v1, q1);\n res.SetLength(rg.mR-1);\n for (long i = 0; i < rg.mR-1; i++) SetCoeff(res, i, v[i]);\n}\n\n// assumes that 'm' is prime\n// modulus of the resolution is p^r\nvoid ring::resolution_of_one (ZZX& res, const long m, const ZZ& p) {\n ZZ_pContext context;\n context.save();\n ZZ_p::init(p);\n \n ZZ_pX phi = (ZZ_pX(INIT_MONO, m)-1)/(ZZ_pX(INIT_MONO, 1)-1);\n\n cout << \".\" << flush;\n\n vec_ZZ_pX factors;\n //SFBerlekamp(factors, phi);\n if (p==ZZ(2))\n SFCanZass(factors, phi);\n else\n RootEDF(factors, phi);\n\n ZZ_pX G = ZZ_pX(1);\n for (long i = 1; i < factors.length(); ++i) G *= factors[i];\n ZZ_pX a, b, c;\n XGCD(a, b, c, factors[0], G); // 1 = a = b * factors[0] + c * G\n ZZ_pX res1 = c*G;\n \n // ZZ_pX res2 = (res1*res1) % phi;\n // if (res1 != res2) {\n // cout << \"Error in resolution_of_one\" << endl;\n // cout << \"res = \" << res1 << endl;\n // cout << \"res2 = \" << res2 << endl;\n // exit(-1);\n // }\n \n res = conv(res1);\n context.restore();\n}\n\nvoid ring::lift_resolution (ZZX& res, const long m, const ZZ& r, const long l) {\n ZZ_p::init(power(r, l));\n ZZ_pX phi = (ZZ_pX(INIT_MONO, m)-1)/(ZZ_pX(INIT_MONO, 1)-1);\n\n ZZ_pX x = conv(-res);\n for (long j = 0; j < l-1; ++j) {\n if ((j % 100) == 0) cout << \".\" << flush;\n x = (power(x+1, conv(r)) - 1) % phi;\n }\n res = conv(-x);\n}\n\nvoid ring::canonical_resolution_of_one (ZZX& res, long prec) {\n resolution_of_one(res, mR, ZZ(pR));\n lift_resolution(res, mR, ZZ(pR), prec); \n}\n\nvoid ring::init_resolution (long prec) {\n if (type == prime) {\n canonical_resolution_of_one(res, prec);\n }\n else { // ring is composite\n if (left->initialized == false)\n left->init_resolution(prec);\n if (right->initialized == false)\n right->init_resolution(prec);\n }\n}\n\nvoid ring::init (long prec, noise& ns) {\n if (initialized == true) return;\n\n cout << \"Initializing ring \" << label << flush;\n \n init_resolution(prec);\n \n cout << \"computing omega...\" << flush;\n init_omega(power(ZZ(2), prec));\n\n depth = get_subrings(subrings);\n\n initialized = true;\n cout << \"done\" << endl;\n}\n\n/***********************************************************************/\n// Transpose a (m*n)-dim. vector 'a'\n// into a m x n matrix (m-dim vector of n-dim vector)'w'\nvoid mat (Vec& aa, const double* a, const long n, const long m) {\n for (long j = 0; j < m; ++j)\n for (long i = 0; i < n; ++i)\n aa[j][i] = a[i + n*j];\n}\n\nvoid transpose (Vec& b, Vec& a) {\n long m = a.length();\n long n = b.length();\n\n for (long i = 0; i < m; ++i)\n for (long j = 0; j < n; ++j)\n b[j][i] = a[i][j]; \n}\n\nvoid vec (double* b, const Vec& a, long n) {\n long m = a.length();\n\n for (long i = 0; i < m; ++i)\n for (long j = 0; j < n; ++j)\n b[i*n+j] = a[i][j];\n}\n\n/***************************************************************************/\n// (Omega)_{i,j} = (rho_{t_i}(eta_j))\nvoid ring::comp_omega (vec_ZZ& o, ZZ& q) {\n ZZX phi = (ZZX(INIT_MONO, mR)-1)/(ZZX(INIT_MONO, 1)-1);\n\n ZZ_p::init(q);\n \n o.SetLength(gR);\n for (long i = 0; i < gR; ++i) {\n if ((i % 100) == 0) cout << \".\" << flush;\n ZZ_pX e = conv(eta(i));\n ZZ_pX a = (e * conv(res)) % conv(phi);\n ZZX aa = conv(a);\n o[i] = scalar_quo(aa, res, q);\n }\n}\n\nvoid ring::comp_omega_inv (vec_ZZ& o, const vec_ZZ& _omega, const ZZ& q) {\n o.SetLength(gR);\n \n for (long i = 0; i < gR; ++i) {\n ZZ w, conj_eta;\n if ((dR % 2) == 1) conj_eta = _omega[(i+gR/2) % gR];\n else conj_eta = _omega[i];\n w = conj_eta - dR;\n w = (w * InvMod(ZZ(mR)%q, q)) % q;\n o[i] = w;\n } \n}\n\n// (Gamma)_{i,j} = (rho_{t_i}(eta_j - d))\nvoid ring::comp_gamma (vec_ZZ& o, const vec_ZZ& _omega, const ZZ& q) {\n o.SetLength(gR);\n\n for (long i = 0; i < gR; ++i) {\n o[i] = (omega[i] - dR) % q;\n } \n}\n\nvoid ring::comp_gamma_inv (vec_ZZ& o, const vec_ZZ& _omega, const ZZ& q) {\n o.SetLength(gR);\n \n for (long i = 0; i < gR; ++i) {\n ZZ conj_eta;\n if ((dR % 2) == 1) conj_eta = _omega[(i+gR/2) % gR];\n else conj_eta = _omega[i];\n o[i] = (conj_eta * InvMod(ZZ(mR)%q, q)) % q;\n } \n}\n\nvoid ring::init_omega (ZZ q) {\n if (type == prime) {\n comp_omega(omega, q);\n comp_omega_inv(omega_inv, omega, q);\n }\n else { // ring type is composite\n if (left->initialized == false)\n left->init_omega(q);\n if (right->initialized == false)\n right->init_omega(q);\n }\n}\n\nvoid param::init (long prec) {\n rg.init(prec, ns); \n}\n\n", "meta": {"hexsha": "25f2d133c17358798da5ed5f0fad5dd2075d778a", "size": 7184, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ring_init.cpp", "max_stars_repo_name": "aritalab/SRHE", "max_stars_repo_head_hexsha": "38161f1e62edc72a6d0afa638d057579f7005095", "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": "ring_init.cpp", "max_issues_repo_name": "aritalab/SRHE", "max_issues_repo_head_hexsha": "38161f1e62edc72a6d0afa638d057579f7005095", "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": "ring_init.cpp", "max_forks_repo_name": "aritalab/SRHE", "max_forks_repo_head_hexsha": "38161f1e62edc72a6d0afa638d057579f7005095", "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.8671096346, "max_line_length": 85, "alphanum_fraction": 0.5025055679, "num_tokens": 2751, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430478583168, "lm_q2_score": 0.5389832206876841, "lm_q1q2_score": 0.4479721567868536}} {"text": "// This file is part of libigl, a simple c++ geometry processing library.\n// \n// Copyright (C) 2014 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 \"harmonic.h\"\n#include \"cotmatrix.h\"\n#include \"massmatrix.h\"\n#include \"invert_diag.h\"\n#include \"min_quad_with_fixed.h\"\n#include \n\ntemplate <\n typename DerivedV,\n typename DerivedF,\n typename Derivedb,\n typename Derivedbc,\n typename DerivedW>\nIGL_INLINE bool igl::harmonic(\n const Eigen::PlainObjectBase & V,\n const Eigen::PlainObjectBase & F,\n const Eigen::PlainObjectBase & b,\n const Eigen::PlainObjectBase & bc,\n const int k,\n Eigen::PlainObjectBase & W)\n{\n using namespace Eigen;\n typedef typename DerivedV::Scalar Scalar;\n typedef Matrix VectorXS;\n SparseMatrix L,M,Mi;\n cotmatrix(V,F,L);\n switch(F.cols())\n {\n case 3:\n massmatrix(V,F,MASSMATRIX_TYPE_VORONOI,M);\n break;\n case 4:\n default:\n massmatrix(V,F,MASSMATRIX_TYPE_BARYCENTRIC,M);\n break;\n }\n invert_diag(M,Mi);\n SparseMatrix Q = -L;\n for(int p = 1;p data;\n min_quad_with_fixed_precompute(Q,b,SparseMatrix(),true,data);\n W.resize(V.rows(),bc.cols());\n for(int w = 0;w, Eigen::Matrix, Eigen::Matrix, Eigen::Matrix, Eigen::Matrix >(Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, int, Eigen::PlainObjectBase >&); \ntemplate bool igl::harmonic, Eigen::Matrix, Eigen::Matrix, Eigen::Matrix, Eigen::Matrix >(Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, Eigen::PlainObjectBase > const&, int, Eigen::PlainObjectBase >&);\n#endif\n", "meta": {"hexsha": "6aecdd7b538c834560cffa6191435527fe16e2f3", "size": 3023, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Code/include/igl/harmonic.cpp", "max_stars_repo_name": "FabianRepository/SinusProject", "max_stars_repo_head_hexsha": "48d68902ccd83f08c4d208ba8e0739a8a1252338", "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": "Code/include/igl/harmonic.cpp", "max_issues_repo_name": "FabianRepository/SinusProject", "max_issues_repo_head_hexsha": "48d68902ccd83f08c4d208ba8e0739a8a1252338", "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": "Code/include/igl/harmonic.cpp", "max_forks_repo_name": "FabianRepository/SinusProject", "max_forks_repo_head_hexsha": "48d68902ccd83f08c4d208ba8e0739a8a1252338", "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.9861111111, "max_line_length": 592, "alphanum_fraction": 0.6520013232, "num_tokens": 1044, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430394931456, "lm_q2_score": 0.5389832206876841, "lm_q1q2_score": 0.44797215227816667}} {"text": "/* boost random/fisher_f_distribution.hpp header file\n *\n * Copyright Steven Watanabe 2011\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 * See http://www.boost.org for most recent version including documentation.\n *\n * $Id$\n */\n\n#ifndef BOOST_RANDOM_FISHER_F_DISTRIBUTION_HPP\n#define BOOST_RANDOM_FISHER_F_DISTRIBUTION_HPP\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost {\nnamespace random {\n\n/**\n * The Fisher F distribution is a real valued distribution with two\n * parameters m and n.\n *\n * It has \\f$\\displaystyle p(x) =\n * \\frac{\\Gamma((m+n)/2)}{\\Gamma(m/2)\\Gamma(n/2)}\n * \\left(\\frac{m}{n}\\right)^{m/2}\n * x^{(m/2)-1} \\left(1+\\frac{mx}{n}\\right)^{-(m+n)/2}\n * \\f$.\n */\ntemplate\nclass fisher_f_distribution {\npublic:\n typedef RealType result_type;\n typedef RealType input_type;\n\n class param_type {\n public:\n typedef fisher_f_distribution distribution_type;\n\n /**\n * Constructs a @c param_type from the \"m\" and \"n\" parameters\n * of the distribution.\n *\n * Requires: m > 0 and n > 0\n */\n explicit param_type(RealType m_arg = RealType(1.0),\n RealType n_arg = RealType(1.0))\n : _m(m_arg), _n(n_arg)\n {}\n\n /** Returns the \"m\" parameter of the distribtuion. */\n RealType m() const { return _m; }\n /** Returns the \"n\" parameter of the distribution. */\n RealType n() const { return _n; }\n\n /** Writes a @c param_type to a @c std::ostream. */\n BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)\n { os << parm._m << ' ' << parm._n; return os; }\n\n /** Reads a @c param_type from a @c std::istream. */\n BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)\n { is >> parm._m >> std::ws >> parm._n; return is; }\n\n /** Returns true if the two sets of parameters are the same. */\n BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)\n { return lhs._m == rhs._m && lhs._n == rhs._n; }\n\n /** Returns true if the two sets of parameters are the different. */\n BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)\n\n private:\n RealType _m;\n RealType _n;\n };\n\n /**\n * Constructs a @c fisher_f_distribution from its \"m\" and \"n\" parameters.\n *\n * Requires: m > 0 and n > 0\n */\n explicit fisher_f_distribution(RealType m_arg = RealType(1.0),\n RealType n_arg = RealType(1.0))\n : _impl_m(m_arg), _impl_n(n_arg)\n {}\n /** Constructs an @c fisher_f_distribution from its parameters. */\n explicit fisher_f_distribution(const param_type& parm)\n : _impl_m(parm.m()), _impl_n(parm.n())\n {}\n\n /**\n * Returns a random variate distributed according to the\n * F distribution.\n */\n template\n RealType operator()(URNG& urng)\n {\n return (_impl_m(urng) * n()) / (_impl_n(urng) * m());\n }\n\n /**\n * Returns a random variate distributed according to the\n * F distribution with parameters specified by @c param.\n */\n template\n RealType operator()(URNG& urng, const param_type& parm) const\n {\n return fisher_f_distribution(parm)(urng);\n }\n\n /** Returns the \"m\" parameter of the distribution. */\n RealType m() const { return _impl_m.n(); }\n /** Returns the \"n\" parameter of the distribution. */\n RealType n() const { return _impl_n.n(); }\n\n /** Returns the smallest value that the distribution can produce. */\n RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return 0; }\n /** Returns the largest value that the distribution can produce. */\n RealType max BOOST_PREVENT_MACRO_SUBSTITUTION () const\n { return std::numeric_limits::infinity(); }\n\n /** Returns the parameters of the distribution. */\n param_type param() const { return param_type(m(), n()); }\n /** Sets the parameters of the distribution. */\n void param(const param_type& parm)\n {\n typedef chi_squared_distribution impl_type;\n typename impl_type::param_type m_param(parm.m());\n _impl_m.param(m_param);\n typename impl_type::param_type n_param(parm.n());\n _impl_n.param(n_param);\n }\n\n /**\n * Effects: Subsequent uses of the distribution do not depend\n * on values produced by any engine prior to invoking reset.\n */\n void reset() { }\n\n /** Writes an @c fisher_f_distribution to a @c std::ostream. */\n BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, fisher_f_distribution, fd)\n {\n os << fd.param();\n return os;\n }\n\n /** Reads an @c fisher_f_distribution from a @c std::istream. */\n BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, fisher_f_distribution, fd)\n {\n param_type parm;\n if(is >> parm) {\n fd.param(parm);\n }\n return is;\n }\n\n /**\n * Returns true if the two instances of @c fisher_f_distribution will\n * return identical sequences of values given equal generators.\n */\n BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(fisher_f_distribution, lhs, rhs)\n { return lhs._impl_m == rhs._impl_m && lhs._impl_n == rhs._impl_n; }\n\n /**\n * Returns true if the two instances of @c fisher_f_distribution will\n * return different sequences of values given equal generators.\n */\n BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(fisher_f_distribution)\n\nprivate:\n chi_squared_distribution _impl_m;\n chi_squared_distribution _impl_n;\n};\n\n} // namespace random\n} // namespace boost\n\n#endif // BOOST_RANDOM_EXTREME_VALUE_DISTRIBUTION_HPP\n", "meta": {"hexsha": "dc2f1a6d2c2e6f98105eaffbcaf3622a77a98b46", "size": 5912, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "deps/src/boost_1_65_1/boost/random/fisher_f_distribution.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/random/fisher_f_distribution.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/random/fisher_f_distribution.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": 32.1304347826, "max_line_length": 77, "alphanum_fraction": 0.6430987821, "num_tokens": 1459, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7154239957834733, "lm_q2_score": 0.6261241772283034, "lm_q1q2_score": 0.44794426072931237}} {"text": "/* boost random/mixmax.hpp header file\n *\n * Copyright Kostas Savvidis 2008-2019\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 * See http://www.boost.org for most recent version including documentation.\n *\n * $Id$\n *\n * Revision history\n * 2019-04-23 created\n */\n\n#ifndef BOOST_RANDOM_MIXMAX_HPP\n#define BOOST_RANDOM_MIXMAX_HPP\n\n#include \n#include \n#include \n\n#include \n#include \n\nnamespace boost {\nnamespace random {\n\n/**\n * Instantiations of class template mixmax_engine model,\n * \\pseudo_random_number_generator .\n * It uses the MIXMAX generator algorithms from:\n *\n * @blockquote\n * G.K.Savvidy and N.G.Ter-Arutyunian,\n * On the Monte Carlo simulation of physical systems,\n * J.Comput.Phys. 97, 566 (1991);\n * Preprint EPI-865-16-86, Yerevan, Jan. 1986\n * http://dx.doi.org/10.1016/0021-9991(91)90015-D\n *\n * K.Savvidy\n * The MIXMAX random number generator\n * Comp. Phys. Commun. 196 (2015), pp 161–165\n * http://dx.doi.org/10.1016/j.cpc.2015.06.003\n *\n * K.Savvidy and G.Savvidy\n * Spectrum and Entropy of C-systems. MIXMAX random number generator\n * Chaos, Solitons & Fractals, Volume 91, (2016) pp. 33–38\n * http://dx.doi.org/10.1016/j.chaos.2016.05.003\n * @endblockquote\n *\n * The generator crucially depends on the choice of the\n * parameters. The valid sets of parameters are from the published papers above.\n *\n */\n\ntemplate // MIXMAX TEMPLATE PARAMETERS\nclass mixmax_engine{\npublic:\n // Interfaces required by C++11 std::random and boost::random\n typedef boost::uint64_t result_type ;\n BOOST_STATIC_CONSTANT(boost::uint64_t,mixmax_min=0);\n BOOST_STATIC_CONSTANT(boost::uint64_t,mixmax_max=((1ULL<<61)-1));\n BOOST_STATIC_CONSTEXPR result_type min BOOST_PREVENT_MACRO_SUBSTITUTION() {return mixmax_min;}\n BOOST_STATIC_CONSTEXPR result_type max BOOST_PREVENT_MACRO_SUBSTITUTION() {return mixmax_max;}\n static const bool has_fixed_range = false;\n BOOST_STATIC_CONSTANT(int,N=Ndim); ///< The main internal parameter, size of the defining MIXMAX matrix\n // CONSTRUCTORS:\n explicit mixmax_engine(); ///< Constructor, unit vector as initial state, acted on by A^2^512\n explicit mixmax_engine(boost::uint64_t); ///< Constructor, one 64-bit seed\n explicit mixmax_engine(uint32_t clusterID, uint32_t machineID, uint32_t runID, uint32_t streamID ); ///< Constructor, four 32-bit seeds for 128-bit seeding flexibility\n void seed(boost::uint64_t seedval=default_seed){seed_uniquestream( &S, 0, 0, (uint32_t)(seedval>>32), (uint32_t)seedval );} ///< seed with one 64-bit seed\n \nprivate: // DATATYPES\n struct rng_state_st{\n boost::array V;\n boost::uint64_t sumtot;\n int counter;\n };\n \n typedef struct rng_state_st rng_state_t; // struct alias\n rng_state_t S;\n \npublic: // SEEDING FUNCTIONS\n template mixmax_engine(It& first, It last) { seed(first,last); }\n BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(mixmax_engine, SeedSeq, seq){ seed(seq); }\n \n /** Sets the state of the generator using values from an iterator range. */\n template\n void seed(It& first, It last){\n uint32_t v[4];\n detail::fill_array_int<32>(first, last, v);\n seed_uniquestream( &S, v[0], v[1], v[2], v[3]);\n }\n /** Sets the state of the generator using values from a seed_seq. */\n BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(mixmax_engine, SeeqSeq, seq){\n uint32_t v[4];\n detail::seed_array_int<32>(seq, v);\n seed_uniquestream( &S, v[0], v[1], v[2], v[3]);\n }\n \n /** return one uint64 between min=0 and max=2^61-1 */\n boost::uint64_t operator()(){\n if (S.counter<=(Ndim-1) ){\n return S.V[S.counter++];\n }else{\n S.sumtot = iterate_raw_vec(S.V.data(), S.sumtot);\n S.counter=2;\n return S.V[1];\n }\n }\n \n /** Fills a range with random values */\n template\n void generate(Iter first, Iter last) { detail::generate_from_int(*this, first, last); }\n \n void discard(boost::uint64_t nsteps) { for(boost::uint64_t j = 0; j < nsteps; ++j) (*this)(); } ///< discard n steps, required in boost::random\n \n /** save the state of the RNG to a stream */\n template\n friend std::basic_ostream&\n operator<< (std::basic_ostream& ost, const mixmax_engine& me){\n ost << Ndim << \" \" << me.S.counter << \" \" << me.S.sumtot << \" \";\n for (int j=0; (j< (Ndim) ); j++) {\n ost << (boost::uint64_t)me.S.V[j] << \" \";\n }\n ost << \"\\n\";\n ost.flush();\n return ost;\n }\n \n /** read the state of the RNG from a stream */\n template\n friend std::basic_istream&\n operator>> (std::basic_istream &in, mixmax_engine& me){\n // will set std::ios::failbit if the input format is not right\n boost::array vec;\n boost::uint64_t sum=0, savedsum=0, counter=0;\n in >> counter >> std::ws;\n BOOST_ASSERT(counter==Ndim);\n in >> counter >> std::ws;\n in >> savedsum >> std::ws;\n for(int j=0;j> std::ws >> vec[j] ;\n sum=me.MOD_MERSENNE(sum+vec[j]);\n }\n if (sum == savedsum && counter>0 && counter> BITS) );}\ninline boost::uint64_t MULWU(boost::uint64_t k);\ninline void seed_vielbein(rng_state_t* X, unsigned int i); // seeds with the i-th unit vector, i = 0..Ndim-1, for testing only\ninline void seed_uniquestream( rng_state_t* Xin, uint32_t clusterID, uint32_t machineID, uint32_t runID, uint32_t streamID );\ninline boost::uint64_t iterate_raw_vec(boost::uint64_t* Y, boost::uint64_t sumtotOld);\ninline boost::uint64_t apply_bigskip(boost::uint64_t* Vout, boost::uint64_t* Vin, uint32_t clusterID, uint32_t machineID, uint32_t runID, uint32_t streamID );\ninline boost::uint64_t modadd(boost::uint64_t foo, boost::uint64_t bar);\ninline boost::uint64_t fmodmulM61(boost::uint64_t cum, boost::uint64_t s, boost::uint64_t a);\n};\n\ntemplate mixmax_engine ::mixmax_engine()\n///< constructor, with no params, seeds with seed=0, random numbers are as good as from any other seed\n{\n seed_uniquestream( &S, 0, 0, 0, default_seed);\n}\n\ntemplate mixmax_engine ::mixmax_engine(boost::uint64_t seedval){\n ///< constructor, one uint64_t seed, random numbers are statistically independent from any two distinct seeds, e.g. consecutive seeds are ok\n seed_uniquestream( &S, 0, 0, (uint32_t)(seedval>>32), (uint32_t)seedval );\n}\n\ntemplate mixmax_engine ::mixmax_engine(uint32_t clusterID, uint32_t machineID, uint32_t runID, uint32_t streamID){\n // constructor, four 32-bit seeds for 128-bit seeding flexibility\n seed_uniquestream( &S, clusterID, machineID, runID, streamID );\n}\n\ntemplate uint64_t mixmax_engine ::MULWU (uint64_t k){ return (( (k)<<(SPECIALMUL) & M61) ^ ( (k) >> (BITS-SPECIALMUL)) ) ;}\n\ntemplate boost::uint64_t mixmax_engine ::iterate_raw_vec(boost::uint64_t* Y, boost::uint64_t sumtotOld){\n // operates with a raw vector, uses known sum of elements of Y\n boost::uint64_t tempP=0, tempV=sumtotOld;\n Y[0] = tempV;\n boost::uint64_t sumtot = Y[0], ovflow = 0; // will keep a running sum of all new elements\n for (int i=1; i void mixmax_engine ::seed_vielbein(rng_state_t* X, unsigned int index){\n for (int i=0; i < Ndim; i++){\n X->V[i] = 0;\n }\n if (indexV[index] = 1; }else{ X->V[0]=1; }\n X->counter = Ndim; // set the counter to Ndim if iteration should happen right away\n X->sumtot = 1;\n}\n\n\ntemplate void mixmax_engine ::seed_uniquestream( rng_state_t* Xin, uint32_t clusterID, uint32_t machineID, uint32_t runID, uint32_t streamID ){\n seed_vielbein(Xin,0);\n Xin->sumtot = apply_bigskip(Xin->V.data(), Xin->V.data(), clusterID, machineID, runID, streamID );\n Xin->counter = 1;\n}\n\n\ntemplate boost::uint64_t mixmax_engine ::apply_bigskip( boost::uint64_t* Vout, boost::uint64_t* Vin, uint32_t clusterID, uint32_t machineID, uint32_t runID, uint32_t streamID ){\n /*\n makes a derived state vector, Vout, from the mother state vector Vin\n by skipping a large number of steps, determined by the given seeding ID's\n \n it is mathematically guaranteed that the substreams derived in this way from the SAME (!!!) Vin will not collide provided\n 1) at least one bit of ID is different\n 2) less than 10^100 numbers are drawn from the stream\n (this is good enough : a single CPU will not exceed this in the lifetime of the universe, 10^19 sec,\n even if it had a clock cycle of Planck time, 10^44 Hz )\n \n Caution: never apply this to a derived vector, just choose some mother vector Vin, for example the unit vector by seed_vielbein(X,0),\n and use it in all your runs, just change runID to get completely nonoverlapping streams of random numbers on a different day.\n \n clusterID and machineID are provided for the benefit of large organizations who wish to ensure that a simulation\n which is running in parallel on a large number of clusters and machines will have non-colliding source of random numbers.\n \n did i repeat it enough times? the non-collision guarantee is absolute, not probabilistic\n \n */\n \n \n const boost::uint64_t skipMat17[128][17] =\n#include \"boost/random/detail/mixmax_skip_N17.ipp\"\n ;\n \n const boost::uint64_t* skipMat[128];\n BOOST_ASSERT(Ndim==17);\n for (int i=0; i<128; i++) { skipMat[i] = skipMat17[i];}\n \n uint32_t IDvec[4] = {streamID, runID, machineID, clusterID};\n boost::uint64_t Y[Ndim], cum[Ndim];\n boost::uint64_t sumtot=0;\n \n for (int i=0; i> 1); r++; // bring up the r-th bit in the ID\n }\n }\n sumtot=0;\n for (int i=0; i inline boost::uint64_t mixmax_engine ::fmodmulM61(boost::uint64_t cum, boost::uint64_t s, boost::uint64_t a){\n // works on all platforms, including 32-bit linux, PPC and PPC64, ARM and Windows\n const boost::uint64_t MASK32=0xFFFFFFFFULL;\n boost::uint64_t o,ph,pl,ah,al;\n o=(s)*a;\n ph = ((s)>>32);\n pl = (s) & MASK32;\n ah = a>>32;\n al = a & MASK32;\n o = (o & M61) + ((ph*ah)<<3) + ((ah*pl+al*ph + ((al*pl)>>32))>>29) ;\n o += cum;\n o = (o & M61) + ((o>>61));\n return o;\n}\n\ntemplate boost::uint64_t mixmax_engine ::modadd(boost::uint64_t foo, boost::uint64_t bar){\n return MOD_MERSENNE(foo+bar);\n}\n\n/* @copydoc boost::random::detail::mixmax_engine_doc */\n/** Instantiation with a valid parameter set. */\ntypedef mixmax_engine<17,36,0> mixmax;\n}// namespace random\n}// namespace boost\n\n#endif // BOOST_RANDOM_MIXMAX_HPP\n", "meta": {"hexsha": "3f09fc323612d159ef821419335ab237a64795b2", "size": 14131, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "ReactNativeFrontend/ios/Pods/boost/boost/random/mixmax.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": 2728.0, "max_stars_repo_stars_event_min_datetime": "2015-01-01T10:06:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T18:12:58.000Z", "max_issues_repo_path": "ReactNativeFrontend/ios/Pods/boost/boost/random/mixmax.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": 1192.0, "max_issues_repo_issues_event_min_datetime": "2015-01-01T06:03:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T09:14:36.000Z", "max_forks_repo_path": "ReactNativeFrontend/ios/Pods/boost/boost/random/mixmax.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": 334.0, "max_forks_repo_forks_event_min_datetime": "2015-01-08T20:47:03.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-18T07:07:01.000Z", "avg_line_length": 45.0031847134, "max_line_length": 267, "alphanum_fraction": 0.653173873, "num_tokens": 4178, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7371581741774411, "lm_q2_score": 0.6076631698328916, "lm_q1q2_score": 0.4479438727888907}} {"text": "// Copyright (c) Dietmar Wolz.\r\n//\r\n// This source code is licensed under the MIT license found in the\r\n// LICENSE file in the root directory.\r\n\r\n// Eigen based implementation of multi objective\r\n// Differential Evolution using the DE/all/1 strategy.\r\n//\r\n// Can switch to NSGA-II like population update via parameter 'nsga_update'.\r\n// Then it works essentially like NSGA-II but instead of the tournament selection\r\n// the whole population is sorted and the best individuals survive. To do this\r\n// efficiently the crowd distance ordering is slightly inaccurate.\r\n//\r\n// Supports parallel fitness function evaluation.\r\n//\r\n// Features enhanced multiple constraint ranking (https://www.jstage.jst.go.jp/article/tjpnsec/11/2/11_18/_article/-char/en/)\r\n// improving its performance in handling constraints for engineering design optimization.\r\n//\r\n// Enables the comparison of DE and NSGA-II population update mechanism with everything else\r\n// kept completely identical.\r\n//\r\n// Uses the following deviation from the standard DE algorithm:\r\n// a) oscillating CR/F parameters.\r\n//\r\n// You may keep parameters F and CR at their defaults since this implementation works well with the given settings for most problems,\r\n// since the algorithm oscillates between different F and CR settings.\r\n//\r\n// For expensive objective functions (e.g. machine learning parameter optimization) use the workers\r\n// parameter to parallelize objective function evaluation. The workers parameter is limited by the\r\n// population size.\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 \"pcg_random.hpp\"\r\n#include \"evaluator.h\"\r\n\r\nnamespace mode_optimizer {\r\n\r\nclass MoDeOptimizer {\r\n\r\npublic:\r\n\r\n MoDeOptimizer(long runid_, Fitness *fitfun_, callback_type log_, int dim_,\r\n \t\tint nobj_, int ncon_, int seed_,\r\n int popsize_, int maxEvaluations_, double F_, double CR_,\r\n double pro_c_, double dis_c_, double pro_m_, double dis_m_,\r\n bool nsga_update_, double pareto_update_, int log_period_) {\r\n // runid used to identify a specific run\r\n runid = runid_;\r\n // fitness function to minimize\r\n fitfun = fitfun_;\r\n // callback to log progress\r\n log = log_;\r\n // Number of objective variables/problem dimension\r\n dim = dim_;\r\n // Number of objectives\r\n nobj = nobj_;\r\n // Number of constraints\r\n ncon = ncon_;\r\n // Population size\r\n popsize = popsize_ > 0 ? popsize_ : 128;\r\n // maximal number of evaluations allowed.\r\n maxEvaluations = maxEvaluations_ > 0 ? maxEvaluations_ : 500000;\r\n // DE population update parameters, ignored if nsga_update == true\r\n F = F0 = F_ > 0 ? F_ : 0.5;\r\n CR = CR0 = CR_ > 0 ? CR_ : 0.9;\r\n // Number of iterations already performed.\r\n iterations = 0;\r\n // Number of evaluations already performed.\r\n n_evals = 0;\r\n // position of current x/y\r\n pos = 0;\r\n //std::random_device rd;\r\n rs = new pcg64(seed_);\r\n // NSGA population update parameters, ignored if nsga_update == false\r\n \t // usually use pro_c = 1.0, dis_c = 20.0, pro_m = 1.0, dis_m = 20.0.\r\n \tpro_c = pro_c_;\r\n \tdis_c = dis_c_;\r\n \tpro_m = pro_m_;\r\n \tdis_m = dis_m_;\r\n // if true, use NSGA population update, if false, use DE population update\r\n // Use DE update to diversify your results.\r\n \tnsga_update = nsga_update_;\r\n // DE population update parameter. Only applied if nsga_update = false.\r\n \t// Use the pareto front for population update\r\n \t// with probability pareto_update, else use the whole population.\r\n \t// If pareto_update == 0: use always the whole population.\r\n // usually should be 0, optimization can get stuck in local minima otherwise.\r\n \tpareto_update = pareto_update_;\r\n // The log callback is called each log_period iterations \r\n log_period = log_period_;\r\n if (log_period <= 0)\r\n log_period = 1000;\r\n init();\r\n }\r\n\r\n ~MoDeOptimizer() {\r\n delete rs;\r\n }\r\n\r\n double rnd01() {\r\n return distr_01(*rs);\r\n }\r\n\r\n int rndInt(int max) {\r\n return (int) (max * distr_01(*rs));\r\n }\r\n\r\n vec nextX(int p) {\r\n if (p == 0) {\r\n iterations++;\r\n \tif (iterations % log_period == 0) {\r\n \t\tif (log(popX.cols(), popX.data(), popY.data()))\r\n \t\t\tfitfun->setTerminate();\r\n \t}\r\n }\r\n \tif (nsga_update) {\r\n \t\tvec x = vX.col(vp);\r\n \t\tvp = (vp + 1) % popsize;\r\n \t\treturn x;\r\n \t}\r\n \t// use DE update strategy.\r\n if (p == 0) {\r\n CR = iterations % 2 == 0 ? 0.5 * CR0 : CR0;\r\n F = iterations % 2 == 0 ? 0.5 * F0 : F0;\r\n }\r\n int r3;\r\n if (rnd01() < pareto_update) {\r\n\t\t\t// sample from pareto front\r\n do {\r\n \tr3 = rndInt(bestP.size());\r\n \tr3 = bestP[r3];\r\n } while (r3 == p);\r\n } else {\r\n\t\t\t// sample from whole population\r\n do {\r\n r3 = rndInt(popsize);\r\n } while (r3 == p);\r\n }\r\n vec xp = popX.col(p);\r\n vec x3 = popX.col(r3);\r\n int r1, r2;\r\n do {\r\n r1 = rndInt(popsize);\r\n } while (r1 == p || r1 == r3);\r\n do {\r\n r2 = rndInt(popsize);\r\n } while (r2 == p || r2 == r3 || r2 == r1);\r\n vec x1 = popX.col(r1);\r\n vec x2 = popX.col(r2);\r\n vec x = x3 + (x1 - x2) * F;\r\n int r = rndInt(dim);\r\n for (int j = 0; j < dim; j++)\r\n if (j != r && rnd01() > CR)\r\n x[j] = xp[j];\r\n return fitfun->getClosestFeasible(x);\r\n }\r\n\r\n vec crowd_dist(mat& y) { // crowd distance for 1st objective\r\n \tint n = y.cols();\r\n \tvec y0 = y.row(0);\r\n \tivec si = sort_index(y0); // sort 1st objective\r\n \tvec y0s = y0(si); // sorted y0\r\n \tvec d(n-1);\r\n for (int i = 0; i < n-1; i++)\r\n \td(i) = y0s[i+1] - y0s[i]; // neighbor distance\r\n if (d.maxCoeff() == 0)\r\n \treturn zeros(n);\r\n vec dsum = zeros(n);\r\n for (int i = 0; i < n; i++) {\r\n \tif (i > 0)\r\n \t\tdsum(i) += d(i-1); // distance to left\r\n \tif (i < n-1)\r\n \t\tdsum(i) += d(i); // distance to right\r\n }\r\n dsum(0) = DBL_MAX; // keep borders\r\n dsum(n-1) = DBL_MAX;\r\n vec ds(n);\r\n ds(si) = dsum; // inverse order\r\n return ds;\r\n }\r\n\r\n bool is_dominated(const mat& y, int i, int index) {\r\n \tfor (int j = 0; j < y.rows(); j++)\r\n \t\tif (y(j,i) < y(j,index))\r\n \t\t\treturn false;\r\n \treturn true;\r\n }\r\n\r\n vec pareto_levels(const mat& y) {\r\n int n = y.cols();\r\n ivec pareto(n);\r\n for (int i = 0; i < n; i++)\r\n \tpareto(i) = i;\r\n vec domination = zeros(n);\r\n bool mask[n];\r\n for (int i = 0; i < n; i++)\r\n \t mask[i] = true;\r\n for (int index = 0; index < n;) {\r\n \t\tfor (int i = 0; i < n; i++) {\r\n \t\t\tif (i != index && mask[i] && is_dominated(y, i, index))\r\n \t\t\t\tmask[i] = false;\r\n \t\t}\r\n \t\tfor (int i = 0; i < n; i++) {\r\n \t\t\tif (mask[i])\r\n \t\t\t\tdomination[i] += 1;\r\n \t\t}\r\n \t\tindex++;\r\n \t\twhile(!mask[index] && index < n)\r\n \t\t\tindex++;\r\n }\r\n return domination;\r\n }\r\n\r\n vec objranks(mat objs) {\r\n \timat ci(objs.cols(), objs.rows());\r\n \tfor (int i = 0; i < objs.rows(); i++)\r\n \t\tci.col(i) = sort_index(objs.row(i).transpose());\r\n \tmat rank(objs.rows(), objs.cols());\r\n \tfor (int j = 0; j < objs.rows(); j++)\r\n \t\tfor (int i = 0; i < objs.cols(); i++) {\r\n \t\t\trank(j, ci(i,j)) = i;\r\n \t}\r\n \treturn rank.colwise().sum();\r\n }\r\n\r\n vec ranks(mat cons) {\r\n \timat ci(cons.cols(), cons.rows());\r\n \tfor (int i = 0; i < cons.rows(); i++)\r\n \t\tci.col(i) = sort_index(cons.row(i).transpose());\r\n \tmat rank(cons.rows(), cons.cols());\r\n \tvec alpha = zeros(cons.rows());\r\n \tfor (int j = 0; j < cons.rows(); j++) {\r\n \t\tfor (int i = 0; i < cons.cols(); i++) {\r\n \t\t\tif (cons(j,i) <= 0) {\r\n \t\t\t\trank(j, ci(i,j)) = 0;\r\n \t\t\t} else {\r\n \t\t\t\trank(j, ci(i,j)) = i;\r\n \t\t\t\talpha[j]++;\r\n \t\t\t}\r\n \t\t}\r\n \t}\r\n \tfor (int j = 0; j < cons.rows(); j++) {\r\n \t\tfor (int i = 0; i < cons.cols(); i++)\r\n \t\t\trank(j, ci(i,j)) *= alpha[j] / cons.rows();\r\n \t}\r\n \treturn rank.colwise().sum();\r\n }\r\n\r\n vec pareto(const mat& ys) {\r\n \tif (ncon == 0)\r\n \t\treturn pareto_levels(ys);\r\n int popn = ys.cols();\r\n mat yobj = ys(Eigen::seqN(0, nobj), Eigen::all);\r\n mat ycon = ys(Eigen::lastN(ncon), Eigen::all);\r\n vec csum = ranks(ycon);\r\n bool feasible[ys.cols()];\r\n bool hasFeasible = false;\r\n for (int i = 0; i < ys.cols(); i++) {\r\n \tfeasible[i] = ycon.col(i).maxCoeff() <= 0;\r\n \tif (feasible[i])\r\n \t\thasFeasible = true;\r\n }\r\n if (hasFeasible)\r\n \tcsum += objranks(yobj);\r\n\t\t// first pareto front of feasible solutions\r\n vec domination = zeros(popn);\r\n std::vector cyv;\r\n for (int i = 0; i < ys.cols(); i++) // collect feasibles\r\n \tif (feasible[i]) cyv.push_back(i);\r\n ivec cy = Eigen::Map(cyv.data(), cyv.size());\r\n if (hasFeasible) { // compute pareto levels only for feasible\r\n \tvec ypar = pareto_levels(yobj(Eigen::all, cy));\r\n \tdomination(cy) += ypar;\r\n }\r\n // then constraint violations\r\n ivec ci = sort_index(csum);\r\n std::vector civ;\r\n for (int i = 0; i < ci.size(); i++)\r\n \tif (!feasible[ci(i)]) civ.push_back(ci(i));\r\n if (civ.size() > 0) {\r\n \tivec ci = Eigen::Map(civ.data(), civ.size());\r\n \tint maxcdom = ci.size();\r\n \t// higher constraint violation level gets lower domination level assigned\r\n \tfor (int i = 0; i < ci.size(); i++)\r\n \t\tdomination(ci(i)) += maxcdom - i;\r\n \tif (cy.size() > 0) { // priorize feasible solutions\r\n \tfor (int i = 0; i < cy.size(); i++)\r\n \t\tdomination(cy(i)) += maxcdom + 1;\r\n \t}\r\n } // higher dominates lower\r\n return domination;\r\n }\r\n\r\n mat variation(const mat& x) {\r\n \tint n2 = x.cols() / 2;\r\n \tint n = 2 * n2;\r\n mat parent1 = x(Eigen::all, Eigen::seq(0, n2-1));\r\n mat parent2 = x(Eigen::all, Eigen::seq(n2, n-1));\r\n mat beta = mat(dim, n2);\r\n vec to1;\r\n if (pro_c < 1.0) {\r\n \tto1 = uniformVec(dim, *rs);\r\n }\r\n for (int p = 0; p < n2; p++) {\r\n\t\t\tfor (int i = 0; i < dim; i++) {\r\n\t\t\t\tif (rnd01() > 0.5 || (pro_c < 1.0 && to1(i) < pro_c))\r\n\t\t\t\t\tbeta(i, p) = 1.0;\r\n\t\t\t\telse {\r\n\t\t\t\t\tdouble r = rnd01();\r\n\t\t\t\t\tif (r <= 0.5)\r\n\t\t\t\t\t\tbeta(i, p) = pow(2 * r, 1.0 / (dis_c + 1.0));\r\n\t\t\t\t\telse\r\n\t\t\t\t\t\tbeta(i, p) = pow(2 * r, -1.0 / (dis_c + 1.0));\r\n\t\t\t\t\tif (rnd01() > 0.5)\r\n\t\t\t\t\t\tbeta(i, p) = -beta(i, p);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n mat offspring1 = ((parent1 + parent2) * 0.5);\r\n mat offspring2 = mat(offspring1);\r\n mat delta = (beta.array() * (parent1 - parent2).array()).matrix() * 0.5;\r\n offspring1 += delta;\r\n offspring2 -= delta;\r\n \tmat offspring = mat(dim, n);\r\n \toffspring << offspring1, offspring2;\r\n\r\n double limit = pro_m / dim;\r\n vec scale = fitfun->scale();\r\n for (int p = 0; p < n; p++) {\r\n for (int i = 0; i < dim; i++) {\r\n \tif (rnd01() < limit) { // site\r\n \t\tdouble mu = rnd01();\r\n \t\t\tdouble norm = fitfun->norm_i(i, offspring(i, p));\r\n \t\tif (mu <= 0.5) // temp\r\n \t\t\toffspring(i, p) += scale(i) * \r\n (pow(2. * mu + (1. - 2. * mu) * pow(1. - norm, dis_m + 1.),\r\n\t 1. / (dis_m + 1.)) - 1.);\r\n \t\telse\r\n \t\t\toffspring(i, p) += scale(i) * \r\n (1. - pow(2. * (1. - mu) + 2. * (mu - 0.5) * pow(1. - norm, dis_m + 1.),\r\n\t 1. / (dis_m + 1.)));\r\n \t\t}\r\n \t}\r\n }\r\n fitfun->setClosestFeasible(offspring);\r\n \treturn offspring;\r\n }\r\n\r\n void pop_update() {\r\n \tvec domination = pareto(popY);\r\n \tstd::vector x;\r\n \tstd::vector y;\r\n \tint maxdom = (int) domination.maxCoeff();\r\n \tfor (int dom = maxdom; dom >= 0; dom--) {\r\n \t\tstd::vector level;\r\n \t\tfor (int i = 0; i < domination.size(); i++)\r\n \t\t\tif (domination(i) == dom)\r\n \t\t\t\tlevel.push_back(i);\r\n ivec domlevel = Eigen::Map(level.data(), level.size());\r\n\t\t\tmat domx = popX(Eigen::all, domlevel);\r\n\t\t\tmat domy = popY(Eigen::all, domlevel);\r\n\t\t\tif (dom == maxdom) // store pareto front in bestP\r\n\t\t\t\tbestP = domlevel;\r\n\r\n \t\tif ((int)(x.size() + domlevel.size()) <= popsize) {\r\n\t\t\t\t// whole level fits\r\n \t\t\tfor (int i = 0; i < domy.cols(); i++) {\r\n \t\t\t\tx.push_back(domx.col(i));\r\n \t\t\t\ty.push_back(domy.col(i));\r\n \t\t\t}\r\n \t\t} else {\r\n \t\t\tstd::vector si;\r\n \t\t\tsi.push_back(0);\r\n \t\t\tif (domy.cols() > 1) {\r\n \t\t\t\tvec cd = crowd_dist(domy);\r\n \t\t\t\tivec si = sort_index(cd).reverse();\r\n \t\t\t\tfor (int i = 0; i < si.size(); i++) {\r\n \t\t\t\t\tif (((int)x.size()) >= popsize)\r\n \t\t\t\t\t\tbreak;\r\n \t\t\t\t\tx.push_back(domx.col(si(i)));\r\n \t\t\t\t\ty.push_back(domy.col(si(i)));\r\n \t\t\t\t}\r\n \t\t\t}\r\n \t\t\tbreak;\r\n \t\t}\r\n \t}\r\n \tfor (int i = 0; i < popsize; i++) {\r\n \t\tpopX.col(i) = x[i];\r\n \t\tpopY.col(i) = y[i];\r\n \t}\r\n \tif (nsga_update)\r\n \t\tvX = variation(popX(Eigen::all, Eigen::seqN(0, popsize)));\r\n }\r\n\r\n vec ask(int &p) {\r\n\t\tp = pos;\r\n\t\tvec x = nextX(p);\r\n\t\tpos = (pos + 1) % popsize;\r\n\t\treturn x;\r\n }\r\n\r\n int tell(const vec &y, const vec &x, int p) {\r\n \tlong unsigned int dp = 0;\r\n \tfor (; dp < vdone.size(); dp++)\r\n \t\tif (!vdone[dp]) break;\r\n \tnX.col(dp) = x;\r\n \tnY.col(dp) = y;\r\n \tvdone[dp] = true;\r\n \tint ndone = 0;\r\n \tfor (long unsigned int i = 0; i < vdone.size(); i++)\r\n \t\tif (vdone[i]) ndone++;\r\n \tif (ndone >= popsize) {\r\n\t\t\tint p = popsize;\r\n \tfor (dp = 0; dp < vdone.size(); dp++) {\r\n \t\tif (vdone[dp]) {\r\n\t\t\t\t\tpopX.col(p) = nX.col(dp);\r\n\t\t\t\t\tpopY.col(p) = nY.col(dp);\r\n\t\t\t\t\tvdone[dp] = false;\r\n\t\t\t\t\tif (p >= popY.cols())\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tp++;\r\n \t\t}\r\n \t}\r\n \tpop_update();\r\n \t}\r\n \tn_evals += 1;\r\n// if (n_evals % 1000 == 999)\r\n// \tstd::cout << popY << std::endl;\r\n \treturn stop;\r\n }\r\n\r\n void doOptimize() {\r\n \titerations = 0;\r\n \tfitfun->resetEvaluations();\r\n \twhile (fitfun->evaluations() < maxEvaluations && !fitfun->terminate()) {\r\n for (int p = 0; p < popsize; p++) {\r\n \tvec x = nextX(p);\r\n \tpopX.col(popsize + p) = x;\r\n \tpopY.col(popsize + p) = fitfun->eval(x);\r\n }\r\n pop_update();\r\n \t}\r\n }\r\n\r\n void do_optimize_delayed_update(int workers) {\r\n \t iterations = 0;\r\n \t fitfun->resetEvaluations();\r\n workers = std::min(workers, popsize); // workers <= popsize\r\n \t evaluator eval(fitfun, nobj, workers);\r\n \t vec evals_x[popsize];\r\n\t // fill eval queue with initial population\r\n \t for (int i = 0; i < workers; i++) {\r\n \t\t int p;\r\n \t\t vec x = ask(p);\r\n \t\t eval.evaluate(x, p);\r\n \t\t evals_x[p] = x;\r\n \t }\r\n \t while (fitfun->evaluations() < maxEvaluations && !fitfun->terminate()) {\r\n \t\t vec_id* vid = eval.result();\r\n \t\t vec y = vec(vid->_v);\r\n \t\t int p = vid->_id;\r\n \t\t delete vid;\r\n \t\t vec x = evals_x[p];\r\n \t\t tell(y, x, p); // tell evaluated x\r\n \t\t if (fitfun->evaluations() >= maxEvaluations)\r\n \t\t\t break;\r\n \t\t x = ask(p);\r\n \t\t eval.evaluate(x, p);\r\n \t\t evals_x[p] = x;\r\n \t }\r\n\t}\r\n\r\n void init() {\r\n popX = mat(dim, 2*popsize);\r\n popY = mat(nobj + ncon, 2*popsize);\r\n for (int p = 0; p < popsize; p++) {\r\n popX.col(p) = fitfun->sample(*rs);\r\n popY.col(p) = constant(nobj + ncon, DBL_MAX);\r\n }\r\n next_size = 2*popsize;\r\n vdone = std::vector(next_size, false);\r\n\t\tnX = mat(dim, next_size);\r\n\t\tnY = mat(nobj + ncon, next_size);\r\n\t\tvX = mat(popX);\r\n\t\tvp = 0;\r\n\t\tbestP = ivec(popsize);\r\n\t\tfor (int i = 0; i < popsize; i++)\r\n\t\t\tbestP(i) = i;\r\n }\r\n\r\n mat getX() {\r\n return popX;\r\n }\r\n\r\n mat getY() {\r\n return popY;\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 Fitness* getFitfun() {\r\n return fitfun;\r\n }\r\n\r\n int getDim() {\r\n return dim;\r\n }\r\n\r\nprivate:\r\n long runid;\r\n Fitness *fitfun;\r\n callback_type log;\r\n int popsize; // population size\r\n int dim;\r\n int nobj;\r\n int ncon;\r\n int maxEvaluations;\r\n double keep;\r\n double stopfitness;\r\n int iterations;\r\n int n_evals;\r\n ivec bestP;\r\n int stop;\r\n double F0;\r\n double CR0;\r\n double F;\r\n double CR;\r\n\tdouble pro_c;\r\n\tdouble dis_c;\r\n\tdouble pro_m;\r\n\tdouble dis_m;\r\n pcg64 *rs;\r\n mat popX;\r\n mat popY;\r\n mat nX;\r\n mat nY;\r\n mat vX;\r\n int vp;\r\n int next_size;\r\n std::vector vdone;\r\n int pos;\r\n bool nsga_update;\r\n double pareto_update;\r\n int log_period;\r\n};\r\n}\r\n\r\nusing namespace mode_optimizer;\r\n\r\nextern \"C\" {\r\nvoid optimizeMODE_C(long runid, callback_type func, callback_type log,\r\n\t\tint dim, int nobj, int ncon, int seed,\r\n double *lower, double *upper, int maxEvals,\r\n\t\tint popsize, int workers, double F, double CR, \r\n\t double pro_c, double dis_c, double pro_m, double dis_m,\r\n bool nsga_update, double pareto_update, int log_period, double* res) {\r\n vec lower_limit(dim), upper_limit(dim);\r\n for (int i = 0; i < dim; i++) {\r\n lower_limit[i] = lower[i];\r\n upper_limit[i] = upper[i];\r\n }\r\n Fitness fitfun(func, dim, nobj + ncon, lower_limit, upper_limit);\r\n MoDeOptimizer opt(runid, &fitfun, log, dim, nobj, ncon,\r\n \t\tseed, popsize, maxEvals, F, CR, \r\n pro_c, dis_c, pro_m, dis_m,\r\n nsga_update, pareto_update, log_period);\r\n try {\r\n if (workers <= 1)\r\n opt.doOptimize();\r\n else\r\n opt.do_optimize_delayed_update(workers);\r\n double* xdata = opt.getX().data();\r\n for (int i = 0; i < opt.getX().size(); i++)\r\n res[i] = xdata[i];\r\n } catch (std::exception &e) {\r\n \tstd::cout << e.what() << std::endl;\r\n }\r\n }\r\n}\r\n\r\n\r\n", "meta": {"hexsha": "283cef2a14f5b68d4b041875d15a4ccd27af84a9", "size": 18640, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "_fcmaescpp/modeoptimizer.cpp", "max_stars_repo_name": "vishalbelsare/fast-cma-es", "max_stars_repo_head_hexsha": "c6bed439bc4bf78dca7d9f2203b56d74ce272f01", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 20.0, "max_stars_repo_stars_event_min_datetime": "2020-05-28T10:23:11.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T08:09:58.000Z", "max_issues_repo_path": "_fcmaescpp/modeoptimizer.cpp", "max_issues_repo_name": "vishalbelsare/fast-cma-es", "max_issues_repo_head_hexsha": "c6bed439bc4bf78dca7d9f2203b56d74ce272f01", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 11.0, "max_issues_repo_issues_event_min_datetime": "2020-03-04T15:16:41.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-27T07:14:19.000Z", "max_forks_repo_path": "_fcmaescpp/modeoptimizer.cpp", "max_forks_repo_name": "vishalbelsare/fast-cma-es", "max_forks_repo_head_hexsha": "c6bed439bc4bf78dca7d9f2203b56d74ce272f01", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 12.0, "max_forks_repo_forks_event_min_datetime": "2020-02-19T12:26:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-26T11:22:13.000Z", "avg_line_length": 31.3277310924, "max_line_length": 134, "alphanum_fraction": 0.5032188841, "num_tokens": 5326, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7371581741774411, "lm_q2_score": 0.6076631698328916, "lm_q1q2_score": 0.4479438727888907}} {"text": "#ifndef NUMERICAL_OPTIMIZATION_HPP\n#define 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, LBfgs\n };\n\n enum class Type\n {\n Min, 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 inline Result RunOptimization(const Setting& input)\n {\n const auto f = (input.type == Type::Min) ? input.f : [&input](const Eigen::VectorXd& x) { return - input.f(x); };\n const auto g = (input.type == Type::Min) ? input.g : [&input](const Eigen::VectorXd& x) { return - input.g(x); };\n\n switch (input.algorithm) {\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, f, g, input.epsilon, input.max_num_iterations, result.x_star, 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, f, g, input.epsilon, input.max_num_iterations, result.x_star, result.num_iterations);\n return result;\n }\n }\n }\n }\n}\n\n#endif // NUMERICAL_OPTIMIZATION_HPP\n", "meta": {"hexsha": "085b4115a16437865dfb1599e4df38e2f68785f4", "size": 2509, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/mathtoolbox/numerical-optimization.hpp", "max_stars_repo_name": "josefgraus/self_similiarity", "max_stars_repo_head_hexsha": "c032daa3009f60fdc8a52c437a07c6e3ba2efe4b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-02-25T09:35:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-25T09:35:14.000Z", "max_issues_repo_path": "include/mathtoolbox/numerical-optimization.hpp", "max_issues_repo_name": "josefgraus/self_similarity", "max_issues_repo_head_hexsha": "c032daa3009f60fdc8a52c437a07c6e3ba2efe4b", "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/mathtoolbox/numerical-optimization.hpp", "max_forks_repo_name": "josefgraus/self_similarity", "max_forks_repo_head_hexsha": "c032daa3009f60fdc8a52c437a07c6e3ba2efe4b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-02-25T09:35:15.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-12T13:26:38.000Z", "avg_line_length": 33.4533333333, "max_line_length": 128, "alphanum_fraction": 0.4647269829, "num_tokens": 490, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7371581626286834, "lm_q2_score": 0.6076631698328916, "lm_q1q2_score": 0.44794386577113593}} {"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#include \"theia/vision/sfm/pose/five_point_relative_pose.h\"\n\n#include \n#include \n\n#include \n#include \n#include \n\n#include \"theia/math/matrix/gauss_jordan.h\"\n#include \"theia/math/polynomial.h\"\n#include \"theia/vision/sfm/pose/util.h\"\n\nnamespace theia {\n\nusing Eigen::Map;\nusing Eigen::Matrix3d;\nusing Eigen::Matrix4d;\nusing Eigen::Matrix;\nusing Eigen::RowVector3d;\nusing Eigen::RowVector4d;\nusing Eigen::Vector2d;\nusing Eigen::Vector3d;\nusing Eigen::Vector4d;\n\ntypedef Matrix RowMatrix3d;\n\nnamespace {\n// Multiplies two polynomials over the same variable.\ntemplate \nMatrix MultiplyPoly(const Matrix& a,\n const Matrix& b) {\n Matrix poly = Matrix::Zero();\n for (int i = 0; i < a.cols(); i++)\n for (int j = 0; j < b.cols(); j++)\n poly[i + j] += a[i] * b[j];\n\n return poly;\n}\n\n// Evaluates a given polynomial at the value x.\ntemplate \ndouble EvaluatePoly(const Matrix& poly, double x) {\n double val = 0;\n for (int i = poly.cols() - 1; i > 0; i--) {\n val += poly[i];\n val *= x;\n }\n val += poly[0];\n return val;\n}\n\n// Multiply two degree one polynomials of variables x, y, z.\n// E.g. p1 = a[0]x + a[1]y + a[2]z + a[3]\n// x^2 y^2 z^2 xy xz yz x y z 1\nMatrix MultiplyDegOnePoly(const RowVector4d& a,\n const RowVector4d& b) {\n Matrix output;\n output(0) = a(0) * b(0);\n output(1) = a(1) * b(1);\n output(2) = a(2) * b(2);\n output(3) = a(0) * b(1) + a(1) * b(0);\n output(4) = a(0) * b(2) + a(2) * b(0);\n output(5) = a(1) * b(2) + a(2) * b(1);\n output(6) = a(0) * b(3) + a(3) * b(0);\n output(7) = a(1) * b(3) + a(3) * b(1);\n output(8) = a(2) * b(3) + a(3) * b(2);\n output(9) = a(3) * b(3);\n return output;\n}\n\n// Multiply a 2 deg poly (in x, y, z) and a one deg poly.\n// x^3 y^3 x^2y xy^2 x^2z x^2 y^2z y^2 xyz xy | z^2x zx x z^2y zy y z^3 z^2 z 1\n// NOTE: after the | all are variables along z.\nMatrix MultiplyDegTwoDegOnePoly(const Matrix& a,\n const RowVector4d& b) {\n Matrix output;\n output(0) = a(0) * b(0);\n output(1) = a(1) * b(1);\n output(2) = a(0) * b(1) + a(3) * b(0);\n output(3) = a(1) * b(0) + a(3) * b(1);\n output(4) = a(0) * b(2) + a(4) * b(0);\n output(5) = a(0) * b(3) + a(6) * b(0);\n output(6) = a(1) * b(2) + a(5) * b(1);\n output(7) = a(1) * b(3) + a(7) * b(1);\n output(8) = a(3) * b(2) + a(4) * b(1) + a(5) * b(0);\n output(9) = a(3) * b(3) + a(6) * b(1) + a(7) * b(0);\n output(10) = a(2) * b(0) + a(4) * b(2);\n output(11) = a(4) * b(3) + a(8) * b(0) + a(6) * b(2);\n output(12) = a(6) * b(3) + a(9) * b(0);\n output(13) = a(2) * b(1) + a(5) * b(2);\n output(14) = a(5) * b(3) + a(8) * b(1) + a(7) * b(2);\n output(15) = a(7) * b(3) + a(9) * b(1);\n output(16) = a(2) * b(2);\n output(17) = a(2) * b(3) + a(8) * b(2);\n output(18) = a(8) * b(3) + a(9) * b(2);\n output(19) = a(9) * b(3);\n return output;\n}\n\n// Shorthand for multiplying the Essential matrix with its transpose according\n// to Eq. 20 in Nister paper.\nMatrix EETranspose(\n const Matrix& null_matrix, int i, int j) {\n return MultiplyDegOnePoly(null_matrix.row(3 * i), null_matrix.row(3 * j)) +\n MultiplyDegOnePoly(null_matrix.row(3 * i + 1),\n null_matrix.row(3 * j + 1)) +\n MultiplyDegOnePoly(null_matrix.row(3 * i + 2),\n null_matrix.row(3 * j + 2));\n}\n\n// Builds the 10x20 constraint matrix according to Section 3.2.2 of Nister\n// paper. Constraints are built based on the singularity of the Essential\n// matrix, and the trace equation (Eq. 6). This builds the 10x20 matrix such\n// that the columns correspond to: x^3, yx^2, y^2x, y^3, zx^2, zyx, zy^2, z^2x,\n// z^2y, z^3, x^2, yx, y^2, zx, zy, z^2, x, y, z, 1.\nMatrix BuildConstraintMatrix(\n const Matrix& null_space) {\n Matrix constraint_matrix;\n // Singularity constraint.\n constraint_matrix.row(0) =\n MultiplyDegTwoDegOnePoly(\n MultiplyDegOnePoly(null_space.row(1), null_space.row(5)) -\n MultiplyDegOnePoly(null_space.row(2), null_space.row(4)),\n null_space.row(6)) +\n MultiplyDegTwoDegOnePoly(\n MultiplyDegOnePoly(null_space.row(2), null_space.row(3)) -\n MultiplyDegOnePoly(null_space.row(0), null_space.row(5)),\n null_space.row(7)) +\n MultiplyDegTwoDegOnePoly(\n MultiplyDegOnePoly(null_space.row(0), null_space.row(4)) -\n MultiplyDegOnePoly(null_space.row(1), null_space.row(3)),\n null_space.row(8));\n\n // Trace Constraint. Only need to compute the upper triangular part of the\n // symmetric polynomial matrix\n Matrix symmetric_poly[3][3];\n symmetric_poly[0][0] = EETranspose(null_space, 0, 0);\n symmetric_poly[1][1] = EETranspose(null_space, 1, 1);\n symmetric_poly[2][2] = EETranspose(null_space, 2, 2);\n\n Matrix half_trace = 0.5*(symmetric_poly[0][0] +\n symmetric_poly[1][1] +\n symmetric_poly[2][2]);\n\n symmetric_poly[0][0] -= half_trace;\n symmetric_poly[1][1] -= half_trace;\n symmetric_poly[2][2] -= half_trace;\n symmetric_poly[0][1] = EETranspose(null_space, 0, 1);\n symmetric_poly[0][2] = EETranspose(null_space, 0, 2);\n symmetric_poly[1][0] = symmetric_poly[0][1];\n symmetric_poly[1][2] = EETranspose(null_space, 1, 2);\n symmetric_poly[2][0] = symmetric_poly[0][2];\n symmetric_poly[2][1] = symmetric_poly[1][2];\n\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n constraint_matrix.row(3*i + j + 1) =\n MultiplyDegTwoDegOnePoly(symmetric_poly[i][0],\n null_space.row(j)) +\n MultiplyDegTwoDegOnePoly(symmetric_poly[i][1],\n null_space.row(3 + j)) +\n MultiplyDegTwoDegOnePoly(symmetric_poly[i][2],\n null_space.row(6 + j));\n }\n }\n return constraint_matrix;\n}\n\n// Efficient nullspace extraction based on the idea of QR decomposition on the 5\n// correspondences of the epipolar constraint. Instead of QR, we use\n// Gauss-Jordan for the same effect.\nMatrix EfficientNullspaceExtraction(\n const Matrix& constraint) {\n Matrix constraint_copy(constraint);\n GaussJordan(&constraint_copy);\n Matrix null_space;\n null_space << constraint_copy.rightCols(4).transpose(),\n -Matrix4d::Identity();\n return null_space.transpose();\n}\n\nvoid EfficientSVDDecomp(const Matrix3d& essential_mat,\n Vector3d* null_space,\n Matrix3d rotation[4],\n Vector3d translation[4]) {\n Matrix3d d;\n d << 0, 1, 0,\n -1, 0, 0,\n 0, 0, 1;\n\n const Vector3d& ea = essential_mat.row(0);\n const Vector3d& eb = essential_mat.row(1);\n const Vector3d& ec = essential_mat.row(2);\n\n // Generate cross products.\n Matrix3d cross_products;\n cross_products << ea.cross(eb), ea.cross(ec), eb.cross(ec);\n\n // Choose the cross product with the largest norm (for numerical accuracy).\n const Vector3d cf_scales(cross_products.col(0).squaredNorm(),\n cross_products.col(1).squaredNorm(),\n cross_products.col(2).squaredNorm());\n int max_index;\n cf_scales.maxCoeff(&max_index);\n\n // For index 0, 1, we want ea and for index 2 we want eb.\n const int max_e_index = max_index / 2;\n\n // Construct v of the SVD.\n Matrix3d v = Matrix3d::Zero();\n v.col(2) = cross_products.col(max_index).normalized();\n v.col(0) = essential_mat.row(max_e_index).normalized();\n v.col(1) = v.col(2).cross(v.col(0));\n\n // Construct U of the SVD.\n Matrix3d u = Matrix3d::Zero();\n u.col(0) = (essential_mat * v.col(0)).normalized();\n u.col(1) = (essential_mat * v.col(1)).normalized();\n u.col(2) = u.col(0).cross(u.col(1));\n\n // Possible rotation configurations.\n const RowMatrix3d ra =\n Eigen::Quaterniond(u * d * v.transpose()).normalized().toRotationMatrix();\n const RowMatrix3d rb = Eigen::Quaterniond(u * d.transpose() * v.transpose())\n .normalized().toRotationMatrix();\n\n // Scale t to be proper magnitude. Scale factor is derived from the fact that\n // U*diag*V^t = E. We simply choose to scale it such that the last terms will\n // be equal.\n const Vector3d t = u.col(2).normalized();\n const Vector3d t_neg = -t;\n\n // Copy the 4 possible decompositions into the output arrays.\n rotation[0] = ra;\n translation[0] = t;\n rotation[1] = ra;\n translation[1] = t_neg;\n rotation[2] = rb;\n translation[2] = t;\n rotation[3] = rb;\n translation[3] = t_neg;\n\n *null_space = v.col(2);\n}\n\nvoid DecomposeWithIdealCorrespondence(const Vector2d& image_point1,\n const Vector2d& image_point2,\n const Matrix3d& essential_mat,\n Matrix3d* rotation,\n Vector3d* translation) {\n const Vector3d image_point1_homog = image_point1.homogeneous();\n const Vector3d image_point2_homog = image_point2.homogeneous();\n\n // Map the image points to vectors.\n Matrix3d candidate_rotation[4];\n Vector3d candidate_translation[4];\n Vector3d null_space;\n EfficientSVDDecomp(essential_mat, &null_space, candidate_rotation,\n candidate_translation);\n\n Matrix projection_mat;\n projection_mat.block<3, 3>(0, 0) = candidate_rotation[0];\n projection_mat.block<3, 1>(0, 3) = candidate_translation[0];\n\n // Compute c.\n Matrix3d temp_diag = Matrix3d::Identity();\n temp_diag(2, 2) = 0.0;\n const Vector3d c =\n image_point2_homog.cross(temp_diag * essential_mat * image_point1_homog);\n\n // Compute C.\n const Vector4d C = projection_mat.transpose() * c;\n const Vector4d Q(image_point1_homog(0) * C(3),\n image_point1_homog(1) * C(3),\n image_point1_homog(2) * C(3),\n -(image_point1_homog.dot(C.head<3>())));\n // We only care about the sign of the depth because it informs us of the\n // direction of the point (i.e. if it is in front of the camera). Use a\n // multiply instead of divide for speed.\n const double scaled_depth_1 = Q(2) * Q(3);\n const double scaled_depth_2 = projection_mat.row(2).dot(Q) * Q(3);\n\n // Create the twisted pair transformation.\n const Vector4d twisted_transformation(-2.0 * null_space(0),\n -2.0 * null_space(1),\n -2.0 * null_space(2),\n -1.0);\n\n // Determine the proper configuration for the R,t decomposition.\n int best_index;\n if (scaled_depth_1 > 0 && scaled_depth_2 > 0) {\n best_index = 0;\n } else if (scaled_depth_1 < 0 && scaled_depth_2 < 0) {\n best_index = 1;\n } else if (Q(2) * twisted_transformation.dot(Q) > 0) {\n best_index = 2;\n } else {\n best_index = 3;\n }\n\n *rotation = candidate_rotation[best_index];\n *translation = candidate_translation[best_index];\n}\n\n} // namespace\n\n// Implementation of Nister from \"An Efficient Solution to the Five-Point\n// Relative Pose Problem\"\nbool FivePointRelativePose(const Vector2d image1_points[5],\n const Vector2d image2_points[5],\n std::vector* rotation,\n std::vector* translation) {\n // Step 1. Create the 5x9 matrix containing epipolar constraints.\n // Essential matrix is a linear combination of the 4 vectors spanning the\n // null space of this matrix (found by SVD).\n Matrix epipolar_constraint;\n for (int i = 0; i < 5; i++) {\n // Fill matrix with the epipolar constraint from q'_t*E*q = 0. Where q is\n // from the first image, and q' is from the second. Eq. 8 in the Nister\n // paper.\n epipolar_constraint.row(i) <<\n image1_points[i].x() * image2_points[i].x(),\n image1_points[i].y() * image2_points[i].x(),\n image2_points[i].x(),\n image1_points[i].x() * image2_points[i].y(),\n image1_points[i].y() * image2_points[i].y(),\n image2_points[i].y(),\n image1_points[i].x(),\n image1_points[i].y(),\n 1.0;\n }\n\n // Solve for right null space of the 5x9 matrix. NOTE: We use a\n // super-efficient method that is a variation of the QR decomposition\n // described in the Nister paper. by roughly 5x.\n Matrix null_space =\n EfficientNullspaceExtraction(epipolar_constraint);\n\n // Step 2. Expansion of the epipolar constraints Eq. 5 and 6 from Nister\n // paper.\n Matrix constraint_matrix = BuildConstraintMatrix(null_space);\n\n // Step 3. Gauss-Jordan Elimination with partial pivoting on constraint\n // matrix.\n GaussJordan(&constraint_matrix);\n\n // Step 4. Expand determinant polynomial of 3x3 polynomial B.\n // Create matrix B. Horribly ugly, but not sure if there's a better way to do\n // it!\n RowVector4d b11(constraint_matrix(4, 12),\n constraint_matrix(4, 11) - constraint_matrix(5, 12),\n constraint_matrix(4, 10) - constraint_matrix(5, 11),\n -constraint_matrix(5, 10));\n RowVector4d b12(constraint_matrix(4, 15),\n constraint_matrix(4, 14) - constraint_matrix(5, 15),\n constraint_matrix(4, 13) - constraint_matrix(5, 14),\n -constraint_matrix(5, 13));\n Matrix b13;\n b13 << constraint_matrix(4, 19),\n constraint_matrix(4, 18) - constraint_matrix(5, 19),\n constraint_matrix(4, 17) - constraint_matrix(5, 18),\n constraint_matrix(4, 16) - constraint_matrix(5, 17),\n -constraint_matrix(5, 16);\n RowVector4d b21(constraint_matrix(6, 12),\n constraint_matrix(6, 11) - constraint_matrix(7, 12),\n constraint_matrix(6, 10) - constraint_matrix(7, 11),\n -constraint_matrix(7, 10));\n RowVector4d b22(constraint_matrix(6, 15),\n constraint_matrix(6, 14) - constraint_matrix(7, 15),\n constraint_matrix(6, 13) - constraint_matrix(7, 14),\n -constraint_matrix(7, 13));\n Matrix b23;\n b23 << constraint_matrix(6, 19),\n constraint_matrix(6, 18) - constraint_matrix(7, 19),\n constraint_matrix(6, 17) - constraint_matrix(7, 18),\n constraint_matrix(6, 16) - constraint_matrix(7, 17),\n -constraint_matrix(7, 16);\n RowVector4d b31(constraint_matrix(8, 12),\n constraint_matrix(8, 11) - constraint_matrix(9, 12),\n constraint_matrix(8, 10) - constraint_matrix(9, 11),\n -constraint_matrix(9, 10));\n RowVector4d b32(constraint_matrix(8, 15),\n constraint_matrix(8, 14) - constraint_matrix(9, 15),\n constraint_matrix(8, 13) - constraint_matrix(9, 14),\n -constraint_matrix(9, 13));\n Matrix b33;\n b33 << constraint_matrix(8, 19),\n constraint_matrix(8, 18) - constraint_matrix(9, 19),\n constraint_matrix(8, 17) - constraint_matrix(9, 18),\n constraint_matrix(8, 16) - constraint_matrix(9, 17),\n -constraint_matrix(9, 16);\n\n // Eq. 24.\n Matrix p1 = MultiplyPoly(b12, b23) - MultiplyPoly(b13, b22);\n // Eq. 25.\n Matrix p2 = MultiplyPoly(b13, b21) - MultiplyPoly(b11, b23);\n // Eq. 26.\n Matrix p3 = MultiplyPoly(b11, b22) - MultiplyPoly(b12, b21);\n\n // Eq. 27. Form determinant of B as a 10th degree polynomial.\n Matrix n = MultiplyPoly(p1, b31) + MultiplyPoly(p2, b32) +\n MultiplyPoly(p3, b33);\n\n // Step 5. Extract real roots of the 10th degree polynomial.\n Eigen::VectorXd roots;\n FindRealPolynomialRoots(n.transpose().reverse(), &roots);\n\n rotation->reserve(roots.size());\n translation->reserve(roots.size());\n static const double kTolerance = 1e-12;\n for (int i = 0; i < roots.size(); i++) {\n // We only want non-zero roots\n if (fabs(roots(i)) < kTolerance)\n continue;\n\n double x = EvaluatePoly(p1, roots(i)) / EvaluatePoly(p3, roots(i));\n double y = EvaluatePoly(p2, roots(i)) / EvaluatePoly(p3, roots(i));\n Matrix temp_sum =\n x * null_space.col(0) + y * null_space.col(1) +\n roots(i) * null_space.col(2) + null_space.col(3);\n // Need to do it like this because temp_sum is a row vector and recasting\n // it as a 3x3 will load it column-major.\n Matrix3d candidate_essential_mat;\n candidate_essential_mat << temp_sum.head<3>().transpose(),\n temp_sum.segment(3, 3).transpose(), temp_sum.tail(3).transpose();\n\n Matrix3d rotation_soln;\n Vector3d translation_soln;\n // Decompose into R, t using the first point correspondence.\n DecomposeWithIdealCorrespondence(image1_points[0], image2_points[0],\n candidate_essential_mat, &rotation_soln,\n &translation_soln);\n rotation->push_back(rotation_soln);\n translation->push_back(translation_soln);\n }\n return (roots.size() > 0);\n}\n\n} // namespace theia\n", "meta": {"hexsha": "20977aa57ff4e01260a7ca371e367cbdfe68471a", "size": 19173, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/theia/vision/sfm/pose/five_point_relative_pose.cc", "max_stars_repo_name": "nuernber/Theia", "max_stars_repo_head_hexsha": "4bac771b09458a46c44619afa89498a13cd39999", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-02-02T13:30:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-02T13:30:52.000Z", "max_issues_repo_path": "src/theia/vision/sfm/pose/five_point_relative_pose.cc", "max_issues_repo_name": "nuernber/Theia", "max_issues_repo_head_hexsha": "4bac771b09458a46c44619afa89498a13cd39999", "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/vision/sfm/pose/five_point_relative_pose.cc", "max_forks_repo_name": "nuernber/Theia", "max_forks_repo_head_hexsha": "4bac771b09458a46c44619afa89498a13cd39999", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-09-28T08:43:13.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-28T08:43:13.000Z", "avg_line_length": 40.3642105263, "max_line_length": 80, "alphanum_fraction": 0.6238460335, "num_tokens": 5706, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7371581626286834, "lm_q2_score": 0.6076631698328916, "lm_q1q2_score": 0.44794386577113593}} {"text": "#include \"profile.hpp\"\n#include \"profile_python.hpp\"\n#include \n#include \n#include \"optimization.hpp\"\n#include \"rootfinder.hpp\"\n\nnamespace gd {\nusing namespace boost::python;\n\n// in km/s^2 Msun/kpc\nconst double GravConst = 4.30200406461e-06;\n\nboost::python::tuple ProfileModel::Lmax_and_rcirc_at_E_(double E) {\n\tdouble Lmax, rcirc;\n\tLmax_and_rcirc_at_E(E, Lmax, rcirc);\n\treturn boost::python::make_tuple(Lmax, rcirc);\n}\nvoid ProfileModel::Lmax_and_rcirc_at_E(double E, double& Lmax, double& rcirc) {\n\t/*\tdef f(r, E=E):\n\t\t\tr = abs(r)\n\t\t\treturn -r**2*(2*(E-self.potentialr(r)))\n\t\trLmax, Lmaxsq = scipy.optimize.fmin(f, rtry, full_output=True, disp=False)[:2]\n\t\treturn sqrt(abs(Lmaxsq)), abs(rLmax[0])\n\t*/\n\tauto f = [&](double logr) -> double {\n\t\t//r = fabs(r);\n\t\tdouble r = pow(10, logr);\n\t\t//printf(\"r = %f logr\\n \", r);\n\t\treturn -r*r*(2*(E-this->potentialr(r)));\n\t};\n\tMinimizerNLopt2<> opt(f);\n\t//double lower_bounds[1] = { 0};\n\t//nlopt_set_lower_bounds(opt.opt, lower_bounds);\n\t//opt.x = 1.;\n\trcirc = pow(10, opt.optimize());\n\t//printf(\"r = %f Ekin = %f\\n\", r, 2*(E-this->potentialr(r)));\n\tLmax = sqrt(2*(E-this->potentialr(rcirc)))*rcirc;\n}\ndouble ProfileModel::Lmax_at_E(double E) {\n\tdouble Lmax, rcirc;\n\tLmax_and_rcirc_at_E(E, Lmax, rcirc);\n\treturn Lmax;\n}\ndouble ProfileModel::rcirc_at_E(double E) {\n\tdouble Lmax, rcirc;\n\tLmax_and_rcirc_at_E(E, Lmax, rcirc);\n\treturn rcirc;\n}\ndouble ProfileModel::rmax_at_E(double E, double rcirc) {\n\tauto f = [&](double r) -> double {\n\t\treturn E - this->potentialr(r);\n\t};\n\tdouble scale = 1.5;\n\tdouble r_far_way = rcirc * scale;\n\tassert(f(rcirc) >= 0);\n\twhile(f(r_far_way) > 0) {\n\t\tr_far_way *= scale;\n\t}\n\tRootFinderGSL<> rootfinder(f);\n\tdouble rmax = rootfinder.findRoot(rcirc, r_far_way);\n\treturn rmax;\n\t\n\t/*auto f = [&](double r) -> double {\n\t\treturn E - this->potentialr(r);\n\t};\n\tauto root = [&](double x, double * y, double *dy) -> void {\n\t\tdouble r = pow(10, x) + rcirc;\n\t\t// x = log10(r-rcirc)\n\t\t// dx = 1/(r-rcirc) / log(10) dr\n\t\t*y = f(r);\n\t\tdouble gradient = -this->dphidr(r) * (r-rcirc) * log(10);\n\t\t*dy = gradient;\n\t\t//*\n\t\tdouble r1 = r;\n\t\tdouble dx = 1e-4;\n\t\tdouble r2 = pow(10, x+dx)+rcirc;\n\t\tdouble y1 = f(r1);\n\t\tdouble y2 = f(r2);\n\t\tprintf(\"rmax grad: logr=%f r=%10.5f: erad=%10.5f [%10.5f %10.5f] (%f) \\n\", x, r, *y, (y2-y1)/dx, gradient, this->potentialr(r));\n\t\t//return g\n\t\t/**/\n\t/*};\n\t\n\t// find apo or peri center\n\tRootFinderGSLDerivative<> rootfinderFirst(root);\n\tdouble rstart = pow(10, rootfinderFirst.findRoot(1, 0, 1e-5))+rcirc; //pow(10, rootfinderFirst.findRoot(0));\n\tdouble scale = 1.+1e-4;\n\tassert(f(rstart*scale) < 0);\n\tassert(f(rstart/scale) > 0);\n\treturn rstart;*/\n}\n\n\nboost::python::tuple ProfileModel::get_apo_peri(double E, double L, double rmin, double rcirc, double rmax) {\n\n\tauto ekinrad = [&](double r) -> double { // kinetic energy in radial direction\n\t\treturn (-L*L/(2*r*r) - (this->potentialr(r) - E));\n\t};\n\tauto root = [&](double x, double * y, double *dy) -> void {\n\t\tif(x < 0) {\n\t\t\t//*y =FP_INFINITE;// inf;\n\t\t\t//*dy = FP_INFINITE;//inf;\n\t\t\t//return;\n\t\t\t//printf(\"grad: x=%f\\n\", x);\n\t\t\t//x = -x;\n\t\t}\n\t\tdouble r = pow(10, x);\n\t\t*y = ekinrad(r);\n\t\tdouble gradient = (-this->dphidr(r) + L*L/pow(r, 3)) * r * log(10);\n\t\t*dy = gradient;\n\t\t//*\n\t\tdouble r1 = r;\n\t\tdouble dx = 1e-4;\n\t\tdouble r2 = pow(10, x+dx);\n\t\tdouble y1 = ekinrad(r1);\n\t\tdouble y2 = ekinrad(r2);\n\t\t//printf(\"grad: logr=%f r=%10.5f: erad=%10.5f [%10.5f %10.5f] (%f) \\n\", x, r, *y, (y2-y1)/dx, gradient, this->potentialr(r));\n\t\t//return g\n\t\t/**/\n\t};\n\n\t// find apo or peri center\n\t//RootFinderGSLDerivative<> rootfinderFirst(root);\n\t//double rstart = pow(10, rootfinderFirst.findRoot(1)); //pow(10, rootfinderFirst.findRoot(0));\n\n\tdouble scale = (1+1e-4);\n\tdouble apo, peri;\n\tRootFinderGSL<> rootfinder(ekinrad);\n\t//printf(\"found a valid r %f (E=%f L=%f Eleft=%f (%f %f))\\n\", rstart, E, L, ekinrad(rstart), ekinrad(rstart*scale), ekinrad(rstart/scale));\n\t//printf(\"rmin : %f ekinrad: %f %f %f\\n\", rmin, ekinrad(rmin), ekinrad(rmin*scale), ekinrad(rmin/scale));\n\t//printf(\"rcirc: %f ekinrad: %f %f %f\\n\", rcirc, ekinrad(rcirc), ekinrad(rcirc*scale), ekinrad(rcirc/scale));\n\t//printf(\"rmax : %f ekinrad: %f %f %f\\n\", rmax, ekinrad(rmax), ekinrad(rmax*scale), ekinrad(rmax/scale));\n\tint n;\n\tn = 0;\n\tassert(ekinrad(rcirc) >= 0);\n\twhile((n < 10) & (ekinrad(rmin) > 0)) {\n\t\trmin /= scale;\n\t\tn++;\n\t}\n\tif(ekinrad(rmin) > 0) {\n\t\tthrow std::range_error(\"rmin cannot be properly found\");\n\t}\n\n\tn = 0;\n\twhile((n < 10) & (ekinrad(rmax) > 0)) {\n\t\trmax *= scale;\n\t\tn++;\n\t}\n\tif(ekinrad(rmax) > 0) {\n\t\tthrow std::range_error(\"rmax cannot be properly found\");\n\t}\n\n\n\tperi = rootfinder.findRoot(rmin, rcirc);\n\tapo = rootfinder.findRoot(rcirc, rmax);\n\t\n\t\t//printf(\"finding apocenter [%f]\\n\", rstart);\n\t\t//printf(\"found apocenter [%f]\\n\", apo);\n\t\t//printf(\"finding pericenter [%f] (%f %f %f)\\n\", rstart, ekinrad(1e-6), ekinrad(rstart/scale/scale), ekinrad(rstart*scale*scale));\n\t\t//printf(\"found pericenter [%f]\\n\", peri);\n\tscale = (1+1e-5);\n\twhile(ekinrad(peri) < 0) {\n\t\tperi *= scale;\n\t}\n\twhile(ekinrad(apo) < 0) {\n\t\tapo /= scale;\n\t}\n\treturn boost::python::make_tuple(apo/scale, peri*scale);\n\t\n\t/*\n\t# just find apo or pericenter\n\trstart = self.findR_at_EL(E, L, rtry)\n\ttry:\n\t\trstart = rstart[0]\n\texcept:\n\t\tpass\n\ts = (1+1e-5) # scale factor for testing apo/peri\n\tr = rstart\n\t#print rstart, ekinrad(rstart/s), ekinrad(rstart*s), -L**2/(2*r**2) - (self.potentialr(r) - E), -L**2/(2*r**2) , (self.potentialr(r) - E)\n\tif (ekinrad(rstart/s) < 0) and (ekinrad(rstart*s) > 0): # we found pericenter\n\t\trp = rstart\n\t\tra = brentq(ekinrad, rstart*s, 1e9)\n\telse: # we found apocenter\n\t\tra = rstart\n\t\trp = brentq(ekinrad, 1e-9, rstart/s)\n\t\n\t# sanity checks\n\tassert ekinrad(ra*s) < 0, \"available energy ar r > r_apo should be negative\"\n\tassert ekinrad(rp/s) < 0, \"available energy ar r < r_peri should be negative\"\n\tassert ekinrad(ra/s) > 0, \"available energy ar r < r_apo should be positive\"\n\tassert ekinrad(rp*s) > 0, \"available energy ar r > r_peri should be positive\"\n\tassert ra > rp, \"apocenter should be larger than pericenter\" \n\treturn ra/s, rp*s*/\n}\n\n\n\nvoid py_export_profile() {\n\tclass_< ProfileModel, boost::noncopyable >(\"ProfileModel\", no_init)\n\t\t.def(\"get_apo_peri\", (&ProfileModel::get_apo_peri))\n\t\t.def(\"Lmax_at_E\", (&ProfileModel::Lmax_at_E))\n\t\t.def(\"Lmax_and_rcirc_at_E\", (&ProfileModel::Lmax_and_rcirc_at_E_))\n\t\t.def(\"rcirc_at_E\", (&ProfileModel::rcirc_at_E))\n\t\t.def(\"rmax_at_E\", (&ProfileModel::rmax_at_E))\n\t\t\n\t\t;\n\tclass_, boost::noncopyable >(\"ProfileModel1C\", init())\n\t\t.def(\"densityr\", (&ProfileModel1C::densityr))\n\t\t.def(\"dphidr\", (&ProfileModel1C::dphidr))\n\t\t.def(\"potentialr\", (&ProfileModel1C::potentialr))\n\t\t;\n\tclass_, boost::noncopyable >(\"ProfileModel2C\", init())\n\t\t.def(\"densityr\", (&ProfileModel2C::densityr))\n\t\t.def(\"dphidr\", (&ProfileModel2C::dphidr))\n\t\t.def(\"potentialr\", (&ProfileModel2C::potentialr))\n\t\t;\n\t\n\tclass_< Profile, boost::noncopyable >(\"Profile\", no_init)\n\t\t.def(\"densityr\", pure_virtual(&Profile::densityr))\n\t\t;\n\tclass_< Density, boost::noncopyable >(\"Density\", no_init)\n\t\t.def(\"densityr\", pure_virtual(&Density::densityr))\n\t\t;\n\t//py_export_profile_profile>(\"Plummer\");\n\t//init((boost::python::arg(\"b\"), boost::python::arg(\"M\"), boost::python::arg(\"G\")))\n\tpy_export_profile_profile_kw(\"Plummer\", init((boost::python::arg(\"M\"), boost::python::arg(\"b\"), boost::python::arg(\"G\")=GravConst)));\n\t/*class_ >(\"Plummer\", init())\n\t\t.def(\"potentialr\", (&Plummer::potentialr))\n\t\t.def(\"densityr\", (&Plummer::densityr))\n\t\t.def(\"densityR\", (&Plummer::densityR))\n\t\t.def(\"dphidr\", (&Plummer::dphidr))\n\t\t//.def(\"dphidr2\", (&Plummer::dphidr2))\n\t\t;\n\t*/\n\t//py_export_profile_profile_kw(\"ProjectedExponential\", init((boost::python::arg(\"M\"), boost::python::arg(\"scale\"), boost::python::arg(\"G\")=GravConst)));\n\tpy_export_profile_profile_kw(\"ProjectedExponential\", init());\n\t\n\t\n\tclass_ >(\"TestCase\", init())\n\t\t.def(\"potentialr\", (&TestCase::potentialr))\n\t\t.def(\"densityr\", (&TestCase::densityr))\n\t\t.def(\"densityR\", (&TestCase::densityR))\n\t\t.def(\"dphidr\", (&TestCase::dphidr))\n\t\t//.def(\"dphidr2\", (&TestCase::dphidr2))\n\t\t;\n\tclass_ >(\"LogarithmicProfile\", init())\n\t\t.def(\"densityr\", (&LogarithmicProfile::densityr))\n\t\t.def(\"densityR\", (&LogarithmicProfile::densityR))\n\t\t.def(\"dphidr\", (&LogarithmicProfile::dphidr))\n\t\t//.def(\"dphidr2\", (&LogarithmicProfile::dphidr2))\n\t;\n\tclass_ >(\"Isochrone\", init())\n\t\t.def(\"densityr\", (&Isochrone::densityr))\n\t\t.def(\"densityR\", (&Isochrone::densityR))\n\t\t.def(\"dphidr\", (&Isochrone::dphidr))\n\t\t//.def(\"dphidr2\", (&Isochrone::dphidr2))\n\t\t.def(\"potentialr\", (&Isochrone::potentialr))\n\t\t;\n\tclass_ >(\"NullProfile\", init<>())\n\t\t.def(\"densityr\", (&NullProfile::densityr))\n\t\t.def(\"densityR\", (&NullProfile::densityR))\n\t\t.def(\"dphidr\", (&NullProfile::dphidr))\n\t\t//.def(\"dphidr2\", (&NullProfile::dphidr2))\n\t;\n\tclass_ >(\"Hernquist\", init())\n\t\t.def(\"densityr\", (&Hernquist::densityr))\n\t\t.def(\"densityR\", (&Hernquist::densityR))\n\t\t.def(\"dphidr\", (&Hernquist::dphidr))\n\t\t.def(\"potentialr\", (&Hernquist::potentialr))\n\t\t;\n\tclass_ >(\"Jaffe\", init())\n\t\t.def(\"densityr\", (&Jaffe::densityr))\n\t\t.def(\"densityR\", (&Jaffe::densityR))\n\t\t.def(\"dphidr\", (&Jaffe::dphidr))\n\t\t.def(\"potentialr\", (&Jaffe::potentialr))\n\t\t;\n\tclass_ >(\"Einasto\", init())\n\t\t.def(\"densityr\", (&Einasto::densityr))\n\t\t.def(\"densityR\", (&Einasto::densityR))\n\t\t.def(\"dphidr\", (&Einasto::dphidr))\n\t\t.def(\"potentialr\", (&Einasto::potentialr))\n\t\t;\n\tclass_ >(\"Burkert\", init())\n\t\t.def(\"densityr\", (&Burkert::densityr))\n\t\t.def(\"densityR\", (&Burkert::densityR))\n\t\t.def(\"dphidr\", (&Burkert::dphidr))\n\t\t.def(\"potentialr\", (&Burkert::potentialr))\n\t\t;\n\tclass_ >(\"NFW\", init())\n\t\t.def(\"densityr\", (&NFW::densityr))\n\t\t.def(\"potentialr\", (&NFW::potentialr))\n\t\t.def(\"dphidr\", (&NFW::dphidr))\n\t\t.def_readonly(\"c\", &NFW::c)\n\t\t.def_readonly(\"mass200\", &NFW::mass200)\n\t\t.def_readonly(\"r200\", &NFW::r200)\n\t\t.def_readonly(\"rs\", &NFW::rs)\n\t\t.def_readonly(\"rho0\", &NFW::rho0);\n\t;\n\tclass_ >(\"NFWCut\", init())\n\t\t.def(\"densityr\", (&NFWCut::densityr))\n\t\t.def_readwrite(\"rs\", &NFWCut::rs)\n\t\t.def_readwrite(\"rte\", &NFWCut::rte)\n\t\t.def_readwrite(\"rho0\", &NFWCut::rho0)\n\t\t;\n\tclass_ >(\"TwoSlopeDensity\", init())\n\t\t.def(\"densityr\", (&TwoSlopeDensity::densityr))\n\t\t.def_readwrite(\"alpha\", &TwoSlopeDensity::alpha)\n\t\t.def_readwrite(\"beta\", &TwoSlopeDensity::beta)\n\t\t.def_readwrite(\"rho0\", &TwoSlopeDensity::rho0)\n\t\t.def_readwrite(\"rs\", &TwoSlopeDensity::rs)\n\t\t.def_readwrite(\"gamma\", &TwoSlopeDensity::gamma)\n\t\t;\n\tclass_ >(\"TwoSlopeDensityCut\", init())\n\t\t.def(\"densityr\", (&TwoSlopeDensityCut::densityr))\n\t\t.def_readwrite(\"alpha\", &TwoSlopeDensityCut::alpha)\n\t\t.def_readwrite(\"beta\", &TwoSlopeDensityCut::beta)\n\t\t.def_readwrite(\"rho0\", &TwoSlopeDensityCut::rho0)\n\t\t.def_readwrite(\"rs\", &TwoSlopeDensityCut::rs)\n\t\t.def_readwrite(\"gamma\", &TwoSlopeDensityCut::gamma)\n\t\t.def_readwrite(\"rte\", &TwoSlopeDensityCut::rte)\n\t\t;\n\tclass_ >(\"BrokenPowerLawDensitySoft3\", init())\n\t\t.def(\"densityr\", (&BrokenPowerLawDensitySoft3::densityr))\n\t\t.def_readwrite(\"rho0\", &BrokenPowerLawDensitySoft3::rho0)\n\t\t.def_readwrite(\"s1\", &BrokenPowerLawDensitySoft3::s1)\n\t\t.def_readwrite(\"s2\", &BrokenPowerLawDensitySoft3::s2)\n\t\t.def_readwrite(\"s3\", &BrokenPowerLawDensitySoft3::s3)\n\t\t.def_readwrite(\"gamma1\", &BrokenPowerLawDensitySoft3::gamma1)\n\t\t.def_readwrite(\"gamma2\", &BrokenPowerLawDensitySoft3::gamma2)\n\t\t.def_readwrite(\"rs1\", &BrokenPowerLawDensitySoft3::rs1)\n\t\t.def_readwrite(\"rs2\", &BrokenPowerLawDensitySoft3::rs2)\n\t\t;\n\t\n}\n\n\n}\n", "meta": {"hexsha": "8945770a1ac2af654c8835b315f047809695fe7e", "size": 12590, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "gdfast/src/profile.cpp", "max_stars_repo_name": "maartenbreddels/mab", "max_stars_repo_head_hexsha": "112dcfbc4a74b07aff13d489b3776bca58fe9bdf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2018-12-01T04:10:34.000Z", "max_stars_repo_stars_event_max_datetime": "2018-12-01T04:10:34.000Z", "max_issues_repo_path": "gdfast/src/profile.cpp", "max_issues_repo_name": "maartenbreddels/mab", "max_issues_repo_head_hexsha": "112dcfbc4a74b07aff13d489b3776bca58fe9bdf", "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": "gdfast/src/profile.cpp", "max_forks_repo_name": "maartenbreddels/mab", "max_forks_repo_head_hexsha": "112dcfbc4a74b07aff13d489b3776bca58fe9bdf", "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.1386430678, "max_line_length": 199, "alphanum_fraction": 0.6633836378, "num_tokens": 4434, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7371581510799253, "lm_q2_score": 0.6076631698328917, "lm_q1q2_score": 0.4479438587533811}} {"text": "// Copyright (c) 2021 Stig Rune Sellevag\n//\n// This file is distributed under the MIT License. See the accompanying file\n// LICENSE.txt or http://www.opensource.org/licenses/mit-license.php for terms\n// and conditions.\n\n#ifdef _MSC_VER\n#pragma warning(push)\n#pragma warning(disable : 5054)\n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing Timer = std::chrono::duration;\n\nvoid print(int n, const Timer& t_eigen, const Timer& t_sci, const Timer& t_val)\n{\n std::cout << \"Dot product:\\n\"\n << \"------------\\n\"\n << \"size = \" << n << '\\n'\n << \"scilib/eigen = \" << t_sci.count() / t_eigen.count() << \"\\n\"\n << \"scilib/valarray = \" << t_sci.count() / t_val.count()\n << \"\\n\\n\";\n}\n\nvoid benchmark(int n)\n{\n Eigen::VectorXd aa(n);\n Eigen::VectorXd ab(n);\n\n aa.fill(1.0);\n ab.fill(2.0);\n\n auto t1 = std::chrono::high_resolution_clock::now();\n double dot_eigen;\n for (int it = 0; it < 10000; ++it) {\n dot_eigen = aa.dot(ab);\n }\n auto t2 = std::chrono::high_resolution_clock::now();\n Timer t_eigen = t2 - t1;\n (void) dot_eigen; // ignore unused result\n\n Sci::Vector na(n);\n Sci::Vector nb(n);\n na = 1.0;\n nb = 2.0;\n t1 = std::chrono::high_resolution_clock::now();\n double sci;\n for (int it = 0; it < 10000; ++it) {\n sci = Sci::Linalg::dot(na.view(), nb.view());\n }\n t2 = std::chrono::high_resolution_clock::now();\n Timer t_sci = t2 - t1;\n (void) sci;\n\n std::valarray va(1.0, n);\n std::valarray vb(2.0, n);\n t1 = std::chrono::high_resolution_clock::now();\n double val;\n for (int it = 0; it < 10000; ++it) {\n val = std::inner_product(std::begin(va), std::end(va), std::begin(vb),\n 0.0);\n }\n t2 = std::chrono::high_resolution_clock::now();\n Timer t_val = t2 - t1;\n (void) val;\n\n print(n, t_eigen, t_sci, t_val);\n}\n\nint main()\n{\n int n = 10;\n benchmark(n);\n\n n = 100;\n benchmark(n);\n\n n = 1000;\n benchmark(n);\n\n n = 10000;\n benchmark(n);\n\n n = 100000;\n benchmark(n);\n}\n\n#ifdef _MSC_VER\n#pragma warning(pop)\n#endif\n", "meta": {"hexsha": "2b64ca64e6f4fb9992d7cd93eda9546383c0510d", "size": 2328, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "bench/bench_dot.cpp", "max_stars_repo_name": "stigrs/scilib", "max_stars_repo_head_hexsha": "c49f1f882bf2031a4de537e0f5701b2648af181f", "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": "bench/bench_dot.cpp", "max_issues_repo_name": "stigrs/scilib", "max_issues_repo_head_hexsha": "c49f1f882bf2031a4de537e0f5701b2648af181f", "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": "bench/bench_dot.cpp", "max_forks_repo_name": "stigrs/scilib", "max_forks_repo_head_hexsha": "c49f1f882bf2031a4de537e0f5701b2648af181f", "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.7551020408, "max_line_length": 80, "alphanum_fraction": 0.5652920962, "num_tokens": 698, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7371581510799252, "lm_q2_score": 0.6076631698328917, "lm_q1q2_score": 0.44794385875338105}} {"text": "/**\n * DD cut generation for CPLEX\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"cut_cplex.hpp\"\n#include \"flow_decomp.hpp\"\n#include \"../bdd/bdd.hpp\"\n#include \"../util/graph.hpp\"\n#include \"../util/stats.hpp\"\n\nusing boost::any_cast;\nusing boost::unordered_set;\n\n\n/**\n * Generates a cut for the set of points represented by the given BDD towards the direction of the given point.\n * All input must be in layer space. Store additional information in cut_info unless it is NULL (default).\n */\nInequality* generate_bdd_inequality(BDD* bdd, const vector& x, const vector& interior_point, Options* options,\n CutInfo* cut_info /* = NULL */)\n{\n\tInequality* facet;\n\tint nvars = bdd->layers.size() - 1;\n\n\tStats stats;\n\tstats.register_name(\"cut-time\");\n\tstats.start_timer(0);\n\ttry {\n\n\t\tIloEnv env;\n\t\tIloModel model(env);\n\n\t\tIloNumVarArray u(env, nvars);\n\t\tIloArray v(env, nvars+1);\n\n\t\t// Create variables\n\t\tfor (int i = 0; i < nvars; ++i) {\n\t\t\tu[i] = IloNumVar(env, -IloInfinity, IloInfinity, IloNumVar::Float, (\"u\" + to_string(i)).c_str());\n\t\t}\n\n\t\tfor (int i = 0; i < nvars + 1; ++i) {\n\t\t\tint size = bdd->layers[i].size();\n\t\t\tv[i] = IloNumVarArray(env, size);\n\t\t\tfor (int j = 0; j < size; ++j) {\n\t\t\t\tv[i][j] = IloNumVar(env, -IloInfinity, IloInfinity, IloNumVar::Float,\n\t\t\t\t (\"v\" + to_string(i) + \",\" + to_string(j)).c_str());\n\t\t\t}\n\t\t}\n\n\t\t// Define objective\n\t\tIloObjective obj = IloAdd(model, IloMaximize(env));\n\t\tfor (int i = 0; i < nvars; ++i) {\n\t\t\tobj.setLinearCoef(u[i], x[i] - interior_point[i]);\n\t\t}\n\n\t\t// Initialize constraint arrays\n\t\tIloArray zero_arc_constrs(env, nvars + 1);\n\t\tIloArray one_arc_constrs(env, nvars + 1);\n\t\tfor (int i = 0; i < nvars + 1; ++i) {\n\t\t\tint size = bdd->layers[i].size();\n\t\t\tzero_arc_constrs[i] = IloRangeArray(env, size);\n\t\t\tone_arc_constrs[i] = IloRangeArray(env, size);\n\t\t}\n\n\t\t// Add constraints\n\t\tfor (int i = 0; i < nvars; ++i) {\n\t\t\tint size = bdd->layers[i].size();\n\t\t\tfor (int j = 0; j < size; ++j) {\n\t\t\t\tNode* zero_node = bdd->layers[i][j]->zero_arc;\n\t\t\t\tNode* one_node = bdd->layers[i][j]->one_arc;\n\n\t\t\t\tif (zero_node != NULL) {\n\t\t\t\t\t// cout << i << \",\" << j << \" / \" << zero_node->layer << \",\" << zero_node->id << endl;\n\t\t\t\t\t// model.add( v[zero_node->layer][zero_node->id] <= v[i][j] );\n\t\t\t\t\tzero_arc_constrs[i][j] = IloRange(env, v[zero_node->layer][zero_node->id] - v[i][j], 0,\n\t\t\t\t\t (\"a0_\" + to_string(i) + \",\" + to_string(j)).c_str());\n\t\t\t\t\tmodel.add(zero_arc_constrs[i][j]);\n\t\t\t\t}\n\t\t\t\tif (one_node != NULL) {\n\t\t\t\t\t// cout << i << \",\" << j << \" / \" << one_node->layer << \",\" << one_node->id << endl;\n\t\t\t\t\t// model.add( v[one_node->layer][one_node->id] <= v[i][j] - u[i] );\n\t\t\t\t\tone_arc_constrs[i][j] = IloRange(env, v[one_node->layer][one_node->id] - v[i][j] + u[i], 0,\n\t\t\t\t\t (\"a1_\" + to_string(i) + \",\" + to_string(j)).c_str());\n\t\t\t\t\tmodel.add(one_arc_constrs[i][j]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// v_s = 1 + u^T interior_point\n\t\tIloExpr vs(env);\n\t\tvs += 1;\n\t\tfor (int i = 0; i < nvars; ++i) {\n\t\t\tvs += u[i] * interior_point[i];\n\t\t}\n\t\tassert(bdd->layers[0].size() == 1);\n\t\tmodel.add(v[0][0] == vs);\n\n\t\t// v_t = 0\n\t\tassert(bdd->layers[nvars].size() == 1);\n\t\tmodel.add(v[nvars][0] == 0);\n\n\t\t// Create CPLEX object\n\t\tIloCplex cplex(model);\n\t\tcplex.setParam(IloCplex::Threads, 1);\n\t\tcplex.setParam(IloCplex::AggInd, 100); // Important parameter for efficiency; there is often a lot to aggregate\n\t\t// cplex.setOut(env.getNullStream()); // Suppress output\n\n\t\tstats.end_timer(0);\n\t\tcout << \"Time to construct LP model: \" << stats.get_time(0) << endl;\n\t\tcout << cplex.getNrows() << \" rows and \" << cplex.getNcols() << \" columns\" << endl;\n\t\t// cplex.exportModel(\"cutlp.lp\");\n\n\t\t// Solve cut LP\n\t\tstats.start_timer(0);\n\t\tcplex.solve();\n\t\tstats.end_timer(0);\n\n\t\tcout << \"Time to solve LP: \" << stats.get_time(0) << endl;\n\n\t\tdouble bound = cplex.getObjValue();\n\t\tcout << \"Polar opt obj: \" << bound << endl;\n\n\t\t// // Debugging info, if unbounded\n\t\t// cout << \"Status: \" << cplex.getStatus() << endl;\n\t\t// IloNumArray ray_vals(env);\n\t\t// IloNumVarArray ray_vars(env);\n\t\t// cplex.getRay(ray_vals, ray_vars);\n\t\t// cout << \"Ray: \";\n\t\t// for (int i = 0; i < ray_vars.getSize(); ++i) {\n\t\t// cout << ray_vars[i] << \" \" << ray_vals[i] << endl;\n\t\t// }\n\t\t// cout << endl;\n\n\t\t// Restrict to optimal face and perturb to obtain extreme point of the polar\n\t\tif (options->cut_perturbation_iterative) {\n\t\t\tperturb_bdd_cut_iterative(env, cplex, model, u, obj, nvars, x, interior_point);\n\t\t} else if (options->cut_perturbation_random) {\n\t\t\tperturb_bdd_cut_random(env, cplex, model, u, obj, nvars, x, interior_point);\n\t\t}\n\n\t\tvector coeffs(nvars);\n\t\tdouble rhs;\n\n\t\t// Retrieve left-hand side coefficients: u\n\t\tfor (int i = 0; i < nvars; ++i) {\n\t\t\tif (cplex.isExtracted(u[i])) {\n\t\t\t\tcoeffs[i] = cplex.getValue(u[i]);\n\t\t\t} else {\n\t\t\t\t// If u[i] not extracted, this means it was not added to model: objective is zero and not added to constraints\n\t\t\t\t// Could be a bug, but it also may be the valid scenario of the variable being fixed to zero in the DD\n\t\t\t\tcoeffs[i] = 0;\n\t\t\t}\n\t\t}\n\n\t\t// Retrieve right-hand side: 1 + u^T interior\n\t\trhs = 1;\n\t\tfor (int i = 0; i < nvars; ++i) {\n\t\t\trhs += coeffs[i] * interior_point[i];\n\t\t}\n\n\t\t// Inequality u^T x <= 1 + u^T interior\n\t\tfacet = new Inequality();\n\t\tfacet->coeffs = coeffs;\n\t\tfacet->rhs = rhs;\n\n\t\t// cout << \"Relaxation facet generated (normalized), BDD order: \";\n\t\t// for( int i = 0; i < nvars; ++i ) {\n\t\t// cout << facet->coeffs[i] / facet->rhs << \" \";\n\t\t// }\n\t\t// cout << \"<= 1\" << endl;\n\t\t// cout << \"Relaxation facet generated, BDD order: \";\n\t\t// for( int i = 0; i < nvars; ++i ) {\n\t\t// cout << facet->coeffs[i] << \" \";\n\t\t// }\n\t\t// cout << \"<= \" << facet->rhs << endl;\n\n\t\tdouble lhs = 0;\n\t\tfor (int i = 0; i < nvars; ++i) {\n\t\t\tlhs += facet->coeffs[i] * x[i];\n\t\t\t// cout << \"coeff = \" << facet->coeffs[i] << \", x = \" << x[i] << endl;\n\t\t}\n\t\tcout << \"LHS = \" << lhs << \" / Violation: \" << lhs - facet->rhs << endl;\n\n\t\tcout << \"Distance = \" << get_distance_hyperplane_point(facet, x) << endl;\n\n\t\t// // Debugging info: Assert complementary slackness\n\t\t// int n_tight = 0;\n\t\t// int n_nzdual = 0;\n\t\t// for (int i = 0; i < nvars; ++i) {\n\t\t// \tint size = bdd->layers[i].size();\n\t\t// \t// cout << \"u[\" << i << \"] = \" << cplex.getValue(u[i]) << endl;\n\t\t// \tfor (int j = 0; j < size; ++j) {\n\t\t// \t\tNode* zero_node = bdd->layers[i][j]->zero_arc;\n\t\t// \t\tNode* one_node = bdd->layers[i][j]->one_arc;\n\t\t// \t\tif (zero_node != NULL) {\n\t\t// \t\t\tcout << \"Dual (\" << i << \",\" << j << \") -0-> (\" << zero_node->layer << \",\" << zero_node->id << \"): \" << cplex.getDual(zero_arc_constrs[i][j]);\n\t\t// \t\t\tcout << \" / slack: \" << cplex.getValue(v[zero_node->layer][zero_node->id]) - cplex.getValue(v[i][j]) << endl;\n\t\t// \t\t\tassert(DBL_EQ(cplex.getDual(zero_arc_constrs[i][j]), 0) || DBL_EQ(cplex.getValue(v[zero_node->layer][zero_node->id]), cplex.getValue(v[i][j])));\n\t\t// \t\t\tif (DBL_EQ(cplex.getValue(v[zero_node->layer][zero_node->id]), cplex.getValue(v[i][j])))\n\t\t// \t\t\t\tn_tight++;\n\t\t// \t\t\tif (!DBL_EQ(cplex.getDual(zero_arc_constrs[i][j]), 0))\n\t\t// \t\t\t\tn_nzdual++;\n\t\t// \t\t}\n\t\t// \t\tif (one_node != NULL) {\n\t\t// \t\t\tcout << \"Dual (\" << i << \",\" << j << \") -1-> (\" << one_node->layer << \",\" << one_node->id << \"): \" << cplex.getDual(one_arc_constrs[i][j]);\n\t\t// \t\t\tcout << \" / slack: \" << cplex.getValue(v[one_node->layer][one_node->id]) - (cplex.getValue(v[i][j]) - cplex.getValue(u[i])) << endl;\n\t\t// \t\t\tassert(DBL_EQ(cplex.getDual(one_arc_constrs[i][j]), 0) || DBL_EQ(cplex.getValue(v[one_node->layer][one_node->id]), cplex.getValue(v[i][j]) - cplex.getValue(u[i])));\n\t\t// \t\t\tif (DBL_EQ(cplex.getValue(v[one_node->layer][one_node->id]), cplex.getValue(v[i][j]) - cplex.getValue(u[i])))\n\t\t// \t\t\t\tn_tight++;\n\t\t// \t\t\tif (!DBL_EQ(cplex.getDual(one_arc_constrs[i][j]), 0))\n\t\t// \t\t\t\tn_nzdual++;\n\t\t// \t\t}\n\t\t// \t\t// cout << \"v[\" << i << \"][\" << j << \"] = \" << cplex.getValue(v[i][j]) << endl;\n\t\t// \t}\n\t\t// }\n\t\t// // cout << \"Tight arcs = \" << n_tight << \" / Nonzero duals = \" << n_nzdual << endl;\n\n\t\t// Store additional information in cut_info\n\t\tif (cut_info != NULL) {\n\t\t\tint bdd_size = bdd->layers.size();\n\t\t\tcut_info->zero_arc_flow.clear();\n\t\t\tcut_info->zero_arc_flow.resize(bdd_size);\n\t\t\tcut_info->one_arc_flow.clear();\n\t\t\tcut_info->one_arc_flow.resize(bdd_size);\n\t\t\tfor (int layer = 0; layer < bdd_size; ++layer) {\n\t\t\t\tint size = bdd->layers[layer].size();\n\t\t\t\tfor (int k = 0; k < size; ++k) {\n\t\t\t\t\tNode* node = bdd->layers[layer][k];\n\t\t\t\t\tdouble zero_flow = 0;\n\t\t\t\t\tif (node->zero_arc != NULL) {\n\t\t\t\t\t\tzero_flow = cplex.getDual(zero_arc_constrs[layer][k]);\n\t\t\t\t\t}\n\t\t\t\t\tdouble one_flow = 0;\n\t\t\t\t\tif (node->one_arc != NULL) {\n\t\t\t\t\t\tone_flow = cplex.getDual(one_arc_constrs[layer][k]);\n\t\t\t\t\t}\n\t\t\t\t\tcut_info->zero_arc_flow[layer].push_back(zero_flow);\n\t\t\t\t\tcut_info->one_arc_flow[layer].push_back(one_flow);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// // Uncomment for debugging purposes\n\t\t\t// print_all_paths_in_flow(bdd, cut_info->zero_arc_flow, cut_info->one_arc_flow);\n\t\t}\n\n\t\tobj.end();\n\t\tzero_arc_constrs.end();\n\t\tone_arc_constrs.end();\n\t\tenv.end();\n\n\t} catch (IloException& ex) {\n\t\tcout << \"error: \" << ex << endl;\n\t\texit(1);\n\t}\n\n\treturn facet;\n}\n\n\nvoid perturb_bdd_cut_iterative(IloEnv env, IloCplex cplex, IloModel model, const IloNumVarArray u, IloObjective obj, int nvars,\n\tconst vector& x, const vector& interior_point)\n{\n\t// cplex.setOut(env.getNullStream()); // Suppress output\n\tcout << \"Before perturbation: \";\n\tfor (int i = 0; i < nvars; ++i) {\n\t\tcout << cplex.getValue(u[i]) << \" \";\n\t}\n\tcout << endl;\n\n\tIloExpr obj_expr(env);\n\tfor (int i = 0; i < nvars; ++i) {\n\t\tobj_expr += u[i] * (x[i] - interior_point[i]);\n\t}\n\tdouble bound = cplex.getObjValue();\n\t// model.add( obj_expr == bound );\n\tmodel.add(obj_expr <= bound + 1e-5);\n\tmodel.add(obj_expr >= bound - 1e-5);\n\tobj_expr.end();\n\n\tfor (int k = 0; k < nvars; ++k) {\n\t\tfor (int i = 0; i < nvars; ++i) {\n\t\t\tobj.setLinearCoef(u[i], 0);\n\t\t}\n\t\tobj.setLinearCoef(u[k], 1);\n\t\tcplex.solve();\n\t\tif (k != nvars - 1) {\n\t\t\tcout << \"u[\" << k << \"] = \" << cplex.getObjValue() << endl;\n\t\t\tif (DBL_EQ(cplex.getObjValue(), 0)) {\n\t\t\t\tu[k].setBounds(0, 0);\n\t\t\t} else {\n\t\t\t\t// u[k].setBounds(cplex.getObjValue(), cplex.getObjValue());\n\t\t\t\tu[k].setBounds(cplex.getObjValue() - 1e-5, cplex.getObjValue() + 1e-5);\n\t\t\t}\n\t\t}\n\t}\n\n\tcout << \"After perturbation: \";\n\tfor (int i = 0; i < nvars; ++i) {\n\t\tcout << cplex.getValue(u[i]) << \" \";\n\t}\n\tcout << endl;\n}\n\n\nvoid perturb_bdd_cut_random(IloEnv env, IloCplex cplex, IloModel model, const IloNumVarArray u, IloObjective obj, int nvars,\n\tconst vector& x, const vector& interior_point)\n{\n\t// Perturb the objective slightly\n\tcout << \"Before perturbation: \";\n\tfor (int i = 0; i < nvars; ++i) {\n\t\tcout << cplex.getValue(u[i]) << \" \";\n\t}\n\tcout << endl;\n\n\tIloExpr obj_expr(env);\n\tfor (int i = 0; i < nvars; ++i) {\n\t\tobj_expr += u[i] * (x[i] - interior_point[i]);\n\t}\n\tdouble bound = cplex.getObjValue();\n\tmodel.add(obj_expr == bound);\n\t// model.add( obj_expr <= bound + 1e-5 );\n\t// model.add( obj_expr >= bound - 1e-5 );\n\tobj_expr.end();\n\n\tfor (int i = 0; i < nvars; ++i) {\n\t\tdouble pert = ((double) rand() / (double) RAND_MAX - 0.5) * 2 * 1e-4;\n\t\tdouble new_coeff = x[i] - interior_point[i] + pert;\n\t\tif (new_coeff < 0) {\n\t\t\tnew_coeff = x[i] - interior_point[i] - pert;\n\t\t}\n\t\tobj.setLinearCoef(u[i], new_coeff);\n\t}\n\n\tcplex.solve();\n\n\tcout << \"After perturbation: \";\n\tfor (int i = 0; i < nvars; ++i) {\n\t\tcout << cplex.getValue(u[i]) << \" \";\n\t}\n\tcout << endl;\n}\n", "meta": {"hexsha": "05af53a0db2691b4250fdeb59fb21d427cdfb26b", "size": 11695, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ddopt/src/cut/cut_cplex.cpp", "max_stars_repo_name": "ctjandra/ddopt-cut", "max_stars_repo_head_hexsha": "0ca4358e7c27a8a56fb2640d450356dcda91b7f0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2018-02-15T03:54:35.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-24T03:06:05.000Z", "max_issues_repo_path": "ddopt/src/cut/cut_cplex.cpp", "max_issues_repo_name": "ctjandra/ddopt-cut", "max_issues_repo_head_hexsha": "0ca4358e7c27a8a56fb2640d450356dcda91b7f0", "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": "ddopt/src/cut/cut_cplex.cpp", "max_forks_repo_name": "ctjandra/ddopt-cut", "max_forks_repo_head_hexsha": "0ca4358e7c27a8a56fb2640d450356dcda91b7f0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-07T02:29:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-05T13:21:13.000Z", "avg_line_length": 33.6063218391, "max_line_length": 173, "alphanum_fraction": 0.5819581018, "num_tokens": 3965, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7606506526772884, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.44793890167311246}} {"text": "#ifndef EXPSUM_REDUCTION_CONEIG_SYM_RRD_HPP\n#define EXPSUM_REDUCTION_CONEIG_SYM_RRD_HPP\n\n#include \n\n#include \n\n#include \"arma/lapack_extra.hpp\"\n\nnamespace expsum\n{\n\n//\n// Compute accurate con-eigenvalue decomposition of the matrix $A=XD^{2}X^{H}$\n//\n// This class computes the con-eigenvalue decomposition\n//\n// ``` math\n// A U = \\Lambda \\overline{U},\n// ```\n//\n// of a real symmetric (or complex Hermitian) and positive-definite matrix $A$\n// having a rank-revealing decomposition of the form, $A = X D^{2} X^{H}$.\n//\n// @X A matrix of type `T` of dimension $m \\times n$.\n// On entry, the rank-revealing factor $X$.\n// On exit, orthonormal con-eigenvectors of the matrix $A$.\n// @d A vector of real values with size $n$.\n// On entry, the diagonal elements of rank-revealing factor $D$. The\n// diagonal of $D$ must be all positive and decreasing.\n// On exit, con-eigenvalues of the matrix $A$.\n// @threshold threshold value for con-eigenvalues.\n//\n\ntemplate \nclass coneig_sym_rrd\n{\npublic:\n // Scalar types\n using size_type = arma::uword;\n using value_type = T;\n using real_type = typename arma::get_pod_type::result;\n using complex_type = std::complex;\n\n // Matrix/Vector types\n using vector_type = arma::Col;\n using matrix_type = arma::Mat;\n using index_vector_type = arma::uvec;\n using real_vector_type = arma::Col;\n using real_matrix_type = arma::Mat;\n using complex_vector_type = arma::Col;\n using complex_matrix_type = arma::Mat;\n\n static size_type run(matrix_type& X, real_vector_type& d,\n real_type threshold, value_type* work,\n real_type* rwork);\n\nprivate:\n //\n // Compute QR factorization of matrix G = Q * R.\n //\n static void qr_factorization(matrix_type& G, value_type* work)\n {\n auto n = static_cast(G.n_rows);\n auto lwork = n * n;\n value_type* tau = work + n * n;\n arma::blas_int info;\n arma::lapack::geqrf(&n, &n, G.memptr(), &n, tau, work, &lwork, &info);\n if (info)\n {\n std::ostringstream msg;\n msg << \"(coneig_sym_rrd) xGEQRF failed with info \" << info;\n throw std::runtime_error(msg.str());\n }\n }\n //\n // Solve R * Y = X, where R is upper triangular matrix.\n //\n static void tri_solve(matrix_type& R, matrix_type& X)\n {\n char uplo = 'U';\n char trans = 'N';\n char diag = 'N';\n auto m = static_cast(R.n_rows);\n auto nrhs = static_cast(X.n_cols);\n arma::blas_int info;\n arma::lapack::trtrs(&uplo, &trans, &diag, &m, &nrhs, R.memptr(), &m,\n X.memptr(), &m, &info);\n if (info)\n {\n std::ostringstream msg;\n msg << \"(coneig_sym_rrd) xTRTRS failed with info \" << info;\n throw std::runtime_error(msg.str());\n }\n }\n //\n // Compute singular values and corresponding left singular vectors of upper\n // triangular matrix R using one-sided Jacobi method.\n //\n // --- for real matrix\n static void jacobi_svd(matrix_type& R, real_vector_type& sigma,\n real_type* work, real_type* /*dummy*/)\n {\n assert(R.n_rows == R.n_cols);\n assert(sigma.n_elem == R.n_cols);\n\n char joba = 'U'; // Input matrix R is upper triangular matrix\n char jobu = 'U'; // Compute left singular vectors\n char jobv = 'N'; // Do not compute right singular vectors\n auto n = static_cast(R.n_cols);\n auto mv = arma::blas_int();\n auto ldv = arma::blas_int(2);\n\n real_type dummy_v[2];\n auto lwork = 2 * n;\n\n arma::blas_int info;\n\n arma::lapack::gesvj(&joba, &jobu, &jobv, &n, &n, R.memptr(), &n,\n sigma.memptr(), &mv, &dummy_v[0], &ldv, work,\n &lwork, &info);\n\n if (info < arma::blas_int())\n {\n std::ostringstream msg;\n msg << \"[s/d]GESVJ error: \" << -info\n << \" th argument had an illegal value\";\n throw std::logic_error(msg.str());\n }\n\n if (info > arma::blas_int())\n {\n std::ostringstream msg;\n msg << \"[s/d]GESVJ did not converge in the maximal allowed number \"\n << info << \" of sweeps\";\n throw std::runtime_error(msg.str());\n }\n }\n // --- for complex matrix\n static void jacobi_svd(matrix_type& R, real_vector_type& sigma,\n complex_type* work, real_type* rwork)\n {\n assert(R.n_rows == R.n_cols);\n assert(sigma.n_elem == R.n_cols);\n\n char joba = 'U'; // Input matrix R is upper triangular matrix\n char jobu = 'U'; // Compute left singular vectors\n char jobv = 'N'; // Do not compute right singular vectors\n auto n = static_cast(R.n_cols);\n auto mv = arma::blas_int();\n auto ldv = arma::blas_int(2);\n\n complex_type dummy_v[2];\n auto lwork = 2 * n;\n auto lrwork = std::max(arma::blas_int(6), 2 * n);\n\n arma::blas_int info;\n\n arma::lapack::gesvj(&joba, &jobu, &jobv, &n, &n, R.memptr(), &n,\n sigma.memptr(), &mv, &dummy_v[0], &ldv, work,\n &lwork, rwork, &lrwork, &info);\n\n if (info < arma::blas_int())\n {\n std::ostringstream msg;\n msg << \"[c/z]GESVJ error: \" << -info\n << \" th argument had an illegal value\";\n throw std::logic_error(msg.str());\n }\n\n if (info > arma::blas_int())\n {\n std::ostringstream msg;\n msg << \"[c/z]GESVJ did not converge in the maximal allowed number \"\n << info << \" of sweeps\";\n throw std::runtime_error(msg.str());\n }\n }\n};\n\n//\n// Required memory for workspace\n//\n// work size:\n// for matrix G : n * n\n// for matrix Y : n * n\n// for workspace: 2 * n\n// ------------------------------\n// Total : 2 * n * (n + 1)\n//\n// rwork size:\n// if `T` is real type : n\n// if `T` is complex type: 3 * n\n//\ntemplate \ntypename coneig_sym_rrd::size_type\nconeig_sym_rrd::run(matrix_type& X, real_vector_type& d, real_type threshold,\n value_type* work, real_type* rwork)\n{\n // const size_type m = X.n_rows;\n const size_type n = X.n_cols;\n\n value_type* ptr1 = work;\n value_type* ptr2 = work + n * n;\n value_type* ptr3 = work + 2 * n * n;\n\n real_vector_type dinv(rwork, n, false, true);\n dinv = real_type(1) / d;\n\n //\n // Form G = D * (X.st() * X) * D\n //\n matrix_type G(ptr1, n, n, false, true);\n G = X.st() * X;\n for (size_type j = 0; j < n; ++j)\n {\n for (size_type i = 0; i < n; ++i)\n {\n G(i, j) *= d(i) * d(j);\n }\n }\n //\n // Compute G = Q * R by Householder QR factorization\n //\n qr_factorization(G, ptr2);\n matrix_type& R = G; // R = trimatu(G), on exit\n //\n // Compute SVD of R = U * S * V.t() using one-sided Jacobi method.\n // We need singular values and left singular vectors here.\n //\n real_vector_type& sigma = d;\n matrix_type U(ptr2, n, n, false, true);\n U = arma::trimatu(R); // make a copy of matrix R\n jacobi_svd(U, sigma, ptr3, rwork + n);\n\n //-------------------------------------------------------------------------\n // Truncation: discard con-eigenvalues if negligibly small\n //-------------------------------------------------------------------------\n auto sum_d = real_type();\n size_type nvec = n;\n while (nvec)\n {\n sum_d += d(nvec - 1);\n if (2 * sum_d > threshold)\n {\n break;\n }\n --nvec;\n }\n\n if (nvec == size_type(0))\n {\n return size_type();\n }\n\n //-------------------------------------------------------------------------\n //\n // The eigenvectors of A * conj(A) are given as\n //\n // conj(X') = X * D * V * S^{-1/2}.\n //\n // However, direct evaluation of eigenvectors with this formula might be\n // inaccurate since D is ill-conditioned. The following formula are used\n // instead.\n //\n // conj(X') = X * D * R^(-1) * U * S^{1/2}\n // = X * (D.inv() * R * D.inv())^(-1) * (D.inv() * U * S^{1/2})\n // = X * R1.inv() * X1\n //\n //-------------------------------------------------------------------------\n //\n // Compute X1 = D^(-1) * U * S^{1/2} [in-place]\n //\n matrix_type U_trunc(ptr2, n, nvec, false, true);\n for (size_type j = 0; j < nvec; ++j)\n {\n const auto sj = std::sqrt(sigma(j));\n for (size_type i = 0; i < n; ++i)\n {\n U_trunc(i, j) *= sj * dinv(i);\n }\n }\n //\n // Compute R1 = D^(-1) * R * D^(-1) [in-place]\n //\n for (size_type j = 0; j < n; ++j)\n {\n for (size_type i = 0; i <= j; ++i)\n {\n R(i, j) *= dinv(i) * dinv(j);\n }\n }\n //\n // Solve R1 * Y1 = X1 in-place\n //\n tri_solve(R, U_trunc);\n //\n // Compute con-eigenvectors U = conj(X) * conj(Y).\n //\n X.head_cols(nvec) = arma::conj(X) * arma::conj(U_trunc);\n //\n // Adjust phase factor of each con-eigenvectors, so that U^{T} * U = I\n //\n if (arma::is_complex::value)\n {\n for (size_type j = 0; j < nvec; ++j)\n {\n auto xj = X.col(j);\n const auto t = arma::dot(xj, xj);\n const auto phase = t / std::abs(t);\n const auto scale = std::sqrt(arma::access::alt_conj(phase));\n xj *= scale;\n }\n }\n\n return nvec;\n}\n\n} // namespace: expsum\n\n#endif /* EXPSUM_REDUCTION_CONEIG_SYM_RRD_HPP */\n", "meta": {"hexsha": "7332b875204403778d19a6e63a63398efb990651", "size": 10005, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/expsum/reduction/coneig_sym_rrd.hpp", "max_stars_repo_name": "hide-ikeno/expsum", "max_stars_repo_head_hexsha": "7b1be33b7c342f875d6d5e5c0cd8df9ec62abbda", "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/expsum/reduction/coneig_sym_rrd.hpp", "max_issues_repo_name": "hide-ikeno/expsum", "max_issues_repo_head_hexsha": "7b1be33b7c342f875d6d5e5c0cd8df9ec62abbda", "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/expsum/reduction/coneig_sym_rrd.hpp", "max_forks_repo_name": "hide-ikeno/expsum", "max_forks_repo_head_hexsha": "7b1be33b7c342f875d6d5e5c0cd8df9ec62abbda", "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.0714285714, "max_line_length": 80, "alphanum_fraction": 0.5106446777, "num_tokens": 2762, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7606506526772883, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.44793890167311234}} {"text": "/*\nCopyright 2013-2015 Rogier van Dalen.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n#ifndef MATH_MAX_SEMIRING_HPP_INCLUDED\n#define MATH_MAX_SEMIRING_HPP_INCLUDED\n\n#include \n#include \n#include \n\n#include \n\n#include \n\n#include \"magma.hpp\"\n\n#include \"detail/is_close.hpp\"\n\nnamespace math {\n\n/**\nSemiring whose \\ref plus (and \\ref choose) operation picks the maximum of the\ntwo values.\n\\ref times performs multiplication on the underlying value.\n\nThe underlying value must always be non-negative, so that the additive identity\nhas value 0.\nThe multiplicative identity has value 1.\n\nDivision is only implemented for non-integer types.\n\nThis type supports Boost.Hash, if \\c boost/functional/hash.hpp is included.\n\n\\tparam Type\n Underlying type that represents the value.\n*/\ntemplate class max_semiring;\n\ntemplate struct max_semiring_tag;\n\ntemplate struct decayed_magma_tag >\n{ typedef max_semiring_tag type; };\n\ntemplate class max_semiring {\nprivate:\n Type value_;\npublic:\n /**\n Initialise with 0.\n */\n max_semiring() : value_()\n { assert (value_ >= Type (0)); }\n\n /**\n Initialise with \\a value as the value.\n */\n explicit max_semiring (Type const & value) : value_ (value) {}\n\n /**\n Return the underlying value.\n */\n Type const & value() const { return value_; }\n};\n\nnamespace detail {\n\n template struct is_max_semiring_tag : boost::mpl::false_ {};\n template struct is_max_semiring_tag >\n : boost::mpl::true_ {};\n\n} // namespace detail\n\nMATH_MAGMA_GENERATE_OPERATORS (detail::is_max_semiring_tag)\n\nnamespace operation {\n\n /* Queries. */\n\n template \n struct is_member , typename std::enable_if <\n std::numeric_limits ::has_quiet_NaN>::type>\n {\n // Detect NaN.\n bool operator() (max_semiring const & v) const { return v == v; }\n };\n\n template struct equal > {\n bool operator() (\n max_semiring const & left, max_semiring const & right)\n const\n { return left.value() == right.value(); }\n };\n\n template struct approximately_equal ,\n typename std::enable_if ::is_exact>::type>\n {\n bool operator() (\n max_semiring const & left, max_semiring const & right)\n const\n {\n static Type const tolerance = 1e-5;\n return math::detail::is_close (left.value(), right.value(),\n tolerance);\n }\n };\n\n // compare always orders smaller values first.\n template struct compare > {\n bool operator() (\n max_semiring const & left, max_semiring const & right)\n const\n { return left.value() < right.value(); }\n };\n\n // \"choose\" and \"plus\" both select the maximal element.\n template \n struct order , callable::choose>\n : reverse_order >> {};\n\n template \n struct order , callable::plus>\n : reverse_order >> {};\n\n /* Produce. */\n\n // Return the not-a-number value, not-a-number, if it is available.\n template struct non_member , typename\n std::enable_if ::has_quiet_NaN>::type>\n {\n max_semiring operator() () const {\n return max_semiring (\n std::numeric_limits ::quiet_NaN());\n }\n };\n\n template \n struct identity , callable::times>\n {\n max_semiring operator() () const\n { return max_semiring (1); }\n };\n\n template \n struct identity , callable::choose>\n {\n max_semiring operator() () const\n { return max_semiring (0); }\n };\n\n // Additive identity: same as \"choose\".\n template \n struct identity , callable::plus>\n : identity , callable::choose> {};\n\n // Multiplicative annihilator: forward to additive identity.\n template \n struct annihilator , callable::times>\n : identity , callable::plus> {};\n\n /* Operations. */\n\n // \"choose\" and \"plus\" are implemented automatically, since \"order\" is\n // implemented for them.\n\n template struct times >\n : associative, commutative, approximate_if <\n boost::mpl::bool_ ::is_exact>>\n {\n max_semiring operator() (max_semiring const & left,\n max_semiring const & right) const\n { return max_semiring (left.value() * right.value()); }\n };\n\n // Semiring in both directions.\n template struct is_semiring <\n max_semiring_tag , either, callable::times, callable::choose>\n : rime::true_type {};\n\n template struct is_semiring <\n max_semiring_tag , either, callable::times, callable::plus>\n : rime::true_type {};\n\n // Division is only implemented for non-integer types.\n template struct divide , either,\n typename std::enable_if ::is_integer>::type>\n : approximate_if ::is_exact>>\n {\n max_semiring operator() (max_semiring const & left,\n max_semiring const & right) const\n { return max_semiring (left.value() / right.value()); }\n };\n\n // Inversion is only implemented for non-integer types.\n template \n struct invert , either, callable::times,\n typename std::enable_if ::is_integer>::type>\n {\n max_semiring operator() (max_semiring const & c) const\n { return max_semiring (1 / c.value()); }\n };\n\n template struct print > {\n template \n void operator() (Stream & stream, max_semiring const & c)\n const\n { stream << c.value(); }\n };\n\n} // namespace operation\n\ntemplate \n inline std::size_t hash_value (max_semiring const & m)\n{ return boost::hash () (m.value()); }\n\n} // namespace math\n\n#endif // MATH_MAX_SEMIRING_HPP_INCLUDED\n", "meta": {"hexsha": "127b3c6c3bfd0a5ba5d6b2d90ab957581b06a2cf", "size": 7385, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/math/max_semiring.hpp", "max_stars_repo_name": "rogiervd/math", "max_stars_repo_head_hexsha": "96174afac1a2933d71cb7ae3962437f860fc10ec", "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/math/max_semiring.hpp", "max_issues_repo_name": "rogiervd/math", "max_issues_repo_head_hexsha": "96174afac1a2933d71cb7ae3962437f860fc10ec", "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/math/max_semiring.hpp", "max_forks_repo_name": "rogiervd/math", "max_forks_repo_head_hexsha": "96174afac1a2933d71cb7ae3962437f860fc10ec", "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": 31.9696969697, "max_line_length": 80, "alphanum_fraction": 0.6578199052, "num_tokens": 1771, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7606506526772883, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.44793890167311234}} {"text": "#include \n#include \n#include \n#include \n\n#include \"data.hpp\"\n#include \"../helper.hpp\"\n\n#include \"g2o/core/sparse_optimizer.h\"\n#include \"g2o/core/block_solver.h\"\n#include \"g2o/core/solver.h\"\n#include \"g2o/core/optimization_algorithm_levenberg.h\"\n#include \"g2o/core/base_vertex.h\"\n#include \"g2o/core/base_unary_edge.h\"\n#include \"g2o/solvers/csparse/linear_solver_csparse.h\"\n\nusing namespace std;\n\ntypedef g2o::BlockSolver< g2o::BlockSolverTraits<1, 1> > ScaleBlockSolver;\ntypedef g2o::LinearSolverCSparse ScaleLinearSolver;\n\nclass VertexScale : public g2o::BaseVertex<1, double>\n{\n public:\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW;\n VertexScale()\n {\n }\n\n virtual bool read(std::istream& /*is*/)\n {\n cerr << __PRETTY_FUNCTION__ << \" not implemented yet\" << endl;\n return false;\n }\n\n virtual bool write(std::ostream& /*os*/) const\n {\n cerr << __PRETTY_FUNCTION__ << \" not implemented yet\" << endl;\n return false;\n }\n\n virtual void setToOriginImpl()\n {\n cerr << __PRETTY_FUNCTION__ << \" not implemented yet\" << endl;\n }\n\n virtual void oplusImpl(const double* update)\n {\n // cout<<_estimate<<\" + \"<<*update<\n{\n public:\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n EdgeScaleDirect(const Eigen::Vector3d& point3d, const Eigen::Matrix3d& K, double tx, const cv::Mat& _img1)\n : img1(_img1)\n {\n Eigen::Vector3d KX = K * point3d;\n\n u_base = KX(0)/KX(2);\n v = KX(1)/KX(2);\n u_inc = tx*K(0,0)/point3d(2);\n au_as << u_inc, 0;\n }\n\n virtual bool read(std::istream& /*is*/)\n {\n cerr << __PRETTY_FUNCTION__ << \" not implemented yet\" << endl;\n return false;\n }\n virtual bool write(std::ostream& /*os*/) const\n {\n cerr << __PRETTY_FUNCTION__ << \" not implemented yet\" << endl;\n return false;\n }\n\n void computeError();\n void linearizeOplus();\n\n private:\n\n double u_base;\n double v;\n double u_inc;\n Eigen::Matrix au_as;\n const cv::Mat& img1;\n};\n", "meta": {"hexsha": "4cec10e1996aaeb031ea3aaec6ca5c543ef8968d", "size": 2209, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/stereo_processor/g2o_edges/scale_edge.hpp", "max_stars_repo_name": "jiawei-mo/dsvo", "max_stars_repo_head_hexsha": "a6d6f3a5377b472550fd3f48308adc701ed5c679", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 19.0, "max_stars_repo_stars_event_min_datetime": "2018-09-22T16:00:44.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T15:14:04.000Z", "max_issues_repo_path": "include/stereo_processor/g2o_edges/scale_edge.hpp", "max_issues_repo_name": "TianQi-777/dsvo", "max_issues_repo_head_hexsha": "60f4153bc970718b7ebb4be66fa1ebb0f1372a38", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2018-12-22T02:12:15.000Z", "max_issues_repo_issues_event_max_datetime": "2018-12-28T18:57:12.000Z", "max_forks_repo_path": "include/stereo_processor/g2o_edges/scale_edge.hpp", "max_forks_repo_name": "jiawei-mo/dsvo", "max_forks_repo_head_hexsha": "a6d6f3a5377b472550fd3f48308adc701ed5c679", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2019-01-02T02:05:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-01-16T08:00:28.000Z", "avg_line_length": 24.2747252747, "max_line_length": 110, "alphanum_fraction": 0.6482571299, "num_tokens": 622, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7606506526772883, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.44793890167311234}} {"text": "/*\nCopyright 2009-2021 Nicolas Colombe\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n*/\n\n#pragma once\n\n#include \"math.hpp\"\n#include \"vector2.hpp\"\n\n#include \n\nnamespace eXl\n{\n template \n class AABB2D\n {\n public:\n inline AABB2D(){}\n inline AABB2D(Real iMinX, Real iMinY, Real iMaxX, Real iMaxY)\n {\n m_Data[0] = Vector2(iMinX,iMinY);\n m_Data[1] = Vector2(iMaxX,iMaxY);\n }\n\n static inline AABB2D FromCenterAndSize(Vector2 iCenter,Vector2 iSize)\n {\n AABB2D ret;\n ret.m_Data[0] = iCenter - iSize / 2.0;\n ret.m_Data[1] = iCenter + iSize / 2.0;\n return ret;\n }\n\n inline AABB2D(Vector2 iMin,Vector2 iSize)\n {\n m_Data[0] = iMin;\n m_Data[1] = iMin + iSize;\n }\n\n template \n explicit inline AABB2D(AABB2D const& iOther)\n {\n m_Data[0] = Vector2(iOther.m_Data[0]);\n m_Data[1] = Vector2(iOther.m_Data[1]);\n }\n\n inline bool Empty() const\n {\n return m_Data[0].X() == m_Data[1].X() || m_Data[0].Y() == m_Data[1].Y();\n }\n\n bool CircleTest(Vector2f const& iPos, Real iRadius)\n {\n if(Contains(iPos))\n {\n return true;\n }\n else\n {\n //Test segment X == X0\n Real dist = m_Data[0].X() - iPos.X(); //(x0-xc)\n dist = (iRadius + dist)*(iRadius - dist); //R^2 - (x0-xc)^2\n if(dist > 0)\n {\n Real y = Math::Sqrt(dist) + iPos.Y();\n if(Math::ZERO_TOLERANCE < m_Data[1].Y() - y && y - m_Data[0].Y() > Math::ZERO_TOLERANCE)\n return true;\n }\n //Test segment X == X1\n dist = m_Data[1].X() - iPos.X(); //(x0-xc)\n dist = (iRadius + dist)*(iRadius - dist); //R^2 - (x0-xc)^2\n if(dist > 0)\n {\n Real y = Math::Sqrt(dist) + iPos.Y();\n if(Math::ZERO_TOLERANCE < m_Data[1].Y() - y && y - m_Data[0].Y() > Math::ZERO_TOLERANCE)\n return true;\n }\n\n //TestSegment Y == Y0\n dist = m_Data[0].Y() - iPos.Y(); //(x0-xc)\n dist = (iRadius + dist)*(iRadius - dist); //R^2 - (x0-xc)^2\n if(dist > 0)\n {\n Real x = Math::Sqrt(dist) + iPos.X();\n if(Math::ZERO_TOLERANCE < m_Data[1].X() - x && x - m_Data[0].X() > Math::ZERO_TOLERANCE)\n return true;\n }\n //Test segment Y == Y1\n dist = m_Data[1].Y() - iPos.Y(); //(x0-xc)\n dist = (iRadius + dist)*(iRadius - dist); //R^2 - (x0-xc)^2\n if(dist > 0)\n {\n Real x = Math::Sqrt(dist) + iPos.X();\n if(Math::ZERO_TOLERANCE < m_Data[1].X() - x && x - m_Data[0].X() > Math::ZERO_TOLERANCE)\n return true;\n }\n }\n return false;\n }\n\n inline void Rotate(Real iAngle)\n {\n Vector2 center = GetCenter();\n Vector2 size = GetSize();\n Vector2 points[4];\n points[0] = size * -0.5;\n points[1] = Vector2(size.X() * -0.5, size.Y() * 0.5) ;\n points[2] = Vector2(size.X() * 0.5, size.Y() * -0.5) ;\n points[3] = size * 0.5;\n points[0] = Vector2(points[0].X() * Math::Cos(iAngle) + points[0].Y() * Math::Sin(iAngle)\n , points[0].Y() * Math::Cos(iAngle) - points[0].X() * Math::Sin(iAngle));\n points[1] = Vector2(points[1].X() * Math::Cos(iAngle) + points[1].Y() * Math::Sin(iAngle)\n , points[1].Y() * Math::Cos(iAngle) - points[1].X() * Math::Sin(iAngle));\n points[2] = Vector2(points[2].X() * Math::Cos(iAngle) + points[2].Y() * Math::Sin(iAngle)\n , points[2].Y() * Math::Cos(iAngle) - points[2].X() * Math::Sin(iAngle));\n points[3] = Vector2(points[3].X() * Math::Cos(iAngle) + points[3].Y() * Math::Sin(iAngle)\n , points[3].Y() * Math::Cos(iAngle) - points[3].X() * Math::Sin(iAngle));\n\n m_Data[0] = m_Data[1] = points[0];\n for (unsigned int i = 1; i < 4; ++i)\n {\n m_Data[0].X() = Math::Min(m_Data[0].X(), points[i].X());\n m_Data[0].Y() = Math::Min(m_Data[0].Y(), points[i].Y());\n m_Data[1].X() = Math::Max(m_Data[1].X(), points[i].X());\n m_Data[1].Y() = Math::Max(m_Data[1].Y(), points[i].Y());\n }\n m_Data[0] += center;\n m_Data[1] += center;\n }\n\n inline Vector2 GetCenter()const\n {\n return (m_Data[0] + m_Data[1])/2;\n }\n\n inline Vector2 GetSize()const\n {\n return m_Data[1] - m_Data[0];\n }\n\n inline void Inflate(Real iCoeff)\n {\n Vector2 center = (m_Data[1] + m_Data[0]) / 2;\n Vector2 size = m_Data[1] - m_Data[0];\n size = size * iCoeff;\n m_Data[0] = center - size / 2.0;\n m_Data[1] = center + size / 2.0;\n }\n\n inline Real MinX()const{return m_Data[0].X();}\n inline Real MinY()const{return m_Data[0].Y();}\n inline Real MaxX()const{return m_Data[1].X();}\n inline Real MaxY()const{return m_Data[1].Y();}\n \n inline Real& MinX(){return m_Data[0].X();}\n inline Real& MinY(){return m_Data[0].Y();}\n inline Real& MaxX(){return m_Data[1].X();}\n inline Real& MaxY(){return m_Data[1].Y();}\n\n inline bool operator ==(AABB2D const& iOther) const\n {\n return m_Data[0]==iOther.m_Data[0] && m_Data[1] == iOther.m_Data[1];\n }\n\n inline bool operator !=(AABB2D const& iOther) const\n {\n return !((*this) == iOther);\n }\n\n\t inline bool Empty()\n\t {\n\t\t return m_Data[0].X() == m_Data[1].X() || m_Data[0].Y() == m_Data[1].Y();\n\t }\n\n inline void SetCommonBox(AABB2D const& iBox1,AABB2D const& iBox2)\n {\n m_Data[0].X() = Math::Max(iBox1.m_Data[0].X(),iBox2.m_Data[0].X());\n m_Data[0].Y() = Math::Max(iBox1.m_Data[0].Y(),iBox2.m_Data[0].Y());\n m_Data[1].X() = Math::Max(Math::Min(iBox1.m_Data[1].X(),iBox2.m_Data[1].X()),m_Data[0].X());\n m_Data[1].Y() = Math::Max(Math::Min(iBox1.m_Data[1].Y(),iBox2.m_Data[1].Y()),m_Data[0].Y());\n }\n\n inline void Absorb(Vector2 const& iPoint)\n {\n m_Data[0].X() = Math::Min(m_Data[0].X(), iPoint.X());\n m_Data[0].Y() = Math::Min(m_Data[0].Y(), iPoint.Y());\n m_Data[1].X() = Math::Max(m_Data[1].X(), iPoint.X());\n m_Data[1].Y() = Math::Max(m_Data[1].Y(), iPoint.Y());\n }\n\n inline void Absorb(AABB2D const& iBox)\n {\n m_Data[0].X() = Math::Min(m_Data[0].X(),iBox.m_Data[0].X());\n m_Data[0].Y() = Math::Min(m_Data[0].Y(),iBox.m_Data[0].Y());\n m_Data[1].X() = Math::Max(m_Data[1].X(),iBox.m_Data[1].X());\n m_Data[1].Y() = Math::Max(m_Data[1].Y(),iBox.m_Data[1].Y());\n }\n\n inline bool IsInside(AABB2D const& iOther, Real iEpsilon = Math::ZERO_TOLERANCE) const\n {\n return (m_Data[0].X() - iOther.m_Data[0].X() >= iEpsilon && m_Data[0].Y() - iOther.m_Data[0].Y() >= iEpsilon\n && iOther.m_Data[1].X() - m_Data[1].X() >= iEpsilon && iOther.m_Data[1].Y() - m_Data[1].Y() >= iEpsilon );\n }\n\n inline bool Intersect(AABB2D const& iOther, Real iEpsilon = Math::ZERO_TOLERANCE) const\n {\n return iOther.m_Data[1].X() - m_Data[0].X() >= iEpsilon && m_Data[1].X() - iOther.m_Data[0].X() >= iEpsilon\n && iOther.m_Data[1].Y() - m_Data[0].Y() >= iEpsilon && m_Data[1].Y() - iOther.m_Data[0].Y() >= iEpsilon;\n }\n\n //0 No, 1 Left, 2 Right, 3 Down, 4 Up\n inline int Touch(AABB2D const& iOther, Real iEpsilon = Math::ZERO_TOLERANCE) const\n {\n if(iOther.m_Data[1].Y() - m_Data[0].Y() >= iEpsilon && m_Data[1].Y() - iOther.m_Data[0].Y() >= iEpsilon)\n {\n Real val = m_Data[0].X() - iOther.m_Data[1].X();\n if(val <= iEpsilon && val >= -iEpsilon)\n return 1;\n \n val = m_Data[1].X() - iOther.m_Data[0].X();\n if(val <= iEpsilon && val >= -iEpsilon)\n return 2;\n }\n if(iOther.m_Data[1].X() - m_Data[0].X() >= iEpsilon && m_Data[1].X() - iOther.m_Data[0].X() >= iEpsilon)\n {\n Real val = m_Data[0].Y() - iOther.m_Data[1].Y();\n \n if(val <= iEpsilon && val >= -iEpsilon)\n return 3;\n\n val = m_Data[1].Y() - iOther.m_Data[0].Y();\n if(val <= iEpsilon && val >= -iEpsilon)\n return 4;\n }\n return 0;\n }\n\n boost::optional> SegmentTest(Vector2 const& iOrigin, Vector2 const& iDir, Real iEpsilon = Math::ZERO_TOLERANCE)\n {\n Real const scaleX = 1.0 / iDir.X();\n Real const scaleY = 1.0 / iDir.Y();\n Real const signX = Math::Sign(scaleX);\n Real const signY = Math::Sign(scaleY);\n\n Real const nearTimeX = ((signX > 0 ? m_Data[0].X() : m_Data[1].X()) - iOrigin.X()) * scaleX;\n Real const nearTimeY = ((signY > 0 ? m_Data[0].Y() : m_Data[1].Y()) - iOrigin.Y()) * scaleY;\n Real const farTimeX = ((signX > 0 ? m_Data[1].X() : m_Data[0].X()) - iOrigin.X()) * scaleX;\n Real const farTimeY = ((signY > 0 ? m_Data[1].Y() : m_Data[0].Y()) - iOrigin.Y()) * scaleY;\n\n if (nearTimeX > farTimeY || nearTimeY > farTimeX) \n {\n return boost::none;\n }\n\n Real const nearTime = nearTimeX > nearTimeY ? nearTimeX : nearTimeY;\n Real const farTime = farTimeX < farTimeY ? farTimeX : farTimeY;\n\n if (nearTime > 1 - iEpsilon || farTime < -iEpsilon) \n {\n return boost::none;\n }\n\n return iOrigin + iDir * nearTime;\n }\n\n inline bool Contains(Vector2const& iPoint, Real iEpsilon = Math::ZERO_TOLERANCE) const\n {\n return iPoint.X() - m_Data[0].X() >= iEpsilon && m_Data[1].X() - iPoint.X() >= iEpsilon\n && iPoint.Y() - m_Data[0].Y() >= iEpsilon && m_Data[1].Y() - iPoint.Y() >= iEpsilon;\n }\n\n // Neg value -> distance to min, Pos value -> distance to max, 0, inside\n Vector2f Classify(Vector2const& iPoint, Real iEpsilon = Math::ZERO_TOLERANCE) const\n {\n Vector2f res(iPoint.X() - m_Data[0].X(), iPoint.Y() - m_Data[0].Y());\n for(uint32_t axis = 0; axis < 2; ++axis)\n {\n if(!(res.m_Data[axis] < -iEpsilon))\n {\n res.m_Data[axis] = m_Data[1].m_Data[axis] - iPoint.m_Data[axis];\n if(res.m_Data[axis] < -iEpsilon)\n {\n res.m_Data[axis] *= -1;\n }\n else\n {\n res.m_Data[axis] = 0;\n }\n }\n }\n\n return res;\n }\n\n inline Vector2 GetDistX(AABB2D const& iOther) const\n {\n return Vector2(iOther.m_Data[0].X() - m_Data[0].X(),m_Data[1].X() - iOther.m_Data[1].X());\n }\n\n inline Vector2 GetDistY(AABB2D const& iOther) const\n {\n return Vector2(iOther.m_Data[0].Y() - m_Data[0].Y(),m_Data[1].Y() - iOther.m_Data[1].Y());\n }\n\n Vector2 m_Data[2];\n };\n\n typedef AABB2D AABB2Di; \n typedef AABB2D AABB2Df;\n typedef AABB2D AABB2Dd;\n}", "meta": {"hexsha": "89ca1f8220f4ea8ff90d526c673ac8b7de0bd901", "size": 12076, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/math/aabb2d.hpp", "max_stars_repo_name": "eXl-Nic/eXl", "max_stars_repo_head_hexsha": "a5a0f77f47db3179365c107a184bb38b80280279", "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/math/aabb2d.hpp", "max_issues_repo_name": "eXl-Nic/eXl", "max_issues_repo_head_hexsha": "a5a0f77f47db3179365c107a184bb38b80280279", "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/math/aabb2d.hpp", "max_forks_repo_name": "eXl-Nic/eXl", "max_forks_repo_head_hexsha": "a5a0f77f47db3179365c107a184bb38b80280279", "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.2151898734, "max_line_length": 460, "alphanum_fraction": 0.5607817158, "num_tokens": 3918, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461390043208003, "lm_q2_score": 0.6001883592602049, "lm_q1q2_score": 0.44782394478334403}} {"text": "#ifndef SKYLARK_GEMV_HPP\n#define SKYLARK_GEMV_HPP\n\n#include \n#include \"exception.hpp\"\n\n// Defines a generic Gemv function that recieves a wider set of matrices\n\nnamespace skylark { namespace base {\n\ntemplate\ninline void Gemv(elem::Orientation oA,\n T alpha, const elem::Matrix& A, const elem::Matrix& x,\n T beta, elem::Matrix& y) {\n elem::Gemv(oA, alpha, A, x, beta, y);\n}\n\ntemplate\ninline void Gemv(elem::Orientation oA,\n T alpha, const elem::Matrix& A, const elem::Matrix& x,\n elem::Matrix& y) {\n elem::Gemv(oA, alpha, A, x, y);\n}\n\ntemplate\ninline void Gemv(elem::Orientation oA,\n T alpha, const elem::DistMatrix& A, const elem::DistMatrix& x,\n T beta, elem::DistMatrix& y) {\n elem::Gemv(oA, alpha, A, x, beta, y);\n}\n\ntemplate\ninline void Gemv(elem::Orientation oA,\n T alpha, const elem::DistMatrix& A, const elem::DistMatrix& x,\n elem::DistMatrix& y) {\n elem::Gemv(oA, alpha, A, x, y);\n}\n\n/**\n * The following combinations is not offered by Elemental, but is useful for us.\n * We implement it partially.\n */\n\ntemplate\ninline void Gemv(elem::Orientation oA,\n T alpha, const elem::DistMatrix& A,\n const elem::DistMatrix& x,\n T beta, elem::DistMatrix& y) {\n // TODO verify sizes etc.\n // TODO verify matching grids.\n\n if (oA == elem::TRANSPOSE) {\n boost::mpi::communicator comm(y.Grid().Comm(), boost::mpi::comm_attach);\n elem::Matrix ylocal(y.Matrix());\n elem::Gemv(elem::TRANSPOSE,\n alpha, A.LockedMatrix(), x.LockedMatrix(),\n beta / T(comm.size()), ylocal);\n boost::mpi::all_reduce(comm,\n ylocal.Buffer(), ylocal.MemorySize(), y.Buffer(),\n std::plus());\n } else {\n SKYLARK_THROW_EXCEPTION(base::unsupported_base_operation());\n }\n}\n\ntemplate\ninline void Gemv(elem::Orientation oA,\n T alpha, const elem::DistMatrix& A,\n const elem::DistMatrix& x,\n elem::DistMatrix& y) {\n\n int y_height = (oA == elem::NORMAL ? A.Height() : A.Width());\n elem::Zeros(y, y_height, 1);\n base::Gemv(oA, alpha, A, x, T(0), y);\n}\n\ntemplate\ninline void Gemv(elem::Orientation oA,\n T alpha, const elem::DistMatrix& A,\n const elem::DistMatrix& x,\n T beta, elem::DistMatrix& y) {\n // TODO verify sizes etc.\n\n if (oA == elem::NORMAL) {\n elem::Gemv(elem::NORMAL,\n alpha, A.LockedMatrix(), x.LockedMatrix(),\n beta, y.Matrix());\n } else {\n SKYLARK_THROW_EXCEPTION(base::unsupported_base_operation());\n }\n}\n\ntemplate\ninline void Gemv(elem::Orientation oA,\n T alpha, const elem::DistMatrix& A,\n const elem::DistMatrix& x,\n elem::DistMatrix& y) {\n\n int y_height = (oA == elem::NORMAL ? A.Height() : A.Width());\n elem::Zeros(y, y_height, 1);\n base::Gemv(oA, alpha, A, x, T(0), y);\n}\n\ntemplate\ninline void Gemv(elem::Orientation oA,\n T alpha, const sparse_matrix_t& A, const elem::Matrix& x,\n T beta, elem::Matrix& y) {\n // TODO verify sizes etc.\n\n const int* indptr = A.indptr();\n const int* indices = A.indices();\n const double *values = A.locked_values();\n double *yd = y.Buffer();\n const double *xd = x.LockedBuffer();\n\n int n = A.width();\n\n if (oA == elem::NORMAL) {\n elem::Scal(beta, y);\n\n# if SKYLARK_HAVE_OPENMP\n# pragma omp parallel for\n# endif\n for(int col = 0; col < n; col++) {\n T xv = alpha * xd[col];\n for (int j = indptr[col]; j < indptr[col + 1]; j++) {\n int row = indices[j];\n T val = values[j];\n yd[row] += val * xv;\n }\n }\n\n } else {\n\n# if SKYLARK_HAVE_OPENMP\n# pragma omp parallel for\n# endif\n for(int col = 0; col < n; col++) {\n double yv = beta * yd[col];\n for (int j = indptr[col]; j < indptr[col + 1]; j++) {\n int row = indices[j];\n T val = values[j];\n yv += alpha * val * xd[row];\n }\n yd[col] = yv;\n }\n\n }\n}\n\n} } // namespace skylark::base\n\n\n#endif // SKYLARK_GEMV_HPP\n", "meta": {"hexsha": "e8c3a0f3867fcac594ed9024121edb0235f1e1e1", "size": 4584, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "base/Gemv.hpp", "max_stars_repo_name": "wangg12/libskylark", "max_stars_repo_head_hexsha": "e8836190be854d0284d38772c48e110b3c6d5e51", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2021-06-12T07:26:43.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-12T07:26:47.000Z", "max_issues_repo_path": "base/Gemv.hpp", "max_issues_repo_name": "cjiyer/libskylark", "max_issues_repo_head_hexsha": "e8836190be854d0284d38772c48e110b3c6d5e51", "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": "base/Gemv.hpp", "max_forks_repo_name": "cjiyer/libskylark", "max_forks_repo_head_hexsha": "e8836190be854d0284d38772c48e110b3c6d5e51", "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.5741935484, "max_line_length": 80, "alphanum_fraction": 0.577443281, "num_tokens": 1293, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461389930307512, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.44782393800718806}} {"text": "/* Siconos is a program dedicated to modeling, simulation and control\n * of non smooth dynamical systems.\n *\n * Copyright 2021 INRIA.\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 \n\n\n#include \"determinant.hpp\"\n#include \"SiconosVector.hpp\"\n#include \"SimpleMatrix.hpp\"\n#include \"BlockMatrixIterators.hpp\"\n#include \"BlockMatrix.hpp\"\n\n#include \"SiconosAlgebra.hpp\"\n#include \"SiconosException.hpp\"\n\nusing namespace Siconos;\n\n//=======================\n// get norm\n//=======================\n\ndouble SimpleMatrix::normInf() const\n{\n if(_num == DENSE)\n return norm_inf(*mat.Dense);\n else if(_num == TRIANGULAR)\n return norm_inf(*mat.Triang);\n else if(_num == SYMMETRIC)\n return norm_inf(*mat.Sym);\n else if(_num == SPARSE)\n return norm_inf(*mat.Sparse);\n else if(_num == SPARSE_COORDINATE)\n return norm_inf(*mat.SparseCoordinate);\n else if(_num == BANDED)\n return norm_inf(*mat.Banded);\n else if(_num == ZERO)\n return 0;\n else if(_num == IDENTITY)\n return 1;\n\n THROW_EXCEPTION(\"Matrix type not supported\");\n return std::numeric_limits::infinity();\n}\n\nvoid SimpleMatrix::normInfByColumn(SP::SiconosVector vIn) const\n{\n if(_num == DENSE)\n {\n if(vIn->size() != size(1))\n THROW_EXCEPTION(\"the given vector does not have the right length\");\n DenseVect tmpV = DenseVect(size(0));\n for(unsigned int i = 0; i < size(1); i++)\n {\n ublas::noalias(tmpV) = ublas::column(*mat.Dense, i);\n (*vIn)(i) = norm_inf(tmpV);\n }\n }\n else\n THROW_EXCEPTION(\"not implemented for data other than DenseMat\");\n}\n//=======================\n// determinant\n//=======================\n\ndouble SimpleMatrix::det() const\n{\n if(_num == DENSE)\n return determinant(*mat.Dense);\n else if(_num == TRIANGULAR)\n return determinant(*mat.Triang);\n else if(_num == SYMMETRIC)\n return determinant(*mat.Sym);\n else if(_num == SPARSE)\n return determinant(*mat.Sparse);\n else if(_num == SPARSE_COORDINATE)\n return determinant(*mat.Sparse);\n else if(_num == BANDED)\n return determinant(*mat.Banded);\n else if(_num == ZERO)\n return 0;\n else if(_num == IDENTITY)\n return 1;\n THROW_EXCEPTION(\"Matrix type not supported\");\n return std::numeric_limits::infinity();\n}\n\n\nvoid SimpleMatrix::trans()\n{\n switch(_num)\n {\n case DENSE:\n *mat.Dense = ublas::trans(*mat.Dense);\n break;\n case TRIANGULAR:\n THROW_EXCEPTION(\"failed, the matrix is triangular matrix and can not be transposed in place.\");\n break;\n case SYMMETRIC:\n break;\n case SPARSE:\n *mat.Sparse = ublas::trans(*mat.Sparse);\n break;\n case SPARSE_COORDINATE:\n *mat.Sparse = ublas::trans(*mat.Sparse);\n break;\n case BANDED:\n *mat.Banded = ublas::trans(*mat.Banded);\n break;\n case Siconos::ZERO:\n break;\n case Siconos::IDENTITY:\n break;\n default:\n THROW_EXCEPTION(\"Matrix type not supported\");\n }\n resetFactorizationFlags();\n}\n\nvoid SimpleMatrix::trans(const SiconosMatrix &m)\n{\n if(m.isBlock())\n THROW_EXCEPTION(\"not yet implemented for m being a BlockMatrix.\");\n\n\n if(&m == this)\n trans();\n else\n {\n Siconos::UBLAS_TYPE numM = m.num();\n switch(numM)\n {\n case DENSE:\n if(_num != DENSE)\n THROW_EXCEPTION(\"try to transpose a dense matrix into another type.\");\n noalias(*mat.Dense) = ublas::trans(*m.dense());\n break;\n case TRIANGULAR:\n if(_num != DENSE)\n THROW_EXCEPTION(\"try to transpose a triangular matrix into a non-dense one.\");\n noalias(*mat.Dense) = ublas::trans(*m.triang());\n break;\n case SYMMETRIC:\n *this = m;\n break;\n case SPARSE:\n if(_num == DENSE)\n noalias(*mat.Dense) = ublas::trans(*m.sparse());\n else if(_num == SPARSE)\n noalias(*mat.Sparse) = ublas::trans(*m.sparse());\n else if(_num == SPARSE_COORDINATE)\n noalias(*mat.SparseCoordinate) = ublas::trans(*m.sparse());\n else\n THROW_EXCEPTION(\"try to transpose a sparse matrix into a forbidden type (not dense nor sparse).\");\n break;\n case SPARSE_COORDINATE:\n if(_num == DENSE)\n noalias(*mat.Dense) = ublas::trans(*m.sparseCoordinate());\n else if(_num == SPARSE)\n noalias(*mat.Sparse) = ublas::trans(*m.sparseCoordinate());\n else if(_num == SPARSE_COORDINATE)\n noalias(*mat.SparseCoordinate) = ublas::trans(*m.sparseCoordinate());\n else\n THROW_EXCEPTION(\"try to transpose a sparse coordinate matrix into a forbidden type (not dense nor sparse coordinate).\");\n break;\n case BANDED:\n if(_num == DENSE)\n noalias(*mat.Dense) = ublas::trans(*m.banded());\n else if(_num == BANDED)\n noalias(*mat.Banded) = ublas::trans(*m.banded());\n else\n THROW_EXCEPTION(\"try to transpose a banded matrix into a forbidden type (not dense nor banded).\");\n break;\n case ZERO:\n *this = m;\n break;\n case IDENTITY:\n *this = m;\n break;\n default:\n THROW_EXCEPTION(\"\");\n }\n resetFactorizationFlags();\n }\n}\n\n\n\n\n\n\n\n\n\n/*\nThe following code inverts the matrix input using LU-decomposition with backsubstitution of unit vectors. Reference: Numerical Recipies in C, 2nd ed., by Press, Teukolsky, Vetterling & Flannery.\n\nyou can solve Ax=b using three lines of ublas code:\n\npermutation_matrix<> piv;\nlu_factorize(A, piv);\nlu_substitute(A, piv, x);\n\n*/\n#ifndef INVERT_MATRIX_HPP\n#define INVERT_MATRIX_HPP\n\n// REMEMBER to update \"lu.hpp\" header includes from boost-CVS\n#include \n#include \n#include \n#include \n#include \n#include \n\n/* Matrix inversion routine.\nUses lu_factorize and lu_substitute in uBLAS to invert a matrix */\ntemplate\nbool InvertMatrix(const ublas::matrix& input, ublas::matrix& inverse)\n{\n using namespace boost::numeric::ublas;\n typedef permutation_matrix pmatrix;\n// create a working copy of the input\n matrix A(input);\n// create a permutation matrix for the LU-factorization\n pmatrix pm(A.size1());\n\n// perform LU-factorization\n int res = lu_factorize(A,pm);\n if(res != 0) return false;\n\n// create identity matrix of \"inverse\"\n inverse.assign(ublas::identity_matrix(A.size1()));\n\n// backsubstitute to get the inverse\n lu_substitute(A, pm, inverse);\n\n return true;\n}\n\n#endif //INVERT_MATRIX_HPP\n\n// Note FP: never used. Comment before removal ?\n// void invertMatrix(const SimpleMatrix& input, SimpleMatrix& output)\n// {\n// InvertMatrix(*input.dense(), *output.dense());\n// }\n\n", "meta": {"hexsha": "cbd5d2761c3d7a5026dcbab01c4c0b56a27820ae", "size": 7210, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "kernel/src/utils/SiconosAlgebra/SimpleMatrixMisc.cpp", "max_stars_repo_name": "BuildJet/siconos", "max_stars_repo_head_hexsha": "5e9c95806f0a01d62ab564ffb1d9d50c2dc32ef0", "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": "kernel/src/utils/SiconosAlgebra/SimpleMatrixMisc.cpp", "max_issues_repo_name": "BuildJet/siconos", "max_issues_repo_head_hexsha": "5e9c95806f0a01d62ab564ffb1d9d50c2dc32ef0", "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": "kernel/src/utils/SiconosAlgebra/SimpleMatrixMisc.cpp", "max_forks_repo_name": "BuildJet/siconos", "max_forks_repo_head_hexsha": "5e9c95806f0a01d62ab564ffb1d9d50c2dc32ef0", "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": 27.3106060606, "max_line_length": 194, "alphanum_fraction": 0.6633841886, "num_tokens": 1899, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7279754607093178, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.4477688649960148}} {"text": "/*\n * Copyright Nick Thompson, 2017\n * Use, modification and distribution are subject to the\n * Boost Software License, Version 1.0. (See accompanying file\n * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n */\n\n#ifndef BOOST_MATH_INTERPOLATORS_BARYCENTRIC_RATIONAL_DETAIL_HPP\n#define BOOST_MATH_INTERPOLATORS_BARYCENTRIC_RATIONAL_DETAIL_HPP\n\n#include \n#include // for std::move\n#include // for std::is_sorted\n#include \n#include \n#include \n#include \n\nnamespace boost{ namespace math{ namespace detail{\n\ntemplate\nclass barycentric_rational_imp\n{\npublic:\n template \n barycentric_rational_imp(InputIterator1 start_x, InputIterator1 end_x, InputIterator2 start_y, size_t approximation_order = 3);\n\n barycentric_rational_imp(std::vector&& x, std::vector&& y, size_t approximation_order = 3);\n\n Real operator()(Real x) const;\n\n Real prime(Real x) const;\n\n // The barycentric weights are not really that interesting; except to the unit tests!\n Real weight(size_t i) const { return m_w[i]; }\n\n std::vector&& return_x()\n {\n return std::move(m_x);\n }\n\n std::vector&& return_y()\n {\n return std::move(m_y);\n }\n\nprivate:\n\n void calculate_weights(size_t approximation_order);\n\n std::vector m_x;\n std::vector m_y;\n std::vector m_w;\n};\n\ntemplate \ntemplate \nbarycentric_rational_imp::barycentric_rational_imp(InputIterator1 start_x, InputIterator1 end_x, InputIterator2 start_y, size_t approximation_order)\n{\n std::ptrdiff_t n = std::distance(start_x, end_x);\n\n if (approximation_order >= (std::size_t)n)\n {\n throw std::domain_error(\"Approximation order must be < data length.\");\n }\n\n // Big sad memcpy.\n m_x.resize(n);\n m_y.resize(n);\n for(unsigned i = 0; start_x != end_x; ++start_x, ++start_y, ++i)\n {\n // But if we're going to do a memcpy, we can do some error checking which is inexpensive relative to the copy:\n if(boost::math::isnan(*start_x))\n {\n std::string msg = std::string(\"x[\") + boost::lexical_cast(i) + \"] is a NAN\";\n throw std::domain_error(msg);\n }\n\n if(boost::math::isnan(*start_y))\n {\n std::string msg = std::string(\"y[\") + boost::lexical_cast(i) + \"] is a NAN\";\n throw std::domain_error(msg);\n }\n\n m_x[i] = *start_x;\n m_y[i] = *start_y;\n }\n calculate_weights(approximation_order);\n}\n\ntemplate \nbarycentric_rational_imp::barycentric_rational_imp(std::vector&& x, std::vector&& y,size_t approximation_order) : m_x(std::move(x)), m_y(std::move(y))\n{\n BOOST_ASSERT_MSG(m_x.size() == m_y.size(), \"There must be the same number of abscissas and ordinates.\");\n BOOST_ASSERT_MSG(approximation_order < m_x.size(), \"Approximation order must be < data length.\");\n BOOST_ASSERT_MSG(std::is_sorted(m_x.begin(), m_x.end()), \"The abscissas must be listed in increasing order x[0] < x[1] < ... < x[n-1].\");\n calculate_weights(approximation_order);\n}\n\ntemplate\nvoid barycentric_rational_imp::calculate_weights(size_t approximation_order)\n{\n using std::abs;\n int64_t n = m_x.size();\n m_w.resize(n, 0);\n for(int64_t k = 0; k < n; ++k)\n {\n int64_t i_min = (std::max)(k - (int64_t) approximation_order, (int64_t) 0);\n int64_t i_max = k;\n if (k >= n - (std::ptrdiff_t)approximation_order)\n {\n i_max = n - approximation_order - 1;\n }\n\n for(int64_t i = i_min; i <= i_max; ++i)\n {\n Real inv_product = 1;\n int64_t j_max = (std::min)(static_cast(i + approximation_order), static_cast(n - 1));\n for(int64_t j = i; j <= j_max; ++j)\n {\n if (j == k)\n {\n continue;\n }\n\n Real diff = m_x[k] - m_x[j];\n using std::numeric_limits;\n if (abs(diff) < (numeric_limits::min)())\n {\n std::string msg = std::string(\"Spacing between x[\")\n + boost::lexical_cast(k) + std::string(\"] and x[\")\n + boost::lexical_cast(i) + std::string(\"] is \")\n + boost::lexical_cast(diff) + std::string(\", which is smaller than the epsilon of \")\n + boost::core::demangle(typeid(Real).name());\n throw std::logic_error(msg);\n }\n inv_product *= diff;\n }\n if (i % 2 == 0)\n {\n m_w[k] += 1/inv_product;\n }\n else\n {\n m_w[k] -= 1/inv_product;\n }\n }\n }\n}\n\n\ntemplate\nReal barycentric_rational_imp::operator()(Real x) const\n{\n Real numerator = 0;\n Real denominator = 0;\n for(size_t i = 0; i < m_x.size(); ++i)\n {\n // Presumably we should see if the accuracy is improved by using ULP distance of say, 5 here, instead of testing for floating point equality.\n // However, it has been shown that if x approx x_i, but x != x_i, then inaccuracy in the numerator cancels the inaccuracy in the denominator,\n // and the result is fairly accurate. See: http://epubs.siam.org/doi/pdf/10.1137/S0036144502417715\n if (x == m_x[i])\n {\n return m_y[i];\n }\n Real t = m_w[i]/(x - m_x[i]);\n numerator += t*m_y[i];\n denominator += t;\n }\n return numerator/denominator;\n}\n\n/*\n * A formula for computing the derivative of the barycentric representation is given in\n * \"Some New Aspects of Rational Interpolation\", by Claus Schneider and Wilhelm Werner,\n * Mathematics of Computation, v47, number 175, 1986.\n * http://www.ams.org/journals/mcom/1986-47-175/S0025-5718-1986-0842136-8/S0025-5718-1986-0842136-8.pdf\n * and reviewed in\n * Recent developments in barycentric rational interpolation\n * Jean-Paul Berrut, Richard Baltensperger and Hans D. Mittelmann\n *\n * Is it possible to complete this in one pass through the data?\n */\n\ntemplate\nReal barycentric_rational_imp::prime(Real x) const\n{\n Real rx = this->operator()(x);\n Real numerator = 0;\n Real denominator = 0;\n for(size_t i = 0; i < m_x.size(); ++i)\n {\n if (x == m_x[i])\n {\n Real sum = 0;\n for (size_t j = 0; j < m_x.size(); ++j)\n {\n if (j == i)\n {\n continue;\n }\n sum += m_w[j]*(m_y[i] - m_y[j])/(m_x[i] - m_x[j]);\n }\n return -sum/m_w[i];\n }\n Real t = m_w[i]/(x - m_x[i]);\n Real diff = (rx - m_y[i])/(x-m_x[i]);\n numerator += t*diff;\n denominator += t;\n }\n\n return numerator/denominator;\n}\n}}}\n#endif\n", "meta": {"hexsha": "b4199ea266bd819d6fa717db123421ef3e0987a9", "size": 7187, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "ReactNativeFrontend/ios/Pods/boost/boost/math/interpolators/detail/barycentric_rational_detail.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": 597.0, "max_stars_repo_stars_event_min_datetime": "2018-07-17T10:59:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T07:59:36.000Z", "max_issues_repo_path": "ReactNativeFrontend/ios/Pods/boost/boost/math/interpolators/detail/barycentric_rational_detail.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": 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": "ReactNativeFrontend/ios/Pods/boost/boost/math/interpolators/detail/barycentric_rational_detail.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": 112.0, "max_forks_repo_forks_event_min_datetime": "2018-07-26T04:36:34.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T02:29:34.000Z", "avg_line_length": 33.2731481481, "max_line_length": 168, "alphanum_fraction": 0.5971893697, "num_tokens": 1897, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7279754371026368, "lm_q2_score": 0.6150878555160666, "lm_q1q2_score": 0.4477688504758321}} {"text": "#pragma once\n\n#include \"../../util/assert.hh\"\n#include \"../../util/meta.hh\"\n\n#include \n#include \n#include \n\nnamespace bold\n{\n template\n struct LineSegment : Eigen::Matrix\n {\n public:\n typedef Eigen::Matrix Base;\n typedef Eigen::Matrix PointType;\n\n template\n LineSegment(Eigen::MatrixBase const& other)\n : Base(other)\n {}\n\n LineSegment(PointType const& p1,\n PointType const& p2)\n {\n static_assert(std::is_arithmetic::value, \"Must be an arithmetic type\");\n\n this->col(0) = p1;\n this->col(1) = p2;\n\n ASSERT((p2 - p1).cwiseAbs().maxCoeff() != 0);\n }\n\n template\n LineSegment& operator=(Eigen::MatrixBase const& other)\n {\n this->Base::operator=(other);\n return *this;\n }\n\n PointType p1() const { return this->col(0); }\n PointType p2() const { return this->col(1); }\n\n /** Returns the vector formed by p2() - p1() */\n PointType delta() const { return p2() - p1(); }\n\n /** Returns the vector formed by (p2() + p1()) / 2.0 */\n PointType mid() const { return (p2() + p1()) / 2.0; }\n\n T length() const { return delta().norm(); }\n\n double normalisedDot(LineSegment other) const\n {\n return delta().normalized().dot( other.delta().normalized() );\n }\n\n /** Calculate the smallest angle between the two line segments.\n *\n * The output will be between 0 and PI/2, inclusive.\n */\n double smallestAngleBetween(LineSegment other)\n {\n auto a = fabs(acos(normalisedDot(other)));\n if (a >= M_PI/2)\n a = M_PI - a;\n return a;\n }\n\n template\n LineSegment to() const\n {\n auto newLineSegment = LineSegment{LineSegment::Zero()};\n newLineSegment.col(0).template head< meta::min::value >() =\n this->col(0).template head< meta::min::value >();\n newLineSegment.col(1).template head< meta::min::value >() =\n this->col(1).template head< meta::min::value >();\n return newLineSegment;\n }\n\n bool operator==(LineSegment const& other) const\n {\n const double epsilon = 0.0000004;\n return (this->array() - other.array()).abs().sum() < epsilon;\n }\n\n LineSegment operator+(PointType const& delta) const\n {\n return LineSegment{this->colwise() + delta};\n }\n\n LineSegment operator-(PointType const& delta) const\n {\n return LineSegment{this->colwise() - delta};\n }\n\n friend std::ostream& operator<<(std::ostream& stream, LineSegment const& lineSegment)\n {\n return stream << \"LineSegment (P1=\" << lineSegment.p1().transpose() << \" P2=\" << lineSegment.p2().transpose() << \")\";\n }\n\n };\n\n typedef LineSegment LineSegment3d;\n typedef LineSegment LineSegment3i;\n}\n", "meta": {"hexsha": "7d71fdc44f87a4970dfd8eff1d0cd7cde4c9e1e0", "size": 3036, "ext": "hh", "lang": "C++", "max_stars_repo_path": "geometry/LineSegment/linesegment.hh", "max_stars_repo_name": "drewnoakes/bold-humanoid", "max_stars_repo_head_hexsha": "6025fcc92cdf3ce9486d4fe5af4f30ee7a7a3335", "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": "geometry/LineSegment/linesegment.hh", "max_issues_repo_name": "drewnoakes/bold-humanoid", "max_issues_repo_head_hexsha": "6025fcc92cdf3ce9486d4fe5af4f30ee7a7a3335", "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": "geometry/LineSegment/linesegment.hh", "max_forks_repo_name": "drewnoakes/bold-humanoid", "max_forks_repo_head_hexsha": "6025fcc92cdf3ce9486d4fe5af4f30ee7a7a3335", "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.3738317757, "max_line_length": 123, "alphanum_fraction": 0.6123188406, "num_tokens": 820, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7279754371026368, "lm_q2_score": 0.6150878555160666, "lm_q1q2_score": 0.4477688504758321}} {"text": "/*\n * ---------------------------------------------------------------------\n * Copyright (C) 2012, 2014 Tino Kluge (ttk448 at gmail.com)\n *\n * This program is free software; you can redistribute it and/or\n * modify it under the terms of the GNU General Public License\n * as published by the Free Software Foundation; either version 2\n * of the License, or (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program. If not, see .\n * ---------------------------------------------------------------------\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \"dvs_reconstruction/poisson_solver/laplace.h\"\n\n#ifdef TIME_REPORT\n#include \n#include \nnamespace pde\n{\n\ndouble stoptime(void)\n{\n struct timeval t;\n gettimeofday(&t,NULL);\n return (double) t.tv_sec + t.tv_usec/1000000.0;\n}\n}\n#endif // TIME_REPORT\n\n\nnamespace\n{\n\n// convenience function: square\ninline double sqr(double x)\n{\n return x*x;\n}\n\n} // namespace\n\n\n// 2d-array utility functions\n// --------------------------\nnamespace arr\n{\n\n// helper function: [0,1] uniform random generator\ndouble runif()\n{\n return (double) rand()/(RAND_MAX+1.0);\n}\n// fill vector with random values\nvoid runif(std::vector& X)\n{\n size_t n=X.size();\n for(size_t i=0; i& X)\n{\n size_t n1=X.shape()[0];\n size_t n2=X.shape()[1];\n for(size_t i=0; i& X)\n{\n size_t n1=X.shape()[0];\n size_t n2=X.shape()[1];\n for(size_t i=0; i& X,\n const std::vector& Y,\n bool allow_shift)\n{\n\n assert(X.size()==Y.size());\n size_t n=X.size();\n\n double c=0.0;\n if(allow_shift) {\n c=X[1]-Y[1];\n }\n double sum=0.0;\n for(size_t i=0; i& X, double c)\n{\n size_t n=X.size();\n double sum=0.0;\n for(size_t i=0; i& X,\n const boost::multi_array& Y,\n bool allow_shift, bool ignore_corner)\n{\n\n size_t n1=X.shape()[0];\n size_t n2=X.shape()[1];\n\n assert(Y.shape()[0]==n1 && n1>1);\n assert(Y.shape()[1]==n2 && n2>1);\n\n double c=0.0;\n if(allow_shift) {\n c=X[1][1]-Y[1][1];\n }\n double sum=0.0;\n for(size_t i=0; i& bd1a, std::vector& bd1b,\n std::vector& bd2a, std::vector& bd2b,\n double value, size_t n1, size_t n2)\n{\n\n bd1a.resize(n2);\n bd1b.resize(n2);\n bd2a.resize(n1);\n bd2b.resize(n1);\n for(size_t i=0; i& bd1a, std::vector& bd1b,\n std::vector& bd2a, std::vector& bd2b,\n const boost::multi_array& X,\n double h1, double h2, types::boundary boundary)\n{\n size_t n1=X.shape()[0];\n size_t n2=X.shape()[1];\n assert(n1>2 && n2>2);\n\n // allocating memory for boundary vectors\n bd1a.resize(n2-2);\n bd1b.resize(n2-2);\n bd2a.resize(n1-2);\n bd2b.resize(n1-2);\n\n // reading boundary values\n if(boundary==types::Dirichlet) {\n for(size_t i=1; i& X, double h1, double h2,\n const std::vector& bd1a, const std::vector& bd1b,\n const std::vector& bd2a, const std::vector& bd2b,\n types::boundary boundary, bool add)\n{\n\n size_t n1=X.shape()[0];\n size_t n2=X.shape()[1];\n assert(n1>0 && n2>0);\n\n if(add==true) {\n // add boundary --> grow array\n X.resize(boost::extents[n1+2][n2+2]); // element preserving resize\n n1=X.shape()[0];\n n2=X.shape()[1];\n // shifting numbers inside the array to make space for boundary\n for(int i=n1-3; i>=0; i--) {\n for(int j=n2-3; j>=0; j--) {\n X[i+1][j+1]=X[i][j];\n }\n }\n }\n\n // check the boundary vectors are of the correct size\n assert( bd1a.size()==bd1b.size() && bd1a.size()==n2-2 );\n assert( bd2a.size()==bd2b.size() && bd2a.size()==n1-2 );\n\n // setting boundary values\n if(boundary==types::Dirichlet) {\n for(int i=0; i<(int)n2; i++) {\n // include corner cases, which are otherwise undetermined\n int idx = std::min(std::max(i-1,0),(int)n2-3);\n X[0][i] = bd1a[idx];\n X[n1-1][i] = bd1b[idx];\n }\n for(size_t i=1; i& X, double h1, double h2,\n double bdvalue, types::boundary bdcond, bool add)\n{\n size_t n1=X.shape()[0];\n size_t n2=X.shape()[1];\n // set the correct size of the boundary vectors\n size_t m1,m2;\n if(add==true) {\n m1=n1;\n m2=n2;\n } else {\n assert(n1>=2 && n2>=2);\n m1=n1-2;\n m2=n2-2;\n }\n // fill boundary vectors\n std::vector bd1a,bd1b,bd2a,bd2b;\n set_boundary_to_uniform(bd1a,bd1b,bd2a,bd2b,bdvalue,m1,m2);\n\n // call the general routine\n set_boundary(X,h1,h2,bd1a,bd1b,bd2a,bd2b,bdcond,add);\n}\n\n\n\n\n\n// PDE functions to solve the discrete Poisson's Equation\n// ------------------------------------------------------\n\n// discrete Gradient operator on a uniform grid\n// given u(x,y), it returns DX = a_1 du/dx, DY = a_2 du/dy,\n// using one-sided finite differences\n// U[i][j] = u(x_i, y_j), i=0...n-1\n// DX[i][j] = a1*(U[i+1][j]-U[i][j])/h, i=0...n-2\nvoid grad(boost::multi_array& DX, boost::multi_array& DY,\n const boost::multi_array& U,\n double a1, double a2, double h1, double h2)\n{\n assert(U.shape()[0]>1 && U.shape()[1]>1);\n size_t n1=U.shape()[0]-1;\n size_t n2=U.shape()[1]-1;\n DX.resize(boost::extents[n1][n2]);\n DY.resize(boost::extents[n1][n2]);\n for(size_t i=0; i& DX, boost::multi_array& DY,\n const boost::multi_array& U,\n double a1, double a2, double h1, double h2,\n const std::vector& bd1a, const std::vector& bd1b,\n const std::vector& bd2a, const std::vector& bd2b,\n types::boundary boundary)\n{\n // this is lazy and very memory inefficient\n // TODO: replace with a direct calculation\n boost::multi_array V=U;\n pde::set_boundary(V,h1,h2,bd1a,bd1b,bd2a,bd2b,boundary,true);\n grad(DX,DY,V,a1,a2,h1,h2);\n}\n// simplified version where only one boundary value can be specified\nvoid grad(boost::multi_array& DX, boost::multi_array& DY,\n const boost::multi_array& U,\n double a1, double a2, double h1, double h2,\n double bdvalue, types::boundary bdcond)\n{\n size_t n1=U.shape()[0];\n size_t n2=U.shape()[1];\n\n // fill boundary vectors\n std::vector bd1a,bd1b,bd2a,bd2b;\n set_boundary_to_uniform(bd1a,bd1b,bd2a,bd2b,bdvalue,n1,n2);\n\n // call the general routine\n grad(DX,DY,U,a1,a2,h1,h2,bd1a,bd1b,bd2a,bd2b,bdcond);\n}\n\n// discrete Divergence operator on a uniform grid\n// given u(x,y), v(x,y), it returns f = a_1 du/dx + a_2 dv/dx,\n// using one-sided finite differences\nvoid div(boost::multi_array& F,\n const boost::multi_array& U,\n const boost::multi_array& V,\n double a1, double a2, double h1, double h2)\n{\n assert(U.shape()[0]==V.shape()[0]);\n assert(U.shape()[1]==V.shape()[1]);\n assert(U.shape()[0]>1 && U.shape()[1]>1);\n size_t n1=U.shape()[0]-1;\n size_t n2=V.shape()[1]-1;\n F.resize(boost::extents[n1][n2]);\n for(size_t i=0; i& F,\n const boost::multi_array& U,\n double a1, double a2, double h1, double h2)\n{\n assert(U.shape()[0]>2 && U.shape()[1]>2);\n size_t n1=U.shape()[0]-2;\n size_t n2=U.shape()[1]-2;\n F.resize(boost::extents[n1][n2]);\n for(size_t i=0; i& F,\n const boost::multi_array& U,\n double a1, double a2, double h1, double h2,\n const std::vector& bd1a, const std::vector& bd1b,\n const std::vector& bd2a, const std::vector& bd2b,\n types::boundary boundary)\n{\n size_t n1=U.shape()[0];\n size_t n2=U.shape()[1];\n assert(n1>0 && n2>0);\n assert(bd1a.size()==bd1b.size() && bd1a.size()==n2);\n assert(bd2a.size()==bd2b.size() && bd2a.size()==n1);\n\n F.resize(boost::extents[n1][n2]);\n for(int i=0; i<(int)n1; i++) {\n for(int j=0; j<(int)n2; j++) {\n double Um1, U0, Up1; // U[i-1], U[i], U[i+1]\n\n // first dimension\n Um1 = U[std::max(i-1,0)][j];\n U0 = U[i][j];\n Up1 = U[std::min(i+1,(int)n1-1)][j];\n if(i==0) {\n if(boundary==types::Dirichlet) {\n Um1 = bd1a[j];\n } else if(boundary==types::Neumann) {\n Um1 = U[1][j] + 2.0*h1*bd1a[j];\n }\n } else if(i==(int)n1-1) {\n if(boundary==types::Dirichlet) {\n Up1 = bd1b[j];\n } else if(boundary==types::Neumann) {\n Up1 = U[n1-2][j] + 2.0*h1*bd1b[j];\n }\n }\n F[i][j] = a1 * (Um1 - 2.0*U0 + Up1) / (h1*h1);\n\n // second dimension\n Um1 = U[i][std::max(j-1,0)];\n Up1 = U[i][std::min(j+1,(int)n2-1)];\n if(j==0) {\n if(boundary==types::Dirichlet) {\n Um1 = bd2a[i];\n } else if(boundary==types::Neumann) {\n Um1 = U[i][1] + 2.0*h2*bd2a[i];\n }\n } else if(j==(int)n2-1) {\n if(boundary==types::Dirichlet) {\n Up1 = bd2b[i];\n } else if(boundary==types::Neumann) {\n Up1 = U[i][n2-2] + 2.0*h2*bd2b[i];\n }\n }\n F[i][j] += a2 * (Um1 - 2.0*U0 + Up1) / (h2*h2);\n }\n }\n}\n// simplified version where only one boundary value can be specified\nvoid laplace(boost::multi_array& F,\n const boost::multi_array& U,\n double a1, double a2, double h1, double h2,\n double bdvalue, types::boundary bdcond)\n{\n\n size_t n1=U.shape()[0];\n size_t n2=U.shape()[1];\n assert(n1>0 && n2>0);\n\n // fill boundary vectors\n std::vector bd1a,bd1b,bd2a,bd2b;\n set_boundary_to_uniform(bd1a,bd1b,bd2a,bd2b,bdvalue,n1,n2);\n\n // call the general routine\n laplace(F,U,a1,a2,h1,h2,bd1a,bd1b,bd2a,bd2b,bdcond);\n}\n\n// Neumann boundary condition with a general right hand side F will not\n// have a solution, however by looking at F we can say what the minimum\n// L2-norm error will be for 0-Neumann boundary conditions:\n// return = min ||Laplace U - F||\n// min is taken over all U consistent with 0-Neumann condition\ndouble neumann_error(const boost::multi_array& F)\n{\n size_t n1=F.shape()[0];\n size_t n2=F.shape()[1];\n assert(n1>1 && n2>1);\n\n // assuming 0 boundary conditions, otherwise would have to adjust\n // right hand side F as in poisolve()\n\n // calculate min L2 error ||Laplace U - F|| = |\\hat F[0]| * ||EV[0]||\n // where \\hat F, are the coordinates of F in EV-space,\n // and can simply be calculated as follows\n double sum=0.0;\n double fac=1.0;\n for(size_t i=0; i norm=sqrt(n)\n double l2_error=F00*norm_ev;\n return l2_error;\n}\n\n// given a right hand side F, we can find a constant Neumann-boundary\n// value which will have a solution U, so that Laplace U = F,\n// returns the boundary value\ndouble neumann_compat(const boost::multi_array& F,\n double a1, double a2, double h1, double h2)\n{\n size_t n1=F.shape()[0];\n size_t n2=F.shape()[1];\n\n double l2_error=neumann_error(F);\n double norm_ev=sqrt((double)(n1*n2)); // EV[0]=(1,...,1) --> norm=sqrt(n)\n double F00 = l2_error/norm_ev; // \\hat F [0][0] (EV space)\n\n // with non-zero Neumann boundary condition, rhs F is modified,\n // as in poisolve(), so we can calculate the exact boundary\n // value to make the l2_error zero\n double bd = F00 / (2.0*a1/(h1*(n1-1)) + 2.0*a2/(h2*(n2-1)));\n\n return bd;\n}\n\n\n\n\n// solves the 2D Poisson equation: a1 u_xx + a2 u_yy = f\n//\n// discretised with uniform grid, x_{i+1} = x_i + h1, y_{i+1} = y_i + h2\n// input: rhs F[i][j] = f(x_i, y_j)\n// output: solution U[i][j] = u(x_i, y_j), ie only inner points by default\n//\n//\n//\n// boundary condition:\n// - lower and upper boundary in dimension 1: bd1a, bd1b\n// - lower and upper boundary in dimension 2: bd2a, bd2b\n// - e.g. bd1a[i] refers to U[-1][i]\ndouble poisolve( boost::multi_array& U,\n const boost::multi_array& F,\n double a1, double a2, double h1, double h2,\n const std::vector& bd1a, const std::vector& bd1b,\n const std::vector& bd2a, const std::vector& bd2b,\n types::boundary boundary, bool add_boundary_to_solution)\n{\n\n#ifdef TIME_REPORT\n double t0=stoptime();\n double t1=t0;\n double t2;\n#endif\n\n size_t n1=F.shape()[0];\n size_t n2=F.shape()[1];\n assert(n1>0 && n2>0);\n\n\n // adjust right hand side F with boundary condition (nothing to do for =0)\n boost::multi_array rhs = F;\n assert( bd1a.size()==bd1b.size() && bd1a.size()==n2 );\n assert( bd2a.size()==bd2b.size() && bd2a.size()==n1 );\n {\n // factors for boundary adjustment to rhs\n double c1 = 0.0, c2 = 0.0;\n if(boundary==types::Dirichlet) {\n c1=a1/sqr(h1);\n c2=a2/sqr(h2);\n } else if(boundary==types::Neumann) {\n c1=2.0*a1/h1;\n c2=2.0*a2/h2;\n } else {\n assert(false);\n }\n // adjust rhs with boundary conditions\n for(size_t i=0; i lambda1(n1);\n std::vector lambda2(n2);\n if(boundary==types::Dirichlet) {\n for(size_t i=0; i& U,\n const boost::multi_array& F,\n double a1, double a2, double h1, double h2,\n double bound_value,\n types::boundary boundarycondition,\n bool add_boundary_to_solution)\n{\n\n size_t n1=F.shape()[0];\n size_t n2=F.shape()[1];\n\n // fill boundary vectors\n std::vector bd1a,bd1b,bd2a,bd2b;\n set_boundary_to_uniform(bd1a,bd1b,bd2a,bd2b,bound_value,n1,n2);\n\n // call the general solver\n return poisolve(U,F,a1,a2,h1,h2,bd1a,bd1b,bd2a,bd2b,\n boundarycondition,add_boundary_to_solution);\n}\n\n} // namespace pde\n\n\n", "meta": {"hexsha": "a81c2868e111cbdd499103af74bbbce35cb948d8", "size": 25023, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "dvs_reconstruction/src/poisson_solver/laplace.cpp", "max_stars_repo_name": "jsz0913/rpg_dvs_evo_open", "max_stars_repo_head_hexsha": "93edc7a2d215ed097e3f6a9abbefd0b572958b74", "max_stars_repo_licenses": ["BSD-2-Clause-Patent"], "max_stars_count": 97.0, "max_stars_repo_stars_event_min_datetime": "2021-06-24T09:34:08.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-28T01:58:09.000Z", "max_issues_repo_path": "dvs_reconstruction/src/poisson_solver/laplace.cpp", "max_issues_repo_name": "jsz0913/rpg_dvs_evo_open", "max_issues_repo_head_hexsha": "93edc7a2d215ed097e3f6a9abbefd0b572958b74", "max_issues_repo_licenses": ["BSD-2-Clause-Patent"], "max_issues_count": 14.0, "max_issues_repo_issues_event_min_datetime": "2021-06-14T13:01:27.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T01:49:57.000Z", "max_forks_repo_path": "dvs_reconstruction/src/poisson_solver/laplace.cpp", "max_forks_repo_name": "jsz0913/rpg_dvs_evo_open", "max_forks_repo_head_hexsha": "93edc7a2d215ed097e3f6a9abbefd0b572958b74", "max_forks_repo_licenses": ["BSD-2-Clause-Patent"], "max_forks_count": 32.0, "max_forks_repo_forks_event_min_datetime": "2021-06-24T09:34:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-01T15:23:29.000Z", "avg_line_length": 30.4046172539, "max_line_length": 83, "alphanum_fraction": 0.5540502737, "num_tokens": 8359, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7279754489059774, "lm_q2_score": 0.6150878414043816, "lm_q1q2_score": 0.4477688474629633}} {"text": "#ifndef EIGEN_SOLVER_H\n#define EIGEN_SOLVER_H\n\n#include \n#include \n\n\n\nnamespace willow { namespace qcmol {\n\n\nclass EigenSolver\n{\npublic:\n\n EigenSolver (): m_is_init(false), m_eig_vals(), m_eig_vecs() {}\n\n // Sinvh.n_rows = nbf\n // Sinvh.n_cols = nmo\n // F.n_rows = nbf\n // F.n_cols = nbf\n // solve WF(nmo, nmo) = Sinv^T(nmo,nbf) F(nbf,nbf) Sinv(nbf,nmo)\n // dsyevd(WF) or eig_sym ()\n // save m_eig_vecs (nbf,nmo) = Sinvh(nbf,nmo)*Cvec(nmo,nmo)\n //\n EigenSolver (const arma::mat Sinvh, const arma::mat F):\n m_is_init(true),\n m_eig_vals(Sinvh.n_cols),\n m_eig_vecs(Sinvh.n_rows, Sinvh.n_cols) {\n\n compute (Sinvh, F);\n\n }\n \n void compute (const arma::mat Sinvh, const arma::mat F) {\n \n const int nbf = Sinvh.n_rows;\n const int nmo = Sinvh.n_cols;\n \n if (!m_is_init) {\n m_is_init = true;\n m_eig_vals.set_size (nmo);\n m_eig_vecs.set_size (nbf, nmo);\n }\n\n // F' \n arma::mat wf = Sinvh.t()*F*Sinvh; // (nmo, nmo)\n\n // Update Orbitals and Energies\n arma::mat eg_vecs;\n bool ok = arma::eig_sym (m_eig_vals, eg_vecs, wf);\n\n // Transform back to non-orthogonal basis\n m_eig_vecs = Sinvh*eg_vecs; // (nbf, nmol)\n \n }\n\n arma::vec eigenvalues() const {\n assert (m_is_init);\n return m_eig_vals;\n }\n \n arma::mat eigenvectors() const {\n assert (m_is_init);\n return m_eig_vecs;\n }\n\nprotected:\n bool m_is_init;\n arma::vec m_eig_vals;\n arma::mat m_eig_vecs;\n};\n\n\n\n} } // namespace willow::qcmol\n\n#endif\n", "meta": {"hexsha": "7113ce146f3d97191e9247698d1ae019f6b62e77", "size": 1513, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "EigenSolver.hpp", "max_stars_repo_name": "swillow/w-qcmol", "max_stars_repo_head_hexsha": "b278417ca8b9eaf08c4a0712e295bdf5ac18595a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2018-02-19T22:13:38.000Z", "max_stars_repo_stars_event_max_datetime": "2018-02-19T22:13:42.000Z", "max_issues_repo_path": "EigenSolver.hpp", "max_issues_repo_name": "swillow/w-qcmol", "max_issues_repo_head_hexsha": "b278417ca8b9eaf08c4a0712e295bdf5ac18595a", "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": "EigenSolver.hpp", "max_forks_repo_name": "swillow/w-qcmol", "max_forks_repo_head_hexsha": "b278417ca8b9eaf08c4a0712e295bdf5ac18595a", "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": 19.1518987342, "max_line_length": 66, "alphanum_fraction": 0.6226040978, "num_tokens": 535, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673269042767, "lm_q2_score": 0.5506073655352404, "lm_q1q2_score": 0.44757073739643677}} {"text": "/* \n// Copyright 2018 University of Liege\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// Authors:\n// - Adrien Crovato\n*/\n\n//// Wake panels creation\n// Compute wake panel collocation point, surface, vertices, normal, longitudinal, transverse and perpendicular\n// vectors from data contained into sGrid\n// Wake panels extend to a constant x coordinate, based on the geometry\n//\n// I/O:\n// - sGrid: temporary dynamic array containing body panel vertices\n// - bPan: body panels (structure)\n// - wPan: wake panels (structure)\n\n#include \n#include \n#include \"create_wake.h\"\n\n#define NDIM 3\n\nusing namespace std;\nusing namespace Eigen;\n\nvoid create_wake(MatrixX3d &sGrid, Network &bPan, Network &wPan) {\n\n // Temporary variables\n double norm = 0;\n Vector3d v1(NDIM), v2(NDIM);\n double dwnstrm;\n int c2, c3;\n\n //// Begin\n cout << \"Creating wake panels... \" << flush;\n\n // Set number of panels (currently only handles predefined wakes)\n wPan.nC = 2;\n wPan.nC_ = 1;\n wPan.nS = bPan.nS;\n wPan.nS_ = bPan.nS_;\n wPan.nP = wPan.nS_;\n\n // Resize network matrices\n wPan.CG.resize(wPan.nP, NDIM);\n wPan.v0.resize(wPan.nP, NDIM);\n wPan.v1.resize(wPan.nP, NDIM);\n wPan.v2.resize(wPan.nP, NDIM);\n wPan.v3.resize(wPan.nP, NDIM);\n wPan.S.resize(wPan.nP, 1);\n wPan.n.resize(wPan.nP, NDIM);\n wPan.l.resize(wPan.nP, NDIM);\n wPan.t.resize(wPan.nP, NDIM);\n wPan.p.resize(wPan.nP, NDIM);\n\n // Downstream coordinate of wake panels = tip x-coord+ 5*chord\n dwnstrm = sGrid(sGrid.rows()-1,0) + 5*sGrid(0,0);\n\n // Collocations points, corners and vectors\n for (int j = 0; j < wPan.nP; ++j) {\n\n c2 = j * bPan.nC;\n c3 = (j+1) * bPan.nC;\n\n wPan.v0(j,0) = dwnstrm; // pts[i][k]\n wPan.v1(j,0) = sGrid(c2,0); // pts[i+1][k]\n wPan.v2(j,0) = sGrid(c3,0); // pts[i+1][k+1]\n wPan.v3(j,0) = dwnstrm; // pts[i][k+1]\n wPan.v0(j,1) = sGrid(c2,1);\n wPan.v1(j,1) = sGrid(c2,1);\n wPan.v2(j,1) = sGrid(c3,1);\n wPan.v3(j,1) = sGrid(c3,1);\n wPan.v0(j,2) = sGrid(c2,2);\n wPan.v1(j,2) = sGrid(c2,2);\n wPan.v2(j,2) = sGrid(c3,2);\n wPan.v3(j,2) = sGrid(c3,2);\n\n wPan.CG(j,0) = (wPan.v0(j,0) + wPan.v1(j,0) + wPan.v2(j,0) + wPan.v3(j,0)) / 4;\n wPan.CG(j,1) = (wPan.v1(j,1) + wPan.v2(j,1)) / 2;\n wPan.CG(j,2) = (wPan.v1(j,2) + wPan.v2(j,2)) / 2;\n\n wPan.l(j,0) = (wPan.v0(j,0) + wPan.v3(j,0) - wPan.v1(j,0) - wPan.v2(j,0)) / 4;\n wPan.l(j,1) = 0;\n wPan.l(j,2) = 0;\n wPan.l.row(j) /= wPan.l.row(j).norm();\n\n wPan.t(j,0) = (wPan.v2(j,0) - wPan.v1(j,0)) / 2;\n wPan.t(j,1) = (wPan.v2(j,1) - wPan.v1(j,1)) / 2;\n wPan.t(j,2) = (wPan.v2(j,2) - wPan.v1(j,2)) / 2;\n wPan.t.row(j) /= wPan.t.row(j).norm();\n }\n // Surfaces and normals\n for (int j = 0; j < wPan.nP; ++j) {\n v1(0) = wPan.v2(j,0) - wPan.v0(j,0);\n v2(0) = wPan.v1(j,0) - wPan.v3(j,0);\n v1(1) = wPan.v2(j,1) - wPan.v0(j,1);\n v2(1) = wPan.v1(j,1) - wPan.v3(j,1);\n v1(2) = wPan.v2(j,2) - wPan.v0(j,2);\n v2(2) = wPan.v1(j,2) - wPan.v3(j,2);\n\n wPan.n.row(j) = v1.cross(v2);\n norm = wPan.n.row(j).norm();\n\n wPan.S(j) = norm/2;\n wPan.n.row(j) /= norm;\n }\n // Perpendicular vector\n for (int j = 0; j < wPan.nP; ++j)\n wPan.p.row(j) = wPan.n.row(j).cross(wPan.l.row(j));\n\n //// Control display\n cout << \"Done!\" << endl;\n cout << \"Wake panels extend to \" << dwnstrm << \" in the x direction\" << endl;\n #ifdef VERBOSE\n cout << \"Collocation points: \" << wPan.CG.rows() << 'X' << wPan.CG.cols() << endl;\n for (int i = 0; i < wPan.nP; ++i)\n cout << i << ' ' << wPan.CG(i,0) << ' ' << wPan.CG(i,1) << ' ' << wPan.CG(i,2) << endl;\n cout << \"Panel surfaces: \" << wPan.S.rows() << 'X' << wPan.S.cols() << endl;\n for (int i = 0; i < wPan.nP; ++i)\n cout << i << ' ' << wPan.S(i) << endl;\n cout << \"Unit normals: \" << wPan.n.rows() << 'X' << wPan.n.cols() << endl;\n for (int i = 0; i < wPan.nP; ++i)\n cout << i << ' ' << wPan.n(i,0) << ' ' << wPan.n(i,1) << ' ' << wPan.n(i,2) << endl;\n cout << \"Unit longitudinal vectors: \" << wPan.l.rows() << 'X' << wPan.l.cols() << endl;\n for (int i = 0; i < wPan.nP; ++i)\n cout << i << ' ' << wPan.l(i,0) << ' ' << wPan.l(i,1) << ' ' << wPan.l(i,2) << endl;\n cout << \"Unit transverse vectors: \" << wPan.t.rows() << 'X' << wPan.t.cols() << endl;\n for (int i = 0; i < wPan.nP; ++i)\n cout << i << ' ' << wPan.t(i,0) << ' ' << wPan.t(i,1) << ' ' << wPan.t(i,2) << endl;\n cout << \"Unit perpendicular vectors: \" << wPan.p.rows() << 'X' << wPan.p.cols() << endl;\n for (int i = 0; i < wPan.nP; ++i)\n cout << i << ' ' << wPan.p(i,0) << ' ' << wPan.p(i,1) << ' ' << wPan.p(i,2) << endl;\n #endif\n cout << endl;\n}", "meta": {"hexsha": "6dd09e4b58ef780422cef92ffbd4739995e5d0b9", "size": 5473, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/create_wake.cpp", "max_stars_repo_name": "acrovato/aero", "max_stars_repo_head_hexsha": "310e6840670f5a39ca015c61c9090f123da8cfd6", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2020-11-16T15:24:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-15T09:36:09.000Z", "max_issues_repo_path": "src/create_wake.cpp", "max_issues_repo_name": "acrovato/aero", "max_issues_repo_head_hexsha": "310e6840670f5a39ca015c61c9090f123da8cfd6", "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/create_wake.cpp", "max_forks_repo_name": "acrovato/aero", "max_forks_repo_head_hexsha": "310e6840670f5a39ca015c61c9090f123da8cfd6", "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": 36.9797297297, "max_line_length": 110, "alphanum_fraction": 0.5278640599, "num_tokens": 2017, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673178375734, "lm_q2_score": 0.5506073655352404, "lm_q1q2_score": 0.44757073240424317}} {"text": "#ifndef LIMEX_HH\n#define LIMEX_HH\n\n#include \n#include \n\n#include \n\n#include \"dune/istl/solvers.hh\"\n\n#include \"fem/embedded_errorest.hh\"\n#include \"fem/iterate_grid.hh\"\n#include \"fem/hierarchicErrorEstimator.hh\"\n#include \"fem/hierarchicspace.hh\"\n#include \"fem/istlinterface.hh\"\n\n#include \"dune/istl/solvers.hh\"\n#include \"dune/istl/preconditioners.hh\"\n\n#include \"timestepping/extrapolation.hh\"\n#include \"timestepping/semieuler.hh\"\n\n#include \"linalg/factorization.hh\"\n#include \"linalg/umfpack_solve.hh\"\n// #include \"linalg/mumps_solve.hh\"\n// #include \"linalg/superlu_solve.hh\"\n\n#include \"linalg/trivialpreconditioner.hh\"\n#include \"linalg/direct.hh\"\n#include \"linalg/triplet.hh\"\n#include \"linalg/iluprecond.hh\"\n#include \"linalg/additiveschwarz.hh\"\n// #include \"linalg/hyprecond.hh\"\n#include \"linalg/jacobiPreconditioner.hh\"\n\n#include \"utilities/enums.hh\"\n\n#include \"io/vtk.hh\"\n\nbool fabscompare( double a, double b ) { return fabs( a ) < fabs( b ) ; }\n\nDirectType xyz = DirectType::UMFPACK;\n\nnamespace Kaskade\n{\n \n \n template \n struct CardioD2\n {\n template \n class D2: public Functional::template D2\n {\n typedef typename Functional::template D2 d2;\n \n public:\n\tstatic bool const present = d2::present && (row==0) && (col==0);\n\tstatic bool const lumped = true;\n };\n };\n \n/**\n * \\ingroup timestepping\n * \\brief Extrapolated linearly implicit Euler method.\n * \n * This class implements the extrapolated linearly implicit Euler\n * method for integrating time-dependent evolution problems. The\n * implementation follows Deuflhard/Bornemann Chapter 6.4.3.\n */\ntemplate \nclass Limex \n{\npublic:\n typedef Eq EvolutionEquation;\n typedef typename EvolutionEquation::AnsatzVars::VariableSet State;\n\nprivate:\n typedef SemiLinearizationAt > Linearization;\n typedef VariationalFunctionalAssembler Assembler;\n \n // for hierarchic error estimator\n typedef FEFunctionSpace > SpaceEx;\n typedef boost::fusion::vector< typename SpaceType::type const*, SpaceEx const*> ExSpaces;\n \n// two components, 1 space -- how to generalize?\n// typedef boost::fusion::vector, VariableDescription<1,1,1> > ExVariableDescriptions;\n \n // 1 component, 1 space -- how to generalize?\n typedef boost::fusion::vector > ExVariableDescriptions;\n \n typedef VariableSetDescription ExVariableSet;\n typedef HierarchicErrorEstimator > ErrorEstimator;\n typedef VariationalFunctionalAssembler EstimatorAssembler;\n \n// typedef typename EstimatorAssembler::template AnsatzVariableRepresentation<> Ansatz;\n// typedef typename EstimatorAssembler::template TestVariableRepresentation<> Test;\n/* typedef typename ExVariableSet::template CoefficientVectorRepresentation<0,1>::type ExCoefficientVectors;*/\n \n typedef typename Eq::AnsatzVars::Grid::Traits::LeafIndexSet IS ;\n \n\npublic:\n /**\n * Constructs an ODE integrator. The arguments eq and ansatzVars\n * have to exist during the lifetime of the integrator.\n */\n Limex(GridManager& gridManager_,\n EvolutionEquation& eq_, typename EvolutionEquation::AnsatzVars const& ansatzVars_, DirectType st=DirectType::UMFPACK):\n gridManager(gridManager_), ansatzVars(ansatzVars_), eq(&eq_,0),\n assembler(gridManager,ansatzVars.spaces), \n iteSteps(10000), iteEps(1e-6), extrap(0),\n rhsAssemblyTime(0.0), matrixAssemblyTime(0.0), factorizationTime(0.0), solutionTime(0.0), adaptivityTime(0.0),\n solverType(st)\n {}\n\n\n /**\n * In order to maintain compatibility with existing code,\n * this overload is needed, as non const reference parameters (refinements) can not\n * have default values. All ist does is call the original method with a temporary\n * parameter.\n */\n State const& step(State const& x, double dt, int order,\n std::vector > const& tolX)\n {\n std::vector > tmp ;\n return step(x,dt,order,tolX,tmp);\n }\n\n /**\n * Computes a state increment that advances the given state in\n * time. The time in the given evolution equation is increased by\n * dt.\n *\n * \\param x the initial state to be evolved\n * \\param dt the time step\n * \\param order the extrapolation order >= 0 (0 corresponds to the linearly implicit Euler)\n * \\param tolX \n * \\param refinements keep track of the cells marked for refinement\n * \\return the state increment (references an internal variable that will be\n * invalidated by a subsequent call of step)\n *\n * \\todo (i) check for B constant, do not reassemble matrix in this case\n * (ii) implement fixed point iteration instead of new factorization\n * in case B is not constant\n */\n State const& step(State const& x, double dt, int order,\n std::vector > const& tolX,\n\t\t \n\t\t std::vector< std::vector > &refinements )\n {\n boost::timer::cpu_timer timer;\n \n std::vector stepFractions(order+1);\n for (int i=0; i<=order; ++i) stepFractions[i] = 1.0/(i+1); // harmonic sequence\n extrap.clear();\n\n typedef typename EvolutionEquation::AnsatzVars::Grid Grid;\n \n int const dim = EvolutionEquation::AnsatzVars::Grid::dimension;\n int const nvars = EvolutionEquation::AnsatzVars::noOfVariables;\n int const neq = EvolutionEquation::TestVars::noOfVariables;\n size_t nnz = assembler.nnz(0,neq,0,nvars,false);\n size_t size = ansatzVars.degreesOfFreedom(0,nvars);\n \n std::vector rhs(size), sol(size);\n\n State dx(x), dxsum(x), tmp(x);\n double const t = eq.time();\n \n double estTime = 0 ;\n\n eq.temporalEvaluationRange(t,t+dt);\n \n typedef AssembledGalerkinOperator Op;\n \n bool iterative = true ;\n int fill_lev = /*0*/ /*1*/2;\n \n typedef typename EvolutionEquation::AnsatzVars::template CoefficientVectorRepresentation<0,neq>::type\n CoefficientVectors;\n typedef typename EvolutionEquation::TestVars::template CoefficientVectorRepresentation<0,neq>::type \n LinearSpaceX;\n\n for (int i=0; i<=order; ++i) {\n double const tau = stepFractions[i]*dt;\n eq.setTau(tau);\n eq.time(t);\n\n // mesh adaptation loop. Just once if i>0.\n bool accurate = true;\n int refinement_count = 0 ; \n\t\n \n do {\t\n // Evaluate and factorize matrix B(t)-tau*J\n dx/* * */= 0;\n timer.start();\n\t\n// \tassembler.assemble(Linearization(eq,x,x,dx)/*,(Assembler::VALUE|Assembler::RHS|Assembler::MATRIX),4*/);\n\t\n// #ifndef KASKADE_SEQUENTIAL\n// \tgridManager.enforceConcurrentReads(std::is_same >::value);\n// \tassembler.setNSimultaneousBlocks(40);\n// \tassembler.setRowBlockFactor(2.0);\n// #endif\n// \tstd::cout << \"assemble linear system ...\" ; std::cout.flush();\n\tassembler.assemble(Linearization(eq,x,x,dx)/*,(Assembler::VALUE|Assembler::RHS|Assembler::MATRIX),4*/);\n// \tstd::cout << \" done\\n\"; std::cout.flush();\n\n\tmatrixAssemblyTime += (double)(timer.elapsed().user)/1e9;\n\t\n\tOp A(assembler);\n// \tstd::cout << \"solve linear system\\n\"; std::cout.flush();\n\t \n\tif (iterative) \n\t{ \t \n\t timer.start();\n\n\t CoefficientVectors solution(EvolutionEquation::AnsatzVars::template CoefficientVectorRepresentation<0,neq>::init(ansatzVars.spaces)\n\t );\n\t solution = 0;\n\t CoefficientVectors rhs(assembler.rhs());\n\t \n\t ILUKPreconditioner p(A,fill_lev,0);\n// \t ILUTPreconditioner p(A,240,1e-2,0);\n// \t JacobiPreconditioner p(A,1.0);\n\n\t Dune::BiCGSTABSolver cg(A,p,1e-7,2000,0); //verbosity: 0-1-2 (nothing-start/final-every it.)\n\t Dune::InverseOperatorResult res;\n\t cg.apply(solution,rhs,res);\n\t if ( !(res.converged) || (res.iterations == 2001) ) {\n\t std::cout << \" no of iterations in cg = \" << res.iterations << std::endl;\n\t std::cout << \" convergence status of cg = \" << res.converged << std::endl;\n\t assert(0);\n\t }\n\t dx.data = solution.data;\n\t solutionTime += (double)(timer.elapsed().user)/1e9;\n\t}\n\telse\n\t{\n\t // direct solution\n\t timer.start();\n// \t assembler.toTriplet(0,neq,0,nvars,ridx.begin(),cidx.begin(),data.begin(),false);\n\t MatrixAsTriplet triplet = A.template get >();\n\t \n\t Factorization *matrix = 0;\n\t switch (solverType) {\n\t case DirectType::UMFPACK:\n\t matrix = new UMFFactorization(size,0,triplet.ridx,triplet.cidx,triplet.data);\n\t break;\n\t case DirectType::UMFPACK3264:\n\t matrix = new UMFFactorization(size,0,triplet.ridx,triplet.cidx,triplet.data);\n\t break;\n// \t case MUMPS:\n// \t matrix = new MUMPSFactorization(size,0,triplet.ridx,triplet.cidx,triplet.data);\n// \t break;\n// \t case SUPERLU:\n// \t matrix = new SUPERLUFactorization(size,0,triplet.ridx,triplet.cidx,triplet.data);\n// \t break;\n\t default:\n\t throw -321;\n\t break;\n\t }\n\t factorizationTime += (double)(timer.elapsed().user)/1e9;\n\t \n\t // First right hand side (j=0) has been assembled together with matrix.\n\t timer.start();\n\t A.getAssembler().toSequence(0,neq,rhs.begin());\n\t for (int k=0; ksolve(rhs,sol);\n\t delete matrix;\n\t for (int k=0; k *matrix = 0;\n// \t switch (solverType)\n// \t {\n// \t case UMFPACK:\n// \t\tmatrix = new UMFFactorization(size,0,ridx,cidx,data);\n// \t\tbreak;\n// \t case UMFPACK3264:\n// \t\tmatrix = new UMFFactorization(size,0,ridx,cidx,data);\n// \t\tbreak;\n// \t case MUMPS:\n// \t\tmatrix = new MUMPSFactorization(size,0,ridx,cidx,data);\n// \t\tbreak;\n// \t case SUPERLU:\n// \t\tmatrix = new SUPERLUFactorization(size,0,ridx,cidx,data);\n// \t\tbreak;\n// \t default:\n// \t\tthrow -321;\n// \t\tbreak;\n// \t }\n// \t factorizationTime += (double)(timer.elapsed().user)/1e9;\n// \n// \t // First right hand side (j=0) has been assembled together with matrix.\n// \t timer.start();\n// \t assembler.toSequence(0,neq,rhs.begin());\n// \t for (size_t k=0; ksolve(rhs,sol);\n// \t delete matrix;\n// \t for (size_t k=0; k::Iterator CellIterator ;\n \n\taccurate = true ;\n\ttimer.start();\n\tIS const& is = gridManager.grid().leafIndexSet();\n\tstd::vector errorDistribution(is.size(0),0.0);\n\tdouble maxErr = 0.0, errNorm = 0.0 ;\n\n if (!tolX.empty() && i==0) {\n\n\t // embeddedErrorEstimator can not be used for linear finite elements\n\t // use HierarchicErrorEstimator instead\n\t // preparation for HierarchicErrorEstimator\n\t if(true) // to avoid mesh adaptation for exVariables\n\t {\n\t //TODO: this should be using the gridviews/index sets of the original space, not the leaf!\n\t SpaceEx spaceEx(gridManager,gridManager.grid().leafGridView(), boost::fusion::at_c<0>(ansatzVars.spaces)->mapper().getOrder()+1);\n\t typename SpaceType::type spaceH1 = *(boost::fusion::at_c<0>(ansatzVars.spaces)) ;\n\t ExSpaces exSpaces(&spaceH1,&spaceEx);\n\t std::string exVarNames[2] = { \"ev\", \"ew\" };\n\t ExVariableSet exVariableSet(exSpaces, exVarNames);\n\t EstimatorAssembler estAssembler(gridManager,exSpaces); \n\t \n\t tmp/* * */= 0 ;\n// \t estAssembler.assemble(ErrorEstimator(Linearization(eq,x,x,tmp/*dx*/),dx));\n\t estAssembler.assemble(ErrorEstimator(semiLinearization(eq,x,x,/*dx*/tmp),dx));\n\n\t \n\t int const estNvars = ErrorEstimator::AnsatzVars::noOfVariables;\n// \t std::cout << \"estimator: nvars = \" << estNvars << \"\\n\";\n\t int const estNeq = ErrorEstimator::TestVars::noOfVariables;\n// \t std::cout << \"estimator: neq = \" << estNeq << \"\\n\";\n\t size_t estNnz = estAssembler.nnz(0,estNeq,0,estNvars,false);\n\t size_t estSize = exVariableSet.degreesOfFreedom(0,estNvars);\n\t \n\t std::vector estRidx(estNnz), estCidx(estNnz);\n\t std::vector estData(estNnz), estRhs(estSize), estSolVec(estSize);\n\t \n\t estAssembler.toSequence(0,estNeq,estRhs.begin());\n\t \n\t typedef typename ExVariableSet::template CoefficientVectorRepresentation<0,estNeq>::type ExCoefficientVectors;\n\t \n\t // iterative solution of error estimator\n// \t timer.start();\n// \t AssembledGalerkinOperator E(estAssembler);\n// \t typename Dune::InverseOperatorResult estRes;\n// \t typename Test::type estRhside( Test::rhs(estAssembler) ) ;\n// \t typename Ansatz::type estSol( Ansatz::init(estAssembler) ) ;\n// \t estSol = 1.0 ;\n// \t JacobiPreconditioner jprec(estAssembler, 1.0);\n// \t jprec.apply(estSol,estRhside); //single Jacobi iteration\n// \t estTime += (double)(timer.elapsed().user)/1e9;\n// \t estSol.write(estSolVec.begin());\n\t \n\t typedef AssembledGalerkinOperator AssEstOperator;\n\t AssEstOperator agro(estAssembler);\n\t Dune::InverseOperatorResult estRes;\n\t ExCoefficientVectors estRhside(estAssembler.rhs());\n\t ExCoefficientVectors estSol(ExVariableSet::template CoefficientVectorRepresentation<0,estNeq>::init(exVariableSet.spaces));\n\t estSol = 1.0 ;\n\t JacobiPreconditioner jprec(agro, 1.0);\n\t jprec.apply(estSol,estRhside); //single Jacobi iteration\n// \t estTime += (double)(timer.elapsed().user)/1e9;\n\t estSol.write(estSolVec.begin());\n\t \n\t //--\n\t \n\t // Transfer error indicators to cells.\n\t CellIterator ciEnd = ansatzVars.gridView.template end<0>() ;\n\t for (CellIterator ci=ansatzVars.gridView.template begin<0>(); ci!=ciEnd; ++ci) {\n\t typedef typename SpaceEx::Mapper::GlobalIndexRange GIR;\n\t double err = 0.0;\n\t GIR gix = spaceEx.mapper().globalIndices(*ci);\n\t for (typename GIR::iterator j=gix.begin(); j!=gix.end(); ++j)\n\t err += fabs(boost::fusion::at_c<0>(estSol.data)[*j]);\n\t // only for 1st component -- second in monodomain is ODE\n\t errorDistribution[is.index(*ci)] = err;\n\t if (fabs(err)>maxErr) maxErr = fabs(err);\n\t }\n// \t std::cout << \"maxErr: \" << maxErr << \"\\n\";\n\t \n// \t for( size_t cno = 0 ; cno < is.size(0); cno++ )\n// \t std::cout << cno << \"\\t\\t\" << errorDistribution[cno] << \"\\n\";\n// \t std::cout.flush();\n\t \n\t //TODO: estimate only error in PDE, not ODE!\n\t // what about relative accuracy?\n\t for (size_t k = 0; k < estRhs.size() ; k++ ) errNorm += fabs( estRhs[k] * estSolVec[k] ); \n\t // this is for all variables?!\n// \t errNorm = tau/*dt*/*sqrt(errNorm);\n\t std::cout << \"errNorm = \" << errNorm << std::endl ;\n\t std::cout.flush();\n\n\t }\n\t\n\t double overallTol = tolX[0].first ;\n\n\t \n// \t for( int i = 0 ; i < 1 /*nvars*/ ; i++ )\n// \t overallTol += tolX[i].first*tolX[i].first ; \n// \t overallTol = sqrt(overallTol);\n\t \n// \t std::cout << \"overallTol = \" << overallTol << std::endl ;\n\t \n\t \n// \t alpha = 0 ; // for uniform refinement\n\n\t int nRefMax = /*10*/7 ;/*7*//*5*//*3*//*15*/ /*4*/ /*5*/ /*10*/\n\t double fractionOfCells = 0.05; /*0.1,0.2*/\n\t unsigned long noToRefine = 0, noToCoarsen = 0;\n\t double alpha = 1.0; /*0.5; //test april 13*/\n\t \n\t double errLevel = 0.5*maxErr ; //0.75\n// \t double minRefine = 0.05;\n\t \n// \t if (minRefine>0.0)\n// \t {\n// \t std::vector eSort(errorDistribution);\n// \t std::sort(eSort.begin(),eSort.end(),fabscompare);\n// \t int minRefineIndex = minRefine*(eSort.size()-1);\n// \t double minErrLevel = fabs(eSort[minRefineIndex])+1.0e-15;\n// \t if (minErrLevel0.0)\n// \t {\n// \t std::vector eSort(errorDistribution);\n// \t std::sort(eSort.begin(),eSort.end(),fabscompare);\n// \t int minRefineIndex = minRefine*(eSort.size()-1);\n// \t double minErrLevel = fabs(eSort[minRefineIndex])+1.0e-15;\n// \t if (minErrLevel overallTol && refinement_count < nRefMax \n\t && gridManager.grid().size(/*dim*/0) < /*maxNoOfVertices*/maxNoOfElements )\n\t //current setup: for 2D BFGS; for 3D fibrillation: use maxNoOfElements\n\t { \n// \t accurate = false;\n// \t std::vector toRefine( is.size(0), false ) ; \n// \t size_t noCells = gridManager.grid().size(0);\n// // \t std::cout << is.size(0) << \" \" << noCells << \"\\n\"; std::cout.flush();\n// \t for( size_t cno = 0 ; cno < noCells ; cno++ )\n// \t {\n// \t if (fabs(errorDistribution[cno]) >= alpha*errLevel)\n// \t {\n// \t\tnoToRefine++;\n// \t\ttoRefine[cno] = true ;\n// \t }\n// \t }\n\t std::vector toRefine( is.size(0), false ) ; //for adaptivity in compression\n\t \n\t accurate = false ;\n\t size_t noCells = gridManager.grid().size(0);\n\t \n// \t // Nagaiah paper:\n// \t unsigned minLevel = 10 ; // do not coarsen below that level \n// \t CellIterator ciEnd = ansatzVars.gridView.template end<0>() ;\n// \t for (CellIterator ci=ansatzVars.gridView.template begin<0>(); ci!=ciEnd; ++ci) \n// \t {\n// \t double vol = sqrt( ci->geometry().volume() );\n// \t if (fabs(errorDistribution[is.index(*ci)])/vol >= 0.2 /*0.1*/ )\n// \t {\n// \t\tif( ci->level() < maxLevel && gridManager.grid().size(dim) < maxNoOfVertices )\n// \t\t{\n// \t\t gridManager.mark(1,*ci);\n// \t\t noToRefine++;\n// \t\t}\n// \t }\n// \t else if (fabs(errorDistribution[is.index(*ci)])/vol < 0.1 /* /2 */ && ci->level() > minLevel ) \n// \t {\n// \t\tgridManager.mark(-1,*ci);\n// \t\tnoToCoarsen++;\n// \t }\n// \t }\n// \t std::cout << \"refine: \" << noToRefine << \" coarsen: \" << noToCoarsen << \"\\n\";\n// \t gridManager.countMarked();\n\t \n// \t last implementation was the following:\n\t unsigned long noToRefineOld = 0;\n\t do{\n\t noToRefineOld = noToRefine;\n\t for( size_t cno = 0 ; cno < noCells ; cno++ )\n\t {\n\t\t if (fabs(errorDistribution[cno]) >= alpha*errLevel) \n\t\t { // TODO: check and bugfix this!\n\t\t\t if( !toRefine[cno] ) noToRefine++;\n\t\t\t toRefine[cno] = true ;\n\t\t }\n\t }\n// \t\tstd::cout << \"alpha: \" << alpha << \"\\trefine: \" << noToRefine << \"\\n\";\n// \t\tstd::cout.flush();\n\t\talpha *= 0.75; // refine more aggressively: reduce alpha by larger amount\n\t } while ( noToRefine < fractionOfCells * noCells && (!noToRefineOld == noToRefine) ) ;\n// \t std::cout << \"to refine: \" << noToRefine << \"\\n\";\n\t std::cout.flush();\n\n\t \n// \t alpha = 0.5; //50\n// \t do {\n// \t for( size_t cno = 0 ; cno < noCells ; cno++ )\n// \t\tif (fabs(errorDistribution[cno]) > alpha*maxErr/*overallTol/noCells*/) {\n// \t\t /*if( !toRefine[cno] )*/ noToRefine++;\n// \t\t toRefine[cno] = true;\n// \t\t }\n// \t \n// \t\t alpha *=0.9;\n// \t } while (noToRefine < fractionOfCells * noCells);\n\t \n// \t long int nRefined = (long int) std::count( toRefine.begin(), toRefine.end(), true );\n// \t std::cout << \" noToRefine = \" << nRefined << std::endl;\n// \t refinements.push_back(toRefine);\n\n\t for (CellIterator ci=ansatzVars.gridView.template begin<0>(); ci!=ansatzVars.gridView.template end<0>(); ++ci)\n\t if( toRefine[is.index(*ci)] && ci->level() < maxLevel ) gridManager.mark(1,*ci);\n\t \n\t bool refok = gridManager.adaptAtOnce(); // something has been refined?\n\t if( !refok ) \n\t {\n\t // nothing has been refined\n\t std::cout << \"nothing has been refined (probably due to maxLevel constraint), stopping\\n\";\n\t accurate = true ;\n\t }\n\t \n\t if (!accurate) {\n\t refinement_count++ ;\n\t nnz = assembler.nnz(0,neq,0,nvars,false);\n\t size = ansatzVars.degreesOfFreedom(0,nvars);\n\t rhs.resize(size);\n\t sol.resize(size);\n\t }\n\t }\n\t else\n\t {\n\t if( errNorm > overallTol && refinement_count > nRefMax ) \n\t std::cout << \"max no of refinements exceeded\\n\";\n// \t if( errNorm > overallTol && gridManager.grid().size(2) > maxNoOfVertices ) \n// \t std::cout << \"max no of nodes exceeded\\n\";\n\t \n\t accurate = true ;\n\t }\n }\n } while (!accurate); \n adaptivityTime += (double)(timer.elapsed().user)/1e9;\n\n// std::cout << gridManager.grid().size(dim) << \" nodes on \" << gridManager.grid().maxLevel() << \"levels\\n\";\n\n dxsum = dx;\n\n // propagate by linearly implicit Euler \n for (int j=1; j<=i; ++j) {\n\t// Assemble new right hand side tau*f(x_j)\n eq.time(eq.time()+tau);\n\ttmp = x; tmp += dxsum;\n State zero(x); zero /* * */= 0;\n timer.start();\n// \tgridManager.enforceConcurrentReads(true);\n// \tassembler.setNSimultaneousBlocks(40);\n// \tassembler.setRowBlockFactor(2.0);\n assembler.assemble(Linearization(eq,tmp,x,zero),Assembler::RHS|Assembler::MATRIX,4);\n rhsAssemblyTime += (double)(timer.elapsed().user)/1e9;\n\t\n\tOp A(assembler);\n\t\n\tif( !iterative )\n\t{\n\t timer.start();\n\t //direct solution\n\t A.getAssembler().toSequence(0,neq,rhs.begin());\n\t MatrixAsTriplet triplet = A.template get >();\n\t Factorization *matrix = 0;\n\t switch (solverType) {\n\t case DirectType::UMFPACK:\n\t matrix = new UMFFactorization(size,0,triplet.ridx,triplet.cidx,triplet.data);\n\t break;\n\t case DirectType::UMFPACK3264:\n\t matrix = new UMFFactorization(size,0,triplet.ridx,triplet.cidx,triplet.data);\n\t break;\n// \t case MUMPS:\n// \t matrix = new MUMPSFactorization(size,0,triplet.ridx,triplet.cidx,triplet.data);\n// \t break;\n// \t case SUPERLU:\n// \t matrix = new SUPERLUFactorization(size,0,triplet.ridx,triplet.cidx,triplet.data);\n// \t break;\n\t default:\n\t throw -321;\n\t break;\n\t }\n\t factorizationTime += (double)(timer.elapsed().user)/1e9;\n\t timer.start();\n\t matrix->solve(rhs,sol);\n\t delete matrix;\n\t for (int k=0; k::init(ansatzVars.spaces) );\n\t solution = 0;\n\t // \t assembler.assemble(linearization(F,x));\n\t CoefficientVectors rhs(assembler.rhs());\n\t \n\t ILUKPreconditioner p(A,fill_lev,0);\n// \t ILUTPreconditioner p(A,240,1e-2,0);\n// \t JacobiPreconditioner p(A,1.0);\n\n\t \n\t Dune::BiCGSTABSolver cg(A,p,1e-7,2000,0); //verbosity: 0-1-2 (nothing-start/final-every it.)\n\t Dune::InverseOperatorResult res;\n\t cg.apply(solution,rhs,res);\n\t if ( !(res.converged) || (res.iterations == 2001) ) {\n\t std::cout << \" no of iterations in cg = \" << res.iterations << std::endl;\n\t std::cout << \" convergence status of cg = \" << res.converged << std::endl;\n\t assert(0);\n\t }\n\t dx.data = solution.data;\n// \t// iterative solution\n// timer.start();\n// \ttypedef typename Assembler::template TestVariableRepresentation<>::type Rhs;\n// \ttypedef typename Assembler::template AnsatzVariableRepresentation<>::type Sol;\n// \tSol solution(Assembler::template AnsatzVariableRepresentation<>::init(assembler));\n// \tRhs rhside(Assembler::template TestVariableRepresentation<>::rhs(assembler));\n// \tAssembledGalerkinOperator A(assembler, false);\n// \ttypename AssembledGalerkinOperator::matrix_type tri(A.getmat());\n// \n// \t\n// typedef typename Assembler::template TestVariableRepresentation<>::type LinearSpace;\n// \tDune::InverseOperatorResult res;\n// \tsolution = 1.0;\n// \tJacobiPreconditioner p(assembler,1.0);\n// // \tTrivialPreconditioner trivial;\n// \tDune::CGSolver cg(A,/*trivial*/p,iteEps,iteSteps,0);\n// \tcg.apply(solution,rhside,res);\n// \tA.applyscaleadd(-1.0,rhside,solution);\n// \tdouble slntime = (double)(timer.elapsed().user)/1e9;\n// \tsolutionTime += slntime ;\n// \tdx.data = solution.data ; \n// \t// end: iterative solution\n\t}\n\t\n dxsum += dx;\n solutionTime += (double)(timer.elapsed().user)/1e9;\n }\n\n // insert into extrapolation tableau\n extrap.push_back(dxsum,stepFractions[i]);\n\n // restore initial time\n eq.time(t);\n }\n\n return extrap.back();\n }\n\n /**\n * Estimates the time discretization error of the previously\n * computed step by taking the difference between the diagonal and\n * subdiagonal extrapolation values of maximal order. This requires\n * that order>1 has been given for the last step.\n */\n std::vector > estimateError(State const& x,int i, int j) const \n {\n assert(extrap.size()>1);\n\n std::vector > e(ansatzVars.noOfVariables);\n \n relativeError(typename EvolutionEquation::AnsatzVars::Variables(),extrap[i].data,\n extrap[j].data,x.data,\n ansatzVars.spaces,eq.scaling(),e.begin());\n \n return e;\n }\n \n template \n void reportTime(OutStream& out) const {\n out << \"Limex time: \" << matrixAssemblyTime << \"s matrix assembly\\n\"\n << \" \" << rhsAssemblyTime << \"s rhs assembly\\n\"\n << \" \" << factorizationTime << \"s factorization\\n\"\n << \" \" << solutionTime << \"s solution\\n\"\n\t<< \" \" << adaptivityTime << \"s adaptivity\\n\";\n }\n \n void advanceTime(double dt) { eq.time(eq.time()+dt); }\n \n \nprivate:\n GridManager& gridManager;\n typename EvolutionEquation::AnsatzVars const& ansatzVars;\n SemiImplicitEulerStep eq;\n Assembler assembler;\n int iteSteps ;\n double iteEps ;\n \npublic:\n ExtrapolationTableau extrap;\n double rhsAssemblyTime, matrixAssemblyTime, factorizationTime, solutionTime, adaptivityTime;\n DirectType solverType;\n};\n\n} //namespace Kaskade\n#endif\n", "meta": {"hexsha": "1361a37f4b1da97bb92190c9e2e46117ec901d0b", "size": 26700, "ext": "hh", "lang": "C++", "max_stars_repo_path": "Kaskade/timestepping/limexWithoutJensHierarchicEst.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/timestepping/limexWithoutJensHierarchicEst.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:30.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-09T22:02:33.000Z", "max_forks_repo_path": "Kaskade/timestepping/limexWithoutJensHierarchicEst.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": 36.8275862069, "max_line_length": 135, "alphanum_fraction": 0.6483146067, "num_tokens": 7687, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7025300573952054, "lm_q2_score": 0.6370307944803832, "lm_q1q2_score": 0.4475332806088169}} {"text": "#ifndef SCALARREWRITE_HPP\n#define SCALARREWRITE_HPP\n\n#include \"scalarbase.hpp\"\n#include \"exprrewrite.hpp\"\n#include \"exprmatch.hpp\"\n#include \n//#include \n#include \"scalarrange.hpp\"\n\nbool isgenexp(const expr &e) {\n\tif (e.isleaf()) {\n\t\tif (e.asleaf().type()==typeid(matchleaf)) {\n\t\t\tmatchleaf ml = MYany_cast(e.asleaf());\n\t\t\tif (std::dynamic_pointer_cast(ml)\n\t\t\t || std::dynamic_pointer_cast(ml)\n\t\t\t || std::dynamic_pointer_cast(ml)\n\t\t\t || std::dynamic_pointer_cast(ml))\n\t\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n\tauto n = std::dynamic_pointer_cast(e.asnode());\n\tif (!n) return false;\n\tif (e.children().size()!=1) return false;\n\treturn isgenexp(e.children()[0]);\n}\n\n\nexpr chainpatternmod(const expr &ex) {\n\treturn ex.map([](const expr &e) {\n\t\t\tif (e.isleaf()) return optional{};\n\t\t\tauto n = e.asnode();\n\t\t\tif (n==pluschain || n==multiplieschain) {\n\t\t\t\tauto bop = std::dynamic_pointer_cast(n)->baseop;\n\t\t\t\tauto ch = e.children();\n\t\t\t\tauto last = ch.back();\n\t\t\t\tif (isgenexp(last))\n\t\t\t\t\treturn optional{in_place,std::make_shared(std::make_shared(bop)),\n\t\t\t\t\t\t\tch};\n\t\t\t\telse return optional{in_place,std::make_shared(bop),\n\t\t\t\t\t\t\tch};\n\t\t\t}\n\t\t\treturn optional{};\n\t\t});\n}\n\nstruct sortchildren : public rewriterule {\n\tvirtual ruleptr clone() const { return std::make_shared(*this); }\n\toptional vars;\n\tstd::vector cops;\n\n\tsortchildren(std::vector comops)\n\t\t: cops(comops), vars{} { }\n\tsortchildren(std::vector comops, vset v)\n\t\t: cops(comops), vars(in_place,std::move(v)) {}\n\n\tint typeorder(const expr &e) const {\n\t\t// TODO: use map/unordered_map\n\t\tif (isconst(e)) return 0;\n\t\tint add = (isconstexpr(e,vars) ? 0 : 13);\n\t\tif (e.isleaf()) return 1+add;\n\t\tauto &op = e.asnode();\n\t\tif (op==plusop || op==pluschain) return 2+add;\n\t\tif (op==multipliesop || op==multiplieschain) return 3+add;\n\t\tif (op==powerop) return 4+add;\n\t\tif (op==logop) return 5+add;\n\t\t//if (op==switchop) return 6+add;\n\t\tif (op==condop) return 7+add;\n\t\tif (op==condeqop) return 8+add;\n\t\tif (op==absop) return 9+add;\n\t\tif (op==derivop) return 10+add;\n\t\tif (op==integrateop) return 11+add;\n\t\tif (op==evalatop) return 12+add;\n\t\treturn 13+add;\n\t}\n\n\tvirtual void setvars(const vset &v) {\n\t\tvars = v;\n\t}\n\n\tint secondordering(const expr &e1, const expr &e2) const {\n\t\tif (isconst(e1)) {\n\t\t\tscalarreal v1 = getconst(e1);\n\t\t\tscalarreal v2 = getconst(e2);\n\t\t\tif (v1v2) return +1;\n\t\t\treturn 0;\n\t\t}\n\t\tif (isvar(e1))\n\t\t\treturn MYany_cast(e1.asleaf())->name\n\t\t\t\t\t.compare(MYany_cast(e2.asleaf())->name);\n\t\tif (e1.isleaf()) return 0;\n\t\tauto &ch1 = e1.children();\n\t\tauto &ch2 = e2.children();\n\t\tfor(int i=std::min(ch1.size(),ch2.size())-1;i>=0;i--) {\n\t\t\tint res = exprcmp(ch1[i],ch2[i]);\n\t\t\tif (res!=0) return res;\n\t\t}\n\t\treturn ch1.size()-ch2.size();\n\t}\n\n\tint exprcmp(const expr &e1, const expr &e2) const {\n\t\tint o1 = typeorder(e1), o2 = typeorder(e2);\n\t\tif (o1!=o2) return o1-o2;\n\t\treturn secondordering(e1,e2);\n\t}\n\n\tvirtual optional apply(const expr &e) const {\n\t\tif (e.isleaf()) return {};\n\t\tif (std::find(cops.begin(),cops.end(),e.asnode())==cops.end())\n\t\t\treturn {};\n\t\tauto &ch = e.children();\n\t\tif (ch.size()<2) return {};\n\t\tfor(int i=1;i0) {\n\t\t\t\tstd::vector che = ch;\n\t\t\t\tstd::sort(che.begin(),che.end(),\n\t\t\t\t\t\t[this](const expr &e1, const expr &e2) {\n\t\t\t\t\t\t\treturn exprcmp(e1,e2)<0;\n\t\t\t\t\t\t}\n\t\t\t\t);\n\t\t\t\treturn optional{in_place,e.asnode(),che};\n\t\t\t}\n\t\t}\n\t\treturn {};\n\t}\n};\n\nscalarset rangeprop(const expr &e) {\n\tif (isconst(e)) {\n\t\treturn {getconst(e)};\n\t}\n\tif (isop(e,pluschain)) {\n\t\tauto &ch = e.children();\n\t\tif (ch.empty()) return {-std::numeric_limits::infinity(),\n\t\t\t\t\tstd::numeric_limits::infinity()};\n\t\tauto ret = rangeprop(ch[0]);\n\t\tfor(int i=1;i &a, const range &b) {\n\t\t\t\t\t\treturn range{a.first+b.first,\n\t\t\t\t\t\t\t\t\ta.second+b.second}; });\n\t\treturn ret;\n\t}\n\tif (isop(e,multiplieschain)) {\n\t\tauto &ch = e.children();\n\t\tif (ch.empty()) return {-std::numeric_limits::infinity(),\n\t\t\t\t\tstd::numeric_limits::infinity()};\n\t\tauto ret = rangeprop(ch[0]);\n\t\tfor(int i=1;i &a, const range &b) {\n\t\t\t\t\t\tauto v1=a.first*b.first, v2=a.second*b.second,\n\t\t\t\t\t\t\tv3 = a.first*b.second, v4=a.second*b.first;\n\t\t\t\t\t\treturn range{\n\t\t\t\t\t\t\tstd::min(std::min(v1,v2),std::min(v3,v4)),\n\t\t\t\t\t\t\tstd::max(std::max(v1,v2),std::max(v3,v4))};\n\t\t\t\t\t\t\t});\n\t\treturn ret;\n\t}\n\tif (isop(e,absop)) {\n\t\treturn rangeprop(e.children()[0]).modify(\n\t\t\t\t[](const range &a) {\n\t\t\t\t\tif (a.first>=0) return a;\n\t\t\t\t\tif (a.second<=0) return range{-a.second,-a.first};\n\t\t\t\t\treturn range{scalarreal{0},std::max(-a.first,a.second)};\n\t\t\t\t\t});\n\t}\n\tif (isop(e,powerop)) {\n\t\treturn rangeprop(e.children()[0]).combinemult(\n\t\t\t\trangeprop(e.children()[1]),\n\t\t\t\t[](const range &b, const range &p) {\n\t\t\t\t\tscalarset ret;\n\t\t\t\t\tlimpt zero(scalarreal{0});\n\t\t\t\t\tif (b.first>zero) {\n\t\t\t\t\t\tauto v1=pow(b.first,p.first),\n\t\t\t\t\t\t\tv2=pow(b.second,p.second),\n\t\t\t\t\t\t\tv3=pow(b.first,p.second),\n\t\t\t\t\t\t\tv4=pow(b.second,p.first);\n\t\t\t\t\t\tret.x.emplace(\n\t\t\t\t\t\t\tstd::min(std::min(v1,v2),std::min(v3,v4)),\n\t\t\t\t\t\t\tstd::max(std::max(v1,v2),std::max(v3,v4)));\n\t\t\t\t\t\treturn ret;\n\t\t\t\t\t}\n\t\t\t\t\tif (b.second>zero) {\n\t\t\t\t\t\tauto v1=pow(zero,p.first),\n\t\t\t\t\t\t\tv2=pow(b.second,p.second),\n\t\t\t\t\t\t\tv3=pow(zero,p.second),\n\t\t\t\t\t\t\tv4=pow(b.second,p.first);\n\t\t\t\t\t\tv1.closed = v3.closed = false;\n\t\t\t\t\t\tret.x.emplace(\n\t\t\t\t\t\t\tstd::min(std::min(v1,v2),std::min(v3,v4)),\n\t\t\t\t\t\t\tstd::max(std::max(v1,v2),std::max(v3,v4)));\n\t\t\t\t\t}\n\t\t\t\t\t// what to do with negative base???\n\t\t\t\t\tif (p.first.pt==p.second.pt) { // single exponent\n\t\t\t\t\t\tif (p.first.pt.isint()) {\n\t\t\t\t\t\t\tauto v1 = pow(zero,p.first);\n\t\t\t\t\t\t\tauto v2 = pow(b.first,p.first);\n\t\t\t\t\t\t\tret.x.emplace(v1,v2);\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tlimpt b2 = b.second.pt>=zero ? zero :\n\t\t\t\t\t\t\t\t(b.second.pt.isint() ? b.second :\n\t\t\t\t\t\t\t\t\t(limpt{\n\t\t\t\t\t\t\t\t\t\tb.first.pt.floor()}));\n\t\t\t\t\t\tlimpt b1 = b2-limpt{scalarreal{1}};\n\t\t\t\t\t\tif (b1>b.first) {\n\t\t\t\t\t\t\tauto v1 = pow(b2,p.first);\n\t\t\t\t\t\t\tauto v2 = pow(b1,p.first);\n\t\t\t\t\t\t\tauto v3 = pow(b2,p.second);\n\t\t\t\t\t\t\tauto v4 = pow(b1,p.second);\n\t\t\t\t\t\t\tret.x.emplace(\n\t\t\t\t\t\t\t\tstd::min(std::min(v1,v2),\n\t\t\t\t\t\t\t\t\tstd::min(v3,v4)),\n\t\t\t\t\t\t\t\tstd::max(std::max(v1,v2),\n\t\t\t\t\t\t\t\t\tstd::max(v3,v4)));\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tauto v1 = pow(b2,p.first);\n\t\t\t\t\t\t\tauto v3 = pow(b2,p.second);\n\t\t\t\t\t\t\tret.x.emplace(v1,v3);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\t/* not sure why this was the code... seems very wrong\n\t\t\t\t\t * p not even mentioned!\n\t\t\t\t\t */\n\t\t\t\t\t/*\n\t\t\t\t\tfor(auto ip = b.first.closed\n\t\t\t\t\t\t\t\t|| !b.first.pt.iseven() ?\n\t\t\t\t\t\t\tceil(b.first.pt/2)*2\n\t\t\t\t\t\t\t: ceil(b.first.pt/2+1)*2;\n\t\t\t\t\t\t\tip<0 && b.second>ip;ip+=2) {\n\t\t\t\t\t\tstd::cout << \"looking at \" << tostring(b.first.pt) << ' ' << tostring(b.second.pt) << ' ' << tostring(ip) << std::endl;\n\t\t\t\t\t\tret.x.emplace(\n\t\t\t\t\t\t\tb.first<=0 && b.second>=0 ?\n\t\t\t\t\t\t\t\tscalarreal{0} : pow(\n\t\t\t\t\t\t\t\t\tstd::min(abs(b.first),\n\t\t\t\t\t\t\t\t\t\tabs(b.second)),ip),\n\t\t\t\t\t\t\tpow(std::max(abs(b.first),\n\t\t\t\t\t\t\t\t\tabs(b.second)),ip));\n\t\t\t\t\t}\n\t\t\t\t\t*/\n\n\t\t\t\t});\n\t}\n\tif (isop(e,logop)) {\n\t\treturn rangeprop(e.children()[0]).modify(\n\t\t\t\t[](range a) {\n\t\t\t\t\ta.first.pt = log(a.first.pt);\n\t\t\t\t\ta.second.pt = log(a.second.pt);\n\t\t\t\t\treturn a;\n\t\t\t\t\t});\n\t}\n\tif (isop(e,heavisideop)) {\n\t\treturn rangeprop(e.children()[0]).modify(\n\t\t\t\t[](const range &a) {\n\t\t\t\t\treturn range{a.first < 0 ? 0 : 1,\n\t\t\t\t\t\t\t\ta.second < 0 ? 0 : 1};\n\t\t\t\t\treturn a;\n\t\t\t\t});\n\t}\n\tif (isop(e,diracop)) {\n\t\treturn rangeprop(e.children()[0]).modify(\n\t\t\t\t[](const range &a) {\n\t\t\t\t\treturn range{scalarreal{0},\n\t\t\t\t\t\ta.overlap(range(0,0)) ?\n\t\t\t\t\t\t\tstd::numeric_limits::infinity()\n\t\t\t\t\t\t\t: scalarreal{0}};\n\t\t\t\t});\n\t}\n\treturn {-std::numeric_limits::infinity(),\n\t\t\t\t\tstd::numeric_limits::infinity()};\n}\n\n\n// perhaps these should do their own simplification first...\n\nbool ispos(const expr &e) {\n\tauto rs = rangeprop(e);\n\tif (rs.x.empty()) return false; //???\n\tfor(auto &r : rs.x)\n\t\tif (r.first<=0) return false;\n\treturn true;\n}\nbool isneg(const expr &e) {\n\tauto rs = rangeprop(e);\n\tif (rs.x.empty()) return false; //???\n\tfor(auto &r : rs.x)\n\t\tif (r.second>=0) return false;\n\treturn true;\n}\nbool isnonneg(const expr &e) {\n\tauto rs = rangeprop(e);\n\tif (rs.x.empty()) return false; //???\n\tfor(auto &r : rs.x)\n\t\tif (r.first<0) return false;\n\treturn true;\n}\nbool isnonpos(const expr &e) {\n\tauto rs = rangeprop(e);\n\tif (rs.x.empty()) return false; //???\n\tfor(auto &r : rs.x)\n\t\tif (r.second>0) return false;\n\treturn true;\n}\nbool isconst(const expr &e, scalarreal k) {\n\tauto rs = rangeprop(e);\n\tif (rs.x.empty()) return false; //???\n\tfor(auto &r : rs.x)\n\t\tif (r.first!=k || r.second!=k) return false;\n\treturn true;\n}\nbool iseven(const expr &e) {\n\tauto rs = rangeprop(e);\n\tif (rs.x.empty()) return false; //???\n\tfor(auto &r : rs.x)\n\t\tif (r.first!=r.second || !r.first.pt.iseven()) return false;\n\treturn true;\n}\nbool isodd(const expr &e) {\n\tauto rs = rangeprop(e);\n\tif (rs.x.empty()) return false; //???\n\tfor(auto &r : rs.x)\n\t\tif (r.first!=r.second || !r.first.pt.isodd()) return false;\n\treturn true;\n}\n\nstruct simpcond : public rewriterule {\n\tvirtual ruleptr clone() const { return std::make_shared(*this); }\n\tvirtual optional apply(const expr &e) const {\n\t\tif (!isop(e,condop) && !isop(e,condeqop)) return {};\n\t\tauto rngset = rangeprop(e.children()[0]);\n\t\tif (isop(e,condop)) {\n\t\t\tbool hasless=false, hasgreq=false;\n\t\t\tfor(auto &rng : rngset.x) {\n\t\t\t\tif (rng.first<0) {\n\t\t\t\t\thasless=true;\n\t\t\t\t\tif (hasgreq) break;\n\t\t\t\t}\n\t\t\t\tif (rng.second>=0) {\n\t\t\t\t\thasgreq=true;\n\t\t\t\t\tif (hasless) break;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!hasgreq) return optional{in_place,e.children()[1]};\n\t\t\tif (!hasless) return optional{in_place,e.children()[2]};\n\t\t\treturn {};\n\t\t} else {\n\t\t\tbool hasnotzero=false, haszero=false;\n\t\t\tfor(auto &rng : rngset.x) {\n\t\t\t\tif (rng.first!=0 || rng.second!=0) {\n\t\t\t\t\thasnotzero=true;\n\t\t\t\t\tif (haszero) break;\n\t\t\t\t}\n\t\t\t\tif (rng.first<=0 && rng.second>=0) {\n\t\t\t\t\thaszero=true;\n\t\t\t\t\tif (hasnotzero) break;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!hasnotzero) return optional{in_place,e.children()[1]};\n\t\t\tif (!haszero) return optional{in_place,e.children()[2]};\n\t\t\treturn {};\n\t\t}\n\t}\n};\n\n\n/*\nstruct normswitch : public rewriterule {\n\tvirtual ruleptr clone() const { return std::make_shared(*this); }\n\tvirtual optional apply(const expr &e) const {\n\t\tif (!isop(e,switchop)) return {};\n\t\tauto &c0 = e.children()[0];\n\t\texpr tosub = scalar(0);\n\t\tif (c0.isleaf()) {\n\t\t\tif (!isconst(c0) || getconst(c0)==0)\n\t\t\t\treturn {};\n\t\t\ttosub = c0;\n\t\t} else {\n\t\t\tif (!isop(c0,pluschain) || c0.children().empty()\n\t\t\t\t\t|| !isconst(c0.children()[0])\n\t\t\t\t\t|| getconst(c0.children()[0])==0)\n\t\t\t\treturn {};\n\t\t\ttosub = c0.children()[0];\n\t\t}\n\t\tstd::vector newch(e.children());\n\t\tfor (int i=0;i{in_place,e.asnode(),newch};\n\t}\n};\n\nstruct liftswitch : public rewriterule {\n\tvirtual ruleptr clone() const { return std::make_shared(*this); }\n\tstatic expr replacech(const expr &e, int chi, const expr &ch) {\n\t\tauto &ech = e.children();\n\t\tstd::vector newch;\n\t\tnewch.reserve(ech.size());\n\t\tfor(int i=0;i apply(const expr &e) const {\n\t\tif (e.isleaf() || e.asnode()==switchop) return {};\n\t\tauto &ch = e.children();\n\t\tfor(int i=0;i newch;\n\t\t\t\tfor(int j=0;j{in_place,switchop,newch};\n\t\t\t}\n\t\treturn {};\n\t}\n};\n\nstruct squeezeswitch : public rewriterule {\n\tvirtual ruleptr clone() const { return std::make_shared(*this); }\n\tvirtual optional apply(expr &e) const {\n\t\tif (!isop(e,switchop)) return {};\n\t\tauto &ch = e.children();\n\t\tif (ch.size()<5) {\n\t\t\tif (ch[1]==ch[3]) // technically, this might expand\n\t\t\t\t// the domain (if ch[0] is undefined in places)\n\t\t\t\treturn optional{in_place,ch[1]};\n\t\t\treturn {};\n\t\t}\n\t\tfor(int i=2;i newch;\n\t\t\t\tnewch.reserve(ch.size()-2);\n\t\t\t\tfor(int j=0;j{in_place,e.asnode(),newch};\n\t\t\t}\n\t\treturn {};\n\t}\n};\n\n\nstruct mergeswitch : public rewriterule {\n\tvirtual ruleptr clone() const { return std::make_shared(*this); }\n\tstatic bool ismergeable(const expr &e, const expr &te, bool checkte=true) {\n\t\tif (!isop(e,switchop)) return false;\n\t\tauto &ch = e.children();\n\t\tif (checkte && !(ch[0]==te)) return false;\n\t\tscalarreal lastk = 0;\n\t\tfor(int i=2;i2) {\n\t\t\t\tscalarreal newk = getconst(ch[i]);\n\t\t\t\tif (newk apply(expr &e) const {\n\t\tif (!ismergeable(e,e,false)) return {};\n\t\tauto &ch = e.children();\n\t\tint mchi = -1;\n\t\tscalarreal preth = -std::numeric_limits::infinity();\n\t\tscalarreal postth = std::numeric_limits::infinity();\n\t\tfor(int i=1;i1) preth = getconst(ch[i-1]);\n\t\t\t\tif (i+1 < ch.size()) postth = getconst(ch[i+1]);\n\t\t\t\tbreak;\n\t\t\t}\n\t\tif (mchi==-1) return {};\n\n\t\tauto &mch = ch[mchi].children();\n\t\tstd::vector newch;\n\t\tfor(int i=0;i(mch[i+1])\n\t\t\t\t\t\t\t: std::numeric_limits::infinity());\n\t\t\tif (th > preth) {\n\t\t\t\tnewch.emplace_back(mch[i]);\n\t\t\t\tif (th < postth && i+1{in_place,e.asnode(),newch};\n\t}\n};\n*/\n\nruleptr SRR(const expr &s, const expr &p) {\n\treturn SR(chainpatternmod(s),p);\n}\n\ntemplate\nruleptr SRR(const expr &s, const expr &p, F &&f) {\n\treturn SR(chainpatternmod(s),p,std::forward(f));\n}\n\ntemplate\nstruct bigopexpand : public rewriterule {\n\tvirtual ruleptr clone() const { return std::make_shared(*this); }\n\tint nterms;\n\top bigop, chainop;\n\tT id;\n\n\tbigopexpand(int n, op bop, op cop, T i) : nterms(n), bigop(bop), chainop(cop), id(i) {}\n\n\tvirtual optional apply(const expr &e) const {\n\t\tif (!isop(e,bigop)) return {};\n\t\tauto &ch = e.children();\n\t\tif (!isconst(ch[2]) || !isconst(ch[3])) return {};\n\t\tscalarreal x0 = getconst(ch[2]);\n\t\tscalarreal x1 = getconst(ch[3]);\n\t\tif (x1 < x0) return optional{in_place,scalar(id)};\n\t\tif (x1 >= x0+nterms) return {};\n\t\tstd::vector terms;\n\t\tfor(scalarreal x=x0;x<=x1;x+=1)\n\t\t\tterms.emplace_back(substitute(ch[1],ch[0],scalar(x)));\n\t\treturn optional{in_place,chainop,terms};\n\t}\n};\n\nexpr x_ = newvar(\"x_\");\nexpr notx_{makematchleaf(vset{{getvar(x_)}})};\nexpr k1_ = L(1,notx_);\nexpr k2_ = L(2,notx_);\nexpr k3_ = L(3,notx_);\nexpr k4_ = L(4,notx_);\nexpr k5_ = L(5,notx_);\nexpr k6_ = L(6,notx_);\nexpr k7_ = L(7,notx_);\nexpr k8_ = L(8,notx_);\nexpr k9_ = L(9,notx_);\n\nstruct tableintegrate : public rewriterule {\n\tvirtual ruleptr clone() const { return std::make_shared(*this); }\n\tstd::vector> antiderivs;\n\n\ttableintegrate(std::vector> ader)\n\t\t\t: antiderivs(std::move(ader)) {}\n\n\tvirtual optional apply(const expr &e) const {\n\t\tif (!isop(e,integrateop)) return {};\n\t\tauto &ch = e.children();\n\t\texpr newint = substitute(ch[1],ch[0],x_);\n\t\tfor(auto &ad : antiderivs) {\n\t\t\tauto res = match(newint,ad.first);\n\t\t\tif (res) {\n\t\t\t\texpr ader = substitute(ad.second,*res);\n\t\t\t\texpr ret = substitute(ader,x_,ch[3])\n\t\t\t\t\t- substitute(ader,x_,ch[2]);\n\t\t\t\treturn optional{in_place,std::move(ret)};\n\t\t\t}\n\t\t}\n\t\treturn {};\n\t}\n};\n\ntemplate\nstd::pair ADR(E1 &&e, E2 &&ad) {\n\treturn std::make_pair(chainpatternmod(std::forward(e)),\n\t\t\tstd::forward(ad));\n}\n\nstd::vector> stdantiderivs\n\t{{\n\t\t ADR( k1_, \n\t P1_*x_ ),\n\n\t\t ADR( x_,\n\t\t x_*x_/2 ),\n\n\t\t // TODO:\n\t\t // when k1_<0 this doesn't work if the integral goes over the pole (@ x_=0)\n\t\t // similar problem with the other rational function antiderivatives below!\n\t\t ADR( pow(x_,k1_),\n\t\t\t ifeqthenelse(P1_+1,log(abs(x_)),pow(x_,P1_+1)/(P1_+1)) ),\n\n\t\t ADR( pow(x_ + k2_,k3_),\n\t\t\t ifeqthenelse(P3_+1, log(abs(x_+P2_)),\n\t\t\t\t\t\t\tpow(x_+P2_,P3_+1)/(P3_+1))),\n\n\t\t ADR( pow(k1_*x_ + k2_,k3_),\n\t\t\t ifeqthenelse(P1_,pow(P2_,P3_)*x_,\n\t\t\t\t ifeqthenelse(P3_+1, log(abs(P1_*x_+P2_))/P1_,\n\t\t\t\t\t \t\t\tpow(P1_*x_+P2_,P3_+1)/(P3_+1)/P1_))),\n\n\t\t // added to make example in proposal work... needs to be\n\t\t // more general\n\t\t ADR( pow(k1_,k2_*x_),\n\t\t\t\t ifeqthenelse(P2_,x_,\n\t\t\t\t\t pow(P1_,P2_*x_)/(P2_*log(P1_)))),\n\n\t }};\n\n// all of the next few \"helpers\" should perhaps be moved elsewhere\n// they may also need to be made more efficient and perhaps given\n// their own algebraic symbols to be reasonable about directly\n// (for instance, we probably don't want to be evaluating \"factorial\"\n// or \"choose\" directly)\nexpr factorial(const expr &n) {\n\texpr i = newvar(); \n\treturn prod(i,i,scalar(1),n);\n}\n\nexpr nchoosek(const expr &n, const expr k) {\n\treturn factorial(n)/(factorial(k)*factorial(n-k));\n}\n\nexpr B0(const expr &m) {\n\texpr k=newvar(), v=newvar();\n\n\t// pos series\n\t//return sum(sum(pow(scalar(-1),v)*nchoosek(k,v)*pow(v+1,m)/(k+1),v,scalar(0),k),k,scalar(0),m);\n\t// neg series\n\treturn sum(sum(pow(scalar(-1),v)*nchoosek(k,v)*pow(v,m)/(k+1),v,scalar(0),k),k,scalar(0),m);\n}\n\n// Bernoulli polynomial\nexpr B(const expr &n, const expr &m) {\n\texpr k = newvar();\n\treturn sum(nchoosek(n,k)*B0(n-k)*pow(m,k),k,scalar(0),n);\n}\n\nexpr psum(const expr &p, const expr &n) {\n\texpr k = newvar();\n\treturn sum(nchoosek(p,k)*B0(p-k)*pow(-1,p-k)/(k+1)*pow(n,k+1),k,scalar(0),p);\n}\n\n// TODO: will need to be separated out into general and specific to scalars\n//std::vector\n\nruleset basicscalarrules\n\t{{toptr(),\n\t toptr(),\n\t toptr(std::vector{pluschain,multiplieschain}),\n\n SRR(E1_ - E2_ , P1_ + -1*P2_ ),\n SRR(-E1_ , -1*P1_ ),\n\n SRR(E1_ / E2_ , P1_ * pow(P2_,-1) ),\n\n /*\n SRR(E1_ + (E2_ + E3_) , P1_ + P2_ + P3_ ),\n SRR( E1_ + (E2_ + E3_) + E4_ , P1_ + P2_ + P3_ + P4_ ),\n\n SRR(E1_ * (E2_ * E3_) , P1_ * P2_ * P3_ ),\n SRR( E1_ * (E2_ * E3_) * E4_ , P1_ * P2_ * P3_ * P4_ ),\n */\n toptr(pluschain,true),\n toptr(multiplieschain,true),\n toptr(pluschain),\n toptr(multiplieschain),\n toptr(),\n /*\n toptr(),\n toptr(),\n toptr(),\n toptr(),\n */\n\n // some of these are only true \"almost everywhere\"\n // and might need to be removed for some applications\n // (or, we need a \"domain\" to be propagated with the expr)\n //\n SRR( 0 + E1_ , P1_ ),\n SRR( -0 + E1_ , P1_ ),\n SRR( 1 * E1_ , P1_ ),\n SRR( 0 * E1_ , scalar(0) ),\n SRR( -0 * E1_ , scalar(0) ),\n SRR( pow(E1_,1) , P1_ ),\n SRR( pow(1,E1_) , scalar(1) ),\n SRR( pow(0,E1_) , ifthenelse(P1_,\n\t\t\t\tscalar(std::numeric_limits::infinity()),\n\t\t\t\tscalar(0)) ),\n SRR( pow(E1_,0) , scalar(1) ),\n\n SRR( E1_ + E1_ , 2*P1_ ),\n SRR( E1_ + E1_ + E2_ , 2*P1_ + P2_ ),\n\n SRR( E1_ * E1_ , pow(P1_,2) ),\n SRR( E1_ * E1_ * E2_ , pow(P1_,2)*P2_ ),\n\n SRR( log(pow(E1_,E2_)) , P2_*log(P1_) ),\n SRR( log(E1_*E2_) , log(P1_) + log(P2_) ),\n\n SRR( (W2_ + W3_)*E1_ , P1_*P2_ + P1_*P3_ ),\n SRR( (K2_ + W3_)*E1_ , P1_*P2_ + P1_*P3_ ),\n SRR( (W2_ + K3_)*E1_ , P1_*P2_ + P1_*P3_ ),\n\n SRR( K1_*E2_ + K3_*E2_ , (P1_+P3_) * P2_ ),\n SRR( K1_*E2_ + K3_*E2_ + E4_ , (P1_+P3_) * P2_ + P4_ ),\n SRR( E2_ + K3_*E2_ , (scalar(1)+P3_) * P2_ ),\n SRR( E2_ + K3_*E2_ + E4_ , (scalar(1)+P3_) * P2_ + P4_ ),\n\n SRR( pow(E1_,E2_) * pow(E1_,E3_) , pow(P1_,P2_+P3_) ),\n SRR( pow(E1_,E2_) * pow(E1_,E3_) * E4_ , pow(P1_,P2_+P3_)*P4_ ),\n SRR( E1_ * pow(E1_,E3_) , pow(P1_,scalar(1)+P3_) ),\n SRR( E1_ * pow(E1_,E3_) * E4_ , pow(P1_,scalar(1)+P3_)*P4_ ),\n\n SRR( pow(pow(W1_,E2_),E3_) , pow(P1_,P2_*P3_) ),\n SRR( pow(pow(K1_,W2_),W3_) , pow(P1_,P2_*P3_) ),\n SRR( pow(pow(K1_,W2_),K3_) , pow(pow(P1_,P3_),P2_) ),\n SRR( pow(K1_,K2_*E3_) , pow(pow(P1_,P2_),P3_) ),\n\n SRR( pow(E1_*W2_,E3_) , pow(P1_,P3_)*pow(P2_,P3_) ),\n SRR( pow(W1_*E2_,E3_) , pow(P1_,P3_)*pow(P2_,P3_) ),\n SRR( pow(K1_,E3_)*pow(K2_,E3_) , pow(P1_*P2_,P3_) ),\n\n\n SRR( log(ifthenelse(E1_,E2_,E3_)) , ifthenelse(P1_,log(P2_),log(P3_)) ),\n\n SRR( abs(E1_) , P1_ ,\n [](const exprmap &m) { return isnonneg(m.at(1)); } ),\n\n SRR( abs(E1_) , -P1_ ,\n [](const exprmap &m) { return isnonpos(m.at(1)); } ),\n\t }};\n\nruleset derivscalarrules{{\n SRR( deriv(E1_,V2_,V3_) , scalar(0),\n [](const exprmap &m) { return isconstexpr(m.at(1),getvar(m.at(2))); }),\n SRR( deriv(V1_,V1_,V3_) , scalar(1) ),\n\n SRR( deriv(E1_+E2_,V3_,V4_) ,\n\t\t deriv(P1_,P3_,P4_) + deriv(P2_,P3_,P4_) ),\n\n SRR( deriv(E1_*E2_,V3_,V4_) ,\n\t\t deriv(P1_,P3_,P4_)*evalat(P2_,P3_,P4_)\n\t\t + evalat(P1_,P3_,P4_)* deriv(P2_,P3_,P4_) ),\n\n SRR( deriv(pow(E1_,E2_),V3_,V4_) ,\n\t evalat(pow(P1_,P2_),P3_,P4_)*evalat(log(P1_),P3_,P4_)*deriv(P2_,P3_,P4_)\n + evalat(P2_,P3_,P4_)*evalat(pow(P1_,P2_-1),P3_,P4_)*deriv(P1_,P3_,P4_) ),\n\n SRR( deriv(log(E1_),V2_,V3_) ,\n\t\t deriv(P1_,P2_,P3_) / evalat(P1_,P2_,P3_) ),\n\n SRR( deriv(abs(E1_),V2_,V3_) ,\n\t\t deriv(P1_,P2_,P3_)*ifthenelse(P1_,scalar(-1),scalar(1)) ),\n\n SRR( deriv(expr{heavisideop,E1_},V2_,V3_),\n\t\t\t\t evalat(expr{diracop,P1_},P2_,P3_)*deriv(P1_,P2_,P3_) ),\n\n // not sure this is right with diracop\n SRR( deriv(ifthenelse(E1_,E2_,E3_),V4_,V5_) ,\n\t\t evalat(expr{diracop,P1_},P4_,P5_)*deriv(P1_,P4_,P5_)*(E2_-E3_)\n\t\t + ifthenelse(P1_,deriv(P2_,P4_,P5_),deriv(P3_,P4_,P5_)) ),\n\n SRR( deriv(ifeqthenelse(E1_,E2_,E3_),V4_,V5_) ,\n\t\t ifeqthenelse(evalat(P1_,P4_,P5_),\n\t\t\t deriv(P2_,P4_,P5_),deriv(P3_,P4_,P5_)) ),\n\n SRR( deriv(integrate(E1_,E2_,E3_,E4_),E5_,E6_) ,\n\t\t integrate(deriv(P1_,P5_,P6_),P2_,\n\t\t\t\t\tevalat(P3_,P5_,P6_),evalat(P4_,P5_,P6_))\n\t\t + deriv(P4_,P5_,P6_)*evalat(evalat(P1_,P2_,P4_),P5_,P6_)\n\t\t - deriv(P3_,P5_,P6_)*evalat(evalat(P1_,P2_,P3_),P5_,P6_) ),\n}};\n\nruleset integralscalarrules {{\n SRR( integrate(E1_+E2_,E3_,E4_,E5_), integrate(P1_,P3_,P4_,P5_) + integrate(P2_,P3_,P4_,P5_) ),\n\n SRR( integrate(E1_*E2_,E3_,E4_,E5_), P1_ * integrate(P2_,P3_,P4_,P5_) ,\n \t\t[](const exprmap &m) { return isconstexpr(m.at(1),getvar(m.at(3))); } ),\n\n SRR( integrate(E1_*E2_,E3_,E4_,E5_), integrate(P1_,P3_,P4_,P5_) * P2_ ,\n \t\t[](const exprmap &m) { return isconstexpr(m.at(2),getvar(m.at(3))); } ),\n\n SRR( integrate(ifthenelse(E1_+E2_*E3_,E4_,E5_),E3_,E6_,E7_) ,\n\t\t ifthenelse(-P1_/P2_ - P6_,\n\t\t\t \t\tintegrate(P5_,P3_,P6_,P7_),\n\t\t\t\t\tifthenelse(-P1_/P2_ - P7_,\n\t\t\t\t\t\tintegrate(P5_,P3_,P6_,-P1_/P2_)\n\t\t\t\t\t\t+ integrate(P4_,P3_,-P1_/P2_,P7_),\n\t\t\t\t\t\tintegrate(P4_,P3_,P6_,P7_))),\n\t\t [](const exprmap &m) { \n\t\t \treturn isconstexpr(m.at(1),getvar(m.at(3)))\n\t\t\t\t\t&& isconstexpr(m.at(2),getvar(m.at(3))); } ),\n\n toptr(stdantiderivs),\n\n SRR( sum(E1_,V2_,E3_,E4_) , scalar(0),\n\t\t [](const exprmap &m) { return isneg(E4_-E3_); } ),\n SRR( prod(E1_,V2_,E3_,E4_) , scalar(1),\n\t\t [](const exprmap &m) { return isneg(E4_-E3_); } ),\n\n // perhaps need \"max(0,P4_-P3_+1)\"??\n SRR( sum(E1_,V2_,E3_,E4_) , P1_*(P4_-P3_+1),\n [](const exprmap &m) { return isconstexpr(m.at(1),getvar(m.at(2))); } ),\n\n SRR( sum(E1_*E2_,V3_,E4_,E5_) , P1_*sum(P2_,P3_,P4_,P5_),\n\t [](const exprmap &m) { return isconstexpr(m.at(1),getvar(m.at(3))); } ),\n SRR( sum(E1_*E2_,V3_,E4_,E5_) , sum(P1_,P3_,P4_,P5_)*P2_,\n\t [](const exprmap &m) { return isconstexpr(m.at(2),getvar(m.at(3))); } ),\n}};\n\nruleset sumprodscalarrules {{\n toptr>(3,sumop,pluschain,0),\n toptr>(3,prodop,multiplieschain,1),\n\n SRR( sum(V2_,V2_,E3_,E4_) , ifthenelse(P4_-P3_,scalar(0),(P4_+1-P3_)*(P4_+P3_)/2) ),\n SRR( sum((V2_+E1_),V2_,E3_,E4_) , ifthenelse(P4_-P3_,scalar(0),(P4_+1-P3_)*(P4_+P3_+2*P1_)/2) ,\n\t [](const exprmap &m) { return isconstexpr(m.at(1),getvar(m.at(2))); } ),\n\n SRR( sum(pow(V2_,2),V2_,E3_,E4_) \n\t , ifthenelse(P4_-P3_,scalar(0),scalarreal{1,6}*(P4_-P3_+1) + scalarreal{1,2}*(pow(P4_,2)-pow(P3_-1,2))\n\t \t\t+ scalarreal{1,3}*(pow(P4_,3)-pow(P3_-1,3))) ),\n SRR( sum(pow(V2_+E1_,2),V2_,E3_,E4_) \n\t , ifthenelse(P4_-P3_,scalar(0),scalarreal{1,6}*(P4_-P3_+1) + scalarreal{1,2}*(pow(P4_,2)-pow(P3_-1,2))\n\t \t\t+ scalarreal{1,3}*(pow(P4_,3)-pow(P3_-1,3))\n\t\t\t+ pow(P1_,2)*(P4_-P3_) + P1_*(pow(P4_,2)-pow(P3_,2)) ),\n\t [](const exprmap &m) { return isconstexpr(m.at(1),getvar(m.at(2))); } ),\n\n // Faulhaber's formula\n SRR( sum(pow(V1_,E2_),V1_,E3_,E4_) ,\n\t//\t \t\t\t(B(P2_+1,P4_+1) - B(P2_+1,P3_+1))/(P2_+1) ,\n\t\tifthenelse(P4_-P3_,scalar(0),psum(P2_,P4_) - psum(P2_,P3_-1)),\n \t[](const exprmap &m) { return isconstexpr(m.at(2),getvar(m.at(1))); } ),\n SRR( sum(pow((V1_+E5_),E2_),V1_,E3_,E4_) ,\n\t//\t \t\t\t(B(P2_+1,P4_+1) - B(P2_+1,P3_+1))/(P2_+1) ,\n\t\tifthenelse(P4_-P3_,scalar(0),psum(P2_,P4_+P5_) - psum(P2_,P3_+P5_-1)),\n \t[](const exprmap &m) { return isconstexpr(m.at(2),getvar(m.at(1)))\n\t\t\t\t&& isconstexpr(m.at(5),getvar(m.at(1))); } ),\n}};\n\nruleset numericevalrules {{\n\t\t toptr(),\n\t }};\n\nruleset scalarruleset = basicscalarrules\n\t\t\t+ derivscalarrules\n\t\t\t+ integralscalarrules\n\t\t\t+ sumprodscalarrules\n\t\t\t+ numericevalrules;\n#endif\n", "meta": {"hexsha": "a9a12d3ec4e48c18a3505dce11d6a9aa80a54d49", "size": 28262, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "scalarrewrite.hpp", "max_stars_repo_name": "cshelton/tqscas", "max_stars_repo_head_hexsha": "404fc79993571fe0c844bfca964eec5484e3b307", "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": "scalarrewrite.hpp", "max_issues_repo_name": "cshelton/tqscas", "max_issues_repo_head_hexsha": "404fc79993571fe0c844bfca964eec5484e3b307", "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": "scalarrewrite.hpp", "max_forks_repo_name": "cshelton/tqscas", "max_forks_repo_head_hexsha": "404fc79993571fe0c844bfca964eec5484e3b307", "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.3278301887, "max_line_length": 125, "alphanum_fraction": 0.5703418017, "num_tokens": 9926, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7025300573952054, "lm_q2_score": 0.6370307944803832, "lm_q1q2_score": 0.4475332806088169}} {"text": "#include \n#include \n#include \n#include \"HartreeFock.hh\"\n#include \"HFConverger.hh\"\n#include \"exceptions.hh\"\n\nconst int HartreeFock::default_max_iter = 100;\nconst double HartreeFock::default_tolerance = 1.e-10;\n\nHartreeFock::HartreeFock(): _max_iter(default_max_iter),\n\t_tolerance(default_tolerance), _conv_method(\"diis\"), _status(),\n\t_orbitals(), _orb_ener(), _density() {}\n\nHartreeFock::HartreeFock(const Basis& basis, const Geometry& geometry,\n\tint multiplicity, bool restricted): _max_iter(default_max_iter),\n\t_tolerance(default_tolerance), _conv_method(\"diis\"), _status(),\n\t_orbitals(), _orb_ener(), _density()\n{\n\titerate(basis, geometry, multiplicity, restricted);\n}\n\nvoid HartreeFock::iterate(const Basis& basis, const Geometry& geometry,\n\tint multiplicity, bool restricted)\n{\n\t_status.reset();\n\t_restricted = restricted;\n\tsetMultiplicity(geometry, multiplicity);\n\n\tdouble nuc_rep = geometry.nuclearRepulsion();\n\tstd::cout << \"nuclear repulsion = \" << nuc_rep << \"\\n\";\n\n\tEigen::MatrixXd H = basis.kineticEnergy()\n\t\t+ basis.nuclearAttraction(geometry.positions(), geometry.charges());\n\tconst Eigen::MatrixXd& S = basis.overlap();\n\n\tif (restricted)\n\t\titerateRestricted(basis, H, S, nuc_rep);\n\telse\n\t\titerateUnrestricted(basis, H, S, nuc_rep);\n}\n\nvoid HartreeFock::iterateRestricted(const Basis& basis,\n\tconst Eigen::MatrixXd& H, const Eigen::MatrixXd& S,\n\tdouble nuc_rep)\n{\n\tcalcOrbitals(H, S);\n\n\t_energy = nuc_rep;\n\tif (_nr_double > 0) _energy += 2 * _orb_ener.head(_nr_double).sum();\n\tif (_nr_single > 0) _energy += _orb_ener.segment(_nr_double, _nr_single).sum();\n\tstd::cout << \"Energy: \" << _energy << \"\\n\";\n\n\tEigen::MatrixXd J, K;\n\tHFConverger::Ptr converger = HFConverger::create(_conv_method, *this,\n\t\tbasis);\n\tfor (int iter = 0; iter < _max_iter; ++iter)\n\t{\n\t\tdouble last_energy = _energy;\n\t\t\n\t\tconst Eigen::MatrixXd& D = density();\n\t\tbasis.twoElectron(D, J, K);\n\t\t_energy = (H + 0.5*(J - 0.5*K)).cwiseProduct(D).sum() + nuc_rep;\n\t\tstd::cout << std::setw(3) << iter << \" \"\n\t\t\t<< std::setw(20) << std::setprecision(15) << std::fixed << _energy << \" \"\n\t\t\t<< std::setw(13) << std::setprecision(6) << std::scientific << converger->error()\n\t\t\t<< \"\\n\";\n\t\t//std::cout << \"orbital energies: \" << _orb_ener.transpose() << \"\\n\";\n\n\t\tif (std::abs(_energy - last_energy) < _tolerance)\n\t\t{\n\t\t\t_status.set(ENERGY_CONVERGED);\n\t\t\treturn;\n\t\t}\n\n\t\tEigen::MatrixXd F = H + J - 0.5*K;\n\t\tconverger->step(F, _energy);\n\t\tcalcOrbitals(F, S);\n\t}\n\t\n\tthrow NoConvergence();\n}\n\nvoid HartreeFock::iterateUnrestricted(const Basis& basis,\n\tconst Eigen::MatrixXd& H, const Eigen::MatrixXd& S,\n\tdouble nuc_rep)\n{\n\tint nr_func = basis.size();\n\n\tcalcOrbitals(H, H, S);\t\n\t_energy = nuc_rep + _orb_ener.head(_nr_alpha).sum()\n\t\t+ _orb_ener.segment(nr_func, _nr_beta).sum();\n\tstd::cout << \"Energy: \" << _energy << \"\\n\";\n\n\tEigen::MatrixXd Ja, Ka, Jb, Kb;\n\tHFConverger::Ptr converger = HFConverger::create(_conv_method, *this,\n\t\tbasis);\n\tfor (int iter = 0; iter < _max_iter; ++iter)\n\t{\n\t\tdouble last_energy = _energy;\n\n\t\tEigen::MatrixXd::ConstColsBlockXpr Da = density().leftCols(nr_func);\n\t\tEigen::MatrixXd::ConstColsBlockXpr Db = density().rightCols(nr_func);\n\t\tbasis.twoElectron(Da, Ja, Ka);\n\t\tbasis.twoElectron(Db, Jb, Kb);\n\n\t\tdouble energyA = (H + 0.5*(Ja+Jb-Ka)).cwiseProduct(Da).sum();\n\t\tdouble energyB = (H + 0.5*(Ja+Jb-Kb)).cwiseProduct(Db).sum();\n\t\t_energy = energyA + energyB + nuc_rep;\n\n\t\tstd::cout << std::setw(3) << iter << \" \"\n\t\t\t<< std::setw(20) << std::setprecision(15) << std::fixed << _energy << \" \"\n\t\t\t<< std::setw(13) << std::setprecision(6) << std::scientific << converger->error() << \"\\n\";\n\t\t//std::cout << \"orbital energies: \" << _orb_ener.transpose() << \"\\n\";\n\n\t\tif (std::abs(_energy - last_energy) < _tolerance)\n\t\t{\n\t\t\t_status.set(ENERGY_CONVERGED);\n\t\t\treturn;\n\t\t}\n\n\t\tEigen::MatrixXd Fa = H + Ja + Jb - Ka;\n\t\tEigen::MatrixXd Fb = H + Ja + Jb - Kb;\n\t\tconverger->step(Fa, Fb, _energy);\n\t\tcalcOrbitals(Fa, Fb, S);\n\t}\n\n\tthrow NoConvergence();\n}\n\ndouble HartreeFock::energy()\n{\n\treturn _energy;\n}\n\nvoid HartreeFock::setMultiplicity(const Geometry& geometry, int multiplicity)\n{\n\tint nr_elec = geometry.totalCharge();\n\n\tif (multiplicity < 1)\n\t\t// Use lowest possible spin multiplicity\n\t\tmultiplicity = 1 + nr_elec % 2;\n\telse if (nr_elec % 2 == multiplicity % 2 || multiplicity > nr_elec+1)\n\t\tthrow Li::Exception(\"Multiplicity does not match number of electrons\");\n\n\t_nr_single = multiplicity - 1;\n\t_nr_double = (nr_elec - _nr_single) / 2;\n\tif (!_restricted)\n\t{\n\t\t_nr_alpha = _nr_double + _nr_single;\n\t\t_nr_beta = _nr_double;\n\t}\n}\n\nvoid HartreeFock::calcDensity()\n{\n\tif (!_status.test(ORBITALS_CURRENT))\n\t\tthrow Li::Exception(\"No orbitals to compute density matrix with\");\n\n\tint nr_func = _orbitals.rows();\n\tif (_restricted)\n\t{\n\t\t_density.resize(nr_func, nr_func);\n\t\tfor (int j = 0; j < nr_func; j++)\n\t\t{\n\t\t\tfor (int i = 0; i <= j; i++)\n\t\t\t{\n\t\t\t\tdouble sum = 0.0;\n\t\t\t\tif (_nr_double)\n\t\t\t\t\tsum += 2 * _orbitals.row(i).head(_nr_double).dot(\n\t\t\t\t\t\t_orbitals.row(j).head(_nr_double));\n\t\t\t\tif (_nr_single)\n\t\t\t\t\tsum += _orbitals.row(i).segment(_nr_double, _nr_single).dot(\n\t\t\t\t\t\t_orbitals.row(j).segment(_nr_double, _nr_single));\n\t\t\t\t_density(j,i) = _density(i,j) = sum;\n\t\t\t}\n\t\t}\n }\n else\n\t{\n\t\t_density.resize(nr_func, 2*nr_func);\n\t\tif (_nr_alpha == 0)\n\t\t{\n\t\t\t_density.leftCols(nr_func).setZero();\n\t\t}\n\t\telse\n\t\t{\n\t\t\tEigen::MatrixXd::ColsBlockXpr occ\n\t\t\t\t= _orbitals.leftCols(_nr_alpha);\n\t\t\t_density.leftCols(nr_func) = occ * occ.transpose();\n\t\t}\n\t\tif (_nr_beta == 0)\n\t\t{\n\t\t\t_density.rightCols(nr_func).setZero();\n\t\t}\n\t\telse\n\t\t{\n\t\t\tEigen::Block occ\n\t\t\t\t= _orbitals.block(0, nr_func, nr_func, _nr_beta);\n\t\t\t_density.rightCols(nr_func) = occ * occ.transpose();\n\t\t}\n\t}\n\n\t_status.set(DENSITY_CURRENT);\n}\n\nvoid HartreeFock::calcOrbitals(const Eigen::MatrixXd& F,\n\tconst Eigen::MatrixXd& S)\n{\n\tEigen::GeneralizedSelfAdjointEigenSolver solver(F, S);\n\t_orbitals = solver.eigenvectors();\n\t_orb_ener = solver.eigenvalues();\n\t_status.set(ORBITALS_CURRENT);\n\t_status.reset(DENSITY_CURRENT);\n}\n\nvoid HartreeFock::calcOrbitals(const Eigen::MatrixXd& Fa,\n\tconst Eigen::MatrixXd& Fb, const Eigen::MatrixXd& S)\n{\n\tint nr_func = S.rows();\n\t_orbitals.resize(nr_func, 2*nr_func);\n\t_orb_ener.resize(2*nr_func);\n\n\tEigen::GeneralizedSelfAdjointEigenSolver solver(Fa, S);\n\t_orbitals.leftCols(nr_func) = solver.eigenvectors();\n\t_orb_ener.head(nr_func) = solver.eigenvalues();\n\tsolver.compute(Fb, S);\n\t_orbitals.rightCols(nr_func) = solver.eigenvectors();\n\t_orb_ener.tail(nr_func) = solver.eigenvalues();\n\n\t_status.set(ORBITALS_CURRENT);\n\t_status.reset(DENSITY_CURRENT);\n}", "meta": {"hexsha": "3288dfb4e667c131d115c55bfc0515015fb28798", "size": 6628, "ext": "cc", "lang": "C++", "max_stars_repo_path": "HartreeFock.cc", "max_stars_repo_name": "gvissers/quill2", "max_stars_repo_head_hexsha": "589d7bc3ce20da888547f8f4f6b8da908b3d63a5", "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": "HartreeFock.cc", "max_issues_repo_name": "gvissers/quill2", "max_issues_repo_head_hexsha": "589d7bc3ce20da888547f8f4f6b8da908b3d63a5", "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": "HartreeFock.cc", "max_forks_repo_name": "gvissers/quill2", "max_forks_repo_head_hexsha": "589d7bc3ce20da888547f8f4f6b8da908b3d63a5", "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.4463519313, "max_line_length": 93, "alphanum_fraction": 0.6789378395, "num_tokens": 2090, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7853085909370421, "lm_q2_score": 0.5698526514141571, "lm_q1q2_score": 0.4475101827237891}} {"text": "/*\n * BSD 2-Clause License\n *\n * Copyright (c) 2020, Christoph Neuhauser\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#include \n#include \n\n#include \n#include \n\n#include \n#include \n\n#include \"Utils/TriangleNormals.hpp\"\n#include \"StressTrajectoriesDatLoader.hpp\"\n\n#ifdef USE_EIGEN\n#include \n\nvoid computePrincipalStresses(\n float xx, float yy, float zz, float xy, float yz, float zx,\n float& majorStress, float& mediumStress, float& minorStress/*,\n glm::vec3& v0, glm::vec3& v1, glm::vec3& v2*/) {\n Eigen::Matrix3f stressTensor;\n stressTensor.row(0) << xx, xy, zx;\n stressTensor.row(1) << xy, yy, yz;\n stressTensor.row(2) << zx, yz, zz;\n\n Eigen::SelfAdjointEigenSolver selfAdjointEigenSolver;\n selfAdjointEigenSolver.compute(stressTensor);\n Eigen::Vector3f eigenvalues = selfAdjointEigenSolver.eigenvalues();\n /*Eigen::Matrix3f eigenvectors = selfAdjointEigenSolver.eigenvectors();\n v0 = glm::vec3(eigenvectors(0, 0), eigenvectors(1, 0), eigenvectors(2, 0));\n v1 = glm::vec3(eigenvectors(0, 1), eigenvectors(1, 1), eigenvectors(2, 1));\n v2 = glm::vec3(eigenvectors(0, 2), eigenvectors(1, 2), eigenvectors(2, 2));*/\n\n minorStress = eigenvalues(0);\n mediumStress = eigenvalues(1);\n majorStress = eigenvalues(2);\n}\n\nfloat computeDegeneracyMeasure(float sigma1, float sigma2, float sigma3) {\n float degeneracyMeasure = 0.5f * std::abs((sigma1 - sigma2) / (sigma1 + sigma2));\n degeneracyMeasure = std::min(degeneracyMeasure, 0.5f * std::abs((sigma3 - sigma2) / (sigma3 + sigma2)));\n return degeneracyMeasure;\n}\n#endif\n\nvoid loadStressLineHierarchyFromDat(\n const std::vector& filenamesHierarchy,\n std::vector& stressTrajectoriesDataPs) {\n size_t psIdx = 0;\n for (size_t fileIdx = 0; fileIdx < filenamesHierarchy.size(); fileIdx++) {\n const std::string& filename = filenamesHierarchy.at(fileIdx);\n\n sgl::LineReader lineReader(filename);\n while (lineReader.isLineLeft()) {\n assert(psIdx < stressTrajectoriesDataPs.size());\n StressTrajectoriesData& stressTrajectoriesData = stressTrajectoriesDataPs.at(psIdx);\n std::vector linesInfo = lineReader.readVectorLine();\n // Line metadata saved?\n uint32_t numLines = 0;\n if (linesInfo.size() == 1) {\n numLines = sgl::fromString(linesInfo.at(0));\n } else if (linesInfo.size() == 2) {\n numLines = sgl::fromString(linesInfo.at(1));\n } else {\n sgl::Logfile::get()->writeError(\n std::string() + \"ERROR in loadStressLineHierarchyFromDat: Invalid line metadata in file \\\"\"\n + filename + \"\\\".\");\n }\n assert(stressTrajectoriesData.size() == numLines);\n for (uint32_t lineIdx = 0; lineIdx < numLines; lineIdx++) {\n StressTrajectoryData& stressTrajectoryData = stressTrajectoriesData.at(lineIdx);\n float lineHierarchyLevel = lineReader.readScalarLine();\n stressTrajectoryData.hierarchyLevels.push_back(lineHierarchyLevel);\n }\n\n psIdx++;\n }\n }\n}\n\nvoid loadStressTrajectoriesFromDat_v1(\n const std::vector& filenamesTrajectories,\n const std::vector& filenamesHierarchy,\n std::vector& loadedPsIndices,\n std::vector& trajectoriesPs,\n std::vector& stressTrajectoriesDataPs) {\n trajectoriesPs.reserve(filenamesTrajectories.size());\n stressTrajectoriesDataPs.reserve(filenamesTrajectories.size());\n size_t geometryByteSize = 0;\n\n size_t psIdx = 0;\n for (size_t fileIdx = 0; fileIdx < filenamesTrajectories.size(); fileIdx++) {\n const std::string& filename = filenamesTrajectories.at(fileIdx);\n\n sgl::LineReader lineReader(filename);\n while (lineReader.isLineLeft()) {\n Trajectories trajectories;\n StressTrajectoriesData stressTrajectoriesData;\n std::vector linesInfo = lineReader.readVectorLine();\n // Line metadata saved?\n uint32_t numLines = 0;\n if (linesInfo.size() == 1) {\n numLines = sgl::fromString(linesInfo.at(0));\n } else if (linesInfo.size() == 2) {\n numLines = sgl::fromString(linesInfo.at(1));\n boost::algorithm::to_lower(linesInfo.at(0));\n if (boost::ends_with(linesInfo.at(0), \"major\")) {\n loadedPsIndices.push_back(0);\n } else if (boost::ends_with(linesInfo.at(0), \"medium\")) {\n loadedPsIndices.push_back(1);\n } else if (boost::ends_with(linesInfo.at(0), \"minor\")) {\n loadedPsIndices.push_back(2);\n } else {\n sgl::Logfile::get()->writeError(\n std::string() + \"ERROR in loadStressTrajectoriesFromDat_: \"\n + \"Invalid principal stress identifier \\\"\" + linesInfo.at(0) + \"\\\".\");\n }\n } else {\n sgl::Logfile::get()->writeError(\n std::string() + \"ERROR in loadStressTrajectoriesFromDat_v1: Invalid line metadata in file \\\"\"\n + filename + \"\\\".\");\n }\n trajectories.resize(numLines);\n stressTrajectoriesData.resize(numLines);\n for (uint32_t lineIdx = 0; lineIdx < numLines; lineIdx++) {\n Trajectory& trajectory = trajectories.at(lineIdx);\n StressTrajectoryData& stressTrajectoryData = stressTrajectoriesData.at(lineIdx);\n\n uint32_t lineLength = lineReader.readScalarLine();\n trajectory.positions.reserve(lineLength);\n stressTrajectoryData.majorPs.reserve(lineLength);\n stressTrajectoryData.mediumPs.reserve(lineLength);\n stressTrajectoryData.minorPs.reserve(lineLength);\n stressTrajectoryData.majorPsDir.reserve(lineLength);\n stressTrajectoryData.mediumPsDir.reserve(lineLength);\n stressTrajectoryData.minorPsDir.reserve(lineLength);\n trajectory.attributes.resize(2);\n trajectory.attributes.front().reserve(lineLength);\n std::vector positionData = lineReader.readVectorLine(lineLength * 3);\n std::vector psData = lineReader.readVectorLine(lineLength * 12);\n std::vector vonMisesData = lineReader.readVectorLine(lineLength);\n\n for (uint32_t pointIdx = 0; pointIdx < lineLength; pointIdx++) {\n trajectory.positions.push_back(glm::vec3(\n positionData.at(pointIdx * 3),\n positionData.at(pointIdx * 3 + 1),\n positionData.at(pointIdx * 3 + 2)));\n stressTrajectoryData.majorPs.push_back(psData.at(pointIdx * 12));\n stressTrajectoryData.majorPsDir.push_back(glm::vec3(\n psData.at(pointIdx * 12 + 1),\n psData.at(pointIdx * 12 + 2),\n psData.at(pointIdx * 12 + 3)));\n stressTrajectoryData.mediumPs.push_back(psData.at(pointIdx * 12 + 4));\n stressTrajectoryData.mediumPsDir.push_back(glm::vec3(\n psData.at(pointIdx * 12 + 5),\n psData.at(pointIdx * 12 + 6),\n psData.at(pointIdx * 12 + 7)));\n stressTrajectoryData.minorPs.push_back(psData.at(pointIdx * 12 + 8));\n stressTrajectoryData.minorPsDir.push_back(glm::vec3(\n psData.at(pointIdx * 12 + 9),\n psData.at(pointIdx * 12 + 10),\n psData.at(pointIdx * 12 + 11)));\n trajectory.attributes.at(0).push_back(vonMisesData.at(pointIdx));\n if (psIdx == 0) {\n trajectory.attributes.at(1).push_back(std::abs(stressTrajectoryData.majorPs.back()));\n } else if (psIdx == 1) {\n trajectory.attributes.at(1).push_back(std::abs(stressTrajectoryData.mediumPs.back()));\n } else {\n trajectory.attributes.at(1).push_back(std::abs(stressTrajectoryData.minorPs.back()));\n }\n }\n }\n\n for (size_t trajectoryIdx = 0; trajectoryIdx < trajectories.size(); trajectoryIdx++) {\n Trajectory& trajectory = trajectories.at(trajectoryIdx);\n StressTrajectoryData& stressTrajectoryData = stressTrajectoriesData.at(trajectoryIdx);\n geometryByteSize += trajectory.positions.size() * sizeof(float) * 3;\n geometryByteSize += sizeof(float); // hierarchy level\n geometryByteSize += stressTrajectoryData.majorPs.size() * sizeof(float);\n geometryByteSize += stressTrajectoryData.mediumPs.size() * sizeof(float);\n geometryByteSize += stressTrajectoryData.minorPs.size() * sizeof(float);\n geometryByteSize += stressTrajectoryData.majorPsDir.size() * sizeof(float) * 3;\n geometryByteSize += stressTrajectoryData.mediumPsDir.size() * sizeof(float) * 3;\n geometryByteSize += stressTrajectoryData.minorPsDir.size() * sizeof(float) * 3;\n for (const std::vector& attributes : trajectory.attributes) {\n geometryByteSize += attributes.size() * sizeof(float);\n }\n }\n\n trajectoriesPs.emplace_back(trajectories);\n stressTrajectoriesDataPs.emplace_back(stressTrajectoriesData);\n psIdx++;\n }\n }\n\n // Check if there's additional line hierarchy data.\n if (filenamesHierarchy.size() > 0) {\n loadStressLineHierarchyFromDat(filenamesHierarchy, stressTrajectoriesDataPs);\n }\n\n // Assume that all three PS directions are provided for the v1 .dat format.\n if (loadedPsIndices.size() == 0 && trajectoriesPs.size() == 3) {\n loadedPsIndices = {0, 1, 2};\n }\n\n std::cout << \"Size of line geometry data (MiB): \" << (geometryByteSize / (1024.0 * 1024.0)) << std::endl;\n}\n\nvoid loadStressTrajectoriesFromDat_v2(\n const std::vector& filenamesTrajectories,\n std::vector& loadedPsIndices,\n std::vector& trajectoriesPs,\n std::vector& stressTrajectoriesDataPs,\n std::vector>>& bandPointsListLeftPs,\n std::vector>>& bandPointsListRightPs) {\n trajectoriesPs.reserve(filenamesTrajectories.size());\n stressTrajectoriesDataPs.reserve(filenamesTrajectories.size());\n bandPointsListLeftPs.reserve(filenamesTrajectories.size());\n bandPointsListRightPs.reserve(filenamesTrajectories.size());\n size_t geometryByteSize = 0;\n\n size_t psIdx = 0;\n for (size_t fileIdx = 0; fileIdx < filenamesTrajectories.size(); fileIdx++) {\n const std::string& filename = filenamesTrajectories.at(fileIdx);\n\n sgl::LineReader lineReader(filename);\n while (lineReader.isLineLeft()) {\n Trajectories trajectories;\n StressTrajectoriesData stressTrajectoriesData;\n std::vector> bandPointsListLeft;\n std::vector> bandPointsListRight;\n std::vector linesInfo = lineReader.readVectorLine();\n // Line metadata saved?\n uint32_t numLines = 0;\n if (linesInfo.size() == 1) {\n numLines = sgl::fromString(linesInfo.at(0));\n } else if (linesInfo.size() == 2) {\n boost::algorithm::to_lower(linesInfo.at(0));\n if (boost::ends_with(linesInfo.at(0), \"major\")) {\n loadedPsIndices.push_back(0);\n } else if (boost::ends_with(linesInfo.at(0), \"medium\")) {\n loadedPsIndices.push_back(1);\n } else if (boost::ends_with(linesInfo.at(0), \"minor\")) {\n loadedPsIndices.push_back(2);\n } else {\n sgl::Logfile::get()->writeError(\n std::string() + \"ERROR in loadStressTrajectoriesFromDat_v2: \"\n + \"Invalid principal stress identifier \\\"\" + linesInfo.at(0) + \"\\\".\");\n }\n numLines = sgl::fromString(linesInfo.at(1));\n } else {\n sgl::Logfile::get()->writeError(\n std::string() + \"ERROR in loadStressTrajectoriesFromDat_v2: \"\n + \"Invalid line metadata in file \\\"\" + filename + \"\\\".\");\n }\n trajectories.resize(numLines);\n stressTrajectoriesData.resize(numLines);\n bandPointsListLeft.resize(numLines);\n bandPointsListRight.resize(numLines);\n for (uint32_t lineIdx = 0; lineIdx < numLines; lineIdx++) {\n Trajectory& trajectory = trajectories.at(lineIdx);\n StressTrajectoryData& stressTrajectoryData = stressTrajectoriesData.at(lineIdx);\n std::vector& bandPointsLeft = bandPointsListLeft.at(lineIdx);\n std::vector& bandPointsRight = bandPointsListRight.at(lineIdx);\n\n std::vector firstLineVector = lineReader.readVectorLine();\n if (firstLineVector.size() != 2) {\n sgl::Logfile::get()->writeError(\n std::string() + \"ERROR in loadStressTrajectoriesFromDat_v2: \"\n + \"Invalid per line metadata in file \\\"\" + filename + \"\\\".\");\n }\n uint32_t lineLength = sgl::fromString(firstLineVector.at(0));\n float hierarchyLevel = sgl::fromString(firstLineVector.at(1));\n stressTrajectoryData.hierarchyLevels.push_back(hierarchyLevel);\n trajectory.positions.reserve(lineLength);\n trajectory.attributes.resize(1);\n trajectory.attributes.front().reserve(lineLength);\n bandPointsLeft.reserve(lineLength);\n bandPointsRight.reserve(lineLength);\n std::vector positionData = lineReader.readVectorLine(lineLength * 3);\n std::vector bandVertexData = lineReader.readVectorLine(lineLength * 6);\n std::vector scalarFieldData = lineReader.readVectorLine(lineLength);\n\n for (uint32_t pointIdx = 0; pointIdx < lineLength; pointIdx++) {\n trajectory.positions.push_back(glm::vec3(\n positionData.at(pointIdx * 3),\n positionData.at(pointIdx * 3 + 1),\n positionData.at(pointIdx * 3 + 2)));\n bandPointsLeft.push_back(glm::vec3(\n bandVertexData.at(pointIdx * 6 + 0),\n bandVertexData.at(pointIdx * 6 + 1),\n bandVertexData.at(pointIdx * 6 + 2)));\n bandPointsRight.push_back(glm::vec3(\n bandVertexData.at(pointIdx * 6 + 3),\n bandVertexData.at(pointIdx * 6 + 4),\n bandVertexData.at(pointIdx * 6 + 5)));\n trajectory.attributes.at(0).push_back(scalarFieldData.at(pointIdx));\n }\n }\n\n for (size_t trajectoryIdx = 0; trajectoryIdx < trajectories.size(); trajectoryIdx++) {\n Trajectory& trajectory = trajectories.at(trajectoryIdx);\n StressTrajectoryData& stressTrajectoryData = stressTrajectoriesData.at(trajectoryIdx);\n geometryByteSize += trajectory.positions.size() * sizeof(float) * 3;\n geometryByteSize += sizeof(float); // hierarchy level\n geometryByteSize += stressTrajectoryData.majorPs.size() * sizeof(float);\n geometryByteSize += stressTrajectoryData.mediumPs.size() * sizeof(float);\n geometryByteSize += stressTrajectoryData.minorPs.size() * sizeof(float);\n geometryByteSize += stressTrajectoryData.majorPsDir.size() * sizeof(float) * 3;\n geometryByteSize += stressTrajectoryData.mediumPsDir.size() * sizeof(float) * 3;\n geometryByteSize += stressTrajectoryData.minorPsDir.size() * sizeof(float) * 3;\n for (const std::vector& attributes : trajectory.attributes) {\n geometryByteSize += attributes.size() * sizeof(float);\n }\n geometryByteSize += bandPointsListLeft.at(trajectoryIdx).size() * sizeof(float) * 3;\n geometryByteSize += bandPointsListRight.at(trajectoryIdx).size() * sizeof(float) * 3;\n }\n\n trajectoriesPs.emplace_back(trajectories);\n stressTrajectoriesDataPs.emplace_back(stressTrajectoriesData);\n bandPointsListLeftPs.emplace_back(bandPointsListLeft);\n bandPointsListRightPs.emplace_back(bandPointsListRight);\n psIdx++;\n }\n }\n\n std::cout << \"Size of line geometry data (MiB): \" << (geometryByteSize / (1024.0 * 1024.0)) << std::endl;\n}\n\n\n\nvoid parseOutlineMeshHull(\n sgl::LineReader& lineReader,\n std::vector& simulationMeshOutlineTriangleIndices,\n std::vector& simulationMeshOutlineVertexPositions) {\n std::vector numVerticesLine = lineReader.readVectorLine();\n if (numVerticesLine.size() != 2 || numVerticesLine.front() != \"#Vertices\") {\n sgl::Logfile::get()->writeError(\"Error in parseOutlineMeshHull: Invalid vertex information.\");\n }\n uint32_t numVertices = sgl::fromString(numVerticesLine.at(1));\n for (uint32_t vertexIdx = 0; vertexIdx < numVertices; vertexIdx++) {\n std::vector vertexPosition = lineReader.readVectorLine(3);\n assert(vertexPosition.size() == 3);\n simulationMeshOutlineVertexPositions.push_back(\n glm::vec3(vertexPosition.at(0), vertexPosition.at(1), vertexPosition.at(2)));\n }\n\n std::vector numFacesLine = lineReader.readVectorLine();\n if (numFacesLine.size() != 2 || numFacesLine.front() != \"#Faces\") {\n sgl::Logfile::get()->writeError(\"Error in parseOutlineMeshHull: Invalid face information.\");\n }\n uint32_t numFaces = sgl::fromString(numFacesLine.at(1));\n for (uint32_t faceIdx = 0; faceIdx < numFaces; faceIdx++) {\n std::vector faceIndices = lineReader.readVectorLine(4);\n assert(faceIndices.size() == 4);\n\n simulationMeshOutlineTriangleIndices.push_back(faceIndices.at(0));\n simulationMeshOutlineTriangleIndices.push_back(faceIndices.at(1));\n simulationMeshOutlineTriangleIndices.push_back(faceIndices.at(2));\n\n simulationMeshOutlineTriangleIndices.push_back(faceIndices.at(0));\n simulationMeshOutlineTriangleIndices.push_back(faceIndices.at(2));\n simulationMeshOutlineTriangleIndices.push_back(faceIndices.at(3));\n }\n}\n\nvoid loadStressTrajectoriesFromDat_v3(\n const std::vector& filenamesTrajectories,\n std::vector& loadedPsIndices, MeshType& meshType,\n std::vector& trajectoriesPs,\n std::vector& stressTrajectoriesDataPs,\n std::vector>>& bandPointsUnsmoothedListLeftPs,\n std::vector>>& bandPointsUnsmoothedListRightPs,\n std::vector>>& bandPointsSmoothedListLeftPs,\n std::vector>>& bandPointsSmoothedListRightPs,\n std::vector& simulationMeshOutlineTriangleIndices,\n std::vector& simulationMeshOutlineVertexPositions) {\n trajectoriesPs.reserve(filenamesTrajectories.size());\n stressTrajectoriesDataPs.reserve(filenamesTrajectories.size());\n bandPointsUnsmoothedListLeftPs.reserve(filenamesTrajectories.size());\n bandPointsUnsmoothedListRightPs.reserve(filenamesTrajectories.size());\n bandPointsSmoothedListLeftPs.reserve(filenamesTrajectories.size());\n bandPointsSmoothedListRightPs.reserve(filenamesTrajectories.size());\n size_t geometryByteSize = 0;\n\n size_t psIdx = 0;\n for (size_t fileIdx = 0; fileIdx < filenamesTrajectories.size(); fileIdx++) {\n const std::string& filename = filenamesTrajectories.at(fileIdx);\n\n sgl::LineReader lineReader(filename);\n while (lineReader.isLineLeft()) {\n Trajectories trajectories;\n StressTrajectoriesData stressTrajectoriesData;\n std::vector> bandPointsUnsmoothedListLeft;\n std::vector> bandPointsUnsmoothedListRight;\n std::vector> bandPointsSmoothedListLeft;\n std::vector> bandPointsSmoothedListRight;\n std::vector linesInfo = lineReader.readVectorLine();\n\n if (linesInfo.front() == \"#Outline\") {\n if (linesInfo.size() == 1) {\n meshType = MeshType::CARTESIAN;\n } else {\n if (linesInfo.at(1) == \"Cartesian\") {\n meshType = MeshType::CARTESIAN;\n } else {\n meshType = MeshType::UNSTRUCTURED;\n }\n }\n parseOutlineMeshHull(\n lineReader, simulationMeshOutlineTriangleIndices, simulationMeshOutlineVertexPositions);\n continue;\n }\n\n // Line metadata saved?\n uint32_t numLines = 0;\n if (linesInfo.size() == 1) {\n numLines = sgl::fromString(linesInfo.at(0));\n if (numLines == 0) {\n continue;\n }\n } else if (linesInfo.size() == 2) {\n numLines = sgl::fromString(linesInfo.at(1));\n if (numLines == 0) {\n continue;\n }\n boost::algorithm::to_lower(linesInfo.at(0));\n if (boost::ends_with(linesInfo.at(0), \"major\")) {\n loadedPsIndices.push_back(0);\n } else if (boost::ends_with(linesInfo.at(0), \"medium\")) {\n loadedPsIndices.push_back(1);\n } else if (boost::ends_with(linesInfo.at(0), \"minor\")) {\n loadedPsIndices.push_back(2);\n } else {\n sgl::Logfile::get()->writeError(\n std::string() + \"ERROR in loadStressTrajectoriesFromDat_v2: \"\n + \"Invalid principal stress identifier \\\"\" + linesInfo.at(0) + \"\\\".\");\n }\n } else {\n sgl::Logfile::get()->writeError(\n std::string() + \"ERROR in loadStressTrajectoriesFromDat_v2: \"\n + \"Invalid line metadata in file \\\"\" + filename + \"\\\".\");\n }\n trajectories.resize(numLines);\n stressTrajectoriesData.resize(numLines);\n bandPointsUnsmoothedListLeft.resize(numLines);\n bandPointsUnsmoothedListRight.resize(numLines);\n bandPointsSmoothedListLeft.resize(numLines);\n bandPointsSmoothedListRight.resize(numLines);\n for (uint32_t lineIdx = 0; lineIdx < numLines; lineIdx++) {\n Trajectory& trajectory = trajectories.at(lineIdx);\n StressTrajectoryData& stressTrajectoryData = stressTrajectoriesData.at(lineIdx);\n std::vector& bandPointsUnsmoothedLeft = bandPointsUnsmoothedListLeft.at(lineIdx);\n std::vector& bandPointsUnsmoothedRight = bandPointsUnsmoothedListRight.at(lineIdx);\n std::vector& bandPointsSmoothedLeft = bandPointsSmoothedListLeft.at(lineIdx);\n std::vector& bandPointsSmoothedRight = bandPointsSmoothedListRight.at(lineIdx);\n\n std::vector firstLineVector = lineReader.readVectorLine();\n if (firstLineVector.size() == 0) {\n sgl::Logfile::get()->writeError(\n std::string() + \"ERROR in loadStressTrajectoriesFromDat_v2: \"\n + \"Invalid per line metadata in file \\\"\" + filename + \"\\\".\");\n }\n uint32_t lineLength = sgl::fromString(firstLineVector.at(0));\n\n // Add the hierarchy levels.\n for (int hierarchyIdx = 1; hierarchyIdx < std::max(int(firstLineVector.size()), 5); hierarchyIdx++) {\n float hierarchyLevel = sgl::fromString(firstLineVector.at(hierarchyIdx));\n stressTrajectoryData.hierarchyLevels.push_back(hierarchyLevel);\n }\n if (firstLineVector.size() == 9) {\n stressTrajectoryData.appearanceOrder = sgl::fromString(firstLineVector.at(5)) - 1;\n stressTrajectoryData.seedPosition = glm::vec3(\n sgl::fromString(firstLineVector.at(6)),\n sgl::fromString(firstLineVector.at(7)),\n sgl::fromString(firstLineVector.at(8)));\n }\n\n trajectory.positions.reserve(lineLength);\n bandPointsUnsmoothedLeft.reserve(lineLength);\n bandPointsUnsmoothedRight.reserve(lineLength);\n bandPointsSmoothedLeft.reserve(lineLength);\n bandPointsSmoothedRight.reserve(lineLength);\n std::vector positionData = lineReader.readVectorLine(\n lineLength * 3);\n std::vector bandVertexDataUnsmoothed = lineReader.readVectorLine(\n lineLength * 6);\n std::vector bandVertexDataSmoothed = lineReader.readVectorLine(\n lineLength * 6);\n\n for (uint32_t pointIdx = 0; pointIdx < lineLength; pointIdx++) {\n trajectory.positions.emplace_back(\n positionData.at(pointIdx * 3),\n positionData.at(pointIdx * 3 + 1),\n positionData.at(pointIdx * 3 + 2));\n bandPointsUnsmoothedLeft.emplace_back(\n bandVertexDataUnsmoothed.at(pointIdx * 6 + 0),\n bandVertexDataUnsmoothed.at(pointIdx * 6 + 1),\n bandVertexDataUnsmoothed.at(pointIdx * 6 + 2));\n bandPointsUnsmoothedRight.emplace_back(\n bandVertexDataUnsmoothed.at(pointIdx * 6 + 3),\n bandVertexDataUnsmoothed.at(pointIdx * 6 + 4),\n bandVertexDataUnsmoothed.at(pointIdx * 6 + 5));\n bandPointsSmoothedLeft.emplace_back(\n bandVertexDataSmoothed.at(pointIdx * 6 + 0),\n bandVertexDataSmoothed.at(pointIdx * 6 + 1),\n bandVertexDataSmoothed.at(pointIdx * 6 + 2));\n bandPointsSmoothedRight.emplace_back(\n bandVertexDataSmoothed.at(pointIdx * 6 + 3),\n bandVertexDataSmoothed.at(pointIdx * 6 + 4),\n bandVertexDataSmoothed.at(pointIdx * 6 + 5));\n }\n\n#ifdef USE_EIGEN\n trajectory.attributes.resize(13);\n#else\n trajectory.attributes.resize(9);\n#endif\n\n // Principal stress.\n trajectory.attributes.at(0).reserve(lineLength);\n std::vector scalarFieldData = lineReader.readVectorLine(lineLength);\n for (uint32_t pointIdx = 0; pointIdx < lineLength; pointIdx++) {\n trajectory.attributes.at(0).push_back(scalarFieldData.at(pointIdx));\n }\n\n // Principal stress magnitude.\n for (uint32_t pointIdx = 0; pointIdx < lineLength; pointIdx++) {\n trajectory.attributes.at(1).push_back(std::abs(scalarFieldData.at(pointIdx)));\n }\n\n // Von Mises stress, normal stress (xx), normal stress (yy), normal stress (zz), shear stress (yz),\n // shear stress (zx), shear stress (xy).\n for (int varIdx = 2; varIdx < 9; varIdx++) {\n trajectory.attributes.at(varIdx).reserve(lineLength);\n std::vector scalarFieldData = lineReader.readVectorLine(lineLength);\n for (uint32_t pointIdx = 0; pointIdx < lineLength; pointIdx++) {\n trajectory.attributes.at(varIdx).push_back(scalarFieldData.at(pointIdx));\n }\n }\n\n#ifdef USE_EIGEN\n int xxIdx = 3;\n int yyIdx = 4;\n int zzIdx = 5;\n int xyIdx = 8;\n int yzIdx = 6;\n int zxIdx = 7;\n\n float majorStress, mediumStress, minorStress;\n //glm::vec3 v0, v1, v2;\n for (uint32_t pointIdx = 0; pointIdx < lineLength; pointIdx++) {\n computePrincipalStresses(\n trajectory.attributes.at(xxIdx).at(pointIdx),\n trajectory.attributes.at(yyIdx).at(pointIdx),\n trajectory.attributes.at(zzIdx).at(pointIdx),\n trajectory.attributes.at(xyIdx).at(pointIdx),\n trajectory.attributes.at(yzIdx).at(pointIdx),\n trajectory.attributes.at(zxIdx).at(pointIdx),\n majorStress, mediumStress, minorStress/*, v0, v1, v2*/);\n float degeneracyMeasure = computeDegeneracyMeasure(\n minorStress, mediumStress, majorStress);\n trajectory.attributes.at(9).push_back(majorStress);\n trajectory.attributes.at(10).push_back(mediumStress);\n trajectory.attributes.at(11).push_back(minorStress);\n trajectory.attributes.at(12).push_back(degeneracyMeasure);\n }\n#endif\n }\n\n for (size_t trajectoryIdx = 0; trajectoryIdx < trajectories.size(); trajectoryIdx++) {\n Trajectory& trajectory = trajectories.at(trajectoryIdx);\n StressTrajectoryData& stressTrajectoryData = stressTrajectoriesData.at(trajectoryIdx);\n geometryByteSize += trajectory.positions.size() * sizeof(float) * 3;\n geometryByteSize += sizeof(float); // hierarchy level\n geometryByteSize += stressTrajectoryData.majorPs.size() * sizeof(float);\n geometryByteSize += stressTrajectoryData.mediumPs.size() * sizeof(float);\n geometryByteSize += stressTrajectoryData.minorPs.size() * sizeof(float);\n geometryByteSize += stressTrajectoryData.majorPsDir.size() * sizeof(float) * 3;\n geometryByteSize += stressTrajectoryData.mediumPsDir.size() * sizeof(float) * 3;\n geometryByteSize += stressTrajectoryData.minorPsDir.size() * sizeof(float) * 3;\n for (const std::vector& attributes : trajectory.attributes) {\n geometryByteSize += attributes.size() * sizeof(float);\n }\n geometryByteSize += bandPointsUnsmoothedListLeft.at(trajectoryIdx).size() * sizeof(float) * 3;\n geometryByteSize += bandPointsUnsmoothedListRight.at(trajectoryIdx).size() * sizeof(float) * 3;\n geometryByteSize += bandPointsSmoothedListLeft.at(trajectoryIdx).size() * sizeof(float) * 3;\n geometryByteSize += bandPointsSmoothedListRight.at(trajectoryIdx).size() * sizeof(float) * 3;\n }\n\n trajectoriesPs.emplace_back(trajectories);\n stressTrajectoriesDataPs.emplace_back(stressTrajectoriesData);\n bandPointsUnsmoothedListLeftPs.emplace_back(bandPointsUnsmoothedListLeft);\n bandPointsUnsmoothedListRightPs.emplace_back(bandPointsUnsmoothedListRight);\n bandPointsSmoothedListLeftPs.emplace_back(bandPointsSmoothedListLeft);\n bandPointsSmoothedListRightPs.emplace_back(bandPointsSmoothedListRight);\n psIdx++;\n }\n }\n\n std::cout << \"Size of line geometry data (MiB): \" << (geometryByteSize / (1024.0 * 1024.0)) << std::endl;\n}\n", "meta": {"hexsha": "17f87b65fbabf3694e3974e774d96c49070296d7", "size": 34701, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/Loaders/StressTrajectoriesDatLoader.cpp", "max_stars_repo_name": "chrismile/ActionsTestRepo", "max_stars_repo_head_hexsha": "bcea39e6bf280c7c8e84ee5e0d8d9db6114d6add", "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/Loaders/StressTrajectoriesDatLoader.cpp", "max_issues_repo_name": "chrismile/ActionsTestRepo", "max_issues_repo_head_hexsha": "bcea39e6bf280c7c8e84ee5e0d8d9db6114d6add", "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/Loaders/StressTrajectoriesDatLoader.cpp", "max_forks_repo_name": "chrismile/ActionsTestRepo", "max_forks_repo_head_hexsha": "bcea39e6bf280c7c8e84ee5e0d8d9db6114d6add", "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": 55.080952381, "max_line_length": 117, "alphanum_fraction": 0.5997233509, "num_tokens": 7564, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7799929002541068, "lm_q2_score": 0.5736784074525098, "lm_q1q2_score": 0.4474650848420403}} {"text": "// Copyright (c) 2018 by University Paris-Est Marne-la-Vallee\n// MetaData.cpp\n// This file is part of the Garamon Generator.\n// Authors: Stephane Breuils and Vincent Nozick\n// Contact: vincent.nozick@u-pem.fr\n//\n// Licence MIT\n// A a copy of the MIT License is given along with this program\n\n\n#include \n#include \n\n#include \n\n#include \"MetaData.hpp\"\n#include \"ConfigParser.hpp\"\n\n\nMetaData::MetaData() : dimension(0), inputMetricDiagonal(false), identityMetric(false), inputMetricPermutationOfDiagonal(false), maxDimPrecomputedProducts(256) {}\n\nMetaData::~MetaData() {}\n\nvoid MetaData::display() const {\n std::cout << \"MetaData\" << std::endl;\n std::cout << \"dimension : \" << dimension << std::endl;\n std::cout << \"namespace : \" << namespaceName << std::endl;\n\n std::cout << \"refinement : \" << (useEigenRefinement==true?\"true\":\"false\") << std::endl;\n std::cout << \"cleanup : \" << (useNumericalCleanUp==true?\"true\":\"false\") << std::endl;\n std::cout << \"maxDim prec func : \" << maxDimPrecomputedProducts << std::endl;\n std::cout << \"maxDim accessors : \" << maxDimBasisAccessor << std::endl;\n std::cout << \"epsilon : \" << epsilon << std::endl;\n std::cout << \"basis vector name : \";\n for(unsigned int i=0; i epsilon)\n symetric = false;\n if (!symetric) {\n std::cout << \"error: the metric is not a symmetric matrix.\" << std::endl;\n consistencyCheck = false;\n }\n }\n }\n\n // check if the name of the vector basis are not ambiguous for high dimensions\n // i.e. in dimension 15: e12 is for twelve or one-two ?\n std::set basis;\n\n // represent a k-vector with a binary number (k-st bit to 1 means the k-st basis is used)\n for(unsigned int i=1; i<=pow(2,dimension); ++i){\n\n std::string kvector;\n for(unsigned int k=0; k\n\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#include \n\n\nnamespace itl { namespace pc {\n\ntemplate ::value_type>\nclass ic_0\n{\n public:\n typedef Value value_type;\n typedef typename mtl::Collection::size_type size_type;\n typedef ic_0 self;\n\n typedef mtl::matrix::parameters para;\n typedef mtl::matrix::compressed2D U_type;\n#ifndef ITL_IC_0_ONE_MATRIX\n typedef U_type L_type;\n#else\n typedef typename mtl::matrix::transposed_view L_type;\n#endif\n typedef mtl::matrix::detail::lower_trisolve_t lower_solver_t;\n typedef mtl::matrix::detail::upper_trisolve_t upper_solver_t;\n\n ic_0(const Matrix& A) : f(A, U), L(trans(U)), lower_solver(L), upper_solver(U) {}\n\n\n // solve x = U^* U y --> y= U^{-1} U^{-*} x\n template \n Vector solve(const Vector& x) const\n {\n\tmtl::vampir_trace<5036> tracer;\n\treturn inverse_upper_trisolve(U, inverse_lower_trisolve(adjoint(U), x));\n }\n\n // solve x = U^* y --> y0= U^{-*} x\n template \n const VectorOut& solve_lower(const VectorIn& x, VectorOut&) const\n {\n\tstatic VectorOut y0;\n\ty0.change_resource(resource(x));\n\tlower_solver(x, y0);\n\treturn y0;\n }\n\n // solve x = U^* U y --> y= U^{-1} U^{-*} x\n template \n void solve(const VectorIn& x, VectorOut& y) const\n {\n\tmtl::vampir_trace<5037> tracer;\n\tconst VectorOut& y0= solve_lower(x, y);\n\n\ty.checked_change_resource(x);\n\tupper_solver(y0, y);\n }\n\n // solve x = (LU)^* y --> y= L^{-*} U^{-*} x\n template \n Vector adjoint_solve(const Vector& x) const\n {\n\tmtl::vampir_trace<5044> tracer;\n\treturn solve(x);\n }\n\n // solve x = (LU)^* y --> y= L^{-*} U^{-*} x\n template \n void adjoint_solve(const VectorIn& x, VectorOut& y) const\n {\n\tmtl::vampir_trace<5044> tracer;\n\tsolve(x, y); \n }\n\n\n L_type get_L() { return L_type(L); }\n U_type get_U() { return U; }\n\n protected:\n template friend struct ic_0_evaluator;\n\n // Dummy type to perform factorization in initializer list not in \n struct factorizer\n {\n\tfactorizer(const Matrix &A, U_type& U)\n\t{ factorize(A, U, mtl::traits::is_sparse(), boost::is_same::value_type>()); }\n\n\ttemplate \n\tvoid factorize(const Matrix&, U_type&, boost::mpl::false_, T)\n\t{ MTL_THROW_IF(true, mtl::logic_error(\"IC(0) is not suited for dense matrices\"));\t}\n\n\t// When we change the value_type then the factorization is still performed with that of A\n\ttemplate \n\tvoid factorize(const Matrix& A, UF& U, boost::mpl::true_, boost::mpl::false_)\n\t{\n\t typedef mtl::matrix::compressed2D::value_type, para> tmp_type;\n\t tmp_type U_tmp;\n\t factorize(A, U_tmp, boost::mpl::true_(), boost::mpl::true_());\n\t U= U_tmp;\n\t}\n\n\t// Factorization adapted from Saad\n\t// Undefined (runtime) behavior if matrix is not symmetric \n\t// UF is type for the factorization\n\ttemplate \n\tvoid factorize(const Matrix& A, UF& U, boost::mpl::true_, boost::mpl::true_)\n\t{\n\t using namespace mtl; using namespace mtl::tag; using mtl::traits::range_generator; \n\t using math::reciprocal; using mtl::matrix::upper;\n\t mtl::vampir_trace<5035> tracer;\n\n\t // For the factorization we take still the value_type of A and later we copy it maybe to another value_type\n\t typedef typename mtl::Collection::value_type value_type;\n\t typedef typename range_generator::type cur_type; \n\t typedef typename range_generator::type icur_type; \n\n\t MTL_THROW_IF(num_rows(A) != num_cols(A), mtl::matrix_not_square());\n\t U= upper(A);\n\n\t typename mtl::traits::col::type col(U);\n\t typename mtl::traits::value::type value(U); \t\n\n\t cur_type kc= begin(U), kend= end(U);\n\t for (size_type k= 0; kc != kend; ++kc, ++k) {\n\n\t\ticur_type ic= begin(kc), iend= end(kc);\n\t\tMTL_DEBUG_THROW_IF(col(*ic) != k, mtl::missing_diagonal());\n\n\t\t// U[k][k]= 1.0 / sqrt(U[k][k]);\n\t\tvalue_type inv_dia= reciprocal(sqrt(value(*ic)));\n\t\tvalue(*ic, inv_dia);\n\t\t// icur_type jbegin= \n\t\t++ic;\n\t\tfor (; ic != iend; ++ic) {\n\t\t // U[k][i] *= U[k][k]\n\t\t value_type d= value(*ic) * inv_dia;\n\t\t value(*ic, d);\n\t\t size_type i= col(*ic);\n\n\t\t // find non-zeros U[j][i] below U[k][i] for j in (k, i]\n\t\t // 1. Go to ith row in U (== ith column in U)\n\t\t cur_type irow(i, U); // = begin(U); irow+= i;\n\t\t // 2. Find nonzeros with col() in (k, i]\n\t\t icur_type jc= begin(irow), jend= end(irow);\n\t\t while (col(*jc) <= k) ++jc;\n\t\t while (col(*--jend) > i) ;\n\t\t ++jend; \n\t\t\n\t\t for (; jc != jend; ++jc) {\n\t\t\tsize_type j= col(*jc);\n\t\t\tU.lvalue(j, i)-= d * U[k][j];\n\t\t }\n\t\t // std::cout << \"U after eliminating U[\" << i << \"][\" << k << \"] =\\n\" << U;\n\t\t}\n\t }\n\t}\n };\n\n U_type U;\n factorizer f;\n L_type L;\n lower_solver_t lower_solver;\n upper_solver_t upper_solver;\n}; \n\n#if 0\ntemplate \nstruct ic_0_solver\n : mtl::vector::assigner >\n{\n typedef ic_0 pc_type;\n\n ic_0_solver(const ic_0& P, const Vector& x) : P(P), x(x) {}\n\n template \n void assign_to(VectorOut& y) const\n {\tP.solve(x, y); } \n\n const ic_0& P; \n const Vector& x;\n};\n#endif\n\ntemplate \nstruct ic_0_evaluator\n{\n typedef typename Solver::pc_type pc_type;\n typedef typename pc_type::size_type size_type;\n typedef typename mtl::Collection::value_type out_value_type;\n\n\n ic_0_evaluator(VectorOut& y, const Solver& s) \n : y(y), s(s), U(s.P.U), y0(s.P.solve_lower(s.x, y)) { MTL_DEBUG_ARG(lr= 99999999); }\n\n\n void operator()(size_type i) { at<0>(i); }\n void operator[](size_type i) { at<0>(i); }\n\n template \n void at(size_type r)\n {\n#ifndef NDEBUG\n\tMTL_THROW_IF(r+Offset >= lr, mtl::logic_error(\"Traversal must be backward\")); lr= r+Offset;\n#endif\n\tsize_type j0= U.ref_major()[r+Offset];\n\tconst size_type cj1= U.ref_major()[r+Offset+1];\n\tMTL_DEBUG_THROW_IF(j0 == cj1 || U.ref_minor()[j0] != r+Offset, mtl::missing_diagonal());\n\tout_value_type rr= y0[r+Offset], dia= U.data[j0++];\n\tfor (; j0 != cj1; ++j0) {\n\t MTL_DEBUG_THROW_IF(U.ref_minor()[j0] <= r+Offset, mtl::logic_error(\"Matrix entries must be sorted for this.\"));\n\t rr-= U.data[j0] * y[U.ref_minor()[j0]];\n\t}\n\ty[r+Offset]= rr * dia;\n }\n\n VectorOut& y;\n const Solver& s;\n const typename pc_type::U_type& U;\n const VectorOut& y0;\n MTL_DEBUG_ARG(size_type lr;)\n};\n\ntemplate \ninline std::size_t size(const ic_0_evaluator& eval)\n{ return size(eval.y); }\n\ntemplate \nsolver, Vector, false>\ninline solve(const ic_0& P, const Vector& x)\n{\n return solver, Vector, false>(P, x);\n}\n\ntemplate \nsolver, Vector, true>\ninline adjoint_solve(const ic_0& P, const Vector& x)\n{\n return solver, Vector, true>(P, x);\n}\n\n\n}} // namespace itl::pc\n\nnamespace mtl { namespace vector {\n using itl::pc::size;\n}} // namespace mtl::vector\n\n#endif // ITL_PC_IC_0_INCLUDE\n", "meta": {"hexsha": "d38b8b4a5ac0c2564cbeaa64ef6a7726090ca464", "size": 9583, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "lib/mtl4/boost/numeric/itl/pc/ic_0.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/pc/ic_0.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/pc/ic_0.hpp", "max_forks_repo_name": "spraetor/amdis2", "max_forks_repo_head_hexsha": "53c45c81a65752a8fafbb54f9ae6724a86639dcd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.3476702509, "max_line_length": 129, "alphanum_fraction": 0.6343524992, "num_tokens": 2717, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7799929002541068, "lm_q2_score": 0.5736784074525096, "lm_q1q2_score": 0.44746508484204023}} {"text": "/* =========================================================================\n Copyright (c) 2012-2014, Institute for Microelectronics,\n Institute for Analysis and Scientific Computing,\n TU Wien.\n -----------------\n ViennaFEM - The Vienna Finite Element Method Library\n -----------------\n\n Author: Karl Rupp rupp@iue.tuwien.ac.at\n\n License: MIT (X11), see file LICENSE in the ViennaFEM base directory\n============================================================================ */\n\n// remove assert() statements and the like in order to get reasonable performance\n#ifndef NDEBUG\n #define NDEBUG\n#endif\n\n// include necessary system headers\n#include \n\n// ViennaFEM includes:\n#include \"viennafem/fem.hpp\"\n#include \"viennafem/io/vtk_writer.hpp\"\n\n// ViennaGrid includes:\n#include \"viennagrid/forwards.hpp\"\n#include \"viennagrid/config/default_configs.hpp\"\n#include \"viennagrid/io/netgen_reader.hpp\"\n\n// ViennaData includes:\n#include \"viennadata/api.hpp\"\n\n// ViennaMath includes:\n#include \"viennamath/expression.hpp\"\n\n// Boost.uBLAS includes:\n#include \n#include \n#include \n#include \n#include \n\n\n//ViennaCL includes:\n#ifndef VIENNACL_HAVE_UBLAS\n #define VIENNACL_HAVE_UBLAS\n#endif\n\n#include \"viennacl/linalg/cg.hpp\"\n#include \"viennacl/linalg/norm_2.hpp\"\n#include \"viennacl/linalg/prod.hpp\"\n\n\nint main()\n{\n typedef viennagrid::hexahedral_3d_mesh DomainType;\n typedef viennagrid::result_of::segmentation::type SegmentationType;\n\n typedef viennagrid::result_of::element::type VertexType;\n typedef viennagrid::result_of::element_range::type VertexContainer;\n typedef viennagrid::result_of::iterator::type VertexIterator;\n\n typedef boost::numeric::ublas::compressed_matrix MatrixType;\n typedef boost::numeric::ublas::vector VectorType;\n\n typedef viennamath::function_symbol FunctionSymbol;\n typedef viennamath::equation Equation;\n\n //\n // Create a domain from file\n //\n DomainType my_domain;\n SegmentationType segments(my_domain);\n\n //\n // Create a storage object\n //\n typedef viennadata::storage<> StorageType;\n StorageType storage;\n\n try\n {\n viennagrid::io::netgen_reader my_reader;\n my_reader(my_domain, segments, \"../examples/data/cube343_hex.mesh\");\n }\n catch (...)\n {\n std::cerr << \"File-Reader failed. Aborting program...\" << std::endl;\n exit(EXIT_FAILURE);\n }\n\n\n //\n // Specify two PDEs:\n //\n FunctionSymbol u(0, viennamath::unknown_tag<>()); //an unknown function used for PDE specification\n Equation poisson_equ_1 = viennamath::make_equation( viennamath::laplace(u), -1);\n Equation poisson_equ_2 = viennamath::make_equation( viennamath::laplace(u), -1);\n\n MatrixType system_matrix_1, system_matrix_2;\n VectorType load_vector_1, load_vector_2;\n\n //\n // Setting boundary information on domain (this should come from device specification)\n //\n //setting some boundary flags:\n VertexContainer vertices = viennagrid::elements(my_domain);\n for (VertexIterator vit = vertices.begin();\n vit != vertices.end();\n ++vit)\n {\n // First equation: Homogeneous boundary conditions at x=0, x=1, y=0, or y=1\n if ( viennagrid::point(my_domain, *vit)[0] == 0.0 || viennagrid::point(my_domain, *vit)[0] == 1.0\n || viennagrid::point(my_domain, *vit)[1] == 0.0 || viennagrid::point(my_domain, *vit)[1] == 1.0 )\n viennafem::set_dirichlet_boundary(storage, *vit, 0.0, 0); //simulation with ID 0 uses homogeneous boundary data\n\n // Boundary for second equation (ID 1): 0 at left boundary, 1 at right boundary\n if ( viennagrid::point(my_domain, *vit)[0] == 0.0)\n viennafem::set_dirichlet_boundary(storage, *vit, 0.0, 1);\n else if ( viennagrid::point(my_domain, *vit)[0] == 1.0)\n viennafem::set_dirichlet_boundary(storage, *vit, 1.0, 1);\n }\n\n\n //\n // Create PDE solver functors: (discussion about proper interface required)\n //\n viennafem::pde_assembler fem_assembler(storage);\n\n\n //\n // Solve system and write solution vector to pde_result:\n // (discussion about proper interface required. Introduce a pde_result class?)\n //\n fem_assembler(viennafem::make_linear_pde_system(poisson_equ_1,\n u,\n viennafem::make_linear_pde_options(0,\n viennafem::lagrange_tag<1>(),\n viennafem::lagrange_tag<1>())\n ),\n my_domain,\n system_matrix_1,\n load_vector_1\n );\n\n fem_assembler(viennafem::make_linear_pde_system(poisson_equ_2,\n u,\n viennafem::make_linear_pde_options(1,\n viennafem::lagrange_tag<1>(),\n viennafem::lagrange_tag<1>())\n ),\n my_domain,\n system_matrix_2,\n load_vector_2\n );\n\n VectorType pde_result_1 = viennacl::linalg::solve(system_matrix_1, load_vector_1, viennacl::linalg::cg_tag());\n std::cout << \"* solve(): Residual: \" << norm_2(prod(system_matrix_1, pde_result_1) - load_vector_1) << std::endl;\n\n VectorType pde_result_2 = viennacl::linalg::solve(system_matrix_2, load_vector_2, viennacl::linalg::cg_tag());\n std::cout << \"* solve(): Residual: \" << norm_2(prod(system_matrix_2, pde_result_2) - load_vector_2) << std::endl;\n\n\n //\n // Writing solution back to domain (discussion about proper way of returning a solution required...)\n //\n viennafem::io::write_solution_to_VTK_file(pde_result_1, \"poisson_3d_hex_1\", my_domain, segments, storage, 0);\n viennafem::io::write_solution_to_VTK_file(pde_result_2, \"poisson_3d_hex_2\", my_domain, segments, storage, 1);\n\n std::cout << \"*****************************************\" << std::endl;\n std::cout << \"* Poisson solver finished successfully! *\" << std::endl;\n std::cout << \"*****************************************\" << std::endl;\n return EXIT_SUCCESS;\n}\n", "meta": {"hexsha": "44e5d53a8502286cbd0615530a05f2354eae802b", "size": 6902, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/tutorials/poisson_3d_hex.cpp", "max_stars_repo_name": "viennafem/viennafem-dev", "max_stars_repo_head_hexsha": "1f2d772cef5fb1c148e22e5bbbb6302b301e896b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2019-06-23T17:35:29.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-19T14:39:03.000Z", "max_issues_repo_path": "examples/tutorials/poisson_3d_hex.cpp", "max_issues_repo_name": "viennafem/viennafem-dev", "max_issues_repo_head_hexsha": "1f2d772cef5fb1c148e22e5bbbb6302b301e896b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2019-11-17T03:28:47.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-04T03:40:11.000Z", "max_forks_repo_path": "examples/tutorials/poisson_3d_hex.cpp", "max_forks_repo_name": "viennafem/viennafem-dev", "max_forks_repo_head_hexsha": "1f2d772cef5fb1c148e22e5bbbb6302b301e896b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-12-23T20:24:15.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-23T20:24:15.000Z", "avg_line_length": 39.2159090909, "max_line_length": 118, "alphanum_fraction": 0.5924369748, "num_tokens": 1654, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7799929002541068, "lm_q2_score": 0.5736784074525096, "lm_q1q2_score": 0.44746508484204023}} {"text": "/**\n* @file AdBidStrategy.cpp\n* @brief Implementation to class AdBidStrategy.\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 \"AdBidStrategy.h\"\n\nnamespace sf1r\n{\n\nnamespace sponsored\n{\n\nstatic const double E = 2.71828;\n\nAdBidStrategy::AdBidStrategy()\n{\n\n}\n\nAdBidStrategy::~AdBidStrategy()\n{\n\n}\n\nstatic bool isZero(double f)\n{\n return std::abs(f) < std::numeric_limits::epsilon();\n}\n\nstruct Point\n{\n double x;\n double y;\n\n Point(double X = 0.0, double Y = 0.0):x(X), y(Y) {}\n};\n\nstatic bool operator<(const Point& p1, const Point& p2)\n{\n return (p1.x < p2.x) || (isZero(p1.x - p2.x) && p1.y < p2.y);\n}\n\nstatic bool xsmall(const Point& p1, const Point& p2)\n{\n return (p1.x < p2.x) ;\n}\n\n//judge the turning direction for line p0->p1->p2 at point p1.\n//turn left return 1, turn right return -1, in the same line return 0.\nstatic int turnDirection(const Point& p0, const Point& p1, const Point& p2)\n{\n double tmp = (p2.x - p0.x)*(p1.y - p0.y) - (p2.y - p0.y)*(p1.x - p0.x);\n if (tmp < 0) return 1;\n else if (tmp > 0) return -1;\n else return 0;\n}\n\nclass AnglePredicate\n{\npublic:\n AnglePredicate(const Point& p): base_(p) {}\n\n bool operator()(const Point& p1, const Point& p2)\n {\n int tmp = turnDirection(base_, p1, p2);\n return (tmp > 0) || (tmp == 0 &&\n (p1.x - base_.x)*(p1.x - base_.x) + (p1.y - base_.y)*(p1.y - base_.y) < (p2.x - base_.x)*(p2.x - base_.x) + (p2.y - base_.y)*(p2.y - base_.y)\n );\n }\n\nprivate:\n Point base_;\n};\n\nstd::vector > AdBidStrategy::convexUniformBid( const std::vector& qsInfos, int budget)\n{\n static const std::vector > NULLBID_(2, std::make_pair(0, 0.0));\n\n if (qsInfos.empty())\n {\n return NULLBID_;\n }\n\n\n //aggregate landscape\n boost::unordered_map landscape; //(cpc, )\n for (std::vector::const_iterator cit = qsInfos.begin(); cit != qsInfos.end(); ++cit)\n {\n std::vector::const_iterator cpcit = cit->cpc_.begin();\n std::vector::const_iterator ctrit = cit->ctr_.begin();\n for (; cpcit != cit->cpc_.end() && ctrit != cit->ctr_.end(); ++cpcit, ++ctrit)\n {\n Point& curP = landscape[*cpcit];\n curP.x += (*cpcit) * (*ctrit);\n curP.y += (*ctrit);\n }\n }\n\n std::vector allPoints;\n allPoints.reserve(landscape.size());\n Point minP(std::numeric_limits::max(), std::numeric_limits::max());\n size_t minI = -1;\n for (boost::unordered_map::const_iterator cit = landscape.begin(); cit != landscape.end(); ++cit)\n {\n if (cit->second.y > 0 && cit->second.x > 0)\n {\n allPoints.push_back(cit->second);\n\n if (cit->second < minP)\n {\n minP = cit->second;\n minI = allPoints.size() - 1;\n }\n }\n }\n // landscape.clear();\n\n if (allPoints.empty())\n {\n std::vector > minBID_(2, std::make_pair(qsInfos.front().minBid_, 0.5));\n return minBID_;\n }\n\n std::swap(allPoints[0], allPoints[minI]);\n\n AnglePredicate ap(minP);\n std::sort(++allPoints.begin(), allPoints.end(), ap);\n\n //convex hull, Graham's Scan Algorithm.\n std::vector ch;\n int i = 0;\n while (i < 2 && i < (int)allPoints.size())\n {\n //init\n ch.push_back(allPoints[i++]);\n }\n\n for (; i < (int)allPoints.size(); ++i)\n {\n while(ch.size() >= 2)\n {\n int tmp = turnDirection(ch[ch.size() -2], ch[ch.size() - 1], allPoints[i]);\n if (tmp < 0)\n {\n ch.pop_back();\n }\n else\n {\n break;\n }\n }\n ch.push_back(allPoints[i]);\n }\n allPoints.clear();\n\n //candidate convex hull points for bid\n std::vector canch;\n int j = 0;\n for (; j < (int)ch.size(); ++j)\n {\n if (j < ((int)ch.size()) - 1 && ch[j] < ch[j+1])\n {\n continue;\n }\n else\n {\n break;\n }\n }\n\n //upper bipart of convex hull.\n canch.reserve(ch.size() - j + 2);\n canch.push_back(Point()); //zero point.\n if (ch.size()>= 2 && !isZero(ch.front().x - ch.back().x))\n {\n canch.push_back(ch[0]);\n }\n\n for (int i = ch.size() -1; i >= j; --i)\n {\n canch.push_back(ch[i]);\n }\n\n ch.clear();\n\n //convex combination\n std::vector > bid;\n int minBid = qsInfos.front().minBid_;\n\n int singleBudget = 1000000000;\n int totalImpression = 0;\n for (std::vector::const_iterator cit = qsInfos.begin(); cit != qsInfos.end(); ++cit)\n {\n totalImpression += cit->impression_;\n singleBudget = std::min(cit->minBid_, singleBudget);\n }\n if (totalImpression > 0)\n {\n singleBudget = std::max(singleBudget, (int)(budget / (totalImpression / (double)qsInfos.size())));\n }\n\n\n\n Point budgetPoint(singleBudget, 0.0);\n std::vector::const_iterator uit = std::upper_bound(canch.begin(), canch.end(), budgetPoint, xsmall);\n if (uit == canch.end())\n {\n int mybid = std::max(minBid, singleBudget);\n bid.push_back(std::make_pair(mybid, 0.5));\n bid.push_back(std::make_pair(mybid, 0.5));\n }\n else\n {\n std::vector::const_iterator preit = uit - 1;\n if (isZero(preit->x - singleBudget))\n {\n int mybid = isZero(preit->y) ? 0 : int(preit->x / preit->y);\n mybid = std::max(minBid, mybid);\n bid.push_back(std::make_pair(mybid, 0.5));\n bid.push_back(std::make_pair(mybid, 0.5));\n }\n else\n {\n double p = double((singleBudget - preit->x) / (uit->x - preit->x));\n int prebid = int(isZero(preit->y)? 0 : preit->x / preit->y);\n if(prebid > 0)\n prebid = std::max(prebid, minBid);\n int lastbid = std::max(int(uit->x / uit->y), minBid);\n\n bid.push_back(std::make_pair(prebid, p));\n bid.push_back(std::make_pair(lastbid, 1.0 - p));\n }\n }\n\n return bid;\n}\n\nint AdBidStrategy::realtimeBidWithRevenueMax(const AdQueryStatisticInfo& qsInfo, int budgetUsed, int budgetLeft, int vpc /*= 1000*/)\n{\n int budget = budgetLeft + budgetUsed;\n if (budget <= 0 || qsInfo.cpc_.empty())\n {\n return 0;\n }\n\n double U = std::numeric_limits::max();\n int minBid = qsInfo.minBid_;\n if (minBid < 0)\n {\n minBid = 0;\n }\n if (minBid > 0)\n {\n U = ((double)vpc) / minBid;\n }\n\n double z = ((double)budgetUsed) / budget;\n\n //efficiency\n double eff = pow(U * E, z) / E;\n\n for (int i = 0; i < (int)qsInfo.cpc_.size(); ++i)\n {\n double avaiableB = budgetLeft / (qsInfo.ctr_[i] * qsInfo.impression_);\n double myeff = ((double)vpc) / qsInfo.cpc_[i];\n if (eff > myeff && qsInfo.cpc_[i] <= avaiableB)\n {\n eff = myeff;\n }\n }\n\n for (int i = 0; i < (int)qsInfo.cpc_.size(); ++i)\n {\n double myeff = ((double)vpc) / qsInfo.cpc_[i];\n if (myeff >= eff)\n {\n return qsInfo.cpc_[i];\n }\n }\n\n return int(vpc / (1 + eff));\n}\n\nint AdBidStrategy::realtimeBidWithProfitMax( const AdQueryStatisticInfo& qsInfo, int budgetUsed, int budgetLeft, int vpc /*= 1000*/)\n{\n static const double MINEFF = 0.1;\n\n int budget = budgetLeft + budgetUsed;\n if (budget <= 0 || qsInfo.cpc_.empty())\n {\n return 0;\n }\n\n double U = std::numeric_limits::max();\n int minBid = qsInfo.minBid_;\n if (minBid < 0)\n {\n minBid = 0;\n }\n if (minBid > 0)\n {\n U = ((double)vpc) / minBid - 1;\n }\n\n double z = ((double)budgetUsed) / budget;\n\n //efficiency\n double eff = pow(U * E / MINEFF, z) * MINEFF / E;\n\n for (int i = 0; i < (int)qsInfo.cpc_.size(); ++i)\n {\n double avaiableB = budgetLeft / (qsInfo.ctr_[i] * qsInfo.impression_);\n double myeff = ((double)vpc) / qsInfo.cpc_[i] - 1;\n if (eff > myeff && qsInfo.cpc_[i] <= avaiableB)\n {\n eff = myeff;\n }\n }\n\n int maxI = -1;\n double maxV = -1.0;\n for (int i = 0; i < (int)qsInfo.cpc_.size(); ++i)\n {\n double myeff = ((double)vpc) / qsInfo.cpc_[i] - 1;\n if (myeff >= eff)\n {\n double myV = (vpc - qsInfo.cpc_[i]) * qsInfo.ctr_[i];\n if (myV > maxV)\n {\n maxV = myV;\n maxI = i;\n }\n }\n }\n if (maxI >= 0)\n {\n return qsInfo.cpc_[maxI];\n }\n else\n return int(vpc / (1 + eff));\n}\n\n\nclass LargerFit\n{\npublic:\n LargerFit(const std::vector& Fit): _fit(Fit) {}\n bool operator()(int l, int r)\n {\n return _fit[l] < _fit[r];\n }\n\nprivate:\n const std::vector& _fit;\n};\n\nstatic void enumKPRecursive(const std::vector >& W, const std::vector >& V, int i, std::vector&curSol, double leftB, double curValue, double& maxValue, std::vector& maxSol)\n{\n if(i >= (int) W.size())\n {\n if(curValue > maxValue)\n {\n maxValue = curValue;\n maxSol = curSol;\n }\n return;\n }\n\n //do not choose cur item.\n curSol[i] = -1;\n enumKPRecursive(W, V, i+1, curSol, leftB, curValue, maxValue, maxSol);\n\n for(int j = 0; j < (int)W[i].size(); ++j)\n {\n if(leftB >= W[i][j])\n {\n curSol[i] = j;\n enumKPRecursive(W, V, i+1, curSol, leftB - W[i][j], curValue + V[i][j], maxValue, maxSol);\n }\n }\n}\n\nstatic std::vector enumKP(const std::vector >& W, const std::vector >& V, int B)\n{\n std::vector curSol(W.size(), -1);\n std::vector maxSol(W.size(), -1);\n double maxValue = 0.0;\n\n enumKPRecursive(W, V, 0, curSol, B, 0.0, maxValue, maxSol);\n\n return maxSol;\n}\n\n//dynamic programming for knapsack problem\nstatic std::vector dpKP(const std::vector >& W, const std::vector >& V, int B)\n{\n typedef boost::multi_array array_type;\n typedef array_type::index index;\n array_type\tS(boost::extents[W.size()][B+1]);\n std::vector F(B + 1, 0.0);\n\n for(int i = 0; i < (int)W.size(); ++i)\n {\n for(int v = B; v >= 0; --v)\n {\n double maxF = F[v];\n int maxI = -1;\n for(int j = 0; j < (int)W[i].size(); ++j)\n {\n if(v >= W[i][j])\n {\n double myF = F[v - W[i][j]] + V[i][j];\n if(myF > maxF)\n {\n maxF = myF;\n maxI = j;\n }\n }\n }\n F[v] = maxF;\n S[i][v] = maxI;\n }\n }\n\n //construct solution.\n std::vector Sol(W.size(), -1);\n for(int i = W.size() - 1, v = B; i >= 0; --i)\n {\n Sol[i] = S[i][v];\n if(S[i][v] != -1)\n {\n v = (int)(v - W[i][Sol[i]]);\n }\n }\n\n return Sol;\n}\n\nstatic void convertIndexToBid(const std::vector& qsInfos, const std::vector& bidindex, std::vector& bid)\n{\n std::vector::const_iterator cit = qsInfos.begin();\n int i = 0;\n int bi = 0;\n for (; cit != qsInfos.end(); ++cit, ++i)\n {\n if (cit->bid_ != -1)\n {\n bid[i] = cit->bid_;\n }\n else\n {\n if (bidindex[bi] != -1)\n {\n bid[i] = cit->cpc_[bidindex[bi]];\n }\n else\n {\n bid[i] = 0;\n }\n\n ++bi;\n }\n }\n\n}\n\n//for debug.\nstatic double computeValue(const std::vector& qsInfos, const std::vector& sol)\n{\n double myV = 0.0;\n std::vector::const_iterator cit = qsInfos.begin();\n std::vector::const_iterator sit = sol.begin();\n for (; cit != qsInfos.end(); ++cit)\n {\n if (cit->bid_ == -1)\n {\n if (*sit != -1)\n {\n myV += cit->ctr_[*sit] * cit->impression_;\n }\n ++sit;\n }\n }\n\n return myV;\n}\n\nstatic void checkGABid(const std::vector& qsInfos, int budget, std::vector& bid)\n{\n bool allZeroFlag = true;\n std::vector::const_iterator qsIt = qsInfos.begin();\n for (std::vector::iterator it = bid.begin(); it != bid.end(); ++it, ++qsIt)\n {\n if (*it > 0)\n {\n if (*it < qsIt->minBid_)\n {\n *it = qsIt->minBid_;\n }\n\n allZeroFlag = false;\n }\n }\n if (!allZeroFlag)\n {\n return;\n }\n\n int minBid = qsInfos.front().minBid_;\n std::vector > ubid = AdBidStrategy::convexUniformBid(qsInfos, budget);\n int lastBid = int(ubid.front().first * ubid.front().second + ubid.back().first * ubid.back().second);\n lastBid = std::max(lastBid, minBid);\n for (std::vector::iterator it = bid.begin(); it != bid.end(); ++it)\n {\n *it = lastBid;\n }\n}\n\nstd::vector AdBidStrategy::geneticBid( const std::vector& qsInfos, int budget )\n{\n std::vector bid(qsInfos.size(), 0);\n\n\n //support for predefined bidding.\n int tmpKeywordNum = 0, tmpBidIndex = 0, tmpBudget = budget;\n for (std::vector::const_iterator cit = qsInfos.begin(); cit != qsInfos.end(); ++cit, ++tmpBidIndex)\n {\n if (cit->bid_ == -1)\n {\n ++tmpKeywordNum;\n bid[tmpBidIndex] = 0;\n }\n else\n {\n bid[tmpBidIndex] = cit->bid_;\n int i = 0;\n for (; i <(int)cit->cpc_.size(); ++i)\n {\n if (cit->bid_ >= cit->cpc_[i])\n {\n break;\n }\n }\n if (i < (int)cit->cpc_.size())\n {\n tmpBudget -= cit->cpc_[i] * cit->ctr_[i] * cit->impression_;\n }\n }\n }\n\n const int KeywordNum = tmpKeywordNum;\n const int AvaiableBudget = tmpBudget;\n\n\n const int MaxAllowedEvolutions = 300 * KeywordNum;\n const int MinAllowedEvolutions = 50 * KeywordNum;\n static const double EndPopulationRate = 0.90; //when 90% of the population has same fitness value, stop evolute.\n static const int PopulationSize = 40; //must be even\n static const int ElitismSize = 2;\n static const double MinFitVariance = 0.001; //minimum max fitness variance ratio. variance / fit^2\n static const long long MaxLoopNum = 10000000000;\n static const long long MaxDPSpace = 100000000;\n\n\n if (KeywordNum <= 0 || AvaiableBudget <= 0)\n {\n return bid;\n }\n\n typedef std::vector > TQSDataType;\n TQSDataType W(KeywordNum), V(KeywordNum);\n std::vector adP(KeywordNum); //ad position num for each keyword.\n int kNum = 0;\n for (std::vector::const_iterator cit = qsInfos.begin(); cit != qsInfos.end(); ++cit)\n {\n if (cit->bid_ != -1)\n {\n continue;\n }\n\n const std::vector& cpc = cit->cpc_;\n const std::vector& ctr = cit->ctr_;\n\n W[kNum].reserve(cpc.size());\n V[kNum].reserve(cpc.size());\n adP[kNum] = cpc.size();\n\n for (int j = 0; j < (int)cpc.size(); ++j)\n {\n W[kNum].push_back(cpc[j] * cit->impression_ * ctr[j]);\n V[kNum].push_back(cit->impression_ * ctr[j]); //max traffics. value is defined as click traffics.\n }\n\n ++kNum;\n }\n\n // judge whether problem can be solved by enumerating to directly get optimal solution.\n {\n long long timeCP = 1;\n for(int i = 0; i < KeywordNum; ++i)\n {\n timeCP *= (W[i].size() + 1);\n if(timeCP > MaxLoopNum) break;\n }\n if(timeCP < MaxLoopNum)\n {\n const std::vector& mySol = enumKP(W, V, AvaiableBudget);\n convertIndexToBid(qsInfos, mySol, bid);\n checkGABid(qsInfos, budget, bid);\n return bid;\n }\n }\n\n // judge whether problem can be solved by dynamic programming to directly get optimal solution.\n {\n long long spaceComplexity = KeywordNum;\n spaceComplexity *= (AvaiableBudget + 1);\n if (spaceComplexity <= MaxDPSpace)\n {\n const std::vector& mySol = dpKP(W, V, AvaiableBudget);\n convertIndexToBid(qsInfos, mySol, bid);\n checkGABid(qsInfos, budget, bid);\n return bid;\n }\n }\n\n typedef std::vector > TPopType; //every individual is a vector of index of ad position for each keyword, 0-based.\n TPopType P(PopulationSize);\n TPopType newP(PopulationSize);\n\n srand(time(NULL));\n for (int i = 0; i < PopulationSize; ++i)\n {\n P[i].reserve(KeywordNum);\n newP[i].reserve(KeywordNum);\n for (size_t j = 0; j < KeywordNum; ++j)\n {\n int N = adP[j] + 1;\n P[i].push_back(rand() % N - 1); //ad position is 0-based, -1 means do not bid for that keyword.\n newP[i].push_back(0);\n }\n\n //clear population for budget requirement.\n for (int i = 0; i < PopulationSize; ++i)\n {\n std::vector > kw; //(keyword index, selected ad position index)\n for (int j = 0; j < (int)(P[i].size()); ++j)\n {\n //for each keyword\n if (P[i][j] != -1)\n {\n kw.push_back(std::make_pair(j, P[i][j]));\n }\n }\n\n double totalW = 0.0;\n for (std::vector >::const_iterator cit = kw.begin(); cit != kw.end(); ++cit)\n {\n totalW += W[cit->first][cit->second];\n }\n\n int aN = kw.size();\n while(totalW > AvaiableBudget)\n {\n int r = rand() % aN;\n totalW -= W[kw[r].first][kw[r].second];\n P[i][kw[r].first] = -1;\n std::swap(kw[r], kw[aN - 1]);\n --aN;\n }\n }\n }\n\n int iterNum = MaxAllowedEvolutions;\n double averageFit = 0.0, averageSquareFit = 0.0;\n\n while(iterNum--)\n {\n //selection,\n std::vector SP(PopulationSize); //selected individual's index in P\n int GASize = PopulationSize - ElitismSize;\n\n {\n std::vector fitness(PopulationSize); //total fitness.\n std::vector fit(PopulationSize); //each individual fitness.\n double fn = 0.0;\n for (int i = 0; i < PopulationSize; ++i)\n {\n double curfn = 0.0;\n for (int j = 0; j < (int)(P[i].size()); ++j)\n {\n //for each keyword\n if (P[i][j] != -1)\n {\n curfn += V[j][P[i][j]];\n }\n }\n fn += curfn;\n fit[i] = curfn;\n fitness[i] = fn;\n }\n\n //check condition of stop evolution.\n if (MaxAllowedEvolutions - iterNum > MinAllowedEvolutions)\n {\n boost::unordered_map fitNum;\n for (int i = 0; i < PopulationSize; ++i)\n {\n fitNum[fit[i]]++;\n }\n int maxNum = -1;\n for (boost::unordered_map::const_iterator cit = fitNum.begin(); cit != fitNum.end(); ++cit)\n {\n if (cit->second > maxNum)\n {\n maxNum = cit->second;\n }\n }\n\n if ((double)maxNum / PopulationSize >= EndPopulationRate)\n {\n break;\n }\n }\n\n //stochastic universal sampling.\n double fstep = fn / GASize;\n double fstart = ((double)rand()) / RAND_MAX * fstep;\n\n if (!isZero(fstep))\n {\n for (int i = 0, j = 0; i < GASize; ++i)\n {\n double fcur = fstart + i * fstep;\n for (int k = j; k < PopulationSize; ++k)\n {\n if (fitness[k] > fcur)\n {\n SP[i] = k;\n j = k;\n break;\n }\n }\n }\n }\n else\n {\n for (int i = 0; i < PopulationSize; ++i)\n {\n SP[i] = i;\n }\n }\n\n //random to select crossover pair\n for (int i = GASize; i >= 1; --i)\n {\n int j = rand() % i;\n std::swap(SP[j], SP[i - 1]);\n }\n\n //elitism\n LargerFit mylf(fit);\n std::priority_queue, LargerFit> pq(mylf);\n for (int i = 0; i < PopulationSize; ++i)\n {\n pq.push(i);\n }\n\n {\n //average fit\n int eNum = MaxAllowedEvolutions - iterNum;\n double curMaxFit = fit[pq.top()];\n if (!isZero(curMaxFit))\n {\n averageFit = ((eNum - 1) * averageFit + curMaxFit) / eNum;\n averageSquareFit = ((eNum - 1) * averageSquareFit + curMaxFit * curMaxFit) / eNum;\n //variance\n double variance = averageSquareFit - averageFit * averageFit;\n if (eNum > MinAllowedEvolutions && variance / (curMaxFit*curMaxFit) < MinFitVariance)\n {\n break;\n }\n }\n }\n\n for (int i = GASize; i < PopulationSize; ++i)\n {\n SP[i] = pq.top();\n pq.pop();\n }\n\n\n }\n\n //crossover\n int crossoverRate = 85;\n for (int i = 0; i < GASize; i += 2)\n {\n int myRate = rand() % 100;\n if (myRate < crossoverRate)\n {\n const std::vector& lp = P[SP[i]];\n const std::vector& rp = P[SP[i+1]];\n\n for (int j = 0; j < KeywordNum; ++j)\n {\n double p = (double)rand() / RAND_MAX * 1.50 - 0.25;\n\n if (lp[j] != -1 && rp[j] != -1)\n {\n //newP[i][j]\n int v = (int)(lp[j] * p + rp[j] * (1.0 - p) + 0.5);\n v = std::max(v, 0);\n v = std::min(v, adP[j] - 1);\n newP[i][j] = v;\n\n //newP[i+1]\n //newP[i]\n v = (int)(lp[j] * ( 1.0 - p ) + rp[j] * p + 0.5);\n v = std::max(v, 0);\n v = std::min(v, adP[j] - 1);\n newP[i+1][j] = v;\n }\n else if (lp[j] == -1 && rp[j] == -1)\n {\n newP[i][j] = -1;\n newP[i+1][j] = -1;\n }\n else\n {\n //discrete\n int ip = rand() % 2;\n if (ip)\n {\n newP[i][j] = -1;\n newP[i+1][j] = -1;\n }\n else\n {\n int tmp = std::max(lp[j], rp[j]);\n newP[i][j] = tmp;\n newP[i+1][j] = tmp;\n }\n }\n\n }\n }\n else\n {\n newP[i] = P[SP[i]];\n newP[i+1] = P[SP[i+1]];\n }\n }\n for (int i = GASize; i < PopulationSize; ++i)\n {\n newP[i] = P[SP[i]];\n }\n\n //mutation, mutation rate, 1/countof(var)\n int mRate = KeywordNum;\n for (int i = 0; i < GASize; ++i)\n {\n for (int j = 0; j < KeywordNum; ++j)\n {\n if (rand() % mRate == 0)\n {\n //do mutation\n newP[i][j] = rand() % (adP[j] + 1) - 1;\n }\n }\n }\n\n newP.swap(P);\n\n\n //clear population for budget requirement.\n for (int i = 0; i < PopulationSize; ++i)\n {\n std::vector > kw; //(keyword index, selected ad position index)\n for (int j = 0; j < (int)(P[i].size()); ++j)\n {\n //for each keyword\n if (P[i][j] != -1)\n {\n kw.push_back(std::make_pair(j, P[i][j]));\n }\n }\n\n double totalW = 0.0;\n for (std::vector >::const_iterator cit = kw.begin(); cit != kw.end(); ++cit)\n {\n totalW += W[cit->first][cit->second];\n }\n\n int aN = kw.size();\n while(totalW > AvaiableBudget)\n {\n int r = rand() % aN;\n totalW -= W[kw[r].first][kw[r].second];\n P[i][kw[r].first] = -1;\n std::swap(kw[r], kw[aN - 1]);\n --aN;\n }\n }\n\n }\n\n //max fitness in population\n int maxI = -1;\n double maxfit = -1.0;\n for (int i = 0; i < PopulationSize; ++i)\n {\n double ft = 0.0;\n for (int j = 0; j < KeywordNum; ++j)\n {\n if (P[i][j] != -1)\n {\n ft += V[j][P[i][j]];\n }\n }\n if (ft > maxfit)\n {\n maxfit = ft;\n maxI = i;\n }\n }\n\n\n if (maxI != -1)\n {\n convertIndexToBid(qsInfos, P[maxI], bid);\n\n }\n\n checkGABid(qsInfos, budget, bid);\n return bid;\n}\n\n}\n}\n\n", "meta": {"hexsha": "dfed8a1234ab33e47ebc20d903697e41ca07d4cf", "size": 26788, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "source/core/ad-manager/sponsored-ad-search/AdBidStrategy.cpp", "max_stars_repo_name": "izenecloud/sf1r-ad-delivery", "max_stars_repo_head_hexsha": "998eadb243098446854615de9a96e58a24bd2f4f", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 18.0, "max_stars_repo_stars_event_min_datetime": "2015-04-20T03:40:36.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-09T08:43:07.000Z", "max_issues_repo_path": "source/core/ad-manager/sponsored-ad-search/AdBidStrategy.cpp", "max_issues_repo_name": "izenecloud/sf1r-ad-delivery", "max_issues_repo_head_hexsha": "998eadb243098446854615de9a96e58a24bd2f4f", "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/core/ad-manager/sponsored-ad-search/AdBidStrategy.cpp", "max_forks_repo_name": "izenecloud/sf1r-ad-delivery", "max_forks_repo_head_hexsha": "998eadb243098446854615de9a96e58a24bd2f4f", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2015-02-01T13:53:35.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-07T15:45:36.000Z", "avg_line_length": 28.0502617801, "max_line_length": 222, "alphanum_fraction": 0.4627445125, "num_tokens": 7331, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7549149868676283, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.44741289852120847}} {"text": "#pragma once\n\n#include \n#include \n#include \n\nnamespace argus\n{\n\nVectorType flatten_matrices( const std::vector& mats )\n{\n\tunsigned int n = 0;\n\tBOOST_FOREACH( const MatrixType& mat, mats )\n\t{\n\t\tn += mat.size();\n\t}\n\tVectorType out(n);\n\tunsigned int ind = 0;\n\tBOOST_FOREACH( const MatrixType& mat, mats )\n\t{\n\t\tEigen::Map v( mat.data(), mat.size(), 1 );\n\t\tout.segment(ind, mat.size()) = v;\n\t\tind += v.size();\n\t}\n\treturn out;\n}\n\nMatrixType vstack_matrices( const std::vector& mats )\n{\n\tunsigned int rows = 0;\n\tunsigned int cols = mats[0].cols();\n\n\tBOOST_FOREACH( const MatrixType& mat, mats )\n\t{\n\t\trows += mat.rows();\n\t\tif( mat.cols() != cols )\n\t\t{\n\t\t\tthrow std::invalid_argument( \"Not all mats same width!\" );\n\t\t}\n\t}\n\n\tMatrixType out( rows, cols );\n\tunsigned int ind = 0;\n\tBOOST_FOREACH( const MatrixType& mat, mats )\n\t{\n\t\tout.block(ind, 0, mat.rows(), mat.cols() ) = mat;\n\t\tind += mat.rows();\n\t}\n\treturn out;\n}\n\nMatrixType hstack_matrices( const std::vector& mats )\n{\n\tunsigned int rows = mats[0].rows();\n\tunsigned int cols = 0;\n\n\tBOOST_FOREACH( const MatrixType& mat, mats )\n\t{\n\t\tcols += mat.cols();\n\t\tif( mat.rows() != rows )\n\t\t{\n\t\t\tthrow std::invalid_argument( \"Not all mats same height!\" );\n\t\t}\n\t}\n\n\tMatrixType out( rows, cols );\n\tunsigned int ind = 0;\n\tBOOST_FOREACH( const MatrixType& mat, mats )\n\t{\n\t\tout.block(0, ind, mat.rows(), mat.cols() ) = mat;\n\t\tind += mat.cols();\n\t}\n\treturn out;\n}\n\n// template \n// Derived ConcatenateHor( const Eigen::DenseBase& l,\n// const Eigen::DenseBase& r )\n// {\n// \tif( l.size() == 0 )\n// \t{\n// \t\treturn r;\n// \t}\n// \tif( r.size() == 0 )\n// \t{\n// \t\treturn l;\n// \t}\n\n// \tif( l.rows() != r.rows() )\n// \t{\n// \t\tthrow std::runtime_error( \"ConcatenateHor: Dimension mismatch.\" );\n// \t}\n// \tDerived out( l.rows(), l.cols() + r.cols() );\n// \tout.leftCols( l.cols() ) = l;\n// \tout.rightCols( r.cols() ) = r;\n// \treturn out;\n// }\n\n// template \n// Derived ConcatenateVer( const Eigen::DenseBase& l,\n// const Eigen::DenseBase& r )\n// {\n// \tif( l.size() == 0 )\n// \t{\n// \t\treturn r;\n// \t}\n// \tif( r.size() == 0 )\n// \t{\n// \t\treturn l;\n// \t}\n\n// \tif( l.cols() != r.cols() )\n// \t{\n// \t\tthrow std::runtime_error( \"ConcatenateVer: Dimension mismatch.\" );\n// \t}\n// \tDerived out( l.rows() + r.rows(), l.cols() );\n// \tout.topRows( l.rows() ) = l;\n// \tout.bottomRows( r.rows() ) = r;\n// \treturn out;\n// }\n\n}", "meta": {"hexsha": "1808100c3021f41a5c8a6935b5216e94eaac0b04", "size": 2531, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/modprop/utils/MatrixUtils.hpp", "max_stars_repo_name": "Humhu/modprop", "max_stars_repo_head_hexsha": "0cff8240d5e1522f620de8004c22a74491a0c9fb", "max_stars_repo_licenses": ["AFL-3.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2017-11-10T00:54:53.000Z", "max_stars_repo_stars_event_max_datetime": "2017-11-10T00:54:53.000Z", "max_issues_repo_path": "include/modprop/utils/MatrixUtils.hpp", "max_issues_repo_name": "Humhu/modprop", "max_issues_repo_head_hexsha": "0cff8240d5e1522f620de8004c22a74491a0c9fb", "max_issues_repo_licenses": ["AFL-3.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/modprop/utils/MatrixUtils.hpp", "max_forks_repo_name": "Humhu/modprop", "max_forks_repo_head_hexsha": "0cff8240d5e1522f620de8004c22a74491a0c9fb", "max_forks_repo_licenses": ["AFL-3.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 20.7459016393, "max_line_length": 71, "alphanum_fraction": 0.5827736073, "num_tokens": 776, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5926665999540698, "lm_q2_score": 0.7549149813536518, "lm_q1q2_score": 0.4474128952532588}} {"text": "//\n// Copyright (c) 2015-2019 CNRS INRIA\n// Copyright (c) 2015 Wandercraft, 86 rue de Paris 91400 Orsay, France.\n//\n\n#include \"pinocchio/bindings/python/spatial/explog.hpp\"\n#include \n\nnamespace pinocchio\n{\n namespace python\n {\n namespace bp = boost::python;\n \n void exposeExplog()\n {\n \n bp::def(\"exp3\",&exp3_proxy,\n bp::arg(\"Angular velocity (vector of size 3)\"),\n \"Exp: so3 -> SO3. Return the integral of the input\"\n \" angular velocity during time 1.\");\n \n bp::def(\"Jexp3\",&Jexp3_proxy,\n bp::arg(\"v: Angular velocity (vector of size 3)\"),\n \"Jacobian of exp(R) which maps from the tangent of SO(3) at exp(v) to\"\n \" the tangent of SO(3) at Identity.\");\n \n bp::def(\"log3\",&log3_proxy,\n bp::arg(\"Rotation matrix (matrix of size 3x3))\"),\n \"Log: SO3 -> so3. Pseudo-inverse of log from SO3\"\n \" -> { v in so3, ||v|| < 2pi }.Exp: so3 -> SO3.\");\n \n bp::def(\"Jlog3\",&Jlog3_proxy,\n bp::arg(\"Rotation matrix R (matrix of size 3x3)\"),\n \"Jacobian of log(R) which maps from the tangent of SO(3) at R to\"\n \" the tangent of SO(3) at Identity.\");\n \n bp::def(\"exp6\",&exp6_proxy,\n bp::arg(\"Spatial velocity (Motion)\"),\n \"Exp: se3 -> SE3. Return the integral of the input\"\n \" spatial velocity during time 1.\");\n \n bp::def(\"exp6\",&exp6_proxy,\n bp::arg(\"Spatial velocity (vector 6x1)\"),\n \"Exp: se3 -> SE3. Return the integral of the input\"\n \" spatial velocity during time 1.\");\n \n bp::def(\"Jexp6\",&Jexp6_proxy,\n bp::arg(\"v: Spatial velocity (Motion)\"),\n \"Jacobian of exp(v) which maps from the tangent of SE(3) at exp(v) to\"\n \" the tangent of SE(3) at Identity.\");\n \n bp::def(\"Jexp6\",&Jexp6_proxy,\n bp::arg(\"v: Spatial velocity (vector 6x1)\"),\n \"Jacobian of exp(v) which maps from the tangent of SE(3) at exp(v) to\"\n \" the tangent of SE(3) at Identity.\");\n \n bp::def(\"log6\",(Motion (*)(const SE3 &))&log6,\n bp::arg(\"Spatial transform (SE3)\"),\n \"Log: SE3 -> se3. Pseudo-inverse of exp from SE3\"\n \" -> { v,w in se3, ||w|| < 2pi }.\");\n \n bp::def(\"log6\",&log6_proxy,\n bp::arg(\"Homegenious matrix (matrix 4x4)\"),\n \"Log: SE3 -> se3. Pseudo-inverse of exp from SE3\"\n \" -> { v,w in se3, ||w|| < 2pi }.\");\n \n bp::def(\"Jlog6\",&Jlog6_proxy,\n bp::arg(\"Spatial transform M (SE3)\"),\n \"Jacobian of log(M) which maps from the tangent of SE(3) at M to\"\n \" the tangent of SE(3) at Identity.\");\n \n }\n \n } // namespace python\n} // namespace pinocchio\n", "meta": {"hexsha": "4fb2fb3ad8a0ecd1e377a80a45687912ee915697", "size": 3066, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "bindings/python/spatial/expose-explog.cpp", "max_stars_repo_name": "thanhndv212/pinocchio", "max_stars_repo_head_hexsha": "3b4d272bf4e8a231954b71201ee7e0963c944aef", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2020-05-10T08:06:43.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-22T14:26:57.000Z", "max_issues_repo_path": "bindings/python/spatial/expose-explog.cpp", "max_issues_repo_name": "thanhndv212/pinocchio", "max_issues_repo_head_hexsha": "3b4d272bf4e8a231954b71201ee7e0963c944aef", "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": "bindings/python/spatial/expose-explog.cpp", "max_forks_repo_name": "thanhndv212/pinocchio", "max_forks_repo_head_hexsha": "3b4d272bf4e8a231954b71201ee7e0963c944aef", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-04-21T16:00:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-03T06:24:52.000Z", "avg_line_length": 39.8181818182, "max_line_length": 84, "alphanum_fraction": 0.5293542074, "num_tokens": 860, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6619228758499942, "lm_q2_score": 0.6757646140788307, "lm_q1q2_score": 0.4473040567487211}} {"text": "// Copyright (c) 2017 Graphcore Ltd. All rights reserved.\n#include \"poplibs_support/logging.hpp\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// Fwd state array indices\n#define LSTM_FWD_STATE_FORGET_GATE 2\n#define LSTM_FWD_STATE_CAND_TANH 3\n#define LSTM_FWD_STATE_INPUT_GATE 4\n#define LSTM_FWD_STATE_OUTPUT_GATE 5\n#define LSTM_FWD_STATE_OUTPUT_TANH 6\n\nusing IndexRange = boost::multi_array_types::index_range;\nusing Array1dRef = boost::multi_array_ref;\nusing Array1dRefUNSIGNED = boost::multi_array_ref;\nusing Array2dRef = boost::multi_array_ref;\nusing Array2d = boost::multi_array;\nusing Array3dRef = boost::multi_array_ref;\nusing Array4dRef = boost::multi_array_ref;\nusing Array3d = boost::multi_array;\n\nusing namespace poplibs_support;\nusing namespace poplibs_test;\n\nstatic void matrixZero(boost::multi_array_ref matA) {\n std::fill(matA.data(), matA.data() + matA.num_elements(), 0.0);\n}\n\n/**\n * Process a given unit type within an LSTM given its weights and biases.\n * The non-linearity is also specified although it may be derived from the unit\n */\nstatic void processBasicLstmUnit(const Array2dRef prevOutput,\n const Array2dRef input,\n const Array3dRef weightsInput,\n const Array3dRef weightsOutput,\n const Array2dRef biases, Array2dRef output,\n unsigned lstmUnitOffset,\n popnn::NonLinearityType nonLinearityType) {\n const auto batchSize = prevOutput.shape()[0];\n const auto outputSize = prevOutput.shape()[1];\n\n /* split weight into two parts:\n * 1) part which weighs only the previous output\n * 2) part which weighs only the input\n */\n Array2d weightsOutputUnit = weightsOutput[lstmUnitOffset];\n Array2d weightsInputUnit = weightsInput[lstmUnitOffset];\n\n gemm::generalMatrixMultiply(prevOutput, weightsOutputUnit, output, output,\n 1.0, 0, false, false);\n gemm::generalMatrixMultiply(input, weightsInputUnit, output, output, 1.0, 1.0,\n false, false);\n /* add bias */\n for (auto b = 0U; b != batchSize; ++b) {\n for (auto i = 0U; i != outputSize; ++i) {\n output[b][i] += biases[lstmUnitOffset][i];\n }\n }\n\n /* apply non-linearity */\n nonLinearity(nonLinearityType, output);\n}\n\n/**\n * Apply mask to gates.\n */\nstatic void applySeqMask(const boost::optional &timeSteps,\n const unsigned step, Array2dRef ionput) {\n if (timeSteps) {\n const auto batchSize = ionput.shape()[0];\n const auto outputSize = ionput.shape()[1];\n for (auto b = 0U; b != batchSize; ++b) {\n for (auto i = 0U; i != outputSize; ++i) {\n auto limit = (*timeSteps)[timeSteps->size() > 1 ? b : 0];\n if (step >= limit) {\n ionput[b][i] = 0;\n }\n }\n }\n }\n}\n\n/**\n * Update output for batches that have not reached iteration limit\n */\nstatic void\ncopyIfStepWithinRange(const boost::optional &timeSteps,\n const unsigned step,\n const boost::optional ¤t,\n const Array2dRef update, Array2dRef dst) {\n const auto batchSize = dst.shape()[0];\n const auto outputSize = dst.shape()[1];\n for (auto b = 0U; b != batchSize; ++b) {\n for (auto i = 0U; i != outputSize; ++i) {\n auto limit = (*timeSteps)[(timeSteps->size() > 1) ? b : 0];\n if (step < limit) {\n dst[b][i] = update[b][i];\n } else if (current) {\n dst[b][i] = (*current)[b][i];\n }\n }\n }\n}\n\nstatic void\ncopyIfStepWithinRange(const boost::optional &timeSteps,\n const unsigned step, const Array2dRef update,\n Array2dRef dst) {\n copyIfStepWithinRange(timeSteps, step, {}, update, dst);\n}\n\nstatic std::unordered_map\ngetCellMapping(const std::vector &cellOrder) {\n // build a mapping of the order that the gates are stored in.\n std::unordered_map cellMapping;\n for (unsigned i = 0; i < cellOrder.size(); ++i) {\n auto gate = cellOrder.at(i);\n cellMapping.insert(std::make_pair(gate, i));\n }\n\n return cellMapping;\n}\n\nvoid poplibs_test::lstm::basicLstmCellForwardPass(\n const Array3dRef input, const Array2dRef biases,\n const Array2dRef prevOutput, const Array3dRef weightsInput,\n const Array3dRef weightsOutput,\n const boost::optional &timeSteps,\n Array2dRef prevCellState, Array4dRef state, Array2dRef lastOutput,\n Array2dRef lastCellState, const std::vector &cellOrder,\n const popnn::NonLinearityType activation,\n const popnn::NonLinearityType recurrentActivation) {\n const auto sequenceSize = state.shape()[1];\n const auto batchSize = state.shape()[2];\n const auto outputSize = state.shape()[3];\n#ifndef NDEBUG\n const auto inputSize = input.shape()[2];\n#endif\n assert(state.shape()[0] == LSTM_NUM_FWD_STATES);\n assert(weightsInput.shape()[0] == BASIC_LSTM_CELL_NUM_UNITS);\n assert(weightsInput.shape()[1] == inputSize);\n assert(weightsInput.shape()[2] == outputSize);\n assert(weightsOutput.shape()[0] == BASIC_LSTM_CELL_NUM_UNITS);\n assert(weightsOutput.shape()[1] == outputSize);\n assert(weightsOutput.shape()[2] == outputSize);\n assert(prevCellState.shape()[0] == batchSize);\n assert(prevCellState.shape()[1] == outputSize);\n assert(biases.shape()[0] == BASIC_LSTM_CELL_NUM_UNITS);\n assert(biases.shape()[1] == outputSize);\n assert(prevOutput.shape()[0] == batchSize);\n assert(prevOutput.shape()[1] == outputSize);\n\n auto cellMapping = getCellMapping(cellOrder);\n\n Array2d nextOutput = prevOutput;\n Array2d nextCellState = prevCellState;\n for (auto s = 0U; s != sequenceSize; ++s) {\n Array2d inputThisStep = input[s];\n\n auto cellState = nextCellState;\n\n /* forget gate */\n Array2d forgetGate(boost::extents[batchSize][outputSize]);\n processBasicLstmUnit(nextOutput, inputThisStep, weightsInput, weightsOutput,\n biases, forgetGate,\n cellMapping.at(BASIC_LSTM_CELL_FORGET_GATE),\n recurrentActivation);\n applySeqMask(timeSteps, s, forgetGate);\n state[LSTM_FWD_STATE_FORGET_GATE][s] = forgetGate;\n\n /* input gate */\n Array2d inputGate(boost::extents[batchSize][outputSize]);\n processBasicLstmUnit(nextOutput, inputThisStep, weightsInput, weightsOutput,\n biases, inputGate,\n cellMapping.at(BASIC_LSTM_CELL_INPUT_GATE),\n recurrentActivation);\n applySeqMask(timeSteps, s, inputGate);\n state[LSTM_FWD_STATE_INPUT_GATE][s] = inputGate;\n\n /* new candidate contribution to this cell */\n Array2d candidate(boost::extents[batchSize][outputSize]);\n processBasicLstmUnit(nextOutput, inputThisStep, weightsInput, weightsOutput,\n biases, candidate,\n cellMapping.at(BASIC_LSTM_CELL_CANDIDATE), activation);\n applySeqMask(timeSteps, s, candidate);\n state[LSTM_FWD_STATE_CAND_TANH][s] = candidate;\n\n /* output gate */\n Array2d outputGate(boost::extents[batchSize][outputSize]);\n processBasicLstmUnit(nextOutput, inputThisStep, weightsInput, weightsOutput,\n biases, outputGate,\n cellMapping.at(BASIC_LSTM_CELL_OUTPUT_GATE),\n recurrentActivation);\n applySeqMask(timeSteps, s, outputGate);\n state[LSTM_FWD_STATE_OUTPUT_GATE][s] = outputGate;\n\n poplibs_test::gemm::hadamardProduct(forgetGate, cellState, cellState);\n poplibs_test::gemm::hadamardProduct(inputGate, candidate, candidate);\n poplibs_test::axpby::add(cellState, candidate, cellState);\n\n /* need to maintain the cell state for next step */\n Array2d outputThisStep = cellState;\n nonLinearity(activation, outputThisStep);\n state[LSTM_FWD_STATE_OUTPUT_TANH][s] = outputThisStep;\n gemm::hadamardProduct(outputThisStep, outputGate, outputThisStep);\n\n if (timeSteps) {\n copyIfStepWithinRange(timeSteps, s, outputThisStep, nextOutput);\n copyIfStepWithinRange(timeSteps, s, cellState, nextCellState);\n } else {\n nextOutput = outputThisStep;\n nextCellState = cellState;\n }\n state[LSTM_FWD_STATE_ACTS_IDX][s] = outputThisStep;\n state[LSTM_FWD_STATE_CELL_STATE_IDX][s] = cellState;\n }\n\n // Save final state\n lastOutput = nextOutput;\n lastCellState = nextCellState;\n}\n\nstatic void computeGradients(const Array2dRef weightIn,\n const Array2dRef weightPrev, const Array2dRef grad,\n Array2dRef gradIn, Array2dRef gradPrev, bool acc) {\n double k = acc ? 1.0 : 0.0;\n gemm::generalMatrixMultiply(grad, weightIn, gradIn, gradIn, 1.0, k, false,\n true);\n gemm::generalMatrixMultiply(grad, weightPrev, gradPrev, gradPrev, 1.0, k,\n false, true);\n}\n\nvoid poplibs_test::lstm::basicLstmCellBackwardPass(\n bool outputFullSequence, const Array3dRef weightsInput,\n const Array3dRef weightsOutput, const Array3dRef gradsNextLayer,\n const Array2dRef prevCellState, const Array4dRef fwdState,\n const boost::optional initOutputGrad,\n const boost::optional initCellStateGrad,\n const boost::optional &timeSteps, Array4dRef bwdState,\n Array3dRef gradsPrevLayer, Array2dRef lastGradLayerOut,\n Array2dRef lastGradCellState,\n const std::vector &cellOrder,\n const popnn::NonLinearityType activation,\n const popnn::NonLinearityType recurrentActivation) {\n const auto sequenceSize = fwdState.shape()[1];\n const auto batchSize = fwdState.shape()[2];\n const auto outputSize = fwdState.shape()[3];\n const auto inputSize = gradsPrevLayer.shape()[2];\n\n assert(fwdState.shape()[0] == LSTM_NUM_FWD_STATES);\n assert(bwdState.shape()[0] == LSTM_NUM_BWD_STATES);\n assert(weightsInput.shape()[0] == BASIC_LSTM_CELL_NUM_UNITS);\n assert(weightsInput.shape()[1] == inputSize);\n assert(weightsInput.shape()[2] == outputSize);\n assert(weightsOutput.shape()[0] == BASIC_LSTM_CELL_NUM_UNITS);\n assert(weightsOutput.shape()[1] == outputSize);\n assert(weightsOutput.shape()[2] == outputSize);\n assert(prevCellState.shape()[0] == batchSize);\n assert(prevCellState.shape()[1] == outputSize);\n assert(fwdState.shape()[1] == sequenceSize);\n assert(fwdState.shape()[2] == batchSize);\n assert(fwdState.shape()[3] == outputSize);\n assert(bwdState.shape()[1] == sequenceSize);\n assert(bwdState.shape()[2] == batchSize);\n assert(bwdState.shape()[3] == outputSize);\n assert(gradsNextLayer.shape()[0] == sequenceSize);\n assert(gradsNextLayer.shape()[1] == batchSize);\n assert(gradsNextLayer.shape()[2] == outputSize);\n assert(gradsPrevLayer.shape()[0] == sequenceSize);\n assert(gradsPrevLayer.shape()[1] == batchSize);\n\n auto cellMapping = getCellMapping(cellOrder);\n\n // gradient of cell state for this step\n Array2d prevGradCellState(boost::extents[batchSize][outputSize]);\n if (initCellStateGrad) {\n prevGradCellState = *initCellStateGrad;\n } else {\n matrixZero(prevGradCellState);\n }\n\n // gradient of output of this step\n Array2d gradOutput(boost::extents[batchSize][outputSize]);\n if (initOutputGrad) {\n gradOutput = *initOutputGrad;\n } else {\n matrixZero(gradOutput);\n }\n\n for (auto i = sequenceSize; i != 0; --i) {\n const auto s = i - 1;\n Array2d gradOut(boost::extents[batchSize][outputSize]);\n Array2d sumGradOut(boost::extents[batchSize][outputSize]);\n\n if (outputFullSequence) {\n gradOut = gradsNextLayer[s];\n } else {\n // Only the last layer receive the gradient\n if (s == sequenceSize - 1)\n gradOut = gradsNextLayer[0];\n else {\n matrixZero(gradOut);\n }\n }\n auto gradCellState = prevGradCellState;\n axpby::add(gradOut, gradOutput, sumGradOut);\n\n Array2d actOutGate = fwdState[LSTM_FWD_STATE_OUTPUT_GATE][s];\n Array2d gradAtOTanhInp(boost::extents[batchSize][outputSize]);\n gemm::hadamardProduct(actOutGate, sumGradOut, gradAtOTanhInp);\n\n Array2d actTanhOutGate = fwdState[LSTM_FWD_STATE_OUTPUT_TANH][s];\n Array2d gradAtOutGate(boost::extents[batchSize][outputSize]);\n ;\n\n gemm::hadamardProduct(actTanhOutGate, sumGradOut, gradAtOutGate);\n\n bwdNonLinearity(activation, actTanhOutGate, gradAtOTanhInp);\n\n bwdNonLinearity(recurrentActivation, actOutGate, gradAtOutGate);\n\n Array2dRef gradAtCellStateSum = gradAtOTanhInp;\n axpby::add(gradAtOTanhInp, gradCellState, gradAtCellStateSum);\n\n Array2d actInpGate = fwdState[LSTM_FWD_STATE_INPUT_GATE][s];\n Array2d gradAtCand(boost::extents[batchSize][outputSize]);\n ;\n gemm::hadamardProduct(actInpGate, gradAtCellStateSum, gradAtCand);\n Array2d actCand = fwdState[LSTM_FWD_STATE_CAND_TANH][s];\n Array2d gradAtInpGate(boost::extents[batchSize][outputSize]);\n ;\n gemm::hadamardProduct(actCand, gradAtCellStateSum, gradAtInpGate);\n bwdNonLinearity(activation, actCand, gradAtCand);\n bwdNonLinearity(recurrentActivation, actInpGate, gradAtInpGate);\n\n Array2d actForgetGate = fwdState[LSTM_FWD_STATE_FORGET_GATE][s];\n gemm::hadamardProduct(actForgetGate, gradAtCellStateSum, gradCellState);\n\n Array2d pCellAct(boost::extents[batchSize][outputSize]);\n\n if (s == 0) {\n pCellAct = prevCellState;\n } else {\n pCellAct = fwdState[LSTM_FWD_STATE_CELL_STATE_IDX][s - 1];\n }\n Array2d gradAtForgetGate(boost::extents[batchSize][outputSize]);\n ;\n\n gemm::hadamardProduct(pCellAct, gradAtCellStateSum, gradAtForgetGate);\n bwdNonLinearity(recurrentActivation, actForgetGate, gradAtForgetGate);\n\n Array2d gradIn(boost::extents[batchSize][inputSize]);\n ;\n Array2d weightsInUnit =\n weightsInput[cellMapping.at(BASIC_LSTM_CELL_FORGET_GATE)];\n Array2d weightsOutUnit =\n weightsOutput[cellMapping.at(BASIC_LSTM_CELL_FORGET_GATE)];\n Array2d nextGradOut(boost::extents[batchSize][outputSize]);\n computeGradients(weightsInUnit, weightsOutUnit, gradAtForgetGate, gradIn,\n nextGradOut, false);\n weightsInUnit = weightsInput[cellMapping.at(BASIC_LSTM_CELL_INPUT_GATE)];\n weightsOutUnit = weightsOutput[cellMapping.at(BASIC_LSTM_CELL_INPUT_GATE)];\n computeGradients(weightsInUnit, weightsOutUnit, gradAtInpGate, gradIn,\n nextGradOut, true);\n weightsInUnit = weightsInput[cellMapping.at(BASIC_LSTM_CELL_OUTPUT_GATE)];\n weightsOutUnit = weightsOutput[cellMapping.at(BASIC_LSTM_CELL_OUTPUT_GATE)];\n computeGradients(weightsInUnit, weightsOutUnit, gradAtOutGate, gradIn,\n nextGradOut, true);\n weightsInUnit = weightsInput[cellMapping.at(BASIC_LSTM_CELL_CANDIDATE)];\n weightsOutUnit = weightsOutput[cellMapping.at(BASIC_LSTM_CELL_CANDIDATE)];\n computeGradients(weightsInUnit, weightsOutUnit, gradAtCand, gradIn,\n nextGradOut, true);\n\n if (timeSteps) {\n if (outputFullSequence) {\n copyIfStepWithinRange(timeSteps, s, nextGradOut, gradOutput);\n } else {\n copyIfStepWithinRange(timeSteps, s, sumGradOut, nextGradOut,\n gradOutput);\n }\n copyIfStepWithinRange(timeSteps, s, gradCellState, prevGradCellState);\n } else {\n gradOutput = nextGradOut;\n prevGradCellState = gradCellState;\n }\n gradsPrevLayer[s] = gradIn;\n\n // save bwd state for weight update\n bwdState[BASIC_LSTM_CELL_FORGET_GATE][s] = gradAtForgetGate;\n bwdState[BASIC_LSTM_CELL_INPUT_GATE][s] = gradAtInpGate;\n bwdState[BASIC_LSTM_CELL_OUTPUT_GATE][s] = gradAtOutGate;\n bwdState[BASIC_LSTM_CELL_CANDIDATE][s] = gradAtCand;\n }\n lastGradLayerOut = gradOutput;\n lastGradCellState = prevGradCellState;\n}\n\nvoid poplibs_test::lstm::basicLstmCellParamUpdate(\n const Array3dRef prevLayerActs, const Array4dRef fwdState,\n const Array2dRef outputActsInit, const Array4dRef bwdState,\n Array3dRef weightsInputDeltas, Array3dRef weightsOutputDeltas,\n Array2dRef biasDeltas, const std::vector &cellOrder) {\n const auto sequenceSize = prevLayerActs.shape()[0];\n const auto batchSize = prevLayerActs.shape()[1];\n const auto inputSize = prevLayerActs.shape()[2];\n const auto outputSize = fwdState.shape()[3];\n\n assert(fwdState.shape()[0] == LSTM_NUM_FWD_STATES);\n assert(fwdState.shape()[1] == sequenceSize);\n assert(fwdState.shape()[2] == batchSize);\n assert(outputActsInit.shape()[0] == batchSize);\n assert(outputActsInit.shape()[1] == outputSize);\n assert(bwdState.shape()[0] == LSTM_NUM_BWD_STATES);\n assert(bwdState.shape()[1] == sequenceSize);\n assert(bwdState.shape()[2] == batchSize);\n assert(bwdState.shape()[3] == outputSize);\n assert(weightsInputDeltas.shape()[0] == BASIC_LSTM_CELL_NUM_UNITS);\n assert(weightsInputDeltas.shape()[1] == inputSize);\n assert(weightsInputDeltas.shape()[2] == outputSize);\n assert(weightsOutputDeltas.shape()[0] == BASIC_LSTM_CELL_NUM_UNITS);\n assert(weightsOutputDeltas.shape()[1] == outputSize);\n assert(weightsOutputDeltas.shape()[2] == outputSize);\n assert(biasDeltas.shape()[0] == BASIC_LSTM_CELL_NUM_UNITS);\n assert(biasDeltas.shape()[1] == outputSize);\n\n auto cellMapping = getCellMapping(cellOrder);\n\n for (auto it = weightsInputDeltas.data(),\n end = weightsInputDeltas.data() + weightsInputDeltas.num_elements();\n it != end; ++it) {\n *it = 0;\n }\n for (auto it = weightsOutputDeltas.data(),\n end =\n weightsOutputDeltas.data() + weightsOutputDeltas.num_elements();\n it != end; ++it) {\n *it = 0;\n }\n for (auto it = biasDeltas.data(),\n end = biasDeltas.data() + biasDeltas.num_elements();\n it != end; ++it) {\n *it = 0;\n }\n\n for (auto i = sequenceSize; i != 0; --i) {\n const auto s = i - 1;\n Array2d outActs(boost::extents[batchSize][outputSize]);\n if (s == 0) {\n outActs = outputActsInit;\n } else {\n outActs = fwdState[LSTM_FWD_STATE_ACTS_IDX][s - 1];\n }\n Array2d inActs = prevLayerActs[s];\n for (auto i = 0; i != BASIC_LSTM_CELL_NUM_UNITS; ++i) {\n const auto unit = static_cast(i);\n\n Array2d grad = bwdState[i][s];\n Array2d wInputDeltasUnit(boost::extents[inputSize][outputSize]);\n\n gemm::generalMatrixMultiply(inActs, grad, wInputDeltasUnit,\n wInputDeltasUnit, 1.0, 0, true, false);\n for (auto ic = 0u; ic != inputSize; ++ic) {\n for (auto oc = 0u; oc != outputSize; ++oc) {\n weightsInputDeltas[cellMapping.at(unit)][ic][oc] +=\n wInputDeltasUnit[ic][oc];\n }\n }\n Array2d wOutputDeltasUnit(boost::extents[outputSize][outputSize]);\n\n gemm::generalMatrixMultiply(outActs, grad, wOutputDeltasUnit,\n wOutputDeltasUnit, 1.0, 0, true, false);\n for (auto oc1 = 0u; oc1 != outputSize; ++oc1) {\n for (auto oc2 = 0u; oc2 != outputSize; ++oc2) {\n weightsOutputDeltas[cellMapping.at(unit)][oc1][oc2] +=\n wOutputDeltasUnit[oc1][oc2];\n }\n }\n\n for (auto oc = 0u; oc != outputSize; ++oc) {\n for (auto b = 0u; b != batchSize; ++b) {\n biasDeltas[cellMapping.at(unit)][oc] += grad[b][oc];\n }\n }\n }\n }\n}\n", "meta": {"hexsha": "06c01b7f99f2742b96426b542e12645fca4c2e1f", "size": 19672, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "lib/poplibs_test/Lstm.cpp", "max_stars_repo_name": "graphcore/poplibs", "max_stars_repo_head_hexsha": "3fe5a3ecafe995eddb72675d1b4a7af8a622009e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 95.0, "max_stars_repo_stars_event_min_datetime": "2020-07-06T17:11:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-12T14:42:28.000Z", "max_issues_repo_path": "lib/poplibs_test/Lstm.cpp", "max_issues_repo_name": "graphcore/poplibs", "max_issues_repo_head_hexsha": "3fe5a3ecafe995eddb72675d1b4a7af8a622009e", "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/poplibs_test/Lstm.cpp", "max_forks_repo_name": "graphcore/poplibs", "max_forks_repo_head_hexsha": "3fe5a3ecafe995eddb72675d1b4a7af8a622009e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2020-07-15T12:32:57.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-26T14:58:45.000Z", "avg_line_length": 39.9026369168, "max_line_length": 80, "alphanum_fraction": 0.6828995527, "num_tokens": 5265, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956581049086031, "lm_q2_score": 0.5621765008857981, "lm_q1q2_score": 0.4473002893189437}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace Euclid\n{\n\nnamespace _impl\n{\n\ntemplate\nvoid init_queue(const Mesh& mesh,\n std::queue>& queue,\n std::vector& inqueue)\n{\n auto eimap = get(boost::edge_index, mesh);\n inqueue.resize(num_edges(mesh), false);\n for (auto e : edges(mesh)) {\n if (!is_delaunay(mesh, e)) {\n queue.push(e);\n inqueue[get(eimap, e)] = true;\n }\n }\n}\n\ntemplate\nvoid init_physical_edges(const Mesh& mesh, std::vector& physical)\n{\n auto eimap = get(boost::edge_index, mesh);\n physical.resize(num_edges(mesh), true);\n for (auto e : edges(mesh)) {\n if (eq_almost(dihedral_angle(e, mesh),\n boost::math::constants::pi>())) {\n physical[get(eimap, e)] = false;\n }\n }\n}\n\ntemplate\nvoid flip(Mesh& mesh,\n Visitor& visitor,\n edge_t e,\n std::queue>& queue,\n std::vector& inqueue)\n{\n auto eimap = get(boost::edge_index, mesh);\n auto h = halfedge(e, mesh);\n auto ho = opposite(h, mesh);\n auto ha = next(h, mesh);\n auto hb = next(ha, mesh);\n auto hc = next(ho, mesh);\n auto hd = next(hc, mesh);\n auto ea = edge(ha, mesh);\n auto eb = edge(hb, mesh);\n auto ec = edge(hc, mesh);\n auto ed = edge(hd, mesh);\n visitor.on_flipping(mesh, e);\n CGAL::Euler::flip_edge(h, mesh);\n visitor.on_flipped(mesh, e);\n if (!inqueue[get(eimap, ea)]) {\n queue.push(ea);\n inqueue[get(eimap, ea)] = true;\n }\n if (!inqueue[get(eimap, eb)]) {\n queue.push(eb);\n inqueue[get(eimap, eb)] = true;\n }\n if (!inqueue[get(eimap, ec)]) {\n queue.push(ec);\n inqueue[get(eimap, ec)] = true;\n }\n if (!inqueue[get(eimap, ed)]) {\n queue.push(ed);\n inqueue[get(eimap, ed)] = true;\n }\n}\n\ntemplate\nbool is_flip_topologically_ok(const Mesh& mesh, edge_t& e)\n{\n auto h = halfedge(e, mesh);\n return !halfedge(target(next(h, mesh), mesh),\n target(next(opposite(h, mesh), mesh), mesh),\n mesh)\n .second;\n}\n\ntemplate\nvoid split(Mesh& mesh,\n Visitor& visitor,\n edge_t e,\n std::queue>& queue,\n std::vector& inqueue,\n std::vector& physical_edges,\n std::unordered_set>& split_vertices)\n{\n auto hpq = halfedge(e, mesh);\n auto hqp = opposite(hpq, mesh);\n auto hqv = next(hpq, mesh);\n auto hvp = prev(hpq, mesh);\n auto hpu = next(hqp, mesh);\n auto huq = prev(hqp, mesh);\n\n // do edge split\n visitor.on_splitting(mesh, e);\n auto hps = CGAL::Euler::split_edge(hpq, mesh);\n auto hsq = next(hps, mesh);\n auto hqs = opposite(hsq, mesh);\n auto hsv = CGAL::Euler::split_face(hps, hqv, mesh);\n auto hsu = CGAL::Euler::split_face(hqs, hpu, mesh);\n auto vs = target(hps, mesh);\n\n SplitSite site;\n site.epq = e;\n site.vs = vs;\n site.hps = hps;\n site.hqs = opposite(hsq, mesh);\n site.hvs = opposite(hsv, mesh);\n site.hus = opposite(hsu, mesh);\n visitor.on_split(mesh, site);\n\n // update realted buffers\n auto eimap = get(boost::edge_index, mesh);\n auto eqv = edge(hqv, mesh);\n if (!inqueue[get(eimap, eqv)]) {\n queue.push(eqv);\n inqueue[get(eimap, eqv)] = true;\n }\n auto evp = edge(hvp, mesh);\n if (!inqueue[get(eimap, evp)]) {\n queue.push(evp);\n inqueue[get(eimap, evp)] = true;\n }\n auto epu = edge(hpu, mesh);\n if (!inqueue[get(eimap, epu)]) {\n queue.push(epu);\n inqueue[get(eimap, epu)] = true;\n }\n auto euq = edge(huq, mesh);\n if (!inqueue[get(eimap, euq)]) {\n queue.push(euq);\n inqueue[get(eimap, euq)] = true;\n }\n auto esp = edge(hps, mesh);\n auto esq = edge(hsq, mesh);\n auto esu = edge(hsu, mesh);\n auto esv = edge(hsv, mesh);\n // auto isp = get(eimap, esp);\n // auto isq = get(eimap, esq);\n // auto isu = get(eimap, esu);\n // auto isv = get(eimap, esv);\n queue.push(esp);\n queue.push(esq);\n queue.push(esu);\n queue.push(esv);\n inqueue[get(eimap, esq)] = true;\n inqueue.push_back(true); // esp\n inqueue.push_back(true); // esv\n inqueue.push_back(true); // esu\n physical_edges.push_back(true); // esp\n physical_edges.push_back(false); // esv\n physical_edges.push_back(false); // esu\n split_vertices.insert(vs);\n\n // determine new vertex position\n auto vpmap = get(boost::vertex_point, mesh);\n auto vp = target(hvp, mesh);\n auto vq = target(huq, mesh);\n auto pp = get(vpmap, vp);\n auto pq = get(vpmap, vq);\n auto pm = CGAL::midpoint(pp, pq);\n auto lm = length(pp - pm);\n auto l = 0.0;\n if (lm > 1.5) {\n l = 2.0;\n while (l < lm) {\n l *= 2.0;\n }\n if (std::abs(l - lm) > std::abs(l * 0.5 - lm)) {\n l *= 0.5;\n }\n }\n else if (lm < 0.75) {\n l = 0.5;\n while (l > lm) {\n l *= 0.5;\n }\n if (std::abs(l - lm) > std::abs(l * 2.0 - lm)) {\n l *= 2.0;\n }\n }\n else {\n l = 1.0;\n }\n if (split_vertices.find(vp) == split_vertices.end()) {\n auto ps = pp + normalized(pm - pp) * l;\n put(vpmap, vs, ps);\n }\n else {\n auto ps = pq + normalized(pm - pq) * l;\n put(vpmap, vs, ps);\n }\n}\n\ntemplate\nvoid remesh_delaunay_simple_flip(Mesh& mesh, Visitor& visitor)\n{\n visitor.on_started(mesh);\n auto eimap = get(boost::edge_index, mesh);\n std::queue> queue;\n std::vector inqueue;\n init_queue(mesh, queue, inqueue);\n while (!queue.empty()) {\n auto e = queue.front();\n queue.pop();\n inqueue[get(eimap, e)] = false;\n if (!is_delaunay(mesh, e) && is_flip_topologically_ok(mesh, e)) {\n flip(mesh, visitor, e, queue, inqueue);\n }\n else {\n visitor.on_nonflippable(mesh, e);\n }\n }\n visitor.on_finished(mesh);\n}\n\ntemplate\nvoid remesh_delaunay_geometry_preserving(Mesh& mesh, Visitor& visitor)\n{\n visitor.on_started(mesh);\n auto eimap = get(boost::edge_index, mesh);\n std::queue> queue;\n std::vector inqueue;\n init_queue(mesh, queue, inqueue);\n std::vector physical_edges;\n init_physical_edges(mesh, physical_edges);\n std::unordered_set> split_vertices;\n while (!queue.empty()) {\n auto e = queue.front();\n queue.pop();\n inqueue[get(eimap, e)] = false;\n if (!is_delaunay(mesh, e)) {\n if (!physical_edges[get(eimap, e)]) {\n flip(mesh, visitor, e, queue, inqueue);\n }\n else {\n visitor.on_nonflippable(mesh, e);\n split(mesh,\n visitor,\n e,\n queue,\n inqueue,\n physical_edges,\n split_vertices);\n }\n }\n }\n visitor.on_finished(mesh);\n}\n\ntemplate\nvoid remesh_delaunay_feature_preserving(Mesh& mesh,\n Visitor& visitor,\n double threshold)\n{\n visitor.on_started(mesh);\n auto eimap = get(boost::edge_index, mesh);\n std::queue> queue;\n std::vector inqueue;\n init_queue(mesh, queue, inqueue);\n std::vector physical_edges;\n init_physical_edges(mesh, physical_edges);\n std::unordered_set> split_vertices;\n while (!queue.empty()) {\n auto e = queue.front();\n queue.pop();\n inqueue[get(eimap, e)] = false;\n if (!is_delaunay(mesh, e)) {\n if (!physical_edges[get(eimap, e)] ||\n dihedral_angle(e, mesh) > threshold) {\n flip(mesh, visitor, e, queue, inqueue);\n }\n else {\n visitor.on_nonflippable(mesh, e);\n split(mesh,\n visitor,\n e,\n queue,\n inqueue,\n physical_edges,\n split_vertices);\n }\n }\n }\n visitor.on_finished(mesh);\n}\n\n} // namespace _impl\n\ntemplate\nbool is_delaunay(const Mesh& mesh, double eps)\n{\n for (auto e : edges(mesh)) {\n if (!is_delaunay(mesh, e, eps)) {\n return false;\n }\n }\n return true;\n}\n\ntemplate\nbool is_delaunay(const Mesh& mesh, edge_t e, double eps)\n{\n auto cot = static_cast(cotangent_weight(e, mesh));\n return cot > eps;\n}\n\ntemplate\nvoid remesh_delaunay(Mesh& mesh,\n RemeshDelaunayScheme scheme,\n double dihedral_angle)\n{\n RemeshDelaunayVisitor visitor;\n remesh_delaunay(mesh, visitor, scheme, dihedral_angle);\n}\n\ntemplate\nvoid remesh_delaunay(Mesh& mesh,\n Visitor& visitor,\n RemeshDelaunayScheme scheme,\n double dihedral_angle)\n{\n switch (scheme) {\n case RemeshDelaunayScheme::FeaturePreserving:\n _impl::remesh_delaunay_feature_preserving(\n mesh,\n visitor,\n boost::math::constants::pi() -\n dihedral_angle * boost::math::constants::degree());\n break;\n case RemeshDelaunayScheme::GeometryPreserving:\n _impl::remesh_delaunay_geometry_preserving(mesh, visitor);\n break;\n case RemeshDelaunayScheme::SimpleFlip:\n default:\n _impl::remesh_delaunay_simple_flip(mesh, visitor);\n break;\n }\n}\n\n} // namespace Euclid\n", "meta": {"hexsha": "8d2ff8e9c7de58f7974068a6d861ae0974c0b4ff", "size": 10197, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "include/Euclid/SurfaceDelaunay/src/DelaunayMesh.cpp", "max_stars_repo_name": "unclejimbo/euclid", "max_stars_repo_head_hexsha": "e118abdcdf51b6bc05cf5aa056bf228e052cf501", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 31.0, "max_stars_repo_stars_event_min_datetime": "2017-05-02T07:04:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-31T10:00:01.000Z", "max_issues_repo_path": "include/Euclid/SurfaceDelaunay/src/DelaunayMesh.cpp", "max_issues_repo_name": "unclejimbo/euclid", "max_issues_repo_head_hexsha": "e118abdcdf51b6bc05cf5aa056bf228e052cf501", "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/Euclid/SurfaceDelaunay/src/DelaunayMesh.cpp", "max_forks_repo_name": "unclejimbo/euclid", "max_forks_repo_head_hexsha": "e118abdcdf51b6bc05cf5aa056bf228e052cf501", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2018-07-02T17:59:35.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-18T07:01:17.000Z", "avg_line_length": 28.723943662, "max_line_length": 75, "alphanum_fraction": 0.5542806708, "num_tokens": 2710, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956581000631542, "lm_q2_score": 0.5621765008857981, "lm_q1q2_score": 0.4473002865949462}} {"text": "#define _USE_MATH_DEFINES\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \"Macros.h\"\n#include \"StandardLibrary.h\"\n#include \"DataTypes/Ops/Ops.h\"\n#include \"DataTypes/Ops/StringOps.h\"\n#include \"DataTypes/Ops/ArrayOps.h\"\n#include \"DataTypes/Ops/IntegerOps.h\"\n#include \"Utils/FileStreamHelper.h\"\n\nnamespace FPTL\n{\n\tnamespace Runtime\n\t{\n\t\tnamespace {\n\t\t\tvoid id(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\t// Копируем данные аргументы от начала фрейма.\n\t\t\t\tfor (size_t i = 0; i < aCtx.argNum; ++i)\n\t\t\t\t{\n\t\t\t\t\taCtx.push(aCtx.getArg(i));\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvoid tupleLength(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\taCtx.push(DataBuilders::createInt(static_cast(aCtx.argNum)));\n\t\t\t}\n\n\t\t\tvoid Not(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\n\t\t\t\taCtx.push(DataBuilders::createBoolean(!arg.getOps()->toInt(arg)));\n\t\t\t}\n\n\t\t\tvoid And(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(DataBuilders::createBoolean((lhs.getOps()->toInt(lhs) * rhs.getOps()->toInt(rhs))));\n\t\t\t}\n\n\t\t\tvoid Or(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(DataBuilders::createBoolean((lhs.getOps()->toInt(lhs) + rhs.getOps()->toInt(rhs))));\n\t\t\t}\n\n\t\t\tvoid Xor(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(DataBuilders::createBoolean((lhs.getOps()->toInt(lhs) ^ rhs.getOps()->toInt(rhs))));\n\t\t\t}\n\n\t\t\tvoid equal(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(lhs.getOps()->combine(rhs.getOps())->equal(lhs, rhs));\n\t\t\t}\n\n\t\t\tvoid notEqual(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(\n\t\t\t\t\tDataBuilders::createBoolean(\n\t\t\t\t\t\t!lhs.getOps()->combine(rhs.getOps())->equal(lhs, rhs).mIntVal\n\t\t\t\t\t)\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tvoid greater(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(lhs.getOps()->combine(rhs.getOps())->greater(lhs, rhs));\n\t\t\t}\n\n\t\t\tvoid greaterOrEqual(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(\n\t\t\t\t\tDataBuilders::createBoolean(\n\t\t\t\t\t\t!lhs.getOps()->combine(rhs.getOps())->less(lhs, rhs).mIntVal\n\t\t\t\t\t)\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tvoid less(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(lhs.getOps()->combine(rhs.getOps())->less(lhs, rhs));\n\t\t\t}\n\n\t\t\tvoid lessOrEqual(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(\n\t\t\t\t\tDataBuilders::createBoolean(\n\t\t\t\t\t\t!lhs.getOps()->combine(rhs.getOps())->greater(lhs, rhs).mIntVal\n\t\t\t\t\t)\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tvoid add(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(lhs.getOps()->combine(rhs.getOps())->add(lhs, rhs));\n\t\t\t}\n\n\t\t\tvoid sub(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(lhs.getOps()->combine(rhs.getOps())->sub(lhs, rhs));\n\t\t\t}\n\n\t\t\tvoid mul(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(lhs.getOps()->combine(rhs.getOps())->mul(lhs, rhs));\n\t\t\t}\n\n\t\t\tvoid div(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(lhs.getOps()->combine(rhs.getOps())->div(lhs, rhs));\n\t\t\t}\n\n\t\t\tvoid mod(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & lhs = aCtx.getArg(0);\n\t\t\t\tconst auto & rhs = aCtx.getArg(1);\n\n\t\t\t\taCtx.push(lhs.getOps()->combine(rhs.getOps())->mod(lhs, rhs));\n\t\t\t}\n\n\t\t\t// Генерирует случайное вещественное число в диапазоне от 0 до 1.\n\t\t\tvoid rand(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tstatic thread_local std::random_device rd;\n\t\t\t\tstatic thread_local std::mt19937_64 gen(rd());\n\t\t\t\tstatic std::uniform_real_distribution realDistrib;\n\t\t\t\taCtx.push(DataBuilders::createDouble(realDistrib(gen)));\n\t\t\t}\n\n\t\t\tvoid sqrt(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\t\t\t\taCtx.push(DataBuilders::createDouble(std::sqrt(arg.getOps()->toDouble(arg))));\n\t\t\t}\n\n\t\t\tvoid sin(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\t\t\t\taCtx.push(DataBuilders::createDouble(std::sin(arg.getOps()->toDouble(arg))));\n\t\t\t}\n\n\t\t\tvoid cos(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\t\t\t\taCtx.push(DataBuilders::createDouble(std::cos(arg.getOps()->toDouble(arg))));\n\t\t\t}\n\n\t\t\tvoid tan(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\t\t\t\taCtx.push(DataBuilders::createDouble(std::tan(arg.getOps()->toDouble(arg))));\n\t\t\t}\n\n\t\t\tvoid asin(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\t\t\t\taCtx.push(DataBuilders::createDouble(std::asin(arg.getOps()->toDouble(arg))));\n\t\t\t}\n\n\t\t\tvoid atan(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\t\t\t\taCtx.push(DataBuilders::createDouble(std::atan(arg.getOps()->toDouble(arg))));\n\t\t\t}\n\n\t\t\tvoid round(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\t\t\t\taCtx.push(DataBuilders::createDouble(std::floor(arg.getOps()->toDouble(arg) + 0.5)));\n\t\t\t}\n\n\t\t\tvoid log(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\t\t\t\taCtx.push(DataBuilders::createDouble(std::log(arg.getOps()->toDouble(arg))));\n\t\t\t}\n\n\t\t\tvoid exp(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\t\t\t\taCtx.push(DataBuilders::createDouble(std::exp(arg.getOps()->toDouble(arg))));\n\t\t\t}\n\n\t\t\tvoid loadPi(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\taCtx.push(DataBuilders::createDouble(M_PI));\n\t\t\t}\n\n\t\t\tvoid loadE(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\taCtx.push(DataBuilders::createDouble(M_E));\n\t\t\t}\n\n\t\t\tvoid abs(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\t\t\t\taCtx.push(arg.getOps()->abs(arg));\n\t\t\t}\n\n\t\t\tvoid print(const SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tstatic boost::mutex outputMutex;\n\t\t\t\tboost::lock_guard guard(outputMutex);\n\n\t\t\t\taCtx.print(std::cout);\n\t\t\t}\n\n\t\t\tvoid printType(const SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tstatic boost::mutex outputMutex;\n\t\t\t\tboost::lock_guard guard(outputMutex);\n\n\t\t\t\taCtx.printTypes(std::cout);\n\t\t\t}\n\n\t\t\t// Преобразование в строку.\n\t\t\tvoid toString(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tstd::stringstream strStream;\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\n\t\t\t\targ.getOps()->print(arg, strStream);\n\n\t\t\t\taCtx.push(StringBuilder::create(aCtx, strStream.str()));\n\t\t\t}\n\n\t\t\t// Преобразование в вещественное число.\n\t\t\tvoid toInteger(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\n\t\t\t\taCtx.push(DataBuilders::createInt(arg.getOps()->toInt(arg)));\n\t\t\t}\n\n\t\t\t// Преобразование в целое число.\n\t\t\tvoid toDouble(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\n\t\t\t\taCtx.push(DataBuilders::createDouble(arg.getOps()->toDouble(arg)));\n\t\t\t}\n\n\t\t\t// Конкатенация строк.\n\t\t\tvoid concat(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tsize_t len = 0;\n\t\t\t\tfor (size_t i = 0; i < aCtx.argNum; ++i)\n\t\t\t\t{\n\t\t\t\t\tconst auto & arg = aCtx.getArg(i);\n\t\t\t\t\tconst auto inStr = arg.getOps()->toString(arg);\n\t\t\t\t\tlen += inStr->length();\n\t\t\t\t}\n\n\t\t\t\tconst auto val = StringBuilder::create(aCtx, len);\n\t\t\t\tconst auto str = val.mString->getChars();\n\t\t\t\tsize_t curPos = 0;\n\n\t\t\t\tfor (size_t i = 0; i < aCtx.argNum; ++i)\n\t\t\t\t{\n\t\t\t\t\tconst auto & arg = aCtx.getArg(i);\n\t\t\t\t\tconst auto inStr = arg.getOps()->toString(arg);\n\t\t\t\t\tstd::memcpy(str + curPos, inStr->getChars(), inStr->length());\n\t\t\t\t\tcurPos += inStr->length();\n\t\t\t\t}\n\n\t\t\t\taCtx.push(val);\n\t\t\t}\n\n\t\t\t// Длина строки.\n\t\t\tvoid length(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\t\t\t\tconst auto str = arg.getOps()->toString(arg);\n\n\t\t\t\taCtx.push(DataBuilders::createInt(static_cast(str->length())));\n\t\t\t}\n\n\t\t\t// Поиск по регулярному выражению.\n\t\t\tvoid search(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg0 = aCtx.getArg(0);\n\t\t\t\tconst auto & arg1 = aCtx.getArg(1);\n\n\t\t\t\tconst auto src = arg0.getOps()->toString(arg0);\n\t\t\t\tconst auto regEx = arg1.getOps()->toString(arg1);\n\n\t\t\t\tstd::regex rx(regEx->str());\n\t\t\t\tstd::cmatch matchResults;\n\n\t\t\t\tif (std::regex_search(static_cast(src->getChars()), static_cast(src->getChars() + src->length()), matchResults, rx))\n\t\t\t\t{\n\t\t\t\t\tfor (size_t i = 0; i < rx.mark_count(); i++)\n\t\t\t\t\t{\n\t\t\t\t\t\tauto & m = matchResults[i + 1];\n\t\t\t\t\t\tauto val = StringBuilder::create(aCtx, src, m.first - src->contents(), m.second - src->contents());\n\t\t\t\t\t\taCtx.push(val);\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\taCtx.push(DataBuilders::createUndefinedValue());\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Проверка соответствия по регулярному выражению.\n\t\t\tvoid match(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg0 = aCtx.getArg(0);\n\t\t\t\tconst auto & arg1 = aCtx.getArg(1);\n\n\t\t\t\tconst auto src = arg0.getOps()->toString(arg0);\n\t\t\t\tconst auto regEx = arg1.getOps()->toString(arg1);\n\n\t\t\t\tstd::regex rx(regEx->str());\n\t\t\t\tstd::cmatch match;\n\n\t\t\t\tif (std::regex_match(static_cast(src->getChars()), static_cast(src->getChars() + src->length()), match, rx))\n\t\t\t\t{\n\t\t\t\t\tfor (size_t i = 0; i < rx.mark_count(); ++i)\n\t\t\t\t\t{\n\t\t\t\t\t\tconst auto & m = match[i + 1];\n\t\t\t\t\t\tconst auto val = StringBuilder::create(aCtx, src, m.first - src->contents(), m.second - src->contents());\n\t\t\t\t\t\taCtx.push(val);\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\taCtx.push(DataBuilders::createUndefinedValue());\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Замена по регулярному выражению.\n\t\t\tvoid replace(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg0 = aCtx.getArg(0);\n\t\t\t\tconst auto & arg1 = aCtx.getArg(1);\n\t\t\t\tconst auto & arg2 = aCtx.getArg(2);\n\n\n\t\t\t\tconst auto src = arg0.getOps()->toString(arg0);\n\t\t\t\tconst auto pattern = arg1.getOps()->toString(arg1);\n\t\t\t\tconst auto format = arg2.getOps()->toString(arg2);\n\n\t\t\t\tconst std::regex rx(pattern->str());\n\t\t\t\tconst auto result = std::regex_replace(src->str(), rx, format->str());\n\t\t\t\taCtx.push(StringBuilder::create(aCtx, result));\n\t\t\t}\n\n\t\t\t// Выделение лексемы с начала строки.\n\t\t\tvoid getToken(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arg0 = aCtx.getArg(0);\n\t\t\t\tconst auto & arg1 = aCtx.getArg(1);\n\n\t\t\t\tconst auto src = arg0.getOps()->toString(arg0);\n\t\t\t\tconst auto pattern = arg1.getOps()->toString(arg1);\n\n\t\t\t\tconst std::regex rx(\"^(?:\\\\s*)(\" + pattern->str() + \")\");\n\n\t\t\t\tstd::cmatch matchResults;\n\n\t\t\t\tconst auto first = static_cast(src->getChars());\n\t\t\t\tconst auto last = static_cast(src->getChars() + src->length());\n\n\t\t\t\tif (std::regex_search(first, last, matchResults, rx))\n\t\t\t\t{\n\t\t\t\t\tconst auto prefix = StringBuilder::create(aCtx, src, matchResults[1].first - src->contents(), matchResults[1].second - src->contents());\n\t\t\t\t\taCtx.push(prefix);\n\n\t\t\t\t\tconst auto suffix = StringBuilder::create(aCtx, src, matchResults.suffix().first - src->contents(), matchResults.suffix().second - src->contents());\n\t\t\t\t\taCtx.push(suffix);\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\taCtx.push(DataBuilders::createUndefinedValue());\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Чтение содержимого файла.\n\t\t\tvoid readFile(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\t// Проверяем имя файла.\n\t\t\t\tconst auto & arg = aCtx.getArg(0);\n\n\t\t\t\tconst auto fileName = arg.getOps()->toString(arg);\n\t\t\t\t\n\t\t\t\tDataValue val;\n\t\t\t\tstd::string errMsg = \"\";\n\t\t\t\tstd::fstream input;\n\t\t\t\tinput.exceptions(std::ifstream::failbit | std::ifstream::badbit);\n\t\t\t\ttry\n\t\t\t\t{\n\t\t\t\t\t// Вычисляем размер файла.\n\t\t\t\t\tconst auto begin = input.tellg();\n\t\t\t\t\tinput.seekg(0, std::ios::end);\n\t\t\t\t\tconst auto size = input.tellg() - begin;\n\t\t\t\t\tinput.seekg(0, std::ios::beg);\n\n\t\t\t\t\t// Резервируем память под файл.\t\t\t\t\t\n\t\t\t\t\tval = StringBuilder::create(aCtx, size);\n\t\t\t\t\t// Читаем данные.\n\t\t\t\t\tstd::copy(std::istreambuf_iterator(input), std::istreambuf_iterator(), val.mString->getChars());\n\t\t\t\t\tinput.close();\n\t\t\t\t}\n\t\t\t\tcatch (const std::ios_base::failure& exc)\n\t\t\t\t{\n\t\t\t\t\tval = DataBuilders::createUndefinedValue();\n\t\t\t\t\terrMsg = Utils::getfStreamError(input);\n\t\t\t\t\tif (errMsg == \"\") errMsg = exc.what();\n\t\t\t\t}\n\t\t\t\taCtx.push(val);\n\t\t\t\taCtx.push(StringBuilder::create(aCtx, errMsg));\n\t\t\t}\n\n\t\t\tvoid writeToFile(SExecutionContext & aCtx, std::ios::openmode mode)\n\t\t\t{\n\t\t\t\t// Проверяем имя файла.\n\t\t\t\tconst auto & val = aCtx.getArg(0);\n\t\t\t\tconst auto & file = aCtx.getArg(1);\n\n\t\t\t\tconst auto fileName = file.getOps()->toString(file);\n\t\t\t\t\n\t\t\t\tUtils::setPermissions(fileName->str());\n\n\t\t\t\tDataValue res;\n\t\t\t\tstd::string errMsg = \"\";\n\t\t\t\tstd::fstream output;\n\t\t\t\toutput.exceptions(std::ifstream::failbit | std::ifstream::badbit);\n\t\t\t\ttry\n\t\t\t\t{\n\t\t\t\t\toutput.open(fileName->str(), mode);\n\t\t\t\t\toutput.precision(std::numeric_limits::max_digits10);\n\t\t\t\t\tval.getOps()->write(val, output);\n\t\t\t\t\tres = DataBuilders::createBoolean(true);\n\t\t\t\t\toutput.close();\n\t\t\t\t}\n\t\t\t\tcatch (const std::ios_base::failure& exc)\n\t\t\t\t{\n\t\t\t\t\tres = DataBuilders::createBoolean(false);\n\t\t\t\t\terrMsg = Utils::getfStreamError(output);\n\t\t\t\t\tif (errMsg == \"\") errMsg = exc.what();\n\t\t\t\t}\n\t\t\t\taCtx.push(res);\n\t\t\t\taCtx.push(StringBuilder::create(aCtx, errMsg));\n\t\t\t}\n\n\t\t\t// Создание или перезапись файла.\n\t\t\tvoid createFile(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\twriteToFile(aCtx, std::ios::out);\n\t\t\t}\n\n\t\t\t// Запись в конец файла.\n\t\t\tvoid appendFile(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\twriteToFile(aCtx, std::ios::app);\n\t\t\t}\n\n\t\t\t// Создание массива.\n\t\t\tvoid createArray(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto sizeVal = aCtx.getArg(0);\n\t\t\t\tconst auto& initialVal = aCtx.getArg(1);\n\n\t\t\t\tconst auto intSize = sizeVal.getOps()->toInt(sizeVal);\n\n#if fptlDebugBuild\n\t\t\t\tif (sizeVal.getOps() != IntegerOps::get())\n\t\t\t\t\tthrow BaseOps::invalidOperation(sizeVal.getOps()->getType(sizeVal), \"toInt\");\n\t\t\t\tif (intSize <= 0) throw std::invalid_argument(ArrayValue::negativeSizeMsg(intSize));\n#endif\n\n\t\t\t\tconst auto size = static_cast(intSize);\n\t\t\t\taCtx.push(ArrayValue::create(aCtx, size, initialVal));\n\t\t\t}\n\n\t\t\t// Чтение элемента из массива.\n\t\t\tvoid getArrayElement(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arrVal = aCtx.getArg(0);\n\t\t\t\tconst auto & posVal = aCtx.getArg(1);\n\n#if fptlDebugBuild\n\t\t\t\tArrayValue::arrayValueCheck(arrVal);\n\t\t\t\tif (posVal.getOps() != IntegerOps::get())\n\t\t\t\t\tthrow BaseOps::invalidOperation(posVal.getOps()->getType(posVal), \"toInt\");\n#endif\n\n\t\t\t\tconst size_t pos = posVal.getOps()->toInt(posVal);\n\t\t\t\taCtx.push(ArrayValue::get(arrVal, pos));\n\t\t\t}\n\n\t\t\t// Запись элемента в массив.\n\t\t\tvoid setArrayElement(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arrVal = aCtx.getArg(0);\n\t\t\t\tconst auto & posVal = aCtx.getArg(1);\n\t\t\t\tconst auto & val = aCtx.getArg(2);\n\n#if fptlDebugBuild\n\t\t\t\tArrayValue::arrayValueCheck(arrVal);\n\t\t\t\tif (posVal.getOps() != IntegerOps::get())\n\t\t\t\t\tthrow BaseOps::invalidOperation(posVal.getOps()->getType(posVal), \"toInt\");\n#endif\n\n\t\t\t\tconst size_t pos = posVal.getOps()->toInt(posVal);\n\n\t\t\t\tArrayValue::set(const_cast(arrVal), pos, val);\n\n\t\t\t\taCtx.push(arrVal);\n\t\t\t}\n\n\t\t\tvoid getArrayLength(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arrVal = aCtx.getArg(0);\n\t\t\t\tArrayValue::arrayValueCheck(arrVal);\n\t\t\t\taCtx.push(DataBuilders::createInt(ArrayValue::getLen(arrVal)));\n\t\t\t}\n\n\t\t\tvoid ArrayConcat(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\taCtx.push(ArrayValue::concat(aCtx));\n\t\t\t}\n\n\t\t\tvoid ArrayCopy(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arrVal = aCtx.getArg(0);\n\t\t\t\tArrayValue::arrayValueCheck(arrVal);\n\t\t\t\taCtx.push(ArrayValue::copy(aCtx, arrVal));\n\t\t\t}\n\n\t\t\tvoid ArrayDot(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tconst auto & arrVal1 = aCtx.getArg(0);\n\t\t\t\tconst auto & arrVal2 = aCtx.getArg(1);\n\t\t\t\tArrayValue::arrayValueCheck(arrVal1);\n\t\t\t\tArrayValue::arrayValueCheck(arrVal2);\n\t\t\t\taCtx.push(ArrayValue::dot(aCtx, arrVal1, arrVal2));\n\t\t\t}\n\n\t\t\t// Запись элемента в массив.\n\t\t\tvoid arrayFromFile(SExecutionContext & aCtx)\n\t\t\t{\n\t\t\t\tauto arrVal = aCtx.getArg(0);\n\t\t\t\tconst auto fileVal = aCtx.getArg(1);\n\n\t\t\t\tArrayValue::arrayValueCheck(arrVal);\n\t\t\t\tconst auto fileName = fileVal.getOps()->toString(fileVal);\n\n\t\t\t\tstd::string errMsg = \"\";\n\t\t\t\tstd::fstream input;\n\t\t\t\tinput.exceptions(std::ifstream::failbit | std::ifstream::badbit);\n\t\t\t\ttry\n\t\t\t\t{\n\t\t\t\t\tinput.open(fileName->str());\n\t\t\t\t\tArrayValue::fromString(arrVal, static_cast(input));\n\t\t\t\t\tinput.close();\n\t\t\t\t}\n\t\t\t\tcatch (const std::ios_base::failure& exc)\n\t\t\t\t{\n\t\t\t\t\tarrVal = DataBuilders::createUndefinedValue();\n\t\t\t\t\terrMsg = Utils::getfStreamError(input);\n\t\t\t\t\tif (errMsg == \"\") errMsg = exc.what();\n\t\t\t\t}\n\t\t\t\taCtx.push(arrVal);\n\t\t\t\taCtx.push(StringBuilder::create(aCtx, errMsg));\n\t\t\t}\n\t\t} // anonymous namespace\n\n\t\tconst std::map StandardLibrary::mFunctions =\n\t\t{\n\t\t\t// Работа с кортежем.\n\t\t\t{\"id\", &id},\n\t\t\t{\"tupleLen\", &tupleLength},\n\n\t\t\t// Арифметические.\n\t\t\t{\"add\",&add},\n\t\t\t{\"sub\", &sub},\n\t\t\t{\"mul\", &mul},\n\t\t\t{\"div\", &div},\n\t\t\t{\"mod\", &mod},\n\t\t\t{\"abs\", &abs},\n\t\t\t{\"sqrt\", &sqrt},\n\t\t\t{\"exp\", &exp},\n\t\t\t{\"ln\", &log},\n\t\t\t{\"round\", &round},\n\t\t\t{\"sin\", &sin},\n\t\t\t{\"cos\", &cos},\n\t\t\t{\"tan\", &tan},\n\t\t\t{\"asin\", &asin},\n\t\t\t{\"atan\", &atan},\n\t\t\t{\"Pi\", &loadPi},\n\t\t\t{\"E\", &loadE},\n\t\t\t{\"rand\", &rand},\n\n\t\t\t//Логические.\n\t\t\t{\"not\", &Not},\n\t\t\t{\"and\", &And},\n\t\t\t{\"or\", &Or },\n\t\t\t{\"xor\", &Xor },\n\t\t\t{\"equal\", &equal},\n\t\t\t{\"nequal\", ¬Equal},\n\t\t\t{\"greater\", &greater},\n\t\t\t{\"gequal\", &greaterOrEqual},\n\t\t\t{\"less\", &less},\n\t\t\t{\"lequal\", &lessOrEqual},\n\n\t\t\t// Работа со строками.\n\t\t\t{\"length\", &length},\n\t\t\t{\"cat\", &concat},\n\t\t\t{\"search\", &search},\n\t\t\t{\"replace\", &replace},\n\t\t\t{\"match\", &match},\n\t\t\t{\"getToken\", &getToken},\n\n\t\t\t// Преобразования типов.\n\t\t\t{\"toInt\", &toInteger},\n\t\t\t{\"toReal\", &toDouble},\n\t\t\t{\"toString\", &toString},\n\n\t\t\t// Ввод / вывод.\n\t\t\t{\"print\", &print},\n\t\t\t{\"printType\", &printType},\n\t\t\t{\"readFile\", &readFile},\n\t\t\t{\"createFile\", &createFile},\n\t\t\t{\"appendFile\", &appendFile},\n\n\t\t\t// Работа с массивами.\n\t\t\t{\"arrayCreate\", &createArray},\n\t\t\t{\"arrayGet\", &getArrayElement},\n\t\t\t{\"arraySet\", &setArrayElement},\n\t\t\t{\"arrayLen\", &getArrayLength},\n\t\t\t{\"arrayCat\", &ArrayConcat},\n\t\t\t{\"arrayCopy\", &ArrayCopy},\n\t\t\t{\"ArrayDot\", &ArrayDot},\n\t\t\t{\"arrayFromFile\", &arrayFromFile}\n\t\t};\n\n\t\tStandardLibrary::StandardLibrary() : FunctionLibrary(\"StdLib\")\n\t\t{\n\t\t\taddFunctions(mFunctions);\n\t\t}\n\t}\n}\n", "meta": {"hexsha": "d8f6730a7f0c46ab7750f4e23b521a479eebbe26", "size": 18550, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Source/Libraries/StandardLibrary.cpp", "max_stars_repo_name": "Psy-Rat/FPTL", "max_stars_repo_head_hexsha": "f3e1f560efa0c67ce62e673a8e142bc4df837a6e", "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/Libraries/StandardLibrary.cpp", "max_issues_repo_name": "Psy-Rat/FPTL", "max_issues_repo_head_hexsha": "f3e1f560efa0c67ce62e673a8e142bc4df837a6e", "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/Libraries/StandardLibrary.cpp", "max_forks_repo_name": "Psy-Rat/FPTL", "max_forks_repo_head_hexsha": "f3e1f560efa0c67ce62e673a8e142bc4df837a6e", "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.5759312321, "max_line_length": 153, "alphanum_fraction": 0.6262533693, "num_tokens": 5442, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956581000631541, "lm_q2_score": 0.5621765008857981, "lm_q1q2_score": 0.44730028659494614}} {"text": "/***********************************************************************************************************************\n * OpenStudio(R), Copyright (c) 2008-2018, Alliance for Sustainable Energy, LLC. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the\n * following conditions are met:\n *\n * (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following\n * disclaimer.\n *\n * (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the\n * following disclaimer in the documentation and/or other materials provided with the distribution.\n *\n * (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote\n * products derived from this software without specific prior written permission from the respective party.\n *\n * (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative\n * works may not use the \"OpenStudio\" trademark, \"OS\", \"os\", or any other confusingly similar designation without\n * specific prior written permission from Alliance for Sustainable Energy, LLC.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES,\n * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER, THE UNITED STATES GOVERNMENT, OR ANY CONTRIBUTORS BE LIABLE FOR\n * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n * PROCUREMENT OF SUBSTITUTE 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 NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n **********************************************************************************************************************/\n\n#ifndef UTILITIES_GEOMETRY_GEOMETRY_HPP\n#define UTILITIES_GEOMETRY_GEOMETRY_HPP\n\n#include \"../UtilitiesAPI.hpp\"\n\n#include \n#include \n\nnamespace openstudio{\n\n class Point3d;\n class PointLatLon;\n class Vector3d;\n\n /// convert degrees to radians\n UTILITIES_API double degToRad(double degrees);\n\n /// convert radians to degrees\n UTILITIES_API double radToDeg(double radians);\n\n /// compute area from surface as Point3dVector\n UTILITIES_API boost::optional getArea(const std::vector& points);\n\n /// compute Newall vector from surface as Point3dVector, direction is same as outward normal\n /// magnitude is twice the area\n UTILITIES_API boost::optional getNewallVector(const std::vector& points);\n\n /// compute outward normal from surface as Point3dVector\n UTILITIES_API boost::optional getOutwardNormal(const std::vector& points);\n\n /// compute centroid from surface as Point3dVector\n UTILITIES_API boost::optional getCentroid(const std::vector& points);\n\n /// reorder points to upper-left-corner convention\n UTILITIES_API std::vector reorderULC(const std::vector& points);\n\n /// removes collinear points, tolerance is for length of cross product after normalizing each line segment\n UTILITIES_API std::vector removeCollinear(const std::vector& points, double tol = 0.001);\n\n /// return distance between two points\n UTILITIES_API double getDistance(const Point3d& point1, const Point3d& point2);\n\n /// return distance between a point and a line segment\n /// returns 0 if lineSegment does not have length 2\n UTILITIES_API double getDistancePointToLineSegment(const Point3d& point, const std::vector& lineSegment);\n\n /// return distance between a point and a triangle\n /// returns 0 if triangle does not have length 3\n UTILITIES_API double getDistancePointToTriangle(const Point3d& point, const std::vector& triangle);\n\n /// return angle (in radians) between two vectors\n UTILITIES_API double getAngle(const Vector3d& vector1, const Vector3d& vector2);\n\n /// check if two vectors of points are equal (within tolerance) irregardless of initial ordering.\n UTILITIES_API bool circularEqual(const std::vector& points1, const std::vector& points2, double tol = 0.001);\n\n /// if point3d is within tol of any existing points then returns existing point\n /// otherwise adds point3d to allPoints and returns point3d\n UTILITIES_API Point3d getCombinedPoint(const Point3d& point3d, std::vector& allPoints, double tol = 0.001);\n\n /// compute triangulation of vertices, holes are removed in the triangulation\n /// requires that vertices and holes are in clockwise order on the z = 0 plane (i.e. in face coordinates but reversed)\n UTILITIES_API std::vector > computeTriangulation(const std::vector& vertices, const std::vector >& holes, double tol = 0.001);\n\n /// move all vertices towards point by distance, pass negative distance to move away from point\n /// no guarantee that resulting polygon will be valid\n UTILITIES_API std::vector moveVerticesTowardsPoint(const std::vector& vertices, const Point3d& point, double distance);\n\n /// reverse order of vertices\n UTILITIES_API std::vector reverse(const std::vector& vertices);\n\n /// Sets view and daylighting window, overhang and light shelf vertices by reference. Returns true if successful, false otherwise.\n UTILITIES_API bool applyViewAndDaylightingGlassRatios(double viewGlassToWallRatio, double daylightingGlassToWallRatio,\n double desiredViewGlassSillHeight, double desiredDaylightingGlassHeaderHeight,\n double exteriorShadingProjectionFactor, double interiorShelfProjectionFactor,\n const std::vector& surfaceVertices, std::vector& viewVertices,\n std::vector& daylightingVertices, std::vector& exteriorShadingVertices,\n std::vector& interiorShelfVertices);\n\n} // openstudio\n\n#endif //UTILITIES_GEOMETRY_GEOMETRY_HPP\n", "meta": {"hexsha": "edb4f2a0ddda8387cfdc53ab20a9c73ac3327fb0", "size": 6615, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "3DViewer/src/utilities/geometry/Geometry.hpp", "max_stars_repo_name": "nschrader/floorspace.js", "max_stars_repo_head_hexsha": "236da0deecdb98fde2f4c79e6f55873b3113df58", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 47.0, "max_stars_repo_stars_event_min_datetime": "2017-12-21T20:40:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-19T14:08:11.000Z", "max_issues_repo_path": "3DViewer/src/utilities/geometry/Geometry.hpp", "max_issues_repo_name": "nschrader/floorspace.js", "max_issues_repo_head_hexsha": "236da0deecdb98fde2f4c79e6f55873b3113df58", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 139.0, "max_issues_repo_issues_event_min_datetime": "2017-12-06T22:24:35.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-02T01:51:14.000Z", "max_forks_repo_path": "3DViewer/src/utilities/geometry/Geometry.hpp", "max_forks_repo_name": "nschrader/floorspace.js", "max_forks_repo_head_hexsha": "236da0deecdb98fde2f4c79e6f55873b3113df58", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 28.0, "max_forks_repo_forks_event_min_datetime": "2018-05-02T21:33:10.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-03T09:58:04.000Z", "avg_line_length": 59.5945945946, "max_line_length": 179, "alphanum_fraction": 0.7185185185, "num_tokens": 1414, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7185944046238982, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.44729579250758655}} {"text": "// MIT License\n// \n// Copyright (c) 2019 worldwide-asset-exchange\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#pragma once\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\nnamespace wax {\n //// Simple RSA signer class\n class rsa_signer {\n public:\n /// @param private_exp Non empty hex string\n /// @param modulus Non empty hex string, the 1st char cannot be 0 (zero)\n /// @exception std::invalid_argument if strings are empty, non hex or\n /// 1st char in modulus is 0\n rsa_signer(const std::string& private_exp, const std::string& modulus) \n : private_exp_{ \"0x\" + check_emptiness(private_exp) }\n , modulus_{ \"0x\" + check_modulus(check_emptiness(modulus)) }\n , modulus_size_{ modulus.size() } {\n }\n\n /// @param message Message/Data to sign\n /// @return Signed message as hex string\n /// @exception std::invalid_argument if message is empty\n std::string sign(const std::string& message) const {\n using namespace boost::multiprecision;\n\n check_emptiness(message);\n fc::sha256 message_hash(fc::sha256::hash(message.data(), message.size()));\n\n std::string pkcs1_encoding = \n pkcs1_encode(modulus_size_, bytes_to_string(message_hash.data(), message_hash.data_size()));\n \n cpp_int pkcs1_encoding_big{ \"0x\" + pkcs1_encoding };\n cpp_int modexp = powm(pkcs1_encoding_big, private_exp_, modulus_);\n\n std::vector result;\n export_bits(modexp, std::back_inserter(result), 8);\n\n return bytes_to_string(result.data(), result.size());\n }\n\n /// @todo Add getters/setter for private_exp and modulus\n\n // Implementation\n private:\n boost::multiprecision::cpp_int private_exp_;\n boost::multiprecision::cpp_int modulus_;\n std::size_t modulus_size_;\n\n static std::string bytes_to_string(const char* in, std::size_t size) {\n std::string out;\n const char* hex = \"0123456789abcdef\";\n for (std::size_t i = 0; i < size; i++) {\n out += hex[(in[i]>>4) & 0xF];\n out += hex[in[i] & 0xF];\n }\n return out;\n }\n\n static const std::string& check_emptiness(const std::string& str) {\n if (str.empty()) throw std::invalid_argument(\"String cannot be empty\");\n return str;\n }\n\n static const std::string& check_modulus(const std::string& modulus) {\n if (modulus[0] == '0') throw std::invalid_argument(\"No leading zeroes allowed in modulus\");\n return modulus;\n }\n\n /**\n * @dev Generates the pkcs1 encoding for an already hashed (via sha256) message.\n * @param modulus_length [size_t] the length in hex digits of the modulus, not including any leading zeroes\n * @param message_hash [string] the sha256 hash of the message intended for signing over\n * @returns [string] the pkcs1 encoding for the message hash given the modulus length\n *\n * For more on RSA signatures, see:\n * https://www.emc.com/collateral/white-papers/h11300-pkcs-1v2-2-rsa-cryptography-standard-wp.pdf\n * Page 39 is extra useful for understanding the padding scheme\n */\n static std::string pkcs1_encode(std::size_t modulus_length, const std::string& message_hash) {\n // pkcs1 padding constant indicating sha256 was used as the message digest for signing\n const char* PKCS1_SHA256 = \"003031300d060960864801650304020105000420\";\n\n // Prepend the hash type identifier for sha256\n std::string pkcs1_encoding = PKCS1_SHA256 + message_hash;\n\n // Prepend all f's and a starting 1 so that the final result is as long as the modulus, minus 3\n pkcs1_encoding = std::string(modulus_length - pkcs1_encoding.size() - 3, 'f').append(pkcs1_encoding);\n\n // First byte must be 1\n pkcs1_encoding[0] = '1';\n return pkcs1_encoding;\n }\n\n }; // class rsa_signer\n\n\n} // namespace wax\n\n", "meta": {"hexsha": "f2744b1c1b4aa7dcfbb3287339881daa4c031a53", "size": 5325, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "tests/src/rsa_signer.hpp", "max_stars_repo_name": "extrasaucestudio/wax-orng", "max_stars_repo_head_hexsha": "31b68eebfc7a359361bf87925f314e6888fb027e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 17.0, "max_stars_repo_stars_event_min_datetime": "2019-06-20T22:44:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-09T20:47:11.000Z", "max_issues_repo_path": "tests/src/rsa_signer.hpp", "max_issues_repo_name": "extrasaucestudio/wax-orng", "max_issues_repo_head_hexsha": "31b68eebfc7a359361bf87925f314e6888fb027e", "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": "tests/src/rsa_signer.hpp", "max_forks_repo_name": "extrasaucestudio/wax-orng", "max_forks_repo_head_hexsha": "31b68eebfc7a359361bf87925f314e6888fb027e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2019-08-02T02:37:54.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T12:45:23.000Z", "avg_line_length": 41.9291338583, "max_line_length": 115, "alphanum_fraction": 0.6469483568, "num_tokens": 1219, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7185943925708562, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.4472957850050581}} {"text": "/* Copyright (C) 2020 IBM Corp.\n * This program is Licensed under the Apache License, Version 2.0\n * (the \"License\"); you may not use this file except in compliance\n * with the License. You may obtain a copy of the License at\n * http://www.apache.org/licenses/LICENSE-2.0\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. See accompanying LICENSE file.\n */\n\n// This is a sample program for education purposes only.\n// It implements a very simple homomorphic encryption based\n// db search algorithm for demonstration purposes.\n\n// This country lookup example is derived from the BGV database demo\n// code originally written by Jack Crawford for a lunch and learn\n// session at IBM Research (Hursley) in 2019.\n// The original example code ships with HElib and can be found at\n// https://github.com/IBM-HElib/HElib/tree/master/examples/BGV_database_lookup\n\n#include \n\n#include \n#include \n#include \n#include \n\n// Utility function to print polynomials\nvoid printPoly(NTL::ZZX& poly)\n{\n for (int i = NTL::deg(poly); i >= 0; i--) {\n std::cout << poly[i] << \"x^\" << i;\n if (i > 0)\n std::cout << \" + \";\n else\n std::cout << \"\\n\";\n }\n}\n\n// Utility function to read CSV data from file\nstd::vector> read_csv(std::string filename)\n{\n std::vector> dataset;\n std::ifstream data_file(filename);\n\n if (!data_file.is_open())\n throw std::runtime_error(\n \"Error: This example failed trying to open the data file: \" + filename +\n \"\\n Please check this file exists and try again.\");\n\n std::vector row;\n std::string line, entry, temp;\n\n if (data_file.good()) {\n // Read each line of file\n while (std::getline(data_file, line)) {\n row.clear();\n std::stringstream ss(line);\n while (getline(ss, entry, ',')) {\n row.push_back(entry);\n }\n // Add key value pairs to dataset\n dataset.push_back(std::make_pair(row[0], row[1]));\n }\n }\n\n data_file.close();\n return dataset;\n}\n\nint main(int argc, char* argv[])\n{\n /************ HElib boiler plate ************/\n\n // Note: The parameters have been chosen to provide a somewhat\n // faster running time with a non-realistic security level.\n // Do Not use these parameters in real applications.\n\n // Plaintext prime modulus\n unsigned long p = 131;\n // Cyclotomic polynomial - defines phi(m)\n unsigned long m = 130; // this will give 48 slots\n // Hensel lifting (default = 1)\n unsigned long r = 1;\n // Number of bits of the modulus chain\n unsigned long bits = 1000;\n // Number of columns of Key-Switching matrix (default = 2 or 3)\n unsigned long c = 2;\n // Size of NTL thread pool (default =1)\n unsigned long nthreads = 1;\n // input database file name\n std::string db_filename = \"./countries_dataset.csv\";\n // debug output (default no debug output)\n bool debug = false;\n\n helib::ArgMap amap;\n amap.arg(\"m\", m, \"Cyclotomic polynomial ring\");\n amap.arg(\"p\", p, \"Plaintext prime modulus\");\n amap.arg(\"r\", r, \"Hensel lifting\");\n amap.arg(\"bits\", bits, \"# of bits in the modulus chain\");\n amap.arg(\"c\", c, \"# fo columns of Key-Switching matrix\");\n amap.arg(\"nthreads\", nthreads, \"Size of NTL thread pool\");\n amap.arg(\"db_filename\",\n db_filename,\n \"Qualified name for the database filename\");\n amap.toggle().arg(\"-debug\", debug, \"Toggle debug output\", \"\");\n amap.parse(argc, argv);\n\n // set NTL Thread pool size\n if (nthreads > 1)\n NTL::SetNumThreads(nthreads);\n\n std::cout << \"\\n*********************************************************\";\n std::cout << \"\\n* Privacy Preserving Search Example *\";\n std::cout << \"\\n* ================================= *\";\n std::cout << \"\\n* *\";\n std::cout << \"\\n* This is a sample program for education purposes only. *\";\n std::cout << \"\\n* It implements a very simple homomorphic encryption *\";\n std::cout << \"\\n* based db search algorithm for demonstration purposes. *\";\n std::cout << \"\\n* *\";\n std::cout << \"\\n*********************************************************\";\n std::cout << \"\\n\" << std::endl;\n\n std::cout << \"---Initialising HE Environment ... \";\n // Initialize context\n // This object will hold information about the algebra used for this scheme.\n std::cout << \"\\nInitializing the Context ... \";\n HELIB_NTIMER_START(timer_Context);\n helib::Context context = helib::ContextBuilder()\n .m(m)\n .p(p)\n .r(r)\n .bits(bits)\n .c(c)\n .build();\n HELIB_NTIMER_STOP(timer_Context);\n\n // Secret key management\n std::cout << \"\\nCreating Secret Key ...\";\n HELIB_NTIMER_START(timer_SecKey);\n // Create a secret key associated with the context\n helib::SecKey secret_key = helib::SecKey(context);\n // Generate the secret key\n secret_key.GenSecKey();\n HELIB_NTIMER_STOP(timer_SecKey);\n\n // Compute key-switching matrices that we need\n HELIB_NTIMER_START(timer_SKM);\n helib::addSome1DMatrices(secret_key);\n HELIB_NTIMER_STOP(timer_SKM);\n\n // Public key management\n // Set the secret key (upcast: FHESecKey is a subclass of FHEPubKey)\n std::cout << \"\\nCreating Public Key ...\";\n HELIB_NTIMER_START(timer_PubKey);\n const helib::PubKey& public_key = secret_key;\n HELIB_NTIMER_STOP(timer_PubKey);\n\n // Get the EncryptedArray of the context\n const helib::EncryptedArray& ea = context.getEA();\n\n // Print the context\n std::cout << std::endl;\n if (debug)\n context.printout();\n\n // Print the security level\n // Note: This will be negligible to improve performance time.\n std::cout << \"\\n***Security Level: \" << context.securityLevel()\n << \" *** Negligible for this example ***\" << std::endl;\n\n // Get the number of slot (phi(m))\n long nslots = ea.size();\n std::cout << \"\\nNumber of slots: \" << nslots << std::endl;\n\n /************ Read in the database ************/\n std::vector> country_db;\n try {\n country_db = read_csv(db_filename);\n } catch (std::runtime_error& e) {\n std::cerr << \"\\n\" << e.what() << std::endl;\n exit(1);\n }\n\n // Convert strings into numerical vectors\n std::cout << \"\\n---Initializing the encrypted key,value pair database (\"\n << country_db.size() << \" entries)...\";\n std::cout\n << \"\\nConverting strings to numeric representation into Ptxt objects ...\"\n << std::endl;\n\n // Generating the Plain text representation of Country DB\n HELIB_NTIMER_START(timer_PtxtCountryDB);\n std::vector, helib::Ptxt>>\n country_db_ptxt;\n for (const auto& country_capital_pair : country_db) {\n if (debug) {\n std::cout << \"\\t\\tname_addr_pair.first size = \"\n << country_capital_pair.first.size() << \" (\"\n << country_capital_pair.first << \")\"\n << \"\\tname_addr_pair.second size = \"\n << country_capital_pair.second.size() << \" (\"\n << country_capital_pair.second << \")\" << std::endl;\n }\n\n helib::Ptxt country(context);\n // std::cout << \"\\tname size = \" << country.size() << std::endl;\n for (long i = 0; i < country_capital_pair.first.size(); ++i)\n country.at(i) = country_capital_pair.first[i];\n\n helib::Ptxt capital(context);\n for (long i = 0; i < country_capital_pair.second.size(); ++i)\n capital.at(i) = country_capital_pair.second[i];\n country_db_ptxt.emplace_back(std::move(country), std::move(capital));\n }\n HELIB_NTIMER_STOP(timer_PtxtCountryDB);\n\n // Encrypt the Country DB\n std::cout << \"Encrypting the database...\" << std::endl;\n HELIB_NTIMER_START(timer_CtxtCountryDB);\n std::vector> encrypted_country_db;\n for (const auto& country_capital_pair : country_db_ptxt) {\n helib::Ctxt encrypted_country(public_key);\n helib::Ctxt encrypted_capital(public_key);\n public_key.Encrypt(encrypted_country, country_capital_pair.first);\n public_key.Encrypt(encrypted_capital, country_capital_pair.second);\n encrypted_country_db.emplace_back(std::move(encrypted_country),\n std::move(encrypted_capital));\n }\n\n HELIB_NTIMER_STOP(timer_CtxtCountryDB);\n\n // Print DB Creation Timers\n if (debug) {\n helib::printNamedTimer(std::cout << std::endl, \"timer_Context\");\n helib::printNamedTimer(std::cout, \"timer_Chain\");\n helib::printNamedTimer(std::cout, \"timer_SecKey\");\n helib::printNamedTimer(std::cout, \"timer_SKM\");\n helib::printNamedTimer(std::cout, \"timer_PubKey\");\n helib::printNamedTimer(std::cout, \"timer_PtxtCountryDB\");\n helib::printNamedTimer(std::cout, \"timer_CtxtCountryDB\");\n }\n\n std::cout << \"\\nInitialization Completed - Ready for Queries\" << std::endl;\n std::cout << \"--------------------------------------------\" << std::endl;\n\n /** Create the query **/\n\n // Read in query from the command line\n std::string query_string;\n std::cout << \"\\nPlease enter the name of an European Country: \";\n // std::cin >> query_string;\n std::getline(std::cin, query_string);\n std::cout << \"Looking for the Capital of \" << query_string << std::endl;\n std::cout << \"This may take few minutes ... \" << std::endl;\n\n HELIB_NTIMER_START(timer_TotalQuery);\n\n HELIB_NTIMER_START(timer_EncryptQuery);\n // Convert query to a numerical vector\n helib::Ptxt query_ptxt(context);\n for (long i = 0; i < query_string.size(); ++i)\n query_ptxt[i] = query_string[i];\n\n // Encrypt the query\n helib::Ctxt query(public_key);\n public_key.Encrypt(query, query_ptxt);\n HELIB_NTIMER_STOP(timer_EncryptQuery);\n\n /************ Perform the database search ************/\n\n HELIB_NTIMER_START(timer_QuerySearch);\n std::vector mask;\n mask.reserve(country_db.size());\n for (const auto& encrypted_pair : encrypted_country_db) {\n helib::Ctxt mask_entry = encrypted_pair.first; // Copy of database key\n mask_entry -= query; // Calculate the difference\n mask_entry.power(p - 1); // Fermat's little theorem\n mask_entry.negate(); // Negate the ciphertext\n mask_entry.addConstant(NTL::ZZX(1)); // 1 - mask = 0 or 1\n // Create a vector of copies of the mask\n std::vector rotated_masks(ea.size(), mask_entry);\n for (int i = 1; i < rotated_masks.size(); i++)\n ea.rotate(rotated_masks[i], i); // Rotate each of the masks\n totalProduct(mask_entry, rotated_masks); // Multiply each of the masks\n mask_entry.multiplyBy(encrypted_pair.second); // multiply mask with values\n mask.push_back(mask_entry);\n }\n\n // Aggregate the results into a single ciphertext\n // Note: This code is for educational purposes and thus we try to refrain\n // from using the STL and do not use std::accumulate\n helib::Ctxt value = mask[0];\n for (int i = 1; i < mask.size(); i++)\n value += mask[i];\n\n HELIB_NTIMER_STOP(timer_QuerySearch);\n\n /************ Decrypt and print result ************/\n\n HELIB_NTIMER_START(timer_DecryptQueryResult);\n helib::Ptxt plaintext_result(context);\n secret_key.Decrypt(plaintext_result, value);\n HELIB_NTIMER_STOP(timer_DecryptQueryResult);\n\n // Convert from ASCII to a string\n std::string string_result;\n for (long i = 0; i < plaintext_result.size(); ++i)\n string_result.push_back(static_cast(plaintext_result[i]));\n\n HELIB_NTIMER_STOP(timer_TotalQuery);\n\n // Print DB Query Timers\n if (debug) {\n helib::printNamedTimer(std::cout << std::endl, \"timer_EncryptQuery\");\n helib::printNamedTimer(std::cout, \"timer_QuerySearch\");\n helib::printNamedTimer(std::cout, \"timer_DecryptQueryResult\");\n std::cout << std::endl;\n }\n\n if (string_result.at(0) == 0x00) {\n string_result =\n \"Country name not in the database.\"\n \"\\n*** Please make sure to enter the name of a European Country\"\n \"\\n*** with the first letter in upper case.\";\n }\n std::cout << \"\\nQuery result: \" << string_result << std::endl;\n helib::printNamedTimer(std::cout, \"timer_TotalQuery\");\n\n return 0;\n}\n", "meta": {"hexsha": "783e4b7c77ab60cea41f4ff72b83ddd6a1c4499c", "size": 12708, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/BGV_country_db_lookup/BGV_country_db_lookup.cpp", "max_stars_repo_name": "Manny27nyc/HElib", "max_stars_repo_head_hexsha": "a5f914e498bc9358aa55d1731c0fb0ff02955bcd", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 18.0, "max_stars_repo_stars_event_min_datetime": "2021-03-10T18:33:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-19T09:53:49.000Z", "max_issues_repo_path": "examples/BGV_country_db_lookup/BGV_country_db_lookup.cpp", "max_issues_repo_name": "Manny27nyc/HElib", "max_issues_repo_head_hexsha": "a5f914e498bc9358aa55d1731c0fb0ff02955bcd", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 4.0, "max_issues_repo_issues_event_min_datetime": "2021-02-11T18:45:47.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-27T14:46:59.000Z", "max_forks_repo_path": "examples/BGV_country_db_lookup/BGV_country_db_lookup.cpp", "max_forks_repo_name": "Manny27nyc/HElib", "max_forks_repo_head_hexsha": "a5f914e498bc9358aa55d1731c0fb0ff02955bcd", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2021-03-03T10:34:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-19T07:27:52.000Z", "avg_line_length": 38.0479041916, "max_line_length": 80, "alphanum_fraction": 0.6339313818, "num_tokens": 3232, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6791787121629466, "lm_q2_score": 0.6584174938590246, "lm_q1q2_score": 0.4471831455447271}} {"text": "/*******************************************************************************\n * Copyright (c) 2012, Dougal J. Sutherland (dsutherl@cs.cmu.edu). *\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 Carnegie Mellon University nor the *\n * names of the 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 HOLDER OR CONTRIBUTORS BE *\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR *\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF *\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS *\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN *\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) *\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE *\n * POSSIBILITY OF SUCH DAMAGE. *\n ******************************************************************************/\n#include \"sdm/basics.hpp\"\n#include \"sdm/kernels/polynomial.hpp\"\n\n#include \n#include \n\n#include \n#include \n\nnamespace sdm {\n\ndouble PolynomialKernel::transformDivergence(double div) const {\n return std::pow(div + coef0, (int) degree);\n}\n\nstd::string PolynomialKernel::name() const {\n return (boost::format(\"Polynomial(%d, %g)\") % degree % coef0).str();\n}\nsize_t PolynomialKernel::getDegree() const { return degree; }\ndouble PolynomialKernel::getCoef0() const { return coef0; }\n\nPolynomialKernel* PolynomialKernel::do_clone() const {\n return new PolynomialKernel(degree, coef0);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nconst boost::ptr_vector* PolynomialKernelGroup::getTuningVector(\n const double* divs, size_t n)\nconst {\n boost::ptr_vector* kerns = new boost::ptr_vector;\n for (size_t d = 0; d < degrees.size(); d++) {\n for (size_t c = 0; c < coef0s.size(); c++) {\n kerns->push_back(new PolynomialKernel(degrees[d], coef0s[c]));\n }\n }\n return kerns;\n}\n\nPolynomialKernelGroup* PolynomialKernelGroup::do_clone() const {\n return new PolynomialKernelGroup(degrees, coef0s);\n}\n\n} // end namespace\n", "meta": {"hexsha": "e6e886fc9c7c73c4044cd04d35c13f4962f16f68", "size": 3716, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "sdm/kernels/polynomial.cpp", "max_stars_repo_name": "dougalsutherland/sdm", "max_stars_repo_head_hexsha": "2f6a57c5b337649a64f899dd5acba6e4eb35dff9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2015-04-03T11:49:19.000Z", "max_stars_repo_stars_event_max_datetime": "2017-12-22T12:08:02.000Z", "max_issues_repo_path": "sdm/kernels/polynomial.cpp", "max_issues_repo_name": "dougalsutherland/sdm", "max_issues_repo_head_hexsha": "2f6a57c5b337649a64f899dd5acba6e4eb35dff9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2020-07-05T00:02:54.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-05T00:02:54.000Z", "max_forks_repo_path": "sdm/kernels/polynomial.cpp", "max_forks_repo_name": "dougalsutherland/sdm", "max_forks_repo_head_hexsha": "2f6a57c5b337649a64f899dd5acba6e4eb35dff9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2016-05-20T10:40:40.000Z", "max_forks_repo_forks_event_max_datetime": "2018-05-21T15:50:32.000Z", "avg_line_length": 49.5466666667, "max_line_length": 80, "alphanum_fraction": 0.5578579117, "num_tokens": 683, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.679178699175393, "lm_q2_score": 0.658417500561683, "lm_q1q2_score": 0.44718314154579747}} {"text": "#include \n#include \n#include \n#include \n#include \n//#include \n#include \n\n\n#include \n\n\n#include \n#include \n#include \n#include \n\n\n#include \n\n\n\nusing namespace std;\nusing namespace cv;\nusing namespace Eigen;\n\n\n\ndouble dt = 1;\n\nEigen::VectorXd\t\tp_k(3);\nEigen::VectorXd \t\tq_k(4);\nEigen::VectorXd\t\tq_k_1(4);\nEigen::VectorXd\t\tq_k_dot(4);\nEigen::MatrixXd \t\tR_k(3,3);\t\t//passo attuale\nEigen::MatrixXd \t\tR_k_1(3,3);\t\t//passo precedente\nEigen::MatrixXd \t\tR_k_dot(3,3);\nEigen::MatrixXd \t\tR_k_dot2(3,3);\nEigen::MatrixXd\t\tS_w(3,3);\nEigen::MatrixXd\t\tS_w2(3,3);\nEigen::MatrixXd\t\tE_q(4,3);\nEigen::VectorXd\t\tw(3);\n\n\n\n\nvoid skew(const geometry_msgs::TransformStamped::ConstPtr& Transform_estimate)\n{\n\n\nstd::cout<<\"---------------FRAME_-----------------------\"<< endl;\n\tcout <<\tTransform_estimate->header.frame_id << endl;\nstd::cout<<\"--------------------------------------\"<< endl;\n\n\n\nstd::cout<<\"---------------FRAME_CHILD-----------------------\"<< endl;\n\tcout <<\tTransform_estimate->child_frame_id <transform.translation.x;\n\t\tp_k[1] = Transform_estimate->transform.translation.y;\n\t\tp_k[2] = Transform_estimate->transform.translation.z;\n\t\tq_k[0] = Transform_estimate->transform.rotation.w; \t\t\t\n\t\tq_k[1] = Transform_estimate->transform.rotation.x;\t\t\t\n\t\tq_k[2] = Transform_estimate->transform.rotation.y;\t\t\n\t\tq_k[3] = Transform_estimate->transform.rotation.z;\t\t\t\n\n\n\n//\t\tq[0] w q[1] x q[2] y q[3] z\n\n\n\t\tstd::cout<<\"---------------QUATERNION-----------------------\"<< endl;\n\t\tstd::cout<< q_k[0] << endl;\n\t\tstd::cout<< q_k[1] << endl;\n\t\tstd::cout<< q_k[2] << endl;\n\t\tstd::cout<< q_k[3] << endl;\n\t\tstd::cout<<\"------------------------------------------------\"<< endl;\n\n\n\n\t\tstd::cout<<\"---------------QUATERNION_PREVIOUS--------------\"<< endl;\n\t\tstd::cout<< q_k_1[0] << endl;\n\t\tstd::cout<< q_k_1[1] << endl;\n\t\tstd::cout<< q_k_1[2] << endl;\n\t\tstd::cout<< q_k_1[3] << endl;\n\t\tstd::cout<<\"------------------------------------------------\"<< endl;\n\n\n\n\t\tstd::cout<<\"---------------SAMPLING_TIME--------------------\"<< endl;\n\t\tstd::cout<< dt << endl;\n\t\tstd::cout<<\"------------------------------------------------\"<< endl;\n\n\n\t\t\n\n\t\tq_k_dot(0) = ( q_k(0) - q_k_1(0) ) / dt ; \n\t\tq_k_dot(1) = ( q_k(1) - q_k_1(1) ) / dt ; \n\t\tq_k_dot(2) = ( q_k(2) - q_k_1(2) ) / dt ; \n\t\tq_k_dot(3) = ( q_k(3) - q_k_1(3) ) / dt ; \n\n\t\n\t\tstd::cout<<\"---------------QUATERNION_DOT-------------------\"<< endl;\n\t\tstd::cout<< q_k_dot[0] << endl;\n\t\tstd::cout<< q_k_dot[1] << endl;\n\t\tstd::cout<< q_k_dot[2] << endl;\n\t\tstd::cout<< q_k_dot[3] << endl;\n\t\tstd::cout<<\"------------------------------------------------\"<< endl;\n\n\t\t\n\n\n\t\n\n\t\tE_q(0,0) = - q_k(1) ;\n\t\tE_q(0,1) = - q_k(2) ;\n\t\tE_q(0,2) = - q_k(3) ;\n\t\tE_q(1,0) = q_k(0) ;\n\t\tE_q(1,1) = q_k(3) ;\n\t\tE_q(1,2) = - q_k(2) ;\n\t\tE_q(2,0) = - q_k(3) ;\n\t\tE_q(2,1) = q_k(0) ;\n\t\tE_q(2,2) = q_k(1) ;\n\t\tE_q(3,0) = q_k(2) ;\n\t\tE_q(3,1) = - q_k(1) ;\n\t\tE_q(3,2) = q_k(0) ;\n\n\n\t\t\n\t\tstd::cout<<\"---------------E_q-----------------------------\"<< endl;\n\t\tstd::cout<< E_q << endl;\n\t\tstd::cout<<\"------------------------------------------------\"<< endl;\n\n\n\n\t\n\t\tw = 2*E_q.transpose()*q_k_dot ;\n\n\n\n\t\tstd::cout<<\"---------------ANGULAR_VELOCITY--------------------\"<< endl;\n\t\tstd::cout<< w << endl;\n\t\tstd::cout<<\"------------------------------------------------\"<< endl;\n\n\n\n\n\n\n\t\tR_k(0,0)\t= q_k[0]*q_k[0] + q_k[1]*q_k[1] - q_k[2]*q_k[2] - q_k[3]*q_k[3];\n\t\tR_k(0,1)\t= 2*q_k[1]*q_k[2] - 2*q_k[0]*q_k[3];\n\t\tR_k(0,2)\t= 2*q_k[1]*q_k[3] + 2*q_k[0]*q_k[2];\n\t\tR_k(1,0)\t= 2*q_k[1]*q_k[2] + 2*q_k[0]*q_k[3];\n\t\tR_k(1,1)\t= q_k[0]*q_k[0] + q_k[2]*q_k[2] - q_k[1]*q_k[1] - q_k[3]*q_k[3];\n\t\tR_k(1,2)\t= 2*q_k[2]*q_k[3] - 2*q_k[0]*q_k[1];\n\t\tR_k(2,0)\t= 2*q_k[1]*q_k[3] - 2*q_k[0]*q_k[2];\n\t\tR_k(2,1)\t= 2*q_k[2]*q_k[3] + 2*q_k[0]*q_k[1];\n\t\tR_k(2,2)\t= q_k[0]*q_k[0] + q_k[3]*q_k[3] - q_k[2]*q_k[2] - q_k[1]*q_k[1];\n\n\t\t\n\n\t\t//\t\t\tR_k_dot = ( R_k - R_k_1 ) / dt ;\t\n\n\n\t\tR_k_dot(0,0)\t= ( R_k(0,0) - R_k_1(0,0) ) / dt ;\n\t\tR_k_dot(0,1)\t= ( R_k(0,1) - R_k_1(0,1) ) / dt ;\n\t\tR_k_dot(0,2)\t= ( R_k(0,2) - R_k_1(0,2) ) / dt ;\n\t\tR_k_dot(1,0)\t= ( R_k(1,0) - R_k_1(1,0) ) / dt ;\n\t\tR_k_dot(1,1)\t= ( R_k(1,1) - R_k_1(1,1) ) / dt ;\n\t\tR_k_dot(1,2)\t= ( R_k(1,2) - R_k_1(1,2) ) / dt ;\n\t\tR_k_dot(2,0)\t= ( R_k(2,0) - R_k_1(2,0) ) / dt ;\n\t\tR_k_dot(2,1)\t= ( R_k(2,1) - R_k_1(2,1) ) / dt ;\n\t\tR_k_dot(2,2)\t= ( R_k(2,2) - R_k_1(2,2) ) / dt ;\n\n\n\t\t\n\t\tR_k_dot2(0,0)\t= 2*(q_k(0)*q_k_dot(0) + q_k(1)*q_k_dot(1) - q_k(2)*q_k_dot(2) - q_k(3)*q_k_dot(3));\n\t\tR_k_dot2(0,1)\t= 2*(q_k_dot(1)*q_k(2) + q_k(1)*q_k_dot(2) - q_k_dot(0)*q_k(3) - q_k(0)*q_k_dot(3));\n\t\tR_k_dot2(0,2)\t= 2*(q_k_dot(1)*q_k(3) + q_k(1)*q_k_dot(3) + q_k_dot(0)*q_k(2) + q_k(0)*q_k_dot(2));\n\t\tR_k_dot2(1,0)\t= 2*(q_k_dot(1)*q_k(2) + q_k(1)*q_k_dot(2) + q_k_dot(0)*q_k(3) + q_k(0)*q_k_dot(3));\n\t\tR_k_dot2(1,1)\t= 2*(q_k(0)*q_k_dot(0) - q_k(1)*q_k_dot(1) + q_k(2)*q_k_dot(2) - q_k(3)*q_k_dot(3));\n\t\tR_k_dot2(1,2)\t= 2*(q_k_dot(2)*q_k(3) + q_k(2)*q_k_dot(3) - q_k_dot(0)*q_k(1) - q_k(0)*q_k_dot(1));\n\t\tR_k_dot2(2,0)\t= 2*(q_k_dot(1)*q_k(3) + q_k(1)*q_k_dot(3) - q_k_dot(0)*q_k(2) - q_k(0)*q_k_dot(2));\n\t\tR_k_dot2(2,1)\t= 2*(q_k_dot(2)*q_k(3) + q_k(2)*q_k_dot(3) + q_k_dot(0)*q_k(1) + q_k(0)*q_k_dot(1));\n\t\tR_k_dot2(2,2)\t= 2*(q_k(0)*q_k_dot(0) + q_k(1)*q_k_dot(1) - q_k(2)*q_k_dot(2) - q_k(3)*q_k_dot(3));\n\n\t\n\n\t\tS_w2 = R_k_dot2 * R_k.transpose() ;\n\n\t\tS_w = R_k_dot * R_k.transpose() ;\t\t\t//body_frame\n\t\t\n\n/*\n\t\n\t\tstd::cout<<\"---------------SAMPLING_TIME--------------------\"<< endl;\n\t\tstd::cout<< dt << endl;\n\t\tstd::cout<<\"------------------------------------------------\"<< endl;\n\n*/\n\t\t\n\n\t\tstd::cout<<\"----------------ROTATION_MATRIX-----------------\"<< endl;\n\t\tstd::cout<< R_k << endl;\n\t\tstd::cout<<\"------------------------------------------------\"<< endl;\n\n\n\n\n\n \tstd::cout<<\"-------------DOT_ROTATION_MATRIX----------------\"<< endl;\n\t\tstd::cout<< R_k_dot << endl;\n\t\tstd::cout<<\"------------------------------------------------\"<< endl;\n\n\n\n\t\tstd::cout<<\"-----------------SKEW_MATRIX--------------------\"<< endl;\n\t\tstd::cout<< S_w << endl;\n\t\tstd::cout<<\"------------------------------------------------\"<< endl;\n\n\n/*\n\n\t std::cout<<\"----------2_____________DOT_ROTATION_MATRIX----------------\"<< endl;\n\t\tstd::cout<< R_k_dot2 << endl;\n\t\tstd::cout<<\"------------------------------------------------\"<< endl;\n\n\n\n\n\t\tstd::cout<<\"----------2_______SKEW_MATRIX--------------------\"<< endl;\n\t\tstd::cout<< S_w2 << endl;\n\t\tstd::cout<<\"------------------------------------------------\"<< endl;\n\n\n*/\n\n\t\tR_k_1 = R_k ;\n\n\t\tq_k_1 = q_k ;\n\n}\n\n\n\n\nint main(int argc, char** argv)\n{\n \n\t//inizializzazione nodo \n\tros::init(argc, argv, \"skew\");// ROS node\n ros::NodeHandle nn;\n\n\n\tcout<<\"1\"<\n#include \n\n#include \n#include \n#include \n\n\n\ntypedef CGAL::Simple_cartesian K;\n\n\n// The points are stored in a flat array of doubles\n// The triangles are stored in a flat array of indices\n// referring to an array of coordinates: three consecutive\n// coordinates represent a point, and three consecutive\n// indices represent a triangle.\n\ntypedef size_t* Point_index_iterator;\n\n// Let us now define the iterator on triangles that the tree needs:\nclass Triangle_iterator\n : public boost::iterator_adaptor<\n Triangle_iterator // Derived\n , Point_index_iterator // Base\n , boost::use_default // Value\n , boost::forward_traversal_tag // CategoryOrTraversal\n >\n{\npublic:\n Triangle_iterator()\n : Triangle_iterator::iterator_adaptor_() {}\n\n explicit Triangle_iterator(Point_index_iterator p)\n : Triangle_iterator::iterator_adaptor_(p) {}\n\nprivate:\n friend class boost::iterator_core_access;\n void increment() { this->base_reference() += 3; }\n};\n\n\n// The following primitive provides the conversion facilities between\n// my own triangle and point types and the CGAL ones\nstruct My_triangle_primitive {\npublic:\n typedef Triangle_iterator Id;\n\n // the CGAL types returned\n typedef K::Point_3 Point;\n typedef K::Triangle_3 Datum;\n\n // a static pointer to the vector containing the points\n // is needed to build the triangles on the fly:\n static const double* point_container;\n\nprivate:\n Id m_it; // this is what the AABB tree stores internally\n\npublic:\n My_triangle_primitive() {} // default constructor needed\n\n // the following constructor is the one that receives the iterators from the\n // iterator range given as input to the AABB_tree\n My_triangle_primitive(Triangle_iterator a)\n : m_it(a) {}\n\n Id id() const { return m_it; }\n\n // on the fly conversion from the internal data to the CGAL types\n Datum datum() const\n {\n Point_index_iterator p_it = m_it.base();\n Point p(*(point_container + 3 * (*p_it)),\n *(point_container + 3 * (*p_it) + 1),\n *(point_container + 3 * (*p_it) + 2) );\n ++p_it;\n Point q(*(point_container + 3 * (*p_it)),\n *(point_container + 3 * (*p_it) + 1),\n *(point_container + 3 * (*p_it) + 2));\n ++p_it;\n Point r(*(point_container + 3 * (*p_it)),\n *(point_container + 3 * (*p_it) + 1),\n *(point_container + 3 * (*p_it) + 2));\n\n return Datum(p, q, r); // assembles triangle from three points\n }\n\n // one point which must be on the primitive\n Point reference_point() const\n {\n return Point(*(point_container + 3 * (*m_it)),\n *(point_container + 3 * (*m_it) + 1),\n *(point_container + 3 * (*m_it) + 2));\n }\n};\n\n\n// types\ntypedef CGAL::AABB_traits My_AABB_traits;\ntypedef CGAL::AABB_tree Tree;\nconst double* My_triangle_primitive::point_container = 0;\n\nint main()\n{\n // generates point set\n double points[12];\n My_triangle_primitive::point_container = points;\n points[0] = 1.0; points[1] = 0.0; points[2] = 0.0;\n points[3] = 0.0; points[4] = 1.0; points[5] = 0.0;\n points[6] = 0.0; points[7] = 0.0; points[8] = 1.0;\n points[9] = 0.0; points[10] = 0.0; points[11] = 0.0;\n\n\n // generates indexed triangle set\n size_t triangles[9];\n triangles[0] = 0; triangles[1] = 1; triangles[2] = 2;\n triangles[3] = 0; triangles[4] = 1; triangles[5] = 3;\n triangles[6] = 0; triangles[7] = 3; triangles[8] = 2;\n\n // constructs AABB tree\n Tree tree(Triangle_iterator(triangles),\n Triangle_iterator(triangles+9));\n\n // counts #intersections\n K::Ray_3 ray_query(K::Point_3(0.2, 0.2, 0.2), K::Point_3(0.0, 1.0, 0.0));\n std::cout << tree.number_of_intersected_primitives(ray_query)\n << \" intersections(s) with ray query\" << std::endl;\n\n // computes closest point\n K::Point_3 point_query(2.0, 2.0, 2.0);\n K::Point_3 closest_point = tree.closest_point(point_query);\n std::cout << \"closest point to \" << point_query << \" is: \" << closest_point.x() << \" \" << closest_point.y() << \" \" << closest_point.z() << std::endl;\n\n return EXIT_SUCCESS;\n}\n\n\n", "meta": {"hexsha": "d15c7155cd9140c09acfdf493632bc8a69be322a", "size": 4418, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "AABB_tree/examples/AABB_tree/AABB_custom_indexed_triangle_set_array_example.cpp", "max_stars_repo_name": "gaschler/cgal", "max_stars_repo_head_hexsha": "d1fe2afa18da5524db6d4946f42ca4b8d00e0bda", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2020-12-12T09:30:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-04T05:00:23.000Z", "max_issues_repo_path": "AABB_tree/examples/AABB_tree/AABB_custom_indexed_triangle_set_array_example.cpp", "max_issues_repo_name": "guorongtao/cgal", "max_issues_repo_head_hexsha": "a848e52552a9205124b7ae13c7bcd2b860eb4530", "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": "AABB_tree/examples/AABB_tree/AABB_custom_indexed_triangle_set_array_example.cpp", "max_forks_repo_name": "guorongtao/cgal", "max_forks_repo_head_hexsha": "a848e52552a9205124b7ae13c7bcd2b860eb4530", "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": 31.7841726619, "max_line_length": 153, "alphanum_fraction": 0.6349026709, "num_tokens": 1191, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802370707281, "lm_q2_score": 0.5813030906443133, "lm_q1q2_score": 0.44706871876267545}} {"text": "//==================================================================================================\n/*!\n @file\n\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_SCALAR_FUNCTION_HYPOT_HPP_INCLUDED\n#define BOOST_SIMD_ARCH_COMMON_SCALAR_FUNCTION_HYPOT_HPP_INCLUDED\n#include \n#include \n\n\n#ifndef BOOST_SIMD_NO_INVALIDS\n#include \n#include \n#include \n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost { namespace simd { namespace ext\n{\n namespace bd = boost::dispatch;\n namespace bs = boost::simd;\n BOOST_DISPATCH_OVERLOAD ( hypot_\n , (typename A0)\n , bd::cpu_\n , bd::scalar_ >\n , bd::scalar_ >\n )\n {\n\n BOOST_FORCEINLINE A0 operator() ( A0 a0, A0 a1) const BOOST_NOEXCEPT\n {\n using i_t = bd::as_integer_t;\n #ifndef BOOST_SIMD_NO_INVALIDS\n if (is_nan(a0) && is_inf(a1)) return Inf();\n if (is_inf(a0) && is_nan(a1)) return Inf();\n #endif\n A0 r = bs::abs(a0);\n A0 i = bs::abs(a1);\n i_t e = exponent(bs::max(i, r));\n e = bs::min(bs::max(e,Minexponent()),Maxexponentm1());\n return bs::ldexp(sqrt(sqr(bs::ldexp(r, -e))+sqr(bs::ldexp(i, -e))), e);\n }\n };\n\n BOOST_DISPATCH_OVERLOAD ( hypot_\n , (typename A0)\n , bd::cpu_\n , bd::scalar_ >\n , bd::scalar_ >\n , boost::simd::std_tag\n )\n {\n\n BOOST_FORCEINLINE A0 operator() ( A0 a0, A0 a1\n , std_tag const&) const BOOST_NOEXCEPT\n {\n return std::hypot(a0, a1);\n }\n };\n} } }\n\n\n#endif\n", "meta": {"hexsha": "6096eaa8b09cee3f56dc7a1cabe432074ad89027", "size": 2837, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/boost/simd/arch/common/scalar/function/hypot.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/hypot.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/hypot.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.7738095238, "max_line_length": 100, "alphanum_fraction": 0.5720831865, "num_tokens": 699, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802264851919, "lm_q2_score": 0.5813030906443133, "lm_q1q2_score": 0.4470687126092705}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \"utlt.h\"\n#include \"OneD_system_solve.h\"\n#include \"OneD_exciton_TDDFT_Linear_resp.h\"\n\nusing namespace std;\nusing Eigen::VectorXd;\n\nint main()\n{\n\tclock_t t_begin,t_end;\n\tt_begin=clock();\n\tint band_considered(3), gridnum(150), kpointnum(151);\n\tdouble amplitude1(3.5645),amplitude2(1.0);\n\tVectorXd w1(2), h1(w1.rows());\n\t// w1<<2.4, 0.6; h1<<0.0, 8.0;\n\tw1<<0.5, 0.5; h1<<0.0, 20.0;\n\tVectorXd w2(4), h2(w2.rows());\n\tw2<<2.4, 0.6, 2.8, 0.2;\n\th2<<0.0, 8.0, 0.0, 10.0;\n\t// --------------------------------------------------------------------------------\n\tOneD_system KP_model(w1, h1, \"My_kp_model\", gridnum, kpointnum, band_considered);\n\tcout<\n#include \n#include \n\nusing boost::program_options::variables_map;\nusing boost::program_options::options_description;\nusing boost::program_options::value;\nusing boost::program_options::store;\nusing boost::program_options::parse_command_line;\n\nusing boost::shared_ptr;\nusing std::min;\nusing std::vector;\n\n\nvoid jacobi_kernel_wrap(size_t y_begin, size_t y_end, size_t n, vector & dst, vector const & src) {\n for(size_t y = y_begin; y < y_end; ++y) {\n size_t offset = y * n;\n for(size_t x = offset + 1; x < offset + n-1; ++x) {\n dst[x] = (src[x-n] + src[x+n] + src[x] + src[x-1] + src[x+1]) * 0.2;\n }\n }\n}\n\nvoid jacobi( size_t n , size_t iterations, size_t block_size, std::string output_filename) {\n shared_ptr< vector > grid_new(new vector(n * n, 1));\n shared_ptr< vector > grid_old(new vector(n * n, 1));\n\n size_t n_block = static_cast(std::ceil(double(n)/block_size));\n\n#pragma omp parallel \n{\n#pragma omp single\n{\n auto start = std::chrono::high_resolution_clock::now();\n\n for(size_t i = 0; i < iterations; ++i) {\n for(size_t y = 1, j = 0; y < n - 1; y += block_size, ++j) {\n size_t y_end = min(y + block_size, n - 1);\n\n double *dest = (*grid_new).data();\n double *src = (*grid_old).data();\n\n#pragma omp task firstprivate(y, y_end, grid_new, grid_old) depend(inout: dest[y*n], src[y*n])\n {\n jacobi_kernel_wrap(y, y_end, n, boost::ref(*grid_new), boost::cref(*grid_old));\n }\n std::swap(grid_new, grid_old);\n }\n }\n#pragma omp taskwait\n auto end = std::chrono::high_resolution_clock::now();\n double elapsed = std::chrono::duration_cast< std::chrono::duration >(end-start).count();\n jacobi_smp::report_timing(n, iterations, elapsed);\n jacobi_smp::output_grid(output_filename, *grid_old, n);\n}}\n\n}\n\n\nint main(int argc, char **argv)\n{\n options_description\n desc_cmd(\"usage: jacobi_omp [options]\");\n\n desc_cmd.add_options()\n (\n \"n\", value()->default_value(16)\n , \"Will run on grid with dimensions (n x n)\"\n )\n (\n \"iterations\", value()->default_value(1000)\n , \"Number of iterations\"\n )\n (\n \"block-size\", value()->default_value(256)\n , \"Block size of the different chunks to calculate in parallel\"\n )\n (\n \"output-filename\", value()\n , \"Filename of the result (if empty no result is written)\"\n );\n\n variables_map vm;\n store(parse_command_line( argc, argv, desc_cmd), vm);\n boost::program_options::notify(vm);\n\n std::size_t n = vm[\"n\"].as();\n std::size_t iterations = vm[\"iterations\"].as();\n std::size_t block_size = vm[\"block-size\"].as();\n\n std::string output_filename;\n if(vm.count(\"output-filename\"))\n {\n output_filename = vm[\"output-filename\"].as();\n }\n\n jacobi(n, iterations, block_size, output_filename);\n\n return 0;\n}\n", "meta": {"hexsha": "020a92f9edc00f95957d759621e9dd7ea4329498", "size": 3401, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/hpx/jacobi_smp/jacobi_omp.cpp", "max_stars_repo_name": "tianyi93/hpxMP_mirror", "max_stars_repo_head_hexsha": "668e8881a6f2f437a614ae92e205ae49f083691e", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 22.0, "max_stars_repo_stars_event_min_datetime": "2018-07-16T14:39:17.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-08T11:25:09.000Z", "max_issues_repo_path": "examples/hpx/jacobi_smp/jacobi_omp.cpp", "max_issues_repo_name": "tianyi93/hpxMP_mirror", "max_issues_repo_head_hexsha": "668e8881a6f2f437a614ae92e205ae49f083691e", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 25.0, "max_issues_repo_issues_event_min_datetime": "2018-06-18T14:59:09.000Z", "max_issues_repo_issues_event_max_datetime": "2019-10-16T20:43:57.000Z", "max_forks_repo_path": "examples/hpx/jacobi_smp/jacobi_omp.cpp", "max_forks_repo_name": "tianyi93/hpxMP_mirror", "max_forks_repo_head_hexsha": "668e8881a6f2f437a614ae92e205ae49f083691e", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2018-06-22T18:44:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-21T11:17:28.000Z", "avg_line_length": 31.2018348624, "max_line_length": 115, "alphanum_fraction": 0.6218759188, "num_tokens": 909, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7057850278370114, "lm_q2_score": 0.6334102567576901, "lm_q1q2_score": 0.4470514756979748}} {"text": "#include \n#include \n\n#include \n#include \n\n#include \n\n#include \nnamespace po = boost::program_options;\n\nusing namespace std;\n\n#include \"PolyhedralSurf.h\"\n#include \"PolyhedralSurf_operations.h\"\n#include \"PolyhedralSurf_rings.h\"\n\n//Kernel of the PolyhedralSurf\ntypedef double DFT;\ntypedef CGAL::Simple_cartesian Data_Kernel;\ntypedef Data_Kernel::Point_3 DPoint;\ntypedef Data_Kernel::Vector_3 DVector;\n\n//HDS\ntypedef PolyhedralSurf::Vertex_handle Vertex_handle;\ntypedef PolyhedralSurf::Vertex Vertex;\ntypedef PolyhedralSurf::Halfedge_handle Halfedge_handle;\ntypedef PolyhedralSurf::Halfedge Halfedge;\ntypedef PolyhedralSurf::Vertex_iterator Vertex_iterator;\ntypedef PolyhedralSurf::Facet_handle Facet_handle;\ntypedef PolyhedralSurf::Facet Facet;\n\nstruct Hedge_cmp{\n bool operator()(Halfedge_handle a, Halfedge_handle b) const{\n return &*a < &*b;\n }\n};\n\nstruct Facet_cmp{\n bool operator()(Facet_handle a, Facet_handle b) const{\n return &*a < &*b;\n }\n};\n\n//Vertex property map, with std::map\ntypedef std::map Vertex2int_map_type;\ntypedef boost::associative_property_map< Vertex2int_map_type > Vertex_PM_type;\ntypedef T_PolyhedralSurf_rings Poly_rings;\n\n//Hedge property map, with enriched Halfedge with its length\n// typedef HEdge_PM Hedge_PM_type;\n// typedef T_PolyhedralSurf_hedge_ops Poly_hedge_ops;\n//Hedge property map, with std::map\ntypedef std::map Hedge2double_map_type;\ntypedef boost::associative_property_map Hedge_PM_type;\ntypedef T_PolyhedralSurf_hedge_ops Poly_hedge_ops;\n\n// //Facet property map with enriched Facet with its normal\n// typedef Facet_PM Facet_PM_type;\n// typedef T_PolyhedralSurf_facet_ops Poly_facet_ops;\n//Facet property map, with std::map\ntypedef std::map Facet2normal_map_type;\ntypedef boost::associative_property_map Facet_PM_type;\ntypedef T_PolyhedralSurf_facet_ops Poly_facet_ops;\n\ntypedef double LFT;\ntypedef CGAL::Simple_cartesian Local_Kernel;\ntypedef CGAL::Monge_via_jet_fitting My_Monge_via_jet_fitting;\ntypedef My_Monge_via_jet_fitting::Monge_form My_Monge_form;\n\n\n// default parameter values and global variables\nunsigned int d_fitting = 2;\nunsigned int d_monge = 2;\nunsigned int nb_rings = 0;//seek min # of rings to get the required #pts\nunsigned int nb_points_to_use = 0;//\nbool verbose = false;\nunsigned int min_nb_points = (d_fitting + 1) * (d_fitting + 2) / 2;\n\n\n//gather points around the vertex v using rings on the\n//polyhedralsurf. the collection of points resorts to 3 alternatives:\n// 1. the exact number of points to be used\n// 2. the exact number of rings to be used\n// 3. nothing is specified\nvoid gather_fitting_points(Vertex* v,\n std::vector &in_points,\n Vertex_PM_type& vpm)\n{\n //container to collect vertices of v on the PolyhedralSurf\n std::vector gathered;\n //initialize\n in_points.clear();\n\n //OPTION -p nb_points_to_use, with nb_points_to_use != 0. Collect\n //enough rings and discard some points of the last collected ring to\n //get the exact \"nb_points_to_use\"\n if ( nb_points_to_use != 0 ) {\n Poly_rings::collect_enough_rings(v, nb_points_to_use, gathered, vpm);\n if ( gathered.size() > nb_points_to_use ) gathered.resize(nb_points_to_use);\n }\n else { // nb_points_to_use=0, this is the default and the option -p is not considered;\n // then option -a nb_rings is checked. If nb_rings=0, collect\n // enough rings to get the min_nb_points required for the fitting\n // else collect the nb_rings required\n if ( nb_rings == 0 )\n Poly_rings::collect_enough_rings(v, min_nb_points, gathered, vpm);\n else Poly_rings::collect_i_rings(v, nb_rings, gathered, vpm);\n }\n\n //store the gathered points\n std::vector::iterator\n itb = gathered.begin(), ite = gathered.end();\n CGAL_For_all(itb,ite) in_points.push_back((*itb)->point());\n}\n\n///////////////MAIN///////////////////////////////////////////////////////\n#if defined(CGAL_USE_BOOST_PROGRAM_OPTIONS) && ! defined(DONT_USE_BOOST_PROGRAM_OPTIONS)\nint main(int argc, char *argv[])\n#else\nint main()\n#endif\n{\n string if_name_string;\n string if_name; //input file name\n string w_if_name; //as above, but / replaced by _\n string res4openGL_fname;\n string verbose_fname;\n std::ofstream out_4ogl, out_verbose;\n\n try {\n#if defined(CGAL_USE_BOOST_PROGRAM_OPTIONS) && ! defined(DONT_USE_BOOST_PROGRAM_OPTIONS)\n po::options_description desc(\"Allowed options\");\n desc.add_options()\n (\"help,h\", \"produce help message.\")\n (\"input-file,f\", po::value(&if_name_string)->default_value(CGAL::data_file_path(\"meshes/ellipe0.003.off\")),\n \"name of the input off file\")\n (\"degree-jet,d\", po::value(&d_fitting)->default_value(2),\n \"degree of the jet, 1 <= degre-jet <= 4\")\n (\"degree-monge,m\", po::value(&d_monge)->default_value(2),\n \"degree of the Monge rep, 1 <= degree-monge <= degree-jet\")\n (\"nb-rings,a\", po::value(&nb_rings)->default_value(0),\n \"number of rings to collect neighbors. 0 means collect enough rings to make appro possible a>=1 fixes the nb of rings to be collected\")\n (\"nb-points,p\", po::value(&nb_points_to_use)->default_value(0),\n \"number of neighbors to use. 0 means this option is not considered, this is the default p>=1 fixes the nb of points to be used\")\n (\"verbose,v\", po::value(&verbose)->default_value(false),\n \"verbose output on text file\")\n ;\n\n po::variables_map vm;\n po::store(po::parse_command_line(argc, argv, desc), vm);\n po::notify(vm);\n\n if (vm.count(\"help\")) {\n cout << desc << \"\\n\";\n return 1;\n }\n#else\n std::cerr << \"Command-line options require Boost.ProgramOptions\" << std::endl;\n if_name_string = CGAL::data_file_path(\"meshes/ellipe0.003.off\");\n d_fitting = 2;\n d_monge = 2;\n nb_rings = 0;\n nb_points_to_use = 0;\n verbose = false;\n#endif\n }\n catch(exception& e) {\n cerr << \"error: \" << e.what() << \"\\n\";\n return 1;\n }\n catch(...) {\n cerr << \"Exception of unknown type!\\n\";\n }\n\n //modify global variables which are fct of options:\n min_nb_points = (d_fitting + 1) * (d_fitting + 2) / 2;\n if (nb_points_to_use < min_nb_points && nb_points_to_use != 0)\n {std::cerr << \"the nb of points asked is not enough to perform the fitting\" << std::endl; exit(0);}\n\n //prepare output file names\n //--------------------------\n std::cerr << \"if_name_string\" << if_name_string << std::endl;\n if_name = if_name_string;\n\n w_if_name = if_name;\n for(unsigned int i=0; i\n //------------------------------\n PolyhedralSurf P;\n std::ifstream stream(if_name.c_str());\n stream >> P;\n std::cout << \"loadMesh... \"<< \"Polysurf with \" << P.size_of_vertices()\n << \" vertices and \" << P.size_of_facets()\n << \" facets. \" << std::endl;\n\n if(verbose)\n out_verbose << \"Polysurf with \" << P.size_of_vertices()\n << \" vertices and \" << P.size_of_facets()\n << \" facets. \" << std::endl;\n //exit if not enough points in the model\n if (min_nb_points > P.size_of_vertices()) exit(0);\n\n //create property maps\n //-----------------------------\n //Vertex, using a std::map\n Vertex2int_map_type vertex2props;\n Vertex_PM_type vpm(vertex2props);\n\n //Hedge, with enriched hedge\n //HEdgePM_type hepm = get_hepm(boost::edge_weight_t(), P);\n //Hedge, using a std::map\n Hedge2double_map_type hedge2props;\n Hedge_PM_type hepm(hedge2props);\n\n //Facet PM, with enriched Facet\n //FacetPM_type fpm = get_fpm(boost::vertex_attribute_t(), P);\n //Facet PM, with std::map\n Facet2normal_map_type facet2props;\n Facet_PM_type fpm(facet2props);\n\n //initialize Polyhedral data : length of edges, normal of facets\n Poly_hedge_ops::compute_edges_length(P, hepm);\n Poly_facet_ops::compute_facets_normals(P, fpm);\n\n //MAIN LOOP: perform calculation for each vertex\n //----------------------------------------------\n std::vector in_points; //container for data points\n Vertex_iterator vitb, vite;\n\n //initialize the tag of all vertices to -1\n vitb = P.vertices_begin(); vite = P.vertices_end();\n CGAL_For_all(vitb,vite) put(vpm, &(*vitb), -1);\n\n vitb = P.vertices_begin(); vite = P.vertices_end();\n for (; vitb != vite; vitb++) {\n //initialize\n Vertex* v = &(*vitb);\n in_points.clear();\n My_Monge_form monge_form;\n\n //gather points around the vertex using rings\n gather_fitting_points(v, in_points, vpm);\n\n //skip if the nb of points is to small\n if ( in_points.size() < min_nb_points )\n {std::cerr << \"not enough pts for fitting this vertex\" << in_points.size() << std::endl;\n continue;}\n\n // perform the fitting\n My_Monge_via_jet_fitting monge_fit;\n monge_form = monge_fit(in_points.begin(), in_points.end(),\n d_fitting, d_monge);\n //switch min-max ppal curv/dir wrt the mesh orientation\n const DVector normal_mesh = Poly_facet_ops::compute_vertex_average_unit_normal(v, fpm);\n monge_form.comply_wrt_given_normal(normal_mesh);\n\n //OpenGL output. Scaling for ppal dir, may be optimized with a\n //global mean edges length computed only once on all edges of P\n DFT scale_ppal_dir = Poly_hedge_ops::compute_mean_edges_length_around_vertex(v, hepm)/2;\n\n out_4ogl << v->point() << \" \";\n monge_form.dump_4ogl(out_4ogl, scale_ppal_dir);\n\n //verbose txt output\n if (verbose) {\n std::vector::iterator itbp = in_points.begin(), itep = in_points.end();\n out_verbose << \"in_points list : \" << std::endl ;\n for (;itbp!=itep;itbp++) out_verbose << *itbp << std::endl ;\n\n out_verbose << \"--- vertex \" << ++nb_vertices_considered\n << \" : \" << v->point() << std::endl\n << \"number of points used : \" << in_points.size() << std::endl\n ;// << monge_form;\n }\n } //all vertices processed\n\n //cleanup filenames\n //------------------\n out_4ogl.close();\n if(verbose) {\n out_verbose.close();\n }\n return 0;\n}\n", "meta": {"hexsha": "eb100d51f6ae10028f01d8dfa1334c5b0b10899b", "size": 11148, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Jet_fitting_3/examples/Jet_fitting_3/Mesh_estimation.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": "Jet_fitting_3/examples/Jet_fitting_3/Mesh_estimation.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": "Jet_fitting_3/examples/Jet_fitting_3/Mesh_estimation.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": 36.7920792079, "max_line_length": 142, "alphanum_fraction": 0.6817366344, "num_tokens": 3074, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7057850278370111, "lm_q2_score": 0.6334102498375401, "lm_q1q2_score": 0.44705147081383645}} {"text": "\n\n#include\n#include \n#include\"numerics.hpp\"\n#include\"reddm.hpp\"\n#include\"tpoperators.hpp\"\n#include \"files.hpp\"\n#include \n\nusing namespace boost::program_options;\nusing namespace Many_Body;\nint main(int argc, char *argv[])\n{\n using Mat= Operators::Mat;\n size_t M{};\n size_t L{};\n double t0{};\n double omega{};\n double gamma{};\n bool PB{};\n try\n {\n options_description desc{\"Options\"};\n desc.add_options()\n (\"help,h\", \"Help screen\")\n (\"L\", value(&L)->default_value(4), \"L\")\n (\"M\", value(&M)->default_value(2), \"M\")\n (\"t\", value(&t0)->default_value(1.), \"t0\")\n (\"gam\", value(&gamma)->default_value(1.), \"gamma\")\n (\"omg\", value(&omega)->default_value(1.), \"omega\")\n (\"pb\", value(&PB)->default_value(true), \"PB\");\n \n\n\n variables_map vm;\n store(parse_command_line(argc, argv, desc), vm);\n notify(vm);\n\n if (vm.count(\"help\"))\n {std::cout << desc << '\\n'; return 0;}\n else{\n if (vm.count(\"L\"))\n { std::cout << \"L: \" << vm[\"L\"].as() << '\\n';\n\t\n }\n if (vm.count(\"M,m\"))\n {\n\tstd::cout << \"M: \" << vm[\"M\"].as() << '\\n';\n\t\n }\n if (vm.count(\"t\"))\n {\n\tstd::cout << \"t0: \" << vm[\"t\"].as() << '\\n';\t\n }\n if (vm.count(\"omg\"))\n {\n\tstd::cout << \"omega: \" << vm[\"omg\"].as() << '\\n';\n }\n if (vm.count(\"gam\"))\n {\n\tstd::cout << \"gamma: \" << vm[\"gam\"].as() << '\\n';\n }\n if (vm.count(\"pb\"))\n {\n\tstd::cout << \"PB: \" << vm[\"pb\"].as() << '\\n';\n }\n }\n }\n catch (const error &ex)\n {\n std::cerr << ex.what() << '\\n';\n return 0;\n }\n\n \nusing HolsteinBasis= TensorProduct;\n // std::vector ee(L, 0);\n // ee[L-1]=1;\n // ElectronState aa(ee);\n // ElectronBasis e(aa);\n ElectronBasis e( L, 1);\n // std::cout<< e<0.00001){\n\t // \tif(std::abs(HH(j, i)-HH(i, j))>0.000001){ std::cout<< \"err \"< Tr={0.0100, 0.1000, 1.000, 2.0000, 5.0000, 10.0000};\n // \t // for(auto t: Tr){\n // \t // std::string sT=std::string(std::to_string(t)).substr(0,6);\n // auto t=0.5;\n // \t auto optModes=makeThermalRDMTP(HH,ev, TP, t, isDiag, 0);\n // \t // //\t std::cout << \"sum of all eigenvalues \"<< optModes.sum()<< std::endl;\n // \t // isDiag=true;\n // \t int n=0;\n\t \n // \t for(auto& l : optModes)\n // \t {\n // \t \t std::string sn=std::string(std::to_string(n)).substr(0,1);\n // \t\t //std::string filename=\"OML\"+std::to_string(L)+\"M\"+std::to_string(M)+\"t0_\"+\"1.0\"+\"gam\"+sgam+\"omg\"+ somg+\"T\"+ sT+ \"esec\" +sn + \".bin\";\n // \t\t std::cout << n << std::endl;\n // \t\t std::cout<< \"value \"<< \" fot T = \"<< t <\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 QuantLib;\n\nnamespace QLExtension {\n\t// penalty function class for multiple curve\n\ttemplate \n\tclass MultiCurvePenaltyFunction : public CostFunction {\n\tpublic:\n\t\ttypedef typename Curve::traits_type Traits;\n\t\ttypedef typename Traits::helper helper;\n\t\ttypedef\n\t\t\ttypename std::vector< boost::shared_ptr >::const_iterator helper_iterator;\n\n\t\tMultiCurvePenaltyFunction(std::vector curves,\n\t\t\tstd::vector initialIndexes,\n\t\t\tstd::vector rateHelpersStarts,\n\t\t\tstd::vector rateHelpersEnds)\n\t\t\t: curves_(curves), initialIndexes_(initialIndexes),\n\t\t\trateHelpersStarts_(rateHelpersStarts), rateHelpersEnds_(rateHelpersEnds) {\n\t\t}\n\n\t\tReal value(const Array& x) const;\n\t\tDisposable values(const Array& x) const;\n\n\tprivate:\n\t\tstd::vector curves_;\n\t\tstd::vector initialIndexes_;\n\t\tstd::vector rateHelpersStarts_;\n\t\tstd::vector rateHelpersEnds_;\n\t};\n\n\n\ttemplate \n\tclass MultiCurveOptimizer : public LazyObject {\n\tpublic:\n\t\tMultiCurveOptimizer(bool forcePositive = true)\n\t\t\t: accuracy_(1.0e-12), forcePositive_(forcePositive){};\n\t\tvoid addTermStructure(Curve* c) {\n\t\t\tfor (Size i = 0; iinstruments_.size(); ++i){\n\t\t\t\tthis->registerWith(c->instruments_[i]);\n\t\t\t}\n\t\t\tts_.push_back(c);\n\t\t\taccuracy_ = accuracy_ > c->accuracy_ ? c->accuracy_ : accuracy_;\n\t\t};\n\t\tvoid optimize() const { calculate(); };\n\t\t//! \\name Observer interface\n\t\t//@{\n\t\tvoid update();\n\t\t//@}\n\tprivate:\n\t\t//! \\name LazyObject interface\n\t\t//@{\n\t\tvoid performCalculations() const;\n\t\t//@}\n\t\tReal accuracy_;\n\t\tbool forcePositive_;\n\t\tstd::vector ts_;\n\t};\n\n\ttemplate \n\tvoid MultiCurveOptimizer::update() {\n\t\tLazyObject::update();\n\t}\n\n\ttemplate \n\tvoid MultiCurveOptimizer::performCalculations() const {\n\n\t\tstd::vector initialIndexes;\n\t\tstd::vector< typename MultiCurvePenaltyFunction::helper_iterator > rateHelpersStarts;\n\t\tstd::vector< typename MultiCurvePenaltyFunction::helper_iterator > rateHelpersEnds;\n\n\t\tSize nInsts = 0;\n\t\tfor (Size i = 0; i < ts_.size(); i++) {\n\t\t\tts_[i]->bootstrap_.initialize();\n\t\t\tnInsts += ts_[i]->instruments_.size();\n\t\t\tinitialIndexes.push_back(1);\n\t\t\trateHelpersStarts.push_back(ts_[i]->instruments_.begin());\n\t\t\trateHelpersEnds.push_back(ts_[i]->instruments_.end());\n\t\t}\n\n\t\tLevenbergMarquardt solver(accuracy_,\n\t\t\taccuracy_,\n\t\t\taccuracy_);\n\n\t\tEndCriteria endCriteria(20 * nInsts, 10, 0.00, accuracy_, 0.00);\n\t\tPositiveConstraint posConstraint;\n\t\tNoConstraint noConstraint;\n\t\tConstraint& solverConstraint = forcePositive_ ?\n\t\t\tstatic_cast(posConstraint) :\n\t\t\tstatic_cast(noConstraint);\n\n\t\tArray startArray(nInsts);\n\n\t\tSize pos = 0;\n\t\tfor (Size i = 0; i < ts_.size(); i++) {\n\t\t\tfor (Size j = 0; j < ts_[i]->instruments_.size(); j++) {\n\t\t\t\tstartArray[pos] = ts_[i]->data_[j + initialIndexes[i]];\n\t\t\t\tpos++;\n\t\t\t}\n\t\t}\n\n\t\tMultiCurvePenaltyFunction currentCost(\n\t\t\tts_,\n\t\t\tinitialIndexes,\n\t\t\trateHelpersStarts,\n\t\t\trateHelpersEnds);\n\n\t\tProblem toSolve(currentCost, solverConstraint, startArray);\n\n\t\tEndCriteria::Type endType = solver.minimize(toSolve, endCriteria);\n\n\t\t// check the end criteria\n\t\tQL_REQUIRE(endType == EndCriteria::StationaryFunctionAccuracy ||\n\t\t\tendType == EndCriteria::StationaryFunctionValue,\n\t\t\t\"Unable to strip yieldcurve to required accuracy \");\n\n\n\t}\n\n\t//! multiple bootstrapper for simultanaous bootstrap of multiple curves.\n\t/*!\n\t\\TODO: template should be unique for all curves.\n\t*/\n\ttemplate \n\tclass MultiBootstrap {\n\t\ttypedef typename Curve::traits_type Traits;\n\t\ttypedef typename Curve::interpolator_type Interpolator;\n\tpublic:\n\n\t\tMultiBootstrap(boost::shared_ptr > optimizer =\n\t\t\tboost::shared_ptr >(new MultiCurveOptimizer()));\n\t\tvoid setup(Curve* ts);\n\t\tvoid calculate() const;\n\n\tprivate:\n\t\tfriend MultiCurveOptimizer;\n\t\tvoid initialize() const;\n\t\tmutable bool validCurve_;\n\t\tCurve* ts_;\n\t\tboost::shared_ptr > multiCurveOptimizer_;\n\t};\n\n\n\t// template definitions\n\n\ttemplate \n\tMultiBootstrap::MultiBootstrap(boost::shared_ptr > optimizer)\n\t\t: ts_(0), validCurve_(false), multiCurveOptimizer_(optimizer)\n\t{}\n\n\ttemplate \n\tvoid MultiBootstrap::setup(Curve* ts) {\n\n\t\tts_ = ts;\n\n\t\tSize n = ts_->instruments_.size();\n\t\tQL_REQUIRE(n >= Interpolator::requiredPoints,\n\t\t\t\"not enough instruments: \" << n << \" provided, \" <<\n\t\t\tInterpolator::requiredPoints << \" required\");\n\n\t\tfor (Size i = 0; iregisterWith(ts_->instruments_[i]);\n\t\t}\n\n\t\tmultiCurveOptimizer_->addTermStructure(ts_);\n\n\t}\n\n\ttemplate \n\tvoid MultiBootstrap::initialize() const {\n\n\t\tSize nInsts = ts_->instruments_.size();\n\n\t\t// ensure rate helpers are sorted\n\t\tstd::sort(ts_->instruments_.begin(), ts_->instruments_.end(),\n\t\t\tdetail::BootstrapHelperSorter());\n\n\t\t// check that there is no instruments with the same maturity\n\t\tfor (Size i = 1; iinstruments_[i - 1]->latestDate(),\n\t\t\t\tm2 = ts_->instruments_[i]->latestDate();\n\t\t\tQL_REQUIRE(m1 != m2,\n\t\t\t\t\"two instruments have the same maturity (\" << m1 << \")\");\n\t\t}\n\n\t\t// check that there is no instruments with invalid quote\n\t\tfor (Size i = 0; iinstruments_[i]->quote()->isValid(),\n\t\t\tio::ordinal(i + 1) << \" instrument (maturity: \" <<\n\t\t\tts_->instruments_[i]->latestDate() <<\n\t\t\t\") has an invalid quote\");\n\n\t\t// setup instruments\n\t\tfor (Size i = 0; iinstruments_[i]->setTermStructure(const_cast(ts_));\n\t\t}\n\t\t// set initial guess only if the current curve cannot be used as guess\n\t\tif (validCurve_)\n\t\t\tQL_ENSURE(ts_->data_.size() == nInsts + 1,\n\t\t\t\"dimension mismatch: expected \" << nInsts + 1 <<\n\t\t\t\", actual \" << ts_->data_.size());\n\t\telse {\n\t\t\tts_->data_ = std::vector(nInsts + 1);\n\t\t\tts_->data_[0] = Traits::initialValue(ts_);\n\t\t}\n\n\t\t// calculate dates and times\n\t\tts_->dates_ = std::vector(nInsts + 1);\n\t\tts_->times_ = std::vector