data/code/maple/0.40-0.45.jsonl

{"text": "######################################################################\n# pair_subsets(A) is the set of all subsets B of A with |B| = 2\n\n`is_element/pair_subsets` := (A::set) -> proc(B)\n type(B,set) and B minus A = {} and nops(B) = 2;\nend;\n\n`is_equal/pair_subsets` := (A::set) -> (B,C) -> evalb(B = C):\n\n`is_leq/pair_subsets` := NULL;\n\n`random_element/pair_subsets` := (A::set) -> proc()\n local r,B;\n\n if nops(A) < 2 then return FAIL; fi;\n\n r := rand(1..nops(A));\n B := {};\n\n while nops(B) < 2 do\n  B := [A[r()],A[r()]];\n  B := {op(B)};\n od;\n\n return B;\nend;\n\n`list_elements/pair_subsets` := proc(A::set)\n local i,j;\n return [seq(seq({A[i],A[j]},j=i+1..nops(A)),i=1..nops(A)-1)];\nend:\n\n`count_elements/pair_subsets` := (A::set) -> nops(A) * (nops(A) - 1)/2;\n", "meta": {"hexsha": "45e2b1e3671f5938ec9363a345e5e1fc349fc1e2", "size": 757, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/pair_subsets.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/pair_subsets.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/pair_subsets.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.2647058824, "max_line_length": 71, "alphanum_fraction": 0.5112285337, "num_tokens": 266, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6688802603710086, "lm_q2_score": 0.6723317057447908, "lm_q1q2_score": 0.44970940639426}}
{"text": "make_boys_complex := proc()\n local T,U,F,p,f,i,L,w,n,P,vb,vn;\n global boys_complex,boys_complex_alt;\n \n T := table([\n  \"vertices\" = [1,2,3,4,5,6],\n  \"edges\"  = [[1,2],[1,3],[1,5],[1,6],[2,3],[2,4],[2,6],[3,4],[3,5],[4,5],[4,6],[5,6]],\n  \"faces\"  = [[1,2,3],[1,2,6],[1,5,3],[1,5,6],[4,2,3],[4,2,6],[4,5,3],[4,5,6]],\n  \"embedding\" = table(),\n  \"embedding_dim\" = 3\n ]);\n\n T[\"max_simplices\"] := T[\"faces\"];\n \n for i from 1 to 6 do\n  T[\"embedding\"][i]   :=    boys_corners[i];\n od:\n \n T := eval(`triangular_subdivision/simplicial_complex`(T)):\n T := eval(`condense/simplicial_complex`(T)):\n `normalise_embedding/simplicial_complex`(T):\n `star_subdivide/simplicial_complex`(T,{7,8,11}):\n `star_subdivide/simplicial_complex`(T,{16,17,18}):\n `normalise_embedding/simplicial_complex`(T):\n for p from 1 to 4 do \n  T := eval(`triangular_subdivision/simplicial_complex`(T)):\n  T := eval(`condense/simplicial_complex`(T)):\n  `normalise_embedding/simplicial_complex`(T):\n od:\n F := select(f -> min(op(f)) <= 6,T[\"max_simplices\"]):\n for f in F do \n  `star_subdivide/simplicial_complex`(T,{op(f)} minus {min(op(f))});\n od:\n `normalise_embedding/simplicial_complex`(T):\n for p from 1 to 3 do \n  for i from 1 to 6 do\n   L := `link/simplicial_complex`(T,i); \n   w := max(op(L[\"vertices\"]));\n   w := `square_refine/simplicial_complex`(T,i,w);\n  od:\n  `normalise_embedding/simplicial_complex`(T):\n od:\n\n n := nops(T[\"vertices\"]);\n P := eval(T[\"embedding\"]):\n vb := table():\n vn := table():\n for i from 1 to n do \n  vb[i] := evalf(boys_embedding(P[i]));\n  vn[i] := evalf(boys_normal(P[i]));\n od:\n\n T[\"boys_embedding\"] := eval(vb);\n T[\"boys_normal\"] := eval(vn);\n\n `set_javascript/simplicial_complex`(T);\n\n boys_complex := eval(T):\n\n U := table();\n U[\"vertices\"] := boys_complex[\"vertices\"];\n U[\"embedding\"] := eval(boys_complex[\"boys_embedding\"]);\n U[\"normal\"]    := eval(boys_complex[\"boys_normal\"]);\n U[\"max_simplices\"] := boys_complex[\"max_simplices\"];\n `set_javascript/simplicial_complex`(U);\n \n boys_complex_alt := eval(U);\n \n return eval(T);\nend:\n\nsave_boys_complex := proc()\n local js_file,T;\n global boys_complex;\n\n if not(type(boys_complex,table)) then\n  make_boys_complex();\n fi;\n\n save(boys_complex,boys_complex_alt,cat(data_dir,\"/boys_complex.m\"));\n\n js_file := cat(data_dir,\"/boys_cover_complex.js\");\n fprintf(js_file,\"%s\",boys_complex[\"javascript\"]);\n fclose(js_file);\n\n js_file := cat(data_dir,\"/boys_complex_alt.js\");\n fprintf(js_file,\"%s\",boys_complex_alt[\"javascript\"]);\n fclose(js_file);\n\nend:\n\n", "meta": {"hexsha": "9716ac00c97a0bf6b53215e834692e21e66738cc", "size": 2492, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/simplicial_complexes/boys_complex.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/simplicial_complexes/boys_complex.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/simplicial_complexes/boys_complex.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.0869565217, "max_line_length": 87, "alphanum_fraction": 0.6496789727, "num_tokens": 808, "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": "`basis/ass_operad` := (A::set) -> map(u -> bar(op(u)),`list_elements/ord`(A));\n\n`vec/ass_operad` := (A::set) -> proc(u)\n local n,ub,uc,T,B,i;\n global `vec_table/ass_operad`;\n n := nops(A);\n if u = 0 then\n  return [0$(n!)];\n elif type(u,`+`) then\n  return map(`vec/ass_operad`(A),u); \n else\n  if type(u,specfunc(bar)) then\n   ub := u;\n   uc := 1;\n  elif type(u,`*`) then\n   ub,uc := selectremove(type,u,specfunc(bar));\n   ub := map(op,bar(ub));\n  else\n   return FAIL;\n  fi;\n  if not(type(`vec_table/ass_operad`[A],table)) then\n   T := table():\n   B := `basis/ass_operad`(A);\n   for i from 1 to n! do\n    T[B[i]] := [0$(i-1),1,0$(n!-i)];\n   od:\n   `vec_table/ass_operad`[A] := eval(T);\n  fi;\n  return uc *~ `vec_table/ass_operad`[A][ub];\n fi;\nend:\n\n", "meta": {"hexsha": "0fb400244e5a00055cc60cb4e81a22141be3a82b", "size": 747, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/operads/ass.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/operads/ass.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/operads/ass.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.6363636364, "max_line_length": 78, "alphanum_fraction": 0.5609103079, "num_tokens": 291, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7662936430859598, "lm_q2_score": 0.5851011542032312, "lm_q1q2_score": 0.44835929502819394}}
{"text": "(*\n Copyright (C) 2017 M.A.L. Marques\n\n This Source Code Form is subject to the terms of the Mozilla Public\n License, v. 2.0. If a copy of the MPL was not distributed with this\n file, You can obtain one at http://mozilla.org/MPL/2.0/.\n*)\n\n(* type: gga_exc *)\n\n$include \"scaling.mpl\"\n\n(* parameters *)\nwpbeh_A :=  1.0161144:\nwpbeh_B := -0.37170836:\nwpbeh_C := -0.077215461:\nwpbeh_D :=  0.57786348:\nwpbeh_E := -0.051955731:\n\n(*\n Note that kF has a 6 and not a 3 as it should in principle\n be. This is because the HSE formula, if one would take the papers\n seriously, does not fulfill the spin sum-rule. This is probably\n an oversight from them. So, we have to choose, either a 6 or a 3.\n\n Nwchem seems to have the factor of 6, but VASP and espresso have\n a 3. This would amount to rescaling omega by a factor of\n cbrt(2). We follow the quantum chemistry community and put the 6.\n*)\n\n(* Cutoff criterion below which to use polynomial expansion *)\nEGscut     := 0.08:\nwcutoff    := 14:\nexpfcutoff := 700:\n\n(* first let us calculate H(s) *)\nwpbeh_Ha1 := 0.00979681:\nwpbeh_Ha2 := 0.0410834:\nwpbeh_Ha3 := 0.187440:\nwpbeh_Ha4 := 0.00120824:\nwpbeh_Ha5 := 0.0347188:\nwpbeh_H := s ->\n  + (wpbeh_Ha1*s^2 + wpbeh_Ha2*s^4)\n  / (1 + wpbeh_Ha3*s^4 + wpbeh_Ha4*s^5 + wpbeh_Ha5*s^6):\n\n(*\n  Now we calculate F(s). We use the parameters that were in the original code,\n  but these constants are:\n\n  wpbeh_Fc1 := 4*wpbeh_A^2/(9*wpbeh_C) + (wpbeh_B - wpbeh_A*wpbeh_D)/wpbeh_C:\n  wpbeh_Fc2 := -4/(3*36*wpbeh_C):\n*)\nwpbeh_Fc1 := 6.4753871:\nwpbeh_Fc2 := 0.47965830:\nwpbeh_F := s ->\n  wpbeh_Fc1*wpbeh_H(s) + wpbeh_Fc2:\n\n(* several auxiliary variables *)\neb1  := w -> my_piecewise3(w < wcutoff, 1.455915450052607, 2):\naux1 := s -> wpbeh_D + s^2*wpbeh_H(s):\naux2 := s -> 9*wpbeh_H(s)*s^2/(4*wpbeh_A):\naux3 := (w, s) -> aux1(s) + w^2:\naux4 := (w, s) -> s^2*wpbeh_H(s) + eb1(w)*w^2:\naux5 := (w, s) -> 9*aux4(w, s)/(4*wpbeh_A):\naux6 := (w, s) -> wpbeh_D + aux4(w, s):\n\n(* and now G(s) *)\nGa := s ->\n  + sqrt(Pi)*(\n    + 15*wpbeh_E\n    + 6*wpbeh_C*(1 + wpbeh_F(s)*s^2)*aux1(s)\n    + 4*wpbeh_B*aux1(s)^2\n    + 8*wpbeh_A*aux1(s)^3)\n  / (16*aux1(s)^(7/2))\n  - (3*Pi/4)*sqrt(wpbeh_A)*exp(aux2(s))*(1 - erf(sqrt(aux2(s)))):\nGb := s ->\n  15*sqrt(Pi)*s^2/(16*aux1(s)^(7/2)):\n\nwpbeh_EGa1 := -0.02628417880:\nwpbeh_EGa2 := -0.07117647788:\nwpbeh_EGa3 :=  0.08534541323:\nwpbeh_EG := s -> my_piecewise3(s > EGscut,\n  -(3*Pi/4 + Ga(s))/Gb(s),\n  wpbeh_EGa1 + wpbeh_EGa2*s^2 + wpbeh_EGa3*s^4\n):\n\nterm2 := s-> (\n  + aux1(s)^2*wpbeh_B\n  + aux1(s)*wpbeh_C\n  + 2*wpbeh_E\n  + aux1(s)*s^2*wpbeh_C*wpbeh_F(s)\n  + 2*s^2*wpbeh_EG(s)\n)/(2*aux1(s)^3):\n\nterm3 := (w, s) -> -w*(\n  + 4*aux3(w, s)^2*wpbeh_B\n  + 6*aux3(w, s)*wpbeh_C\n  + 15*wpbeh_E\n  + 6*aux3(w, s)*s^2*wpbeh_C*wpbeh_F(s)\n  + 15*s^2*wpbeh_EG(s)\n)/(8*aux1(s)*aux3(w, s)^(5/2)):\n\nterm4 := (w, s) -> -w^3*(\n  + aux3(w, s)*wpbeh_C\n  + 5*wpbeh_E\n  + aux3(w, s)*s^2*wpbeh_C*wpbeh_F(s)\n  + 5*s^2*wpbeh_EG(s)\n)/(2*aux1(s)^2*aux3(w, s)^(5/2)):\n\nterm5 := (w, s) -> -w^5*(\n  + wpbeh_E\n  + s^2*wpbeh_EG(s)\n)/(aux1(s)^3*aux3(w, s)^(5/2)):\n\nt10 := (w, s) ->\n  1/2*wpbeh_A*log(aux4(w, s)/aux6(w, s)):\n\n(* Use simple gaussian approximation for large w *)\nterm1_largew := (w, s) ->\n  -1/2*wpbeh_A*(-xc_E1_scaled(aux5(w, s)) + log(aux6(w, s)) - log(aux4(w, s))):\n\n(* For everything else use the full blown expression *)\nea1 := -1.128223946706117:\nea2 :=  1.452736265762971:\nea3 := -1.243162299390327:\nea4 :=  0.971824836115601:\nea5 := -0.568861079687373:\nea6 :=  0.246880514820192:\nea7 := -0.065032363850763:\nea8 :=  0.008401793031216:\n\nnp1 := w ->\n  - 1.5*ea1*sqrt(wpbeh_A)*w\n  + 27*ea3*w^3/(8*sqrt(wpbeh_A))\n  - 243*ea5*w^5/(32*(wpbeh_A)^(3/2))\n  + 2187*ea7*w^7/(128*(wpbeh_A)^(5/2)):\n\nnp2 := w ->\n  - wpbeh_A\n  + 9*ea2*w^2/4.0\n  - 81*ea4*w^4/(16*wpbeh_A)\n  + 729*ea6*w^6/(64*wpbeh_A^2)\n  - 6561*ea8*w^8/(256*wpbeh_A^3):\n\nt1 := (w, s) ->\n  1/2*(np1(w)*Pi*xc_erfcx(sqrt(aux5(w, s))) - np2(w)*xc_E1_scaled(aux5(w, s))):\n\nf2 := (w, s) ->\n  1/2*ea1*sqrt(Pi)*wpbeh_A/sqrt(aux6(w, s)):\nf3 := (w, s) ->\n  1/2*ea2*wpbeh_A/aux6(w, s):\nf4 := (w, s) ->\n  ea3*sqrt(Pi)*(-9/(8*sqrt(aux4(w, s))) + 0.25*wpbeh_A/aux6(w, s)^(3/2)):\nf5 := (w, s) ->\n  (ea4/128)*(-144/aux4(w, s) + 64*wpbeh_A/aux6(w, s)^2):\nf6 := (w, s) ->\n  ea5*(3*sqrt(Pi)*(3*aux6(w, s)^(5/2)*(9*aux4(w, s) - 2*wpbeh_A)\n    + 4*aux4(w, s)^(3/2)*wpbeh_A^2))/(32*aux6(w, s)^(5/2)*aux4(w, s)^(3/2)*wpbeh_A):\nf7 := (w, s) ->\n  ea6*((32*wpbeh_A/aux6(w, s)^3 + (-36 + 81*s^2*wpbeh_H(s)/wpbeh_A)/aux4(w, s)^2))/32:\nf8 := (w, s) ->\n  ea7*(-3*sqrt(Pi)*(-40*aux4(w, s)^(5/2)*wpbeh_A^3\n    + 9*aux6(w, s)^(7/2)*(27*aux4(w, s)^2 - 6*aux4(w, s)*wpbeh_A + 4*wpbeh_A^2)))\n  /(128*aux6(w, s)^(7/2)*aux4(w, s)^(5/2)*wpbeh_A^2):\nf9 := (w, s) -> (\n  + 324*ea6*eb1(w)*aux6(w, s)^4*aux4(w, s)*wpbeh_A\n  + ea8*(384*aux4(w, s)^3*wpbeh_A^3\n    + aux6(w, s)^4*(-729*aux4(w, s)^2 + 324*aux4(w, s)*wpbeh_A - 288*wpbeh_A^2))\n  )/(128*aux6(w, s)^4*aux4(w, s)^3*wpbeh_A^2):\n\nt2t9 := (w, s) ->\n  + f2(w, s)*w + f3(w, s)*w^2 + f4(w, s)*w^3 + f5(w, s)*w^4\n  + f6(w, s)*w^5 + f7(w, s)*w^6 + f8(w, s)*w^7 + f9(w, s)*w^8:\n\nterm1 := (w, s) -> my_piecewise3(\n  w > wcutoff, term1_largew(w, s),\n  t1(m_min(w, wcutoff), s) + t2t9(m_min(w, wcutoff), s) + t10(m_min(w, wcutoff), s)\n):\n\nf_wpbeh0 := (w, s) -> - 8/9 *(\n  term1(w, s) + term2(s) + term3(w, s) + term4(w, s) + term5(w, s)\n):\n\nf_wpbeh := (rs, z, x) ->\n  f_wpbeh0(nu(rs, z), m_max(1e-15, s_scaling_2(X2S*x))):\n\nf  := (rs, z, xt, xs0, xs1) ->\n  gga_exchange_nsp(f_wpbeh, rs, z, xs0, xs1):\n", "meta": {"hexsha": "22d7b84c7b9562049a77a8859adfb8d0c2b73794", "size": 5443, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "libxc-5.1.6/maple/gga_exc/gga_x_wpbeh.mpl", "max_stars_repo_name": "pwang234/lsms", "max_stars_repo_head_hexsha": "6044153b6138512093e457bdc0c15c699c831778", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2018-04-03T15:35:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T03:19:23.000Z", "max_issues_repo_path": "libxc-5.1.6/maple/gga_exc/gga_x_wpbeh.mpl", "max_issues_repo_name": "pwang234/lsms", "max_issues_repo_head_hexsha": "6044153b6138512093e457bdc0c15c699c831778", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2019-07-30T13:59:18.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T17:43:35.000Z", "max_forks_repo_path": "libxc-5.1.6/maple/gga_exc/gga_x_wpbeh.mpl", "max_forks_repo_name": "pwang234/lsms", "max_forks_repo_head_hexsha": "6044153b6138512093e457bdc0c15c699c831778", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2018-06-30T00:30:48.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-31T09:14:29.000Z", "avg_line_length": 28.7989417989, "max_line_length": 86, "alphanum_fraction": 0.5822156899, "num_tokens": 2580, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8539127417985637, "lm_q2_score": 0.523420348936324, "lm_q1q2_score": 0.4469553052733774}}
{"text": "# This file is about Singer systems of endomorphisms of the additive formal\n# group.  Such a system has groups G(i,j) (for 0 <= i <= j <= n say),\n# all of which are equal to the standard additive formal group.  There\n# are morphisms G(j,k) -> G(i,l) whenever i <= j <= k <= l, with the\n# evident functoriality condition.  The horizontal maps are linear\n# and the vertical maps are short isogenies.  Every equal-length\n# L-shaped subdiagram is like G -> G/a <- G//a for some a.\n\n\n\naa := proc(i::nonnegint,k::nonnegint)\n if i > k then return FAIL; fi;\n return v[k] * mul(v[t]^(2^(k-t-1)),t=i..k-1);\nend:\n\nbb := proc(i::nonnegint,k::nonnegint)\n if i > k then return FAIL; fi;\n return v[i-1]^(2^(k-i));\nend:\n\n# G(i,k) to G(i-1,k)\npp := (i,k) -> (x) -> bb(i,k) * x:\n\n# G(i,k) to G(i,k+1)\nqq := (i,k) -> (x) -> aa(i,k) * x + x^2:\n\n# G(j,k) to G(i,k)\nppp := proc(i,j,k)\n local x,y,z;\n\n if i > j then \n  return FAIL;\n elif i = j then \n  return (x -> x);\n else\n  y := ppp(i+1,j,k)(x);\n  z := collect(modp(expand(pp(i+1,k)(y)),2),x);\n  return unapply(z,x);\n fi;\nend:\n\n# G(j,k) to G(i,k)\nppp1 := proc(i,j,k) local x; unapply(mul(v[m]^(2^(k-m-1)),m=i..j-1) * x,x); end:\n \n# G(i,k) to G(i,l)\nqqq := proc(i,k,l)\n local x,y,z;\n\n if k > l then \n  return FAIL;\n elif l = k then \n  return (x -> x);\n else\n  y := qqq(i,k,l-1)(x);\n  z := collect(modp(expand(qq(i,l-1)(y)),2),x);\n  return unapply(z,x);\n fi;\nend:\n\nW0V := (k) -> mul(V[i],i=0..k-1):\n\nWW := proc(k,l,m)\n  local J,P;\n  J := [seq(j,j=k..l-1)];\n  P := combinat[choose](J,l-k-m);\n  return add(mul(V[u[t]]^(2^(k+m+t-1-u[t])),t=1..l-k-m),u in P);\nend: \n\nWWW := (j,k,l,m) -> WW(k,l,m) * W0V(j)^(2^(k+m-j) - 2^(l-j)):\n\nWWWW := (i,j,k,l,m) -> WW(k,l,m) * W0V(j)^(2^(k+m-j)) / W0V(i)^(2^(l-i)):\n\n# G(i,k) to G(i,l)\nqqq1 := proc(j,k,l)\n local x;\n return unapply(sort(collect(expand(add(WWW(j,k,l,i) * x^(2^i),i=0..l-k)),x)),x):\nend:\n\n# G(j,k) to G(i,l)\nff := proc(i,j,k,l)\n local x;\n return unapply(sort(collect(expand(add(WWWW(i,j,k,l,m) * x^(2^m),m=0..l-k)),x)),x):\nend:\n \nvV_rule := {seq(v[i]=V[i]/W0V(i),i=0..100)}:\n", "meta": {"hexsha": "60ea41dd8adc019e6d64dc8e8bc9e67edab61ebb", "size": 2052, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/steenrod/ss.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/steenrod/ss.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/steenrod/ss.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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.8604651163, "max_line_length": 84, "alphanum_fraction": 0.544834308, "num_tokens": 832, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.863391599428538, "lm_q2_score": 0.5156199157230156, "lm_q1q2_score": 0.4451819037333024}}
{"text": "input := FileTools:-Text:-ReadFile(\"AoC-2021-18-input.txt\" ):\n\nfind5nested := proc(input::string,$)\nlocal c, i, count;\n    count := 0;\n    for i from 1 to length(input) do\n        if input[i] = \"[\" then count += 1; if count=5 then return i; end if;\n        elif input[i] = \"]\" then count -= 1;\n        end if;\n    end do;\n    return 0;\nend proc:\n\nPRINT := s->printf(cat(s,\"\\n\"),_rest):\n\nsfreduce := proc(inp::string,$)\nlocal n, pin, regnums, input:=inp, oldinput;\n\n    while oldinput <> input do\n        oldinput := input;\n    #check\n        pin := parse(input);\n        if not nops(pin) = 2 then\n        error \"bad input\", input;\n        end if;\n\n        PRINT(\"reducing %s\", input);\n\n        n := find5nested(input);\n        if n > 0 then\n            input := ( sfexplode(input, n) );\n            next;\n        end if;\n\n        regnums := indets(pin, integer);\n        if max(regnums) >= 10 then\n            input := ( sfsplit(input) );\n            next;\n        end if;\n    end do;\n\n    return input;\n\nend proc:\n\nsfexplode := proc(input::string, pos::posint:=find5nested(input), $)\nlocal mid, toreplace, toreplacestr;\nlocal lh := input[1..pos-1];\nlocal rh := input[pos..-1]; # starting at the fifth [\nlocal m,n := StringTools:-FirstFromLeft(\"]\", rh);\nlocal toexplode := rh[1..n];\n    rh := rh[n+1..-1];\n    toexplode := parse(toexplode); # get a list with ints\n# righthand element\n    n := StringTools:-FirstFromRight(\",\", lh); # any number will be followed by a ,\n\n    PRINT(\"exploding %a at position %d\", toexplode, pos);\n\n    if n <> 0 then\n        if lh[n-1] = \"]\" then\n            while lh[n-1] = \"]\" do n -= 1 end do;\n            mid := lh[n..-1];\n            lh := lh[1..n-1]; # number still in lh \n            n := max(StringTools:-FirstFromRight(\",\", lh),StringTools:-FirstFromRight(\"[\", lh));\n        else\n            mid := lh[n..-1]; # number still in lh \n            lh := lh[1..n-1]; \n            n := StringTools:-FirstFromRight(\"[\", lh);\n        end if;\n        toreplace := lh[n+1..-1]; \n        lh := lh[1..n];\n        toreplacestr := parse(toreplace) + toexplode[1];\n        lh := cat(lh, toreplacestr, mid);\n        end if;\n\n    if toreplace = \"\" then\n      error \"bug\"\n    end if;\n\n# lefthand element\n    n := StringTools:-FirstFromLeft(\",\", rh); # any number will be proceded by a ,\n    if n <> 0 then\n        if rh[n+1] = \"[\" then      \n            while rh[n+1] = \"[\" do n += 1 end do;\n            mid := rh[1..n];\n            rh := rh[n+1..-1]; # number still in rh \n            n := min(subs(0=NULL,[StringTools:-FirstFromLeft(\",\", rh), StringTools:-FirstFromLeft(\"]\", rh)]));\n        else\n        mid := rh[1..n];\n        rh := rh[n+1..-1]; # number still in rh \n        n := StringTools:-FirstFromLeft(\"]\", rh);\n    end if;\n        toreplace := rh[1..n-1];\n        rh := rh[n..-1];\n        toreplacestr := parse(toreplace) + toexplode[2];\n        rh := cat(mid, toreplacestr, rh);\n    end if;\n\n    if toreplace = \"\" then\n      error \"bug\"\n    end if;\n\n    return cat(lh,0,rh);\n\nend proc:\n\n\nsfsplit := proc(input::string, $)\nlocal i,n,regnum,dig,diglocs;\n    # find leftmost - this is slow \n    # a better would be to just sweep to find a two digit number\n    dig := map(d->cat(\"\",d), [select(d->d>9,indets(parse(input), 'posint'))[]]);\n    diglocs := map(d->StringTools:-Search(d, input), dig);\n    i := min[index](diglocs);\n    regnum := parse(dig[i]);\n    n := diglocs[i];\n   \n    PRINT(\"splitting %d at position %d\", regnum, n);\n    if n > 0 then\n        return cat(input[1..n-1], \"[\", floor(regnum/2), \",\",\n                   ceil(regnum/2) ,\"]\", input[n+length(rs)..-1]);\n    else\n        error \"%1 is not in %2\", regnum, input;\n    end if;\nend proc:\n\nsfnorm := proc(input::{list,integer,string},$)\n    if type(input, string) then return thisproc(parse(input)); end if;\n    if type(input, integer) then return input; end if;\n    if nops(input) <> 2 then error \"bad sf number\", input; end if;\n    return thisproc(input[1])*3 + thisproc(input[2])*2;\nend proc:\n\nsfadd := proc(s1, s2)\n   return cat(\"[\",s1,\",\",s2,\"]\");\nend proc:\n\n# unit tests\nsfexplode( \"[[[[[9,8],1],2],3],4]\")=\"[[[[0,9],2],3],4]\";\nsfexplode( \"[7,[6,[5,[4,[3,2]]]]]\") = \"[7,[6,[5,[7,0]]]]\";\nsfexplode(\"[[6,[5,[4,[3,2]]]],1]\") = \"[[6,[5,[7,0]]],3]\";\nsfexplode(\"[[3,[2,[1,[7,3]]]],[6,[5,[4,[3,2]]]]]\") = \"[[3,[2,[8,0]]],[9,[5,[4,[3,2]]]]]\";\nsfexplode(\"[[3,[2,[8,0]]],[9,[5,[4,[3,2]]]]]\")=\"[[3,[2,[8,0]]],[9,[5,[7,0]]]]\";\nsfadd(\"[[[[4,3],4],4],[7,[[8,4],9]]]\", \"[1,1]\");\nsfexplode(%);\nsfexplode(%);\nsfsplit(%);\nsfsplit(%);\nsfexplode(%)= \"[[[[0,7],4],[[7,8],[6,0]]],[8,1]]\";\nsfreduce(\"[[[[[4,3],4],4],[7,[[8,4],9]]],[1,1]]\") = \"[[[[0,7],4],[[7,8],[6,0]]],[8,1]]\";\nsfsplit( \"[[[[5,11],[13,0]],[[15,14],[14,0]]],[[2,[11,10]],[[0,8],[8,0]]]]\") = \"[[[[5,[5,6]],[13,0]],[[15,14],[14,0]]],[[2,[11,10]],[[0,8],[8,0]]]]\";\n\nPRINT := 'PRINT':\nhomework := StringTools:-Split(input,\"\\n\"): nops(homework);\n\nsofar := homework[1];\nfor i from 2 to nops(homework) do\n    sofar := sfreduce(sfadd(sofar, homework[i]));\nend do:\nanswer1 := sfnorm(sofar);\nanswer2 := max([seq(seq(ifelse(i<>j,sfnorm( sfreduce(sfadd(homework[i],homework[j])) ),NULL), j=1..nops(homework)),i=1..nops(homework))]);\n", "meta": {"hexsha": "812beeaa639636cf6bfead5214dc21ce6e07d4d3", "size": 5169, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "Day18/AoC18-Maple.mpl", "max_stars_repo_name": "johnpmay/AdventOfCode2021", "max_stars_repo_head_hexsha": "b51756bcebea662333072cf518cf040a962ef8b7", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-12-04T18:24:03.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-04T18:24:03.000Z", "max_issues_repo_path": "Day18/AoC18-Maple.mpl", "max_issues_repo_name": "johnpmay/AdventOfCode2021", "max_issues_repo_head_hexsha": "b51756bcebea662333072cf518cf040a962ef8b7", "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": "Day18/AoC18-Maple.mpl", "max_forks_repo_name": "johnpmay/AdventOfCode2021", "max_forks_repo_head_hexsha": "b51756bcebea662333072cf518cf040a962ef8b7", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.9074074074, "max_line_length": 149, "alphanum_fraction": 0.515960534, "num_tokens": 1751, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6992544085240401, "lm_q2_score": 0.6334102636778401, "lm_q1q2_score": 0.4429149192811044}}
{"text": "local Simplify_DConstrain := (can_simp, do_simp) -> module()\r\n    uses Domain;\r\n\r\n    export ModuleApply := proc(vs0 :: DomBound, sh :: DomShape, $)\r\n        local vs := vs0, ctx;\r\n        if _Env_HakaruSolve=false then\r\n           return sh end if;\r\n        vs  := Domain:-Bound:-varsOf(vs,\"set\");\r\n        ctx := Domain:-Bound:-toConstraints(vs0, 'bound_types');\r\n        subsindets(sh, DomConstrain\r\n                  ,x->do_simpl_constraints(vs0, vs, ctx, x));\r\n    end proc;\r\n\r\n    local do_simpl_constraints := proc(vs0, vars, ctx_vs, x, $)\r\n        local ctx1, ctx, ss, td, rest, d, in_vs;\r\n        ss, ctx := selectremove(q->depends(q,indets(vars,Name)), x);\r\n        td, rest := selectremove(can_simp(vs0), ss);\r\n        ctx1 := { op(ctx), op(ctx_vs), op(rest) };\r\n        d := map(x->do_simp(vs0,ctx1,x), td);\r\n        DConstrain(op(d), op(ctx), op(rest));\r\n    end proc;\r\nend module;\r\n\r\nconstraints_about_vars := module()\r\n  export SimplName  := \"Make constraints abouts vars\";\r\n  export SimplOrder := 6;\r\n  export ModuleApply := Simplify_DConstrain(can_make_about, try_make_about);\r\n\r\n  local can_make_about := proc(vs)\r\n    local vars := Domain:-Bound:-varsOf(vs,\"set\");\r\n    c -> c::relation and (not(lhs(c) in vars) and not(rhs(c) in vars) and has(c,{ln,exp}));\r\n  end proc;\r\n  local try_make_about := proc(dbnd, ctx1, q0, $)\r\n      local vars_q, vars, q_s, q_r, q := q0;\r\n      vars := Domain:-Bound:-varsOf(dbnd,\"set\");\r\n      vars_q := indets(q, name) intersect vars;\r\n      if nops(vars_q)=0 then return q end if;\r\n\r\n      vars_q := op(1,vars_q);\r\n      q := KB:-try_improve_exp(q, vars_q, ctx1);\r\n      q_r := `if`(has(q,{ln,exp}),q0,q);\r\n      q_s := 'solve({q},[op(vars_q)], 'useassumptions'=true) assuming (op(ctx1))';\r\n      q_s := eval(q_s);\r\n      if q_s::list then\r\n        if nops(q_s)=0 then return q_r end if;\r\n        q_s := map(s->remove(c->c in ctx1 or `and`(c::relation,lhs(c)::name,lhs(c)=rhs(c)), s), q_s);\r\n        q_s := remove(x->x=[],q_s);\r\n        if nops(q_s)=0 then return q_r end if;\r\n        userinfo(3, 'constraints_about_vars'\r\n                ,printf(\"Found a solution to %a (with solve):\\n\\t%a\\n\", q0, op(1,q_s)));\r\n        op(op(1,q_s)); # pick the first solution arbitrarily!\r\n      else\r\n        q_r\r\n      end if;\r\n  end proc;\r\nend module;\r\n\r\n\r\nclamp_extraneous_constraints := module()\r\n  export SimplName  := \"clamp_extraneous_constraints\";\r\n  export SimplOrder := 6 - 1/10;\r\n  export ModuleApply := Simplify_DConstrain(can, `try`);\r\n\r\n  local can := proc(vs)\r\n    local vars := Domain:-Bound:-varsOf(vs,\"set\");\r\n    c-> c::relation and\r\n        (ormap(s->s(c)::Name and not(c in vars),[lhs,rhs]) and has(c, vars));\r\n  end proc;\r\n\r\n  local `try` := proc(dbnd, ctx1, q0, $)\r\n    local bnd, b_ty, b_rel, b_var, b_bnd, b_bnd_vs, vars, extremum, q := q0;\r\n    if has(q, {ln,exp}) then\r\n      vars := Domain:-Bound:-varsOf(dbnd, \"set\");\r\n      bnd := Domain:-Improve:-classify_relation(q0, x -> type(x, Name) and not (x in vars));\r\n      if bnd=FAIL then return q0 end if;\r\n      b_ty, b_rel, b_var, b_bnd := op(bnd):\r\n      b_bnd_vs := indets(b_bnd, satisfies(x -> x in vars));\r\n      if b_bnd_vs <> {} then\r\n        b_ty := `if`(b_ty=B_LO, 'minimize', 'maximize');\r\n        extremum := b_ty(b_bnd, op(b_bnd_vs)) assuming(op(ctx1));\r\n        if not (ext :: SymbolicInfinity or has(extremum, {maximize,minimize})) then\r\n          q := q, b_rel(b_var,extremum);\r\n        end if;\r\n      end if;\r\n    end if;\r\n    q\r\n  end proc;\r\nend module;\r\n\r\n# Pushes constraints down, or pulls them up, when there are such constraints.\r\nlocal do_ctx_dir := dir -> proc(vs :: DomBound, sh :: DomShape, $)\r\n    local ctx := `if`(nops(vs)=2,op(2,vs),{});\r\n    ctx := remove(x->x::`::`,ctx);\r\n    if ctx <> {} then\r\n        dir(ctx)(sh);\r\n    else\r\n        sh;\r\n    end if;\r\nend proc;\r\n\r\npush_ctx_down := module()\r\n  uses Domain;\r\n  export ModuleApply := do_ctx_dir(ctx->sh->subsindets(sh, DomConstrain, x->if nops(x)<>0 then DConstrain(op(x), op(ctx)) else DConstrain() end if));\r\n  export SimplName  := \"Push context down\";\r\n  export SimplOrder := 1;\r\nend module;\r\n\r\npull_ctx_out := module()\r\n  export ModuleApply :=\r\n    do_ctx_dir(ctx->sh->subsindets(sh, DomConstrain\r\n              ,x->remove(c->c in ctx or (is(c) assuming op(ctx)), x)));\r\n  export SimplName  := \"Pull context out\";\r\n  export SimplOrder := 20;\r\nend module;\r\n\r\n# Turns constraints(relations) into bounds\r\nclassify_DConstrains := module()\r\n  uses Domain;\r\n\r\n  export SimplName  := \"Classify constraints\";\r\n  export SimplOrder := 8;\r\n\r\n  export ModuleApply := proc(dbnds::DomBound,dsh::DomShape,$)\r\n    subsindets(dsh, DomConstrain, x->classify_Rels([op(x)], dbnds));\r\n  end proc;\r\n\r\n  # Split relations into those we can incorporate\r\n  # into bounds and others; this process also includes\r\n  # some intermediate computations about the new bound:\r\n  #  [ DInto(var), orig, upd_bound, bound_kind, numVars ]\r\n  #    var         :=   variable to be modified\r\n  #    orig        :=   the original relation\r\n  #    upd_bound   :=   how to modify (a function)\r\n  #    bound_kind  :=   {LO/HI}\r\n  #    numVars     :=   how many variables are mentioned by the bound\r\n  local classify_Rel := proc(r0,dbnd,$)\r\n    local ret, vars, mk_k, bnd_k, i, var_k, q, cl, lhs_r, rhs_r, r := r0;\r\n    ret := [ DConstrain, r0 ];\r\n    vars := Domain:-Bound:-varsOf(dbnd,\"set\");\r\n\r\n    # extract a representation of the relation, and check that it is a bound\r\n    cl := Domain:-Improve:-classify_relation(r, vars);\r\n    if cl=FAIL or not (op(1,cl) in {B_LO,B_HI}) then return ret; end if;\r\n    bnd_k,mk_k,lhs_r,rhs_r := op(cl);\r\n\r\n    i := Domain:-Bound:-varIx_mb(dbnd, lhs_r);\r\n    if i >= 0 then\r\n      var_k := op([1,i,3], dbnd);\r\n      q := Domain:-ExtBound[var_k]:-RecogBound(mk_k,rhs_r);\r\n      if q <> NULL then\r\n        ret := [ DInto(lhs_r), r0, q, bnd_k, countVs(vars minus {lhs_r},r0) ];\r\n      end if;\r\n    end if;\r\n    ret;\r\n  end proc;\r\n\r\n  # Classifies a set of relations as potential bounds. The process\r\n  # is as follows:\r\n  #  - Classify each relation individually (see classify_Rel)\r\n  #  - \"Categorize\" by the classification\r\n  #  - Split relations which will be DConstrains, and those where we found\r\n  #      more than one LO/HI bound or more than 2 bounds total.\r\n  #  - Sort the relations which are to become bounds by the number of variables\r\n  #      mentioned in the bound\r\n  #  - Rebuild the continuations producing each new bound (see make_DInto)\r\n  #  - Rebuild the leftover relations as a DConstrain.\r\n  #  - Squash together (\"foldr (.) id fs z\") the continuations and leftover relations.\r\n  local classify_Rels := proc(rs0,dbnd,$)\r\n    local cs1, cs2, cs, rs := rs0;\r\n    rs := map(r->classify_Rel(r,dbnd), rs);\r\n    rs := [ListTools[Categorize]( ((a,b) -> op(1,a)=op(1,b) ), rs )];\r\n    cs1, rs := selectremove(x->op([1,1],x)=DConstrain, rs);\r\n    rs, cs2 := selectremove(x->nops(x)=1 or (nops(x)=2 and op([1,4],x)<>op([2,4],x)), rs);\r\n    rs := sort(rs, key=solOrder);\r\n    rs := map(r->make_DInto(r,dbnd),rs);\r\n    cs := DConstrain(map(c->map(q->op(2,q),c)[], [op(cs1),op(cs2)])[]);\r\n    foldr((f,g)->f@g,x->x,op(rs))(cs);\r\n  end proc;\r\n\r\n  # Rebuild a classified (by classify_Rel) relation; this\r\n  # takes a list of such classifications, all of whose variable should\r\n  # be identical, and for which the different bound kinds are all distinct.\r\n  # None of this is checked!\r\n  # (since there are 2 bound kinds, this list is at most length 2)\r\n  local make_DInto := proc(r::list([specfunc(DInto),anything,anything,identical(B_LO,B_HI),nonnegint]), dbnd, $)\r\n    local var_nm, var_ty;\r\n    var_nm := op([1,1,1], r);\r\n    var_ty := Domain:-Bound:-get(dbnd, var_nm)[1];\r\n    var_ty := foldr( ((q,x)->op(3,q)(x)), var_ty, op(r) );\r\n    (ctx -> DInto(var_nm, var_ty, ctx))\r\n  end proc;\r\n  local flip_rel := table([`=`=`=`,`<>`=`<>`,`<=`=`>=`,`<`=`>`,`>=`=`<=`,`>`=`<`]);\r\n  local countVs := ((vs,c)-> nops(indets(c, DomBoundVar) intersect {op(vs)} ));\r\n  local solOrder := (x->`+`(map(z->op(5,z),x)[]));\r\nend module;\r\n\r\n# todo; this should actually solve for a variable, then substitute\r\n# that variable in. In most cases, it would probably be enough to\r\n# leave that as it is; it would simplify later.\r\nsingular_pts := module()\r\n  export SimplName  := \"Single_pts\";\r\n  export SimplOrder := 14;\r\n\r\n  local can_remove := ((xs,vs_ty) ->\r\n     nops(xs)>0 and\r\n     andmap(x ->\r\n     x :: `=` and\r\n     ormap(s->s(x)::vs_ty,[lhs,rhs]) and\r\n     not(is(x)), xs));\r\n\r\n  export ModuleApply := proc(bnds_ :: DomBound, sh_ :: DomShape, $)\r\n    local bnds := bnds_, sh := sh_, vs, todo, sh1, vs_ty;\r\n    vs := applyop(bl -> select(b->op(3,b)=`Int`, bl), 1, bnds);\r\n    vs := Domain:-Bound:-varsOf(vs,\"set\");\r\n    vs_ty := 'satisfies(x->x in vs)';\r\n    todo := indets(sh, specfunc(`DConstrain`));\r\n    todo := select(x->can_remove(x,vs_ty), todo);\r\n    subs([seq(t=DSum(),t=todo)], sh);\r\n  end proc;\r\nend module;\r\n", "meta": {"hexsha": "cde672a213ff516000645995b078974f69a3c34b", "size": 8909, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "maple/Domain/Improve/Constraints.mpl", "max_stars_repo_name": "zaxtax/hakaru", "max_stars_repo_head_hexsha": "03ac5b645815e99437e28d228e6c668753b2640e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2015-02-07T17:57:04.000Z", "max_stars_repo_stars_event_max_datetime": "2016-01-29T19:40:24.000Z", "max_issues_repo_path": "maple/Domain/Improve/Constraints.mpl", "max_issues_repo_name": "zaxtax/hakaru", "max_issues_repo_head_hexsha": "03ac5b645815e99437e28d228e6c668753b2640e", "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": "maple/Domain/Improve/Constraints.mpl", "max_forks_repo_name": "zaxtax/hakaru", "max_forks_repo_head_hexsha": "03ac5b645815e99437e28d228e6c668753b2640e", "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": 40.3122171946, "max_line_length": 150, "alphanum_fraction": 0.5953530138, "num_tokens": 2707, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7310585786300049, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.4415095479531115}}
{"text": "program whilest;\nvar n, i, sum : integer;\nbegin\n    readln(n);\n    i := n;\n    sum := 0;\n    while i > 0 do begin\n        sum := sum + i;\n        i := i - 1\n    end;\n    writeln('Summention of 1 - ', n, '  is ', sum)\nend.", "meta": {"hexsha": "ba0980299a92713cffcce21d2f7ab94df39439ab", "size": 221, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "program2/answers/sample26.mpl", "max_stars_repo_name": "Hiroya-W/lang-processing", "max_stars_repo_head_hexsha": "c93ef2d5757e560c4df2335f07ac25552750140c", "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": "program2/answers/sample26.mpl", "max_issues_repo_name": "Hiroya-W/lang-processing", "max_issues_repo_head_hexsha": "c93ef2d5757e560c4df2335f07ac25552750140c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 14, "max_issues_repo_issues_event_min_datetime": "2020-10-04T11:15:32.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-20T02:11:14.000Z", "max_forks_repo_path": "program2/answers/sample26.mpl", "max_forks_repo_name": "Hiroya-W/lang-processing", "max_forks_repo_head_hexsha": "c93ef2d5757e560c4df2335f07ac25552750140c", "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": 18.4166666667, "max_line_length": 50, "alphanum_fraction": 0.4660633484, "num_tokens": 78, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6113819874558603, "lm_q2_score": 0.721743200312399, "lm_q1q2_score": 0.44126079223974757}}
{"text": "# This file contains code related to the following situation.\n# We have P0 in ICP_N(A) restricting to Q0 in ICP_N(B),\n# where B = A \\ {a}.  We also have Q1 in ICP_N(B) refining Q0.\n# We let U denote the poset of elements M in ICP_N(A) such that\n# the restriction of M to B is Q1, and M refines P0.\n# The claim is that |U| is contractible.\n\n`random_element/PQQ` := (N::posint) -> (A::set,a) -> proc()\n local B,P0,Q0,Q1;\n B := A minus {a};\n P0 := `random_element/ICP`(N)(A)():\n Q0 := `res/ICP`(N)(A,B)(P0):\n Q1 := NULL:\n while Q1 = NULL or not(`is_leq/ICP`(N)(B)(Q0,Q1)) do\n  Q1 := `random_element/ICP`(N)(B)():\n od:\n return [P0,Q0,Q1];\nend: \n\n######################################################################\n\n`analyse/PQQ` := (N::posint) -> (A::set,a) -> proc(PQQ)\n local B,P0,Q0,Q1,P0r,Q0r,Q1r,L1,n1,T,M,RR,SS,US,PN,PS,U,nU,U0,UR0,\n  Q1B,AQ1B,RT,Bm,Bo,Bp,Bmr,Bpr,NB,NU,VV,b,i,j,k,l,beta,kk,ee;\n B := A minus {a};\n P0,Q0,Q1 := op(PQQ);\n T := table():\n T[\"N\"] := N;\n T[\"A\"] := A;\n T[\"B\"] := B;\n T[\"a\"] := a;\n T[\"P0\"] := P0;\n T[\"Q0\"] := Q0;\n T[\"Q1\"] := Q1;\n T[\"P0_tot\"] := `totalise/ICP/ord`(N)(A)(P0);\n T[\"Q0_tot\"] := `totalise/ICP/ord`(N)(B)(Q0);\n T[\"Q1_tot\"] := `totalise/ICP/ord`(N)(B)(Q1);\n P0r := table():\n Q0r := table():\n Q1r := table():\n for i from 1 to N do\n  P0r[i] := `rank_table/preord`(A)(P0[i]);\n  Q0r[i] := `rank_table/preord`(B)(Q0[i]);\n  Q1r[i] := `rank_table/preord`(B)(Q1[i]);\n od:\n T[\"P0_rank_table\"] := eval(P0r);\n T[\"Q0_rank_table\"] := eval(Q0r);\n T[\"Q1_rank_table\"] := eval(Q1r);\n RR := table():\n SS := table():\n US := table():\n for b in B do\n  RR[b] := `list_elements/ICP`(N)({a,b}):\n  SS[b] := map(`f/fibre_sphere/ICP`(N)(A)(a,b,Q1),RR[b]):\n  US[b] := select(M -> `is_leq/ICP`(N)(A)(P0,M),SS[b]):\n  PN[b] := evalb(nops(US[b]) > 0);\n  PS[b] := evalb(modp(nops(US[b]),2) = 0);\n  k := 1;\n  while member([a,b],P0[k]) and member([b,a],P0[k]) do\n   k := k+1;\n  od:\n  kk[b] := k;\n  ee[b] := `if`(member([a,b],P0[k]),-1,+1);\n od:\n T[\"fibre_sphere\"] := eval(SS);\n T[\"upper_fibre_part\"] := eval(US);\n T[\"part_is_empty\"] := eval(PE);\n T[\"part_is_sphere\"] := eval(PS);\n T[\"P0_split_stage\"] := eval(kk);\n T[\"P0_split_direction\"] := eval(ee);\n T[\"fibre\"] := {seq(op(SS[b]),b in B)};\n U := {seq(op(US[b]),b in B)};\n nU := nops(U);\n U0,UR0 := op(`skeleton/partord/from_comparator`(U)(`is_leq/ICP`(N)(A))); \n T[\"upper_fibre\"] := U;\n T[\"U0\"] := U0;\n T[\"upper_fibre_size\"] := nU;\n T[\"upper_fibre_skeleton\"] := UR0;\n T[\"upper_fibre_hasse_diagram\"] := \n  `hasse_diagram/partord`(U0)(UR0);\n L1 := T[\"Q1_tot\"];\n n1 := nops(L1);\n T[\"part_list\"] := [seq(US[L1[i]],i=1..n1)];\n T[\"part_is_nonempty_list\"] := [seq(PN[L1[i]],i=1..n1)];\n T[\"part_is_sphere_list\"] := [seq(PS[L1[i]],i=1..n1)];\n T[\"left_nested_list\"] :=\n  [FAIL,seq(evalb({op(US[L1[i]])} minus {op(US[L1[i-1]])} = {}),i=2..n1)];\n T[\"right_nested_list\"] :=\n  [seq(evalb({op(US[L1[i]])} minus {op(US[L1[i+1]])} = {}),i=1..n1-1),FAIL];\n T[\"part_skeleton\"] := [\n  seq(select(i -> member(U[i],US[L1[j]]),U0),j=1..n1)\n ];\n Q1B := table():\n AQ1B := table():\n RT := table():\n Bm := table():\n Bo := table():\n Bp := table():\n Bmr := table():\n Bpr := table():\n NU  := table():\n for i from 1 to N do\n  Q1B[i] := `block_partition/equiv`(B)(Q1[i] union `op/autorel`(B)(Q1[i]));\n  AQ1B[i] := select(u -> member([u[1],a],P0[i]) or member([a,u[1]],P0[i]),Q1B[i]);\n  for beta in AQ1B[i] do\n   RT[i,beta] := `rank_table/preord`(beta)(Q1[i]);\n   NB[i,beta] := max(0,seq(RT[i,beta][b]+1,b in beta));\n   Bm[i,beta] := select(b -> not(member([a,b],P0[i])),beta);\n   Bo[i,beta] := select(b -> member([a,b],P0[i]) and member([b,a],P0[i]),beta);\n   Bp[i,beta] := select(b -> not(member([b,a],P0[i])),beta);\n   Bmr[i,beta] := max(0,seq(RT[i,beta][b]+1,b in Bm[i,beta]));\n   Bpr[i,beta] := min(NB[i,beta],seq(RT[i,beta][b],b in Bp[i,beta]));\n   NU[i,beta] := Bpr[i,beta] - Bmr[i,beta] + 1;\n   VV[i,beta] := {seq([i,beta,l-0.5],l=Bmr[i,beta]..Bpr[i,beta])};\n  od:\n od:\n Q1B[N+1] := {seq({b},b in B)};\n AQ1B[N+1] := {};\n T[\"Q1_comparability_blocks\"] := eval(Q1B):\n T[\"admissible_blocks\"] := eval(AQ1B);\n T[\"admissible_tree\"] := [seq(seq([i,beta],beta in AQ1B[i]),i=1..N)];\n T[\"Q1_rank_table\"] := eval(RT);\n T[\"lower_set\"]  := eval(Bm);\n T[\"middle_set\"] := eval(Bo);\n T[\"upper_set\"]  := eval(Bp);\n T[\"lower_rank\"] := eval(Bmr);\n T[\"upper_rank\"] := eval(Bpr);\n T[\"block_quotient_size\"] := eval(NB);\n T[\"num_U\"]      := eval(NU);\n T[\"V\"] := {seq(seq(op(VV[i,beta]),beta in AQ1B[i]),i=1..N)};\n return eval(T):\nend:\n\n######################################################################\n\n`f/PQQ/U/V` := (T) -> proc(M)\n local a,b,j,k,beta,beta0,gamma,rt,r;\n k := 1:\n beta := T[\"B\"]:\n a := T[\"a\"]:\n for j from 2 to T[\"N\"] do \n  beta0 := select(b -> member([a,b],M[j]) or member([b,a],M[j]),beta);\n  if beta0 <> {} then\n   beta := beta0;\n   k := j;\n  else\n   break;\n  fi;\n od:\n gamma := select(b -> not(member([a,b],M[k])),beta);\n rt := eval(T[\"Q1_rank_table\"][k,beta]):\n r := max(-1,seq(rt[b],b in gamma)) + 0.5;\n return [k,beta,r];\nend:\n\n######################################################################\n\n`g/PQQ/V/U` := (T) -> proc(x)\n local i,k,N,a,b,B,MT,QQ,MM,M,beta,r,b0,L,U,rt;\n k,beta,r := op(x);\n N := T[\"N\"];\n a := T[\"a\"];\n B := T[\"B\"];\n MT := table():\n for i from 1 to N do\n  QQ := T[\"Q1\"][i];\n  MM := QQ union {[a,a]};\n  if i < k then\n   b0 := beta[1];\n   L := select(b -> member([b,b0],QQ),B);\n   U := select(b -> member([b0,b],QQ),B);\n   MM := {op(MM),seq([b,a],b in L),seq([a,b],b in U)};\n  elif i = k then\n   rt := T[\"Q1_rank_table\"][k,beta];\n   L := select(b -> rt[b] < r,beta);\n   U := select(b -> rt[b] > r,beta);\n   MM := {op(MM),seq([b,a],b in L),seq([a,b],b in U)};\n  fi;\n  MT[i] := MM; \n od:\n M := [seq(MT[i],i=1..N)];\n return M;\nend:\n\n######################################################################\n\n`is_leq/PQQ/V` := (T) -> proc(x0,x1)\n local k0,k1,beta0,beta1,r0,r1,r2,b0;\n k0,beta0,r0 := op(x0);\n k1,beta1,r1 := op(x1);\n if k0 < k1 then return false; fi;\n if k0 = k1 then\n  return evalb(beta0 = beta1 and r0 = r1);\n fi;\n b0 := beta0[1];\n if not(member(b0,beta1)) then return false; fi;\n r2 := T[\"Q1_rank_table\"][k1,beta1][b0];\n if not(r1 = r2 - 0.5 or r1 = r2 + 0.5) then\n  return false;\n fi;\n return true;\nend:\n\n######################################################################\n\n`rho/PQQ` := (T) -> (j,e) -> proc(x)\n local k,beta,gamma,beta1,b0,QQ,rt,r1;\n k,beta,gamma := op(x);\n if j >= k then return FAIL; fi;\n b0 := beta[1];\n QQ := T[\"Q1\"][j];\n beta1 := select(b -> member([b,b0],QQ) or member([b0,b],QQ),T[\"B\"]);\n rt := T[\"Q1_rank_table\"][j,beta1];\n r1 := rt[beta[1]] + 0.5 * e;\n return [j,beta1,r1];\nend:\n\n######################################################################\n\n`describe/PQQ` := proc(T)\n cat(`describe/ICP`(T[\"N\"])(T[\"A\"])(T[\"P0\"]),\"\\n\",\n     `describe/ICP`(T[\"N\"])(T[\"B\"])(T[\"Q0\"]),\"\\n\",\n     `describe/ICP`(T[\"N\"])(T[\"B\"])(T[\"Q1\"]),\"\\n\");\nend:\n\n######################################################################\n\n`check_UV/PQQ` := proc(T)\n local N,A,U,V,ff,gg,M,M0,M1,x,x0,x1,cU,cV;\n N := T[\"N\"];\n A := T[\"A\"];\n U := T[\"upper_fibre\"]:\n V := T[\"V\"]:\n ff := table():\n gg := table():\n for M in U do \n  x := `f/PQQ/U/V`(T)(M);\n  if not(member(x,V)) then return false; fi;\n  M1 := `g/PQQ/V/U`(T)(x);\n  if M <> M1 then return false; fi;\n  ff[M] := x;\n od:\n for x in V do \n  M := `g/PQQ/V/U`(T)(x);\n  if not(member(M,U)) then return false; fi;\n  x1 := `f/PQQ/U/V`(T)(M);\n  if x <> x1 then return false; fi;\n  gg[x] := M;\n od:\n for x0 in V do\n  for x1 in V do\n   M0 := gg[x0];\n   M1 := gg[x1];\n   cU := `is_leq/ICP`(N)(A)(M0,M1);\n   cV := `is_leq/PQQ/V`(T)(x0,x1);\n   if cU <> cV then return false; fi;\n  od;\n od;\n return true;\nend:\n\n######################################################################\n\n`check_rho/PQQ` := proc(T)\n global reason;\n local VV,i,j,k,x,y,z,C,y1,y2,y3,y4,y5,y6;\n VV := table():\n for k from 1 to T[\"N\"] do \n  VV[k] := select(x -> x[1] = k,T[\"V\"]):\n od:\n for k from 2 to T[\"N\"] do\n  for j from 1 to k-1 do\n   for x in VV[k] do\n    y := `rho/PQQ`(T)(j,-1)(x);\n    z := `rho/PQQ`(T)(j,+1)(x);\n    C := select(w -> `is_leq/PQQ/V`(T)(x,w),VV[j]);\n    if (y = z) or (C <> {y,z}) then\n     return false;\n    fi;\n   od;\n  od;\n od;\n for k from 3 to T[\"N\"] do\n  for j from 2 to k-1 do\n   for i from 1 to j-1 do \n    for x in VV[k] do\n     y1 := `rho/PQQ`(T)(i,-1)(x);\n     y2 := `rho/PQQ`(T)(i,+1)(x);\n     y3 := `rho/PQQ`(T)(i,-1)(`rho/PQQ`(T)(j,-1)(x));\n     y4 := `rho/PQQ`(T)(i,-1)(`rho/PQQ`(T)(j,+1)(x));\n     y5 := `rho/PQQ`(T)(i,+1)(`rho/PQQ`(T)(j,-1)(x));\n     y6 := `rho/PQQ`(T)(i,+1)(`rho/PQQ`(T)(j,+1)(x));\n     if not(y3 = y1 and y4 = y1 and y5 = y2 and y6 = y2) then\n      reason := [i,j,k,x,y1,y2,y3,y4,y5,y6];\n      return false;\n     fi;\n    od;\n   od;\n  od;\n od;\n \n return true;\nend:\n\n######################################################################\n\n`check_UL/PQQ` := proc(T)\n global reason;\n local N,A,B,a,b,Q,kk,k,L,U,S,i,e;\n N := T[\"N\"];\n a := T[\"a\"];\n A := T[\"A\"];\n B := T[\"B\"];\n Q := T[\"Q1\"];\n kk := T[\"P0_split_stage\"];\n for b in B do\n  k := kk[b];\n  L := {seq(seq(`f_alt/fibre_sphere/ICP`(N)(A)(a,b,Q)([i,e]),e in {-1,1}),i=1..k-1)};\n  U := {seq(seq(`f_alt/fibre_sphere/ICP`(N)(A)(a,b,Q)([i,e]),e in {-1,1}),i=k+1..N)};\n  S := {op(T[\"upper_fibre_part\"][b])};\n  if not((U intersect S = {}) and (L minus S = {})) then\n   return false;\n  fi;\n od:\n return true;\nend:\n\n######################################################################\n\n`check_is_sphere/PQQ` := proc(T)\n global reason;\n local N,A,B,a,b,P0,Q0,Q1,kk,k,ee,e,C,D,E,F,u;\n N := T[\"N\"];\n a := T[\"a\"];\n A := T[\"A\"];\n B := T[\"B\"];\n P0 := T[\"P0\"];\n Q0 := T[\"Q0\"];\n Q1 := T[\"Q1\"];\n kk := eval(T[\"P0_split_stage\"]);\n ee := eval(T[\"P0_split_direction\"]);\n for b in B do\n  k := kk[b];\n  e := ee[b];\n  if e = -1 then \n   C := select(x -> member([x,b],Q0[k]) and member([b,x],Q0[k]),B);\n   D := select(x -> member([x,b],Q1[k]) and\n                    not(member([b,x],Q1[k])),C);\n   E := select(x -> member([a,x],P0[k]) and\n                    member([x,b],P0[k]) and\n                    not(member([x,a],P0[k])) and\n                    not(member([b,x],P0[k])),B);\n   F := select(x -> member([x,b],Q1[k]) or member([b,x],Q1[k]),E);\n  else\n   C := select(x -> member([x,b],Q0[k]) and member([b,x],Q0[k]),B);\n   D := select(x -> member([b,x],Q1[k]) and\n                    not(member([x,b],Q1[k])),C);\n   E := select(x -> member([x,a],P0[k]) and\n                    member([b,x],P0[k]) and\n                    not(member([a,x],P0[k])) and\n                    not(member([x,b],P0[k])),B);\n   F := select(x -> member([x,b],Q1[k]) or member([b,x],Q1[k]),E);\n  fi;\n  u := not(evalb(D = {} and F = {}));\n  if u <> T[\"part_is_sphere\"][b] then\n   reason := [b,k,e,C,D,E,F]:\n   return false;\n  fi;\n od:\n return true;\nend:\n\n######################################################################\n\n`check_sphere_in_ball/PQQ` := proc(T)\n global reason;\n local N,A,B,a,b,P0,Q0,Q1,US,kk,k,ee,e,C,C1,b1;\n N := T[\"N\"];\n a := T[\"a\"];\n A := T[\"A\"];\n B := T[\"B\"];\n P0 := T[\"P0\"];\n Q0 := T[\"Q0\"];\n Q1 := T[\"Q1\"];\n kk := eval(T[\"P0_split_stage\"]);\n ee := eval(T[\"P0_split_direction\"]);\n US := eval(T[\"upper_fibre_part\"]);\n for b in B do\n  if T[\"part_is_sphere\"][b] then\n   k := kk[b];\n   e := ee[b];\n   if e = -1 then \n    C := select(x -> member([x,b],Q1[k]) and not(member([x,a],P0[k])),B);\n    if C = {} then\n     reason := [b,k,e,C];\n     return false;\n    fi;\n    # Choose b1 to be Q1[k]-minimal in C\n    C1 := C;\n    while C1 <> {} do\n     b1 := C1[1];\n     C1 := select(x -> not(member([b1,x],Q1[k])),C1);\n    od:\n    if T[\"part_is_sphere\"][b1] or\n       ({op(US[b])} minus {op(US[b1])} <> {}) or\n       member([b,b1],Q1[k]) then\n     reason := [b,k,e,C,b1];\n     return false;\n    fi;\n   else\n    C := select(x -> member([b,x],Q1[k]) and not(member([a,x],P0[k])),B);\n    if C = {} then\n     reason := [b,k,e,C];\n     return false;\n    fi;\n    # Choose b1 to be Q1[k]-maximal in C\n    C1 := C;\n    while C1 <> {} do\n     b1 := C1[1];\n     C1 := select(x -> not(member([x,b1],Q1[k])),C1);\n    od:\n    if T[\"part_is_sphere\"][b1] or\n       ({op(US[b])} minus {op(US[b1])} <> {}) or\n       member([b1,b],Q1[k]) then\n     reason := [b,k,e,C,b1];\n     return false;\n    fi;\n   fi;\n  fi;\n od:\n return true;\nend:\n\n\n######################################################################\n\n`check_nonempty_interval/PQQ` := proc(T)\n local L,J,i,j,j0,j1;\n L := T[\"part_is_nonempty_list\"];\n if not(`or`(op(L))) then return false; fi;\n J := select(i -> L[i],[seq(i,i=1..nops(L))]);\n j0 := min(op(J));\n j1 := max(op(J));\n return `and`(seq(L[j],j=j0..j1));\nend:\n\n######################################################################\n\n`check_adjacent_nonempty/PQQ` := proc(T)\n local L,P,i;\n L := T[\"part_is_nonempty_list\"];\n P := T[\"part_list\"];\n for i from 1 to nops(L)-1 do\n  if L[i] and L[i+1] and ({op(P[i])} intersect {op(P[i+1])} = {}) then\n   return false;\n  fi;\n od;\n return true;\nend:\n\n######################################################################\n\n`check_incomparable_min/PQQ` := proc(T)\n local n,LN,RN,P,i,b,P1;\n n := nops(T[\"B\"]);\n LN := T[\"left_nested_list\"];\n RN := T[\"right_nested_list\"];\n P := T[\"part_list\"];\n for i from 1 to n-1 do\n  if not(LN[i+1]) and not(RN[i]) then\n   b := T[\"Q1_tot\"][i];\n   P1 := `m/fibre_sphere/ICP`(T[\"N\"])(T[\"A\"])(a,b,T[\"Q1\"]):\n   if not (member(P1,{op(P[i])}) and member(P1,{op(P[i+1])})) then\n    return false;\n   fi;\n  fi;\n od;\n return true;\nend:\n\n######################################################################\n\n`check_intersections_nested/PQQ` := proc(T)\n global reason;\n local n,P,PS,i,j,k;\n n := nops(T[\"B\"]);\n P := T[\"part_list\"];\n for i from 1 to n do PS[i] := {op(P[i])}; od:\n for i from 1 to n-2 do\n  for j from i+1 to n-1 do\n   for k from j+1 to n do\n    if (PS[i] intersect PS[k]) minus PS[j] <> {} then\n     reason := [i,j,k];\n     return false;\n    fi;\n   od;\n  od;\n od;\n return true;\nend:\n\n", "meta": {"hexsha": "c3fbaa11e8cac06261fe1a8428bd464ac2b0dae2", "size": 13825, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/operads/chains/PQQ.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/operads/chains/PQQ.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/operads/chains/PQQ.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.5398406375, "max_line_length": 85, "alphanum_fraction": 0.4729837251, "num_tokens": 5193, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7185943925708562, "lm_q2_score": 0.611381973294151, "lm_q1q2_score": 0.43933565772808186}}
{"text": "# This is a generic bracket operation.  With more than two arguments,\n# it represents an iterated bracket associated like [a,[b,[c,[d,e]]]].\n# Multilinearity rules are applied automatically, and the Jacobi\n# rule is also used automatically to convert other kinds of iterated\n# brackets into the fully right associated form.\n\nbracket := proc()\n local n,m,i,j,u,a,b,c,v,ac,av,x,y;\n n := nargs;\n for i from 1 to n do\n  u := seq(args[j],j=1..i-1);\n  a := args[i];\n  v := seq(args[j],j=i+1..n);\n  if type(a,`+`) then\n   return map(t -> bracket(u,t,v),a);\n  elif type(a,`*`) then\n   ac,av := selectremove(type,a,rational);\n   if ac <> 1 then\n    return ac * bracket(u,av,v);\n   fi;\n  elif type(a,specfunc(bracket)) then\n   if i = n then\n    return bracket(u,op(a));\n   else\n    b := op(1,a);\n    c := bracket(op(2..-1,a));\n    if nops(c) = 1 then c := op(c); fi;\n    return bracket(u,b,c,v) - bracket(u,c,b,v);\n   fi;\n  fi;\n od;\n\n if type(args[n],specfunc(bracket)) then\n  return bracket(args[1..n-1],op(args[n]));\n fi;\n \n return 'procname'(args);\nend:\n\n", "meta": {"hexsha": "e3b1218d9a32af3bda2485c7a12f97e59e092f24", "size": 1048, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/lie_algebra.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/lie_algebra.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/lie_algebra.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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.2, "max_line_length": 70, "alphanum_fraction": 0.6154580153, "num_tokens": 337, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7549149868676284, "lm_q2_score": 0.5813030906443133, "lm_q1q2_score": 0.43883441503986353}}
{"text": "`is_element/colour_profiles` := (C::set) -> (n::nonnegint) -> proc(c)\n type(c,list) and nops(c) = n and {op(c)} minus C = {};\nend:\n\n`is_equal/colour_profiles` := (C::set) -> (n::nonnegint) -> (c,b) -> evalb(c = b);\n\n`list_elements/colour_profiles` := (C::set) -> proc(n::nonnegint)\n local L,i,x,c;\n L := [[]];\n for i from 1 to n do\n  L := [seq(seq([op(c),x],x in C),c in L)];\n od:\n return L;\nend:\n\n`count_elements/colour_profiles` := (C::set) -> (n::nonnegint) -> nops(C)^n;\n\n`random_element/colour_profiles` := (C::set) -> (n::nonnegint) -> proc()\n local i;\n [seq(random_element_of(C),i=1..n)];\nend:\n\n`o/colour_profiles` := proc() map(op,[args]); end:\n\n`gamma/colour_profiles` := (C::set) -> (L::list(nonnegint)) -> proc(c,d)\n map(op,d);\nend:\n\n`circ/colour_profiles` := (C::set) -> (i,m,n) -> proc(c,b)\n [op(1..i-1,c),op(b),op(i+1..m,c)];\nend:\n", "meta": {"hexsha": "76ebed382b689c93a31941b1c3cad3b3e5e9a62d", "size": 845, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/semioperads/coloured.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/semioperads/coloured.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/semioperads/coloured.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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.40625, "max_line_length": 82, "alphanum_fraction": 0.5775147929, "num_tokens": 312, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6992544335934766, "lm_q2_score": 0.6261241772283034, "lm_q1q2_score": 0.43782010690695883}}
{"text": "######################################################################\n\n`is_element/ACP` := (N::posint) -> (A::set) -> proc(Q)\n local procname_,i,U,V;\n\n global reason;\n\n procname_ := \"is_element/ACP\";\n \n if not (type(Q,list) and nops(Q) = N) then\n  reason := [procname_,\"Q is not a list of length N\",Q,N];\n  return false;\n fi;\n\n for i from 1 to N do\n  if not `is_element/preord`(A)(Q[i]) then\n   reason := [procname_,\"Q[i] is not a preorder on A\",Q[i],A,reason];\n   return false;\n  fi;\n od;\n\n if not `is_total/preord`(A)(Q[1]) then\n  reason := [procname_,\"Q[1] is not total\",Q[1]];\n  return false;  \n fi;\n\n for i from 1 to N-1 do\n  U := Q[i] intersect `op/preord`(A)(Q[i]);\n  V := Q[i+1] union `op/preord`(A)(Q[i+1]);\n  if U <> V then\n   reason := [procname_,\"Q[i] and Q[i+1] do not match\",Q[i],Q[i+1]];\n   return false;\n  fi;\n od;\n\n return true;\nend:\n\n`is_equal/ACP` := (N::posint) -> (A::set) -> proc(Q1,Q2)\n local procname_;\n global reason;\n\n procname_ := \"is_equal/ACP\";\n \n if Q1 <> Q2 then\n  reason := [procname_,\"Q1 <> Q2\",Q1,Q2];\n  return false;\n fi;\n\n return true;\nend:\n\n`is_leq/ACP` := (N::posint) -> (A::set) -> proc(Q1,Q2)\n local i;\n\n for i from 1 to N do \n  if Q2[i] minus Q1[i] <> {} then\n   return false;\n  fi;\n od;\n\n return true;\nend:\n\n`list_elements/ACP` := (N::posint) -> proc(A::set)\n local W,X,Y,Z,Q,R,S,pi,B;\n\n if nops(A) = 0 then\n  return FAIL;\n fi;\n\n if N = 1 then\n  X := `list_elements/total_preord`(A);\n  return map(Q -> [Q],X);\n fi;\n\n X := `list_elements/ACP`(N-1)(A);\n Y := NULL;\n \n for Q in X do\n  pi := `block_partition/preord`(A)(Q[N-1]);\n  Z := [{}];\n  for B in pi do\n   W := `list_elements/total_preord`(B);\n   Z := [seq(seq(R union S,S in W),R in Z)];\n  od:\n  Y := Y,seq([op(Q),R],R in Z);\n od;\n return [Y];\nend:\n\n`count_elements/ACP` := (N::posint) -> proc(A::set)\n local d;\n add(Stirling2(nops(A),d)*d!*N^(d-1),d=1..nops(A)); \nend:\n\n`random_element/ACP` := (N::posint) -> (A::set) -> proc()\n local i,n,pi,Q,R,S,B,C;\n\n if nops(A) = 0 then\n  return FAIL;\n fi;\n\n R := `random_element/total_preord`(A)();\n Q := [R];\n for i from 2 to N do \n  pi := `block_partition/preord`(A)(R);\n  R := {};\n  for B in pi do\n   S := `random_element/total_preord`(B)();\n   R := R union S;\n  od;\n  Q := [op(Q),R];\n od;\n\n return Q;\nend:\n\n`rank_vector/ACP` := (N::posint) -> (A::set) -> proc(Q)\n local i;\n [seq(`rank/preord`(N)(A)(Q[i]),i=1..N)];\nend:\n\n`rank/ACP` := (N::posint) -> (A::set) -> proc(Q)\n local i;\n add(`rank/preord`(N)(A)(Q[i]),i=1..N);\nend:\n\n`res/ACP` := (N::posint) -> (A::set,B::set) -> proc(Q)\n return map(`intersect`,Q,`top/autorel`(B));\nend:\n\n`is_constant/ACP` := (N::posint) -> (A::set) -> proc(Q)\n return evalb(nops(Q[N]) = nops(A)^2);\nend;\n\n`is_separated/ACP` := (N::posint) -> (A::set) -> proc(Q)\n return evalb(Q[N] minus `id/autorel`(A) = {});\nend;\n\n`bot/ACP` := (N::posint) -> (A::set) -> [`top/autorel`(A) $ N];\n\n######################################################################\n\n`mu/W/ACP` := (N::posint) -> (A::set) -> proc(x) \n local QT,ET,AA,i,a,b;\n\n QT := table():\n ET := table():\n AA := {seq(seq([a,b],b in A),a in A)};\n ET[0] := AA;\n\n for i from 1 to N do\n  QT[i] := select(ab -> is(x[ab[1]][i] <= x[ab[2]][i]),ET[i-1]);\n  ET[i] := QT[i] intersect `op/autorel`(A)(QT[i]);\n od:\n \n return [seq(QT[i],i=1..N)];\nend:\n\n`sigma/ACP/W` := (N::posint) -> (A::set) -> proc(Q)\n local u,x,a,i;\n\n u := [seq(`rank_table/preord`(A)(Q[i]),i=1..N)];\n x := table():\n for a in A do \n  x[a] := [seq(u[i][a],i=1..N)];\n od:\n\n return eval(x);\nend;\n\n######################################################################\n\n`is_element/realisation/ACP` := (N::posint) -> (A::set) -> \n `is_element/realisation/generic`(\"ACP\",\n  eval(`is_element/ACP`(N)(A)),\n  eval(`is_leq/ACP`(N)(A))\n );\n\n`is_equal/realisation/ACP` := (N::posint) -> (A::set) -> \n `is_equal/realisation/generic`(\"ACP\",\n  eval(`is_equal/ACP`(N)(A))\n );\n\n`sigma/realisation/ACP/W` := (N::posint) -> (A::set) -> proc(u)\n local x,y,m,a,Q,S;\n\n x := table();\n for a in A do\n  x[a] := [0$N];\n od:\n\n S := map(op,[indices(u)]);\n for Q in S do \n  y := `sigma/ACP/W`(N)(A)(Q);\n  m := u[Q];\n  for a in A do \n   x[a] := x[a] +~ (m *~ y[a]);\n  od:\n od:\n\n return eval(x);\nend;\n\n`mu_aux/ACP` := (N::posint) -> (A::set) -> proc(x)\n local Q,t,i,ab,a,b,s,y,u;\n\n Q := `mu/W/ACP`(N)(A)(x);\n\n if nops(Q[N]) = nops(A)^2 then\n  return(table());\n fi;\n\n t := 1;\n for i from 1 to N do\n  for ab in Q[i] minus `op/autorel`(A)(Q[i]) do\n   a,b := op(ab);\n   t := min(t,x[b][i] - x[a][i]);\n  od;\n od;\n\n s := `sigma/ACP/W`(N)(A)(Q);\n y := table();\n for a in A do \n  y[a] := x[a] -~ (t *~ s[a]);\n od;\n\n u := `mu_aux/ACP`(N)(A)(y);\n if `is_element/RR`(u[Q]) then \n  u[Q] := u[Q] + t;\n else\n  u[Q] := t;\n fi;\n\n return eval(u);\nend;\n\n######################################################################\n\n`rank_vector/ACP` := (N) -> (A) -> proc(Q)\n local i;\n return [seq(`rank/preord`(A)(Q[i])-1,i=1..N)];\nend;\n\n`rank/ACP` := (N) -> (A) -> proc(Q)\n return `+`(op(`rank_vector/ACP`(N)(A)(Q)));\nend;\n\n\n`cofunctor/ACP` := (N::posint) -> (A::set,B::set) -> (f) -> proc(Q)\n map(`cofunctor/autorel`(A,B)(f),Q);\nend;\n\n######################################################################\n\n`is_element/split_spots/ACP` := (N::posint) -> (A::set) -> (Q) -> proc(iCD)\n global reason;\n local procname_,i,B,C,D,B1,E,C1;\n\n procname_ := \"is_element/split_spots/ACP\";\n \n if not(type(iCD,list) and nops(iCD) = 3) then\n  reason := [procname_,\"iCD is not a list of length 3\",iCD];\n  return false;\n fi;\n\n i,C,D := op(iCD);\n if not(type(i,posint) and i <= N) then\n  reason := [procname_,\"i is not in [1,N]\",i,N];\n  return false;\n fi;\n\n if not(type(C,set) and nops(C) > 0 and C minus A = {}) then\n  reason := [procname_,\"C is not a nonempty subset of A\",C,A];\n  return false;\n fi;\n\n if not(type(D,set) and nops(D) > 0 and D minus A = {}) then\n  reason := [procname_,\"D is not a nonempty subset of A\",D,A];\n  return false;\n fi;\n\n if C intersect D <> {} then\n  reason := [procname_,\"C and D are not disjoint\",C,D];\n  return false;\n fi;\n\n B := C union D;\n \n B1 := select(a -> member([a,B[1]],Q[i]) and member([B[1],a],Q[i]),A);\n if B1 <> B then\n  reason := [procname_,\"C u D is not an equivalence class for Q[i]\",C,D,i,Q[i]];\n  return false;\n fi;\n\n if i < N then\n  E := select(ab -> member([ab[2],ab[1]],Q[i+1]),Q[i+1]);\n  C1 := map(ab -> ab[1],select(ab -> member(ab[1],C),E));\n  if C minus C1 <> {} then\n   reason := [procname_,\"C is not a union of equivalence classes for Q[i+1]\",C,D,i,Q[i+1]];\n   return false;\n  fi;\n fi;\n\n return true;\nend:\n\n######################################################################\n\n`list_elements/split_spots/ACP` := (N::posint) -> (A::set) -> proc(Q)\n local E,L,i,B,m,UU,U,CC,C,a;\n\n E := [seq(`block_partition/preord`(A)(Q[i]),i=1..N),{seq({a},a in A)}];\n L := NULL;\n for i from 1 to N do\n  for B in E[i] do\n   UU := select(U -> U minus B = {},E[i+1]);\n   m := nops(UU);\n   UU := select(U -> nops(U) < m,`list_elements/nonempty_subsets`(UU));\n   CC := map(U -> map(op,U),UU);\n   L := L,seq([i,C,B minus C],C in CC);\n  od: \n od:\n return [L];\nend:\n\n######################################################################\n\n`split/ACP` := (N::posint) -> (A::set) -> (Q) -> proc(iCD)\n local i,j,C,D,CD,DC,c,d;\n\n i,C,D := op(iCD);\n CD := {seq(seq([c,d],d in D),c in C)};\n DC := {seq(seq([d,c],d in D),c in C)};\n return([\n  seq(Q[j],j=1..i-1),\n  Q[i] minus DC,\n  seq(Q[j] minus DC minus CD,j=i+1..N)\n ]);\nend:\n\n######################################################################\n\n`is_element/glue_spots/ACP` := (N::posint) -> (A::set) -> (Q) -> proc(iCDS)\n global reason;\n local procname_,i,C,D,S,Qi,Qis,Ei,C1,D1,E,nC,nD;\n\n procname_ := \"is_element/glue_spots/ACP\";\n \n if not(type(iCDS,list) and nops(iCDS) = 4) then\n  reason := [procname_,\"iCDS is not a list of length 4\",iCDS];\n  return false;\n fi;\n\n i,C,D,S := op(iCDS);\n if not(type(i,posint) and i <= N) then\n  reason := [procname_,\"i is not in [1,N]\",i,N];\n  return false;\n fi;\n\n if not(type(C,set) and nops(C) > 0 and C minus A = {}) then\n  reason := [procname_,\"C is not a nonempty subset of A\",C,A];\n  return false;\n fi;\n\n if not(type(D,set) and nops(D) > 0 and D minus A = {}) then\n  reason := [procname_,\"D is not a nonempty subset of A\",D,A];\n  return false;\n fi;\n\n if C intersect D <> {} then\n  reason := [procname_,\"C and D are not disjoint\",C,D];\n  return false;\n fi;\n\n Qi := Q[i];\n Ei,Qis := selectremove(ab -> member([ab[2],ab[1]],Qi),Qi);\n\n if not(member([C[1],D[1]],Qis)) then\n  reason := [procname_,\"not(C < D)\",C,D,Qi];\n  return false;\n fi;\n\n C1 := select(a -> member([a,C[1]],Ei),A);\n if C1 <> C then\n  reason := [procname_,\"C is not an equivalence class\",C,C1,Qi];\n  return false;\n fi;\n\n D1 := select(a -> member([a,D[1]],Ei),A);\n if D1 <> D then\n  reason := [procname_,\"D is not an equivalence class\",D,D1,Qi];\n  return false;\n fi;\n\n E := select(a -> member([C[1],a],Qis) and member([a,D[1]],Qis),A);\n if E <> {} then\n  reason := [procname_,\"C and D are not adjacent\",C,D,E,Qi];\n  return false;\n fi;\n\n if i = N then\n  if S = {} then\n   return true;\n  else\n   reason := [procname_,\"i=N but S <> {}\",i,N,S];\n   return false;\n  fi;\n fi;\n\n nC := nops(`block_partition/preord`(C)(`res/preord`(A,C)(Q[i+1])));\n nD := nops(`block_partition/preord`(D)(`res/preord`(A,D)(Q[i+1])));\n\n if not (type(S,set(posint)) and\n         nops(S) = nC and\n         max(op(S)) <= nC+nD) then\n  reason := [procname_,\"S is not a subset of size nC in [1,nC+nD]\",S,C,D,Q[i+1]];\n  return false;\n fi;\n\n return true;\nend:\n\n######################################################################\n\n`list_elements/glue_spots/ACP` := (N::posint) -> (A::set) -> proc(Q)\n local L,i,j,Qi,Qis,E,E0,E1,B,U,C,a,b,r0,nn,SS,S;\n\n L := NULL;\n for i from 1 to N do\n  Qi := Q[i];\n  Qis := remove(ab -> member([ab[2],ab[1]],Qi),Qi);\n  E := `block_partition/preord`(A)(Qi);\n  E0 := NULL;\n  E1 := table():\n  for B in E do \n   E0 := E0,B[1];\n   E1[B[1]] := B;\n  od:\n  E0 := {E0}:\n  U := table():\n  C := table():\n  for a in E0 do \n   U[a] := select(b -> member([a,b],Qis),E0);\n  od: \n  for a in E0 do \n   C[a] := U[a] minus {seq(op(U[b]),b in U[a])};\n  od:\n  if i < N then\n   r0 := `rank_table/preord`(A)(Q[i+1]);\n   for a in E0 do \n    nn[a] := 1 + max(seq(r0[b],b in E1[a]));\n   od;\n  fi;\n\n  for a in E0 do \n   for b in C[a] do\n    if i < N then\n     SS := combinat[choose]({seq(j,j=1..nn[a]+nn[b])},nn[a]);\n    else\n     SS := {{}};\n    fi;\n    L := L,seq([i,E1[a],E1[b],S],S in SS);\n   od;\n  od;\n od:\n return [L];\nend:\n\n######################################################################\n\n`glue/ACP` := (N::posint) -> (A::set) -> (Q) -> proc(iCDS)\n local i,C,D,S,CD,DC,c,d,P,j,k,rc,rd,nc,nd,ic,id,n,Cn,Dn,BB,x,y;\n\n i,C,D,S := op(iCDS);\n CD := {seq(seq([c,d],d in D),c in C)};\n DC := {seq(seq([d,c],d in D),c in C)};\n P := table():\n for j from 1 to i-1 do \n  P[j] := Q[j];\n od:\n P[i] := Q[i] union DC;\n if i < N then\n  rc := `rank_table/preord`(C)(Q[i+1]);\n  rd := `rank_table/preord`(D)(Q[i+1]);\n  nc := max(seq(rc[c],c in C)) + 1;\n  nd := max(seq(rd[d],d in D)) + 1;\n  for n from 1 to nc do Cn[n] := select(c -> rc[c] = n-1,C); od;\n  for n from 1 to nd do Dn[n] := select(d -> rd[d] = n-1,D); od;\n  ic := 0;\n  id := 0;\n  BB := NULL;\n  for j from 1 to nc + nd do\n   if member(j,S) then\n    ic := ic+1;\n    BB := BB,Cn[ic];\n   else\n    id := id+1;\n    BB := BB,Dn[id];\n   fi;\n  od;\n  BB := [BB];\n  P[i+1] := Q[i+1] union {seq(seq(seq(seq([x,y],y in BB[k]),x in BB[j]),k=j..nc+nd),j=1..nc+nd)};\n fi;\n for j from i+2 to N do\n  P[j] := Q[j];  \n od:\n return [seq(P[j],j=1..N)];\nend:\n\n######################################################################\n\n`describe/ACP` := (N::posint) -> (A::set) -> proc(Q)\n local s,E,i,j,k,r,s0,s1,s2,B,C,m;\n\n s := \"\";\n E := {A};\n for i from 1 to N do\n  s0 := \"\";\n  for B in E do\n   if nops(B) > 1 then\n    r := `rank_table/preord`(B)(Q[i] intersect `top/autorel`(B));\n    m := max(map(b -> r[b],B));\n    s1 := \"\";\n    for j from 0 to m do \n     C := select(b -> r[b]=j,B);\n     s2 := \"\";\n     for k from 1 to nops(C) do \n      s2 := cat(s2,`if`(k>1,\"=\",\"\"),sprintf(\"%A\",C[k]));\n     od:\n     s1 := cat(s1,`if`(j>0,\"<\",\"\"),s2);\n    od;\n    s0 := cat(s0,`if`(s0=\"\",\"\",\",\"),s1);\n   fi;\n  od:\n  s := cat(s,`if`(s=\"\",\"\",\";\"),s0);\n  E := `block_partition/preord`(A)(Q[i]);\n od;\n s := cat(\"(\",s,\")\");\nend:\n", "meta": {"hexsha": "6a40b6d8713b73241e6c6183243e49d2861aabf2", "size": 12222, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/operads/chains/ACP.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/operads/chains/ACP.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/operads/chains/ACP.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.5498154982, "max_line_length": 97, "alphanum_fraction": 0.4960726559, "num_tokens": 4535, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920020959545, "lm_q2_score": 0.5467381519846138, "lm_q1q2_score": 0.4377688655348027}}
{"text": "\n# Kinematik-Berechnung 3. Arm KAS5\n# Beschreibung\n# \n# Modell m5: \n# * Kurbel N7 ist starr mit Körper K2 gekoppelt (über die Achse) (wie m3), \n# * Zahnradkopplung zwischen Körpern Z2 und Z3 (Unterschied zu m3)\n# \n# Setze die Zwangsbedingung (Zahnradkopplung) in die bereits berechneten Zwangsbedingungen für das KAS5m3 ein\n# \n# Berechnung der Kopplung der Zahnräder am Ellenbogen\n# Autor\n# Moritz Schappler, schappler@irt.uni-hannover.de, 2016-02\n# Institut fuer Regelungstechnik, Leibniz Universitaet Hannover\n# Initialisierung\nrestart:\nkin_constraints_exist := true: # Für Speicherung\n;\nwith(LinearAlgebra):\nwith(StringTools):\nread \"../helper/proc_convert_s_t\":\nread \"../helper/proc_convert_t_s\": \nread \"../helper/proc_MatlabExport\":\nread \"../robot_codegen_constraints/proc_subs_kintmp_exp\":\nread \"../robot_codegen_definitions/robot_env\":\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", robot_name):\n# Lese Ergebnisse der Kinematik von KAS5m3 aus.\n# Siehe KAS5m3_sym_codegen_kinematic_constraints.mw\n# kintmp_qs, kintmp_qt, lpar_qs, lpar_qt, kintmp_subsexp\nread  sprintf(\"../codeexport/KAS5m3/tmp/kinematic_constraints_maple_inert.m\", robot_name):\nkintmp_qs_KAS5m3 := kintmp_qs:\nkintmp_qt_KAS5m3 := kintmp_qt:\nlpar_qs_KAS5m3 := lpar_qs:\nlpar_qt_KAS5m3 := lpar_qt:\nkintmp_subsexp_KAS5m3 := kintmp_subsexp:\n# Wende Zwangsbedingungen aus Zahnradkontakt an\n# Wandle die verallgemeinerten Koordinaten um. Benutze die Reihenfolge für KAS5m5.\n# Funktion zur Ersetzung der Gelenkwinkel (allgemein -> m3)\nsubs_q_J_m3 := proc(A)\n  local A_s, j; \n  A_s := A; \n  for j from 1 to RowDimension(qJ_s) do\n    A_s := subs({qJ_s(j,1) = qJs_KAS5m3(j,1)}, A_s):\n  end do:\n  return A_s:\nend proc:\nqJs_KAS5m3:=Matrix(7, 1, [qJs1_m3, qJs2_m3, qJs3_m3, qJs4_m3, qJs5_m3, qJs6_m3, qJs7_m3]):\nkintmp_subsexp_KAS5m3 := subs_q_J_m3(kintmp_subsexp_KAS5m3):\nkintmp_qs_KAS5m3 := subs_q_J_m3(kintmp_qs_KAS5m3):\nlpar_qs_KAS5m3 := subs_q_J_m3(lpar_qs_KAS5m3):\n# Funktion zur Ersetzung der verallgemeinerten Koordinaten (m3 -> m5)\nsubs_q_m3_m5 := proc(A)\n  local A_s, j; \n  A_s := A; \n  for j from 1 to RowDimension(qJ_s) do\n    A_s := subs({qJs_KAS5m3(j,1) = qJs_KAS5m3m5subs(j,1)}, A_s):\n  end do:\n  return A_s:\nend proc:\nqJs_KAS5m3m5subs:=Matrix(7, 1, [qJs1_m5, qJs2_m5, qJs3_m5, qJs4_m5, qJs4_m5-qJs3_m5+delta18s, qJs5_m5, 0]):\nkintmp_subsexp_KAS5m5 := subs_q_m3_m5(kintmp_subsexp_KAS5m3):\nkintmp_qs_KAS5m5 := subs_q_m3_m5(kintmp_qs_KAS5m3):\nlpar_qs_KAS5m5 := subs_q_m3_m5(lpar_qs_KAS5m3):\n# Konvertiere Ergebnisse\n# Rückersetzung der markierten Koordinaten gegen die normale Form (qJ_KAS5m5 -> qJ)\nsubs_q_m5_J := proc(A)\n  local A_s, j; \n  A_s := A; \n  for j from 1 to RowDimension(qJs_KAS5m5) do\n    A_s := subs({qJs_KAS5m5(j,1) = qJ_s(j,1)}, A_s):\n  end do:\n  return A_s:\nend proc:\nqJs_KAS5m5:=Matrix(5, 1, [qJs1_m5, qJs2_m5, qJs3_m5, qJs4_m5, qJs5_m5]):\nkintmp_subsexp := subs_q_m5_J(kintmp_subsexp_KAS5m5):\nkintmp_qs := subs_q_m5_J(kintmp_qs_KAS5m5):\nlpar_qs := subs_q_m5_J(lpar_qs_KAS5m5):\nkintmp_qt := convert_s_t(kintmp_qs):\nlpar_qt := convert_s_t(lpar_qs):\n# Speichern der Ergebnisse\nsave kin_constraints_exist, kintmp_qs, kintmp_qt, lpar_qs, lpar_qt, kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_inert\", robot_name):\nsave kin_constraints_exist, kintmp_qs, kintmp_qt, lpar_qs, lpar_qt, kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_inert.m\", robot_name):\n# Liste der Parameter speichern\n# Liste mit abhängigen konstanten Kinematikparametern erstellen (wichtig für Matlab-Funktionsgenerierung)\nread \"../helper/proc_list_constant_expressions\";\nkc_symbols := Matrix(list_constant_expressions( kintmp_subsexp(..,2) )):\nsave kc_symbols, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_symbols_list_maple\", robot_name):\nMatlabExport(Transpose(kc_symbols), sprintf(\"../codeexport/%s/tmp/kinematic_constraints_symbols_list_matlab.m\", robot_name), 2):\nprintf(\"Zwangsbedingungen der Parallelstruktur von KAS5m3 nach KAS5m5 angepasst. %s\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n\n\n", "meta": {"hexsha": "5817e776033327293ebb62bb19d9c067211f3ce8", "size": 4022, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "exoskeleton_model/model_generation/constraints/KAS5m5_kinematic_constraints.mpl", "max_stars_repo_name": "SchapplM/robsynth-paper_iftommwc2019_dynamics_hybridrobots", "max_stars_repo_head_hexsha": "b3d83b4c99bb5bccb3076ca93790b079fc4e1d2f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-12-19T14:12:45.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-19T14:12:45.000Z", "max_issues_repo_path": "exoskeleton_model/model_generation/constraints/KAS5m5_kinematic_constraints.mpl", "max_issues_repo_name": "SchapplM/robsynth-paper_iftommwc2019_dynamics_hybridrobots", "max_issues_repo_head_hexsha": "b3d83b4c99bb5bccb3076ca93790b079fc4e1d2f", "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": "exoskeleton_model/model_generation/constraints/KAS5m5_kinematic_constraints.mpl", "max_forks_repo_name": "SchapplM/robsynth-paper_iftommwc2019_dynamics_hybridrobots", "max_forks_repo_head_hexsha": "b3d83b4c99bb5bccb3076ca93790b079fc4e1d2f", "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.7173913043, "max_line_length": 164, "alphanum_fraction": 0.7737444058, "num_tokens": 1519, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7577943822145998, "lm_q2_score": 0.5698526514141571, "lm_q1q2_score": 0.4318311379317429}}
{"text": "######################################################################\n\n`is_element/SCP2` := (N::posint) -> (A::set,B::set) -> proc(QP)\n local i,Q0,Q,P;\n\n global reason;\n\n if not(type(QP,list) and nops(QP) = 2) then\n  reason := [convert(procname,string),\"QP is not a list of length two\",reason];\n fi;\n\n Q,P := op(QP);\n\n if not `is_element/SCP`(N)(A)(Q) then\n  reason := [convert(procname,string),\"Q not in SCP(N)(A)\",reason];\n  return false;\n fi;\n\n if not `is_element/SCP`(N)(B)(P) then\n  reason := [convert(procname,string),\"P not in SCP(N)(B)\",reason];\n  return false;\n fi;\n\n Q0 := `res/SCP`(N)(A,B)(Q);\n\n if Q0 <> P and Q0 <> [`top/autorel`(B)$N] then\n  reason := [convert(procname,string),\"Q and P are incompatible\"];\n  return false;\n fi;\n\n return true;\nend:\n\n`is_equal/SCP2` := (N::posint) -> (A::set,B::set) -> proc(QP1,QP2)\n return \n  `is_equal/SCP`(N)(A)(QP1[1],QP2[1]) and\n  `is_equal/SCP`(N)(B)(QP1[2],QP2[2]);\nend:\n\n`is_leq/SCP` := (N::posint) -> (A::set) -> proc(Q1,Q2)\n local i;\n\n for i from 1 to N do \n  if Q2[i] minus Q1[i] <> {} then\n   return false;\n  fi;\n od;\n\n return true;\nend:\n\n`list_elements/SCP2` := (N::posint) -> proc(A::set,B::set)\n local X,Y,Z,n,Q,P;\n\n X := `list_elements/SCP`(N)(A);\n Y := `list_elements/SCP`(N)(B);\n Z := NULL;\n\n n := nops(B);\n\n for Q in X do\n  P := `res/SCP`(N)(A,B)(Q);\n\n  if nops(P[N]) = n^2 then\n   Z := Z,seq([Q,P],P in Y);\n  else\n   Z := Z,[Q,P];\n  fi;\n od:\n\n Z := [Z];\n\n return Z;\nend:\n\n`random_element/SCP2` := (N::posint) -> (A::set,B::set) -> proc(p := 0.5)\n local A0,p0,a,Q0,AA,Q,P,i;\n if rand(1..10000)() < evalf(10000 * p) then\n  A0 := (A minus B) union {b0};\n  p0 := table();\n  for a in A do \n   p0[a] := `if`(member(a,B),b0,a);\n  od;\n  Q0 := `random_element/SCP`(N)(A0)();\n  AA := `top/autorel`(A);\n  Q := [seq(select(xy -> member(map(p0,xy),Q0[i]),AA),i=1..N)];\n  P := `random_element/SCP`(N)(B)();\n  return [Q,P];\n else\n  Q := `random_element/SCP`(N)(A)();\n  P := `res/SCP`(N)(A,B)(Q);\n\n  while `is_constant/ACP`(N)(B)(P) do\n   Q := `random_element/SCP`(N)(A)();\n   P := `res/SCP`(N)(A,B)(Q);\n  od;\n\n  return [Q,P];\n fi;\nend:\n\n\n\n", "meta": {"hexsha": "a6c158d77ebd05048632e0f8f3582534231256f2", "size": 2092, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/operads/chains/SCP2.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/operads/chains/SCP2.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/operads/chains/SCP2.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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": 20.1153846154, "max_line_length": 79, "alphanum_fraction": 0.5301147228, "num_tokens": 794, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7279754489059775, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.4314467341531434}}
{"text": "#===============================================================================\nIdentifiabilityODE := proc(system_ODEs, params_to_assess, p, output_targets, count_solutions, char)#{p := 0.99, infolevel := 1, method := 2, num_nodes := 6}) \n#===============================================================================\n local i, j, k, n, m, s, all_params, all_vars, eqs, Q, X, Y, poly, d0, D1, \n        sample, all_subs,alpha, beta, Et, x_theta_vars, prolongation_possible, \n        eqs_i, JacX, vars, vars_to_add, ord_var, var_index, deg_variety, D2, \n        y_hat, u_hat, theta_hat, Et_hat, Q_hat, theta_l, theta_g, gb, v, X_eq, Y_eq, \n        poly_d, separant, leader, x_functions, y_functions, u_functions,\n        all_symbols_rhs, mu, x_vars, y_vars, u_vars, theta, subst_first_order,\n        subst_zero_order, x_eqs, y_eqs, param, other_params, to_add, at_node,\n        prime, max_rank, R, tr, e, p_local, xy_ders, polys_to_process, new_to_process, method, start, finish, infolevel,\n        num_nodes ,Et_x_vars, out_sian, var, G, P, solutions_table, check:\n\n  #----------------------------------------------\n  # 0. Extract inputs, outputs, states, and parameters from the system\n  #----------------------------------------------\n  method := 2:\n  \n  if SearchText(\".\", convert(system_ODEs, string)) <> 0 then\n    LogText(sprintf(\"WARNING: It looks like your system involves floating-point numbers. This may result into a non-meaninful result, please convert them to rationals (e.g., 0.2 -> 1/5)\"), \"LogAreaSIAN\"):\n    WARNING(\"WARNING: It looks like your system involves floating-point numbers. This may result into a non-meaninful result, please convert them to rationals (e.g., 0.2 -> 1/5)\"):\n  end if:\n  \n  if not (indets(system_ODEs, name) subset indets(system_ODEs)) then\n    LogText(sprintf(cat(\"ERROR: you are using reserved maple symbols: \", convert(indets(system_ODEs, name) minus indets(system_ODEs), string))), output_targets[log]):\n    DocumentTools:-SetProperty(\"GlobalParams1\", expression, Error(BadName)):\n    DocumentTools:-SetProperty(\"LocalParams1\", expression,  Error(BadName)):\n    DocumentTools:-SetProperty(\"NoIDParams1\", expression,  Error(BadName)):\n    error (cat(\"ERROR: you are using reserved maple symbols: \", convert(indets(system_ODEs, name) minus indets(system_ODEs), string))):\n    return;\n  end if:\n  \n  randomize():\n  infolevel:=1:\n  num_nodes:=1:\n  if infolevel > 0 then\n    PrintHeader(\"0. Extracting states, inputs, outputs, and parameters from the system\"):\n  end if:\n  x_functions := map(f -> int(f, t), select( f -> type(int(f, t), function(name)), map(lhs, system_ODEs) )):\n  y_functions := select( f -> not type(int(f, t), function(name)), map(lhs, system_ODEs) ):\n  all_symbols_rhs := foldl(`union`, op( map(e -> indets(rhs(e)), system_ODEs) )) minus {t}:\n  xy_ders := {op(x_functions), op(y_functions), op(select(f -> (f in all_symbols_rhs), map(lhs, system_ODEs)))}:\n  u_functions := select( f -> type(f, function), convert(all_symbols_rhs minus xy_ders, list)):\n  mu := convert(all_symbols_rhs minus {op(xy_ders), op(u_functions)}, list):\n\n  x_vars := map(FunctionToVariable, x_functions):\n  y_vars := map(FunctionToVariable, y_functions):\n  u_vars := map(FunctionToVariable, u_functions):\n  theta := map(ParamToInner, params_to_assess):\n  subst_first_order := {seq(diff(x_functions[i], t) = MakeDerivative(x_vars[i], 1), i = 1 .. nops(x_vars))}:\n  subst_zero_order := {\n    seq(x_functions[i] = MakeDerivative(x_vars[i], 0), i = 1 .. nops(x_vars)),\n    seq(y_functions[i] = MakeDerivative(y_vars[i], 0), i = 1 .. nops(y_vars)),\n    seq(u_functions[i] = MakeDerivative(u_vars[i], 0), i = 1 .. nops(u_vars))\n  }:\n  x_eqs := subs(subst_zero_order, subs(subst_first_order, select(e -> type(int(lhs(e), t), function(name)), system_ODEs))):\n  y_eqs := subs(subst_zero_order, select(e -> not type(int(lhs(e), t), function(name)), system_ODEs)):\n\n  # taking into account that fact that Groebner[Basis] is Monte Carlo with probability of error \n  # at most 10^(-18) (for Maple 2017)\n  p_local := p + nops(params_to_assess) * 10^(-18):\n  if p_local >= 1 then\n    LogTextSIAN(\"The probability of success cannot exceed 1 - #params_to_assess 10^{-18}. We reset it to 0.99\");\n    p_local := 0.99:\n  end if:\n\n  if infolevel > 0 then\n    LogText(sprintf(\"\\n===== Input info =====\\n\"), output_targets[log]): \n    LogText(sprintf(\"%s %a\\n\", `State variables:         `, x_functions), output_targets[log]): \n    LogText(sprintf(\"%s %a\\n\", `Output variables:        `, y_functions), output_targets[log]): \n    LogText(sprintf(\"%s %a\\n\", `Input variables:         `, u_functions), output_targets[log]): \n    LogText(sprintf(\"%s %a\\n\", `Parameters in equations: `, mu), output_targets[log]): \n    LogText(sprintf(\"===================\\n\\n\"), output_targets[log]): \n  end if:\n\n  #----------------------------------------------\n  # 1. Construct the maximal system.\n  #----------------------------------------------\n\n  if infolevel > 0 then\n    PrintHeader(\"1. Constructing the maximal polynomial system\"):\n  end if:\n\n  # (a) ---------------\n  n := nops(x_vars):\n  m := nops(y_vars):\n  s := nops(mu) + n:\n  all_params := [op(mu), op(map(x -> MakeDerivative(x, 0), x_vars ))]:\n  all_vars := [ op(x_vars), op(y_vars), op(u_vars) ]:\n  eqs := [op(x_eqs), op(y_eqs)]:\n  Q := foldl( (f, g) -> lcm(f, g), op( map(f -> denom(rhs(f)), eqs) )):\n  \n\n  # (b,c) ---------------\n  X := []:\n  X_eq := []:\n  for i from 1 to n do\n    X := [op(X), []]:\n    poly := numer(lhs(x_eqs[i]) - rhs(x_eqs[i])):\n    for j from 0 to s + 1 do\n      poly_d := Differentiate(poly, all_vars, j):\n      leader := MakeDerivative(x_vars[i], j + 1):\n      separant := diff(poly_d, leader):\n      X[i] := [op(X[i]), poly_d]:\n      X_eq := [op(X_eq), leader = -(poly_d - separant * leader) / separant]:\n    end do:\n  end do:\n  # LogExpression(X[1]);\n  \n  # (d,e) ---------------\n  Y := []:\n  Y_eq := []:\n  for i from 1 to m do\n    Y := [op(Y), []]:\n    poly := numer(lhs(y_eqs[i]) - rhs(y_eqs[i])):\n    for j from 0 to s + 1 do\n      poly_d := Differentiate(poly, all_vars, j):\n      leader := MakeDerivative(y_vars[i], j):\n      separant := diff(poly_d, leader):\n      Y[i] := [op(Y[i]), poly_d]:\n      Y_eq := [op(Y_eq), leader = -(poly_d - separant * leader) / separant]:\n    end do:\n  end do:\n\n\n  #----------------------------------------------\n  # 2. Truncate.\n  #----------------------------------------------\n\n  if infolevel > 0 then\n    PrintHeader(\"2. Truncating the polynomial system based on the Jacobian condition\"):\n  end if:\n\n  # (a) ---------------\n  d0 := max(op( map(f -> degree( simplify(Q * rhs(f)) ), eqs) ), degree(Q)):\n\n  # (b) ---------------\n  # extra factor nops(theta) + 1 compared to the formula in the paper is to\n  # provide probability gaurantee to the local identifiability test\n  D1 := floor( (nops(theta) + 1) * 2 * d0 * s * (n + 1) * (1 + 2 * d0 * s) / (1 - p_local) ):\n  # prime := nextprime(D1):\n  if infolevel > 1 then\n    LogText(sprintf(\"%s %a\\n\", `Bound D_1 for testing the rank of the Jacobian probabilistically: `, D1), output_targets[log]);\n  end if:\n\n  # (c, d) ---------------\n  sample := SamplePoint(D1, x_vars, y_vars, u_vars, mu, X_eq, Y_eq, Q):\n  all_subs := sample[4]:\n  u_hat := sample[2]:\n  y_hat := sample[1]:\n \n  # (e) ------------------\n  alpha := [seq(1, i = 1..n)]:\n  beta := [seq(0, i = 1..m)]:\n  Et := [];\n  # TODO: improve for arbitrary derivatives\n  x_theta_vars := all_params:\n  prolongation_possible := [seq(1, i = 1..m)]:\n\n  # (f) ------------------\n  while add(prolongation_possible) > 0 do\n    for i from 1 to m do\n      if prolongation_possible[i] = 1 then\n        eqs_i := [op(Et), Y[i][beta[i] + 1]]:\n        JacX := VectorCalculus[Jacobian](subs({op(u_hat), op(y_hat)}, eqs_i), x_theta_vars = subs(all_subs, x_theta_vars)):\n        if LinearAlgebra[Rank](JacX) = nops(eqs_i) then\n          Et := [op(Et), Y[i][beta[i] + 1]]:\n          beta[i] := beta[i] + 1:\n          # adding necessary X-equations\n          polys_to_process := [op(Et), seq(Y[k][beta[k] + 1], k=1..m)]:\n          while nops(polys_to_process) <> 0 do\n            new_to_process := []:\n            vars := {};\n            for poly in polys_to_process do\n              vars := vars union { op(GetVars(poly, x_vars)) }:\n            end do:\n            vars_to_add := { op(remove(v -> evalb(v in x_theta_vars), vars)) };\n            for v in vars_to_add do\n              x_theta_vars := [op(x_theta_vars), v];\n              ord_var := GetOrderVar(v);\n              var_index := ListTools[Search](ord_var[1], x_vars):\n              poly := X[ var_index ][ ord_var[2] ]:\n              Et := [op(Et), poly]:\n              new_to_process := [op(new_to_process), poly]:\n              alpha[ var_index ] := max(alpha[ var_index ], ord_var[2] + 1):\n            end do:\n            polys_to_process := new_to_process:\n          end do:\n        else\n          prolongation_possible[i] := 0;\n        end if:\n      end if: \n    end do:\n  end do:\n  # is used for assessing local identifiabilty\n  max_rank := nops(Et):\n\n  # (g) --------------\n  for i from 1 to m do\n    for j from beta[i] + 1 to nops(Y[i]) do\n      to_add := true:\n      for v in GetVars(Y[i][j], x_vars) do\n        if not (v in x_theta_vars) then\n          to_add := false:\n        end if:\n      end do:\n      if to_add = true then\n        beta[i] := beta[i] + 1:\n        Et := [op(Et), Y[i][j]]:\n      end if:\n    end do:\n  end do:\n \n  if infolevel > 1 then\n    LogText(sprintf(\"%s %a\\n\", `Orders of prolongations of the outputs (beta) = `, beta), output_targets[log]):\n    LogText(sprintf(\"%s %a\\n\", `Orders of prolongations of the state variables (alpha) = `, alpha), output_targets[log]):\n  end if:\n  ##############################\n\n  if infolevel > 0 then\n    PrintHeader(\"3. Assessing local identifiability\"):\n  end if:\n \n  theta_l := []:\n  for param in theta do\n    other_params := subs(param = NULL, x_theta_vars):\n    JacX := VectorCalculus[Jacobian]( \n        subs( { op(u_hat), param = subs(all_subs, param), op(y_hat) }, Et), \n        other_params = subs(all_subs, other_params)\n    ):\n    if LinearAlgebra[Rank](JacX) <> max_rank then\n      theta_l := [op(theta_l), param]:\n    end if:\n  end do:\n  DocumentTools:-SetProperty(\"LocalLabel\" , caption, \"Locally Identifiable Paramters\");\n  if infolevel > 1 then\n    LogText(sprintf(\"%s %a\\n\", `Locally identifiable paramters: `, map(x -> ParamToOuter(x, all_vars), theta_l)), output_targets[log]);\n    LogText(sprintf(\"%s %a\\n\", `Nonidentifiable parameter: `, map(x -> ParamToOuter(x, all_vars), [op({op(theta)} minus {op(theta_l)})])), output_targets[log]);\n  end if:\n\n  DocumentTools:-SetProperty(output_targets[localparams], expression, map(x -> ParamToOuter(x, all_vars), theta_l), 'refresh'): # local\n  DocumentTools:-SetProperty(output_targets[noidparams], expression, map(x -> ParamToOuter(x, all_vars), [op({op(theta)} minus {op(theta_l)})]), 'refresh'): # no id\n\n  #----------------------------------------------\n  # 3. Randomize.\n  #----------------------------------------------\n\n  if infolevel > 0 then\n    PrintHeader(\"4. Randomizing the truncated system\"):\n  end if:\n\n  # (a) ------------\n  deg_variety := foldl(`*`, op( map(e -> degree(e), Et) )):\n  D2 := floor( 6 * nops(theta_l) * deg_variety * (1 + 2 * d0 * max(op(beta))) / (1 - p_local) ):\n  if infolevel > 1 then\n    LogText(sprintf(\"%s %a\\n\", `Bound D_2 for assessing global identifiability: `, D2), output_targets[log]):\n  end if:\n\n  # (b, c) ---------\n  sample := SamplePoint(D2, x_vars, y_vars, u_vars, mu, X_eq, Y_eq, Q):\n  y_hat := sample[1]:\n  u_hat := sample[2]:\n  theta_hat := sample[3]:\n  if infolevel > 1 then\n    LogText(sprintf(\"%s %a\\n\", `Random sample for the outputs and inputs is generated from `, theta_hat), output_targets[log]):\n  end if:\n\n  # (d) ------------\n  Et_hat := map(e -> subs([op(y_hat), op(u_hat)], e), Et):\n  Et_x_vars := {}:\n  for poly in Et_hat do\n    Et_x_vars := Et_x_vars union { op(GetVars(poly, x_vars)) }:\n  end do:\n  if infolevel > 1 then\n    LogText(sprintf(\"%s %a %s %a %s\\n\", \"The polynomial system contains\", nops(Et_hat), \"equations in \", nops(Et_x_vars) + nops(mu), \" variables\"), output_targets[log]);\n  end if:\n  Q_hat := subs(u_hat, Q):\n\n  vars := [\n    op(sort([op(Et_x_vars)], (a, b) -> CompareDiffVar(a, b, x_vars))),\n    z_aux, w_aux,\n    op(sort(mu))\n  ]:\n  if infolevel > 1 then\n    LogText(sprintf(\"Variable ordering to be used for Groebner basis computation %a\\n\", vars), output_targets[log]);\n  end if:\n \n  #----------------------------------------------\n  # 4. Determine.\n  #----------------------------------------------\n\n  if infolevel > 0 then\n    PrintHeader(\"5. Assessing global identifiability\"):\n  end if:\n  theta_g := []:\n  if method = 1 then\n    at_node := proc(var, args_node)\n      local gb_loc, fname;\n      gb_loc := Groebner[Basis](op(args_node)):\n      gb_loc;\n    end proc:\n\n    if nops(theta_l) > 1 and num_nodes > 1 then\n      Grid[Setup](\"local\", numnodes = num_nodes):\n      Grid[Set](at_node):\n      gb := Grid[Seq](\n        at_node(theta_l[i], [\n          [op(Et_hat), z_aux * Q_hat - 1, (theta_l[i] - subs(theta_hat, theta_l[i])) * w_aux - 1],\n          tdeg(vars)\n        ]),\n        i = 1..nops(theta_l)\n      ):\n    else\n      gb := []:\n      for i from 1 to nops(theta_l) do\n        gb := [\n          op(gb), \n          at_node(\n            theta_l[i], \n            [[op(Et_hat), z_aux * Q_hat - 1, (theta_l[i] - subs(theta_hat, theta_l[i])) * w_aux - 1], tdeg(op(vars))]\n           ) \n        ]:\n      end do:\n    end if:\n    for i from 1 to nops(theta_l) do\n      if gb[i] = [1] then\n        theta_g := [op(theta_g), theta_l[i]]:\n      else\n        if infolevel > 1 then\n          LogText(sprintf(\"%s %a %s %a\\n\", `Groebner basis corresponding to the parameter `, theta_l[i], ` is `, gb[i]), output_targets[log]):\n        end if:\n      end if:\n    end do:    \n  elif method = 2 then\n     LogText(sprintf(\"%s %a\\n\", `Computing Groebner Basis with characteristic`, char), output_targets[log]):\n    \tgb := Groebner[Basis]([op(Et_hat), z_aux * Q_hat - 1], tdeg(op(vars)), characteristic=char);\n     for i from 1 to nops(theta_l) do\n       if char>0 then\n       \tcheck := subs(theta_hat, theta_l[i]) mod char:\n       else\n       \tcheck := subs(theta_hat, theta_l[i]):\n       end if:\n       if Groebner[NormalForm](theta_l[i], gb, tdeg(op(vars)), characteristic=char) = check then\n         theta_g := [ op(theta_g), theta_l[i] ]:\n       end if:\n     end do:\n\n    if count_solutions then\n     LogParameters(\"\",output_targets[parameters]):\n    \tfor var in theta_g do\n \t\tLogText(sprintf(\"%s %a, %s %a\\n\",`The number of solutions for`, var, `is`, 1), output_targets[log]):\n\t\tLogParameters(sprintf(\"%s %a, %s %a\\n\",`Parameter`, ParamToOuter(var, all_vars), `number of solutions:`, 1), output_targets[parameters]):\n\t\tsolutions_table[var]:=1:\n    \tend do:\n\t\n    \tfor var in select(p -> not p in theta_g, theta_l) do\n\t\tG := Groebner[Walk](gb, tdeg(op(vars)), lexdeg([op({op(vars)} minus {var})], [var]), characteristic=char):\n\t\tP := select(x->evalb(indets(x)={var}), G):\n\t\tsolutions_table[var]:=degree(P[1], [op(indets(P))]): \n\t\tLogText(sprintf(\"%s %a, %s %a\\n\",`The number of solutions for`, var, `is`, degree(P[1], [op(indets(P))])), output_targets[log]):\n\t\tLogParameters(sprintf(\"%s %a, %s %a\\n\",`Parameter`, ParamToOuter(var, all_vars), `number of solutions:`, degree(P[1], [op(indets(P))])),  output_targets[parameters])\n    \tend do:\n     fi:\n    \tDocumentTools:-SetProperty(output_targets[globalparams], value,  [op(map(x -> ParamToOuter(x, all_vars), theta_g))], 'refresh'): # global\n    \tDocumentTools:-SetProperty(output_targets[localparams], value,  [op(map(x -> ParamToOuter(x, all_vars), select(p -> not p in theta_g, theta_l)))], 'refresh'): # global\n  else\n    LogText(sprintf(`No such method`), output_targets[log]):\n    LogText(sprintf(\"%q\\n\", \"Provided method: %d, allowed methods: 1, 2\", method), output_targets[log]):\n  end if:\n\n  if infolevel > 0 then\n    LogText(sprintf(\"\\n=== Summary ===\\n\"), output_targets[log]):\n    LogText(sprintf(\"%s %a\\n\", `Globally identifiable parameters:                 `, map(x -> ParamToOuter(x, all_vars), theta_g)), output_targets[log]):\n    LogText(sprintf(\"%s %a\\n\", `Locally but not globally identifiable parameters: `, map(x -> ParamToOuter(x, all_vars), select(p -> not p in theta_g, theta_l))), output_targets[log]):\n    LogText(sprintf(\"%s %a\\n\", `Not identifiable parameters:                      `, map(x -> ParamToOuter(x, all_vars), select(p -> not p in theta_l, theta))), output_targets[log]):\n    LogText(sprintf(\"===============\\n\\n\"), output_targets[log]):\n  end if:\n   DocumentTools:-SetProperty(\"LocalLabel\" , caption, \"Locally but not Globally Identifiable Paramters\");\n  out_sian := table([\n    globally = [op(map(x -> ParamToOuter(x, all_vars), theta_g))],\n    locally_not_globally = {op(map(x -> ParamToOuter(x, all_vars), select(p -> not p in theta_g, theta_l)))},\n    non_identifiable = {op(map(x -> ParamToOuter(x, all_vars), select(p -> not p in theta_l, theta)))},\n    parameters = mu,\n    basis=gb,\n    varordering=tdeg(op(vars)),\n    allvars=vars,\n    for_outer=all_vars\n  ]):\n  PrintHeader(\"WARNING: The result of solution counting is guaranteed with high probability, however it NOT the same probability 'p' as provided in the input.\"):\n  out_sian[num_solutions] := solutions_table:\n  return out_sian;\nend proc:\n\n#===============================================================================\nPrintHeader := proc(text):\n#===============================================================================\n  LogText(sprintf(\"\\n=======================================================\\n\"), \"LogAreaSIAN\"):\n  LogText(sprintf(text), \"LogAreaSIAN\"):\n  LogText(sprintf(\"\\n=======================================================\\n\"), \"LogAreaSIAN\"):\nend proc:\n\n#===============================================================================\nGetParameters := proc(system_ODEs, initial_conditions) local initial_values, all_symbols_rhs, mu:\n#===============================================================================\n  initial_values := map(f -> subs({t = 0}, int(f, t)), select( f -> type(int(f, t), function(name)), map(lhs, system_ODEs) )):\n  all_symbols_rhs := foldl(`union`, op( map(e -> indets(rhs(e)), system_ODEs) )) minus {t}:\n  mu := select(s -> not type(s, function), all_symbols_rhs):\n  if initial_conditions then\n    return [op(mu), op(initial_values)]:\n  else\n    return [op(mu)]:\n  end if:\nend proc:\n\n#===============================================================================\nFunctionToVariable := proc(f):\n#===============================================================================\n  convert(cat(convert(f, string)[1..-4], \"_\"), symbol):\nend proc:\n\n#===============================================================================\nParamToInner := proc(p) local s:\n#===============================================================================\n  s := convert(p, string):\n  if length(s) > 3 and s[-3..-1] = \"(0)\" then\n    MakeDerivative(FunctionToVariable(p), 0):\n  else\n    p:\n  end if:\nend proc:\n\n#===============================================================================\nParamToOuter := proc(p, varnames) local s:\n#===============================================================================\n  s := convert(p, string):\n  if length(s) > 2 and s[-2..-1] = \"_0\" and parse(s[1..-2] )in varnames then\n    parse(cat(s[1..-3], \"(0)\")):\n  else\n    p:\n  end if:\nend proc:\n\n#===============================================================================\nMakeDerivative := proc(var_name, der_order):\n#===============================================================================\n  cat(var_name, der_order):\nend proc:\n\n\n#===============================================================================\nDifferentiateOnce := proc(diff_poly, var_list) \n#===============================================================================\n  local result, aux, v, h, diff_v:\n  result := 0:\n  for diff_v in indets(diff_poly) do\n    aux := GetOrderVar(diff_v):\n    # seems that Maple does not have unpacking\n    v := aux[1]:\n    h := aux[2]:\n    if v in var_list then\n      result := result + diff(diff_poly, MakeDerivative(v, h)) * MakeDerivative(v, h + 1):\n    end if:\n  end do:\n  simplify(result):\nend proc:\n\n\n#===============================================================================\nDifferentiate := proc(diff_poly, var_list, ord := 1) \n#===============================================================================\n  local result, i;\n  result := diff_poly:\n  for i from 1 to ord do\n    result := DifferentiateOnce(result, var_list):\n  end do:\n  result:\nend proc:\n\n\n#===============================================================================\nGetVars := proc(diff_poly, var_list)\n#===============================================================================\n  local result;\n  result := select(v -> evalb(GetOrderVar(v)[1] in var_list), indets(diff_poly)):\n  return result:\nend proc:\n\n\n#===============================================================================\nGetOrderVar := proc(diff_var)\n#===============================================================================\n  local s, v, h;\n  if not StringTools[RegMatch](\"^(.*_)([0-9]+)$\", diff_var, s, v, h) then\n    return [\"\", \"\"]:\n  end if:\n  return [parse(v), parse(h)]:\nend proc:\n\n\n#===============================================================================\nSamplePoint := proc(bound, x_vars, y_vars, u_vars, mu, X_eq, Y_eq, Q)\n#===============================================================================\n  local n, m, s, all_params, all_vars, theta_hat, u_variables, \n        u_hat, x_hat, y_hat, eq, eq_num, eq_denom, \n        v, poly, i, j, all_subs, roll, to_compute;\n  n := nops(x_vars):\n  m := nops(y_vars):\n  s := nops(mu) + n:\n  all_params := [op(mu), op(map(x -> MakeDerivative(x, 0), x_vars ))]:\n  all_vars := [ op(x_vars), op(y_vars), op(u_vars) ]:\n\n  roll := rand(0 .. bound):\n  while true do\n    theta_hat := map(p -> p = roll(), all_params): \n    u_variables := [];\n    for i from 1 to nops(u_vars) do\n      u_variables := [ op(u_variables), seq(MakeDerivative(u_vars[i], j), j = 0..s + 1) ]:\n    end do:\n    u_hat := map(p -> p = roll(), u_variables) :   \n  \n    all_subs := [op(theta_hat), op(u_hat)]:\n    if subs(all_subs, Q) = 0 then\n      next\n    end if:\n    to_compute := [op(X_eq), op(Y_eq)]:\n    while nops(to_compute) <> 0 do\n      to_compute := map(e -> lhs(e) = subs(all_subs, rhs(e)), to_compute);\n      all_subs := [ op(all_subs), op(select(e -> type(rhs(e), numeric), to_compute)) ]:\n      to_compute := remove(e -> type(rhs(e), numeric), to_compute):\n    end do:\n    y_hat := map(e -> lhs(e) = subs(all_subs, rhs(e)), Y_eq):\n    x_hat := map(e -> lhs(e) = subs(all_subs, rhs(e)), X_eq):\n    break:\n  end do:\n\n  return [y_hat, u_hat, theta_hat, all_subs];\nend proc:\n\n#===============================================================================\nGenerateReplica := proc(equations, r)\n#===============================================================================\n  # generates a system of equations corresponding to r independent trajectories of\n  # the original system. Time-dependent variabes are replicated, parameters are not\n  local all_functions, zero_order, first_order, funcs, without_t, result, i, subst:\n  all_functions := select(f -> type(f, function), foldl(`union`, op( map(indets, equations) ))):\n  zero_order := select(f -> not type(int(f, t), function(name)), all_functions):\n  first_order := map(f -> int(f, t), select(f -> type(int(f, t), function(name)), all_functions)):\n  funcs := {op(zero_order), op(first_order)}:\n  without_t := map(f -> convert(convert(f, string)[1..-4], symbol), funcs):\n  result := []:\n  for i from 1 to r do\n    subst := map(f -> f = convert(cat(convert(f, string), \"_r\", i), symbol), without_t):\n    result := [op(result), op(map(e -> subs(subst, e), equations))]:\n  end do: \n  return result:\nend proc:\n\n#===============================================================================\nCompareDiffVar := proc(dvl, dvr, var_list)\n#===============================================================================\n  local vl, vr, hl, hr;\n  vl, hl := op(GetOrderVar(dvl, var_list)):\n  vr, hr := op(GetOrderVar(dvr, var_list)):\n  if evalb(hl <> hr) then\n    return evalb(hl > hr):\n  end if:\n  if evalb(length(vl) <> length(vr)) then\n    return evalb(length(vl) > length(vr)):\n  end if:\n  return StringTools[Compare](vr, vl):\nend proc:\n\n\n", "meta": {"hexsha": "2f7a981c928af637f811ad31ce928fc2c475dd33", "size": 24478, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "src/IdentifiabilityODE.mpl", "max_stars_repo_name": "iliailmer/sian-web-app", "max_stars_repo_head_hexsha": "0c5f8afceba45fd23391e7fd670c14b6fd469305", "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/IdentifiabilityODE.mpl", "max_issues_repo_name": "iliailmer/sian-web-app", "max_issues_repo_head_hexsha": "0c5f8afceba45fd23391e7fd670c14b6fd469305", "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/IdentifiabilityODE.mpl", "max_forks_repo_name": "iliailmer/sian-web-app", "max_forks_repo_head_hexsha": "0c5f8afceba45fd23391e7fd670c14b6fd469305", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.6445993031, "max_line_length": 204, "alphanum_fraction": 0.5410572759, "num_tokens": 6615, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7549149758396752, "lm_q2_score": 0.5698526514141572, "lm_q1q2_score": 0.4301903005744933}}
{"text": "`is_element/cacti` := (A::set) -> proc(C)\n global reason;\n local tag,n,i,j,a,b,U;\n\n tag := \"is_element/cacti\";\n\n if not(is_table_on(A)(C)) then\n  reason := [tag,\"C is not a table indexed by A\",C,A];\n  return false;\n fi;\n\n for a in A do\n  if not(`is_element/cactus_lobes`(C[a])) then\n   reason := [tag,\"C[a] is not a cactus lobe\",a,C[a],reason];\n   return false;\n  fi;\n od;\n\n n := nops(A);\n for i from 1 to n do \n  for j from i+1 to n do\n   a := A[i];\n   b := A[j];\n   if `are_crossed/RZ_set`(C[a][2],C[b][2]) then\n    reason := [tag,\"lobes C[a] and C[b] are crossed\",a,b,C[a],C[b]];\n    return false;\n   fi;\n  od;\n od;\n\n U := `empty/RZ_set`;\n for a in A do\n  U := `union/RZ_set`(U,C[a][2]);\n od;\n\n if U <> `top/RZ_set` then\n  reason := [tag,\"The lobes do not fill the whole circle\",C,U];\n  return false;\n fi;\n\n return true;\nend:\n\n`is_equal/cacti` := (A::set) -> proc(C0,C1)\n local a;\n `and`(seq(evalb(C0[a]=C1[a]),a in A));\nend:\n\n`is_leq/cacti` := NULL:\n\n######################################################################\n\n`random_element/cacti` := (A) -> proc()\n local J,s,s1,n,l,m,c,T,i,j,a,C;\n\n if nops(A) = 0 then return FAIL; fi;\n\n J,s := op(`random_element/cactus_planar_trees`(A)());\n\n if nops(A) = 1 then\n  return table([op(A) = `id/cactus_lobes`]);\n fi;\n \n s1 := map(e -> e[1],s);\n n := nops(s1);\n l := [seq(rand(1..6)(),i=1..n)];\n l := l /~ `+`(op(l));\n m := [seq(add(l[i],i=1..j),j=0..n)];\n c := table([seq(a = `random_element/RZ`(),a in A)]);\n T := table([seq(a = [],a in A)]):\n for i from 1 to n do\n  T[s1[i]] := [op(T[s1[i]]),m[i],m[i+1]];\n od:\n C := table():\n for a in A do C[a] := [c[a],T[a]]; od:\n C := `source_shift/cacti`(A)(`random_element/RZ`())(C):\n return eval(C);\nend:\n\n`list_elements/cacti` := NULL:\n`count_elements/cacti` := NULL:\n\n######################################################################\n# Here t should be in R/Z\n\n`source_shift/cacti` := (A::set) -> (t) -> proc(C)\n local D,a;\n\n D := table():\n for a in A do \n  D[a] := `source_shift/cactus_lobes`(t)(C[a]);\n od:\n return eval(D);\nend:\n\n######################################################################\n# Here t should be a table with indices A and entries in R/Z\n\n`target_shift/cacti` := (A::set) -> (t) -> proc(C)\n local D,a;\n\n D := table():\n for a in A do \n  D[a] := `target_shift/cactus_lobes`(t[a])(C[a]);\n od:\n return eval(D);\nend:\n\n######################################################################\n# The standard basepoint for the space of cacti on {1,..,n}\n\n`basepoint/cacti` := proc(n::posint)\n local i,C;\n C := table():\n for i from 1 to n do \n  C[i] := [0,[(i-1)/n,i/n]];\n od:\n return eval(C);\nend:\n\n######################################################################\n# A path in the space of cacti on {1,..,n}, from the basepoint to \n# its image under the transposition (m,m+1).\n\n`omega/cacti` := (n::posint) -> (m::posint) -> proc(t)\n local A,C,i,k;\n if m >= n then error(\"m is out of range\"); fi;\n A := {seq(i,i=1..n)};\n C := table():\n for k from 1 to n do\n  if k = m then\n   C[k] := [0,[m-1+t,m+t] /~ n]\n  elif k = m+1 then\n   if t = 0 then\n    C[k] := [0,[m,m+1] /~ n];\n   elif t = 1 then\n    C[k] := [0,[m-1,m] /~ n];\n   else\n    C[k] := [0,[m-1,m-1+t,m+t,m+1] /~ n];\n   fi;\n  else\n   C[k] := [0,[k-1,k] /~ n];\n  fi;\n od:\n return eval(C);\nend:\n\n######################################################################\n# A family of paths in the space of cacti on {1,2,3}\n\n`alpha/cacti` := proc(i,t)\n local L,C;\n if t < 0 or t > 1 then\n  error(\"t out of range\");\n fi;\n if t = 0 then\n  L := [[1,2] /~ 3,[0,1] /~ 3,[2,3] /~ 3];\n elif t = 1 then\n  L := [[0,1] /~ 3,[1,2] /~ 3,[2,3] /~ 3];\n else\n  L := [[0,t,1+t,2] /~ 3,[t,1+t] /~ 3,[2,3] /~ 3];\n fi;\n L := map(u -> [0,u],L);\n C := table():\n if i = 1 then\n  C[1] := L[1]; C[2] := L[2]; C[3] := L[3]; \n elif i = 2 then\n  C[1] := L[3]; C[2] := L[1]; C[3] := L[2]; \n elif i = 3 then\n  C[1] := L[2]; C[2] := L[3]; C[3] := L[1];\n else\n  error(\"i out of range\");\n fi; \n return eval(C);\nend:\n\n######################################################################\n# A family of paths in the space of cacti on {1,2,3}\n\n`beta/cacti` := proc(z,i,t)\n local C,w;\n\n C := `alpha/cacti`(i,t);\n if i = 1 then \n  w := z;\n elif i = 2 then\n  w := z - (1+t)/3;\n elif i = 3 then\n  w := z + (1+t)/3;\n else\n  error(\"i is out of range\");\n fi;\n\n return `source_shift/cacti`({1,2,3})(w)(C);\nend:\n\n######################################################################\n\n`planar_tree/cacti` := (A::set) -> proc(C)\n local S,SI,D,E,E0,E1,EI,J,t0,t1,t,j,jt,u,v,a,ok,s;\n\n S := table():\n D := table():\n SI := table():\n\n for a in A do\n  S[a] := `starts/RZ_set`(C[a][2]);\n  D[a] := `boundary/RZ_set`(C[a][2]);\n  for t in S[a] do SI[t] := a; od;\n od:\n\n E1 := map(op,{seq(S[a],a in A)});\n E1 := sort([op(E1)]);\n\n J := {};\n E0 := E1;\n EI := table():\n while E0 <> [] do\n  t0 := E0[1];\n  jt := {t0};\n  j := {SI[t0]};\n  for t1 in [op(2..-1,E0)] do\n   u := `interval/RZ_set`(t0,t1);\n   v := `interval/RZ_set`(t1,t0);\n   ok := true;\n   for a in A do\n    if not (`intersect/RZ_set`(u,C[a][2]) = `empty/RZ_set` or \n            `intersect/RZ_set`(v,C[a][2]) = `empty/RZ_set`) then\n     ok := false;\n     break;\n    fi;\n   od;\n   if ok then\n    jt := {op(jt),t1};\n    j := {op(j),SI[t1]};\n   fi;\n  od:\n  J := {op(J),j};\n  E0 := select(t -> not(member(t,jt)),E0);\n  for t in jt do EI[t] := [SI[t],j]; od;\n od:\n\n s := [seq(EI[t],t in E1)];\n return [J,s];\nend:\n\n######################################################################\n\n# This computes the matrix x as in lem-cactus-x\n\n`x/cacti` := (A::set) -> proc(C)\n local x,a,a1;\n\n x := table();\n for a1 in A do\n  for a in A do\n   if a1 <> a then\n    x[a,a1] := `eval/cactus_lobes`(C[a])(C[a1][2][1]);\n   fi;\n  od:\n od:\n\n return eval(x);\nend:\n\n######################################################################\n\n`eta/cacti` := (A::set) ->\n `if`(nops(A) = 1,table([op(A) = `id/cactus_lobes`]),FAIL):\n \n`gamma/cacti` := (A::set,B::set) -> (p) -> proc(D,C)\n local a,E;\n\n E := table():\n for a in A do\n  E[a] := `o/cactus_lobes`(C[p[a]][a],D[p[a]]);\n od:\n return eval(E);\nend:\n\n######################################################################\n\n`phi/ord_simplex_interior/cacti` := (A::set) -> proc(Rx)\n local R,x,n,C,y,i,j;\n R,x := op(Rx);\n n := nops(R);\n C := table():\n y := [seq(add(x[R[i]],i=1..j),j=0..n)];\n for i from 1 to n do\n  C[R[i]] := [0,[y[i],y[i+1]]];\n od:\n return eval(C);\nend:\n\n######################################################################\n\n`phi/cacti/simplex_interior` := (A::set) -> proc(C)\n local x,a;\n x := table();\n for a in A do\n  x[a] := `length/RZ_set`(C[a][2]);\n od:\n return eval(x):\nend: \n\n######################################################################\n\n`plot/cacti` := (A::set) -> proc(C,r := 1,c := [0,0])\n local n,z,i;\n n := nops(A);\n z := table([seq(i = `centroid_R2/RZ_set`(C[A[i]][2]),i=1..n)]);\n display(\n  seq(`plot/RZ_set`(C[A[i]][2],r,c,colour=standard_colour(i)),i=1..n),\n  seq(point(z[i],colour=standard_colour(i)),i=1..n)\n );\nend:", "meta": {"hexsha": "47a1b6ede38320979c248b3c0a265d92760f195c", "size": 6957, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/operads/cacti/cacti.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/operads/cacti/cacti.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/operads/cacti/cacti.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.0158227848, "max_line_length": 70, "alphanum_fraction": 0.4464568061, "num_tokens": 2485, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7025300698514778, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.42951422040427434}}
{"text": "######################################################################\n\n# A standard Stasheff tree for n is a Stasheff tree for the set\n# {1,...,n} with its standard ordering.\n\n`is_element/standard_stasheff_trees` := (n::posint) -> proc(TT)\n local A,T,i;\n global reason;\n\n A := {seq(i,i=1..n)};\n\n if not(`is_element/full_trees`(A)(TT)) then\n  reason := [\"is_element/standard_stasheff_trees\",\"TT is not a full tree\",TT,reason];\n  return false;\n fi;\n\n for T in TT do\n  if nops(T) <> max(T) - min(T) + 1 then\n   reason := [\"is_element/standard_stasheff_trees\",\"T is not an interval\",T];\n   return false;\n  fi;\n od;\n\n return true;\nend;\n\n######################################################################\n\n`is_equal/standard_stasheff_trees` := (n::posint) -> proc(TT,UU)\n local A,i;\n\n A := {seq(i,i=1..n)};\n return `is_equal/trees`(A)(TT,UU);\nend;\n\n######################################################################\n\n`is_leq/standard_stasheff_trees` := (n::posint) -> proc(TT,UU)\n local A,i;\n\n A := {seq(i,i=1..n)};\n return `is_leq/trees`(A)(TT,UU);\nend;\n\n######################################################################\n\n`random_element/standard_stasheff_trees` := (n::posint) -> proc()\n local N,pi,TT,UU,U,i;\n\n if n = 0 then return FAIL; fi;\n if n = 1 then return {{1}}; fi;\n\n N := {seq(i,i=1..n)};\n\n pi := {N};\n while nops(pi) = 1 do \n  pi := `random_element/interval_partitions`(n)();\n od;\n\n TT := N;\n\n for U in pi do \n  UU := `random_element/standard_stasheff_trees`(nops(U))();\n\n  UU := map(V -> map(v -> v+min(U)-1,V),UU);\n  TT := TT,op(UU);\n od;\n\n TT := {TT};\n\n return TT;\nend;\n\n######################################################################\n\n`list_elements/standard_stasheff_trees` := proc(n::posint)\n option remember;\n\n local TTT,UUU,TT,UU,N,IP,pi,pi_list,P,B,b,i;\n if n = 0 then return []; fi;\n if n = 1 then return [{{1}}]; fi;\n\n N := {seq(i,i=1..n)};\n TTT := NULL;\n IP := select(pi -> pi <> {N},`list_elements/interval_partitions`(n));\n\n for pi in IP do\n  pi_list := [op(pi)];\n  P := NULL;\n  for B in pi_list do\n   b := min(op(B));\n   UUU := `list_elements/standard_stasheff_trees`(nops(B));\n   UUU := map(UU -> map(V -> map(v -> b-1+v,V),UU),UUU);\n   P := P,UUU;\n  od;\n  P := `cartesian_product/lists`(P);\n  TTT := TTT,op(map(UU -> {N,op(map(op,UU))},P));\n od:\n return([TTT]);\nend:\n\n######################################################################\n# This is A001003 in OEIS\n\n`count_elements/standard_stasheff_trees` := proc(n)\n local f,L,i;\n if n = 0 then\n  return 0;\n elif n = 1 then \n  return 1;\n else\n  f := (k) -> op([seq(i,i=0..k+1),seq(k-i,i=0..k)]); \n  L := [0];\n  for i from 1 to n-2 do\n   L := map(f,L);\n  od;\n  return nops(L);\n fi;\nend;\n\n# Alternative formula for n > 1:\n# add(2^k*3^(n-2-2*k)*binomial(n-2,2*k)*binomial(2*k,k)/(k+1),k=0..floor((n-2)/2));\n\n`dim/standard_stasheff_trees` := (n) -> proc(TT)\n 2*n - 1 - nops(TT);\nend:\n\n`count_by_dim/standard_stasheff_trees` := proc(n,k)\n if k < 0 or k > n-2 then return 0; fi;\n\n return binomial(n-2,n-k-2) * binomial(2*n-k-2,n) / (n - k - 1);\nend:\n\n\n######################################################################\n\n`draw/standard_stasheff_trees` := (n::posint) -> proc(TT)\n local p,P,T,U,m,i;\n p := table();\n P := NULL;\n for T in TT do \n  p[T] := [`+`(op(T))/nops(T),nops(T)];\n od;\n \n m := parent_map({seq(i,i=1..n)})(TT);\n\n for T in TT do\n  if nops(T) < n then\n   U := m[T];\n   P := P,line(p[T],p[U]);\n  fi;\n od;\n for T in TT do\n  P := P,point(p[T],colour=red,symbol=solidcircle,symbolsize=20);\n od;\n\n P := display(P,axes=none,scaling=constrained);\n return P;\nend:\n\n######################################################################\n\n`root_children/standard_stasheff_tree` := (n::posint) -> proc(TT)\n local C,A,i,XX,X,m;\n\n if n = 1 then return []; fi;\n \n C := NULL;\n A := {seq(i,i=1..n)};\n while A <> {} do\n  i := min(op(A));\n  XX := select(X -> member(i,X) and nops(X) < n,TT);\n  m := max(op(map(nops,XX)));\n  XX := select(X -> nops(X) = m,XX);\n  X := XX[1];\n  C := C,X;\n  A := A minus X;\n od:\n return [C];\nend:\n\n######################################################################\n# A Stasheff tree TT on A is binary if every non-minimal set in TT has\n# precisely two children.  This holds iff |TT| = 2|A|-1.\n\n`is_binary/standard_stasheff_trees` := (n::posint) -> proc(TT)\n return evalb(nops(TT) = 2*n-1);\nend:\n\n######################################################################\n\n`e/loday` := (n::posint) -> proc(pq)\n local p,q;\n p,q := op(pq);\n return [0 $ (p-1), 1 $ (q-p), 0 $ (n-q)];\nend: \n\n######################################################################\n\n`m/loday` := (n::posint) -> pq -> (pq[2]-pq[1]+1)*(pq[2]-pq[1])/2;\n\n######################################################################\n\n`p/loday` := (n::posint) -> proc(pq,u)\n local i;\n return add(u[i],i=pq[1]..pq[2]-1) - `m/loday`(n)(pq);\nend:\n\n######################################################################\n\n`is_element/PK` := (n::posint) -> proc(u)\n global reason;\n local p,q;\n \n if not `is_element/R`(n-1)(u) then\n  reason := [convert(procname,string),\"u is not a list of length n-1\",u,n-1];\n  return false;\n fi;\n \n if `p/loday`(n)([1,n],u) <> 0 then\n  reason := [convert(procname,string),\"p_A(u) <> 0\",u];\n  return false;\n fi;\n\n for p from 1 to n do\n  for q from p to n do\n   if `p/loday`(n)([p,q],u) < 0 then\n    reason := [convert(procname,string),\"p_J(u) < 0\",u,[p,q]];\n    return false;\n   fi;\n  od;\n od;\n\n return true;\nend;\n\n######################################################################\n\n`tau/loday` := (n::posint) -> proc(u)\n local TT,p,q,i;\n TT := NULL;\n for p from 1 to n do\n  for q from p to n do\n   if `p/loday`(n)([p,q],u) = 0 then\n    TT := TT,{seq(i,i=p..q)};\n   fi;\n  od;\n od;\n TT := {TT};\n\n return TT;\nend;\n \n######################################################################\n\n`is_element/Sigma0_loday` := (n::posint) -> proc(sigma)\n global reason;\n local JJ,J,g,i,j,k;\n \n if not type(sigma,table) then\n  reason := [convert(procname,string),\"sigma is not a table\",sigma];\n  return false;\n fi;\n\n JJ := {seq(seq({seq(k,k=i..j)},j=i+1..n),i=1..n)};\n if map(op,{indices(sigma)}) <> JJ then\n  reason := [convert(procname,string),\"sigma is not indexed by the appropriate set of intervals\",sigma,JJ];\n  return false;\n fi;\n\n for J in JJ do\n  g := sigma[J];\n  if not (type(g,set) and nops(g) = 2 and max(op(g)) - min(op(g)) = 1) then\n   reason := [convert(procname,string),\"sigma(J) is not a gap\",sigma,J,g];\n   return false;\n  fi;\n\n  if g minus J <> {} then\n   reason := [convert(procname,string),\"sigma(J) is not a gap in J\",sigma,J,g];\n   return false;\n  fi;\n od;\n\n return true;\nend;\n\n######################################################################\n\n`w0/loday` := (n::posint) -> proc(sigma)\n local v,JJ,J,i,j,k;\n \n v := Vector(n-1);\n JJ := {seq(seq({seq(k,k=i..j)},j=i+1..n),i=1..n)};\n for J in JJ do\n  i := min(op(sigma[J]));\n  v[i] := v[i] + 1;\n end:\n\n return convert(v,list);\nend;\n\n######################################################################\n\n`pi/loday` := (n::posint) -> (TT) -> proc(J)\n local UU,k;\n\n UU := select(T -> J minus T = {},TT);\n k := min(map(nops,UU));\n UU := select(U -> nops(U) = k,UU);\n return(UU[1]);\nend;\n\n######################################################################\n\n`w/loday` := (n::posint) -> proc(TT)\n local v,JJ,J,P,G,T,S,g,m,i,j,k;\n \n v := Vector(n-1);\n JJ := {seq(seq({seq(k,k=i..j)},j=i+1..n),i=1..n)};\n P := table();\n for J in JJ do\n  P[J] := `pi/loday`(n)(TT)(J);\n od;\n G := {seq({i,i+1},i=1..n-1)};\n for J in JJ do \n  T := P[J];\n  S[J] := NULL;\n  for j from min(J) to max(J)-1 do\n   g := {j,j+1};\n   if P[g] = T then\n    S[J] := S[J],g;\n   fi;\n  od;\n  S[J] := {S[J]};\n  m := nops(S[J]);\n  for g in S[J] do\n   v[min(g)] := v[min(g)] + 1/m;\n  od;\n od;\n return convert(v,list);\nend:\n\n######################################################################\n\n`w/loday/bin` := (n::posint) -> proc(TT)\n local C,T,v,i;\n C := children_map({seq(i,i=1..n)})(TT);\n v := Vector(n-1);\n for i from 1 to n-1 do\n  T := `pi/loday`(n)(TT)({i,i+1});\n  v[i] := `*`(op(map(nops,C[T])));\n od;\n return convert(v,list); \nend:\n\n######################################################################\n\n`T/loday` := (n::posint) -> proc(i)\n local j,k;\n {seq({j},j=1..n),{seq(j,j=1..n)},\n  seq({seq(k,k=1..j)},j=2..i),\n  seq({seq(k,k=j..n)},j=i+1..n-1)\n };\nend:\n\n######################################################################\n\n`phi/standard_stasheff_trees/PK` := (n::posint) -> (TT) -> `w/loday`(n)(TT);\n\n######################################################################\n\n`phi/realisation/standard_stasheff_trees/PK` := (n::posint) -> proc(x)\n local C,v,TT;\n \n C := map(op,[indices(x)]);\n v := [0$(n-1)];\n for TT in C do\n  v := v +~ x[TT] *~ `phi/standard_stasheff_trees/PK`(n)(TT);\n od;\n\n return v;\nend:\n", "meta": {"hexsha": "385d5d3af4ea0c79b186800dcc654a01226eeddb", "size": 8766, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/standard_stasheff_trees.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/standard_stasheff_trees.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/standard_stasheff_trees.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.8877284595, "max_line_length": 107, "alphanum_fraction": 0.4593885467, "num_tokens": 2818, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6477982179521103, "lm_q2_score": 0.6619228758499942, "lm_q1q2_score": 0.4287924593973622}}
{"text": "\n# Konvertierung Vektor zu symmetrischer Matrix\n# Einleitung\n# Generiere die Umwandlung von Vektor mit oberem rechten Teil einer Symmetrischen Matrix zur Matrix selbst für die Dimensionen des Roboters.\n# Diese Umwandlung verursacht weniger Rechenoperationen als die Verwendung der numerischen Funktion vec2symmat in Matlab, da dort jedes Mal die Indizes beim Zusammenbauen der Matrix getestet werden müssen.\n# Autor\n# Moritz Schappler, schappler@irt.uni-hannover.de, 2016-12\n# (C) Institut fuer Regelungstechnik, Leibniz Universitaet Hannover\n# Initialization\ninterface(warnlevel=0): # Unterdrücke die folgende Warnung.\nrestart: # Gibt eine Warnung, wenn über Terminal-Maple mit read gestartet wird.\ninterface(warnlevel=3):\nwith(LinearAlgebra):\nwith(ArrayTools):\nwith(codegen):\nwith(CodeGeneration):\nwith(StringTools):\n# Einstellungen für Code-Export: Optimierungsgrad (2=höchster) und Aktivierung jedes Terms.\nread \"../helper/proc_MatlabExport\":\nread \"../helper/proc_vector2symmat\":\nread \"../robot_codegen_definitions/robot_env\":\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", robot_name):\nprintf(\"Generiere Symmat2Vector-Funktionen für %s\\n\", robot_name):\ncodegen_opt := 0: # Soll nicht von Einstellung in robot_env überschrieben werden.\n;\n# Funktion symmat2vector für den Roboter definieren\n# Erstelle eine Dummy-Variable (mv), die als temporäre Variable in Matlab dient (zum Zusammensetzen der Matrix).\nclear('mv'):\nM_NQ:= vec2symmat(mv, NQ):\nM_NQJ:= vec2symmat(mv, NQJ):\nM_6:= vec2symmat(mv, 6):\n# Warnungen bei Code-Generierung unterdrücken. Die Meldung das der Ausdruck mv() in Matlab nicht bekannt ist, spielt keine Rolle, da diese Variable nach dem Einsetzen des Codes vorher definiert sein wird.\ninterface(warnlevel=0):\nMatlabExport(M_NQ, sprintf(\"../codeexport/%s/tmp/vec2symmat_%d_matlab.m\", robot_name, NQ), codegen_opt):\nMatlabExport(M_NQJ, sprintf(\"../codeexport/%s/tmp/vec2symmat_%d_matlab.m\", robot_name, NQJ), codegen_opt):\nMatlabExport(M_6, sprintf(\"../codeexport/%s/tmp/vec2symmat_%d_matlab.m\", robot_name, 6), codegen_opt):\n\n", "meta": {"hexsha": "e9c7e492743a690d7811e8af5b1ad9956dcc51fa", "size": 2060, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "helper/robot_gen_symmat2vector.mpl", "max_stars_repo_name": "SchapplM/robsynth-modelgen", "max_stars_repo_head_hexsha": "33b345ae0dd6ec4aa15499ab3d43edbbded0bea5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-05-25T07:31:46.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-15T09:54:50.000Z", "max_issues_repo_path": "helper/robot_gen_symmat2vector.mpl", "max_issues_repo_name": "SchapplM/robsynth-modelgen", "max_issues_repo_head_hexsha": "33b345ae0dd6ec4aa15499ab3d43edbbded0bea5", "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": "helper/robot_gen_symmat2vector.mpl", "max_forks_repo_name": "SchapplM/robsynth-modelgen", "max_forks_repo_head_hexsha": "33b345ae0dd6ec4aa15499ab3d43edbbded0bea5", "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": 54.2105263158, "max_line_length": 205, "alphanum_fraction": 0.7922330097, "num_tokens": 598, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7606506526772883, "lm_q2_score": 0.5583269943353745, "lm_q1q2_score": 0.4246917926485512}}
{"text": "######################################################################\n# Binary operations on finite sets\n\n`is_element/binops` := (A::set,B::set,C::set) -> proc(p)\n local AB,dom,cod,a,b;\n global reason;\n\n if not(type(p,table)) then\n  reason := [convert(procname,string),\"not table\"];\n  return false;\n fi;\n\n AB := {seq(seq([a,b],b in B),a in A)};\n\n if {indices(p)} <> AB then\n  reason := [convert(procname,string),\"wrong domain\",{indices(p)},AB];\n  return false;\n fi;\n\n cod := map(op,{entries(p)});\n if cod minus C <> {} then\n  reason := [convert(procname,string),\"wrong codomain\",cod,C];\n  return false;\n fi;\n\n return true;\nend;\n\n`is_equal/binops` := (A::set,B::set,C::set) -> proc(p,q)\n local a,b;\n global reason;\n\n for a in A do \n  for b in B do\n   if p[a,b] <> q[a,b] then\n    reason := [convert(procname,string),\"different value\",a,b,p[a,b],q[a,b]];\n    return false;\n   fi;\n  od;\n od;\n\n return true;\nend;\n\n`is_leq/binops` := NULL;\n\n`random_element/binops` := (A::set,B::set,C::set) -> proc()\n local p,n,r,a,b;\n\n p := table();\n if B = {} then\n  if A = {} then\n   return eval(p);\n  else\n   return FAIL;\n  fi;\n fi;\n\n n := nops(C);\n\n r := rand(1..n);\n\n for a in A do\n  for b in B do \n   p[a,b] := C[r()];\n  od;\n od;\n \n return eval(p);\nend;\n\n`list_elements/binops` := proc(A::set,B::set,C::set)\n local nA,nB,nC,J,L,i,j,k,u;\n\n nA := nops(A);\n nB := nops(B);\n nC := nops(C);\n J := [seq(seq([A[i],B[j]],j=1..nB),i=1..nA)];\n L := [[]];\n for i from 1 to nA*nB do\n  L := [seq(seq([op(u),j],j=1..nC),u in L)];\n od:\n\n L := map(u -> table([seq(op(J[k])=C[u[k]],k=1..nA*nB)]),L);\n return L;\nend;\n\n`count_elements/binops` := (A::set,B::set,C::set) -> nops(C) ^ (nops(A)*nops(B));\n\n`is_associative/binops` := (A::set) -> proc(m)\n local a,b,c;\n for a in A do \n  for b in A do\n   for c in A do\n    if m[a,m[b,c]] <> m[m[a,b],c] then\n     return false;\n    fi;\n   od;\n  od;\n od;\n return true;\nend:\n\n`is_commutative/binops` := (A::set) -> proc(m)\n local a,b;\n for a in A do \n  for b in A do\n   if m[a,b] <> m[b,a] then\n    return false;\n   fi;\n  od;\n od;\n return true;\nend:\n\n`is_left_proj/binops` := (A::set) -> proc(m)\n local a,b;\n for a in A do \n  for b in A do\n   if m[a,b] <> a then\n    return false;\n   fi;\n  od;\n od;\n return true;\nend:\n\n`is_right_proj/binops` := (A::set) -> proc(m)\n local a,b;\n for a in A do \n  for b in A do\n   if m[a,b] <> b then\n    return false;\n   fi;\n  od;\n od;\n return true;\nend:\n\n`is_idempotent/binops` := (A::set) -> proc(m)\n local a;\n for a in A do \n  if m[a,a] <> a then\n   return false;\n  fi;\n od;\n return true;\nend:\n\n`is_left_neutral/binops` := (A::set) -> proc(m,e)\n local a;\n\n if not(member(e,A)) then return false; fi;\n for a in A do \n  if m[e,a] <> a then return false; fi;\n od: \n return true;\nend:\n\n`is_right_neutral/binops` := (A::set) -> proc(m,e)\n local a;\n\n if not(member(e,A)) then return false; fi;\n for a in A do \n  if m[a,e] <> a then return false; fi;\n od: \n return true;\nend:\n\n`is_neutral/binops` := (A::set) -> proc(m,e)\n return `is_left_neutral/binops`(A)(m,e) and\n        `is_right_neutral/binops`(A)(m,e);\nend:\n\n`has_left_neutral/binops` := (A::set) -> proc(m)\n local e;\n\n for e in A do\n  if `is_left_neutral/binops`(A)(m,e) then\n   return true;\n  fi;\n od:\n return false;\nend:\n\n`has_right_neutral/binops` := (A::set) -> proc(m)\n local e;\n\n for e in A do\n  if `is_right_neutral/binops`(A)(m,e) then\n   return true;\n  fi;\n od:\n return false;\nend:\n\n`has_neutral/binops` := (A::set) -> proc(m)\n local e;\n\n for e in A do\n  if `is_neutral/binops`(A)(m,e) then\n   return true;\n  fi;\n od:\n return false;\nend:\n\n`is_left_absorbing/binops` := (A::set) -> proc(m,e)\n local a;\n\n if not(member(e,A)) then return false; fi;\n for a in A do \n  if m[e,a] <> e then return false; fi;\n od: \n return true;\nend:\n\n`is_right_absorbing/binops` := (A::set) -> proc(m,e)\n local a;\n\n if not(member(e,A)) then return false; fi;\n for a in A do \n  if m[a,e] <> e then return false; fi;\n od: \n return true;\nend:\n\n`is_absorbing/binops` := (A::set) -> proc(m,e)\n return `is_left_absorbing/binops`(A)(m,e) and\n        `is_right_absorbing/binops`(A)(m,e);\nend:\n\n`has_left_absorbing/binops` := (A::set) -> proc(m)\n local e;\n\n for e in A do\n  if `is_left_absorbing/binops`(A)(m,e) then\n   return true;\n  fi;\n od:\n return false;\nend:\n\n`has_right_absorbing/binops` := (A::set) -> proc(m)\n local e;\n\n for e in A do\n  if `is_right_absorbing/binops`(A)(m,e) then\n   return true;\n  fi;\n od:\n return false;\nend:\n\n`has_absorbing/binops` := (A::set) -> proc(m)\n local e;\n\n for e in A do\n  if `is_absorbing/binops`(A)(m,e) then\n   return true;\n  fi;\n od:\n return false;\nend:\n\n\n\n", "meta": {"hexsha": "9b91d9d76d2dadf5b87dd3bf0c045f4d70dc4e00", "size": 4570, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/binops.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/binops.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/binops.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 17.052238806, "max_line_length": 81, "alphanum_fraction": 0.5748358862, "num_tokens": 1586, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6992544210587585, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.4223020047509993}}
{"text": "rename_cohomology_gens := proc(T0::table,u::list)\n local u0,n0,r,T,i;\n\n u0 := [op(T0[\"cohomology_gens\"])];\n n0 := nops(u0);\n\n if nops(u) <> n0 then\n  error(\"Incorect number of cohomology generators\");\n fi;\n\n r := [seq(u0[i] = u[i],i=1..n0)];\n\n T := copy(T0);\n T[\"cohomology_gens\"] := subs(r,T0[\"cohomology_gens\"]);\n T[\"cohomology_rels\"] := subs(r,T0[\"cohomology_rels\"]);\n T[\"cohomology_degrees\"] := table([]):\n for i from 1 to n0 do \n  T[\"cohomology_degrees\"][u[i]] := \n   T0[\"cohomology_degrees\"][u0[i]];\n od;\n T[\"cohomology_basis\"] := subs(r,T0[\"cohomology_basis\"]);\n for i from 0 to T[\"dimension\"] do \n  T[\"cohomology_graded_basis\"][i] := \n   subs(r,T[\"cohomology_graded_basis\"][i]); \n od:\n\n return eval(T);\nend:\n\n\nmake_product_space := proc(T0,T1)\n local T,d0,d1,B0,B1,B,i0,i1,u0,u1,x,i;\n T := table():\n \n T[\"name\"] := sprintf(\"%s x %s\",T0[\"name\"],T1[\"name\"]);\n d0 := T0[\"dimension\"];\n d1 := T1[\"dimension\"];\n T[\"dimension\"] := d0+d1;\n T[\"cohomology_gens\"] := tdeg(op(T0[\"cohomology_gens\"]),\n                              op(T1[\"cohomology_gens\"]));\n T[\"cohomology_rels\"] := [op(T0[\"cohomology_rels\"]),\n                          op(T1[\"cohomology_rels\"])];\n T[\"cohomology_degrees\"] := table([]);\n for x in T0[\"cohomology_gens\"] do \n  T[\"cohomology_degrees\"][x] := T0[\"cohomology_degrees\"][x];\n od:\n for x in T1[\"cohomology_gens\"] do \n  T[\"cohomology_degrees\"][x] := T1[\"cohomology_degrees\"][x];\n od:\n\n T[\"cohomology_basis\"] := [seq(seq(u0*u1,u0 in T0[\"cohomology_basis\"]),\n                                         u1 in T1[\"cohomology_basis\"])];\n\n B0 := T0[\"cohomology_graded_basis\"]:\n B1 := T1[\"cohomology_graded_basis\"]:\n B := table():\n\n for i from 0 to d0+d1 do\n  B[i] := NULL:\n\n  for i0 from max(0,i-d1) to min(i,d0) do\n   i1 := i - i0; \n   B[i] := B[i],seq(seq(u0*u1,u0 in B0[i0]),u1 in B1[i1]);\n  od:\n od;\n\n T[\"cohomology_graded_basis\"] := eval(B):\n\n return eval(T);\nend:\n\n", "meta": {"hexsha": "169017d7068e559c09c94361a2ea3c556a8f8cd3", "size": 1883, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/spaces/spaces.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/spaces/spaces.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/spaces/spaces.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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.1527777778, "max_line_length": 72, "alphanum_fraction": 0.5884227297, "num_tokens": 668, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5851011686727232, "lm_q2_score": 0.7217432182679956, "lm_q1q2_score": 0.42229280049021656}}
{"text": "(*\n    变量可以划分为：\n    + 自由变量：在满足非零的前提下可以全部取0。\n    + 确定性变量：取值已经确定，或者由其它变量确定。\n    + 有约束变量：其约束来自于解的定义域，由解的性质可知，其值不由其它变量所确定。\n\n    处理时主要处理约束条件，自由变量可以加单取0，确定性变量的值已知。在完全处理约束的前提下，无需验证是否满足约束。\n\n    至于如何处理约束：\n    + 和c有关的约束：为了能够始终满足约束，特解应当和c有关，可以采取变成等式约束进行求解的方式进行处理。(注意对于单独的c的约束，直接删除)\n    + 和c无关的约束：可以简单求解不等式，求解后的结果，都是单边的不等式约束，可以看情况取解。\n\n    对于求解后的结果，可以细分为：\n    + 单变量约束，可以按照简单的方法取定特解。\n    + 多变量约束，可以在取定其它变量的值之后，转化单变量约束进行处理。\n*)\n\n$ifndef _FETCH_\n$define _FETCH_\n\n$include \"Condition.mpl\"\n$include \"Utils.mpl\"\n\n# 根据方程和约束取特解\nfetchSpecSol:=proc(sol::list,con::set,{nonzero::boolean:=false})\n    local vars,vf,eq,ca,cc,res,ccv,sc;\n    vars:=lhs~(sol);\n    vf,eq,ca,cc:=filtCon({sol[],classifySolve(con)[]});\n    if cc<>{} then\n        # 对于和c有关的不等式约束，转化成等式约束后再进行求解\n        cc:=transIeq~(cc);\n        ccv:=indets(cc,name);\n        ccv:=select(type,ccv,specindex(a));\n        sc:=RealDomain:-solve(cc,[ccv[]],explicit);\n        res:=map(rebuildAndFetch,sc,vars,vf,eq,ca,nonzero);\n        res:=sortByComplexity(res);\n        return res[1];\n    else\n        return fetchByCons(vars,vf,eq,ca,nonzero);\n    end if;\nend proc:\n\n# 转化关于c的不等式约束之后，再对约束进行分类\nrebuildAndFetch:=proc(s,vars,_vf,_eq,_ca,nonzero)\n    local vf,eq,ca,cc;\n    vf,eq,ca,cc:=filtCon({s[]} union findSolutionDomain(s));\n    vf:=_vf minus indets(lhs~(eq),name);\n    eq:=eq union _eq;\n    ca:=ca union _ca;\n    return fetchByCons(vars,vf,eq,ca,nonzero);\nend proc:\n\n# 求解关于a的约束之后，转化为单边约束，再逐解取特解\nfetchByCons:=proc(vars,vf,eq,ca,nonzero)\n    local sca,res;\n    sca:=[RealDomain:-solve(ca)];\n    res:=map[4](fetchBySingleCons,vars,vf,eq,sca,nonzero);\n    if nonzero then\n        # 在满足非零要求时，目的是给出所有可能的基\n        # 而求解a的约束产生的每个解是不相交的\n        # 所以需要合并各个解的基\n        return `union`(res[]);\n    else\n        return sortByComplexity(res)[1];\n    end if;\nend proc:\n\n# 对于和a有关的约束，采用逐步替换的方法取特解\nfetchBySingleCons:=proc(vars,_vf,_eq,_ca,nonzero)\n    local vf,eq,ca,sca,res,req,tmp,i,n,ra;\n    vf:=_vf;# 自由变量\n    eq:=_eq;# 不等式方程的解等式约束\n    ca:=_ca;# 求解跟a有关的约束得到的解\n    # 对于单变量约束，采用最邻近整数方式取特解\n    # 逐步替换多变量约束中的变量，最终都取得特解\n    while true do\n        sca,ca:=selectremove(isSingleCon,ca);\n        if sca={} then\n            break;\n        end if;\n        sca:=fetchIeq~(sca);\n        eq:=eq union sca;\n        ca:=subs(sca[],ca);\n    end do;\n    # 由于对不等约束的求解可能存在等式约束，因此最后剩下的是等式约束\n    # BUG  出错的问题在于上面得到的ca可能会有等式约束\n    ca,ra:=selectremove(type,ca,equation);\n    vf:={seq(x=0,x in vf)};\n    eq:=eq union ca union vf;\n    req:=vars;\n    # 带入两次是因为带入一次可能不完全\n    res:=eval(subs(eq[],req));\n    res:=eval(subs(eq[],res));\n    # 假设还有变量存在，就重新求解\n    if indets(res,specindex(a))<>{} then\n        res:=fetchSpecSol([seq(a[i]=res[i],i=1..numelems(vars))],{});\n    end if;\n    if nonzero then\n        if andmap(type,res,0) then\n            n:=numelems(vf);\n            res:={};\n            for i from 1 to n do\n                tmp:=subsop([i,2]=1,vf);\n                res:=res union {eval(subs(tmp[],eq[],req))};\n            end do;\n        else\n            res:={res};\n        end if;\n    end if;\n    return res;\nend proc:\n\n# 是否是单变量约束\nisSingleCon:=proc(x)\n    return not type(x,`=`) and numelems(indets(x,name))=1;\nend proc:\n\n# 筛选：自由变量，确定性约束，和c无关的不等式约束，和c有关的不等式约束\n# 会删除之和c有关的约束\nfiltCon:=proc(con::set)\n    local ef,eq,ca,cc,rst,vf;\n    ef,rst:=selectremove(x->lhs(x)=rhs(x),con);\n    eq,rst:=selectremove(type,rst,`=`);\n    vf:=indets(ef,name) minus lhs~(eq) minus indets(rst,name);\n    cc,ca:=selectremove(has,rst,c);\n    cc:=select(has,cc,a);\n    return vf,eq,ca,cc;\nend proc:\n\n# 将不等式约束转化为等式约束\ntransIeq:=proc(x)\n    if op(0,x)=`<>` or op(0,x)=`<` then\n        return lhs(x)=rhs(x)-1;\n    elif op(0,x)=`>` then\n        return lhs(x)=rhs(x)+1;\n    else\n        return lhs(x)=rhs(x);\n    end if;\nend proc:\n\n# 对于 <> < <= 的约束条件取特解\n# 取满足条件的最邻近整数\nfetchIeq:=proc(x)\n    local r;\n    if type(x,`<>`) then\n        r:=lhs(x)=floor(rhs(x))+1;\n    elif type(lhs(x),numeric) then\n        if type(x,`<`) then\n            r:=rhs(x)=floor(lhs(x))+1;\n        else\n            r:=rhs(x)=ceil(lhs(x));\n        end if;\n    else\n        if type(x,`<`) then\n            r:=lhs(x)=ceil(rhs(x))-1;\n        else\n            r:=lhs(x)=floor(rhs(x));\n        end if;\n    end if;\nend proc:\n\n$endif", "meta": {"hexsha": "e783d03be572fa276134245123d3e7e051898baa", "size": 4165, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "InvClassify/Fetch.mpl", "max_stars_repo_name": "yu961549745/InvariantClassify", "max_stars_repo_head_hexsha": "eeb14ca2b39679e5a2da0f23888681ec7e2edd84", "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": "InvClassify/Fetch.mpl", "max_issues_repo_name": "yu961549745/InvariantClassify", "max_issues_repo_head_hexsha": "eeb14ca2b39679e5a2da0f23888681ec7e2edd84", "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": "InvClassify/Fetch.mpl", "max_forks_repo_name": "yu961549745/InvariantClassify", "max_forks_repo_head_hexsha": "eeb14ca2b39679e5a2da0f23888681ec7e2edd84", "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": 25.7098765432, "max_line_length": 74, "alphanum_fraction": 0.5901560624, "num_tokens": 1883, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998611746912, "lm_q2_score": 0.5428632831725052, "lm_q1q2_score": 0.4219675546468254}}
{"text": "#######################################################################\n# This file is part of the crlibm library, and is distributed under\n# the  LGPL.\n# To use:\n# restart; read \"exp-td.mpl\";\nDigits := 145:\n\ninterface(quiet=true):\n\nread \"common-procedures.mpl\":\nread \"triple-double.mpl\":\nread \"gal.mpl\":\nmkdir(\"TEMPASIN\"):\n\nwith(orthopoly,T):\n\n\ntruncPoly := proc(p,k) \nlocal i, q:\nq := 0:\nconvert(q,polynom):\nfor i from 0 to min(degree(p,x),k) do\n    q := q + coeff(p,x,i) * x^i:\nod:\nreturn (q):\nend:\n\nintervals := 10:\n\nfor i from 1 to intervals do\n\tepsAccurate[i] := 0.5:\n\tepsQuick[i] := 0.5:\n\tpolyAccurate[i] := 1:\n\tpolyQuick[i] := 1:\nod:\nepsAccurateSpecial := 0.5:\nepsQuickExtra := 0.5:\n\nlowestIntervalMax := 0.185:\nhighestIntervalMin := 0.78:\n\npolyAccurateTDCoeffsLowest := 13:\npolyAccurateDDCoeffsLowest := 12:\npolyAccurateDCoeffsLowest := 16:\n\npolyAccurateDegreeLowest := polyAccurateTDCoeffsLowest + polyAccurateDDCoeffsLowest + polyAccurateDCoeffsLowest:\n\npolyQuickDDCoeffsLowest := 12:\npolyQuickDCoeffsLowest := 10:\n\npolyQuickDegreeLowest := polyQuickDDCoeffsLowest + polyQuickDCoeffsLowest:\n\npolyAccurateTDCoeffsMiddle := 7:\npolyAccurateDDCoeffsMiddle := 9:\npolyAccurateDCoeffsMiddle := 19:\n\npolyAccurateDegreeMiddle := polyAccurateTDCoeffsMiddle + polyAccurateDDCoeffsMiddle + polyAccurateDCoeffsMiddle:\n\npolyQuickDDCoeffsMiddle := 7:\npolyQuickDCoeffsMiddle := 7:\n\npolyQuickDegreeMiddle := polyQuickDDCoeffsMiddle + polyQuickDCoeffsMiddle:\n\n\npolyAccurateTDCoeffsHighest := 9:\npolyAccurateDDCoeffsHighest := 9:\npolyAccurateDCoeffsHighest := 11:\n\npolyAccurateDegreeHighest := polyAccurateTDCoeffsHighest + polyAccurateDDCoeffsHighest + polyAccurateDCoeffsHighest:\n\npolyQuickDDCoeffsHighest := 9:\npolyQuickDCoeffsHighest := 9:\n\npolyQuickDegreeHighest := polyQuickDDCoeffsHighest + polyQuickDCoeffsHighest:\n\nextrabound := hexa2ieee([\"3F500000\",\"00000000\"]):\npolyQuickDegreeExtra := 5:\n\nbound[0] := 0:\nb := nearest(lowestIntervalMax):\nhe := ieeehexa(b):\nbound[1] := hexa2ieee([he[1],\"00000000\"]):\nb := nearest(highestIntervalMin):\nhe := ieeehexa(b):\nbound[intervals - 1] := hexa2ieee([he[1],\"00000000\"]):\nbound[intervals] := 1:\nlinearWidth := (highestIntervalMin - lowestIntervalMax) / (intervals - 2):\nscaleSum := 0:\nscale[2] := 1.5:\nscale[3] := 1.35:\nscale[4] := 1.18:\nscale[5] := 1.00:\nscale[6] := 0.915:\nscale[7] := 0.74:\nscale[8] := 0.595:\nscale[9] := 0.50:\nfor i from 2 to (intervals-1) do\n\tscaleSum := scaleSum + scale[i]:\nod:\nfor i from 2 to (intervals-1) do\n\tscale[i] := scale[i] / scaleSum;\nod:\ncurrent := lowestIntervalMax:\nfor i from 2 to (intervals-2) do\n\tb := nearest(current + (highestIntervalMin - lowestIntervalMax) * scale[i]):\n\tcurrent := b:\n\the := ieeehexa(b):\n\tbound[i] := hexa2ieee([he[1],\"00000000\"]):\nod:\nprintf(\"Using %d intervals with bounds:\\n\",intervals):\nfor i from 0 to intervals do\n\tprintf(\"bound[%d] = %1.30e\\n\",i,bound[i]):\nod:\nprintf(\"Using an extra bound for truncating the quick poly to deg. %d in interval #0 for small args up to %f (2^(%f))\\n\",\n\tpolyQuickDegreeExtra,extrabound,log[2](abs(extrabound)));\n\nprintf(\"Computing Gal's accurate table values for interval midpoints\\n\"):\nfor i from 2 to (intervals-1) do\n\tm := nearest((bound[i] + bound[i-1]) / 2):\n\tmhe := ieeehexa(m):\n\tprintf(\"Interval %d: accurate table research start value %f (%s%s)\\n\",i,m,mhe[1],mhe[2]):\n\tmidpointFloat[i] := galDoubleToDoubleDouble(nearest(m),arcsin,2^(-121),2^(15)):\nod:\n\n\nprintf(\"Using the following floating point midpoints for intervals 2-%d:\\n\",intervals-2):\nfor i from 2 to (intervals-1) do\n\tmhe := ieeehexa(midpointFloat[i]):\n\tprintf(\"midpointFloat[%d] = %f (%s%s)\\n\",i,midpointFloat[i],mhe[1],mhe[2]):\nod:\n\nprintf(\"The reduced argument z is therefore bounded by:\\n\"):\nprintf(\"Interval 1: |z| < 2^(%f)\\n\",\n\tlog[2](abs(bound[1]))):\nfor i from 2 to (intervals-1) do\n\tprintf(\"Interval %d: |z| < 2^(%f)\\n\",i,\n\tlog[2](max(abs(midpointFloat[i] - bound[i-1]),abs(midpointFloat[i] - bound[i])))):\nod:\nprintf(\"Interval %d: |z| < 2^(%f)\\n\",intervals,\n\tlog[2](abs(1 - bound[intervals-1]))):\n\n\n\nprintf(\"Using a %d degree polynomial for lowest interval (1) (accurate phase)\\n\",\n\tpolyAccurateDegreeLowest):\nprintf(\"with %d triple-double, %d double-double and %d double coefficients\\n\",\n\tpolyAccurateTDCoeffsLowest, polyAccurateDDCoeffsLowest, polyAccurateDCoeffsLowest):\nprintf(\"Using a %d degree polynomial for lowest interval (1) (quick phase)\\n\",\n\tpolyQuickDegreeLowest):\nprintf(\"with %d double-double and %d double coefficients\\n\",\n\tpolyQuickDDCoeffsLowest, polyQuickDCoeffsLowest):\nprintf(\"Using a %d degree polynomial for middle intervals (2-%d) (accurate phase)\\n\",\n\tpolyAccurateDegreeMiddle,intervals-2):\nprintf(\"with %d triple-double, %d double-double and %d double coefficients\\n\",\n\tpolyAccurateTDCoeffsMiddle, polyAccurateDDCoeffsMiddle, polyAccurateDCoeffsMiddle):\nprintf(\"Using a %d degree polynomial for middle intervals (2-%d) (quick phase)\\n\",\n\tpolyQuickDegreeMiddle,intervals-2):\nprintf(\"with %d double-double and %d double coefficients\\n\",\n\tpolyQuickDDCoeffsMiddle, polyQuickDCoeffsMiddle):\nprintf(\"Using a %d degree polynomial for highest interval (%d) (accurate phase)\\n\",\n\tpolyAccurateDegreeHighest,intervals):\nprintf(\"with %d triple-double, %d double-double and %d double coefficients\\n\",\n\tpolyAccurateTDCoeffsHighest, polyAccurateDDCoeffsHighest, polyAccurateDCoeffsHighest):\nprintf(\"Using a %d degree polynomial for highest interval (%d) (quick phase)\\n\",\n\tpolyQuickDegreeHighest,intervals):\nprintf(\"with %d double-double and %d double coefficients\\n\",\n\tpolyQuickDDCoeffsHighest, polyQuickDCoeffsHighest):\n\nif true then \n\nprintf(\"Computing polynomials for interval 1 ([%f;%f])\\n\",bound[0],bound[1]):\n\nf := unapply(convert(series((arcsin(sqrt(x))/sqrt(x) - 1)/x,x=0,300),polynom),x):\n\np := unapply(eval(numapprox[chebyshev](f(x),x=(bound[0])^2..(bound[1])^2,2^(-127))),x):\n\npolyAccuExact[1] := truncPoly(subs(X=x^2,p(X))*x^3+x,polyAccurateDegreeLowest):\n\npolyAccurate[1] := poly_exact32(polyAccuExact[1],polyAccurateTDCoeffsLowest,polyAccurateDDCoeffsLowest):\n\n\nepsAccurate[1] := numapprox[infnorm]((polyAccurate[1]/arcsin(x))-1, x=bound[0]..bound[1]):\nepsAccurateSpecial := numapprox[infnorm]((polyAccurate[1]/arcsin(x))-1, x=bound[0]..evalf(sin(2^(-18)))):\n\n\npolyQuickExact[1] := truncPoly(polyAccuExact[1],polyQuickDegreeLowest):\npolyQuick[1] := poly_exact2(polyQuickExact[1],polyQuickDDCoeffsLowest):\n\nepsQuick[1] := numapprox[infnorm]((polyQuick[1]/arcsin(x))-1, x=bound[0]..bound[1]):\n\npolyQuickExtraExact := truncPoly(polyAccuExact[1],polyQuickDegreeExtra):\npolyQuickExtra := poly_exact2(polyQuickExtraExact,polyQuickDegreeExtra):\nepsQuickExtra := numapprox[infnorm]((polyQuickExtra/arcsin(x))-1, x=bound[0]..extrabound):\n\nend if:\n\nfor i from 2 to (intervals-1) do\n\nprintf(\"Computing polynomials for interval %d ([%f;%f])\\n\",i,bound[i-1],bound[i]):\nprintf(\"Reduced argument z will be in interval [%1.8e;%1.8e] ([-2^%f,2^%f]),\\n\",\n\tbound[i-1]-midpointFloat[i],bound[i]-midpointFloat[i],\n\tlog[2](abs(bound[i-1]-midpointFloat[i])),log[2](abs(bound[i]-midpointFloat[i]))):\n\nf := unapply(arcsin(x+midpointFloat[i]),x):\n\nfhelp := unapply(convert(series((f(x)-arcsin(midpointFloat[i]))/x,x=0,polyAccurateDegreeMiddle*3),polynom),x):\n\npolyAccuExact[i] := numapprox[minimax](fhelp(x),\n\t\t\t\tx=bound[i-1]-midpointFloat[i]..bound[i]-midpointFloat[i],\n\t\t\t\t[polyAccurateDegreeMiddle,0],1,'err')*x + nearestDD(evalf(arcsin(midpointFloat[i]))):\n\npolyAccurate[i] := poly_exact32(polyAccuExact[i],polyAccurateTDCoeffsMiddle,polyAccurateDDCoeffsMiddle):\n\nepsAccurate[i] := numapprox[infnorm]((polyAccurate[i]/f(x))-1, \n\t\t\t\t\tx=bound[i-1]-midpointFloat[i]..bound[i]-midpointFloat[i]):\n\npolyQuickExact[i] := truncPoly(polyAccuExact[i],polyQuickDegreeMiddle):\npolyQuick[i] := poly_exact2(polyQuickExact[i],polyQuickDDCoeffsMiddle):\n\nepsQuick[i] := numapprox[infnorm]((polyQuick[i]/f(x))-1, \n\t\t\t \t   x=bound[i-1]-midpointFloat[i]..bound[i]-midpointFloat[i]):\n\n\nod:\n\n\nif true then \n\nprintf(\"Computing polynomials for interval %d ([%f;%f])\\n\",intervals,bound[intervals-1],bound[intervals]):\n\n\ng := unapply(((arcsin(1 - x) - Pi/2)/sqrt(2*x)),x):\nf := unapply(convert(series(((g(x)+1)/x),x=0,polyAccurateDegreeHighest*4),polynom),x):\n\n\npolyAccuExact[intervals] := numapprox[minimax](f(x),x=(1-bound[intervals]+2^(-53))..(1-bound[intervals-1]),\n\t\t\t\t\t\t[polyAccurateDegreeHighest-1,0],1,'err')*x-1:\n\npolyAccurate[intervals] := poly_exact32(polyAccuExact[intervals],polyAccurateTDCoeffsHighest,polyAccurateDDCoeffsHighest):\n\n\nepsAccurate[intervals] := numapprox[infnorm](((unapply(polyAccurate[intervals],x)(x)/g(x))-1), \n\t\t\t\t\tx=(1-bound[intervals]+2^(-53))..(1-bound[intervals-1])):\n\n\npolyQuickExact[intervals] := truncPoly(polyAccuExact[intervals],polyQuickDegreeHighest):\npolyQuick[intervals] := poly_exact2(polyQuickExact[intervals],polyQuickDDCoeffsHighest):\n\nepsQuick[intervals] := numapprox[infnorm](((unapply(polyQuick[intervals],x)(x)/g(x))-1), \n\t\t\t\t\tx=(1-bound[intervals]+2^(-53))..(1-bound[intervals-1])):\n\nprintf(\"Checking if the polynomial for interval %d is exactly -1 in z = %f...\\n\",intervals,1-bound[intervals]);\n\nif (unapply(polyAccurate[intervals],x)(1-bound[intervals]) = -1) then\n\tprintf(\"  Check passed!\\n\"):\nelse\n\tprintf(\"  Check failed!\\n\"):\nend if:\n\nend if:\n\n\n\nfor i from 1 to intervals do \n\tprintf(\"Relative error for accurate phase polynomial in interval %d ([%f;%f]) is 2^(%f)\\n\",\n       \t\ti,bound[i-1],bound[i],log[2](abs(epsAccurate[i]))):\n\tprintf(\"Relative error for quick phase polynomial in interval %d ([%f;%f]) is 2^(%f)\\n\",\n       \t\ti,bound[i-1],bound[i],log[2](abs(epsQuick[i]))):\nod:\nprintf(\"Relative error for accurate phase polynomial #1 in special interval [0;sin(2^(-18))]) is 2^(%f)\\n\",\n       log[2](abs(epsAccurateSpecial))):\n\nprintf(\"Relative error for quick phase extra case truncated polynomial #1 in special interval [0;%f]) is 2^(%f)\\n\",\n       extrabound,log[2](abs(epsQuickExtra))):\n\n\n(PiHalfH, PiHalfM, PiHalfL) := hi_mi_lo(evalf(Pi/2)):\n\nepsPiDD := evalf(((PiHalfH + PiHalfM) - Pi/2)/(Pi/2)):\nepsPiTD := evalf(((PiHalfH + PiHalfM + PiHalfL) - Pi/2) / (Pi/2)):\n\nprintf(\"Relative error for storing Pi/2 as a double-double is 2^(%f)\\n\",evalf(log[2](abs(epsPiDD)))):\nprintf(\"Relative error for storing Pi/2 as a triple-double is 2^(%f)\\n\",evalf(log[2](abs(epsPiTD)))):\n\n# Ce qui suit est pifometrique et doit etre prouve en Gappa ensuite\n\narithmeticalErrorQuick[1] := 2^(-61):\narithmeticalErrorQuick[2] := 2^(-61):\narithmeticalErrorQuick[3] := 2^(-61):\narithmeticalErrorQuick[4] := 2^(-61):\narithmeticalErrorQuick[5] := 2^(-61):\narithmeticalErrorQuick[6] := 2^(-61):\narithmeticalErrorQuick[7] := 2^(-61):\narithmeticalErrorQuick[8] := 2^(-61):\narithmeticalErrorQuick[9] := 2^(-61):\narithmeticalErrorQuick[10] := 2^(-68):\n\narithmeticalErrorQuickExtra := 2^(-80):\n\nfor i from 1 to intervals do\n\testimatedOverallEpsQuick[i] := abs(epsQuick[i]) + \n\t\t\t\t       abs(arithmeticalErrorQuick[i]) + \n                                       abs(epsQuick[i]) * abs(arithmeticalErrorQuick[i]):\n\tprintf(\"Relative quick phase overall error bound to show in Gappa for interval %d ([%f;%f]) is 2^(%f)\\n\",\n\t\ti,bound[i-1],bound[i],log[2](abs(estimatedOverallEpsQuick[i]))):\nod:\n\nestimatedOverallEpsQuickExtra := abs(epsQuickExtra) + \n\t\t\t\t abs(arithmeticalErrorQuickExtra) + \n                                 abs(epsQuickExtra) * abs(arithmeticalErrorQuickExtra):\nprintf(\"Relative quick phase overall error bound to show for extra truncted poly in interval [0;%f]) is 2^(%f)\\n\",\n\textrabound,log[2](abs(estimatedOverallEpsQuickExtra))):\n\n\nprintf(\"Write tables...\\n\"):\n\nfilename:=\"TEMPASIN/asin-td.h\":\nfd:=fopen(filename, WRITE, TEXT):\n\nfprintf(fd, \"#include \\\"crlibm.h\\\"\\n#include \\\"crlibm_private.h\\\"\\n\"):\n\nfprintf(fd, \"\\n/* File generated by maple/asin-td.mpl */\\n\\n\"):\n\nprintf(\"Write table with bounds\\n\"):\n\nfprintf(fd, \"/* High order words of interval bounds (low order word is 0) */\\n\"):\nfor i from 1 to (intervals-1) do \n\theb := ieeehexa(bound[i]):\n\tfprintf(fd, \"\\#define BOUND%d 0x%s\\n\",i,heb[1]):\nod:\n\nheb := ieeehexa(extrabound):\nfprintf(fd, \"\\#define EXTRABOUND 0x%s\\n\",heb[1]):\n\nprintf(\"Write additional constants\\n\"):\n\nfprintf(fd, \"\\n\\n/* Pi/2 as a triple-double*/\\n\"):\nfprintf(fd, \"\\#define PIHALFH %1.50e\\n\",PiHalfH):\nfprintf(fd, \"\\#define PIHALFM %1.50e\\n\",PiHalfM):\nfprintf(fd, \"\\#define PIHALFL %1.50e\\n\",PiHalfL):\n\nprintf(\"Write table with midpoints and polynomial coefficients\\n\"):\nk := 0:\nfor i from 0 to polyAccurateDegreeLowest do\n\t(hi,mi,lo) := hi_mi_lo(coeff(polyAccurate[1],x,i)):\n\tif ((abs(hi) = 1.0) and (mi = 0) and (lo = 0)) then \n\t\tprintf(\n\t\t\"Coefficient %d of interval 1 polynomial is exactly %f and will not be stored in the table\\n\",i,hi): \n\telse \n\tg := 0;\n\tif (hi <> 0) then\n\t\tif (i <= polyQuickDegreeLowest) then\n\t\t\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, accPolyLowC%dh, quickPolyLowC%dh */\",hi,k,i,i):\n\t\telse\n\t\t\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, accPolyLowC%dh */\",hi,k,i):\n\t\tend if:\n\t\tk := k + 1:\n\tend if:\n\tif (mi <> 0) then\n\t\tif (i <= polyQuickDDCoeffsLowest) then\n\t\t\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, accPolyLowC%dm, quickPolyLowC%dl */\",mi,k,i,i):\n\t\telse\n\t\t\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, accPolyLowC%dm */\",mi,k,i):\n\t\tend if:\n\t\tk := k + 1:\n\tend if:\n\tif (lo <> 0) then\n\t\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, accPolyLowC%dl */\",lo,k,i):\n\t\tk := k + 1:\n\tend if:\n\tend if:\nod:\ntbl[k] := sprintf(\"%1.50e, \\t/* %d, RN rounding constant quick poly low*/\",\n\t\tcompute_rn_constant(estimatedOverallEpsQuick[1]),k):\nk := k + 1:\ntbl[k] := sprintf(\"%1.50e, \\t/* %d, RD rounding constant quick poly low*/\",\n\t\testimatedOverallEpsQuick[1],k):\nk := k + 1:\nprintf(\"Table for interval 1 written\\n\"):\nfor l from 2 to (intervals-1) do\n\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, midpoint in interval %d*/\",midpointFloat[l],k,l):\n\ttblidx[l] := k;\n\tk := k + 1;\n\tfor i from 0 to polyAccurateDegreeMiddle do\n\t\t(hi,mi,lo) := hi_mi_lo(coeff(polyAccurate[l],x,i)):\n\t\tif ((abs(hi) = 1.0) and (mi = 0) and (lo = 0)) then \n\t\t\tprintf(\n\t\t\"Coefficient %d of interval %d polynomial is exactly %f and will not be stored in the table\\n\",i,l,hi): \n\t\telse \n\t\tg := 0;\n\t\tif (hi <> 0) then\n\t\t\tif (i <= polyQuickDegreeMiddle) then\n\t\t\t\ttbl[k] := sprintf(\n\t\t\t\t\t\"%1.50e, \\t/* %d, accPolyMid%dC%dh, quickPolyMid%dC%dh */\",hi,k,l,i,l,i):\n\t\t\telse\n\t\t\t\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, accPolyMid%dC%dh */\",hi,k,l,i):\n\t\t\tend if:\n\t\t\tk := k + 1:\n\t\tend if:\n\t\tif (mi <> 0) then\n\t\t\tif (i <= polyQuickDDCoeffsMiddle) then\n\t\t\t\ttbl[k] := sprintf(\n\t\t\t\t\t\"%1.50e, \\t/* %d, accPolyMid%dC%dm, quickPolyMid%dC%dl */\",mi,k,l,i,l,i):\n\t\t\telse\n\t\t\t\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, accPolyMid%dC%dm */\",mi,k,l,i):\n\t\t\tend if:\n\t\t\tk := k + 1:\n\t\tend if:\n\t\tif (lo <> 0) then\n\t\t\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, accPolyMid%dC%dl */\",lo,k,l,i):\n\t\t\tk := k + 1:\n\t\tend if:\n\t\tend if:\n\tod:\n\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, RN rounding constant quick poly middle %d*/\",\n\t\t\tcompute_rn_constant(estimatedOverallEpsQuick[l]),k,l):\n\tk := k + 1:\n\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, RD rounding constant quick poly middle %d*/\",\n\t\t\testimatedOverallEpsQuick[l],k,l):\n\tk := k + 1:\n\tprintf(\"Table for interval %d written\\n\",l):\nod:\ntblidx[intervals] := k:\nfor i from 0 to polyAccurateDegreeHighest do\n\t(hi,mi,lo) := hi_mi_lo(coeff(polyAccurate[intervals],x,i)):\n\tif ((abs(hi) = 1.0) and (mi = 0) and (lo = 0)) then \n\t\tprintf(\n\t\"Coefficient %d of interval %d polynomial is exactly %f and will not be stored in the table\\n\",i,intervals,hi): \n\telse \n\tg := 0;\t\n\tif (hi <> 0) then\n\t\tif (i <= polyQuickDegreeHighest) then\n\t\t\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, accPolyHighC%dh, quickPolyHighC%dh */\",hi,k,i,i):\n\t\telse\n\t\t\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, accPolyHighC%dh */\",hi,k,i):\n\t\tend if:\n\t\tk := k + 1:\n\tend if:\n\tif (mi <> 0) then\n\t\tif (i <= polyQuickDDCoeffsHighest) then\n\t\t\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, accPolyHighC%dm, quickPolyHighC%dl */\",mi,k,i,i):\n\t\telse\n\t\t\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, accPolyHighC%dm */\",mi,k,i):\n\t\tend if:\n\t\tk := k + 1:\n\tend if:\n\tif (lo <> 0) then\n\t\ttbl[k] := sprintf(\"%1.50e, \\t/* %d, accPolyHighC%dl */\",lo,k,i):\n\t\tk := k + 1:\n\tend if:\n\tend if:\nod:\ntbl[k] := sprintf(\"%1.50e, \\t/* %d, RN rounding constant quick poly high*/\",\n\t\tcompute_rn_constant(estimatedOverallEpsQuick[intervals]),k):\nk := k + 1:\ntbl[k] := sprintf(\"%1.50e, \\t/* %d, RD rounding constant quick poly high*/\",\n \t\testimatedOverallEpsQuick[intervals],k):\nk := k + 1:\nprintf(\"Table for interval %d written\\n\",intervals):\ntbllen := k:\nprintf(\"The whole table has %d entries, so uses %d bytes of memory\\n\",tbllen,tbllen*8):\nfprintf(fd,\"\\n\\n/* Indices to the following table */\\n\"):\nfor i from 2 to intervals do\n\tfprintf(fd,\"\\#define TBLIDX%d %d\\n\",i,tblidx[i]):\nod:\nfprintf(fd, \"\\n\\n/* Table with midpoints and polynomial coefficients */\\n\"):\nfprintf(fd, \"static const double tbl[%d] = {\\n\",tbllen):\nfor i from 0 to (tbllen - 1) do\n\tfprintf(fd, \"%s\\n\",tbl[i]):\nod:\nfprintf(fd, \"};\\n\\n\"):\n\nfclose(fd):\n\nprintf(\"----DONE---\\n\"):\n\n\n", "meta": {"hexsha": "3306a112e47e4dce50b2a7ef176b045c9afa95bf", "size": 16836, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "crlibm/maple/asin-td.mpl", "max_stars_repo_name": "squarePenguin/parvsl", "max_stars_repo_head_hexsha": "0d502abe795540a3dfc99d43726d3fc29a5e6e5d", "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": "crlibm/maple/asin-td.mpl", "max_issues_repo_name": "squarePenguin/parvsl", "max_issues_repo_head_hexsha": "0d502abe795540a3dfc99d43726d3fc29a5e6e5d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-03-25T17:02:38.000Z", "max_issues_repo_issues_event_max_datetime": "2019-03-25T17:02:38.000Z", "max_forks_repo_path": "crlibm/maple/asin-td.mpl", "max_forks_repo_name": "squarePenguin/parvsl", "max_forks_repo_head_hexsha": "0d502abe795540a3dfc99d43726d3fc29a5e6e5d", "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.2217573222, "max_line_length": 122, "alphanum_fraction": 0.6761701117, "num_tokens": 5787, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7248702761768248, "lm_q2_score": 0.5813030906443134, "lm_q1q2_score": 0.42136933185778525}}
{"text": "\n# Vierachsroboter implizit\n# Initialisierung\nrestart:\nkin_constraints_exist := true: # Für Speicherung\n;\nwith(StringTools): # Für Zeitausgabe\nwith(LinearAlgebra):\nwith(codegen):\nwith(CodeGeneration):\ncodegen_act := true:\ncodegen_opt := 1: # Geringerer Optimierungsgrad. Sonst zu lange.\ncodegen_debug := 0: # Zur Code-Generierung auch für Nicht-Inert-Ausdrücke\n;\nread \"../helper/proc_MatlabExport\":\nread \"../transformation/proc_rotx\":\nread \"../transformation/proc_roty\":\nread \"../transformation/proc_rotz\":\nread \"../transformation/proc_trotz\":\nread \"../transformation/proc_transl\":\nread \"../helper/proc_convert_s_t\":\nread \"../helper/proc_convert_t_s\":\nread \"../robot_codegen_constraints/proc_subs_kintmp_exp\":\nread \"../helper/proc_intersect_circle\":\nwith(RealDomain): # Schränkt alle Funktionen auf den reellen Bereich ein. Muss nach Definition von MatlabExport kommen. Sonst geht dieses nicht.\n;\nread \"../robot_codegen_definitions/robot_env_IC\":\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", robot_name_OL):\n# Ergebnisse der Kinematik laden\nread sprintf(\"../codeexport/%s/tmp/kinematics_floatb_%s_rotmat_maple.m\", robot_name_OL, base_method_name);\nread \"../robot_codegen_definitions/robot_env_IC\":\nTrf := Trf:\nTrf_c := Trf_c:\nTrf\n;\n# VGK Gelb 2-7-11-14-6\n# Schleife (1-6)-(6-14)\nT_1_14 := combine( Matrix(Trf(1..4,1..4, 6)) . Matrix(Trf(1..4,1..4,14))):\n# Schleife (1-2)-(2-7)-(7-11)\nT_1_11:= combine( Matrix(Trf(1..4,1..4, 2)) . Matrix(Trf(1..4,1..4,7)) . Matrix(Trf(1..4,1..4,11))):\nh1t := T_1_14(1..3,4) - T_1_11(1..3,4);\n\n#tmp := Transpose( Matrix(T_1_14(1..3,1..3)) ) . Matrix(T_1_11(1..3,1..3));  nur anzeigen lassen für h1r\n;\n#combine(tmp);# nur anzeigen lassen für h1r\n;\nh1r := -(-qJ6(t)+qJ2(t)+qJ7(t)+phi711+qJ11(t))+Pi/2:\n# VGK PINK 2-3-12-15-9-8-2\n# Schleife (2-3)-(3-12)\nT_2_12 := combine(Matrix(Trf(1..4,1..4, 3)) . Matrix(Trf(1..4,1..4,12))):\n# Schleife (2-8)-(8-9)-(9-15)\nT_2_15:= combine(Matrix(Trf(1..4,1..4, 8)) . Matrix(Trf(1..4,1..4,9)).Matrix(Trf(1..4,1..4, 15))):\nh2t := T_2_12(1..3,4) - T_2_15(1..3,4):\ntmp := Transpose( Matrix(T_2_12(1..3,1..3)) ) . Matrix(T_2_15(1..3,1..3));  # nur anzeigen lassen für h1r\n;\n combine(tmp); # nur anzeigen lassen für h1r\n;\nh2r:=(qJ3(t)+phi312+qJ12(t)-qJ8(t)-qJ9(t))+3*Pi/2:\n# VGK GRÜN 2-3-4-13-16-10-7-2\n# Schleife (2-3)-(3-4)-(4-13)\nT_2_13 := combine( Matrix(Trf(1..4,1..4, 3)) . Matrix(Trf(1..4,1..4,4)) . Matrix(Trf(1..4,1..4,13))):\n# Schleife (2-7)-(7-10)-(10-16)\nT_2_16:= combine( Matrix(Trf(1..4,1..4, 7)) . Matrix(Trf(1..4,1..4,10)).Matrix(Trf(1..4,1..4,16)) ):\nh3t := T_2_13(1..3,4) - T_2_16(1..3,4):\n#tmp := Transpose( Matrix(T_2_13(1..3,1..3)) ) . Matrix(T_2_16(1..3,1..3));  nur anzeigen lassen für h2r\n;\n#combine(tmp);  nur anzeigen lassen für h3r\n;\nh3r:=-(qJ3(t)+qJ4(t)+phi413+qJ13(t)-qJ7(t)+phi710-qJ10(t))+5*Pi/2:\n# Zusammenstellen aller Zwangsbedingungen\nimplconstr_t := <h1t([1, 3],1);h2t([1, 2],1);h3t([1, 2],1); h1r; h2r; h3r>; # TODO: In h1r, h2r, h3r muss das richtige drinstehen.\nimplconstr_s := convert_t_s(implconstr_t):\n# Exportiere Code für folgende Skripte\nkin_constraints_exist:=true:\nsave implconstr_t, implconstr_s, kin_constraints_exist, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_implicit_maple.m\", robot_name):\n# Exportieren des vollständigen Ausdruckes\nif codegen_act then\n  MatlabExport(implconstr_s, sprintf(\"../codeexport/%s/tmp/kinconstr_impl_matlab.m\", robot_name), 2):\nend if:\n# Liste mit abhängigen konstanten Kinematikparametern erstellen (wichtig für Matlab-Funktionsgenerierung)\nread \"../helper/proc_list_constant_expressions\";\nkc_symbols := Matrix(list_constant_expressions( implconstr_s )):\nsave kc_symbols, sprintf(\"../codeexport/%s/tmp/kinematic_implicit_constraints_symbols_list_maple\", robot_name):\nMatlabExport(Transpose(kc_symbols), sprintf(\"../codeexport/%s/tmp/kinematic_implicit_constraints_symbols_list_matlab.m\", robot_name), 2):\n\n", "meta": {"hexsha": "abb5bd81baba31055ca5fb3e689a61f716fef95c", "size": 3871, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "systems/palh1m2/codegen/palh1m2IC_kinematic_constraints_implicit.mpl", "max_stars_repo_name": "SchapplM/robsynth-serhybroblib", "max_stars_repo_head_hexsha": "8e4d39cf919a85a5d3d54391b699ae51ada191a1", "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": "systems/palh1m2/codegen/palh1m2IC_kinematic_constraints_implicit.mpl", "max_issues_repo_name": "SchapplM/robsynth-serhybroblib", "max_issues_repo_head_hexsha": "8e4d39cf919a85a5d3d54391b699ae51ada191a1", "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": "systems/palh1m2/codegen/palh1m2IC_kinematic_constraints_implicit.mpl", "max_forks_repo_name": "SchapplM/robsynth-serhybroblib", "max_forks_repo_head_hexsha": "8e4d39cf919a85a5d3d54391b699ae51ada191a1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.011627907, "max_line_length": 144, "alphanum_fraction": 0.70679411, "num_tokens": 1480, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.8459424295406088, "lm_q2_score": 0.4960938294709195, "lm_q1q2_score": 0.41966681938273415}}
{"text": "make_example_surfaces := proc()\n global example_surface;\n local P,T,R,dp,a,u,i,j,k;\n \n dp := (u,v) -> add(u[i] * v[i],i=1..3):\n R := (x) -> [-x[1]/2+sqrt(3)*x[2]/2,-sqrt(3)*x[1]/2-x[2]/2,x[3]]:\n\n P := table():\n P[0] := `map/pants`(x -> x,`base/pants`):\n for i from 1 to 5 do P[i] := `sprout/pants`(P[i-1],modp(i-1,3)+1); od:\n T := table():\n T[0] := `pants_joiner/pants_tube`(P[0],2,P[1],3):\n T[1] := `pants_joiner/pants_tube`(P[2],1,P[3],2):\n T[2] := `pants_joiner/pants_tube`(P[4],3,P[5],1):\n example_surface[0] := display(\n  seq(`rough_plot/pants`(op(X)),X in entries(P)),\n  seq(`plot/pants_tube`(op(X)),X in entries(T))\n ):\n\n P := table():\n T := table():\n P[0] := eval(`base/pants`):\n P[1] := `sprout/pants`(P[0],1):\n T[0] := `pants_joiner/pants_tube`(P[0],2,P[1],3):\n T[1] := `pants_joiner/pants_tube`(P[0],3,P[1],2):\n example_surface[1] := display(\n  seq(`rough_plot/pants`(op(X)),X in entries(P)),\n  seq(`plot/pants_tube`(op(X)),X in entries(T))\n ):\n\n P := table(): T := table():\n P[0] := eval(`base/pants`):\n P[1] := `sprout/pants`(P[0],1):\n P[2] := `map/pants`((x) -> x +~ [0,3,0],P[0]):\n P[3] := `map/pants`((x) -> x +~ [0,3,0],P[1]):\n T[0] := `pants_joiner/pants_tube`(P[0],2,P[2],3):\n T[1] := `pants_joiner/pants_tube`(P[1],3,P[3],2):\n T[3] := `pants_joiner/pants_tube`(P[0],3,P[1],2):\n T[4] := `pants_joiner/pants_tube`(P[2],2,P[3],3):\n example_surface[2] := display(\n  seq(`rough_plot/pants`(op(X)),X in entries(P)),\n  seq(`plot/pants_tube`(op(X)),X in entries(T))\n ):\n\n P := table(): T := table():\n P[0] := eval(`base/pants`):\n P[1] := `sprout/pants`(P[0],1):\n T[0] := `pants_joiner/pants_tube`(P[0],2,P[0],3):\n T[1] := `pants_joiner/pants_tube`(P[1],2,P[1],3):\n example_surface[3] := display(\n  seq(`rough_plot/pants`(op(X)),X in entries(P)),\n  seq(`plot/pants_tube`(op(X)),X in entries(T))\n ):\n\n a := 2:\n u := table():\n P := table():\n T := table():\n u[0] := simplex_embedding([1,0,0,0]):\n u[1] := simplex_embedding([0,1,0,0]):\n u[2] := simplex_embedding([0,0,1,0]):\n u[3] := simplex_embedding([0,0,0,1]):\n for i from 0 to 3 do \n  P[i] := table([\n   \"centre\" = a *~ u[i],\n   \"circle_centres\" = [seq(simplify(a *~ u[i] +~ (u[j] -~ dp(u[j],u[i]) *~ u[i]) *~ (sqrt(27/32))),j in {0,1,2,3} minus {i})],\n   \"top\" = (a + 1/2) *~ u[i]\n  ]);\n od:\n T[0,1] := `pants_joiner/pants_tube`(P[0],1,P[1],1):\n T[0,2] := `pants_joiner/pants_tube`(P[0],2,P[2],1):\n T[0,3] := `pants_joiner/pants_tube`(P[0],3,P[3],1):\n T[1,2] := `pants_joiner/pants_tube`(P[1],2,P[2],2):\n T[1,3] := `pants_joiner/pants_tube`(P[1],3,P[3],2):\n T[2,3] := `pants_joiner/pants_tube`(P[2],3,P[3],3):\n example_surface[4] := display(\n  seq(`rough_plot/pants`(op(X)),X in entries(P)),\n  seq(`plot/pants_tube`(op(X)),X in entries(T)),\n  axes=none,scaling=constrained\n ):\n\n P := table():\n T := table():\n a := 2:\n for i in [-1,1] do \n  for j in [-1,1] do\n   for k in [-1,1] do \n    P[i,j,k] := table([\n     \"centre\" = a *~ [i,j,k],\n     \"circle_centres\" = evalf(map(x -> (a *~ [i,j,k] +~ x /~ sqrt(8)), \n\t\t\t    [[-2*i,j,k],[i,-2*j,k],[i,j,-2*k]])),\n     \"top\" = evalf((a + 1/(2*sqrt(3))) *~ [i,j,k])\n    ]);\n   od:\n  od:\n od:\n T[ 0, 1, 1] := `pants_joiner/pants_tube`(P[ 1, 1, 1],1,P[-1, 1, 1],1):\n T[ 0, 1,-1] := `pants_joiner/pants_tube`(P[ 1, 1,-1],1,P[-1, 1,-1],1):\n T[ 0,-1, 1] := `pants_joiner/pants_tube`(P[ 1,-1, 1],1,P[-1,-1, 1],1):\n T[ 0,-1,-1] := `pants_joiner/pants_tube`(P[ 1,-1,-1],1,P[-1,-1,-1],1):\n T[ 1, 0, 1] := `pants_joiner/pants_tube`(P[ 1, 1, 1],2,P[ 1,-1, 1],2):\n T[ 1, 0,-1] := `pants_joiner/pants_tube`(P[ 1, 1,-1],2,P[ 1,-1,-1],2):\n T[-1, 0, 1] := `pants_joiner/pants_tube`(P[-1, 1, 1],2,P[-1,-1, 1],2):\n T[-1, 0,-1] := `pants_joiner/pants_tube`(P[-1, 1,-1],2,P[-1,-1,-1],2):\n T[ 1, 1, 0] := `pants_joiner/pants_tube`(P[ 1, 1, 1],3,P[ 1, 1,-1],3):\n T[ 1,-1, 0] := `pants_joiner/pants_tube`(P[ 1,-1, 1],3,P[ 1,-1,-1],3):\n T[-1, 1, 0] := `pants_joiner/pants_tube`(P[-1, 1, 1],3,P[-1, 1,-1],3):\n T[-1,-1, 0] := `pants_joiner/pants_tube`(P[-1,-1, 1],3,P[-1,-1,-1],3):\n example_surface[5] := display(\n  seq(`rough_plot/pants`(op(X)),X in entries(P)),\n  seq(`plot/pants_tube`(op(X)),X in entries(T)),\n  axes=none,scaling=constrained\n ):\n\n return eval(example_surface);\nend:\n", "meta": {"hexsha": "0be70e70c9bb4663c590a6bce1945db3cf235a09", "size": 4160, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/simplicial_complexes/example_surfaces.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/simplicial_complexes/example_surfaces.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/simplicial_complexes/example_surfaces.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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.5555555556, "max_line_length": 126, "alphanum_fraction": 0.5348557692, "num_tokens": 1886, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7057850154599562, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.4156291242631745}}
{"text": "make_alternating_five := proc()\n global alternating_five;\n local G,x2,y2,z2,x3,x5,y5,id,o,oo,inv,idm,om,oom,E,ccl,\n       t0,t1,i,j,k,l,g,h,w,m,x,u0,u1,u2,u3,u,v,M,theta;\n \n G := table():\n\n x2 := [2,1,4,3,5];\n y2 := [3,4,1,2,5];\n z2 := [1,3,2,5,4];\n x3 := [2,3,1,4,5];\n x5 := [3,5,4,2,1];\n y5 := [2,3,4,5,1];\n\n id := [1,2,3,4,5];\n o  := (u,v) -> [seq(u[v[i]],i=1..5)];\n oo := proc()\n  if   nargs = 0 then return(id);\n  elif nargs = 1 then return(args[1]);\n  elif nargs = 2 then return(o(args));\n  else return o(args[1],oo(args[2..-1]));\n  fi;\n end:\n inv := proc(g)\n  local gi;\n  gi := table():\n  for i from 1 to 5 do gi[g[i]] := i; od;\n  return [seq(gi[i],i=1..5)];\n end:\n \n G[\"id\"] := id;\n G[\"o\"]  := eval(o);\n G[\"oo\"]  := eval(oo);\n G[\"inv\"] := eval(inv);\n \n G[\"x2\"] := x2;  G[\"x2c\"] := convert(x2,disjcyc);\n G[\"y2\"] := y2;  G[\"y2c\"] := convert(y2,disjcyc);\n G[\"z2\"] := z2;  G[\"z2c\"] := convert(z2,disjcyc);\n G[\"x3\"] := x3;  G[\"x3c\"] := convert(x3,disjcyc);\n G[\"x5\"] := x5;  G[\"x5c\"] := convert(x5,disjcyc);\n G[\"y5\"] := y5;  G[\"y5c\"] := convert(y5,disjcyc);\n\n G[\"H\"] := table():\n \n G[\"H\"][ 1] := [id];\n G[\"H\"][ 2] := [id,x2];\n G[\"H\"][ 3] := [id,x3,o(x3,x3)];\n G[\"H\"][ 4] := [id,x2,y2,o(x2,y2)];\n G[\"H\"][ 5] := [id,x5,o(x5,x5),oo(x5 $ 3),oo(x5 $ 4)];\n G[\"H\"][ 6] := [seq(seq(o(u,v),u in [id,z2]),v in G[\"H\"][3])];\n G[\"H\"][10] := [seq(seq(o(u,v),u in G[\"H\"][ 2]),v in G[\"H\"][5])];\n G[\"H\"][12] := [seq(seq(o(u,v),u in G[\"H\"][ 4]),v in G[\"H\"][3])];\n G[\"H\"][60] := [seq(seq(o(u,v),u in G[\"H\"][12]),v in G[\"H\"][5])];\n\n E := G[\"H\"][60];\n G[\"elements\"] := E;\n \n G[\"element_index\"] := table();\n for i from 1 to 60 do\n  G[\"element_index\"][E[i]] := i; \n od:\n\n G[\"gens_rule\"] := {X2 = x2, Y2 = y2, Z2 = z2, X3 = x3, X5 = x5, Y5 = y5};\n\n # words in x2, y2, z2 for all elements\n G[\"words_a\"] := [\n [],[X2],[Y2],[X2,Y2],[X2,Z2,Y2,Z2,X2,Z2],[Z2,Y2,Z2,X2,Z2],[Z2,Y2,Z2,X2,Z2,X2],\n [Y2,Z2,Y2,Z2,X2,Z2],[Y2,Z2,X2,Z2,Y2,Z2],[Z2,X2,Z2,Y2,Z2,Y2],[Z2,X2,Z2,Y2,Z2],\n [X2,Z2,X2,Z2,Y2,Z2],[X2,Y2,Z2,Y2],[Y2,Z2,Y2],[X2,Z2,Y2],[Z2,Y2],[X2,Y2,Z2,Y2,Z2,X2,Y2],\n [Y2,Z2,Y2,Z2,X2,Y2],[X2,Z2,Y2,Z2,X2,Y2],[Z2,Y2,Z2,X2,Y2],[X2,Y2,Z2,X2,Z2],[Y2,Z2,X2,Z2],\n [X2,Z2,X2,Z2],[Z2,X2,Z2],[X2,Y2,Z2,X2,Z2,Y2],[Y2,Z2,X2,Z2,Y2],[X2,Z2,X2,Z2,Y2],\n [Z2,X2,Z2,Y2],[X2,Y2,Z2],[Y2,Z2],[X2,Z2],[Z2],[X2,Y2,Z2,Y2,Z2,X2],[Y2,Z2,Y2,Z2,X2],\n [X2,Z2,Y2,Z2,X2],[Z2,Y2,Z2,X2],[Z2,Y2,Z2,Y2,Z2,X2,Z2],[X2,Z2,Y2,Z2,Y2,Z2,X2,Z2],\n [Z2,X2,Z2,X2,Y2],[X2,Z2,X2,Z2,X2,Y2],[Z2,X2],[X2,Z2,X2],[Y2,Z2,X2],[X2,Y2,Z2,X2],\n [X2,Z2,Y2,Z2],[Z2,Y2,Z2],[X2,Y2,Z2,Y2,Z2],[Y2,Z2,Y2,Z2],[Y2,Z2,X2,Y2],[Z2,X2,Y2,Z2],\n [Z2,X2,Y2],[X2,Z2,X2,Y2],[Z2,Y2,Z2,Y2],[X2,Z2,Y2,Z2,Y2],[Y2,Z2,Y2,Z2,Y2],\n [X2,Y2,Z2,Y2,Z2,Y2],[X2,Z2,X2,Z2,X2],[Z2,X2,Z2,X2],[X2,Y2,Z2,X2,Z2,X2],[Y2,Z2,X2,Z2,X2]];\n\n # words in x2, y2, x3, x5 for all elements\n G[\"words_b\"] := [seq(seq(seq(seq([X2$i,Y2$j,X3$k,X5$l],i=0..1),j=0..1),k=0..2),l=0..4)];\n\n G[\"rels\"] := [\n  [X2$2],[Y2$2],[Z2$2],[X3$3],[X5$5],[Y5$5],\n  map(op,[[X2,Y2]$2]),map(op,[[X2,Y2,Z2]$3]),\n  map(op,[[Z2,X2,Z2,Y2]$3]),map(op,[[X2,Z2]$5]),map(op,[[Y2,Z2]$5]),\n  [X3,Y2,Z2,X2,Z2,Y2,Z2],[Y5,Y2,Z2,X2,Z2,X2],[X5,Y2,X5,X5,X5,X3,X3]];\n\n ccl := (x) -> sort([op({seq(oo(g,x,inv(g)), g in E)})]);\n\n G[\"conjugacy_classes\"] := [\n  ccl(id),\n  ccl(x2),\n  ccl(x3),\n  ccl(o(x5,x5)),\n  ccl(x5)\n ];\n\n G[\"conjugacy_class_index\"] := table();\n for i from 1 to 5 do\n  for g in G[\"conjugacy_classes\"][i] do\n   G[\"conjugacy_class_index\"][g] := i;\n  od;\n od;\n\n G[\"element_order\"] := table();\n\n for g in E do \n  h := g;\n  i := 1;\n  while h <> id do i := i + 1; h := o(g,h); od:\n  G[\"element_order\"][g] := i;\n od:\n  \n t0 := (sqrt(5)+1)/2;\n t1 := (sqrt(5)-1)/2;\n \n # Dodecahedron representation\n\n idm := [[1,0,0],[0,1,0],[0,0,1]];\n om := (u,v) -> expand(convert(Matrix(u) . Matrix(v),listlist));\n oom := proc()\n  if   nargs = 0 then return(idm);\n  elif nargs = 1 then return(args[1]);\n  elif nargs = 2 then return(om(args));\n  else return om(args[1],oom(args[2..-1]));\n  fi;\n end:\n\n G[\"idm\"] := idm;\n G[\"om\"]  := eval(om);\n G[\"oom\"] := eval(oom);\n \n G[\"matrix_gens_rule\"] := {\n   X1 = [[ 1,0,0],[0, 1,0],[0,0, 1]],\n   X2 = [[ 1,0,0],[0,-1,0],[0,0,-1]],\n   Y2 = [[-1,0,0],[0,-1,0],[0,0, 1]],\n   Z2 = [[t1,-t0,-1],[-t0,-1,t1],[-1,t1,-t0]] /~ 2,\n   X3 = [[0,0,1],[1,0,0],[0,1,0]],\n   X5 = [[t1,-t0,1],[t0,1,t1],[-1,t1,t0]] /~ 2,\n   Y5 = [[t0,1,-t1],[-1,t1,-t0],[-t1,t0,1]] /~ 2\n };\n\n G[\"matrix\"] := table();\n G[\"axis\"]   := table();\n G[\"angle\"]  := table();\n\n for i from 1 to 60 do\n  g := E[i];\n  G[\"matrix\"][g] := oom(op(subs(G[\"matrix_gens_rule\"],G[\"words_b\"][i])));\n  if i = 1 then\n   G[\"axis\"][g] := [0,0,0];\n   G[\"angle\"][g] := 0;\n  else\n   M := Matrix(G[\"matrix\"][g]);\n   u0 := convert(NullSpace(M - IdentityMatrix(3))[1],list);\n   u0 := simplify(expand(rationalize(u0 /~ sqrt(add(u0[j]^2,j=1..3)))));\n   u1 := [1,2,3];\n   u1 := u1 -~ add(u1[j] * u0[j],j=1..3) *~ u0;\n   u1 := simplify(expand(rationalize(u1)));\n   u2 := [u0[2] * u1[3] - u0[3] * u1[2],\n          u0[3] * u1[1] - u0[1] * u1[3],\n          u0[1] * u1[2] - u0[2] * u1[1]];\n   u2 := simplify(expand(rationalize(u2)));\n   u3 := simplify(expand(rationalize(convert(M . Vector(u1), list))));\n   \n   theta := evalf(arctan(add(u3[j] * u2[j],j=1..3),add(u3[j] * u1[j],j=1..3)));\n   theta := round(evalf(60 * theta / Pi)) * Pi / 60;\n   \n   if evalf(theta) < 0 then u0 := -~ u0; theta := -theta; fi; \n   G[\"axis\"][g] := u0;\n   G[\"angle\"][g] := theta;\n  fi;\n od;\n\n alternating_five := eval(G);\n return eval(G);\nend:\n\nmake_alternating_five():\n\ncheck_alternating_five := proc()\n local A5,f,fm,is_rot,ok,i,j,ij,g,h,gh,gm,hm,ghm0,ghm1;\n \n A5 := eval(make_alternating_five()):\n\n f := (u) -> A5[\"oo\"](op(subs(A5[\"gens_rule\"],u)));\n fm := (u) -> A5[\"oom\"](op(subs(A5[\"matrix_gens_rule\"],u)));\n\n _ASSERT(\n  evalb({op(map(f,A5[\"rels\"]))} = {A5[\"id\"]}),\n  \"permutation relations\");\n\n _ASSERT(\n  evalb({op(map(fm,A5[\"rels\"]))} = {A5[\"idm\"]}),\n  \"matrix relations\");\n\n _ASSERT(\n  `and`(seq(evalb(f(A5[\"words_a\"][i]) = A5[\"elements\"][i]),i=1..60)),\n  \"words_a\");\n\n _ASSERT(\n  `and`(seq(evalb(f(A5[\"words_b\"][i]) = A5[\"elements\"][i]),i=1..60)),\n  \"words_b\");\n\n is_rot := proc(m)\n  local M,N;\n  M := Matrix(m);\n  if (simplify(expand(Determinant(M) - 1)) <> 0) then\n   return false;\n  fi;\n\n  N := map(simplify,map(expand,Transpose(M) . M - IdentityMatrix(3)));\n  if not(Equal(N,Matrix(3,3))) then return false; fi;\n  return true;\n end:\n\n _ASSERT(\n  `and`(seq(is_rot(A5[\"matrix\"][g]),g in A5[\"elements\"])),\n  \"matrices are rotations\"\n );\n\n ok := true;\n for i from 1 to 60 do \n  for j from 1 to 60 do \n   g := A5[\"elements\"][i];\n   h := A5[\"elements\"][j];\n   gh := A5[\"o\"](g,h);\n   ij := A5[\"element_index\"][gh];\n   gm := A5[\"matrix\"][g];\n   hm := A5[\"matrix\"][h];\n   ghm0 := A5[\"matrix\"][gh];\n   ghm1 := A5[\"om\"](gm,hm);\n   if ghm0 <> ghm1 then ok := false; break; fi;\n  od:\n  if not(ok) then break; fi;\n od:\n\n _ASSERT(ok,\"matrix representation is a homomorphism\");\nend:", "meta": {"hexsha": "035d70610ff562a66082ddcfce78c9ba723bc3eb", "size": 6841, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/groups/alternating_five.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/groups/alternating_five.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/groups/alternating_five.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.6234309623, "max_line_length": 90, "alphanum_fraction": 0.5113287531, "num_tokens": 3144, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311956428947, "lm_q2_score": 0.5273165233795671, "lm_q1q2_score": 0.4154891387487168}}
{"text": "######################################################################\n# This section is about the suboperad of little 1-cubes where the \n# subintervals fill the whole interval.\n\n`is_element/one_cubes_prime` := (A::set) -> proc(f)\n local X,n,i;\n global reason;\n\n if not(`is_element/cubes`(1)(A)(f)) then\n  reason := [convert(procname,string),\"f is not a 1-cube for A\",f,A,reason];\n  return false;\n fi;\n\n X := map(a -> map(op,f[a]),[op(A)]);\n X := sort(X,(u,v) -> evalb(u[1]<v[1]));\n n := nops(A);\n if X[1][1] <> 0 then\n  reason := [convert(procname,string),\"The first interval does not start at 0\",X[1]];\n  return false;\n fi;\n if X[n][2] <> 1 then\n  reason := [convert(procname,string),\"The last interval does not end at 1\",X[n]];\n  return false;\n fi;\n\n for i from 1 to n-1 do\n  if X[i][2] <> X[i+1][1] then\n   reason := [convert(procname,string),\"Successive intervals do not touch\",X[i],X[i+1]];\n   return false;\n  fi;\n od;\n\n return true;\nend;\n\n`is_equal/one_cubes_prime` := (A::set) -> proc(f1,f2)\n `is_equal/cubes`(1)(A)(f1,f2);\nend:\n\n`is_leq/one_cubes_prime` := NULL;\n\n`random_element/one_cubes_prime` := (A::set) -> proc()\n local d,n,u,i,r,R,xy;\n\n d := 12;\n n := nops(A);\n u := table();\n u[0] := 0;\n for i from 1 to n do \n  u[i] := u[i-1] + rand(1..d)();\n od;\n r := u[n];\n for i from 1 to n do u[i] := u[i]/r; od;\n\n R := `random_element/ord`(A)();\n xy := table();\n for i from 1 to n do \n  xy[R[i]] := [[u[i-1]],[u[i]]];\n od;\n\n return eval(xy);\nend;\n\n`list_elements/one_cubes_prime` := NULL;\n`count_elements/one_cubes_prime` := NULL;\n\n", "meta": {"hexsha": "cd888d4778983bb17ba37ceed3bba868e75f72ef", "size": 1539, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/one_cubes_prime.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/one_cubes_prime.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/one_cubes_prime.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.9701492537, "max_line_length": 88, "alphanum_fraction": 0.5711500975, "num_tokens": 514, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6477982315512488, "lm_q2_score": 0.6370307806984444, "lm_q1q2_score": 0.4126674131801637}}
{"text": "\n# Kinematik-Berechnung 3. Arm KAS5\n# Beschreibung\n# \n# Modell m5: \n# * Kurbel N7 ist starr mit Körper K2 gekoppelt (über die Achse) (wie m3), \n# * Zahnradkopplung zwischen Körpern Z2 und Z3 (Unterschied zu m3)\n# \n# Setze die Zwangsbedingung (Zahnradkopplung) in die bereits berechneten Zwangsbedingungen für das KAS5m3 ein\n# \n# Berechnung der Kopplung der Zahnräder am Ellenbogen\n# Autor\n# Moritz Schappler, schappler@irt.uni-hannover.de, 2016-02\n# Institut fuer Regelungstechnik, Leibniz Universitaet Hannover\n# Initialisierung\ninterface(warnlevel=0): # Unterdrücke die folgende Warnung.\nrestart: # Gibt eine Warnung, wenn über Terminal-Maple mit read gestartet wird.\ninterface(warnlevel=3):\nkin_constraints_exist := true: # Für Speicherung\n;\nwith(LinearAlgebra):\nwith(StringTools): # Für Zeitausgabe\n;\nwith(codegen):\nwith(CodeGeneration):\nread \"../helper/proc_convert_s_t\":\nread \"../helper/proc_convert_t_s\": \nread \"../helper/proc_MatlabExport\":\ncodegen_act := true:\nread \"../robot_codegen_constraints/proc_subs_kintmp_exp\":\nread \"../robot_codegen_definitions/robot_env\":\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", robot_name):\n# Lese Ergebnisse der Kinematik von KAS5m3 aus.\n# Siehe KAS5m3_sym_codegen_kinematic_constraints.mw\n# kintmp_qs, kintmp_qt, lpar_qs, lpar_qt, kintmp_subsexp\nread  sprintf(\"../codeexport/KAS5m5/tmp/kinematic_constraints_maple_inert.m\", robot_name):\nkintmp_qs_KAS5m5 := kintmp_qs:\nkintmp_qt_KAS5m5 := kintmp_qt:\nlpar_qs_KAS5m5 := lpar_qs:\nlpar_qt_KAS5m5 := lpar_qt:\nkintmp_subsexp_KAS5m5 := kintmp_subsexp:\nread  sprintf(\"../codeexport/KAS5m5/tmp/tree_floatb_definitions\", robot_name):\nkintmp_s_KAS5m5 := kintmp_s:\nkintmp_t_KAS5m5 := kintmp_t:\nread \"../robot_codegen_definitions/robot_env\":\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", robot_name):\nkintmp_s := kintmp_s:\nkintmp_t := kintmp_t:\nkintmp_qs := kintmp_s:\nkintmp_qt := kintmp_t:\nkintmp_subsexp := Matrix(2*RowDimension(kintmp_s),2):\nfor i from 1 to RowDimension(kintmp_s) do\n  kintmp_subsexp(2*i-1, 1) := sin(kintmp_s(i,1)):\n  kintmp_subsexp(2*i,   1) := cos(kintmp_s(i,1)):\n  # Initialisierung der rechten Spalte mit gleichen Werten. Später nur Ersetzung, wenn Vorteilhaft.\n  kintmp_subsexp(2*i-1, 2) := kintmp_subsexp(2*i-1, 1):\n  kintmp_subsexp(2*i,   2) := kintmp_subsexp(2*i,   1):\nend do:\nprintf(\"Beginn der Berechnungen. %s\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\nst := time():\n# Übernehme die Ersetzungsausdrücke von KAS5m5\n# \nfor i from 1 to RowDimension(kintmp_s_KAS5m5) do\n  for j from 1 to RowDimension(kintmp_s) do\n    if kintmp_s_KAS5m5(i,1) = kintmp_s(j,1) then\n      # printf(\"KAS5m5 %d = KAS5m7 %d\\n\", i, j):\n      kintmp_qs(j,1) := kintmp_qs_KAS5m5(i,1):\n      kintmp_qt(j,1) := kintmp_qt_KAS5m5(i,1):\n    end if:\n  end do:\nend do:\nfor i from 1 to RowDimension(kintmp_subsexp_KAS5m5) do\n  for j from 1 to RowDimension(kintmp_subsexp) do\n    if kintmp_subsexp_KAS5m5(i,1) = kintmp_subsexp(j,1) then\n      # printf(\"KAS5m5 %d = KAS5m7 %d\\n\", i, j):\n      kintmp_subsexp(j,2) := kintmp_subsexp_KAS5m5(i,2):\n    end if:\n  end do:\nend do:\n# Hierbei werden die Definitionen für kintmp_s und kintmp_t überschrieben, da die Elemente in kintmp_qs und kintmp_qt drin stehen.\n# Umgehung des Problems: Definitionen neu laden.\nread \"../robot_codegen_definitions/robot_env\":\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", robot_name):\nkintmp_s := kintmp_s:\nkintmp_t := kintmp_t:\ninterface(rtablesize=100):\n# Korrigiere die Bedingungen. Dort wurden die konstanten Winkel auch mit substitutierten Variablen \"s\" bezeichnet, was eigentlich keinen Sinn ergibt.\n# Die mit Suffix \"s\" gekennzeichneten substituierten Winkel beziehen sich nur auf Zeitableitungen, die mit einem konstanten Ausdruck ersetzt wurden.\n# Damit nicht delta8 und delta8s als unterschiedliche Variablen auftauchen, werden diese ersetzt.\nsubs_kp1 := <delta8s; delta9s; delta10s; delta12s; delta17s; delta18s>:\nsubs_kp2 := <delta8;  delta9;  delta10;  delta12;  delta17;  delta18>:\nfor i from 1 to RowDimension(subs_kp1) do\n  for j from 1 to RowDimension(kintmp_subsexp) do\n    kintmp_subsexp(j,2) := subs({subs_kp1(i,1)=subs_kp2(i,1)}, kintmp_subsexp(j,2));\n  end do:\n  for j from 1 to RowDimension(kintmp_qs) do\n    kintmp_qs(j,1) := subs({subs_kp1(i,1)=subs_kp2(i,1)}, kintmp_qs(j,1));\n    kintmp_qt(j,1) := subs({subs_kp1(i,1)=subs_kp2(i,1)}, kintmp_qt(j,1));\n  end do:\n  lpar_qs_KAS5m5 := subs({subs_kp1(i,1)=subs_kp2(i,1)}, lpar_qs_KAS5m5);\nend do:\n# Zahnrad Abwälzbedingung (delta19)\n# Siehe Aufzeichnungen vom 3.6.2016\nkintmp_s(24);\nkintmp_subsexp(47,2);\nkintmp_subsexp(48,2);\ndelta19_qs := convert_t_s(theta(4)):\nkintmp_qs(24) := delta19_qs:\nkintmp_subsexp(47,2) := sin(delta19_qs):\nkintmp_subsexp(48,2) := cos(delta19_qs):\n# Zahnrad Abwälzbedingung (rho6)\n# Siehe Aufzeichnungen vom 3.6.2016\nkintmp_s(28);\nkintmp_subsexp(55,2);\nkintmp_subsexp(56,2);\nrho6_qs := convert_t_s(theta(5)) - convert_t_s(theta(4)) + delta18:\nkintmp_qs(28) := rho6_qs:\nkintmp_subsexp(55,2) := sin(rho6_qs):\nkintmp_subsexp(56,2) := cos(rho6_qs):\n# Berechne delta7\n# Gl. (30)\nkintmp_s(12);\nkintmp_subsexp(23,2);\nkintmp_subsexp(24,2);\ndelta7_qs := delta17 + delta19_qs: # Geändert ggü. KAS5\n;\nkintmp_qs(12) := delta7_qs:\nkintmp_subsexp(23,2) := sin(delta7_qs):\nkintmp_subsexp(24,2) := cos(delta7_qs):\n\n# Dummy-Einträge für Schnitt-Gelenke\n# Die Winkel der Schnittgelenke sind egal, daher keine Berechnung.\n\n# delta 14\n# \nkintmp_s(19);\nkintmp_subsexp(37,2);\nkintmp_subsexp(38,2);\nkintmp_qs(19) := 0:\n# delta 21\n# \nkintmp_s(26);\nkintmp_subsexp(51,2);\nkintmp_subsexp(52,2);\nkintmp_qs(26) := 0:\n\n# Setze Federlänge als Variable\nkintmp_s(29);\nkintmp_qs(29) := lpar_qs_KAS5m5:\n# Nachverarbeiten\n# \nkintmp_qt := convert_s_t(kintmp_qs):\n# Speichern der Ergebnisse\nsave kin_constraints_exist, kintmp_qs, kintmp_qt, kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_inert\", robot_name):\nsave kin_constraints_exist, kintmp_qs, kintmp_qt, kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_inert.m\", robot_name):\n# Exportieren der Zwangsbedingungen\n# Matlab-Funktionen für ZB\nif codegen_act then\n  MatlabExport(kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematik_parallel_kintmp_subsexp_matlab_opt1.m\", robot_name), 1):\nend if:\nprintf(\"Ausdrücke mit Inert-Arctan exportiert (Matlab). %s. CPU-Zeit bis hier: %1.2fs.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\"), time()-st):\n# Liste der Parameter speichern\n# Liste mit abhängigen konstanten Kinematikparametern erstellen (wichtig für Matlab-Funktionsgenerierung)\nread \"../helper/proc_list_constant_expressions\";\nkc_symbols := Matrix(list_constant_expressions( kintmp_subsexp(..,2) )):\nsave kc_symbols, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_symbols_list_maple\", robot_name):\nMatlabExport(Transpose(kc_symbols), sprintf(\"../codeexport/%s/tmp/kinematic_constraints_symbols_list_matlab.m\", robot_name), 2):\nprintf(\"Zwangsbedingungen der Parallelstruktur von KAS5m5 nach KAS5m7 angepasst. %s\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n\n", "meta": {"hexsha": "8c43d37bc5c2942a25e476a6ca9f2fc277c27d57", "size": 7003, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "exoskeleton_model/model_generation/constraints/KAS5m7TE_kinematic_constraints.mpl", "max_stars_repo_name": "SchapplM/robsynth-paper_iftommwc2019_dynamics_hybridrobots", "max_stars_repo_head_hexsha": "b3d83b4c99bb5bccb3076ca93790b079fc4e1d2f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-12-19T14:12:45.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-19T14:12:45.000Z", "max_issues_repo_path": "exoskeleton_model/model_generation/constraints/KAS5m7TE_kinematic_constraints.mpl", "max_issues_repo_name": "SchapplM/robsynth-paper_iftommwc2019_dynamics_hybridrobots", "max_issues_repo_head_hexsha": "b3d83b4c99bb5bccb3076ca93790b079fc4e1d2f", "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": "exoskeleton_model/model_generation/constraints/KAS5m7TE_kinematic_constraints.mpl", "max_forks_repo_name": "SchapplM/robsynth-paper_iftommwc2019_dynamics_hybridrobots", "max_forks_repo_head_hexsha": "b3d83b4c99bb5bccb3076ca93790b079fc4e1d2f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.1941176471, "max_line_length": 149, "alphanum_fraction": 0.7546765672, "num_tokens": 2560, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7634837635542924, "lm_q2_score": 0.5389832206876841, "lm_q1q2_score": 0.4115049378232468}}
{"text": "\n# Berechnung und Projektion der Dynamikgleichungen in Regressorform\n# Einleitung\n# Berechnung und Projektion der Dynamikgleichungen in Regressorform\n# \n# Dateiname:\n# robot -> Berechnung für allgemeinen Roboter\n# para -> Berechnung für einen parallelen Roboter\n# rotmat -> Kinematik wird mit Rotationsmatrizen berechnet\n# projection -> Die Dynamikgleichungen werden auf EE-Koordinaten projiziert\n# dynamics -> Berechnung der Dynamik\n# regressor -> Regressorform (parameterlinear)\n# \n# TODO\n# Die Regressorform ist noch nicht in Minimaldarstellung. Außerdem treten Dynamikparameter auf, die bei reduzierten EE-FG (z.B. 2T1R-Bewegung) keinen Einfluss haben.\n# \n# Autor\n# Tim Job (Studienarbeit bei Moritz Schappler), 2018-12\n# Moritz Schappler, moritz.schappler@imes.uni-hannover.de\n# (C) Institut für Mechatronische Systeme, Universität Hannover\n# Sources\n# [GautierKhalil1990] Direct Calculation of Minimum Set of Inertial Parameters of Serial Robots\n# [KhalilDombre2002] Modeling, Identification and Control of Robots\n# [Ortmaier2014] Vorlesungsskript Robotik I\n# [Job2018_S759] Job, T. (Studienarbeit; Betreuer Moritz Schappler): Implementierung einer strukturunabhängigen Dynamikmodellierung für parallelkinematische Maschinen (2018)\n# Initialization\ninterface(warnlevel=0): # Unterdrücke die folgende Warnung.\nrestart: # Gibt eine Warnung, wenn über Terminal-Maple mit read gestartet wird.\ninterface(warnlevel=3):\ninterface(rtablesize=100):\nwith(LinearAlgebra):\nwith(codegen):\nwith(CodeGeneration):\nwith(StringTools): # Für Zeitausgabe\n;\n# Einstellungen für Code-Export: Optimierungsgrad (2=höchster) und Aktivierung jedes Terms.\n#codegen_act := true: # noch nicht implementiert\ncodegen_opt := 2:\ncodeexport_invdyn := true:\ncodeexport_actcoord := false: # Generierung der Dynamik in Antriebskoordinaten nicht standardmäßig (hoher Rechenaufwand)\n;\nread \"../helper/proc_MatlabExport\": \n# Roboter-Definitionen laden\nread \"../robot_codegen_definitions/robot_env_par\":\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", leg_name):\nread \"../robot_codegen_definitions/robot_env_par\":\n# Ergebnisse der Plattform-Dynamik in Regressorform laden\n\ndynamicsfile := sprintf(\"../codeexport/%s/tmp/floatb_%s_platform_dynamic_reg_maple.m\", robot_name, base_method_name):\nif FileTools[Exists](dynamicsfile) then\n  read dynamicsfile:\nelse\n  printf(\"%s. Plattform-Dynamik (Regressor) konnte nicht geladen werden. Abbruch der Berechnung.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  quit: # Funktioniert in GUI nicht richtig...\n  robot_name := \"\": # ...Daher auch Löschung des Roboternamens.\nend if:\n# Neu-Definieren, damit Variablen im Workspace auftauchen\nparamVecP := paramVecP:\nparamVecP_M := paramVecP_M:\nA_E := A_E:\nH := H:\ndH := dH:\nM_regmin := M_regmin:\nc_regmin := c_regmin:\ng_regmin := g_regmin:\n# Ergebnisse der Dynamik der Gelenkkette in Regressorform laden\n\ndynamicsfile := sprintf(\"../codeexport/%s/tmp/invdyn_%s_%s_maple.m\", leg_name, \"fixb\", \"regressor_minpar\"):\nif FileTools[Exists](dynamicsfile) then\n  read dynamicsfile:\nelse\n  printf(\"%s. PKM-Dynamik konnte nicht geladen werden. Abbruch der Berechnung.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  quit: # Funktioniert in GUI nicht richtig...\n  robot_name := \"\": # ...Daher auch Löschung des Roboternamens.\nend if:\ntau_regressor_s := tau_regressor_s:\ntauMM_regressor_s := tauMM_regressor_s:\nMMjj_regressor_s := MMjj_regressor_s:\ntauC_regressor_s := tauC_regressor_s:\ntaug_regressor_s := taug_regressor_s:\nread \"../robot_codegen_definitions/robot_env_par\":\n\n# Ergebnisse des Minimalparametervektors der Gelenkkette laden\nread sprintf(\"../codeexport/%s/tmp/minimal_parameter_vector_fixb_maple\", leg_name):\nParamvec2 := Paramvec2:\nread \"../robot_codegen_definitions/robot_env_par\": # Nochmal laden, um Standard-Einstellungen überschreiben zu können.\n;\n# Ergebnisse der zusätzlichen Definitionen für parallele Roboter laden\nread sprintf(\"../codeexport/%s/tmp/para_definitions\", robot_name):\nprintf(\"Generiere Parameterlineare Form der Dynamik für PKM %s mit Minimal-Parametersatz\\n\", robot_name):\n# Lade \"robotics_repo_path\"-File mit Link zum \"imes-robotics-matlab\"-Repo\nread(\"../robotics_repo_path\"):\n# Lade die Funktionen aus dem \"imes-robotics-matlab\"-Repo\nread(sprintf(\"%s/transformation/maple/proc_eul%s2r\", robotics_repo_path, angleConvLeg)):\nread(sprintf(\"%s/transformation/maple/proc_eul%sjac\", robotics_repo_path, \"zyx\")):\n\n\n# Berechne Dynamik-Matrizen für alle Beine\n# Alle Basisgeschwindigkeiten und -winkel aus Berechnung der seriellen Kette zu null setzen.\nomegaxs_base := 0:\nomegays_base := 0:\nomegazs_base := 0:\nalphaxs_base := 0:\nbetays_base := 0:\ngammazs_base := 0:\nvxs_base := 0:\nvys_base := 0:\nvzs_base := 0:\nalphaDx_base := 0:\nbetaDy_base := 0:\ngammaDz_base := 0:\nvDxs_base := 0:\nvDys_base := 0:\nvDzs_base := 0:\nalphaDDx_base := 0:\nbetaDDy_base := 0:\ngammaDDz_base := 0:\n\n\n# Ergebnisse der Kinematik für parallelen Roboter laden\n\n\nkinematicsfile := sprintf(\"../codeexport/%s/tmp/kinematics_%s_platform_maple.m\", robot_name, base_method_name):\nif FileTools[Exists](kinematicsfile) then\n  read kinematicsfile:\nelse\n  printf(\"%s. PKM-Kinematik konnte nicht geladen werden. Abbruch der Berechnung.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  quit: # Funktioniert in GUI nicht richtig...\n  robot_name := \"\": # ...Daher auch Löschung des Roboternamens.\nend if:\n# Variablen neu laden\npivotMat := pivotMat:\npivotMatMas := pivotMatMas:\nP_i := P_i:\nJinv := Jinv:\nJB_i := JB_i:\nJBD_i := JBD_i:\nJBinv_i := JBinv_i:\nJBDinv_i := JBDinv_i:\nU_i := U_i:\nUD_i := UD_i:\n\n# Dynamik-Parameter für virtuelle Segmente nach den Plattform-Koppelgelenken entfernen\nNQ := NQ - (NQJ-NQJ_parallel):\nParamvec3:=Paramvec2: # Dynamik-Minimalparametervektor der Beinkette\n;\nfor i from NQJ_parallel+1 to NQJ do\n  Paramvec3 := subs({XXC||i = 0}, Paramvec3):\n  Paramvec3 := subs({XYC||i = 0}, Paramvec3):\n  Paramvec3 := subs({XZC||i = 0}, Paramvec3):\n  Paramvec3 := subs({YYC||i = 0}, Paramvec3):\n  Paramvec3 := subs({YZC||i = 0}, Paramvec3):\n  Paramvec3 := subs({ZZC||i = 0}, Paramvec3):\n  Paramvec3 := subs({XX||i  = 0}, Paramvec3):\n  Paramvec3 := subs({XY||i  = 0}, Paramvec3):\n  Paramvec3 := subs({XZ||i  = 0}, Paramvec3):\n  Paramvec3 := subs({YY||i  = 0}, Paramvec3):\n  Paramvec3 := subs({YZ||i  = 0}, Paramvec3):\n  Paramvec3 := subs({ZZ||i  = 0}, Paramvec3):\n  Paramvec3 := subs({SX||i  = 0}, Paramvec3):\n  Paramvec3 := subs({SY||i  = 0}, Paramvec3):\n  Paramvec3 := subs({SZ||i  = 0}, Paramvec3):\n  Paramvec3 := subs({MX||i  = 0}, Paramvec3):\n  Paramvec3 := subs({MY||i  = 0}, Paramvec3):\n  Paramvec3 := subs({MZ||i  = 0}, Paramvec3):\n  Paramvec3 := subs({M||i   = 0}, Paramvec3):\nend do:\nParamvec2: # Bein-Dynamik-Parametervektor vor Vereinfachungen\n;\nParamvec3: # Bein-Dynamik-Parametervektor nach Vereinfachungen\n;\nparamVecP: # Plattform-Dynamik-Parametervektor ohne Zusammenfassungen\n;\nparamVecP_M: # Plattform-Dynamik-Parametervektor mit Zusammenfassung mit Bein-Dynamikparametern\n;\n# Alle Einträge des Minimalparametervektors, die jetzt Null sind, entfernen\nParamvecNew := Matrix(RowDimension(Paramvec3), 1): # Initialisierung mit maximaler Größe\nk := 0:\nfor j from 1 to RowDimension(Paramvec3) do\n  if not Paramvec3(j,1) = 0 then\n    k := k + 1:\n    ParamvecNew(k,1) := Paramvec3(j,1):\n  end if:\nend do:\n# Neuen Parametervektor für die Beinsegmenten (ohne Plattform)\nParamvecNew := ParamvecNew(1..k,1):\n# Dupliziere alle berechneten Matrizen. i steht für den Index des jeweiligen Beines\ntauReg := tau_regressor_s(7..NQ,..):\n#MatrixEnd := index_symmat2vec(NQJ_parallel,NQJ_parallel,NQJ_parallel):\n#MMjjReg := MMjj_regressor_s(1..MatrixEnd,..):\ntauMMReg := tauMM_regressor_s(7..NQ,..):\nfor i to NQ do \n  tauMMReg := subs({qD_s(i, 1) = 0}, tauMMReg):\nend do:\ntauCReg := tauC_regressor_s(7..NQ,..):\ntaugReg := taug_regressor_s(7..NQ,..):\n\n# Regressor aus Berechnung für serielle Beinketten. Dort erste sechs Einträge für Basis\ng := <g1;g2;g3>:\ntmp := <tmp1;tmp2;tmp3>:\nRmat := Transpose(parse(sprintf(\"eul%s2r\",angleConvLeg))(frame_A_i(1..3,1))):\ngtmp := Rmat.g:\nfor i to NQJ_parallel do\n  for k to ColumnDimension(tauReg) do\n    for j to 3 do \n      tauReg(i,k) := subs({g(j)=tmp(j)},tauReg(i,k)):\n      taugReg(i,k) := subs({g(j)=tmp(j)},taugReg(i,k)):\n    end do:\n    for j to 3 do \n      tauReg(i,k) := subs({tmp(j)=gtmp(j)},tauReg(i,k)):\n      taugReg(i,k) := subs({tmp(j)=gtmp(j)},taugReg(i,k)):\n    end do:\n  end do:\nend do:\n\nfor i to N_LEGS do\n  tau_regressor_s||i := Copy(tauReg):\n  tauMM_regressor_s||i := Copy(tauMMReg):\n  #MMjj_regressor_s||i := Copy(MMjjReg):\n  tauC_regressor_s||i := Copy(tauCReg):\n  taug_regressor_s||i := Copy(taugReg):\nend do:\nCOLUMNreg := ColumnDimension(tau_regressor_s):\n# \n# Substituiere in jeder Matrix den Winkel Alpha (Verdrehung in der Basis) und die Gelenkkoordinaten und -geschwindigkeiten\nfor k from 1 by 1 to N_LEGS do\n  for i to NQJ_parallel do\n    for j to COLUMNreg do\n      for p from NQJ_parallel+1 to NQJ do\n        tau_regressor_s||k(i,j) := subs({qJDD||p||s=0,qJD||p||s=0,qJ||p||s=0},tau_regressor_s||k(i,j)):\n        tauMM_regressor_s||k(i,j) := subs({qJDD||p||s=0,qJD||p||s=0,qJ||p||s=0},tauMM_regressor_s||k(i,j)):\n        tauC_regressor_s||k(i,j) := subs({qJDD||p||s=0,qJD||p||s=0,qJ||p||s=0},tauC_regressor_s||k(i,j)):\n        taug_regressor_s||k(i,j) := subs({qJDD||p||s=0,qJD||p||s=0,qJ||p||s=0},taug_regressor_s||k(i,j)):\n      end do:\n      for l to 3 do\n        tau_regressor_s||k(i,j) := subs({frame_A_i(l,1)=frame_A_i(l,k)},tau_regressor_s||k(i,j)):\n        tauMM_regressor_s||k(i,j) := subs({frame_A_i(l,1)=frame_A_i(l,k)},tauMM_regressor_s||k(i,j)):\n        tauC_regressor_s||k(i,j) := subs({frame_A_i(l,1)=frame_A_i(l,k)},tauC_regressor_s||k(i,j)):\n        taug_regressor_s||k(i,j) := subs({frame_A_i(l,1)=frame_A_i(l,k)},taug_regressor_s||k(i,j)):\n      end do:\n      for m to NQJ_parallel do\n        n := (m + (k-1)*NQJ_parallel):\n        tau_regressor_s||k(i,j) := subs({qJDD||m||s=qJDD||n||s,qJD||m||s=qJD||n||s,qJ||m||s=qJ||n||s},tau_regressor_s||k(i,j)):\n        tauMM_regressor_s||k(i,j) := subs({qJDD||m||s=qJDD||n||s,qJD||m||s=qJD||n||s,qJ||m||s=qJ||n||s},tauMM_regressor_s||k(i,j)):\n        tauC_regressor_s||k(i,j) := subs({qJDD||m||s=qJDD||n||s,qJD||m||s=qJD||n||s,qJ||m||s=qJ||n||s},tauC_regressor_s||k(i,j)):\n        taug_regressor_s||k(i,j) := subs({qJDD||m||s=qJDD||n||s,qJD||m||s=qJD||n||s,qJ||m||s=qJ||n||s},taug_regressor_s||k(i,j)):\n      end do:\n    end do:\n  end do:\nend do:\n\n\nprintf(\"%s. Dynamik-Matrizen bestimmt. Beginne Projektion/Addition.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n# Berechnung, Projektion und Addition der Dynamikgleichungen\n# Berechnung der Kräfte/Momente an den Gelenken der jeweiligen Beine und Projektion auf EE-Plattform\nA_E := A_E:\nU_i := U_i:\nJBinv_i := JBinv_i:\nfor i to N_LEGS do\n   A_||i:= simplify(Transpose(U_i(..,..,i)).Transpose(JBinv_i(..,..,i))).simplify(tau_regressor_s||i):\n   Mreg_||i:= simplify(Transpose(U_i(..,..,i)).Transpose(JBinv_i(..,..,i))).simplify(tauMM_regressor_s||i):\n   Creg_||i:= simplify(Transpose(U_i(..,..,i)).Transpose(JBinv_i(..,..,i))).simplify(tauC_regressor_s||i):\n   greg_||i:= simplify(Transpose(U_i(..,..,i)).Transpose(JBinv_i(..,..,i))).simplify(taug_regressor_s||i):\nend do:\n# Aufsummieren aller Kräfte, projiziert auf EE-Plattform\nTmp := 0:\nTmpM := 0:\nTmpC := 0:\nTmpg := 0:\nfor i to N_LEGS do\n  Tmp := Tmp + A_||i:\n  TmpM := TmpM + Mreg_||i:\n  TmpC := TmpC + Creg_||i:\n  Tmpg := Tmpg + greg_||i:\nend do:\nA_j := Tmp:\nMreg_j := TmpM:\nCreg_j := TmpC:\ngreg_j := Tmpg:\n# Addiere Inverse Dynamik der Plattform\nROWS := RowDimension(ParamvecNew):\n# \n# Neuer Parametervektor für Beine und Plattform\nparamMin := <ParamvecNew;paramVecP>: # TODO: Hier stand vorher paramVecP_M. Damit war die Regressorform aber nicht für alle Systeme konsistent. Jetzt ist die parameterlineare Form aber nicht mehr so stark zusammengefasst, wie sie es sein könnte.\n;\n# Regressormatrix zusammenstellen\nA := pivotMat.<A_j(1..6,1..ROWS)|A_E>:\nMreg := pivotMat.<Mreg_j(1..6,1..ROWS)|M_regmin>:\nCreg := pivotMat.<Creg_j(1..6,1..ROWS)|c_regmin>:\ngreg := pivotMat.<greg_j(1..6,1..ROWS)|g_regmin>:\nNotNullEntries := 0:\nfor i to RowDimension(paramMin) do\n\tif not(paramMin(i,1) = 0 or Equal(Column(A,i), ZeroVector[column](RowDimension(A)))) then\n\t\tNotNullEntries := NotNullEntries + 1:\n\tend if:\nend do:\nNotNullEntries:\nparamMinRed := Matrix(NotNullEntries,1):\nARed := Matrix(RowDimension(A),NotNullEntries):\nMregRed := Matrix(RowDimension(A),NotNullEntries):\nCregRed := Matrix(RowDimension(A),NotNullEntries):\ngregRed := Matrix(RowDimension(A),NotNullEntries):\nj := 1:\nfor i to RowDimension(paramMin) do\n\tif not(paramMin(i,1) = 0 or Equal(Column(A,i), ZeroVector[column](RowDimension(A)))) then\n\t\tparamMinRed(j,1) := paramMin(i,1):\n\t\tfor k to RowDimension(A) do\n\t\t\tARed(k,j) := A(k,i):\n\t\t\tMregRed(k,j) := Mreg(k,i):\n\t\t\tCregRed(k,j) := Creg(k,i):\n\t\t\tgregRed(k,j) := greg(k,i):\n\t\tend do:\n\t\tj := j + 1:\n\tend if:\nend do:\nprintf(\"%s. Beginne Ersetzung der Geschwindigkeiten und Bestimmung der Plattform-Terme.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n# Replace Joint Velocities\n# Substituiere die Gelenkgeschwindigkeiten über H-, Ui- und JBi-Matrix mit EE-Geschwindikeiten\nTmp := 0:\nTmp2 := 0:\n\nfor i to N_LEGS do\n  Tmp := Multiply(H,xED_s):\n  Tmp := Multiply(U_i(..,..,i),Tmp):\n  z||i := simplify(Multiply(JBinv_i(..,..,i),Tmp)):\n  Tmp2 := JBinv_i(..,..,i).(Multiply(U_i(..,..,i),H).xEDD_s+Multiply(U_i(..,..,i),dH).xED_s+Multiply(UD_i(..,..,i),H).xED_s):\n  A||i := simplify(Multiply(JBinv_i(..,..,i),JBD_i(..,..,i))):\n  B||i := Multiply(A||i,Matrix(qJD_i_s(..,i))):\n  C||i := Tmp2 - B||i:\nend do:\n\nRowParamMin := RowDimension(paramMinRed):\nMtoC := copy(MregRed):\nfor i to NX do\n  for k to RowParamMin do\n    for j to N_LEGS do\n      for l to NQJ_parallel do\n        ARed(i,k) := subs({qJDD_i_s(l,j)=C||j(l)},ARed(i,k)):\n        MregRed(i,k) := subs({qJDD_i_s(l,j)=C||j(l)},MregRed(i,k)):\n        MtoC(i,k) := subs({qJDD_i_s(l,j)=C||j(l)},MtoC(i,k)):\n      end do:\n    end do:\n    for j to N_LEGS do\n      for l to NQJ_parallel do\n        ARed(i,k) := subs({qJD_i_s(l,j)=z||j(l)},ARed(i,k)):\n        MregRed(i,k) := subs({qJD_i_s(l,j)=z||j(l)},MregRed(i,k)):\n        MtoC(i,k) := subs({qJD_i_s(l,j)=z||j(l)},MtoC(i,k)):\n        CregRed(i,k) := subs({qJD_i_s(l,j)=z||j(l)},CregRed(i,k)):\n      end do:\n    end do:\n    for j to N_LEGS do\n      for l to 6 do\n        MregRed(i,k) := subs({xED_s(l,1)=0},MregRed(i,k)):\n        MtoC(i,k) := subs({xEDD_s(l,1)=0},MtoC(i,k)):\n      end do:\n    end do:\n  end do:\nend do:\nCregRed := CregRed+MtoC:\ntauGes := ARed:#.paramMinRed:\n# Dynamik-Regressor in Plattform-Koordinaten (oben berechnet)\ntau_x := tauGes:\n# Dynamik-Regressor in Antriebs-Koordinaten umrechnen. Nur machen, wenn die Jacobi-Matrix einfach genug ist.\nif RowDimension(Jinv) < 5 and codeexport_actcoord then\n  read sprintf(\"../codeexport/%s/tmp/jacobian_maple.m\", robot_name): # Annahme, dass die Jacobi-Matrix (aus Invertierung) vorher berechnet wurde. Setzt aktuell das normale Dynamik-Skript voraus.\n  J:=J: # Neudefinition, damit Variable im Workspace ist.\n  tau_qa:=Transpose(J).tauGes:\n  Mreg_qa:=Transpose(J).MregRed:\n  Creg_qa:=Transpose(J).CregRed:\n  greg_qa:=Transpose(J).gregRed:\nend if:\n\n# Erzeuge Minimalkoordinatenvektor zur Erstellung der Massenmatrix durch Ableitungen im folgenden Schritt\nxEDD_s_dummy := Matrix(NX,1):\nzaehler := 1:\nfor i to 6 do\n\tif not(xEDD_s(i) = 0) then\n\t\txEDD_s_dummy(zaehler) := xEDD_s(i):\n\t\tzaehler := zaehler + 1:\n\tend if:\nend do:\n# Erzeugung der Massenmatrizen\nMMregRed := Matrix(NX*NX, RowDimension(paramMinRed)):\nMMreg_qa := Matrix(NX*NX, RowDimension(paramMinRed)):\ni_rr := 0:\nfor i to NX do # Zeilenindex der Massenmatrix\n  for j to NX do  # Spaltenindex der Massenmatrix\n    #if j > i then\n    #  next: # rechte obere Seite der symmetrischen Matrix. Keine neue Information. Nicht berechnen oder speichern.\n    #end if:\n    i_rr := i_rr + 1: # Gehe zeilenweise durch den unteren linken Teil der Massenmatrix (inkl. Diagonale)\n    for k to RowDimension(paramMinRed) do # Spaltenindex der Regressormatrix\n      MMregRed[i_rr, k] := diff(MregRed[i, k], xEDD_s_dummy[j, 1]):\n      MMreg_qa[i_rr, k] := diff(Mreg_qa[i, k], xEDD_s_dummy[j, 1]):\n    end do:\n  end do:\nend do:\n# Dynamik in Plattform-Koordinaten (oben berechnet)\ntau_x := ARed:\nMMreg_x := MMregRed:\nCreg_x := CregRed:\ngreg_x := gregRed:\n# PKM-Dynamik-Funktionen mit MPV bereits eingesetzt\n# Erzeuge MPV-Vektor\nnMDP := RowDimension(paramMinRed):\nPV := Matrix(nMDP,1):\nfor i from 1 to nMDP do\n  PV(i,1) := parse(sprintf(\"MDP%d%\", i)):\nend do:\n\ntau_x_mdp := tau_x.PV:\nMMreg_x_mdp := MMreg_x.PV:\nCreg_x_mdp := Creg_x.PV:\ngreg_x_mdp := greg_x.PV:\n\ntau_qa_mdp := tau_qa.PV:\nMMreg_qa_mdp := MMreg_qa.PV:\nCreg_qa_mdp := Creg_qa.PV:\ngreg_qa_mdp := greg_qa.PV:\n\n# Export\n# Maple-Export (zur eventuellen späteren Verarbeitung in Maple)\n\nsave tau_x,   sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_reg_maple.m\",     robot_name):\nsave MMreg_x, sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_MMreg_maple.m\",   robot_name):\nsave Creg_x,  sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_tauCreg_maple.m\", robot_name):\nsave greg_x,  sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_taugreg_maple.m\", robot_name):\n\n# Matlab Export: Floating base (TODO: Was heißt das? Hier ist doch kein Floating Base?)\n# Berechnung der Basis-Belastung ist für manche Basis-Darstellungen falsch (siehe oben unter Gravitationslast). (TODO: Ist das noch aktuell?)\n\nif codeexport_invdyn then\n  printf(\"%s. Beginne Code-Export Inverse Dynamik (Regressor) in Plattform-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(tau_x, sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_reg_matlab.m\", robot_name), codegen_opt):\n  printf(\"%s. Beginne Code-Export Massenmatrix (MDP eingesetzt) in Plattform-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(MMreg_x, sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_MMreg_matlab.m\", robot_name), codegen_opt):\n  printf(\"%s. Beginne Code-Export Coriolis-Vektor (MDP eingesetzt) in Plattform-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(Creg_x, sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_tauCreg_matlab.m\", robot_name), codegen_opt):\n  printf(\"%s. Beginne Code-Export Gravitations-Vektor (MDP eingesetzt) in Plattform-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(greg_x, sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_taugreg_matlab.m\", robot_name), codegen_opt):\nend if:\n\nif codeexport_invdyn and RowDimension(Jinv) < 5 and codeexport_actcoord then\n  printf(\"%s. Beginne Code-Export Inverse Dynamik (Regressor) in Antriebs-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(tau_qa, sprintf(\"../codeexport/%s/tmp/invdyn_para_actcoord_reg_matlab.m\", robot_name), codegen_opt):\n  printf(\"%s. Beginne Code-Export Massenmatrix (Regressor) in Antriebs-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(MMreg_qa, sprintf(\"../codeexport/%s/tmp/invdyn_para_actcoord_MMreg_matlab.m\", robot_name), codegen_opt):\n  printf(\"%s. Beginne Code-Export Coriolis-Vektor (Regressor) in Antriebs-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(Creg_qa, sprintf(\"../codeexport/%s/tmp/invdyn_para_actcoord_tauCreg_matlab.m\", robot_name), codegen_opt):\n  printf(\"%s. Beginne Code-Export Gravitations-Vektor (Regressor) in Antriebs-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(greg_qa, sprintf(\"../codeexport/%s/tmp/invdyn_para_actcoord_taugreg_matlab.m\", robot_name), codegen_opt):\nend if:\n\n# Maple-Export\n\nsave paramMinRed, sprintf(\"../codeexport/%s/tmp/minimal_parameter_parrob_maple.m\", robot_name):\nsave RowParamMin, sprintf(\"../codeexport/%s/tmp/RowMinPar_parallel_maple.m\",       robot_name):\n\nMatlabExport(paramMinRed, sprintf(\"../codeexport/%s/tmp/minimal_parameter_parrob_matlab.m\", robot_name), codegen_opt):\nMatlabExport(RowParamMin, sprintf(\"../codeexport/%s/tmp/RowMinPar_parallel.m\", robot_name), 2);\n\n# PKM-Dynamik-Funktionen mit MPV bereits eingesetzt\n\n# Maple-Export\n\nsave tau_x_mdp,   sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_reg_mdp_maple.m\",     robot_name):\nsave MMreg_x_mdp, sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_MMreg_mdp_maple.m\",   robot_name):\nsave Creg_x_mdp,  sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_tauCreg_mdp_maple.m\", robot_name):\nsave greg_x_mdp,  sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_taugreg_mdp_maple.m\", robot_name):\n\n# Matlab Export: \nif codeexport_invdyn then\n  printf(\"%s. Beginne Code-Export Inverse Dynamik (MDP eingesetzt) in Plattform-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(tau_x_mdp, sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_reg_mdp_matlab.m\", robot_name), codegen_opt):\n  printf(\"%s. Beginne Code-Export Massenmatrix (MDP eingesetzt) in Plattform-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(MMreg_x_mdp, sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_MMreg_mdp_matlab.m\", robot_name), codegen_opt):\n  printf(\"%s. Beginne Code-Export Coriolis-Vektor (MDP eingesetzt) in Plattform-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(Creg_x_mdp, sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_tauCreg_mdp_matlab.m\", robot_name), codegen_opt):\n  printf(\"%s. Beginne Code-Export Gravitations-Vektor (MDP eingesetzt) in Plattform-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(greg_x_mdp, sprintf(\"../codeexport/%s/tmp/invdyn_para_plfcoord_taugreg_mdp_matlab.m\", robot_name), codegen_opt):\nend if:\n\nif codeexport_invdyn and RowDimension(Jinv) < 5 and codeexport_actcoord then\n  printf(\"%s. Beginne Code-Export Inverse Dynamik (MDP eingesetzt) in Antriebs-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(tau_qa_mdp, sprintf(\"../codeexport/%s/tmp/invdyn_para_actcoord_reg_mdp_matlab.m\", robot_name), codegen_opt):\n  printf(\"%s. Beginne Code-Export Massenmatrix (MDP eingesetzt) in Antriebs-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(MMreg_qa_mdp, sprintf(\"../codeexport/%s/tmp/invdyn_para_actcoord_MMreg_mdp_matlab.m\", robot_name), codegen_opt):\n  printf(\"%s. Beginne Code-Export Coriolis-Vektor (MDP eingesetzt) in Antriebs-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(Creg_qa_mdp, sprintf(\"../codeexport/%s/tmp/invdyn_para_actcoord_tauCreg_mdp_matlab.m\", robot_name), codegen_opt):\n  printf(\"%s. Beginne Code-Export Gravitations-Vektor (MDP eingesetzt) in Antriebs-Koordinaten.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n  MatlabExport(greg_qa_mdp, sprintf(\"../codeexport/%s/tmp/invdyn_para_actcoord_taugreg_mdp_matlab.m\", robot_name), codegen_opt):\nend if:\n\n", "meta": {"hexsha": "0ae86e370cde362697dfd8dd087437c8978b724a", "size": 22609, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "robot_codegen_parallel/robot_para_rotmat_projection_dynamics_regressor.mpl", "max_stars_repo_name": "SchapplM/robsynth-modelgen", "max_stars_repo_head_hexsha": "33b345ae0dd6ec4aa15499ab3d43edbbded0bea5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-05-25T07:31:46.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-15T09:54:50.000Z", "max_issues_repo_path": "robot_codegen_parallel/robot_para_rotmat_projection_dynamics_regressor.mpl", "max_issues_repo_name": "SchapplM/robsynth-modelgen", "max_issues_repo_head_hexsha": "33b345ae0dd6ec4aa15499ab3d43edbbded0bea5", "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": "robot_codegen_parallel/robot_para_rotmat_projection_dynamics_regressor.mpl", "max_forks_repo_name": "SchapplM/robsynth-modelgen", "max_forks_repo_head_hexsha": "33b345ae0dd6ec4aa15499ab3d43edbbded0bea5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.7672064777, "max_line_length": 245, "alphanum_fraction": 0.7125481003, "num_tokens": 7742, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125737597972, "lm_q2_score": 0.5467381519846138, "lm_q1q2_score": 0.41115396484662464}}
{"text": "`is_element/itloc/I` := (n::nonnegint) -> (i) ->\n type(i,nonnegint) and i < n:\n\n`list_elements/itloc/I` := (n::nonnegint) -> [seq(i,i=0..n-1)]:\n\n######################################################################\n\n`is_element/itloc/P` := (n::nonnegint) -> (A) -> \n type(A,set(nonnegint)) and (nops(A) = 0 or max(0,op(A)) < n):\n\n`list_elements/itloc/P` := (n::nonnegint) ->\n [op(combinat[powerset]({seq(i,i=0..n-1)}))];\n\n`is_leq/itloc/P` := (n::nonnegint) -> (A,B) -> evalb (A minus B = {});\n\n`bot/itloc/P` := (n::nonnegint) -> {};\n\n`top/itloc/P` := (n::nonnegint) -> {seq(i,i=0..n-1)};\n\n`sup/itloc/P` := (n::nonnegint) -> (A,B) -> A union B;\n\n`inf/itloc/P` := (n::nonnegint) -> (A,B) -> A intersect B;\n\n`angle/itloc/P` := (n::nonnegint) -> (A,B) ->\n (A = {} or B = {} or max(op(A)) <= min(op(B)));\n\n######################################################################\n\n`is_element/itloc/Q` := (n::nonnegint) -> proc(U)\n local N,A,b;\n\n if not type(U,set(set(nonnegint))) then\n  return false;\n fi;\n\n if n = 0 then\n  return evalb(U minus {{}} = {});\n fi;\n\n if max(0,op(map(op,U))) >= n then\n  return false;\n fi;\n\n N := `list_elements/itloc/I`(n);\n \n for A in U do\n  for b in N minus A do\n   if not(member(A union {b},U)) then\n    return false;\n   fi;\n  od;\n od;\n\n return true;\nend:\n\n`is_leq/itloc/Q` := (n::nonnegint) -> (U,V) -> evalb (V minus U = {});\n\n`itloc/u` := (n::nonnegint) -> proc (A::set(nonnegint))\n local BB;\n \n BB := `list_elements/itloc`(n) minus A;\n\n return map(B -> A union B,BB);\nend:\n\n`bot/itloc/Q` := (n::nonnegint) -> `itloc/u`(n)({});\n\n`top/itloc/Q` := (n::nonnegint) -> {};\n\n`omul/itloc/Q` := (n::nonnegint) -> proc(U,V)\n local UV;\n\n UV := {seq(seq([A,B],B in V),A in U)};\n\n UV := select(AB -> `angle/itloc/P`(n)(op(AB)),UV);\n\n return UV;\nend:\n\n`mul/itloc/Q` := (n::nonnegint) -> (U,V) ->\n map(AB -> AB[1] union AB[2],`omul/itloc/Q`(U,V));\n\n######################################################################\n\n`is_element/itloc/M` := (n::nonnegint) -> (AB) -> \n type(AB,list) and nops(AB) = 2 and\n  `is_element/itloc/P`(n)(AB[1]) and \n  `is_element/itloc/P`(n)(AB[2]) and\n  `itloc/angle`(n)(op(AB));\n\n`list_elements/itloc/M` := proc(n::nonnegint)\n local P,Q,i;\n \n P := `list_elements/itloc/P`(n);\n Q := table();\n for i from 0 to n do\n  Q[i] := combinat[powerset]({seq(j,j=i..n-1)});\n end:\n return [seq(seq([A,B],B in Q[max(0,op(A))]),A in P)];\nend:\n\n`is_leq/itloc/M` := (n::nonnegint) -> (AB0,AB1) ->\n evalb (`is_leq/itloc/P`(n)(AB0[1],AB1[1]) and\n        `is_leq/itloc/P`(n)(AB0[2],AB1[2]));\n\n`bot/itloc/M` := (n::nonnegint) -> [{},{}];\n\n`inf/itloc/M` := (n::nonnegint) -> (AB0,AB1) ->\n [AB0[1] intersect AB1[1],AB0[2] intersect AB1[2]];\n\n`zeta/itloc`  := (n::nonnegint) -> B -> [{},B];\n`xi/itloc`    := (n::nonnegint) -> A -> [A,{}];\n\n`sigma/itloc` := (n::nonnegint) -> AB -> AB[1] union AB[2];\n\n`alpha/itloc` := (n::nonnegint) -> (i) -> (AB) ->\n [select(a -> a < i,AB[1]), select(a -> a >= i,AB[1]) union AB[2]];\n\n`beta/itloc`  := (n::nonnegint) -> (i) -> (AB) ->\n [select(a -> a <= i,AB[1]), select(a -> a >= i,AB[1]) union AB[2]];\n\n`gamma/itloc` := (n::nonnegint) -> (i) -> (AB) ->\n [AB[1] union select(b -> b < i,AB[2]), select(b -> b >= i,AB[2])];\n\n`delta/itloc` := (n::nonnegint) -> (i) -> (AB) ->\n [AB[1] union select(b -> b <= i,AB[2]), select(b -> b >= i,AB[2])];\n\n######################################################################\n\n`is_element/itloc/L` := (n::nonnegint) -> proc(U)\n local N,AB,A,B,a,b,A1,B1,i,j;\n\n if not type(U,set(list(set(nonnegint)))) then\n  return false;\n fi;\n\n N := `list_elements/itloc/I`(n);\n \n for AB in U do\n  if not(`is_element/itloc/M`(n)(AB)) then\n   return false;\n  fi;\n od;\n \n for AB in U do\n  A,B = op(AB);\n  a := max(0,op(A));\n  b := min(n-1,op(B));\n  A1 := {seq(i,i=0..b)} minus A;\n  B1 := {seq(i,i=a..n-1)} minus B;\n  for i in A1 do\n   if not(member([A union {i},B]),U) then return false; fi;\n  od;\n  for j in B1 do\n   if not(member([A,B union {j}]),U) then return false; fi;\n  od;\n od;\n\n return true;\nend:\n\n`is_leq/itloc/L` := (n::nonnegint) -> (U,V) -> evalb (V minus U = {})\n\n`itloc/v` := (n::nonnegint) -> proc (AB::[set(nonnegint),set(nonnegint)])\n local a,b,A,A1,A2,A3,B,B1,L;\n\n A,B = op(AB);\n b := min(n-1,op(B));\n A1 := {seq(i,i=0..b)} minus A;\n\n L := NULL;\n for A2 in combinat[powerset](A1) do\n  A3 := A union A2;\n  a := max(0,op(A3));\n  B1 := {seq(j,j=a..n-1)} minus B;\n  L := L,seq([A3,B union B2],B2 in combinat[powerset](B1));\n od:\n return {L};\nend:\n\n\n", "meta": {"hexsha": "497f359565004cc7403aa9670ddb59750cc54341", "size": 4445, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/itloc.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/itloc.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/itloc.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.2896174863, "max_line_length": 73, "alphanum_fraction": 0.5007874016, "num_tokens": 1746, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7025300573952054, "lm_q2_score": 0.5851011542032312, "lm_q1q2_score": 0.4110511474443969}}
{"text": "input := FileTools:-Text:-ReadFile(\"AoC-2021-8-input.txt\" ):\n\nlines := subs(\"\"=NULL,(op@StringTools:-Split)~(StringTools:-Split(input, \"\\n\"),\"|\"));\n\n# part 1, just count the 1, 4, 7, and 8s\ntotal := 0:\nfor i from 2 to nops(lines) by 2 do\n    tal := table(sparse=0,Statistics:-Tally(map(length, StringTools:-Split(lines[i]))));\n    total := total + tal[2] + tal[3] + tal[4] + tal[7];\nend do:\n\nanswer1 := total;\n\n# part 2\n\nsortstring := s->StringTools:-Join( sort( StringTools:-Explode(s) ), \"\");\nlookups := [\"abcefg\"=\"0\", \"acdeg\"=\"2\", \"acdfg\"=\"3\", \"abdfg\"=\"5\", \"abdefg\"=\"6\", \"abcdfg\"=\"9\"];\nalphab := {seq(j,j in \"abcdefg\")};\n\nDecode := proc( code, output )\nlocal j, displays, cypher, i, decoded, w, wl, l, wc, n;\n\n    displays := sort( StringTools:-Split(StringTools:-Trim(code),\" \"), length );\n\n    cypher := table([seq(i={seq(j,j in \"abcdefg\")},i in \"abcdefg\")]):\n    decoded := table();\n\n    for w in displays do\n        wl := {seq(i, i in w)};\n        if length(w) = 2 and not assigned(decoded[\"1\"]) then # 1\n            decoded[\"1\"] := sortstring(w);\n            # may be\n            cypher[\"c\"] := cypher[\"c\"] intersect wl;\n            cypher[\"f\"] := cypher[\"f\"] intersect wl;\n            # can't be\n            for l in \"abdeg\" do\n                cypher[l] := cypher[l] minus wl;\n            end do;\n        elif length(w) = 3 and not assigned(decoded[\"7\"])then # 7\n            decoded[\"7\"] := sortstring(w);\n            cypher[\"c\"] := cypher[\"c\"] intersect {seq(i, i in w)};\n            cypher[\"f\"] := cypher[\"f\"] intersect {seq(i, i in w)};\n            cypher[\"a\"] := cypher[\"a\"] intersect {seq(i, i in w)};\n            if assigned(decoded[\"2\"]) then\n                cypher[\"a\"] := cypher[\"a\"] intersect {seq(i, i in w)} minus cypher[\"c\"];\n            end if;\n            if nops( cypher[\"a\"] ) = 1 then\n                for l in alphab minus {\"a\"} do\n                    cypher[l] := cypher[l] minus cypher[\"a\"];\n                end do;\n            end if;\n            for l in \"bdeg\" do\n                cypher[l] := cypher[l] minus wl;\n            end do;\n        elif length(w) = 4 and not assigned(decoded[\"4\"])then # 4\n            decoded[\"4\"] := sortstring(w);\n            cypher[\"b\"] := cypher[\"b\"] intersect {seq(i, i in w)};\n            cypher[\"d\"] := cypher[\"d\"] intersect {seq(i, i in w)};\n            cypher[\"c\"] := cypher[\"c\"] intersect {seq(i, i in w)};\n            cypher[\"f\"] := cypher[\"f\"] intersect {seq(i, i in w)};\n            for l in \"aeg\" do\n                cypher[l] := cypher[l] minus wl;\n            end do;\n        elif length(w) = 7 and not assigned(decoded[\"8\"]) then # 8\n            decoded[\"8\"] := sortstring(w);\n            cypher[\"b\"] := cypher[\"b\"] intersect {seq(i, i in w)};\n            cypher[\"d\"] := cypher[\"d\"] intersect {seq(i, i in w)};\n            cypher[\"c\"] := cypher[\"c\"] intersect {seq(i, i in w)};\n            cypher[\"f\"] := cypher[\"f\"] intersect {seq(i, i in w)};\n        elif length(w) = 6 then # 0, 6, 9 missing letters must be c,d,e\n            wc := alphab minus wl;\n            for l in \"abf\" do\n                cypher[l] := cypher[l] minus wc;\n            end do; \n        elif length(w) = 5 then # 2, 3, 5 missing letters must be b,c,e,f\n            wc := alphab minus wl;\n            for l in \"adg\" do\n                cypher[l] := cypher[l] minus wc;\n            end do; \n        end if;\n    end do:\n    \n    for l in alphab do\n        if nops(cypher[l]) = 1 then\n            for n in alphab minus {l} do\n                cypher[n] := cypher[n] minus cypher[l];\n            end do;\n        end if;\n    end do;\n\n    for l in alphab do\n        if nops(cypher[l]) <> 1 then\n            error \"need more!\";\n        end if;\n        cypher[l] := op(cypher[l]);\n    end do:\n\n    cypher := sort((rhs=lhs)~([entries(cypher,pairs)]));\n    decoded := sort((rhs=lhs)~([entries(decoded,pairs)]));\n\n    tmp := map(sortstring, StringTools:-Split(output,\" \"));\n    tmp := map2(subs, decoded, tmp);\n    tmp := (StringTools:-Join([seq]( subs(lookups, StringTools:-Join(sort( subs(cypher, convert(w,list)) ),\"\")), w in tmp), \"\") );\n\n    return parse(tmp);\n\nend proc:\n\nanswer2 := add( Decode(lines[i], lines[i+1]), i=1..nops(lines), 2);\n", "meta": {"hexsha": "c91be8bd5d84864450197bb2c483176f1be8fcd2", "size": 4179, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "Day8/AoC8-Maple.mpl", "max_stars_repo_name": "johnpmay/AdventOfCode2021", "max_stars_repo_head_hexsha": "b51756bcebea662333072cf518cf040a962ef8b7", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-12-04T18:24:03.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-04T18:24:03.000Z", "max_issues_repo_path": "Day8/AoC8-Maple.mpl", "max_issues_repo_name": "johnpmay/AdventOfCode2021", "max_issues_repo_head_hexsha": "b51756bcebea662333072cf518cf040a962ef8b7", "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": "Day8/AoC8-Maple.mpl", "max_forks_repo_name": "johnpmay/AdventOfCode2021", "max_forks_repo_head_hexsha": "b51756bcebea662333072cf518cf040a962ef8b7", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.9909090909, "max_line_length": 130, "alphanum_fraction": 0.498444604, "num_tokens": 1275, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7185943925708561, "lm_q2_score": 0.5698526514141571, "lm_q1q2_score": 0.40949291989784803}}
{"text": "apply_linear := proc(f,T := rational)\n return\n   proc(u)\n    local c,v;\n\n    if u = 0 then\n     return 0;\n    elif type(u,`+`) or type(u,list) or type(u,set) then\n     return map(apply_linear(f,T),u);\n    elif type(u,`*`) then\n     c,v := selectremove(type,u,T);\n     return c * f(v);\n    elif type(u,T) then\n     return u * f(1);\n    else\n     return f(u);\n    fi;\n   end:\nend:\n\napply_linear_mod := (f,m::posint) -> proc(u)\n local c,v;\n \n if u = 0 then\n  return 0;\n elif type(u,`+`) or type(u,list) or type(u,set) then\n  return modp(map(apply_linear(f),u),m);\n elif type(u,`*`) then\n  c,v := selectremove(type,u,integer);\n  c := modp(c,m);\n  if c = 0 then\n   return 0;\n  else \n   return modp(expand(c * f(v)),m);\n  fi;\n elif type(u,integer) then\n  return modp(u * f(1),m);\n else\n  return f(u);\n fi;\nend:\n\napply_list_linear := (f) -> proc(u)\n local c,v;\n \n if u = 0 then\n  return 0;\n elif type(u,`+`) or type(u,list) or type(u,set) then\n  return map(apply_list_linear(f),u);\n elif type(u,`*`) then\n  c,v := selectremove(type,u,rational);\n  return c * f(v);\n elif type(u,rational) then\n  return u * f(1);\n else\n  return f(u);\n fi;\nend:\n\napply_list_linear_mod := (f,m::posint) -> proc(u)\n local c,v;\n \n if u = 0 then\n  return 0;\n elif type(u,`+`) or type(u,list) or type(u,set) then\n  return modp(map(apply_list_linear(f),u),m);\n elif type(u,`*`) then\n  c,v := selectremove(type,u,integer);\n  c := modp(c,m);\n  if c = 0 then\n   return 0;\n  else \n   return modp(expand(c * f(v)),m);\n  fi;\n elif type(u,rational) then\n  return modp(u * f(1),m);\n else\n  return f(u);\n fi;\nend:\n\napply_bilinear := (f) -> proc(u,v)\n local cu,xu,cv,xv;\n\n if u = 0 or v = 0 then\n  return 0; \n elif type(u,`+`) then\n  return map(apply_bilinear(f),u,v);\n elif type(v,`+`) then\n  return map2(apply_bilinear(f),u,v);\n fi;\n\n if type(u,`*`) then\n  cu,xu := selectremove(type,u,rational);\n else\n  cu,xu := 1,u;\n fi;\n \n if type(v,`*`) then\n  cv,xv := selectremove(type,v,rational);\n else\n  cv,xv := 1,v;\n fi;\n\n return cu * cv * f(xu,xv);\nend:\n\napply_bilinear_mod := (f,m::posint) -> proc(u,v)\n local cu,xu,cv,xv,c;\n\n if u = 0 or v = 0 then\n  return 0; \n elif type(u,`+`) then\n  return modp(map(apply_bilinear(f),u,v),m);\n elif type(v,`+`) then\n  return modp(map2(apply_bilinear(f),u,v),m);\n fi;\n\n if type(u,`*`) then\n  cu,xu := selectremove(type,u,integer);\n else\n  cu,xu := 1,u;\n fi;\n \n if type(v,`*`) then\n  cv,xv := selectremove(type,v,integer);\n else\n  cv,xv := 1,v;\n fi;\n\n c := modp(cu * cv,m);\n if c = 0 then\n  return 0;\n else\n  return modp(expand(c * f(xu,xv)),m);\n fi;\nend:\n\napply_assoc := (f,e) -> proc()\n if nargs = 0 then\n  return e;\n elif nargs = 1 then\n  return args[1];\n elif args = 2 then\n  return f(args[1],args[2]);\n else\n  return f(args[1],apply_assoc(f,e)(args[2..-1]));\n fi;\nend:\n\napply_linear_assoc := (f,e) -> proc()\n if nargs = 0 then\n  return e;\n elif nargs = 1 then\n  return args[1];\n elif args = 2 then\n  return apply_bilinear(f)(args[1],args[2]);\n else\n  return apply_bilinear(f)(args[1],apply_linear_assoc(f,e)(args[2..-1]));\n fi;\nend:\n\napply_linear_assoc_mod := (f,e,m::posint) -> proc()\n if nargs = 0 then\n  return e;\n elif nargs = 1 then\n  return args[1];\n elif args = 2 then\n  return apply_bilinear_mod(f,m)(args[1],args[2]);\n else\n  return apply_bilinear_mod(f,m)(args[1],apply_linear_assoc_mod(f,e,m)(args[2..-1]));\n fi;\nend:\n\napply_deg := proc(f,deg_type := rational)\n return \n  proc(u)\n   local c,v,d,e,i,n;\n\n   if u = 0 then\n    return 0;\n   elif type(u,`+`) then\n    d := map(apply_deg(f),{op(u)});\n    if nops(d) = 1 then\n     return d[1];\n    else\n     return FAIL;\n    fi;\n   elif type(u,`*`) then\n    d := map(apply_deg(f),[op(u)]);\n    if type(d[1],deg_type) then\n     return `+`(op(d));\n    elif type(d[1],list) then\n     e := d[1];\n     for i from 2 to nops(d) do e := e +~ d[i]; od;\n     return e;\n    else\n     return FAIL;\n    fi;\n   elif type(u,`^`) and type(op(2,u),deg_type) then\n    d := apply_deg(f)(op(1,u));\n    n := op(2,u);\n    if type(d,deg_type) then\n     return n*d;\n    elif type(d,list) then\n     return n *~ d;\n    else\n     return FAIL;\n    fi;\n   else\n    return f(u);\n   fi;\n  end:\nend:\n\napply_max_deg := (f) -> proc(u)\n local c,v,d,e,i,n;\n \n if u = 0 then\n  return 0;\n elif type(u,`+`) then\n  return max(op(map(apply_max_deg(f),{op(u)})));\n elif type(u,`*`) then\n  d := map(apply_max_deg(f),[op(u)]);\n  if type(d[1],rational) then\n   return `+`(op(d));\n  elif type(d[1],list) then\n   e := d[1];\n   for i from 2 to nops(d) do e := e +~ d[i]; od;\n   return e;\n  else\n   return FAIL;\n  fi;\n elif type(u,`^`) and type(op(2,u),rational) then\n  d := apply_max_deg(f)(op(1,u));\n  n := op(2,u);\n  if type(d,rational) then\n   return n*d;\n  elif type(d,list) then\n   return n *~ d;\n  else\n   return FAIL;\n  fi;\n else\n  return f(u);\n fi;\nend:\n\napply_leibniz := (f) -> proc(u)\n local n,v,uu,i;\n \n if type(u,`+`) or type(u,list) or type(u,set) then\n  return map(apply_leibniz(f),u);\n elif type(u,`*`) then\n  uu := [op(u)];\n  return expand(add(`*`(op(subsop(i = apply_leibniz(f)(uu[i]),uu))),i=1..nops(uu)));\n elif type(u,`^`) then\n  v,n := op(u);\n  return n * v^(n-1) * apply_leibniz(f)(v);\n elif type(u,rational) then\n  return 0;\n else\n  return f(u);\n fi;\nend:\n\napply_leibniz_mod := (f,m::posint) -> proc(u)\n local n,v,uu,i;\n \n if type(u,`+`) or type(u,list) or type(u,set) then\n  return map(apply_leibniz(f),u);\n elif type(u,`*`) then\n  uu := [op(u)];\n  return modp(expand(add(`*`(op(subsop(i = apply_leibniz(f)(uu[i]),uu))),i=1..nops(uu))),m);\n elif type(u,`^`) then\n  v,n := op(u);\n  if modp(n,m) = 0 then\n   return 0;\n  else \n   return modp(expand(n * v^(n-1) * apply_leibniz(f)(v)),m);\n  fi;\n elif type(u,rational) then\n  return 0;\n else\n  return f(u);\n fi;\nend:\n", "meta": {"hexsha": "0e806d10c14f654e16eddd4e09a008220d8156e4", "size": 5689, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/apply.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/apply.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/apply.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 19.7534722222, "max_line_length": 92, "alphanum_fraction": 0.5783090174, "num_tokens": 2077, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7025300698514778, "lm_q2_score": 0.5774953651858118, "lm_q1q2_score": 0.40570785924289304}}
{"text": "`is_element/FFbar` := (N::posint) -> (A::set) -> proc(Q)\n local B,C,P,P1;\n global reason;\n\n P := {op(`list_elements/big_subsets`(A))};\n\n if not(is_table_on(P)(Q)) then\n  reason := [convert(procname,string),\"Q is not a table indexed by big subsets of A\",eval(Q)];  \n  return false;\n fi;\n\n for B in P do \n  if not(`is_element/SCP`(N)(B)(Q[B])) then\n   reason := [convert(procname,string),\"Q[B] is not in SCP(N)(B)\",eval(Q[B]),N,B,reason];  \n   return false;\n  fi;\n\n  P1 := {op(`list_elements/big_subsets`(B))} minus {B};\n\n  for C in P1 do\n   if not(`is_element/SCP2`(N)(B,C)([Q[B],Q[C]])) then\n    reason := [convert(procname,string),\"(Q[B],Q[C]) is not in SCP(N)(B,C)\",\n               eval(Q[B]),eval(Q[C]),N,B,C,reason];  \n    return false;\n   fi;\n  od;\n od;\n\n return true;\nend;\n\n######################################################################\n\n`is_equal/FFbar` := (N::posint) -> (A::set) -> proc(Q0,Q1)\n local B,P;\n global reason;\n\n P := `list_elements/big_subsets`(A);\n\n for B in P do \n  if not(`is_equal/SCP`(N)(B)(Q0[B],Q1[B])) then\n   reason := [convert(procname,string),\"Q0[B] <> Q1[B]\",B,Q0[B],Q1[B],reason];  \n   return false;\n  fi;\n od;\n\n return true;\nend;\n\n######################################################################\n\n`is_leq/FFbar` := (N) -> (A) -> proc(Q0,Q1)\n local B,P;\n global reason;\n\n P := `list_elements/big_subsets`(A);\n\n for B in P do \n  if not(`is_leq/SCP`(N)(B)(Q0[B],Q1[B])) then\n   reason := [convert(procname,string),\"Q0[B] is not <= Q1[B]\",B,Q0[B],Q1[B],reason];  \n   return false;\n  fi;\n od;\n\n return true;\n\nend;\n\n######################################################################\n\n`build/FFbar` := (N::posint) -> (A::set) -> proc(RTTu)\n local R,TT,i,j,k,n,m,ij,A0,C,TT1,TTS,TTc,T,Q,Q0,D,u,v,M,L,M0,M1,RT,BS,UU,U,a,b;\n R,TT,u := op(RTTu);\n n := nops(A);\n A0 := {seq(i,i=1..n)};\n C := children_map(A0)(TT);\n TT1 := select(T -> nops(T) > 1,TT);\n TTS := sort(map(T -> sort([op(T)]),[op(TT1)]));\n Q := table():\n for T in TTS do \n  D := sort([op(C[{op(T)}])],(U,V) -> (U[1] <= V[1]));\n  D := map(U -> sort([op(U)]),D);\n  m := nops(D);\n  v := [seq(u[max(D[i])],i=1..nops(D)-1)];\n  M := [seq(i,i=1..m)];\n  Q0 := `build/ICP`(N)({op(M)})([M,v]);\n  L := [];\n  for k from 1 to N do\n   M0 := Q0[k];\n   M1 := NULL;\n   for ij in M0 do\n    i,j := op(ij);\n    M1 := M1,seq(seq([R[a],R[b]],a in D[i]),b in D[j]);\n   od;\n   M1 := {M1};\n   L := [op(L),M1];\n  od;\n  RT := {seq(R[a],a in T)};\n  Q[RT] := L;\n od:\n TT1 := map(op,{indices(Q)});\n BS := {op(`list_elements/big_subsets`(A))};\n TTc := BS minus TT1;\n for T in TTc do\n  UU := select(U -> T minus U = {},TT1);\n  m := min(map(nops,UU));\n  UU := select(U -> nops(U) = m,UU);\n  U := UU[1];\n  Q[T] := `res/ICP`(N)(U,T)(Q[U]);\n od:\n return eval(Q);\nend:\n\n`unbuild/FFbar` := (N::posint) -> (A::set) -> proc(Q)\n local n,R,r,i,TT,TT0,u,a,b,UU,d,U,P,k;\n n := nops(A);\n R := `totalise/FFbar/ord`(N)(A)(Q);\n r := table():\n for i from 1 to n do r[R[i]] := i; od;\n TT := `critical_tree/FFbar`(N)(A)(Q);\n TT0 := map(U -> map(a -> r[a],U),TT);\n u := NULL;\n for i from 1 to n-1 do\n  a := R[i];\n  b := R[i+1];\n  UU := select(U -> member(a,U) and member(b,U),TT);\n  d := min(map(nops,UU));\n  UU := select(U -> nops(U) = d,UU);\n  U := UU[1];\n  P := Q[U];\n  k := 1;\n  while k < N and member([b,a],P[k]) do k := k+1; od;\n  u := u,k; \n od;\n u := [u];\n return [R,TT0,u];\nend:\n\n######################################################################\n\n`is_interior/FFbar` := (N::posint) -> (A::set) -> proc(Q)\n return `is_separated/SCP`(N)(A)(Q[N]);\nend;\n\n######################################################################\n\n`inc/ICP/FFbar` := (N::posint) -> (A::set) -> proc(Q0)\n local TT,T,Q;\n \n Q := table();\n TT := `list_elements/big_subsets`(A);\n for T in TT do\n  Q[T] := `res/ACP`(N)(A,T)(Q0);\n od;\n\n return eval(Q);\nend:\n\n######################################################################\n\n`res/FFbar/ICP` := (N::posint) -> (A::set) -> proc(Q)\n if not(`is_interior/FFbar`(N)(A)(Q)) then\n  return FAIL;\n fi;\n\n return Q[A];\nend;\n\n######################################################################\n# The functions below could be made much more efficient, but for\n# the moment we will stick with the most obvious approach.\n\n`is_critical/FFbar` := (N::posint) -> (A::set) -> proc(Q,U)\n local UU,a;\n\n UU := `top/autorel`(U);\n\n for a in A minus U do\n  if UU minus Q[U union {a}][N] <> {} then\n   return false;\n  fi;\n od;\n\n return true;\nend;\n\n##################################################\n\n`critical_tree/FFbar` := (N::posint) -> (A::set) -> proc(Q)\n select(U -> `is_critical/FFbar`(N)(A)(Q,U),\n        {op(`list_elements/nonempty_subsets`(A))});\nend;\n\n##################################################\n\n`rank/FFbar` := (N::posint) -> (A::set) -> proc(Q)\n local TT,TT1,T;\n\n TT := `critical_tree/FFbar`(N)(A)(Q);\n TT1 := select(T -> nops(T) > 1,TT);\n return add(`rank/ACP`(N)(T)(Q[T])-1,T in TT1);\nend;\n\n##################################################\n\n`totalise/FFbar/ord` := (N::posint) -> (A::set) -> proc(Q)\n local C,P,k;\n C := proc(a,b)\n  option remember;\n  if a = b then return true; fi;\n  P := Q[{a,b}];\n  for k from 1 to N do \n   if not(member([b,a],P[k])) then \n    return true;\n   fi;\n   if not(member([a,b],P[k])) then \n    return false;\n   fi;\n  od;\n  return true;\n end:\n return sort([op(A)],C);\nend:\n\n##################################################\n\n`random_element/FFbar` := (N::posint) -> (A::set) -> proc()\n local n,R,TT,u,i;\n \n n := nops(A);\n R := `random_element/ord`(A)();\n TT := `random_element/standard_stasheff_trees`(n)();\n u := [seq(rand(1..N)(),i=1..n-1)];\n return `build/FFbar`(N)(A)([R,TT,u]);\nend:\n\n`list_elements/FFbar` := (N::posint) -> proc(A::set)\n local n,RR,R,U,u,i,j,TTT,TT;\n \n n := nops(A);\n RR := `list_elements/ord`(A);\n U := [[]];\n for i from 1 to n-1 do\n  U := [seq(seq([op(u),j],j=1..N),u in U)];\n od;\n TTT := `list_elements/standard_stasheff_trees`(n);\n\n return([\n  seq(seq(seq(\n   `build/FFbar`(N)(A)([R,TT,u]),\n   u in U),TT in TTT),R in RR)\n ]);\nend:\n\n`count_elements/FFbar` := (N::posint) -> (A::set) ->\n nops(A)! * N^(nops(A)-1) *\n `count_elements/standard_stasheff_trees`(nops(A)); \n\n`list_ordered_elements/FFbar` := (N::posint) -> proc(A::{set,list})\n local n,A0,R,U,u,i,j,TTT,TT;\n \n n := nops(A);\n A0 := {op(A)};\n R := [op(A)];\n U := [[]];\n for i from 1 to n-1 do\n  U := [seq(seq([op(u),j],j=1..N),u in U)];\n od;\n TTT := `list_elements/standard_stasheff_trees`(n);\n\n return([\n  seq(seq(\n   `build/FFbar`(N)(A)([R,TT,u]),\n   u in U),TT in TTT)\n ]);\nend:\n\n`count_ordered_elements/FFbar` := (N::posint) -> (A::set) ->\n N^(nops(A)-1) *\n `count_elements/standard_stasheff_trees`(nops(A)); \n\n######################################################################\n\n`eta/FFbar` := (N::posint) -> (A::set) -> `if`(nops(A) = 1,table(),FAIL);\n\n######################################################################\n\n`gamma/FFbar` := (N::posint) -> (A::set,B::set) -> (p) -> proc(Q,P) \n local R,TT,T,U,M,i;\n\n R := table();\n TT := `list_elements/big_subsets`(A);\n \n for T in TT do\n  U := map(a -> p[a],T);\n  if nops(U) > 1 then\n   M := Q[U];\n   R[T] := [seq(select(u -> member([p[u[1]],p[u[2]]],M[i]),`top/autorel`(T)),i=1..N)];\n  else \n   R[T] := eval(P[op(U)][T]);\n  fi;\n od;\n\n return eval(R);\nend;\n\n######################################################################\n\n`mu/Fbar/FFbar` := (N::posint) -> (A::set) -> proc(x)\n local Q,TT,T;\n \n Q := table();\n\n TT := `list_elements/big_subsets`(A);\n for T in TT do\n  Q[T] := `mu/W/ACP`(N)(T)(x[T]);\n od;\n\n return eval(Q);\nend;\n\n######################################################################\n\n`sigma/Fbar/FFbar` := (N::posint) -> (A::set) -> proc(Q)\n local x,TT,T;\n \n x := table();\n\n TT := `list_elements/big_subsets`(A);\n for T in TT do\n  x[T] := `sigma/ACP/W`(N)(T)(Q[T]);\n od;\n\n return eval(x);\nend;\n\n######################################################################\n\n`describe/FFbar` := (N::posint) -> (A::set) -> proc(Q)\n local TT,TT1,T,s;\n TT := `critical_tree/FFbar`(N)(A)(Q);\n TT1 := select(T -> nops(T) > 1,TT);\n TT1 := sort([op(TT1)],(U,V) -> nops(U) >= nops(V));\n s := \"\";\n for T in TT1 do\n  if s <> \"\" then s := cat(s,\"\\n\"); fi;\n  s := cat(s,`describe/ACP`(N)(T)(Q[T]));\n od:\n return s;\nend:", "meta": {"hexsha": "782d2ae117ad4c099f855bc9ea5440d5c0b66295", "size": 8183, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/operads/chains/FFbar.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/operads/chains/FFbar.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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/operads/chains/FFbar.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "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.38, "max_line_length": 96, "alphanum_fraction": 0.4638885494, "num_tokens": 2823, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6548947425132315, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.40281780276121015}}