Regenerate minified files with fixed preprocessor directives and fix test file path resolution

Author: adamant-pwn

.verify-helper/scripts/inject_minified_docs.py

@@ -197,9 +197,10 @@ def main():
 
         if is_test_file:
             # For test files, only generate bundled+minified version (not plain minified)
-            # Reconstruct source file path
+            # Reconstruct source file path - test files are relative to repo root
             if original_ext:
-                source_file = Path(path_without_ext + original_ext)
+                # path_without_ext is like "verify/test_file", we need the actual file in the repo
+                source_file = docs_root.parent / (path_without_ext + original_ext)
                 if source_file.exists():
                     # Generate bundled+minified version only
                     minified_bundled_code = bundle_and_minify(source_file)

cp-algo/min/geometry/closest_pair.hpp

@@ -4,25 +4,53 @@
 #include "point.hpp"
 #include <vector>
 #include <map>
-namespace cp_algo::geometry{template<typename ftype>
-auto closest_pair(std::vector<point_t<ftype>>const&r){using point=point_t<ftype>;
+namespace cp_algo::geometry{
+template<typename ftype>
+auto closest_pair(std::vector<point_t<ftype>>const&r){
+using point=point_t<ftype>;
 size_t n=size(r);
 int64_t md=1e18;
-for(size_t i=0;i<n/100;i++){auto A=random::rng()%n;
+for(size_t i=0;i<n/100;i++){
+auto A=random::rng()%n;
 auto B=random::rng()%n;
-if(A!=B){md=std::min(md,norm(r[A]-r[B]));
-if(md==0){return std::pair{A,B};}}}
+if(A!=B){
+md=std::min(md,norm(r[A]-r[B]));
+if(md==0){
+return std::pair{A,B};
+}
+}
+}
 std::map<point,std::vector<size_t>>neigs;
 md=(int64_t)ceil(sqrt((double)md));
-for(size_t i=0;i<n;i++){neigs[r[i]/md].push_back(i);}
+for(size_t i=0;i<n;i++){
+neigs[r[i]/md].push_back(i);
+}
 size_t a=0,b=1;
 md=norm(r[a]-r[b]);
-for(auto&[p,id]:neigs){for(int dx:{-1,0,1}){for(int dy:{-1,0,1}){auto pp=p+point{dx,dy};
-if(!neigs.count(pp)){continue;}
-for(size_t i:neigs[pp]){for(size_t j:id){if(j==i){break;}
+for(auto&[p,id]:neigs){
+for(int dx:{-1,0,1}){
+for(int dy:{-1,0,1}){
+auto pp=p+point{dx,dy};
+if(!neigs.count(pp)){
+continue;
+}
+for(size_t i:neigs[pp]){
+for(size_t j:id){
+if(j==i){
+break;
+}
 int64_t cur=norm(r[i]-r[j]);
-if(cur<md){md=cur;
+if(cur<md){
+md=cur;
 a=i;
-b=j;}}}}}}
-return std::pair{a,b};}}
-#endif
+b=j;
+}
+}
+}
+}
+}
+}
+return std::pair{a,b};
+}
+}
+#endif

cp-algo/min/geometry/convex_hull.hpp

@@ -5,17 +5,33 @@
 #include <utility>
 #include <vector>
 #include <ranges>
-namespace cp_algo::geometry{template<typename ftype>
-std::vector<point_t<ftype>>convex_hull(std::vector<point_t<ftype>>r){using point=point_t<ftype>;
+namespace cp_algo::geometry{
+template<typename ftype>
+std::vector<point_t<ftype>>convex_hull(std::vector<point_t<ftype>>r){
+using point=point_t<ftype>;
 std::ranges::sort(r);
-if(size(r)<=1||r[0]==r.back()){return empty(r)?r:std::vector{r[0]};}
+if(size(r)<=1||r[0]==r.back()){
+return empty(r)?r:std::vector{r[0]};
+}
 std::vector<point>hull={r[0]};
-for(int half:{0,1}){size_t base=size(hull);
-for(auto it:std::views::drop(r,1)){while(size(hull)>=base+1){point a=hull.back();
-if(point::ccw(it-a,end(hull)[-2]-a)){break;}else{hull.pop_back();}}
-hull.push_back(it);}
+for(int half:{0,1}){
+size_t base=size(hull);
+for(auto it:std::views::drop(r,1)){
+while(size(hull)>=base+1){
+point a=hull.back();
+if(point::ccw(it-a,end(hull)[-2]-a)){
+break;
+}else{
+hull.pop_back();
+}
+}
+hull.push_back(it);
+}
 std::ranges::reverse(r);
-std::ignore=half;}
+std::ignore=half;
+}
 hull.pop_back();
-return hull;}}
-#endif
+return hull;
+}
+}
+#endif

cp-algo/min/geometry/point.hpp

@@ -2,23 +2,39 @@
 #define CP_ALGO_GEOMETRY_POINT_HPP
 #include "../util/complex.hpp"
 #include <iostream>
-namespace cp_algo::geometry{template<typename ftype>
-struct point_t:complex<ftype>{using Base=complex<ftype>;
+namespace cp_algo::geometry{
+template<typename ftype>
+struct point_t:complex<ftype>{
+using Base=complex<ftype>;
 using Base::Base;
 point_t(Base const&t):Base(t){}
-auto operator<=>(point_t const&t)const{return std::pair{y(),-x()}<=>std::pair{t.y(),-t.x()};}
+auto operator<=>(point_t const&t)const{
+return std::pair{y(),-x()}<=>std::pair{t.y(),-t.x()};
+}
 ftype x()const{return Base::real();}
 ftype y()const{return Base::imag();}
 point_t cmul(point_t const&t)const{return conj(*this)*t;}
 ftype dot(point_t const&t)const{return cmul(t).x();}
 ftype cross(point_t const&t)const{return cmul(t).y();}
 static constexpr point_t O={0,0};
-int half()const{return*this<O?-1:*this==O?0:1;}
-static bool ccw(point_t const&a,point_t const&b){return a.cross(b)>0;}
-static bool ccw_abs(point_t const&a,point_t const&b){return std::tuple{a.half(),(ftype)0,norm(a)}<
-std::tuple{b.half(),a.cross(b),norm(b)};}
-void read(){ftype _x,_y;
+int half()const{
+return*this<O?-1:*this==O?0:1;
+}
+static bool ccw(point_t const&a,point_t const&b){
+return a.cross(b)>0;
+}
+static bool ccw_abs(point_t const&a,point_t const&b){
+return std::tuple{a.half(),(ftype)0,norm(a)}<
+std::tuple{b.half(),a.cross(b),norm(b)};
+}
+void read(){
+ftype _x,_y;
 std::cin>>_x>>_y;
-*this={_x,_y};}
-void print()const{std::cout<<x()<<' '<<y()<<"\n";}};}
-#endif
+*this={_x,_y};
+}
+void print()const{
+std::cout<<x()<<' '<<y()<<"\n";
+}
+};
+}
+#endif

cp-algo/min/graph/base.hpp

@@ -4,25 +4,43 @@
 #include "concepts.hpp"
 #include "../structures/stack_union.hpp"
 #include <ranges>
-namespace cp_algo::graph{using edge_index=int;
+namespace cp_algo::graph{
+using edge_index=int;
 template<edge_type _edge_t=edge_base,graph_mode _mode=undirected>
-struct graph{using edge_t=_edge_t;
+struct graph{
+using edge_t=_edge_t;
 static constexpr auto mode=_mode;
 using incidence_list=structures::stack_union<edge_index>;
 graph(int n,int v0=0):v0(v0),adj(n){}
-graph transpose()const{static_assert(mode==directed,"transpose is only defined for directed graphs");
+graph transpose()const{
+static_assert(mode==directed,"transpose is only defined for directed graphs");
 graph<edge_t,mode>gt(n(),v0);
-for(auto v:nodes()){for(auto e:outgoing(v)){gt.add_edge(edge(e).traverse(v),edge(e));}}
-return gt;}
-edge_index add_edge(node_index u,edge_t e){edge_index idx=(edge_index)size(E);
+for(auto v:nodes()){
+for(auto e:outgoing(v)){
+gt.add_edge(edge(e).traverse(v),edge(e));
+}
+}
+return gt;
+}
+edge_index add_edge(node_index u,edge_t e){
+edge_index idx=(edge_index)size(E);
 E.push_back(e);
 adj.push(u,idx);
-if constexpr(mode==undirected){adj.push(e.traverse(u),idx);}
-return idx;}
-edge_index add_edge(node_index u,auto... Args){return add_edge(u,edge_t(u,Args...));}
-void read_edges(node_index m){adj.reserve(mode==undirected?2*m:m);
-for(edge_index i=0;i<m;i++){auto[u,e]=edge_t::read(v0);
-add_edge(u,e);}}
+if constexpr(mode==undirected){
+adj.push(e.traverse(u),idx);
+}
+return idx;
+}
+edge_index add_edge(node_index u,auto... Args){
+return add_edge(u,edge_t(u,Args...));
+}
+void read_edges(node_index m){
+adj.reserve(mode==undirected?2*m:m);
+for(edge_index i=0;i<m;i++){
+auto[u,e]=edge_t::read(v0);
+add_edge(u,e);
+}
+}
 auto outgoing(node_index v)const{return adj[v];}
 auto edges()const{return E|std::views::all;}
 auto nodes()const{return std::views::iota(node_index(0),n());}
@@ -31,13 +49,16 @@ auto&&incidence_lists(this auto&&self){return self.adj;}
 auto&&edge(this auto&&self,edge_index e){return self.E[e];}
 node_index n()const{return(node_index)incidence_lists().size();}
 edge_index m()const{return(edge_index)edges().size();}
-private:node_index v0;
+private:
+node_index v0;
 big_vector<edge_t>E;
-incidence_list adj;};
+incidence_list adj;
+};
 template<edge_type edge_t=edge_base>
 using digraph=graph<edge_t,directed>;
 template<weighted_edge_type edge_t=weighted_edge,graph_mode mode=undirected>
 using weighted_graph=graph<edge_t,mode>;
 template<weighted_edge_type edge_t=weighted_edge>
-using weighted_digraph=digraph<edge_t>;}
-#endif
+using weighted_digraph=digraph<edge_t>;
+}
+#endif

cp-algo/min/graph/concepts.hpp

@@ -2,15 +2,18 @@
 #define CP_ALGO_GRAPH_CONCEPTS_HPP
 #include "edge_types.hpp"
 #include <type_traits>
-namespace cp_algo::graph{enum graph_mode{directed,undirected};
+namespace cp_algo::graph{
+enum graph_mode{directed,undirected};
 template<typename T,typename=void>
 struct graph_traits:std::false_type{};
 template<typename T>
-struct graph_traits<T,std::void_t<typename T::edge_t,decltype(T::mode)>>:std::true_type{using edge_t=typename T::edge_t;
+struct graph_traits<T,std::void_t<typename T::edge_t,decltype(T::mode)>>:std::true_type{
+using edge_t=typename T::edge_t;
 static constexpr auto mode=T::mode;
 static constexpr bool is_directed=mode==directed;
 static constexpr bool is_undirected=mode==undirected;
-static constexpr bool is_weighted=weighted_edge_type<edge_t>;};
+static constexpr bool is_weighted=weighted_edge_type<edge_t>;
+};
 template<typename G>
 concept graph_type=graph_traits<G>::value;
 template<typename G>
@@ -22,5 +25,6 @@ concept weighted_graph_type=graph_type<G>&&graph_traits<G>::is_weighted;
 template<typename G>
 concept weighted_digraph_type=digraph_type<G>&&graph_traits<G>::is_weighted;
 template<typename G>
-concept weighted_undirected_graph_type=undirected_graph_type<G>&&graph_traits<G>::is_weighted;}
-#endif
+concept weighted_undirected_graph_type=undirected_graph_type<G>&&graph_traits<G>::is_weighted;
+}
+#endif

cp-algo/min/graph/cycle.hpp

@@ -3,19 +3,33 @@
 #include "dfs.hpp"
 #include "base.hpp"
 #include <deque>
-namespace cp_algo::graph{template<graph_type graph>
-struct cycle_context:dfs_context<graph>{using base=dfs_context<graph>;
+namespace cp_algo::graph{
+template<graph_type graph>
+struct cycle_context:dfs_context<graph>{
+using base=dfs_context<graph>;
 using base::base;
 std::deque<edge_index>cycle;
 bool closed=false;
 int v0;
-void on_return_from_child(node_index v,edge_index e){if(!empty(cycle)&&!closed){cycle.push_front(e);
-closed|=v==v0;}}
-void on_back_edge(node_index v,edge_index e){if(empty(cycle)){v0=base::g->edge(e).traverse(v);
+void on_return_from_child(node_index v,edge_index e){
+if(!empty(cycle)&&!closed){
+cycle.push_front(e);
+closed|=v==v0;
+}
+}
+void on_back_edge(node_index v,edge_index e){
+if(empty(cycle)){
+v0=base::g->edge(e).traverse(v);
 base::done=true;
 closed=v==v0;
-cycle.push_front(e);}}};
+cycle.push_front(e);
+}
+}
+};
 template<graph_type graph>
-std::pair<node_index,std::deque<edge_index>>find_cycle(graph const&g){auto context=dfs<cycle_context>(g);
-return{context.v0,context.cycle};}}
-#endif
+std::pair<node_index,std::deque<edge_index>>find_cycle(graph const&g){
+auto context=dfs<cycle_context>(g);
+return{context.v0,context.cycle};
+}
+}
+#endif