{"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 := 120:\n\ninterface(quiet=true):\n\nread \"common-procedures.mpl\":\nread \"triple-double.mpl\":\n\nmkdir(\"TEMPPOW\"):\n\n# Some constants for special cases tests \n\ntwo52 := 2^(52):\ntwo53 := 2^(53):\ntwoM53 := 2^(-53):\ntwoM54 := 2^(-54):\ntwoM1021 := 2^(-1021):\ntwo1021 := 2^(1021):\ntwoM1000 := 2^(-1000):\ntwo1000 := 2^(1000):\ntwo999 := 2^(999):\ntwo11 := 2^(11):\ntwo64 := 2^(64):\ntwoM64 := 2^(-64):\n\nscale := 2^(12):\nrescale := 2^(-12):\nshiftConst := 2^(52) + 2^(51):\n\nlargest := 2^(1023) * ((2^(53) - 1) / 2^(52)):\nsmallest := 2^(-1023) * 1 * 2^(-51):\n\n# Logarithm log2_12 for power\n\nL := 7: # number of bits used to address the table\n\nMAXINDEX    := round(2^L * (sqrt(2)-1)):\n\nfor i from 0 to MAXINDEX-1 do\n    center[i] := 1 + i*2^(-L): # center[i] in [1, 2[\n    t :=  evalf(1/center[i]):\n    r[i] := round(t * 2**(floor(-log[2](abs(t))) + 23)) / 2**(floor(-log[2](abs(t))) + 23):\n    (logih[i], logil[i], logill[i]) := hi_mi_lo(evalf(-log[2](r[i]))):\nod:\nfor i from MAXINDEX to 2^L do\n    # y has been divided by two, center[i] in [0.5, 1[\n    center[i]:=(1 + i*2^(-L)) / 2:\n    t :=  evalf(1/center[i]):\n    r[i] := round(t * 2**(floor(-log[2](abs(t))) + 23)) / 2**(floor(-log[2](abs(t))) + 23):\n    (logih[i], logil[i], logill[i]) := hi_mi_lo(evalf(-log[2](r[i]))):\nod:\n\n\n\n\n#Computation of ZMax.\nfor i from 0 to MAXINDEX-1 do\n    __x := center[i] + 2^(-L-1) :\n    zmax[i] := (__x*r[i]-1) :\n    __x := center[i] - 2^(-L-1) :\n    zmin[i] := (__x*r[i]-1) :\nod:\nfor i from MAXINDEX to 2^L do\n    __x := center[i] + 2^(-L-2) :\n    zmax[i] := (__x*r[i]-1) :\n    __x := center[i] - 2^(-L-2) :\n    zmin[i] := (__x*r[i]-1) :\nod:\n\nzmaxmax:=0:\nzminmin:=0:\nfor i from 0 to 2^L do\n    if zmax[i] > zmaxmax then zmaxmax := zmax[i]: fi:\n    if zmin[i] < zminmin then zminmin := zmin[i]: fi:\nod:\nprintf(\"zminmin = -2^(%2f)   zmaxmax = 2^(%2f)\\n\", log2(-zminmin), log2(zmaxmax) ):\n\npLogExact := unapply(-6497523352912697/36028797018963968*X^8+464105351149111/2251799813685248*X^7-4331547231022885/18014398509481984*X^6+324866042375467/1125899906842624*X^5-6497320848556805/18014398509481984*X^4+8460053188225/17592186044416*X^3-58522663504933901518104329421789/81129638414606681695789005144064*X^2+29261331752466950759073917813481/20282409603651670423947251286016*X,X):\n\npLog := poly_exact2(pLogExact(x),3):\n\nepsLog := numapprox[infnorm](pLog/log[2](1+x)-1,x=zminmin..zmaxmax):\n\nprintf(\"Relative error of pLog w.r.t log2(1+x) is 2^(%f)\\n\",log[2](abs(epsLog))):\n\n\n# Exponential exp2_12 for power \n\n\nfor i from 0 to 2^6 - 1 do\n\ttwoPowerIndex1hi[i], twoPowerIndex1lo[i], twoPowerIndex1lolo[i] := hi_mi_lo(evalf(2^(i/(2^6)))):\n\ttwoPowerIndex2hi[i], twoPowerIndex2lo[i], twoPowerIndex2lolo[i] := hi_mi_lo(evalf(2^(i/(2^(12))))):\nod: \n\npExpExact := unapply(2772236920359585/288230376151711744*X^4+1999746284130149/36028797018963968*X^3+8655072057804175/36028797018963968*X^2+6243314768165359/9007199254740992*X+1,X):\n\npExp := poly_exact(pExpExact(x)):\n\nepsExp := numapprox[infnorm]((pExp/2^x)-1,x=-2^(-12)..2^(-12)):\n\nprintf(\"Relative error of pExp w.r.t 2^x is 2^(%f)\\n\",log[2](abs(epsExp))):\n\nlog2 := nearest(log(2)):\n\n\n# Exponential exp2_33 for power\n\n# Polynomial for approximating 2^x - 1 in x=-2^(-42)..2^(-42)\n\npExpXM := unapply(poly_exact2(x * ((6243314768165359 * 2^(-53) + 29397410857115 * 2^(-100)) + (x * 8655072057804175 * 2^(-55))),2),x):\n\nepsExpXM := numapprox[infnorm](pExpXM(x)/(2^x-1)-1,x=-2^(-42)..2^(-42)):\n\nprintf(\"The relative error of pExpXM w.r.t. 2^x - 1 is 2^(%f)\\n\",log[2](abs(epsExpXM))):\n\n\n# Polynomial for approximating 2^x - 1 in x=-2^(-95)..2^(-95)\n\npExpXL := unapply(poly_exact(x * 6243314768165359 * 2^(-53)), x):\n\nepsExpXL := numapprox[infnorm](pExpXL(x)/(2^x-1)-1,x=-2^(-95)..2^(-95)):\n\nprintf(\"The relative error of pExpXL w.r.t. 2^x - 1 is 2^(%f)\\n\",log[2](abs(epsExpXL))):\n\n# Polynomial for approximating 2^x in x=-2^(-12)..2^(-12)\n\npExpXH := unapply(poly_exact32(x * (506517869649829535567849302923399275789356375957 * 2^(-159) + (x * (38978979294391673005692521213079 * 2^(-107) + (x * (36024226132016099441525232746301 * 2^(-109) + (x * (3121261346907607936312652866425 * 2^(-108) + (x * (55385433661433492776134419224183 * 2^(-115) + (x * (5682899659966205 * 2^(-65) + (x * (4501812434047971 * 2^(-68) + (x * 6240991224781291 * 2^(-72))))))))))))))),2,4),x):\n\nepsExpXH := numapprox[infnorm](pExpXH(x)/(2^x-1)-1,x=-2^(-12)..2^(-12)):\n\nprintf(\"The relative error of pExpXH w.r.t. 2^x - 1 is 2^(%f)\\n\",log[2](abs(epsExpXH))):\n\n\n# Logarithm log2_13 for power\n\npLog13 := unapply(poly_exact32(x * (65890661388387311068680317907364672336343222485 * 2^(-155) + (x * ((-263562645553549244274721271629458689351564598207 * 2^(-158)) + (x * (39015109003289267678766993386435 * 2^(-106) + (x * ((-29261331752466950759075245039823 * 2^(-106)) + (x * (11704532700986780303630098000775 * 2^(-105) + (x * ((-78030218006578535357533995772145 * 2^(-108)) + (x * (66883044005638744592219245028355 * 2^(-108) + (x * ((-14630665876233475378839909031845 * 2^(-106)) + (x * (721924538728533 * 2^(-52) + (x * ((-324866042427843 * 2^(-51)) + (x * (4725324253587977 * 2^(-55) + (x * ((-8663094456247059 * 2^(-56)) + (x * (7996693900181249 * 2^(-56) + (x * ((-7425880934468497 * 2^(-56)) + (x * 7091529758988931 * 2^(-56))))))))))))))))))))))))))))),3,6),x):\n\nepsLog13 := numapprox[infnorm](pLog13(x)/(log[2](1+x))-1,x=-2^(-8)..2^(-8)):\n\nprintf(\"The relative error of pLog13 w.r.t. log2(1+x) is 2^(%f)\\n\",log[2](abs(epsLog13))):\n\n\n# exp2_30bits for exactness test \n\ncoeff_0 :=  9.99999999947486895024439945700578391551971435546875000000000000000000000000000000e-01:\ncoeff_1 :=  6.93147180274189311788290979166049510240554809570312500000000000000000000000000000e-01:\ncoeff_2 :=  2.40226513201275415632096610352164134383201599121093750000000000000000000000000000e-01:\ncoeff_3 :=  5.55041194035996443556513213479775004088878631591796875000000000000000000000000000e-02:\ncoeff_4 :=  9.61801251055323207228564541537707555107772350311279296875000000000000000000000000e-03:\ncoeff_5 :=  1.33325640280455024258565721595459763193503022193908691406250000000000000000000000e-03:\ncoeff_6 :=  1.54736006782907911617439000728779774362919852137565612792968750000000000000000000e-04:\ncoeff_7 :=  1.55294506644329091183710789270122631933190859854221343994140625000000000000000000e-05:\n\npExp2Exact := unapply(coeff_0 + X * (coeff_1 + X * (coeff_2 + X * (coeff_3 + X * (coeff_4 + X * (coeff_5 + X * (coeff_6 + X * coeff_7)))))),X):\n\npExp2 := poly_exact(pExp2Exact(x)):\n\nepsExp2 := numapprox[infnorm]((pExp2/2^x)-1,x=-0.5..0.5):\n\nprintf(\"Relative error of pExp2 w.r.t 2^x is 2^(%f)\\n\",log[2](abs(epsExp2))):\n\n# Overall accuracy estimate\n\n# C'est pifometrique\nepsOverall := 2^(-62):\n\nbi := floor(-log[2](abs(epsOverall))):\napproxBoundFactor := 2^(-(bi - 54)):\n\nepsOverallAccurate := 2^(-120):\n\nbi2 := floor(-log[2](abs(epsOverallAccurate))) - 1:\napproxBoundFactorAccurate := 2^(-(bi2 - 54)):\n\n\n# Print out of the .h file \n\nfilename:=\"TEMPPOW/pow.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/pow.mpl*/\\n\"):\n\nfprintf(fd, \"\\#define APPROXBOUNDFACTOR %1.50e\\n\", approxBoundFactor):   \nfprintf(fd, \"\\#define APPROXBOUNDFACTORACCURATE %1.50e\\n\", approxBoundFactorAccurate):   \nfprintf(fd, \"\\#define TWO52 %1.50e\\n\", two52):   \nfprintf(fd, \"\\#define TWO53 %1.50e\\n\", two53):   \nfprintf(fd, \"\\#define TWO11 %1.50e\\n\", two11):   \nfprintf(fd, \"\\#define TWOM53 %1.50e\\n\", twoM53):   \nfprintf(fd, \"\\#define TWOM54 %1.50e\\n\", twoM54):   \nfprintf(fd, \"\\#define TWOM1021 %1.50e\\n\", twoM1021):   \nfprintf(fd, \"\\#define TWO1021 %1.50e\\n\", two1021):   \nfprintf(fd, \"\\#define TWOM1000 %1.50e\\n\", twoM1000):   \nfprintf(fd, \"\\#define TWO999 %1.50e\\n\", two999):   \nfprintf(fd, \"\\#define TWO1000 %1.50e\\n\\n\", two1000):   \nfprintf(fd, \"\\#define TWO64 %1.50e\\n\", two64):   \nfprintf(fd, \"\\#define TWOM64 %1.50e\\n\", twoM64):   \nfprintf(fd, \"\\#define SCALE %1.50e\\n\", scale):   \nfprintf(fd, \"\\#define RESCALE %1.50e\\n\", rescale):   \nfprintf(fd, \"\\#define SHIFTCONSTANT %1.50e\\n\", shiftConst):   \nfprintf(fd, \"\\#define LARGEST %1.50e\\n\",largest):\nfprintf(fd, \"\\#define SMALLEST %1.50e\\n\\n\",smallest):\n\n\n(log2coeff1dh,log2coeff1dl) := hi_lo(coeff(pLog,x,1)):\n(log2coeff2dh,log2coeff2dl) := hi_lo(coeff(pLog,x,2)):\nfprintf(fd, \"\\#define log2coeff1h %1.50e\\n\",log2coeff1dh):\t\nfprintf(fd, \"\\#define log2coeff1l %1.50e\\n\",log2coeff1dl):\t\nfprintf(fd, \"\\#define log2coeff2h %1.50e\\n\",log2coeff2dh):\t\nfprintf(fd, \"\\#define log2coeff2l %1.50e\\n\",log2coeff2dl):\t\nfor i from 3 to 8 do\n\tfprintf(fd, \"\\#define log2coeff%d %1.50e\\n\",i,coeff(pLog,x,i)):\nod:\nfprintf(fd,\"\\n\"):\n\nfor i from 1 to 4 do\n\tfprintf(fd, \"\\#define exp2coeff%d %1.50e\\n\",i,coeff(pExp,x,i)):\nod:\nfprintf(fd,\"\\n\"):\n\nfor i from 0 to 7 do \n\tfprintf(fd, \"\\#define exp2InaccuCoeff%d %1.50e\\n\",i,coeff(pExp2,x,i)):\nod:\nfprintf(fd,\"\\n\"):\n\n(exp2XMcoeff1dh, exp2XMcoeff1dl) := hi_lo(coeff(pExpXM(x),x,1)):\nexp2XMcoeff2dh := nearest(coeff(pExpXM(x),x,2)):\nfprintf(fd, \"\\#define exp2XMcoeff1h %1.50e\\n\",exp2XMcoeff1dh):\t\nfprintf(fd, \"\\#define exp2XMcoeff1l %1.50e\\n\",exp2XMcoeff1dl):\t\nfprintf(fd, \"\\#define exp2XMcoeff2h %1.50e\\n\\n\",exp2XMcoeff2dh):\t\n\nexp2XLcoeff1dh := nearest(coeff(pExpXL(x),x,1)):\nfprintf(fd, \"\\#define exp2XLcoeff1h %1.50e\\n\\n\",exp2XLcoeff1dh):\t\n\n(exp2XHcoeff1dh,exp2XHcoeff1dm,exp2XHcoeff1dl) := hi_mi_lo(coeff(pExpXH(x),x,1)):\nfprintf(fd, \"\\#define exp2XHcoeff1h %1.50e\\n\",exp2XHcoeff1dh):\t\nfprintf(fd, \"\\#define exp2XHcoeff1m %1.50e\\n\",exp2XHcoeff1dm):\t\nfprintf(fd, \"\\#define exp2XHcoeff1l %1.50e\\n\",exp2XHcoeff1dl):\t\n\nfor i from 2 to 5 do\n\t(exp2XHcoeffidh,exp2XHcoeffidl) := hi_lo(coeff(pExpXH(x),x,i)):\n\tfprintf(fd, \"\\#define exp2XHcoeff%dh %1.50e\\n\",i,exp2XHcoeffidh):\t\n\tfprintf(fd, \"\\#define exp2XHcoeff%dm %1.50e\\n\",i,exp2XHcoeffidl):\t\nod:\n\nfor i from 6 to 8 do \n\tfprintf(fd, \"\\#define exp2XHcoeff%dh %1.50e\\n\",i,nearest(coeff(pExpXH(x),x,i))):\t\t\nod:\n\nfprintf(fd,\"\\n\"):\n\n(log213coeff1dh,log213coeff1dm,log213coeff1dl) := hi_mi_lo(coeff(pLog13(x),x,1)):\nfprintf(fd, \"\\#define log213coeff1h %1.50e\\n\",log213coeff1dh):\t\nfprintf(fd, \"\\#define log213coeff1m %1.50e\\n\",log213coeff1dm):\t\nfprintf(fd, \"\\#define log213coeff1l %1.50e\\n\",log213coeff1dl):\t\n\n(log213coeff2dh,log213coeff2dm,log213coeff2dl) := hi_mi_lo(coeff(pLog13(x),x,2)):\nfprintf(fd, \"\\#define log213coeff2h %1.50e\\n\",log213coeff2dh):\t\nfprintf(fd, \"\\#define log213coeff2m %1.50e\\n\",log213coeff2dm):\t\nfprintf(fd, \"\\#define log213coeff2l %1.50e\\n\",log213coeff2dl):\t\n\nfor i from 3 to 8 do\n\t(log213coeffidh, log213coeffidl) := hi_lo(coeff(pLog13(x),x,i)):\n\tfprintf(fd, \"\\#define log213coeff%dh %1.50e\\n\",i,log213coeffidh):\t\n\tfprintf(fd, \"\\#define log213coeff%dm %1.50e\\n\",i,log213coeffidl):\t\nod:\n\nfor i from 9 to 15 do \n\tfprintf(fd, \"\\#define log213coeff%dh %1.50e\\n\",i,nearest(coeff(pLog13(x),x,i))):\t\t\nod:\n\n\nfprintf(fd, \"\\n\\#define LOG2 %1.50e\\n\\n\", log2):   \n\nfprintf(fd, \"typedef struct rri_tag {float ri; double logih; double logil; double logill;} rri;  \\n\"):\nfprintf(fd, \"static const rri argredtable[%d] = {\\n\", 2^L):\nfor i from 0 to 2^L-1 do\n      fprintf(fd, \"  { \\n\"):\n      fprintf(fd, \"    %1.50e,   /* r[%d] */ \\n\", r[i], i):\n      fprintf(fd, \"    %1.50e, /* logih[%d] */ \\n\", logih[i], i):\n      fprintf(fd, \"    %1.50e, /* logil[%d] */ \\n\", logil[i], i):\n      fprintf(fd, \"    %1.50e, /* logill[%d] */ \\n\", logill[i], i):\n      fprintf(fd, \"  } \"):\n      if(i<2^L-1) then  fprintf(fd, \", \\n\"): fi\nod:\nfprintf(fd, \"}; \\n \\n\"):\n\nfprintf(fd, \"typedef struct tPi_t_tag {double hi; double lo; double lolo;} tPi_t;  \\n\"):\nfprintf(fd, \"static const tPi_t twoPowerIndex1[%d] = {\\n\", 2^(6)):\nfor i from 0 to 2^(6)-1 do\n      fprintf(fd, \"  { \\n\"):      \n      fprintf(fd, \"    %1.50e, /* twoPowerIndex1hi[%d] */ \\n\", twoPowerIndex1hi[i], i):\n      fprintf(fd, \"    %1.50e, /* twoPowerIndex1lo[%d] */ \\n\", twoPowerIndex1lo[i], i):\n      fprintf(fd, \"    %1.50e, /* twoPowerIndex1lolo[%d] */ \\n\", twoPowerIndex1lolo[i], i):\n      fprintf(fd, \"  } \"):\n      if(i<2^(6)-1) then  fprintf(fd, \", \\n\"): fi\nod:\nfprintf(fd, \"}; \\n \\n\"):\nfprintf(fd, \"static const tPi_t twoPowerIndex2[%d] = {\\n\", 2^(6)):\nfor i from 0 to 2^(6)-1 do\n      fprintf(fd, \"  { \\n\"):      \n      fprintf(fd, \"    %1.50e, /* twoPowerIndex2hi[%d] */ \\n\", twoPowerIndex2hi[i], i):\n      fprintf(fd, \"    %1.50e, /* twoPowerIndex2lo[%d] */ \\n\", twoPowerIndex2lo[i], i):\n      fprintf(fd, \"    %1.50e, /* twoPowerIndex2lolo[%d] */ \\n\", twoPowerIndex2lolo[i], i):\n      fprintf(fd, \"  } \"):\n      if(i<2^(6)-1) then  fprintf(fd, \", \\n\"): fi\nod:\nfprintf(fd, \"}; \\n \\n\"):\n\n\n\n\n\nfclose(fd):\n\nprintf(\"--------- DONE -----------\\n\");", "meta": {"hexsha": "31d274451df833b686460a4b2f4af8480115bedc", "size": 12761, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "crlibm/maple/pow.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/pow.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/pow.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": 39.753894081, "max_line_length": 774, "alphanum_fraction": 0.6447770551, "num_tokens": 5158, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031738057795402, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.4999430299843809}}
{"text": "# generators corresponding to the invariants for E8\ngam[3] := (1/2)*c(3);\ngam[4] := (1/3)*(c(4)+2*t[0]^4);\ngam[5] := (1/2)*(c(5)-3*t[0]*gam[4]+2*t[0]^2*gam[3]);\ngam[6] := (1/5)*(c(6)-2*gam[3]^2-t[0]*gam[5]+t[0]^2*gam[4]-2*t[0]^6);\ngam[9] := (1/2)*(2*c(6)*gam[3]+t[0]*c(8)+t[0]^2*c(7)-3*t[0]^3*c(6));\ngam[10] := (1/3)*(gam[5]^2-2*c(7)*gam[3]-t[0]^2*c(8)+3*t[0]^3*c(7));\ngam[15] := (1/2)*((c(8)-t[0]^2*c(6)+2*t[0]^3*gam[5]+3*t[0]^4*gam[4]-t[0]^8)*(c(7)-3*t[0]*c(6))-2*(gam[3]^2+c(6))*(gam[9]-c(6)*gam[3])):\n\n# degree 2\n    t[1] := -w[1]+w[2];\n    t[2] := w[1]+w[2]-w[3];\n    t[3] := w[2]+w[3]-w[4];\n    t[4] := w[4]-w[5];\n    t[5] := w[5]-w[6];\n    t[6] := w[6]-w[7];\n    t[7] := w[7]-w[8];\n    t[8] := w[8];\n    t[0] := w[2];\n\n# Schubert class generators for E8\n# X[[5,4,2]]\n    x[3] := gam[3]-t[0]^3;\n# X[[6,5,4,2]]\n    x[4] := gam[4]-t[0]^4;\n# X[[7,6,5,4,2]]\n    x[5] := gam[5];\n# X[[1,3,6,5,4,2]]\n\tx[6] := gam[6]-t[0]*gam[5]+t[0]^2*gam[4];\n# X[[1,5,4,3,7,6,5,4,2]]\n    x[9] := gam[9]-2*gam[3]^3-4*gam[3]*gam[6]-gam[4]*gam[5]-6*t[0]*gam[4]^2+5*t[0]*c(8)-4*t[0]^2*c(7)-2*t[0]^3*gam[3]^2+14*t[0]^3*gam[6]-5*t[0]^4*gam[5]-10*t[0]^5*gam[4]+10*t[0]^6*gam[3]+4*t[0]*gam[3]*gam[5]+14*t[0]^2*gam[3]*gam[4];\n# X[[1,6,5,4,3,7,6,5,4,2]]\n    x[10] := -gam[10]+gam[5]^2+2*t[0]^10-2*gam[3]^2*gam[4]-4*gam[4]*gam[6]+2*t[0]^2*gam[4]^2+2*t[0]^4*gam[3]^2+4*t[0]^4*gam[6]-4*t[0]^6*gam[4];\n# X[[1,3,4,2,7,6,5,4,3,8,7,6,5,4,2]]\n \tx[15] := 382*gam[3]*t[0]^12+241*gam[4]*t[0]^11+18*gam[3]^2*t[0]^9+4*gam[5]*t[0]^10-685*gam[3]*gam[4]*t[0]^8+gam[6]*t[0]^9+198*gam[3]*gam[5]*t[0]^7+22*t[0]^8*c(7)+604*gam[3]^2*gam[4]*t[0]^5+1094*gam[3]*gam[6]*t[0]^6+133*gam[4]*gam[5]*t[0]^6+3*t[0]^7*c(8)+130*gam[3]^2*gam[5]*t[0]^4+117*gam[3]*gam[4]^2*t[0]^4-194*gam[3]*t[0]^5*c(7)+513*gam[4]*gam[6]*t[0]^5+gam[9]*t[0]^6-795*gam[3]^3*gam[4]*t[0]^2-674*gam[3]^2*gam[6]*t[0]^3-83*gam[3]*gam[4]*gam[5]*t[0]^3+26*gam[3]*t[0]^4*c(8)+31*gam[4]*t[0]^4*c(7)+139*gam[5]*gam[6]*t[0]^4+gam[3]^5-181*gam[3]^3*gam[5]*t[0]+276*gam[3]^2*gam[4]^2*t[0]+190*gam[3]^2*t[0]^2*c(7)-945*gam[3]*gam[4]*gam[6]*t[0]^2+134*gam[3]*gam[9]*t[0]^3-6*gam[4]^2*gam[5]*t[0]^2-123*gam[4]*t[0]^3*c(8)-31*gam[5]*t[0]^3*c(7)+3*gam[6]^2*t[0]^3-gam[3]^3*gam[6]+4*gam[3]^2*gam[4]*gam[5]-258*gam[3]^2*t[0]*c(8)+32*gam[3]*gam[4]*t[0]*c(7)-96*gam[3]*gam[5]*gam[6]*t[0]+48*gam[3]*gam[10]*t[0]^2+165*gam[4]^2*gam[6]*t[0]+93*gam[4]*gam[9]*t[0]^2+11*gam[5]*t[0]^2*c(8)+107*gam[6]*t[0]^2*c(7)+5*gam[3]^2*gam[9]-29*gam[3]*gam[4]*c(8)-12*gam[3]*gam[5]*c(7)+6*gam[3]*gam[6]^2-6*gam[5]*gam[9]*t[0]-167*gam[6]*t[0]*c(8)+gam[5]*gam[10]+16*gam[6]*gam[9]+gam[15]:\n\n\n# relations\n# rational relations\nrho[2] := c[2] -4*t[0]^2;\nrho[8] := -3*c[8]+3*G[4]^2-2*G[3]*G[5]+t[0]*(2*c[7]-6*G[3]*G[4])+t[0]^2*(2*G[3]^2-5*G[6])+3*t[0]^3*G[5]+4*t[0]^4*G[4]-6*t[0]^5*G[3]+t[0]^8:\nrho[12] := 15*G[6]^2+2*G[3]*G[4]*G[5]-2*c[7]*G[5]+2*G[3]^4+10*G[3]^2*G[6]-3*c[8]*G[4]-2*G[4]^3+t[0]*(c[8]*G[3]-2*G[3]^2*G[5]+4*c[7]*G[4]+6*G[3]*G[4]^2)+t[0]^2*(3*G[10]-25*G[4]*G[6]-c[7]*G[3]-16*G[3]^2*G[4])+t[0]^3*(25*G[3]*G[6]-3*G[4]*G[5]+10*G[3]^3)+t[0]^4*(3*c[8]+3*G[3]*G[5]+5*G[4]^2)+t[0]^5*(-3*c[7]-5*G[3]*G[4])+4*t[0]^6*G[3]^2-7*t[0]^8*G[4]+4*t[0]^9*G[3];\nrho[14] := c[7]^2-3*c[8]*G[6]+6*G[4]*G[10]-4*c[8]*G[3]^2+6*c[7]*G[3]*G[4]-6*G[3]^2*G[4]^2-12*G[4]^2*G[6]-2*G[3]*G[5]*G[6]+t[0]*(24*G[3]*G[4]*G[6]-8*c[7]*G[3]^2-8*c[7]*G[6]+4*c[8]*G[5]-6*G[3]*G[10]+12*G[3]^3*G[4])+t[0]^2*(-2*G[3]*G[4]*G[5]+6*G[4]^3+2*G[3]^2*G[6]+20*G[6]^2-4*G[3]^4-c[7]*G[5])+t[0]^3*(-12*G[3]*G[4]^2+8*c[8]*G[3]-5*c[7]*G[4]+3*G[5]*G[6])+t[0]^4*(3*G[10]-26*G[4]*G[6]+6*c[7]*G[3]-4*G[3]^2*G[4])+t[0]^5*(24*G[3]*G[6]+3*G[4]*G[5]+12*G[3]^3)+t[0]^6*(-6*c[8]+2*G[4]^2)-4*t[0]^7*c[7]+t[0]^8*(6*G[6]-6*G[3]^2)-6*t[0]^10*G[4]+12*t[0]^11*G[3]-2*t[0]^14;\nrho[18] := 4*G[3]^6-10*G[6]^3-9*c[7]*c[8]*G[3]-2*G[3]^3*G[4]*G[5]+2*c[7]*G[3]^2*G[5]+2*c[7]*G[5]*G[6]+c[8]*G[3]^2*G[4]+3*c[8]*G[4]*G[6]-6*c[7]*G[3]*G[4]^2+2*G[3]*G[5]*G[10]-10*G[3]*G[6]*G[9]+10*t[0]^18-2*G[3]*G[4]*G[5]*G[6]+G[9]^2+6*t[0]^13*G[5]+t[0]^12*(60*G[6]+18*G[3]^2)+t[0]^11*(3*c[7]+27*G[3]*G[4])+t[0]^10*(-4*c[8]-6*G[4]^2-13*G[3]*G[5])+t[0]^9*(6*G[9]-42*G[3]^3-99*G[3]*G[6])-12*t[0]^15*G[3]-9*t[0]^14*G[4]-9*c[8]*G[10]-6*G[4]^2*G[10]-4*G[3]^3*G[9]+6*G[3]^2*G[4]^3+12*G[4]^3*G[6]+2*c[7]^2*G[4]+t[0]^2*(24*G[3]^4*G[4]-2*c[8]^2-c[7]*G[9]-11*G[3]^2*G[10]+2*G[3]*G[4]*G[9]-2*c[8]*G[3]*G[5]+16*c[7]*G[3]*G[6]-3*c[7]*G[4]*G[5]+75*G[4]*G[6]^2-6*G[4]^4-9*c[8]*G[4]^2+81*G[3]^2*G[4]*G[6]-13*G[6]*G[10]+4*G[3]*G[4]^2*G[5]-c[7]*G[3]^3)+t[0]*(-2*G[3]*G[5]*G[9]-24*c[7]*G[4]*G[6]+8*c[8]*G[4]*G[5]+4*c[7]*G[3]^2*G[4]+4*c[7]*G[10]-c[8]*G[9]+2*c[7]^2*G[3]+4*c[8]*G[3]*G[6]+12*G[3]*G[4]*G[10]-36*G[3]*G[4]^2*G[6]+12*G[3]^2*G[5]*G[6]+c[8]*G[3]^3+6*G[3]^4*G[5]-18*G[3]^3*G[4]^2)+15*G[3]^2*G[6]^2+18*G[3]^4*G[6]+t[0]^3*(-3*G[5]*G[10]-150*G[3]*G[6]^2-135*G[3]^3*G[6]+6*G[3]^2*G[9]-2*c[7]*G[3]*G[5]+21*c[7]*G[4]^2+15*c[7]*c[8]+3*G[4]*G[5]*G[6]-3*G[3]^2*G[4]*G[5]+18*G[3]*G[4]^3+15*G[6]*G[9]+14*c[8]*G[3]*G[4]-30*G[3]^5)+t[0]^4*(-13*c[8]*G[6]+2*G[4]*G[10]-5*c[7]^2-33*G[3]^2*G[4]^2+3*G[5]*G[9]-28*G[3]*G[5]*G[6]-45*G[4]^2*G[6]-41*c[7]*G[3]*G[4]-13*G[3]^3*G[5]-9*c[8]*G[3]^2)+t[0]^5*(3*c[7]*G[6]-6*G[4]^2*G[5]+23*c[7]*G[3]^2+105*G[3]*G[4]*G[6]-6*c[8]*G[5]-3*G[4]*G[9]+45*G[3]^3*G[4])+t[0]^6*(11*G[4]^3-4*G[3]*G[9]+4*c[7]*G[5]+9*G[3]*G[4]*G[5]+12*G[3]^4+66*G[3]^2*G[6]+75*G[6]^2+2*c[8]*G[4])+t[0]^7*(-33*G[3]*G[4]^2+12*G[3]^2*G[5]+15*G[5]*G[6])+t[0]^8*(-4*G[10]+21*G[3]^2*G[4]-5*c[7]*G[3]-3*G[4]*G[6]);\nrho[20] := 9*u[1]^20+45*u[1]^14*u[6]+12*u[1]^10*u[10]+60*u[1]^8*u[6]^2+30*u[1]^4*u[6]*u[10]+10*u[1]^2*u[6]^3+3*u[10]^2;\nrho[24] := 11*u[1]^24+60*u[1]^18*u[6]+21*u[1]^14*u[10]+105*u[1]^12*u[6]^2+60*u[1]^8*u[6]*u[10]+60*u[1]^6*u[6]^3+9*u[1]^4*u[10]^2+30*u[1]^2*u[6]^2*u[10]+5*u[6]^4;\nrho[30] := -9*u[15]^2-12*u[1]^9*u[6]*u[15]-6*u[1]^5*u[10]*u[15]+9*u[1]^14*u[6]*u[10]-10*u[1]^12*u[6]^3-3*u[1]^10*u[10]^2+30*u[1]^8*u[6]^2*u[10]-35*u[1]^6*u[6]^4+6*u[1]^4*u[6]*u[10]^2-10*u[1]^2*u[6]^3*u[10]-4*u[6]^5-2*u[10]^3;\n\n# mod prime relations\nrho[3] := c[3] - 2*G[3];\nrho[4] := c[4]+2*t[0]^4 - 3*G[4];\nrho[5] := c[5]-t[0]*c[4]+t[0]^2*c[3]-2*t[0]^5 - 2*G[5];\nrho[6] := (c[6]-2*G[3]^2-t[0]*G[5]+t[0]^2*G[4]-2*t[0]^6) - 5*G[6];\nrho[9] := c[6]*c[3]+t[0]*c[8]+t[0]^2*c[7]-3*t[0]^3*c[6] -2*G[9];\nrho[10] := G[5]^2-2*c[7]*G[3]-t[0]^2*c[8]+3*t[0]^3*c[7] - 3*G[10];\nrho[15]:=((c[8]-t[0]^2*c[6]+2*t[0]^3*G[5]+3*t[0]^4*G[4]-t[0]^8)*(c[7]-3*t[0]*c[6])-2*(G[3]^2+c[6])*(G[9]-c[6]*G[3])) - 2*G[15];\n\n\n# auxiliary variables\naux :=\nu[15] = -t^14*u[1]-12*t^15+131*t^4*u[1]^11+(-17*t^8+t^6*u[1]^2+11*t^5*u[1]^3+14*t^4*u[1]^4-4*t^2*u[1]^6+118*t*u[1]^7+3*u[1]^8)*G[3]*G[4]-6*G[3]^5-233*t^2*u[1]^13+(-2*t^12+6*t^11*u[1]+2*t^10*u[1]^2-20*t^9*u[1]^3+11*t^8*u[1]^4+22*t^7*u[1]^5-8*t^6*u[1]^6+83*t^5*u[1]^7+15*t^4*u[1]^8+5*t^3*u[1]^9-116*t^2*u[1]^10+t*u[1]^11+117*u[1]^12)*G[3]+175*t*u[1]^14-13*t^10*u[1]^5+9*t^8*u[1]^7-t^7*u[1]^8+3*u[1]*G[4]*G[10]-u[1]*G[5]*G[9]-58*u[1]^15+(-3*t+2*u[1])*G[3]^3*G[5]-3*u[1]*G[3]^2*G[4]^2-20*G[3]*G[6]^2+3*G[3]^2*G[9]-23*G[3]^3*G[6]+4*G[6]*G[9]+(-6*t^3-2*t^2*u[1]-6*t*u[1]^2+5*u[1]^3)*G[3]^4+(3*t^2*u[1]+u[1]^3)*G[4]^3+G[15]-6*u[1]*G[4]^2*G[6]+(t^2+t*u[1]-u[1]^2)*c[7]*G[3]^2+(-t^2-u[1]^2)*G[4]*G[9]+(5*t^2+6*t*u[1]+2*u[1]^2)*G[3]^3*G[4]+(3*t^2+4*t*u[1]+u[1]^2)*c[7]*G[6]-u[1]^3*G[3]*G[9]+(-2*t^4-4*t^3*u[1]-3*t*u[1]^3+3*u[1]^4)*c[7]*G[4]+(2*t^2*u[1]+3*t*u[1]^2)*c[7]*G[5]+(-33*t^3+t^2*u[1]-31*t*u[1]^2+13*u[1]^3)*G[3]^2*G[6]+(t^3-2*t^2*u[1]+t*u[1]^2-u[1]^3)*G[3]*G[4]*G[5]+6*t^12*u[1]^3+(-45*t^3+10*t^2*u[1]-40*t*u[1]^2)*G[6]^2+3*u[1]*c[7]*G[3]*G[4]+(-4*t+4*u[1])*G[3]*G[5]*G[6]+(9*t^2+12*t*u[1]+5*u[1]^2)*G[3]*G[4]*G[6]+(-9*t^4-6*t^3*u[1]-18*t^2*u[1]^2+5*t*u[1]^3-3*u[1]^4)*G[5]*G[6]+(-3*t^4-3*t^3*u[1]-7*t^2*u[1]^2+5*t*u[1]^3-4*u[1]^4)*G[3]^2*G[5]+(-t^4-6*t^3*u[1]-t^2*u[1]^2-3*t*u[1]^3)*G[3]*G[4]^2+(-3*t^4*u[1]-6*t^3*u[1]^2+3*t^2*u[1]^3+15*t*u[1]^4)*G[10]+(-3*t^4*u[1]+t^3*u[1]^2+5*t^2*u[1]^3+10*t*u[1]^4-u[1]^5)*c[7]*G[3]+(39*t^5-13*t^4*u[1]+8*t^3*u[1]^2+35*t^2*u[1]^3-31*t*u[1]^4-3*u[1]^5)*G[4]*G[6]+(15*t^5-2*t^4*u[1]+3*t^3*u[1]^2+14*t^2*u[1]^3-16*t*u[1]^4+3*u[1]^5)*G[3]^2*G[4]+(t^6-t^4*u[1]^2-t^3*u[1]^3-t^2*u[1]^4-t*u[1]^5-u[1]^6)*G[9]+(-13*t^6+12*t^5*u[1]+5*t^4*u[1]^2-56*t^3*u[1]^3+8*t^2*u[1]^4+21*t*u[1]^5+2*u[1]^6)*G[3]*G[6]+(6*t^6+3*t^5*u[1]+2*t^4*u[1]^2+7*t^3*u[1]^3+t^2*u[1]^4-8*t*u[1]^5+3*u[1]^6)*G[4]*G[5]+(-8*t^6+6*t^5*u[1]+2*t^4*u[1]^2-22*t^3*u[1]^3+6*t^2*u[1]^4+8*t*u[1]^5-2*u[1]^6)*G[3]^3+(-6*t^7+t^6*u[1]-7*t^4*u[1]^3+5*t^3*u[1]^4+3*t^2*u[1]^5+3*t*u[1]^6-63*u[1]^7)*G[4]^2+(-t^7+2*t^6*u[1]+t^5*u[1]^2-11*t^4*u[1]^3+6*t^3*u[1]^4+5*t^2*u[1]^5+6*t*u[1]^6+39*u[1]^7)*G[3]*G[5]-118*t^6*u[1]^9+(2*t^8+6*t^7*u[1]+3*t^6*u[1]^2-4*t^5*u[1]^3-15*t^4*u[1]^4+6*t^3*u[1]^5+3*t^2*u[1]^6-40*t*u[1]^7+59*u[1]^8)*c[7]-18*t^5*u[1]^10-6*t^3*u[1]^12+(-48*t^9+3*t^8*u[1]-41*t^7*u[1]^2+18*t^6*u[1]^3+16*t^5*u[1]^4-13*t^4*u[1]^5-67*t^3*u[1]^6+125*t^2*u[1]^7-15*t*u[1]^8-291*u[1]^9)*G[6]+(-18*t^9-3*t^8*u[1]-16*t^7*u[1]^2+10*t^6*u[1]^3-4*t^5*u[1]^4-8*t^4*u[1]^5-16*t^3*u[1]^6-23*t^2*u[1]^7-10*t*u[1]^8-115*u[1]^9)*G[3]^2+(-6*t^10-3*t^9*u[1]-9*t^8*u[1]^2+5*t^7*u[1]^3-5*t^6*u[1]^4-14*t^4*u[1]^6-52*t^3*u[1]^7+6*t^2*u[1]^8-60*t*u[1]^9+117*u[1]^10)*G[5]+(18*t^11-3*t^10*u[1]+5*t^9*u[1]^2+11*t^8*u[1]^3-28*t^7*u[1]^4+8*t^6*u[1]^5+20*t^5*u[1]^6-64*t^4*u[1]^7-15*t^3*u[1]^8+54*t^2*u[1]^9+178*t*u[1]^10-177*u[1]^11)*G[4]-31*t^9*u[1]^6+7*t^11*u[1]^4-10*t^13*u[1]^2,\nu[10] = G[10]+u[1]*G[9]-u[1]^3*c[7]-u[1]*G[4]*G[5]+2*u[1]^2*G[4]^2-2*u[1]^2*G[3]*G[5]+G[3]*G[4]*(-6*t*u[1]^2+2*u[1]^3)+G[3]^2*(2*t^2*u[1]^2+2*t*u[1]^3-2*u[1]^4)+G[6]*(-5*t^2*u[1]^2+5*t*u[1]^3)+G[5]*(t^4*u[1]+3*t^3*u[1]^2+t^2*u[1]^3)+G[4]*(6*t^4*u[1]^2-3*t^3*u[1]^3-2*t^2*u[1]^4-t*u[1]^5+u[1]^6)+G[3]*(-6*t^5*u[1]^2-2*t^4*u[1]^3+4*t^3*u[1]^4+6*t^2*u[1]^5-4*t*u[1]^6+u[1]^7)+4*t^7*u[1]^3-6*t^5*u[1]^5+2*t^4*u[1]^6+t^3*u[1]^7-t^2*u[1]^8,\nu[6] = 2*G[6]+G[3]^2-u[1]*G[5]+G[4]*(-t^2+u[1]^2)-u[1]^3*G[3]+t^6-t^4*u[1]^2+t^3*u[1]^3+t^2*u[1]^4-t*u[1]^5,\nu[1] = t[8],\nt = w[2];\n#\nrho[20] := subs(aux, rho[20]);\nrho[24] := subs(aux, rho[24]);\nrho[30] := subs(aux, rho[30]);\n", "meta": {"hexsha": "4a11529e94e1b1c3ddb3e18c2e0d75f6752f72d8", "size": 9891, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "E8gen.mpl", "max_stars_repo_name": "shizuo-kaji/Maple-flag-cohomology", "max_stars_repo_head_hexsha": "c4e1669cfd228e182a44d291d6b0ffe0f670a8af", "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": "E8gen.mpl", "max_issues_repo_name": "shizuo-kaji/Maple-flag-cohomology", "max_issues_repo_head_hexsha": "c4e1669cfd228e182a44d291d6b0ffe0f670a8af", "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": "E8gen.mpl", "max_forks_repo_name": "shizuo-kaji/Maple-flag-cohomology", "max_forks_repo_head_hexsha": "c4e1669cfd228e182a44d291d6b0ffe0f670a8af", "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": 141.3, "max_line_length": 2849, "alphanum_fraction": 0.4562733798, "num_tokens": 6967, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.926303728259492, "lm_q2_score": 0.5389832206876841, "lm_q1q2_score": 0.4992621667923104}}
{"text": "$ifndef _UTILS_\n$define _UTILS_\n\ntpop:=proc(t,k)\n\tlocal r;\n\tr:=t[k][1];\n\tt[k]:=t[k] minus {r};\n\treturn r;\nend proc:\n\n# 表达式按照复杂度升序排序\nsortByComplexity:=proc(_s::list,{index::boolean:=false})\n    local s,t,i,n;\n    if index then\n        s:=_s;\n        t:=table();\n        n:=numelems(s);\n        for i from 1 to n do\n            tappend(t,s[i],i);\n        end do;\n        s:=ListTools[Reverse](SolveTools[SortByComplexity](s));\n        return map[2](tpop,t,s);\n    else\n        return ListTools[Reverse](SolveTools[SortByComplexity](_s));\n    end if;\nend proc:\n\n# 按照集合拓展table键值 \ntappend:=proc(t,k,v)\n    if assigned(t[k]) then\n        t[k]:=t[k] union {v};\n    else\n        t[k]:={v};\n    end if;\nend proc:\n\n# 对象按键值分类\n# 推荐对键做convert/global处理，以消除局部变量相等的问题。\ncollectObj:=proc(s,key,{output:=[val]::{[ind],[val],[ind,val]}})\n    local t,v,res;\n    t:=table();\n    for v in s do\n        tappend(t,key(v),v);\n    end do;\n    res:=();\n    if (ind in output) then\n        res:=res,[indices(t,nolist)];\n    end if;\n    if (val in output) then\n        res:=res,[entries(t,nolist)];\n    end if;\n    return res;\nend proc:\n\n# 对象按键值唯一化\n# 推荐对键做convert/global处理，以消除局部变量相等的问题\nuniqueObj:=proc(s,key,{index::boolean:=false})\n    local t,i,n;\n    t:=table();\n    n:=numelems(s);\n    for i from 1 to n do\n        t[key(s[i])]:=`if`(index,i,s[i]);\n    end do;\n    return [entries(t,nolist)];\nend proc:\n\n# 选择目标函数值最小的元素\nMinSelect:=proc(v::list,fun)\n    return v[min[index]([seq(fun(x),x in v)])];\nend proc:\n\n# 寻找特定值的下标\nfind:=proc(v::list,k)\n    return map(i->`if`(v[i]=k,i,NULL),[seq(1..numelems(v))]);\nend proc:\n\n$endif", "meta": {"hexsha": "6f504bf3afebebe498214e35c05c83b98c8039e9", "size": 1593, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "InvClassify/Utils.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/Utils.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/Utils.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": 20.6883116883, "max_line_length": 68, "alphanum_fraction": 0.5706214689, "num_tokens": 590, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6261241772283034, "lm_q2_score": 0.7905303186696747, "lm_q1q2_score": 0.4949701453510786}}
{"text": "Q := [b*c+a, a*c-b, b*c-2*c^2+a-2, b*c-c^2+a-1, b*c+c^2+a+1, b*c+2*c^2+a+2, 2*\nb*c-c^2+2*a-1, 2*b*c+c^2+2*a+1, a*c-2*c^2-b-2, a*c-c^2-b-1, a*c+c^2-b+1, a*c+2\n*c^2-b+2, 2*a*c-c^2-2*b-1, 2*a*c+c^2-2*b+1, a*c-2*b*c-2*a-b, a*c-b*c-a-b, a*c+\nb*c+a-b, a*c+2*b*c+2*a-b, 2*a*c-b*c-a-2*b, 2*a*c+b*c+a-2*b, a^2+b^2-3*c^2-3, a\n^2+b^2-c^2-1, 3*a^2+3*b^2-c^2-1, a^2+b^2-2*b*c-2*a, a^2+b^2-b*c-a, a^2+b^2+b*c\n+a, a^2+b^2+2*b*c+2*a, 2*a^2+2*b^2-b*c-a, 2*a^2+2*b^2+b*c+a, a^2-2*a*c+b^2+2*b\n, a^2-a*c+b^2+b, a^2+a*c+b^2-b, a^2+2*a*c+b^2-2*b, 2*a^2-a*c+2*b^2+b, 2*a^2+a*\nc+2*b^2-b, a*c-2*b*c-2*c^2-2*a-b-2, a*c-2*b*c-c^2-2*a-b-1, a*c-2*b*c+c^2-2*a-b\n+1, a*c-2*b*c+2*c^2-2*a-b+2, a*c-b*c-2*c^2-a-b-2, a*c-b*c-c^2-a-b-1, a*c-b*c+c\n^2-a-b+1, a*c-b*c+2*c^2-a-b+2, a*c+b*c-2*c^2+a-b-2, a*c+b*c-c^2+a-b-1, a*c+b*c\n+c^2+a-b+1, a*c+b*c+2*c^2+a-b+2, a*c+2*b*c-2*c^2+2*a-b-2, a*c+2*b*c-c^2+2*a-b-\\\n1, a*c+2*b*c+c^2+2*a-b+1, a*c+2*b*c+2*c^2+2*a-b+2, 2*a*c-2*b*c-c^2-2*a-2*b-1,\n2*a*c-2*b*c+c^2-2*a-2*b+1, 2*a*c-b*c-2*c^2-a-2*b-2, 2*a*c-b*c-c^2-a-2*b-1, 2*a\n*c-b*c+c^2-a-2*b+1, 2*a*c-b*c+2*c^2-a-2*b+2, 2*a*c+b*c-2*c^2+a-2*b-2, 2*a*c+b*\nc-c^2+a-2*b-1, 2*a*c+b*c+c^2+a-2*b+1, 2*a*c+b*c+2*c^2+a-2*b+2, 2*a*c+2*b*c-c^2\n+2*a-2*b-1, 2*a*c+2*b*c+c^2+2*a-2*b+1, a^2+b^2-4*b*c-3*c^2-4*a-3, a^2+b^2-4*b*\nc-c^2-4*a-1, a^2+b^2-4*b*c+c^2-4*a+1, a^2+b^2-4*b*c+3*c^2-4*a+3, a^2+b^2-2*b*c\n-3*c^2-2*a-3, a^2+b^2-2*b*c-c^2-2*a-1, a^2+b^2-b*c-c^2-a-1, a^2+b^2+b*c-c^2+a-\\\n1, a^2+b^2+2*b*c-3*c^2+2*a-3, a^2+b^2+2*b*c-c^2+2*a-1, a^2+b^2+4*b*c-3*c^2+4*a\n-3, a^2+b^2+4*b*c-c^2+4*a-1, a^2+b^2+4*b*c+c^2+4*a+1, a^2+b^2+4*b*c+3*c^2+4*a+\n3, 3*a^2+3*b^2-4*b*c-c^2-4*a-1, 3*a^2+3*b^2-4*b*c+c^2-4*a+1, 3*a^2+3*b^2-2*b*c\n-c^2-2*a-1, 3*a^2+3*b^2+2*b*c-c^2+2*a-1, 3*a^2+3*b^2+4*b*c-c^2+4*a-1, 3*a^2+3*\nb^2+4*b*c+c^2+4*a+1, a^2-4*a*c+b^2-3*c^2+4*b-3, a^2-4*a*c+b^2-c^2+4*b-1, a^2-4\n*a*c+b^2+c^2+4*b+1, a^2-4*a*c+b^2+3*c^2+4*b+3, a^2-2*a*c+b^2-3*c^2+2*b-3, a^2-\\\n2*a*c+b^2-c^2+2*b-1, a^2-a*c+b^2-c^2+b-1, a^2+a*c+b^2-c^2-b-1, a^2+2*a*c+b^2-3\n*c^2-2*b-3, a^2+2*a*c+b^2-c^2-2*b-1, a^2+4*a*c+b^2-3*c^2-4*b-3, a^2+4*a*c+b^2-\nc^2-4*b-1, a^2+4*a*c+b^2+c^2-4*b+1, a^2+4*a*c+b^2+3*c^2-4*b+3, 3*a^2-4*a*c+3*b\n^2-c^2+4*b-1, 3*a^2-4*a*c+3*b^2+c^2+4*b+1, 3*a^2-2*a*c+3*b^2-c^2+2*b-1, 3*a^2+\n2*a*c+3*b^2-c^2-2*b-1, 3*a^2+4*a*c+3*b^2-c^2-4*b-1, 3*a^2+4*a*c+3*b^2+c^2-4*b+\n1, a^2-2*a*c+b^2-2*b*c-2*a+2*b, a^2-2*a*c+b^2-b*c-a+2*b, a^2-2*a*c+b^2+b*c+a+2\n*b, a^2-2*a*c+b^2+2*b*c+2*a+2*b, a^2-a*c+b^2-2*b*c-2*a+b, a^2-a*c+b^2-b*c-a+b,\na^2-a*c+b^2+b*c+a+b, a^2-a*c+b^2+2*b*c+2*a+b, a^2+a*c+b^2-2*b*c-2*a-b, a^2+a*c\n+b^2-b*c-a-b, a^2+a*c+b^2+b*c+a-b, a^2+a*c+b^2+2*b*c+2*a-b, a^2+2*a*c+b^2-2*b*\nc-2*a-2*b, a^2+2*a*c+b^2-b*c-a-2*b, a^2+2*a*c+b^2+b*c+a-2*b, a^2+2*a*c+b^2+2*b\n*c+2*a-2*b, 2*a^2-2*a*c+2*b^2-b*c-a+2*b, 2*a^2-2*a*c+2*b^2+b*c+a+2*b, 2*a^2-a*\nc+2*b^2-2*b*c-2*a+b, 2*a^2-a*c+2*b^2-b*c-a+b, 2*a^2-a*c+2*b^2+b*c+a+b, 2*a^2-a\n*c+2*b^2+2*b*c+2*a+b, 2*a^2+a*c+2*b^2-2*b*c-2*a-b, 2*a^2+a*c+2*b^2-b*c-a-b, 2*\na^2+a*c+2*b^2+b*c+a-b, 2*a^2+a*c+2*b^2+2*b*c+2*a-b, 2*a^2+2*a*c+2*b^2-b*c-a-2*\nb, 2*a^2+2*a*c+2*b^2+b*c+a-2*b, a^2-4*a*c+b^2-4*b*c-3*c^2-4*a+4*b-3, a^2-4*a*c\n+b^2-4*b*c-c^2-4*a+4*b-1, a^2-4*a*c+b^2-4*b*c+c^2-4*a+4*b+1, a^2-4*a*c+b^2-4*b\n*c+3*c^2-4*a+4*b+3, a^2-4*a*c+b^2-4*b*c+5*c^2-4*a+4*b+5, a^2-4*a*c+b^2-2*b*c-3\n*c^2-2*a+4*b-3, a^2-4*a*c+b^2-2*b*c-c^2-2*a+4*b-1, a^2-4*a*c+b^2-2*b*c+c^2-2*a\n+4*b+1, a^2-4*a*c+b^2-2*b*c+3*c^2-2*a+4*b+3, a^2-4*a*c+b^2+2*b*c-3*c^2+2*a+4*b\n-3, a^2-4*a*c+b^2+2*b*c-c^2+2*a+4*b-1, a^2-4*a*c+b^2+2*b*c+c^2+2*a+4*b+1, a^2-\\\n4*a*c+b^2+2*b*c+3*c^2+2*a+4*b+3, a^2-4*a*c+b^2+4*b*c-3*c^2+4*a+4*b-3, a^2-4*a*\nc+b^2+4*b*c-c^2+4*a+4*b-1, a^2-4*a*c+b^2+4*b*c+c^2+4*a+4*b+1, a^2-4*a*c+b^2+4*\nb*c+3*c^2+4*a+4*b+3, a^2-4*a*c+b^2+4*b*c+5*c^2+4*a+4*b+5, a^2-2*a*c+b^2-4*b*c-\\\n3*c^2-4*a+2*b-3, a^2-2*a*c+b^2-4*b*c-c^2-4*a+2*b-1, a^2-2*a*c+b^2-4*b*c+c^2-4*\na+2*b+1, a^2-2*a*c+b^2-4*b*c+3*c^2-4*a+2*b+3, a^2-2*a*c+b^2-2*b*c-3*c^2-2*a+2*\nb-3, a^2-2*a*c+b^2-2*b*c-c^2-2*a+2*b-1, a^2-2*a*c+b^2-2*b*c+c^2-2*a+2*b+1, a^2\n-2*a*c+b^2-b*c-c^2-a+2*b-1, a^2-2*a*c+b^2-b*c+c^2-a+2*b+1, a^2-2*a*c+b^2+b*c-c\n^2+a+2*b-1, a^2-2*a*c+b^2+b*c+c^2+a+2*b+1, a^2-2*a*c+b^2+2*b*c-3*c^2+2*a+2*b-3\n, a^2-2*a*c+b^2+2*b*c-c^2+2*a+2*b-1, a^2-2*a*c+b^2+2*b*c+c^2+2*a+2*b+1, a^2-2*\na*c+b^2+4*b*c-3*c^2+4*a+2*b-3, a^2-2*a*c+b^2+4*b*c-c^2+4*a+2*b-1, a^2-2*a*c+b^\n2+4*b*c+c^2+4*a+2*b+1, a^2-2*a*c+b^2+4*b*c+3*c^2+4*a+2*b+3, a^2-a*c+b^2-2*b*c-\nc^2-2*a+b-1, a^2-a*c+b^2-2*b*c+c^2-2*a+b+1, a^2-a*c+b^2-b*c-c^2-a+b-1, a^2-a*c\n+b^2+b*c-c^2+a+b-1, a^2-a*c+b^2+2*b*c-c^2+2*a+b-1, a^2-a*c+b^2+2*b*c+c^2+2*a+b\n+1, a^2+a*c+b^2-2*b*c-c^2-2*a-b-1, a^2+a*c+b^2-2*b*c+c^2-2*a-b+1, a^2+a*c+b^2-\nb*c-c^2-a-b-1, a^2+a*c+b^2+b*c-c^2+a-b-1, a^2+a*c+b^2+2*b*c-c^2+2*a-b-1, a^2+a\n*c+b^2+2*b*c+c^2+2*a-b+1, a^2+2*a*c+b^2-4*b*c-3*c^2-4*a-2*b-3, a^2+2*a*c+b^2-4\n*b*c-c^2-4*a-2*b-1, a^2+2*a*c+b^2-4*b*c+c^2-4*a-2*b+1, a^2+2*a*c+b^2-4*b*c+3*c\n^2-4*a-2*b+3, a^2+2*a*c+b^2-2*b*c-3*c^2-2*a-2*b-3, a^2+2*a*c+b^2-2*b*c-c^2-2*a\n-2*b-1, a^2+2*a*c+b^2-2*b*c+c^2-2*a-2*b+1, a^2+2*a*c+b^2-b*c-c^2-a-2*b-1, a^2+\n2*a*c+b^2-b*c+c^2-a-2*b+1, a^2+2*a*c+b^2+b*c-c^2+a-2*b-1, a^2+2*a*c+b^2+b*c+c^\n2+a-2*b+1, a^2+2*a*c+b^2+2*b*c-3*c^2+2*a-2*b-3, a^2+2*a*c+b^2+2*b*c-c^2+2*a-2*\nb-1, a^2+2*a*c+b^2+2*b*c+c^2+2*a-2*b+1, a^2+2*a*c+b^2+4*b*c-3*c^2+4*a-2*b-3, a\n^2+2*a*c+b^2+4*b*c-c^2+4*a-2*b-1, a^2+2*a*c+b^2+4*b*c+c^2+4*a-2*b+1, a^2+2*a*c\n+b^2+4*b*c+3*c^2+4*a-2*b+3, a^2+4*a*c+b^2-4*b*c-3*c^2-4*a-4*b-3, a^2+4*a*c+b^2\n-4*b*c-c^2-4*a-4*b-1, a^2+4*a*c+b^2-4*b*c+c^2-4*a-4*b+1, a^2+4*a*c+b^2-4*b*c+3\n*c^2-4*a-4*b+3, a^2+4*a*c+b^2-4*b*c+5*c^2-4*a-4*b+5, a^2+4*a*c+b^2-2*b*c-3*c^2\n-2*a-4*b-3, a^2+4*a*c+b^2-2*b*c-c^2-2*a-4*b-1, a^2+4*a*c+b^2-2*b*c+c^2-2*a-4*b\n+1, a^2+4*a*c+b^2-2*b*c+3*c^2-2*a-4*b+3, a^2+4*a*c+b^2+2*b*c-3*c^2+2*a-4*b-3,\na^2+4*a*c+b^2+2*b*c-c^2+2*a-4*b-1, a^2+4*a*c+b^2+2*b*c+c^2+2*a-4*b+1, a^2+4*a*\nc+b^2+2*b*c+3*c^2+2*a-4*b+3, a^2+4*a*c+b^2+4*b*c-3*c^2+4*a-4*b-3, a^2+4*a*c+b^\n2+4*b*c-c^2+4*a-4*b-1, a^2+4*a*c+b^2+4*b*c+c^2+4*a-4*b+1, a^2+4*a*c+b^2+4*b*c+\n3*c^2+4*a-4*b+3, a^2+4*a*c+b^2+4*b*c+5*c^2+4*a-4*b+5, 3*a^2-4*a*c+3*b^2-4*b*c-\nc^2-4*a+4*b-1, 3*a^2-4*a*c+3*b^2-4*b*c+c^2-4*a+4*b+1, 3*a^2-4*a*c+3*b^2-2*b*c-\nc^2-2*a+4*b-1, 3*a^2-4*a*c+3*b^2-2*b*c+c^2-2*a+4*b+1, 3*a^2-4*a*c+3*b^2+2*b*c-\nc^2+2*a+4*b-1, 3*a^2-4*a*c+3*b^2+2*b*c+c^2+2*a+4*b+1, 3*a^2-4*a*c+3*b^2+4*b*c-\nc^2+4*a+4*b-1, 3*a^2-4*a*c+3*b^2+4*b*c+c^2+4*a+4*b+1, 3*a^2-2*a*c+3*b^2-4*b*c-\nc^2-4*a+2*b-1, 3*a^2-2*a*c+3*b^2-4*b*c+c^2-4*a+2*b+1, 3*a^2-2*a*c+3*b^2-2*b*c-\nc^2-2*a+2*b-1, 3*a^2-2*a*c+3*b^2+2*b*c-c^2+2*a+2*b-1, 3*a^2-2*a*c+3*b^2+4*b*c-\nc^2+4*a+2*b-1, 3*a^2-2*a*c+3*b^2+4*b*c+c^2+4*a+2*b+1, 3*a^2+2*a*c+3*b^2-4*b*c-\nc^2-4*a-2*b-1, 3*a^2+2*a*c+3*b^2-4*b*c+c^2-4*a-2*b+1, 3*a^2+2*a*c+3*b^2-2*b*c-\nc^2-2*a-2*b-1, 3*a^2+2*a*c+3*b^2+2*b*c-c^2+2*a-2*b-1, 3*a^2+2*a*c+3*b^2+4*b*c-\nc^2+4*a-2*b-1, 3*a^2+2*a*c+3*b^2+4*b*c+c^2+4*a-2*b+1, 3*a^2+4*a*c+3*b^2-4*b*c-\nc^2-4*a-4*b-1, 3*a^2+4*a*c+3*b^2-4*b*c+c^2-4*a-4*b+1, 3*a^2+4*a*c+3*b^2-2*b*c-\nc^2-2*a-4*b-1, 3*a^2+4*a*c+3*b^2-2*b*c+c^2-2*a-4*b+1, 3*a^2+4*a*c+3*b^2+2*b*c-\nc^2+2*a-4*b-1, 3*a^2+4*a*c+3*b^2+2*b*c+c^2+2*a-4*b+1, 3*a^2+4*a*c+3*b^2+4*b*c-\nc^2+4*a-4*b-1, 3*a^2+4*a*c+3*b^2+4*b*c+c^2+4*a-4*b+1, 5*a^2-4*a*c+5*b^2-4*b*c+\nc^2-4*a+4*b+1, 5*a^2-4*a*c+5*b^2+4*b*c+c^2+4*a+4*b+1, 5*a^2+4*a*c+5*b^2-4*b*c+\nc^2-4*a-4*b+1, 5*a^2+4*a*c+5*b^2+4*b*c+c^2+4*a-4*b+1, -b*c+a, a*b+c, -2*b^2-b*\nc+a-2, -b^2-2*b*c+2*a-1, -b^2-b*c+a-1, b^2-2*b*c+2*a+1, b^2-b*c+a+1, 2*b^2-b*c\n+a+2, a*b-2*b*c+2*a+c, a*b-b*c+a+c, a*b+b*c-a+c, a*b+2*b*c-2*a+c, 2*a*b-b*c+a+\n2*c, 2*a*b+b*c-a+2*c, a*b-2*b^2+c-2, a*b-b^2+c-1, a*b+b^2+c+1, a*b+2*b^2+c+2,\n2*a*b-b^2+2*c-1, 2*a*b+b^2+2*c+1, a^2-2*b*c+c^2+2*a, a^2-b*c+c^2+a, a^2+b*c+c^\n2-a, a^2+2*b*c+c^2-2*a, 2*a^2-b*c+2*c^2+a, 2*a^2+b*c+2*c^2-a, a^2-3*b^2+c^2-3,\na^2-b^2+c^2-1, 3*a^2-b^2+3*c^2-1, a^2-2*a*b+c^2-2*c, a^2-a*b+c^2-c, a^2+a*b+c^\n2+c, a^2+2*a*b+c^2+2*c, 2*a^2-a*b+2*c^2-c, 2*a^2+a*b+2*c^2+c, a*b-2*b^2-2*b*c+\n2*a+c-2, a*b-2*b^2-b*c+a+c-2, a*b-2*b^2+b*c-a+c-2, a*b-2*b^2+2*b*c-2*a+c-2, a*\nb-b^2-2*b*c+2*a+c-1, a*b-b^2-b*c+a+c-1, a*b-b^2+b*c-a+c-1, a*b-b^2+2*b*c-2*a+c\n-1, a*b+b^2-2*b*c+2*a+c+1, a*b+b^2-b*c+a+c+1, a*b+b^2+b*c-a+c+1, a*b+b^2+2*b*c\n-2*a+c+1, a*b+2*b^2-2*b*c+2*a+c+2, a*b+2*b^2-b*c+a+c+2, a*b+2*b^2+b*c-a+c+2, a\n*b+2*b^2+2*b*c-2*a+c+2, 2*a*b-2*b^2-b*c+a+2*c-2, 2*a*b-2*b^2+b*c-a+2*c-2, 2*a*\nb-b^2-2*b*c+2*a+2*c-1, 2*a*b-b^2-b*c+a+2*c-1, 2*a*b-b^2+b*c-a+2*c-1, 2*a*b-b^2\n+2*b*c-2*a+2*c-1, 2*a*b+b^2-2*b*c+2*a+2*c+1, 2*a*b+b^2-b*c+a+2*c+1, 2*a*b+b^2+\nb*c-a+2*c+1, 2*a*b+b^2+2*b*c-2*a+2*c+1, 2*a*b+2*b^2-b*c+a+2*c+2, 2*a*b+2*b^2+b\n*c-a+2*c+2, a^2-3*b^2-4*b*c+c^2+4*a-3, a^2-3*b^2-2*b*c+c^2+2*a-3, a^2-3*b^2+2*\nb*c+c^2-2*a-3, a^2-3*b^2+4*b*c+c^2-4*a-3, a^2-b^2-4*b*c+c^2+4*a-1, a^2-b^2-2*b\n*c+c^2+2*a-1, a^2-b^2-b*c+c^2+a-1, a^2-b^2+b*c+c^2-a-1, a^2-b^2+2*b*c+c^2-2*a-\\\n1, a^2-b^2+4*b*c+c^2-4*a-1, a^2+b^2-4*b*c+c^2+4*a+1, a^2+b^2+4*b*c+c^2-4*a+1,\na^2+3*b^2-4*b*c+c^2+4*a+3, a^2+3*b^2+4*b*c+c^2-4*a+3, 3*a^2-b^2-4*b*c+3*c^2+4*\na-1, 3*a^2-b^2-2*b*c+3*c^2+2*a-1, 3*a^2-b^2+2*b*c+3*c^2-2*a-1, 3*a^2-b^2+4*b*c\n+3*c^2-4*a-1, 3*a^2+b^2-4*b*c+3*c^2+4*a+1, 3*a^2+b^2+4*b*c+3*c^2-4*a+1, a^2-2*\na*b-2*b*c+c^2+2*a-2*c, a^2-2*a*b-b*c+c^2+a-2*c, a^2-2*a*b+b*c+c^2-a-2*c, a^2-2\n*a*b+2*b*c+c^2-2*a-2*c, a^2-a*b-2*b*c+c^2+2*a-c, a^2-a*b-b*c+c^2+a-c, a^2-a*b+\nb*c+c^2-a-c, a^2-a*b+2*b*c+c^2-2*a-c, a^2+a*b-2*b*c+c^2+2*a+c, a^2+a*b-b*c+c^2\n+a+c, a^2+a*b+b*c+c^2-a+c, a^2+a*b+2*b*c+c^2-2*a+c, a^2+2*a*b-2*b*c+c^2+2*a+2*\nc, a^2+2*a*b-b*c+c^2+a+2*c, a^2+2*a*b+b*c+c^2-a+2*c, a^2+2*a*b+2*b*c+c^2-2*a+2\n*c, 2*a^2-2*a*b-b*c+2*c^2+a-2*c, 2*a^2-2*a*b+b*c+2*c^2-a-2*c, 2*a^2-a*b-2*b*c+\n2*c^2+2*a-c, 2*a^2-a*b-b*c+2*c^2+a-c, 2*a^2-a*b+b*c+2*c^2-a-c, 2*a^2-a*b+2*b*c\n+2*c^2-2*a-c, 2*a^2+a*b-2*b*c+2*c^2+2*a+c, 2*a^2+a*b-b*c+2*c^2+a+c, 2*a^2+a*b+\nb*c+2*c^2-a+c, 2*a^2+a*b+2*b*c+2*c^2-2*a+c, 2*a^2+2*a*b-b*c+2*c^2+a+2*c, 2*a^2\n+2*a*b+b*c+2*c^2-a+2*c, a^2-4*a*b-3*b^2+c^2-4*c-3, a^2-4*a*b-b^2+c^2-4*c-1, a^\n2-4*a*b+b^2+c^2-4*c+1, a^2-4*a*b+3*b^2+c^2-4*c+3, a^2-2*a*b-3*b^2+c^2-2*c-3, a\n^2-2*a*b-b^2+c^2-2*c-1, a^2-a*b-b^2+c^2-c-1, a^2+a*b-b^2+c^2+c-1, a^2+2*a*b-3*\nb^2+c^2+2*c-3, a^2+2*a*b-b^2+c^2+2*c-1, a^2+4*a*b-3*b^2+c^2+4*c-3, a^2+4*a*b-b\n^2+c^2+4*c-1, a^2+4*a*b+b^2+c^2+4*c+1, a^2+4*a*b+3*b^2+c^2+4*c+3, 3*a^2-4*a*b-\nb^2+3*c^2-4*c-1, 3*a^2-4*a*b+b^2+3*c^2-4*c+1, 3*a^2-2*a*b-b^2+3*c^2-2*c-1, 3*a\n^2+2*a*b-b^2+3*c^2+2*c-1, 3*a^2+4*a*b-b^2+3*c^2+4*c-1, 3*a^2+4*a*b+b^2+3*c^2+4\n*c+1, a^2-4*a*b-3*b^2-4*b*c+c^2+4*a-4*c-3, a^2-4*a*b-3*b^2-2*b*c+c^2+2*a-4*c-3\n, a^2-4*a*b-3*b^2+2*b*c+c^2-2*a-4*c-3, a^2-4*a*b-3*b^2+4*b*c+c^2-4*a-4*c-3, a^\n2-4*a*b-b^2-4*b*c+c^2+4*a-4*c-1, a^2-4*a*b-b^2-2*b*c+c^2+2*a-4*c-1, a^2-4*a*b-\nb^2+2*b*c+c^2-2*a-4*c-1, a^2-4*a*b-b^2+4*b*c+c^2-4*a-4*c-1, a^2-4*a*b+b^2-4*b*\nc+c^2+4*a-4*c+1, a^2-4*a*b+b^2-2*b*c+c^2+2*a-4*c+1, a^2-4*a*b+b^2+2*b*c+c^2-2*\na-4*c+1, a^2-4*a*b+b^2+4*b*c+c^2-4*a-4*c+1, a^2-4*a*b+3*b^2-4*b*c+c^2+4*a-4*c+\n3, a^2-4*a*b+3*b^2-2*b*c+c^2+2*a-4*c+3, a^2-4*a*b+3*b^2+2*b*c+c^2-2*a-4*c+3, a\n^2-4*a*b+3*b^2+4*b*c+c^2-4*a-4*c+3, a^2-4*a*b+5*b^2-4*b*c+c^2+4*a-4*c+5, a^2-4\n*a*b+5*b^2+4*b*c+c^2-4*a-4*c+5, a^2-2*a*b-3*b^2-4*b*c+c^2+4*a-2*c-3, a^2-2*a*b\n-3*b^2-2*b*c+c^2+2*a-2*c-3, a^2-2*a*b-3*b^2+2*b*c+c^2-2*a-2*c-3, a^2-2*a*b-3*b\n^2+4*b*c+c^2-4*a-2*c-3, a^2-2*a*b-b^2-4*b*c+c^2+4*a-2*c-1, a^2-2*a*b-b^2-2*b*c\n+c^2+2*a-2*c-1, a^2-2*a*b-b^2-b*c+c^2+a-2*c-1, a^2-2*a*b-b^2+b*c+c^2-a-2*c-1,\na^2-2*a*b-b^2+2*b*c+c^2-2*a-2*c-1, a^2-2*a*b-b^2+4*b*c+c^2-4*a-2*c-1, a^2-2*a*\nb+b^2-4*b*c+c^2+4*a-2*c+1, a^2-2*a*b+b^2-2*b*c+c^2+2*a-2*c+1, a^2-2*a*b+b^2-b*\nc+c^2+a-2*c+1, a^2-2*a*b+b^2+b*c+c^2-a-2*c+1, a^2-2*a*b+b^2+2*b*c+c^2-2*a-2*c+\n1, a^2-2*a*b+b^2+4*b*c+c^2-4*a-2*c+1, a^2-2*a*b+3*b^2-4*b*c+c^2+4*a-2*c+3, a^2\n-2*a*b+3*b^2+4*b*c+c^2-4*a-2*c+3, a^2-a*b-b^2-2*b*c+c^2+2*a-c-1, a^2-a*b-b^2-b\n*c+c^2+a-c-1, a^2-a*b-b^2+b*c+c^2-a-c-1, a^2-a*b-b^2+2*b*c+c^2-2*a-c-1, a^2-a*\nb+b^2-2*b*c+c^2+2*a-c+1, a^2-a*b+b^2+2*b*c+c^2-2*a-c+1, a^2+a*b-b^2-2*b*c+c^2+\n2*a+c-1, a^2+a*b-b^2-b*c+c^2+a+c-1, a^2+a*b-b^2+b*c+c^2-a+c-1, a^2+a*b-b^2+2*b\n*c+c^2-2*a+c-1, a^2+a*b+b^2-2*b*c+c^2+2*a+c+1, a^2+a*b+b^2+2*b*c+c^2-2*a+c+1,\na^2+2*a*b-3*b^2-4*b*c+c^2+4*a+2*c-3, a^2+2*a*b-3*b^2-2*b*c+c^2+2*a+2*c-3, a^2+\n2*a*b-3*b^2+2*b*c+c^2-2*a+2*c-3, a^2+2*a*b-3*b^2+4*b*c+c^2-4*a+2*c-3, a^2+2*a*\nb-b^2-4*b*c+c^2+4*a+2*c-1, a^2+2*a*b-b^2-2*b*c+c^2+2*a+2*c-1, a^2+2*a*b-b^2-b*\nc+c^2+a+2*c-1, a^2+2*a*b-b^2+b*c+c^2-a+2*c-1, a^2+2*a*b-b^2+2*b*c+c^2-2*a+2*c-\\\n1, a^2+2*a*b-b^2+4*b*c+c^2-4*a+2*c-1, a^2+2*a*b+b^2-4*b*c+c^2+4*a+2*c+1, a^2+2\n*a*b+b^2-2*b*c+c^2+2*a+2*c+1, a^2+2*a*b+b^2-b*c+c^2+a+2*c+1, a^2+2*a*b+b^2+b*c\n+c^2-a+2*c+1, a^2+2*a*b+b^2+2*b*c+c^2-2*a+2*c+1, a^2+2*a*b+b^2+4*b*c+c^2-4*a+2\n*c+1, a^2+2*a*b+3*b^2-4*b*c+c^2+4*a+2*c+3, a^2+2*a*b+3*b^2+4*b*c+c^2-4*a+2*c+3\n, a^2+4*a*b-3*b^2-4*b*c+c^2+4*a+4*c-3, a^2+4*a*b-3*b^2-2*b*c+c^2+2*a+4*c-3, a^\n2+4*a*b-3*b^2+2*b*c+c^2-2*a+4*c-3, a^2+4*a*b-3*b^2+4*b*c+c^2-4*a+4*c-3, a^2+4*\na*b-b^2-4*b*c+c^2+4*a+4*c-1, a^2+4*a*b-b^2-2*b*c+c^2+2*a+4*c-1, a^2+4*a*b-b^2+\n2*b*c+c^2-2*a+4*c-1, a^2+4*a*b-b^2+4*b*c+c^2-4*a+4*c-1, a^2+4*a*b+b^2-4*b*c+c^\n2+4*a+4*c+1, a^2+4*a*b+b^2-2*b*c+c^2+2*a+4*c+1, a^2+4*a*b+b^2+2*b*c+c^2-2*a+4*\nc+1, a^2+4*a*b+b^2+4*b*c+c^2-4*a+4*c+1, a^2+4*a*b+3*b^2-4*b*c+c^2+4*a+4*c+3, a\n^2+4*a*b+3*b^2-2*b*c+c^2+2*a+4*c+3, a^2+4*a*b+3*b^2+2*b*c+c^2-2*a+4*c+3, a^2+4\n*a*b+3*b^2+4*b*c+c^2-4*a+4*c+3, a^2+4*a*b+5*b^2-4*b*c+c^2+4*a+4*c+5, a^2+4*a*b\n+5*b^2+4*b*c+c^2-4*a+4*c+5, 3*a^2-4*a*b-b^2-4*b*c+3*c^2+4*a-4*c-1, 3*a^2-4*a*b\n-b^2-2*b*c+3*c^2+2*a-4*c-1, 3*a^2-4*a*b-b^2+2*b*c+3*c^2-2*a-4*c-1, 3*a^2-4*a*b\n-b^2+4*b*c+3*c^2-4*a-4*c-1, 3*a^2-4*a*b+b^2-4*b*c+3*c^2+4*a-4*c+1, 3*a^2-4*a*b\n+b^2-2*b*c+3*c^2+2*a-4*c+1, 3*a^2-4*a*b+b^2+2*b*c+3*c^2-2*a-4*c+1, 3*a^2-4*a*b\n+b^2+4*b*c+3*c^2-4*a-4*c+1, 3*a^2-2*a*b-b^2-4*b*c+3*c^2+4*a-2*c-1, 3*a^2-2*a*b\n-b^2-2*b*c+3*c^2+2*a-2*c-1, 3*a^2-2*a*b-b^2+2*b*c+3*c^2-2*a-2*c-1, 3*a^2-2*a*b\n-b^2+4*b*c+3*c^2-4*a-2*c-1, 3*a^2-2*a*b+b^2-4*b*c+3*c^2+4*a-2*c+1, 3*a^2-2*a*b\n+b^2+4*b*c+3*c^2-4*a-2*c+1, 3*a^2+2*a*b-b^2-4*b*c+3*c^2+4*a+2*c-1, 3*a^2+2*a*b\n-b^2-2*b*c+3*c^2+2*a+2*c-1, 3*a^2+2*a*b-b^2+2*b*c+3*c^2-2*a+2*c-1, 3*a^2+2*a*b\n-b^2+4*b*c+3*c^2-4*a+2*c-1, 3*a^2+2*a*b+b^2-4*b*c+3*c^2+4*a+2*c+1, 3*a^2+2*a*b\n+b^2+4*b*c+3*c^2-4*a+2*c+1, 3*a^2+4*a*b-b^2-4*b*c+3*c^2+4*a+4*c-1, 3*a^2+4*a*b\n-b^2-2*b*c+3*c^2+2*a+4*c-1, 3*a^2+4*a*b-b^2+2*b*c+3*c^2-2*a+4*c-1, 3*a^2+4*a*b\n-b^2+4*b*c+3*c^2-4*a+4*c-1, 3*a^2+4*a*b+b^2-4*b*c+3*c^2+4*a+4*c+1, 3*a^2+4*a*b\n+b^2-2*b*c+3*c^2+2*a+4*c+1, 3*a^2+4*a*b+b^2+2*b*c+3*c^2-2*a+4*c+1, 3*a^2+4*a*b\n+b^2+4*b*c+3*c^2-4*a+4*c+1, 5*a^2-4*a*b+b^2-4*b*c+5*c^2+4*a-4*c+1, 5*a^2-4*a*b\n+b^2+4*b*c+5*c^2-4*a-4*c+1, 5*a^2+4*a*b+b^2-4*b*c+5*c^2+4*a+4*c+1, 5*a^2+4*a*b\n+b^2+4*b*c+5*c^2-4*a+4*c+1, a*c+b, a*b-c, a*c-2*b^2-2*c^2+b, a*c-b^2-c^2+b, a*\nc+b^2+c^2+b, a*c+2*b^2+2*c^2+b, 2*a*c-b^2-c^2+2*b, 2*a*c+b^2+c^2+2*b, a*b-2*b^\n2-2*c^2-c, a*b-b^2-c^2-c, a*b+b^2+c^2-c, a*b+2*b^2+2*c^2-c, 2*a*b-b^2-c^2-2*c,\n2*a*b+b^2+c^2-2*c, a*b-2*a*c-2*b-c, a*b-a*c-b-c, a*b+a*c+b-c, a*b+2*a*c+2*b-c,\n2*a*b-a*c-b-2*c, 2*a*b+a*c+b-2*c, a^2-3*b^2-3*c^2+1, a^2-b^2-c^2+1, 3*a^2-b^2-\nc^2+3, a^2-2*a*c-2*b+1, a^2-a*c-b+1, a^2+a*c+b+1, a^2+2*a*c+2*b+1, 2*a^2-a*c-b\n+2, 2*a^2+a*c+b+2, a^2-2*a*b+2*c+1, a^2-a*b+c+1, a^2+a*b-c+1, a^2+2*a*b-2*c+1,\n2*a^2-a*b+c+2, 2*a^2+a*b-c+2, a*b-2*a*c-2*b^2-2*c^2-2*b-c, a*b-2*a*c-b^2-c^2-2\n*b-c, a*b-2*a*c+b^2+c^2-2*b-c, a*b-2*a*c+2*b^2+2*c^2-2*b-c, a*b-a*c-2*b^2-2*c^\n2-b-c, a*b-a*c-b^2-c^2-b-c, a*b-a*c+b^2+c^2-b-c, a*b-a*c+2*b^2+2*c^2-b-c, a*b+\na*c-2*b^2-2*c^2+b-c, a*b+a*c-b^2-c^2+b-c, a*b+a*c+b^2+c^2+b-c, a*b+a*c+2*b^2+2\n*c^2+b-c, a*b+2*a*c-2*b^2-2*c^2+2*b-c, a*b+2*a*c-b^2-c^2+2*b-c, a*b+2*a*c+b^2+\nc^2+2*b-c, a*b+2*a*c+2*b^2+2*c^2+2*b-c, 2*a*b-2*a*c-b^2-c^2-2*b-2*c, 2*a*b-2*a\n*c+b^2+c^2-2*b-2*c, 2*a*b-a*c-2*b^2-2*c^2-b-2*c, 2*a*b-a*c-b^2-c^2-b-2*c, 2*a*\nb-a*c+b^2+c^2-b-2*c, 2*a*b-a*c+2*b^2+2*c^2-b-2*c, 2*a*b+a*c-2*b^2-2*c^2+b-2*c,\n2*a*b+a*c-b^2-c^2+b-2*c, 2*a*b+a*c+b^2+c^2+b-2*c, 2*a*b+a*c+2*b^2+2*c^2+b-2*c,\n2*a*b+2*a*c-b^2-c^2+2*b-2*c, 2*a*b+2*a*c+b^2+c^2+2*b-2*c, a^2-4*a*c-3*b^2-3*c^\n2-4*b+1, a^2-4*a*c-b^2-c^2-4*b+1, a^2-4*a*c+b^2+c^2-4*b+1, a^2-4*a*c+3*b^2+3*c\n^2-4*b+1, a^2-2*a*c-3*b^2-3*c^2-2*b+1, a^2-2*a*c-b^2-c^2-2*b+1, a^2-a*c-b^2-c^\n2-b+1, a^2+a*c-b^2-c^2+b+1, a^2+2*a*c-3*b^2-3*c^2+2*b+1, a^2+2*a*c-b^2-c^2+2*b\n+1, a^2+4*a*c-3*b^2-3*c^2+4*b+1, a^2+4*a*c-b^2-c^2+4*b+1, a^2+4*a*c+b^2+c^2+4*\nb+1, a^2+4*a*c+3*b^2+3*c^2+4*b+1, 3*a^2-4*a*c-b^2-c^2-4*b+3, 3*a^2-4*a*c+b^2+c\n^2-4*b+3, 3*a^2-2*a*c-b^2-c^2-2*b+3, 3*a^2+2*a*c-b^2-c^2+2*b+3, 3*a^2+4*a*c-b^\n2-c^2+4*b+3, 3*a^2+4*a*c+b^2+c^2+4*b+3, a^2-4*a*b-3*b^2-3*c^2+4*c+1, a^2-4*a*b\n-b^2-c^2+4*c+1, a^2-4*a*b+b^2+c^2+4*c+1, a^2-4*a*b+3*b^2+3*c^2+4*c+1, a^2-2*a*\nb-3*b^2-3*c^2+2*c+1, a^2-2*a*b-b^2-c^2+2*c+1, a^2-a*b-b^2-c^2+c+1, a^2+a*b-b^2\n-c^2-c+1, a^2+2*a*b-3*b^2-3*c^2-2*c+1, a^2+2*a*b-b^2-c^2-2*c+1, a^2+4*a*b-3*b^\n2-3*c^2-4*c+1, a^2+4*a*b-b^2-c^2-4*c+1, a^2+4*a*b+b^2+c^2-4*c+1, a^2+4*a*b+3*b\n^2+3*c^2-4*c+1, 3*a^2-4*a*b-b^2-c^2+4*c+3, 3*a^2-4*a*b+b^2+c^2+4*c+3, 3*a^2-2*\na*b-b^2-c^2+2*c+3, 3*a^2+2*a*b-b^2-c^2-2*c+3, 3*a^2+4*a*b-b^2-c^2-4*c+3, 3*a^2\n+4*a*b+b^2+c^2-4*c+3, a^2-2*a*b-2*a*c-2*b+2*c+1, a^2-2*a*b-a*c-b+2*c+1, a^2-2*\na*b+a*c+b+2*c+1, a^2-2*a*b+2*a*c+2*b+2*c+1, a^2-a*b-2*a*c-2*b+c+1, a^2-a*b-a*c\n-b+c+1, a^2-a*b+a*c+b+c+1, a^2-a*b+2*a*c+2*b+c+1, a^2+a*b-2*a*c-2*b-c+1, a^2+a\n*b-a*c-b-c+1, a^2+a*b+a*c+b-c+1, a^2+a*b+2*a*c+2*b-c+1, a^2+2*a*b-2*a*c-2*b-2*\nc+1, a^2+2*a*b-a*c-b-2*c+1, a^2+2*a*b+a*c+b-2*c+1, a^2+2*a*b+2*a*c+2*b-2*c+1,\n2*a^2-2*a*b-a*c-b+2*c+2, 2*a^2-2*a*b+a*c+b+2*c+2, 2*a^2-a*b-2*a*c-2*b+c+2, 2*a\n^2-a*b-a*c-b+c+2, 2*a^2-a*b+a*c+b+c+2, 2*a^2-a*b+2*a*c+2*b+c+2, 2*a^2+a*b-2*a*\nc-2*b-c+2, 2*a^2+a*b-a*c-b-c+2, 2*a^2+a*b+a*c+b-c+2, 2*a^2+a*b+2*a*c+2*b-c+2,\n2*a^2+2*a*b-a*c-b-2*c+2, 2*a^2+2*a*b+a*c+b-2*c+2, a^2-4*a*b-4*a*c-3*b^2-3*c^2-\\\n4*b+4*c+1, a^2-4*a*b-4*a*c-b^2-c^2-4*b+4*c+1, a^2-4*a*b-4*a*c+b^2+c^2-4*b+4*c+\n1, a^2-4*a*b-4*a*c+3*b^2+3*c^2-4*b+4*c+1, a^2-4*a*b-4*a*c+5*b^2+5*c^2-4*b+4*c+\n1, a^2-4*a*b-2*a*c-3*b^2-3*c^2-2*b+4*c+1, a^2-4*a*b-2*a*c-b^2-c^2-2*b+4*c+1, a\n^2-4*a*b-2*a*c+b^2+c^2-2*b+4*c+1, a^2-4*a*b-2*a*c+3*b^2+3*c^2-2*b+4*c+1, a^2-4\n*a*b+2*a*c-3*b^2-3*c^2+2*b+4*c+1, a^2-4*a*b+2*a*c-b^2-c^2+2*b+4*c+1, a^2-4*a*b\n+2*a*c+b^2+c^2+2*b+4*c+1, a^2-4*a*b+2*a*c+3*b^2+3*c^2+2*b+4*c+1, a^2-4*a*b+4*a\n*c-3*b^2-3*c^2+4*b+4*c+1, a^2-4*a*b+4*a*c-b^2-c^2+4*b+4*c+1, a^2-4*a*b+4*a*c+b\n^2+c^2+4*b+4*c+1, a^2-4*a*b+4*a*c+3*b^2+3*c^2+4*b+4*c+1, a^2-4*a*b+4*a*c+5*b^2\n+5*c^2+4*b+4*c+1, a^2-2*a*b-4*a*c-3*b^2-3*c^2-4*b+2*c+1, a^2-2*a*b-4*a*c-b^2-c\n^2-4*b+2*c+1, a^2-2*a*b-4*a*c+b^2+c^2-4*b+2*c+1, a^2-2*a*b-4*a*c+3*b^2+3*c^2-4\n*b+2*c+1, a^2-2*a*b-2*a*c-3*b^2-3*c^2-2*b+2*c+1, a^2-2*a*b-2*a*c-b^2-c^2-2*b+2\n*c+1, a^2-2*a*b-2*a*c+b^2+c^2-2*b+2*c+1, a^2-2*a*b-a*c-b^2-c^2-b+2*c+1, a^2-2*\na*b-a*c+b^2+c^2-b+2*c+1, a^2-2*a*b+a*c-b^2-c^2+b+2*c+1, a^2-2*a*b+a*c+b^2+c^2+\nb+2*c+1, a^2-2*a*b+2*a*c-3*b^2-3*c^2+2*b+2*c+1, a^2-2*a*b+2*a*c-b^2-c^2+2*b+2*\nc+1, a^2-2*a*b+2*a*c+b^2+c^2+2*b+2*c+1, a^2-2*a*b+4*a*c-3*b^2-3*c^2+4*b+2*c+1,\na^2-2*a*b+4*a*c-b^2-c^2+4*b+2*c+1, a^2-2*a*b+4*a*c+b^2+c^2+4*b+2*c+1, a^2-2*a*\nb+4*a*c+3*b^2+3*c^2+4*b+2*c+1, a^2-a*b-2*a*c-b^2-c^2-2*b+c+1, a^2-a*b-2*a*c+b^\n2+c^2-2*b+c+1, a^2-a*b-a*c-b^2-c^2-b+c+1, a^2-a*b+a*c-b^2-c^2+b+c+1, a^2-a*b+2\n*a*c-b^2-c^2+2*b+c+1, a^2-a*b+2*a*c+b^2+c^2+2*b+c+1, a^2+a*b-2*a*c-b^2-c^2-2*b\n-c+1, a^2+a*b-2*a*c+b^2+c^2-2*b-c+1, a^2+a*b-a*c-b^2-c^2-b-c+1, a^2+a*b+a*c-b^\n2-c^2+b-c+1, a^2+a*b+2*a*c-b^2-c^2+2*b-c+1, a^2+a*b+2*a*c+b^2+c^2+2*b-c+1, a^2\n+2*a*b-4*a*c-3*b^2-3*c^2-4*b-2*c+1, a^2+2*a*b-4*a*c-b^2-c^2-4*b-2*c+1, a^2+2*a\n*b-4*a*c+b^2+c^2-4*b-2*c+1, a^2+2*a*b-4*a*c+3*b^2+3*c^2-4*b-2*c+1, a^2+2*a*b-2\n*a*c-3*b^2-3*c^2-2*b-2*c+1, a^2+2*a*b-2*a*c-b^2-c^2-2*b-2*c+1, a^2+2*a*b-2*a*c\n+b^2+c^2-2*b-2*c+1, a^2+2*a*b-a*c-b^2-c^2-b-2*c+1, a^2+2*a*b-a*c+b^2+c^2-b-2*c\n+1, a^2+2*a*b+a*c-b^2-c^2+b-2*c+1, a^2+2*a*b+a*c+b^2+c^2+b-2*c+1, a^2+2*a*b+2*\na*c-3*b^2-3*c^2+2*b-2*c+1, a^2+2*a*b+2*a*c-b^2-c^2+2*b-2*c+1, a^2+2*a*b+2*a*c+\nb^2+c^2+2*b-2*c+1, a^2+2*a*b+4*a*c-3*b^2-3*c^2+4*b-2*c+1, a^2+2*a*b+4*a*c-b^2-\nc^2+4*b-2*c+1, a^2+2*a*b+4*a*c+b^2+c^2+4*b-2*c+1, a^2+2*a*b+4*a*c+3*b^2+3*c^2+\n4*b-2*c+1, a^2+4*a*b-4*a*c-3*b^2-3*c^2-4*b-4*c+1, a^2+4*a*b-4*a*c-b^2-c^2-4*b-\\\n4*c+1, a^2+4*a*b-4*a*c+b^2+c^2-4*b-4*c+1, a^2+4*a*b-4*a*c+3*b^2+3*c^2-4*b-4*c+\n1, a^2+4*a*b-4*a*c+5*b^2+5*c^2-4*b-4*c+1, a^2+4*a*b-2*a*c-3*b^2-3*c^2-2*b-4*c+\n1, a^2+4*a*b-2*a*c-b^2-c^2-2*b-4*c+1, a^2+4*a*b-2*a*c+b^2+c^2-2*b-4*c+1, a^2+4\n*a*b-2*a*c+3*b^2+3*c^2-2*b-4*c+1, a^2+4*a*b+2*a*c-3*b^2-3*c^2+2*b-4*c+1, a^2+4\n*a*b+2*a*c-b^2-c^2+2*b-4*c+1, a^2+4*a*b+2*a*c+b^2+c^2+2*b-4*c+1, a^2+4*a*b+2*a\n*c+3*b^2+3*c^2+2*b-4*c+1, a^2+4*a*b+4*a*c-3*b^2-3*c^2+4*b-4*c+1, a^2+4*a*b+4*a\n*c-b^2-c^2+4*b-4*c+1, a^2+4*a*b+4*a*c+b^2+c^2+4*b-4*c+1, a^2+4*a*b+4*a*c+3*b^2\n+3*c^2+4*b-4*c+1, a^2+4*a*b+4*a*c+5*b^2+5*c^2+4*b-4*c+1, 3*a^2-4*a*b-4*a*c-b^2\n-c^2-4*b+4*c+3, 3*a^2-4*a*b-4*a*c+b^2+c^2-4*b+4*c+3, 3*a^2-4*a*b-2*a*c-b^2-c^2\n-2*b+4*c+3, 3*a^2-4*a*b-2*a*c+b^2+c^2-2*b+4*c+3, 3*a^2-4*a*b+2*a*c-b^2-c^2+2*b\n+4*c+3, 3*a^2-4*a*b+2*a*c+b^2+c^2+2*b+4*c+3, 3*a^2-4*a*b+4*a*c-b^2-c^2+4*b+4*c\n+3, 3*a^2-4*a*b+4*a*c+b^2+c^2+4*b+4*c+3, 3*a^2-2*a*b-4*a*c-b^2-c^2-4*b+2*c+3,\n3*a^2-2*a*b-4*a*c+b^2+c^2-4*b+2*c+3, 3*a^2-2*a*b-2*a*c-b^2-c^2-2*b+2*c+3, 3*a^\n2-2*a*b+2*a*c-b^2-c^2+2*b+2*c+3, 3*a^2-2*a*b+4*a*c-b^2-c^2+4*b+2*c+3, 3*a^2-2*\na*b+4*a*c+b^2+c^2+4*b+2*c+3, 3*a^2+2*a*b-4*a*c-b^2-c^2-4*b-2*c+3, 3*a^2+2*a*b-\\\n4*a*c+b^2+c^2-4*b-2*c+3, 3*a^2+2*a*b-2*a*c-b^2-c^2-2*b-2*c+3, 3*a^2+2*a*b+2*a*\nc-b^2-c^2+2*b-2*c+3, 3*a^2+2*a*b+4*a*c-b^2-c^2+4*b-2*c+3, 3*a^2+2*a*b+4*a*c+b^\n2+c^2+4*b-2*c+3, 3*a^2+4*a*b-4*a*c-b^2-c^2-4*b-4*c+3, 3*a^2+4*a*b-4*a*c+b^2+c^\n2-4*b-4*c+3, 3*a^2+4*a*b-2*a*c-b^2-c^2-2*b-4*c+3, 3*a^2+4*a*b-2*a*c+b^2+c^2-2*\nb-4*c+3, 3*a^2+4*a*b+2*a*c-b^2-c^2+2*b-4*c+3, 3*a^2+4*a*b+2*a*c+b^2+c^2+2*b-4*\nc+3, 3*a^2+4*a*b+4*a*c-b^2-c^2+4*b-4*c+3, 3*a^2+4*a*b+4*a*c+b^2+c^2+4*b-4*c+3,\n5*a^2-4*a*b-4*a*c+b^2+c^2-4*b+4*c+5, 5*a^2-4*a*b+4*a*c+b^2+c^2+4*b+4*c+5, 5*a^\n2+4*a*b-4*a*c+b^2+c^2-4*b-4*c+5, 5*a^2+4*a*b+4*a*c+b^2+c^2+4*b-4*c+5];\n", "meta": {"hexsha": "1b150294d85ac271ec4e46243c89457f4dceac50", "size": 21718, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "files/quadrics_N3.mpl", "max_stars_repo_name": "copyme/copyme.github.io", "max_stars_repo_head_hexsha": "112c2a9eac8ca155224d86d390d5cf701e16db6b", "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": "files/quadrics_N3.mpl", "max_issues_repo_name": "copyme/copyme.github.io", "max_issues_repo_head_hexsha": "112c2a9eac8ca155224d86d390d5cf701e16db6b", "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": "files/quadrics_N3.mpl", "max_forks_repo_name": "copyme/copyme.github.io", "max_forks_repo_head_hexsha": "112c2a9eac8ca155224d86d390d5cf701e16db6b", "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": 78.6884057971, "max_line_length": 79, "alphanum_fraction": 0.4766092642, "num_tokens": 16085, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467738423873, "lm_q2_score": 0.5621765008857981, "lm_q1q2_score": 0.49423565708375133}}
{"text": "MoreThuente := module()\n\n  description \"More-Thuente\";\n\n  # Module defined as a package (i.e.) collection of procedures\n  option package, load = ModuleLoad, unload = ModuleUnLoad;\n\n  export lines, linesearch, esatta, AB_list, doplot, doplot2;\n  \n  local ModuleLoad,\n        ModuleUnLoad,\n        _debug,\n        min_quadratic,\n        min_cubic,\n        xtol, ftol, gtol, stpmin, stpmax, maxfev,\n        stx, fx, dx, sty, fy, dy, stp, fp, dp, brackt,\n        max_iter, A_list, B_list;\n\n  uses LinearAlgebra;\n\n  ModuleUnLoad := proc()\n    printf(\"PotraShi unload\\n\");\n    NULL;\n  end proc:\n\n  ModuleLoad := proc()\n    printf(\"PotraShi load\\n\");\n    _debug   := true;\n    rho      := 0.25;\n    sigma    := 0.75;\n    tau1     := 0.1;\n    tau2     := 0.49;\n    tau3     := 2.5;\n    Jbig     := 2;\n    max_iter := 40;\n    NULL;\n  end proc;\n  \n  # Explicitly call ModuleLoad here so the type is registered when this\n  # code is cut&pasted in.  ModuleLoad gets called when the module is\n  # read from the repository, but the code used to define a module\n  # (like the command below) is not called at library read time.\n  ModuleLoad();\n\n  AB_list := proc()\n    A_list, B_list;\n  end proc;\n\n  min_quadratic := proc ( a, fa, Dfa, b, fb )\n    local t, delta; # A+B*(x-a)+C*(x-a)^2\n    # p  = fa + Dfa*(x-a)+t*(x-a)^2\n    # p' = Dfa+2*t*(x-a)\n    ##t     := ((fb-fa)/(b-a)-Dfa)/(b-a);\n    ##delta := -Dfa/(2*t);\n    t     := (fb-fa)/(b-a)-Dfa;\n    delta := max(tau1,min(1-tau1,-Dfa/(2*t)));\n    a+(b-a)*delta;\n  end proc;\n\n  lines := proc( f0, df0, L )\n    [ [0,f0], [L,f0+L*rho*df0] ], [ [0,f0], [L,f0+L*sigma*df0] ];\n  end proc;\n\n  pqr := proc()\n    theta := 3*(fx - fp)/(stp - stx) + dx + dp;\n    s     := max([abs(theta),abs(dx),abs(dp)]);\n    gamma := s*sqrt(max(0,(theta/s)^2 - (dx/s)*(dp/s)));\n    if stp > stx then\n      gamma = -gamma;\n    end;\n    p := (gamma - dp) + theta;\n    q := (gamma + (dx - dp)) + gamma;\n    r := p/q;\n  end proc:\nSkip to content\nSearch or jump to…\nPull requests\nIssues\nMarketplace\nExplore\n \n@ebertolazzi \nJuliaNLSolvers\n/\nLineSearches.jl\nPublic\n6\n69\n26\nCode\nIssues\n17\nPull requests\n1\nActions\nProjects\nWiki\nSecurity\nInsights\nLineSearches.jl/src/morethuente.jl\n@pkofod\npkofod Pkm/fix lse (#146)\n…\nLatest commit 0f5571e on Aug 18, 2020\n History\n 6 contributors\n@anriseth@pkofod@antoine-levitt@femtocleaner@mohamed82008@cortner\n658 lines (594 sloc)  20.1 KB\n   \n#   Translation of Matlab version by John Myles White\n#   Translation of minpack subroutine cvsrch\n#   Dianne O'Leary   July 1991\n#\n#     **********\n#\n#     Subroutine cvsrch\n#\n#     The purpose of cvsrch is to find a step which satisfies\n#     a sufficient decrease condition and a curvature condition.\n#     The user must provide a subroutine which calculates the\n#     function and the gradient.\n#\n#     At each stage the subroutine updates an interval of\n#     uncertainty with endpoints stx and sty. The interval of\n#     uncertainty is initially chosen so that it contains a\n#     minimizer of the modified function\n#\n#          f(x + stp * s) - f(x) - f_tol * stp * (gradf(x)' * s).\n#\n#     If a step is obtained for which the modified function\n#     has a nonpositive function value and nonnegative derivative,\n#     then the interval of uncertainty is chosen so that it\n#     contains a minimizer of f(x + stp * s).\n#\n#     The algorithm is designed to find a step which satisfies\n#     the sufficient decrease condition\n#\n#           f(x + stp * s) <= f(x) + f_tol * stp * (gradf(x)' * s),\n#\n#     and the curvature condition\n#\n#           abs(gradf(x + stp * s)' * s)) <= gtol * abs(gradf(x)' * s).\n#\n#     If f_tol is less than gtol and if, for example, the function\n#     is bounded below, then there is always a step which satisfies\n#     both conditions. If no step can be found which satisfies both\n#     conditions, then the algorithm usually stops when rounding\n#     errors prevent further progress. In this case stp only\n#     satisfies the sufficient decrease condition.\n#\n#     The subroutine statement is\n#\n#        subroutine cvsrch(df,n,x,f,s,stp,f_tol,gtol,x_tol,\n#                          alphamin,alphamax,maxfev,info,nfev,wa)\n#\n#     where\n#\n# df is the name of the user-supplied subroutine which\n#    calculates the function and the gradient.  df must\n#    be declared in an external statement in the user\n#    calling program, and should be written as follows.\n#\n#    function [f,g] = df(n,x) (Matlab)\n#                     (10/2010 change in documentation)\n#                     (derived from Fortran subroutine df(n,x,f,g))\n#    integer n\n#    f\n#    x(n),g(n)\n#\n#    Calculate the function at x and\n#    return this value in the variable f.\n#    Calculate the gradient at x and\n#    return this vector in g.\n#\n#  n is a positive integer input variable set to the number\n#   of variables.\n#\n# x is an Abstractarray of length n. On input it must contain the\n#   base point for the line search. On output it contains\n#    x + stp * s.\n#\n# f is a variable. On input it must contain the value of f\n#    at x. On output it contains the value of f at x + stp * s.\n#\n# g is an Abstractarray of length n. On input it must contain the\n#    gradient of f at x. On output it contains the gradient\n#    of f at x + stp * s.\n#\n# s is an input Abstractarray of length n which specifies the\n#    search direction.\n#\n# stp is a nonnegative variable. On input stp contains an\n#    initial estimate of a satisfactory step. On output\n#    stp contains the final estimate.\n#\n#  f_tol and gtol are nonnegative input variables. Termination\n#    occurs when the sufficient decrease condition and the\n#    directional derivative condition are satisfied.\n#\n# x_tol is a nonnegative input variable. Termination occurs\n#    when the relative width of the interval of uncertainty\n#   is at most x_tol.\n#\n# alphamin and alphamax are nonnegative input variables which\n#   specify lower and upper bounds for the step.\n#\n# maxfev is a positive integer input variable. Termination\n#    occurs when the number of calls to df is at least\n#    maxfev by the end of an iteration.\n#\n# info is an integer output variable set as follows:\n#\n#   info = 0  Improper input parameters.\n#\n#   info = 1  The sufficient decrease condition and the\n#              directional derivative condition hold.\n#\n#   info = 2  Relative width of the interval of uncertainty\n#            is at most x_tol.\n#\n#   info = 3  Number of calls to df has reached maxfev.\n#\n#   info = 4  The step is at the lower bound alphamin.\n#\n#   info = 5  The step is at the upper bound alphamax.\n#\n#   info = 6  Rounding errors prevent further progress.\n#              There may not be a step which satisfies the\n#              sufficient decrease and curvature conditions.\n#              Tolerances may be too small.\n#\n#    nfev is an integer output variable set to the number of\n#         calls to df.\n#\n#     Argonne National Laboratory. MINPACK Project. June 1983\n#     Jorge J. More', David J. Thuente\n#\n#     **********\n\n# Returns x, f, stp, info, nfev\n# TODO: Decide whether to update x, f, g and info\n#       or just return step and nfev and let existing code do its job\n\n\"\"\"\nThe line search implementation from:\n  Moré, Jorge J., and David J. Thuente\n    Line search algorithms with guaranteed sufficient decrease.\n    ACM Transactions on Mathematical Software (TOMS) 20.3 (1994): 286-307.\n\"\"\"\n@with_kw struct MoreThuente{T}\n    f_tol::T = 1e-4 # c_1 Wolfe sufficient decrease condition\n    gtol::T = 0.9   # c_2 Wolfe curvature condition (Recommend 0.1 for GradientDescent)\n    x_tol::T = 1e-8\n    alphamin::T = 1e-16\n    alphamax::T = 65536.0\n    maxfev::Int = 100\nend\n\nfunction (ls::MoreThuente)(df::AbstractObjective, x::AbstractArray{T},\n                           s::AbstractArray{T}, alpha::Real, x_new::AbstractArray{T},\n                           ϕ_0, dϕ_0) where T\n    ϕdϕ = make_ϕdϕ(df, x_new, x, s)\n    ls(ϕdϕ, alpha, ϕ_0, dϕ_0)\nend\n\n(ls::MoreThuente)(ϕ, dϕ, ϕdϕ, alpha, ϕ_0, dϕ_0) = ls(ϕdϕ, alpha, ϕ_0, dϕ_0)\n\n# TODO: Should we deprecate the interface that only uses the ϕdϕ argument?\nfunction (ls::MoreThuente)(ϕdϕ,\n                           alpha::T,\n                           ϕ_0,\n                           dϕ_0) where T\n    @unpack f_tol, gtol, x_tol, alphamin, alphamax, maxfev = ls\n\n    iterfinitemax = -log2(eps(T))\n    info = 0\n    info_cstep = 1 # Info from step\n\n    zeroT = convert(T, 0)\n\n    #\n    # Check the input parameters for errors.\n    #\n\n    if  alpha <= zeroT || f_tol < zeroT || gtol < zeroT ||\n        x_tol < zeroT || alphamin < zeroT || alphamax < alphamin || maxfev <= zeroT\n        throw(LineSearchException(\"Invalid parameters to MoreThuente.\", 0))\n    end\n\n    if dϕ_0 >= zeroT\n        throw(LineSearchException(\"Search direction is not a direction of descent.\", 0))\n    end\n\n    #\n    # Initialize local variables.\n    #\n\n    bracketed = false\n    stage1 = true\n    nfev = 0\n    finit = ϕ_0\n    dgtest = f_tol * dϕ_0\n    width = alphamax - alphamin\n    width1 = 2 * width\n\n    # Keep this across calls\n\n    #\n    # The variables stx, fx, dgx contain the values of the step,\n    # function, and directional derivative at the best step.\n    # The variables sty, fy, dgy contain the value of the step,\n    # function, and derivative at the other endpoint of\n    # the interval of uncertainty.\n    # The variables alpha, f, dg contain the values of the step,\n    # function, and derivative at the current step.\n    #\n\n    stx = zeroT\n    fx = finit\n    dgx = dϕ_0\n    sty = zeroT\n    fy = finit\n    dgy = dϕ_0\n\n    # START: Ensure that the initial step provides finite function values\n    # This is not part of the original FORTRAN code\n    if !isfinite(alpha)\n        alpha = one(T)\n    end\n    stmin = stx\n    stmax = alpha + 4 * (alpha - stx) # Why 4?\n    alpha = max(alpha, alphamin)\n    alpha = min(alpha, alphamax)\n\n    f, dg = ϕdϕ(alpha)\n    nfev += 1 # This includes calls to f() and g!()\n    iterfinite = 0\n    while (!isfinite(f) || !isfinite(dg)) && iterfinite < iterfinitemax\n        iterfinite += 1\n        alpha = alpha/2\n\n        f, dg = ϕdϕ(alpha)\n        nfev += 1 # This includes calls to f() and g!()\n\n        # Make stmax = (3/2)*alpha < 2alpha in the first iteration below\n        stx = (convert(T, 7)/8)*alpha\n    end\n    # END: Ensure that the initial step provides finite function values\n\n    while true\n        #\n        # Set the minimum and maximum steps to correspond\n        # to the present interval of uncertainty.\n        #\n\n        if bracketed\n            stmin = min(stx, sty)\n            stmax = max(stx, sty)\n        else\n            stmin = stx\n            stmax = alpha + 4 * (alpha - stx) # Why 4?\n        end\n\n        #\n        # Ensure stmin and stmax (used in cstep) don't violate alphamin and alphamax\n        # Not part of original FORTRAN translation\n        #\n        stmin = max(alphamin,stmin)\n        stmax = min(alphamax,stmax)\n\n        #\n        # Force the step to be within the bounds alphamax and alphamin\n        #\n\n        alpha = max(alpha, alphamin)\n        alpha = min(alpha, alphamax)\n\n        #\n        # If an unusual termination is to occur then let\n        # alpha be the lowest point obtained so far.\n        #\n\n        if (bracketed && (alpha <= stmin || alpha >= stmax)) ||\n            nfev >= maxfev-1 || info_cstep == 0 ||\n            (bracketed && stmax - stmin <= x_tol * stmax)\n            alpha = stx\n        end\n\n        #\n        # Evaluate the function and gradient at alpha\n        # and compute the directional derivative.\n        #\n        f, dg = ϕdϕ(alpha)\n        nfev += 1 # This includes calls to f() and g!()\n\n        if isapprox(dg, 0, atol=eps(T)) # Should add atol value to MoreThuente\n            return alpha, f\n        end\n\n        ftest1 = finit + alpha * dgtest\n\n        #\n        # Test for convergence.\n        #\n\n        # What does info_cstep stand for?\n\n        if (bracketed && (alpha <= stmin || alpha >= stmax)) || info_cstep == 0\n            info = 6\n        end\n        if alpha == alphamax && f <= ftest1 && dg <= dgtest\n            info = 5\n        end\n        if alpha == alphamin && (f > ftest1 || dg >= dgtest)\n            info = 4\n        end\n        if nfev >= maxfev\n            info = 3\n        end\n        if bracketed && stmax - stmin <= x_tol * stmax\n            info = 2\n        end\n        if f <= ftest1 && abs(dg) <= -gtol * dϕ_0\n            info = 1\n        end\n\n        #\n        # Check for termination.\n        #\n\n        if info != 0\n            return alpha, f\n        end\n\n        #\n        # In the first stage we seek a step for which the modified\n        # function has a nonpositive value and nonnegative derivative.\n        #\n\n        if stage1 && f <= ftest1 && dg >= min(f_tol, gtol) * dϕ_0\n            stage1 = false\n        end\n\n        #\n        # A modified function is used to predict the step only if\n        # we have not obtained a step for which the modified\n        # function has a nonpositive function value and nonnegative\n        # derivative, and if a lower function value has been\n        # obtained but the decrease is not sufficient.\n        #\n\n        if stage1 && f <= fx && f > ftest1\n            #\n            # Define the modified function and derivative values.\n            #\n            fm = f - alpha * dgtest\n            fxm = fx - stx * dgtest\n            fym = fy - sty * dgtest\n            dgm = dg - dgtest\n            dgxm = dgx - dgtest\n            dgym = dgy - dgtest\n            #\n            # Call cstep to update the interval of uncertainty\n            # and to compute the new step.\n            #\n            stx, fxm, dgxm,\n            sty, fym, dgym,\n            alpha, fm, dgm,\n            bracketed, info_cstep =\n                cstep(stx, fxm, dgxm, sty, fym, dgym,\n                      alpha, fm, dgm, bracketed, stmin, stmax)\n            #\n            # Reset the function and gradient values for f.\n            #\n            fx = fxm + stx * dgtest\n            fy = fym + sty * dgtest\n            dgx = dgxm + dgtest\n            dgy = dgym + dgtest\n        else\n            #\n            # Call cstep to update the interval of uncertainty\n            # and to compute the new step.\n            #\n            stx, fx, dgx,\n            sty, fy, dgy,\n            alpha, f, dg,\n            bracketed, info_cstep =\n                cstep(stx, fx, dgx, sty, fy, dgy,\n                      alpha, f, dg, bracketed, stmin, stmax)\n        end\n\n        #\n        # Force a sufficient decrease in the size of the\n        # interval of uncertainty.\n        #\n\n        if bracketed\n            if abs(sty - stx) >= (convert(T, 2)/3) * width1\n                alpha = stx + (sty - stx)/2\n            end\n            width1 = width\n            width = abs(sty - stx)\n        end\n    end # while\nend # function\n\n\n# Translation of minpack subroutine cstep\n# Dianne O'Leary   July 1991\n#\n# Subroutine cstep\n#\n# The purpose of cstep is to compute a safeguarded step for\n# a linesearch and to update an interval of uncertainty for\n# a minimizer of the function.\n#\n# The parameter stx contains the step with the least function\n# value. The parameter stp contains the current step. It is\n# assumed that the derivative at stx is negative in the\n# direction of the step. If bracketed is set true then a\n# minimizer has been bracketed in an interval of uncertainty\n# with endpoints stx and sty.\n#\n# The subroutine statement is\n#\n# subroutine cstep(stx, fx, dgx,\n#                  sty, fy, dgy,\n#                  stp, f, dg,\n#                  bracketed, alphamin, alphamax, info)\n#\n# where\n#\n# stx, fx, and dgx are variables which specify the step,\n#   the function, and the derivative at the best step obtained\n#   so far. The derivative must be negative in the direction\n#   of the step, that is, dgx and stp-stx must have opposite\n#   signs. On output these parameters are updated appropriately\n#\n# sty, fy, and dgy are variables which specify the step,\n#   the function, and the derivative at the other endpoint of\n#   the interval of uncertainty. On output these parameters are\n#   updated appropriately\n#\n# stp, f, and dg are variables which specify the step,\n#   the function, and the derivative at the current step.\n#   If bracketed is set true then on input stp must be\n#   between stx and sty. On output stp is set to the new step\n#\n# bracketed is a logical variable which specifies if a minimizer\n#   has been bracketed. If the minimizer has not been bracketed\n#   then on input bracketed must be set false. If the minimizer\n#   is bracketed then on output bracketed is set true\n#\n# alphamin and alphamax are input variables which specify lower\n#   and upper bounds for the step\n#\n# info is an integer output variable set as follows:\n#   If info = 1,2,3,4,5, then the step has been computed\n#   according to one of the five cases below. Otherwise\n#   info = 0, and this indicates improper input parameters\n#\n# Argonne National Laboratory. MINPACK Project. June 1983\n# Jorge J. More', David J. Thuente\n\nfunction cstep(stx::Real, fx::Real, dgx::Real,\n               sty::Real, fy::Real, dgy::Real,\n               alpha::Real, f::Real, dg::Real,\n               bracketed::Bool, alphamin::Real, alphamax::Real)\n\n   T = promote_type(typeof(stx), typeof(fx), typeof(dgx), typeof(sty), typeof(fy), typeof(dgy), typeof(alpha), typeof(f), typeof(dg), typeof(alphamin), typeof(alphamax))\n   zeroT = convert(T, 0)\n   info = 0\n\n   #\n   # Check the input parameters for error\n   #\n\n   if (bracketed && (alpha <= min(stx, sty) || alpha >= max(stx, sty))) ||\n     dgx * (alpha - stx) >= zeroT || alphamax < alphamin\n       throw(ArgumentError(\"Minimizer not bracketed\"))\n   end\n\n   #\n   # Determine if the derivatives have opposite sign\n   #\n\n   sgnd = dg * (dgx / abs(dgx))\n\n   #\n   # First case. A higher function value.\n   # The minimum is bracketed. If the cubic step is closer\n   # to stx than the quadratic step, the cubic step is taken,\n   # else the average of the cubic and quadratic steps is taken\n   #\n\n   if f > fx\n      info = 1\n      bound = true\n      theta = 3 * (fx - f) / (alpha - stx) + dgx + dg\n      # Use s to prevent overflow/underflow of theta^2 and dgx * dg\n      s = max(abs(theta), abs(dgx), abs(dg))\n      gamma = s * sqrt((theta / s)^2 - (dgx / s) * (dg / s))\n      if alpha < stx\n          gamma = -gamma\n      end\n      p = gamma - dgx + theta\n      q = gamma - dgx + gamma + dg\n      r = p / q\n      alphac = stx + r * (alpha - stx)\n      alphaq = stx + (dgx / ((fx - f) / (alpha - stx) + dgx)) / 2 * (alpha - stx)\n      if abs(alphac - stx) < abs(alphaq - stx)\n         alphaf = alphac\n      else\n         alphaf = (alphac + alphaq) / 2\n      end\n      bracketed = true\n\n   #\n   # Second case. A lower function value and derivatives of\n   # opposite sign. The minimum is bracketed. If the cubic\n   # step is closer to stx than the quadratic (secant) step,\n   # the cubic step is taken, else the quadratic step is taken\n   #\n\nelseif sgnd < zeroT\n      info = 2\n      bound = false\n      theta = 3 * (fx - f) / (alpha - stx) + dgx + dg\n      # Use s to prevent overflow/underflow of theta^2 and dgx * dg\n      s = max(abs(theta), abs(dgx), abs(dg))\n      gamma = s * sqrt((theta / s)^2 - (dgx / s) * (dg / s))\n\n      if alpha > stx\n         gamma = -gamma\n      end\n      p = gamma - dg + theta\n      q = gamma - dg + gamma + dgx\n      r = p / q\n      alphac = alpha + r * (stx - alpha)\n      alphaq = alpha + (dg / (dg - dgx)) * (stx - alpha)\n      if abs(alphac - alpha) > abs(alphaq - alpha)\n         alphaf = alphac\n      else\n         alphaf = alphaq\n      end\n      bracketed = true\n\n   #\n   # Third case. A lower function value, derivatives of the\n   # same sign, and the magnitude of the derivative decreases.\n   # The cubic step is only used if the cubic tends to infinity\n   # in the direction of the step or if the minimum of the cubic\n   # is beyond alpha. Otherwise the cubic step is defined to be\n   # either alphamin or alphamax. The quadratic (secant) step is also\n   # computed and if the minimum is bracketed then the the step\n   # closest to stx is taken, else the step farthest away is taken\n   #\n\n   elseif abs(dg) < abs(dgx)\n      info = 3\n      bound = true\n      theta = 3 * (fx - f) / (alpha - stx) + dgx + dg\n      # Use s to prevent overflow/underflow of theta^2 and dgx * dg\n      s = max(abs(theta), abs(dgx), abs(dg))\n      #\n      # The case gamma = 0 only arises if the cubic does not tend\n      # to infinity in the direction of the step\n      #\n      # # Use NaNMath in case s == zero(s)\n      gamma = s * sqrt(NaNMath.max(zero(s), (theta / s)^2 - (dgx / s) * (dg / s)))\n\n      if alpha > stx\n          gamma = -gamma\n      end\n      p = gamma - dg + theta\n      q = gamma + dgx - dg + gamma\n      r = p / q\n      if r < zeroT && gamma != zeroT\n         alphac = alpha + r * (stx - alpha)\n     elseif alpha > stx\n         alphac = alphamax\n      else\n         alphac = alphamin\n      end\n      alphaq = alpha + (dg / (dg - dgx)) * (stx - alpha)\n      if bracketed\n         if abs(alpha - alphac) < abs(alpha - alphaq)\n            alphaf = alphac\n         else\n            alphaf = alphaq\n         end\n      else\n         if abs(alpha - alphac) > abs(alpha - alphaq)\n            alphaf = alphac\n         else\n            alphaf = alphaq\n         end\n      end\n\n   #\n   # Fourth case. A lower function value, derivatives of the\n   # same sign, and the magnitude of the derivative does\n   # not decrease. If the minimum is not bracketed, the step\n   # is either alphamin or alphamax, else the cubic step is taken\n   #\n\n   else\n      info = 4\n      bound = false\n      if bracketed\n         theta = 3 * (f - fy) / (sty - alpha) + dgy + dg\n         # Use s to prevent overflow/underflow of theta^2 and dgy * dg\n         s = max(abs(theta), abs(dgy), abs(dg))\n         gamma = s * sqrt((theta / s)^2 - (dgy / s) * (dg / s))\n\n         if alpha > sty\n             gamma = -gamma\n         end\n         p = gamma - dg + theta\n         q = gamma - dg + gamma + dgy\n         r = p / q\n         alphac = alpha + r * (sty - alpha)\n         alphaf = alphac\n     elseif alpha > stx\n         alphaf = alphamax\n      else\n         alphaf = alphamin\n      end\n   end\n\n   #\n   # Update the interval of uncertainty. This update does not\n   # depend on the new step or the case analysis above\n   #\n\n   if f > fx\n      sty = alpha\n      fy = f\n      dgy = dg\n   else\n      if sgnd < zeroT\n         sty = stx\n         fy = fx\n         dgy = dgx\n      end\n      stx = alpha\n      fx = f\n      dgx = dg\n   end\n\n   #\n   # Compute the new step and safeguard it\n   #\n\n   alphaf = min(alphamax, alphaf)\n   alphaf = max(alphamin, alphaf)\n   alpha = alphaf\n   if bracketed && bound\n      if sty > stx\n         alpha = min(stx + (convert(T, 2)/3) * (sty - stx), alpha)\n      else\n         alpha = max(stx + (convert(T, 2)/3) * (sty - stx), alpha)\n      end\n   end\n\n   return stx, fx, dgx, sty, fy, dgy, alpha, f, dg, bracketed, info\nend\n\n\n  esatta := proc( fun )\n    local res, alpha;\n    #res := Optimization[Minimize](\n    res := Optimization[NLPSolve](\n      fun(alpha),\n      {alpha >= 0, alpha <= 3},\n      #initialpoint={alpha=1},\n      iterationlimit=50\n    ):\n    subs(res[2],alpha);\n  end proc:\n\n  doplot := proc( f_in, df_in, alpha, amax)\n    local f0, df0, x, AA, BB, CC, DD;\n    f0  := evalf(f_in(0));\n    df0 := evalf(df_in(0));\n\n    AA := plot(f_in(x),x=0..amax);\n    BB := plot([[0,f0],[amax,f0+amax*rho*df0]],color=\"LimeGreen\");\n    CC := plot([[0,f0],[amax,f0+amax*sigma*df0]],color=\"blue\");\n    DD := plot([[alpha,f_in(alpha)]],color=\"red\",style = point);\n    display(AA,BB,CC,DD);\n  end;\n\n  doplot2 := proc( f_in, df_in, alpha, amax, A_list, B_list )\n    local i, f0, df0, x, AA, BB, CC, DD, EE;\n    f0  := evalf(f_in(0));\n    df0 := evalf(df_in(0));\n\n    AA := plot(f_in(x),x=0..amax);\n    BB := plot([[0,f0],[amax,f0+amax*rho*df0]],color=\"LimeGreen\");\n    CC := plot([[0,f0],[amax,f0+amax*sigma*df0]],color=\"blue\");\n    DD := plot([[alpha,f_in(alpha)]],color=\"red\",style = point);\n    EE := plot([seq([[A_list[i],-i/5],[B_list[i],-i/5]],i=1..nops(A_list))],color=\"black\");\n    display(AA,BB,CC,DD,EE);\n  end;\n\nend module:\n", "meta": {"hexsha": "2b74fa873224cc0b10a91f4cf44d014ead0b83f1", "size": 24117, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "maple/NL-MoreThuente.mpl", "max_stars_repo_name": "ebertolazzi/NLtoolbox", "max_stars_repo_head_hexsha": "99e47bdc346f3ac7b4834f2a6b431327d00e5ab1", "max_stars_repo_licenses": ["BSD-2-Clause", "Unlicense"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-28T09:12:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-28T09:12:53.000Z", "max_issues_repo_path": "maple/NL-MoreThuente.mpl", "max_issues_repo_name": "ebertolazzi/NLtoolbox", "max_issues_repo_head_hexsha": "99e47bdc346f3ac7b4834f2a6b431327d00e5ab1", "max_issues_repo_licenses": ["BSD-2-Clause", "Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "maple/NL-MoreThuente.mpl", "max_forks_repo_name": "ebertolazzi/NLtoolbox", "max_forks_repo_head_hexsha": "99e47bdc346f3ac7b4834f2a6b431327d00e5ab1", "max_forks_repo_licenses": ["BSD-2-Clause", "Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.8477722772, "max_line_length": 169, "alphanum_fraction": 0.5860181615, "num_tokens": 7060, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.746138993030751, "lm_q2_score": 0.6619228691808011, "lm_q1q2_score": 0.4938864630745885}}
{"text": "#####################################################################\n# this file contains some useful procedures for the computation of atan in\n# DDE\n\nrestart:\nDigits := 200:\n\nwith (numapprox):with(orthopoly):\nread \"double-extended.mpl\";\nread \"common-procedures.mpl\";\n\ne := 2^(-6.3):\nmarge := 2^(-30);\nP19 := convert(series(arctan(x),x=0,20),polynom):\nP18 := (P19-x)/x;\nQ18 := polyExact2Ext(P18, 9);\nQ9 := -1/3 +1/5*x - 1/7*x^2 + 1/9*x^3 - 1/11*x^4 + 1/13*x^5 - 1/15*x^6 + 1/17*x^7- 1/19*x^8;\nQprime := poly_exact( -x /3 + x^2/5 - x^3/7 + x^4 /9);\n#log2 (infnorm( (arctan(x)-x*(1+Q18))/x, x=0..e));\n\n#function taken from the \"old\" coef_atan to compute interval parameters.\nmaxx := bi -> simplify( solve( (x-bi) / (1+x*bi) = e ,x) ):\nminx := bi -> simplify(solve( (x-bi) /(1+x*bi)=-e ,x)):\nnextbi := proc (x) evalf( max(solve( minx(bi) = x ,bi) )*(1-marge)); end:\nallbi := proc (n)\nlocal xi,nbi,x,i,j;\nglobal b,a, nbofai, nbofbi, valuefordicho;\n    x := e;\n    nbi := 0;\n    i := 0;\n    while(i<n and nbi < 1/e and nbi >= 0) do\n        nbi := nearest ( nextbi(x) );\n        b[i] := evalf( nbi );\n        a[i] := x;\n        x   := evalf(maxx(nbi));\n        i:=i+1;\n    od;\n    j:=0;\n    while ( 2^j < i ) do j:=j+1 od:\n    nbofai := i;\n    nbofbi := i;\n    b[i-1] := nearest(1/e+4):\n    valuefordicho := 2^j;\n    return i,b[0],b[i-1];\nend:\nallbi(100);\n#-------------\n\n#-----------------------\n#quick error calc :\n#-----Reduction:-------\nXredEpsilon := 2^(-64) + 2^(-64) + 2^(-64) + 2^(-64):\nXred2Epsilon := 2*XredEpsilon + 2^(-64);\nlog[2.](Xred2Epsilon);\nerrlist:=errlist_quickphase_horner(degree(Qprime),0,0,Xred2Epsilon, 2^(-64));\nerrorr := compute_horner_rounding_error(Qprime,x,e,errlist,true);\nqEpsilon := errorr[1]:\nlog[2.](qEpsilon);\ndeltaApprox := e^11/11:\npolyDelta := e^3*qEpsilon + 2^(-64)*e+ 3*2^(-64)*e^3:\nEpsilonFinal := polyDelta/arctan(e)+2*2^(-64)+deltaApprox/e:\nlog[2.](EpsilonFinal);\n#------no reduction-------\nErrlist:=errlist_quickphase_horner(degree(Qprime),0,0,0, 2**(-64)):\nqEpsilon:= compute_horner_rounding_error(Qprime,x,e,errlist,true)[1]:\ndeltaApprox := e^11/5:\nEpsilonFinalNoRed := infnorm( (qEpsilon.x^3+2^(-64).x+2^(-64).x^3)/arctan(x),x=2^(-27)..2^(-6) ) + deltaApprox + 2^(-64):\nlog[2.](EpsilonFinalNoRed);\n#-----------------------\n\n# Output :\n\ndoth:=proc()\n local filename, fd, i, hi, lo;\n   filename := \"TEMPATAN/atan_ext.h\":\n    fd := fopen (filename,WRITE,TEXT):\n    fprintf(fd,\"/* file generated by atan_ext.mpl*/\\n\\n\"):\n    fprintf(fd,\"#include \\\"double_ext.h\\\"\\n\"):\n\n    fprintf(fd, \"static const double  HALFPI = %1.50e;\\n\", nearest(Pi/2)):\n\n    fprintf(fd, \"#define MIN_REDUCTION_NEEDED %s\\n\",  printDoubleAsHexInt(e)):\n    fprintf(fd,\"#define A 0\\n\"):\n    fprintf(fd,\"#define B 1\\n\"):\n    fprintf(fd,\"#define ATAN_BHI 0\\n\"):\n    fprintf(fd,\"#define ATAN_BLO 1\\n\"):\n\n    fprintf(fd,\"#define epsilon %1.50e\\n\", EpsilonFinal):\n    fprintf(fd,\"#define epsilon_no_red %1.50e\\n\",EpsilonFinalNoRed):\n    fprintf(fd,\"#define TWO_M_64 %1.50e\\n\",2^(-64)):\n    fprintf(fd,\"#define TWO_10 %1.50e\\n\",2^10):\n\n    if 1+1=3 then\n        fprintf(fd, \"__declspec(align(16)) static const unsigned long long int a_table[%d] = {\\n\", nbofai );\n        for i from 0 to nbofai - 1 do\n            fprintf(fd, \" /*a[%d] ~= %1.20e   */ \",i,a[i]):\n            fprintf(fd, \"  %s,\\n\", printDoubleAsULL(a[i]));\n        od:\n        fprintf(fd,\"\\n};\\n\"):\n\n        fprintf(fd, \"static const double b_table[%d] = {\\n\", nbofai );\n        for i from 0 to nbofai - 1 do\n            fprintf(fd, \"   /*b[%d] = */   %1.50e,\\n\", i, b[i]):\n        od:\n        fprintf(fd,\"\\n};\\n\"):\n\n    else\n        fprintf(fd, \"static const struct{long long int a; double b;} ab_table[%d] = {\\n\", nbofai);\n        for i from 0 to nbofai - 1 do\n            fprintf(fd, \" { /*a[%d] ~= %1.20e   */ \",i,a[i]):\n            fprintf(fd, \"  %s,\\n\", printDoubleAsULL(a[i]));\n            fprintf(fd, \"   /*b[%d] = */   %1.50e},\\n\", i, b[i]):\n        od:\n        fprintf(fd,\"\\n};\\n\"):\n\n    fi:\n\n    fprintf(fd, \"#define atanb_table ((const XC_FLOAT_TYPE *)_atanb_table)\\n\");\n    fprintf(fd, \"__declspec(align(16)) static const unsigned short _atanb_table[] = {\\n\", nbofai );\n    for i from 0 to nbofai - 1 do\n        fprintf(fd, \" /*atan_b[%d] ~= %1.10e*/\\n \",i, arctan(b[i])):\n        hi:=nearestExt(arctan(b[i]));\n        lo:=arctan(b[i])-nearestExt(arctan(b[i]));\n        fprintf(fd, \" %s, \\n\", printDoubleExtAsShort(hi));\n        fprintf(fd, \"   %s, \\n\", printDoubleExtAsShort(lo));\n    od:\n    fprintf(fd,\"};\\n\"):\n\n    printPolyExt(fd,Q9,4,\"coef_poly\"):\n    fclose(fd):\nend proc;\n\ndoth();\n\n", "meta": {"hexsha": "dd5140d8cd91371b51a814bcb26d1aca737f7cbe", "size": 4569, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "crlibm/maple/atan-itanium.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/atan-itanium.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/atan-itanium.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": 33.8444444444, "max_line_length": 121, "alphanum_fraction": 0.5491354782, "num_tokens": 1670, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744850834649, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.49375925798401304}}
{"text": "# The goal here is to set up a simplicial complex K and an embedding of\n# |K| in R^3 such that the image is a version of the standard \"pair of\n# pants space\", or in other words a sphere with three discs removed.\n# More specifically, we start with the unit sphere in R^3, and remove\n# three discs of radius 1/2 centred at points equally spaced around\n# the plane perpendicular to [1,1,1].  This has an evident linear action\n# of the group G = S_3 x C_2, and everything will be equivariant with\n# respect to this.  There is a fundamental domain for the action on S^2\n# that is a spherical triangle with one vertex at [1,1,1]/sqrt(3) and\n# the other two vertices separated by Pi/3 on the equator perpendicular\n# to [1,1,1].  One boundary circle meets this domain in a quarter\n# circle, and the other boundary circles do not intersect it at all.\n# We start by setting up a triangulation of the fundamental domain\n# such that this quarter circle is essentially a subcomplex.  We\n# can then propagate this equivariantly and remove the boundary\n# discs to obtain a triangulated surface of the required homeomorphism\n# type.  We can glue a standard horizontal cylinder to each boundary\n# circle to connect to other pieces and so construct various surfaces.\n# However, this is ugly because the tangent spaces do not line up\n# along the glued circles.  To fix this, we construct a map\n# f : S^2 -> R^3 with the property the f is the identity on our\n# boundary circles but acts near those circles in such a way as to\n# line up the tangent spaces with a horizontal cylinder.\n\nlib_read(\"brent.mpl\"):\n\nmake_pants_complex := proc(verbose := false)\n local plot_opts,dp,G,T,U,V,xx,i,j,k,lm,m,v,g,gi,gx,E,R,f2,sphere_retract,\n  xa,xb,xc,ua,rb,rels,F,a,n,s,t,u;\n global pants_group,pants_sphere_sector_complex,pants_sphere_complex,\n  pants_complex,condensed_pants_complex;\n \n plot_opts := scaling=constrained, axes=none:\n dp := `dot/R`(3);\n\n if verbose then printf(\"Making group\\n\"); fi;\n \n # This is the group S_3 x C_2, which will act isometrically on everything.\n G := table():\n pants_group := eval(G);\n G[\"elements\"] := [seq(seq([op(u),s],u in combinat[permute](3)),s in [1,-1])]:\n G[\"id\"] := [1,2,3,1]:\n G[\"o\"] := (u,v) -> [u[v[1]],u[v[2]],u[v[3]],u[4] * v[4]]:\n G[\"inv\"] := proc(u)\n  local ui,i;\n  ui := table():\n  for i from 1 to 3 do ui[u[i]] := i; od:\n  return [ui[1],ui[2],ui[3],u[4]];\n end:\n\n if verbose then printf(\"Making skeleton\\n\"); fi;\n T := table():\n pants_sphere_sector_complex := eval(T):\n \n T[\"u\"] := table([\n   1 = [ 2,-1,-1] /~ sqrt(6),\n   2 = [ 1, 1,-2] /~ sqrt(6),\n   3 = [-1, 2,-1] /~ sqrt(6),\n   4 = [-2, 1, 1] /~ sqrt(6),\n   5 = [-1,-1, 2] /~ sqrt(6),\n   6 = [ 1,-2, 1] /~ sqrt(6),\n ##\n   7 = [ 1, 1, 1] /~ sqrt(3),\n   8 = [-1,-1,-1] /~ sqrt(3),\n ##\n   9 = [ 0, 1,-1] /~ sqrt(2),\n  10 = [-1, 1, 0] /~ sqrt(2),\n  11 = [-1, 0, 1] /~ sqrt(2),\n  12 = [ 0,-1, 1] /~ sqrt(2),\n  13 = [ 1,-1, 0] /~ sqrt(2),\n  14 = [ 1, 0,-1] /~ sqrt(2)\n ]):\n\n T[\"u_index\"] := table():\n for i from 0 to 13 do \n  T[\"u_index\"][T[\"u\"][i]] := i;\n  T[\"u_index\"][simplify(T[\"u\"][i])] := i;\n od:\n\n xx := [x[1],x[2],x[3]];\n \n T[\"act_R3\"] := table():\n for g in G[\"elements\"] do \n  gi := G[\"inv\"](g);\n  gx := [x[gi[1]],x[gi[2]],x[gi[3]]];\n  if g[4] = -1 then \n   gx := expand(gx -~ (2/3 * dp([1,1,1],gx)) *~ [1,1,1]); \n  fi;\n  T[\"act_R3\"][g] := unapply(gx,x);\n od:\n\n T[\"act_u_table\"] := table():\n T[\"act_u\"] := table():\n for g in G[\"elements\"] do \n  T[\"act_u_table\"][g] := \n   table([seq(i = T[\"u_index\"][simplify(T[\"act_R3\"][g](T[\"u\"][i]))],i=0..13)]);\n  T[\"act_u\"][g] := (i) -> T[\"act_u_table\"][g][i];\n od:\n\n T[\"equator\"] := unapply(cos(t) *~ T[\"u\"][1] +~ sin(t) *~ T[\"u\"][9],t):\n T[\"equator_plot\"] := \n  spacecurve(T[\"equator\"](t),t=0..2*Pi,colour=green,plot_opts):\n T[\"equator_sector_plot\"] := \n  spacecurve(T[\"equator\"](t),t=0..Pi/3,colour=green,plot_opts):\n\n T[\"longitude\"] := table():\n T[\"longitude_plot\"] := table():\n for i from 1 to 6 do \n  T[\"longitude\"][i] :=\n   unapply(expand(sin(t) *~ T[\"u\"][7] +~ cos(t) *~ T[\"u\"][i]),t); \n  T[\"longitude_plot\"][i] :=\n   spacecurve(T[\"longitude\"][i](t),t=-Pi/2..Pi/2,colour=blue,plot_opts):\n od:\n T[\"longitude_sector_plot\"] := \n  display(\n   spacecurve(T[\"longitude\"][1](t),t=0..Pi/2,colour=blue,plot_opts),\n   spacecurve(T[\"longitude\"][2](t),t=0..Pi/2,colour=blue,plot_opts),\n   plot_opts\n  ):\n\n T[\"boundary_circle\"] := table():\n T[\"boundary_circle_plot\"] := table():\n for i from 1 to 3 do \n  T[\"boundary_circle\"][i] :=\n   unapply(expand((sqrt(3)/2) *~ T[\"u\"][2*i-1] +~ (cos(t)/2) *~ T[\"u\"][2*i+7] +~ (sin(t)/2) *~ T[\"u\"][7]),t); \n  T[\"boundary_circle_plot\"][i] :=\n   spacecurve(T[\"boundary_circle\"][i](t),t=0..2*Pi,colour=red,plot_opts)\n od:\n T[\"boundary_circle_sector_plot\"] :=\n   spacecurve(T[\"boundary_circle\"][1](t),t=0..Pi/2,colour=red,plot_opts):\n\n T[\"wire_sphere_plot\"]  := sphere(colour=grey,style=wireframe):\n T[\"solid_sphere_plot\"] := sphere(colour=grey,style=patchnogrid):\n T[\"wire_sector_plot\"]  := \n  plot3d(cos(t) *~ T[\"u\"][7] +~ sin(t) *~ (cos(u) *~ T[\"u\"][1] +~ sin(u) *~ T[\"u\"][9]),\n\t t = 0 .. Pi/2,u = 0 .. Pi/3,\n\t colour=grey,style=wireframe,scaling=constrained, axes=none):\n T[\"solid_sector_plot\"]  := \n  plot3d(cos(t) *~ T[\"u\"][7] +~ sin(t) *~ (cos(u) *~ T[\"u\"][1] +~ sin(u) *~ T[\"u\"][9]),\n\t t = 0 .. Pi/2,u = 0 .. Pi/3,\n\t colour=grey,style=patchnogrid,scaling=constrained, axes=none):\n\n T[\"line_plot\"] := display(\n  T[\"equator_plot\"],\n  seq(T[\"longitude_plot\"][i],i=1..6),\n  seq(T[\"boundary_circle_plot\"][i],i=1..3)\n ):\n \n T[\"sphere_plot\"] := display(\n  T[\"solid_sphere_plot\"],T[\"line_plot\"],\n  plot_opts\n ):\n\n T[\"line_sector_plot\"] := display(\n  T[\"equator_sector_plot\"],\n  T[\"longitude_sector_plot\"],\n  T[\"boundary_circle_sector_plot\"],\n  plot_opts\n ):\n\n T[\"sector_plot\"] := display(\n  T[\"solid_sector_plot\"],T[\"line_sector_plot\"],\n  plot_opts\n ):\n\n lm := 4:\n m := 2 ^ lm:\n T[\"m\"] := m:\n\n if verbose then printf(\"Making simplices\\n\"); fi;\n\n v := (i,j) -> [i/m,j/m,(m-i-j)/m]:\n\n T[\"vertices\"] := [seq(seq(v(i,j),j=0..m - i),i=0..m)]:\n\n T[\"edges\"] := [\n  seq(seq([v(i,j),v(i+1,j)],j=0..m-1-i),i=0..m-1),\n  seq(seq([v(i,j),v(i,j+1)],j=0..m-1-i),i=0..m-1),\n  seq(seq([v(i+1,j),v(i,j+1)],j=0..m-1-i),i=0..m-1),\n NULL\n ]:\n\n T[\"faces\"] := [\n  seq(seq([v(i,j),v(i+1,j),v(i,j+1)],j=0..m-1-i),i=0..m-1),\n  seq(seq([v(i,j+1),v(i+1,j),v(i+1,j+1)],j=0..m-2-i),i=0..m-2)\n ]:\n\n T[\"max_simplices\"] := T[\"faces\"]:\n\n if verbose then printf(\"Making explicit embedding\\n\"); fi;\n\n unassign('i');\n T[\"f0\"] := unapply(i[1] *~ T[\"u\"][1] +~ i[2] *~ T[\"u\"][2] +~ i[3] *~ T[\"u\"][7],i):\n T[\"f1\"] := proc(i) local x; x := T[\"f0\"](i); return x /~ sqrt(add(x[j]^2,j=1..3)); end:\n T[\"embedding0\"] := table():\n T[\"embedding1\"] := table():\n for i in T[\"vertices\"] do \n  T[\"embedding0\"][i] := T[\"f0\"](i);\n  T[\"embedding1\"][i] := T[\"f1\"](i);\n od:\n\n E := table():\n for i in T[\"vertices\"] do E[i] := NULL; od:\n\n for i from 0 to m do \n   E[[m-i,i,0] /~ m] := T[\"equator\"](i/m * Pi/3);\n   E[[0,m-i,i] /~ m] := T[\"longitude\"][2](i/m * Pi/2);\n od:\n for i from 0 to m/2 do \n   E[[m-i,0,i]       /~ m] := T[\"longitude\"][1]((2*i/m) * Pi/6); \n   E[[m/2-i,0,m/2+i] /~ m] := T[\"longitude\"][1]((1+4*i/m) * Pi/6); \n   E[[m/2,m/2-i,i]   /~ m] := T[\"boundary_circle\"][1]((2*i/m) * Pi/2);\n od:\n\n sphere_retract := (u) -> evalf(u /~ sqrt(add(u[i]^2,i=1..3))):\n\n `midpoint_extend/simplicial_complex`(E,4,sphere_retract):\n T[\"embedding2\"] := eval(E):\n T[\"embedding\"] := eval(E):\n `plot/simplicial_complex`(T):\n `surface_plot/simplicial_complex`(T):\n\n T[\"proj\"] := table():\n for k from 1 to 3 do \n  T[\"proj\"][k] := unapply(expand(xx - dp(x,T[\"u\"][2*k-1]) *~ T[\"u\"][2*k-1]),x);\n od:\n\n T[\"proj_a\"] := unapply([dp(xx,T[\"u\"][ 1]),dp(xx,T[\"u\"][12])],x):\n T[\"proj_b\"] := unapply([dp(xx,T[\"u\"][ 5]),dp(xx,T[\"u\"][ 7])],x):\n T[\"proj_c\"] := unapply([dp(xx,T[\"u\"][ 1]),dp(xx,T[\"u\"][ 7])],x):\n T[\"proj_d\"] := unapply([dp(xx,T[\"u\"][12]),dp(xx,T[\"u\"][ 7])],x):\n\n unassign('s');\n \n T[\"unproj_a\"] := unapply(s[1] *~ T[\"u\"][ 1] +~ s[2] *~ T[\"u\"][12], s); \n T[\"unproj_b\"] := unapply(s[1] *~ T[\"u\"][ 5] +~ s[2] *~ T[\"u\"][ 7], s); \n T[\"unproj_c\"] := unapply(s[1] *~ T[\"u\"][ 1] +~ s[2] *~ T[\"u\"][ 7], s); \n T[\"unproj_d\"] := unapply(s[1] *~ T[\"u\"][12] +~ s[2] *~ T[\"u\"][ 7] +~ (sqrt(3)/2) *~ T[\"u\"][1], s); \n\n T[\"g\"] := unapply(expand(mul(dp(x,T[\"u\"][2*j-1]) - sqrt(3)/2,j=1..3)),x):\n T[\"h\"] := unapply(expand((2 + dp(x,T[\"u\"][7]) ^ 2)*sqrt(3)/4),x):\n\n # Here we define a particular polynomial function k(x), and then we\n # define f(x) in terms of k(x).  Most of the desired properties hold\n # independently of the choice of k(x).  Our particular choice is\n # designed to straighten out the tangent spaces on the boundary\n # circles and ensure that the width of he surface in the centre\n # is the same as the width of the circles.\n T[\"k\"] := (x) -> (20 + 5 * sqrt(2) * x[1] - 15 * x[1]^2 + 5 * sqrt(2) * x[1]^3 + \n\t\t   (4 * x[1] - 3 * sqrt(2)) * (x[2] + x[3]) + \n\t\t   (8 * sqrt(2) * x[1] - 26) * x[2] * x[3] + \n\t\t   (-5) * sqrt(2) * (x[2] + x[3]) * x[2] * x[3])/27:\n T[\"f2\"] := unapply(simplify(\n   xx +~ \n    (T[\"g\"](x)/T[\"h\"](x)) *~ (\n      T[\"k\"]([x[1],x[2],x[3]]) *~ T[\"proj\"][1](x) +~\n      T[\"k\"]([x[2],x[3],x[1]]) *~ T[\"proj\"][2](x) +~\n      T[\"k\"]([x[3],x[1],x[2]]) *~ T[\"proj\"][3](x))),\n   x):\n\n for i in T[\"vertices\"] do \n  T[\"embedding3\"][i] := evalf(T[\"f2\"](T[\"embedding2\"][i]));\n od:\n T[\"embedding\"] := eval(T[\"embedding4\"]);\n\n if verbose then printf(\"Making implicit embedding\\n\"); fi;\n\n # We now start to define an alternative embedding, using the surface\n # where the following function is zero.\n T[\"l\"] := unapply(\n  12*sqrt(3)*T[\"g\"](xx) + (1-dp(xx,xx))*(27+6*(x[1]*x[2]+x[2]*x[3]+x[3]*x[1])+\n  8*sqrt(3)*T[\"g\"](xx)-6*dp(xx,xx)),x):\n T[\"l_min_root\"] := fsolve(expand(T[\"l\"]((-t) *~ T[\"u\"][1])),t=0.68..0.70);\n T[\"l_max_root\"] := fsolve(expand(T[\"l\"](t *~ T[\"u\"][1])),t=1.42..1.43);\n xa := (r * cos(t)) *~ T[\"u\"][1] +~ (r * sin(t)) *~ T[\"u\"][9] +~ u *~ T[\"u\"][7]:\n ua := solve(simplify(expand(T[\"l\"](xa))),u)[1]:\n ua := sqrt(factor(ua^2)):\n xa := subs(u = ua,xa):\n T[\"chart_a\"] := unapply(xa,r,t):\n xb := (r * cos(t)) *~ T[\"u\"][9] +~ (r * sin(t)) *~ T[\"u\"][7] +~ u *~ T[\"u\"][1]:\n rb := solve(simplify(expand(T[\"l\"](xb))),r)[3]:\n rb := 1/sqrt(factor(expand(rationalize(1/rb^2)))):\n xb := subs(r = rb,xb): \n T[\"chart_b\"] := unapply(xb,u,t):\n xc := (a[0] - a[1] * r^2 - a[2] * r^4) *~ T[\"u\"][1] +~ r *~ (cos(t) *~ T[\"u\"][9] +~ sin(t) *~ T[\"u\"][7]):\n rels := expand([coeffs(collect(simplify(expand(convert(series(T[\"l\"](xc),r=0,5),polynom,r))),r),r)]):\n xc := expand(evalf(subs(a[0] = T[\"l_max_root\"],subs(solve([rels[2],rels[3]],{a[1],a[2]}),xc)))):\n T[\"chart_c\"] := unapply(xc,r,t):\n\n T[\"dl\"] := unapply([seq(diff(T[\"l\"](xx),x[i]),i=1..3)],x);\n \n T[\"retract\"] := proc(x)\n  local g,y,sols;\n  g := evalf(T[\"dl\"](x));\n  g := g /~ sqrt(add(g[i]^2,i=1..3));\n  y := x +~ t *~ g;\n  sols := [fsolve(evalf(expand(T[\"l\"](y))),t)];\n  sols := select(t -> abs(t) = min(map(abs,sols)),sols);\n  if sols = [] then error(\"No solutions\"); fi;\n  return(evalf(subs(t = sols[1],y)));\n end:\n\n T[\"step\"] := proc(q,d0,proj,unproj)\n  local xx,st0,mx,dx,g,h,sol;\n  xx  := eval(unproj([s,t]));\n  st0 := eval(proj(q));\n  mx := evalf(T[\"l\"](xx));\n  dx := (s - st0[1])^2 + (t - st0[2])^2 - d0^2;\n  g := evalf(subs({s = st0[1],t = st0[2]},[-diff(mx,t),diff(mx,s)]));\n  g := (d0 / sqrt(g[1]^2+g[2]^2)) *~ g;\n  h := st0 +~ g;\n  sol := fsolve({mx,dx},{s = h[1], t = h[2]});\n  return evalf(subs(sol,xx));\n end:\n\n F[0] := (E) -> proc(d0)\n  local i;\n  E[[1,0,0]] := evalf(T[\"l_max_root\"] *~ T[\"u\"][1]);\n  for i from 1 to 8 do\n   E[[16-i,i,0] /~ 16] := T[\"step\"](E[[17-i,i-1,0]/~16],d0,T[\"proj_a\"],T[\"unproj_a\"]):\n  od:\n  return table([\"err\" = evalf(sqrt(3)/2 - dp(T[\"u\"][1],E[[1/2,1/2,0]]))]);\n end:\n\n F[1] := (E) -> proc(d0)\n  global p; local i;\n  E[[1/2,1/2,0]] := T[\"u\"][14];\n  for i from 1 to 8 do\n   E[[8-i,8+i,0]/~16] := T[\"step\"](E[[9-i,7+i,0]/~16],d0,T[\"proj_a\"],T[\"unproj_a\"]):\n  od:\n  return table([\"err\" = evalf(dp(T[\"u\"][10],E[[0,1,0]]))]);\n end:\n\n F[2] := (E) -> proc(d0)\n  global p; local i;\n  E[[0,1,0]] := evalf(T[\"l_min_root\"] *~ T[\"u\"][2]):\n  for i from 1 to 16 do\n   E[[0,16-i,i]/~16] := T[\"step\"](E[[0,17-i,i-1]/~16],d0,T[\"proj_b\"],T[\"unproj_b\"]):\n  od:\n  return table([\"err\" = evalf(-dp(T[\"u\"][9],E[[0,0,1]]))]);\n end:\n\n F[3] := (E) -> proc(d0)\n  global p; local i;\n  E[[0,0,1]] := T[\"u\"][7] /~ 2:\n  for i from 1 to 8 do\n   E[[i,0,16-i]/~16] := T[\"step\"](E[[i-1,0,17-i]/~16],d0,T[\"proj_c\"],T[\"unproj_c\"]):\n  od:\n  return table([\"err\" = evalf(dp(E[[1/2,0,1/2]],T[\"u\"][1]) - sqrt(3)/2)]);\n end:\n\n F[4] := (E) -> proc(d0)\n  global p; local i,e;\n  E[[1/2,0,1/2]] := (sqrt(3)/2) *~ T[\"u\"][1] +~ (1/2) *~ T[\"u\"][7];\n  for i from 1 to 8 do\n   E[[8+i,0,8-i]/~16] := T[\"step\"](E[[7+i,0,9-i]/~16],d0,T[\"proj_c\"],T[\"unproj_c\"]):\n  od:\n  e := - evalf(dp(E[[1,0,0]],T[\"u\"][7]));\n  E[[1,0,0]] := evalf(T[\"l_max_root\"] *~ T[\"u\"][1]);\n  return table([\"err\" = e]);\n end:\n\n F[5] := (E) -> proc(d0)\n  global p; local i,e;\n  for i from 1 to 8 do \n   E[[8,8-i,i]/~16] := T[\"step\"](E[[8,9-i,i-1]/~16],d0,T[\"proj_d\"],T[\"unproj_d\"]): \n  od: \n  e := - evalf(dp(E[[1/2,0,1/2]],T[\"u\"][9]));\n  E[[1/2,0,1/2]] := (sqrt(3)/2) *~ T[\"u\"][1] +~ (1/2) *~ T[\"u\"][7];\n  return table([\"err\" = e]);\n end:\n\n E := table():\n for i in T[\"vertices\"] do E[i] := NULL; od:\n T[\"F_step\"] := table([0 = 0.10, 1 = 0.06, 2 = 0.05, 3 = 0.10, 4 = 0.10, 5 = 0.09]):\n T[\"F_error\"] := table():\n for i from 0 to 5 do\n  T[\"F_step\"][i] :=\n   brent_fsolve(F[i](E),T[\"F_step\"][i],T[\"F_step\"][i] + 0.01,false,false,10.^(-10))[1];\n  T[\"F_error\"][i] := F[i](E)(T[\"F_step\"][i]);\n od:\n\n `midpoint_extend/simplicial_complex`(E,4,T[\"retract\"]):\n\n T[\"embedding4\"] := eval(E);\n \n if verbose then printf(\"Extending equivariantly\\n\"); fi;\n\n U := table():\n pants_sphere_complex := eval(U);\n U[\"act_i\"] := table():\n U[\"act_i\"][[1,2,3, 1]] := (j) -> [ j[1], j[2], j[3], j[4]]:\n U[\"act_i\"][[2,3,1, 1]] := (j) -> [-j[2],-j[3], j[1], j[4]]:\n U[\"act_i\"][[3,1,2, 1]] := (j) -> [ j[3],-j[1],-j[2], j[4]]:\n U[\"act_i\"][[2,1,3, 1]] := (j) -> [ j[3], j[2], j[1], j[4]]:\n U[\"act_i\"][[3,2,1, 1]] := (j) -> [-j[2],-j[1], j[3], j[4]]:\n U[\"act_i\"][[1,3,2, 1]] := (j) -> [ j[1],-j[3],-j[2], j[4]]:\n U[\"act_i\"][[1,2,3,-1]] := (j) -> [ j[1], j[2], j[3],-j[4]]:\n U[\"act_i\"][[2,3,1,-1]] := (j) -> [-j[2],-j[3], j[1],-j[4]]:\n U[\"act_i\"][[3,1,2,-1]] := (j) -> [ j[3],-j[1],-j[2],-j[4]]:\n U[\"act_i\"][[2,1,3,-1]] := (j) -> [ j[3], j[2], j[1],-j[4]]:\n U[\"act_i\"][[3,2,1,-1]] := (j) -> [-j[2],-j[1], j[3],-j[4]]:\n U[\"act_i\"][[1,3,2,-1]] := (j) -> [ j[1],-j[3],-j[2],-j[4]]:\n\n U[\"vertex_convert\"] := (i) -> [i[1],i[2],0,i[3]]:\n U[\"edge_convert\"]   := (e) -> sort(map(U[\"vertex_convert\"],e)):\n U[\"face_convert\"]   := (f) -> sort(map(U[\"vertex_convert\"],f)):\n\n U[\"embedding0\"] := table():\n U[\"embedding1\"] := table():\n U[\"embedding2\"] := table():\n U[\"embedding3\"] := table():\n U[\"embedding4\"] := table():\n U[\"vertices\"] := map(U[\"vertex_convert\"],T[\"vertices\"]):\n for i in T[\"vertices\"] do \n  U[\"embedding0\"][U[\"vertex_convert\"](i)] := evalf(T[\"embedding0\"][i]);\n  U[\"embedding1\"][U[\"vertex_convert\"](i)] := evalf(T[\"embedding1\"][i]);\n  U[\"embedding2\"][U[\"vertex_convert\"](i)] := evalf(T[\"embedding2\"][i]);\n  U[\"embedding3\"][U[\"vertex_convert\"](i)] := evalf(T[\"embedding3\"][i]);\n  U[\"embedding4\"][U[\"vertex_convert\"](i)] := evalf(T[\"embedding4\"][i]);\n od:\n\n for i in U[\"vertices\"] do\n  for g in G[\"elements\"] do \n   U[\"embedding0\"][U[\"act_i\"][g](i)] := evalf(T[\"act_R3\"][g](U[\"embedding0\"][i]));\n   U[\"embedding1\"][U[\"act_i\"][g](i)] := evalf(T[\"act_R3\"][g](U[\"embedding1\"][i]));\n   U[\"embedding2\"][U[\"act_i\"][g](i)] := evalf(T[\"act_R3\"][g](U[\"embedding2\"][i]));\n   U[\"embedding3\"][U[\"act_i\"][g](i)] := evalf(T[\"act_R3\"][g](U[\"embedding3\"][i]));\n   U[\"embedding4\"][U[\"act_i\"][g](i)] := evalf(T[\"act_R3\"][g](U[\"embedding4\"][i]));\n  od:\n od:\n U[\"embedding\"] := eval(U[\"embedding4\"]);\n\n U[\"vertices\"] := sort(map(op,[indices(U[\"embedding0\"])])):\n U[\"edges\"] :=\n  {seq(seq(sort(map(U[\"act_i\"][g],U[\"edge_convert\"](e))),\n    e in T[\"edges\"]),g in G[\"elements\"])}:\n U[\"edges\"] := sort([op(U[\"edges\"])]):\n U[\"faces\"] :=\n  {seq(seq(sort(map(U[\"act_i\"][g],U[\"face_convert\"](f))),\n    f in T[\"faces\"]),g in G[\"elements\"])}:\n U[\"faces\"] := sort([op(U[\"faces\"])]):\n\n R := T[\"act_R3\"][[1,2,3,-1]];\n f2 := T[\"f2\"];\n \n U[\"smooth_plot\"] := \n  display(\n   plot3d(  f2(sqrt(1-r^2) *~ T[\"u\"][7] +~ (r * cos(t)) *~ T[\"u\"][1] +~ (r * sin(t)) *~ T[\"u\"][9]),\n          r=0..0.6,t=0..2*Pi,style=patchnogrid),\n   plot3d(R(f2(sqrt(1-r^2) *~ T[\"u\"][7] +~ (r * cos(t)) *~ T[\"u\"][1] +~ (r * sin(t)) *~ T[\"u\"][9])),\n          r=0..0.6,t=0..2*Pi,style=patchnogrid),\n   plot3d(  f2(cos(s) *~ T[\"u\"][7] +~ (sin(s) * cos(t)) *~ T[\"u\"][1] +~ (sin(s) * sin(t)) *~ T[\"u\"][9]),\n          s=0.2*Pi..0.8*Pi,t=0..2*Pi,style=patchnogrid,numpoints=4000),\n   plot_opts\n  );\n\n U[\"chart_plot\"] := display(\n  plot3d(xa,r=0..0.5,t=0..2*Pi,style=patchnogrid),\n  plot3d(T[\"act_R3\"][[1,2,3,-1]](xa),r=0..0.5,t=0..2*Pi,style=patchnogrid),\n  plot3d(xb,u=0..1.4,t=0..2*Pi,style=patchnogrid),\n  plot3d(T[\"act_R3\"][[2,3,1,1]](xb),u=0..1.4,t=0..2*Pi,style=patchnogrid),\n  plot3d(T[\"act_R3\"][[3,1,2,1]](xb),u=0..1.4,t=0..2*Pi,style=patchnogrid),\n  plot3d(xc,r=0..0.3,t=0..2*Pi,style=patchnogrid),\n  plot3d(T[\"act_R3\"][[2,3,1,1]](xc),r=0..0.3,t=0..2*Pi,style=patchnogrid),\n  plot3d(T[\"act_R3\"][[3,1,2,1]](xc),r=0..0.3,t=0..2*Pi,style=patchnogrid),\n  scaling=constrained,axes=none):\n\n if verbose then printf(\"Trimming\\n\"); fi;\n\n V := table():\n pants_complex := eval(V);\n V[\"vertices\"] := select(i -> max(i[1],-i[2],i[3]) <= 1/2,U[\"vertices\"]):\n V[\"edges\"] := select(e -> {op(e)} minus {op(V[\"vertices\"])} = {}, U[\"edges\"]):\n V[\"faces\"] := select(f -> {op(f)} minus {op(V[\"vertices\"])} = {}, U[\"faces\"]):\n V[\"max_simplices\"] := V[\"faces\"]:\n V[\"embedding0\"] := table():\n V[\"embedding1\"] := table():\n V[\"embedding2\"] := table():\n V[\"embedding3\"] := table():\n V[\"embedding4\"] := table():\n for i in V[\"vertices\"] do\n  V[\"embedding0\"][i] := U[\"embedding0\"][i];\n  V[\"embedding1\"][i] := U[\"embedding1\"][i];\n  V[\"embedding2\"][i] := U[\"embedding2\"][i];\n  V[\"embedding3\"][i] := U[\"embedding3\"][i];\n  V[\"embedding4\"][i] := U[\"embedding4\"][i];\n od:\n V[\"embedding\"] := V[\"embedding4\"]:\n\n V[\"normal\"] := table():\n for i in V[\"vertices\"] do\n  n := evalf(T[\"dl\"](V[\"embedding\"][i]));\n  n := n /~ dp(n,n);\n  V[\"normal\"][i] := n;\n od:\n \n V[\"chart_plot\"] :=\n  display(\n   plot3d(xa,r=0..0.5,t=0..2*Pi,style=patchnogrid),\n   plot3d(T[\"act_R3\"][[1,2,3,-1]](xa),r=0..0.5,t=0..2*Pi,style=patchnogrid),\n   plot3d(xb,u=0..sqrt(3.)/2,t=0..2*Pi,style=patchnogrid),\n   plot3d(T[\"act_R3\"][[2,3,1,1]](xb),u=0..sqrt(3.)/2,t=0..2*Pi,style=patchnogrid),\n   plot3d(T[\"act_R3\"][[3,1,2,1]](xb),u=0..sqrt(3.)/2,t=0..2*Pi,style=patchnogrid),\n  scaling=constrained,axes=none):\n\n condensed_pants_complex := \n  `condense/simplicial_complex`(pants_complex);\n\n if verbose then printf(\"Generating javascript\\n\"); fi;\n `set_javascript/simplicial_complex`(condensed_pants_complex);\nend:\n\n`base/pants` := table([\n \"centre\" = [0,0,0],\n \"circle_centres\" = [[sqrt(3)/2,0,0],[-sqrt(3)/4,3/4,0],[-sqrt(3)/4,-3/4,0]],\n \"top\" = [0,0,1/2]\n]):\n\n`outline/pants` := proc(P)\n local c,z,t;\n c := P[\"centre\"];\n z := 2 *~ (P[\"top\"] -~ P[\"centre\"]);\n display(\n  seq(line(P[\"centre\"],u,colour=green),u in P[\"circle_centres\"]),\n  seq(spacecurve(u +~ (cos(t)/sqrt(3)) *~ cross_product(u -~ c,z) +~ (sin(t)/2) *~ z,t=0..2*Pi,colour=red),\n       u in P[\"circle_centres\"]),\n  scaling=constrained,axes=none\n );\nend:\n\n`rough_plot/pants` := proc(P)\n local c,z,t,u,v,w,X;\n c := P[\"centre\"];\n z := 2 *~ (P[\"top\"] -~ P[\"centre\"]);\n X := NULL;\n for u in P[\"circle_centres\"] do \n  v := evalf((u -~ c) *~ (2/sqrt(3)));\n  w := cross_product(v,z);\n  X := X,plot3d(c +~ (s * abs(cos(t))/4 + (1-s) * sqrt(3)/2) *~ v \n                +~ (cos(t)/2) *~ w +~ (sin(t)/2) *~ z,\n                s=0..1,t=0..2*Pi,style=patchnogrid,scaling=constrained,axes=none); \n od:\n return(display(X));\nend:\n\n`plot/pants` := proc(P)\n local dp,h,c,b,u,v,w,p,f,X;\n\n dp := (u,v) -> add(u[i] * v[i],i=1..3);\n h := (x) -> evalf(x /~ sqrt(dp(x,x)));\n c := evalf(P[\"centre\"]);\n b := map(x -> x -~ c,P[\"circle_centres\"]);\n u := h(b[1]);\n v := h(b[2] -~ b[3]);\n w := h(P[\"top\"] -~ c);\n p := pants_sphere_sector_complex[\"u\"];\n f := unapply(c +~ dp(x,p[1]) *~ u +~ dp(x,p[9]) *~ v +~ dp(x,p[7]) *~ w,x);\n X := `map/simplicial_complex`(f,condensed_pants_complex);\n return `surface_plot/simplicial_complex`(X);\nend:\n\n`map/pants` := proc(f,P) \n return table([\n  \"centre\" = f(P[\"centre\"]),\n  \"circle_centres\" = map(f,P[\"circle_centres\"]),\n  \"top\" = f(P[\"top\"])\n ]);\nend:\n\n`sprout/pants` := proc(P,i)\n local Q,u,c;\n c := P[\"centre\"];\n u := P[\"circle_centres\"][i] -~ c;\n Q := table():\n Q[\"centre\"] := c +~ 2 *~ u;\n Q[\"circle_centres\"] := map(v -> 2 *~ c + 2 *~ u -~ v,P[\"circle_centres\"]);\n Q[\"top\"] := P[\"top\"] -~ P[\"centre\"] +~ Q[\"centre\"]; \n return eval(Q);\nend:\n\n\n`pants_tube/base` := table([\n  \"centre\"    = [0,0,0],\n  \"direction\" = [1,0,0],  # unit vector\n  \"bend\"      = [0,1,0],  # unit vector\n  \"length\"    = 1,\n  \"curvature\" = 0\n]):\n\n`outline/pants_tube` := proc(T)\n local c,d,b,l,k,w,x,y,z,s,t0,t;\n c := T[\"centre\"];\n d := T[\"direction\"];\n b := T[\"bend\"];\n l := T[\"length\"];\n k := T[\"curvature\"];\n w := cross_product(d,b);\n x := c -~ (`C/pants_tube`(t*l*k/2)*t^2*l^2*k/8) *~ b +~ (`S/pants_tube`(t*l*k/2)*t*l/2) *~ d;\n y := cos(t*l*k/2) *~ b +~ sin(t*l*k/2) *~ d;\n z := x +~ (cos(s)/2) *~ y +~ (sin(s)/2) *~ w;\n return display(\n  spacecurve(x,t = -1..1,colour=cyan),\n  spacecurve(subs(t=-1,z),s=0..2*Pi,colour=orange),\n  spacecurve(subs(t= 1,z),s=0..2*Pi,colour=orange),\n  scaling=constrained,axes=none\n );\nend:\n\n`S/pants_tube` := unapply(convert(series(sin(x)/x,x=0,11),polynom,x),x);\n`C/pants_tube` := unapply(convert(series(2*(1-cos(x))/x^2,x=0,11),polynom,x),x);\n`A/pants_tube` := unapply(convert(series(arcsin(x)/x,x=0,11),polynom,x),x);\n\n`plot/pants_tube` := proc(T)\n local c,d,b,l,k,w,x,y,z,s,t;\n c := T[\"centre\"];\n d := T[\"direction\"];\n b := T[\"bend\"];\n l := T[\"length\"];\n k := T[\"curvature\"];\n w := cross_product(d,b);\n x := c -~ (`C/pants_tube`(t*l*k/2)*t^2*l^2*k/8) *~ b +~ (`S/pants_tube`(t*l*k/2)*t*l/2) *~ d;\n y := cos(t*l*k/2) *~ b +~ sin(t*l*k/2) *~ d;\n z := x +~ (cos(s)/2) *~ y +~ (sin(s)/2) *~ w;\n return display(\n  plot3d(z,t=-1..1,s=0..2*Pi,style=patchnogrid),\n  scaling=constrained,axes=none\n );\nend:\n\n`map/pants_tube` := proc(f,T)\n local U;\n U := table():\n U[\"centre\"] := f(T[\"centre\"]);\n U[\"direction\"] := f(T[\"centre\"] +~ T[\"direction\"]) -~ U[\"centre\"];\n U[\"bend\"]      := f(T[\"centre\"] +~ T[\"bend\"]     ) -~ U[\"centre\"];\n U[\"length\"]    := T[\"length\"];\n U[\"curvature\"] := T[\"curvature\"];\n return eval(U);\nend:\n\n`joiner/pants_tube` := proc(c1,n1,c2,n2_)\n local dp,d,s,c0,ca,sa,n2,err,p,q,k,l,b,c,T,alpha,m,pic;\n dp := `dot/R`(3);\n\n d := evalf(c2 -~ c1);\n s := sqrt(dp(d,d));           # straight line length\n d := d /~ s;                  # unit vector c1 -> c2\n c0 := evalf((c1 +~ c2) /~ 2); # straight line midpoint\n\n ca := -evalf(dp(n1,d));       # cos(alpha/2)\n sa := sqrt(1 - ca * ca);      # sin(alpha/2)\n\n if nargs >= 4 then \n  n2 := n2_;\n else\n  n2 := n1 +~ (2 * p) *~ d;\n fi;\n\n k := 2 * sa/s;       # curvature\n q := s/2 * sqrt((1-ca)/(1+ca));\n\n err := evalf(cross_product(d,n2 -~ n1));\n err := sqrt(dp(err,err));\n if err > 10.^(-6) then\n  error(\"Non-matching circles\");\n fi;\n\n b := -~ evalf(n1 +~ n2);\n\n if sqrt(dp(b,b)) < 10.^(-4) then\n  # Tube will be straight.  Set b to be an arbitrary vector\n  # orthogonal to d.\n\n  b := [1,0,0]; p := abs(d[1]);\n  if abs(d[2]) < p then b := [0,1,0]; p := abs(d[2]); fi;\n  if abs(d[3]) < p then b := [0,0,1]; p := abs(d[3]); fi;\n  b := b -~ dp(d,b) *~ d;\n  b := b /~ sqrt(dp(b,b));\n  k := 0;\n  c := c0;\n  l := s;\n else\n  b := b /~ sqrt(dp(b,b));\n  c := evalf(c0 +~ q *~ b);\n#  l := s * `A/pants_tube`(s * k / 2);\n  alpha := 2 * arccos(ca);\n  l := alpha / k;\n  m := c -~ b /~ k;\n  pic := display(\n   point(c1,colour=black),\n   line(c1,c2,colour=black),\n   arrow(c1,0.3*~n1,cross_product(b,d),0.05,0.1,0.025,colour=magenta),\n   arrow(c2,0.3*~n2,cross_product(b,d),0.05,0.1,0.025,colour=magenta),\n   line(c0,c,colour=orange),\n   line(m,c1,colour=purple),\n   line(m,c2,colour=purple),\n   spacecurve(m +~ (cos(t)/k) *~ b +~ (sin(t)/k) *~ d,t=-alpha/2..alpha/2,colour=cyan),\n   scaling=constrained,axes=none\n  );\n fi;\n\n T := table([\n  \"c1\" = evalf(c1), \"c2\" = evalf(c2), \"n1\" = evalf(n1), \"n2\" = evalf(n2), \"d\" = d, \"s\" = s, \"c0\" = c0, \"ca\" = ca, \"sa\" = sa, \"q\" = q, \"alpha\" = alpha,\n  \"centre\" = c,\n  \"direction\" = d,\n  \"bend\" = b,\n  \"length\" = l,\n  \"curvature\" = k,\n  \"pic\" = pic\n ]);\n\n return eval(T);\nend:\n\n`pants_joiner/pants_tube` := proc(P1,i1,P2,i2)\n local dp,a1,a2,c1,c2,n1,n2;\n dp := `dot/R`(3);\n a1 := P1[\"centre\"];\n a2 := P2[\"centre\"];\n c1 := P1[\"circle_centres\"][modp(i1-1,3)+1];\n c2 := P2[\"circle_centres\"][modp(i2-1,3)+1];\n n1 := a1 -~ c1;\n n2 := a2 -~ c2;\n n1 := n1 /~ sqrt(dp(n1,n1));\n n2 := n2 /~ sqrt(dp(n2,n2));\n return `joiner/pants_tube`(c1,n1,c2,n2);\nend:\n\n", "meta": {"hexsha": "360c1db14651547ff6294c7f74ac684838de91c0", "size": 24841, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/simplicial_complexes/pants_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/pants_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/pants_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": 34.0287671233, "max_line_length": 150, "alphanum_fraction": 0.5275552514, "num_tokens": 10283, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311956428946, "lm_q2_score": 0.6261241772283034, "lm_q1q2_score": 0.49334277158442075}}
{"text": "\n# Inverse Dynamics for Robot with IC\n# Einleitung\n# Berechnung der inversen Dynamik für Roboter mit impliziten Zwangsbedingungen\n# \n# Dateiname:\n# robot -> Berechnung für allgemeinen Roboter\n# implicit_constraints -> Berechnung für Roboter mit impliziten Zwangsbedingungen\n# rotmat -> Kinematik wird mit Rotationsmatrizen berechnet\n# dynamics -> Berechnung der Dynamik\n# worldframe -> Berechnung basierend auf Energien aus Welt-KS (KS W)\n# par1 -> Parametersatz 1 (Schwerpunkt als Parameter: SX,SY,SZ) \n# reg2 -> Regressorform\n# Autor\n# Tim Job (HiWi-Job bei Moritz Schappler), 2019-05\n# Moritz Schappler, moritz.schappler@imes.uni-hannover.de\n# (C) Institut für Mechatronische Systeme, Universität Hannover\n# Sources\n# [ParkChoPlo1999] Park, FC and Choi, Jihyeon and Ploen, SR: Symbolic formulation of closed chain dynamics in independent coordinates\n# [Docquier2013] Docquier, Nicolas and Poncelet, Antoine and Fisette, Paul: ROBOTRAN: a powerful symbolic gnerator of multibody models (2013)\n# [DoThanhKotHeiOrt2009b] Do Thanh et al.: On the inverse dynamics problem of general parallel robots (2009)\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.\n#codegen_act := true: # noch nicht implementiert\ncodegen_debug := false:\ncodegen_opt := 2:\nread \"../helper/proc_MatlabExport\":\nread \"../robot_codegen_definitions/robot_env_IC\":\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", robot_name_OL):\nread \"../robot_codegen_definitions/robot_env_IC\":\nif base_method_name=\"twist\" then # Basis-Methode \"twist\" wird (hier) nur für fixed Base benutzt\n  expstring:=\"fixb\":\nelif base_method_name=\"eulxyz\" then \n  expstring:=\"floatb_eulxyz\":\nelse\n  printf(\"Nicht behandelte Basis-Methode: %s\\n\", base_method_name):\nfi:\n# Kennung des Parametersatzes, für den die Dynamikfunktionen erstellt werden sollen. Muss im Repo und in der mpl-Datei auf 1 gelassen werden, da die folgende Zeile mit einem Skript verarbeitet wird.\ncodegen_dynpar := 1:\nregressor_modus := \"regressor\":\nherleitungsverfahren := \"lagrange\":\ncodeexport_invdyn := false:\ncodeexport_grav_inertia := false:\ncodeexport_coriolisvec := false:\ncodeexport_regressor := false:\nif herleitungsverfahren = \"lagrange\" then #Dynamik aus Lagrange\n# Ergebnisse der inversen Dynamik für par1/2 laden\n  if codeexport_invdyn then\n    read sprintf(\"../codeexport/%s/tmp/invdyn_fixb_par%d_maple.m\", robot_name_OL, codegen_dynpar):\n    tau := Matrix(taus_fixb(7..NQ,1)):\n    printf(\"%s. Generiere inverse Dynamik (%s) für %s basierend auf IC-Jacobi und OL-Dynamik mit Parametersatz %d  und %s\\n\", \\\n      FormatTime(\"%Y-%m-%d %H:%M:%S\"), herleitungsverfahren, robot_name, codegen_dynpar, base_method_name):\n  fi:\n# Ergebnisse der inversen Dynamik in Regressorform laden\n  if codeexport_regressor then\n    read sprintf(\"../codeexport/%s/tmp/invdyn_%s_%s_maple.m\", robot_name_OL, expstring, regressor_modus):\n    tau_regressor_s := tau_regressor_s(7..NQ,..):\n    printf(\"%s. Generiere Dynamik in Regressorform (%s) für %s basierend auf IC-Jacobi und OL-Dynamik\\n\", \\\n      FormatTime(\"%Y-%m-%d %H:%M:%S\"), herleitungsverfahren, robot_name):\n  fi:\n# Ergebnisse der Massenmatrix und des Gravitationsvektors laden\n  if codeexport_grav_inertia then\n    read sprintf(\"../codeexport/%s/tmp/gravload_par%d_maple.m\", robot_name_OL, codegen_dynpar):\n    taug := Matrix(taug_s(7..NQ,..)):\n    read sprintf(\"../codeexport/%s/tmp/inertia_par%d_maple.m\", robot_name_OL, codegen_dynpar):\n    MM := Matrix(MM_s(7..NQ,7..NQ)):\n    read sprintf(\"../codeexport/%s/tmp/coriolisvec_par%d_maple.m\", robot_name_OL, codegen_dynpar):\n    tauCC := Matrix(tauCC_s(7..NQ,..)):\n    printf(\"%s. Generiere Gravitationsvektor und Massenmatrix (%s) für %s basierend auf IC-Jacobi und OL-Dynamik mit Parametersatz %d und %s\\n\",\\\n      FormatTime(\"%Y-%m-%d %H:%M:%S\"), herleitungsverfahren, robot_name, codegen_dynpar, base_method_name):\n  fi:\n\n# Ergebnisse des Coriolisvektors laden. Noch nicht implementiert.\n  if codeexport_coriolisvec then\n    read sprintf(\"../codeexport/%s/tmp/coriolisvec_par%d_maple.m\", robot_name_OL, codegen_dynpar):\n    tauCC := Matrix(tauCC_s(7..NQ,..)):\n    read sprintf(\"../codeexport/%s/tmp/inertia_par%d_maple.m\", robot_name_OL, codegen_dynpar):\n    MM := Matrix(MM_s(7..NQ,7..NQ)):\n    printf(\"%s. Generiere Coriolisvektor (%s) für %s basierend auf IC-Jacobi und OL-Dynamik mit Parametersatz %d und %s\\n\", \\ \n      FormatTime(\"%Y-%m-%d %H:%M:%S\"), herleitungsverfahren, robot_name, codegen_dynpar, base_method_name):\n  fi:\nelse #Dynamik aus Newton-Euler\n# Ergebnisse der inversen Dynamik für par1/2 laden\n  invdynfile:=sprintf(\"../codeexport/%s/tmp/invdyn_twist_NewtonEuler_linkframe_par%d_maple.m\", robot_name_OL, codegen_dynpar):\n  if FileTools[Exists](invdynfile) then\n    read invdynfile:\n  else\n    printf(\"%s. Inversdynamik der offenen Kette wurde nicht berechnet. Abbruch der Newton-Euler-Berechnung (Regressorform).\\n\", \\\n      FormatTime(\"%Y-%m-%d %H:%M:%S\")):\n    quit: # Funktioniert in GUI nicht richtig...\n    robot_name := \"\": # ...Daher auch Löschung des Roboternamens.\n  end if:  \n  tau := Matrix(tau_J(1..NQJ,..)):\n  taug := copy(tau):\n  for i from 1 to NQ do\n    taug := subs({qD_s[i,1]=0},taug):\n    taug := subs({qDD_s[i,1]=0},taug):\n  end do:\n  printf(\"%s. Generiere Gravitationsvektor und gesamte inverse Dynamik (%s) für %s basierend auf IC-Jacobi und OL-Dynamik mit Parametersatz %d\\n\", \\\n    FormatTime(\"%Y-%m-%d %H:%M:%S\"), herleitungsverfahren, robot_name, codegen_dynpar):\nfi:\n# Ergebnisse der impliziten Zwangsbedingungen laden\nread sprintf(\"../codeexport/%s/tmp/kinconstr_impl_projection_jacobian_maple\", robot_name):\nB21 := B21:\nread sprintf(\"../codeexport/%s/tmp/kinconstr_impl_projection_jacobian_derivative_maple\", robot_name):\nB21D := B21D:\n# Ergebnisse des Positionsvektors und der aktiven und passiven Gelenke laden\nread sprintf(\"../codeexport/%s/tmp/positionVector_NQJ_maple.m\", robot_name):\nposNQJ := posNQJ:\n# Pertubationsmatrizen berechnen\n# Entferne aktive/passive Koordinaten zur Umrechnung\n# Berechne die Anzahl aller aktiven und passiven Gelenke (inkl virtueller Schnittgelenke)\nNAJ := add(mu(k), k=1..NJ):\nNPJ := NJ-NAJ:\n# Bestimme Indizes der aktiven und passiven Gelenke\n# Entspricht Partitionierung der Gelenkwinkel in q1 und q2 in [Docquier2013]. Hier kann die Reihenfolge von aktiven und passiven Winkeln auch durchmischt sein.\nIndAct := Matrix(NAJ, 1):\nIndPass:= Matrix(NPJ, 1):\nka := 1: kp := 1:\nfor i from 1 to NJ do\n  if mu(i) = 1 then\n    IndAct(ka) := i:\n    ka := ka + 1:\n  else\n    IndPass(kp) := i:\n    kp := kp + 1:\n  end if:\nend do:\n# Entfernt die Einträge aus IndPass/IndAct, die virtuelle Schnittglenke sind\nfor i from 1 to NJ do\n  if posNQJ(i) = 0 then\n    posAct := ListTools[Search](i, convert(IndAct, list)):\n    if posAct <> 0 then\n      IndAct := DeleteRow(IndAct,posAct):\n    end if:\n    #posPass := ListTools[Search](i, convert(IndPass, list)):\n    #if posPass <> 0 then\n    #  IndPass := DeleteRow(IndPass,posPass):\n    #end if:\n  end if:\nend do:\nNQJA := RowDimension(IndAct):\nNQJP := NQJ-NQJA: #RowDimension(IndPass):\nIndPass:= Matrix(NQJP, 1):\nkp := 1: ka := 1:\nfor i from 1 to NQJ do\n  if ListTools[Search](i, convert(IndAct, list)) = 0 then\n    IndPass(kp) := i:\n    kp := kp + 1:\n  end if:\nend do:\n# Permutationsmatrizen berechnen zur Umrechnung von aufgeteilten Koordinaten\n# (aktiv/passiv nacheinander) in Koordinaten der Baumstruktur (aktiv/passiv gemischt) \nP1 := Matrix(NQJA,NQJ):\nP2 := Matrix(NQJP,NQJ):\nfor i from 1 to NQJA do\n  P1(i,IndAct(i)) := 1:\nend do:\nfor i from 1 to NQJP do\n  P2(i,IndPass(i)) := 1:\nend do:\n# Inverse Dynamik\n# explizit [Docquier2013], Gl. 12\nW := Transpose(P1 + Transpose(B21).P2):\nWD := Transpose(Transpose(B21D).P2):\n#q1D_s := Transpose(W).qJD_s:\ntauIC := Transpose(W).tau:\ntaugIC := Transpose(W).taug:\n# [DoThanhKotHeiOrt2009b], Gl. (23); [ParkChoPlo1999] Gl. (56)\n#tauCCIC := Transpose(W).tauCC + Transpose(W).MM.WD.q1D_s: # noch nicht implementiert\n;\ntauIC_regressor := P1.tau_regressor_s + Transpose(B21).P2.tau_regressor_s:\nif herleitungsverfahren = \"newton\" then\n  tau_MM := copy(tau):\n  for i to NQ do\n    tau_MM := subs(qD_s[i, 1] = 0,tau_MM);\n  end do:\n\n  MM := Matrix(NQJ, NQJ):\n  for i to NQJ do \n    for j to NQJ do \n      MM[i, j] := diff(tau_MM[i, 1], qDD_s[6+j, 1]):\n    end do:\n  end do:\nend if:\n# [ParkChoPlo1999], Gl. 55; [DoThanhKotHeiOrt2009b], Gl. (23)\nMMIC := Transpose(W).MM.W:\n# Export\n# Export der Belastung der Gelenke\n# Floating Base\nif codeexport_invdyn and not(base_method_name=\"twist\") then\n  MatlabExport(tauIC, sprintf(\"../codeexport/%s/tmp/invdyn_floatb_%s_par%d_ic_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\nif codeexport_regressor and not(base_method_name=\"twist\") then\n  MatlabExport(tauIC_regressor, sprintf(\"../codeexport/%s/tmp/invdyn_floatb_%s_%s_ic_matlab.m\", robot_name, base_method_name, regressor_modus), codegen_opt):\nend if:\n# Fixed Base\nif codeexport_invdyn then\n  tauIC_fixb:=tauIC:\n  for i from 1 to NQB do\n    tauIC_fixb := subs({X_base_s[i,1]=0},tauIC_fixb):\n  end do:\n  for i from 1 to 6 do\n    tauIC_fixb := subs({V_base_s[i,1]=0},tauIC_fixb):\n    tauIC_fixb := subs({VD_base_s[i,1]=0},tauIC_fixb):\n  end do:\n  MatlabExport(tauIC_fixb, sprintf(\"../codeexport/%s/tmp/invdyn_fixb_par%d_ic_matlab.m\", robot_name, codegen_dynpar), codegen_opt):\nend if:\nif codeexport_grav_inertia then\n  taugIC_fixb:=taugIC:\n  MMIC_fixb:=MMIC:\n  for i from 1 to NQB do\n    MMIC_fixb := subs({X_base_s[i,1]=0},MMIC_fixb):\n  end do:\n  for i from 1 to 6 do\n    MMIC_fixb := subs({V_base_s[i,1]=0},MMIC_fixb):\n    MMIC_fixb := subs({VD_base_s[i,1]=0},MMIC_fixb):\n  end do:\n  MatlabExport(taugIC_fixb, sprintf(\"../codeexport/%s/tmp/gravload_joint_floatb_twist_par%d_ic_matlab.m\", robot_name, codegen_dynpar), codegen_opt):\n  MatlabExport(MMIC_fixb, sprintf(\"../codeexport/%s/tmp/inertia_joint_joint_floatb_%s_par%d_ic_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\n# Noch nicht implementiert\nif codeexport_coriolisvec then\n  tauCCIC_fixb:=tauCCIC:\n  for i from 1 to NQB do\n    tauCCIC_fixb := subs({X_base_s[i,1]=0},tauCCIC_fixb):\n  end do:\n  for i from 1 to 6 do\n    tauCCIC_fixb := subs({V_base_s[i,1]=0},tauCCIC_fixb):\n    tauCCIC_fixb := subs({VD_base_s[i,1]=0},tauCCIC_fixb):\n  end do:\n  MatlabExport(tauCCIC_fixb, sprintf(\"../codeexport/%s/tmp/coriolisvec_joint_fixb_twist_par%d_ic_matlab.m\", robot_name, codegen_dynpar), codegen_opt):\nend if:\nif codeexport_regressor then\n  tauIC_regressor_fixb:=tauIC_regressor:\n  for i from 1 to NQB do\n    tauIC_regressor_fixb := subs({X_base_s[i,1]=0},tauIC_regressor_fixb):\n  end do:\n  for i from 1 to 6 do\n    tauIC_regressor_fixb := subs({V_base_s[i,1]=0},tauIC_regressor_fixb):\n    tauIC_regressor_fixb := subs({VD_base_s[i,1]=0},tauIC_regressor_fixb):\n  end do:\n  MatlabExport(tauIC_regressor_fixb, sprintf(\"../codeexport/%s/tmp/invdyn_fixb_%s_ic_matlab.m\", robot_name, regressor_modus), codegen_opt):\nend if:\nif herleitungsverfahren = \"newton\" then\n  tauIC_fixb:=tauIC:\n  taugIC_fixb:=taugIC:\n  MMIC_fixb:=MMIC:\n  for i from 1 to NQB do\n    tauIC_fixb := subs({X_base_s[i,1]=0},tauIC_fixb):\n    MMIC_fixb := subs({X_base_s[i,1]=0},MMIC_fixb):\n  end do:\n  for i from 1 to 6 do\n    tauIC_fixb := subs({V_base_s[i,1]=0},tauIC_fixb):\n    tauIC_fixb := subs({VD_base_s[i,1]=0},tauIC_fixb):\n    MMIC_fixb := subs({V_base_s[i,1]=0},MMIC_fixb):\n    MMIC_fixb := subs({VD_base_s[i,1]=0},MMIC_fixb):\n  end do:\n  MatlabExport(tauIC_fixb, sprintf(\"../codeexport/%s/tmp/invdyn_fixb_snew_par%d_ic_matlab.m\", robot_name, codegen_dynpar), codegen_opt):\n  MatlabExport(taugIC_fixb, sprintf(\"../codeexport/%s/tmp/gravload_joint_floatb_twist_snew_par%d_ic_matlab.m\", robot_name, codegen_dynpar), codegen_opt):\n  MatlabExport(MMIC_fixb, sprintf(\"../codeexport/%s/tmp/inertia_joint_joint_floatb_%s_snew_par%d_ic_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\n# Export Anzahl der aktiven Koordinaten NAJ\nMatlabExport(NAJ, sprintf(\"../codeexport/%s/tmp/NAJ_ic_matlab.m\", robot_name), codegen_opt):\n\n", "meta": {"hexsha": "423d2a747b9e5dda77a95fde6f209e322a7522ba", "size": 12327, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "robot_codegen_dynamics/robot_implicit_contraints_rotmat_dynamics_worldframe_par12_reg2.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_dynamics/robot_implicit_contraints_rotmat_dynamics_worldframe_par12_reg2.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_dynamics/robot_implicit_contraints_rotmat_dynamics_worldframe_par12_reg2.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": 44.9890510949, "max_line_length": 198, "alphanum_fraction": 0.7313214894, "num_tokens": 4127, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677468516188, "lm_q2_score": 0.5813030906443133, "lm_q1q2_score": 0.49292627201154066}}
{"text": "# This file sets up the theory of the simplicial category, with simplicial\n# maps encoded as lists of values.  This is an alternative to simplicial.mpl,\n# where simplicial maps are encoded as tables.  This version is more efficient,\n# but suffers from the fact that Maple uses 1-based indexing, so we need a\n# lot of extra +1's.\n\n`is_element/simplicial_maps_alt` := (n::nonnegint,m::nonnegint) -> proc(f)\n evalb(type(f,list(nonnegint)) and nops(f) = n+1 and max(op(f)) <= m) \nend:\n\n`is_leq/simplicial_maps_alt` := (n::nonnegint,m::nonnegint) -> proc(f,g)\n evalb( min(op(g -~ f)) >= 0 );\nend:\n\n# This assumes that \n# *  p is a subset of {1,...,n} of size k\n# *  q is a subset of {0,...,m} of size k+1\n# It returns the nondecreasing map f : {0,...,n} -> {0,...,m} such that\n# *  The image of f is q\n# * { i > 0 : f(i) > f(i-1) } = p.\n \n`build/simplicial_maps_alt` :=  (n::nonnegint,m::nonnegint) -> proc(k,p,q)\n local pp,i,j,f;\n pp := [0,op(p),n+1];\n f := NULL;\n i := 0;\n for i from 0 to k do\n  for j from pp[i+1] to pp[i+2]-1 do\n   f := f,q[i+1];\n  od;\n od;\n\n return [f];\nend:\n\n`random_element/simplicial_maps_alt` := (n::nonnegint,m::nonnegint) -> proc()\n local p,q,i,j,k,l,f;\n\n k := rand(0..min(n,m))();\n p := combinat[randcomb](n,k);\n q := combinat[randcomb](m+1,k+1) -~ 1;\n return `build/simplicial_maps_alt`(n,m)(k,p,q);\nend:\n\n`list_elements/simplicial_maps_alt` := proc(n::nonnegint,m::nonnegint)\n option remember;\n local i;\n \n if n = 0 then\n  return [seq(`C/simplicial_maps_alt`(0,i),i=0..m)];\n else\n  if m = 0 then\n   return [`C/simplicial_maps_alt`(n,0)];\n  else\n   return [op(map(`I/simplicial_maps_alt`(n,m-1),\n                   `list_elements/simplicial_maps_alt`(n,m-1))),\n           op(map(`T/simplicial_maps_alt`(n-1,m),\n\t           `list_elements/simplicial_maps_alt`(n-1,m)))];\n  fi;\n fi;\nend:\n\n`count_elements/simplicial_maps_alt` := (n::nonnegint,m::nonnegint) -> binomial(n+m+1,m);\n\n# Constant maps\n`C/simplicial_maps_alt` := proc(n::nonnegint,k::nonnegint)\n [k$(n+1)]\nend:\n\n# Inclusion Delta(n,m) -> Delta(n,m+1)\n`I/simplicial_maps_alt` := (n::nonnegint,m::nonnegint) -> proc(f)\n f;\nend:\n\n# Map Delta(n,m) -> Delta(n+1,m): extend by sending n+1 to m\n`T/simplicial_maps_alt` := (n::nonnegint,m::nonnegint) -> proc(f)\n [op(f),m];\nend:\n\n# `delta/simplicial_maps_alt`(n)(i) : [n] >-> [n+1]; image omits i \n`delta/simplicial_maps_alt` := proc(n::nonnegint,i::nonnegint)\n local j;\n if i > n+1 then return FAIL; fi;\n return [seq(j,j=0..i-1),seq(j+1,j=i..n)];\nend:\n\n# `sigma/simplicial_maps_alt`(n)(i) : [n] ->> [n-1]; takes the value i twice \n`sigma/simplicial_maps_alt` := proc(n::nonnegint,i::nonnegint)\n local j;\n if i > n-1 then return FAIL; fi;\n return [seq(j,j=0..i),seq(j-1,j=i+1..n)];\nend:\n\n`id/simplicial_maps_alt` := proc(n::nonnegint)\n local i;\n return [seq(i=i,i=0..n)];\nend:\n\n`eval/simplicial_maps_alt` := (n::nonnegint,m::nonnegint) -> (f) -> (i) -> f[i+1];\n\n# `compose/simplicial_maps`(n,m,p)(f,g) assumes that f:[n] -> [m] and g:[m] -> [p],\n# and it returns the composite g o f : [n] -> [p].\n\n`compose/simplicial_maps_alt` := (n::nonnegint,m::nonnegint,p::nonnegint) -> proc(f,g)\n local i;\n [seq(g[f[i+1]+1],i=0..n)];\nend:\n\n`is_wide/simplicial_maps_alt` := (n::nonnegint,m::nonnegint) -> proc(f)\n return evalb(f[1] = 0 and f[n+1] = m);\nend:\n\n`is_mono/simplicial_maps_alt` := (n::nonnegint,m::nonnegint) -> proc(f)\n evalb(nops({op(f)}) = n+1);\nend:\n\n`is_epi/simplicial_maps_alt` := (n::nonnegint,m::nonnegint) -> proc(f)\n local j;\n evalb({op(f)} = {seq(j,j=0..m)});\nend:\n\n# This assumes that f : [n] -> [m], and it returns [k,g,h] such that\n# g : [n] ->> [k] and h : [k] >-> [m] and f = h o g\n\n`factor/simplicial_maps_alt` := (n::nonnegint,m::nonnegint) -> proc(f)\n local K,k,g,h,hi,i;\n \n h := sort([op({op(f)})]);\n k := nops(h) - 1;\n hi := table();\n for i from 0 to k do hi[h[i+1]] := i; od;\n g := [seq(hi[f[i+1]],i=0..n)];\n return [k,g,h];\nend:\n\n`describe/simplicial_maps_alt` := (n::nonnegint) -> proc(f)\n local i;\n cat(seq(nat_code[f[i]],i=1..n+1));\nend:\n\n######################################################################\n\n`is_element/simplicial_epi_alt` := (n::nonnegint,m::nonnegint) -> proc(f)\n global reason;\n \n if not(`is_element/simplicial_maps_alt`(n,m)(f)) then\n  reason := [convert(procname,string),\"not a simplicial map from [n] to [m]\",reason];\n  return false;\n fi;\n\n return `is_epi/simplicial_maps_alt`(n,m)(f);\nend:\n\n`is_leq/simplicial_epi_alt` :=  (n::nonnegint,m::nonnegint) -> proc(f,g)\n `is_leq/simplicial_maps_alt`(n,m)(f,g);\nend:\n\n`random_element/simplicial_epi_alt` := (n::nonnegint,m::nonnegint) -> proc()\n local p,q,k,f,i;\n\n if n < m then return FAIL; fi;\n\n k := m;\n p := combinat[randcomb](n,k);\n q := [seq(i,i=0..m)];\n return `build/simplicial_maps_alt`(n,m)(k,p,q);\nend:\n\n`list_elements/simplicial_epi_alt` := proc(n::nonnegint,m::nonnegint) \n local P,L,S,i,j;\n\n P := combinat[choose]([seq(i,i=1..n)],m);\n L := map(S -> [0$S[1],seq(j$(S[j+1]-S[j]),j=1..m-1),m$(n+1-S[m])],P);\n\n return L;\nend:\n\n`count_elements/simplicial_epi_alt` := (n::nonnegint,m::nonnegint) -> binomial(n,m);\n\n######################################################################\n\n`is_element/simplicial_mono_alt` := (n::nonnegint,m::nonnegint) -> proc(f)\n global reason;\n \n if not(`is_element/simplicial_maps_alt`(n,m)(f)) then\n  reason := [convert(procname,string),\"not a simplicial map from [n] to [m]\",reason];\n  return false;\n fi;\n\n return `is_mono/simplicial_maps_alt`(n,m)(f);\nend:\n\n`is_leq/simplicial_mono_alt` :=  (n::nonnegint,m::nonnegint) -> proc(f,g)\n `is_leq/simplicial_maps_alt`(n,m)(f,g);\nend:\n\n`random_element/simplicial_mono_alt` := (n::nonnegint,m::nonnegint) -> proc()\n local p,q,i,j,k,l,f;\n\n if n > m then return FAIL; fi;\n\n q := combinat[randcomb](m+1,n+1) -~ 1;\n q := sort([op(q)]);\n return q;\nend:\n\n`list_elements/simplicial_mono_alt` := proc(n::nonnegint,m::nonnegint) \n map(q -> q -~ 1,combinat[choose](m+1,n+1));\nend:\n\n`count_elements/simplicial_mono_alt` := (n::nonnegint,m::nonnegint) -> binomial(m+1,n+1);\n\n\n\n", "meta": {"hexsha": "7f57bbdad2bdad1aba91b9505f82e96accdca119", "size": 5973, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/simplicial_alt.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_alt.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_alt.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.7813953488, "max_line_length": 89, "alphanum_fraction": 0.6129248284, "num_tokens": 2178, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7341195385342971, "lm_q2_score": 0.6688802669716107, "lm_q1q2_score": 0.49103807292389634}}
{"text": "######################################################################\n\n# General framework for operads freely generated by a strongly \n# reduced Sigma-module.\n\n`is_element/Phi/generic` := (gen_name,el_test) -> (A::set) -> \nproc(TTm)\n local pn,TT,m,TT1,C,T;\n global reason;\n\n pn := cat(\"is_element/Phi/\",gen_name);\n \n if not(type(TTm,list) and nops(TTm) = 2) then\n  reason := [pn,\"TTm is not a list of length two\"];\n  return false;\n fi;\n\n TT,m := op(TTm);\n\n if not(`is_element/full_trees`(A)(TT)) then\n  reason := [pn,\"TT is not a full tree on A\",TT,A];\n  return false;\n fi;\n\n if not type(m,table) then\n  reason := [pn,\"m is not a table\"];\n  return false;\n fi;\n\n if map(nops,{indices(m)}) <> {1} then\n  reason := [pn,\"m is not a unidimensional table\"];\n  return false;\n fi;\n \n TT1 := map(op,[indices(m)]);\n \n if {op(TT1)} <> select(T -> nops(T) > 1,TT) then\n  reason := [pn,\"m is not indexed by the big sets in TT\",TT1,TT];\n  return false;  \n fi;\n\n C := children_map(A)(TT);\n\n for T in TT1 do\n  if not(el_test(C[T])(m[T])) then\n   reason := [pn,\"m[T] is not in M(C[T])\",m[T],T,C[T]];\n   return false;\n  fi;\n od;\n\n return true;\nend;\n\n######################################################################\n\n`is_equal/Phi/generic` :=  (gen_name,eq_test) -> (A::set) -> \nproc(TTm,UUn)\n local pn,TT,m,UU,n,C,TT1,T;\n global reason;\n\n pn := cat(\"is_element/realisation/\",poset_name);\n\n TT,m := op(TTm);\n UU,n := op(UUn);\n\n if not(`is_equal/full_trees`(A)(TT,UU)) then\n  reason := [pn,\"TT <> UU\",TT,UU];\n  return false;\n fi;\n\n C := children_map(A)(TT);\n TT1 := select(T -> nops(T) > 1,TT);\n\n for T in TT1 do\n  if not(eq_test(C[T])(m[T],n[T])) then\n   reason := [pn,\"m[T] <> n[T]\",T,C[T],m[T],n[T]];\n   return false;\n  fi;\n od;\n\n return true;\nend;\n\n######################################################################\n\n`eta/Phi/generic` := (gen_name) -> (A::set) -> `if`(nops(A) = 1,[{A},table()],FAIL);\n\n######################################################################\n\n`gamma/Phi/generic` := (gen_name,action) -> (A::set,B::set) -> (p) -> proc(UUn,TTm)\n local F,FF,UU,UU1,CU,CV,CT,U,U0,Ui,CU0,CU1,TT,T,VV,f,b,m,n,o;\n \n F := fibres(A,B)(p);\n UU,n := op(UUn);\n CU := children_map(B)(UU);\n FF := table();\n for U in UU do\n  FF[U] := `union`(seq(F[b],b in U));\n od;\n \n TT := table();\n CT := table();\n m := table();\n \n for b in B do\n  TT[b],m[b] := op(TTm[b]);\n  CT[b] := children_map(F[b])(TT[b]);\n od;\n\n VV := `gamma/trees`(A,B)(p)(UU,TT);\n CV := children_map(A)(VV);\n \n o := table();\n UU1 := select(U -> nops(U) > 1,UU);\n for U in UU do\n  Ui := FF[U];\n  CU0 := CU[U];\n  CU1 := CV[Ui];\n  f := table();\n  for U0 in CU0 do f[U0] := FF[U0]; od;\n  o[Ui] := action(CU0,CU1)(f)(n[U]);\n od;\n\n for b in B do\n  for T in TT[b] do\n   if nops(T) > 1 then\n    o[T] := m[b](T);\n   fi;\n  od;\n od;\n\n return(eval([VV,o]));\nend:\n\n######################################################################\n\n`zeta/Phi/generic` := (gen_name,action) -> (A::set) -> proc(m)\n local TT,n,f,A1,a;\n \n if nops(A) = 1 then return(`eta/Phi/generic`(gen_name)(A)); fi;\n\n TT := corolla(A);\n n := table();\n f := table();\n A1 := {seq({a},a in A)};\n for a in A do f[a] := {a}; od;\n n[A] := action(A,A1)(f)(m);\n return eval([TT,n]);\nend:\n\n######################################################################\n\n`epsilon/Phi/generic` := (gen_name,eta,gamma) -> (A::set) -> proc(TTm)\n local TT,m;\n\n TT,m := op(TTm);\n return `theta/Xi/generic`(gen_name,eta,gamma)(A)(TT,corolla(A))(m);\nend;\n", "meta": {"hexsha": "5a4d578fd7168a79195e17d7c8d4fe574680b404", "size": 3445, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/operads/Phi.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/Phi.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/Phi.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": 21.6666666667, "max_line_length": 84, "alphanum_fraction": 0.4891146589, "num_tokens": 1142, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833841649232, "lm_q2_score": 0.63341027059799, "lm_q1q2_score": 0.4906290709646109}}
{"text": "cdir := \"/home/scott/Documents/research/software/hqca/hqca/maple/test_cases/\":\nwith(LinearAlgebra): with(ArrayTools): with(QuantumChemistry):\nloaddata := readdata(cat(cdir,\"tmp7bh4a4ao.rdm\"), 8):\nFlatten := proc(x) local n, a, i, j, k, l; `local`(a, n, i, j, k, l); `description`(\"convert chemists to numpy and flatten an array to form a matrix\"); n := Size(x); a := Matrix(1 .. n[1]*n[2], 1 .. n[3]*n[4], datatype = float[8]); for i to round(n[1]) do for j to round(n[2]) do for k to round(n[3]) do for l to round(n[4]) do a[(i - 1)*n[1] + j, (k - 1)*n[3] + l] := x[i, j, k, l]; end do; end do; end do; end do; return a; end proc:\nNew := Array(1 .. 4, 1 .. 4, 1 .. 4, 1 .. 4, datatype = float[8]):\nfor i in loaddata[3 .. ()] do\n    New[round(i[1]), round(i[2]), round(i[3]), round(i[4])] := i[5]:\nend do:\nTranspose(Re(Eigenvalues(Flatten(New))));\npure := Purify2RDM(New, spin_free = false, electron_number=4, conv_tol = 0.00000000001):\nExportMatrix(cat(cdir, \"_temp_purified.csv\"), Flatten(pure[rdm2])):\n", "meta": {"hexsha": "f7a3b73bc6060423090906d918e271bda3efe067", "size": 1005, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "hqca/maple/test_cases/maple_input.mpl", "max_stars_repo_name": "damazz/HQCA", "max_stars_repo_head_hexsha": "b013ba68f86e42350913c4abc2e1c91695a429b7", "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": "hqca/maple/test_cases/maple_input.mpl", "max_issues_repo_name": "damazz/HQCA", "max_issues_repo_head_hexsha": "b013ba68f86e42350913c4abc2e1c91695a429b7", "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": "hqca/maple/test_cases/maple_input.mpl", "max_forks_repo_name": "damazz/HQCA", "max_forks_repo_head_hexsha": "b013ba68f86e42350913c4abc2e1c91695a429b7", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-08-10T00:20:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-10T00:20:09.000Z", "avg_line_length": 83.75, "max_line_length": 435, "alphanum_fraction": 0.6258706468, "num_tokens": 378, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8333245953120233, "lm_q2_score": 0.5851011542032312, "lm_q1q2_score": 0.48757918254300536}}
{"text": "######################################################################\n\n`is_element/stasheff_star` := (A::set) -> proc(Rt)\n local R,t,n,JJ,TT,J,u,i,j,k;\n global reason;\n\n if not(type(Rt,list) and nops(Rt) = 2) then \n  reason := [convert(procname,string),\"Rt cannot be split as [R,t]\",Rt];\n  return false;\n fi;\n\n R,t := op(Rt);\n\n if not(`is_element/ord`(A)(R)) then\n  reason := [convert(procname,string),\"R is not an order on A\",R,A,reason];\n  return false;\n fi;\n\n n := nops(A);\n JJ := {seq(seq({seq(R[k],k=i..j)},j=i..n),i=1..n)};\n\n if not(type(t,table)) then\n  reason := [convert(procname,string),\"t is not a table\",t];\n  return false;\n fi;\n\n if map(op,{indices(t)}) <> JJ then\n  reason := [convert(procname,string),\"t is not indexed by the set of R-intervals\",t,R,JJ];\n  return false;\n fi;\n\n TT := NULL;\n\n for J in JJ do\n  u := t[J];\n\n  if not (`is_element/RR`(u) and u >= 0 and u <= 1) then\n   reason := [convert(procname,string),\"t[J] is not in the unit interval\",J,t[J]];\n   return false;\n  fi;\n\n  if (nops(J) = 1 and u <> 1) then\n   reason := [convert(procname,string),\"t[{a}] <> 1\",op(J),t[J]];\n   return false;\n  fi;\n\n  if (nops(J) = 1 or nops(J) = n) and u <> 1 then\n   reason := [convert(procname,string),\"t[A] <> 1\",A,t[J]];\n   return false;\n  fi;\n\n  if u > 0 then TT := TT,J; fi;\n od;\n\n TT := {TT};\n\n if not(`is_element/trees`(A)(TT)) then\n  reason := [convert(procname,string),\"TT is not a tree\",TT,reason];\n  return false;\n fi;\n\n return true;\nend;\n\n######################################################################\n\n`is_equal/stasheff_star` := (A::set) -> proc(Rt1,Rt2)\n local R1,R2,t1,t2,n,JJ,J,i,j,k;\n\n R1,t1 := op(Rt1);\n R2,t2 := op(Rt2);\n\n if not(`is_equal/ord`(A)(R1,R2)) then\n  return false;\n fi;\n \n n := nops(A);\n JJ := {seq(seq({seq(R1[k],k=i..j)},j=i..n),i=1..n)};\n\n for J in JJ do\n  if t1[J] <> t2[J] then return false; fi;\n od;\n\n return true;\nend:\n\n######################################################################\n\n`is_leq/stasheff_star` := NULL;\n\n######################################################################\n# Covariant functoriality for bijections p : A -> B.\n\n`act/stasheff_star` := (A::set,B::set) -> (p) -> proc(Rt)\n local R,t,S,u,JJ,J,J1;\n\n R,t := op(Rt);\n S := map(a -> p[a],R);\n u := table();\n JJ := map(op,[indices(t)]);\n for J in JJ do \n  J1 := map(a -> p[a],J);\n  u[J1] := t[J];\n od:\n return [S,eval(u)];\nend:\n\n######################################################################\n\n`random_element/stasheff_star` := (A::set) -> proc()\n local R,t0,JJ0,J0,t,J;\n\n R := `random_element/ord`(A)();\n t0 := `random_element/standard_stasheff_star`(nops(A))();\n\n JJ0 := map(op,[indices(t0)]);\n t := table();\n for J0 in JJ0 do\n  J := map(i -> R[i],J0);\n  t[J] := t0[J0];\n od:\n\n return [R,eval(t)];\nend:\n\n######################################################################\n\n`list_elements/stasheff_star` := NULL;\n`count_elements/stasheff_star` := NULL;\n\n######################################################################\n\n`phi/stasheff_trees/stasheff_star` := (A::set) -> proc(RTT)\n local R,TT,n,JJ,J,t,i,j,k;\n\n R,TT := op(RTT);\n\n n := nops(R);\n JJ := {seq(seq({seq(R[k],k=i..j)},j=i..n),i=1..n)};\n t := table();\n\n for J in JJ do t[J] := 0; od;\n for J in TT do t[J] := 1; od;\n\n return [R,eval(t)];\nend;\n\n######################################################################\n\n`phi/realisation/stasheff_trees/stasheff_star` := (A::set) -> proc(x)\n local y,C,R,n,JJ,J,RTT,t,TT,z,i,j,k;\n\n y := table();\n C := map(op,[indices(x)]);\n R := C[1][1];\n n := nops(A);\n JJ := {seq(seq({seq(R[k],k=i..j)},j=i..n),i=1..n)};\n\n for J in JJ do y[J] := 0; od;\n \n for RTT in C do\n  t := x[RTT];\n  TT := RTT[2];\n  z := `phi/stasheff_trees/stasheff_star`(A)(TT);\n  for J in JJ do y[J] := y[J] + t * z[J]; od;\n od;\n\n return eval(y);\nend:\n\n######################################################################\n\n`phi/stasheff_star/ord_simplex_interior` := (A::set) -> proc(Rt)\n local R,t,JJ,JS,Ja,J,K,lambda,mu,a,children;\n\n R,t := op(Rt);\n JJ := select(J -> t[J] > 0, map(op,{indices(t)}));\n children := `children_map`(A)(JJ);\n JS := sort([op(JJ),(U,V) -> nops(U) < nops(V)]);\n\n lambda := table();\n for J in JS do\n  if nops(J) = 1 then\n   lambda[J] := 1;\n  else\n   lambda[J] := add(lambda[K]^(1-t[K]),K in children[J]);\n  fi;\n od;\n\n mu := table();\n for a in A do\n  Ja := select(J -> member(a,J),JJ);\n  mu[a] := mul(lambda[J]^(-t[J]),J in Ja);\n od;\n\n return [R,eval(mu)];\nend;\n\n######################################################################\n\n`phi/stasheff_star/one_cubes_prime` := (A::set) -> proc(Rt)\n `phi/ord_simplex_interior/one_cubes_prime`(A)(\n  `phi/stasheff_star/ord_simplex_interior`(A)(Rt));\nend;\n\n######################################################################\n\n`proj/stasheff_star/ord` := (A::set) -> (Rt) -> Rt[1];\n\n######################################################################\n\n`describe/stasheff_star` := (A::set) -> proc(Rt)\n local R,t,n,r,i,TT;\n R,t := op(Rt);\n n := nops(A);\n r := table();\n for i from 1 to n do r[R[i]] := i; od:\n\n TT := map(op,[indices(t)]);\n TT := select(J -> (t[J] > 0 and nops(J) > 1),TT);\n TT := map(J -> [op(J)],TT);\n TT := map(sort,TT,(a,b) -> (r[a] < r[b]));\n TT := sort(TT,(J0,J1) -> (\n        (nops(J0) < nops(J1)) or \n        ((nops(J0) = nops(J1)) and (r[J0[1]] < r[J1[1]]))));\n return sprintf(\"%A\",map(J -> (J=t[{op(J)}]),TT));\nend;", "meta": {"hexsha": "d3b272e1f80b9b3833355f6161874f7034a4a36d", "size": 5336, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/stasheff_star.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/stasheff_star.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/stasheff_star.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.5066079295, "max_line_length": 91, "alphanum_fraction": 0.4662668666, "num_tokens": 1729, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434873426302, "lm_q2_score": 0.629774600455747, "lm_q1q2_score": 0.4860874238555753}}
{"text": "da2 :=\n[\n    [#(1) filter9 ((1)-(34) are from http://homepages.math.uic.edu/~jan/demo.html)\n        [m2*m4*m6 - 1/100,\n a*m4*b - 7/500,\n a**2 + m1**2 - 2/25,\n b**2 + m7**2 - 37/50,\n m3**2 + m5**2 + m4**2 + m2**2 + m6**2 - 9401/10000,\n m4**2*m6**2 + m2**2*m4**2 + m3**2*m6**2 + m2**2*m5**2\n + m3**2*m5**2 + m2**2*m6**2 - 38589/1000000,\n m1*m3*m5*m7 - m6*m1*m3*b + m2*m6*a*b - m2*a*m5*m7 + 81/10000,\n -m1*m2*m3*m4*b - a*m4*m5*m6*m7 + a*m4*b*m6**2 + a*m2**2*m4*b + 39/25000,\n -m4**2*m7**2 - m3**2*m7**2 + 2*m5*m6*b*m7 - m2**2*m7**2 - m5**2*m7**2\n- m3**2*b**2 - b**2*m6**2 - m2**2*b**2 + 27173/40000\n        ],\n        [m1,m2,m3,m4,m5,m6,m7,a,b]\n    ],\n    [#(2) katsura6\n        [ 1*x1+2*x2+2*x3+2*x4+2*x5+2*x6+2*x7-1,\n 2*x4*x3+2*x5*x2+2*x6*x1+2*x7*x2-1*x6,\n 1*x3^2+2*x4*x2+2*x5*x1+2*x6*x2+2*x7*x3-1*x5,\n 2*x3*x2+2*x4*x1+2*x5*x2+2*x6*x3+2*x7*x4-1*x4,\n 1*x2^2+2*x3*x1+2*x4*x2+2*x5*x3+2*x6*x4+2*x7*x5-1*x3,\n 2*x2*x1+2*x3*x2+2*x4*x3+2*x5*x4+2*x6*x5+2*x7*x6-1*x2,\n 1*x1^2+2*x2^2+2*x3^2+2*x4^2+2*x5^2+2*x6^2+2*x7^2-1*x1\n        ],\n        [x1,x2,x3,x4,x5,x6,x7]\n    ],\n    [#(3) katsura7\n        [-x1+2*x8^2+2*x7^2+2*x6^2+2*x5^2+2*x4^2+2*x3^2+2*x2^2+x1^2,\n -x2+2*x8*x7+2*x7*x6+2*x6*x5+2*x5*x4+2*x4*x3+2*x3*x2+2*x2*x1,\n -x3+2*x8*x6+2*x7*x5+2*x6*x4+2*x5*x3+2*x4*x2+2*x3*x1+x2^2,\n -x4+2*x8*x5+2*x7*x4+2*x6*x3+2*x5*x2+2*x4*x1+2*x3*x2,\n -x5+2*x8*x4+2*x7*x3+2*x6*x2+2*x5*x1+2*x4*x2+x3^2,\n -x6+2*x8*x3+2*x7*x2+2*x6*x1+2*x5*x2+2*x4*x3,\n -x7+2*x8*x2+2*x7*x1+2*x6*x2+2*x5*x3+x4^2,\n -1+2*x8+2*x7+2*x6+2*x5+2*x4+2*x3+2*x2+x1\n        ],\n        [x1,x2,x3,x4,x5,x6,x7,x8]\n    ],\n    [#(4) katsura8\n        [ -x1+2*x9^2+2*x8^2+2*x7^2+2*x6^2+2*x5^2+2*x4^2+2*x3^2+2*x2^2+x1^2,\n -x2+2*x9*x8+2*x8*x7+2*x7*x6+2*x6*x5+2*x5*x4+2*x4*x3+2*x3*x2+2*x2*x1,\n -x3+2*x9*x7+2*x8*x6+2*x7*x5+2*x6*x4+2*x5*x3+2*x4*x2+2*x3*x1+x2^2,\n -x4+2*x9*x6+2*x8*x5+2*x7*x4+2*x6*x3+2*x5*x2+2*x4*x1+2*x3*x2,\n -x5+2*x9*x5+2*x8*x4+2*x7*x3+2*x6*x2+2*x5*x1+2*x4*x2+x3^2,\n -x6+2*x9*x4+2*x8*x3+2*x7*x2+2*x6*x1+2*x5*x2+2*x4*x3,\n -x7+2*x9*x3+2*x8*x2+2*x7*x1+2*x6*x2+2*x5*x3+x4^2,\n -x8+2*x9*x2+2*x8*x1+2*x7*x2+2*x6*x3+2*x5*x4,\n -1+2*x9+2*x8+2*x7+2*x6+2*x5+2*x4+2*x3+2*x2+x1\n        ],\n        [x1,x2,x3,x4,x5,x6,x7,x8,x9]\n    ],\n    [#(5) katsura9\n        [ -x1+2*x10^2+2*x9^2+2*x8^2+2*x7^2+2*x6^2+2*x5^2+2*x4^2+2*x3^2+2*x2^2+x1^2,\n -x2+2*x10*x9+2*x9*x8+2*x8*x7+2*x7*x6+2*x6*x5+2*x5*x4+2*x4*x3+2*x3*x2+2*x2*x1,\n -x3+2*x10*x8+2*x9*x7+2*x8*x6+2*x7*x5+2*x6*x4+2*x5*x3+2*x4*x2+2*x3*x1+x2^2,\n -x4+2*x10*x7+2*x9*x6+2*x8*x5+2*x7*x4+2*x6*x3+2*x5*x2+2*x4*x1+2*x3*x2,\n -x5+2*x10*x6+2*x9*x5+2*x8*x4+2*x7*x3+2*x6*x2+2*x5*x1+2*x4*x2+x3^2,\n -x6+2*x10*x5+2*x9*x4+2*x8*x3+2*x7*x2+2*x6*x1+2*x5*x2+2*x4*x3,\n -x7+2*x10*x4+2*x9*x3+2*x8*x2+2*x7*x1+2*x6*x2+2*x5*x3+x4^2,\n -x8+2*x10*x3+2*x9*x2+2*x8*x1+2*x7*x2+2*x6*x3+2*x5*x4,\n -x9+2*x10*x2+2*x9*x1+2*x8*x2+2*x7*x3+2*x6*x4+x5^2,\n -1+2*x10+2*x9+2*x8+2*x7+2*x6+2*x5+2*x4+2*x3+2*x2+x1\n        ],\n        [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10]\n    ],\n    [#(6) katsura10\n        [ -x1+2*x11^2+2*x10^2+2*x9^2+2*x8^2+2*x7^2+2*x6^2+2*x5^2+2*x4^2+2*x3^2+2*x2^2+x1^2,\n -x2+2*x11*x10+2*x10*x9+2*x9*x8+2*x8*x7+2*x7*x6+2*x6*x5+2*x5*x4+2*x4*x3+2*x3*x2+2*x2*x1,\n -x3+2*x11*x9+2*x10*x8+2*x9*x7+2*x8*x6+2*x7*x5+2*x6*x4+2*x5*x3+2*x4*x2+2*x3*x1+x2^2,\n -x4+2*x11*x8+2*x10*x7+2*x9*x6+2*x8*x5+2*x7*x4+2*x6*x3+2*x5*x2+2*x4*x1+2*x3*x2,\n -x5+2*x11*x7+2*x10*x6+2*x9*x5+2*x8*x4+2*x7*x3+2*x6*x2+2*x5*x1+2*x4*x2+x3^2,\n -x6+2*x11*x6+2*x10*x5+2*x9*x4+2*x8*x3+2*x7*x2+2*x6*x1+2*x5*x2+2*x4*x3,\n -x7+2*x11*x5+2*x10*x4+2*x9*x3+2*x8*x2+2*x7*x1+2*x6*x2+2*x5*x3+x4^2,\n -x8+2*x11*x4+2*x10*x3+2*x9*x2+2*x8*x1+2*x7*x2+2*x6*x3+2*x5*x4,\n -x9+2*x11*x3+2*x10*x2+2*x9*x1+2*x8*x2+2*x7*x3+2*x6*x4+x5^2,\n -x10+2*x11*x2+2*x10*x1+2*x9*x2+2*x8*x3+2*x7*x4+2*x6*x5,\n -1+2*x11+2*x10+2*x9+2*x8+2*x7+2*x6+2*x5+2*x4+2*x3+2*x2+x1\n        ],\n        [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11]\n    ],\n    [#(7) utbikker\n        [ x^2+x*y+y^2-2*x*z-4*y*z+3*z^2-3*x*t+2*y*t+t^2-3*x-2*y+3*z-2*t-2,\n 2*x^2-x*y+y^2-x*z-y*z-6*z^2-x*t+y*t-5*z*t-3*t^2-5*x+y+5*z+2*t+5,\n -3-3*x*y+2*x*z+x*t^2-5*x*z^2-5*z^2*t-3*x*t-2*z*t+x*y*z+x*y*t-x^2*z+x^2\n -y^2+2*z^2+11*z-2*t-x+y+x^3+y^3-3*z^3+2*t^3-3*t^2-5*y^2*z+7*y*z^2,\n -15+2*x*y+11*x*t^2+5*x*z^2-z*t-4*x*y*z+6*x*y*t-x^2*z+3*x^2+2*y^2-z^2+4*z\n -10*t-35*x-14*y-x^3+6*y^3+15*z^3+4*t^3+5*t^2+6*y^2*z+4*y*z^2-x*z*t+6*x^2*y\n -12*x*y^2-7*y^2*t+2*y*t\n        ],\n        [x,y,z,t]\n    ],\n    [#(8) kotsireas\n        [ (b-d1)*(a-c) - 2*f + 2,\n (b-d1)*(a+c-2*f) + 2*(a-c),\n (b-d1)*(b-d1) - 2*(b+d1) + t + 1,\n a**2*b**3 - 1,\n c**2*d1**3 - 1,\n f**2*t**3 - 1\n        ],\n        [a,b,c,d1,f,t]\n    ],\n    [#(9) chandra4\n        [ 8*H1 - 051234/100000*H1*(1+(1/2)*H1+(1/3)*H2+(1/4)*H3) - 8,\n 8*H2 - 051234/100000*H2*(1+(2/3)*H1+(2/4)*H2+(2/5)*H3) - 8,\n 8*H3 - 051234/100000*H3*(1+(3/4)*H1+(3/5)*H2+(3/6)*H3) - 8,\n 8*H4 - 051234/100000*H4*(1+(4/5)*H1+(4/6)*H2+(4/7)*H3) - 8\n        ],\n        [H1,H2,H3,H4]\n    ],\n    [#(10) chandra5\n        [ 10*H1 - 051234/100000*H1*(1+(1/2)*H1+(1/3)*H2+(1/4)*H3+(1/5)*H4) - 10,\n 10*H2 - 051234/100000*H2*(1+(2/3)*H1+(2/4)*H2+(2/5)*H3+(2/6)*H4) - 10,\n 10*H3 - 051234/100000*H3*(1+(3/4)*H1+(3/5)*H2+(3/6)*H3+(3/7)*H4) - 10,\n 10*H4 - 051234/100000*H4*(1+(4/5)*H1+(4/6)*H2+(4/7)*H3+(4/8)*H4) - 10,\n 10*H5 - 051234/100000*H5*(1+(5/6)*H1+(5/7)*H2+(5/8)*H3+(5/9)*H4) - 10\n        ],\n        [H1,H2,H3,H4,H5]\n    ],\n    [#(11) chandra6\n        [ 12*H1 - 051234/100000*H1*(1+(1/2)*H1+(1/3)*H2+(1/4)*H3+(1/5)*H4+(1/6)*H5) - 12,\n 12*H2 - 051234/100000*H2*(1+(2/3)*H1+(2/4)*H2+(2/5)*H3+(2/6)*H4+(2/7)*H5) - 12,\n 12*H3 - 051234/100000*H3*(1+(3/4)*H1+(3/5)*H2+(3/6)*H3+(3/7)*H4+(3/8)*H5) - 12,\n 12*H4 - 051234/100000*H4*(1+(4/5)*H1+(4/6)*H2+(4/7)*H3+(4/8)*H4+(4/9)*H5) - 12,\n 12*H5 - 051234/100000*H5*(1+(5/6)*H1+(5/7)*H2+(5/8)*H3+(5/9)*H4+(5/10)*H5) - 12,\n 12*H6 - 051234/100000*H6*(1+(6/7)*H1+(6/8)*H2+(6/9)*H3+(6/10)*H4+(6/11)*H5) - 12\n        ],\n        [H1,H2,H3,H4,H5,H6]\n    ],\n    [#(12) tangents0\n        [x0**2+x1**2+x2**2-1,\nx0*x3+x1*x4+x2*x5,\n 50*x0**2-2*x0*x4+ 14*x0*x5+x1**2-14*x1*x2+ 2*x1*x3+ 49*x2**2-14*x2*x3+x3**2\n+x4**2+x5**2-1,\n 29*x0**2-10*x0*x1-4*x0*x2-4*x0*x4+ 10*x0*x5+ 5*x1**2-20*x1*x2+ 4*x1*x3-2*x1\n*x5+ 26*x2**2-10*x2*x3+ 2*x2*x4+x3**2+x4**2+x5**2-1,\n 9*x0**2-6*x0*x5+ 9*x2**2+ 6*x2*x3+x3**2+x4**2+x5**2-1,\n 9*x0**2+ 6*x0*x5+ 9*x2**2-6*x2*x3+x3**2+x4**2+x5**2-1\n        ],\n        [x0,x1,x2,x3,x4,x5]\n    ],\n    [#(13) assur44\n        [ ca^2+sa^2-1,\n cb^2+sb^2-1,\n cc^2+sc^2-1,\n cd^2+sd^2-1,\n 8*cc*cb*ca+8*cc*cb*sa-8*cc*sb*ca+8*cc*sb*sa-8*sc*cb*ca+8*sc*cb*sa-8*sc*\n sb*ca-8*sc*sb*sa+24*cc*cb-24*cc*sb-24*sc*cb-24*sc*sb-16*cb*ca+12*cb*sa-12*sb*ca\n-16*sb*sa-4*cc+28*sc-48*cb-36*sb+24*ca+48,\n -8*cd*cb*ca+16*cd*cb*sa-16*cd*sb*ca-8*cd*sb*sa+16*sd*cb*ca+8*sd*cb*sa-8*\nsd*sb*ca+16*sd*sb*sa-32*cd*cb+86*cd*sb-86*sd*cb-32*sd*sb+8*cb*ca+12*cb*sa-12*sb\n*ca+8*sb*sa+16*cd+28*sd-73*cb+12*sb-28*ca-30*sa+112,\n -980*cd*cb*ca-1960*cd*cb*sa+1960*cd*sb*ca-980*cd*sb*sa-1960*sd*cb*ca+980\n*sd*cb*sa-980*sd*sb*ca-1960*sd*sb*sa+280*cc*cb*ca-1400*cc*cb*sa+1400*cc*sb*ca+\n280*cc*sb*sa+1400*sc*cb*ca+280*sc*cb*sa-280*sc*sb*ca+1400*sc*sb*sa+6300*cd*cc-\n4900*cd*sc+6860*cd*cb+8330*cd*sb-4900*sd*cc-6300*sd*sc-8330*sd*cb+6860*sd*sb+\n6860*cc*cb+1540*cc*sb+1540*sc*cb-6860*sc*sb+56*cb*ca+2268*cb*sa-2268*sb*ca+56*\nsb*sa-11480*cd+5390*sd-8060*cc+1820*sc-10094*cb-4788*sb+784*ca-1764*sa+19798,\n 280*cd*cc-280*sd*sc-336*cd-240*cc+391\n        ],\n        [ca,cb,cc,cd,sa,sb,sc,sd]\n    ],\n    [#(14) cyclic9\n        [ z0 + z1 + z2 + z3 + z4 + z5 + z6 + z7 + z8,\n  z0*z1 + z1*z2 + z2*z3 + z3*z4 + z4*z5 + z5*z6 + z6*z7 + z7*z8 + z8*z0,\n  z0*z1*z2 + z1*z2*z3 + z2*z3*z4 + z3*z4*z5 + z4*z5*z6 + z5*z6*z7\n+ z6*z7*z8 + z7*z8*z0 + z8*z0*z1,\n  z0*z1*z2*z3 + z1*z2*z3*z4 + z2*z3*z4*z5 + z3*z4*z5*z6 + z4*z5*z6*z7\n+ z5*z6*z7*z8 + z6*z7*z8*z0 + z7*z8*z0*z1 + z8*z0*z1*z2,\n  z0*z1*z2*z3*z4 + z1*z2*z3*z4*z5 + z2*z3*z4*z5*z6 + z3*z4*z5*z6*z7\n+ z4*z5*z6*z7*z8 + z5*z6*z7*z8*z0 + z6*z7*z8*z0*z1 + z7*z8*z0*z1*z2\n+ z8*z0*z1*z2*z3,\n  z0*z1*z2*z3*z4*z5 + z1*z2*z3*z4*z5*z6 + z2*z3*z4*z5*z6*z7 + z3*z4*z5*z6*z7*z8\n+ z4*z5*z6*z7*z8*z0 + z5*z6*z7*z8*z0*z1 + z6*z7*z8*z0*z1*z2 + z7*z8*z0*z1*z2*z3\n+ z8*z0*z1*z2*z3*z4,\n  z0*z1*z2*z3*z4*z5*z6 + z1*z2*z3*z4*z5*z6*z7 + z2*z3*z4*z5*z6*z7*z8\n+ z3*z4*z5*z6*z7*z8*z0 + z4*z5*z6*z7*z8*z0*z1 + z5*z6*z7*z8*z0*z1*z2\n+ z6*z7*z8*z0*z1*z2*z3 + z7*z8*z0*z1*z2*z3*z4 + z8*z0*z1*z2*z3*z4*z5,\n  z0*z1*z2*z3*z4*z5*z6*z7 + z1*z2*z3*z4*z5*z6*z7*z8 + z2*z3*z4*z5*z6*z7*z8*z0\n+ z3*z4*z5*z6*z7*z8*z0*z1 + z4*z5*z6*z7*z8*z0*z1*z2 + z5*z6*z7*z8*z0*z1*z2*z3\n+ z6*z7*z8*z0*z1*z2*z3*z4 + z7*z8*z0*z1*z2*z3*z4*z5 + z8*z0*z1*z2*z3*z4*z5*z6,\n  z0*z1*z2*z3*z4*z5*z6*z7*z8 - 1\n        ],\n        [z0,z1,z2,z3,z4,z5,z6,z7,z8]\n    ],\n    [#(15) cyclic10\n        [  z0 + z1 + z2 + z3 + z4 + z5 + z6 + z7 + z8 + z9,\n  z0*z1 + z1*z2 + z2*z3 + z3*z4 + z4*z5 + z5*z6 + z6*z7 + z7*z8 + z8*z9 + z9*z0,\n  z0*z1*z2 + z1*z2*z3 + z2*z3*z4 + z3*z4*z5 + z4*z5*z6 + z5*z6*z7\n+ z6*z7*z8 + z7*z8*z9 + z8*z9*z0 + z9*z0*z1,\n  z0*z1*z2*z3 + z1*z2*z3*z4 + z2*z3*z4*z5 + z3*z4*z5*z6 + z4*z5*z6*z7\n+ z5*z6*z7*z8 + z6*z7*z8*z9 + z7*z8*z9*z0 + z8*z9*z0*z1 + z9*z0*z1*z2,\n  z0*z1*z2*z3*z4 + z1*z2*z3*z4*z5 + z2*z3*z4*z5*z6 + z3*z4*z5*z6*z7\n+ z4*z5*z6*z7*z8 + z5*z6*z7*z8*z9 + z6*z7*z8*z9*z0 + z7*z8*z9*z0*z1\n+ z8*z9*z0*z1*z2 + z9*z0*z1*z2*z3,\n  z0*z1*z2*z3*z4*z5 + z1*z2*z3*z4*z5*z6 + z2*z3*z4*z5*z6*z7 + z3*z4*z5*z6*z7*z8\n+ z4*z5*z6*z7*z8*z9 + z5*z6*z7*z8*z9*z0 + z6*z7*z8*z9*z0*z1 + z7*z8*z9*z0*z1*z2\n+ z8*z9*z0*z1*z2*z3 + z9*z0*z1*z2*z3*z4,\n  z0*z1*z2*z3*z4*z5*z6 + z1*z2*z3*z4*z5*z6*z7 + z2*z3*z4*z5*z6*z7*z8\n+ z3*z4*z5*z6*z7*z8*z9 + z4*z5*z6*z7*z8*z9*z0 + z5*z6*z7*z8*z9*z0*z1\n+ z6*z7*z8*z9*z0*z1*z2 + z7*z8*z9*z0*z1*z2*z3 + z8*z9*z0*z1*z2*z3*z4\n+ z9*z0*z1*z2*z3*z4*z5,\n  z0*z1*z2*z3*z4*z5*z6*z7 + z1*z2*z3*z4*z5*z6*z7*z8 + z2*z3*z4*z5*z6*z7*z8*z9\n+ z3*z4*z5*z6*z7*z8*z9*z0 + z4*z5*z6*z7*z8*z9*z0*z1 + z5*z6*z7*z8*z9*z0*z1*z2\n+ z6*z7*z8*z9*z0*z1*z2*z3 + z7*z8*z9*z0*z1*z2*z3*z4 + z8*z9*z0*z1*z2*z3*z4*z5\n+ z9*z0*z1*z2*z3*z4*z5*z6,\n  z0*z1*z2*z3*z4*z5*z6*z7*z8 + z1*z2*z3*z4*z5*z6*z7*z8*z9\n+ z2*z3*z4*z5*z6*z7*z8*z9*z0 + z3*z4*z5*z6*z7*z8*z9*z0*z1 \n+ z4*z5*z6*z7*z8*z9*z0*z1*z2 + z5*z6*z7*z8*z9*z0*z1*z2*z3\n+ z6*z7*z8*z9*z0*z1*z2*z3*z4 + z7*z8*z9*z0*z1*z2*z3*z4*z5\n+ z8*z9*z0*z1*z2*z3*z4*z5*z6 + z9*z0*z1*z2*z3*z4*z5*z6*z7,\n  z0*z1*z2*z3*z4*z5*z6*z7*z8*z9 - 1\n        ],\n        [z0,z1,z2,z3,z4,z5,z6,z7,z8,z9]\n    ],\n    [#(16) cyclic11\n        [z0*z1*z2*z3*z4*z5*z6*z7*z8*z9*z10 - 1, \nz0 + z1 + z2 + z3 + z4 + z5 + z6 + z7 + z8 + z9 + z10,\nz0*z1 + z1*z2 + z2*z3 + z3*z4 + z4*z5 + z5*z6 + z6*z7 \n+ z7*z8 + z8*z9 + z9*z10 + z10*z0,\nz0*z1*z2 + z1*z2*z3 + z2*z3*z4 + z3*z4*z5 + z4*z5*z6 + z5*z6*z7\n + z6*z7*z8 + z7*z8*z9 + z8*z9*z10 + z9*z10*z0 + z10*z0*z1,\nz0*z1*z2*z3 + z1*z2*z3*z4 + z2*z3*z4*z5 + z3*z4*z5*z6 + z4*z5*z6*z7\n + z5*z6*z7*z8 + z6*z7*z8*z9 + z7*z8*z9*z10 + z8*z9*z10*z0 + z9*z10*z0*z1\n + z10*z0*z1*z2,\nz0*z1*z2*z3*z4 + z1*z2*z3*z4*z5 + z2*z3*z4*z5*z6 + z3*z4*z5*z6*z7\n + z4*z5*z6*z7*z8 + z5*z6*z7*z8*z9 + z6*z7*z8*z9*z10 + z7*z8*z9*z10*z0\n + z8*z9*z10*z0*z1 + z9*z10*z0*z1*z2 + z10*z0*z1*z2*z3,\nz0*z1*z2*z3*z4*z5 + z1*z2*z3*z4*z5*z6 + z2*z3*z4*z5*z6*z7\n + z3*z4*z5*z6*z7*z8 + z4*z5*z6*z7*z8*z9 + z5*z6*z7*z8*z9*z10\n + z6*z7*z8*z9*z10*z0 + z7*z8*z9*z10*z0*z1 + z8*z9*z10*z0*z1*z2\n + z9*z10*z0*z1*z2*z3 + z10*z0*z1*z2*z3*z4,\nz0*z1*z2*z3*z4*z5*z6 + z1*z2*z3*z4*z5*z6*z7 + z2*z3*z4*z5*z6*z7*z8\n + z3*z4*z5*z6*z7*z8*z9 + z4*z5*z6*z7*z8*z9*z10 + z5*z6*z7*z8*z9*z10*z0\n + z6*z7*z8*z9*z10*z0*z1 + z7*z8*z9*z10*z0*z1*z2 + z8*z9*z10*z0*z1*z2*z3\n + z9*z10*z0*z1*z2*z3*z4 + z10*z0*z1*z2*z3*z4*z5,\nz0*z1*z2*z3*z4*z5*z6*z7 + z1*z2*z3*z4*z5*z6*z7*z8 + z2*z3*z4*z5*z6*z7*z8*z9\n + z3*z4*z5*z6*z7*z8*z9*z10 + z4*z5*z6*z7*z8*z9*z10*z0\n + z5*z6*z7*z8*z9*z10*z0*z1 + z6*z7*z8*z9*z10*z0*z1*z2\n + z7*z8*z9*z10*z0*z1*z2*z3 + z8*z9*z10*z0*z1*z2*z3*z4\n + z9*z10*z0*z1*z2*z3*z4*z5 + z10*z0*z1*z2*z3*z4*z5*z6,\nz0*z1*z2*z3*z4*z5*z6*z7*z8 + z1*z2*z3*z4*z5*z6*z7*z8*z9\n + z2*z3*z4*z5*z6*z7*z8*z9*z10 + z3*z4*z5*z6*z7*z8*z9*z10*z0\n + z4*z5*z6*z7*z8*z9*z10*z0*z1 + z5*z6*z7*z8*z9*z10*z0*z1*z2\n + z6*z7*z8*z9*z10*z0*z1*z2*z3 + z7*z8*z9*z10*z0*z1*z2*z3*z4\n + z8*z9*z10*z0*z1*z2*z3*z4*z5 + z9*z10*z0*z1*z2*z3*z4*z5*z6\n + z10*z0*z1*z2*z3*z4*z5*z6*z7,\nz0*z1*z2*z3*z4*z5*z6*z7*z8*z9 + z1*z2*z3*z4*z5*z6*z7*z8*z9*z10\n + z2*z3*z4*z5*z6*z7*z8*z9*z10*z0 + z3*z4*z5*z6*z7*z8*z9*z10*z0*z1\n + z4*z5*z6*z7*z8*z9*z10*z0*z1*z2 + z5*z6*z7*z8*z9*z10*z0*z1*z2*z3\n + z6*z7*z8*z9*z10*z0*z1*z2*z3*z4 + z7*z8*z9*z10*z0*z1*z2*z3*z4*z5\n + z8*z9*z10*z0*z1*z2*z3*z4*z5*z6 + z9*z10*z0*z1*z2*z3*z4*z5*z6*z7\n + z10*z0*z1*z2*z3*z4*z5*z6*z7*z8\n        ],\n        [z0,z1,z2,z3,z4,z5,z6,z7,z8,z9,z10]\n    ],\n    [#(17) simple\n        [ x^2,\n x*y,\n y^2\n        ],\n        [x,y]\n    ],\n    [#(18) eg1\n        [ x**2,\n y**2\n        ],\n        [x,y]\n    ],\n    [#(19) eg2\n        [ x**2+y**2,\n x-y\n        ],\n        [x,y]\n    ],\n    [#(20) eg3\n        [ x**2,\n x-y\n        ],\n        [x,y]\n    ],\n    [#(21) eg4\n        [ x**3,\n x-y\n        ],\n        [x,y]\n    ],\n    [#(22) eg5\n        [ x**4,\n x-y\n        ],\n        [x,y]\n    ],\n    [#(23) baker1\n        [ x1**2-x2,\n x1**2+x2\n        ],\n        [x1,x2]\n    ],\n    [#(24) cbms1\n        [x1**3-x2*x3,\nx2**3-x1*x3,\nx3**3-x1*x2\n        ],\n        [x1,x2,x3]\n    ],\n    [#(25) cbms2\n        [ x1**3  - 3*x1**2*x2 + 3*x1*x2**2  - x2**3  - x3**2,\n x3**3  - 3*x3**2*x1 + 3*x3*x1**2  - x1**3  - x2**2,\n x2**3  - 3*x2**2*x3 + 3*x2*x3**2  - x3**3  - x1**2\n        ],\n        [x1,x2,x3]\n    ],\n    [#(26) mth191\n        [ x^3+y^2+z^2-1,\n x^2+y^3+z^2-1,\n x^2+y^2+z^3-1\n        ],\n        [x,y,z]\n    ],\n    [#(27) decker1\n        [ x1**3+x1*x2,\n x2**2+x2\n        ],\n        [x1,x2]\n    ],\n    [#(28) decker2\n        [ x1+x2**3,\n x1**2*x2-x2**4\n        ],\n        [x1,x2]\n    ],\n    [#(29) decker3\n        [ x1+x2**2,\n 15/10*x1*x2+x2**2+x2**3\n        ],\n        [x1,x2]\n    ],\n    [#(30) kss3\n        [ x1^2 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 - 2*x1 - 9,\n x2^2 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 - 2*x2 - 9,\n x3^2 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 - 2*x3 - 9,\n x4^2 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 - 2*x4 - 9,\n x5^2 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 - 2*x5 - 9,\n x6^2 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 - 2*x6 - 9,\n x7^2 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 - 2*x7 - 9,\n x8^2 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 - 2*x8 - 9,\n x9^2 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 - 2*x9 - 9,\n x10^2 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 - 2*x10 - 9\n        ],\n        [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10]\n    ],\n    [#(31) ojika1\n        [ x**2+y-3,\n x+0125/1000*y**2-15/10\n        ],\n        [x,y]\n    ],\n    [#(32) ojika2\n        [ x1**2+x2+x3-1,\n x1+x2**2+x3-1,\n x1+x2+x3**2-1\n        ],\n        [x1,x2,x3]\n    ],\n    [#(33) ojika3\n        [ x1+x2+x3-1,\n 02/10*x1**3+05/10*x2**2-x3+05/10*x3**2+05/10,\n x1+x2+05/10*x3**2-05/10\n        ],\n        [x1,x2,x3]\n    ],\n    [#(34) ojika4\n        [ x1+x3*x1**3+x1*x3*x2**2-x1*x3,\n 10*x2-2*x2*x3*x1**2-x3*x2**3-x2*x3,\n -6*x3**2*x1**4-3*x1**2*x2**2*x3**2-x3**2*x1**2+28*x3*x1**2\n -3*x3**2*x2**4+2*x3**2*x2**2+7*x3*x2**2+x3**2-11*x3+10\n        ],\n        [x1,x2,x3]\n    ]\n]:", "meta": {"hexsha": "c61e4f839f8234ca14e1a328579f623bbf952bf0", "size": 15033, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "Examples/database2.mpl", "max_stars_repo_name": "lihaokun/StrongSfTriDec", "max_stars_repo_head_hexsha": "2c5c3bed0a07cb790820fd6ffc7567b5f6c524e4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2022-03-21T11:48:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-21T11:50:26.000Z", "max_issues_repo_path": "Examples/database2.mpl", "max_issues_repo_name": "lihaokun/StrongSfTriDec", "max_issues_repo_head_hexsha": "2c5c3bed0a07cb790820fd6ffc7567b5f6c524e4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Examples/database2.mpl", "max_forks_repo_name": "lihaokun/StrongSfTriDec", "max_forks_repo_head_hexsha": "2c5c3bed0a07cb790820fd6ffc7567b5f6c524e4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.3534031414, "max_line_length": 91, "alphanum_fraction": 0.512805162, "num_tokens": 9499, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.819893335913536, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.4859233957208754}}
{"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\nop_a1 := 1.5214:\nop_a2 := 0.5764:\nop_b1 := 1.1284:\nop_b2 := 0.3183:\n\n(* This wrapper is to avoid overflows in the OP functionals. The\n   energy is not affected, since the value is only changed for\n   densities that are screened away.  *)\nop_b88_zab := (f_x, rs, z, xs0, xs1) ->\n  my_piecewise3(\n    b88_zab(1, op_enhancement, rs, z, xs0, xs1) = 0,\n    DBL_EPSILON,\n    b88_zab(1, op_enhancement, rs, z, xs0, xs1)\n  ):\n\nop_beta := (rs, z, xs0, xs1) ->\n  op_qab/op_b88_zab(op_enhancement, rs, z, xs0, xs1):\n\nop_f_s := (rs, z, xt, xs0, xs1) ->\n  - (1 - z^2)*n_total(rs)/4.0\n  * (op_a1*op_beta(rs, z, xs0, xs1) + op_a2)\n  / (op_beta(rs, z, xs0, xs1)^4 + op_b1*op_beta(rs, z, xs0, xs1)^3 + op_b2*op_beta(rs, z, xs0, xs1)^2)\n:\n\nop_f := (rs, z, xt, xs0, xs1) ->\n   my_piecewise3(1 - abs(z) <= p_a_zeta_threshold or (screen_dens(rs,z) and screen_dens(rs,-z)), 0,\n                 op_f_s(rs, z_thr(z), xt, xs0, xs1)):\n\nf := (rs, z, xt, xs0, xs1) ->\n  op_f(rs, z, xt, xs0, xs1):\n", "meta": {"hexsha": "28ec0e06baf2a3a85241ddd69453e23c6f8452bc", "size": 1208, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "libxc-5.1.6/maple/op.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/op.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/op.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": 30.9743589744, "max_line_length": 102, "alphanum_fraction": 0.6216887417, "num_tokens": 488, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.875787001374006, "lm_q2_score": 0.5544704649604273, "lm_q1q2_score": 0.4855980258581435}}
{"text": "`gamma/permutations` := (J) -> proc(s,t)\n local k,i,m,tt;\n k := nops(J);\n i := `+`(op(J));\n tt := [];\n m := 0;\n for i from 1 to k do\n  tt := [op(tt),t[i] +~ m];\n  m := m + J[i];\n od:\n return [seq(op(tt[s[i]]),i=1..k)];\nend:\n\n`eta/permutations` := [1];\n\n`circ/permutations` := (i,m,n) -> proc(s,t)\n local u,p;\n u := NULL;\n for p from 1 to m do\n  if s[p] < i then\n   u := u,s[p]\n  elif s[p] = i then\n   u := u , op(t +~ (i - 1));\n  else\n   u := u,s[p]+n-1;\n  fi;\n od;\n return [u];\nend:\n\n", "meta": {"hexsha": "26abcd45b4e1d3ea0811e5cbafa3a0d3122dc171", "size": 485, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/semioperads/permutations.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/permutations.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/permutations.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": 15.6451612903, "max_line_length": 43, "alphanum_fraction": 0.4536082474, "num_tokens": 200, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303186696747, "lm_q2_score": 0.611381973294151, "lm_q1q2_score": 0.48331598617711974}}
{"text": "\nDigits := 100:\ninterface(quiet=true):\nread \"common-procedures.mpl\":\nwith(orthopoly):\n\n\nmkdir(\"TEMPTRIG\"):\n\n\n\n# - Evaluation scheme :\n# case 1 : return x\n# case 2 (or Fast) : compute a simple polynomial\n# case 3 : do an argument reduction...\n\n\n\n########################################################\n#  Case 1 : Small arguments\n# return x for sine and tan, return 1 for cos\n########################################################\n\nxmax_return_x_for_sin := 2^(-26):\nxmax_return_1_for_cos_RN := sqrt(2^(-53)):\nxmax_return_1_for_cos_RDIR:=2^(-26):\none_rounded_down := evalf(1-ulp(1/2)):\n\nxmax_return_x_for_tan := 2^(-27):\n\n\n\n\n########################################################\n# Case 2 : simple polynomial approximation\n########################################################\n\n# We want to use the same polynomial in case 2 and 3.\n# So see after arg red\n\n#################################################\n#   Case 3 : Argument reduction\n#################################################\n\n\n\n#################################################\n# CODY and WAITE  Argument reduction\n\n\nC := Pi/256:\ninvC:= nearest(1/C):\nreminvC := evalf(1/C - invC):\nexpC:=ieeedouble(C)[2]:\nepsinvC := abs(reminvC*C):\n\n# There are three sets of constants :\n#  - split redC into two constants, for small values when we are concerned with absolute error\n#  - split redC into three constants, for larger values\n#  - split redC into three doubles, for the cases when we need\n#     good relative precision on the result and fear cancellation\n\n\n\n\n# Fastest reduction using two-part Cody and Waite (up to |k|=2^22)\n\nbitsCh_0:=34:\n\n# 1/2 <= C/2^(expC+1) <1\nCh:= round(evalf(  C * 2^(bitsCh_0-expC-1))) / (2^(bitsCh_0-expC-1)):\n# recompute bitsCh in case we are lucky (and we are for bitsCh_0=32)\nbitsCh:=1+log2(op(2,ieeedouble(Ch)[3])) :  # this means the log of the denominator\n\nCl:=nearest(C - Ch):\n# Cody and Waite argument reduction will work for |k|<kmax_cw2\nkmax_cw2:=2^(53-bitsCh):\n\n# The constants to move to the .h file\nRR_CW2_CH := Ch:\nRR_CW2_MCL := -Cl:\nXMAX_CODY_WAITE_2 := nearest(kmax_cw2*C):\n\n# The error in this case (we need absolute error)\ndelta_repr_C_cw2   := abs(C-Ch-Cl):\ndelta_round_cw2    := kmax_cw2* 1/2 * ulp(Cl) :\ndelta_cody_waite_2 := kmax_cw2 * delta_repr_C_cw2 + delta_round_cw2:\n# This is the delta on y, the reduced argument\n\n#log2(%);\n\n\n\n# Slower reduction using three-part Cody and Waite, up to |k|=2^31\n\nbitsCh_0:=23: # 22 or 23\nCh:= round(evalf(  C * 2^(bitsCh_0-expC-1))) / (2^(bitsCh_0-expC-1)):\n# recompute bitsCh in case we are lucky\nbitsCh:=1+log2(op(2,ieeedouble(Ch)[3])) :  # this means the log of the denominator\n\nr := C-Ch:\nCmed := round(evalf(  r * 2^(2*bitsCh-expC-1))) / (2^(2*bitsCh-expC-1)):\nbitsCmed:=1+log2(op(2,ieeedouble(Cmed)[3])) :\n\nCl:=nearest(C - Ch - Cmed):\n\nkmax_cw3 := 2^min(53-bitsCh, 53-bitsCmed, 31):# Otherwise we have integer overflow\n\n\n\n# The constants to move to the .h file\nRR_CW3_CH  := Ch:\nRR_CW3_CM  := Cmed:\nRR_CW3_MCL := -Cl:\nXMAX_CODY_WAITE_3 := nearest(kmax_cw3*C):\n\n# The error in this case (we need absolute error)\ndelta_repr_C_cw3   := abs(C - Ch - Cmed - Cl):\ndelta_round_cw3    := kmax_cw3 * 1/2 * ulp(Cl) :\ndelta_cody_waite_3 := kmax_cw3 * delta_repr_C_cw3 + delta_round_cw3:\n# This is the delta on y, the reduced argument\n\n#log2(%);\n\n\n\n\n\n# Third range reduction, using double-double arithmetic, for |k| up to 2^51-1\n\n# This max int value can be produced by DOUBLE2LONGINT\nkmax:=2^46-1:\nXMAX_DDRR:=nearest(kmax*C):\n\n#in this case we have C stored as 3 doubles\nCh   := nearest(C):\nCmed := nearest(C-Ch):\nCl   := nearest(C-Ch-Cmed):\n\nRR_DD_MCH := -Ch:\nRR_DD_MCM := -Cmed:\nRR_DD_CL  := Cl:\n\ndelta_repr_C := abs(C - Ch - Cmed - Cl):\n\n# and we have only exact Add12 and Mul12  operations. The only place\n# with possible rounding errors is:\n#       Add22 (pyh, pyl,    (x + kch_h) , (kcm_l - kd*RR_DD_CL),   th, tl) ;\n# where (x + kch_h) is exact (Sterbenz) with up to kmax bits of cancellation\n# and the error is simply the error in  (kcm_l - kd*RR_DD_CL)\n# At the very worst :\ndelta_round :=\n              kmax * 1/2 * ulp(Cl) # for   kd*RR_DD_CL\n              + kmax*ulp(Cl)         # for the subtraction\n              + 2^(-100) * Pi/512 :    # for the Add22\ndelta_RR_DD :=  kmax * delta_repr_C + delta_round:\n\n#  the last case, Payne and Hanek reduction, gives a very small delta:\n#  red arg is on 9*30 bits, then rounded to a double-double (106 bits)\n# This should, of course, be optimized some day\ndelta_PayneHanek := 2^(-100):\n\n# Finally the max delta on the reduced argument is\ndelta_ArgRed := max(delta_cody_waite_2, delta_cody_waite_3,\n                    delta_RR_DD, delta_PayneHanek):\n\n#print(\"delta_ArgRed to move to the .gappa file = \",  evalf(delta_ArgRed)):\n#log2(delta_ArgRed);\n\n\n\n\n\n# Now we use the above absolute error when k mod 256 <> 0\n# otherwise we need to worry about relative accuracy of the result.\n\n# First, what is the worst case for cancellation ?\n\nemax := ieeedouble(XMAX_DDRR)[2] +1 :\n# above emax, we will use Payne and Hanek so we do not worry\n\n(wcn, wce, wceps) := WorstCaseForAdditiveRangeReduction(2,53,-8, emax, C):\nwcx := wcn * 2^wce:\nwck := round(wcx/C):\nwcy := wcx - wck*C:\n\n#log2(wcy);   # y > 2^(-67);\n\n# In these cases we use the double-double range reduction, for |k|<kmax_cw3\n# and the relative precision in the worst case is for wcy\n\ndelta_round := kmax_cw3 * 1/2 * ulp(Cl)      # for   kd*RR_DD_CL\n              + kmax_cw3 * ulp(Cl) :         # for the subtraction\n\ndelta_RR_DD :=  kmax_cw3 * delta_repr_C + delta_round:\n\neps_ArgRed := (1+delta_RR_DD/wcy)*(1+2^(-100)) -1:\n\n#log2(eps_ArgRed);\n\n# In all the other cases we use Payne and Hanek, and eps_ArgRed is\n# much smaller, so this is the max.\n\n\n\n###########\n# Polynomials for do_sine and do_cos, and for the case 2\ndegreeSin := 8:\ndegreeCos := 7:\n\nmaxepsk := (1+epsinvC)*(1+2^(-53))-1:\n\nymaxCase3  := evalf(Pi/512 + XMAX_DDRR*maxepsk):\n#print(\"ymaxCase3 to move to the .gappa file = \",  ymaxCase3):\n\n\ny2maxCase3 := ymaxCase3^2:\n# These are the parameters that can be varied to fine-tune performance\n#   (they should always be larger than Pi/512\nxmaxCosCase2   := Pi/256:\nxmaxSinCase2   := Pi/256:\n\n\nx2maxSinCase2:= xmaxSinCase2^2:\nx2maxCosCase2:= xmaxCosCase2^2:\n\n# We had the difficulty here to find minimax polynomials which are good for case 2\n# as well as for case 3. A simple solution was to set xmaxCosCase2 =ymaxCase3...\n# However we found another answer: in the future we intend to use these polynomials for second\n# step, too. Therefore, no minimax, only Taylor.\n\npolySin:=  poly_exact(convert( series(sin(x), x=0, degreeSin+1), polynom)):\npolyTs := expand(polySin/x-1):\npolyTs2 := subs(x=sqrt(y), polyTs):\n\npolyCos  := poly_exact (convert( series(cos(x), x=0, degreeCos+1), polynom)):\npolyTc2 := subs(x=sqrt(y), polyCos - 1):\n\nepsApproxSinCase2 := numapprox[infnorm]((x*polyTs+x -sin(x))/sin(x), x=0..xmaxSinCase2):\nepsApproxSinCase3 := numapprox[infnorm]((x*polyTs +x -sin(x))/sin(x), x=0..ymaxCase3):\n\ndeltaApproxSinCase2 := numapprox[infnorm]((x*polyTs+x -sin(x)), x=0..xmaxSinCase2):\ndeltaApproxSinCase3 := numapprox[infnorm]((x*polyTs +x -sin(x)), x=0..ymaxCase3):\n\ndeltaApproxCosCase2:= numapprox[infnorm](polyCos -  cos(x), x=0..xmaxCosCase2):\ndeltaApproxCosCase3:= numapprox[infnorm](polyCos -  cos(x), x=0..ymaxCase3):\n\n#print(\"deltaApproxSinCase3 to move to the .gappa file = \",  deltaApproxSinCase3):\n#print(\"deltaApproxCosCase3 to move to the .gappa file = \",  deltaApproxCosCase3):\n\n\n########################## Case 2 for sine  ###########################\n\n\n\n# evaluate this polynomial in double. The error on x*x is at most half an ulp\nerrlist:=errlist_quickphase_horner(degree(polyTs2),0,0,2^(-53), 0):\n(eps_rounding_Ts, delta_rounding_Ts, minTs, maxTs):=\n\tcompute_horner_rounding_error(polyTs2,y,x2maxSinCase2, errlist, true):\n\neps_poly_TsCase2 := numapprox[infnorm]((x*polyTs)/(sin(x)-x) -1, x=0..xmaxSinCase2):\nmaxeps2 := (1+eps_poly_TsCase2)*(1+eps_rounding_Ts)*(1+2^(-53))-1:\n\nmaxepstotalSinCase2 := maxeps2 * numapprox[infnorm](1-x/sin(x), x=0..xmaxSinCase2):\nrnconstantSinCase2 := evalf(compute_rn_constant(maxepstotalSinCase2)):\n\n\n\n\n\n##################################### Case2 cos ###########################\n\n# evaluate this polynomial in double. The error on x*x is at most half an ulp\nerrlist        := errlist_quickphase_horner(degree(polyTc2),0,0,2**(-53), 0):\n(eps_rounding_Tc, delta_rounding_Tc, minTc, maxTc):=\n              compute_horner_rounding_error(polyTc2,y,x2maxCosCase2, errlist, true):\n\n# Then we have an Add12 which is exact. The result is greater then cos(xmaxCosCase2):\nminy := cos(xmaxCosCase2):\nmaxepstotalCosCase2 :=  (delta_rounding_Tc + deltaApproxCosCase2) / miny :\n#log2(%);\nrnconstantCosCase2 := evalf(compute_rn_constant(maxepstotalCosCase2)):\n\n\n\n\n######################## Case2 Tangent #########################\n#\n# Compute the Taylor series\ndegreeTanCase2 := 12:\nxmaxTanCase2   := 2**(-4):\nxminTanCase2   := 2**(-30):\n\nPoly_P := convert(series(tan(sqrt(x))/(x^(3/2))-1/x, x=0, degreeTanCase2*4),polynom):\nPoly_cheb := numapprox[chebpade](Poly_P, x=xminTanCase2..xmaxTanCase2^2, [degreeTanCase2/2-2,0]):\npolyTanCase2 :=  poly_exact2(expand(x + x^3 * subs(x=x^2, Poly_cheb)), 4):\n\n#polyTanCase2 :=  poly_exact2(convert(series(tan(x), x=0, degreeTanCase2), polynom), 4):\n\nmaxepsApproxTanCase2:=numapprox[infnorm](1 - polyTanCase2 / tan(x), x=xminTanCase2..xmaxTanCase2):\n\nmaxepsOverXTanCase2 :=numapprox[infnorm]((1 - polyTanCase2 / tan(x))/x, x=xminTanCase2..xmaxTanCase2):\n# Now we pass these values to Gappa\n\nfilename:=\"TEMPTRIG/TanCase2.sed\":\nfd:=fopen(filename, WRITE, TEXT):\n  t3h, t3l := hi_lo(coeff(polyTanCase2,x,3)):\n  fprintf(fd, \" s/_t3h/%1.40e/g\\n\", t3h):\n  fprintf(fd, \" s/_t3l/%1.40e/g\\n\", t3l):\n  fprintf(fd, \" s/_t5/%1.40e/g\\n\",  coeff(polyTanCase2,x,5)):\n  fprintf(fd, \" s/_t7/%1.40e/g\\n\",  coeff(polyTanCase2,x,7)):\n  fprintf(fd, \" s/_t9/%1.40e/g\\n\",  coeff(polyTanCase2,x,9)):\n  fprintf(fd, \" s/_t11/%1.40e/g\\n\", coeff(polyTanCase2,x,11)):\n  fprintf(fd, \" s/_xmax/%1.40e/g\\n\", xmaxTanCase2):\n  fprintf(fd, \" s/_maxEpsApproxOverX/%1.40e/g\\n\", maxepsOverXTanCase2*1.00001):\n  fprintf(fd, \" s/_maxEpsApprox/%1.40e/g\\n\", maxepsApproxTanCase2*1.00001):\nfclose(fd):\n\nprintf(\"\\n\\n************ DONE TEMPTRIG/TanCase2.sed ************\\n\");\nprintf(\"Now you should use  \\n    sed -f TEMPTRIG/TanCase2.sed trigoTanCase2.gappa | gappa  > /dev/null \\n\");\n\n\n\nmaxepstotalTanCase2:=4.59602e-19:  # Cut from Gappa output\n\nlog2(maxepstotalTanCase2): # almost 61 bits\n\n\n\n\n\n\n###############################################################################\n#   Computing errors for Case3 : now we have an error due to arg red\n\n# First DoSinZero. The notations are those of the paper proof\n\n# Approximation error already computed above as epsApproxSinCase3;\n\n#  polynomial evaluation in double, with an error on  y*y of epsilonArgRed\nerrlist:=errlist_quickphase_horner(degree(polyTs2),0,0,eps_ArgRed, 0):\n(epsRoundingTsSinZero, deltaRoundingTsSinZero, minTs, maxTs):=\n\tcompute_horner_rounding_error(polyTs2,y,y2maxCase3, errlist, true):\n\n# just as in the paper proof\nmaxepsSinZero1 := (1+epsApproxSinCase3)*(1+epsRoundingTsSinZero)*(1+2^(-53))*(1+2^(-53))  - 1:\n\n# just as in the paper proof. For x>0 the absolute values are as given\n\nepstotalSinZero :=  ( (x-sin(x))*maxepsSinZero1 + x*eps_ArgRed + 2^(-53)*x^3/3 )  / sin(x):\nmaxepstotalSinZero := numapprox[infnorm]( epstotalSinZero , x=2^(-30)..ymaxCase3):\n\nprintf(\"\\nMax rel error for DoSinZero is %1.5e, if it's smaller than 2^(-66) (%1.5e) then the proof is OK\\n\\n\", maxepstotalSinZero, 2^(-66)):\n\n\n\n\n\n##############################SinCosCase3############################\n  SinCosSize:= 128: # size f the table\n\n\n# The Gappa files in TEMPTRIG\nfor i from 1 to SinCosSize/2 do\n    filename:=cat(\"TEMPTRIG/SinACosA_\",i,\".sed\"):\n    fd:=fopen(filename, WRITE, TEXT):\n\n    # The table values\n    s:=hi_lo(sin(i*Pi/(2*SinCosSize))):\n    c:=hi_lo(cos(i*Pi/(2*SinCosSize))):\n    fprintf(fd, \" s/_cah/%1.40e/g\\n\", c[1]):\n    fprintf(fd, \" s/_cal/%1.40e/g\\n\", c[2]):\n    fprintf(fd, \" s/_sah/%1.40e/g\\n\", s[1]):\n    fprintf(fd, \" s/_sal/%1.40e/g\\n\", s[2]):\n\n    # The polynomial coefficients\n    fprintf(fd, \" s/_s3/%1.40e/g\\n\", coeff(polySin,x,3)):\n    fprintf(fd, \" s/_s5/%1.40e/g\\n\", coeff(polySin,x,5)):\n    fprintf(fd, \" s/_s7/%1.40e/g\\n\", coeff(polySin,x,7)):\n    fprintf(fd, \" s/_s9/%1.40e/g\\n\", coeff(polySin,x,9)):\n    fprintf(fd, \" s/_c2/%1.40e/g\\n\", coeff(polyCos,x,2)):\n    fprintf(fd, \" s/_c4/%1.40e/g\\n\", coeff(polyCos,x,4)):\n    fprintf(fd, \" s/_c6/%1.40e/g\\n\", coeff(polyCos,x,6)):\n    fprintf(fd, \" s/_c8/%1.40e/g\\n\", coeff(polyCos,x,8)):\n\n    # The approximation errors\n    fprintf(fd, \" s/_ymaxCase3/%1.40e/g\\n\", ymaxCase3*1.00001):\n    fprintf(fd, \" s/_delta_ArgRed/%1.40e/g\\n\", delta_ArgRed*1.00001):\n    fprintf(fd, \" s/_delta_approx_Sin_Case3/%1.40e/g\\n\", deltaApproxSinCase3*1.00001):\n    fprintf(fd, \" s/_delta_approx_Cos_Case3/%1.40e/g\\n\", deltaApproxCosCase3*1.00001):\n\n    fclose(fd):\nod:\n\n\nprintf(\"************ DONE TEMPTRIG/*.sed ************\\n\"):\n\n# A shell script to use them\nfilename:=\"../gappa/run-trigo-proof.sh\":\nfd:=fopen(filename, WRITE, TEXT):\nfprintf(fd, \"#!/bin/sh\\n\"):\nfprintf(fd, \"# You probably need to edit the path to the gappa executable\\n\"):\nfprintf(fd, \"for file in ../maple/TEMPTRIG/SinACosA*.sed  \\n\"):\nfprintf(fd, \"do\\n\"):\nfprintf(fd, \"  echo $file:\\n\"):\nfprintf(fd, \"  sed -f  $file  trigoSinCosCase3.gappa | ~/gappa/src/gappa\\n\"):\nfprintf(fd, \"  echo\\n\"):\nfprintf(fd, \"done\\n\"):\nfclose(fd):\n\nprintf(\"************ DONE trigo_test.sh ************\\n\"):\nprintf(\"To run the Gappa proof, you should go to the gappa directory and run\\n\"):\nprintf(\" sh run-trigo-proof.sh 2> ../maple/TEMPTRIG/Gappa.out\\n\"):\n\nprintf(\"Then look at maple/TEMPTRIG/Gappa.out. It shouldn't contain 'No proof'.\\n This means that everything is OK and the rounding constants in TEMPTRIG/trigo_fast.h are proven upper bounds.\\n\\n\"):\n\n\n\n\n#  This value has been validated by Gappa (using all the previous)\nmaxepstotalSinCosCase3:=3*2^(-66):\nrnconstantSinCosCase3 := evalf(compute_rn_constant(maxepstotalSinCosCase3)):\n\n\n# The error of sin, the error of cos, then the error of Div22\nmaxepstotalTanCase3:= 2.1*maxepstotalSinCosCase3:\nrnconstantTanCase3 := evalf(compute_rn_constant(maxepstotalTanCase3)):\n\n\n\n\n\n##############################################\n## Compute constants for SCS arg red\noldDigits:=Digits:\nDigits:=1000:\n# for 2/Pi:\nn:=round(2^(30*48)*evalf(2/Pi)):\ndigitlist:=[]:\nfor i from 1 to 48 do\n  r:=n mod (2^30):\n  n:=floor(n/(2^30)):\n  hexstring:= convert(convert(r,hex),string):\n  digitlist:=[hexstring, op(digitlist)]:\nend:\ndigitlist:\n\n# for 256/Pi:\nn:=round(2^(30*47)*evalf(256/Pi)):\ndigitlist:=[]:\nfor i from 1 to 48 do\n  r:=n mod (2^30):\n  n:=floor(n/(2^30)):\n  hexstring:= convert(convert(r,hex),string):\n  digitlist:=[hexstring, op(digitlist)]:\nend:\ndigitlist:\nDigits:=oldDigits:\n\n\n\n# an auxiliary output function:\n# Outputs the high part of a double, and the double in comment.\n# As all these high parts are used in code as\n# if(absxhi < XMAX_COS_CASE2)\n# we have to remove one LSB to the high part, or, divide var by\n# (1+2^(-20))\n# Now we have absxhi<highpart(var/(1+2^(-20))\n# => absxhi*(1+2^(-20))<var\n# => x<var\noutputHighPart:=proc(cvarname, var)\n  local varMinusLSB:\n  Digits:=8:\n  varMinusLSB:=var/(1+2^(-20)):\n  (\"#define \" || cvarname || \" 0x\" || (ieeehexa(varMinusLSB)[1])\n    ||  \"        /* \" || (convert(evalf(varMinusLSB),string)) ||  \" */\" )\nend proc:\n\n\n\n\n\n# Output:\n\nfilename:=\"TEMPTRIG/trigo_fast.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/trigo.pl*/\\n\"):\nfprintf(fd, \"\\n\"):\n\n\nfprintf(fd,  \"%s\\n\",  outputHighPart(\"XMAX_RETURN_X_FOR_SIN\", xmax_return_x_for_sin) ):\nfprintf(fd,  \"%s\\n\",  outputHighPart(\"XMAX_SIN_CASE2        \", xmaxSinCase2) ):\n\nfprintf(fd,  \"%s\\n\",  outputHighPart(\"XMAX_RETURN_1_FOR_COS_RN\", xmax_return_1_for_cos_RN) ):\nfprintf(fd,  \"%s\\n\",  outputHighPart(\"XMAX_RETURN_1_FOR_COS_RDIR\", xmax_return_1_for_cos_RDIR) ):\nfprintf(fd,  \"%s\\n\",  outputHighPart(\"XMAX_COS_CASE2        \", xmaxCosCase2) ):\n\nfprintf(fd,  \"%s\\n\",  outputHighPart(\"XMAX_RETURN_X_FOR_TAN\", xmax_return_x_for_tan) ):\nfprintf(fd,  \"%s\\n\",  outputHighPart(\"XMAX_TAN_CASE2        \", xmaxTanCase2) ):\n\nfprintf(fd, \"\\n\"):\nfprintf(fd, \"#define ONE_ROUNDED_DOWN  %1.25e \\n\", one_rounded_down):\nfprintf(fd, \"\\n\"):\n\nfprintf(fd, \"#define EPS_SIN_CASE2     %1.25e \\n\", maxepstotalSinCase2):\nfprintf(fd, \"#define RN_CST_SIN_CASE2  %1.25f \\n\", rnconstantSinCase2):\nfprintf(fd, \"\\n\"):\nfprintf(fd, \"#define EPS_COS_CASE2     %1.25e \\n\", maxepstotalCosCase2):\nfprintf(fd, \"#define RN_CST_COS_CASE2  %1.25f \\n\", rnconstantCosCase2):\nfprintf(fd, \"\\n\"):\nfprintf(fd, \"#define EPS_SINCOS_CASE3     %1.25e \\n\", maxepstotalSinCosCase3):\nfprintf(fd, \"#define RN_CST_SINCOS_CASE3  %1.25f \\n\", rnconstantSinCosCase3):\nfprintf(fd, \"\\n\"):\nfprintf(fd, \"#define EPS_TAN_CASE2     %1.25e \\n\", maxepstotalTanCase2):\nfprintf(fd, \"#define EPS_TAN_CASE3     %1.25e \\n\", maxepstotalTanCase3):\nfprintf(fd, \"#define RN_CST_TAN_CASE3  %1.25f \\n\", rnconstantTanCase3):\n\nfprintf(fd, \"\\n\"):\n\nfprintf(fd, \"#define INV_PIO256        %1.25f \\n\", 1/C):\nfprintf(fd, \"\\n\"):\n\nfprintf(fd,  \"%s\\n\",  outputHighPart(\"XMAX_CODY_WAITE_2\", XMAX_CODY_WAITE_2) ):\nfprintf(fd,  \"%s\\n\",  outputHighPart(\"XMAX_CODY_WAITE_3\", XMAX_CODY_WAITE_3) ):\nfprintf(fd,  \"%s\\n\",  outputHighPart(\"XMAX_DDRR        \", XMAX_DDRR) ):\n#fprintf(fd,  \"%s\\n\",  outputHighPart(\"\", ) ):\nfprintf(fd, \"\\n\"):\n\nfprintf(fd, \"#define RR_CW2_CH  %1.25e\\n\", RR_CW2_CH):\nfprintf(fd, \"#define RR_CW2_MCL %1.25e\\n\", RR_CW2_MCL):\nfprintf(fd, \"\\n\"):\n\nfprintf(fd, \"#define RR_CW3_CH  %1.25e\\n\", RR_CW3_CH):\nfprintf(fd, \"#define RR_CW3_CM  %1.25e\\n\", RR_CW3_CM):\nfprintf(fd, \"#define RR_CW3_MCL %1.25e\\n\", RR_CW3_MCL):\nfprintf(fd, \"\\n\"):\n\nfprintf(fd, \"#define RR_DD_MCH  %1.25e\\n\", RR_DD_MCH):\nfprintf(fd, \"#define RR_DD_MCM  %1.25e\\n\", RR_DD_MCM):\nfprintf(fd, \"#define RR_DD_CL   %1.25e\\n\", RR_DD_CL):\nfprintf(fd, \"\\n\"):\n\nfprintf(fd, \"\\n\"):\n\n  fprintf(fd, \"\\n\\n\"):\n\n  # The 256/Pi SCS array\n  fprintf(fd, \"static const int digits_256_over_pi[] = \\n{\"):\n  for i from 0 to 11 do\n    for j from 1 to 4 do\n      fprintf(fd, \" 0x%s,  \\t\",digitlist[4*i+j]):\n    end:\n    fprintf(fd, \"\\n \"):\n  end:\n  fprintf(fd, \"};\\n\\n\"):\n\n  # The Pi/256 SCS constant\n  fprintf(fd, \"static const scs Pio256=\\n\"):\n  WriteSCS(fd, evalf(C)):\n  fprintf(fd, \";\\n#define Pio256_ptr  (scs_ptr)(& Pio256)\\n\\n\"):\n\nfprintf(fd,\"#ifdef WORDS_BIGENDIAN\\n\"):\nfor isbig from 1 to 0 by -1 do\n\n  if(isbig=0) then\n    fprintf(fd,\"#else\\n\"):\n  fi:\n\n  # The sine polynomial\n\n  fprintf(fd, \"static db_number const s3 = \"):\n  printendian(fd, coeff(polySin,x,3), isbig):\n  fprintf(fd, \";\\n\"):\n  fprintf(fd, \"static db_number const s5 = \"):\n  printendian(fd, coeff(polySin,x,5), isbig):\n  fprintf(fd, \";\\n\"):\n  fprintf(fd, \"static db_number const s7 = \"):\n  printendian(fd, coeff(polySin,x,7), isbig):\n  fprintf(fd, \";\\n\\n\"):\n\n\n  # the cos polynomial\n\n  fprintf(fd, \"static db_number const c2 = \"):\n  printendian(fd, coeff(polyCos,x,2), isbig):\n  fprintf(fd, \";\\n\"):\n  fprintf(fd, \"static db_number const c4 = \"):\n  printendian(fd, coeff(polyCos,x,4), isbig):\n  fprintf(fd, \";\\n\"):\n  fprintf(fd, \"static db_number const c6 = \"):\n  printendian(fd, coeff(polyCos,x,6), isbig):\n  fprintf(fd, \";\\n\\n\"):\n\n\n  # the tan polynomial\n\n  t3h, t3l := hi_lo(coeff(polyTanCase2,x,3)):\n  fprintf(fd, \"static db_number const t3h = \"):\n  printendian(fd, t3h, isbig):\n  fprintf(fd, \";\\n\"):\n  fprintf(fd, \"static db_number const t3l = \"):\n  printendian(fd, t3l, isbig):\n  fprintf(fd, \";\\n\"):\n  fprintf(fd, \"static db_number const t5 = \"):\n  printendian(fd, coeff(polyTanCase2,x,5), isbig):\n  fprintf(fd, \";\\n\"):\n  fprintf(fd, \"static db_number const t7 = \"):\n  printendian(fd, coeff(polyTanCase2,x,7), isbig):\n  fprintf(fd, \";\\n\"):\n  fprintf(fd, \"static db_number const t9 = \"):\n  printendian(fd, coeff(polyTanCase2,x,9), isbig):\n  fprintf(fd, \";\\n\"):\n  fprintf(fd, \"static db_number const t11 = \"):\n  printendian(fd, coeff(polyTanCase2,x,11), isbig):\n  fprintf(fd, \";\\n\\n\"):\n\n\n  # The sincos table\n\n  fprintf(fd, \"\\n/*  sine and cos of kPi/256 in double-double */\\n\"):\n  fprintf(fd, \"static db_number const sincosTable[%d] =\\n{\\n\",  4*(SinCosSize/2+1)):\n  for i from 0 to SinCosSize/2 do\n      s:=hi_lo(sin(i*Pi/(2*SinCosSize))):\n      c:=hi_lo(cos(i*Pi/(2*SinCosSize))):\n      printendian(fd,s[1],isbig):\n      fprintf(fd,\" ,\\n\"):\n      printendian(fd,s[2],isbig):\n      fprintf(fd,\" ,\\n\"):\n      printendian(fd,c[1],isbig):\n      fprintf(fd,\" ,\\n\"):\n      printendian(fd,c[2],isbig):\n    if i<SinCosSize-1 then fprintf(fd,\" ,\\n\"): fi:\n  od:\n  fprintf(fd, \"\\n};\\n\\n\"):\n\n\nod:\nfprintf(fd,\"#endif /* WORDS_BIGENDIAN */\\n\\n\\n\"):\n\nfclose(fd):\n\nprintf(\"\\n\\n************ DONE TEMPTRIG/trigo_fast.h ************\\n Copy it to the crlibm source directory.\\n\\n\");\n\n\n#################################################\n# Stuff for the accurate phase,\n#\n# Should very bad cases be found in the future, only the degrees below\n# should  be increased, then this script rerun. Everything should\n# compile OK with the newly generated trigo_accurate.h\n\nprintf(\"\\n-------------------------------------------------------\\n\"):\nprintf(\"--------------------Accurate phase---------------------\\n\"):\nprintf(\"-------------------------------------------------------\\n\"):\n\nxminSCS   := 0:\nxmaxSCS   := Pi/4:\n\n\n#-----------------Sine-----------------------\ndegreeSinSCS := 26:\nPoly_P := convert(series(sin(sqrt(x))/(x^(3/2))-1/x, x=0, degreeSinSCS*4),polynom):\nPoly_cheb := numapprox[chebpade](Poly_P, x=xminSCS..xmaxSCS^2, [degreeSinSCS/2-2,0]):\npolySinSCS :=  poly_exact_SCS(expand(x + x^3 * subs(x=x^2, Poly_cheb))):\n\nDEGREE_SIN_SCS := degree(polySinSCS):\nmaxepsApproxSinSCS:=numapprox[infnorm](1 - polySinSCS/sin(x), x=xminSCS..xmaxSCS):\nprintf(\"The sine polynomial for the second phase (degree %d) is accurate to %f bits on O..Pi/4\\n\", DEGREE_SIN_SCS, -log2(maxepsApproxSinSCS)):\n# For the proof of the very bad cases, near zero\nmaxepsApproxSinSCSNearZero:=numapprox[infnorm](1 - polySinSCS/sin(x), x=0..2^(-17)):\nprintf(\"  ... and  accurate to %f bits on O..2^(-17)\\n\", -log2(maxepsApproxSinSCSNearZero)):\n\n\n#-----------------Cos-----------------------\ndegreeCosSCS := 28:\nPoly_P := convert(series((cos(sqrt(x)) -1)/x, x=0, degreeCosSCS*4),polynom):\nPoly_cheb := numapprox[chebpade](Poly_P, x=xminSCS..xmaxSCS^2, [degreeCosSCS/2-2,0]):\npolyCosSCS :=  poly_exact_SCS(expand(1 + x^2 * subs(x=x^2, Poly_cheb))):\nDEGREE_COS_SCS := degree(polyCosSCS):\n\nmaxepsApproxCosSCS:=numapprox[infnorm](1 - polyCosSCS/cos(x), x=xminSCS..xmaxSCS):\nprintf(\"The cos polynomial for the second phase (degree %d) is accurate to %f bits on O..Pi/4\\n\", degree(polyCosSCS), -log2(maxepsApproxCosSCS)):\n# For the proof of the very bad cases, near zero\nmaxepsApproxCosSCSNearZero:=numapprox[infnorm](1 - polyCosSCS/cos(x), x=0..2^(-18)):\nprintf(\"  ... and  accurate to %f bits on O..2^(-18)\\n\", -log2(maxepsApproxCosSCSNearZero)):\n\n\n\n#-----------------Tan-----------------------\ndegreeTanSCS := 70:\nPoly_P := convert(series(tan(sqrt(x))/(x^(3/2))-1/x, x=0, degreeTanSCS*4),polynom):\nPoly_cheb := numapprox[chebpade](Poly_P, x=xminSCS..xmaxSCS^2, [degreeTanSCS/2-2,0]):\npolyTanSCS :=  poly_exact_SCS(expand(x + x^3 * subs(x=x^2, Poly_cheb))):\n\nDEGREE_TAN_SCS := degree(polyTanSCS):\nmaxepsApproxTanSCS:=numapprox[infnorm](1 - polyTanSCS/tan(x), x=xminSCS..xmaxSCS):\nprintf(\"The tan polynomial for the second phase (degree %d) is accurate to %f bits on O..Pi/4\\n\", DEGREE_TAN_SCS, -log2(maxepsApproxTanSCS)):\n# For the proof of the very bad cases, near zero\nmaxepsApproxTanSCSNearZero:=numapprox[infnorm](1 - polyTanSCS/tan(x), x=0..2^(-17)):\nprintf(\"  ... and  accurate to %f bits on O..2^(-17)\\n\", -log2(maxepsApproxTanSCSNearZero)):\n\n\nfilename:=\"TEMPTRIG/trigo_accurate.h\":\nfd:=fopen(filename, WRITE, TEXT):\nfprintf(fd, \"/*File generated by maple/trigo.mpl*/\\n\\n\"):\nfprintf(fd, \"#include \\\"crlibm.h\\\"\\n#include \\\"crlibm_private.h\\\"\\n\\n\"):\nfprintf(fd, \"#define DEGREE_SIN_SCS  %d \\n\", DEGREE_SIN_SCS):\nfprintf(fd, \"#define DEGREE_COS_SCS  %d \\n\", DEGREE_COS_SCS):\nfprintf(fd, \"#define DEGREE_TAN_SCS  %d \\n\", DEGREE_TAN_SCS):\nfprintf(fd, \"\\n\"):\nfprintf(fd, \"#define  sin_scs_poly_ptr (scs_ptr)&sin_scs_poly \\n\"):\nfprintf(fd, \"#define  cos_scs_poly_ptr (scs_ptr)&cos_scs_poly \\n\"):\nfprintf(fd, \"#define  tan_scs_poly_ptr (scs_ptr)&tan_scs_poly \\n\"):\nfprintf(fd, \"\\n\"):\nWrite_SCS_poly(fd, sin_scs_poly, polySinSCS):\nfprintf(fd, \"\\n\\n\"):\nWrite_SCS_poly(fd, cos_scs_poly, polyCosSCS):\nfprintf(fd, \"\\n\\n\"):\nWrite_SCS_poly(fd, tan_scs_poly, polyTanSCS):\nfprintf(fd, \"\\n\"):\nfclose(fd):\n\nprintf(\"\\n\\n************ DONE TEMPTRIG/trigo_accurate.h ************\\n Copy it to the crlibm source directory.\\n\\n\");\n\n\n", "meta": {"hexsha": "f8d2bf76d448defa83ee76c2f7bdbacdea5e0708", "size": 24806, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "crlibm/maple/trigo.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/trigo.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/trigo.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": 34.0274348422, "max_line_length": 198, "alphanum_fraction": 0.6489962106, "num_tokens": 8343, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8152324848629215, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.4831610649758154}}
{"text": "sgn := proc(s) local i,j; signum(mul(mul(s[j] - s[i],j=i+1..nops(s)),i=1..nops(s))); end:\n\n######################################################################\n\nis_table_on := (A::set) -> proc(x)\n if not(type(x,table)) then return false; fi;\n if {indices(x)} <> map(a -> [a],A) then\n  return false;\n fi;\n\n return true;\nend:\n\n######################################################################\n\n# Return a randomly selected element of a finite set A\n\nrandom_element_of := proc(A)\n local n,i;\n\n if not type(A,list) and not type(A,set) then\n  error(\"A is not a list or set\");\n fi;\n\n n := nops(A);\n \n if n = 0 then\n  error(\"A is empty\");\n fi;\n \n i := rand(1..n)();\n return A[i];\nend:\n\n######################################################################\n\n# Return a randomly selected element of a finite set A\n\nrandom_subset_of := proc(A,size_::nonnegint)\n local n,i,U,V,r,x;\n\n if not type(A,list) and not type(A,set) then\n  error(\"A is not a list or set\");\n fi;\n\n n := nops(A);\n\n if nargs = 1 then\n  r := rand(2);\n  V := select(a -> (r() = 1),{op(A)});\n  return V;\n else\n  if size_ > n then\n   return FAIL;\n  fi;\n  U := {op(A)};\n  V := {};\n  for i from 0 to size_-1 do\n   x := U[rand(1..(n-i))()];\n   U := U minus {x};\n   V := V union {x};\n  od:\n  return V;\n fi;\nend:\n\nrandom_nonempty_subset_of := proc(A)\n local n,k,B;\n \n if not type(A,list) and not type(A,set) then\n  error(\"A is not a list or set\");\n fi;\n\n n := nops(A);\n if n = 0 then error(\"A is empty\"); fi;\n k := rand(1..n)();\n B := combinat[randcomb](A,k);\n return B;\nend:\n\n\n\n######################################################################\n\n# This function converts small numbers to single-character strings,\n# which is convenient in some circumstances when we need to display\n# a large number of small numbers.\n#\n#  0 ..  9 become \"0\" to \"9\"\n# 10 .. 35 become \"A\" to \"Z\"\n# 36 .. 61 become \"a\" to \"z\"\n\nnat_code := table([\n seq(i = convert([48+i],bytes),i=0..9),\n seq(i = convert([65+i-10],bytes),i=10..35),\n seq(i = convert([97+i-36],bytes),i=36..61)\n]);\n\n######################################################################\n\n# Return a list of pairs [p[i],v[i]] such that the p[i] are distinct\n# primes in increasing order, the v[i] are nonzero integers, and \n# n is the product of the p[i]^v[i].  The real work is done by Maple's\n# ifactor() function, we just convert the result to a more convenient\n# form.\n\nifactor_list := proc(n::rational)\n local u;\n if n = 0 then \n  error(\"Cannot factor zero\");\n fi;\n u := ifactor(abs(n));\n if type(u,`*`) then\n  u := [op(u)];\n else\n  u := [u];\n fi;\n u := map(x -> `if`(type(x,`^`),[op(op(1,x)),op(2,x)],[op(x),1]),u);\n return u;\nend:\n\n######################################################################\n\n# Return true iff n = p^k for some prime p and integer k >= 0.\n\nis_prime_power := proc(n::posint)\n not(type(ifactor(n),`*`));\nend:\n\n######################################################################\n\n# Return the p-adic valuation of m.\n\npadic_val := proc(m::rational,p)\n local k,l;\n if m = 0 then return infinity; fi;\n if denom(m) <> 1 then\n  return padic_val(numer(m),p) - padic_val(denom(m),p);\n fi;\n k := 0;\n l := m;\n while irem(l,p,'l') = 0 do k := k+1; od:\n return k;\nend:\n\n######################################################################\n\n# Return the list of the base p digits of n, least significant first.\n\ndigit_list := proc(n::nonnegint,p::posint)\n local L,m;\n L := NULL;\n m := n;\n while m > 0 do\n  L := L,irem(m,p);\n  m := iquo(m,p);\n od:\n return [L];\nend:\n\n# Return the sum of the base p digits of n.\n\ndigit_sum := (n::nonnegint,p::posint) -> `+`(0,op(digit_list(n,p)));\n\n######################################################################\n\n# If u is an algebraic expression with an overall minus sign, then \n# remove the mius sign.\n\nstrip_sign := proc(u)\n if type(u,list) or type(u,set) then\n  return map(strip_sign,u);\n elif type(u,`*`) then\n  return map(x -> `if`(type(x,numeric),abs(x),x),u);\n else\n  return u;\n fi;\nend:\n\n######################################################################\n\n# Given a Grobner basis such that the corresponding quotient ring is\n# finite-dimensional, return the usual basis for that quotient.\n\ncobasis := proc(basis,vars)\n local lm_basis,B,B0,V,b,i,v;\n\n lm_basis := map(u -> LeadingMonomial(u,vars), basis);\n B := [1];\n V := [op(vars)];\n for v in V do \n  B0 := B;\n  B := NULL;\n  for b in B0 do\n   i := 0;\n   while NormalForm(b*v^i,lm_basis,vars) <> 0 do\n    B := B,b*v^i;\n    i := i+1;\n   od:\n  od:\n  B := [B];\n od:\n return B;\nend:\n\n######################################################################\n\n# Returns the set of monomials occuring in u\n\nmonomials := proc(u)\n if type(u,`+`) or type(u,list) or type(u,set) then\n  return map(op,map(monomials,{op(u)}));\n elif type(u,`*`) then\n  return {remove(type,u,constant)};\n elif type(u,constant) then\n  return {1};\n else \n  return {u};\n fi;\nend:\n\n######################################################################\n\n# Returns the coefficient in u of the monomial m.\n# If u involves variables that do not occur in m, then these will\n# be included in the coefficient.\n\nmulti_coeff := proc(u,m)\n local c,x;\n c := u;\n for x in indets(m) do\n  c := coeff(c,x,degree(m,x));\n od;\n return c;\nend:\n\ncoeff_list := (u,mm) -> map2(multi_coeff,u,mm);\n\n######################################################################\n\n# This function returns a pair [d,q], where d is the gcd of the integers\n# in u, and q is a list of integers such that the sum of the terms\n# q[i] * u[i] is equal to d.  Moreover, q is the unique such list with\n# 0 <= q[i] < d[i]/d[i-1] for i = 2,...,n, where d[i] is the gcd of\n# u[1],...,u[i].  Note that there is no bound on q[1], which will\n# typically be large and negative.\n\nigcd_alt := proc(u::list(posint))\n local n,d,e,v,s,t,p,q,m,i;\n n := nops(u);\n d := table():\n e := table():\n v := table():\n d[1] := u[1];\n for i from 2 to nops(u) do\n  d[i] := igcdex(d[i-1],u[i],s[i],t[i]);\n  e[i-1] := d[i-1]/d[i];\n  v[i] := u[i]/d[i];\n od:\n e[n] := d[n];\n\n p[n] := s[n];\n q[n] := t[n];\n m := iquo(q[n],e[n-1]);\n q[n] := q[n] - m*e[n-1];\n p[n] := p[n] + m*v[n];\n\n for i from n-1 to 2 by -1 do\n  p[i] := s[i]*p[i+1];\n  q[i] := t[i]*p[i+1];\n  m := floor(q[i]/e[i-1]);\n  q[i] := q[i] - m*e[i-1];\n  p[i] := p[i] + m*v[i];\n od;\n\n q[1] := p[2];\n return [d[n],[seq(q[i],i=1..n)]];\nend:\n\n######################################################################\n\n# Permutation matrix\n# (duplicated in groups/general_linear.mpl)\n\nperm_matrix := proc(s)\n local n,M,i;\n n := nops(s);\n M := Matrix(n,n);\n for i from 1 to n do \n  M[s[i],i] := 1;\n od:\n return M;\nend:\n\n######################################################################\n\n# Return u, but with all tiny numerical constants converted to 0.\n\ntrim := proc(u,epsilon := 10.^(-90))\n local c,v;\n if type(u,`+`) or type(u,list) or type(u,set) or type(u,Matrix) or type(u,Vector) then\n  return map(trim,u,epsilon);\n elif type (u,`*`) then\n  c,v := selectremove(type,u,complex(numeric));\n  if abs(Re(c)) < epsilon then c := Im(c) * I; fi;\n  if abs(Im(c)) < epsilon then c := Re(c); fi;\n  return c * v;\n elif type(u,complex(numeric)) then\n  c := u;\n  if abs(Re(c)) < epsilon then c := Im(c) * I; fi;\n  if abs(Im(c)) < epsilon then c := Re(c); fi;\n  return c;\n else\n  return u;\n fi;\nend:\n\n######################################################################\n\nsymmetric_difference := (A,B) ->\n {op(A),op(B)} minus ({op(A)} intersect {op(B)});\n\n\nis_all_zero := proc(x)\n if type(x,{list,set}) then \n  return `and`(op(map(is_all_zero,x)));\n elif type(x,Vector) then \n  return is_all_zero(convert(x,list));\n elif type(x,Matrix) then \n  return is_all_zero(convert(x,listlist));\n else \n  return evalb(x = 0);\n fi;\nend:\n\n######################################################################\n\nis_all_zero := proc(x)\n if type(x,{list,set}) then \n  return `and`(op(map(is_all_zero,x)));\n elif type(x,Vector) then \n  return is_all_zero(convert(x,list));\n elif type(x,Matrix) then \n  return is_all_zero(convert(x,listlist));\n else \n  return evalb(x = 0);\n fi;\nend:\n\n######################################################################\n\nmake_index := proc(L::{list,Vector})\n local L0,T,i;\n \n L0 := L;\n if type(L0,Vector) then L0 := convert(L0,list); fi;\n\n T := table();\n for i from 1 to nops(L0) do\n  T[L0[i]] := i;\n od;\n\n return eval(T);\nend:\n\n######################################################################\n\nsum_terms := proc(x)\n if x = 0 then\n  return [];\n elif type(x,`+`) then\n  return [op(x)];\n else\n  return [x];\n fi;\nend;\n\ncoeff_split := proc(x,T := integer)\n if type(x,T) then\n  return [x,1];\n elif type(x,`*`) then\n  return [selectremove(type,x,T)];\n else\n  return [1,x];\n fi;\nend;", "meta": {"hexsha": "5faedcc0cba9d10cfa9fdc0ab5ea946800897360", "size": 8673, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/util.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/util.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/util.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.4689119171, "max_line_length": 89, "alphanum_fraction": 0.5012106538, "num_tokens": 2544, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6548947290421276, "lm_q2_score": 0.7371581626286834, "lm_q1q2_score": 0.48276099517590426}}
{"text": "#\n# Functions related to the CMS model or Cherednik operators \n#\n###################\n#list of functions#\n###################\n#\t\tHpoly:=proc(poly) \n#\t\tDunkl_i_n:= proc(i, n, poly, Nin:=0, parameter:= beta)\n#\t\tH_n:= proc(n, poly, giveinm:=1)\n#\t\tI_k_n:= proc(k, n, poly, giveinm:=1)\n#\t\tEigenCMSn:= proc(spart,n, hn:=0, IorNot:=NULL, minN:=NULL)\n#\t\tlambdabar_i:= proc(composition, i, N)\n#\t\tFermDunkl_i_n:= proc(i,n, poly)\n#\t\tItilde_k_n:= proc(k, n, poly, giveinm:=1)\n\n\n\n\nHcmsPolyM:= proc(expr_in_m)\n\treturn z_to_m(sort(expand(Hpoly(old_LinBaseConvert(expr_in_m, `z`))))); \nend proc:\npart_Hpoly:= proc(poly, i, nbvars)\n\tlocal j, term2, term3, terms, term23;\n\tterms:= [seq(k, k=(i+1)..nbvars)];\n\t#for j from i+1 to nbvars do\n\t#if j > i  then \n\tterm2:=0; term3:=0;\n\t\tterm2:=map(j->(((z||i+z||j)/(z||i-z||j)*(z||i*diff(\n\t\t\tpoly,z||i)-z||j*diff(poly,z||j)))), terms);\n\t\tterm3:=map(j->(((z||i*z||j)/((z||i-z||j)^2)*(\n\t\t\t\tpoly-subs({theta||i=theta||j,\n\t\t\t\ttheta||j=theta||i,phi||i=phi||j,\n\t\t\t\tphi||j=phi||i},poly)))), terms) ;\n\t#end if;\n\t#end do:\n\tterm23:= term2 -2*term3;\n\treturn sort(expand(add(k, k in term23)));\nend proc:\nHpoly:=proc(poly) \n\tlocal H_on_poly, term1, term23, term3, i,j, Vars, nbvars, varsindices;\n\t#Hamiltonian as a direct generalization of K_ij\n\t#The code is pretty much self-explainatory\n    \tVars:=giveVars(poly);\n    \tnbvars:= max(nops(Vars[1]), nops(Vars[2]), nops(Vars[3]));\n\n\tterm1:=0; term23:=0; term3:=0;\n\tvarsindices:= [seq(k, k=1..nbvars)];\n\t#term1:=term1+sort(expand(z||i*(diff(z||i*diff(poly,z||i),z||i))));\n\tterm1:= map(x-> z||x*(diff(z||x*diff(poly, z||x), z||x)), varsindices);\n\tterm1:= sort(expand(add(k, k in term1)));\n\tterm23:= map(x-> part_Hpoly(poly,x,nbvars), varsindices);\n\tterm23:= sort(expand(beta*add(k, k in term23)));\n\tH_on_poly:= sort(expand(term1+term23));\n\t#H_on_poly:= z_to_m(H_on_poly); \n\treturn factor(H_on_poly);\nend proc:\n\nmH_n:= proc(n, poly_in_m)\n\treturn H_n(n,old_LinBaseConvert(poly_in_m, 'z'), 1);\nend proc:\n\nH_n:= proc(n, poly, giveinm:=1)\n    local Hpoly, N, Vars;\n\t# The hamiltonian tower in terms of the sum of the dunkl on every variables\n    Vars:= giveVars(poly);\n\tN:= max(nops(Vars[1]), nops(Vars[2]), nops(Vars[3]));\n\tif N = 1 then N:= 2; end if;\n    Hpoly:= simplify(add(Dunkl_i_n(i, n, poly, N), i=1..N));\n    if giveinm = 1 then Hpoly:= z_to_m(Hpoly); end if; \n    return Hpoly;\nend proc:\n#J_n:= proc(n, poly, giveninm:=1)\n    #local Hpoly, N, Vars;\n\t# The hamiltonian tower in terms of the sum of the dunkl on every variables\n    #Vars:= giveVars(poly);\n\t#N:= max(nops(Vars[1]), nops(Vars[2]), nops(Vars[3]));\n\t#if N = 1 then N:= 2; end if;\n    #Hpoly:= add(Dunkl_i_n(i, n, phi||i*theta||i*diff(diff(poly, phi||i), theta||i), N), i=1..N);\n    #if giveinm = 1 then Hpoly:= z_to_m(Hpoly); end if; \n    #return Hpoly;\n#end proc:\n#H_n:= proc(n, poly, giveinm:=1)\n\t#local Hpoly, N, Vars; \n\t#Vars:= giveVars(poly);\n\t#N:= max(nops(Vars[1]), nops(Vars[2]), nops(Vars[3]));\n\t#if N = 1 then N:= 2; end if;\n    \t#Hpoly:= add(FermDunkl_i_n(i, n, poly), i=1..N);\n    \t#if giveinm = 1 then Hpoly:= z_to_m(Hpoly); end if; \n    \t#return Hpoly;\n#end proc:\nproject_var_sector:= proc(poly_z,var, sector)\n\tlocal mbarbar, mbar, Ppoly, k,j, mubar, ind, thevar;\n\tmbarbar:= sector[4];\n\tmubar:= sector[3];\n\t#print(mubar);\n\tmbar := sector[2];\n\tPpoly:= poly_z;\n\tif var = \"pt\" then\n\t\tfor k from 1 to mbarbar do\n\t\t\tPpoly:= sort(expand(phi||k*theta||k*diff(diff(Ppoly, phi||k), theta||k)));\n\t\tend do:\n\telif var = \"p\" then \n\t\tfor j from 1 to mbar do\n\t\t\tk:= j+ mbarbar;\n\t\t\tPpoly:= sort(expand(phi||k*diff(Ppoly, phi||k)));\n\t\tend do:\n\telif var = \"t\" then\n\t\tfor j from 1 to mubar do\n\t\t\tk:= j + mbarbar+mbar;\n\t\t\tPpoly:= sort(expand(theta||k*diff(Ppoly, theta||k)));\n\t\tend do:\n\telse return NULL;\n\tend if;\n\treturn Ppoly;\nend proc:\n\nexpI_n:= proc(smalli,n, poly_in_m)\n\tlocal sector, mbarbar, mbar, nbVars, Ipoly, theIndex, mubar, bigM;\n\tprint(poly_in_m);\n\tsector:= givePolySector(poly_in_m);\n\tmbarbar:= sector[4];\n\tmbar:= sector[2];\n\tmubar:= sector[3];\n\tbigM:= [0,sector[4], sector[4]+sector[2], sector[4]+sector[3]+sector[2]];\n    nbVars:= max(map(x-> nops(Flatten(x)), genN2spart(op(sector))));\n\tIpoly:= old_LinBaseConvert(poly_in_m, 'z'); \n\tIpoly:= project_var_sector(Ipoly, \"pt\", sector); \n\tIpoly:= project_var_sector(Ipoly, \"p\", sector); \n\tIpoly:= project_var_sector(Ipoly, \"t\", sector); \n\tIpoly:= Dunkl_i_n(bigM[smalli]+1,n,Ipoly, nbVars); \n\tIpoly:= factor(Kw(Ipoly, nbVars)); \n\tIpoly:= z_to_m(Ipoly);\n\treturn Ipoly;\nend proc:\nIbarbar_n:= proc(n,poly_in_m)\n\tlocal sector, mbarbar, nbVars, Ipoly;\n\tsector:= givePolySector(poly_in_m);\n\tmbarbar:= sector[4];\n\tnbVars:= max(map(x-> nops(Flatten(x)), genN2spart(op(sector))));\n\tIpoly:= old_LinBaseConvert(poly_in_m, 'z'); \n\tif mbarbar = 0 then return 0; end if;\n\tIpoly:= phi1*theta1*diff(diff(Ipoly, phi1), theta1);\n\tIpoly:= Dunkl_i_n(1,n,Ipoly, nbVars);\n\tIpoly:= factor(Kw(Ipoly, nbVars)); \n\tIpoly:= z_to_m(Ipoly);\n\treturn Ipoly;\nend proc:\n\nIbar_n:= proc(n, poly_in_m)\n\tlocal sector, mbarbar, mbar, nbVars, Ipoly, theIndex;\n\tsector:= givePolySector(poly_in_m);\n\tmbarbar:= sector[4];\n\tmbar := sector[2];\n        nbVars:= max(map(x-> nops(Flatten(x)), genN2spart(op(sector))));\n\tIpoly:= old_LinBaseConvert(poly_in_m, 'z'); \n\tIpoly:= project_var_sector(Ipoly, \"pt\", sector); \n\tif mbar = 0 then return 0; end if;\n\ttheIndex:= mbarbar+1;\n\tIpoly:= phi||theIndex*diff(Ipoly, phi||theIndex);\n\tIpoly:= Dunkl_i_n(theIndex,n,Ipoly, nbVars); \n\tIpoly:= factor(Kw(Ipoly, nbVars)); \n\tIpoly:= z_to_m(Ipoly);\n\treturn Ipoly;\nend proc:\n\nIubar_n:= proc(n, poly_in_m)\n\tlocal sector, mbarbar, mbar,mubar, nbVars, Ipoly, theIndex;\n\tsector:= givePolySector(poly_in_m);\n\tmbarbar:= sector[4];\n\tmbar := sector[2];\n\tmubar:= sector[3];\n\tif mubar = 0 then return 0; end if;\n        nbVars:= max(map(x-> nops(Flatten(x)), genN2spart(op(sector))));\n\tIpoly:= old_LinBaseConvert(poly_in_m, 'z'); \n\tIpoly:= project_var_sector(Ipoly, \"pt\", sector); \n\tIpoly:= project_var_sector(Ipoly, \"p\", sector); \n\ttheIndex:= mbarbar+mbar+1;\n\tIpoly:= theta||theIndex*diff(Ipoly, theta||theIndex);\n\tIpoly:= Dunkl_i_n(theIndex,n,Ipoly, nbVars); \n\tIpoly:= factor(Kw(Ipoly, nbVars)); \n\tIpoly:= z_to_m(Ipoly);\n\treturn Ipoly;\nend proc:\ntestJn:= proc(n, poly_in_m)\n\tlocal poly_z, nbVars, Jpoly;\n\tpoly_z:= old_LinBaseConvert(poly_in_m, 'z'); \n\tnbVars:= giveNbVars(poly_z);\n\tJpoly:= map(x-> theta||x*diff(poly_z, theta||x), [seq(k, k=1..nbVars)]); \n\tJpoly:= map(x-> factor(Dunkl_i_n(x, n, Jpoly[x])), [seq(k,k=1..nbVars)]); \n\tJpoly:= factor(add(k, k in Jpoly)); \n\treturn (Jpoly); \nend proc:\n\nVAP_I:= proc(spart, i, N)\n\tlocal spart_sector, M_i, pts, phis, thetas, zeds, Rspart, ellComp, deltaNell, term1, term2, term3, j,m,thesign;\n\tspart_sector:= giveSpartSector(spart);\n\tspart_sector:= [spart_sector[4], spart_sector[2], spart_sector[3]];\n\tM_i:= [0,spart_sector[1],spart_sector[1] + spart_sector[2],spart_sector[1] + spart_sector[2]+ spart_sector[3]];\n\tpts:= spart[1];\n\tphis:= spart[2];\n\tthetas:= spart[3];\n\tzeds:= spart[4]; \n\tRspart:= [op(Reverse(pts)),op(Reverse(phis)), op(Reverse(thetas)), op(Reverse(zeds))];\n\tellComp:= nops(Rspart);\n\tdeltaNell:= N-ellComp;\n\tif deltaNell<>0 then Rspart:= [op(Rspart), seq(0, k=1..deltaNell)]; end if;\n\tprint(Rspart, \"rspart\");\n\tellComp:= N;\n\tterm1:= factorial(N- (spart_sector[1] + spart_sector[2] + spart_sector[3]));\n\tprint(term1, \"globalpref\"); \n\tterm2:= factorial( spart_sector[1]) * factorial(spart_sector[2]) * factorial(spart_sector[3]);\n\tterm2:= term2/factorial(spart_sector[i]);\n\tprint(term2, \"specificpref\"); \n\tterm3:= \n\t\tadd( factorial(M_i[i+1]-j)*( (M_i[i+1]-j)*lambdabar_i(Rspart,j, ellComp) - beta), j=(M_i[i]+1)..(M_i[i+1]-1)) \n\t\t+ lambdabar_i(Rspart, M_i[i+1], ellComp);\n\tfor j from M_i[i]+1 to M_i[i+1] - 1 do\n\t\tprint(\"itt\",j,\"pref\", factorial(M_i[i+1]-j));\n\t\tprint(\"lambdabar\", lambdabar_i(Rspart, j, ellComp)); \n\t\tprint(\"addedterm\",factorial(M_i[i+1]-j)*( (M_i[i+1]-j)*lambdabar_i(Rspart,j, ellComp) - beta)) ;\n\t\tprint((M_i[i+1]-j), hey);\n\tend do;\n\tprint(M_i);\n\tprint(lambdabar_i(Rspart, M_i[i+1], ellComp)); \n\treturn term1*term2*term3;\nend proc:\n\n\n\nEigenCMSn:= proc(spart,n, hn:=0, IorNot:=NULL, minN:=NULL)\n    local DomMonomial, OpDomMonomial, I_1_1EigVal, I_2_1EigVal, H_2EigVal, EigenValues;\n    # The function that returns the Eigen value for a given monomial. The code is probably broken.\n    if minN <> NULL then DomMonomial:= m2n(spart, minN); else DomMonomial:= m2n(spart)  end if;\n\n    I_1_1EigVal:=0;\n    I_2_1EigVal:=0: \n    H_2EigVal:= 0;\n\n    OpDomMonomial:= I_k_n(1,n, DomMonomial, 2);\n    if OpDomMonomial <> 0 then \n        I_1_1EigVal:=  coeff(OpDomMonomial, m[op(spart)]);\n    end if;\n\n    OpDomMonomial:= I_k_n(6,n, DomMonomial, 2);\n    if OpDomMonomial <> 0 then \n        I_2_1EigVal:= coeff(OpDomMonomial, m[op(spart)]);   \n    end if;\n\n    OpDomMonomial:= H_n(n+hn, DomMonomial);\n    if OpDomMonomial <> 0 then \n        H_2EigVal:= coeff(OpDomMonomial, m[op(spart)]);\n    end if;\n    if IorNot=NULL then\n        EigenValues:= [I_1_1EigVal, I_2_1EigVal, H_2EigVal]; \n    else\n        #EigenValues:= [I_1_1EigVal+I_2_1EigVal,I_1_1EigVal-I_2_1EigVal, H_2EigVal]; \n        EigenValues:= [I_1_1EigVal,I_2_1EigVal, H_2EigVal]; \n    end if;\n    return EigenValues;\nend proc:\n", "meta": {"hexsha": "6a36b6da44e7ee3baac519bc9a56403b1f64abfa", "size": 9167, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/CMS.mpl", "max_stars_repo_name": "LAV42/N2-Superpolynomials", "max_stars_repo_head_hexsha": "237274e69b04d206f96d2c15f0f066a3677e47e0", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/CMS.mpl", "max_issues_repo_name": "LAV42/N2-Superpolynomials", "max_issues_repo_head_hexsha": "237274e69b04d206f96d2c15f0f066a3677e47e0", "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": "lib/CMS.mpl", "max_forks_repo_name": "LAV42/N2-Superpolynomials", "max_forks_repo_head_hexsha": "237274e69b04d206f96d2c15f0f066a3677e47e0", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.122605364, "max_line_length": 112, "alphanum_fraction": 0.6511399585, "num_tokens": 3452, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.749087201911703, "lm_q2_score": 0.6442251201477016, "lm_q1q2_score": 0.48258079265267245}}
{"text": "######################################################################\n\n# Real numbers mod integers\n\n`is_element/RZ` := (x) -> type(x,realcons):\n\n`is_equal/RZ` := (x,y) -> type(simplify(y-x),integer):\n\n`is_leq/RZ` := NULL:\n\n`normalize/RZ` := (x) -> simplify(x - floor(x)):\n\n`random_element/RZ` := proc() rand(0..719)()/(720); end:\n\n`list_elements/RZ` := NULL;\n`count_elements/RZ` := NULL;\n\n`d/RZ` := (x,y) -> abs(x - y - round(x - y));\n\n`eta/RZ` := (x) -> exp(2*Pi*I*x);\n\n`is_cyclic/RZ` := proc(x::list)\n local n,y,z,i;\n n := nops(x);\n if n <= 2 then return true; fi;\n y := simplify(x -~ x[1]);\n y := simplify(y -~ map(floor,y));\n z := [seq(y[i+1] - y[i],i=1..n-1)];\n return evalb(simplify(min(op(z))) >= 0);\nend:\n\n`is_strictly_cyclic/RZ` := proc(x::list)\n local n,y,z,i;\n n := nops(x);\n if n <= 2 then return true; fi;\n y := simplify(x -~ x[1]);\n y := simplify(y -~ map(floor,y));\n z := [seq(y[i+1] - y[i],i=1..n-1)];\n return evalb(simplify(min(op(z))) >= 0);\nend:\n\n", "meta": {"hexsha": "34d698144bb62f03bdfc02fb50df52f5883fb595", "size": 967, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/RZ.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/RZ.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/RZ.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.0238095238, "max_line_length": 70, "alphanum_fraction": 0.5056876939, "num_tokens": 338, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7431680086124811, "lm_q2_score": 0.647798211152541, "lm_q1q2_score": 0.48142290656496145}}
{"text": "# A maple code for the dual Leipniz-Hopf(LH) algebra\n# Description: This code includes functions to compute\n# the orverlapping product and the conjugation in the dual\n# Leipniz-Hopf algebra\n# Author: S. Kaji (Yamaguchi University, Japan)\n# Version history: initial version -- 2 Feb. 2014.\n#                  current version -- 2 Jan. 2015.\n# Global variables:\n# T[]: basis for LH-algebra\n# S[]: basis for dual LH-algebra\n# P[]: Cartan-Serre basis for Steenrod algebra\n# Q[]: Cartan-Serre basis for dual Steenrod algebra\n# x[]: Milnor basis for dual Steenrod algebra\n\nwith(LinearAlgebra[Modular]);\n\n## the dual Leibniz-Hopf algebra\n# overlapping shuffle product\nos := proc (f::polynom) local ff, L, t; global p;\n    ff := expand(f) mod p;\n    if degree(ff) < 2 then\n        return ff\n    elif op(0, ff) = `+` then\n        return expand(map(os, ff)) mod p\n    elif op(0, ff) = `*` then\n        if type(op(1, ff), 'numeric') then\n            return op(1, ff)*os(ff/op(1, ff)) mod p;\n        elif nops(ff) = 2 and type(op(1, ff), 'indexed') and type(op(2, ff), 'indexed') then\n            L := osw(op(1, op(1, ff)), op(1, op(2, ff)));\n            return `mod`(add(S[l], l in L), p)\n        else\n            return `mod`(expand(os(os(op(1, ff))*os(mul(op(i, ff), i = 2 .. nops(ff))))), p)\n        end if;\n    elif op(0, ff) = `^` and type(op(1, ff), 'indexed') then\n        t := floor(log[p](op(2, ff)));\n        if 0 < t then\n            return `mod`(os(S[p^t*op(1, op(1, ff))]*op(1, ff)^(op(2, ff)-p^t)), p)\n        else L := osw(op(1, op(1, ff)), op(1, op(1, ff)));\n            return os(add(S[l], l in L)*op(1, ff)^(op(2, ff)-2))\n        end if;\n    else\n        print(ff, op(0, ff), \"Error: no rule to compute the product\")\n    end if;\nend proc;\n\n#overlapping shuffle of two words\nosw := proc (v::list, w::list) local L, i; option remember;\n    if nops(w) = 0 then\n        return [v]\n    end if;\n    if nops(v) = 0 then\n        return [w]\n    end if;\n    L := [seq([w[1], op(x)], x in osw(v, w[2 .. -1]))];\n    for i to nops(v) do\n        L := [op(L), seq([op(v[1 .. i]), w[1], op(x)], x in osw(v[i+1 .. -1], w[2 .. -1]))];\n        L := [op(L), seq([op(v[1 .. i-1]), v[i]+w[1], op(x)], x in osw(v[i+1 .. -1], w[2 .. -1]))]\n    end do;\n    return L;\nend proc;\n\n# pi image of milnor's dual basis\nxi := proc (n) local i, x; global p;\n    if type(n, 'integer') then\n        if n = 0 then\n            return 1\n        else\n            return S[[seq(p^(n-i), i = 1 .. n)]]\n        end if\n    elif type(n, 'list') then\n        x := 1;\n        for i to nops(n) do\n            x := x*xi(i)^n[i]\n        end do;\n        return x\n    else print(\"Error: xi\")\n    end if\nend proc;\n\n# convert a polynomial in x to one in S\nx2xi := proc(f::polynom) local s,ind;\n    ind := [];\n    for s in indets(f) do\n        if op(0,s)=`x` and type(s,'indexed') then\n            ind := [op(ind),op(1,s)]\n        end if;\n    end do;\n    return eval(f,[seq(x[i]=xi(i),i=ind)]);\nend proc:\n\n# conjugation for dual LH-algebra\nchi := proc (f::polynom) global p;\n    if degree(f) < 1 then\n        return f\n    elif type(f, 'indexed') then\n        return add((-1)^nops(op(1, f))*S[x], x in coarsening(ListTools[Reverse](op(1, f))))\n    elif op(0, f) = `+` then\n        return `mod`(map(chi, f), p)\n    elif op(0, f) = `*` then\n        if type(op(1, f), 'numeric') then\n            return `mod`(op(1, f)*chi(f/op(1, f)), p)\n        else\n            return `mod`(chi(op(1, f))*chi(mul(op(i, f), i = 2 .. nops(f))), p)\n        end if\n    elif op(0, f) = `^` then\n        return `mod`(chi(op(1, f))^op(2, f), p)\n    else\n        print(\"cannot compute chi:\", f, op(0, f))\n    end if\nend proc;\n\n# conjugation for LH-algebra\nchi2 := proc (f::polynom) global p;\n    if degree(f) < 1 then\n        return f\n    elif type(f, 'indexed') then\n        return add((-1)^nops(op(1, f))*T[x], x in refinement(ListTools[Reverse](op(1, f))))\n    elif op(0, f) = `+` then\n        return `mod`(map(chi2, f), p)\n    elif op(0, f) = `*` then\n        if type(op(1, f), 'numeric') then\n            return `mod`(op(1, f)*chi2(f/op(1, f)), p)\n        else\n            return `mod`(chi2(op(1, f))*chi2(mul(op(i, f), i = 2 .. nops(f))), p)\n        end if\n    elif op(0, f) = `^` then\n        return `mod`(chi2(op(1, f))^op(2, f), p)\n    else\n        print(\"cannot compute chi2:\", f, op(0, f))\n    end if\nend proc;\n\n# retraction onto the dual steenrod algebra (taking admissble terms)\nretract := proc (f::polynom) local ff, i, w; global p;\n    ff := expand(f);\n    if 1 < degree(ff) then\n        print(ff, \"input must be linear\")\n    elif op(0, ff) = `+` then\n        return map(retract, ff)\n    elif type(ff, 'indexed') then\n        if op(0,ff) != `S` then return ff; end if;\n        w := op(1, ff);\n        for i to nops(w)-1 do\n            if w[i] < p*w[i+1] then\n                return 0\n            end if\n        end do;\n        return Q[w]\n    elif op(0, ff) = `*` and type(op(1, ff), 'numeric') then\n        return `mod`(op(1, ff)*retract(ff/op(1, ff)), p)\n    else\n        print(\"cannot compute retract:\",ff, op(0, ff));\n        return 0\n    end if\nend proc;\n\n# projection onto the steenrod algebra (applying Adem relations)\nprojection := proc (f::polynom) local ff, i, w, t, j; global p;\n    ff := expand(f) mod p;\n    if 1 < degree(ff) then\n        print(ff, \"input must be linear\")\n    elif type(ff,'numeric') then\n        return ff;\n    elif op(0, ff) = `+` then\n        return map(procname, ff) mod p\n    elif type(ff, 'indexed') then\n        if op(0,ff) != `T` and op(0,ff) != `P` then return ff; end if;\n        w := op(1, ff);\n        for i to nops(w)-1 do\n            if w[i] < p*w[i+1] then\n                t := ((-1)^(w[i]))*binomial((p-1)*w[i+1]-1,w[i])\n                      *P[[op(w[1..i-1]),w[i]+w[i+1],op(w[i+2..-1])]];\n                for j to floor(w[i]/p) do\n                    t:=t + ((-1)^(w[i]+j))*binomial((p-1)*(w[i+1]-j)-1,w[i]-p*j)\n                      *P[[op(w[1..i-1]),w[i]+w[i+1]-j,j,op(w[i+2..-1])]];\n                end do;\n                return procname(t mod p);\n            end if\n        end do;\n        return P[w]\n    elif op(0, ff) = `*` and type(op(1, ff), 'numeric') then\n        return `mod`(op(1, ff)*procname(ff/op(1, ff)), p)\n    else\n        print(\"cannot compute projection:\",ff, op(0, ff));\n        return 0\n    end if\nend proc;\n\n## Combinatorics on words\n# ordered partition of an integer\nordpart := proc (n::integer) local L, V; option remember;\n    if n = 0 then\n        return []\n    elif n = 1 then\n        return [[1]]\n    end if;\n    L := ordpart(n-1);\n    V[1] := [seq([1, op(v)], v in L)];\n    V[2] := [seq([v[1]+1, op(v[2 .. -1])], v in L)];\n    return [op(V[1]), op(V[2])]\nend proc;\n# ordered partition of a list\nordpartlist := proc (L::list) local V, u, i, w, pos;\n    V := [];\n    for u in ordpart(nops(L)) do\n        w := [];\n        pos := 1;\n        for i in u do\n            w := [op(w), L[pos .. pos+i-1]];\n            pos := pos+i\n        end do;\n        V := [op(V), w]\n    end do;\n    return V\nend proc;\n\n# coarsening of a word\ncoarsening := proc (w::list) local L, p, i, l, v; option remember;\n    L := [];\n    for p in ordpart(nops(w)) do\n        v := [];\n        l := 1;\n        for i to nops(p) do\n            v := [op(v), add(w[j], j = l .. l+p[i]-1)];\n            l := l+p[i]\n        end do;\n        L := [op(L), v]\n    end do;\n    return L\nend proc;\n\n# refinement of a word\nrefinement := proc (w::list) local L, l, v, U; option remember;\n    if nops(w)=1 then\n        return ordpart(w[1]);\n    else\n        U := [];\n        L := refinement(w[2..-1]);\n        for v in ordpart(w[1]) do\n            for l in L do\n                U := [op(U), [op(v),op(l)]];\n            end do;\n        end do;\n        return U;\n    end if;\nend proc:\n\n# list monomials of degree \"totaldeg\" consisting of \"gens\",\n# whose degrees are specified by \"degs\"\nlist_monom := proc (gens::list, degs::(list(integer)), totaldeg::integer) local v, L, V;\n    L := wpartition(degs, totaldeg);\n    V := [];\n    for v in L do\n        V := [op(V), mul(gens[i]^v[i], i = 1 .. nops(v))]\n    end do;\n    return V\nend proc;\n\n# weighted partition; express \"totaldeg\" as linear combinations of \"degs\"\nwpartition := proc (degs::(list(integer)), totaldeg::integer) local i, L, V;\n    L := [];\n    if totaldeg = 0 then\n        return [[seq(0, i = 1 .. nops(degs))]]\n    elif nops(degs) = 0 then\n        return []\n    elif nops(degs) = 1 then\n        if `mod`(totaldeg, degs[1]) = 0 then\n            return [[totaldeg/degs[1]]]\n        else\n            return []\n        end if\n    end if;\n    for i from floor(totaldeg/degs[-1]) by -1 to 0 do\n        V := wpartition(degs[1 .. -2], totaldeg-i*degs[-1]);\n        L := [op(L), seq([op(v), i], v in V)]\n    end do;\n    return L\nend proc;\n\n## Enumerating basis and the conjugation invariants\n# enumerate admissible sequences with lex order\nadmseq := proc (totaldeg::integer) local n, L; global p;\n    n := floor(log[p]((p-1)*totaldeg+1));\n    L := wpartition([seq((p^i-1)/(p-1), i = 1 .. n)], totaldeg);\n    return map(ex2adm, L)\nend proc;\n\n# convert excess representation to admissible sequence\nex2adm := proc (ex::list) local n; global p;\n    n := nops(ex);\n    while ex[n] = 0 do\n        n := n-1\n    end do;\n    return [seq(add(p^(i-j)*ex[i], i = j .. nops(ex)), j = 1 .. n)]\nend proc;\n\n# enumerate pi image of milnor monomials of degree \"deg\"\nmilnor_images := proc (deg::integer) local L, V, i, s, n; global p;\n    V := [];\n    n := floor(log[p]((p-1)*deg+1));\n    L := list_monom([seq(x[i], i = 1 .. n)], [seq((p^i-1)/(p-1), i = 1 .. n)], deg);\n    for s in L do\n        V := [op(V), s = os(eval(s, [seq(x[i] = xi(i), i = 1 .. n)]))]\n    end do;\n    return V\nend proc;\n\n# polynomial associated to a list\npp := proc (L::list) local x, w;\n    x := 0;\n    for w in L do\n        x := x+mul(S[u], u in w)\n    end do;\n    return x\nend proc;\n\n# linear equation solver\n# Solves equations L in terms of indeterminants A\nsol := proc (L::list, A::list) local X, V, i, j, v, n, Y,Z, rp, d, R, U, r; global p;\n    n := nops(L);\n    X := Matrix(n, n+nops(A));\n    for i to n do\n        X[i, nops(A)+i] := 1;\n        for j to nops(A) do\n            X[i, j] := coeff(op(2, L[i]), A[j])\n        end do\n    end do;\n    X := Mod(p, X, integer[]);\n    U := Mod(p, X, integer[]);\n    Y, rp, d := RowEchelonTransform(p, U, true, true, false, false);\n    r := nops(rp); U := U[1 .. n, 1 .. n];\n    Z := LinearAlgebra[IdentityMatrix](n, compact = false);\n    for i to LinearAlgebra[Dimension](Y) do\n        LinearAlgebra[RowOperation](Z, [i, Y[i]], inplace = true)\n    end do;\n    Z := Mod(p, Z, integer[]);\n    X := Multiply(p, Z, X);\n    X := Multiply(p, U, X);\n    V := [];\n    for v in convert(X, listlist) do\n        V := [op(V), add(v[i]*A[i], i = 1 .. nops(A)) = add(v[nops(A)+i]*op(1, L[i]), i = 1 .. nops(L))]\n    end do;\n    return V\nend proc;\n\n# compute conjugation invariants in degree \"deg\" in the dual Steenrod algebra\nconjinvQ := proc (deg::integer) local L, V, U, v, w; global p;\n    L := milnor_images(deg);\n    V := [];\n    for v in L do\n        V := [op(V), op(1, v) = `mod`(chi(op(2, v))-op(2, v), p)]\n    end do;\n    U := [];\n    for v in sol(V, [seq(S[w], w=admseq(deg))]) do\n        if op(1,v)=0 then\n            U:=[op(U), [op(2, v),retract(os(x2xi(op(2,v))))]];\n        end if;\n    end do:\n    return U;\nend proc;\n# compute conjugation invariants in degree \"deg\" in the dual LH algebra\nconjinvS := proc (deg::integer) local L, V, U, v, w; global p;\n    L := ordpart(deg);\n    V := [];\n    for v in L do\n        V := [op(V), S[v] = `mod`(chi(S[v])-S[v], p)]\n    end do;\n    U:=[];\n    for v in sol(V, [seq(S[w], w=L)]) do\n        if op(1, v) = 0 then\n            U:=[op(U),srt(op(2, v))]\n        end if;\n    end do;\n    return U\nend proc;\n# compute conjugation invariants in degree \"deg\" in the LH algebra\nconjinvT := proc (deg::integer) local L, V, U, v, w; global p;\n    L := ordpart(deg);\n    V := [];\n    for v in L do\n        V := [op(V), T[v] = `mod`(chi2(T[v])-T[v], p)]\n    end do;\n    U:=[];\n    for v in sol(V, [seq(T[w], w=L)]) do\n        if op(1, v) = 0 then\n            U:=[op(U),srt(op(2, v))]\n        end if;\n    end do;\n    return U\nend proc;\n# compute conjugation invariants in degree \"deg\" in the Steenrod algebra\nconjinvP := proc (deg::integer) local L, V, U, v; global p;\n    L := admseq(deg);\n    V := [];\n    for v in L do\n        V := [op(V), P[v] = projection(chi2(T[v]) - T[v]) mod p]\n    end do;\n    U:=[];\n    for v in sol(V, [seq(P[w],w=L)]) do\n        if op(1, v) = 0 then\n            U:=[op(U),srt(op(2, v))]\n        end if;\n    end do;\n    return U\nend proc;\n\n# sort terms in reverse lex order\nsrt := proc (f::polynom) local L;\n    if degree(f) <> 1 then\n        print(\"degree must be one\", f);\n        return f\n    end if;\n    L := sort([seq(ListTools[Reverse](op(1, s)), s in indets(f))]);\n    L := [seq(S[ListTools[Reverse](l)], l in L)];\n    return\n    sort(f, L)\nend proc;\n\n# duality between S_I and T^J\n# Note that S_J is conjugation invariant <=> So is T^K in non-dual LH-algebra\ndual := proc (f::{polynom,list}) local J,K,k,Sym;\n    if op(0, f) = `+` or type(f,'list') then\n        return map(dual, f);\n    elif op(0, f) = `*` then\n        if type(op(1, f), 'numeric') then\n            return op(1, f)*dual(f/op(1, f));\n        else\n            print(\"cannot compute dual :\",f);\n        end if;\n    elif type(f, 'indexed') then\n        if op(0,f)=`S` then\n            Sym := T;\n        else\n            Sym := S;\n        end if;\n        k := 0;\n        J := op(1,f);\n        K := [];\n        while nops(J)>0 do\n            k := k+1;\n            if J[1]=1 then\n                J := J[2..-1];\n                if nops(J)=0 then\n                    K := [op(K),k];\n                end if;\n            else\n                J[1] := J[1]-1;\n                K := [op(K),k];\n                k := 0;\n            end if;\n        end do;\n        return Sym[K];\n    else\n            print(\"cannot compute dual:\",f);\n    end if;\nend proc:\n", "meta": {"hexsha": "69a7552abc1b6dd59416fe68337b1c7ba5b4655a", "size": 13989, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "Leibniz-Hopf.mpl", "max_stars_repo_name": "shizuo-kaji/Leibniz-Hopf-algebra", "max_stars_repo_head_hexsha": "66db02f1019fac30cf4ca695d09a2c5deb0680b1", "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": "Leibniz-Hopf.mpl", "max_issues_repo_name": "shizuo-kaji/Leibniz-Hopf-algebra", "max_issues_repo_head_hexsha": "66db02f1019fac30cf4ca695d09a2c5deb0680b1", "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": "Leibniz-Hopf.mpl", "max_forks_repo_name": "shizuo-kaji/Leibniz-Hopf-algebra", "max_forks_repo_head_hexsha": "66db02f1019fac30cf4ca695d09a2c5deb0680b1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.6105032823, "max_line_length": 104, "alphanum_fraction": 0.4967474444, "num_tokens": 4783, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8438951143326726, "lm_q2_score": 0.5698526514141571, "lm_q1q2_score": 0.48089586841792675}}
{"text": "(*\n Copyright (C) 2020 Susi Lehtola\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: mgga_exc *)\n(* prefix:\n  mgga_k_csk_loc_params *params;\n\n  assert(p->params != NULL);\n  params = (mgga_k_csk_loc_params * )(p->params);\n*)\n\n$include \"mgga_k_csk.mpl\"\n\n(* Equation (21) *)\ncsk_z  := (p, q) -> 1 + params_a_csk_cp*p + params_a_csk_cq*q - (1 + 5*p/3):", "meta": {"hexsha": "959a41e0a2bf37d7d60e52a90482204863875221", "size": 509, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "libxc-5.1.6/maple/mgga_exc/mgga_k_csk_loc.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/mgga_exc/mgga_k_csk_loc.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/mgga_exc/mgga_k_csk_loc.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": 25.45, "max_line_length": 76, "alphanum_fraction": 0.6679764244, "num_tokens": 170, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461390043208003, "lm_q2_score": 0.6442250928250375, "lm_q1q2_score": 0.4806814693189486}}
{"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 subdiagram\n# G(i,i) -> G(i,j) <- G(j,j) is of the form G -> G/a <- G//a.\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 := (i,j,k,l,m) -> WW(k,l,m) * W0V(j)^(2^(k+m-j)) / W0V(i)^(2^(l-i)):\n\n# G(j,k) to G(i,l)\nf := proc(i,j,k,l)\n local x;\n return unapply(sort(collect(expand(add(WWW(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..20)}:\n\nVv_rule := {seq(\n V[i] = v[i] * mul(v[j]^(2^(i-j-1)),j=0..i-1),\n i=0..20)};\n\ncheck_id := proc(i::nonnegint,k::nonnegint)\n local x;\n\n if not (i <= k) then return FAIL; fi;\n \n _ASSERT(f(i,i,k,k)(x) = x,\"identity maps\",[i,k]);\n \nend:\n\ncheck_compose := proc(h::nonnegint,i::nonnegint,j::nonnegint,\n                      k::nonnegint,l::nonnegint,m::nonnegint)\n local x,err;\n\n if not(h <= i and i <= j and j <= k and k <= l and l <= m) then\n  return FAIL;\n fi;\n\n err := modp(expand(f(h,i,l,m)(f(i,j,k,l)(x)) - f(h,j,k,m)(x)),2);\n\n _ASSERT(err = 0,\"maps compose correctly\",[h,i,j,k,l]);\nend: \n\ncheck_linear := proc(i::nonnegint,j::nonnegint,k::nonnegint)\n local x,y,err;\n\n if not(i <= j and j <= k) then\n  return FAIL;\n fi;\n\n y := f(i,j,k,k)(x);\n err := expand(y - coeff(y,x,1) * x);\n\n _ASSERT(err = 0,\"horizontal map is linear\",[i,j,k]);\nend:\n\ncheck_short_isogeny := proc(i::nonnegint,k::nonnegint,l::nonnegint)\n local x,y,err;\n\n if not(i <= k and k <= l) then\n  return FAIL;\n fi;\n\n y := f(i,i,k,l)(x);\n \n _ASSERT(degree(y,x) = 2^(l-k) and coeff(y,x,2^(l-k)) = 1,\n         \"vertical map is a short isogeny\",[i,k,l]);\nend:\n\ncheck_dilation := proc(i::nonnegint,p::nonnegint)\n local x,y,z,err;\n\n y := f(i,i,i,i+p)(x);\n z := f(i,i+p,i+p,i+p)(x);\n _ASSERT(expand(coeff(y,x,1) - coeff(z,x,1)) = 0,\"dilation condition\",[i,j,k]);\nend:\n\ncheck_vV_rules := proc(n)\n _ASSERT(\n  `and`(seq(evalb(subs(vV_rule,subs(Vv_rule,V[i])) = V[i]),i=0..n)) and\n  `and`(seq(evalb(subs(Vv_rule,subs(vV_rule,v[i])) = v[i]),i=0..n)),\n  \"rules for converting v[i] to V[i] and vice versa\"\n );\n \nend:\n\n", "meta": {"hexsha": "639b715d10e43701458ba114ec133b79d535f8b7", "size": 2499, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/steenrod/singer_system.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/singer_system.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/singer_system.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": 25.7628865979, "max_line_length": 83, "alphanum_fraction": 0.5758303321, "num_tokens": 934, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789086703225, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.4803437791361251}}
{"text": "######################################################################\n\n`is_element/WK` := (A::set) -> proc(TTxl)\n local TT,x,l,TT1,T,n,u,children;\n global reason;\n\n if not(type(TTxl,list) and nops(TTxl) = 3) then\n  reason := [convert(procname,string),\"TTxl cannot be split as [TT,x,l]\",TTxl];\n  return false;\n fi;\n\n TT,x,l := op(TTxl);\n\n if not(`is_element/trees`(A)(TT)) then\n  reason := [convert(procname,string),\"TT is not a tree on A\",TT,A];\n  return false;\n fi;\n\n TT1 := select(U -> nops(U) > 1,TT);\n\n if not(type(x,table)) then\n  reason := [convert(procname,string),\"x is not a table\",x];\n  return false;\n fi;\n\n if map(op,{indices(x)}) <> TT1 then\n  reason := [convert(procname,string),\"x is not indexed by TT1\",x,TT1];\n  return false;\n fi;\n\n children := `children_map`(A)(TT);\n for T in TT1 do\n  if not(`is_element/stasheff_star`(children[T])(x[T])) then\n   reason := [convert(procname,string),\"x[T] has invalid type\",T,x[T],reason];\n   return false;\n  fi;\n od;\n\n if not(type(l,table)) then\n  reason := [convert(procname,string),\"l is not a table\",l];\n  return false;\n fi;\n\n if map(op,{indices(l)}) <> TT then\n  reason := [convert(procname,string),\"l is not indexed by TT\",l,TT];\n  return false;\n fi;\n\n n := nops(A);\n\n for T in TT do\n  if not(`is_element/RR`(l[T]) and l[T] >= 0 and l[T] <= 1) then\n   reason := [convert(procname,string),\"l[T] is not in the unit interval\",T,l[T]];\n   return false;\n  fi;\n\n  if nops(T) = 1 and l[T] <> 1 then\n   reason := [convert(procname,string),\"l[{a}] <> 1\",op(T),l[T]];\n   return false;\n  fi;\n\n  if nops(T) = n and l[T] <> 1 then\n   reason := [convert(procname,string),\"l[A] <> 1\",T,l[T]];\n   return false;\n  fi;\n od;\n\n return true;\nend;\n\n######################################################################\n\n`is_interior/WK` := (A::set) -> proc(TTxl)\n local TT,x,l,n,T;\n global reason;\n\n TT,x,l := op(TTxl);\n n := nops(A);\n\n for T in TT do\n  if nops(T) > 1 and nops(T) < n and l[T] = 1 then\n   reason := [convert(procname,string),\"not interior, l[T] = 1\",T];\n   return false;\n  fi;\n od:\n\n return true;\nend;\n\n######################################################################\n\n`is_reduced/WK` := (A::set) -> proc(TTxl)\n local TT,x,l,T;\n global reason;\n\n TT,x,l := op(TTxl);\n\n for T in TT do\n  if l[T] = 0 then\n   reason := [convert(procname,string),\"not reduced, l[T] = 0\",T];\n   return false;\n  fi;\n od:\n\n return true;\nend;\n\n######################################################################\n\n`reduce_once/WK` := (A::set) -> proc(TTxl,T)\n local TT,x,l,parent,children,n,TT1,x1,l1,U,B,C,X,p,y,z;\n\n TT,x,l := op(TTxl);\n\n parent := `parent_map`(A)(TT);\n children := `children_map`(A)(TT);\n\n TT1 := TT minus {T};\n\n U := parent[T];\n C := children[U];\n B := C minus {T} union children[T];\n\n p := table();\n for X in C minus {T} do p[X] := X; od;\n for X in children[T] do p[X] := T; od;\n\n y := table();\n for X in C minus {T} do y[X] := `eta/stasheff_star`({X}); od;\n y[T] := x[T];\n\n z := `gamma/stasheff_star`(B,C)(p)(x[U],y);\n\n x1 := table();\n l1 := table();\n\n for X in TT1 do\n  l1[X] := l[X];\n  if nops(X) > 1 then\n   x1[X] := `if`(X = U,eval(z),eval(x[X]));\n  fi;\n od;\n\n return([TT1,eval(x1),eval(l1)]);\nend;\n\n`reduce/WK` := (A::set) -> proc(TTxl)\n local is_reduced,X,TT,x,l,T;\n\n is_reduced := false;\n X := TTxl;\n\n while not(is_reduced) do\n  TT,x,l := op(X);\n  is_reduced := true;\n\n  for T in TT do\n   if l[T] = 0 then \n    is_reduced := false;\n    X := `reduce_once/WK`(A)(X,T);\n    break;\n   fi;\n  od:\n od;\n\n return X;\nend;\n\n######################################################################\n\n`is_equal/WK` := (A::set) -> proc(X0,X1)\n local Y0,Y1,TT0,TT1,x0,x1,l0,l1,children,T;\n global reason;\n\n Y0 := `reduce/WK`(A)(X0);\n Y1 := `reduce/WK`(A)(X1);\n TT0,x0,l0 := op(Y0);\n TT1,x1,l1 := op(Y1);\n\n if TT0 <> TT1 then\n  reason := [convert(procname,string),\"TT0 <> TT1\",TT0,TT1];\n  return false;\n fi;\n\n children := `children_map`(A)(TT0);\n\n for T in TT0 do\n  if l0[T] <> l1[T] then\n   reason := [convert(procname,string),\"l0[T] <> l1[T]\",T,l0[T],l1[T]];\n   return false;\n  fi;\n\n  if nops(T) > 1 then\n   if not(`is_equal/stasheff_star`(children[T])(x0[T],x1[T])) then\n    reason := [convert(procname,string),\"x0[T] <> x1[T]\",T,x0[T],x1[T],reason];\n    return false;\n   fi;\n  fi;\n od;\n\n return true;\nend;\n\n######################################################################\n\n`is_leq/WK` := NULL;\n\n######################################################################\n\n`random_element/WK` := (A::set) -> proc()\n local TT,x,l,TT1,T,n,children,d;\n\n d := 3;\n TT := `random_element/full_trees`(A)();\n\n TT1 := select(U -> nops(U) > 1,TT);\n\n x := table();\n l := table();\n\n children := `children_map`(A)(TT);\n for T in TT1 do\n  x[T] := `random_element/stasheff_star`(children[T])();\n od;\n\n n := nops(A);\n\n for T in TT do\n  if nops(T) = 1 or nops(T) = n then \n   l[T] := 1;\n  else \n   l[T] := rand(0..d)()/d;\n  fi;\n od;\n\n return [TT,eval(x),eval(l)];\nend;\n\n`list_elements/WK` := NULL;\n`count_elements/WK` := NULL;\n\n######################################################################\n\n`eta/WK` := proc(A::set) \n if nops(A) <> 1 then return FAIL; fi;\n return [[op(A)],table([])];\nend;\n\n`gamma/WK` := (A::set,B::set) -> (p) -> proc(M,N)\n local F,TT,SS,UU,x,y,z,l,m,n,pi,T,T1,C,C1,U,b,L,children;\n\n F := fibres(A,B)(p);\n\n TT,x,l := op(M);\n children := children_map(B)(TT);\n pi := table();\n for T in TT do\n  pi[T] := map(op,map(b -> F[b],T));\n od;\n \n SS := table();\n y := table();\n m := table();\n\n for b in B do \n  SS[b],y[b],m[b] := op(N[b]);\n od;\n\n UU := {seq(op(SS[b]),b in B)};\n z := table();\n n := table();\n\n for T in TT do\n  T1 := pi[T];\n  if nops(T1) > 0 then\n   UU := {op(UU),T1};\n   n[T1] := l[T];\n   if nops(T) = 1 then\n    if nops(T1) > 1 then\n     z[T1] := eval(y[op(T)][T1]);\n    fi;\n   else\n    C := children[T];\n    C1 := map(U -> pi[U],C);\n    z[T1] :=  `act/stasheff_star`(C,C1)(pi)(x[T]);\n   fi;\n  fi;\n od;\n\n for b in B do \n  for U in SS[b] do\n   n[U] := m[b][U];\n   if nops(U) > 1 then  \n    z[U] := y[b][U];\n   fi;\n  od;\n od;\n\n L := [UU,eval(z),eval(n)];\n L := `reduce/WK`(A)(L);\n return L;\nend;\n\n######################################################################\n\n`phi/WK/K` := (A::set) -> proc(TTxl)\n local SS,TT,x,l,TT1,s,t,u,RR,R,T,f,parent,children,J,J1,JJ,i,j,k,n,m;\n\n TT,x,l := op(TTxl);\n\n TT1 := select(U -> nops(U) > 1,TT);\n parent := `parent_map`(A)(TT);\n children := `children_map`(A)(TT);\n\n s := table():\n RR := table():\n\n for T in TT1 do\n  RR[T],s[T] := op(x[T]);\n od:\n\n R := `phi/WK/K/aux`(A,RR);\n u := table():\n n := nops(A);\n JJ := {seq(seq({seq(R[k],k=i..j)},j=i..n),i=1..n)};\n\n for J in JJ do\n  if member(J,TT) then\n   u[J] := (1+l[J])/2;\n  else\n   SS := select(T -> (J minus T = {}),TT);\n   m := min(op(map(nops,SS)));\n   T := select(T -> (nops(T) = m),SS)[1];\n   J1 := select(U -> (U intersect J <> {}),children[T]);\n   if {op(map(op,J1))} = J then\n    u[J] := s[T][J1]/2;\n   else\n    u[J] := 0;\n   fi;   \n  fi;\n od;\n\n return [R,eval(u)];\nend;\n\n########################################\n\n`phi/WK/K/aux` := proc(T,UU)\n  if nops(T) = 1 then\n   return [op(T)];\n  else\n   map(op,map(U -> `phi/WK/K/aux`(U,UU),UU[T]));\n  fi;\n end;\n\n######################################################################\n\n`theta/K/WK` := (A::set) -> proc(Rt)\n local R,t,r,T,TT,RR,s,l,x,C,m,J,J1,i,j,k,children;\n\n R,t := op(Rt);\n\n r := table();\n for i from 1 to nops(R) do\n  r[R[i]] := i;\n od;\n \n TT := select(J -> t[J] > 1/2,map(op,{indices(t)}));\n RR := table():\n s := table():\n l := table():\n x := table():\n\n children := `children_map`(A)(TT);\n for T in TT do\n  l[T] := 2*t[T] - 1;\n  C := [op(children[T])];\n  C := sort(C,(U0,U1) -> (r[U0[1]] < r[U1[1]]));\n  RR[T] := C;\n  m := nops(C);\n  if m > 1 then\n   s[T] := table():\n   for i from 1 to m do \n    for j from i to m do \n     J1 := {seq(C[k],k=i..j)};\n     J := map(op,J1);\n     s[T][J1] := min(1,2*t[J]);\n    od;\n   od;\n   x[T] := [RR[T],eval(s[T])];\n  fi;\n od: \n\n return [TT,eval(x),eval(l)];\nend:\n", "meta": {"hexsha": "3b212b465857e323ee048ce06d0f80c16e78d7b9", "size": 7920, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/operads/WK.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/WK.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/WK.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.0, "max_line_length": 82, "alphanum_fraction": 0.4825757576, "num_tokens": 2720, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7853085909370422, "lm_q2_score": 0.611381973294151, "lm_q1q2_score": 0.4801235159719381}}
{"text": "\n# Kinematik-Berechnung 3. Arm KAS5\n# Beschreibung\n# Berechnung der Kinematik der parallelen Struktur: Stellung des Kompensationsmechanismus in Abhängigkeit der gemessenen Winkel der Haupt-Armkinematik\n# Zu Geometrie und Winkeln, siehe Bild (Unterlagen)\n# \n# Modell m3: Kurbel N7 ist starr mit Körper K2 gekoppelt (über die Achse)\n# \n# Berechne alle notwendigen Winkel in kintmp in Abhängigkeit konstanter Größen und der verallgemeinerten Koordinaten\n# \n# Berechne zuerst nur Sinus und Cosinus jedes Winkels. Diese werden für die Rotationsmatrizen benötigt.\n# Die Berechnung der Winkel selbst (zur Kontrolle) benötigt die arctan-Funktion, die längere Ausdrücke nur sehr langsam auswertet.\n# Daher werden zunächst alle Winkel mit %arctan (inert-Funktion berechnet) und am Ende erst ausgewertet.\n# Die Zeitableitung der Winkel (in späteren Skripten) wird aus der inert-Funktion berechnet.\n# \n# Hinweise:\n# Der Befehl arctan hat die Funktionalität von atan2\n# \n# Eingabe:\n# \"../codeexport/KAS5m3_definitions\"\n# * enthält die Definitionen aller Konstanten und verallgemeinerter Koordinaten\n# \n# Ausgabe:\n# \"../codeexport/%s/tmp/kinematic_constraints_maple_inert.m\"\n# * Erzeugt die Ausdrücke für Winkel der Parallelstruktur (kintmp), Ersetzungsausdrücke für sin,cos (kintmp_subsexp) und die Federlänge (lpar) in Abhängigkeit der verallgemeinerten Koordinaten.\n# Quellen\n# [1] Wang, Jiegao and Gosselin, ClémentM.: A New Approach for the Dynamic Analysis of Parallel Manipulators (1998)\n# Autor\n# Moritz Schappler, schappler@irt.uni-hannover.de, 2015-11\n# Institut fuer Regelungstechnik, Leibniz Universitaet Hannover\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 \"../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\":\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", robot_name):\n# Variable mit Winkeln der Nebenstruktur nur in Abhängigkeit der verallgemeinerten Koordinaten\nkintmp_qs := Matrix(RowDimension(kintmp_s),1):\n# Konstante Winkel bereits hineinschreiben\nfor i from 1 to RowDimension(kintmp_s) do\n  if diff(kintmp_s(i,1), t) = 0 then\n    kintmp_qs(i,1) := kintmp_s(i,1):\n  end if:\nend do:\n# Variablen definieren für die Hilfswinkel\ngamma5_s := kintmp_s(5,1):\ndelta_s := kintmp_s(6..23,1):\ndelta_qs := kintmp_qs(6..23,1):\n# Ersetzungsausdrücke definieren.\n# Speichere Sinus und Cosinus der Winkel direkt ab, da diese in den Rotationsmatrizen direkt auftreten.\n# Spalte 1: Zu suchender Ausdruck (sin oder cos eines Winkels)\n# Spalte 2: Einzusetzender Ausdruck.\n# Dadurch werden arctan-Ausdrücke in der direkten Kinematik reduziert.\n# Ähnliches Vorgehen wie in [1].\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:\n# Annahmen über Konstanten: Längen sind alle Positiv.\n# (Wird anscheinend für arctan gebraucht). Ansonsten steht csgn in exportiertem Code.\nassume(l1>0):\nassume(l2>0):\nassume(l3>0):\nassume(l4>0):\nassume(l5>0):\nassume(l6>0):\nassume(l7>0):\nassume(l8>0):\nassume(l9>0):\nassume(l10>0):\nassume(l11>0):\nassume(l12>0):\nassume(l13>0):\nassume(l14>0):\nassume(l15>0):\nassume(l16>0):\nassume(l17>0):\nassume(l18>0):\nassume(l19>0):\nassume(l20>0):\nassume(l21>0):\nassume(l22>0):\n# Schalter mit Optionen für die Code-Generierung.\n# Wähle, ob trigonometrische arctan-Ausdrücke ausgewertet werden, oder ob Sinus- und Cosinussatz angewendet werden sollen.\n# Dies hat großen Einfluss auf die Rechendauer.\n# Die Optimierungen sind so gewählt, dass\n# * Kreisschnittpunktsfunktionen nicht mit den komplizierten Eingabedaten aufgerufen, sondern mit allgemeinen Platzhaltern, die dann ersetzt werden,\n# * Keine Zwischenoptimierungen durchgeführt werden. Durch simplify und combine werden die symbolischen Ausdrücke größer, was später die Rechenzeit enorm erhöht\n# * Sinus und Cosinus der Parallelwinkel ersetzt werden und kein sin(arctan(...)) ausgerechnet wird.\nSchalter_Opt := <1;1;0;0;0;0;0;1>:\nprintf(\"Beginn der Berechnungen. %s\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\")):\nst := time():\n# Reihenfolge, in der die Winkel der Parallelstruktur berechnet werden. Hilft beim exportieren von Code, wenn beim Debuggen in der gleichen Reihenfolge ausgegeben wird.\nReihenfolge_kintmp := <12; 5; 21; 4; 9; 16; 3; 8; 24; 11; 2; 1; 6; 7; 10; 13; 14; 15; 17; 18; 19; 20; 22; 23>:\n# Berechne delta7\n# Gl. (30)\ndelta_qs(7) := kintmp_qs(22) + convert_t_s(theta(4)):\nkintmp_qs(12) := delta_qs(7):\n# Berechne gamma5\n# Gl.(2)\ngamma5_qs := - kintmp_qs(12) + Pi + convert_t_s(theta(5)):\nkintmp_qs(5) := gamma5_qs:\nkintmp_subsexp(9,2) := sin(gamma5_qs):\nkintmp_subsexp(10,2) := cos(gamma5_qs):\n# Berechne delta16\n# Kreisschnittpunkt berechnen\nr_4_G4_G5 := <l11;0;0>:\nr_12_G5_B := <l14;0;0>:\nR_4_12 := rotz(Pi+delta_qs(7)):\nr_4_G5_B := R_4_12 . r_12_G5_B:\nsave r_4_G5_B, \"../codeexport/KAS5m3_kinematic_constraints_r_4_G5_B_debug_maple\":\nR_3_4 := rotz(convert_t_s(theta(4))):\nR_4_3 := Transpose(R_3_4):\n# Vektor D-G4 (ausgedrückt in KS 3)\nr_3_D_G4 := <l5-l6;0;0>:\nr_4_G4_D := R_4_3 . (-r_3_D_G4):\n# Vektor G4-G5 (ausgedrückt in KS 4)\nr_4_G4_G5 := <l11;0;0>:\nr_4_G5_D := -r_4_G4_G5 + r_4_G4_D:\nsave r_4_G5_D, \"../codeexport/KAS5m3_kinematic_constraints_r_4_G5_D_noopt_debug_maple\":\nif Schalter_Opt(7) = 1 then\n  r_4_G5_D := simplify(r_4_G5_D, trig):\n  r_4_G5_D := simplify(r_4_G5_D):\n  r_4_G5_D := combine(r_4_G5_D, trig):\nend if:\nsave r_4_G5_D, \"../codeexport/KAS5m3_kinematic_constraints_r_4_G5_D_opt_debug_maple\":\nif Schalter_Opt(8) = 1 then\n  # Rufe die Kreisschnittpunkt-Funktion mit allgemeinen Werten auf und ersetze das Ergebnis.\n  subs_ic := <r_4_G5_B_Allg_x; r_4_G5_B_Allg_y; r_4_G5_D_Allg_x; r_4_G5_D_Allg_y>:\n  subs_ic_KAS := <r_4_G5_B(1..2,1); r_4_G5_D(1..2,1)>:\n  ReturnValue_Allg := intersect_circle(<r_4_G5_B_Allg_x; r_4_G5_B_Allg_y>, <r_4_G5_D_Allg_x; r_4_G5_D_Allg_y>, l13, l22):\n  ReturnValue := ReturnValue_Allg:\n  for i from 1 to 4 do \n    ReturnValue := subs({subs_ic(i) = subs_ic_KAS(i)}, ReturnValue):\n  end do:\nelse\n  ReturnValue := intersect_circle(r_4_G5_B, r_4_G5_D, l13, l22):\nend if:\nprintf(\"Erster Kreisschnittpunkt berechnet. %s. CPU-Zeit bis hier: %1.2fs.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\"), time()-st):\nr_4_G5_C := <ReturnValue(1..2, 2); 0>: # Alternative 2\n;\nsave r_4_G5_C, \"../codeexport/KAS5m3_kinematic_constraints_r_4_G5_C_debug_noopt_maple\":\nif Schalter_Opt(4) = 1 then\n  r_4_G5_C := simplify(r_4_G5_C, trig):\n  r_4_G5_C := simplify(r_4_G5_C):\n  r_4_G5_C := combine(r_4_G5_C, trig):\nend if:\nprintf(\"CPU-Zeit bis hier: %1.2fs\\n\", time()-st):\nsave r_4_G5_C, \"../codeexport/KAS5m3_kinematic_constraints_r_4_G5_C_debug_opt_maple\":\nr_4_D_C := - r_4_G5_D + r_4_G5_C:\nr_3_D_C := R_3_4 . r_4_D_C:\nsave r_3_D_C, \"../codeexport/KAS5m3_kinematic_constraints_r_3_D_C_debug_noopt_maple\":\nif Schalter_Opt(6) = 1 then\n  r_3_D_C := simplify(r_3_D_C, trig):\n  r_3_D_C := simplify(r_3_D_C):\n  r_3_D_C := combine(r_3_D_C, trig):\nend if:\nsave r_3_D_C, \"../codeexport/KAS5m3_kinematic_constraints_r_3_D_C_debug_opt_maple\":\n# Gl. (m3.5)\ndelta_qs(16) := %arctan(-r_3_D_C(2), r_3_D_C(1)):\nsin_delta16_qs := -r_3_D_C(2)/l22:\ncos_delta16_qs := r_3_D_C(1)/l22:\nkintmp_qs(21) := delta_qs(16):\nkintmp_subsexp(41,2) := sin_delta16_qs:\nkintmp_subsexp(42,2) := cos_delta16_qs:\n# Berechne gamma3\n# Berechnungen für Hebel E-F-G3\n# Zweiter Kreismittelpunkt für Schnittpunkt-Algorithmus\nr_3_G3_D := <l6;0;0>:\nr_3_D_G3 := -r_3_G3_D:\nr_10_D_E := rotz(delta_qs(9)) . <l21;0;0>:\n# Stelle Rotationsmatrix mit Zeitabhängigen Winkel delta16 auf (ohne Ersetzung mit delta16(q), da dort arctan vorkommt.\n# Ersetze sin(delta16), cos(delta16) mit Ausdrücken von oben. Bei arctan(sin(...)) entstehen kompliziertere Ausdrücke\nif Schalter_Opt(1) = 1 then\n  R_3_10_s := rotz(- delta_s(16)):\n  R_3_10 := subs_kintmp_exp(R_3_10_s):\nelse\n  R_3_10 := rotz(- delta_qs(16)):\nend if:\nr_3_D_E := R_3_10 . r_10_D_E:\nsave r_3_D_E, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_r_3_D_E_noopt_debug_maple\", robot_name):\nif Schalter_Opt(5) = 1 then\n  r_3_D_E := simplify(r_3_D_E, trig):\n  r_3_D_E := simplify(r_3_D_E):\n  r_3_D_E := combine(r_3_D_E, trig):\nend if:\nsave r_3_D_E, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_r_3_D_E_opt_debug_maple\", robot_name):\nif Schalter_Opt(2) = 1 then\n  # Rufe die Kreisschnittpunkt-Funktion mit allgemeinen Werten auf und ersetze das Ergebnis.\n  # dies führt zu einer wesentlichen Verringerungen der Rechenzeit, da das Einsetzen und Weiterrechnen der komplizierten Ausdrücke in der Unterfunktion entfällt.\n  subs_ic := <r_3_D_E_Allg_x; r_3_D_E_Allg_y; r_3_D_G3_Allg_x; r_3_D_G3_Allg_y>:\n  subs_ic_KAS := <r_3_D_E(1..2,1); r_3_D_G3(1..2,1)>:\n  ReturnValue_Allg := intersect_circle(<r_3_D_E_Allg_x; r_3_D_E_Allg_y>, <r_3_D_G3_Allg_x; r_3_D_G3_Allg_y>, l20, l4):\n  ReturnValue := ReturnValue_Allg:\n  for i from 1 to 4 do \n    ReturnValue := subs({subs_ic(i) = subs_ic_KAS(i)}, ReturnValue):\n  end do:\nelse\n  ReturnValue := intersect_circle(r_3_D_E, r_3_D_G3, l20, l4):\nend if:\nprintf(\"Zweiter Kreisschnittpunkt berechnet. %s. CPU-Zeit bis hier: %1.2fs.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\"), time()-st):\nr_3_D_F := <ReturnValue(1..2, 2); 0>: # Alternative 2\n;\nsave r_3_D_F, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_r_3_D_F_noopt_debug_maple\", robot_name):\nif Schalter_Opt(3) = 1 then\n  r_3_D_F := simplify(r_3_D_F, trig):\n  r_3_D_F := simplify(r_3_D_F):\n  r_3_D_F := combine(r_3_D_F, trig):\nend if:\nr_3_F_G3 := -r_3_D_F + r_3_D_G3:\nprintf(\"CPU-Zeit bis hier: %1.2fs\\n\", time()-st):\nsave r_3_D_F, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_r_3_D_F_opt_debug_maple\", robot_name):\nsave ReturnValue, r_3_D_F, r_3_F_G3, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_gamma3_qs_debug_maple\", robot_name):\n# Gl. (m3.6)\ngamma3_qs := %arctan(r_3_F_G3(2,1), -r_3_F_G3(1,1)):\nsin_gamma3_qs := r_3_F_G3(2,1) / l4:\ncos_gamma3_qs := (-r_3_F_G3(1,1)) / l4:\nkintmp_qs(4) := gamma3_qs:\nkintmp_subsexp(7,2) := sin_gamma3_qs:\nkintmp_subsexp(8,2) := cos_gamma3_qs:\nsave ReturnValue, r_3_D_F, r_3_F_G3, gamma3_qs, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_gamma3_qs_debug_maple\", robot_name):\nsave kintmp_qs, kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_debug_nach_gamma3.m\", robot_name):\nprintf(\"Winkel gamma3 berechnet. %s. CPU-Zeit bis hier: %1.2fs.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\"), time()-st):\n# Berechne delta4\n# Gl. (22)\ndelta_qs(4) := Pi/2 - delta_qs(16) - delta_qs(12):\nkintmp_qs(9) := delta_qs(4):\n# Berechne delta11\n# Gl. (3)\ndelta_qs(11) := delta_qs(10) - delta_qs(4):\nkintmp_qs(16) := delta_qs(11):\n# Berechne beta2\n# Gl. (m3.7)\n# Siehe auch: KAS5m3_sym_codegen_kinematic_constraints_hilfsberechnungen.mw\nd7b2 := %arctan((sin(delta_qs(7)) * l14 + r_4_G5_C(2)), (cos(delta_qs(7)) * l14 + r_4_G5_C(1))):\nbeta2_qs := d7b2 - delta_qs(7):\nkintmp_qs(3) := beta2_qs:\n# Nutze Additionstheoreme zur Bestimmung von Sinus und Cosinus.\ncos_d7b2 := (cos(delta_qs(7)) * l14 + r_4_G5_C(1)) / l13:\nsin_d7b2 := (sin(delta_qs(7)) * l14 + r_4_G5_C(2)) / l13:\nsin_beta2_qs := sin_d7b2*cos(delta_qs(7)) - cos_d7b2*sin(delta_qs(7)):\ncos_beta2_qs := cos_d7b2*cos(delta_qs(7)) + sin_d7b2*sin(delta_qs(7)):\nkintmp_subsexp(5,2) := sin_beta2_qs:\nkintmp_subsexp(6,2) := cos_beta2_qs:\nsave kintmp_qs, kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_debug_nach_beta2.m\", robot_name):\n# Berechne delta3\n# Gl. (m3.9)\n# Siehe auch: KAS5m3_sym_codegen_kinematic_constraints_hilfsberechnungen.mw\nr_4_D_B := -r_4_G5_D + r_4_G5_B:\nt7 := convert_t_s(theta(4)) + delta_qs(16):\n# Nutze Additionstheoreme zur Bestimmung von Sinus und Cosinus.\n# Dadurch kann Sinus/Cosinus von delta16 direkt genutzt werden und es tritt kein arctan auf.\ncos_t7 := cos(convert_t_s(theta(4)))*cos_delta16_qs - sin(convert_t_s(theta(4)))*sin_delta16_qs:\nsin_t7 := sin(convert_t_s(theta(4)))*cos_delta16_qs + cos(convert_t_s(theta(4)))*sin_delta16_qs:\n# Hilfswinkel t8\nt8 := %arctan((sin_t7 * l22 + r_4_D_B(2)), (cos_t7 * l22 - r_4_D_B(1))):\nsin_t8 := (sin_t7 * l22 + r_4_D_B(2))/l13:\ncos_t8 := (cos_t7 * l22 - r_4_D_B(1))/l13:\ndelta_qs(3) := t8 - t7:\ncos_delta3_qs := (cos_t8)*(cos_t7) + (sin_t8)*(sin_t7):\nsin_delta3_qs := (sin_t8)*(cos_t7) - (cos_t8)*(sin_t7):\nkintmp_qs(8) := delta_qs(3):\nkintmp_subsexp(15,2) := sin_delta3_qs:\nkintmp_subsexp(16,2) := cos_delta3_qs:\nsave kintmp_qs, kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_debug_nach_delta3.m\", robot_name):\n# Berechne rho3\n# Gl. (11)\nrho3_qs := gamma3_qs + delta_qs(8) - Pi/2:\n# Nutze Additionstheoreme zur Bestimmung von Sinus und Cosinus.\n# Dadurch kann Sinus/Cosinus von gamma3 direkt genutzt werden und es tritt kein arctan auf.\nsin_rho3_qs := (sin_gamma3_qs)*(cos(delta_qs(8) - Pi/2)) + (cos_gamma3_qs)*(sin(delta_qs(8) - Pi/2)):\ncos_rho3_qs := (cos_gamma3_qs)*(cos(delta_qs(8) - Pi/2)) - (sin_gamma3_qs)*(sin(delta_qs(8) - Pi/2)):\nkintmp_qs(24) := rho3_qs:\nkintmp_subsexp(47,2) := sin_rho3_qs:\nkintmp_subsexp(48,2) := cos_rho3_qs:\nsave kintmp_qs, kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_debug_nach_rho3.m\", robot_name):\nprintf(\"Winkel rho3 berechnet. %s. CPU-Zeit bis hier: %1.2fs.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\"), time()-st):\n# Berechne delta6\n# Gl. (m3.8)\n# Siehe auch: KAS5m3_sym_codegen_kinematic_constraints_hilfsberechnungen.mw\nr_3_G3_E := r_3_G3_D + r_3_D_E:\nt1 := -rho3_qs + delta_qs(8):\nt2 := %arctan((-sin_t1 * l4 + r_3_G3_E(1)), (cos_t1 * l4 + r_3_G3_E(2))):\n# Nutze Additionstheoreme zur Bestimmung von Sinus und Cosinus.\ncos_t1 :=  cos_rho3_qs*cos(delta_qs(8)) + sin_rho3_qs*sin(delta_qs(8)):\nsin_t1 := -sin_rho3_qs*cos(delta_qs(8)) + cos_rho3_qs*sin(delta_qs(8)):\ndelta_qs(6) := t1 + t2:\nkintmp_qs(11) := delta_qs(6):\n# Nutze Additionstheoreme zur Bestimmung von Sinus und Cosinus.\ncos_t2 := ( cos_t1 * l4 + r_3_G3_E(2)) / l20:\nsin_t2 := (-sin_t1 * l4 + r_3_G3_E(1)) / l20:\ncos_delta6_qs := cos_t2*cos_t1 - sin_t2*sin_t1:\nsin_delta6_qs := sin_t2*cos_t1 + cos_t2*sin_t1:\nkintmp_subsexp(21,2) := sin_delta6_qs:\nkintmp_subsexp(22,2) := cos_delta6_qs:\nsave kintmp_qs, kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_debug_nach_delta6.m\", robot_name):\n# Kompensationsfeder\nR_5_6:=rotz(convert_t_s(theta(6))):\nr_6_A_H := <l17; 0; 0>:\nr_5_A_H:=R_5_6 . r_6_A_H:\nr_5_G5_G6:=<l12;0;0>:\nr_6_G6_H:=<0; -l18; 0>:\nr_5_G6_H:=R_5_6 . r_6_G6_H:\nr_5_G5_H:= r_5_G5_G6 + r_5_G6_H: # Weg G5-G6-H\n;\nR_12_5_s:=rotz(gamma5_s): # Rotationsmatrix mit allgemeinem zeitabhängigem Ausdruck für den Winkel gamma5\n;\nR_12_5 := subs_kintmp_exp(R_12_5_s): # sinus und cosinus von gamma5 direkt ersetzen, ohne den Winkel einzusetzen.\n;\nR_5_12:=Transpose(R_12_5):\nr_12_B_G5:=<-l14;0;0>:\nr_5_G5_B:=R_5_12 . (-r_12_B_G5):\nr_5_AB_2 := r_5_A_H - r_5_G5_H + r_5_G5_B: # Weg AB aus A-H-G5-B\n;\nl16_c := sqrt(r_5_AB_2[1,1]^2 + r_5_AB_2[2,1]^2): # Länge AB entspricht Federlänge\n;\nlpar_qs := l16_c:\nprintf(\"Kompensationsfederlänge berechnet. %s.  CPU-Zeit bis hier: %1.2fs.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\"), time()-st):\n# Berechne beta1\n# Gl. (29)\n# Siehe auch: KAS5_m4_sym_codegen_kinematic_constraints_hilfsberechnungen.mw\nt2 := cos(convert_t_s(theta(6))):\nt1 := sin(convert_t_s(theta(6))):\nt3 := %arctan(-(t2 * l18 - sin(gamma5_qs) * l14 + t1 * l17), (t2 * l17 + cos(gamma5_qs) * l14 - t1 * l18 - l12)):\nbeta1_qs := t3 - gamma5_qs:\ncos_t3 := (t2 * l17 + cos(gamma5_qs) * l14 - t1 * l18 - l12) / l16_c:\nsin_t3 := (-(t2 * l18 - sin(gamma5_qs) * l14 + t1 * l17)) / l16_c:\nkintmp_qs(2) := beta1_qs:\n# Nutze Additionstheoreme zur Bestimmung von Sinus und Cosinus.\n# Zu erledigen: In den Sinus/Cosinus-Ausdrücken kommt l16 vor. Muss noch generiert werden.\ncos_beta1_qs := cos_t3*cos(gamma5_qs) + sin_t3*sin(gamma5_qs):\nsin_beta1_qs := sin_t3*cos(gamma5_qs) - cos_t3*sin(gamma5_qs):\nkintmp_subsexp(3,2) := sin_beta1_qs:\nkintmp_subsexp(4,2) := cos_beta1_qs:\n# Exportiere Code für folgende Skripte\n# Entferne Annahmen aus Variablen\nl1 := 'l1':\nl2 := 'l2':\nl3 := 'l3':\nl4 := 'l4':\nl5 := 'l5':\nl6 := 'l6':\nl7 := 'l7':\nl8 := 'l8':\nl9 := 'l9':\nl10 := 'l10':\nl11 := 'l11':\nl12 := 'l12':\nl13 := 'l13':\nl14 := 'l14':\nl15 := 'l15':\nl16 := 'l16':\nl17 := 'l17':\nl18 := 'l18':\nl19 := 'l19':\nl20 := 'l20':\nl21 := 'l21':\nl22 := 'l22':\n# Die Annahmen sind im Ausdruck bereits in den Variablen gespeichert. Ersetze das \"~\"-Zeichen.\n# Quelle: http://www.mapleprimes.com/questions/207601-Remove-Assumptions\nnms:=convert(indets(kintmp_qs,name),list): # Liste der Symbole\n;\nnmsS:=convert~(nms,string): # Liste der Symbole als String\n;\nL:=StringTools:-Substitute~(nmsS,\"~\",\"\"): #Removing \"~\"\n;\nL1:=parse~(L):\nS:=nms=~L1:\nkintmp_qs:=subs(S,kintmp_qs):\nlpar_qs:=subs(S,lpar_qs):\nkintmp_subsexp:=subs(S,kintmp_subsexp):\nkintmp_qt := convert_s_t(kintmp_qs):\nlpar_qt := convert_s_t(lpar_qs):\n# Speichere Maple-Ausdruck (Eingabe-Format und internes Format)\nsave kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_kintmp_subsexp_maple\", robot_name):\nsave kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_kintmp_subsexp_maple.m\", robot_name):\nprintf(\"Ausdrücke für kintmp_subsexp gespeichert (Maple). %s. CPU-Zeit bis hier: %1.2fs.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\"), time()-st):\nfor i from 1 to RowDimension(kintmp_s) do\n  tmp := kintmp_qs(i):\n  save tmp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_inert_kintmpq_%d\", robot_name, i):\n  save tmp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_inert_kintmpq_%d.m\", robot_name, i):\nend do:\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):\nsave kintmp_qs, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_kintmp_qs_maple_inert\", robot_name):\n# Exportieren des vollständigen Ausdruckes\nif codegen_act then\n  MatlabExport(kintmp_subsexp, sprintf(\"../codeexport/KAS5_kinematik_parallel_kintmp_subsexp_matlab_noopt.m\"), 0):\n  MatlabExport(kintmp_subsexp, sprintf(\"../codeexport/KAS5_kinematik_parallel_kintmp_subsexp_matlab_opt.m\"), 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 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(\"Fertig. %s. CPU-Zeit bis hier: %1.2fs.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\"), time()-st):\n\n", "meta": {"hexsha": "4a2e852158ba1914d1f4ae5efd3595b2fbe34a43", "size": 19753, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "exoskeleton_model/model_generation/constraints/KAS5m3_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/KAS5m3_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/KAS5m3_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": 46.919239905, "max_line_length": 193, "alphanum_fraction": 0.7405457399, "num_tokens": 7541, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7577943712746406, "lm_q2_score": 0.6334102636778401, "lm_q1q2_score": 0.4799947325226532}}
{"text": "#@ Not autoload\n\nMU_n_max := 10;\n\nmake_fgl_Lazard := proc(d)\n global a,m,ma,am;\n local e,T,u,x,y,q,i,j,k,Fm,Fmp,err,sol;\n\n T := table();\n T[\"degree\"] := d;\n Order := d+2;\n\n T[\"log_m\"] := unapply(x + add(m[i]*x^(i+1),i=1..d-1),x);\n T[\"exp_m\"] := \n   unapply(\n   convert(\n    solve(x = series(T[\"log_m\"](y) + sin(y)^(d+1),y=0,d+1),y),\n    polynom,x\n   ),\n   x\n  );\n\n Fm := x+y;\n for k from 2 to d do\n  Fmp[0] := 1;\n  Fmp[1] := subs({x=e*x,y=e*y},Fm);\n  for j from 2 to k do\n   Fmp[j] := rem(expand(Fmp[1] * Fmp[j-1]),e^(k+1),e);\n  od;\n  err := expand(Fmp[1] - e*x - e*y +\n   add(m[i]*(Fmp[i+1] - e^(i+1)*(x^(i+1)+y^(i+1))),i=1..k-1));\n  Fm := Fm - subs(e=1,err);\n od:\n \n T[\"sum_m\"] := unapply(Fm,x,y):\n\n am[1] := m[1];\n for k from 2 to d-1 do\n  q := igcd_alt([seq(binomial(k+1,i),i=1..k)])[2];\n  am[k] := -add(q[i]*coeff(coeff(Fm,x,i),y,k+1-i),i=1..k);\n od:\n sol := solve({seq(a[i]=am[i],i=1..d-1)},{seq(m[i],i=1..d-1)}):\n for i from 1 to d-1 do ma[i] := subs(sol,m[i]); od:\n\n T[\"log_a\"] := unapply(collect(expand(eval(subs(m = ma,T[\"log_m\"](x)))),x),x);\n T[\"exp_a\"] := unapply(collect(expand(eval(subs(m = ma,T[\"exp_m\"](x)))),x),x);\n T[\"sum_a\"] := unapply(collect(expand(eval(subs(m = ma,T[\"sum_m\"](x,y)))),{x,y}),x,y);\n\n return eval(T);\nend:\n\nMU_vars := plex(seq(a[i],i=1..MU_n_max));\nMUMU_vars := plex(seq(a[i],i=1..MU_n_max),seq(b[i],i=1..MU_n_max));", "meta": {"hexsha": "a091cfdc8e3a96d52c012c317020f95ffd41925d", "size": 1352, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/chromatic/MU.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/chromatic/MU.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/chromatic/MU.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": 25.5094339623, "max_line_length": 86, "alphanum_fraction": 0.5162721893, "num_tokens": 592, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677430095496, "lm_q2_score": 0.5660185351961015, "lm_q1q2_score": 0.47996545979180943}}
{"text": "\n# Inverse Dynamics for Parallel Robot Platform\n# Einleitung\n# Berechnung der inversen Dynamik der Roboter-Plattform\n# \n# Dateiname:\n# robot -> Berechnung für allgemeinen Roboter\n# para -> Berechnung für eine parallelen Roboter\n# plattform -> Bezogen auf Plattform der PKM\n# rotmat -> Kinematik wird mit Rotationsmatrizen berechnet\n# dynamics -> Berechnung der Dynamik\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# [Abdellatif2007] Modellierung, Identifikation und robuste Regelung von Robotern mit parallelkinematischen Strukturen\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(codegen):\nwith(CodeGeneration):\nwith(StringTools):\nwith(VectorCalculus):\n# Einstellungen für Code-Export: Optimierungsgrad (2=höchster) und Aktivierung jedes Terms.\ncodegen_dynpar := 1:\ncodegen_opt := 2:\ncodeexport_invdyn := false:\ncodeexport_grav := false: \ncodeexport_corvec := false:\ncodeexport_inertia := false:\nread \"../helper/proc_MatlabExport\":\nread \"../helper/proc_vec2skew\":\nread \"../robot_codegen_definitions/robot_env_par\":\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", leg_name):\n# Definitionen für parallelen Roboter laden\nread \"../robot_codegen_definitions/robot_env_par\":\nread sprintf(\"../codeexport/%s/tmp/para_definitions\", robot_name):\nr_P_sP_P := -r_P_sP:\ns_P_P_sP := s_P_sP:\n\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, angleConv)):\nread(sprintf(\"%s/transformation/maple/proc_eul%sjac\", robotics_repo_path, angleConv)):\n\n# Additional Kinematics\n# Berechnung der Rotationsmatrizen\n\nR_0_0_E_t := parse(sprintf(\"eul%s2r\",angleConv))(xE_t(4..6)):\nR_0_0_E_s := parse(sprintf(\"eul%s2r\",angleConv))(xE_s(4..6)):\nRPYjac_0_t := parse(sprintf(\"eul%sjac\",angleConv))(xE_t(4..6)):\nRPYjac_0_s := parse(sprintf(\"eul%sjac\",angleConv))(xE_s(4..6)):\nr_0_sP_P := R_0_0_E_s.r_P_sP_P:\nif codegen_dynpar = 1 then\n  J_P_P := J_SP + mE*Multiply(Transpose(vec2skew(r_P_sP_P)),vec2skew(r_P_sP_P)):\nelse\n  J_P_P := J_P_P:\nend if:\nJ_0_P := R_0_0_E_s.J_P_P.Transpose(R_0_0_E_s):\n\nr_0_sP_P := R_0_0_E_t.r_P_sP_P:\nrD_0_sP_P := diff~(r_0_sP_P,t):\ns_0_P_sP := R_0_0_E_t.s_P_P_sP:\nsD_0_P_sP := diff~(s_0_P_sP,t):\nfor i to 3 do\n   for j to 6 do\n      rD_0_sP_P(i) := subs({xED_t(j)=xED_s(j),xE_t(j)=xE_s(j)},rD_0_sP_P(i)):\n      sD_0_P_sP(i) := subs({xED_t(j)=xED_s(j),xE_t(j)=xE_s(j)},sD_0_P_sP(i)):\n   end do:\nend do:\ns_0_P_sP := R_0_0_E_s.s_P_P_sP:\nr_0_sP_P := R_0_0_E_s.r_P_sP_P:\n\n# Berechnung der H-Matrix und deren Ableitung nach Abdellatif2007 S.20\n# \nRPYjac_E_t := simplify(Multiply(Transpose(R_0_0_E_t),RPYjac_0_t)):\nRPYjac_E_s := simplify(Multiply(Transpose(R_0_0_E_s),RPYjac_0_s)):\nw_E_0_E_s := RPYjac_E_s.xED_s(4..6,1):\nw_0_0_E_s := RPYjac_0_s.xED_s(4..6,1):\nw_E_0_E_t := RPYjac_E_t.xED_t(4..6,1):\ndRPYjac_E_t := diff~(RPYjac_E_t,t):\ndRPYjac_0_t := diff~(RPYjac_0_t,t):\ndRPYjac_E_s := Copy(dRPYjac_E_t):\ndRPYjac_0_s := Copy(dRPYjac_0_t):\n# Substituiere die zeitabhängigen Koordinaten in der H-Matrix mit zeitunabhängigen Koordinaten \nfor i to 3 do\n  for j to 3 do\n    for k from 4 to 6 do\n      dRPYjac_E_s(i,j) := subs({xEDD_t(k)=xEDD_s(k),xED_t(k)=xED_s(k),xE_t(k)=xE_s(k)},dRPYjac_E_s(i,j)):\n      dRPYjac_0_s(i,j) := subs({xEDD_t(k)=xEDD_s(k),xED_t(k)=xED_s(k),xE_t(k)=xE_s(k)},dRPYjac_0_s(i,j)):\n    end do:\n  end do:\nend do:\n\nwD_E_0_E_s := simplify(dRPYjac_E_s.xED_s(4..6,1)+RPYjac_E_s.xEDD_s(4..6,1)):\nwD_0_0_E_s := simplify(dRPYjac_0_s.xED_s(4..6,1)+RPYjac_0_s.xEDD_s(4..6,1)):\n\n# Abdellatif2007 S.20 (2.19)\n\nH := <IdentityMatrix(3,3),ZeroMatrix(3);\n      ZeroMatrix(3),RPYjac_0_s>:\nHinv := MatrixInverse(H):\ndH := <ZeroMatrix(3),ZeroMatrix(3);\n      ZeroMatrix(3),dRPYjac_0_s>:\n\n# Gravitational-Vector gE of the platform\n# Berechnung des Gravitationsvektors\n# Abdellatif2007 S.34 (3.20)\nxAll := <x;y;z;an;bn;cn>:\nif codegen_dynpar = 1 then\n  gE_z := xE_s(1..3,1) - r_0_sP_P:\nelse\n  gE_z := mE*xE_s(1..3,1) + s_0_P_sP:\nend if:\nfor j to 3 do\n  for i from 1 to 6 do\n    gE_z(j) := subs(xE_s(i)=xAll(i),gE_z(j)):\n  end do:\nend do:\ndgEdz_final := Matrix(6,1):\ndgEdz := Matrix(3,1):\n\nfor j to 6 do\n  for i to 3 do\n     dgEdz(i) := diff(gE_z(i),xAll(j)):\n  end do:\n  if codegen_dynpar = 1 then\n    dgEdz_final(j) := mE*Transpose(g_world(..,1)).dgEdz(..,1):\n  else \n    dgEdz_final(j) := Transpose(g_world(..,1)).dgEdz(..,1):\n  end if:\nend do:\nfor j to 6 do\n  for i from 1 to 6 do\n    dgEdz_final(j) := subs(xAll(i)=xE_s(i),dgEdz_final(j)):\n  end do:\nend do:\ngE := simplify(Transpose(Hinv).dgEdz_final):\n\nif codeexport_grav then\n  MatlabExport(gE, sprintf(\"../codeexport/%s/tmp/gravload_platform_eul%s_matlab.m\", robot_name, angleConv), codegen_opt):\nend if:\n\n# Mass-Matrix ME of the platform\n# Berechnung Massenmatrix für die EE-Plattform und die Winkelgeschwindigkeit\n# Abdellatif2007 S.39 (3.30)\n\nif codegen_dynpar = 1 then\n  ME := simplify(<mE*Matrix(3,shape=identity),mE*vec2skew(r_0_sP_P);\n         mE*Transpose(vec2skew(r_0_sP_P)),J_0_P>):\nelse \n  ME := simplify(<mE*Matrix(3,shape=identity),vec2skew(-s_0_P_sP);\n         Transpose(vec2skew(-s_0_P_sP)),J_0_P>):\nend if:\n\nif codeexport_inertia then\n  MatlabExport(ME, sprintf(\"../codeexport/%s/tmp/inertia_platform_eul%s_matlab.m\", robot_name, angleConv), codegen_opt):\nend if:\n\n# Coriolis-Vector cE of the platform\n# Coriolis-Matrix\n# Abdellatif2007 S.39 (3.31)\n\nif codegen_dynpar = 1 then\n  cE := simplify(<ZeroMatrix(3,3),mE*vec2skew(rD_0_sP_P);\n         ZeroMatrix(3,3),Multiply(vec2skew(w_0_0_E_s),J_0_P)>):\nelse\n  cE := simplify(<ZeroMatrix(3,3),vec2skew(-sD_0_P_sP);\n         ZeroMatrix(3,3),Multiply(vec2skew(w_0_0_E_s),J_0_P)>):\nend if:\n\nif codeexport_corvec then\n  # Der Term ist nicht der Coriolis-Vektor, sondern eine Matrix, die dazu führt. Daher kein Export.\n  # MatlabExport(cE, sprintf(\"../codeexport/%s/tmp/coriolisvec_platform_eul%s_matlab.m\", robot_name, angleConv), codegen_opt):\nend if:\n\n# Torque at the platform\n# Inverse Dynamik der Plattform\n# Abdellatif2007 S.39 (3.29)\n\nMME := ME.H:\ncvecE := Multiply(ME.dH+cE.H,xED_s):\ntauE := Multiply(MME,xEDD_s) + cvecE - gE:\n# Maple-Export\nsave MME, cvecE , gE, tauE, H, dH, sprintf(\"../codeexport/%s/tmp/floatb_platform_dynamic_maple.m\", robot_name):\n# Matlab Code Export\nif codeexport_invdyn then\n  MatlabExport(tauE, sprintf(\"../codeexport/%s/tmp/invdyn_platform_eul%s_matlab.m\", robot_name, angleConv), codegen_opt):\nend if:\n# \n\n", "meta": {"hexsha": "19f4273c874a96056ccc364b21f70fa2f579717f", "size": 6750, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "robot_codegen_parallel/robot_para_plattform_rotmat_dynamics.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_plattform_rotmat_dynamics.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_plattform_rotmat_dynamics.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": 34.4387755102, "max_line_length": 126, "alphanum_fraction": 0.7268148148, "num_tokens": 2524, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8333245953120233, "lm_q2_score": 0.5736784074525096, "lm_q1q2_score": 0.47806032672960863}}
{"text": "\n# Inverse Dynamics for Robot based on MDH frames\n# Einleitung\n# Berechnung der inversen Dynamik\n# \n# Dateiname:\n# robot -> Berechnung für allgemeinen Roboter\n# tree -> Berechnung für eine beliebige Baumstruktur (ohne Schleifen)\n# floatb -> floating base wird durch base twist (Geschwindigkeit der Basis) oder vollständige Orientierung (Euler-Winkel) berücksichtigt\n# rotmat -> Kinematik wird mit Rotationsmatrizen berechnet\n# dynamics -> Berechnung der Dynamik\n# worldframe -> Berechnung basierend auf Energien aus Welt-KS (KS W)\n# par12 -> Parametersatz 1 (Schwerpunkt als Parameter: SX,SY,SZ) oder Parametersatz 2 (1. und 2. Moment MX,MY,MZ,...)\n# Autor\n# Moritz Schappler, schappler@irt.uni-hannover.de, 2016-03\n# (C) Institut fuer Regelungstechnik, Leibniz Universitaet 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# 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.\ncodegen_act := true:\ncodegen_debug := false:\ncodegen_opt := 2:\ncodeexport_grav := true: \ncodeexport_corvec := true:\ncodeexport_cormat := true:\ncodeexport_inertia := true:\ncodeexport_inertiaD := true:\ncodeexport_invdyn := true:\nread \"../helper/proc_convert_s_t\":\nread \"../helper/proc_convert_t_s\": \nread \"../helper/proc_MatlabExport\":\nread \"../helper/proc_simplify2\":\nread \"../helper/proc_index_symmat2vector\":\nread \"../helper/proc_symmat2vector\":\nread \"../transformation/proc_rotx\": \nread \"../transformation/proc_roty\": \nread \"../transformation/proc_rotz\": \nread \"../transformation/proc_trotx\": \nread \"../transformation/proc_troty\": \nread \"../transformation/proc_trotz\": \nread \"../transformation/proc_transl\": \nread \"../transformation/proc_trafo_mdh\": \nread \"../robot_codegen_definitions/robot_env\":\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", robot_name):\nread sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_inert.m\", robot_name):  \nkin_constraints_exist := kin_constraints_exist: # nur zum Abschätzen der Komplexität\n;\n# Einstellungen für Term-Vereinfachungen: 0=keine, 1=Massenmatrix, 2=Coriolis-Matrix, 3=Massenmatrix-Zeitableitung, Coriolis-Vektor, Invers-Dynamik\n# Motivation: Massenmatrix ist Voraussetzung für andere symbolische Berechnungen (lohnt sich damit mehr)\n# Coriolis-Matrix lässt sich besser vereinfachen, da viele Einträge getrennt voneinander betrachtet werden.\n# Coriolis-Vektor bzw. Invers-Dynamik am kompliziertesten.\nif not assigned(simplify_options) or simplify_options(9)=-1 then # Standard-Einstellungen:\n  if not kin_constraints_exist then # normale serielle Ketten und Baumstrukturen\n    use_simplify := 0: # Standardmäßig aus\n  else # mit kinematischen Zwangsbedingungen\n    # pauschale Annahme für kinematische Zwangsbedingungen.\n    use_simplify := 1: # nur Massenmatrix\n  end if:\nelse # Benutzer-Einstellungen:\n use_simplify := simplify_options(9): # neunter Eintrag ist für Dynamik\nend if:\n\n# Kennung des Parametersatzes, für den die Dynamikfunktionen erstellt werden sollen. Muss im Repo und in der mpl-Datei auf 1 gelassen werden, da die folgende Zeile mit einem Skript verarbeitet wird.\ncodegen_dynpar := 1:\n# Ergebnisse des Lagrange-Formalismus laden\nread sprintf(\"../codeexport/%s/tmp/floatb_%s_lagrange_dUdq_s_par%d_maple.m\", robot_name, base_method_name, codegen_dynpar):\ndUdq_s := dUdq_s:\nread sprintf(\"../codeexport/%s/tmp/floatb_%s_lagrange_dTdq_s_par%d_maple.m\", robot_name, base_method_name, codegen_dynpar):\ndTdq_s := dTdq_s:\nread sprintf(\"../codeexport/%s/tmp/floatb_%s_lagrange_dTdqDdt_s_par%d_maple.m\", robot_name, base_method_name, codegen_dynpar):\ndTdqDdt_s := dTdqDdt_s:\n\nDynString := \"Term:\":\nif codeexport_grav then\n  DynString := sprintf(\"%s g\",DynString):\nend if:\nif codeexport_corvec then\n  DynString := sprintf(\"%s c\",DynString):\nend if:\nif codeexport_cormat then\n  DynString := sprintf(\"%s C\",DynString):\nend if:\nif codeexport_inertia then\n  DynString := sprintf(\"%s M\",DynString):\nend if:\nif codeexport_inertiaD then\n  DynString := sprintf(\"%s MD\",DynString):\nend if:\nif codeexport_invdyn then\n  DynString := sprintf(\"%s tau\",DynString):\nend if:\nprintf(\"%s. Generiere Dynamik (%s) für %s mit Parametersatz %d und %s\\n\", \\\n  FormatTime(\"%Y-%m-%d %H:%M:%S\"), DynString, robot_name, codegen_dynpar, base_method_name):\n\n# Gravitational Load\n# Generate\ntaug_s := dUdq_s:\nsave taug_s, sprintf(\"../codeexport/%s/tmp/gravload_par%d_maple.m\", robot_name, codegen_dynpar):\n# Matlab Export\n# Belastung der Basis (ist falsch für floatb_twist, da das Moment durch diese Wahl der verallgemeinerten Koordinaten (floatb_twist) nicht berechnet werden kann!)\n# Ist korrekt für floatb_eulxyz.\n# Die Berechnungen werden deshalb nicht für floatb_twist durchgeführt.\nif codegen_act and codeexport_grav and not(base_method_name=\"twist\") then\n  MatlabExport(taug_s(1..6), sprintf(\"../codeexport/%s/tmp/gravload_base_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\n# Belastung der Gelenke\nif codegen_act and codeexport_grav then\n  MatlabExport(taug_s(7..NQ), sprintf(\"../codeexport/%s/tmp/gravload_joint_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\n# Kompletter Vektor\nif codegen_act and codeexport_grav and not(base_method_name=\"twist\") then\n  MatlabExport(taug_s(1..NQ), sprintf(\"../codeexport/%s/tmp/gravload_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\n# Mass Matrix\n# Generate\ntauMM_s := dTdqDdt_s:\nMM_s := Matrix(NQ, NQ):\n\nif codeexport_inertia then\n  for i to NQ do \n    for j to NQ do\n    \t if i > j then # linke untere Dreiecksmatrix\n    \t   MM_s[i, j] := MM_s[j,i]: # nehme symmetrischen Teil (wurde schon berechnet)\n    \t   next:\n    \t end if:\n      MM_s[i, j] := diff(tauMM_s[i, 1], qDD_s[j, 1]):\n    end do:\n  end do:\n  # Terme vereinfachen\n  if use_simplify>=1 then\n    tmp_t0:=time():\n    tmp_l0 := length(MM_s):\n    printf(\"%s: Beginne Elementweise Vereinfachung Massenmatrix (Param. %d). Länge: %d.\\n\", \\\n      FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, tmp_l0):\n    for i to NQ do \n      for j to NQ do\n    \t   if i > j then # linke untere Dreiecksmatrix\n    \t     MM_s[i, j] := MM_s[j,i]: # nehme symmetrischen Teil (wurde schon vereinfacht)\n    \t     next:\n    \t   end if:\n        tmp_t1:=time():\n        tmp_l1 := length(MM_s[i,j]):\n        printf(\"%s: Beginne Vereinfachung Massenmatrix (Param. %d; Elem. %d,%d). Länge: %d.\\n\", \\\n          FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, i, j, tmp_l1):\n        MM_s[i,j] := simplify2(MM_s[i,j]):\n        tmp_t2:=time():\n        tmp_l2 := length(MM_s[i,j]):\n        printf(\"%s: Massenmatrix (Param. %d; Elem. %d,%d) vereinfacht. Länge: %d->%d. Rechenzeit %1.1fs.\\n\", \\\n          FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, i, j, tmp_l1, tmp_l2, tmp_t2-tmp_t1):\n      end do:\n    end do:\n    tmp_l2 := length(MM_s):\n    printf(\"%s: Massenmatrix (Param. %d) vereinfacht. Länge: %d->%d. Rechenzeit %1.1fs.\\n\", \\\n      FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, tmp_l0, tmp_l2, tmp_t2-tmp_t0):\n  end if:\n  save MM_s, sprintf(\"../codeexport/%s/tmp/inertia_par%d_maple.m\", robot_name, codegen_dynpar):\nend if:\n# Matlab Export (nur linke untere Dreiecksmatrix bei vollständigen Matrizen)\nif codeexport_inertia and not(base_method_name=\"twist\") then\n  MM_s_vek := symmat2vec(MM_s):\n  filename_tmp := sprintf(\"../codeexport/%s/tmp/inertia_floatb_%s_par%d_maple_symvec.m\", robot_name, base_method_name, codegen_dynpar):\n  save MM_s_vek, filename_tmp:\n  read filename_tmp:\n  if codegen_act then\n    MatlabExport(MM_s_vek, sprintf(\"../codeexport/%s/tmp/inertia_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\n  end if:\nend if:\nif codegen_act and codeexport_inertia and not(base_method_name=\"twist\") then\n  MatlabExport(MM_s(7..NQ,1..6), sprintf(\"../codeexport/%s/tmp/inertia_joint_base_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\n# Gelenk-Massenmatrix.\n# Eliminiere die Basis-Orientierung. Hat keinen Einfluss auf die Matrix, wird aber noch Maple teilweise nicht automatisch entfernt, da die Ausdrücke zu kompliziert zum Optimieren sind.\nMMjj_s := MM_s(7..NQ,7..NQ):\nfor i from 1 to NQB do\n  MMjj_s := subs({X_base_s[i,1]=0},MMjj_s):\nend do:\nif codeexport_inertia then\n  MMjj_s_vek := symmat2vec(MMjj_s):\n  filename_tmp := sprintf(\"../codeexport/%s/tmp/inertia_joint_joint_floatb_%s_par%d_maple_symvec.m\", robot_name, base_method_name, codegen_dynpar):\n  save MMjj_s_vek, filename_tmp:\n  read filename_tmp:\n  if codegen_act then\n    MatlabExport(MMjj_s_vek, sprintf(\"../codeexport/%s/tmp/inertia_joint_joint_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\n  end if:\nend if:\n# Basis-Massenmatrix\nMMbb_s := MM_s(1..6,1..6):\nif codeexport_inertia and not(base_method_name=\"twist\") then\n  MMbb_s_vek := symmat2vec(MMbb_s):\n  filename_tmp := sprintf(\"../codeexport/%s/tmp/inertia_base_base_floatb_%s_par%d_maple_symvec.m\", robot_name, base_method_name, codegen_dynpar):\n  save MMbb_s_vek, filename_tmp:\n  read filename_tmp:\n  if codegen_act then\n    MatlabExport(MMbb_s_vek, sprintf(\"../codeexport/%s/tmp/inertia_base_base_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\n  end if:\nend if:\n\n# Mass Matrix Time Derivative\n# Konvertiere Massenmatrix in zeitabhängige Variablen, um Zeitableitung zu berechnen\n\nif codeexport_inertiaD then\n  read sprintf(\"../codeexport/%s/tmp/inertia_par%d_maple.m\", robot_name, codegen_dynpar):\n  MM_s := MM_s: # Annahme: Massenmatrix wurde vorher generiert.\n  MM_t := convert_s_t(MM_s):\n  MMD_t := diff~(MM_t, t):\n  MMD_s := convert_t_s(MMD_t):\n  # Terme vereinfachen\n  # Terme vereinfachen\n  if use_simplify>=3 then\n    tmp_t0:=time():\n    tmp_l0 := length(MMD_s):\n    printf(\"%s: Beginne Elementweise Vereinfachung Massenmatrix-Zeitableitung (Param. %d). Länge: %d.\\n\", \\\n      FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, tmp_l0):\n    for i to NQ do \n      for j to NQ do\n    \t   if i > j then # linke untere Dreiecksmatrix\n    \t     MMD_s[i, j] := MMD_s[j,i]: # nehme symmetrischen Teil (wurde schon vereinfacht)\n    \t     next:\n    \t   end if:\n        tmp_t1:=time():\n        tmp_l1 := length(MMD_s[i,j]):\n        printf(\"%s: Beginne Vereinfachung Massenmatrix-Zeitableitung (Param. %d; Elem. %d,%d). Länge: %d.\\n\", \\\n          FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, i, j, tmp_l1):\n        MMD_s[i,j] := simplify2(MMD_s[i,j]):\n        tmp_t2:=time():\n        tmp_l2 := length(MMD_s[i,j]):\n        printf(\"%s: Massenmatrix-Zeitableitung (Param. %d; Elem. %d,%d) vereinfacht. Länge: %d->%d. Rechenzeit %1.1fs.\\n\", \\\n          FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, i, j, tmp_l1, tmp_l2, tmp_t2-tmp_t1):\n      end do:\n    end do:\n    tmp_l2 := length(MMD_s):\n    printf(\"%s: Massenmatrix-Zeitableitung (Param. %d) vereinfacht. Länge: %d->%d. Rechenzeit %1.1fs.\\n\", \\\n      FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, tmp_l0, tmp_l2, tmp_t2-tmp_t0):\n  end if:\nend if:\n# Matlab Export\nif codeexport_inertiaD and not(base_method_name=\"twist\") then\n  MMD_s_vek := symmat2vec(MMD_s):\n  filename_tmp := sprintf(\"../codeexport/%s/tmp/inertia_time_derivative_floatb_%s_par%d_maple_symvec.m\", \\\n    robot_name, base_method_name, codegen_dynpar):\n  save MMD_s_vek, filename_tmp:\n  read filename_tmp:\n  if codegen_act then\n    MatlabExport(MMD_s_vek, sprintf(\"../codeexport/%s/tmp/inertia_time_derivative_floatb_%s_par%d_matlab.m\", \\\n      robot_name, base_method_name, codegen_dynpar), codegen_opt):\n  end if:\nend if:\n\nif codegen_act and codeexport_inertiaD and not(base_method_name=\"twist\") then\n  MatlabExport(MMD_s[7..NQ,1..6], sprintf(\"../codeexport/%s/tmp/inertia_joint_base_time_derivative_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\nMMDjj_s := MMD_s(7..NQ,7..NQ):\nfor i from 1 to NQB do\n  MMDjj_s := subs({X_base_s[i,1]=0},MMDjj_s):\nend do:\nfor i from 1 to 6 do\n  MMDjj_s := subs({V_base_s[i,1]=0},MMDjj_s):\nend do:\nif codeexport_inertiaD then\n  # Vektor der unteren linken Dreiecksmatrix generieren, speichern und wieder laden. Ohne Neuladen hängt sich maple durch einen Bug auf. TODO: Klären.\n  MMDjj_s_vek := symmat2vec(MMDjj_s):\n  filename_tmp := sprintf(\"../codeexport/%s/tmp/inertia_joint_joint_time_derivative_floatb_%s_par%d_maple_symvec.m\", robot_name, base_method_name, codegen_dynpar):\n  save MMDjj_s_vek, filename_tmp:\n  read filename_tmp:\n  if codegen_act then\n    MatlabExport(MMDjj_s_vek, sprintf(\"../codeexport/%s/tmp/inertia_joint_joint_time_derivative_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\n  end if:\nend if:\n\n\n# Coriolis Vector\n# Generiere Coriolis-Vektor aus dem Lagrange-Momenten\ntauCC_s := Matrix(NQ,1): # Platzhalter\n;\n\nif codeexport_corvec then\n  tauCC_s := dTdqDdt_s-dTdq_s:\n  for i to NQ do \n    tauCC_s := subs({qDD_s(i, 1) = 0}, tauCC_s):\n  end do:\n  # Terme vereinfachen\n  if use_simplify>=3 then\n    for i to NQ do \n      tmp_t1:=time():\n      tmp_l1 := length(tauCC_s[i,1]):\n      printf(\"%s: Beginne Vereinfachung Coriolis-Vektor (Param. %d; Elem. %d). Länge: %d.\\n\", \\\n        FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, i, tmp_l1):\n      tauCC_s[i,1] := simplify2(tauCC_s[i,1]):\n      tmp_t2:=time():\n      tmp_l2 := length(tauCC_s[i,1]):\n      printf(\"%s: Coriolis-Vektor (Param %d; Elem. %d) vereinfacht. Länge: %d->%d. Rechenzeit %1.1fs.\\n\", \\\n        FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, i, tmp_l1, tmp_l2, tmp_t2-tmp_t1):\n   end do:\n  end if:\n  save tauCC_s, sprintf(\"../codeexport/%s/tmp/coriolisvec_par%d_maple.m\", robot_name, codegen_dynpar):\nend if:\n\n# Einzelne Komponenten exportieren (falls der ganze Vektor zu lange dauert).\nif codegen_act and codeexport_corvec and not(base_method_name=\"twist\") and codegen_debug then\n  for i to NQ do \n    MatlabExport(tauCC_s(i), sprintf(\"../codeexport/%s/tmp/coriolisvec_floatb_%s_%d_par%d_matlab.m\", robot_name, base_method_name, i, codegen_dynpar), codegen_opt):\n  end do:\nend if:\n# Matlab Export: Floating base\nif codegen_act and codeexport_corvec and not(base_method_name=\"twist\") then\n  MatlabExport(tauCC_s[1..6], sprintf(\"../codeexport/%s/tmp/coriolisvec_base_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\nif codegen_act and codeexport_corvec and not(base_method_name=\"twist\") then\n  MatlabExport(tauCC_s[7..NQ], sprintf(\"../codeexport/%s/tmp/coriolisvec_joint_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\nif codegen_act and codeexport_corvec and not(base_method_name=\"twist\") then\n  MatlabExport(tauCC_s[1..NQ], sprintf(\"../codeexport/%s/tmp/coriolisvec_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\n# Matlab Export: Fixed base\ntauCC_s_fixb:=tauCC_s:\nfor i from 1 to NQB do\n  tauCC_s_fixb := subs({X_base_s[i,1]=0},tauCC_s_fixb):\nend do:\nfor i from 1 to 6 do\n  tauCC_s_fixb := subs({V_base_s[i,1]=0},tauCC_s_fixb):\nend do:\nif codegen_act and codeexport_corvec then\n  MatlabExport(tauCC_s_fixb[7..NQ], sprintf(\"../codeexport/%s/tmp/coriolisvec_joint_fixb_par%d_matlab.m\", robot_name, codegen_dynpar), codegen_opt):\nend if:\n\n# Coriolis Matrix\n# Calculation with Christoffel Symbol approach\n# [KhalilDombre2002], equ. (9.7) (p. 195)\n\ncijk := proc (i::integer, j::integer, k::integer, A, qs)\n  local c:\n  c := (1/2)*(diff(A[i, j], qs(k, 1)))+(1/2)*(diff(A[i, k], qs(j, 1)))-(1/2)*(diff(A[j, k], qs(i, 1))):\n  return c:\nend proc:\n\nif codeexport_cormat then\n  read sprintf(\"../codeexport/%s/tmp/inertia_par%d_maple.m\", robot_name, codegen_dynpar):\n  MM_s := MM_s: # Annahme: Massenmatrix wurde vorher generiert.\n  Cqs:=Matrix(NQ,NQ): \n  for i  from 1 to NQ do\n    for j from 1 to NQ do\n      Cqs[i,j]:=0:\n      for k from 1 to NQ do\n        Cqs[i,j]:=Cqs[i,j]+cijk(i,j,k,MM_s,q_s)*qD_s[k,1]:\n      end do:\n    end do:\n  end do:\n  # Terme vereinfachen\n  if use_simplify>=2 then\n    tmp_t1:=time():\n    tmp_l1 := length(Cqs):\n    printf(\"%s: Beginne Vereinfachung Coriols-Matrix (Param. %d). Länge: %d.\\n\", \\\n      FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, tmp_l1):\n    Cqs := simplify2(Cqs):\n    tmp_t2:=time():\n    tmp_l2 := length(Cqs):\n    printf(\"%s: Coriolis-Matrix vereinfacht (Param. %d). Länge: %d->%d. Rechenzeit %1.1fs.\\n\", \\\n      FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, tmp_l1, tmp_l2, tmp_t2-tmp_t1):\n  end if:\nend if:\n\n# Matlab Export: Floating base\nif codegen_act and codeexport_cormat and not(base_method_name=\"twist\") then\n  MatlabExport(Cqs[1..NQ,1..NQ], sprintf(\"../codeexport/%s/tmp/coriolismat_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\nif codegen_act and codeexport_cormat and not(base_method_name=\"twist\") then\n  MatlabExport(Cqs[7..NQ,1..NQ], sprintf(\"../codeexport/%s/tmp/coriolismat_joint_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\n# Matlab Export: Fixed base\nCqs_fixb:=Cqs:\nif codeexport_cormat then\n  for i from 1 to NQB do\n    Cqs_fixb := subs({X_base_s[i,1]=0},Cqs_fixb):\n  end do:\n  for i from 1 to 6 do\n    Cqs_fixb := subs({V_base_s[i,1]=0},Cqs_fixb):\n  end do:\nend if:\nif codegen_act and codeexport_cormat then\n  MatlabExport(Cqs_fixb[7..NQ,7..NQ], sprintf(\"../codeexport/%s/tmp/coriolismat_joint_fixb_par%d_matlab.m\", robot_name, codegen_dynpar), codegen_opt):\nend if:\n\n\n# Joint Torques\n\nif codeexport_invdyn then\n  tau := dTdqDdt_s-dTdq_s+dUdq_s:\n  # Terme vereinfachen\n  if use_simplify>=3 then\n    tmp_t1:=time():\n    tmp_l1 := length(tau):\n    printf(\"%s: Beginne Vereinfachung Invers-Dynamik (Param. %d). Länge: %d.\\n\", \\\n      FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, tmp_l1):\n    tau := simplify2(tau):\n    tmp_t2:=time():\n    tmp_l2 := length(tau):\n    printf(\"%s: Invers-Dynamik (Param. %d) vereinfacht. Länge: %d->%d. Rechenzeit %1.1fs.\\n\", \\\n      FormatTime(\"%Y-%m-%d %H:%M:%S\"), codegen_dynpar, tmp_l1, tmp_l2, tmp_t2-tmp_t1):\n  end if:\nend if:\n# Matlab Export: Floating base\n# Berechnung der Basis-Belastung ist für manche Basis-Darstellungen falsch (siehe oben unter Gravitationslast).\nif codegen_act and codeexport_invdyn and not(base_method_name=\"twist\") then\n  MatlabExport(tau, sprintf(\"../codeexport/%s/tmp/invdyn_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\nif codegen_act and codeexport_invdyn and not(base_method_name=\"twist\") then\n  MatlabExport(tau[1..6], sprintf(\"../codeexport/%s/tmp/invdyn_base_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\nif codegen_act and codeexport_invdyn and not(base_method_name=\"twist\") then\n  MatlabExport(tau[7..NQ], sprintf(\"../codeexport/%s/tmp/invdyn_joint_floatb_%s_par%d_matlab.m\", robot_name, base_method_name, codegen_dynpar), codegen_opt):\nend if:\n# Matlab Export: Fixed base\nif codegen_act and codeexport_invdyn then\n  taus_fixb:=tau:\n  for i from 1 to NQB do\n    taus_fixb := subs({X_base_s[i,1]=0},taus_fixb):\n  end do:\n  for i from 1 to 6 do\n    taus_fixb := subs({V_base_s[i,1]=0},taus_fixb):\n    taus_fixb := subs({VD_base_s[i,1]=0},taus_fixb):\n  end do:\n  save taus_fixb, sprintf(\"../codeexport/%s/tmp/invdyn_fixb_par%d_maple.m\", robot_name, codegen_dynpar):\nend if:\nif codegen_act and codeexport_invdyn then\n  MatlabExport(taus_fixb[7..NQ], sprintf(\"../codeexport/%s/tmp/invdyn_fixb_par%d_matlab.m\", robot_name, codegen_dynpar), codegen_opt):\nend if:\n\n\n", "meta": {"hexsha": "7adb4bdc8373e3611dc969a5064f28b659800e7e", "size": 19929, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "robot_codegen_dynamics/robot_tree_floatb_rotmat_dynamics_worldframe_par12.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_dynamics/robot_tree_floatb_rotmat_dynamics_worldframe_par12.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_dynamics/robot_tree_floatb_rotmat_dynamics_worldframe_par12.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.2931818182, "max_line_length": 198, "alphanum_fraction": 0.724772944, "num_tokens": 6503, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.7799929002541068, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.4768735985127838}}
{"text": "cdir := \"/home/scott/Documents/research/software/hqca/hqca/maple/\":\nwith(LinearAlgebra):\nwith(QuantumChemistry):\nloaddata := readdata(cat(cdir, \"h4_qc_spatial.rdm\"), 6):\nFlatten := proc(x) local n, a, i, j, k, l; `local`(a, n, i, j, k, l); `description`(\"convert chemists to numpy and flatten an array to form a matrix\"); n := Size(x); a := Matrix(1 .. n[1]*n[2], 1 .. n[3]*n[4], datatype = float[8]); for i to n[1] do for j to n[2] do for k to n[3] do for l to n[4] do a[(i - 1)*n[1] + j, (k - 1)*n[3] + l] := x[i, k, j, l]; end do; end do; end do; end do; return a; end proc:  \nNew := Array(1 .. 4, 1 .. 4, 1 .. 4, 1 .. 4, datatype = float[8]):\nfor i in loaddata[3 .. ()] do\n    New[round(i[1]), round(i[3]), round(i[2]), round(i[4])] := i[5];\nend do;\npure := Purify2RDM(New, spin_free = true, electron_number = 4, conv_tol = 0.10000000):\nExportMatrix(cat(cdir, \"h4_qc_spatial_pure.csv\"), Flatten(pure[rdm2]));\n\n", "meta": {"hexsha": "933cb5640e5d3f8e64d80e97eef344983f443766", "size": 914, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "hqca/maple/old/spatial_input.mpl", "max_stars_repo_name": "damazz/HQCA", "max_stars_repo_head_hexsha": "b013ba68f86e42350913c4abc2e1c91695a429b7", "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": "hqca/maple/old/spatial_input.mpl", "max_issues_repo_name": "damazz/HQCA", "max_issues_repo_head_hexsha": "b013ba68f86e42350913c4abc2e1c91695a429b7", "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": "hqca/maple/old/spatial_input.mpl", "max_forks_repo_name": "damazz/HQCA", "max_forks_repo_head_hexsha": "b013ba68f86e42350913c4abc2e1c91695a429b7", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-08-10T00:20:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-10T00:20:09.000Z", "avg_line_length": 70.3076923077, "max_line_length": 409, "alphanum_fraction": 0.6072210066, "num_tokens": 363, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430478583169, "lm_q2_score": 0.5736784074525096, "lm_q1q2_score": 0.4768088200605843}}
{"text": "\n# Parameter Regressor Inverse Dynamics for Robot-Base\n# Einleitung\n# Berechnung der inversen Dynamik der Roboter-Plattform in Regressorform\n# \n# Dateiname:\n# robot -> Berechnung für allgemeinen Roboter\n# para -> Berechnung für eine parallelen Roboter\n# rotmat -> Kinematik wird mit Rotationsmatrizen berechnet\n# dynamics -> Berechnung der Dynamik\n# regressor -> Regressorform (parameterlinear)\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# [Abdel2007] Modellierung, Identifikation und robuste Regelung von Robotern mit parallelkinematischen Strukturen\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):\n#with(ArrayTools):\nwith(codegen):\nwith(CodeGeneration):\nwith(StringTools):\nwith(VectorCalculus):\n# Einstellungen für Code-Export: Optimierungsgrad (2=höchster) und Aktivierung jedes Terms.\ncodegen_opt := 2:\ncodeexport_invdyn := false:\ncodeexport_grav := false: \ncodeexport_corvec := false:\ncodeexport_inertia := false:\nread \"../helper/proc_convert_s_t\":\nread \"../helper/proc_convert_t_s\": \nread \"../helper/proc_MatlabExport\":\nread \"../helper/proc_index_symmat2vector\":\nread \"../helper/proc_symmat2vector\":\nread \"../helper/proc_skew2vec\":\nread \"../helper/proc_vec2skew\":\nread \"../helper/proc_combine2\":\nread \"../transformation/proc_rotx\": \nread \"../transformation/proc_roty\": \nread \"../transformation/proc_rotz\": \nread \"../transformation/proc_trotx\": \nread \"../transformation/proc_troty\": \nread \"../transformation/proc_trotz\": \nread \"../transformation/proc_transl\": \nread \"../transformation/proc_trafo_mdh\": \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# Definitionen für parallelen Roboter laden\nread sprintf(\"../codeexport/%s/tmp/para_definitions\", robot_name):\nr_P_sP_P := -r_P_sP:\ns_P_P_sP := s_P_sP:\n# Ergebnisse der Kinematik für parallen Roboter laden\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:\nP_i := P_i: # nur diese Variable wird benötigt. Alle anderen zur Übersichtlichkeit löschen. Enthält Informationen zu den Koppelpunkten.\nunassign('pivotMat', 'pivotMatMas', 'Jinv', 'JB_i', 'JBD_i', 'JBinv_i', 'JBDinv_i', 'U_i', 'UD_i'):\n\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, angleConvLeg)):\n\n# Additional Kinematics\n# Berechnung der Rotationsmatrizen\nR_0_0_E_t := parse(sprintf(\"eul%s2r\",angleConvLeg))(xE_t(4..6)):\nR_0_0_E_s := parse(sprintf(\"eul%s2r\",angleConvLeg))(xE_s(4..6)):\nRPYjac_0_t := parse(sprintf(\"eul%sjac\",angleConvLeg))(xE_t(4..6)):\nRPYjac_0_s := parse(sprintf(\"eul%sjac\",angleConvLeg))(xE_s(4..6)):\nr_0_sP_P := R_0_0_E_s.r_P_sP_P:\nJ_P_P := J_P_P:\nJ_0_P := R_0_0_E_s.J_P_P.Transpose(R_0_0_E_s):\nJ_0_P_raute := Matrix(6,1,[J_0_P(1,1),J_0_P(1,2),J_0_P(1,3),J_0_P(2,2),J_0_P(2,3),J_0_P(3,3)]):\nJ_P_P_raute := Matrix(6,1,[J_P_P(1,1),J_P_P(1,2),J_P_P(1,3),J_P_P(2,2),J_P_P(2,3),J_P_P(3,3)]):\n\nr_0_sP_P := R_0_0_E_t.r_P_sP_P:\nr_0_P_sP := -r_0_sP_P:\n#rD_0_sP_P := diff~(r_0_sP_P,t):\n#for i to 3 do\n  # for j to 6 do\n      #rD_0_sP_P(i) := subs({xED_t(j)=xED_s(j),xE_t(j)=xE_s(j)},rD_0_sP_P(i)):\n   #end do:\n#end do:\n#rD_0_sP_P:\nr_0_sP_P := R_0_0_E_s.r_P_sP_P:\nr_0_P_sP := -r_0_sP_P:\nr_P_P_sP := -r_P_sP_P:\n#sE := Matrix(mE*r_0_P_sP):\n#sE := Matrix(mE*r_P_P_sP):\nsE := s_P_P_sP:\n\n# Berechnung der H-Matrix und deren Ableitung nach [Abdel2007] S.20\nRPYjac_E_t := simplify(Multiply(Transpose(R_0_0_E_t),RPYjac_0_t)):\nRPYjac_E_s := simplify(Multiply(Transpose(R_0_0_E_s),RPYjac_0_s)):\nw_E_0_E_s := RPYjac_E_s.xED_s(4..6,1):\nw_0_0_E_s := RPYjac_0_s.xED_s(4..6,1):\nw_E_0_E_t := RPYjac_E_t.xED_t(4..6,1):\ndRPYjac_E_t := diff~(RPYjac_E_t,t):\ndRPYjac_0_t := diff~(RPYjac_0_t,t):\ndRPYjac_E_s := Copy(dRPYjac_E_t):\ndRPYjac_0_s := Copy(dRPYjac_0_t):\n# Substituiere die zeitabhängigen Koordinaten in der H-Matrix mit zeitunabhängigen Koordinaten \nfor i to 3 do\n  for j to 3 do\n    for k from 4 to 6 do\n      dRPYjac_E_s(i,j) := subs({xEDD_t(k)=xEDD_s(k),xED_t(k)=xED_s(k),xE_t(k)=xE_s(k)},dRPYjac_E_s(i,j)):\n      dRPYjac_0_s(i,j) := subs({xEDD_t(k)=xEDD_s(k),xED_t(k)=xED_s(k),xE_t(k)=xE_s(k)},dRPYjac_0_s(i,j)):\n    end do:\n  end do:\nend do:\n\nomegaE := <omega1;omega2;omega3>:\nxED_dummy := <xE,yE,zE>:\nomega0 := Transpose(R_0_0_E_s).omegaE:\n<xED_dummy;omegaE>:\nJR := Jacobian(convert(omega0,list),convert(<xED_dummy;omegaE>,list)):\nJR_T := Transpose(JR):\nvel0 := Transpose(R_0_0_E_s).xED_dummy:\nJT := Jacobian(convert(vel0,list),convert(<xED_dummy;omegaE>,list)):\nJT_T := Transpose(JT):\n\nwD_E_0_E_s := dRPYjac_E_s.xED_s(4..6,1)+RPYjac_E_s.xEDD_s(4..6,1):\nwD_0_0_E_s := dRPYjac_0_s.xED_s(4..6,1)+RPYjac_0_s.xEDD_s(4..6,1):\n# Trigonometrische Ausdrücke zusammenfassen.\nw_E_0_E_s := combine2(w_E_0_E_s):\nwD_E_0_E_s := combine2(wD_E_0_E_s):\n\nH := <IdentityMatrix(3,3),ZeroMatrix(3);\n      ZeroMatrix(3),RPYjac_0_s>:\n\nHinv := MatrixInverse(H):\ndH := <ZeroMatrix(3),ZeroMatrix(3);\n      ZeroMatrix(3),dRPYjac_0_s>:\n\na_E := Matrix(xEDD_s(1..3,1)) - g_world:\na_E := Transpose(R_0_0_E_s).(Matrix(xEDD_s(1..3,1)) - g_world):\nw_0_0_E_s_stern := Matrix(3,6,[w_0_0_E_s(1),w_0_0_E_s(2),w_0_0_E_s(3),0,0,0, \\\n                               0,w_0_0_E_s(1),0,w_0_0_E_s(2),w_0_0_E_s(3),0, \\\n                               0,0,w_0_0_E_s(1),0,w_0_0_E_s(2),w_0_0_E_s(3)]):\nwD_0_0_E_s_stern := Matrix(3,6,[wD_0_0_E_s(1),wD_0_0_E_s(2),wD_0_0_E_s(3),0,0,0,\\\n                                0,wD_0_0_E_s(1),0,wD_0_0_E_s(2),wD_0_0_E_s(3),0,\\\n                                0,0,wD_0_0_E_s(1),0,wD_0_0_E_s(2),wD_0_0_E_s(3)]):\nw_E_0_E_s_stern := Matrix(3,6,[w_E_0_E_s(1),w_E_0_E_s(2),w_E_0_E_s(3),0,0,0,\\\n                               0,w_E_0_E_s(1),0,w_E_0_E_s(2),w_E_0_E_s(3),0,\\\n                               0,0,w_E_0_E_s(1),0,w_E_0_E_s(2),w_E_0_E_s(3)]):\nwD_E_0_E_s_stern := Matrix(3,6,[wD_E_0_E_s(1),wD_E_0_E_s(2),wD_E_0_E_s(3),0,0,0,\\\n                                0,wD_E_0_E_s(1),0,wD_E_0_E_s(2),wD_E_0_E_s(3),0,\\\n                                0,0,wD_E_0_E_s(1),0,wD_E_0_E_s(2),wD_E_0_E_s(3)]):\nparamVecP_old := <J_0_P_raute;sE;mE>:\nparamVecP_old := <J_P_P_raute;sE;mE>:\nparamVecP := <J_0_P_raute;sE;mE>:\nparamVecP := <J_P_P_raute;sE;mE>:\nparamVecP_M := Copy(paramVecP):\n# Hierdurch (u.a.?) werden die Massen am Ende der Beinkette mit den Dynamikparametern der Plattform zusammengefasst\ntmp := Matrix(10,1):\nfor i to N_LEGS do\n  tmpSt := M(NQJ_parallel+1,1)*Multiply(Transpose(vec2skew(P_i(1..3,i))),vec2skew(P_i(1..3,i))):\n  tmpSt_raute := Matrix(6,1,[tmpSt(1,1),tmpSt(1,2),tmpSt(1,3),tmpSt(2,2),tmpSt(2,3),tmpSt(3,3)]):\n  tmp := <tmpSt_raute,M(NQJ_parallel+1,1)*P_i(1..3,i),M(NQJ_parallel+1,1)>:\n  paramVecP_M := paramVecP_M + tmp:\nend do:\n# Trigonometrische Ausdrücke zusammenfassen.\nwD_E_0_E_s_stern := combine2(wD_E_0_E_s_stern):\n\nA_E := <JT_T|JR_T>.<ZeroMatrix(3,6),vec2skew(wD_E_0_E_s)+Multiply(vec2skew(w_E_0_E_s),vec2skew(w_E_0_E_s)),a_E;\n        wD_E_0_E_s_stern + Multiply(vec2skew(w_E_0_E_s),w_E_0_E_s_stern),-vec2skew(a_E),ZeroMatrix(3,1)>:\n# Term-Vereinfachungen vornehmen: Im planaren Fall kommt sin²+cos² vor.\n# Im räumlichen Fall ist die Vereinfachung nachteilig. Dann wird der Term so gelassen.\nA_E := combine2(A_E):\n\n# Mass Matrix\n# \nM_regmin := <JT_T|JR_T>.<ZeroMatrix(3,6),vec2skew(wD_E_0_E_s),Transpose(R_0_0_E_s).Matrix(xEDD_s(1..3,1));\n             wD_E_0_E_s_stern,-vec2skew(Transpose(R_0_0_E_s).Matrix(xEDD_s(1..3,1))),ZeroMatrix(3,1)>:\nMM_regmin := Matrix(6*6, RowDimension(paramVecP)):\n\ni_rr := 0:\nfor i to 6 do # Zeilenindex der Massenmatrix\n  for j to 6 do  # Spaltenindex der Massenmatrix\n    i_rr := i_rr + 1: # Gehe zeilenweise durch den unteren linken Teil der Massenmatrix (inkl. Diagonale)\n    for k to RowDimension(paramVecP) do # Spaltenindex der Regressormatrix\n    \t if not(xEDD_s[j, 1] = 0) then\n        MM_regmin[i_rr, k] := diff(M_regmin[i, k], xEDD_s[j, 1]):\n      else\n        MM_regmin[i_rr, k] := 0:\n      end if:\n    end do:\n  end do:\nend do:\n# Term-Vereinfachungen vornehmen: Im planaren Fall kommt sin²+cos² vor:\nMM_regmin := combine2(MM_regmin):\n\n# Coriolis Vector\n# Nur Fliehkraft-Komponente aus Gesamtkraft.\nc_regmin := <JT_T|JR_T>.<ZeroMatrix(3,6),Multiply(vec2skew(w_E_0_E_s),vec2skew(w_E_0_E_s)),ZeroMatrix(3,1);\n             Multiply(vec2skew(w_E_0_E_s),w_E_0_E_s_stern),ZeroMatrix(3,3),ZeroMatrix(3,1)>:\n\n# Gravitional Vector\n# Gravitationskomponente aus Gesamtkraft.\ng_regmin := <JT_T|JR_T>.<ZeroMatrix(3,6),ZeroMatrix(3,3),-Transpose(R_0_0_E_s).g_world;\n             ZeroMatrix(3,6),-vec2skew(-Transpose(R_0_0_E_s).g_world),ZeroMatrix(3,1)>:\n\n# Code Export\n# Matlab\nif codeexport_invdyn then\n  MatlabExport(A_E, sprintf(\"../codeexport/%s/tmp/invdyn_floatb_%s_platform_matlab.m\", robot_name, base_method_name), codegen_opt):\n  MatlabExport(M_regmin, sprintf(\"../codeexport/%s/tmp/invdyn_floatb_%s_Mplatform_matlab.m\", robot_name, base_method_name), codegen_opt):\n  MatlabExport(MM_regmin, sprintf(\"../codeexport/%s/tmp/invdyn_floatb_%s_MMplatform_matlab.m\", robot_name, base_method_name), codegen_opt):\n  MatlabExport(c_regmin, sprintf(\"../codeexport/%s/tmp/invdyn_floatb_%s_cplatform_matlab.m\", robot_name, base_method_name), codegen_opt):\n  MatlabExport(g_regmin, sprintf(\"../codeexport/%s/tmp/invdyn_floatb_%s_gplatform_matlab.m\", robot_name, base_method_name), codegen_opt):\nend if:\n\n# Maple-Export\nsave paramVecP, paramVecP_M, A_E, M_regmin, c_regmin, g_regmin, H, dH, sprintf(\"../codeexport/%s/tmp/floatb_%s_platform_dynamic_reg_maple.m\", robot_name, base_method_name):\n\n", "meta": {"hexsha": "dd6d2b3bd692410ffb41cadb28a7e3034a358c15", "size": 10531, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "robot_codegen_parallel/robot_para_plattform_rotmat_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_plattform_rotmat_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_plattform_rotmat_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.5887445887, "max_line_length": 172, "alphanum_fraction": 0.7202544868, "num_tokens": 4004, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031737869342624, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.4760142774745638}}
{"text": "#@ Not autoload\n\n# 3-stem\nSpherePi(5,2) := [[2,o(eta[2],eta[3],eta[4])]]:\n\n# NB nuprime is usually only defined at p=2. \n# Presumably we get a generator from the unstable J-map?\nSpherePi(6,3) := [[12,nuprime]]: \n\nSpherePi(7,4) := [[infinity,nu[4]],[12,E(nuprime)]]:\n\nfor i from 5 to 20 do \n SpherePi(i+3,i) := [[24,nu[i]]]:\nod:\n\n# 4-stem\nSpherePi(6,2) := [[12,o(eta[2],nuprime)]]:\nSpherePi(7,3) := [[2,o(nuprime,eta[6])]]:\nSpherePi(8,4) := [[2,o(nu[4],eta[7])],[2,o(E(nuprime),eta[7])]]:\nSpherePi(9,5) := [[2,o(nu[5],eta[8])]]:\n\nfor i from 6 to 20 do\n SpherePi(i+4,i) := []:\nod:\n\n# 5-stem\n\nSpherePi(7, 2) := [[2,o(eta[2],nuprime,eta[6])]]:\nSpherePi(8, 3) := [[2,o(nuprime,eta[6],eta[7])]]:\nSpherePi(9, 4) := [[2,o(nu[4],eta[7],eta[8])],\n                   [2,o(E(nuprime),eta[7],eta[8])]]:\nSpherePi(10, 5) := [[2,o(nu[5],eta[8],eta[9])]]:\nSpherePi(11, 6) := [[infinity,w[6]]]:\n\nfor i from 7 to 20 do \n SpherePi(i+5,i) := []:\nod:\n\n# 6-stem\n\nSpherePi(8, 2) := [[2,o(eta[2],nuprime,eta[6],eta[7])]]:\nSpherePi(9, 3) := []:\nSpherePi(10, 4) := [[24,o(nu[4],nu[7])],3]:\n\nfor i from 5 to 20 do\n SpherePi(i+6,i) := [[2,o(nu[i],nu[i+3])]]:\nod:\n\n# 7-stem\n\nSpherePi( 9, 2) := [3]:\nSpherePi(10, 3) := [15]:\nSpherePi(11, 4) := [15]:\nSpherePi(12, 5) := [30]:\nSpherePi(13, 6) := [60]:\nSpherePi(14, 7) := [120]:\nSpherePi(15, 8) := [[infinity,sigma[8]],120]:\n\nfor i from 9 to 20 do\n SpherePi(i+7,i) := [[240,sigma[i]]]:\nod:\n\n# 8-stem\n\nSpherePi(10, 2) := [15]:\nSpherePi(11, 3) := [[2,epsilon[3]]]:\nSpherePi(12, 4) := [[2,epsilon[4]]]:\nSpherePi(13, 5) := [[2,epsilon[5]]]:\nSpherePi(14, 6) := [[2,epsilon[6]],[24,nubar[6]]]:\nSpherePi(15, 7) := [[2,epsilon[7]],[2,nubar[7]],[2,o(sigmaprime,eta[14])]]:\nSpherePi(16, 8) := [[2,epsilon[8]],\n                    [2,nubar[8]],\n                    [2,o(E(sigmaprime),eta[15])],\n                    [2,o(sigma[8],eta[15])]]:\nSpherePi(17, 9) := [[2,epsilon[9]],\n                    [2,nubar[9]],\n                    [2,o(sigma[9],eta[16])]]:\n", "meta": {"hexsha": "5a6db7a381ff96244064868796015ba5cadfe56e", "size": 1962, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/chromatic/TodaGlobal.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/chromatic/TodaGlobal.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/chromatic/TodaGlobal.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": 25.1538461538, "max_line_length": 75, "alphanum_fraction": 0.5117227319, "num_tokens": 873, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789178257654, "lm_q2_score": 0.5851011542032312, "lm_q1q2_score": 0.4742121502772411}}
{"text": "make_ico_oct_complex := proc()\n global ico_oct_complex, ico_oct_complex1;\n local n,T,T0,T1,m,v,w,vo,vi,i,j,k,E,F,e,f,nm;\n\n n := 102;\n T[\"vertices\"] := [seq(i,i=1..n)];\n T[\"embedding_dim\"] := 3;\n\n m := (i,j) -> 3 + 20 * i + modp(j,20):\n v := table():\n \n v[1] := [0,0,1]:\n v[2] := [0,0,-1]:\n\n for i from 0 to 19 do \n  v[m(0,i)] := evalf([cos(Pi*i/10)  ,sin(Pi*i/10)  , 2] /~ sqrt(5));\n  v[m(2,i)] := evalf([cos(Pi*i/10)  ,sin(Pi*i/10)  , 0]);\n  v[m(4,i)] := evalf([cos(Pi*i/10)  ,sin(Pi*i/10)  ,-2] /~ sqrt(5));\n od:\n\n for i from 0 to 4 do \n  v[m(1,4*i)]   := evalf([cos(Pi*4*i/10)*2,sin(Pi*4*i/10)*2, 1] /~ sqrt(5));\n  v[m(3,4*i+2)] := evalf([cos(Pi*(4*i+2)/10)*2,sin(Pi*(4*i+2)/10)*2, -1] /~ sqrt(5));\n od:\n\n nm := (x) -> x /~ sqrt(add(x[i]^2,i=1..3));\n \n for i from 0 to 4 do\n  v[m(1,4*i+2)] := nm(v[m(1,4*i  )] +~ v[m(1,4*i+4)]);\n  v[m(3,4*i  )] := nm(v[m(3,4*i-2)] +~ v[m(3,4*i+2)]);\n od:\n \n for i from 0 to 4 do\n  v[m(1,4*i+1)] := nm(v[m(1,4*i  )] +~ v[m(1,4*i+2)]);\n  v[m(1,4*i+3)] := nm(v[m(1,4*i+2)] +~ v[m(1,4*i+4)]);\n  v[m(3,4*i+1)] := nm(v[m(3,4*i  )] +~ v[m(3,4*i+2)]);\n  v[m(3,4*i+3)] := nm(v[m(3,4*i+2)] +~ v[m(3,4*i+4)]);\n od:\n \n vo := table():\n for i from 1 to n do\n  vo[i] := v[i] /~ `+`(op(map(abs,v[i])));\n od:\n \n T[\"embedding\"] := eval(v);\n T[\"sphere_embedding\"] := eval(v);\n T[\"octahedron_embedding\"] := eval(vo);\n T[\"normal\"] := copy(v);\n \n E := [\n  seq([ 1  , m(0,i)],i=0..19),\n  seq(seq([m(j,i),m(j+1,i)],i=0..19),j=0..3),\n  seq([m(4,i),2],i=0..19),\n  seq(seq([m(j,i),m(j,i+1)],i=0..19),j=0..4),\n  seq([m(0,i),m(1,i+1)],i=1..19,2),\n  seq([m(0,i),m(1,i-1)],i=1..19,2),\n  seq([m(1,i+1),m(2,i)],i=1..19,2),\n  seq([m(1,i-1),m(2,i)],i=1..19,2),\n  seq([m(2,i),m(3,i+1)],i=1..19,2),\n  seq([m(2,i),m(3,i-1)],i=1..19,2),\n  seq([m(3,i+1),m(4,i)],i=1..19,2),\n  seq([m(3,i-1),m(4,i)],i=1..19,2),\n  NULL\n ]:\n\n E := sort([op(map(e -> sort([op(e)]),E))]);\n \n T[\"edges\"] := E;\n \n F := NULL;\n for e in T[\"edges\"] do\n  i,j := op(e);\n  for k from max(i,j)+1 to n do\n   if k <> i and k <> j and member([i,k],E) and member([j,k],E) then\n    F := F,[i,j,k];\n   fi;\n  od:\n od:\n\n F := [F];\n T[\"faces\"] := F;\n T[\"max_simplices\"] := T[\"faces\"];\n\n T[\"octahedron_edges\"] := [\n  seq([ 1  , m(0,i)],i=0..19,5),\n  seq(seq([m(j,i),m(j+1,i)],i=0..19,5),j=0..3),\n  seq([m(4,i),2],i=0..19,5),\n  seq([m(2,i),m(2,i+1)],i=0..19),\n  NULL\n ]:\n\n T[\"octahedron_edges\"] := sort(map(sort,T[\"octahedron_edges\"])):\n \n T[\"octahedron_basic_vertices\"] :=\n  sort([1,2,m(2,0),m(2,5),m(2,10),m(2,15)]);\n  \n T[\"octahedron_basic_edges\"] := [\n  seq([1,m(2,5*i)],i=0..3),\n  seq([m(2,5*i),m(2,5*(i+1))],i=0..3),\n  seq([m(2,5*i),2],i=0..3)\n ]:\n\n T[\"octahedron_basic_edges\"] := sort(map(sort,T[\"octahedron_basic_edges\"])):\n\n T[\"octahedron_basic_faces\"] := [\n  seq([1,m(2,5*i),m(2,5*(i+1))],i=0..3),\n  seq([2,m(2,5*i),m(2,5*(i+1))],i=0..3)\n ]:\n\n T[\"octahedron_basic_faces\"] := sort(map(sort,T[\"octahedron_basic_faces\"])):\n\n T[\"icosahedron_edges\"] := [\n  seq([ 1  , m(0,4*i)],i=0..4),\n  seq([m(0,4*i),m(1,4*i)],i=0..4),\n  seq([m(1,4*i),m(2,4*i+1)],i=0..4),\n  seq([m(1,4*i),m(2,4*i-1)],i=0..4),\n  seq([m(2,4*i+1),m(3,4*i+2)],i=0..4),\n  seq([m(2,4*i-1),m(3,4*i-2)],i=0..4),\n  seq([m(3,4*i+2),m(4,4*i+2)],i=0..4),\n  seq([m(4,4*i+2),2],i=0..4),\n  seq([m(1,i),m(1,i+1)],i=0..19),\n  seq([m(3,i),m(3,i+1)],i=0..19),\n  NULL\n ]:\n\n T[\"icosahedron_edges\"] := sort(map(sort,T[\"icosahedron_edges\"])):\n\n T[\"icosahedron_basic_vertices\"] :=\n  sort([1,2,seq(m(1,4*i),i=0..4),seq(m(3,4*i+2),i=0..4)]);\n  \n T[\"icosahedron_basic_edges\"] := [\n  seq([ 1  , m(1,4*i)],i=0..4),\n  seq([m(1,4*i),m(3,4*i+2)],i=0..4),\n  seq([m(1,4*i),m(3,4*i-2)],i=0..4),\n  seq([m(3,4*i+2),2],i=0..4),\n  seq([m(1,4*i),m(1,4*(i+1))],i=0..4),\n  seq([m(3,4*i+2),m(3,4*i-2)],i=0..4),\n  NULL\n ]:\n\n T[\"icosahedron_basic_edges\"] := sort(map(sort,T[\"icosahedron_basic_edges\"])):\n\n T[\"icosahedron_basic_faces\"] := [\n  seq([1,m(1,4*i),m(1,4*(i+1))],i=0..4),\n  seq([m(1,4*i),m(3,4*i+2),m(1,4*i+4)],i=0..4),\n  seq([m(3,4*i-2),m(1,4*i),m(3,4*i+2)],i=0..4),\n  seq([2,m(3,4*i+2),m(3,4*i-2)],i=0..4),\n  NULL\n ]:\n\n T[\"icosahedron_basic_faces\"] := sort(map(sort,T[\"icosahedron_basic_faces\"])):\n\n w := table():\n\n for k from 1 to 20 do \n  f := T[\"icosahedron_basic_faces\"][k];\n  w[k] := (v[f[1]] +~ v[f[2]] +~ v[f[3]]) /~ 3;\n  w[k] := w[k] /~ add(w[k][i]^2,i=1..3);\n od:\n \n T[\"icosahedron_forms\"] := eval(w):\n\n T[\"icosahedron_norm\"] := (x) ->\n  max(seq(add(x[i]*w[j][i],i=1..3),j=1..20));\n\n vi := table():\n\n for i from 1 to n do\n  vi[i] := v[i] /~ T[\"icosahedron_norm\"](v[i]);\n od:\n\n T[\"icosahedron_embedding\"] := eval(vi);\n\n ico_oct_complex := eval(T):\n\n return eval(T);\nend:\n\n`subdivide/ico_oct_complex` := proc(T)\n local T0,T1,ix,n0,V0,i,x;\n \n T0 := `triangular_subdivision/simplicial_complex`(T):\n `normalise_embedding/simplicial_complex`(T0):\n T0[\"normal\"] := copy(T0[\"embedding\"]):\n\n T0[\"octahedron_edges\"]  := select(e -> nops(e[1]) = 1 and member(e[2],T[\"octahedron_edges\"] ),T0[\"edges\"]):\n T0[\"icosahedron_edges\"] := select(e -> nops(e[1]) = 1 and member(e[2],T[\"icosahedron_edges\"]),T0[\"edges\"]):\n ix := table():\n V0 := T0[\"vertices\"]:\n n0 := nops(V0):\n for i from 1 to n0 do ix[V0[i]] := i; od:\n T1 := table():\n T1[\"vertices\"] := [seq(i,i=1..n0)]:\n T1[\"edges\"] := map(e -> [ix[e[1]],ix[e[2]]],T0[\"edges\"]):\n T1[\"faces\"] := map(f -> [ix[f[1]],ix[f[2]],ix[f[3]]],T0[\"faces\"]):\n T1[\"max_simplices\"] := T1[\"faces\"]:\n T1[\"octahedron_edges\"]  := map(e -> [ix[e[1]],ix[e[2]]],T0[\"octahedron_edges\"]):\n T1[\"icosahedron_edges\"] := map(e -> [ix[e[1]],ix[e[2]]],T0[\"icosahedron_edges\"]):\n T1[\"octahedron_basic_vertices\"]  := T[\"octahedron_basic_vertices\"]:\n T1[\"octahedron_basic_edges\"]     := T[\"octahedron_basic_edges\"]:\n T1[\"octahedron_basic_faces\"]     := T[\"octahedron_basic_faces\"]:\n T1[\"icosahedron_basic_vertices\"] := T[\"icosahedron_basic_vertices\"]:\n T1[\"icosahedron_basic_edges\"]    := T[\"icosahedron_basic_edges\"]:\n T1[\"icosahedron_basic_faces\"]    := T[\"icosahedron_basic_faces\"]:\n\n T1[\"icosahedron_forms\"] := copy(T[\"icosahedron_forms\"]):\n T1[\"icosahedron_norm\"]  := copy(T[\"icosahedron_norm\"]):\n\n T1[\"embedding_dim\"] := 3:\n T1[\"embedding\"] := table():\n T1[\"normal\"] := table():\n T1[\"sphere_embedding\"]      := table():\n T1[\"octahedron_embedding\" ] := table():\n T1[\"icosahedron_embedding\"] := table():\n\n for i from 1 to n0 do \n  x := T0[\"embedding\"][V0[i]];\n  x := x /~ evalf(sqrt(add(x[i]^2,i=1..3)));\n  T1[\"embedding\"][i]        := x;\n  T1[\"normal\"][i]           := x;\n  T1[\"sphere_embedding\"][i] := x;\n  x := x /~ add(abs(x[i]),i=1..3);\n  T1[\"octahedron_embedding\"][i] := x;\n  x := x /~ T1[\"icosahedron_norm\"](x);\n  T1[\"icosahedron_embedding\"][i] := x;\n od:\n\n return eval(T1):\nend:\n\n`find_paths/ico_oct_complex` := proc(T)\n local k,E,P,E0,e,e0;\n \n for k in [\"octahedron\",\"icosahedron\"] do \n  E := {op(T[cat(k,\"_edges\")])};\n  P := NULL:\n\n  while E <> {} do \n   e := E[1];\n   E := E minus {e};\n   E0 := select(e0 -> member(e[-1],e0),E);\n   while E0 <> {} do\n    e0 := E0[1];\n    if e0[1] = e[-1] then\n     e := [op(e),e0[2]];\n    else \n     e := [op(e),e0[1]];\n    fi;\n    E := E minus {e0};\n    E0 := select(e0 -> member(e[-1],e0),E);\n   od;\n   P := P,e;\n  od:\n  T[cat(k,\"_paths\")] := [P];\n od:\nend:\n\n`make_plots/ico_oct_complex` := proc(T)\n local v;\n \n T[\"embedding\"] := copy(T[\"octahedron_embedding\"]);\n `plot/simplicial_complex`(T):\n `surface_plot/simplicial_complex`(T):\n T[\"octahedron_plot\"] := T[\"plot\"];\n T[\"octahedron_surface_plot\"] := T[\"surface_plot\"];\n \n T[\"embedding\"] := copy(T[\"icosahedron_embedding\"]);\n `plot/simplicial_complex`(T):\n `surface_plot/simplicial_complex`(T):\n T[\"icosahedron_plot\"] := T[\"plot\"];\n T[\"icosahedron_surface_plot\"] := T[\"surface_plot\"];\n \n T[\"embedding\"] := copy(T[\"sphere_embedding\"]);\n `plot/simplicial_complex`(T):\n `surface_plot/simplicial_complex`(T):\n T[\"sphere_plot\"] := T[\"plot\"];\n T[\"sphere_surface_plot\"] := T[\"surface_plot\"];\n\n v := eval(T[\"embedding\"]);\n \n T[\"octahedron_arc_plot\"] :=\n  display(\n   seq(line(v[e[1]],v[e[2]],colour=blue,thickness=4),e in T1[\"octahedron_edges\"]),\n   scaling=constrained,axes=none);\n\n T[\"icosahedron_arc_plot\"] :=\n  display(\n   seq(line(v[e[1]],v[e[2]],colour=green,thickness=4),e in T1[\"icosahedron_edges\"]),\n   scaling=constrained,axes=none);\n\n T[\"octahedron_line_plot\"] :=\n  display(\n   seq(line(v[e[1]],v[e[2]],colour=blue,thickness=4),e in T1[\"octahedron_basic_edges\"]),\n   scaling=constrained,axes=none);\n\n T[\"icosahedron_line_plot\"] :=\n  display(\n   seq(line(v[e[1]],v[e[2]],colour=green,thickness=4),e in T1[\"icosahedron_basic_edges\"]),\n   scaling=constrained,axes=none);\n\nend:\n\n`make_javascript/ico_oct_complex` := proc(T)\n local shift,s,E,i,n;\n\n shift := proc(u)\n  if type(u,list) then\n   return map(shift,u);\n  else\n   return u - 1;\n  fi;\n end:\n \n n := nops(T[\"vertices\"]);\n\n s := [\n  [\"vertices\",                    sprintf(\"%A\",[seq(i,i=0..n-1)])],\n  [\"edges\",                       sprintf(\"%A\",shift(T[\"edges\"]))],\n  [\"faces\",                       sprintf(\"%A\",shift(T[\"faces\"]))],\n  [\"octahedron_edges\",            sprintf(\"%A\",shift(T[\"octahedron_edges\"]))],\n  [\"icosahedron_edges\",           sprintf(\"%A\",shift(T[\"icosahedron_edges\"]))],\n  [\"octahedron_paths\",            sprintf(\"%A\",shift(T[\"octahedron_paths\"]))],\n  [\"icosahedron_paths\",           sprintf(\"%A\",shift(T[\"icosahedron_paths\"]))],\n  [\"octahedron_basic_vertices\",   sprintf(\"%A\",shift(T[\"octahedron_basic_vertices\"]))],\n  [\"octahedron_basic_edges\",      sprintf(\"%A\",shift(T[\"octahedron_basic_edges\"]))],\n  [\"octahedron_basic_faces\",      sprintf(\"%A\",shift(T[\"octahedron_basic_faces\"]))],\n  [\"icosahedron_basic_vertices\",  sprintf(\"%A\",shift(T[\"icosahedron_basic_vertices\"]))],\n  [\"icosahedron_basic_edges\",     sprintf(\"%A\",shift(T[\"icosahedron_basic_edges\"]))],\n  [\"icosahedron_basic_faces\",     sprintf(\"%A\",shift(T[\"icosahedron_basic_faces\"]))]\n ]:\n\n E := copy(T[\"sphere_embedding\"]):\n for i from 1 to n do E[i] := evalf[3](E[i]): od:\n s := [op(s),[\"sphere_embedding\",sprintf(\"%A\",[seq(E[i],i=1..n)])]]:\n E := copy(T[\"octahedron_embedding\"]):\n for i from 1 to n do E[i] := evalf[3](E[i]): od:\n s := [op(s),[\"octahedron_embedding\",sprintf(\"%A\",[seq(E[i],i=1..n)])]]:\n E := copy(T[\"icosahedron_embedding\"]):\n for i from 1 to n do E[i] := evalf[3](E[i]): od:\n s := [op(s),[\"icosahedron_embedding\",sprintf(\"%A\",[seq(E[i],i=1..n)])]]:\n\n s := map(u -> sprintf(\"\\\"%s\\\" : %s,\\n\",u[1],u[2]),s);\n s := cat(\"{\\n\",op(s),sprintf(\"\\\"num_vertices\\\" : %d\\n}\\n\",n));\n\n T[\"javascript\"] := s;\n return s;\nend:\n\n\n\nico_oct_complex := make_ico_oct_complex():\n", "meta": {"hexsha": "bd7a2123c29d5e3a98292d4156a3d88450421827", "size": 10422, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/simplicial_complexes/ico_oct_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/ico_oct_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/ico_oct_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": 29.6079545455, "max_line_length": 108, "alphanum_fraction": 0.5495106505, "num_tokens": 4299, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256631249077, "lm_q2_score": 0.5621765008857981, "lm_q1q2_score": 0.47325460565142724}}
{"text": "# Number of subspaces of dimension d in F^n, if |F|=q\n\ngrassmann_count := (q::posint) -> (n,d) ->\n mul(q^(n-i)-1,i=0..d-1)/mul(q^(d-i)-1,i=0..d-1);\n\n# Number of splittings of F^(n+m) as a sum of subspaces of\n# dimensions n and m, if |F| = q.\n\nsplitting_count := (q::posint) -> (n,m) ->\n grassman_count(q)(n+m,n) * q^(n*m);\n\ntanabe_L := (p,n,r) -> (k) -> p^(n*(k+r-1));\n\n# tanabe_N(p,n,r)(k) is the number of irreducible F-linear representations\n# of Z_p^n that have dimension p^k over F.\n\ntanabe_N := (p,n,r) -> (k) -> `if`(k = 0,p^(n*r),(p^n-1) * p^((n-1)*k + n*(r-1)));\n\n# The socle of K^0(BGL_{p^k}(F)) is conjecturally generated by\n# euler(V)^{N-1}, where N = tanabe_N_bar(n,v,k)\n\ntanabe_N_bar := (p,n,r) -> proc(k)\n local j;\n p^(n*r) + (p^n-1)*p^(n*(r-1))*sum(p^((n-1)*j),j=1..k);\nend:\n\ntanabe_N_star := (p,n,r) -> proc(k)\n local j;\n p^(n*r-1) * (p-1) * sum(p^((n-1)*j),j=0..k-1);\nend:\n\ntanabe_N_lim := (p,n,r) -> (k) -> p^(n*r+n*k-k) * (1-p^(-n))/(1-p^(1-n));\n\n# The natural numbers can be partitioned as the disjoint union of\n# the sets tanabe_NN(p,n,r)(k), of size tanabe_N(p,n,r)(k).\n\ntanabe_NN := (p,n,r) -> proc(k::nonnegint)\n if k = 0 then\n  return [seq(i,i=0..tanabe_N_bar(p,n,r)(0)-1)];\n else\n  return [seq(i,i=tanabe_N_bar(p,n,r)(k-1)..tanabe_N_bar(p,n,r)(k)-1)];\n fi;\nend:\n\n# tanabe_s(p,n,r)(m) is the unique k such that m lies in tanabe_NN(p,n,r)(k).\ntanabe_s := (p,n,r) -> proc(m)\n local k;\n k := 0;\n while m >= tanabe_N_bar(p,n,r)(k) do\n  k := k+1;\n od;\n return k;\nend:\n\n# The E^2 page of the AHSS converging to K_*(BV) has a trigrading\n# with E^2_{ijk} = H_i(BV_k;K_j).  It has even generators\n# b[i] and u, and odd generators e[i] with\n#   |b[i]| = tanabe_b_trideg(p,n,r)(i) = [2i,0,1]\n#   |e[i]| = tanabe_e_trideg(p,n,r)(i) = [2i+1,0,1]\n#   |u|    = tanabe_u_trideg(p,n,r)    = [0,2,0].\n\ntanabe_b_trideg  := (p,n,r) -> (i) -> [2*i,0,1];\ntanabe_e_trideg  := (p,n,r) -> (i) -> [2*i+1,0,1];\ntanabe_u_trideg  := (p,n,r) -> [0,2,0];\n\n# The only nontrivial differentials have the form d_r, where\n# r = tanabe_AHSS_page(p,n,r)(k) for some k >= 0\n# [From now on we refer to this as the k'th differential,\n#  and the page on which it occurs as the k'th page.]\n\ntanabe_AHSS_page := (p,n,r) -> (k) -> 2*p^(n*(r+k)) - 1;\n\n# Tridegree of the k'th differential\ntanabe_AHSS_d_trideg := (p,n,r) -> (k) ->\n [1-2*p^(n*(r+k)),2*p^(n*(r+k))-2,0];\n\n# The k'th page can be described in terms of generators\n# bb[i,k] and ee[i,k], with tridegrees as follows:\n\ntanabe_bb_trideg := (p,n,r) -> (i,k) ->\n [2*p^k*tanabe_N_bar(p,n,r)(k-1)+2*p^k*i,0,p^k];\ntanabe_ee_trideg := (p,n,r) -> (i,k) ->\n [1+2*p^k*i-2*p^(n*(r+k))+2*p^k*tanabe_N_bar(p,n,r)(k),2*p^(n*(r+k))-2,p^k];\n\n# (This gives all the odd generators, but not all the even ones.)\n\n# The generators bb[i,k] and ee[i,k] can be expressed in terms of\n# the original generators b[i] and e[i]. as follows:\n\ntanabe_bbb := (p,n,r) -> (i,k) -> b[i+tanabe_N_bar(p,n,r)(k-1)]^(p^k);\n\ntanabe_eee := (p,n,r) -> (i,k) ->\n u^(p^(n*(r+k))-1) * e[i] * mul(b[i+tanabe_N_bar(p,n,r)(j)]^(p^j*(p-1)),j=0..k-1);\n\ntanabe_AHSS_d_rule := (p,n,r) -> proc(k,m)\n local R,Nb,i,j,n0,n1;\n R := NULL;\n Nb := tanabe_N_bar(p,n,r);\n for j from 0 to tanabe_s(p,n,r)(m) do\n  n0 := `if`(j = 0,0,Nb(j-1));\n  n1 := Nb(j);\n  if j <= k then \n   for i from n0 to min(n1-1,m) do \n    R := R,b[i]^(p^j) = 0;\n   od:\n  else\n   for i from n0 to min(n1-1,m) do \n    R := R,b[i]^(p^k) = tanabe_eee(p,n,r)(i-Nb(k),k);\n   od;\n  fi;\n od;\n return {R};\nend:\n\n# This is the part of the inverse Poincare series contributed by\n# irreducible representations of dimension at most p^k.\n\ntanabe_inverse_poincare_series := (p,n,r) -> (k) -> \n (1-t)^(p^(n*r)) * mul((1 - t^(p^j))^(p^(n*(r+j))*(1-1/p^n)),j=1..k);\n\ntanabe_poincare_series := (p,n,r) -> (k) ->\n convert(series(1/tanabe_inverse_poincare_series(p,n,r)(k),t=0,p^k+1),\n         polynom,t);\n\ntanabe_trideg0 := (p,n,r) -> proc(x)\n if type(x,indexed) then\n  if op(0,x) = b then\n   return tanabe_b_trideg(p,n,r)(op(x));\n  elif op(0,x) = e then\n   return tanabe_e_trideg(p,n,r)(op(x));\n  elif op(0,x) = bb then\n   return tanabe_bb_trideg(p,n,r)(op(x));\n  elif op(0,x) = ee then\n   return tanabe_ee_trideg(p,n,r)(op(x));\n  else\n   return [0,0,0];\n  fi;\n elif x = u then\n  return tanabe_u_trideg(p,n,r);\n else\n  return [0,0,0];\n fi;\nend:\n\ntanabe_trideg := (p,n,r) ->\n apply_deg(tanabe_trideg0(p,n,r));\n \n######################################################################\n\ncheck_tanabe_numbers := proc()\n local n,r,k,p,L,N,N_bar,N_star,N_lim,P,err;\n\n assume(n::posint);\n assume(r::posint);\n assume(k::posint);\n assume(p::posint);\n\n L      := tanabe_L(p,n,r);\n N      := tanabe_N(p,n,r);\n N_bar  := tanabe_N_bar(p,n,r);\n N_star := tanabe_N_star(p,n,r);\n N_lim  := tanabe_N_lim(p,n,r);\n \n _ASSERT(\n  simplify(N_bar(k) - N_bar(k-1) - N(k)) = 0,\n  \"N_bar(k) - N_bar(k-1) = N(k)\"\n );\n\n _ASSERT(\n  simplify(N_star(k) - (N_bar(k) - p^(n*k + n*r - k))) = 0,\n  \"N_star(k) = N_bar(k) - p^(n*k + n*r - k)\"\n );\n\n _ASSERT(\n  simplify(N(0) + sum(p^j * N(j),j=1..k) - p^(n*(r+k))) = 0,\n  \"sum(p^j * N(j),j=0..k) = p^(n*(r+k))\"\n );\n\n _ASSERT(\n  simplify((1 - p^(-k)) * N(0) +\n           sum(expand((1 - p^(j - k)) * N(j)),j=1..k) - N_star(k)) = 0,\n  \"sum((1 - p^(j-k)) * N(j),j=0..k) = N_star(k)\"\n );\n\n _ASSERT(\n  simplify(p^(k + 1) * N_star(k + 1) - p^k * N_star(k) - (p - 1) * p^k * N_bar(k)) = 0,\n  \"p^(k + 1) * N_star(k + 1) = p^k * N_star(k) + (p - 1) * p^k * N_bar(k)\"\n );\n\n _ASSERT(\n  simplify(p^k*(N_bar(k) - N_bar(k-1)) - (p^n-1)*L(k)) = 0,\n  \"p^k*(N_bar(k) - N_bar(k-1)) = (p^n-1)*L(k)\"\n );\n\n _ASSERT(\n  simplify(N_bar(k-1) - L(k)/p^k - N_star(k)) = 0,\n  \"N_bar(k-1) = L(k)/p^k + P(k)\"\n );\n\n _ASSERT(\n  simplify(factor(N_bar(k) - (N_star(k)*(p^n-1)/(p-1) + p^(n*r)))) = 0,\n  \"N_bar(k) = N_star(k)*(p^n-1)/(p-1) + p^(n*r)\"\n );\n\n _ASSERT(\n  simplify(sum(p^j*(p-1)*N_bar(j),j=0..k-1) - p^k*N_bar(k) + p^(n*(r+k))) = 0,\n  \"sum(p^j*(p-1)*N_bar(j),j=0..k-1)\"\n );\n \n _ASSERT(\n  limit(simplify(N_bar(k)/N_lim(k)-1),k=infinity) = 0,\n  \"N_bar(k) is asymptotic to N_lim(k)\"\n );\nend:\n\n", "meta": {"hexsha": "2233c1b146a4809b5ed1eb051ba4715b21fe1d0b", "size": 6010, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/tanabe/old/tanabe.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/tanabe/old/tanabe.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/tanabe/old/tanabe.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.8240740741, "max_line_length": 87, "alphanum_fraction": 0.5480865225, "num_tokens": 2529, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8397339676722393, "lm_q2_score": 0.5621765008857982, "lm_q1q2_score": 0.47207870362092746}}
{"text": "\n# Base Parameter Regresor Inverse Dynamics for Robot based on MDH frames\n# Einleitung\n# Berechnung der inversen Dynamik in Regressorform\n# \n# Dateiname:\n# robot -> Berechnung für allgemeinen Roboter\n# chain -> Berechnung für eine serielle Struktur (nicht: Baumstruktur)\n# floatb -> Floating Base (und auch fixed Base) Modell der Basis.\n# rotmat -> Kinematik wird mit Rotationsmatrizen berechnet\n# dynamics -> Berechnung der Dynamik\n# regressor -> Regressorform (parameterlinear)\n# \n# Siehe auch: robot_chain_floatb_rotmat_dynamics_regressor.mw.\n# Im Gegensatz zu der allgemeinen Dynamik werden hier die fixed-Base-Ausdrücke ohne eine \"twist\"-Basis-Berechnung übernommen.\n# Ursache ist, dass der Parametervektor und damit der Regressor sich zwischen Fixed-Base und Floating-Base unterscheidet und daher ein Ableiten des Fixed-Base falles aus der Floating-Base-Formulierung mit einfacher Basis-Darstellung (\"twist\") nicht möglich ist.\n# Autor\n# Moritz Schappler, schappler@irt.uni-hannover.de, 2016-03\n# (C) Institut fuer Regelungstechnik, Leibniz Universitaet 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# 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.\ncodegen_act := true:\ncodegen_opt := 2:\ncodeexport_grav := true: \ncodeexport_corvec := true:\ncodeexport_cormat := true:\ncodeexport_inertia := true:\ncodeexport_inertiaD := true:\ncodeexport_invdyn := true:\nread \"../helper/proc_convert_s_t\":\nread \"../helper/proc_convert_t_s\": \nread \"../helper/proc_MatlabExport\":\nread \"../helper/proc_simplify2\":\nread \"../helper/proc_LagrangeN\":\nread \"../helper/proc_index_symmat2vector\":\nread \"../transformation/proc_rotx\": \nread \"../transformation/proc_roty\": \nread \"../transformation/proc_rotz\": \nread \"../transformation/proc_trotx\": \nread \"../transformation/proc_troty\": \nread \"../transformation/proc_trotz\": \nread \"../transformation/proc_transl\": \nread \"../transformation/proc_trafo_mdh\": \nread \"../robot_codegen_definitions/robot_env\":\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", robot_name):\nread sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_inert.m\", robot_name):  \nkin_constraints_exist := kin_constraints_exist: # nur zum Abschätzen der Komplexität\n;\n# Term-Vereinfachungen einstellen\nif not assigned(simplify_options) or simplify_options(10)=-1 then # Standard-Einstellungen:\n  if not kin_constraints_exist then # normale serielle Ketten und Baumstrukturen\n    use_simplify := 0: # Standardmäßig aus\n  else # mit kinematischen Zwangsbedingungen\n    use_simplify := 1: # standardmäßig simplify-Befehle anwenden\n  end if:\nelse # Benutzer-Einstellungen:\n  use_simplify := simplify_options(10): # zehnter Eintrag ist für Dynamik-Regressor\nend if:\n# Mit diesem Arbeitsblatt werden die Regressor-Ausdrücke für Fixed-Base und Floating-Base Modelle generiert. Erkenne welche Basis-Modellierung aktiv ist\nif base_method_name=\"twist\" then # Basis-Methode \"twist\" wird (hier) nur für fixed Base benutzt\n  expstring:=\"fixb\":\nelif base_method_name=\"eulxyz\" then \n  expstring:=\"floatb_eulxyz\":\nelse\n  printf(\"Nicht behandelte Basis-Methode: %s\\n\", base_method_name):\nfi:\n# Es ist in diesem Arbeitsblatt möglich, zwei verschiedene Regressoren zu generieren und zu exportieren: Basierend auf Minimalparametern und auf vollem Parametersatz (PV2).\n# Der Term \"regressor\" oder \"regressor_minpar\" ist jeweils in den Dateinamen enthalten.\n# Der folgende Befehl muss immer auf \"regressor_minpar\" gesetzt sein, da diese Zeile durch das Skript robot_codegen_maple_preparation.sh ausgewertet und modifiziert wird.\nregressor_modus := \"regressor_minpar\":\nif regressor_modus = \"regressor_minpar\" then\n  ekinfile := sprintf(\"../codeexport/%s/tmp/energy_kinetic_%s_regressor_minpar_maple.m\", robot_name, expstring):\n  if FileTools[Exists](ekinfile) then\n    read ekinfile:\n  else\n    printf(\"%s. Energie-Regressor in Minimalparameterform wurde nicht berechnet. Abbruch der Dynamik-Minimalparameterregressor-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.\n  end if:\n  read ekinfile:\n  read sprintf(\"../codeexport/%s/tmp/energy_potential_%s_regressor_minpar_maple.m\", robot_name, expstring):\n  t_ges := t_ges_minpar:\n  u_ges := u_ges_minpar:\n  printf(\"%s. Generiere Minimalparameterregressor der Dynamik für %s\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\"), robot_name):\nend if:\nif regressor_modus = \"regressor\" then\n  read sprintf(\"../codeexport/%s/tmp/energy_kinetic_%s_regressor_maple.m\", robot_name, expstring):\n  read sprintf(\"../codeexport/%s/tmp/energy_potential_%s_regressor_maple.m\", robot_name, expstring):\n  t_ges := t_ges:\n  u_ges := u_ges:\n  printf(\"%s. Generiere Regressor der Dynamik für %s (nicht Minimalparameter)\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\"), robot_name):\nend if:\n# Schalter zur Auswahl der unterschiedlichen Terme, die exportiert werden sollen. Für parallele Berechnung interessant.\nDynString := \"Term:\":\nif codeexport_grav then\n  DynString := sprintf(\"%s g\",DynString):\nend if:\nif codeexport_corvec then\n  DynString := sprintf(\"%s c\",DynString):\nend if:\nif codeexport_cormat then\n  DynString := sprintf(\"%s C\",DynString):\nend if:\nif codeexport_inertia then\n  DynString := sprintf(\"%s M\",DynString):\nend if:\nif codeexport_inertiaD then\n  DynString := sprintf(\"%s MD\",DynString):\nend if:\nif codeexport_invdyn then\n  DynString := sprintf(\"%s tau\",DynString):\nend if:\nprintf(\"%s. Generiere Dynamik-Regressor (%s) für %s und %s\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\"), DynString, robot_name, base_method_name):\n# Platzhalter-Vektor der Dynamik-Parameter aufstellen\nnDP := ColumnDimension(u_ges):\nPV := Matrix(nDP,1):\nfor i from 1 to nDP do\n  if regressor_modus = \"regressor_minpar\" then\n    PV(i,1) := parse(sprintf(\"MDP%d%\", i)):\n  elif regressor_modus = \"regressor\" then\n    PV(i,1) := parse(sprintf(\"DP%d%\", i)):\n  end if:\nend do:\nPV:\n# Name für Export der Terme als Funktion des Parametervektors\nif regressor_modus = \"regressor_minpar\" then\n  regshortname := \"mdp\":\nelif regressor_modus = \"regressor\" then\n  regshortname := \"dp\":\nend if:\n\n# Lagrange Formalismus (mit Funktion)\nOutputLagrange := LagrangeN(t_ges, u_ges):\ndTdqDdt_s := OutputLagrange[1]:\ndTdq_s := OutputLagrange[2]:\ndUdq_s := OutputLagrange[3]:\nsave dUdq_s, sprintf(\"../codeexport/%s/tmp/floatb_lagrange_dUdq_s_%s_maple.m\", robot_name, regressor_modus):\nsave dTdq_s, sprintf(\"../codeexport/%s/tmp/floatb_lagrange_dTdq_s_%s_maple.m\", robot_name, regressor_modus):\nsave dTdqDdt_s, sprintf(\"../codeexport/%s/tmp/floatb_lagrange_dTdqDdt_s_%s_maple.m\", robot_name, regressor_modus):\n# Extraktion einzelner Terme\n# Gravitational Load\n# Generate\ntaug_regressor_s := dUdq_s:\n# Terme vereinfachen\nif codeexport_grav then\n  if use_simplify=1 then\n    tmp_t1:=time():\n    tmp_l1 := length(taug_regressor_s):\n    taug_regressor_s := simplify2(taug_regressor_s):\n    tmp_t2:=time():\n    tmp_l2 := length(taug_regressor_s):\n    printf(\"%s: Gravitationsmoment-Regressor vereinfacht. Länge: %d->%d. Rechenzeit %1.1fs.\\n\", \\\n      FormatTime(\"%Y-%m-%d %H:%M:%S\"), tmp_l1, tmp_l2, tmp_t2-tmp_t1):\n  end if:\nend if:\nsave taug_regressor_s, sprintf(\"../codeexport/%s/tmp/gravload_%s_maple.m\", robot_name, regressor_modus):\n# Matlab Export\n# Belastung der Basis (nur Floating Base)\nif codegen_act and codeexport_grav and not(base_method_name=\"twist\") then\n  MatlabExport(taug_regressor_s(1..6,..), sprintf(\"../codeexport/%s/tmp/gravload_base_floatb_%s_%s_matlab.m\", robot_name, base_method_name, regressor_modus), codegen_opt):\nend if:\n# Belastung der Gelenke: \n# Fixed-Base: Gravitationsvektor im Basis-KS\n# Floating Base: Gravitationsvektor im Welt-KS, Basis-Orientierung berücksichtigt\ntaug := taug_regressor_s . PV:\nif codegen_act and codeexport_grav then\n  MatlabExport(taug_regressor_s(7..NQ,..), sprintf(\"../codeexport/%s/tmp/gravload_joint_%s_%s_matlab.m\", robot_name, expstring, regressor_modus), codegen_opt):\n  MatlabExport(taug(7..NQ,..), sprintf(\"../codeexport/%s/tmp/gravload_joint_%s_%s_matlab.m\", robot_name, expstring, regshortname), codegen_opt):\nend if:\n# Kompletter Vektor\nif codegen_act and codeexport_grav and not(base_method_name=\"twist\") then\n  MatlabExport(taug_regressor_s(1..NQ,..), sprintf(\"../codeexport/%s/tmp/gravload_floatb_%s_%s_matlab.m\", robot_name, base_method_name, regressor_modus), codegen_opt):\n  MatlabExport(taug(1..NQ,..), sprintf(\"../codeexport/%s/tmp/gravload_floatb_%s_%s_matlab.m\", robot_name, expstring, regshortname), codegen_opt):\nend if:\n\n# Mass Matrix\n# Berechnung vollständige Massenmatrix\n# Generiere die Massenmatrix erst für Floating-Base-Komplettsystem, dann entnehme die Teilmatrizen für Gelenk-Gelenk, Gelenk-Basis zum separaten Export\nParamvec_size := ColumnDimension(t_ges):\n# Berechnung vollständige Massenmatrix\n# Initialisiere. Speichere nur den unteren linken Teil der Massenmatrix\n# Siehe: https://de.wikipedia.org/wiki/Symmetrische_Matrix\ntauMM_regressor_s := dTdqDdt_s(1..NQ,..):\nMM_regressor_s := Matrix(NQ*(NQ+1)/2, Paramvec_size):\nif codeexport_inertia or codeexport_inertiaD or codeexport_cormat then\ni_rr := 0:\nfor i to NQ do # Zeilenindex der Massenmatrix\n  for j to NQ 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 Paramvec_size do # Spaltenindex der Regressormatrix\n      MM_regressor_s[i_rr, k] := diff(tauMM_regressor_s[i, k], qDD_s[j, 1]):\n    end do:\n  end do:\nend do:\n# Terme vereinfachen\nif use_simplify>=1 then\n  tmp_t1:=time():\n  tmp_l1 := length(MM_regressor_s):\n  printf(\"%s. Beginne Vereinfachung: Massenmatrix-Regressor (%s). Länge: %d.\\n\", \\\n    FormatTime(\"%Y-%m-%d %H:%M:%S\"), regressor_modus, tmp_l1):\n  MM_regressor_s := simplify2(MM_regressor_s):\n  tmp_t2:=time():\n  tmp_l2 := length(MM_regressor_s):\n  printf(\"%s. Massenmatrix-Regressor (%s) vereinfacht. Länge: %d->%d. Rechenzeit %1.1fs.\\n\", \\\n    FormatTime(\"%Y-%m-%d %H:%M:%S\"), regressor_modus, tmp_l1, tmp_l2, tmp_t2-tmp_t1):\nend if:\nend if:\n# Export Gesamt-Massenmatrix\nif codegen_act and codeexport_inertia and not(base_method_name=\"twist\") then\n  MatlabExport(MM_regressor_s, sprintf(\"../codeexport/%s/tmp/inertia_floatb_%s_%s_matlab.m\", robot_name, base_method_name, regressor_modus), codegen_opt):\nend if:\n# Gelenk-Massenmatrix extrahieren\nMMjj_regressor_s := Matrix(NQJ*(NQJ+1)/2, Paramvec_size):\nitmp:=0:\nfor i to NQ do\n  for j to NQ 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    if i > 6 and j > 6 then # unterer rechter Teil (Gelenkmoment-Gelenkbeschleunigung-Terme)\n      i_MM := index_symmat2vec(NQ,i,j): # Passender Index für zeilenweise ausgewählten symmetrischen Teil (siehe Gesamt-Massenmatrix)\n      itmp := itmp + 1:\n      MMjj_regressor_s[itmp,..] := MM_regressor_s[i_MM,..]:\n    end if:\n  end do:\nend do:\n# Multiplikation der Massenmatrix mit dem Regressorvektor und Export als obere Dreiecksmatrix\nMMjj_tmp := MMjj_regressor_s . PV: # Vektor der oberen rechten Dreiecksmatrix\n;\n# Export Gelenkmassenmatrix\nif codegen_act and codeexport_inertia and base_method_name=\"twist\" then\n  MatlabExport(MMjj_regressor_s, sprintf(\"../codeexport/%s/tmp/inertia_joint_joint_%s_%s_matlab.m\", robot_name, expstring, regressor_modus), codegen_opt):\n  MatlabExport(MMjj_tmp, sprintf(\"../codeexport/%s/tmp/inertia_joint_joint_%s_%s_matlab.m\", robot_name, expstring, regshortname), codegen_opt):\nend if:\n# Gelenk-Basis-Massenmatrix\n#  (untere linke Teilmatrix der Gesamt-Massenmatrix)\nMMjb_regressor_s := Matrix(6*NQJ, Paramvec_size):\n# Gehe Schleife über alle Massenmatrix-Elemente durch und entnehme die passenden Elemente für die Teilmatrix)\nitmp:=0:\nfor i to NQ do\n  for j to NQ do  # Spaltenindex der Massenmatrix\n    if i > 6 and j < 7 then # unterer linker Teil\n      i_MM := index_symmat2vec(NQ,i,j): # Passender Index für zeilenweise ausgewählten symmetrischen Teil (siehe Gesamt-Massenmatrix)\n      itmp := itmp + 1:\n      MMjb_regressor_s[itmp,..] := MM_regressor_s[i_MM,..]:\n    end if:\n  end do:\nend do:\nif codegen_act and codeexport_inertia and not(base_method_name=\"twist\") then\n  MatlabExport(MMjb_regressor_s, sprintf(\"../codeexport/%s/tmp/inertia_joint_base_floatb_%s_%s_matlab.m\", robot_name, base_method_name, regressor_modus), codegen_opt):\nend if:\n# Basis-Massenmatrix\nMMbb_regressor_s := Matrix(6*(6+1)/2, Paramvec_size):\n# Gehe Schleife über alle Massenmatrix-Elemente durch und entnehme die passenden Elemente für die Teilmatrix)\nitmp:=0:\nfor i to NQ do\n  for j to NQ 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    if i < 7 and j < 7 then # unterer linker Teil\n      i_MM := index_symmat2vec(NQ,i,j): # Passender Index für zeilenweise ausgewählten symmetrischen Teil (siehe Gesamt-Massenmatrix)\n      itmp := itmp + 1:\n      MMbb_regressor_s[itmp,..] := MM_regressor_s[i_MM,..]:\n    end if:\n  end do:\nend do:\nif codegen_act and codeexport_inertia and not(base_method_name=\"twist\") then\n  MatlabExport(MMbb_regressor_s, sprintf(\"../codeexport/%s/tmp/inertia_base_base_floatb_%s_%s_matlab.m\", robot_name, base_method_name, regressor_modus), codegen_opt):\nend if:\n# Mass Matrix Time Derivative\n# Gesamt Massenmatrix\nMM_regressor_t := convert_s_t(MM_regressor_s):\nMMD_regressor_t := diff~(MM_regressor_t, t):\nMMD_regressor_s := convert_t_s(MMD_regressor_t):\nif codegen_act and codeexport_inertiaD and not(base_method_name=\"twist\") then\n  MatlabExport(MMD_regressor_s, sprintf(\"../codeexport/%s/tmp/inertiaD_floatb_%s_%s_matlab.m\", robot_name, base_method_name, regressor_modus), codegen_opt):\nend if:\n# Konvertiere Gelenk-Massenmatrix in zeitabhängige Variablen, um Zeitableitung zu berechnen\nMMjj_regressor_t := convert_s_t(MMjj_regressor_s):\nMMDjj_regressor_t := diff~(MMjj_regressor_t, t):\nMMDjj_regressor_s := convert_t_s(MMDjj_regressor_t):\nif codegen_act and codeexport_inertiaD and base_method_name=\"twist\" then\n  MatlabExport(MMDjj_regressor_s, sprintf(\"../codeexport/%s/tmp/inertiaD_joint_joint_%s_%s_matlab.m\", robot_name, expstring, regressor_modus), codegen_opt):\nend if:\n# Gelenk-Basis-Massenmatrix\nMMjb_regressor_t := convert_s_t(MMjb_regressor_s):\nMMDjb_regressor_t := diff~(MMjb_regressor_t, t):\nMMDjb_regressor_s := convert_t_s(MMDjb_regressor_t):\nif codegen_act and codeexport_inertiaD and not(base_method_name=\"twist\") then\n  MatlabExport(MMDjb_regressor_s, sprintf(\"../codeexport/%s/tmp/inertiaD_joint_base_floatb_%s_%s_matlab.m\", robot_name, base_method_name, regressor_modus), codegen_opt):\nend if:\n# Coriolis Vector\n# Generieren (gleiches Vorgehen für fixed und floating base)\ntauC_regressor_s := dTdqDdt_s-dTdq_s:\nfor i to NQ do \n  tauC_regressor_s := subs({qDD_s(i, 1) = 0}, tauC_regressor_s):\nend do:\nsave tauC_regressor_s, sprintf(\"../codeexport/%s/tmp/coriolisvec_joint_%s_%s_maple.m\", robot_name, expstring, regressor_modus):\ntauc := tauC_regressor_s . PV:\n# Matlab Export\n# Belastung der Gelenke\nif codegen_act and codeexport_corvec then\n  MatlabExport(tauC_regressor_s(7..NQ,..), sprintf(\"../codeexport/%s/tmp/coriolisvec_joint_%s_%s_matlab.m\", robot_name, expstring, regressor_modus), codegen_opt):\n  MatlabExport(tauc(7..NQ,..), sprintf(\"../codeexport/%s/tmp/coriolisvec_joint_%s_%s_matlab.m\", robot_name, expstring, regshortname), codegen_opt):\nend if:\n# Gesamter Vektor für Floating Base\nif codegen_act and codeexport_corvec and not(base_method_name=\"twist\") then\n  MatlabExport(tauC_regressor_s(1..NQ,..), sprintf(\"../codeexport/%s/tmp/coriolisvec_%s_%s_matlab.m\", robot_name, expstring, regressor_modus), codegen_opt):\n  MatlabExport(tauc(1..NQ,..), sprintf(\"../codeexport/%s/tmp/coriolisvec_%s_%s_matlab.m\", robot_name, expstring, regshortname), codegen_opt):\nend if:\n# Nur Basis-Terme\nif codegen_act and codeexport_corvec and not(base_method_name=\"twist\") then\n  MatlabExport(tauC_regressor_s(1..6,..), sprintf(\"../codeexport/%s/tmp/coriolisvec_base_%s_%s_matlab.m\", robot_name, expstring, regressor_modus), codegen_opt):\n  MatlabExport(tauc(1..6,..), sprintf(\"../codeexport/%s/tmp/coriolisvec_base_%s_%s_matlab.m\", robot_name, expstring, regshortname), codegen_opt):\nend if:\n# Coriolis Matrix\n# Floating-Base Coriolismatrix (Gesamt)\n# Calculation with Christoffel Symbol approach\n# [KhalilDombre2002], equ. (9.7) (p. 195)\n# Funktion zur Anwendung des Algorithmus aus [KhalilDombre2002]:\ncijk := proc (i::integer, j::integer, k::integer, A, qs)\n  local c:\n  c := (1/2)*(diff(A[i, j], qs(k, 1)))+(1/2)*(diff(A[i, k], qs(j, 1)))-(1/2)*(diff(A[j, k], qs(i, 1))):\n  return c:\nend proc:\n# Initialisierung. Speichere die vollständige Coriolismatrix (nicht symmetrisch/schiefsymmetrisch). Unterschied zum Vorgehen bei der Massenmatrix\nC_regressor_s := Matrix(NQ*NQ, Paramvec_size):\n# Berechnung\nif codeexport_cormat then:\ni_rr := 0: # Vektor-Index für den Regressor der Coriolismatrix (Ausgabe)\nfor i to NQ do # Zeilenindex der Coriolismatrix\n  for j to NQ do  # Spaltenindex der Coriolismatrix\n    i_rr := i_rr + 1: # Gehe zeilenweise durch den unteren linken Teil der Coriolismatrix (inkl. Diagonale)\n    for k from 1 to Paramvec_size do # Spaltenindex der Regressormatrix\n      # Massenmatrix für Parameter k generieren (für Funktion mit Christoffel-Symbol-Ansatz benötigt)\n      MM_k := Matrix(NQ,NQ):\n      for ii from 1 to NQ do\n        for jj from 1 to NQ do\n          MM_k(ii,jj) := MM_regressor_s(index_symmat2vec(NQ, ii, jj), k):\n        end do:\n      end do:\n      for l from 1 to NQ do # Siehe [KhalilDombre2002]\n        C_regressor_s[i_rr, k] := C_regressor_s[i_rr,k] + cijk(i,j,l,MM_k,q_s)*qD_s[l,1]:\n      end do:\n    end do:\n  end do:\nend do:\n# Terme vereinfachen\nif use_simplify>=1 then\n  tmp_t1:=time():\n  tmp_l1 := length(C_regressor_s):\n  printf(\"%s. Beginne Vereinfachung: Coriolis-Matrix-Regressor (%s). Länge: %d.\\n\", \\\n    FormatTime(\"%Y-%m-%d %H:%M:%S\"), regressor_modus, tmp_l1):\n  C_regressor_s := simplify2(C_regressor_s):\n  tmp_t2:=time():\n  tmp_l2 := length(C_regressor_s):\n  printf(\"%s: Coriolis-Matrix-Regressor (%s) vereinfacht. Länge: %d->%d. Rechenzeit %1.1fs.\\n\", \\\n    FormatTime(\"%Y-%m-%d %H:%M:%S\"), regressor_modus, tmp_l1, tmp_l2, tmp_t2-tmp_t1):\nend if:\nend if:\nsave C_regressor_s, sprintf(\"../codeexport/%s/tmp/coriolismat_%s_%s_maple.m\", robot_name, expstring, regressor_modus):\n# Matlab Export: Floating Base Gesamt\nif codegen_act and codeexport_cormat and not(base_method_name=\"twist\") then\n  MatlabExport(C_regressor_s, sprintf(\"../codeexport/%s/tmp/coriolismat_floatb_%s_%s_matlab.m\", robot_name, base_method_name, regressor_modus), codegen_opt):\nend if:\n# Gelenk-Coriolismatrix\n# Extrahiere Teilmatrix, die für die Gelenkterme (ohne Basiseinfluss) zuständig sind\nCjj_regressor_s := Matrix(NQJ*NQJ, Paramvec_size):\nitmp := 0:\nfor i to NQ do # Zeilenindex der Coriolismatrix\n  for j to NQ do  # Spaltenindex der Coriolismatrix\n    if i > 6 and j > 6 then # unterer rechter Teil\n      i_C := (i-1)*NQ+j: # Passender Index für zeilenweise ausgewähltes Element\n      itmp := itmp + 1:\n      Cjj_regressor_s[itmp,..] := C_regressor_s[i_C,..]:\n    end if:\n  end do:\nend do:\nif codegen_act and codeexport_cormat and base_method_name=\"twist\" then\n  MatlabExport(Cjj_regressor_s, sprintf(\"../codeexport/%s/tmp/coriolismat_joint_fixb_%s_matlab.m\", robot_name, regressor_modus), codegen_opt):\nend if:\n# Inverse Dynamics\n# Generate\ntau_regressor_s := dTdqDdt_s-dTdq_s+dUdq_s:\nsave tau_regressor_s, MMjj_regressor_s, tauMM_regressor_s, tauC_regressor_s, taug_regressor_s, sprintf(\"../codeexport/%s/tmp/invdyn_%s_%s_maple.m\", robot_name, expstring, regressor_modus):\ntau := tau_regressor_s . PV:\n# Gesamter Vektor (floating base)\nif codegen_act and codeexport_invdyn and not(base_method_name=\"twist\") then\n  MatlabExport(tau_regressor_s(1..NQ,..), sprintf(\"../codeexport/%s/tmp/invdyn_%s_%s_matlab.m\", robot_name, expstring, regressor_modus), codegen_opt):\n  MatlabExport(tau, sprintf(\"../codeexport/%s/tmp/invdyn_%s_%s_matlab.m\", robot_name, expstring, regshortname), codegen_opt):\nend if:\n# Belastung der Basis (floating base)\nif codegen_act and codeexport_invdyn and not(base_method_name=\"twist\") then\n  MatlabExport(tau_regressor_s(1..6,..), sprintf(\"../codeexport/%s/tmp/invdyn_base_%s_%s_matlab.m\", robot_name, expstring, regressor_modus), codegen_opt):\n  MatlabExport(tau(1..6,..), sprintf(\"../codeexport/%s/tmp/invdyn_base_%s_%s_matlab.m\", robot_name, expstring, regshortname), codegen_opt):\nend if:\n# Belastung der Gelenke\nif codegen_act and codeexport_invdyn then\n  MatlabExport(tau_regressor_s(7..NQ,..), sprintf(\"../codeexport/%s/tmp/invdyn_joint_%s_%s_matlab.m\", robot_name, expstring, regressor_modus), codegen_opt):\n  MatlabExport(tau(7..NQ,..), sprintf(\"../codeexport/%s/tmp/invdyn_joint_%s_%s_matlab.m\", robot_name, expstring, regshortname), codegen_opt):\nend if:\n# Regressor-Matrix als Vektor hinschreiben. Dabei Null-Einträge herausfinden und nicht weiter berücksichtigen.\n# Dadurch wird die obere rechte Dreiecksform der Regressor-Matrix ausgenutzt.\n# Platzhalter-Vektor für alle Einträge der Regressor-Matrix\nReg_Vector := Matrix(ColumnDimension(tau_regressor_s)*RowDimension(tau_regressor_s), 1):\n# Gelenkmoment in Abhängigkeit des Regressor-Vektors (RV)\ntauJ_RV := Matrix(NQJ, 1):\nkk := 0: # Zähler für laufende Nummer des Regressor-Vektors\nfor i from 1 to ColumnDimension(tau_regressor_s) do\n  for j from 1 to RowDimension(tau_regressor_s)-6 do\n    # Gehe Spalten- und dann Zeilenweise durch die Regressormatrix (nur Gelenk-Teil)\n    if tau_regressor_s(j+6,i) <> 0 then # Eintrag ungleich Null\n    \t kk := kk + 1:\n    \t # Regressor-Vektor-Eintrag als Platzhalter direkt so, wie er in Matlab-Funktion gebraucht wird (\"RV\" ist Eingabe der Matlab-Funktion).\n    \t rv_kk := parse(sprintf(\"RV(%d)\", kk)):\n    \t # Eintrag für Regressor-Vektor so schreiben, dass er in einer Matlab-Funktion aus der Regressor-Matrix gebildet werden kann\n    \t Reg_Vector(kk,1) := parse(sprintf(\"RM(%d,%d)\", j, i)):\n    \t # Gelenkmoment aus Multiplikation mit Parametervektor. Dadurch Berechnung unter Ausnutzung der Nullen.\n    \t tauJ_RV(j) := tauJ_RV(j) + rv_kk*PV(i):\n    end if:\n  end do:\nend do:\n# Kürzen des Regressor-Vektors auf die tatsächlich benutzten Einträge\nReg_Vector := Reg_Vector(1..kk,..):\nsave Reg_Vector, sprintf(\"../codeexport/%s/tmp/invdyn_joint_%s_%s_occupancy_vector_maple\", robot_name, expstring, regressor_modus):\nif codegen_act and codeexport_invdyn then\n  interface(warnlevel=0): # Unterdrücke die folgende Warnung (Ist prinzipbedingt, da RM/RV als Funktionsnamen interpretiert werden. Der Code funktioniert trotzdem.\n  MatlabExport(Reg_Vector, sprintf(\"../codeexport/%s/tmp/invdyn_joint_%s_%s_occupancy_vector_matlab.m\", robot_name, expstring, regressor_modus), codegen_opt):\n  MatlabExport(tauJ_RV, sprintf(\"../codeexport/%s/tmp/invdyn_joint_%s_%s_mult_matlab.m\", robot_name, expstring, regshortname), codegen_opt):\n  interface(warnlevel=3):\nend if:\n\n", "meta": {"hexsha": "3a0f0dfadfe8f8c05266319b49d1cbcfad7b4aed", "size": 23614, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "robot_codegen_dynamics/robot_chain_floatb_rotmat_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_dynamics/robot_chain_floatb_rotmat_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_dynamics/robot_chain_floatb_rotmat_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": 52.5924276169, "max_line_length": 261, "alphanum_fraction": 0.758109596, "num_tokens": 7395, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7606506526772883, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.47067574079119506}}
{"text": "# This file sets up the 15-vertex triangulation of CP^2 introduced by\n# Gaifullin in \"A minimal triangulation of complex projective plane ...\"\n# (arxiv:0904.4222)\n\nwith(GroupTheory):\n\nCP2_complex := proc()\n local T,V,F,p,a,b,d,s,S,om,ob,rt,\n  id_S,o_S,inv_S,act_S,eq_S,eq_X,v,ix_v,i;\n\n T := table():\n\n # We take the vertices to be 1,...,15\n # In Gaifullin's presentation, the vertex set is\n # {transposition pairs} union {1,2,3,4} x {1,2,3}\n # Gaifullin's (i,j) is our 1 + 3 * (i-1) + (j-1)\n # The transposition pairs are our vertices 13-15.\n\n V := {seq(i,i=1..15)}:\n\n T[\"vertices\"] := V;\n\n F := NULL:\n\n # This table encodes the three transposition pairs on {0,1,2,3}\n p := table():\n p[1,0] := 1; p[1,1] := 0; p[1,2] := 3; p[1,3] := 2;\n p[2,0] := 2; p[2,1] := 3; p[2,2] := 0; p[2,3] := 1;\n p[3,0] := 3; p[3,1] := 2; p[3,2] := 1; p[3,3] := 0;\n \n for a from 1 to 3 do \n  for b[0] from 0 to 2 do\n   for b[1] from 0 to 2 do \n    for b[2] from 0 to 2 do\n     for b[3] from 0 to 2 do\n      if b[0] <> b[p[a,0]] and\n\t b[1] <> b[p[a,1]] and\n\t b[2] <> b[p[a,2]] and\n\t b[3] <> b[p[a,3]] then\n       F := F,{b[0]+1,b[1]+4,b[2]+7,b[3]+10,a+12};\n      fi;\n     od:\n    od:\n   od:\n  od:\n od:\n F := {F}:\n\n T[\"max_simplices\"] := F;\n T[\"all_simplices\"] := \n   map(f -> op(combinat[powerset](f)),F) minus {{}}:\n\n T[\"simplices\"] := table():\n for d from 0 to 4 do \n  T[\"simplices\"][d] := select(u -> nops(u) = d+1,T[\"simplices\"]);\n od:\n\n s := table():\n T[\"s\"] := eval(s);\n\n s[0] := Perm([]):\n s[1] := Perm([[ 1, 4],[ 2, 5],[ 3, 6],[14,15]]):\n s[2] := Perm([[ 4, 7],[ 5, 8],[ 6, 9],[13,14]]):\n s[3] := Perm([[ 7,10],[ 8,11],[ 9,12],[14,15]]):\n s[4] := Perm([[ 1, 2],[ 4, 5],[ 7, 8],[10,11]]):\n s[5] := Perm([[ 2, 3],[ 5, 6],[ 8, 9],[11,12]]):\n\n T[\"S4\"] := Group(s[1],s[2],s[3]);\n T[\"S3\"] := Group(s[4],s[5]);\n T[\"G\"]  := Group(seq(s[i],i=1..5));\n\n S := table():\n T[\"S\"] := eval(S);\n\n om := exp( 2*Pi*I/3);\n ob := exp(-2*Pi*I/3);\n rt := sqrt(3);\n\n S[0] := [ 1,[[ 1, 0, 0],[ 0, 1, 0],[ 0, 0, 1]]]:\n S[1] := [-1,[[ 0, 1, 0],[ 1, 0, 0],[ 0, 0, 1]]];\n S[2] := [-1,[[ 1, 0, 0],[ 0, 0, 1],[ 0, 1, 0]]];\n S[3] := [-1,[[ 0,-1, 0],[-1, 0, 0],[ 0, 0, 1]]];\n S[4] := [-1,[[ 1, 0, 0],[ 0, 1, 0],[ 0, 0, 1]]];\n S[5] := [-1,[[ 1, 0, 0],[ 0,om, 0],[ 0, 0,ob]]];\n\n id_S := S[0];\n\n o_S := proc(u,v)\n  local m,n,mn,A,B,AB;\n  m,A := op(u);\n  n,B := op(v);\n  mn := m*n;\n  if n = -1 then A := conjugate(A); fi;\n  AB := convert(Matrix(A) . Matrix(B),listlist);\n  AB := simplify(expand(rationalize(AB)));\n  return [mn,AB]; \n end:\n\n inv_S := proc(u) \n  local m,A;\n  m,A := op(u);\n  if m = -1 then A := conjugate(A); fi;\n  A := convert(1/Matrix(A),listlist);\n  A := simplify(expand(rationalize(A)));\n  return [m,A];\n end:\n\n act_S := (u) -> proc(x)\n  local y;\n  y := Vector(x);\n  y := simplify(convert(Matrix(u[2]) . y,list));\n  if u[1] = -1 then y := map(conjugate,y); fi;\n  return y;\n end:\n\n eq_S := proc(u,v)\n  local w;\n  if u[1] <> v[1] then return false; fi;\n  w := o_S(u,inv_S(v));\n  if w[2][1,1] = 0 then return false; fi;\n  w := [w[1],map(simplify,map(expand,w[2] /~ w[2][1,1]))];\n  return evalb(w = id_S);\n end:\n\n eq_X := proc(u,v)\n  local i,j;\n  `and`(seq(seq(evalb(simplify(u[i]*v[j]-u[j]*v[i])=0),j=i+1..3),i=1..2));\n end:\n\n v := table([\n   1 = [  1,-om,-ob],\n   2 = [  1,-ob,-om],\n   3 = [  1, -1, -1],\n   4 = [  1,-om, ob],\n   5 = [  1,-ob, om],\n   6 = [  1, -1,  1],\n   7 = [  1, om,-ob],\n   8 = [  1, ob,-om],\n   9 = [  1,  1, -1],\n  10 = [  1, om, ob],\n  11 = [  1, ob, om],\n  12 = [  1,  1,  1],\n  13 = [  0,  0, rt],\n  14 = [  0, rt,  0],\n  15 = [ rt,  0,  0]\n ]):\n\n T[\"projective_embedding\"] := eval(v);\n\n ix_v := proc(u)\n  local i;\n  for i from 1 to 15 do\n   if eq_X(u,v[i]) then return i; fi;\n  od;\n  return FAIL;\n end:\n\n return eval(T):\nend:", "meta": {"hexsha": "4218671b5f71b62546a326692a98b28b365067b6", "size": 3716, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/simplicial_complexes/CP2_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/CP2_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/CP2_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": 23.3710691824, "max_line_length": 74, "alphanum_fraction": 0.4644779333, "num_tokens": 1746, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802476562641, "lm_q2_score": 0.611381973294151, "lm_q1q2_score": 0.47020179943364115}}
{"text": "# A raw simplicial complex is a set of nonempty finite sets, no two\n# of which are  contained in each other.  We take this as representing\n# a simplicial complex, with the specified sets as the maximal simplices.\n#\n# A (cooked) simplicial complex is a table with various fields which\n# gives a more structured representation of the data.\n\n`is_element/raw_simplicial_complexes` := proc(K)\n global reason;\n local n,i,j;\n\n if not(type(K,set(set)) or type(K,set(list)) or type(K,list(set)) or type(K,list(list))) then \n  reason := [\"is_element/raw_simplicial_complexes\",\"K is not a set/list of set/lists\",K];\n  return false;\n fi;\n\n if member({},K) or member([],K) then\n  reason := [\"is_element/raw_simplicial_complexes\",\"K contains the empty set\",K];\n  return false;\n fi;\n\n n := nops(K);\n\n for i from 1 to n-1 do \n  for j from i+1 to n do\n   if {op(K[i])} minus {op(K[j])} = {} then\n    reason := [\"is_element/raw_simplicial_complexes\",\"K[i] and K[j] are nested\",i,j,K];\n    return false;\n   fi;\n  od;\n od;\n\n return true;\nend:\n\n`vertices/raw_simplicial_complex` := (K) -> map(op,{op(K)});\n\n`is_simplex/raw_simplicial_complex` := proc(K,s)\n local s0,u;\n \n if not(type(s,{list,set})) then return false; fi;\n \n s0 := {op(s)};\n if s0 = {} then return false; fi;\n \n for u in K do\n  if s0 minus {op(u)} = {} then\n   return true;\n  fi;\n od:\n return false;\nend:\n\n`is_element/simplicial_complexes` := proc(T)\n if not(type(T,table)) then\n  return false;\n fi;\n\n if not(`is_element/raw_simplicial_complexes`(T[\"max_simplices\"])) then\n  return false;\n fi;\n\n if T[\"vertices\"] <> `vertices/raw_simplicial_complex`(T[\"max_simplices\"]) then\n  return false;\n fi;\n\n return true;\nend:\n\n`is_simplex/simplicial_complex` := proc(T,s)\n return `is_simplex/raw_simplicial_complex`(T[\"max_simplices\"],s);\nend:\n\n`all_simplices/raw_simplicial_complex` := proc(K)\n local V,K0;\n V := `vertices/raw_simplicial_complex`(K);\n K0 := map(s -> {op(s)},{op(K)});\n K0 := map(op,map(combinat[powerset],K0)) minus {{}};\n K0 := map(s -> sort([op(s)]),K0);\n return K0;\nend;\n\n`normalise/raw_simplicial_complex` := proc(K)\n local K0,K1,n,i,j,ok;\n K0 := [op(K)];\n K0 := map(s -> {op(s)},K0);\n K0 := sort(K0,(s,t) -> nops(s) <= nops(t));\n n := nops(K0);\n K1 := NULL;\n for i from 1 to n do\n  ok := true;\n  for j from i + 1 to n do\n   if K0[i] minus K0[j] = {} then\n    ok := false;\n    break;\n   fi;\n  od;\n  if ok then K1 := K1,K0[i]; fi;\n od;\n K1 := [K1];\n K1 := map(s -> sort([op(s)]),K1);\n return K1;\nend:\n\n`cook/raw_simplicial_complex` := proc(K)\n local T;\n\n T := table();\n T[\"vertices\"] := `vertices/raw_simplicial_complex`(K);\n T[\"max_simplices\"] := K;\n\n return eval(T);\nend;\n\n`edges/raw_simplicial_complex` := proc(K)\n local i,j,s;\n {seq(seq(seq({s[i],s[j]},j=i+1..nops(s)),i=1..nops(s)),s in K)};\nend:\n\n`faces/raw_simplicial_complex` := proc(K)\n local i,j,k,s;\n {seq(seq(seq(seq({s[i],s[j],s[k]},k=j+1..nops(s)),j=i+1..nops(s)),i=1..nops(s)),s in K)};\nend:\n\n`components/simplicial_complex` := proc(T)\n local P,Q,R,s,v;\n \n P := {seq({v},v in T[\"vertices\"])};\n for s in T[\"max_simplices\"] do\n  Q,R := selectremove(c -> c intersect {op(s)} = {},P);\n  P := {map(op,R),op(Q)};\n od:\n T[\"components\"] := P;\n return P;\nend:\n\n`reindex/simplicial_complex` := proc(T,f)\n local T0,v;\n \n T0 := table();\n T0[\"vertices\"] := map(f,T[\"vertices\"]);\n T0[\"max_simplices\"] := map(s -> map(f,s),T[\"max_simplices\"]);\n\n if member([\"embedding\"],[indices(T)]) then\n  T0[\"embedding_dim\"] = T[\"embedding_dim\"];\n  for v in T[\"vertices\"] do\n   T0[\"embedding\"][f(v)] := T[\"embedding\"][v];\n  od:\n fi;\n\n return eval(T0);\nend:\n\n`set_edges/simplicial_complex` := proc(T,force := false)\n if type(T[\"edges\"],{list,set}) and not force then\n  return T[\"edges\"];\n fi;\n T[\"edges\"] := `edges/raw_simplicial_complex`(T[\"max_simplices\"]);\n return T[\"edges\"];\nend:\n\n`set_faces/simplicial_complex` := proc(T,force := false)\n if type(T[\"faces\"],{list,set}) and not force then\n  return T[\"faces\"];\n fi;\n T[\"faces\"] := `faces/raw_simplicial_complex`(T[\"max_simplices\"]);\n return T[\"faces\"];\nend:\n\n`set_all_simplices/simplicial_complex` := proc(T,force := false)\n local K,d,i;\n\n if (type(T[\"all_simplices\"],{list,set}) and not(force)) then\n  return T[\"all_simplices\"];\n fi;\n \n K := T[\"max_simplices\"];\n T[\"all_simplices\"] := `all_simplices/raw_simplicial_complex`(K);\n d := `dim/raw_simplicial_complex`(K);\n T[\"dim\"] := d;\n T[\"simplices_by_dim\"] := table():\n for i from 0 to d do\n  T[\"simplices_by_dim\"][i] :=\n   select(s -> nops(s) = i + 1,T[\"all_simplices\"]);\n od:\n return T[\"all_simplices\"];\nend:\n\n`dim/raw_simplicial_complex` := (K) -> max(map(nops,K)) - 1;\n\n`dim/simplicial_complex` := proc(T)\n local d;\n d := `dim/raw_simplicial_complex`(T[\"max_simplices\"]);\n T[\"dim\"] := d;\n return d;\nend:\n\n`euler_characteristic/raw_simplicial_complex` := proc(K)\n local L;\n \n L := `all_simplices/raw_simplicial_complex`(K);\n L := [op(L)];\n L := map(s -> (-1)^(nops(s)+1),L);\n return `+`(op(L));\nend:\n\n`euler_characteristic/simplicial_complex` := proc(T)\n local L;\n \n if not(type(T[\"all_simplices\"],{set,list})) then\n  T[\"all_simplices\"] := `all_simplices/raw_simplicial_complex`(T[\"max_simplices\"]);\n fi;\n  \n L := T[\"all_simplices\"];\n L := [op(L)];\n L := map(s -> (-1)^(nops(s)+1),L);\n return `+`(op(L));\nend:\n\n`has_embedding/simplicial_complex` := proc(T)\n if type(T[\"embedding\"],table) then\n  if not(type(T[\"embedding_dim\"],nonnegint))\n     and nops(T[\"vertices\"]) > 0 then\n   T[\"embedding_dim\"] := nops(T[\"embedding\"][T[\"vertices\"][1]]);\n  fi;\n  return true;\n else\n  return false;\n fi;\nend:\n\n`has_normal/simplicial_complex` := proc(T)\n if not(`has_embedding/simplicial_complex`(T)) then\n  return false;\n fi;\n\n return type(T[\"normal\"],table);\nend:\n\n# Condensation replaces a raw simplicial complex by an equivalent one in\n# which the vertex set has the form {1,...,n} for some n.\n\n`is_condensed/raw_simplicial_complex` := proc(K)\n local V,n,i;\n V := `vertices/raw_simplicial_complex`(K);\n n := nops(V);\n return evalb(V = {seq(i,i=1..n)});\nend;\n\n`condense/raw_simplicial_complex` := proc(K)\n local V,ix,n,i,L;\n V := `vertices/raw_simplicial_complex`(K);\n n := nops(V);\n for i from 1 to n do\n  ix[V[i]] := i;\n od:\n L := map(s -> map(v -> ix[v],s),K);\n return L;\nend:\n\n`is_condensed/simplicial_complex` := proc(T)\n local V,n,i;\n V := {op(T[\"vertices\"])};\n n := nops(V);\n return evalb(V = {seq(i,i=1..n)});\nend;\n\n`condense/simplicial_complex` := proc(T)\n local V,T0,n,i;\n\n T0 := table():\n V := T[\"vertices\"];\n n := nops(V);\n \n T0[\"max_simplices\"] := `condense/raw_simplicial_complex`(T[\"max_simplices\"]);\n T0[\"vertices\"] := {seq(i,i=1..n)};\n\n if `has_embedding/simplicial_complex`(T) then\n  T0[\"embedding_dim\"] := T[\"embedding_dim\"];\n  T0[\"embedding\"] := table();\n  for i from 1 to n do\n   T0[\"embedding\"][i] := T[\"embedding\"][V[i]];\n  od;\n\n  if `has_normal/simplicial_complex`(T) then\n   T0[\"normal\"] := table():\n   for i from 1 to n do\n    T0[\"normal\"][i] := T[\"normal\"][V[i]];\n   od;\n  fi;\n fi;\n\n return eval(T0);\nend:\n\n`clone/simplicial_complex` := proc(T)\n local T0,k,keys,i;\n\n T0 := table():\n keys := [\n  \"vertices\",\n  \"edges\",\n  \"faces\",\n  \"max_simplices\",\n  \"all_simplices\",\n  \"dim\",\n  \"embedding_dim\",\n  \"embedding\",\n  \"normal\"\n ];\n\n for k in keys do\n  if member([k],[indices(T)]) then\n   if type(T[k],table) then\n    T0[k] := table():\n    for i in [indices(T[k])] do\n     T0[k][op(i)] := T[k][op(i)];\n    od:\n   else\n    T0[k] := T[k];\n   fi;\n  fi;\n od:\n\n return eval(T0);\nend:\n\n`restrict/simplicial_complex` := proc(T,V0)\n local V1,T0,K0,P0,P,v;\n \n V1 := {op(V0)};\n if V1 minus {op(T[\"vertices\"])} <> {} then\n  error \"V0 is not a subset of the vertex set\";\n fi;\n\n T0 := table();\n T0[\"vertices\"] := V0;\n K0 := map(s -> {op(s)} intersect V1,T[\"max_simplices\"]);\n K0 := `normalise/raw_simplicial_complex`(K0);\n T0[\"max_simplices\"] := K0;\n\n P := T[\"embedding\"];\n if type(P,table) then\n  T0[\"embedding_dim\"] := T[\"embedding_dim\"];\n  P0 := table():\n  for v in V0 do\n   P0[v] := P[v];\n  od:\n  T0[\"embedding\"] := eval(P0);\n fi;\n\n return eval(T0);\nend:\n\n`disjoint_union/simplicial_complex` := proc(T,U)\n local n,U0,TU,v;\n \n if `is_condensed/simplicial_complex`(T) and\n    `is_condensed/simplicial_complex`(U) then\n  n := nops(T[\"vertices\"]);\n  U0 := `reindex/simplicial_complex`(U,i -> i + n);\n else\n  if {op(T[\"vertices\"])} intersect {op(U[\"vertex_set\"])} <> {} then\n   error \"Vertex sets are not disjoint\";\n  fi;\n  U0 := eval(U);\n fi;\n\n TU := table();\n TU[\"vertices\"] := [op(T[\"vertices\"]),op(U0[\"vertices\"])];\n TU[\"max_simplices\"] := [op(T[\"max_simplices\"]),op(U0[\"max_simplices\"])];\n\n if `has_embedding/simplicial_complex`(T) and\n    `has_embedding/simplicial_complex`(U0) and\n    T[\"embedding_dim\"] = U0[\"embedding_dim\"] then\n  TU[\"embedding_dim\"] := T[\"embedding_dim\"];\n  TU[\"embedding\"] := table();\n  for v in T[\"vertices\"] do\n   TU[\"embedding\"][v] := T[\"embedding\"][v];\n  od;\n  for v in U0[\"vertices\"] do\n   TU[\"embedding\"][v] := U0[\"embedding\"][v];\n  od;\n fi;\n\n return eval(TU);\nend:\n\n`join/simplicial_complex` := proc(T,U)\n local n,m,U0,TU,s,t,v;\n \n if `is_condensed/simplicial_complex`(T) and\n    `is_condensed/simplicial_complex`(U) then\n  n := nops(T[\"vertices\"]);\n  U0 := `reindex/simplicial_complex`(U,i -> i + n);\n else\n  if {op(T[\"vertices\"])} intersect {op(U[\"vertex_set\"])} <> {} then\n   error \"Vertex sets are not disjoint\";\n  fi;\n  U0 := eval(U);\n fi;\n\n TU := table();\n TU[\"vertices\"] := [op(T[\"vertices\"]),op(U0[\"vertices\"])];\n TU[\"max_simplices\"] := [\n  op(T[\"max_simplices\"]),\n  op(U0[\"max_simplices\"]),\n  seq(seq([op(s),op(t)],t in U0[\"max_simplices\"]),s in T[\"max_simplices\"])\n ];\n\n if `has_embedding/simplicial_complex`(T) and\n    `has_embedding/simplicial_complex`(U0) then\n  n := T[\"embedding_dim\"];\n  m := U0[\"embedding_dim\"];\n  TU[\"embedding_dim\"] := n+m+1;\n  TU[\"embedding\"] := table();\n  for v in T[\"vertices\"] do\n   TU[\"embedding\"][v] := [op(T[\"embedding\"][v]),0$(m+1)];\n  od;\n  for v in U0[\"vertices\"] do\n   TU[\"embedding\"][v] := [0$n,1,op(U0[\"embedding\"][v])];\n  od;\n fi;\n\n return eval(TU);\nend:\n\n\n# The following function checks whether we have an embedding of a raw\n# simplicial complex K in R^d.  The argument d is the embedding dimension.\n# The argument a should be a list or table, so that a[i] is an element\n# of R^d for each index i appearing in K.\n\n`is_embedding/raw_simplicial_complex` := proc(K,d,a)\n global reason;\n local m,Kl,Ka,i,j,k,eqd,bc,rr,AA,BB,u,v,w,p,M;\n \n m := nops(K);\n Kl := [op(K)];\n Ka := map(s -> [seq(a[i],i in s)],Kl);\n\n for u in Ka do\n  if not `is_element/simplices`(d)(u) then\n   reason := [\"is_embedding/simplicial_complex\",\"u is not a simplex in R^d\",u,d,reason];\n   return false;\n  fi;\n od;\n\n eqd := evalb({d+1,op(map(nops,Kl))} = {d+1});\n \n bc := map(`barycentre/simplex`(d),Ka):\n rr := map(`radius/simplex`(d),Ka):\n\n if eqd then\n  AA := map(`primal_matrix/simplex`(d),Ka):\n  BB := map(A -> 1/A,AA):\n fi;\n\n for i from 1 to m-1 do\n  for j from i+1 to m do\n   u := Ka[i];\n   v := Ka[j];\n   p := {op(K[i])} intersect {op(K[j])};\n   w := {seq(a[k],k in p)};\n   if not(nops(w) = nops(p) and\n          w = {op(u)} intersect {op(v)}) then\n    return false;\n   fi;\n   if evalf(`d_2/R`(d)(bc[i],bc[j]) - rr[i] - rr[j]) <= 0 then\n    if eqd then\n     M := <BB[i].AA[j],BB[j].AA[j]>;\n     if min(seq(max(seq(M[i,j],j=1..d+1)),i=1..2*d+2)) >= 0 then\n      if not(`intersect_nicely/simplices`(d)(u,v)) then\n       reason := [\"is_embedding/simplicial_complex\",\"bad intersection\",u,v];\n       return false;\n      fi;\n     fi;\n    else\n     if not(`intersect_nicely/simplices`(d)(u,v)) then\n      reason := [\"is_embedding/simplicial_complex\",\"bad intersection\",u,v];\n      return false;\n     fi;\n    fi;\n   fi;\n  od;\n od;\n\n return true;\nend:\n\n\n`star/simplicial_complex` := proc(T,s)\n local K,P,K0,T0,P0,s0,v;\n\n K := T[\"max_simplices\"];\n K := map(u -> {op(u)},{op(K)});\n if `is_simplex/raw_simplicial_complex`(K,s) then \n  s0 := {op(s)};\n elif member(s,T[\"vertices\"]) then\n  s0 := {s};\n else\n  error \"Second argument is not a vertex or simplex\";\n fi;\n \n K0 := select(u -> s0 minus u = {},K);\n T0 := `cook/raw_simplicial_complex`(K0);\n\n P := T[\"embedding\"];\n if type(P,table) then\n  T0[\"embedding_dim\"] := T[\"embedding_dim\"];\n  P0 := table():\n  for v in T0[\"vertices\"] do\n   P0[v] := P[v];\n  od:\n  T0[\"embedding\"] := eval(P0);\n fi;\n\n return eval(T0);\nend:\n\n`link/simplicial_complex` := proc(T,s)\n local K,s0,T0,T1;\n\n K := T[\"max_simplices\"];\n K := map(u -> {op(u)},{op(K)});\n if `is_simplex/raw_simplicial_complex`(K,s) then \n  s0 := {op(s)};\n elif member(s,T[\"vertices\"]) then\n  s0 := {s};\n else\n  error \"Second argument is not a vertex or simplex\";\n fi;\n\n T0 := `star/simplicial_complex`(T,s);\n T1 := `restrict/simplicial_complex`(T0,{op(T0[\"vertices\"])} minus s0);\n return eval(T1);\nend:\n\n# For a connected one-manifold (possibly with boundary), list the\n# vertices in natural order.  If the complex is a circle, then\n# the first vertex in the list is repeated at the end.\n\n`track/simplicial_complex` := proc(T,v_)\n local V,K,L,E,v,w,t,xx;\n \n if nops(T[\"vertices\"]) <= 1 then\n  return [op(T[\"vertices\"])];\n fi;\n \n if `dim/simplicial_complex`(T) > 1 then\n  error \"Dimension is bigger than one\";\n fi;\n\n if nops(`components/simplicial_complex`(T)) > 1 then\n  error \"Complex is not connected\";\n fi;\n\n V := T[\"vertices\"];\n if type(V,set) then V := sort([op(V)]); fi;\n \n K := {op(map(s -> {op(s)},T[\"max_simplices\"]))};\n L := table();\n\n for v in V do\n  L[v] := select(u -> u <> v and member({u,v},K),V);\n od;\n\n if max(seq(nops(L[v]),v in V)) > 2 then\n  error \"Complex is branched\";\n fi;\n\n E := select(v -> nops(L[v]) = 1, V);\n if E = [] then\n  if nargs > 1 then\n   if member(v_,V) then\n    v := v_;\n   else\n    error \"Invalid starting point\";\n   fi;\n  else\n   v := V[1];\n  fi;\n else\n  if nargs > 1 then\n   if member(v_,E) then\n    v := v_;\n   else\n    error \"Invalid starting point\";\n   fi;\n  else\n   v := E[1];\n  fi;\n fi;\n \n w := L[v][-1];\n t := [v,w];\n xx := {op(L[w])} minus {op(t)};\n while xx <> {} do\n  w := xx[1];\n  t := [op(t),w];\n  xx := {op(L[w])} minus {op(t)};\n od;\n\n if E = [] then t := [op(t),t[1]]; fi;\n \n return t;\nend:\n\n`barycentric_subdivision/raw_simplicial_complex` := proc(K)\n local V,n,i,j,P,L,d,s,t,p;\n \n V := `all_simplices/raw_simplicial_complex`(K);\n\n n := max(map(nops,V));\n for i from 1 to n do\n  P[i] := combinat[permute](i);\n od:\n\n L := NULL;\n for s in K do\n  d := nops(s);\n  for p in P[d] do\n   t := {seq(sort([seq(s[p[i]],i=1..j)]),j=1..d)};\n   L := L,t\n  od;\n od;\n\n return({L});\nend:\n\n`barycentric_subdivision/simplicial_complex` := proc(T)\n local K,E,K0,V0,T0,E0,d,s,x,v;\n\n K := T[\"max_simplices\"];\n K0 := `barycentric_subdivision/raw_simplicial_complex`(K);\n V0 := `vertices/raw_simplicial_complex`(K0);\n T0 := table():\n T0[\"vertices\"] := V0;\n T0[\"max_simplices\"] := K0;\n\n E := T[\"embedding\"];\n if type(E,table) then\n  d := T[\"embedding_dim\"];\n  T0[\"embedding_dim\"] := d;\n  E0 := table();\n  for s in V0 do\n   x := [0$d];\n   for v in s do x := x +~ E[v]; od;\n   x := x /~ nops(s);\n   E0[s] := x;\n  od;\n  T0[\"embedding\"] := eval(E0);\n fi;\n\n return eval(T0);\nend:\n\n`triangular_subdivision/simplicial_complex` := proc(T)\n local V,E,F,V0,E0,E1,E2,F0,T0,v,e,f,d,P,P0;\n\n if `dim/simplicial_complex`(T) > 2 then\n  error \"Triangular subdivision is only for complexes of dimension <= 2\";\n  # There is a version for dimension 3, with an extra simplex at the\n  # barycentre of each tetrahedron as well as each edge, but we have\n  # not coded it yet.  Perhaps there is a version where we adjoin the\n  # barycentre of each simplex of odd dimension?  Note that even in\n  # dimension two, this triangular subdivision is different from, and\n  # more symmetrical than, the edgewise subdivision.  The edgewise\n  # subdivision needs some kind of order on the vertices.\n fi;\n V := T[\"vertices\"];\n E := `edges/raw_simplicial_complex`(T[\"max_simplices\"]);\n F := `faces/raw_simplicial_complex`(T[\"max_simplices\"]);\n E := map(e -> sort([op(e)]),E);\n E := sort([op(E)]);\n F := map(f -> sort([op(f)]),F);\n F := sort([op(F)]);\n \n V0 := [seq([v],v in V),seq(sort([op(e)]),e in E)];\n E0 := [seq(op([[[e[1]],e],[[e[2]],e]]), e in E),\n        seq(op([\n\t [[f[1],f[2]],[f[1],f[3]]],\n\t [[f[1],f[2]],[f[2],f[3]]],\n\t [[f[1],f[3]],[f[2],f[3]]]\t \n\t]), f in F)\n       ];\n F0 := [seq(op([\n         [[f[1]],[f[1],f[2]],[f[1],f[3]]],\n         [[f[2]],[f[1],f[2]],[f[2],f[3]]],\n         [[f[3]],[f[1],f[3]],[f[2],f[3]]],\n\t [[f[1],f[2]],[f[1],f[3]],[f[2],f[3]]]\n        ]),f in F)];\n\n T0 := table():\n T0[\"vertices\"] := V0;\n T0[\"edges\"] := E0;\n T0[\"faces\"] := F0;\n\n E1 := {op(map(f -> op({[f[1],f[2]],[f[1],f[3]],[f[2],f[3]]}),F0))};\n E2 := {op(E0)} minus E1;\n E2 := [op(E2)];\n T0[\"max_simplices\"] := [op(E2),op(F0)];\n\n P := T[\"embedding\"];\n if type(P,table) then\n  d := T[\"embedding_dim\"];\n  T0[\"embedding_dim\"] := d;\n  P0 := table();\n  for v in V do\n   P0[[v]] := P[v];\n  od:\n\n  for e in E do\n   P0[e] := (P[e[1]] +~ P[e[2]]) /~ 2;\n  od:\n  T0[\"embedding\"] := eval(P0);\n fi;\n\n return T0;\nend:\n\n`partial_triangular_subdivision/simplicial_complex` := proc(T,S)\n local S0,Si,V,E,F,V0,E0,F0,nV,nS,e,e1,e2,e3,f,is_long,fin,\n  long_edges,p,p1,p2,p3,q,i,T0;\n\n S0 := map(e -> sort([op(e)]),S);\n S0 := sort([op(S0)]);\n\n E := `edges/raw_simplicial_complex`(T[\"max_simplices\"]);\n F := `faces/raw_simplicial_complex`(T[\"max_simplices\"]);\n E := map(e -> sort([op(e)]),E);\n E := sort([op(E)]);\n F := map(f -> sort([op(f)]),F);\n F := sort([op(F)]);\n\n is_long := table():\n for e in E do \n  is_long[e] := false;\n od:\n for e in S0 do \n  is_long[e] := true;\n od:\n\n fin := false;\n long_edges := table():\n\n while not fin do\n  fin := true;\n\n  for f in F do \n   e1 := [f[1],f[2]];\n   e2 := [f[1],f[3]];\n   e3 := [f[2],f[3]];\n   long_edges[f] := select(e -> is_long[e],[e1,e2,e3]);\n   if nops(long_edges[f]) = 2 then \n    fin := false;\n    is_long[e1] := true;\n    is_long[e2] := true;\n    is_long[e3] := true;\n   fi;\n  od:\n od:\n\n S0 := select(e -> is_long[e],E);\n V := T[\"vertices\"];\n nV := nops(V):\n nS := nops(S0):\n\n Si := table():\n for i from 1 to nS do \n  Si[S0[i]] := nV + i;\n od:\n\n F0 := NULL;\n for f in F do \n  e1 := [f[1],f[2]];\n  e2 := [f[1],f[3]];\n  e3 := [f[2],f[3]];\n  if nops(long_edges[f]) = 0 then \n  if nops(f) < 3 then print([\"err0\",f]); fi;\n   F0 := F0,f;\n  elif nops(long_edges[f]) = 1 then \n   e := long_edges[f][1];\n   p := ({op(f)} minus {op(e)})[1];\n   q := Si[long_edges[f][1]];\n   if nops({e[1],p,q}) < 3 then print([\"err1\",f,e[1],p,q]); fi;\n   if nops({e[2],p,q}) < 3 then print([\"err2\",f,e[2],p,q]); fi;\n   F0 := F0,[e[1],p,q],[e[2],p,q];\n  elif nops(long_edges[f]) = 2 then \n   print([\"shouldn't happen\",f]);\n  else \n   p1 := Si[e1]; p2 := Si[e2]; p3 := Si[e3];\n   if nops({f[1],p1,p2}) < 3 then print([\"err3\",f,p1,p2,p3]); fi;\n   if nops({f[2],p1,p3}) < 3 then print([\"err4\",f,p1,p2,p3]); fi;\n   if nops({f[3],p2,p3}) < 3 then print([\"err4\",f,p1,p2,p3]); fi;\n   if nops({p1,p2,p3})   < 3 then print([\"err5\",p1,p2,p3]); fi;\n   F0 := F0, [f[1],p1,p2],[f[2],p1,p3],[f[3],p2,p3],[p1,p2,p3];\n  fi;\n od:\n V0 := [seq(i,i=1..nV+nS)];\n F0 := sort([op(map(sort,{F0}))]);\n T0 := table():\n T0[\"vertices\"] := V0;\n T0[\"max_simplices\"] := F0;\n T0[\"embedding_dim\"] := T[\"embedding_dim\"]:\n T0[\"embedding\"] := table():\n for i from 1 to nV do T0[\"embedding\"][i] := T[\"embedding\"][i]; od;\n for i from 1 to nS do \n  e := S0[i];\n  T0[\"embedding\"][nV+i] := 0.5 *~ (T[\"embedding\"][e[1]] +~ T[\"embedding\"][e[2]]);\n od;\n `set_faces/simplicial_complex`(T0,true);\n `set_edges/simplicial_complex`(T0,true);\n\n return eval(T0);\nend:\n\n`star_subdivide/simplicial_complex` := proc(T,s)\n local n,V,K,K1,S0,S1,S2,s0,s1,s2,u,P,d,x,v,i;\n\n if nops(s) = 1 then return; fi;\n \n n := nops(T[\"vertices\"]);\n V := [seq(i,i=1..n)];\n if {op(T[\"vertices\"])} <> {op(V)} then\n  error \"Star subdivision is only implemented for condensed complexes\";\n fi;\n\n K := T[\"max_simplices\"];\n K := map(u -> {op(u)},{op(K)});\n \n s0 := {op(s)};\n S1,S0 := selectremove(u -> s0 minus {op(u)} = {},K);\n S2 := {seq(seq(u minus {v},v in s),u in S1)};\n\n K1 := {op(S0),seq({op(u),n+1},u in S2)};\n K1 := map(u -> sort([op(u)]),K1);\n K1 := sort([op(K1)]);\n \n T[\"vertices\"] := [seq(i,i=1..n+1)];\n T[\"max_simplices\"] := K1;\n\n P := T[\"embedding\"];\n if type(P,table) then\n  d := T[\"embedding_dim\"];\n  x := [0$d];\n  for v in s do x := x +~ P[v]; od;\n  x := evalf(x /~ nops(s));\n  P[n+1] := x;\n fi;\nend:\n\n# This function can be applied to a simplicial surface T with a\n# vertex v whose link is an octagon, thought of as a bisected\n# square.  The vertex w is the midpoint of one edge of the square.\n# This function performs a subdivision that affects the star of v\n# by adding four new vertices at the midpoints of the edges\n# joining v to the corners of the square.  It returns a new vertex\n# w', so that the process can be repeated using v and w'.\n`square_refine/simplicial_complex` := proc(T,v,w)\n local n,K,L,W,P,old_faces,new_faces,i;\n if not(`is_condensed/simplicial_complex`(T)) then\n  error \"Complex is not condensed\";\n fi;\n\n n := nops(T[\"vertices\"]);\n L := `link/simplicial_complex`(T,v);\n W := `track/simplicial_complex`(L,w);\n\n if nops(W) <> 9 then\n  error \"Link is not square\";\n fi;\n\n old_faces := {seq({v,W[i],W[i+1]},i=1..8)};\n new_faces := {\n  {v,W[1],n+1},{v,n+1,W[3]},{v,W[3],n+2},{v,n+2,W[5]},\n  {v,W[5],n+3},{v,n+3,W[7]},{v,W[7],n+4},{v,n+4,W[1]},\n  {W[1],W[2],n+1},{W[2],W[3],n+1},{W[3],W[4],n+2},{W[4],W[5],n+2},\n  {W[5],W[6],n+3},{W[6],W[7],n+3},{W[7],W[8],n+4},{W[8],W[1],n+4}\n };\n\n T[\"vertices\"] := [seq(i,i=1..n+4)];\n K := T[\"max_simplices\"];\n K := {op(map(s -> {op(s)},K))};\n K := (K minus old_faces) union new_faces;\n K := map(s -> sort([op(s)]),K);\n K := sort([op(K)]);\n T[\"max_simplices\"] := K;\n\n if `has_embedding/simplicial_complex`(T) then\n  P := T[\"embedding\"];\n  P[n+1] := (P[v] +~ P[W[2]]) /~ 2;\n  P[n+2] := (P[v] +~ P[W[4]]) /~ 2;\n  P[n+3] := (P[v] +~ P[W[6]]) /~ 2;\n  P[n+4] := (P[v] +~ P[W[8]]) /~ 2;\n fi;\n\n return n+1;\nend:\n\n# Here P is expected to be a table indexed by points \n# i in the 2-simplex for which 2^m * i is integral. \n# The values are either NULL or vectors in R^3, and\n# the values at the vertices of the 2-simplex must \n# be in R^3.  The third parameter r is supposed to\n# be a retraction of R^3 onto a subspace Z, and it\n# is expected that the non-NULL values of P should \n# lie in that subspace.  The procedure fills in the \n# values P[i] for all i so they lie in Z and are \n# spaced out in a reasonably regular way.\n\n`midpoint_extend/simplicial_complex` := proc(P,m,r) \n local X0,p,q,i,j,k,x,y,u,N;\n\n X0 := {[1,-1,0],[-1,1,0],[1,0,-1],[-1,0,1],[0,1,-1],[0,-1,1]};\n\n for p from 0 to m do \n  q := 2^p;\n  for i from 0 to q do \n   for j from 0 to q - i do \n    k := q - i - j;\n    x := [i,j,k];\n    if P[x /~ q] = NULL then\n     N := select(y -> min(op(x +~ y)) >= 0 and \n                      min(op(x -~ y)) >= 0 and\n                      P[(x +~ y) /~ q] <> NULL and\n                      P[(x -~ y) /~ q] <> NULL,X0):\n     if N = {} then DEBUG(); fi;\n     u := [0,0,0]:\n     for y in N do u := u +~ P[(x +~ y)/~ q]; od:\n     u := evalf(u /~ nops(N));\n     u := r(u);\n     P[x /~ q] := u;\n    fi:\n   od:\n  od:\n od:\nend:\n\n\n`normalise_embedding/simplicial_complex` := proc(T)\n local d,P,v,x,i;\n \n d := T[\"embedding_dim\"];\n P := T[\"embedding\"];\n for v in T[\"vertices\"] do\n  x := evalf(P[v]);\n  if not(type(x,[numeric $d])) then\n   print([v,x]);\n   error \"Bad vertex position\";\n  fi;\n  x := evalf(x /~ sqrt(add(x[i]^2,i=1..d)));\n  P[v] := x;\n od:\nend:\n\n`map_in_place/simplicial_complex` := proc(f,T)\n local E,v;\n\n E := eval(T[\"embedding\"]);\n for v in T[\"vertices\"] do E[v] := f(E[v]); od:\nend:\n\n`map/simplicial_complex` := proc(f,T)\n local T0;\n\n T0 := eval(`clone/simplicial_complex`(T));\n `map_in_place/simplicial_complex`(f,T0);\n return eval(T0);\nend:\n\n`plot/raw_simplicial_complex` := proc(K,d,a)\n local V,E,F,v,e,f,P;\n\n V := `vertices/raw_simplicial_complex`(K);\n E := `edges/raw_simplicial_complex`(K);\n F := `faces/raw_simplicial_complex`(K);\n\n P :=\n  seq(point(a[v]),v in V),\n  seq(line(a[e[1]],a[e[2]]),e in E),\n  seq(polygon([a[f[1]],a[f[2]],a[f[3]]],colour=red),f in F);\n\n return display(P,scaling=constrained,axes=none):\nend:\n\n`plot/simplicial_complex` := proc(T,a_)\n local V,E,F,v,e,f,a;\n \n `set_edges/simplicial_complex`(T);\n `set_faces/simplicial_complex`(T);\n V := T[\"vertices\"];\n E := T[\"edges\"];\n F := T[\"faces\"];\n a := `if`(nargs > 1, a_, T[\"embedding\"]);\n T[\"plot\"] := display(\n  seq(point(a[v]),v in V),\n  seq(line(a[e[1]],a[e[2]]),e in E),\n  seq(polygon([a[f[1]],a[f[2]],a[f[3]]],colour=red),f in F),\n  scaling=constrained,axes=none):\n return T[\"plot\"];\nend:\n\n`surface_plot/simplicial_complex` := proc(T,a_)\n local V,E,F,f,a;\n \n `set_faces/simplicial_complex`(T);\n F := T[\"faces\"];\n a := `if`(nargs > 1, a_, T[\"embedding\"]);\n T[\"surface_plot\"] := display(\n  seq(polygon([a[f[1]],a[f[2]],a[f[3]]],style=patchnogrid),f in F),\n  scaling=constrained,axes=none):\n return T[\"surface_plot\"];\nend:\n\n`vertex_labels/simplicial_complex` := proc(T)\n local v;\n if T[\"embedding_dim\"] = 2 then\n  display(seq(textplot([op(T[\"embedding\"][v]),sprintf(\"%A\",v)]),v in T[\"vertices\"]),\n          axes=none,scaling=constrained);\n elif T[\"embedding_dim\"] = 3 then\n  display(seq(textplot3d([op(T[\"embedding\"][v]),sprintf(\"%A\",v)]),v in T[\"vertices\"]),\n          axes=none,scaling=constrained);\n else\n  error \"No 2 or 3 dimensional embedding\";\n fi;\nend:\n\n`set_javascript/simplicial_complex` := proc(T,format_)\n local format,format3,V,F,F1,P,N,V_string,N_string,F_string,T_string,f,f1,n1,n2,v,i;\n\n format := `if`(nargs > 1,format_,\"%f\");\n format3 := sprintf(\"[%s,%s,%s]\",format,format,format);\n if not(`has_embedding/simplicial_complex`(T)) then\n  error \"Complex has no embedding data\";\n fi;\n\n if T[\"embedding_dim\"] <> 3 then\n  error \"Complex is not in R3\";\n fi;\n\n V := T[\"vertices\"];\n P := eval(T[\"embedding\"]);\n `set_faces/simplicial_complex`(T);\n F := T[\"faces\"];\n F := sort([op(map(f -> sort([op(f)]),F))]);\n \n V_string :=\n  cat(\"[\",StringTools[Join]([seq(sprintf(format3,op(evalf(P[v]))),v in V)],\",\"),\"]\");\n\n if type(T[\"normal\"],table) then\n  N := eval(T[\"normal\"]);\n  N_string := \n   cat(\"[\",StringTools[Join]([seq(sprintf(format3,op(evalf(N[v]))),v in V)],\",\"),\"]\");\n  F1 := NULL;\n  for f in F do\n   n1 := cross_product(P[f[2]] -~ P[f[1]],P[f[3]] -~ P[f[1]]);\n   n2 := N[f[1]] +~ N[f[2]] +~ N[f[3]];\n   if add(n1[i] * n2[i],i=1..3) > 0 then \n    f1 := [f[1]-1,f[2]-1,f[3]-1];\n   else \n    f1 := [f[1]-1,f[3]-1,f[2]-1];\n   fi;\n   F1 := F1,f1;\n  od:\n  F1 := [F1];\n  F_string := \n   cat(\"[\",StringTools[Join]([seq(sprintf(\"%A\",f),f in F1)],\",\"),\"]\");\n  T_string :=\n   sprintf(\"{\\npositions:\\n%s,\\nnormals:\\n%s,indices:\\n%s }\",\n           V_string,N_string,F_string);\n else\n  F_string := \n   cat(\"[\",StringTools[Join]([seq(sprintf(\"%A\",f),f in F)],\",\"),\"]\");\n  T_string :=\n   sprintf(\"{\\npositions:\\n%s,indices:\\n%s }\",\n           V_string,F_string);\n fi;\n\n T[\"javascript\"] := T_string;\n \n return T_string;\nend:\n", "meta": {"hexsha": "5827ca7bf7c2ec92731013cf254e124ef33a3b53", "size": 26724, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/simplicial_complexes/simplicial_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/simplicial_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/simplicial_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": 24.6531365314, "max_line_length": 95, "alphanum_fraction": 0.5836326897, "num_tokens": 9527, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7057850278370112, "lm_q2_score": 0.6654105587468141, "lm_q1q2_score": 0.4696368097281614}}
{"text": "######################################################################\n\n`is_element/WFbar` := (N::posint) -> (A::set) -> proc(TTxl)\n local TT,x,l,TT1,T,n,u,children;\n global reason;\n\n if not(type(TTxl,list) and nops(TTxl) = 3) then\n  reason := [convert(procname,string),\"TTxl cannot be split as [TT,x,l]\",TTxl];\n  return false;\n fi;\n\n TT,x,l := op(TTxl);\n\n if not(`is_element/trees`(A)(TT)) then\n  reason := [convert(procname,string),\"TT is not a tree on A\",TT,A];\n  return false;\n fi;\n\n TT1 := select(U -> nops(U) > 1,TT);\n\n if not(type(x,table)) then\n  reason := [convert(procname,string),\"x is not a table\",x];\n  return false;\n fi;\n\n if map(op,{indices(x)}) <> TT1 then\n  reason := [convert(procname,string),\"x is not indexed by TT1\",x,TT1];\n  return false;\n fi;\n\n children := `children_map`(A)(TT);\n for T in TT1 do\n  if not(`is_element/Fbar`(N)(children[T])(x[T])) then\n   reason := [convert(procname,string),\"x[T] has invalid type\",T,x[T],reason];\n   return false;\n  fi;\n od;\n\n if not(type(l,table)) then\n  reason := [convert(procname,string),\"l is not a table\",l];\n  return false;\n fi;\n\n if map(op,{indices(l)}) <> TT then\n  reason := [convert(procname,string),\"l is not indexed by TT\",l,TT];\n  return false;\n fi;\n\n n := nops(A);\n\n for T in TT do\n  if not(`is_element/RR`(l[T]) and l[T] >= 0 and l[T] <= 1) then\n   reason := [convert(procname,string),\"l[T] is not in the unit interval\",T,l[T]];\n   return false;\n  fi;\n\n  if nops(T) = 1 and l[T] <> 1 then\n   reason := [convert(procname,string),\"l[{a}] <> 1\",op(T),l[T]];\n   return false;\n  fi;\n\n  if nops(T) = n and l[T] <> 1 then\n   reason := [convert(procname,string),\"l[A] <> 1\",T,l[T]];\n   return false;\n  fi;\n od;\n\n return true;\nend;\n\n`is_interior/WFbar` := (N::posint) -> (A::set) -> proc(TTxl)\n local TT,x,l,n,T;\n global reason;\n\n TT,x,l := op(TTxl);\n n := nops(A);\n\n for T in TT do\n  if nops(T) > 1 and nops(T) < n and l[T] = 1 then\n   reason := [convert(procname,string),\"not interior, l[T] = 1\",T];\n   return false;\n  fi;\n od:\n\n return true;\nend;\n\n`is_reduced/WFbar` := (N::posint) -> (A::set) -> proc(TTxl)\n local TT,x,l,T;\n global reason;\n\n TT,x,l := op(TTxl);\n\n for T in TT do\n  if l[T] = 0 then\n   reason := [convert(procname,string),\"not reduced, l[T] = 0\",T];\n   return false;\n  fi;\n od:\n\n return true;\nend;\n\n`reduce_once/WFbar` := (N::posint) -> (A::set) -> proc(TTxl,T)\n local TT,x,l,parent,children,n,TT1,x1,l1,U,B,C,X,p,y,z;\n\n TT,x,l := op(TTxl);\n\n parent := `parent_map`(A)(TT);\n children := `children_map`(A)(TT);\n\n TT1 := TT minus {T};\n\n U := parent[T];\n C := children[U];\n B := C minus {T} union children[T];\n\n p := table();\n for X in C minus {T} do p[X] := X; od;\n for X in children[T] do p[X] := T; od;\n\n y := table();\n for X in C minus {T} do y[X] := `eta/Fbar`(N)({X}); od;\n y[T] := x[T];\n\n z := `gamma/Fbar`(N)(B,C)(p)(x[U],y);\n\n x1 := table();\n l1 := table();\n\n for X in TT1 do\n  l1[X] := l[X];\n  if nops(X) > 1 then\n   x1[X] := `if`(X = U,eval(z),eval(x[X]));\n  fi;\n od;\n\n return([TT1,eval(x1),eval(l1)]);\nend;\n\n`reduce/WFbar` := (N::posint) -> (A::set) -> proc(TTxl)\n local is_reduced,X,TT,x,l,T;\n\n is_reduced := false;\n X := TTxl;\n\n while not(is_reduced) do\n  TT,x,l := op(X);\n  is_reduced := true;\n\n  for T in TT do\n   if l[T] = 0 then \n    is_reduced := false;\n    X := `reduce_once/WFbar`(N)(A)(X,T);\n    break;\n   fi;\n  od:\n od;\n\n return X;\nend;\n\n`is_equal/WFbar` := (N::posint) -> (A::set) -> proc(X0,X1)\n local Y0,Y1,TT0,TT1,x0,x1,l0,l1,children,T;\n global reason;\n\n Y0 := `reduce/WFbar`(N)(A)(X0);\n Y1 := `reduce/WFbar`(N)(A)(X1);\n TT0,x0,l0 := op(Y0);\n TT1,x1,l1 := op(Y1);\n\n if TT0 <> TT1 then\n  reason := [convert(procname,string),\"TT0 <> TT1\",TT0,TT1];\n  return false;\n fi;\n\n children := `children_map`(A)(TT0);\n\n for T in TT0 do\n  if l0[T] <> l1[T] then\n   reason := [convert(procname,string),\"l0[T] <> l1[T]\",T,l0[T],l1[T]];\n   return false;\n  fi;\n\n  if nops(T) > 1 then\n   if not(`is_equal/Fbar`(N)(children[T])(x0[T],x1[T])) then\n    reason := [convert(procname,string),\"x0[T] <> x1[T]\",T,x0[T],x1[T],reason];\n    return false;\n   fi;\n  fi;\n od;\n\n return true;\nend;\n\n`is_leq/WFbar` := NULL;\n\n`random_element/WFbar` := (N::posint) -> (A::set) -> proc()\n local TT,x,l,TT1,T,n,children,d;\n\n d := 3;\n TT := `random_element/full_trees`(A)();\n\n TT1 := select(U -> nops(U) > 1,TT);\n\n x := table();\n l := table();\n\n children := `children_map`(A)(TT);\n for T in TT1 do\n  x[T] := `random_element/Fbar`(N)(children[T])();\n od;\n\n n := nops(A);\n\n for T in TT do\n  if nops(T) = 1 or nops(T) = n then \n   l[T] := 1;\n  else \n   l[T] := rand(0..d)()/d;\n  fi;\n od;\n\n return [TT,eval(x),eval(l)];\nend;\n\n`list_elements/WFbar` := NULL;\n`count_elements/WFbar` := NULL;\n", "meta": {"hexsha": "54474bbd39f51fa1b05b571227826881528d5bdd", "size": 4652, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/operads/fulton/WFbar.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/fulton/WFbar.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/fulton/WFbar.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.3144104803, "max_line_length": 82, "alphanum_fraction": 0.5634135856, "num_tokens": 1658, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998714925403, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.4694361367454416}}
{"text": "# File: RigidMotionsRecoverNMM.mpl \n#\n# Description:\n#  This file contains functions used to obtain an arrangement 6 dimensional parameter space of 3D\n#  digitized rigid motions.\n#  This code has been written for research propose and its aim is to calculate a particular\n#  arrangement of quadrics. Therefore, it can or it cannot be useful in study of generic\n#  arrangements. The final output are sample points of full dimensional open cells.\n#\n#  The code was written in relation with the paper: Kacper Pluta, Guillaume Moroz, Yukiko\n#  Kenmochi, Pascal Romon, Quadric arrangement in classifying rigid motions of a 3D digital image,\n#  2016, https://hal.archives-ouvertes.fr/hal-01334257 referred late on as [Quadrics:2016].\n#\n# Author:\n#  Kacper Pluta - kacper.pluta@esiee.fr\n#  Laboratoire d'Informatique Gaspard-Monge - LIGM, A3SI, France\n#\n# Date:\n#  11/12/2015 \n#\n# License:\n#  Simplified BSD License\n#\n# Copyright (c) 2015, Kacper Pluta\n# All rights reserved.\n\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#   * Redistributions of source code must retain the above copyright\n#     notice, this list of conditions and the following disclaimer.\n#   * Redistributions in binary form must reproduce the above copyright\n#     notice, this list of conditions and the following disclaimer in the\n#     documentation and/or other materials provided with the distribution.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\n# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n# DISCLAIMED. IN NO EVENT SHALL Kacper Pluta BE LIABLE FOR ANY\n# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n#\n#\n\nRigidMotionsRecoverNMM := module() \n  option package;\n  uses   RigidMotionsParameterSpaceCommon, RigidMotionsMaplePrimesCode;\n  \n  (* String which represents a type of the neighborhood i.e. N1, N2 or N3. *)\n  global nTypeGlobal;\n  (* String which represents the path to the database. *)\n  global dbPathGlobal; \n  (* List of integers which are the indices of half-grid planes. *)\n  global kRangeGlobal;\n  (* List of the variables in which the problem is expressed. *)\n  global varsGlobal;\n\n  (*Controls how many sample points should be fetch from the database in one quary.*)\n  export BUFFER_SIZE := 1000;\n\n  export ParallelCalculateNMM, Get3DNMM, RecoverTranslationSamplePoints, GetOrderedCriticalPlanes,\n  CriticalPlanes, CalculateNMM, LaunchFindDistinctSamplePoints,  LaunchComputeNMM,\n  FetchSamplePointsFromDB, FetchTopologicallyDistinctSamplePointsFromDB,\n  ParallelFindTopologicallyDistinctSamplePoints;\n\n\n# Procedure: CriticalPlanes\n#   Compute critical planes in the remainder range\n#\n# Parameters:\n#   R                - the rotation matrix obtained from CayleyTransform\n#   neighborhood     - a neighborhood for which one wants to compute NMM\n#   kRange           - a range of planes to consider\n#\n# Output :\n#   Returns a list of lists each containing critical planes for one direction\nCriticalPlanes := proc(R::Matrix, neighborhood::list, kRange::list)\n  # we remove the element [0, 0, 0]\n  local n := subsop(ListTools:-Search([0,0,0], neighborhood)=NULL, neighborhood); \n  local T := combinat:-cartprod([n, kRange]);\n  local planes := [[],[],[]], params;\n  while not T[finished] do \n    params := T[nextvalue](); \n    planes[1] := [op(planes[1]), (R . Vector(3, params[1]) - Vector(3, params[2]-1/2))[1]]; \n    planes[2] := [op(planes[2]), (R . Vector(3, params[1]) - Vector(3, params[2]-1/2))[2]]; \n    planes[3] := [op(planes[3]), (R . Vector(3, params[1]) - Vector(3, params[2]-1/2))[3]];\n  end do;\n return planes;\nend proc;\n\n\n# Procedure: Get3DNMM\n#   Compute neighbourhood motion maps\n#\n# Parameters:\n#   neighborhood     - a neighborhood for which one wants to compute NMM\n#   sampleTrans     - a midpoint of a frame in the remainder range\n#   R                - the rotation matrix obtained from CayleyTransform\n#\n# Output:\n#   Returns 3D neighborhood motion map for given vars and corresponding translations.\nGet3DNMM := proc(neighborhood::list, sampleTrans::Vector, R::Matrix) \n  local n, NMM := [];\n  for n in neighborhood do\n    NMM := [op(NMM), convert(map[inplace](round, R.Vector(3, n) + sampleTrans), list)];\n  od;\n  return NMM;\nend proc;\n\n\n# Procedure: RecoverTranslationSamplePoints\n#   Compute midpoints of each frame in the remainder range\n#\n# Parameters:\n#   planes            - ordered list of critical planes in the remainder range\n#\n# Output:\n#   Returns centers of frames in the remainder range\nRecoverTranslationSamplePoints := proc(planes::list) \n  local s:\n    s := proc(planes::list, i::integer, j::integer, k::integer)\n      return [(1/2) * add(planes[1][i .. i+1]), (1/2)*add(planes[2][j.. j+1]), \n                                            (1/2)*add(planes[3][k .. k+1])];\n  end proc;\n  return [seq(seq(seq(s(planes, i, j, k), k=1..nops(planes[3]-1)),\n               j=1..nops(planes[2]-1)), i =1..nops(planes[1])-1)];\nend proc;\n\n\n# Procedure: GetOrderedCriticalPlanes\n#   Compute critical planes in the remainder range\n#\n# Parameters:\n#   vars             - a list of variables\n#   samplePoint      - a rotational sample point \n#   planes           - a precomputed list of planes in the remainder range\n#\n# Output:\n#   Returns the ordered critical planes in the remainder range for X, Y and Z directions and order\n#   signature.\nGetOrderedCriticalPlanes := proc(vars::list, samplePoint::list, planes::list) \n  local params, sdPlanes := [[],[],[]];\n  local xSig, ySig, zSig, Signature;\n  \n  if nops(vars) <> 3 then\n    error \"Only 3D arrangement is supported.\";\n  fi;\n  \n  sdPlanes[1] := eval(planes[1], [vars[1] = samplePoint[1], vars[2] = samplePoint[2], vars[3] =\n                                                                                  samplePoint[3]]);\n  sdPlanes[2] := eval(planes[2], [vars[1] = samplePoint[1], vars[2] = samplePoint[2], vars[3] =\n                                                                                  samplePoint[3]]);\n  sdPlanes[3] := eval(planes[3], [vars[1] = samplePoint[1], vars[2] = samplePoint[2], vars[3] =\n                                                                                  samplePoint[3]]);\n  \n  xSig, sdPlanes[1] := Isort(sdPlanes[1]); \n  ySig, sdPlanes[2] := Isort(sdPlanes[2]); \n  zSig, sdPlanes[3] := Isort(sdPlanes[3]);\n  \n  # remove all out of the range regions \n  sdPlanes[1] := remove(proc(x) return evalb(x <= -1/2) end proc,\n  remove(proc(x) return evalb(x >= 1/2) end proc, sdPlanes[1]));\n  sdPlanes[2] := remove(proc(x) return evalb(x <= -1/2) end proc,\n  remove(proc(x) return evalb(x >= 1/2) end proc, sdPlanes[2]));\n  sdPlanes[3] := remove(proc(x) return evalb(x <= -1/2) end proc,\n  remove(proc(x) return evalb(x >= 1/2) end proc, sdPlanes[3]));\n  # add region boarders\n  sdPlanes[1] := [-1/2,op(sdPlanes[1]),1/2];\n  sdPlanes[2] := [-1/2,op(sdPlanes[2]),1/2];\n  sdPlanes[3] := [-1/2,op(sdPlanes[3]),1/2]; \n\n  Signature := cat(op(map(proc (x) sprintf(\"%d\", x) end proc, [op(xSig), op(ySig), op(zSig)])));\n  return Signature, sdPlanes;\nend proc:\n\n\n# Procedure: CalculateNMM\n#   Reads data from hard drive and generates NMM\n#\n# Parameters:\n#   vars             - list of variables in which the problem is expressed\n#   planes           - a precomputed list of planes in the remainder range\n#   buffer           - an Array which contains rotational sample points\n#   N                - a given neighborhood\n#   R                - a Matrix computed with Cayley transform\n#   db               - an instance of ComputationRegister with open connection to the database\n# Output:\n#   A neighborhood motion map is saved in the database.\n#\nCalculateNMM := proc(vars::list, planes::list, buffer::Array, N::list, R::Matrix,\n                                                         db::ComputationRegister) \n  local sdPlanes, trans, x, RR, y, NMM; \n  for x in buffer do\n    RR := eval(R, [vars[1] = x[2], vars[2] = x[3], vars[3] = x[4]]);\n    sdPlanes := GetOrderedCriticalPlanes(vars, x[2..()], planes)[2]; \n    trans := RecoverTranslationSamplePoints(sdPlanes); \n    for y in trans do\n      NMM := Get3DNMM(N, Vector(3, y), RR);\n      InsertNMM(db, x[1], NMM, y);\n    od;\n  end do;\nend proc:\n\n\n\n# Procedure: FetchTopologicallyDistinctSamplePointsFromDB\n#   Used to fetch topologically distinct rotational sample points from the database. The number of \n#   sample points is controlled by BUFFER_SIZE.\n#\n# Parameters:\n#   db::ComputationRegister       - an instance of ComputationRegister with open connection to the\n#                                   database.\n#   fromID::integer               - an id of the first sample point from a range to be fetched\n#   last::integer                 - an id of the very last sample points to be fetched\n#\n# Output:\n#   An Array of lists which of each represent a sample point. Note that the first element of each\n#   list is an id of a given sample point.\nFetchTopologicallyDistinctSamplePointsFromDB := proc(db::ComputationRegister, fromID::integer, \n                                                                                last::integer)\n  local n := fromID + RigidMotionsRecoverNMM:-BUFFER_SIZE - 1;\n  if n > last then\n    n := last;\n  fi;\n  return FetchTopologicallyDistinctSamplePoints(db, fromID, n); \nend proc;\n\n\n# Procedure: ParallelCalculateNMM\n#   Uses Grid framework to generates unique NMM.\n#\nParallelCalculateNMM := proc() \n  local db:= Object(ComputationRegister, dbPathGlobal), n;\n  local noTPoints;\n  local first::integer, last::integer;\n  local R := CayleyTransform(varsGlobal), N := GetNeighborhood(nTypeGlobal); \n  local planes := RigidMotionsRecoverNMM:-CriticalPlanes(R, N, kRangeGlobal);\n  local i::integer, buffer, samplePoint, sig::string;\n  noTPoints := NumberOfTopologicallyDistinctSamplePoints(db);\n\n  n := trunc(noTPoints / Grid:-NumNodes());\n  first :=  Grid:-MyNode() * n + 1; last := (Grid:-MyNode() + 1) * n;\n  if Grid:-MyNode() = Grid:-NumNodes() - 1 then\n    last := noTPoints;\n  fi;\n\n  for i from first by RigidMotionsRecoverNMM:-BUFFER_SIZE to last do\n    buffer := RigidMotionsRecoverNMM:-FetchTopologicallyDistinctSamplePointsFromDB(db, i, last);\n    RigidMotionsRecoverNMM:-CalculateNMM(varsGlobal, planes, buffer, N, R, db);\n    SynchronizeNMM(db);\n  od;\n  Close(db);\n  Grid:-Barrier();\nend proc:\n\n\n# Procedure: FetchSamplePointsFromDB\n#   Used to fetch rotational sample points from the database. The number of sample points is\n#   controlled by BUFFER_SIZE.\n#\n# Parameters:\n#   db::ComputationRegister       - an instance of ComputationRegister with open connection to the\n#                                   database.\n#   fromID::integer               - an id of the first sample point from a range to be fetched\n#   last::integer                 - an id of the very last sample points to be fetched\n#\n# Output:\n#   An Array of lists which of each represent a sample point. Note that the first element of each\n#   list is an id of a given sample point.\nFetchSamplePointsFromDB := proc(db::ComputationRegister, fromID::integer, last::integer)\n  local n := fromID + RigidMotionsRecoverNMM:-BUFFER_SIZE - 1;\n  if n > last then\n    n := last;\n  fi;\n  return FetchSamplePointsWithoutSignature(db, fromID, n ); \nend proc;\n\n\n# Procedure: ParallelFindTopologicallyDistinctSamplePoints\n#   Finds rotational sample points which lead to unique arrangement of the critical planes in the\n#   remainder range. \n#\n ParallelFindTopologicallyDistinctSamplePoints := proc() \n  local first::integer, last::integer;\n  local R := CayleyTransform(varsGlobal), N := GetNeighborhood(nTypeGlobal); \n  local planes := RigidMotionsRecoverNMM:-CriticalPlanes(R, N, kRangeGlobal);\n  local db, n, i::integer, buffer, samplePoint, sig, noTPoints;\n  db:= Object(ComputationRegister, dbPathGlobal);\n  noTPoints := NumberOfSamplePoints(db);\n  n := trunc(noTPoints / Grid:-NumNodes());\n  first :=  Grid:-MyNode() * n + 1; last := (Grid:-MyNode() + 1) * n;\n  if Grid:-MyNode() = Grid:-NumNodes() - 1 then\n    last := noTPoints;\n  fi;\n\n  for i from first by RigidMotionsRecoverNMM:-BUFFER_SIZE to last do\n    buffer := RigidMotionsRecoverNMM:-FetchSamplePointsFromDB(db, i, last);\n    for samplePoint in buffer do\n      sig := RigidMotionsRecoverNMM:-GetOrderedCriticalPlanes(varsGlobal,samplePoint[2..()],planes)[1];\n      InsertSignature(db, samplePoint[1], sig);\n    od;\n  od;\n  SynchronizeSamplePointsSignatures(db);\n  Close(db);\n  Grid:-Barrier();\nend proc;\n\n\nLaunchFindDistinctSamplePoints := proc(vars::list, nType::string, kRange::list, dbPath::string, \n                                                        nodes:=kernelopts(numcpus))\n  local db:=Object(ComputationRegister, dbPath);\n  PrepareSamplePoints(db);\n  Close(db);\n  nTypeGlobal := nType; kRangeGlobal := kRange; dbPathGlobal := dbPath; varsGlobal := vars;\n  \n  Grid:-Setup(\"local\"); \n  Grid:-Launch(RigidMotionsRecoverNMM:-ParallelFindTopologicallyDistinctSamplePoints,\n  imports=['varsGlobal', 'nTypeGlobal', 'kRangeGlobal', 'dbPathGlobal'], numnodes=nodes,\n  allexternal=false); \n  db:=Object(ComputationRegister, dbPath);\n  CloseSignaturesAddition(db);\n  Close(db);\nend proc:\n\n\n# Procedure: LaunchOnGridGetNMM\n#   Setup and run computation on a local grid\n#\n# Parameters:\n#   vars             - list of variables in which the problem is expressed\n#   nType            - size of neighborhood i.e N1, N2 and N3. \n#   kRange           - a range of planes of the half-grid\n#   dbPath           - a path to a database file.\n#   nodes            - number of nodes used in the parallel computations\n#\n# Output:\n#   List of unique neighborhood motion maps\nLaunchComputeNMM := proc(vars::list, nType::string, kRange::list, dbPath::string, \n                                                        nodes:=kernelopts(numcpus)) \n  local db:=Object(ComputationRegister, dbPath);\n  DropRedundantSamplePoints(db);\n  Close(db);\n  nTypeGlobal := nType; kRangeGlobal := kRange; dbPathGlobal := dbPath; varsGlobal := vars;\n  \n  Grid:-Setup(\"local\"); \n  Grid:-Launch(RigidMotionsRecoverNMM:-ParallelCalculateNMM, imports=['varsGlobal', 'nTypeGlobal',\n  'kRangeGlobal', 'dbPathGlobal'], numnodes=nodes, allexternal=false); \nend proc:\n\nend module:\n\n", "meta": {"hexsha": "cac1c54edee20d19af0626aa9bdb9b60107a37bc", "size": 14704, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "RigidMotionsRecoverNMM.mpl", "max_stars_repo_name": "copyme/MapleTools", "max_stars_repo_head_hexsha": "7491d0d2cab715e2dd984ce7ba0fb8db46cbe73f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "RigidMotionsRecoverNMM.mpl", "max_issues_repo_name": "copyme/MapleTools", "max_issues_repo_head_hexsha": "7491d0d2cab715e2dd984ce7ba0fb8db46cbe73f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2016-04-14T11:48:04.000Z", "max_issues_repo_issues_event_max_datetime": "2016-05-13T13:48:01.000Z", "max_forks_repo_path": "RigidMotionsRecoverNMM.mpl", "max_forks_repo_name": "copyme/MapleTools", "max_forks_repo_head_hexsha": "7491d0d2cab715e2dd984ce7ba0fb8db46cbe73f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.4197183099, "max_line_length": 103, "alphanum_fraction": 0.6719260065, "num_tokens": 3926, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7310585669110203, "lm_q2_score": 0.6406358411176238, "lm_q1q2_score": 0.4683423199192862}}
{"text": "#\n#  Currently, these are not 'tests' in the usual sense, in that they do\n# not have correct answers encoded.  They are just meant to all be \n# runnable (and are part of the stuff serving as input for the array\n# simplification paper we're writing).\n\nkernelopts(assertlevel=2): # be strict on all assertions while testing\nkernelopts(opaquemodules=false): # allow testing of internal routines\nif not (NewSLO :: `module`) then\n  WARNING(\"loading NewSLO failed\");\n  `quit`(3);\nend if;\n\nwith(Hakaru):\nwith(NewSLO):\nwith(Loop):\n\nkb := KB:-assert(n :: nonnegint, KB:-empty):\ni, kb := KB:-genType(i, HInt(closed_bounds(1..n)), kb):\n\nt1 := Product(idx(x,j),j=1..n):\nr1 := unproduct(t1, x, i=1..n, [], `*`, kb, kb);\n\nt2 := 2:\nr2 := unproduct(t2, x, i=1..n, [], `*`, kb, kb);\n\nt3 := 2^n:\nr3 := unproduct(t3, x, i=1..n, [], `*`, kb, kb);\n\nt4 := Product(2*idx(x,j),j=1..n);\nr4 := unproduct(t4, x, i=1..n, [], `*`, kb, kb);\n\nt5 := Product(2+idx(x,j),j=1..n);\nr5 := unproduct(t5, x, i=1..n, [], `*`, kb, kb);\n\nt6 := Product(f(idx(x,j)),j=1..n);\nr6 := unproduct(t6, x, i=1..n, [], `*`, kb, kb);\n\nt7 := exp(Sum(g(idx(x,k)),k=1..n));\nr7 := unproduct(t7, x, i=1..n, [], `*`, kb, kb);\n\nt8 := t6*t7;\nr8 := unproduct(t8, x, i=1..n, [], `*`, kb, kb);\n\nt9 := Product(f(idx(x,j+1)),j=0..n-1);\nr9 := unproduct(t9, x, i=1..n, [], `*`, kb, kb);\n\nt10 := Product(f(idx(x,j)),j=1..n-1);\nr10 := unproduct(t10, x, i=1..n, [], `*`, kb, kb);\n\n# oops, this ones doesn't !!  Going under (above) is\n# ok, but over does not.  Neither of the following:\n# t10a := Product(f(idx(x,j)),j=1..n+1);\n# r10a := unproduct(t10, x, i=1..n, [], `*`, kb, kb);\n# t10b := Product(f(idx(x,j)),j=0..n);\n# r10b := unproduct(t10, x, i=1..n, [], `*`, kb, kb);\n\nt11 := Product(exp(Sum(f(idx(x,j))+g(idx(x,k)),k=1..j)),j=1..n):\nr11 := unproduct(t11, x, i=1..n, [], `*`, kb, kb);\n\nt12 := Product(exp(Sum(f(idx(x,j),j,k)+g(idx(x,k),j,k),k=1..j)),j=1..n):\nr12 := unproduct(t12, x, i=1..n, [], `*`, kb, kb);\n\n# this is sort-of buggy as well.\nt13 := Product(f(idx(x,5))*g(idx(x,7))*h(j),j=1..n):\nr13 := unproduct(t13, x, i=1..n, [], `*`, kb, kb);\n\n# Bug!\n# t14 := Product(idx(x,2*j),j=1..n/2):\n# r14 := unproduct(t14, x, i=1..n, [], `*`, kb, kb);\n\nt15 := Product(f(idx(x,j),j)*g(idx(x,n+1-j),j)*h(j),j=1..n):\nr15 := unproduct(t15, x, i=1..n, [], `*`, kb, kb);\n\nt16 := Product(piecewise(a<b,f(idx(x,j),j),g(idx(x,n+1-j),j)),j=1..n):\nr16 := unproduct(t16, x, i=1..n, [], `*`, kb, kb);\n\nt17 := Product(5^idx(x,j)*f(idx(x,j))*g(idx(x,n+1-j)),j=1..n):\nr17 := unproduct(t17, x, i=1..n, [], `*`, kb, kb);\n", "meta": {"hexsha": "b2a35b9166f0a9525054910698f9aae96a82c264", "size": 2533, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "maple/unprod_tests.mpl", "max_stars_repo_name": "vmchale/hakaru", "max_stars_repo_head_hexsha": "78922e13876e449d6812a55a11bf84c8eb0af4d6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 327, "max_stars_repo_stars_event_min_datetime": "2015-01-03T08:56:51.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-24T12:12:06.000Z", "max_issues_repo_path": "maple/unprod_tests.mpl", "max_issues_repo_name": "zaxtax/hakaru", "max_issues_repo_head_hexsha": "03ac5b645815e99437e28d228e6c668753b2640e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 155, "max_issues_repo_issues_event_min_datetime": "2015-05-05T17:57:22.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T15:43:39.000Z", "max_forks_repo_path": "maple/unprod_tests.mpl", "max_forks_repo_name": "zaxtax/hakaru", "max_forks_repo_head_hexsha": "03ac5b645815e99437e28d228e6c668753b2640e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 38, "max_forks_repo_forks_event_min_datetime": "2015-01-23T16:25:37.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-14T15:09:12.000Z", "avg_line_length": 31.6625, "max_line_length": 72, "alphanum_fraction": 0.5412554283, "num_tokens": 1050, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125737597972, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.46809724371790873}}
{"text": "# File: RigidMotionsParameterSpaceDecompostionRecursive.mpl  \n#\n# Description:\n#  This file contains functions used to obtain an arrangement 6 dimensional parameter space of 3D\n#  digitized rigid motions.\n#  This code has been written for research propose and its aim is to calculate a particular\n#  arrangement of quadrics. Therefore, it can or it cannot be useful in study of generic\n#  arrangements. The final output are sample points of full dimensional open cells.\n#\n#  The code was written in relation with the paper: Kacper Pluta, Guillaume Moroz, Yukiko\n#  Kenmochi, Pascal Romon, Quadric arrangement in classifying rigid motions of a 3D digital image,\n#  2016, https://hal.archives-ouvertes.fr/hal-01334257 referred late on as [Quadrics:2016].\n#\n# Author:\n#  Kacper Pluta - kacper.pluta@esiee.fr\n#  Laboratoire d'Informatique Gaspard-Monge - LIGM, A3SI, France\n#\n# Date:\n#  12/24/2016 \n#\n# License:\n#  Simplified BSD License\n#\n# Copyright (c) 2016, Kacper Pluta\n# All rights reserved.\n\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#   * Redistributions of source code must retain the above copyright\n#     notice, this list of conditions and the following disclaimer.\n#   * Redistributions in binary form must reproduce the above copyright\n#     notice, this list of conditions and the following disclaimer in the\n#     documentation and/or other materials provided with the distribution.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\n# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n# DISCLAIMED. IN NO EVENT SHALL Kacper Pluta BE LIABLE FOR ANY\n# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n#\n#\nRigidMotionsParameterSpaceDecompostionRecursive := module() \n  option package;\n\n  (*Threshold which controls when to synchronize databases.*)\n  local RECORDS_TO_SYNCH := 1000;\n\n  uses   RigidMotionsParameterSpaceCommon;\n  local  ComputeEventsAType2D, ComputeEventsBType2D, ComputeEventsAType1D,\n         ComputeAsymptoticAAEvents2D, ComputeEventsAlgebraicNumbers2D, ComputeSamplePoints2D;\n         \n  export IsAsymptotic2D, LaunchComputeSamplePoints2D;\n\n# Procedure: ComputeEventsAType2D\n#   Compute events such that a sweep line is tangent to a conic with respect to the first provided\n#   variable. \n#\n# Parameters:\n#   Q2D2       - a set of conics\n#   grid       - if true then computations are performed in the parallel computation framework\n#                called Grid (see Maple documentation)\n#   vars2D       - a list of the variables\n#\n# Output:\n#   list of couples: univariate polynomial and index of the generating conic: [poly, [index]]\n#\n# Comment/Limitations:\n#  - Univariate polynomials are expressed in the first variable.\nComputeEventsAType2D := proc(Q2D2, grid::boolean, vars2D::list)\n  uses ArrayTools;\n  local result := Array([]), s;\n  if nops(vars2D) < 2 then\n    error \"Only systems in at least two variables are supported. The variables are: %1.\", vars2D;\n  fi:\n  s := proc(i::integer, vars2D::list)\n    local sys, univ, sol:\n    local q := Q2D2[i];\n    sys := [q, diff( q, vars2D[2] )];\n    univ := UnivariatePolynomial(sys, vars2D):\n    return SerializeEvents(GenerateEvents(univ, [i]));\n  end proc;\n  if grid then\n    map[inplace](proc(x) Extend(result, x, inplace=true) end proc, [Grid:-Seq( s( i, vars2D ), \n                                                                   i=1..nops( Q2D2 ) )]);\n  else \n    map[inplace](proc(x) Extend(result, x, inplace=true) end proc, [seq( s( i, vars2D ), \n                                                             i=1..nops( Q2D2 ) )]);\n  fi;\n  return ReconstructEvents(result);\nend proc:\n\n# Procedure: ComputeEventsBType2D\n#   Compute events such that two conics intersects in a point.\n#\n# Parameters:\n#   Q2D2       - a set of conics\n#   grid       - if true then computations are performed in the parallel computation framework\n#                called Grid (see Maple documentation)\n#   vars2D       - a list of the variables\n#\n# Output:\n#   list of couples: univariate polynomial and indices of the generating conics: [poly,\n#   [index1,index2]]\n#\n# Comment/Limitations:\n#  - Univariate polynomials are expressed in the first variable.\nComputeEventsBType2D := proc(Q2D2, grid::boolean, vars2D::list)\n  uses ArrayTools;\n  local result := Array([]), s:\n  s := proc (i, j, vars2D::list)\n    local p, sol, univ, sys;\n    sys := [Q2D2[i], Q2D2[j]];\n    univ := UnivariatePolynomial(sys, vars2D);\n    return SerializeEvents(GenerateEvents(univ, [i, j]));\n  end proc;\n  if grid then\n    map[inplace](proc(x) Extend(result, x, inplace=true) end proc, [Grid:-Seq( seq( s(i, j, vars2D), \n                                                       j=i+1..nops( Q2D2 ) ), i=1..nops( Q2D2 ) )]);\n  else \n    map[inplace](proc(x) Extend(result, x, inplace=true) end proc, [seq( seq( s(i, j, vars2D), \n                                                 j=i+1..nops( Q2D2 ) ), i=1..nops( Q2D2 ) )]);\n  fi;\n  return ReconstructEvents(result);\nend proc:\n\n# Procedure: IsAsymptotic2D\n#   Checks if a curve is an asymptote.\n#\n# Parameters:\n#   p          - a curve given as a polynomial\n#   var        - variable to be reduced\n#\n# Output:\n#   Monomial such that there exists a line tangent to the curve at infinity represented in a\n#   variable different than 'var' or a constant.\nIsAsymptotic2D := proc(p::polynom, var)\n  return lcoeff(p, var);\nend proc:\n\n\n# Procedure: ComputeAsymptoticAAEvents2D\n#   Compute real algebraic numbers which corresponds to asymptotic cases given by one curve.\n#\n# Parameters:\n#   Q2D2          - a set of conics\n#   vars2D       - a list of the variables\n#\n# Output: Real\n#   A list of Events (see EventType).\nComputeAsymptoticAAEvents2D := proc(Q2D2, vars2D::list)\n  uses ArrayTools;\n  local result := Array([]), s;\n  s:=proc(i::integer, vars2D::list)\n    local asy;\n    asy := RigidMotionsParameterSpaceDecompostionRecursive:-IsAsymptotic2D(Q2D2[i], vars2D[-1]);\n    return GenerateEvents(asy, [i]);\n  end proc:\n  map[inplace](proc(x) Extend(result, x, inplace=true) end proc, [seq(s(i, vars2D),\n                                                                i=1..nops(Q2D2))]);\n  return result;\nend:\n\n\n# Procedure: ComputeEventsAlgebraicNumbers2D\n#   Compute and sort events\n#\n# Parameters:\n#   Q2D2     - set of conics\n#   grid       - if true then computations are performed in the parallel computation framework\n#                called Grid (see Maple documentation)\n#   vars2D       - a list of the variables\n#\n# Output:\n#   Sorted Array of real algebraic numbers\nComputeEventsAlgebraicNumbers2D := proc(Q2D2, grid::boolean, vars2D::list)\n  uses ArrayTools;\n  local events2D := Array([]);\n  Extend(events2D, ComputeEventsAType2D(Q2D2, grid, vars2D), inplace=true);\n  Extend(events2D, ComputeEventsBType2D(Q2D2, grid, vars2D), inplace=true);\n  Extend(events2D, ComputeAsymptoticAAEvents2D(Q2D2, vars2D), inplace=true);\n  return AlgebraicSort(events2D);\nend proc:\n\n\n# Procedure: ComputeEventsAType1D\n#   Compute and sort events as algebraic numbers \n#\n# Parameters:\n#   Q2D2     - a list of conics\n#\n# Output:\n#   Sorted list of real algebraic numbers without repetitions.\nComputeEventsAType1D := proc(Q2D2::list)\n  local q, factored, sqrFree, rootsF, rf, numbers := Array([]);\n  for q in Q2D2 do\n    if RootFinding:-HasRealRoots(q) then\n      factored := factors( q )[2,..,1];\n      for sqrFree in factored do\n        rootsF := RootFinding:-Isolate(sqrFree, output='interval');\n        for rf in rootsF do\n          ArrayTools:-Append(numbers, RealAlgebraicNumber(sqrFree, op(rf)[2][1],\n                             op(rf)[2][2]));\n        od;\n      od;\n   fi;\n  od;\n  numbers := AlgebraicSort(numbers);\n  return ListTools:-MakeUnique(convert(numbers, list), 1, proc(a,b) evalb(Compare(a,b) = 0) end proc);\nend proc:\n\n\n# Procedure: ComputeSamplePoints2D\n#   Computes sample points for rotational part of rigid motions\n#\n# Parameters:\n#   Q2D         - a list of conics\n#   events2D    - each element contains a list of algebraically unique events\n#   first       - integer value which indicates the first event to proceed.\n#   last        - integer value which indicates the last event to proceed.\n#   vars2D      - list of variables in which conics are expressed\n#   db          - an instance of the class ComputationRegister\n#\n# Output:\n#   It populates a database, given by databasePath, with sample points.\nComputeSamplePoints2D := proc(Q2D, events2D::Array, first::integer, last::integer,\n                              vars2D::list, amid::rational, db::ComputationRegister)\n  local i::integer, j::integer, x::list, midpoint::rational, sys::list, records := 0;\n  local disjointEvent::list, oneD::list, oneDNeg::list, ranumI, ranumJ;\n  if first < 0 or last < 0 or last < first or upperbound(events2D) <= last then \n    error \"Bounds of the array range are incorrect.\": \n  end if:\n  for i from first to last do \n    sys := Q2D[GetQuadrics(events2D[i])];\n    ranumI := GetRealAlgebraicNumber(events2D[i]);\n    ranumJ := GetRealAlgebraicNumber(events2D[i+1]);\n    disjointEvent:=DisjointRanges(ranumI, ranumJ);\n    midpoint := (GetInterval(disjointEvent[1])[2] + GetInterval(disjointEvent[2])[1])/2:\n    # never call eval with sets!\n    sys := eval(sys, vars2D[1] = midpoint);\n    oneD := ComputeEventsAType1D(sys);\n    oneD := select(proc(x) return evalb(GetInterval(x)[2] >= 0); end proc, oneD);\n\n    if upperbound(oneD) > 0 then\n      for j from 1 to upperbound(oneD) - 1 do\n        disjointEvent := DisjointRanges(oneD[j],oneD[j+1]);\n        InsertSamplePoint(db, [amid, midpoint, (GetInterval(disjointEvent[1])[2] +\n                                            GetInterval(disjointEvent[2])[1])/2]);\n        records := records + 1;\n        if records mod RECORDS_TO_SYNCH = 0 then\n          SynchronizeSamplePoints(db);\n        fi;\n      od:\n      InsertSamplePoint(db, [amid, midpoint, GetInterval(oneD[-1])[2] + 1/2]);\n      records := records + 1;\n      if records mod RECORDS_TO_SYNCH = 0 then\n        SynchronizeSamplePoints(db);\n      fi;\n    fi;\n od:\nend proc:\n\n\n# Procedure: ComputeSamplePoints2D\n#   Computes sample points for rotational part of rigid motions using the grid framework\n#\n#\n# Parameters:\n#   s         - a list of conics\n#   midpoint  - the first dimensional midpoint obtained from the 3D decomposition\n#   nodes     - number of nodes used in the parallel computations\n#   grid      - a control variable for parallel computations. If true and additional conditions on\n#               the size of the problem are fulfilled the problem is solved in the grid framework\n#   variables - list of variables in which the problem is expressed\n#   db        - an instance of ComputationRegister which provides interface to the database\n# Output:\n#   It populates a database with sample points.\nLaunchComputeSamplePoints2D := proc (s::list, midpoint::rational, nodes::integer,\n                                           grid::boolean, variables::list, db::ComputationRegister) \n  local events2D, Q2D := ListTools:-MakeUnique([op(variables), op(s)]);\n  if grid and nops(s) > 20 then\n     events2D := ComputeEventsAlgebraicNumbers2D(Q2D, true, variables);\n  else\n     events2D := ComputeEventsAlgebraicNumbers2D(Q2D, false, variables);\n  fi;\n  events2D := remove[flatten](proc(x) evalb(GetInterval(GetRealAlgebraicNumber(x))[2] < 0) end proc, \n                            events2D);\n  if upperbound(events2D) = 0 then\n    return NULL;\n  fi;\n  events2D := ReduceEvents(events2D);\n  AdjustEvents(events2D, upperbound(Q2D), variables);\n  ComputeSamplePoints2D(Q2D, events2D, 1, upperbound(events2D) - 1, variables, midpoint, db);\nend proc:\n\nend module;\n", "meta": {"hexsha": "ff1d1beb5d209b88a1424a7e3237dacbd3c5bb8a", "size": 12212, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "RigidMotionsParameterSpaceDecompositionRecursive.mpl", "max_stars_repo_name": "copyme/MapleTools", "max_stars_repo_head_hexsha": "7491d0d2cab715e2dd984ce7ba0fb8db46cbe73f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "RigidMotionsParameterSpaceDecompositionRecursive.mpl", "max_issues_repo_name": "copyme/MapleTools", "max_issues_repo_head_hexsha": "7491d0d2cab715e2dd984ce7ba0fb8db46cbe73f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2016-04-14T11:48:04.000Z", "max_issues_repo_issues_event_max_datetime": "2016-05-13T13:48:01.000Z", "max_forks_repo_path": "RigidMotionsParameterSpaceDecompositionRecursive.mpl", "max_forks_repo_name": "copyme/MapleTools", "max_forks_repo_head_hexsha": "7491d0d2cab715e2dd984ce7ba0fb8db46cbe73f", "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.5714285714, "max_line_length": 102, "alphanum_fraction": 0.6780216181, "num_tokens": 3310, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.798186768138228, "lm_q2_score": 0.5851011542032312, "lm_q1q2_score": 0.46701999930742405}}
{"text": "######################################################################\n\n`is_element/standard_stasheff_star` := (n::posint) -> proc(t)\n local JJ,TT,J,T,u,i,j,k;\n global reason;\n\n if not(type(t,table)) then\n  reason := [convert(procname,string),\"t is not a table\",t];\n  return false;\n fi;\n\n JJ := {seq(seq({seq(k,k=i..j)},j=i..n),i=1..n)};\n\n if map(op,{indices(t)}) <> JJ then\n  reason := [convert(procname,string),\"t is not indexed by the set of intervals\",t,JJ];\n  return false;\n fi;\n\n TT := NULL;\n\n for J in JJ do\n  u := t[J];\n\n  if not (`is_element/RR`(u) and u >= 0 and u <= 1) then\n   reason := [convert(procname,string),\"t[J] is not in the unit interval\",J,u];\n   return false;\n  fi;\n\n  if (nops(J) = 1 or nops(J) = n) and u <> 1 then\n   return false;\n  fi;\n\n  if u > 0 then TT := TT,J; fi;\n od;\n TT := {TT};\n\n if not(`is_element/trees`({seq(i,i=1..n)})(TT)) then\n  reason := [convert(procname,string),\"TT is not a tree\",TT,reason];\n  return false;\n fi;\n\n return true;\nend;\n\n`is_equal/standard_stasheff_star` := (n::posint) -> proc(t,u)\n local JJ,J,i,j,k;\n\n JJ := {seq(seq({seq(k,k=i..j)},j=i..n),i=1..n)};\n\n for J in JJ do\n  if t[J] <> u[J] then\n   return false;\n  fi;\n od;\n return true;\nend:\n\n`is_leq/standard_stasheff_star` := NULL;\n\n`random_element/standard_stasheff_star` := (n::posint) -> proc()\n local JJ,TT,T,t,i,j,k,d;\n\n d := 12;\n \n JJ := {seq(seq({seq(k,k=i..j)},j=i..n),i=1..n)};\n TT := `random_element/standard_stasheff_trees`(n)();\n t := table();\n\n for T in JJ do t[T] := 0; od;\n t[{seq(i,i=1..n)}] := 1;\n for i from 1 to n do t[{i}] := 1; od;\n\n for T in TT do\n  if nops(T) > 1 and nops(T) < n then \n   t[T] := rand(0..d)()/d;\n  fi;\n od;\n\n return eval(t);\nend;\n\n`list_elements/standard_stasheff_star` := NULL;\n`count_elements/standard_stasheff_star` := NULL;\n\n", "meta": {"hexsha": "1e4cdfe899378e1f7641b072f99e91bc98efe02b", "size": 1778, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/standard_stasheff_star.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_star.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_star.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.9176470588, "max_line_length": 87, "alphanum_fraction": 0.5674915636, "num_tokens": 616, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6859494550081925, "lm_q2_score": 0.6723316991792861, "lm_q1q2_score": 0.46118556263676336}}
{"text": "\n# Berechnungen für Systeme mit impliziten kinematischen Zwangsbedingungen\n# Beschreibung\n# Allgemeine Berechnungen zu den impliziten Zwangsbedingungen\n# Die Bedingungen müssen vorher in einer Roboterspezifischen Datei berechnet werden (händische Erstellung der kinematischen Schleifen und sonstigen Zwangsbedingungen\n# \n# Dateiname:\n# robot -> Berechnung für allgemeinen Roboter\n# kinematic_constraints_calculations_implicit -> Berechnungen bezüglich implizit definierter kinematischer Zwangsbedingungen\n# Quellen\n# [Docquier2013] Docquier, Nicolas and Poncelet, Antoine and Fisette, Paul: ROBOTRAN: a powerful symbolic gnerator of multibody models (2013)\n# [DoThanhKotHeiOrt2009b] Do Thanh et al.: On the inverse dynamics problem of general parallel robots (2009)\n# [ParkChoPlo1999] Park, FC and Choi, Jihyeon and Ploen, SR: Symbolic formulation of closed chain dynamics in independent coordinates\n# Autor\n# Moritz Schappler, schappler@imes.uni-hannover.de, 2018-02\n# Institut fuer Mechatronische Systeme, 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):\ninterface(rtablesize=30):\nwith(StringTools): # Für Zeitausgabe\nwith(LinearAlgebra):\nwith(codegen):\nwith(CodeGeneration):\ncodegen_act := true:\ncodegen_opt := 2: # Hoher Optimierungsgrad.\n;\nread \"../helper/proc_MatlabExport\":\nread \"../helper/proc_simplify2\":\nread \"../helper/proc_convert_s_t\":\nread \"../helper/proc_convert_t_s\":\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_constraints/proc_subs_kintmp_exp\":\n# Definition und Zwangsbedingungen\nread \"../robot_codegen_definitions/robot_env_IC\":\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", robot_name_OL):\nread \"../robot_codegen_definitions/robot_env_IC\":\n# Term-Vereinfachungen: 0=keine; 1=fast alle; 2=auch Zeitableitung der Projektionsmatrix\nif not assigned(simplify_options) or simplify_options(1)=-1 then\n  use_simplify := 1: # standardmäßig simplify-Befehle anwenden.\nelse\n  use_simplify := simplify_options(1): # erster Eintrag ist für Zwangsbedingungen\nend if:\n\n# Lesen der Zwangsbedingungen\nkin_constraints_exist := false:\nconstrfile := sprintf(\"../codeexport/%s/tmp/kinematic_constraints_implicit_maple.m\", robot_name):\nif FileTools[Exists](constrfile) then\n  read constrfile:\n  implconstr_s := implconstr_s: # Für Sichtbarkeit der Variablen\n  implconstr_t := implconstr_t: # Für Sichtbarkeit der Variablen\n  kin_constraints_exist := kin_constraints_exist: # Für Sichtbarkeit der Variablen\nend if:\n\nif kin_constraints_exist = true then:\n  printf(\"Kinematische Zwangsbedingungen in impliziter Form gelesen.\\n\"):\nelse\n  printf(\"Es gibt keine impliziten Zwangsbedingungen. Offene Struktur oder nur explizit definierte Bedingungen. Keine weiteren Berechnungen notwendig.\"):\n  restart: # Funktioniert nicht. Gedacht, damit im worksheet-Modus nichts mehr passieren kann.\n  robot_name := \"\": # Damit werden die Export-Befehle ungültig\n  codegen_act := false:\n  quit:\nend if:\nNIZB := RowDimension(implconstr_s):\n# Gelenkdefinitionen\n# Setze aktuierte Gelenke als Minimalkoordinaten voraus\nNAJ := add(mu(k), k=1..NJ):\nNPJ := NQJ-NAJ:\n# Bestimme Indizes der aktiven und passiven Gelenke\n# Entspricht Partitionierung der Gelenkwinkel in q1 und q2 in [Docquier2013]. Hier kann die Reihenfolge von aktiven und passiven Winkeln auch durchmischt sein.\nIndAct := Matrix(NAJ, 1):\nIndPass:= Matrix(NPJ, 1):\nka := 1: kp := 1:\nfor i from 1 to NQJ do\n  if mu(i) = 1 then\n    IndAct(ka) := i:\n    ka := ka + 1:\n  else\n    IndPass(kp) := i:\n    kp := kp + 1:\n  end if:\nend do:\nprintf(\"Indizes der %d aktiven Gelenke:\\n\", NAJ);\nTranspose(IndAct);\nprintf(\"Indizes der %d passiven Gelenke:\\n\", NPJ);\nTranspose(IndPass);\nprintf(\"%d Zwangsbedingungsgleichungen\\n\", NIZB);\n# Positionsvektor der Minimalkoordinaten zur Umrechnung OL zu TE/DE\n# Zum Vergleich des Ergebnisses aus den expliziten Zwangsbedingungen und den des offenen Systems\nposNQJ := Matrix(NJ,1):\nfor i from 1 to NJ do\n  if SearchText(\"qJ\",convert(theta(i),string)) = 1 or SearchText(\"qJ\",convert(d(i),string)) = 1 then\n    posNQJ(i) := 1:\n  end if:\nend do:\n# Jacobi-Matrix der Impliziten Zwangsbedingungen in Abhängigkeit der unabhängigen Koordinaten\n# \n# Entspricht J1 in [Docquier2013], A in [ParkChoPlo1999]\nPhia_s := Matrix(NIZB, NAJ):\n# Jacobi-Matrix berechnen\nfor i from 1 to NIZB do\n  for j from 1 to NAJ do\n    k := IndAct(j):\n    Phia_s(i,j) := diff(implconstr_s(i,1), qJ_s(k,1)):\n  end do:\nend do:\n# Jacobi-Matrix der Impliziten Zwangsbedingungen in Abhängigkeit der abhängigen Koordinaten\n# \n# Entspricht J2 in [Docquier2013], P in [ParkChoPlo1999]\nPhip_s := Matrix(NIZB, NPJ):\n# Jacobi-Matrix berechnen\nfor i from 1 to NIZB do\n  for j from 1 to NPJ do\n    k := IndPass(j):\n    Phip_s(i,j) := diff(implconstr_s(i,1), qJ_s(k,1)):\n  end do:\nend do:\n# Vereinfache die Ausdrücke\n# \nif use_simplify >= 1 then\n  tmp_t11 := time():\n  tmp_l11 := length(Phia_s):\n  printf(\"%s: Beginne Term-Vereinfachung der %dx%d Zwangsbedingungs-Jacobi für aktive Gelenke. Länge: %d.\\n\", \\\n     FormatTime(\"%Y-%m-%d %H:%M:%S\"), RowDimension(Phia_s), ColumnDimension(Phia_s), tmp_l11):\n  Phia_s := simplify2(Phia_s):\n  tmp_l21 := length(Phia_s):\n  tmp_t21 := time():\n  tmp_l12 := length(Phip_s):\n  printf(\"%s: Beginne Term-Vereinfachung der %dx%d Zwangsbedingungs-Jacobi für passive Gelenke. Länge: %d.\\n\", \\\n     FormatTime(\"%Y-%m-%d %H:%M:%S\"), RowDimension(Phip_s), ColumnDimension(Phip_s), tmp_l12):\n  Phip_s := simplify2(Phip_s):\n  tmp_l22 := length(Phip_s):\n  tmp_t22 := time():\n  printf(\"%s: Terme für Zwangsbedingungs-Jacobis vereinfacht. Länge (aktiv/passiv): %d->%d / %d->%d. Rechenzeit %1.1fs und %1.1fs.\\n\", \\\n    FormatTime(\"%Y-%m-%d %H:%M:%S\"), tmp_l11, tmp_l21, tmp_l12, tmp_l22, tmp_t21-tmp_t11, tmp_t22-tmp_t21):\nend if:\n# Zeitableitung der Jacobi-Matrix\n# Wird benötigt, um die Beschleunigung der Gelenkkoordinaten der offenen Struktur zu berechnen.\nPhia_t := convert_s_t(Phia_s):\nPhiaD_t := diff~(Phia_t, t):\nPhiaD_s := convert_t_s(PhiaD_t):\n\nPhip_t := convert_s_t(Phip_s):\nPhipD_t := diff~(Phip_t, t):\nPhipD_s := convert_t_s(PhipD_t):\n\n# Vereinfache die Ausdrücke\n# \n\nif use_simplify >= 1 then\n  tmp_t11 := time():\n  tmp_l11 := length(PhiaD_s):\n  printf(\"%s: Beginne Term-Vereinfachung der Zeitableitung der %dx%d Zwangsbedingungs-Jacobi für aktive Gelenke. Länge: %d.\\n\", \\\n     FormatTime(\"%Y-%m-%d %H:%M:%S\"), RowDimension(PhiaD_s), ColumnDimension(PhiaD_s), tmp_l11):\n  PhiaD_s := simplify2(PhiaD_s):\n  tmp_l21 := length(PhiaD_s):\n  tmp_t21 := time():\n  tmp_l12 := length(PhipD_s):\n  printf(\"%s: Beginne Term-Vereinfachung der Zeitableitung der %dx%d Zwangsbedingungs-Jacobi für passive Gelenke. Länge: %d.\\n\", \\\n     FormatTime(\"%Y-%m-%d %H:%M:%S\"), RowDimension(PhipD_s), ColumnDimension(PhipD_s), tmp_l12):\n  PhipD_s := simplify2(PhipD_s):\n  tmp_l22 := length(PhipD_s):\n  tmp_t22 := time():\n  printf(\"%s: Terme für Zwangsbedingungs-Jacobis (Zeitableitung) vereinfacht. Länge (aktiv/passiv): %d->%d / %d->%d. Rechenzeit %1.1fs und %1.1fs.\\n\", \\\n    FormatTime(\"%Y-%m-%d %H:%M:%S\"), tmp_l11, tmp_l21, tmp_l12, tmp_l22, tmp_t21-tmp_t11, tmp_t22-tmp_t21):\nend if:\n# Exportiere Code für folgende Skripte\n# Speichere Maple-Ausdruck (Eingabe-Format und internes Format)\nsave Phia_s, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_explicit_active_jacobian_maple.m\", robot_name):\nsave PhiaD_s, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_explicit_active_jacobian_time_derivative_maple.m\", robot_name):\nsave Phip_s, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_explicit_passive_jacobian_maple.m\", robot_name):\nsave PhipD_s, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_explicit_passive_jacobian_time_derivative_maple.m\", robot_name):\nsave posNQJ, IndAct, IndPass, sprintf(\"../codeexport/%s/tmp/positionVector_NQJ_maple.m\", robot_name):\nprintf(\"Ausdrücke für Kinematische ZB gespeichert (Maple)\\n\"):\nif codegen_act then\n  MatlabExport(implconstr_s, sprintf(\"../codeexport/%s/tmp/kinconstr_impl_matlab.m\", robot_name), codegen_opt):\n  MatlabExport(Phia_s, sprintf(\"../codeexport/%s/tmp/kinconstr_impl_active_jacobian_matlab.m\", robot_name), codegen_opt):\n  MatlabExport(PhiaD_s, sprintf(\"../codeexport/%s/tmp/kinconstr_impl_active_jacobianD_matlab.m\", robot_name), codegen_opt):\n  MatlabExport(Phip_s, sprintf(\"../codeexport/%s/tmp/kinconstr_impl_passive_jacobian_matlab.m\", robot_name), codegen_opt):\n  MatlabExport(PhipD_s, sprintf(\"../codeexport/%s/tmp/kinconstr_impl_passive_jacobianD_matlab.m\", robot_name), codegen_opt):\n  MatlabExport(posNQJ, sprintf(\"../codeexport/%s/tmp/positionVector_NQJ_matlab.m\", robot_name), codegen_opt):\n  printf(\"Ausdrücke für Kinematische ZB gespeichert (Matlab)\\n\"):\nend if:\n\n# Invertierung der Gradientenmatrix\n# Invertiere die Gradientenmatrix bezüglich der passiven Gelenke\nn1 := RowDimension(Phip_s):\nn2 := ColumnDimension(Phip_s):\n# Erstelle Matrix ppf mit der Form der Gradientmatrix Phip_s\nppf := Matrix(n1,n2,symbol=uu):\nfor i from 1 to n1 do\n  for j from 1 to n2 do\n    if Phip_s(i,j) = 0 then\n      ppf(i,j) := 0:\n    end if:\n  end do:\nend do:\n# Invertiere die allgemeine Form der Matrix und setze dann die Einträge ein.\nInvPhip_sf := MatrixInverse(ppf):\nInvPhip_s := InvPhip_sf:\n\nfor i from 1 to n1 do\n  for j from 1 to n2 do\n    if not Phip_s(i,j) = 0 then\n      InvPhip_s := subs({ppf(i,j)=Phip_s(i,j)}, InvPhip_s):\n    end if:\n  end do:\nend do:\n\n# Vereinfache den Ausdruck\nif use_simplify >= 1 then\n  tmp_t1 := time(): tmp_l1 := length(InvPhip_s):\n  printf(\"%s: Beginne Term-Vereinfachung der inversen %dx%d Zwangsbedingungs-Jacobi für passive Gelenke. Länge: %d.\\n\", \\\n     FormatTime(\"%Y-%m-%d %H:%M:%S\"), RowDimension(InvPhip_s), ColumnDimension(InvPhip_s), tmp_l1):\n  InvPhip_s := simplify2(InvPhip_s):\n  tmp_t2 := time(): tmp_l2 := length(InvPhip_s):\n  printf(\"%s. Inverse Passiv-Gelenk-Jacobi der ZB vereinfacht. Länge: %d->%d. Rechenzeit %1.1fs.\\n\", \\\n    FormatTime(\"%Y-%m-%d %H:%M:%S\"), tmp_l1, tmp_l2, tmp_t2-tmp_t11):\nend if:\nsave InvPhip_s, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_explicit_passive_jacobian_inv_maple\", robot_name):\nif codegen_act then\n  MatlabExport(InvPhip_sf, sprintf(\"../codeexport/%s/tmp/kinconstr_impl_passive_jacobian_inv_matlab.m\", robot_name), codegen_opt):\nend if:\n\n\n# Projektionsmatrix aus impliziter Gradientenmatrix\n# \n# Form der Projektionsmatrix anschauen\nB21f := -InvPhip_sf.Phia_s:\n# Projektionsmatrix berechnen. [Docquier2013], Text nach Gl. 12\nB21 := -InvPhip_s.Phia_s:\n# Vereinfache den Ausdruck\nif use_simplify >= 1 then\n  tmp_t1 := time(): tmp_l1 := length(B21):\n  printf(\"%s: Beginne Term-Vereinfachung der %dx%d Zwangsbedingungs-Projektionsmatrix. Länge: %d.\\n\", \\\n     FormatTime(\"%Y-%m-%d %H:%M:%S\"), RowDimension(B21), ColumnDimension(B21), tmp_l1):\n  B21 := simplify2(B21):\n  tmp_t2 := time(): tmp_l2 := length(B21):\n  printf(\"%s. ZB-Projektionsmatrix vereinfacht. Länge: %d->%d. Rechenzeit %1.1fs.\\n\", \\\n    FormatTime(\"%Y-%m-%d %H:%M:%S\"), tmp_l1, tmp_l2, tmp_t2-tmp_t11):\nend if:\nsave B21, sprintf(\"../codeexport/%s/tmp/kinconstr_impl_projection_jacobian_maple\", robot_name):\nif codegen_act then\n  MatlabExport(B21, sprintf(\"../codeexport/%s/tmp/kinconstr_impl_projection_jacobian_matlab.m\", robot_name), codegen_opt):\nend if:\n\n# Zeitableitung der Projektionsmatrix\n# [ParkChoPlo1999], Text nach Gl. 73\n# [DoThanhKotHeiOrt2009b], Gl. 20\nB21D := (InvPhip_s . PhipD_s . InvPhip_s . Phia_s ) + (-InvPhip_s.PhiaD_s):\n# Vereinfache den Ausdruck\nif use_simplify >= 2 then\n  tmp_t1 := time(): tmp_l1 := length(B21D):\n  printf(\"%s: Beginne Term-Vereinfachung der Zeitableitung der %dx%d Zwangsbedingungs-Projektionsmatrix. Länge: %d.\\n\", \\\n     FormatTime(\"%Y-%m-%d %H:%M:%S\"), RowDimension(B21D), ColumnDimension(B21D), tmp_l1):\n  B21D := simplify2(B21D):\n  tmp_t2 := time(): tmp_l2 := length(B21D):\n  printf(\"%s. ZB-Projektionsmatrix-Zeitableitung vereinfacht. Länge: %d->%d. Rechenzeit %1.1fs.\\n\", \\\n    FormatTime(\"%Y-%m-%d %H:%M:%S\"), tmp_l1, tmp_l2, tmp_t2-tmp_t11):\nend if:\nsave B21D, sprintf(\"../codeexport/%s/tmp/kinconstr_impl_projection_jacobian_derivative_maple\", robot_name):\nif codegen_act then\n  MatlabExport(B21D, sprintf(\"../codeexport/%s/tmp/kinconstr_impl_projection_jacobian_derivative_matlab.m\", robot_name), codegen_opt):\nend if:\n\nprintf(\"Fertig\\n\"):\n\n", "meta": {"hexsha": "d49c6861869ea0b177970fdad22c77918a264468", "size": 12470, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "robot_codegen_constraints/robot_kinematic_constraints_calculations_implicit.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_constraints/robot_kinematic_constraints_calculations_implicit.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_constraints/robot_kinematic_constraints_calculations_implicit.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": 46.1851851852, "max_line_length": 165, "alphanum_fraction": 0.7438652767, "num_tokens": 4112, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624789529375, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.460901426915192}}
{"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: mgga_exc *)\n\n(* prefix:\n  mgga_x_mvsb_params *params;\n\n  assert(p->params != NULL);\n  params = (mgga_x_mvsb_params * ) (p->params);\n*)\n\n$include \"mgga_x_mvs.mpl\"\n\nmvsb_beta := (t, x) -> mvs_alpha(t, x)*K_FACTOR_C/(t - K_FACTOR_C):\n\nmvsb_f := (x, u, t) -> (1 + params_a_k0*mvs_fa(mvsb_beta(t,x)))\n       / (1 + params_a_b*(X2S*x)^4)^(1/8):\n\nf := (rs, z, xt, xs0, xs1, u0, u1, t0, t1) ->\n  mgga_exchange(mvsb_f, rs, z, xs0, xs1, u0, u1, t0, t1):\n", "meta": {"hexsha": "020dce3f69fc0ae8b5d09cf6deea34cdff5e9767", "size": 692, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "libxc-5.1.6/maple/mgga_exc/mgga_x_mvsb.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/mgga_exc/mgga_x_mvsb.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/mgga_exc/mgga_x_mvsb.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": 25.6296296296, "max_line_length": 68, "alphanum_fraction": 0.6271676301, "num_tokens": 266, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920020959544, "lm_q2_score": 0.5736784074525096, "lm_q1q2_score": 0.4593397126223686}}
{"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: mgga_exc *)\n(* prefix:\n  mgga_c_m06l_params *params;\n\n  assert(p->params != NULL);\n  params = (mgga_c_m06l_params * )(p->params);\n*)\n\n$include \"mgga_c_vsxc.mpl\"\n$include \"mgga_c_m05.mpl\"\n\nm06l_f := (rs, z, xs0, xs1, ts0, ts1) ->\n  + m05_f(rs, z, xs0, xs1, ts0, ts1)\n  + vsxc_f(rs, z, xs0, xs1, ts0, ts1):\n\nf := (rs, z, xt, xs0, xs1, us0, us1, ts0, ts1) ->\n  m06l_f(rs, z, xs0, xs1, ts0, ts1):\n\n", "meta": {"hexsha": "7f63168b6cd0a4a6054710c5ae63f3ebb02e0fd1", "size": 642, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "libxc-5.1.6/maple/mgga_exc/mgga_c_m06l.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/mgga_exc/mgga_c_m06l.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/mgga_exc/mgga_c_m06l.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": 23.7777777778, "max_line_length": 68, "alphanum_fraction": 0.6339563863, "num_tokens": 252, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430478583168, "lm_q2_score": 0.5506073655352404, "lm_q1q2_score": 0.457633483964198}}
{"text": "#@ Not autoload\n\nE := proc(u)\n local n,i;\n if type(u,`+`) then\n  return(map(E,u));\n else\n  return('E'(u));\n fi;\nend:\n\nH := proc(u)\n local n,i,J;\n if type(u,`+`) then\n  return(map(H,u));\n else\n  return('H'(u));\n fi;\nend:\n\nP := proc(u)\n local n,i;\n if type(u,`+`) then\n  return(map(P,u));\n else\n  return('P'(u));\n fi;\nend:\n \no := proc(a,b)\n if a=0 or b=0 then\n  return(0);\n elif type(b,`+`) then\n  return(map2(o,a,b));\n elif type(a,indexed) and op(0,a)=x and op(2,a)=[] then\n  return(b);\n elif type(b,indexed) and op(0,b)=x and op(2,b)=[] then\n  return(a);\n else\n  return('o'(args));\n fi;\nend:\n\nis_o := proc(u)\n type(u,specfunc(anything,o));\nend:\n\nSpherePi := proc(n,m)\n local stem,is_stable,G;\n stem := n-m;\n is_stable := evalb(m>stem+1);\n\n if stem<0 or m<=0 or (n>1 and m=1) then\n  return(Group());\n elif stem=0 then\n  return(Group([],[x[n,[]]]));\n elif is_stable then\n  G := StableSpherePi(stem);\n  return(Group(map(a -> x[m,op(2,a)],op(1,G))));\n else\n  return('SpherePi'(n,m));\n fi;\nend:\n\nSource := proc(a)\n if type(a,indexed) and op(0,a) = x then\n  return(op(1,a) + `+`(op(op(2,a))));\n elif is_o(a) and nops(a) > 0 then\n  return Source(op(nops(a),a))\n else\n  return('Source'(args));\n fi; \nend:\n\nTarget := proc(a)\n if type(a,indexed) and op(0,a) = x then\n  return(op(1,a));\n elif is_o(a) and nops(a) > 0 then\n  return Target(op(1,a))\n else\n  return('Target'(args));\n fi; \nend:\n\nStem := proc(a) Source(a) - Target(a); end:\n\nIsAdmissible := proc(a)\n local m,J,r,i;\n if type(a,indexed) and op(0,a) = x then\n  m := op(1,a);\n  J := op(2,a);\n  r := nops(J);\n  if r>0 and J[1] >= m then \n   return(false);\n  fi;\n  for i from 1 to r-1 do\n   if J[i+1] > 2*J[i] then\n    return(false);\n   fi;\n  od;\n  return(true);\n else\n  return('IsAdmissible'(args));\n fi; \nend:\n\n# 1-stem\n\nSpherePi( 3, 2) := Group([],[x[2,[1]]]):\nSpherePi( 4, 3) := Group([x[3,[1]]]):\n\nStableSpherePi( 1) := Group([x[infinity,[1]]]):\n\n# 2-stem \n\nSpherePi( 4, 2) := Group([x[2,[1,1]]]):\nSpherePi( 5, 3) := Group([x[3,[1,1]]]):\n\nStableSpherePi( 2) := Group([x[infinity,[1,1]]]):\n\n# 3-stem\n\nSpherePi( 5, 2) := Group([x[2,[1,1,1]]]):\nSpherePi( 6, 3) := Group([x[3,[2,1]],\n                          x[3,[1,1,1]]]):\nSpherePi( 7, 4) := Group([x[4,[2,1]],\n                          x[4,[1,1,1]]],\n                         [x[4,[3]]]):\n\nStableSpherePi( 3) := Group([x[infinity,[3]],\n\t\t             x[infinity,[2,1]],\n\t\t             x[infinity,[1,1,1]]]):\n\n# 4-stem\n\nSpherePi( 6, 2) := Group([x[2,[1,1,1,1]],\n                          x[2,[1,2,1]]]):\nSpherePi( 7, 3) := Group([x[3,[2,1,1]]]):\nSpherePi( 8, 4) := Group([x[4,[3,1]],\n                          x[4,[2,1,1]]]):\nSpherePi( 9, 5) := Group([x[5,[3,1]]]):\n\nStableSpherePi( 4) := Group([]):\n\n# 5-stem \n\nSpherePi( 7, 2) := Group([x[2,[1,2,1,1]]]):\nSpherePi( 8, 3) := Group([x[3,[2,1,1,1]]]):\nSpherePi( 9, 4) := Group([x[4,[3,1,1]],\n                          x[4,[2,1,1,1]]]):\nSpherePi(10, 5) := Group([x[5,[3,1,1]]]):\nSpherePi(11, 6) := Group([],[x[6,[5,0]]]):\n\nStableSpherePi( 5) := Group([]):\n\n# 6-stem \n\nSpherePi( 8, 2) := Group([x[2,[1,2,1,1,1]]]):\nSpherePi( 9, 3) := Group([]):\nSpherePi(10, 4) := Group([x[4,[3,3]],\n                          x[4,[3,2,1]],\n                          x[4,[3,1,1,1]]]):\nSpherePi(11, 5) := Group([x[5,[3,3]]]):\nSpherePi(12, 6) := Group([x[6,[3,3]]]):\nSpherePi(13, 7) := Group([x[7,[3,3]]]):\n\nStableSpherePi( 6) := Group([x[infinity,[3,3]]]):\n\n# 7-stem \n\nSpherePi( 9, 2) := Group([]):\nSpherePi(10, 3) := Group([]):\nSpherePi(11, 4) := Group([]):\nSpherePi(12, 5) := Group([x[5,[4,1,1,1]]]):\nSpherePi(13, 6) := Group([x[6,[5,1,1]],\n                          x[6,[4,1,1,1]]]):\nSpherePi(14, 7) := Group([x[7,[6,1]],\n                          x[7,[5,1,1]],\n                          x[7,[4,1,1,1]]]):\nSpherePi(15, 8) := Group([x[8,[6,1]]],[x[8,[7]]]):\n\nStableSpherePi( 7) := Group([x[infinity,[7]],\n\t\t             x[infinity,[6,1]],\n                             x[infinity,[5,1,1]],\n                             x[infinity,[4,1,1,1]]]):\n\n# 8-stem \n\nSpherePi(10, 2) := Group([]):\nSpherePi(11, 3) := Group([x[3,[2,3,3]]]):\nSpherePi(12, 4) := Group([x[4,[2,3,3]]]):\nSpherePi(13, 5) := Group([x[5,[2,3,3]]]):\nSpherePi(14, 6) := Group([x[6,[5,3]],\n                          x[6,[5,2,1]],\n                          x[6,[5,1,1,1]],\n                          x[6,[2,3,3]]]):\nSpherePi(15, 7) := Group([x[7,[6,1,1]],\n                          x[7,[5,3]],\n                          x[7,[2,3,3]]]):\nSpherePi(16, 8) := Group([x[8,[7,1]],\n                          x[8,[6,1,1]],\n                          x[8,[5,3]],\n                          x[8,[2,3,3]]]):\nSpherePi(17, 9) := Group([x[9,[7,1]],\n                          x[9,[5,3]],\n                          x[9,[2,3,3]]]):\n\nStableSpherePi( 8) := Group([x[infinity,[5,3]],\n                             x[infinity,[2,3,3]]]):\n\n# 9-stem \n\nSpherePi(11, 2) := Group([x[2,[1,2,3,3]]]):\nSpherePi(12, 3) := Group([x[3,[2,4,1,1,1]],\n                          x[3,[1,2,3,3]]]):\nSpherePi(13, 4) := Group([x[4,[3,3,3]],\n                          x[4,[2,4,1,1,1]],\n                          x[4,[1,2,3,3]]]):\nSpherePi(14, 5) := Group([x[5,[3,3,3]],\n                          x[5,[2,4,1,1,1]],\n                          x[5,[1,2,3,3]]]):\nSpherePi(15, 6) := Group([x[6,[3,3,3]],\n                          x[6,[2,4,1,1,1]],\n                          x[6,[1,2,3,3]]]):\nSpherePi(16, 7) := Group([x[7,[6,1,1,1]],\n                          x[7,[3,3,3]],\n                          x[7,[2,4,1,1,1]],\n                          x[7,[1,2,3,3]]]):\nSpherePi(17, 8) := Group([x[8,[7,1,1]],\n                          x[8,[6,1,1,1]],\n                          x[8,[3,3,3]],\n                          x[8,[2,4,1,1,1]],\n                          x[8,[1,2,3,3]]]):\nSpherePi(18, 9) := Group([x[9,[7,1,1]],\n                          x[9,[3,3,3]],\n                          x[9,[2,4,1,1,1]],\n                          x[9,[1,2,3,3]]]):\nSpherePi(19,10) := Group([x[10,[3,3,3]],\n                          x[10,[2,4,1,1,1]],\n                          x[10,[1,2,3,3]]],\n                         [x[10,[9,0]]]):\n\nStableSpherePi( 9) := Group([x[infinity,[3,3,3]],\n                             x[infinity,[2,4,1,1,1]],\n                             x[infinity,[1,2,3,3]]]):\n\n# 10-stem \n\nSpherePi(12, 2) := Group([x[2,[1,2,4,1,1,1]],\n                          x[2,[1,1,2,3,3]]]):\nSpherePi(13, 3) := Group([x[3,[2,2,3,3]],\n                          x[3,[1,2,4,1,1,1]],\n                          x[3,[1,1,2,3,3]]]):\nSpherePi(14, 4) := Group([x[4,[3,6,1]],\n                          x[4,[3,5,1,1]],\n                          x[4,[3,4,1,1,1]],\n                          x[4,[2,2,3,3]],\n                          x[4,[1,2,4,1,1,1]],\n                          x[4,[1,1,2,3,3]]]):\nSpherePi(15, 5) := Group([x[5,[4,3,3]],\n                          x[5,[2,2,3,3]],\n                          x[5,[1,2,4,1,1,1]],\n                          x[5,[1,1,2,3,3]]]):\nSpherePi(16, 6) := Group([x[6,[4,3,3]],\n                          x[6,[2,2,3,3]],\n                          x[6,[1,2,4,1,1,1]],\n                          x[6,[1,1,2,3,3]]]):\nSpherePi(17, 7) := Group([x[7,[4,3,3]],\n                          x[7,[2,2,3,3]],\n                          x[7,[1,2,4,1,1,1]],\n                          x[7,[1,1,2,3,3]]]):\nSpherePi(18, 8) := Group([x[8,[7,3]],\n                          x[8,[7,2,1]],\n                          x[8,[7,1,1,1]],\n                          x[8,[4,3,3]],\n                          x[8,[2,2,3,3]],\n                          x[8,[1,2,4,1,1,1]],\n                          x[8,[1,1,2,3,3]]]):\nSpherePi(19, 9) := Group([x[9,[7,3]],\n                          x[9,[7,2,1]],\n                          x[9,[7,1,1,1]],\n                          x[9,[1,2,4,1,1,1]]]):\nSpherePi(20,10) := Group([x[10,[7,3]],\n                          x[10,[7,2,1]],\n                          x[10,[1,2,4,1,1,1]]]):\nSpherePi(21,11) := Group([x[11,[7,3]],\n                          x[11,[1,2,4,1,1,1]]]):\n\nStableSpherePi(10) := Group([x[infinity,[1,2,4,1,1,1]]]):\n\n# 11-stem \n\nSpherePi(13, 2) := Group([x[2,[1,2,2,3,3]],\n                          x[2,[1,1,1,2,3,3]],\n                          x[2,[1,1,2,4,1,1,1]]]):\nSpherePi(14, 3) := Group([x[3,[2,3,3,3]],\n                          x[3,[2,2,4,1,1,1]],\n                          x[3,[2,1,2,3,3]],\n                          x[3,[1,1,2,4,1,1,1]]]):\nSpherePi(15, 4) := Group([x[4,[3,6,1,1]],\n                          x[4,[3,5,3]],\n                          x[4,[3,2,3,3]],\n                          x[4,[2,3,3,3]],\n                          x[4,[2,2,4,1,1,1]],\n                          x[4,[2,1,2,3,3]],\n                          x[4,[1,1,2,4,1,1,1]]]):\nSpherePi(16, 5) := Group([x[5,[4,4,1,1,1]],\n                          x[5,[3,5,3]],\n                          x[5,[3,2,3,3]],\n                          x[5,[2,2,4,1,1,1]],\n                          x[5,[1,1,2,4,1,1,1]]]):\nSpherePi(17, 6) := Group([x[6,[5,3,3]],\n                          x[6,[4,4,1,1,1]],\n                          x[6,[2,2,4,1,1,1]],\n                          x[6,[1,1,2,4,1,1,1]]]):\nSpherePi(18, 7) := Group([x[7,[5,3,3]],\n                          x[7,[4,4,1,1,1]],\n                          x[7,[2,2,4,1,1,1]],\n                          x[7,[1,1,2,4,1,1,1]]]):\nSpherePi(19, 8) := Group([x[8,[5,3,3]],\n                          x[8,[4,4,1,1,1]],\n                          x[8,[2,2,4,1,1,1]],\n                          x[8,[1,1,2,4,1,1,1]]]):\nSpherePi(20, 9) := Group([x[9,[5,3,3]],\n                          x[9,[4,4,1,1,1]],\n                          x[9,[2,2,4,1,1,1]],\n                          x[9,[1,1,2,4,1,1,1]]]):\nSpherePi(21,10) := Group([x[10,[4,4,1,1,1]],\n                          x[10,[2,2,4,1,1,1]],\n                          x[10,[1,1,2,4,1,1,1]]]):\nSpherePi(22,11) := Group([x[11,[4,4,1,1,1]],\n                          x[11,[2,2,4,1,1,1]],\n                          x[11,[1,1,2,4,1,1,1]]]):\nSpherePi(23,12) := Group([x[12,[4,4,1,1,1]],\n                          x[12,[2,2,4,1,1,1]],\n                          x[12,[1,1,2,4,1,1,1]]]):\n\nStableSpherePi(11) := Group([x[infinity,[4,4,1,1,1]],\n                             x[infinity,[2,2,4,1,1,1]],\n                             x[infinity,[1,1,2,4,1,1,1]]]):\n\n# 12-stem \n\nStableSpherePi(12) := Group([]):\n\n# 13-stem \n\nStableSpherePi(13) := Group([]):\n\n# 14-stem \n\nStableSpherePi(14) := Group([x[infinity,[7,7]],\n                             x[infinity,[6,2,3,3]]]):\n\n\nN := 11:\ndegrees_above := (k) -> [seq(k+i,i=0..N),infinity];\n\nfor n in degrees_above(1) do\n TodaName(x[n,[]]) := iota[n]:\nod:\n\nfor n in degrees_above(2) do \n TodaName(x[n,[1]]) := eta[n]:\n TodaName(x[n,[1,1]]) := o(eta[n],eta[n+1]):\n TodaName(x[n,[1,2,3,3]]) := o(eta[n],epsilon[n+1]):\n TodaName(x[n,[1,2,4,1,1,1]]) := o(eta[n],mu[n+1]):\nod:\n\nfor n in degrees_above(3) do \n TodaName(x[n,[2,3,3]]) := epsilon[n]:\n TodaName(x[n,[2,4,1,1,1]]) := mu[n]:\nod:\n\nfor n in degrees_above(4) do\n TodaName(x[n,[3]]) := nu[n]:\n TodaName(x[n,[3,3,3]]) := o(nu[n],nu[n+3],nu[n+6]):\nod:\n\nfor n in degrees_above(5) do \n TodaName(x[n,[4,4,1,1,1]]) := zeta[n]:\n TodaName(x[n,[2,2,4,1,1,1]]) := 2 * zeta[n]:\n TodaName(x[n,[1,1,2,4,1,1,1]]) := 4 * zeta[n]:\n TodaName(x[n,[3,3]]) := o(nu[n],nu[n+3]):\n TodaName(x[n,[2,1]]) :=  2 * nu[n]:\n TodaName(x[n,[1,1,1]]) :=  4 * nu[n]:\nod:\n\nfor n in degrees_above(6) do\n TodaName(x[n,[5,3]]) := nubar[n]:\nod:\n\nfor n in degrees_above(8) do\n TodaName(x[n,[7]]) := sigma[n]:\nod:\n\nfor n in degrees_above(9) do\n TodaName(x[n,[6,1]]) := 2*sigma[n]:\n TodaName(x[n,[5,1,1]]) := 4*sigma[n]:\n TodaName(x[n,[4,1,1,1]]) := 8*sigma[n]:\nod:\n\nTodaName(x[2,[1,1,1,1]]) := - o(eta[2],nuprime):\nTodaName(x[8,[7]]) := sigma[8]:\nTodaName(x[2,[1,2,2,3,3]]) := 3 * o(eta[2],epsilonprime):\nTodaName(x[2,[1,2,2,4,1,1,1]]) := 3 * o(eta[2],muprime):\nTodaName(x[2,[1,1,1]]) := o(eta[2],eta[3],eta[4]):\nTodaName(x[3,[1,1,1]]) := 2 * nuprime:\nTodaName(x[3,[2,1]]) := nuprime:\nTodaName(x[4,[1,1,1]]) := 2 * E(nuprime):\nTodaName(x[4,[2,1]]) := E(nuprime):\nTodaName(x[2,[1,2,1]]) := 2 * o(eta[2],nuprime):\nTodaName(x[3,[2,1,1]]) := o(nuprime,eta[6]):\nTodaName(x[4,[2,1,1]]) := o(E(nuprime),eta[7]):\nTodaName(x[4,[3,1]]) := o(nu[4],eta[7]):\nTodaName(x[5,[3,1]]) := o(nu[5],eta[8]):\nTodaName(x[2,[1,2,1,1]]) := o(eta[2],nuprime,eta[6]):\nTodaName(x[3,[2,1,1,1]]) := o(nuprime,eta[6],eta[7]):\nTodaName(x[4,[3,1,1]]) := o(nu[4],eta[7],eta[8]):\nTodaName(x[4,[2,1,1,1]]) := o(E(nuprime),eta[7],eta[8]):\nTodaName(x[5,[3,1,1]]) := o(nu[5],eta[8],eta[9]):\nTodaName(x[6,[5,0]]) := w[6]:\nTodaName(x[2,[1,2,1,1,1]]) := o(eta[2],nuprime,eta[6],eta[7]):\nTodaName(x[4,[3,3]]) := o(nu[4],nu[7]):\nTodaName(x[4,[3,2,1]]) := 2*o(nu[4],nu[7]):\nTodaName(x[4,[3,1,1,1]]) := 4*o(nu[4],nu[7]):\nTodaName(x[5,[4,1,1,1]]) := sigmathird:\nTodaName(x[6,[5,1,1]]) := sigmasecond:\nTodaName(x[6,[4,1,1,1]]) := 2*sigmasecond:\nTodaName(x[7,[6,1]]) := sigmaprime:\nTodaName(x[7,[5,1,1]]) := 2*sigmaprime:\nTodaName(x[7,[4,1,1,1]]) := 4*sigmaprime:\nTodaName(x[8,[6,1]]) := E(sigmaprime):\nTodaName(x[8,[5,1,1]]) := 2*E(sigmaprime):\nTodaName(x[8,[4,1,1,1]]) := 4*E(sigmaprime):\nTodaName(x[6,[5,2,1]]) := 2*nubar[6]:\nTodaName(x[6,[5,1,1,1]]) := 4*nubar[6]:\nTodaName(x[7,[6,1,1]]) := o(sigmaprime,eta[14]):\nTodaName(x[8,[6,1,1]]) := o(E(sigmaprime),eta[15]):\nTodaName(x[8,[7,1]]) := o(sigma[8],eta[15]):\nTodaName(x[9,[7,1]]) := o(sigma[9],eta[16]):\nTodaName(x[7,[6,1,1,1]]) := o(sigmaprime,eta[14],eta[15]):\nTodaName(x[8,[6,1,1,1]]) := o(E(sigmaprime),eta[15],eta[16]):\nTodaName(x[8,[7,1,1]]) := o(sigma[8],eta[15],eta[16]):\nTodaName(x[9,[7,1,1]]) := o(sigma[9],eta[16],eta[17]):\nTodaName(x[2,[1,1,2,3,3]]) := o(eta[2],eta[3],epsilon[4]):\nTodaName(x[3,[2,2,3,3]]) := epsilonprime:\nTodaName(x[3,[1,1,2,3,3]]) := 2*epsilonprime:\nTodaName(x[4,[2,2,3,3]]) := E(epsilonprime):\nTodaName(x[4,[1,1,2,3,3]]) := 2*E(epsilonprime):\nTodaName(x[4,[3,6,1]]) := o(nu[4],sigmaprime):\nTodaName(x[4,[3,5,1,1]]) := 2*o(nu[4],sigmaprime):\nTodaName(x[4,[3,4,1,1,1]]) := 4*o(nu[4],sigmaprime):\nTodaName(x[5,[4,3,3]]) := o(nu[5],sigma[8]):\nTodaName(x[5,[2,2,3,3]]) := 2*o(nu[5],sigma[8]):\nTodaName(x[5,[1,1,2,3,3]]) := 4*o(nu[5],sigma[8]):\nTodaName(x[6,[4,3,3]]) := o(nu[6],sigma[9]):\nTodaName(x[6,[2,2,3,3]]) := 2*o(nu[6],sigma[9]):\nTodaName(x[6,[1,1,2,3,3]]) := 4*o(nu[6],sigma[9]):\nTodaName(x[7,[4,3,3]]) := o(nu[7],sigma[10]):\nTodaName(x[7,[2,2,3,3]]) := 2*o(nu[7],sigma[10]):\nTodaName(x[7,[1,1,2,3,3]]) := 4*o(nu[7],sigma[10]):\nTodaName(x[8,[4,3,3]]) := o(nu[8],sigma[11]):\nTodaName(x[8,[2,2,3,3]]) := 2*o(nu[8],sigma[11]):\nTodaName(x[8,[1,1,2,3,3]]) := 4*o(nu[8],sigma[11]):\nTodaName(x[8,[7,3]]) := o(sigma[8],nu[15]):\nTodaName(x[8,[7,2,1]]) := 2*o(sigma[8],nu[15]):\nTodaName(x[8,[7,1,1,1]]) := 4*o(sigma[8],nu[15]):\nTodaName(x[9,[7,3]]) := o(sigma[9],nu[16]):\nTodaName(x[9,[7,2,1]]) := 2*o(sigma[9],nu[16]):\nTodaName(x[9,[7,1,1,1]]) := 4*o(sigma[9],nu[16]):\nTodaName(x[10,[9,0]]) := w[10]:\nTodaName(x[10,[7,3]]) := o(sigma[10],nu[17]):\nTodaName(x[10,[7,2,1]]) := 2*o(sigma[10],nu[17]):\nTodaName(x[11,[7,3]]) := o(sigma[11],nu[18]):\nTodaName(x[2,[1,1,1,2,3,3]]) := 2*o(eta[2],epsilonprime):\nTodaName(x[2,[1,1,2,4,1,1,1]]) := o(eta[2],eta[3],mu[4]):\nTodaName(x[3,[2,2,4,1,1,1]]) := muprime:\nTodaName(x[3,[1,1,2,4,1,1,1]]) := 2*muprime:\nTodaName(x[3,[2,3,3,3]]) := o(epsilon[3],nu[11]):\nTodaName(x[3,[2,1,2,3,3]]) := o(nuprime,epsilon[6]):\nTodaName(x[4,[2,2,4,1,1,1]]) := E(muprime):\nTodaName(x[4,[1,1,2,4,1,1,1]]) := 2*E(muprime):\nTodaName(x[4,[2,3,3,3]]) := o(epsilon[4],nu[12]):\nTodaName(x[4,[2,1,2,3,3]]) := o(E(nuprime),epsilon[7]):\nTodaName(x[4,[3,6,1,1]]) := o(nu[4],sigmaprime,eta[14]):\nTodaName(x[4,[3,5,3]]) := o(nu[4],nubar[7]):\nTodaName(x[4,[3,2,3,3]]) := o(nu[4],epsilon[7]):\nTodaName(x[5,[3,5,3]]) := o(nu[5],nubar[8]):\nTodaName(x[5,[3,2,3,3]]) := o(nu[5],epsilon[8]):\nTodaName(x[6,[5,3,3]]) := o(nubar[6],nu[14]):\nTodaName(x[6,[3,2,3,3]]) := 2*o(nubar[6],nu[14]):\nTodaName(x[7,[5,3,3]]) := o(nubar[7],nu[15]):\nTodaName(x[8,[5,3,3]]) := o(nubar[8],nu[16]):\nTodaName(x[9,[5,3,3]]) := o(nubar[9],nu[17]):\n\n\ngenerators  :=  proc(G) \n map(op,[op(G)]):\nend:\n\nfor i from 0 to N do\n for j from 1 to i+2 do\n  G  :=  SpherePi(i+j,j):\n  for a in generators(G) do\n   if not(Source(a)=i+j and\n          Target(a)=j and\n          IsAdmissible(a)) then\n    print([i+j,j,a]):\n   fi:\n  od:\n od:\nod:\n\nall_gens  :=  [seq(seq(op(generators(SpherePi(i,j))),i=1..j+N),j=1..N+2)]:\n\nfor a in all_gens do\n GN(TodaName(a)) := a:\nod:\n\nfor a in all_gens do\n m := Source(a):\n n := Target(a):\n b := two(a):\n if type(b,specfunc(anything,two)) then\n  two(a) := 0:\n fi:\n b := E(a):\n if type(b,specfunc(anything,E)) then\n  E(a) := x[op(1,a)+1,op(2,a)]:\n fi:\n b := H(a):\n if type(b,specfunc(anything,H)) then\n  if (2*m-1>n or n=m) then \n   H(a) := 0:\n  else\n   J := op(2,a):\n   if J[1] > n-1 then\n    H(a) := 0:\n   else \n    H(a) := x[2*n-1,J[2..-1]]:\n   fi:\n  fi:\n fi:\n\n o(a,x[m,[]]) := a;\n o(x[n,[]],a) := a;\nod:\n\nfor n in degrees_above(5) do\n two(x[n,[3]]) := x[n,[2,1]]:\n two(x[n,[2,1]]) := x[n,[1,1,1]]:\n two(x[n,[4,4,1,1,1]]) := x[n,[2,2,4,1,1,1]]:\n two(x[n,[2,2,4,1,1,1]]) := x[n,[1,1,2,4,1,1,1]]:\nod:\n\nfor n in degrees_above(6) do\n two(x[n,[5,1,1]])       := x[n,[4,1,1,1]]:\nod:\n\nfor n in degrees_above(9) do \n two(x[n,[7]]) := x[n,[6,1]]:\n two(x[n,[6,1]]) := x[n,[5,1,1]]:\n two(x[n,[5,1,1]]) := x[n,[4,1,1,1]]:\nod:\n\ntwo(x[2,[1]])           := x[2,[1,0]]:\ntwo(x[2,[1,1,1,1]])     := x[2,[1,2,1]]:\ntwo(x[2,[1,1,1,1]])     := x[2,[1,2,1]]:\ntwo(x[2,[1,2,2,3,3]])   := x[2,[1,1,1,2,3,3]]:\ntwo(x[3,[2,1]])         := x[3,[1,1,1]]:\ntwo(x[4,[3]])           := x[4,[3,0]]:\ntwo(x[4,[3,2,1]])       := x[4,[3,1,1,1]]:\ntwo(x[4,[3,3]])         := x[4,[3,2,1]]:\ntwo(x[4,[3,6,1]])       := x[4,[3,5,1,1]]:\ntwo(x[5,[2,2,3,3]])     := x[5,[1,1,2,3,3]]:\ntwo(x[5,[3,5,1,1]])     := x[5,[3,4,1,1,1]]:\ntwo(x[5,[4,3,3]])       := x[5,[2,2,3,3]]:\ntwo(x[6,[2,2,3,3]])     := x[6,[1,1,2,3,3]]:\ntwo(x[6,[4,3,3]])       := x[6,[2,2,3,3]]:\ntwo(x[6,[5,1,1]])       := x[6,[4,1,1,1]]:\ntwo(x[6,[5,2,1]])       := x[6,[5,1,1,1]]:\ntwo(x[6,[5,3,3]])       := x[6,[3,2,3,3]]:\ntwo(x[6,[5,3]])         := x[6,[5,2,1]]:\ntwo(x[7,[2,2,3,3]])     := x[7,[1,1,2,3,3]]:\ntwo(x[7,[4,3,3]])       := x[7,[2,2,3,3]]:\ntwo(x[7,[5,1,1,1]])     := x[7,[4,1,1,1,1]]:\ntwo(x[7,[6,1]])         := x[7,[5,1,1]]:\ntwo(x[8,[2,2,3,3]])     := x[8,[1,1,2,3,3]]:\ntwo(x[8,[4,3,3]])       := x[8,[2,2,3,3]]:\ntwo(x[8,[5,1,1,1]])     := x[8,[4,1,1,1,1]]:\ntwo(x[8,[6,1]])         := x[8,[5,1,1]]:\ntwo(x[8,[7]])           := x[8,[7,0]]:\ntwo(x[8,[7,2,1]])       := x[8,[7,1,1,1]]:\ntwo(x[8,[7,3]])         := x[8,[7,2,1]]:\ntwo(x[9,[7,2,1]])       := x[9,[7,1,1,1]]:\ntwo(x[9,[7,3]])         := x[9,[7,2,1]]:\ntwo(x[10,[7,3]])        := x[10,[7,2,1]]:\n\nfor n in degrees_above(2) do \n o(x[n,[1]],x[n+1,[1]]) := x[n,[1,1]]:\n o(x[n,[1]],x[n+1,[1,1]]) := x[n,[1,1,1]]:\n o(x[n,[1,1]],x[n+2,[1]]) := x[n,[1,1,1]]:\n o(x[n,[1]],x[n+1,[2,3,3]]) := x[n,[1,2,3,3]]:\n o(x[n,[1]],x[n+1,[2,4,1,1,1]]) := x[n,[1,2,4,1,1,1]]:\nod:\n\nfor n in degrees_above(4) do\n o(x[n,[3]],x[n+3,[3]]) := x[n,[3,3]]:\n o(x[n,[3]],x[n+3,[3,3]]) := x[n,[3,3,3]]:\n o(x[n,[3,3]],x[n+6,[3]]) := x[n,[3,3,3]]:\nod:\n\n# Predictable ternary+ composites\no(x[2,[1]],    x[3,[2,1]],   x[6,[1]],   x[7,[1]]) := x[2,[1,2,1,1,1]]:\no(x[3,[2,1]],  x[6,[1]],     x[7,[1]])             := x[3,[2,1,1,1]]:\no(x[4,[2,1]],  x[7,[1]],     x[8,[1]])             := x[4,[2,1,1,1]]:\no(x[4,[3]],    x[7,[1]],     x[8,[1]])             := x[4,[3,1,1]]:\no(x[4,[3]],    x[7,[6,1]],   x[14,[1]])            := x[4,[3,6,1,1]]:\no(x[4,[3]],    x[7,[3]],     x[10,[3]])            := x[4,[3,3,3]]:\no(x[5,[3]],    x[8,[1]],     x[9,[1]])             := x[5,[3,1,1]]:\no(x[7,[6,1]],  x[14,[1]],    x[15,[1]])            := x[7,[6,1,1,1]]:\no(x[8,[6,1]],  x[15,[1]],    x[16,[1]])            := x[8,[6,1,1,1]]:\no(x[8,[7]],    x[15,[1]],    x[16,[1]])            := x[8,[7,1,1]]:\no(x[9,[7]],    x[16,[1]],    x[17,[1]])            := x[9,[7,1,1]]:\n\n# Predictable composites\no(x[2,[1]],    x[3,[1,2,3,3]])     := x[2,[1,1,2,3,3]]:\no(x[2,[1]],    x[3,[1,1,2,3,3]])   := x[2,[1,1,1,2,3,3]]:\no(x[2,[1]],    x[3,[1,2,4,1,1,1]]) := x[2,[1,1,2,4,1,1,1]]:\no(x[2,[1]],    x[3,[2,1]])         := x[2,[1,2,1]]:\no(x[2,[1]],    x[3,[2,1,1]])       := x[2,[1,2,1,1]]:\no(x[2,[1]],    x[3,[2,1,1,1]])     := x[2,[1,2,1,1,1]]:\no(x[2,[1]],    x[3,[1,1,1]])       := x[2,[1,1,1,1]]:\no(x[2,[1,1]],  x[4,[2,1]])         := 0:\no(x[2,[1,1]],  x[4,[1,1]])         := x[2,[1,1,1,1]]: #?\no(x[2,[1,1,1]],x[5,[1]])           := x[2,[1,1,1,1]]:\no(x[2,[1]],    x[3,[2,1]])         := x[2,[1,2,1]]:\no(x[2,[1,2,1]],x[6,1])             := x[2,[1,2,1,1]]:\no(x[3,[1]],    x[4,[2,1]])         := 0:\no(x[3,[1]],    x[4,[2,1,1]])       := 0:\no(x[3,[1]],    x[4,[2,4,1,1,1]])   := x[3,[1,2,4,1,1,1]]:\no(x[3,[2,1]],  x[6,[1]])           := x[3,[2,1,1]]:\no(x[3,[2,1]],  x[6,[1,1]])         := x[3,[2,1,1,1]]:\no(x[3,[2,1,1]],x[7,[1]])           := x[3,[2,1,1,1]]:\no(x[3,[2,1]],  x[6,[2,3,3]])       := x[3,[2,1,2,3,3]]:\no(x[3,[2,3,3]],x[11,[3]])          := x[3,[2,3,3,3]]:\no(x[4,[2,1]],  x[7,[1]])           := x[4,[2,1,1]]:\no(x[4,[2,1]],  x[7,[2,3,3]])       := x[4,[2,1,2,3,3]]:\no(x[4,[2,3,3]],x[12,[3]])          := x[4,[2,3,3,3]]:\no(x[4,[3]],    x[7,[1]])           := x[4,[3,1]]:\no(x[4,[3]],    x[7,[2,3,3]])       := x[4,[3,2,3,3]]:\no(x[4,[3]],    x[7,[3]])           := x[4,[3,3]]:\no(x[4,[3]],    x[7,[5,3]])         := x[4,[3,5,3]]:\no(x[4,[3]],    x[7,[6,1]])         := x[4,[3,6,1]]:\no(x[5,[3]],    x[8,[1]])           := x[5,[3,1]]:\no(x[5,[3]],    x[8,[2,3,3]])       := x[5,[3,2,3,3]]:\no(x[5,[3]],    x[8,[5,3]])         := x[5,[3,5,3]]:\no(x[6,[5,3]],  x[14,[3]])          := x[6,[5,3,3]]:\no(x[7,[5,3]],  x[15,[3]])          := x[7,[5,3,3]]:\no(x[7,[6,1]],  x[14,[1]])          := x[7,[6,1,1]]:\no(x[8,[5,3]],  x[16,[3]])          := x[8,[5,3,3]]:\no(x[8,[6,1]],  x[15,[1]])          := x[8,[6,1,1]]:\no(x[8,[7]],    x[15,[1]])          := x[8,[7,1]]:\no(x[8,[7]],    x[15,[3]])          := x[8,[7,3]]:\no(x[9,[5,3]],  x[17,[3]])          := x[9,[5,3,3]]:\no(x[9,[7]],    x[16,[1]])          := x[9,[7,1]]:\no(x[9,[7]],    x[16,[3]])          := x[9,[7,3]]:\no(x[10,[7]],   x[17,[3]])          := x[10,[7,3]]:\no(x[11,[7]],   x[18,[3]])          := x[11,[7,3]]:\no(x[2,[1,1]],  x[4,[1]])           := x[2,[1,1,1]]:\no(x[2,[1,1]],  x[4,[2,3,3]])       := x[2,[1,1,2,3,3]]:\n\no(x[2, [1, 1]], x[4, [2, 4, 1, 1, 1]]) := x[2, [1, 1, 2, 4, 1, 1, 1]]:\no(x[2, [1, 1]], x[4, [2, 1, 1]]) := 0:\no(x[2, [1, 2, 1, 1]], x[7, [1]]) := x[2, [1, 2, 1, 1, 1]]:\n\n# Unpredictable composites\no(x[2,[1]],    x[3,[2,1]])   := x[2,[1,1,1,1]] + x[2,[1,2,1]]:\no(x[2,[1]],    x[3,[2,2,3,3]]) := x[2,[1,2,2,3,3]]+x[2,[1,1,1,2,3,3]]:\no(x[5,[3]],    x[8,[7]])     := x[5,[4,3,3]]:\no(x[6,[3]],    x[9,[7]])     := x[6,[4,3,3]]:\no(x[7,[3]],    x[10,[7]])    := x[7,[4,3,3]]:\no(x[8,[3]],    x[11,[7]])    := x[8,[4,3,3]]:\n\n# Suspensions\nE(x[2,[1,1,1,1]]) := 0:\nE(x[2,[1,2,1]])   := 0:\n\n# (************************************************************************)\n# (* Suspensions                                                          *)\n\n\n\n\n# TodaName(x[6,[5,0]])               := w[6]:\n# TodaName(x[6,[5,1,1]])             := sigmasecond:\n# TodaName(x[7,[6,1]])               := sigmaprime:\n# TodaName(x[8,[6,1]])               := E(sigmaprime):\n# TodaName(x[10,[9,0]])              := w[10]:\n\n# TodaName(x[2,[1,1,1,2,3,3]])       := 2*o(x[2,[1]],x[3,[2,2,3,3]]):\n# TodaName(x[2,[1,2,1]])             := 2*o(x[2,[1]],x[3,[2,1]]):\n# TodaName(x[3,[1,1,1]])             := 2*x[3,[2,1]]:\n# TodaName(x[3,[1,1,2,3,3]])         := 2*x[3,[2,2,3,3]]:\n# TodaName(x[3,[1,1,2,4,1,1,1]])     := 2*x[3,[2,2,4,1,1,1]]:\n# TodaName(x[4,[1,1,1]])             := 2*x[4,[2,1]]:\n# TodaName(x[4,[1,1,2,3,3]])         := 2*x[4,[2,2,3,3]]:\n# TodaName(x[4,[1,1,2,4,1,1,1]])     := 2*x[4,[2,2,4,1,1,1]]:\n# TodaName(x[4,[3,2,1]])             := 2*o(x[4,[3]],x[7,[3]]):\n# TodaName(x[4,[3,5,1,1]])           := 2*o(x[4,[3]],x[7,[6,1]]):\n# TodaName(x[5,[2,2,3,3]])           := 2*o(x[5,[3]],x[8,[7]]):\n# TodaName(x[6,[2,2,3,3]])           := 2*o(x[6,[3]],x[9,[7]]):\n# TodaName(x[6,[3,2,3,3]])           := 2*o([6,[5,3]],x[14,[3]]):\n# TodaName(x[6,[4,1,1,1]])           := 2*x[6,[5,1,1]]:\n# TodaName(x[6,[5,2,1]])             := 2*[6,[5,3]]:\n# TodaName(x[7,[2,2,3,3]])           := 2*o(x[7,[3]],x[10,[7]]):\n# TodaName(x[7,[5,1,1]])             := 2*x[7,[6,1]]:\n# TodaName(x[8,[2,2,3,3]])           := 2*o(x[8,[3]],x[11,[7]]):\n# TodaName(x[8,[5,1,1]])             := 2*x[8,[6,1]]:\n# TodaName(x[8,[7,2,1]])             := 2*o(x[8,[7]],x[15,[3]]):\n# TodaName(x[9,[7,2,1]])             := 2*o(x[9,[7]],x[16,[3]]):\n# TodaName(x[10,[7,2,1]])            := 2*o(x[10,[7]],x[17,[3]]):\n\n# TodaName(x[4,[3,1,1,1]])           := 4*o(x[4,[3]],x[7,[3]]):\n# TodaName(x[4,[3,4,1,1,1]])         := 4*o(x[4,[3]],x[7,[6,1]]):\n# TodaName(x[5,[1,1,2,3,3]])         := 4*o(x[5,[3]],x[8,[7]]):\n# TodaName(x[6,[1,1,2,3,3]])         := 4*o(x[6,[3]],x[9,[7]]):\n# TodaName(x[6,[5,1,1,1]])           := 4*[6,[5,3]]:\n# TodaName(x[7,[1,1,2,3,3]])         := 4*o(x[7,[3]],x[10,[7]]):\n# TodaName(x[7,[4,1,1,1]])           := 4*x[7,[6,1]]:\n# TodaName(x[8,[1,1,2,3,3]])         := 4*o(x[8,[3]],x[11,[7]]):\n# TodaName(x[8,[4,1,1,1]])           := 4*x[8,[6,1]]:\n# TodaName(x[8,[7,1,1,1]])           := 4*o(x[8,[7]],x[15,[3]]):\n# TodaName(x[9,[7,1,1,1]])           := 4*o(x[9,[7]],x[16,[3]]):\n\n\n# TodaName(x[2,[1,1,1,1]])           := - o(x[2,[1]],x[3,[2,1]]):\n# TodaName(x[2,[1,2,2,3,3]])         := 3 * o(x[2,[1]],x[3,[2,2,3,3]]):\n# TodaName(x[2,[1,2,2,4,1,1,1]])     := 3 * o(x[2,[1]],x[3,[2,2,4,1,1,1]]):\n\n# TodaName(x[2,[1,1,2,3,3]])         := o(x[2,[1]],x[3,[1]],x[4,[2,3,3]]):\n# TodaName(x[2,[1,1,2,4,1,1,1]])     := o(x[2,[1]],x[3,[1]],x[4,[2,4,1,1,1]]):\n# TodaName(x[2,[1,2,1,1,1]])         := o(x[2,[1]],x[3,[2,1]],x[6,[1]],x[7,[1]]):\n# TodaName(x[2,[1,2,1,1]])           := o(x[2,[1]],x[3,[2,1]],x[6,[1]]):\n# TodaName(x[3,[2,1,1,1]])           := o(x[3,[2,1]],x[6,[1]],x[7,[1]]):\n# TodaName(x[4,[2,1,1,1]])           := o(x[4,[2,1]],x[7,[1]],x[8,[1]]):\n# TodaName(x[4,[3,1,1]])             := o(x[4,[3]],x[7,[1]],x[8,[1]]):\n# TodaName(x[4,[3,6,1,1]])           := o(x[4,[3]],x[7,[6,1]],x[14,[1]]):\n# TodaName(x[7,[6,1,1,1]])           := o(x[7,[6,1]],x[14,[1]],x[15,[1]]):\n# TodaName(x[8,[6,1,1,1]])           := o(x[8,[6,1]],x[15,[1]],x[16,[1]]):\n# TodaName(x[8,[7,1,1]])             := o(x[8,[7]],x[15,[1]],x[16,[1]]):\n# TodaName(x[9,[7,1,1]])             := o(x[9,[7]],x[16,[1]],x[17,[1]]):\n# TodaName(x[5,[3,1,1]])             := o(x[5,[3]],x[8,[1]],x[9,[1]]):\n\n\n", "meta": {"hexsha": "82b7895dc3270f212559a90f4d27029bef303715", "size": 26355, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/chromatic/Genealogy.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/chromatic/Genealogy.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/chromatic/Genealogy.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": 34.8150594452, "max_line_length": 81, "alphanum_fraction": 0.3884272434, "num_tokens": 12528, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7025300573952052, "lm_q2_score": 0.6513548511303336, "lm_q1q2_score": 0.45759636094923867}}
{"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\nop_a1 := 1.5214:\nop_a2 := 0.5764:\nop_b1 := 1.1284:\nop_b2 := 0.3183:\n\nop_beta := (rs, z, xs0, xs1) ->\n  op_qab/b88_zab(1, op_f, rs, z, xs0, xs1):\n\nf_op := (rs, z, xt, xs0, xs1) ->\n  - (1 - z^2)*n_total(rs)/4.0\n  * (op_a1*op_beta(rs, z, xs0, xs1) + op_a2)\n  / (op_beta(rs, z, xs0, xs1)^4 + op_b1*op_beta(rs, z, xs0, xs1)^3 + op_b2*op_beta(rs, z, xs0, xs1)^2):\n\nf := (rs, z, xt, xs0, xs1) ->\n  f_op(rs, z, xt, xs0, xs1):\n", "meta": {"hexsha": "599d9052f788c3867ac3e73290b3015aaa23c6f7", "size": 657, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "libxc-4.2.3/maple/op.mpl", "max_stars_repo_name": "rdietric/lsms", "max_stars_repo_head_hexsha": "8d0d5f01186abf9a1cc54db3f97f9934b422cf92", "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-4.2.3/maple/op.mpl", "max_issues_repo_name": "rdietric/lsms", "max_issues_repo_head_hexsha": "8d0d5f01186abf9a1cc54db3f97f9934b422cf92", "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-4.2.3/maple/op.mpl", "max_forks_repo_name": "rdietric/lsms", "max_forks_repo_head_hexsha": "8d0d5f01186abf9a1cc54db3f97f9934b422cf92", "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": 27.375, "max_line_length": 103, "alphanum_fraction": 0.601217656, "num_tokens": 290, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8652240756264638, "lm_q2_score": 0.5273165233795671, "lm_q1q2_score": 0.4562469515036465}}
{"text": "######################################################################\n\n`is_element/tree_height_functions` := (A::set) -> (TT) -> proc(h)\n local P,U,V,a,u,is_minimal;\n global reason;\n\n if not(type(h,table)) then\n  reason := [convert(procname,string),\"h is not a table\",h];\n  return false;\n fi;\n\n if map(op,{indices(h)}) <> TT then\n  reason := [convert(procname,string),\"h is not indexed by TT\",h,TT];\n  return false;\n fi;\n\n for a in A do if h[{a}] <> 0 then\n  reason := [convert(procname,string),\"h({a}) <> 0\",a,h[{a}]];\n  return false;\n fi; od;\n\n for V in TT do\n  u := h[V];\n  if not (`is_element/RR`(u) and u >= 0 and u <= 1) then\n   reason := [convert(procname,string),\"h(V) is not in the unit interval\",V,u];\n   return false;\n  fi;\n\n  is_minimal := true;\n  for U in TT do\n   if U <> V and U minus V = {} then\n    is_minimal := false;\n    if h[U] > h[V] then return false; fi;\n   fi;\n  od;\n  if is_minimal and h[V] <> 0 then\n   reason := [convert(procname,string),\"V is minimal in TT but h(V) <> 0\",V,TT,h[V]];\n   return false;\n  fi;\n od;\n\n return true;\nend;\n\n######################################################################\n\n`is_equal/tree_height_functions` := (A::set) -> (TT) -> proc(h1,h2) \n local T;\n global reason;\n\n for T in TT do \n  if h1[T] <> h2[T] then\n   reason := [convert(procname,string),\"h1[T] <>  h2[T]\",T,h1[T],h2[T]];\n   return false;\n  fi;\n od;\n\n return true;\nend;\n\n######################################################################\n\n`is_leq/tree_height_functions` := NULL;\n\n######################################################################\n\n`random_element/tree_height_functions` := (A::set) -> (TT) -> proc(d::posint := 12)\n local e,TS,T,h,parent,children;\n\n TS := sort([op(TT)],(U,V) -> nops(U) > nops(V));\n h := table();\n\n parent := parent_map(A)(TT);\n children := children_map(A)(TT);\n\n for T in TS do\n  if children[T] = {} then\n   h[T] := 0;\n  elif parent[T] = FAIL then\n   h[T] := rand(0..d)()/d;\n  else\n   e := h[parent[T]] * d;\n   h[T] := rand(0..e)()/d;\n  fi;\n od;\n\n return eval(h); \nend;\n\n######################################################################\n\n`list_elements/tree_height_functions` := NULL;\n`count_elements/tree_height_functions` := NULL;\n\n######################################################################\n\n`is_singular/tree_height_functions` := (A::set) -> (TT) -> proc(h)\n local TS,n,i,j;\n\n TS := sort([op(TT)],(U,V) -> nops(U) < nops(V));\n n := nops(TS);\n for i from 1 to n do \n  if h[TS[i]] = 1 then return true; fi;\n  for j from i+1 to n do\n   if TS[i] minus TS[j] = {} and h[TS[i]] = h[TS[j]] then\n    return true;\n   fi;\n  od;\n od;\n\n return false;\nend;\n\n######################################################################\n\n`extend/tree_height_functions` := (A::set) -> (TT) -> proc(h)\n local he,TS,P,T,U;\n\n he := table;\n TS := sort([op(TT)],(U,V) -> nops(U) < nops(V));\n\n P := `list_elements/nonempty_subsets`(A);\n for T in P do \n  he[T] := 1;\n  for U in TS do\n   if T minus U = {} then\n    he[T] := h[U];\n    break;\n   fi;\n  od;\n od;\n\n return eval(he);\nend;\n\n", "meta": {"hexsha": "f8962a9522972756db2a0cb9f2941f7dafd1b9e8", "size": 3041, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/tree_height_functions.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/tree_height_functions.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/tree_height_functions.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.3602941176, "max_line_length": 85, "alphanum_fraction": 0.4810917461, "num_tokens": 889, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.737158174177441, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.4561390547553415}}
{"text": "# JACOBI\n#\n# A package for the computation of the Jacobi property for Poisson brackets\n#\n\n#\n# See https://gdeq.org/Weakly_nonlocal_Poisson_brackets for further details\n#\n# Authors: M. Casati, P. Lorenzoni, D. Valeri, R. Vitolo (2021)\n#\n#  L i c e n s e\n#\n# JACOBI is a free software distributed under the terms of the GNU General \n# Public License <http://www.gnu.org/copyleft/gpl.html> as published by \n# the Free Software Foundation.\n#\n# In particular, JACOBI comes with ABSOLUTELY NO WARRANTY.\n#\n# Version history\n#\n# Version 1.0, 15 January 2021\n\nprint(`JACOBI 1.0 for Maple 2020`);\nprint(`Authors: M. Casati, P. Lorenzoni, D. Valeri, R. Vitolo`);\nprint(`Web site: https://gdeq.org/Weakly_nonlocal_Poisson_brackets`);\n\nSchouten_bracket:= proc(P,Q,T,N,M)\n  description \"Calculate the Schouten bracket [P,Q]\",\n              \"N: number of components of the operators P,Q;\",\n              \"M: order of derivatives in P,Q\",\n\t      \"T: the three-vector T=[P,Q]\";\n\n  local P_xy,P_yx,P_xz,P_zx,P_zy,P_yz,Q_xy,Q_yx,Q_xz,Q_zx,Q_yz,Q_zy,\n  i,j,k,l,r,s,t,T0,T1,T2,cfnl_xyxz,cfnl_zxzy,cfnl_yzyx,cfl_xyxz:\n  global delta:\n\n  print(\"Step 0: calculating Dubrovin-Zhang formula\");\n\n# Calculate the total derivatives of the operator P\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to M do\n        P[i,j,k]:=add(\n\t  add(\n\t    diff(P[i,j,k-1],u[q,x,s])*u[q,x,s+1],\n\t    s=0..M-1),\n\t  q=1..N)\n\t  + add(\n\t      diff(P[i,j,k-1],delta[x-y,s])*delta[x-y,s+1],\n\t    s=-1..M-1)\n      end do\n    end do\n  end do:\n\n#Generate the operators P in all variables needed in Dubrovin-Zhang formula\n  P_xy:=P:\n  P_yx:=subs({x=y,y=x},P_xy):\n  P_xz:=subs(y=z,P_xy):\n  P_zx:=subs(y=z,P_yx):\n  P_yz:=subs(x=y,P_xz):\n  P_zy:=subs(x=z,P_xy):\n\n# Calculate the total derivatives of the operator Q\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to M do\n        Q[i,j,k]:=add(\n\t  add(\n\t    diff(Q[i,j,k-1],u[q,x,s])*u[q,x,s+1],\n\t    s=0..M-1),\n\t  q=1..N)\n\t  + add(\n\t      diff(Q[i,j,k-1],delta[x-y,s])*delta[x-y,s+1],\n\t    s=-1..M-1)\n      end do\n    end do\n  end do:\n\n#Generate the operators Q in all variables needed in Dubrovin-Zhang formula\n  Q_xy:=Q:\n  Q_yx:=subs({x=y,y=x},Q_xy):\n  Q_xz:=subs(y=z,Q_xy):\n  Q_zx:=subs(y=z,Q_yx):\n  Q_yz:=subs(x=y,Q_xz):\n  Q_zy:=subs(x=z,Q_xy):\n\n# The three-vector T0 from Dubrovin-Zhang formula\nT0:=Array(1..N,1..N,1..N):\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        T0[i,j,k]:=\n\tadd(add(diff(P_xy[i,j,0],u[l,x,s])*Q_xz[l,k,s],s=0..M)\n\t+ subs(delta[x-y,-1]=-delta[y-x,-1],\n\t    add(diff(P_xy[i,j,0],u[l,y,s])*Q_yz[l,k,s],s=0..M))\n\t+ add(diff(P_zx[k,i,0],u[l,z,s])*Q_zy[l,j,s],s=0..M)\n\t+ subs(delta[z-x,-1]=-delta[x-z,-1],\n\t    add(diff(P_zx[k,i,0],u[l,x,s])*Q_xy[l,j,s],s=0..M))\n\t+ add(diff(P_yz[j,k,0],u[l,y,s])*Q_yx[l,i,s],s=0..M)\n\t+ subs(delta[y-z,-1]=-delta[z-y,-1],\n\t    add(diff(P_yz[j,k,0],u[l,z,s])*Q_zx[l,i,s],s=0..M))\n\t+ add(diff(Q_xy[i,j,0],u[l,x,s])*P_xz[l,k,s],s=0..M)\n\t+ subs(delta[x-y,-1]=-delta[y-x,-1],\n\t    add(diff(Q_xy[i,j,0],u[l,y,s])*P_yz[l,k,s],s=0..M))\n\t+ add(diff(Q_zx[k,i,0],u[l,z,s])*P_zy[l,j,s],s=0..M)\n\t+ subs(delta[z-x,-1]=-delta[x-z,-1],\n\t    add(diff(Q_zx[k,i,0],u[l,x,s])*P_xy[l,j,s],s=0..M))\n\t+ add(diff(Q_yz[j,k,0],u[l,y,s])*P_yx[l,i,s],s=0..M)\n\t+ subs(delta[y-z,-1]=-delta[z-y,-1],\n\t    add(diff(Q_yz[j,k,0],u[l,z,s])*P_zx[l,i,s],s=0..M))\n\t    ,l=1..N)\n      end do\n    end do\n  end do:\n\n# Here we calculate the step 1 of the algorithm\n# enhanced by a first application of the step 3\n# in order to reconstruct a new three-vector T1\n# which is equivalent to T0 up to total derivatives.\n\nprint(\"Step 1 of the algorithm\");\n\n# Replacing nu(z-y)*delta(z-x)\n  delta[z-y,-1,z-x,0]:=delta[x-y,-1]*delta[x-z,0]:\n  for i from 1 to M-1 do\n    delta[z-y,-1,z-x,i]:= - add(diff(delta[z-y,-1,z-x,i-1],\n      delta[x-y,k])*delta[x-y,k+1],k=-1..M)\n       - add(diff(delta[z-y,-1,z-x,i-1],\n         delta[x-z,k])*delta[x-z,k+1],k=-1..M)\n  end do:\n\n# Replacing nu(y-x)*delta(y-z)\n  delta[y-x,-1,y-z,0]:=delta[z-x,-1]*delta[z-y,0]:\n  for i from 1 to M-1 do\n    delta[y-x,-1,y-z,i]:= - add(diff(delta[y-x,-1,y-z,i-1],\n      delta[z-x,k])*delta[z-x,k+1],k=-1..M)\n       - add(diff(delta[y-x,-1,y-z,i-1],\n         delta[z-y,k])*delta[z-y,k+1],k=-1..M)\n  end do:\n\n# Replacing nu(x-z)*delta(x-y)\n  delta[x-z,-1,x-y,0]:=delta[y-z,-1]*delta[y-x,0]:\n  for i from 1 to M-1 do\n  delta[x-z,-1,x-y,i]:= - add(diff(delta[x-z,-1,x-y,i-1],\n    delta[y-z,k])*delta[y-z,k+1],k=-1..M)\n     - add(diff(delta[x-z,-1,x-y,i-1],\n       delta[y-x,k])*delta[y-x,k+1],k=-1..M)\n  end do:\n\n# Replacing all products of delta's to products of the form\n# delta^(m)(x-y)*delta^(n)(x-z)\n  for l from 0 to M do\n    delta[x-y,0,y-z,l]:=delta[x-y,0]*delta[x-z,l]\n  end do:\n\n  for k from 1 to M do\n    for l from 0 to M do\n      delta[x-y,k,y-z,l]:=add(diff(delta[x-y,k-1,y-z,l],delta[x-y,m])\n        *delta[x-y,m+1],m=-1..M)\n        +add(diff(delta[x-y,k-1,y-z,l],delta[x-z,m])*delta[x-z,m+1],m=-1..M)\n    end do\n  end do:\n\n  for l from 0 to M do\n    delta[z-x,0,z-y,l]:=delta[x-y,l]*delta[x-z,0]\n  end do:\n\n  for k from 1 to M do\n    for l from 0 to M do\n      delta[z-x,k,z-y,l]:=-add(diff(delta[z-x,k-1,z-y,l],delta[x-y,m])\n        *delta[x-y,m+1],m=-1..M)\n\t - add(diff(delta[z-x,k-1,z-y,l],delta[x-z,m])\n        *delta[x-z,m+1],m=-1..M)\n    end do\n  end do:\n\n  for k from 0 to M do\n    for l from 0 to M do\n      delta[z-x,k,x-y,l]:=(-1)^k*delta[x-y,l]*delta[x-z,k]\n    end do\n  end do:\n\n  for k from 0 to M do\n    delta[y-z,k,y-x,0]:=delta[x-y,0]*delta[x-z,k]\n  end do:\n\n  for l from 1 to M do\n    for k from 0 to M do\n      delta[y-z,k,y-x,l]:=-add(diff(delta[y-z,k,y-x,l-1],delta[x-y,m])\n        *delta[x-y,m+1],m=-1..M)\n\t-add(diff(delta[y-z,k,y-x,l-1],delta[x-z,m])\n\t*delta[x-z,m+1],m=-1..M)\n    end do\n  end do:\n\n  for k from 0 to M do\n    delta[y-z,k,z-x,0]:=(-1)^k*delta[x-y,k]*delta[x-z,0]\n  end do:\n\n  for l from 1 to M do\n    for k from 0 to M do\n      delta[y-z,k,z-x,l]:=-add(diff(delta[y-z,k,z-x,l-1],delta[x-y,m])\n        *delta[x-y,m+1],m=-1..M)\n\t-add(diff(delta[y-z,k,z-x,l-1],delta[x-z,m])\n\t*delta[x-z,m+1],m=-1..M)\n    end do\n  end do:\n\n# The three-vector T1\nT1:=Array(1..N,1..N,1..N):\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        T1[i,j,k]:=\n\t  coeff(coeff(T0[i,j,k],delta[x-y,-1]),delta[x-z,-1])\n\t  *delta[x-y,-1]*delta[x-z,-1]\n\t  + coeff(coeff(T0[i,j,k],delta[y-x,-1]),delta[y-z,-1])\n\t  *delta[y-x,-1]*delta[y-z,-1]\n\t  + coeff(coeff(T0[i,j,k],delta[z-x,-1]),delta[z-y,-1])\n\t  *delta[z-x,-1]*delta[z-y,-1]\n\t  + add(coeff(coeff(T0[i,j,k],delta[z-y,-1]),delta[z-x,m])\n\t  *delta[z-y,-1,z-x,m],m=0..M)\n\t  + add(coeff(coeff(T0[i,j,k],delta[x-y,-1]),delta[x-z,m])\n\t  *delta[x-y,-1]*delta[x-z,m],m=0..M)\n\t  + add(coeff(coeff(T0[i,j,k],delta[y-x,-1]),delta[y-z,m])\n\t  *delta[y-x,-1,y-z,m],m=0..M)\n\t  + add(coeff(coeff(T0[i,j,k],delta[z-x,-1]),delta[z-y,m])\n\t  *delta[z-x,-1]*delta[z-y,m],m=0..M)\n\t  + add(coeff(coeff(T0[i,j,k],delta[x-z,-1]),delta[x-y,m])\n\t  *delta[x-z,-1,x-y,m],m=0..M)\n\t  + add(coeff(coeff(T0[i,j,k],delta[y-z,-1]),delta[y-x,m])\n\t  *delta[y-z,-1]*delta[y-x,m],m=0..M)\n\t  + add(add(coeff(coeff(T0[i,j,k],delta[x-y,l]),delta[x-z,m])\n\t  *delta[x-y,l]*delta[x-z,m],l=0..M),m=0..M)\n\t  + add(add(coeff(coeff(T0[i,j,k],delta[x-y,l]),delta[y-z,m])\n\t  *delta[x-y,l,y-z,m],l=0..M),m=0..M)\n\t  + add(add(coeff(coeff(T0[i,j,k],delta[z-x,l]),delta[z-y,m])\n\t  *delta[z-x,l,z-y,m],l=0..M),m=0..M)\n\t  + add(add(coeff(coeff(T0[i,j,k],delta[z-x,l]),delta[x-y,m])\n\t  *delta[z-x,l,x-y,m],l=0..M),m=0..M)\n\t  + add(add(coeff(coeff(T0[i,j,k],delta[y-z,l]),delta[y-x,m])\n\t  *delta[y-z,l,y-x,m],l=0..M),m=0..M)\n\t  + add(add(coeff(coeff(T0[i,j,k],delta[y-z,l]),delta[z-x,m])\n\t  *delta[y-z,l,z-x,m],l=0..M),m=0..M)\n      end do\n    end do\n  end do:\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        T1[i,j,k]:=coeff(coeff(T1[i,j,k],delta[x-y,-1]),delta[x-z,-1])\n\t*delta[x-y,-1]*delta[x-z,-1]\n\t+ coeff(coeff(T1[i,j,k],delta[y-x,-1]),delta[y-z,-1])\n\t*delta[y-x,-1]*delta[y-z,-1]\n\t+ coeff(coeff(T1[i,j,k],delta[z-x,-1]),delta[z-y,-1])\n\t*delta[z-x,-1]*delta[z-y,-1]\n\t+ add(coeff(coeff(T1[i,j,k],delta[z-y,-1]),delta[z-x,m])\n\t*delta[z-y,-1,z-x,m],m=0..M)\n\t+ add(coeff(coeff(T1[i,j,k],delta[x-y,-1]),delta[x-z,m])\n\t*delta[x-y,-1]*delta[x-z,m],m=0..M)\n\t+ add(coeff(coeff(T1[i,j,k],delta[y-x,-1]),delta[y-z,m])\n\t*delta[y-x,-1,y-z,m],m=0..M)\n\t+ add(coeff(coeff(T1[i,j,k],delta[z-x,-1]),delta[z-y,m])\n\t*delta[z-x,-1]*delta[z-y,m],m=0..M)\n\t+ add(coeff(coeff(T1[i,j,k],delta[x-z,-1]),delta[x-y,m])\n\t*delta[x-z,-1,x-y,m],m=0..M)\n\t+ add(coeff(coeff(T1[i,j,k],delta[y-z,-1]),delta[y-x,m])\n\t*delta[y-z,-1]*delta[y-x,m],m=0..M)\n\t+ add(add(coeff(coeff(T1[i,j,k],delta[x-y,l]),delta[x-z,m])\n\t*delta[x-y,l]*delta[x-z,m],l=0..M),m=0..M)\n\t+ add(add(coeff(coeff(T1[i,j,k],delta[x-y,l]),delta[y-z,m])\n\t*delta[x-y,l,y-z,m],l=0..M),m=0..M)\n\t+ add(add(coeff(coeff(T1[i,j,k],delta[z-x,l]),delta[z-y,m])\n\t*delta[z-x,l,z-y,m],l=0..M),m=0..M)\n\t+ add(add(coeff(coeff(T1[i,j,k],delta[z-x,l]),delta[x-y,m])\n\t*delta[z-x,l,x-y,m],l=0..M),m=0..M)\n\t+ add(add(coeff(coeff(T1[i,j,k],delta[y-z,l]),delta[y-x,m])\n\t*delta[y-z,l,y-x,m],l=0..M),m=0..M)\n\t+ add(add(coeff(coeff(T1[i,j,k],delta[y-z,l]),delta[z-x,m])\n\t*delta[y-z,l,z-x,m],l=0..M),m=0..M)\n      end do\n    end do\n  end do:\n\n# Here we calculate the step 2 of the algorithm\n\nprint(\"Step 2 of the algorithm\");\n\n# The three-vector T2\nT2:=Array(1..N,1..N,1..N):\n\n# Array for coefficients\ncfnl_xyxz:=Array(1..N,1..N,1..N,0..M,0..M):\ncfnl_zxzy:=Array(1..N,1..N,1..N,0..M,0..M):\ncfnl_yzyx:=Array(1..N,1..N,1..N,0..M,0..M):\ncfl_xyxz:=Array(1..N,1..N,1..N,0..M,0..M,0..M):\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        for r from 0 to M do\n\t  cfnl_xyxz[i,j,k,r,0]:=\n\t  coeff(coeff(T1[i,j,k],delta[x-y,-1]),delta[x-z,r])\n\tend do\n      end do\n    end do\n  end do:\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        for r from 0 to M do\n\t  for s from 1 to M do\n\t    cfnl_xyxz[i,j,k,r,s]:=\n\t    add(add(diff(cfnl_xyxz[i,j,k,r,s-1],u[l,z,t])\n\t    *u[l,z,t+1],t=0..M),l=1..N)\n\t  end do\n\tend do\n      end do\n    end do\n  end do:\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        for r from 0 to M do\n\t  cfnl_zxzy[i,j,k,r,0]:=\n\t  coeff(coeff(T1[i,j,k],delta[z-x,-1]),delta[z-y,r])\n        end do\n      end do\n    end do\n  end do:\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        for r from 0 to M do\n\t  for s from 1 to M do\n\t    cfnl_zxzy[i,j,k,r,s]:=\n\t    add(add(diff(cfnl_zxzy[i,j,k,r,s-1],u[l,y,t])\n\t    *u[l,y,t+1],t=0..M),l=1..N)\n\t  end do\n\tend do\n      end do\n    end do\n  end do:\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        for r from 0 to M do\n\t  cfnl_yzyx[i,j,k,r,0]:=\n\t  coeff(coeff(T1[i,j,k],delta[y-z,-1]),delta[y-x,r])\n\tend do\n      end do\n    end do\n  end do:\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        for r from 0 to M do\n\t  for s from 1 to M do\n\t    cfnl_yzyx[i,j,k,r,s]:=add(add(diff(cfnl_yzyx[i,j,k,r,s-1],u[l,x,t])\n\t    *u[l,x,t+1],t=0..M),l=1..N)\n\t  end do\n\tend do\n      end do\n    end do\n  end do:\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        for r from 0 to M do\n\t  for s from 0 to M do\n\t    cfl_xyxz[i,j,k,r,s,0]:=\n\t    coeff(coeff(T1[i,j,k],delta[x-y,r]),delta[x-z,s])\n\t  end do\n\tend do\n      end do\n    end do\n  end do:\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        for r from 0 to M do\n\t  for s from 0 to M do\n\t    for t from 1 to M do\n\t      cfl_xyxz[i,j,k,r,s,t]:=\n\t      add(add(diff(cfl_xyxz[i,j,k,r,s,t-1],u[l,y,p])\n\t      *u[l,y,p+1],p=0..M),l=1..N)\n\t    end do\n\t  end do\n\tend do\n      end do\n    end do\n  end do:\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        T2[i,j,k]:=coeff(coeff(T1[i,j,k],delta[x-y,-1]),delta[x-z,-1])\n\t*delta[x-y,-1]*delta[x-z,-1]\n\t+ coeff(coeff(T1[i,j,k],delta[y-x,-1]),delta[y-z,-1])\n\t*delta[y-x,-1]*delta[y-z,-1]\n\t+ coeff(coeff(T1[i,j,k],delta[z-x,-1]),delta[z-y,-1])\n\t*delta[z-x,-1]*delta[z-y,-1]\n\t+ delta[x-y,-1]*add(add(binomial(m,s)*subs(z=x,cfnl_xyxz[i,j,k,m,s])\n\t*delta[x-z,m-s],s=0..m),m=0..M)\n\t+ delta[z-x,-1]*add(add(binomial(m,s)*subs(y=z,cfnl_zxzy[i,j,k,m,s])\n\t*delta[z-y,m-s],s=0..m),m=0..M)\n\t+ delta[y-z,-1]*add(add(binomial(m,s)*subs(x=y,cfnl_yzyx[i,j,k,m,s])\n\t*delta[y-x,m-s],s=0..m),m=0..M)\n\t+ add(add(add(binomial(l,s)*subs(y=x,cfl_xyxz[i,j,k,l,m,s])\n\t*delta[x-y,l-s],s=0..l)*delta[x-z,m],l=0..M),m=0..M)\n      end do\n    end do\n  end do:\n\n# Here we calculate the step 3 of the algorithm\n\n# The three-vector T is set equal to the result\n# of the third step of the algorithm\n\nprint(\"Step 3 of the algorithm\");\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        for r from 0 to M do\n\t  for s from 0 to M do\n\t    cfl_xyxz[i,j,k,r,s,0]:=coeff(coeff(T2[i,j,k],delta[x-y,r]),\n\t    delta[x-z,s])\n\t  end do\n\tend do\n      end do\n    end do\n  end do:\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        for r from 0 to M do\n\t  for s from 0 to M do\n\t    for t from 1 to M do\n\t      cfl_xyxz[i,j,k,r,s,t]:=\n\t      add(add(diff(cfl_xyxz[i,j,k,r,s,t-1],u[l,z,p])\n\t      *u[l,z,p+1],p=0..M),l=1..N)\n\t    end do\n\t  end do\n\tend do\n      end do\n    end do\n  end do:\n\n  for i from 1 to N do\n    for j from 1 to N do\n      for k from 1 to N do\n        T[i,j,k]:=simplify(coeff(coeff(T2[i,j,k],delta[x-y,-1]),delta[x-z,-1])\n\t*delta[x-y,-1]*delta[x-z,-1]\n\t+ coeff(coeff(T2[i,j,k],delta[y-x,-1]),delta[y-z,-1])\n\t*delta[y-x,-1]*delta[y-z,-1]\n\t+ coeff(coeff(T2[i,j,k],delta[z-x,-1]),delta[z-y,-1])\n\t*delta[z-x,-1]*delta[z-y,-1]\n\t+ add(coeff(coeff(T2[i,j,k],delta[x-y,-1]),delta[x-z,m])\n\t*delta[x-y,-1]*delta[x-z,m],m=0..M)\n\t+ add(coeff(coeff(T2[i,j,k],delta[z-x,-1]),delta[z-y,m])\n\t*delta[z-x,-1]*delta[z-y,m],m=0..M)\n\t+ add(coeff(coeff(T2[i,j,k],delta[y-z,-1]),delta[y-x,m])\n\t*delta[y-z,-1]*delta[y-x,m],m=0..M)\n\t+ add(add(add(binomial(m,s)*subs(z=x,cfl_xyxz[i,j,k,l,m,s])\n\t*delta[x-z,m-s],s=0..m)*delta[x-y,l],m=0..M),l=0..M))\n      end do\n    end do\n  end do:\n\nend proc:\n", "meta": {"hexsha": "4f866975e5cab5522bc4f7ebe25a0f6204c5a8b3", "size": 14161, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "WDVV-Ham_op_and_symbolic_computations/jacobi.mpl", "max_stars_repo_name": "Jakub-Vasicek/WDVV-computations", "max_stars_repo_head_hexsha": "d9af78b6ae3446d5d1d3c0ac42a997565dd3eef0", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "WDVV-Ham_op_and_symbolic_computations/jacobi.mpl", "max_issues_repo_name": "Jakub-Vasicek/WDVV-computations", "max_issues_repo_head_hexsha": "d9af78b6ae3446d5d1d3c0ac42a997565dd3eef0", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "WDVV-Ham_op_and_symbolic_computations/jacobi.mpl", "max_forks_repo_name": "Jakub-Vasicek/WDVV-computations", "max_forks_repo_head_hexsha": "d9af78b6ae3446d5d1d3c0ac42a997565dd3eef0", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-21T08:19:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-21T08:19:35.000Z", "avg_line_length": 29.3188405797, "max_line_length": 78, "alphanum_fraction": 0.5524327378, "num_tokens": 5802, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7549149868676283, "lm_q2_score": 0.6039318337259584, "lm_q1q2_score": 0.4559171923261745}}
{"text": "input := FileTools:-Text:-ReadFile(\"AoC-2021-20-input.txt\"):\nwith(StringTools):\n\nsplit:=Split(Trim(input), \"\\n\"):\ncode := split[1]; length(code);\n\nbin2dec := proc(s)\n     if length(s) <> 9 then error \"length of %1 is not 9, it is %2\", s, length(s); end if;\n     local l := Explode(s);\n     add(ifelse(l[i]=\".\", 0, ifelse(l[i]=\"#\", 1, X))*2^(9-i), i=1..9);\nend proc:\n\nbin2dec(\"...#...#.\") = 34; code[34+1];\n\nimage := split[3..-1]: {Explode(Join(image,\"\"))[]};\n\niwidth := length(image[1]);\nilength := nops(image);\nipad := 2;\np := code[bin2dec(cat(code[1]$9))+1];\n\nimage := [ cat(p$(iwidth+2*ipad))$ipad,\n    seq(cat(p$ipad,image[i],p$ipad), i=1..iwidth),\n    cat(p$(iwidth+2*ipad))$ipad\n    ]:\n\n{map(length, image)[]};\n\nviewimage := proc(image)\n  for local line in image do\n     printf(cat(line,\"\\n\"));\n  end do;\nend proc:\n\nviewimage(image);\n# walk the image\nnimage := image:\n\nfor gen to 50 do\n    nwidth := length(nimage[1]);\n    nlength := nops(nimage);\n    nbuf := StringBuffer():\n    for i from 2 to nlength-1 do\n        for j from 2 to nwidth-1 do\n            nbhd := cat( seq(nimage[i+k][j-1..j+1], k=-1..1));\n            pxidx := bin2dec(nbhd);\n            nbuf:-append(code[pxidx+1]);\n        end do;\n    end do;\n    tmp :=  nbuf:-value();\n    nimage := [ seq(tmp[(i-1)*(nwidth-2)+1..i*(nwidth-2)], i=1..nlength-2) ];\n    nwidth := length(nimage[1]);\n    nlength := nops(nimage);\n    ipad := 2;\n    p := ifelse(gen mod 2 = 1, code[1], code[bin2dec(cat(code[1]$9))+1]);\n    nimage := [ cat(p$(nwidth+2*ipad))$ipad, seq(cat(p$ipad,nimage[i],p$ipad), i=1..nwidth), cat(p$(nwidth+2*ipad))$ipad ]:\nend do:\n\nviewimage(nimage);\n\nanswer2 := add(CountCharacterOccurrences(nimage[i], \"#\"), i=1..nops(nimage));\n\n\n", "meta": {"hexsha": "dedd3cdbf882b3b82972b44022dde5bc2c6773bf", "size": 1708, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "Day20/AoC20-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": "Day20/AoC20-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": "Day20/AoC20-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": 26.6875, "max_line_length": 123, "alphanum_fraction": 0.5644028103, "num_tokens": 616, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7401743735019595, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.4552722681052683}}
{"text": "#@ Not autoload\n\nwith(LinearAlgebra):\n\np := 2;\nchromatic_n_max := 4;  # NB degree(v[4]) = 30, degree(v[5]) = 62\nchromatic_s_max := 20;\n\nunprotect('v','m','t');\nunassign('v','m','t');\n\nv[0] := p;\nm[0] := 1;\nt[0] := 1;\n\nprotect('v','m','t');\n\n# On BP_* we use a lexicographic ordering with v[1] >> v[2] >> v[3] >> ... >> 1.\n# This seems to be the best order except that we really want to treat v[0]\n# as a variable with v[0] >> v[1], so any monomial multiplied by p comes\n# after all the bare monomials.  Then the terms p^t * monomial in any\n# given degree have order type omega, and the terms after any given term\n# span an invariant ideal.\n\nBP_vars   := plex(seq(v[i],i=1..chromatic_n_max));\n\n# On the other hand, it might be better to use some kind of order that treats\n# the powers v[n]^(p^m) in a special way.  This might import more information\n# from the chromatic spectral sequence into the ordering.  One option would be\n# like\n# .. v[1]^(p^2) >> v[2]^(p^2) >> .. >> v[1]^p >> v[2]^p >> .. v[1] >> v[2] >> ...\n\n\n# On BP_*BP we use a lexicographic ordering with\n# v[1] >> v[2] >> .... >> t[1] >> t[2] >> ... >> 1\n# This privileges the ideal J = (t[1],...,t[k]); note that BP_*BP/J is\n# the Hopf algebroid whose Ext calculates \\pi_*(T(k)).\n\n# Again, it might be better to use some kind of order that treats\n# the powers t[n]^(p^m) in a special way.  This might import more information\n# from the May spectral sequence into the ordering.\n\nBPBP_vars := plex(seq(v[i],i=1..chromatic_n_max),seq(t[i],i=1..chromatic_n_max));\n\n# The cobar complex involves variables t[n,s] corresponding to the copy of\n# t[n] in the s'th tensor factor.  We use the ordering with\n# v[1] >> v[2] >> ... >> t[1,1] >> t[2,1] >> ... >> t[1,2] >> t[2,2] >> ...\n# so the variables from each tensor factor dominate those from the next tensor\n# factor.  It is not clear whether this is the best choice.\nBP_cobar_vars :=\n plex(op(BPBP_vars),seq(seq(t[i,j],i=1..chromatic_n_max),j=1..chromatic_s_max));\n \nBP_cmp   := (a,b) -> TestOrder(a,b,BP_vars):\nBPBP_cmp := (a,b) -> TestOrder(a,b,BPBP_vars):\nBP_cobar_cmp := (a,b) -> TestOrder(a,b,BP_cobar_vars):\n\nBP_degree := (u) -> degree(subs(BP_degree_rule,u),e);\n\n# Basis for Z[v[i] : i >= n] in degree d\nBP_basis := proc(d::integer,n::posint := 1)\n option remember;\n local m,r,i;\n m := 2*p^n-2;\n r := floor(d/m);\n if d < 0 or modp(d,2*p-2) <> 0 then\n  return [];\n elif d = 0 then\n  return [1];\n elif r = 0 then\n  return [];\n else\n  map(op,[seq(v[n]^i *~ BP_basis(d-m*i,n+1),i=0..r)]);\n fi;\nend:\n\n# Basis for Z[m[i] : i >= n] in degree d\nHBP_basis := proc(d::integer,n::posint := 1)\n eval(subs(v = m,BP_basis(d,n)));\nend:\n\n# Basis for Z[t[i] : i >= n] in degree d\nT_basis := proc(d::integer,n::posint := 1)\n eval(subs(v = t,BP_basis(d,n)));\nend:\n\n# Basis for Z[v[i] : i >= n] in degree <= d\nBP_lower_basis := proc(d::integer,n::posint := 1)\n option remember;\n local m,r,i;\n m := 2*p^n-2;\n r := floor(d/m);\n if d < 0 or modp(d,2*p-2) <> 0 then\n  return [];\n elif r = 0 then\n  return [1];\n else\n  map(op,[seq(v[n]^i *~ BP_lower_basis(d-m*i,n+1),i=0..r)]);\n fi;\nend:\n\n# Basis for Z[m[i] : i >= n] in degree d\nHBP_lower_basis := proc(d::integer,n::posint := 1)\n eval(subs(v = m,BP_lower_basis(d,n)));\nend:\n\n# Basis for Z[t[i] : i >= n] in degree d\nT_lower_basis := proc(d::integer,n::posint := 1)\n eval(subs(v = t,BP_lower_basis(d,n)));\nend:\n\n# Basis for BP_*BP in degree d\nBPBP_basis := proc(d::integer)\n local B,m,u,v;\n B := NULL;\n for u in BP_lower_basis(d) do\n  m := d - BP_degree(u);\n  for v in T_basis(m) do\n   B := B,(u*v);\n  od;\n od;\n return [B];\nend:\n\n# Basis for the s-fold tensor power of Z[t_1,t_2,...] in degree d\n# The copy of t[i] in the j'th tensor factor is represented by t[i,j]\nT_power_basis := proc(s::nonnegint,d::integer)\n local B,m,R1,R2,u,v;\n if s = 0 then return `if`(d = 0,[1],[]); fi;\n\n R1 := {seq(t[n] = t[n,1],n=1..chromatic_n_max)};\n R2 := {seq(seq(t[n,i] = t[n,i+1],i=1..s-1),n=1..chromatic_n_max)};\n B := NULL;\n \n for u in subs(R1,T_lower_basis(d)) do\n  m := d - BP_degree(u);\n  for v in subs(R2,T_power_basis(s-1,m)) do\n   B := B,(u*v);\n  od;\n od;\n return [B];\nend:\n\n# Basis for the s-fold tensor power of the augmentation ideal in\n# Z[t_1,t_2,...] in degree d\nT_reduced_power_basis := proc(s::nonnegint,d::integer)\n local B,m,R1,R2,u,v;\n if s = 0 then return `if`(d = 0,[1],[]); fi;\n\n R1 := {seq(t[n] = t[n,1],n=1..chromatic_n_max)};\n R2 := {seq(seq(t[n,i] = t[n,i+1],i=1..s-1),n=1..chromatic_n_max)};\n B := NULL;\n \n for u in subs(R1,T_lower_basis(d)) do\n  if u <> 1 then \n   m := d - BP_degree(u);\n   for v in subs(R2,T_reduced_power_basis(s-1,m)) do\n    B := B,(u*v);\n   od;\n  fi;\n od;\n return [B];\nend:\n\nBP_cobar_basis := (s,d) ->\n [seq(seq(seq(a*b,a in BP_basis(i)),b in T_reduced_power_basis(s,d-i)),i=0..d)];\n\n# Hazewinkel generators in terms of log coefficients\nvm := proc(n::nonnegint)\n option remember;\n if n = 0 then\n  return p;\n else \n  return expand(p*m[n] - add(m[k]*vm(n-k)^(p^k),k=1..n-1));\n fi;\nend:\n\n# Log coefficients in terms of Hazewinkel generators\n# This is inefficient; should use Ravenel's formulae instead\nmv := proc(n::nonnegint)\n local err;\n option remember;\n\n if n = 0 then return 1; fi;\n \n err := vm(n) - v[n];\n err := expand(subs({seq(m[i] = mv(i),i=1..n-1)},err));\n \n return rhs(solve(err=0,{m[n]})[1]);\nend:\n\n# Right unit map on the log coefficients\neta_m := (k) -> add(m[i] * t[k-i]^(p^i),i=0..k);\n\n# Right unit map on the Hazewinkel generators\neta_v := proc(k::posint,s::nonnegint)\n option remember;\n local u,R;\n\n if nargs = 1 then\n  u := expand(subs({seq(m[i] = eta_m(i),i=1..k)},vm(k)));\n  u := expand(subs({seq(m[i] = mv(i),i=1..k)},u));\n  return u;\n else\n  if s = 0 then\n   return v[k];\n  elif s = 1 then\n   u := expand(subs({seq(m[i] = eta_m(i),i=1..k)},vm(k)));\n   u := expand(subs({seq(m[i] = mv(i),i=1..k)},u));\n   u := subs({seq(t[i] = t[i,1],i=1..chromatic_n_max)},u);\n   return u;\n  else\n   u := eta_v(k,s-1);\n   R := { seq(seq(t[i,j] = t[i,j+1],i=1..chromatic_n_max),j=1..s-1),\n          seq(v[i] = eta_v(i,1),i=1..chromatic_n_max) };\n   u := subs(R,u);\n   return u;\n  fi;\n fi;\nend:\n\n# Hopf algebroid coproduct on the generators t[n]\npsi_t := proc(n)\n local a,b;\n option remember;\n if n = 0 then return 1; fi;\n\n a := add(add(mv(i)*t[j,1]^(p^i)*t[n-i-j,2]^(p^(i+j)),j=0..n-i),i=0..n);\n b := add(mv(i)*psi_t(n-i)^(p^i),i=1..n);\n a := subs({t[0,1]=1,t[0,2]=1},a);\n b := subs({t[0,1]=1,t[0,2]=1},b);\n return expand(a - b);\nend:\n\nd_BP_cobar_rule := proc(s,i)\n local R0,R1,R2,R3;\n if i = 0 then\n  R0 := {seq(t[j]=t[j,1],j=1..chromatic_n_max)};\n  R1 := {seq(t[j]=t[j,2],j=1..chromatic_n_max)};\n  R2 := {seq(seq(t[j,k]=t[j,k+1],k=1..s),j=1..chromatic_n_max)};\n  return \n   {seq(v[j] = expand(subs(R0,eta_v(j))),j=1..chromatic_n_max),op(R1),op(R2)};\n else\n  R0 := {seq(t[j,1]=t[j,i],j=1..chromatic_n_max),\n         seq(t[j,2]=t[j,i+1],j=1..chromatic_n_max),\n\t seq(v[j] = eta_v(j,i-1),j=1..chromatic_n_max)};\n  R1 := {seq(seq(t[j,k]=t[j,k+1],k=i+1..s),j=1..chromatic_n_max)};\n  R2 := {seq(t[j,i] = subs(R0,psi_t(j)),j=1..chromatic_n_max)};\n  if i = 1 then\n   R3 := {seq(t[j] = expand(subs(R0,psi_t(j))),j=1..chromatic_n_max)};\n  else\n   R3 := {seq(t[j] = t[j,1],j=1..chromatic_n_max)};\n  fi;\n  return {op(R1),op(R2),op(R3)};\n fi;\nend:\n\nd_BP_cobar := (s) -> (u) ->\n expand(add((-1)^i * subs(d_BP_cobar_rule(s,i),u),i=0..s+1));\n\n\nd_BP_cobar_matrix := proc(s,d)\n local B1,B2,cf;\n B1 := BP_cobar_basis(s,d);\n B2 := BP_cobar_basis(s+1,d);\n cf := proc(u)\n  local sol;\n  sol := solve({coeffs(u - add(c[i]*B2[i],i=1..nops(B2)),indets(B2))});\n  subs(sol,[seq(c[i],i=1..nops(B2))]);\n end;\n Transpose(Matrix(map(cf,map(d_BP_cobar(s),B1))));\nend:\n\nBP_cobar_cycles := proc(s,d)\n local M;\n M := d_BP_cobar_matrix(s,d);\n map(u -> Transpose(Vector(BP_cobar_basis(s,d))) . u,NullSpace(M));\nend:\n\nmu_BP_cobar := (s1,s2) -> proc(a,b)\n local i,b0;\n b0 := b;\n for i from 0 to s1-1 do\n  b0 := expand(subs(d_BP_cobar_rule(s2+i,0),b0));\n od:\n return expand(a * b0);\nend:\n\nanalyse_BP := proc(p_,n_)\n global p,chromatic_n_max;\n\n if nargs > 0 then p := p_; fi;\n if nargs > 1 then chromatic_n_max := n_; fi;\n\n vm(chromatic_n_max);\n mv(chromatic_n_max);\n eta_v(chromatic_n_max);\n psi_t(chromatic_n_max);\n NULL;\nend:\n\nanalyse_BP_cobar := proc(s::nonnegint,d::integer)\n local i,R,R0,B1,B2,n1,n2,M,L0,P0,x,x1,L,P,Q,nx,LB2,y,HB,HE,T,U,L1,K,Ki;\n global BP_cobar_data;\n \n if d + s >= 2*(p^(chromatic_n_max + 1) - 1) then\n  error(\"chromatic_n_max is too small\");\n fi;\n\n if s > chromatic_s_max then\n  error(\"chromatic_s_max is too small\");\n fi;\n \n R := table():\n\n if s = 0 then\n  if d = 0 then\n   R[\"chain_basis\"]     := [1];\n   R[\"chain_rank\"]      := 1;\n   R[\"cycle_basis\"]     := [1];\n   R[\"cycle_rank\"]      := 1;\n   R[\"boundary_basis\"]  := [];\n   R[\"boundary_rank\"]   := 0;\n   R[\"pivot_data\"]      := [[1,infinity]];\n   R[\"non_cycle_basis\"] := [];\n   R[\"homology_basis\"]  := [1];\n   R[\"homology_exponents\"] := [infinity];\n  else\n   R[\"chain_basis\"]     := BP_cobar_basis(0,d);\n   R[\"chain_rank\"]      := nops(R[\"chain_basis\"]);\n   R[\"cycle_basis\"]     := [];\n   R[\"cycle_rank\"]      := 0;\n   R[\"boundary_basis\"]  := [];\n   R[\"boundary_rank\"]   := 0;\n   R[\"pivot_data\"]      := [];\n   R[\"non_cycle_basis\"] := R[\"chain_basis\"];\n   R[\"homology_basis\"]  := [];\n   R[\"homology_exponents\"] := [];\n  fi;\n\n  BP_cobar_data[s,d] := eval(R);\n  return eval(R);\n fi;\n\n if type(BP_cobar_data[s-1,d+1],table) then\n  R0 := BP_cobar_data[s-1,d+1];\n  B1 := R0[\"non_cycle_basis\"];\n else\n  B1 := BP_cobar_basis(s-1,s+d):\n fi;\n\n B2 := BP_cobar_basis(s,s+d):\n n1 := nops(B1);\n n2 := nops(B2);\n R[\"chain_basis\"] := B2;\n R[\"chain_rank\"]  := n2;\n\n if n2 = 0 then\n  R[\"cycle_basis\"]     := [];\n  R[\"cycle_rank\"]      := 0;\n  R[\"boundary_basis\"]  := [];\n  R[\"boundary_rank\"]   := 0;\n  R[\"pivot_data\"]      := [];\n  R[\"non_cycle_basis\"] := [];\n  R[\"homology_basis\"]  := [];\n  R[\"homology_exponents\"] := [];\n  BP_cobar_data[s,d] := eval(R);\n  return eval(R);\n fi;\n \n M := Transpose(Matrix(map(coeff_list,map(d_BP_cobar(s-1),B1),B2)));\n L0,P0,x := op(Zpl_reduce(Transpose(M),p)):\n L := Transpose(L0):\n P := Transpose(P0):\n nx := nops(x):\n R[\"cycle_rank\"] := nx;\n \n LB2 := convert(L0.Vector(B2),list):\n R[\"boundary_basis\"] := [seq(LB2[i],i=1..nx)];\n R[\"cycle_basis\"]    := [seq(LB2[i]/p^x[i][2],i=1..nx)];\n R[\"pivot_data\"]     := x;\n\n y := sort([op({seq(i,i=1..n2)} minus {seq(x[i][1],i=1..nx)})]);\n R[\"non_cycle_basis\"] := [seq(B2[i],i in y)];\n \n HB := [];\n HE := [];\n \n for i from 1 to nx do\n  if x[i][2] > 0 then\n   HB := [op(HB),R[\"cycle_basis\"][i]];\n   HE := [op(HE),p^x[i][2]];\n  fi;\n od;\n\n R[\"homology_basis\"] := HB;\n R[\"homology_exponents\"] := HE;\n  \n T := <IdentityMatrix(nx)|Matrix(nx,n1-nx)>;\n U := Matrix(nx,n2):\n for i from 1 to nx do U[i,x[i][1]] := 1; od:\n L1 := U.L.Transpose(T);\n Q := P.Transpose(T).(1/L1).U;\n K := <SubMatrix(L,1..n2,1..nx)|Matrix(n2,n2-nx)>;\n y := sort([op({seq(i,i=1..n2)} minus {seq(x[i][1],i=1..nx)})]);\n for i from 1 to n2 - nx do \n  K[y[i],nx+i] := 1;\n od:\n Ki := 1/K;\n\n BP_cobar_data[s,d] := eval(R);\n return eval(R);\nend:\n\nBP_set_p := proc(p_)\n global p,v,BP_degree_rule,BP_basis,BP_lower_basis,vm,mv,eta_v,psi_t;\n\n p := p_;\n unprotect('v');\n v[0] := p;\n protect('v');\n \n BP_degree_rule := {\n  seq(v[n] = e^(2*(p^n-1)) * v[n],n=1..chromatic_n_max),\n  seq(t[n] = e^(2*(p^n-1)) * t[n],n=1..chromatic_n_max),\n  seq(seq(t[n,i] = e^(2*(p^n-1)) * t[n,i],n=1..chromatic_n_max),i=1..chromatic_s_max)\n }:\n\n forget(BP_basis);\n forget(BP_lower_basis);\n forget(vm);\n forget(mv);\n forget(eta_v);\n forget(psi_t);\n NULL;\nend:\n\nsave_BP_data := proc()\n local file;\n file := sprintf(\"%s/BP_%d.m\",data_dir,p);\n save(p,chromatic_n_max,chromatic_s_max,vm,mv,eta_v,psi_t,BP_basis,BP_lower_basis,file);\nend:\n\nload_BP_data := proc(p)\n local file;\n file := sprintf(\"%s/BP_%d.m\",data_dir,p);\n load(file);\nend:\n\nsave_BP_cobar_data := proc()\n local file;\n file := sprintf(\"%s/BP_cobar_data_%d.m\",data_dir,p);\n save(BP_cobar_data,file);\nend:\n\nload_BP_cobar_data := proc(p)\n local file;\n file := sprintf(\"%s/BP_cobar_data_%d.m\",data_dir,p);\n load(file);\nend:\n\n", "meta": {"hexsha": "847418314da728ea51dc9988912c306ff1f00de2", "size": 11991, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/chromatic/BP.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/chromatic/BP.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/chromatic/BP.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.010845987, "max_line_length": 88, "alphanum_fraction": 0.5894420816, "num_tokens": 4448, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7577943712746406, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.4548193603519451}}
{"text": "\n# Vierachsroboter KUKA KR700PA implizit\n# Initialisierung\n# Import (Library)\ninterface(warnlevel=0): \t\t# Unterdrücke die folgende Warnung.\nrestart: \t\t\t\t# Gibt eine Warnung, wenn über Terminal-Maple mit read gestartet wird.\ninterface(warnlevel=3):\nkin_constraints_exist := true:\t\t# Für Speicherung\n;\nwith(StringTools): \t\t\t# Für Zeitausgabe\nwith(LinearAlgebra):\nwith(codegen):\nwith(CodeGeneration):\ncodegen_act := true:\ncodegen_opt := 1: \t\t\t# Geringerer Optimierungsgrad. Sonst zu lange.\ncodegen_debug := 0:\t\t        # Zur Code-Generierung auch für Nicht-Inert-Ausdrücke\n;\n# Import (Hybriddyn)\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\":\t\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\":\t\t\t#aktuelle Roboter, MDH-Tabelle\n;\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\", robot_name_OL):\t\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# VGK Gelb 1-6-11-9-7-2-1\n# Schleife (1-6)-(6-11)\nT_1_11 := combine( Matrix(Trf(1..4,1..4, 6)) . Matrix(Trf(1..4,1..4,11))):\n# Schleife (1-2)(2-7)(7-9)\nT_1_9 := combine(Matrix(Trf(1..4,1..4, 2)) . Matrix(Trf(1..4,1..4,7)) . Matrix(Trf(1..4, 1..4, 9))):\nh1t := T_1_11(1..3,4) - T_1_9(1..3,4);\ntmp := Transpose( Matrix(T_1_11(1..3,1..3)) ) . Matrix(T_1_9(1..3,1..3)): #nur anzeigen lassen für h1r\n;\ncombine(tmp);# nur anzeigen lassen für h1r\n;\nh1r := -(-qJ6(t)+qJ2(t)+qJ7(t)+phi79+qJ9(t)) + Pi;\n# VGK GRÜN 2-3-4-10-12-8-7-2\n# Schleife (2-3)-(3-4)-(4-10)\nT_2_10 := combine( Matrix(Trf(1..4,1..4, 3)) . Matrix(Trf(1..4,1..4,4)) . Matrix(Trf(1..4,1..4,10))):\n# Schleife (2-7)-(7-8)-(8-12)\nT_2_12:= combine( Matrix(Trf(1..4,1..4, 7)) . Matrix(Trf(1..4,1..4,8)).Matrix(Trf(1..4,1..4,12)) ):\nh2t := T_2_10(1..3,4) - T_2_12(1..3,4);\ntmp := Transpose( Matrix(T_2_10(1..3,1..3)) )  .  Matrix(T_2_12(1..3,1..3)):  #nur anzeigen lassen für h2r\n;\ncombine(tmp);  #nur anzeigen lassen für h2r\n;\nh2r := (qJ3(t)+qJ4(t)+phi410+qJ10(t)-qJ7(t)+phi78-qJ8(t))+Pi;\n# Zusammenstellen aller Zwangsbedingungen\nimplconstr_t := <h1t([1, 3],1);h2t([1, 2],1); h1r; h2r>; # TODO: In h1r, h2r 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": "9265723b1e11b626c367dc828dd96b3641ceb00f", "size": 3599, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "systems/palh3m2/codegen/palh3m2IC_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/palh3m2/codegen/palh3m2IC_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/palh3m2/codegen/palh3m2IC_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": 46.141025641, "max_line_length": 144, "alphanum_fraction": 0.7232564601, "num_tokens": 1286, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619350028204, "lm_q2_score": 0.5506073655352404, "lm_q1q2_score": 0.4539548140159895}}
{"text": "# # Comuting BGG operator and characteristic homomorphism\n# # by Shizuo Kaji\n# # version: 2007/12/10 12:30\n# # See the included demo maple worksheet for usage\n# # LIMITATION: due to computational complexity,\n# #       for type-E this script deal with modulo\n# #         maximal parabolic P2 by default\n\n# require coxeter and weyl package by J.Stembridge\n# http://www.math.lsa.umich.edu/~jrs/maple.html\n\n# Data files\n# E8data.m: load reduced words of E8 up to length 15, into a variable \"redu\"\n# E8data-P2.m: load reduced words of E8/P2, into a variable \"redu\"\n# E8gen.mpl: load definition for ring generators of E8/T\n\n# global variables:\n# R: Lie type\n# B: simple roots\n# redu[deg]: reduced words\n# reduw: flattened list of reduced words\n# w[i]: i-th weight\n# a[i]: i-th root\n# s[[]]: weyl group element\n# X[weyl]: Schubert class corresponding to weyl\n# S[weyl]: Schubert polynomial corresponding to weyl\n# gam[deg],x[deg]: special generator\n# rho[deg]: relation\n\nwith(coxeter); with(weyl);\nwith(WeylOps):\n\n# convert poly of weights into that of e\nw2e := proc (wpol::polynom) global R,B;\n    return eval(wpol, [seq(w[j]=weights(R)[j], j=1..nops(B))]);\nend proc;\n\n# convert poly of special generators to that of weights \"w[1..r]\"\ngen2w := proc (f::polynom) global R,B;\n    return eval(f, [seq(G[i] = gam[i], i = [3,4,5,6,9,10,15]),\n\t\tseq(c[i] = c(i), i = 1 .. nops(B)),\n\t\tseq(T[i] = t[i], i = 0 .. 8)]);\nend proc;\n\n# listup monomials of degree \"deg\" consisting of \"gens\", whose degrees are specified by \"degs\"\nlist_monom := proc (gens::list, degs::list, deg::integer) local i, L;\n L := {};\n for i to nops(gens) do\n   if 0 < deg-degs[i] then\n     L := `union`(L, map2(`*`, gens[i], list_monom(gens, degs, deg-degs[i])))\n   elif deg-degs[i] = 0 then\n     L := `union`(L, {gens[i]});\n   end if;\n end do;\n return L;\nend proc:\n\n# BGG operator for w-poly wrt any root\nBGG_root := proc (vec::linear, f::polynom) global R;\n    return -simplify((f - subs([seq(w[i]=e2w(reflect(vec, weights(R)[i])),i=1..rank(R))], f))\n\t      / e2w(vec));\nend proc;\n\n# BGG for w-poly by recursive computation using Leibniz-rule\nBGG_w := proc (rt::integer, f::polynom) local i, j, term;\n\tif degree(f) < 1 then return 0\n    elif type(f, monomial) then\n\t\treturn -sum(ref_weight(rt)^i*w[rt]^(-i-1)*f, i=0..degree(f, w[rt])-1);\n    elif op(0, f) = `+` then\n\t\treturn expand(map2(procname, rt, f));\n    elif op(0, f) = `*` then\n\t\tif type(op(1,f), 'rational') then\n\t\t\treturn op(1,f)*procname(rt, f/op(1,f));\n\t\tend if;\n\t\tj := 1;\n\t\tfor i to nops(f) do\n\t\t    if degree(op(i, f)) <= degree(op(j, f)) and length(op(i, f)) < length(op(j, f)) then\n\t\t\tj := i\n\t\t    end if\n\t\tend do;\n\t\tterm[1] := op(j, f);\n\t\tterm[2] := mul(op(i, f), i = 1 .. j-1)*mul(op(i, f), i = j+1 .. nops(f));\n\t\treturn procname(rt, term[1])*term[2]+ref_rt(rt, term[1])*procname(rt, term[2]);\n    elif op(0, f) = `^` then\n\t    term[1] := op(1, f);\n\t    return procname(rt, term[1])*add(term[1]^(i-1)*ref_rt(rt, term[1])^(op(2,f)-i),i=1..op(2,f));\n    else\n        print(\"cannot compute BGG:\",f);\n        return infinity;\n    end if\nend proc;\n\n# BGG operator for e-poly\nBGG_e := proc (rt::integer, f::polynom) global R;\n    return -simplify((f - subs([seq(e(i)=reflect(B[rt], e(i)),i=1..dimr(R))], f))\n\t      / B[rt]);\nend proc;\n\n# a simple reflection on fundamental weight\nref_weight := proc (rt::integer) option remember; global R,B;\n\treturn w[rt]-e2w(B[rt]);\nend proc;\n\n# simple reflection on Schubert cycle\nref_weyl := proc(rt::integer,weyl::list) local a,j,v,u,w,temp; global B; option remember;\n\ttemp := X[weyl];\n\tw := weyl.[rt];\n    if nops(w) > nops(weyl) then\n\t\treturn X[weyl];\n\tend if;\n\tfor a in pos_roots(B) do\n       \t v := reflect(a,interior_pt(B));\n     \t v := reflect(seq(B[j],j=w),v);\n\t  \t  vec2fc(v,R,'u');    # u = w.s_a\n\t\t  if nops(u)=nops(weyl) then\n\t\t\t   temp := temp - iprod(2/iprod(a,a)*a,B[rt])*X[u];\n          end if;\n     end do;\n     return temp;\nend proc:\n\n# simple reflection on polynomial\nref_rt := proc (rt::integer, f::polynom) local ff;\n    if type(f, 'rational') then\n        return f;\n    else\n        ff:=subs(w[rt]=ref_weight(rt), f);\n        if has(f,'X') then\n            if type(ff, 'indexed') and op(0,ff)='X' then return ref_weyl(rt,op(1,ff));\n            elif op(0,ff) =`+` or op(0,ff)=`*` then return map2(procname, rt, ff);\n            elif op(0,ff) =`^` then return procname(rt,op(1,ff))^op(2,ff);\n            end if;\n        end if;\n        return ff;\n    end if;\nend proc;\n\n# weyl group action on polynomial\nref := proc(weyl, f::polynom);\n    return WeylFunc(weyl,f,ref_rt);\nend proc:\n\n# Schubert basis expansion\nChar := proc (f::polynom, func::procedure, roots::set, R) local weyl;\n    return add( WeylFunc(weyl, f, func)*X[weyl],\n\t       weyl=PReducedWd(R, roots, degree(f))[degree(f)]);\nend proc;\n\n# Schubert basis expansion for poly in special generators\nChar_w := proc (f::polynom) local temp, deg; global redu; global R;\n\ttemp:=collect(gen2w(f), {seq(w[i], i=1..rank(R))});\n    if not type(temp, polynom) then\n        print('not polynomial', f); return -infinity;\n    end if;\n    deg := degree(temp);\n    if deg < 1 then return temp;\n\telif deg <> ldegree(temp) then\n\t\tprint(\"not homogeneous:\", temp); return -infinity;\n    elif deg>nops(redu) then return 0;\n    end if;\n\treturn add(WeylFunc(weyl, temp, BGG_w)*X[weyl], weyl=redu[deg]);\n# for multi thread\n#\treturn Threads:-Add( WeylFunc(weyl, temp)*X[weyl], weyl=redu[deg] );\nend proc;\n\n# Schubert basis expansion for poly in \"X[weyl]\"\nChar_X := proc(f::polynom) local weyl,deg; global redu;\n    deg := deg_X(f);\n    if deg < 1 then return f;\n    elif deg>nops(redu) then return 0;\n    end if;\n  return add(WeylFunc(weyl, f, BGG_X)*X[weyl], weyl=redu[deg]);\nend proc:\n\n# Schubert basis expansion for poly in \"e\"\nChar_e := proc(f::polynom) local weyl,deg; global redu;\n    deg := degree(f);\n    if deg <1 then return f;\n\telif deg <> ldegree(f) then\n\t\tprint(\"not homogeneous:\", f); return -infinity;\n    elif deg>nops(redu) then return 0;\n    end if;\n  return add(WeylFunc(weyl, f, BGG_e)*X[weyl], weyl=redu[degree(f)]);\nend proc:\n\n# BGG operator for poly in \"X[weyl]\"\nBGG_X := proc(rt::integer, f::polynom) local w,term;\n    if degree(f) < 1 then return 0 end if;\n    if type(f, 'indexed') and op(0,f)=`X` then\n\t\tw:=op(1,f).[rt];\n\t\tif nops(w)=0 then return 1;\n\t\t\telif nops(w) < nops(op(1,f)) then return(X[w]);\n\t\t\telse return 0;\n\t\tend if;\n    elif op(0, f) = `+` then\n\t\treturn expand(map2(procname, rt, f));\n    elif op(0, f) = `*` then\n\t\tif type(op(1,f), 'rational') then\n\t\t\treturn op(1,f)*procname(rt, f/op(1,f));\n\t\tend if;\n\t\tterm[1] := op(1, f);\n\t\tterm[2] := mul(op(i, f), i = 2 .. nops(f));\n\t\treturn expand(procname(rt, term[1])*term[2]\n\t\t\t+ref_rt(rt, term[1])*procname(rt, term[2]));\n    elif op(0, f) = `^` then\n\t    term[1] := op(1, f);\n\t    return expand(procname(rt, term[1])*add(term[1]^(i-1)*ref_rt(rt, term[1])^(op(2,f)-i),i=1..op(2,f)));\n    else\n\t    print(\"Error in BGG_X:\",f)\n    end if;\nend proc;\n\n\n# top (point) cohomology class\ntop := proc (roots::set := {}) local k, j, i, RP, temp, lie_type; global R,P,reduw;\n\tif not roots={} then\n       RP := relative_roots(R,roots);\n\t   return (-1)^(nops(RP))*mul(i,i=RP)/nops(reduw);\n    end if;\n    temp := 1;\n\tlie_type := name_of(R);\n    if lie_type = F4 then\n        return (-255887*gam[3]^4*gam[4]^3+178123*gam[4]^6)/173408256000;\n    elif lie_type = E7 then\n\t\ttemp := mul(t[i]-t[0], i = 1 .. 7);\n\t\tfor i to 6 do temp := temp*mul(t[i]-t[j], j = i+1 .. 7) end do;\n\t    for i to 5 do\n\t\t for j from i+1 to 6 do\n\t\t\ttemp := temp*mul(t[i]+t[j]+t[k]-t[0], k = j+1 .. 7);\n\t     end do;\n\t\tend do;\n\t\treturn temp;\n    elif lie_type = E8 then\n\t\ttemp := mul(t[i], i = 1 .. 8);\n\t\tfor i to 7 do temp := temp*mul(t[i]-t[j], j = i+1 .. 8) end do;\n\t\tfor i to 7 do temp := temp*mul(t[i]+t[j]-t[0], j = i+1 .. 8) end do;\n\t\tfor i to 6 do\n\t\t\tfor j from i+1 to 7 do\n\t\t\t\ttemp := temp*mul(t[i]+t[j]+t[k]-t[0], k = j+1 .. 8)\n\t\t\tend do;\n\t\tend do;\n\t\treturn temp;\n    elif lie_type = G2 then\n\t\treturn (-9*w[1]^6+6*w[1]^5*w[2])/12;\n    elif lie_type = cat('A',rank(R)) then\n\t     return mul(e(i)^(rank(R)-i+1), i = 1 .. rank(R));\n\telif lie_type = cat('B',rank(R)) then\n\t\t return (-1)^rank(R)*mul(e(i)^(2*i-1), i = 1 .. rank(R))/2^rank(R);\n    elif lie_type = cat('C',rank(R)) then\n\t\t return (-1)^rank(R)*mul(e(i)^(2*i-1), i = 1 .. rank(R));\n    else\n\t\treturn (-1)^(nops(P))*mul(i, i = P)/mul(i,i=degrees(R));\n    end if\nend proc;\n\n# enumerate Schubert polynomials by applying BGG to the top degree class\nschubertpolys := proc() global S, R, reduw; local w,func,top_class,top_weyl;\n  top_class := top();\n  top_weyl  := longest_elt(R);\n  S[[]] := 1;\n  if evalb(name_of(R) in {'G2','F4','E6','E7','E8'}) then\n  \t func:='BGG_w';\n  else\n\tfunc:='BGG_e';\n  end if;\n  for w in reduw do\n  \t   S[w] := WeylFunc(inv(w).top_weyl, top_class, func);\n  end do;\n  print(\"The top class is\", top_weyl, top_class);\nend proc:\n\n# polynomial representatives in given generators for Schubert classes in a given degree\nSchubert_Polynomials := proc (gens::list, deg::integer) local i,j,v,temp,M,L,A,V,degs;\n L:=[]; A:=[];\n degs := map(degree, map(gen2w, gens));\n M := convert(list_monom(gens, degs, deg), `list`);\n for i from 1 to nops(M) do\n  temp := Char_w(M[i]);\n  L:=[op(L), M[i] = temp];\n  v := vector(nops(redu[deg])+nops(M), 0);\n  v[nops(redu[deg])+i] := 1;\n  for j to nops(redu[deg]) do\n     v[j] := coeff(temp, X[redu[deg][j]]);\n  end do;\n  A := [op(A), convert(v, list)];\n end do;\n A := LinearAlgebra[HermiteForm](Matrix(A));\n# for printing\n V := [];\n for v in convert(A, `listlist`) do\n\tV := [op(V),\n\t    add(v[i]*X[redu[deg][i]], i=1..nops(redu[deg]))\n        = add(v[nops(redu[deg])+i]*M[i], i=1..nops(M))];\n  end do;\n  return V;\nend proc:\n\n\n\n## initialization for Lie types (using Toda-Watanabe basis for exceptional types)\nsetup := proc (lie_type, roots::set := {}, upto::integer := 0) local i,S;\n\t\tglobal R, P, B, x, u, z, t, udim, gam, rho, redu, reduw;\n  forget(ref_weight);\n  forget(ref_weyl);\n  unassign('gam','t','x','S','rho');\n\n# type G2\n  if lie_type = G2 then\n    R := lie_type;\n    t[1] := -w[1];\n    t[2] := -w[1]+w[2];\n    t[3] := 2*w[1]-w[2];\n    rho[2] := w[2]^2+3*w[1]^2-3*w[1]*w[2];\n    gam[3] := (1/2)*t[1]*t[2]*t[3];\n\tx[3] := 1/2*(w[1]*w[2]^2-w[1]^2*w[2]); # [2,1,2]\n# type F4\n  elif lie_type = F4 then\n    R := linalg[transpose](cartan_matrix(lie_type));\n    t[1] := -w[4];\n    t[2] := w[1]-w[4];\n    t[3] := -w[1]+w[2]-w[4];\n    t[4] := -w[2]+2*w[3]-w[4];\n    t[0] := w[3]-2*w[4];\n    gam[3] := (1/2)*c(3);\n    gam[4] := (1/3)*c(4)-(2/3)*t[0]*c(3)+(8/3)*t[0]^4;\n\trho[2] := c(2)-2*t[0]^2;\n\trho[6] := gam[3]^2-3*t[0]^2*gam[4]-4*t[0]^3*gam[3]+8*t[0]^6;\n\trho[8] := 3*gam[4]^2+6*t[0]*gam[3]*gam[4]-3*t[0]^4*gam[4]-13*t[0]^8;\n# type E6 / P2\n  elif lie_type = E6 then\n    R := linalg[transpose](cartan_matrix(lie_type));\n    t[1] := -w[1]+w[2];\n    t[2] := w[1]+w[2]-w[3];\n    t[3] := w[2]+w[3]-w[4];\n    t[4] := w[4]-w[5];\n    t[5] := w[5]-w[6];\n    t[6] := w[6]; t[0] := w[2];\n    gam[3] := c(3);\n    gam[4] := c(4)+2*t[0]^4;\n# type E7 / P2\n  elif lie_type = E7 then\n    R := linalg[transpose](cartan_matrix(lie_type));\n    t[1] := -w[1]+w[2];\n    t[2] := w[1]+w[2]-w[3];\n    t[3] := w[2]+w[3]-w[4];\n    t[4] := w[4]-w[5];\n    t[5] := w[5]-w[6];\n    t[6] := w[6]-w[7];\n    t[7] := w[7];\n    t[0] := w[2];\n    gam[3] := 1/2*c(3);\n    gam[4] := 1/3*(c(4)+2*t[0]^4);\n    gam[5] := 1/2*(c(5)-t[0]*c(4)+t[0]^2*c(3)-2*t[0]^5);\n    gam[9] := 1/2*(c(6)*c(3)+t[0]^2*c(7)-3*t[0]^3*c(6));\n# type E8 / P2\n  elif lie_type = E8 then\n    R := linalg[transpose](cartan_matrix(lie_type));\n\tread \"E8data-p2.m\";\n\tread \"E8gen.mpl\";\n  else\n    R := lie_type;\n  end if;\n\n  B := base(R);\n  P := pos_roots(lie_type);\n  udim := `if`(upto>0,upto,nops(P));\n  if not lie_type = E8 then\n      redu := PReducedWd(R, roots, udim);\n  end if;\n  reduw := [[],seq(op(i),i=redu)];\n  print(lie_type, \"mod the parabolic w.r.t\", roots);\n  return diagram(R);\nend proc;\n", "meta": {"hexsha": "d1b0d4ac91ac0bc8a1adaa8441ba8631522b3ce6", "size": 11896, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "BGG.mpl", "max_stars_repo_name": "shizuo-kaji/Maple-flag-cohomology", "max_stars_repo_head_hexsha": "c4e1669cfd228e182a44d291d6b0ffe0f670a8af", "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": "BGG.mpl", "max_issues_repo_name": "shizuo-kaji/Maple-flag-cohomology", "max_issues_repo_head_hexsha": "c4e1669cfd228e182a44d291d6b0ffe0f670a8af", "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": "BGG.mpl", "max_forks_repo_name": "shizuo-kaji/Maple-flag-cohomology", "max_forks_repo_head_hexsha": "c4e1669cfd228e182a44d291d6b0ffe0f670a8af", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.807486631, "max_line_length": 106, "alphanum_fraction": 0.5741425689, "num_tokens": 4568, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673087708699, "lm_q2_score": 0.5583269943353744, "lm_q1q2_score": 0.4538457612995245}}
{"text": "# Let E be the surjection operad, as explained by Berger and Fresse\n# following McClure.  We represent a basis element of E(A) by\n# expressions S(...), where the arguments are elements of A,\n# each element appears at least once, and no two adjacent elements\n# are the same.\n\n`is_element/surjections` := (A::set) -> proc(x)\n global reason;\n local i,y,z;\n\n if x = 0 then return true; fi;\n \n if type(x,`+`) then\n  return `and`(op(map(`is_element/surjections`(A),[op(x)])));\n fi;\n\n if type(x,`*`) then\n  y,z := selectremove(type,[op(x)],integer);\n  return (nops(z) = 1 and `is_element/surjections`(A)(z[1]));\n fi;\n \n if not type(x,specfunc(S)) then return false; fi;\n if {op(x)} <> A then return false; fi;\n\n for i from 1 to nops(x) - 1 do\n  if x[i] = x[i+1] then return false; fi;\n od;\n\n return true;\nend:\n\n`is_equal/surjections` := (A::set) -> (x0,x1) -> evalb(expand(x0 - x1) = 0);\n\n`is_equal_unsigned/surjections` := (A::set) -> (x0,x1) -> evalb(modp(expand(x0 - x1),2) = 0);\n\n`random_basis_element/surjections` := (A) -> proc(m_)\n local n,m,i,x,ok;\n\n n := nops(A);\n\n if n = 0 then return FAIL; fi;\n\n if n = 1 then \n  if nargs = 0 or m_ = 1 then\n   return S(op(A));\n  else\n   return FAIL;\n  fi;\n fi;\n \n if nargs > 0 then\n  m := m_;\n else \n  m := rand(0..5)();\n end:\n\n ok := false;\n while not(ok) do \n  x := [op(A),seq(random_element_of(A),i=1..m)];\n  x := combinat[randperm](x);\n  ok := true;\n  for i from 1 to n + m - 1 do\n   if x[i] = x[i+1] then\n    ok := false;\n    break;\n   fi;\n  od;\n od;\n x := S(op(x));\n return x;\nend:\n\n`random_element/surjections` := (A) -> proc(coeff_range_,num_terms_)\n local coeff_range,num_terms;\n\n coeff_range := -3..3;\n num_terms := 5;\n if nargs > 0 then coeff_range := args[1]; fi;\n if nargs > 1 then num_terms := args[2]; fi;\n \n add(rand(coeff_range)() * `random_basis_element/surjections`(A)(),i=1..num_terms);\nend:\n\n# Let u be a basis element of E(A), of length n say.  A gap means\n# a pair (i,i+1) with 1 <= i < i+1 <= n.  The gap is bound if\n# u[i] = u[j] for some j > i.  Here we represent a bound gap\n# (i,i+1) by its initial index i.  The following function\n# returns the ordered list of bound gaps.\n\n`bound_gaps/surjections` := (A) -> proc(u)\n local G,N,M,a;\n G := NULL;\n N := [seq(i,i=1..nops(u))];\n for a in A do \n  M := select(i -> op(i,u) = a,N);\n  G := G,op(1..-2,M);\n od:\n G := sort([G]);\n return(G);\nend:\n\n# Auxiliary function feeding into `diff/surjections`\n\n`diff0/surjections` := (A::set) -> proc(x)\n local i,j,m,y,z,s,ss,t,l,r;\n \n i := [op(x)];\n m := nops(i);\n \n y := 0;\n s := 1;\n ss := table();\n \n for j from 1 to m do\n  l := [op(1..j-1,i)];\n  r := [op(j+1..m,i)];\n  if member(i[j],r) then\n   t := s;\n   ss[i[j]] := t;\n   s := -s;\n  elif member(i[j],l) then\n   t := -ss[i[j]];\n   ss[i[j]] := t;\n  else\n   t := 0;\n  fi;\n  if 1 < j and j < m and op(j-1,i) = op(j + 1,i) then\n   t := 0;\n  fi;\n  y := y + t * S(op(1..j-1,i),op(j+1..m,i));\n od:\nend:\n\n# Differential on the surjection chain complex\n\n`diff/surjections` := (A::set) -> apply_linear(`diff0/surjections`(A));\n\n# Auxilary function feeding into `deg/surjections`\n`deg0/surjections` := (A) -> (u) -> nops(u) - nops(A);\n\n# Degree function for the surjection chain complex.\n`deg/surjections` := (A) -> apply_deg(`deg0/surjections`(A));\n\n`reflect/surjections` := (A) -> proc(u)\n local c,v;\n \n if type(u,`+`) then\n  return map(`reflect/surjections`(A),u);\n fi;\n\n c,v := op(coeff_split(u));\n\n if not(type(v,specfunc(S))) then return FAIL; fi;\n\n return (-1)^(nops(v) - nops(A)) * u;\nend:\n\n# This is the circle product for the operad structure.\n# It is assumed that B is a subset of A and u is in E(A/B) and v is in E(B),\n# where A/B is implemented as A \\ B u {B}.\n\n`o0/surjections` := (A,B) -> proc(u,v)\n local AB,nu,nv,Nu,Nv,M,l,m,JJ,w,J,k,p,i,j,s;\n\n AB := A minus B union {B};\n \n nu := nops(u);\n nv := nops(v);\n Nu := [seq(i,i=1..nu)];\n Nv := [seq(i,i=1..nv)];\n M := select(i -> op(i,u) = B,Nu);\n m := nops(M);\n JJ := combinat[choose]([seq(i,i=2..nv+m-1)],m-1);\n JJ := map(J -> [1,seq(J[i]-i,i=1..m-1),nv],JJ);\n\n w := 0;\n for J in JJ do \n  k := NULL;\n  l := NULL;\n  p := 1;\n  for i from 1 to nu do \n   if op(i,u) = B then\n    k := k,seq(op(j,v),j=J[p]..J[p+1]);\n    l := l,seq([i,j],j=J[p]..J[p+1]);\n    p := p+1;\n   else\n    k := k,op(i,u);\n    l := l,[i,0];\n   fi;\n  od;\n  l := [l];\n  s := NULL;\n  for i in `bound_gaps/surjections`(AB)(u) do\n   j := nops(l);\n   while j > 1 and l[j][1] <> i do j := j - 1; od;\n   s := s,j;\n  od;\n  for i in `bound_gaps/surjections`(B)(v) do\n   j := nops(l);\n   while j > 1 and l[j][2] <> i do j := j - 1; od;\n   s := s,j;  \n  od;\n  w := w + sgn([s]) * S(k);\n od:\n\n return w;\nend:\n\n`o/surjections` := (A,B) -> apply_bilinear(`o0/surjections`(A,B));\n\n`gamma0/surjections` := (A::set,B::set) -> (p) -> proc(y,x)\n local F,J,I0,J0,b,L,m,n,S0,s;\n\n F := fibres(A,B)(p);\n J := [seq(i,i=0..nops(y)-1)];\n I0 := table():\n J0 := table():\n for b in B do \n  I0[b] := [seq(i,i=0..nops(x[b])-1)];\n  J0[b] := select(j -> op(j+1,y) = b,J);\n od:\n L := [[]];\n\n for b in B do\n  m := nops(J0[b]) - 1;\n  n := nops(I0[b]) - 1;\n  S0 := map(`to_grid_path/shuffles`(m,n),`list_elements/shuffles`(m,n));\n  S0 := map(s -> [seq(s[i],i=0..n+m)],S0);\n  S0 := map(s -> map(ji -> [J0[b][ji[1]+1],ji[2]],s),S0);\n  L := [seq(seq([op(l),op(s)],s in S0),l in L)];\n od:\n L := map(sort,L);\n L := map(l -> S(op(map(ji -> op(ji[2]+1,x[op(ji[1]+1,y)]),l))),L);\n return `+`(op(L));\nend:\n\n`gamma/surjections` := eval(extend_gamma_linear(`gamma0/surjections`)):\n\n# We now have various functions related to an interesting filtration\n# of the surjections operad.\n\n`flip_count/surjections` := (A::set) -> proc(u,s_)\n local r,m,a,b,c,u0,i;\n if nargs > 1 then\n  r := `rank_table/ord`(A)(s_);\n else\n  r := NULL;\n fi;\n \n m := table():\n for a in A do\n  for b in A do\n   m[a,b] := 0;\n   u0 := select(p -> p = a or p = b,[op(u)]);\n   for i from 1 to nops(u0) - 1 do\n    if u0[i+1] <> u0[i] then m[a,b] := m[a,b] + 1; fi;\n   od;\n\n   if m[a,b] > 0 and r <> NULL then\n    c := `if`(r[a] < r[b],a,b);\n    if u0[-1] = c then m[a,b] := m[a,b] + 1; fi;\n   fi;\n  od;\n od;\n\n return eval(m);\nend:\n\n`flip_count_matrix/surjections` := (A::set) -> proc(u,s_)\n local m;\n m := `flip_count/surjections`(A)(args);\n return Matrix([seq([seq(m[a,b],b in A)],a in A)]);\nend:\n\n\n`max_flip_count/surjections` := (A::set) -> proc(u)\n local m,mm,a,b;\n \n m := `flip_count/surjections`(A)(u);\n\n mm := 0;\n for a in A do\n  for b in A do\n   mm := max(mm,m[a,b]);\n  od;\n od;\n\n return mm;\nend:\n\n`is_cell_member/surjections` := (A::set) -> (ms) -> proc(u)\n local m0,m1,s,r,i,j,a,b,c,u0,k,l,y,z;\n\n if x = 0 then return true; fi;\n if type(x,`+`) then\n  return `and`(seq(`is_cell_member/surjections`(A)(ms)(y),y in x));\n fi;\n if type(x,`*`) then\n  y,z := selectremove(type,[op(x)],integer);\n  if nops(z) = 1 then\n   return `is_cell_member/surjections`(A)(ms)(z[1]);\n  else\n   return false;\n  fi;\n fi;\n \n m0,s := op(ms);\n m1 := `flip_count/surjections`(A)(u,s);\n\n for a in A do\n  for b in A do\n   if m1[a,b] > m0[a,b] then return false; fi;\n  od;\n od;\n\n return true;\nend:\n\n`filtration0/surjections` := (A::set) -> proc(u)\n local m,m_max,s,rr,k,i,r0,r1,a,b;\n\n if type(u,integer) then return 0; fi;\n\n return 1 + `max_flip_count/surjections`(A)(u);\nend:\n\n`filtration/surjections` := (A::set) ->\n apply_max_deg(`filtration0/surjections`(A));\n\n`rho0/barratt_eccles/surjections` := (A::set) -> proc(x)\n local rr,d,R,r,y,z,z0,ok,i,m;\n\n rr := nops(A);\n d := nops(x) - 1;\n R := combinat[choose]([seq(i,i=1..d+rr-1)],d);\n R := map(r -> [0,op(r),d+rr],R);\n R := map(r -> [seq(r[i+1]-r[i],i=1..d+1)],R);\n y := 0;\n for r in R do \n  z := NULL;\n  z0 := NULL;\n  ok := true;\n  for i from 1 to d+1 do\n   m := select(j -> not(member(j,[z0])),op(i,x));\n   if nops(m) >= r[i] and ([z] = [] or [z][-1] <> m[1]) then\n    z := z,op(1..r[i],m);\n    z0 := z0,op(1..r[i]-1,m);\n   else \n    ok := false;\n    break;\n   fi;\n  od;\n  if ok then y := y + S(z); fi;\n od;\n return y;\nend:\n\n`rho/barratt_eccles/surjections` := (A::set) -> \n apply_linear(`rho0/barratt_eccles/surjections`(A));\n\n# We now define a map from the surjections operad to the\n# Barratt-Eccles operad.  This is not an operad morphism,\n# but it is a section of the map in the opposite direction.\n\n`sigma0/surjections/barratt_eccles` := (A::set) -> proc(x)\n local i,j,k,l,r,t,p,m,d,w,ww;\n \n i := [op(x)];\n m := nops(i);\n d := m - nops(A);\n\n ww := NULL;\n\n for k from 0 to d do \n  w := NULL;\n\n  p := 0;\n  \n  for j from 1 to m do\n   l := [op(1..j-1,i)];\n   r := [op(j+1..m,i)];\n   if member(i[j],r) then\n    t := false;\n    p := p + 1;\n   else\n    t := true;\n   fi;\n\n   if not(member(i[j],[w])) then\n    if t or (p > k) then\n     w := w,i[j];\n    fi;\n   fi;\n  od:\n  w := [w];\n  ww := ww,w;\n od;\n \n return T(ww);\nend:\n\n`sigma/surjections/barratt_eccles` := (A::set) -> \n apply_linear(`sigma0/surjections/barratt_eccles`(A));\n\n# The cut operation construction gives a morphism from the surjection\n# operad to the Eilenberg-Zilber operad.  Unfortunately the EZ operad\n# cannot be represented properly in our framework because each set\n# EZ(A) is an infinite product over the natural numbers.  To deal with\n# this we insert natural number indices in various places.\n\n`cut_operation0/surjections` := (n::nonnegint) -> (A::set) -> proc(x)\n local A0,m,d,N,J,p,q,r,j,c,t,a,is_degen;\n\n A0 := sort([op(A)]);\n m := nops(A);\n d := nops(x) - m;\n N := [seq(i,i=0..n)];\n J := [[0]];\n for p from 1 to m + d - 1 do \n  J := [seq(seq([op(j),q],q=j[-1]..n),j in J)];\n od:\n J := map(j -> [op(j),n],J);\n\n c := 0;\n\n for j in J do \n  t := table():\n  for a in A0 do t[a] := []: od:\n  for p from 1 to m+d do \n   a := op(p,x);\n   t[a] := [op(t[a]),seq(r,r=j[p]..j[p+1])];\n  od:\n\n  is_degen := false;\n\n  for a in A0 do \n   if nops(t[a]) > nops({op(t[a])}) then \n    is_degen := true;\n    break;\n   fi;\n  od:\n\n  if not(is_degen) then \n   c := c + `detranspose/eilenberg_zilber`(A)(t);\n  fi;\n od:\n\n return c;\nend:\n\n`cut_operation1/surjections` := (n::nonnegint) -> (A::set) -> proc(x)\n add(`cut_operation0/surjections`(k)(A)(x),k=0..n);\nend:\n\n`cut_operation/surjections` := (n::nonnegint) -> (A::set) ->\n apply_linear(`cut_operation1/surjections`(n)(A));\n\n`multiplicity_table/surjections` := (A::set) -> proc(x)\n local t,a;\n\n t := table():\n for a in A do t[a] := 0; od:\n for a in [op(x)] do \n  t[a] := t[a] + 1;\n od:\n return eval(t);\nend:\n`max_multiplicity/surjections` := (A::set) -> proc(x)\n local t,m,a;\n t := `multiplicity_table/surjections`(A)(x);\n m := 0;\n for a in A do m := max(m,t[a]); od;\n return m;\nend:\n`is_biased/surjections` := (A::set) -> proc(x,a0_)\n local a,a0,t;\n\n a0 := NULL;\n if nargs > 1 then a0 := a0_; fi;\n\n t := `multiplicity_table/surjections`(A)(x);\n\n for a in A do \n  if t[a] > 1 then \n   if a0 = NULL then\n    a0 := a;\n   else\n    if a0 <> a then \n     return false;\n    fi;\n   fi;\n  fi;\n od:\n\n return true;\nend:\n`is_strongly_biased/surjections` := (A::set) -> proc(x,a0_)\n local a,a0,t;\n\n a0 := NULL;\n if nargs > 1 then a0 := a0_; fi;\n\n t := `multiplicity_table/surjections`(A)(x);\n\n for a in A do \n  if t[a] > 1 then \n   if a0 = NULL then\n    a0 := a;\n   else\n    if a0 <> a then \n     return false;\n    fi;\n   fi;\n  fi;\n od:\n \n if a0 = NULL or t[a0] <= 1 then return false; fi;\n\n return true;\nend:\n\n", "meta": {"hexsha": "049a9515389e77530e93aa224ffe94e57615ebc0", "size": 11177, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/operads/surjections.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/surjections.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/surjections.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": 21.4118773946, "max_line_length": 93, "alphanum_fraction": 0.5562315469, "num_tokens": 4203, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461390043208003, "lm_q2_score": 0.6076631698328917, "lm_q1q2_score": 0.45340119250153516}}