{"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": "(*\n Copyright (C) 2017 M.A.L. Marques\n\n This Source Code Form is subject to the terms of the Mozilla Public\n License, v. 2.0. If a copy of the MPL was not distributed with this\n file, You can obtain one at http://mozilla.org/MPL/2.0/.\n*)\n\n(* type: gga_exc *)\n(* prefix:\n  gga_k_mpbe_params *params;\n\n  assert(p->params != NULL);\n  params = (gga_k_mpbe_params * )(p->params);\n*)\n\n$include \"gga_x_mpbe.mpl\"\n\nf := (rs, z, xt, xs0, xs1) -> gga_kinetic(mpbe_f, rs, z, xs0, xs1):\n", "meta": {"hexsha": "af525ba1cd4828a8911f7c479f860e47091b529f", "size": 474, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "libxc-5.1.6/maple/gga_exc/gga_k_mpbe.mpl", "max_stars_repo_name": "pwang234/lsms", "max_stars_repo_head_hexsha": "6044153b6138512093e457bdc0c15c699c831778", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2018-04-03T15:35:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T03:19:23.000Z", "max_issues_repo_path": "libxc-5.1.6/maple/gga_exc/gga_k_mpbe.mpl", "max_issues_repo_name": "pwang234/lsms", "max_issues_repo_head_hexsha": "6044153b6138512093e457bdc0c15c699c831778", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2019-07-30T13:59:18.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T17:43:35.000Z", "max_forks_repo_path": "libxc-5.1.6/maple/gga_exc/gga_k_mpbe.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.7, "max_line_length": 68, "alphanum_fraction": 0.6624472574, "num_tokens": 160, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.7956581000631542, "lm_q2_score": 0.6261241772283034, "lm_q1q2_score": 0.4981807732570775}}
{"text": "# \u4ea4\u4e92\u5f0f\u6c42\u89e3\u51fd\u6570\n\n$ifndef _INTERACTION_\n$define _INTERACTION_\n\n# \u6dfb\u52a0\u65b0\u7684RepSol\u8fdb\u884c\u6c42\u89e3\nresolveRep:=proc(rep,solInd,{newIsol:=[],newRep:=[],nocheck::boolean:=false})\n    return resolveSol(rep:-osol[solInd],_options);\nend proc:\n\n# \u6dfb\u52a0\u65b0\u7684InvSol\u8fdb\u884c\u6c42\u89e3\nresolveSol:=proc(sol::InvSol,{newIsol:=[],newRep:=[],nocheck::boolean:=false})\n    local s,nreps;\n    if (newIsol=[]) and (newRep=[]) then\n        error \"\u81f3\u5c11\u8bbe\u7f6enewIsol\u548cnewRep\u4e4b\u4e00\u7684\u503c\";\n    end if;\n    s:=Object(sol);\n    if (newIsol<>[]) then\n        setIsol(s,newIsol,_options['nocheck']);\n    end if;\n    if (newRep<>[]) then\n        setRep(s,newRep,_options['nocheck']);\n    end if;\n    resolve(s);\n    nreps:=addReps(getNewSols());\n    printf(\"\u65b0\u4ea7\u751f\u4ee3\u8868\u5143:\");\n    printReps(nreps);\n    return nreps;\nend proc:\n\n# \u83b7\u53d6\u65b0\u7684\u4ee3\u8868\u5143\nfetchNewRep:=proc(rep,solInd,con)\n    return fetchSolRep(rep:-osol[solInd],addcon=con);\nend proc:\n\n# \u68c0\u67e5\u4e24\u4e2a\u4ee3\u8868\u5143\u4e4b\u95f4\u80fd\u5426\u76f8\u4e92\u8f6c\u5316\ncanTransform:=proc(r1,i1,r2,i2)\n    local s1,s2,eqs;\n    s1:=r1:-osol[i1];\n    s2:=r2:-osol[i2];\n    eqs:=table();\n    eqs[1]:=testTransform(s1,s2,s1);\n    if (eqs[1]=true) then\n        return true;\n    end if;\n    eqs[2]:=testTransform(s1,s2,s2);\n    if (eqs[2]=true) then\n        return true;\n    end if;\n    eqs[3]:=testTransform(s2,s1,s1);\n    if (eqs[3]=true) then\n        return true;\n    end if;\n    eqs[4]:=testTransform(s2,s1,s2);\n    if (eqs[4]=true) then\n        return true;\n    end if;\n    printf(\"\u65e0\u6cd5\u6c42\u89e3\u53d8\u6362\u65b9\u7a0b\");\n    print~([entries(eqs,nolist)]);\n    return false;\nend proc:\n\n# \u68c0\u67e5\u4e24\u4e2a\u89e3\u4e4b\u95f4\u80fd\u5426\u76f8\u4e92\u8f6c\u5316\n# TODO\u3000\u8fd9\u91cc\u6ca1\u6709\u8003\u8651\u8f6c\u5316\u662f\u5426\u6709\u6210\u7acb\u7684\u6761\u4ef6\ntestTransform:=proc(s1,s2,base)\n    local eq,sol,con;\n    eq,sol,con:=solveTeq(s1:-rvec,s2:-rvec,base);\n    if (sol<>[]) then\n        print(s2:-rep);\n        printf(\"\u53ef\u4ee5\u5728\");\n        print(base:-isol);\n        printf(\"\u4e0b\uff0c\u901a\u8fc7\");\n        print(sol);\n        printf(\"\u8f6c\u5316\u4e3a\");\n        print(s1:-rep);\n        return true;\n    else\n        return eq;\n    end if;\nend proc:\n\n# \u8f93\u51fa\u6240\u6709InvSol\u5bf9\u8c61\nprintSols:=proc(sols)\n    local n,i;\n    n:=numelems(sols);\n    for i from 1 to n do\n        printf(\"---------------------------------------------------------\");\n        printf(\"sols[%d]\",i);\n        printSol(sols[i]);\n    end do;\n    return sols;\nend proc:\n\n# \u8f93\u51fa\u6240\u6709RepSol\u5bf9\u8c61\nprintReps:=proc(reps)\n    local i,n;\n    n:=numelems(reps);\n    for i from 1 to n do\n        printf(\"\u4ee3\u8868\u5143 [%d]---------------------------\",i);\n        printRep(reps[i]);\n    end do;\nend proc:\n\n# \u7b80\u8981\u8f93\u51fa\u4ee3\u8868\u5143\u53ca\u5176\u6210\u7acb\u6761\u4ef6\nprintRepCon:=proc()\n    map(x->print([x:-rep,getCon(x)[x:-sid]]),getReps()):\n    return;\nend proc:\n\n# \u7b80\u8981\u8f93\u51fa\u4ee3\u8868\u5143\u53ca\u5176\u6210\u7acb\u6761\u4ef6\u4ee5\u53ca\u4e0d\u53d8\u91cf\u65b9\u7a0b\u548c\u53d8\u6362\u65b9\u7a0b\u7684\u89e3\nsummaryReps:=proc()\n    local i,n,r,_reps,id;\n    _reps:=getReps();\n    n:=numelems(_reps);\n    for i from 1 to n do\n        r:=_reps[i];\n        printf(\"\u4ee3\u8868\u5143 [%d]\",i);\n        print(r:-rep);\n        printf(\"\u5177\u6709\u6761\u4ef6:\");\n        for id in r:-sid do\n            print(getCon(r)[id]);\n            print(r:-isol[id]);\n            print(r:-tsol[id]);\n            printf(\"-------------------------------------\");\n        end do;\n    end do;\n    return;\nend proc:\n\n$endif", "meta": {"hexsha": "f3dbabacf7260ee4a6c144cdc4b5fe9a1053a262", "size": 2938, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "old/Interaction.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": "old/Interaction.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": "old/Interaction.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": 22.6, "max_line_length": 78, "alphanum_fraction": 0.5476514636, "num_tokens": 1033, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7154239957834733, "lm_q2_score": 0.6959583250334526, "lm_q1q2_score": 0.4979052857942059}}
{"text": "(*\n Copyright (C) 2017 M.A.L. Marques\n\n This Source Code Form is subject to the terms of the Mozilla Public\n License, v. 2.0. If a copy of the MPL was not distributed with this\n file, You can obtain one at http://mozilla.org/MPL/2.0/.\n*)\n\n(* type: gga_exc *)\n\ngamma_ss := 0.2:\ncc_ss    := [0.0136823, 0.268920, -0.550769,  1.03947, 0.0]:\n\ngamma_ab := 0.006:\ncc_ab    := [0.836897,  1.72051,  -2.78498,  -4.57504, 0.0]:\n\n$include \"lda_c_vwn.mpl\"\n$include \"b97.mpl\"\n\nf := (rs, z, xt, xs0, xs1) ->\n  b97_f(f_vwn, gamma_ss, cc_ss, gamma_ab, cc_ab,\n        rs, z, xs0, xs1):", "meta": {"hexsha": "5b25dbb35798c83743466412d29639bc87e2a227", "size": 569, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "libxc-5.1.6/maple/gga_exc/gga_c_hcth_a.mpl", "max_stars_repo_name": "pwang234/lsms", "max_stars_repo_head_hexsha": "6044153b6138512093e457bdc0c15c699c831778", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2018-04-03T15:35:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T03:19:23.000Z", "max_issues_repo_path": "libxc-5.1.6/maple/gga_exc/gga_c_hcth_a.mpl", "max_issues_repo_name": "pwang234/lsms", "max_issues_repo_head_hexsha": "6044153b6138512093e457bdc0c15c699c831778", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2019-07-30T13:59:18.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T17:43:35.000Z", "max_forks_repo_path": "libxc-5.1.6/maple/gga_exc/gga_c_hcth_a.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.8636363636, "max_line_length": 68, "alphanum_fraction": 0.6291739895, "num_tokens": 228, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577681049901037, "lm_q2_score": 0.5774953651858118, "lm_q1q2_score": 0.49535710503600167}}
{"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# \u8868\u8fbe\u5f0f\u6309\u7167\u590d\u6742\u5ea6\u5347\u5e8f\u6392\u5e8f\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# \u6309\u7167\u96c6\u5408\u62d3\u5c55table\u952e\u503c \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# \u5bf9\u8c61\u6309\u952e\u503c\u5206\u7c7b\n# \u63a8\u8350\u5bf9\u952e\u505aconvert/global\u5904\u7406\uff0c\u4ee5\u6d88\u9664\u5c40\u90e8\u53d8\u91cf\u76f8\u7b49\u7684\u95ee\u9898\u3002\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# \u5bf9\u8c61\u6309\u952e\u503c\u552f\u4e00\u5316\n# \u63a8\u8350\u5bf9\u952e\u505aconvert/global\u5904\u7406\uff0c\u4ee5\u6d88\u9664\u5c40\u90e8\u53d8\u91cf\u76f8\u7b49\u7684\u95ee\u9898\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# \u9009\u62e9\u76ee\u6807\u51fd\u6570\u503c\u6700\u5c0f\u7684\u5143\u7d20\nMinSelect:=proc(v::list,fun)\n    return v[min[index]([seq(fun(x),x in v)])];\nend proc:\n\n# \u5bfb\u627e\u7279\u5b9a\u503c\u7684\u4e0b\u6807\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\u2026\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\u2026\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\u00e9, 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                           \u03d5_0, d\u03d5_0) where T\n    \u03d5d\u03d5 = make_\u03d5d\u03d5(df, x_new, x, s)\n    ls(\u03d5d\u03d5, alpha, \u03d5_0, d\u03d5_0)\nend\n\n(ls::MoreThuente)(\u03d5, d\u03d5, \u03d5d\u03d5, alpha, \u03d5_0, d\u03d5_0) = ls(\u03d5d\u03d5, alpha, \u03d5_0, d\u03d5_0)\n\n# TODO: Should we deprecate the interface that only uses the \u03d5d\u03d5 argument?\nfunction (ls::MoreThuente)(\u03d5d\u03d5,\n                           alpha::T,\n                           \u03d5_0,\n                           d\u03d5_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\u03d5_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 = \u03d5_0\n    dgtest = f_tol * d\u03d5_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\u03d5_0\n    sty = zeroT\n    fy = finit\n    dgy = d\u03d5_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 = \u03d5d\u03d5(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 = \u03d5d\u03d5(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 = \u03d5d\u03d5(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\u03d5_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\u03d5_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": "var $arr1 <[10] i32>\nvar $arr2 <[10] i32>\nvar $arr3 <[10] i32>\n\nfunc $ArrayAdd () void {\n var %i i32\n doloop %i ( \n  constval i32 0, \n  lt i32 i32 (dread i32 %i, constval i32 10), \n  add i32(dread i32 %i, constval i32 1)){\n   iassign <* [10] i32>(\n    array 1 a32 <* [10] i32>(addrof a32 $arr1, dread i32 %i),\n    add i32(\n     iread i32 <* [10] i32>(\n      array 1 a32 <* [10] i32>(addrof a32 $arr2, dread i32 %i)), \n     iread i32 <* [10] i32>(\n      array 1 a32 <* [10] i32>(addrof a32 $arr3, dread i32 %i))\n     ))\n  }\n  return() \n}\n # EXEC: %irbuild Main.mpl\n # EXEC: %irbuild Main.irb.mpl\n # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl\n", "meta": {"hexsha": "6a12bf5e8c4014a5c556bf8d1f8946cad643fbc1", "size": 639, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "test/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/Main.mpl", "max_stars_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_stars_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_stars_repo_licenses": ["MulanPSL-1.0"], "max_stars_count": 796, "max_stars_repo_stars_event_min_datetime": "2019-08-30T16:20:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-25T14:45:06.000Z", "max_issues_repo_path": "test/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/Main.mpl", "max_issues_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_issues_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_issues_repo_licenses": ["MulanPSL-1.0"], "max_issues_count": 16, "max_issues_repo_issues_event_min_datetime": "2019-08-30T18:04:08.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-19T05:02:58.000Z", "max_forks_repo_path": "test/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/Main.mpl", "max_forks_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_forks_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_forks_repo_licenses": ["MulanPSL-1.0"], "max_forks_count": 326, "max_forks_repo_forks_event_min_datetime": "2019-08-30T16:11:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-26T12:31:17.000Z", "avg_line_length": 25.56, "max_line_length": 65, "alphanum_fraction": 0.5665101721, "num_tokens": 275, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7371581626286834, "lm_q2_score": 0.6688802603710085, "lm_q1q2_score": 0.4930705437536879}}
{"text": "\n# Inverse Dynamics for Robot with IC\n# Einleitung\n# Berechnung der inversen Dynamik f\u00fcr Roboter mit impliziten Zwangsbedingungen\n# \n# Dateiname:\n# robot -> Berechnung f\u00fcr allgemeinen Roboter\n# implicit_constraints -> Berechnung f\u00fcr 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\u00fcr Mechatronische Systeme, Universit\u00e4t 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\u00fccke die folgende Warnung.\nrestart: # Gibt eine Warnung, wenn \u00fcber Terminal-Maple mit read gestartet wird.\ninterface(warnlevel=3):\nwith(LinearAlgebra):\nwith(ArrayTools):\nwith(codegen):\nwith(CodeGeneration):\nwith(StringTools):\n# Einstellungen f\u00fcr Code-Export: Optimierungsgrad (2=h\u00f6chster) 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\u00fcr 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\u00fcr 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\u00fcr 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\u00fcr %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\u00fcr %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\u00fcr %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\u00fcr %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\u00fcr 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\u00f6schung 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\u00fcr %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\u00e4ge 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": " func $fooi64 (\n  var %i i64, var %j i64\n  ) i64 { \n   return (\n     add i64(dread i64 %i, dread i64 %j))}\n\n func $addi64I (\n  var %i i64\n  ) i64 { \n   return (\n#add i64(dread i64 %i, constval i64 0x123456789))}\n     add i64(dread i64 %i, constval i64 0x800000115))}\n # EXEC: %irbuild Main.mpl\n # EXEC: %irbuild Main.irb.mpl\n # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl\n", "meta": {"hexsha": "b93dc8e37e7b9e31edbb1d181f3d54481aea05fe", "size": 369, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "test/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/Main.mpl", "max_stars_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_stars_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_stars_repo_licenses": ["MulanPSL-1.0"], "max_stars_count": 796, "max_stars_repo_stars_event_min_datetime": "2019-08-30T16:20:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-25T14:45:06.000Z", "max_issues_repo_path": "test/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/Main.mpl", "max_issues_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_issues_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_issues_repo_licenses": ["MulanPSL-1.0"], "max_issues_count": 16, "max_issues_repo_issues_event_min_datetime": "2019-08-30T18:04:08.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-19T05:02:58.000Z", "max_forks_repo_path": "test/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/Main.mpl", "max_forks_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_forks_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_forks_repo_licenses": ["MulanPSL-1.0"], "max_forks_count": 326, "max_forks_repo_forks_event_min_datetime": "2019-08-30T16:11:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-26T12:31:17.000Z", "avg_line_length": 23.0625, "max_line_length": 54, "alphanum_fraction": 0.6151761518, "num_tokens": 153, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7248702761768248, "lm_q2_score": 0.6757646075489391, "lm_q1q2_score": 0.4898416777045231}}
{"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 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_revtpss_params *params;\n\n  assert(p->params != NULL);\n  params = (mgga_c_revtpss_params * )(p->params);\n*)\n\n$include \"gga_c_regtpss.mpl\"\n$include \"tpss_c.mpl\"\n\nf := (rs, z, xt, xs0, xs1, us0, us1, ts0, ts1) ->\n  + tpss_f(f_pbe, rs, z, xt, xs0, xs1, ts0, ts1):\n\n\n\n\n", "meta": {"hexsha": "ffc5bd8af3ba10e0d322dc6e1ed745ad72aba60c", "size": 544, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "libxc-5.1.6/maple/mgga_exc/mgga_c_revtpss.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_revtpss.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_revtpss.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": 20.9230769231, "max_line_length": 68, "alphanum_fraction": 0.6544117647, "num_tokens": 193, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624789529376, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.48717556320583116}}
{"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": " func $foo (\n  var %i i32 \n#var %i1 i32, var %j1 i32, var %k1 i32\n  ) i32 { \n   return (\n     depositbits i32 1 23(\n       constval i32 0xfff, constval i32 0x11))}\n # EXEC: %irbuild Main.mpl\n # EXEC: %irbuild Main.irb.mpl\n # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl\n", "meta": {"hexsha": "80efe03affd5546fc7b9db7a81a16ba23539695e", "size": 266, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "test/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/Main.mpl", "max_stars_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_stars_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_stars_repo_licenses": ["MulanPSL-1.0"], "max_stars_count": 796, "max_stars_repo_stars_event_min_datetime": "2019-08-30T16:20:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-25T14:45:06.000Z", "max_issues_repo_path": "test/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/Main.mpl", "max_issues_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_issues_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_issues_repo_licenses": ["MulanPSL-1.0"], "max_issues_count": 16, "max_issues_repo_issues_event_min_datetime": "2019-08-30T18:04:08.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-19T05:02:58.000Z", "max_forks_repo_path": "test/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/Main.mpl", "max_forks_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_forks_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_forks_repo_licenses": ["MulanPSL-1.0"], "max_forks_count": 326, "max_forks_repo_forks_event_min_datetime": "2019-08-30T16:11:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-26T12:31:17.000Z", "avg_line_length": 24.1818181818, "max_line_length": 47, "alphanum_fraction": 0.6165413534, "num_tokens": 110, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7341195269001831, "lm_q2_score": 0.6619228825191872, "lm_q1q2_score": 0.4859305133593912}}
{"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": "check_set_generic(\"RR\");\ncheck_set_generic(\"CC\");\ncheck_set_generic(\"RZ\");\ncheck_set_generic(\"R\",[[5]]);\ncheck_set_generic(\"C\",[[5]]);\ncheck_set_generic(\"CP\",[[5]]);\ncheck_set_generic(\"sphere\",[[5]]);\ncheck_set_generic(\"RZ_set\");\ncheck_set_generic(\"RP_points\");\ncheck_set_generic(\"RP_lines\");\ncheck_set_generic(\"RP_conics\");\ncheck_set_generic(\"RP_arcs\");\ncheck_set_generic(\"simplices\",[[5], [3]]);\ncheck_set_generic(\"real_functions\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"vector_functions\",[[4], [{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"maps\",[[{10, 20, 30, 40, 50}, {1, 2, 3}]]);\ncheck_set_generic(\"binops\",[[{0, 1}, {1, 2, 3}, {1, 2, 3}]]);\ncheck_set_generic(\"epi\",[[{10, 20, 30, 40, 50}, {1, 2, 3}]]);\ncheck_set_generic(\"subsets\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"nonempty_subsets\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"proper_nonempty_subsets\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"big_subsets\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"pairs\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"pair_subsets\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"triples\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"partitions\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"permutations\",[[5]]);\ncheck_set_generic(\"shuffles\",[[3, 4]]);\ncheck_set_generic(\"nat_partitions\",[[8, 3]]);\ncheck_set_generic(\"pos_partitions\",[[8, 3]]);\ncheck_set_generic(\"rel\",[[{11, 22, 33, 44}, {1, 2, 3}]]);\ncheck_set_generic(\"autorel\",[[{1, 2, 3}]]);\ncheck_set_generic(\"equiv\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"preord\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"partord\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"total_preord\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"ord\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"cycord\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"linord\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"posint_intervals\");\ncheck_set_generic(\"interval_partitions\",[[5]]);\ncheck_set_generic(\"graphs\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"paths\",[[{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}], [{[11, 15], [11, 17], [11, 18], [11, 19], [11, 20], [12, 13], [12, 16], [12, 19], [12, 20], [13, 12], [13, 15], [13, 16], [13, 19], [13, 20], [14, 15], [14, 18], [14, 20], [15, 11], [15, 13], [15, 14], [15, 16], [15, 18], [15, 20], [16, 12], [16, 13], [16, 15], [16, 19], [17, 11], [17, 19], [17, 20], [18, 11], [18, 14], [18, 15], [18, 19], [19, 11], [19, 12], [19, 13], [19, 16], [19, 17], [19, 18], [20, 11], [20, 12], [20, 13], [20, 14], [20, 15], [20, 17]}], [4]]);\ncheck_set_generic(\"trails\",[[{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}], [{[11, 15], [11, 17], [11, 18], [11, 19], [11, 20], [12, 13], [12, 16], [12, 19], [12, 20], [13, 12], [13, 15], [13, 16], [13, 19], [13, 20], [14, 15], [14, 18], [14, 20], [15, 11], [15, 13], [15, 14], [15, 16], [15, 18], [15, 20], [16, 12], [16, 13], [16, 15], [16, 19], [17, 11], [17, 19], [17, 20], [18, 11], [18, 14], [18, 15], [18, 19], [19, 11], [19, 12], [19, 13], [19, 16], [19, 17], [19, 18], [20, 11], [20, 12], [20, 13], [20, 14], [20, 15], [20, 17]}], [4]]);\ncheck_set_generic(\"digraphs\",[[{11, 22, 33, 44}]]);\ncheck_set_generic(\"dipaths\",[[{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}], [{[11, 12], [11, 13], [11, 15], [11, 19], [12, 14], [12, 15], [12, 16], [12, 19], [13, 16], [13, 17], [13, 19], [14, 15], [14, 19], [15, 13], [15, 17], [15, 19], [16, 11], [16, 15], [16, 18], [16, 19], [17, 11], [17, 12], [17, 14], [17, 19], [18, 12], [19, 18], [19, 20], [20, 13], [20, 15], [20, 18]}], [4]]);\ncheck_set_generic(\"ditrails\",[[{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}], [{[11, 12], [11, 13], [11, 15], [11, 19], [12, 14], [12, 15], [12, 16], [12, 19], [13, 16], [13, 17], [13, 19], [14, 15], [14, 19], [15, 13], [15, 17], [15, 19], [16, 11], [16, 15], [16, 18], [16, 19], [17, 11], [17, 12], [17, 14], [17, 19], [18, 12], [19, 18], [19, 20], [20, 13], [20, 15], [20, 18]}], [4]]);\ncheck_set_generic(\"trees\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"full_trees\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"binary_trees\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"standard_stasheff_trees\",[[6]]);\ncheck_set_generic(\"binary_standard_stasheff_trees\",[[6]]);\ncheck_set_generic(\"stasheff_trees\",[[{11, 22, 33, 44}]]);\ncheck_set_generic(\"standard_stasheff_star\",[[5]]);\ncheck_set_generic(\"stasheff_star\",[[{11, 22, 33, 44}]]);\ncheck_set_generic(\"W\",[[4], [{11, 22, 33, 44}]]);\ncheck_set_generic(\"prime_W\",[[4], [{11, 22, 33, 44}]]);\ncheck_set_generic(\"SW\",[[4], [{11, 22, 33, 44}]]);\ncheck_set_generic(\"W1\",[[{11, 22, 33, 44}]]);\ncheck_set_generic(\"BW1\",[[{11, 22, 33, 44}]]);\ncheck_set_generic(\"SWW\",[[3], [{10, 20, 30, 40, 50}, {10, 30, 50}]]);\ncheck_set_generic(\"single_cubes\",[[3]]);\ncheck_set_generic(\"cubes\",[[3], [{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"one_cubes_prime\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"simplicial_interval\",[[6]]);\ncheck_set_generic(\"simplicial_maps\",[[6, 5]]);\ncheck_set_generic(\"simplicial_epi\",[[5, 3]]);\ncheck_set_generic(\"simplicial_mono\",[[3, 5]]);\ncheck_set_generic(\"simplex\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"simplex_interior\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"ord_simplex_interior\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"prime_simplex\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"prime_simplex_boundary\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"height_functions\",[[{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}]]);\ncheck_set_generic(\"tree_height_functions\",[[{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}], [{{11}, {12}, {13}, {14}, {15}, {16}, {17}, {18}, {19}, {20}, {11, 13, 14}, {16, 17, 18, 19, 20}, {11, 12, 13, 14, 15, 16, 17, 18, 19, 20}}]]);\ncheck_set_generic(\"F\",[[3], [{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"Fbar\",[[3], [{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"E\",[[6]]);\ncheck_set_generic(\"P\",[[6]]);\ncheck_set_generic(\"SEM\",[[3], [{10, 11, 12, 13, 14, 15, 16}]]);\ncheck_set_generic(\"ACP\",[[3], [{10, 11, 12, 13, 14, 15, 16}]]);\ncheck_set_generic(\"SCP\",[[3], [{10, 11, 12, 13, 14, 15, 16}]]);\ncheck_set_generic(\"ICP\",[[3], [A]]);\ncheck_set_generic(\"SCP2\",[[3], [{10, 11, 12, 13, 14, 15, 16}], [B6]]);\ncheck_set_generic(\"FFbar\",[[3], [{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"X/F3\",[[4]]);\ncheck_set_generic(\"Y/F3\",[[4]]);\ncheck_set_generic(\"D_plus/F3\",[[4]]);\ncheck_set_generic(\"D_minus/F3\",[[4]]);\ncheck_set_generic(\"D_zero/F3\",[[4]]);\ncheck_set_generic(\"comm\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"itloc\",[[{1, 2, 3}], [3]]);\ncheck_set_generic(\"Phi0/itloc\",[[{10, 20, 30, 40, 50}]]);\ncheck_set_generic(\"M11/itloc\",[[{10, 20, 30, 40, 50}], [{10, 30, 50}]]);\ncheck_set_generic(\"M1/itloc\",[[{1, 2, 3, 4, 5}], [[{4}, {3, 4}, {1, 3}, {3, 4}]]]);\n", "meta": {"hexsha": "e435235412bafcdc1e6c69124bcd86a302d23d79", "size": 6669, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib_checks/_check_all_sets.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_checks/_check_all_sets.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_checks/_check_all_sets.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": 69.46875, "max_line_length": 542, "alphanum_fraction": 0.5732493627, "num_tokens": 3032, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7431680086124811, "lm_q2_score": 0.6513548646660543, "lm_q1q2_score": 0.4840660976739237}}
{"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# Fonctions on polynomials#\n###########################\n\n\n\n\n\n\n######################################################\n## Definition of basis on directly on the coordinates#\n######################################################\nm_in_z:= proc(spart::pN2spart,forceVars:=`MORE`)\n\tlocal sector,part_phi, part_phitheta, part_theta, part_zed, monome_length, nbVars, perm_indices, supermonome, lem, lemprime, ledegree, part_pt, mbarbar; remember;\n\t# This procedure produces the monomial in terms of the variables\n\t# This requires the procedure partial_monomial\n\twith(Physics);\n\tpart_pt:= spart[1];\n\tpart_phi:=spart[2];\n\tpart_theta:=spart[3];\n\tpart_zed:=spart[4];\n\tmonome_length:=nops(Flatten(spart));\n\tif forceVars= `MORE` then \n\t\tsector:= giveSpartSector(spart);\n        \tledegree:= sector[1];\n\t\tlem:= sector[2];\n\t\tlemprime:= sector[3];\n\t\tmbarbar:= sector[4];\n        \tnbVars:= max(map(x-> nops(Flatten(x)), genN2spart(ledegree, lem, lemprime, mbarbar)));\n\telse\n\t\tif forceVars=`MIN` then \n\t    \t\tnbVars:= monome_length; \n           \t\tif nbVars=1 then nbVars:= nbVars+1; end if;\n\t    \telse\n\t    \t\tif forceVars<monome_length then\n\t\t\t\tprint(\"Error[1]: Forced number of variable invalid\");\n\t\t\t\tprint(\" minimal number of variables set instead\"); \n\t\t\t\tnbVars:=monome_length;\n\t\t\telse\n\t\t\t\tnbVars:=forceVars;\n\t\t\tend if;\n\t\tend if;\n\tend if;\n\tsupermonome:= partial_monomial(switch_notation(spart,a));\n\tsupermonome:= Kw(supermonome, nbVars);\n\treturn supermonome;\nend proc:\npartial_monomial:= proc(spart)\n\tlocal the_indices, a_monomial,k, part_mono;\n\t#Creates the first monomial to be symmetrized, the spart going in the argument must be written in terms of the TC spart notation\n\tthe_indices:= [seq(k, k=1..nops(spart))];\n\ta_monomial := map(x-> \n\t\tif \tspart[x][2] = \"T\" \tthen (phi||x)*(z||(x))^(spart[x][1]);\n\t\telif \tspart[x][2] = \"C\" \tthen (theta||x)*(z||(x))^(spart[x][1]);\n\t\telif \tspart[x][2] = \"TC\" \tthen (phi||x)*(theta||x)*(z||x)^(spart[x][1]);\n\t\telif \tspart[x][2] = \"\" \tthen (z||x)^(spart[x][1]);\n\t\tend if, the_indices);\n\tpart_mono:=1; for k in a_monomial do part_mono:= part_mono*k; end do;\n\treturn sort(part_mono); \nend proc: \n\np_in_z:= proc(spart,forceVars:=0,factoring:=0,help:=0) \n\t#Produces the powersums in terms of the variables\n\tlocal sector,phipart,phithetapart,thetapart,zedpart,nbVar,prod,phis,thetas, phithetas,zed,part,Vars, Lambda, powersums, powersum, k; option remember;\n\tif help <> 0 then\n\t\tp2nHelp();\n\t\treturn NULL;\n\tend if;\n\tif spart = [[],[],[],[0]] then return 0; end if;\n\tsector:= giveSpartSector(spart);\n\tnbVar:= max(map(x-> nops(Flatten(x)), genN2spart(op(sector)))); \n\tif forceVars>nbVar then nbVar:=forceVars; end if;\n\tif forceVars<>0 then nbVar:=forceVars; end if;\n\tLambda:= switch_notation(spart,a);\n\tpowersums:= map(x-> nth_powersum(x, nbVar), Lambda);\n\n\t#specific to our symmetry\n\t#subzero:= {seq(phi||k*theta||k = 0, k=1..nbVar)};\n\tif factoring <> 0 then \n\t\tpowersum:= mul(k, k in powersums);\n\t\t#powersum:= PerformOnAnticommutativeSystem(mul,[k, k in powersums]);\n\telse\n\t\tpowersum:=1;\n\t\tfor k in powersums do\n\t\t\tpowersum:= sort(expand(powersum*k));\n\t\t\tpowersum:= powersum - add(phi||k*theta||k*diff(diff(powersum,phi||k),theta||k),k=1..nbVar);\n\t\tend do:\n\tend if;\n\treturn sort(expand(powersum));\nend proc:\nnth_powersum:= proc(a_part, nbvar); \n\t#Gives the n_th powersums ex: \\bar{p}_3 = (phi_1z_1^3 + ...)\n\tif a_part[2] = \"\" then \n\t\t#return add( (z||k)^a_part[1], k=1..nbvar);\n\t\treturn m_in_z([[],[],[a_part[1]]],nbvar);\n\telif a_part[2] = \"T\" then\n\t\t#return add( phi||k*(z||k)^a_part[1], k=1..nbvar);\n\t\treturn m_in_z([[a_part[1]],[],[]], nbvar);\n\telif a_part[2] = \"C\" then\n\t\t#return add( theta||k*(z||k)^a_part[1], k=1..nbvar);\n\t\treturn m_in_z([[],[a_part[1]],[]], nbvar);\n\telif a_part[2] = \"TC\" then\n\t\treturn add( tau||k*psi||k*x^(a_part[1]), k=1..nbvar); \n\tend if;\nend proc:\n\nz_to_p:= proc(inpoly)\n\tlocal powersums, pre_soln, pre_solnzed, polyinp,a, k, laspart,Vars, nbvars, poly, phis, thetas, zeds, lem, mprime, degreeSym, degreeFerm, sparts, monomials, syseq, soln, polyinm;\n\toption remember;\n\t# Takes a polynomial in the variables in solve it in terms of powersums \n\tpoly:= inpoly;\n\tVars:= giveVars(poly);\n\tif inpoly=0 then return 0; end if;\n\tnbvars:= max(nops(Vars[1]), nops(Vars[2]), nops(Vars[3]));\n\tphis:=Vars[1];\n\tthetas:=Vars[2];\n\tzeds:=Vars[3];\n\tif nbvars = 0 then return 1; end if; \n    \tlem:=         nops(giveVars(op(1,sort(expand(poly))))[1]); \n    \tmprime :=   nops(giveVars(op(1,sort(expand(poly))))[2]);\n\tdegreeFerm:= lem+mprime;\n    \tdegreeSym:= degree(poly, zeds);\n    \tsparts:= genN2spart(degreeSym, lem, mprime, mbarbar);\n\n    \tsparts:= map(x-> if nops(Flatten(x)) > nbvars then NULL; else x; end if, sparts);\n    \tpowersums:= map(x-> p[op(x)] = p_in_z(x, nbvars), sparts);\n\tpre_soln:=add(a[k]*p[op(sparts[k])], k=1..nops(sparts)) ;\n\tpre_solnzed:= subs(powersums, pre_soln);\n    \tsyseq:= pre_solnzed - poly;\n    \tsyseq:= sort(expand(syseq));\n   \tsoln:= superSolve(syseq);\n\tpolyinp:= subs(soln, pre_soln); \n\treturn polyinp;\nend proc:\n\nold_z_to_m:= proc(inpoly, mixed:=0)\n\tlocal pre_soln, pre_solnzed,a, k, laspart,Vars, nbvars, poly, phis, thetas, zeds, lem, mprime, degreeSym, degreeFerm, sparts, monomials, syseq, soln, polyinm;\n\toption remember;\n\t#Converts a polynomial in the variables in terms of monomial symetric functions\n\t#Old procedure, the new one is better, kept to make sure the new one works well. \n\tpoly:= inpoly;\n\tVars:= giveVars(poly);\n\tif inpoly=0 then return 0; end if;\n\tnbvars:= max(nops(Vars[1]), nops(Vars[2]), nops(Vars[3]));\n\tphis:=Vars[1];\n\tthetas:=Vars[2];\n\tzeds:=Vars[3];\n\tif nbvars = 0 then return 1; end if; \n    \tlem:=         nops(giveVars(op(1,expand(poly)))[1]); \n    \tmprime :=   nops(giveVars(op(1,expand(poly)))[2]);\n\tdegreeFerm:= lem+mprime;\n    \tdegreeSym:= degree(poly, zeds);\n    \tsparts:= genN2spart(degreeSym, lem, mprime);\n\n    \tsparts:= map(x-> if nops(Flatten(x)) > nbvars then NULL; else x; end if, sparts);\n    \tmonomials:= map(x-> m[op(x)] = m_in_z(x, nbvars), sparts);\n\tpre_soln:=add(a[k]*m[op(sparts[k])], k=1..nops(sparts)) ;\n\tpre_solnzed:= subs(monomials, pre_soln);\n    \tsyseq:= pre_solnzed - poly;\n    \tsyseq:= sort(expand(syseq));\n   \tsoln:= superSolve(syseq);\n\tpolyinm:= subs(soln, pre_soln); \n\treturn polyinm;\nend proc:\n\none_e2m:= proc(spart)\n\toption remember;\n\tlocal thetas, zeds, fermion_sparts, boson_sparts, mul_chain, resulting_monos, k, pts, phis, sparts;\n\t#Works only for N=1\n\tpts:= spart[1];\n\tphis:= spart[2];\n\tif pts <> [] or phis <> [] then return \"ERROR: e2m not implemented for N=2\"; end if; \n\tthetas:= spart[3];\n\tzeds:= spart[4];\n\tfermion_sparts:=\tmap(x-> m[[],[],[0],[seq(1, i=1..x)]], thetas);\n\tboson_sparts:=\t\tmap(x-> m[[],[],[],[seq(1, i=1..x)]], zeds);\n\tmul_chain := [op(fermion_sparts), op(boson_sparts)];\n\tmul_chain:= Reverse(mul_chain);\n\tresulting_monos:= mul_chain[1];\n\tfor k from 2 to nops(mul_chain) do \n\t\tresulting_monos:= one_mono_on_expr_prod(mul_chain[k], resulting_monos);\n\tend do:\n\treturn resulting_monos;\nend proc:\ne_en_m:= proc(spart)\n\toption remember;\n\treturn one_e2m(spart); \nend proc:\n\ne2m:= proc(expr)\n\tlocal elementaries, sparts, convertin, sublist, expr_out;\n\telementaries:= [op(indets(expr, elementary_symbolic))]; \n\tsparts:= map(x-> [op(x)], elementaries); \n\tconvertin:= map(x-> one_e2m(x), sparts); \n\tsublist:= map(x-> elementaries[x] = convertin[x], [seq(k, k=1..nops(elementaries))]);\n\texpr_out:= subs( { op(sublist) }, expr);\n\texpr_out:= collect_monomials(expr_out);\n\treturn expr_out;\nend proc:\n\nm_en_e:= proc(spart)\n\tlocal all_sparts, ep_m, ep_ep, preAns, systeq, allindets; \n\toption remember;\n\tall_sparts:= genN2spart(op(giveSpartSector(spart)));\n\tep_m:= map(x-> a[x]*e_en_m(all_sparts[x]), [seq(i, i=1..nops(all_sparts))]);\n\tep_ep:= map(x-> e[op(x)], all_sparts);\n\tpreAns:= add(a[k]*ep_ep[k], k=1..nops(all_sparts));\n\tsysteq:= collect_monomials(m[op(spart)]- add(k, k in ep_m)); \n\tallindets:= solve_monomialeq(systeq);\n\treturn subs(allindets, preAns); \nend proc:\nm_en_h:= proc(spart)\n\tlocal all_sparts, ep_m, ep_ep, preAns, systeq, allindets; \n\toption remember;\n\tall_sparts:= genN2spart(op(giveSpartSector(spart)));\n\tep_m:= map(x-> a[x]*h_en_m(all_sparts[x]), [seq(i, i=1..nops(all_sparts))]);\n\tep_ep:= map(x-> h[op(x)], all_sparts);\n\tpreAns:= add(a[k]*ep_ep[k], k=1..nops(all_sparts));\n\tsysteq:= collect_monomials(m[op(spart)]- add(k, k in ep_m)); \n\tallindets:= solve_monomialeq(systeq);\n\treturn subs(allindets, preAns); \nend proc:\n\n#Faire m2e \ne2p:= proc(expr)\n\treturn collect_powersums(m_to_p(e2m(expr))); \nend proc:\n\n\none_p2m:= proc(spart)\n\toption remember;\n\tlocal nota_spart, chain_sparts, chain_spartR, the_chain, resulting_monos, k;\n\tif spart = [[],[],[],[]] then return 1; end if;\n\t#Take a superpartition in and expresse the powersum represented by it in terms of monomial symetric functions\n\t#The basis transformation is obtained with the rules for the product of two monomials. Theses rules are stated in https://arxiv.org/abs/1511.05002\n\tnota_spart:= switch_notation(spart);\n\tchain_sparts:= map(x-> [x], nota_spart);\n\tchain_spartR:= map(x-> reverse_notation(x), chain_sparts);\n\tthe_chain:= Reverse(chain_spartR);\n\tthe_chain:= map(x-> m[op(x)], the_chain);\n\tresulting_monos:= the_chain[1];\n\tfor k from 2 to nops(the_chain) do\n\t\tresulting_monos:= one_mono_on_expr_prod(the_chain[k], resulting_monos);\n\tend do:\n\treturn resulting_monos;\nend proc:\n\nrow_p2m:= proc(expr_monomial, sparts)\n\t#Produces a row of the transition matrix\n\treturn map(x-> coeff(expr_monomial, m[op(x)]), sparts);\nend proc:\n\ntransition_matrix_p2m:= proc(n, mbar, mubar, mbarbar)\n\toption remember;\n\tlocal sparts, the_matrix;\n\t#Generate the transition matrix of powersums to monomials\n\tsparts:=genN2spart(n,mbar, mubar, mbarbar);\n\tthe_matrix:= map(x->row_p2m(one_p2m(x), sparts), sparts);\n\tthe_matrix:= Matrix(the_matrix);\n\treturn the_matrix;\nend proc:\n\ntransition_matrix_m2p:= proc(n, mbar, mubar, mbarbar)\n\toption remember;\n\tlocal the_matrix_inv, the_matrix;\n\t#Obtain the transition matrix of monomials to powersums\n\t#It is obtained by inversion of the p to m matrix\n\tthe_matrix_inv:= transition_matrix_p2m(n, mbar, mubar, mbarbar);\n\tthe_matrix:= LinearAlgebra[MatrixInverse](the_matrix_inv);\n\treturn the_matrix;\nend proc:\n\np_to_m:= proc(expr)\n\tlocal powersums, sector, sparts, monomials, transition_matrix, mono_expansion, sublist, out;\n\t#Takes a linear expression of powersums and converts it in terms of monomial using the transition matrix \n\tpowersums:= indets(expr, powersum_symbolic);\n\tsector:= giveSpartSector([op(powersums[1])]); \n\tsparts:= genN2spart(op(sector));\n\tpowersums:= Vector(map(x-> p[op(x)], sparts));\n\tmonomials:= Vector(map(x-> m[op(x)], sparts));\n\ttransition_matrix:= transition_matrix_p2m(op(sector));\n\tmono_expansion:= transition_matrix.monomials;\n\tmono_expansion:=convert(mono_expansion, list);\n\tpowersums:= convert(powersums,list);\n\tsublist:= map(x-> powersums[x] = mono_expansion[x], [seq(k,k=1..nops(sparts))]); \n\tout:= collect_monomials( subs(sublist, expr)); \n\treturn out;\nend proc:\n\nm_to_p:= proc(expr)\n\tlocal power_expansion,powersums, sector, sparts, monomials, transition_matrix, mono_expansion, sublist, out;\n\t#Takes a linear superposition of monomials and converts it to powersums. Uses the the transition matrix\n\tmonomials:= indets(expr, monomial_symbolic);\n\tsector:= giveSpartSector([op(monomials[1])]); \n\tsparts:= genN2spart(op(sector));\n\tpowersums:= Vector(map(x-> p[op(x)], sparts));\n\tmonomials:= Vector(map(x-> m[op(x)], sparts));\n\ttransition_matrix:= transition_matrix_m2p(op(sector));\n\tpower_expansion:= transition_matrix.powersums;\n\tpower_expansion:=convert(power_expansion, list);\n\tmonomials:= convert(monomials,list);\n\tsublist:= map(x-> monomials[x] = power_expansion[x], [seq(k,k=1..nops(sparts))]); \n\tout:= collect_powersums( subs(sublist, expr)); \n\treturn out;\nend proc:\nm_systeq:= proc(the_equation)\n\tlocal systeq;\n\tsysteq:=map(x-> coeff(the_equation, x), indets(the_equation, monomial_symbolic)); \n\treturn systeq;\n\t#return solve(systeq, indets(the_equation, a_indet)); \nend proc:\nsuperSolve:= proc(the_equation, inconnu:=a)\n\tlocal vartosolve, systEq;\n\t#Takes an equation the_equation = 0 = a[1]*poly(z,phi,theta) + a[2]*poly(z,phi_theta) + ... and returns the solution. The point of this is that it works with AC_Vars and doesn't require that you specify the variables to solve for. \n\tsystEq:={Coefficients(simplify(sort(expand(the_equation))), giveVars(the_equation,1), 'onlynonzero')};\n\tvartosolve:= indets(the_equation, a_indet);\n\treturn solve(systEq, vartosolve); \n\t#return 1;\nend proc:\n\ngiveVars:= proc(poly, flat:=0) local zeds, phis, thetas;\n\t#Takes a polynomial in the variables and returns all the variables found inside. It is returned as threes sets in a list: [ {phi_i}, {theta_j}, {z_k} ] \n\tzeds:= indets(poly, z_var);\n\tphis:= indets(poly,AC_phi);\n\tthetas:= indets(poly, AC_theta);\n\tif flat<>0 then return [ op(phis), op(thetas), op(zeds) ]; end if;\n\treturn [phis, thetas, zeds]; \nend proc:\n\ngiveNbVars:= proc(poly)\n\t#Returns the number of indices of a give polynomial\n\treturn max(map(x-> nops(x),giveVars(poly))); \nend proc:\n\nold_LinBaseConvert:= proc(exprin, totype)\n\t#Takes an expression expressed on the superbasis and give it back in term of another basis. It doesn't use the transition matrix method yet\n#Exemple LinBaseConvert(m[[1],[],[0],[1]] + beta/(beta+1)*m[[0],[],[1],[1]], `p`); \n\tlocal nbVars,a_numbering, thesector, sparts, z_expr, other_indets, protecting_a, expr, out;\n\texpr:= exprin:\n\tprotecting_a:=indets(expr, a_indet):\n\tif nops(protecting_a)<>0 then \n\t\ta_numbering:= map(x-> op(op(x)), protecting_a):\n\t\texpr:=subs(map(k->a[k] = other_indets[k], a_numbering), expr):\n\tend if:\n\tthesector:=givePolySector(expr) ; #[ mphi, mtheta, nzed, nbVars]\n\tsparts:= genN2spart(op(thesector)):\n\tnbVars:= max( map(x-> nops(Flatten(x)), sparts) );\n\tif \ttype(op(1,indets(expr, superbase)), monomial_symbolic) then\n\t\tz_expr:= map(x-> m[op(x)] = m_in_z(x), sparts): \n\telif \ttype(op(1,indets(expr, superbase)), powersum_symbolic) then\n\t\tz_expr:= map(x-> p[op(x)]= p_in_z(x), sparts): \n\telif \ttype(op(1,indets(expr, superbase)), elementary_symbolic) then\n\t\tz_expr:= map(x-> e[op(x)] =e2n(x), sparts): \n\telif \ttype(op(1,indets(expr, superbase)), homogeneous_symbolic) then\n\t\tz_expr:= map(x-> h[op(x)] =h2n(x), sparts): \n\telif \ttype(op(1,indets(expr, superbase)), g_symbolic) then\n\t\t#z_expr:= map(x-> g[op(x)] =g2n(x, thesector[4]), sparts): \n\t\t#z_expr:= map(x-> p[op(x)]= p2n(x, thesector[4]), sparts): \n\t\tprint(\"Not yet defined\");\n\tend if;\n\t#z_expr:= add(k, k in Subs({op(z_expr)}, expr)):\n\tif totype=`z` or totype=\"z\" then \n\t\tz_expr:= subs(z_expr, expr);\n\t\tif nops(protecting_a)<>0 then \n\t\t\tz_expr:=subs(map(k->other_indets[k] = a[k], a_numbering), z_expr):\n\t\tend if:\n\t\t\treturn z_expr; \n\tend if;\n\tz_expr:= sort(expand(subs(z_expr, expr)));\n\tif\ttotype= `monomial` or totype=`m` or totype=\"m\" then out:= collect_monomials(z_to_m(z_expr)): end if:\n\tif\ttotype= `powersum` or totype=`p` or totype=\"p\" then out:= collect_powersums(z_to_p(z_expr)): end if:\n\tif\ttotype= `homogeneous` or totype= `h` or totype=\"h\" then out:= z_to_h(z_expr): end if:\n\tif\ttotype= `elementary` or totype=`e` or totype=\"e\" then out:= z_to_e(z_expr): end if:\n\tif \ttotype= `gbasis` or totype=`g` or totype=\"g\" then out:= z_to_g(z_expr): end if; \n\t\n\tif nops(protecting_a)<>0 then \n\t\tout:=subs(map(k->other_indets[k] = a[k], a_numbering), out):\n\tend if:\n\treturn out:\nend proc:\n\n\ngivePolySector:= proc(poly)\n\tlocal terms, aspart;\n\t#Takes an expression in terms of superbasis and returns the sector in which it lives\n\tterms:= indets(poly,superbase);\n\taspart:= [op( op(1,terms) ) ]; \n\treturn giveSpartSector(aspart);\nend proc:\n\ncollect_by_type:= proc(thetype, expr, normalize_by:=0)\n\tlocal collected_expr; \n\t#factorize the coefficients of a expression on a basis. \n\tif normalize_by = 0 then\n\t\tcollected_expr:= map(factor, collect(expr, indets(expr, thetype))); \n\telse\n\t\tcollected_expr:= map(factor, collect(expr/coeff(expr, normalize_by), indets(expr, thetype))); \n\tend if:\n\treturn collected_expr;\nend proc:\n\ncollect_galpha:= proc(expr, normalize_by:=0)\n\treturn collect_by_type(g_symbolic, expr, normalize_by);\nend proc:\ncollect_monomials:= proc(expr, normalize_by:=0, mode:=[1,2,3])\n\tlocal normalize;\n\tnormalize:=0;\n\tif normalize_by <> 0 then\n\t\tif coeff(expr, normalize_by) = 0 then\n\t\t\tnormalize:= 0;\n\t\telse\n\t\t\tnormalize:= normalize_by;\n\t\tend if;\n\tend if;\n\treturn super_pol_sort(collect_by_type(monomial_symbolic, expr, normalize), m, givePolySector(expr), mode); \nend proc:\ncollect_powersums:= proc(expr, normalize_by:=0)\n\treturn collect_by_type(powersum_symbolic, expr, normalize_by);\nend proc:\n\n\n#ns Basis\nnsMonome:= proc(comp_in)\n\tlocal N;\n\t#Returns the non-symetric monomial of the composition given as an argument\n\tN:= nops(comp_in); \n\treturn mul(z||k^(comp_in[k]), k=1..N); \nend proc:\n\nnsJack:= proc(comp_in, N:=0)\n\tlocal solns, leading_monome, complength, poids, allcomp, smallercomp, smallermonomes, prensJack, D_nsJack, lambda_nsJack, systEQ; \n\t#Returns the non-symmetric jack of a composition\n\tpoids:= add(k,k in Flatten(comp_in)); \n\tallcomp:= [seq(op(composition(poids,k)),k=1..poids)]; \n\tif N <> 0 then\n\t\tcomplength:= N; \n\telse\n\t\tif poids > nops(comp_in) then complength:= poids; else complength:= nops(comp_in); end if;\n\tend if; \n\tallcomp:= map(x-> if nops(x) < complength then [op(x),seq(0, k=1..(complength-nops(x)))]; else x; end if, allcomp); \n\tallcomp:= map(x-> permute(x), allcomp); \n\tallcomp:= FlattenOnce(allcomp); \n\tallcomp:= MakeUnique(allcomp); \n\tsmallercomp:= map(x-> if compare_bruhat(comp_in, x) = `>` then x; else NULL; end if, allcomp); \n\tleading_monome:= nsMonome(comp_in); \n\tsmallermonomes:= map(nsMonome, smallercomp); \n\tprensJack:= leading_monome + add(a[k]*smallermonomes[k], k=1..nops(smallermonomes));   \n\tD_nsJack:= map(x-> Dunkl_i_n(x,1, prensJack, complength), [seq(k, k=1..complength)]); \n\tlambda_nsJack:= map(x-> lambdabar_i(comp_in, x, complength)*prensJack, [seq(k, k=1..complength)]); \n\tsystEQ:= simplify(D_nsJack - lambda_nsJack); \n\tsystEQ:= Coefficients(systEQ, [seq(z||k, k=1..complength)], 'onlynonzero'); \n\tsystEQ:= MakeUnique(systEQ);\n\tsystEQ:= {op(systEQ)}; \n\tsolns:= solve(systEQ, indets(systEQ,a_indet));\n\t#solns:= {op(Flatten(map(x-> op(superSolve(x)),systEQ)))};\n\t#return leading_monome+ DotProduct(solvevect,smallermonomes); \n\treturn subs(solns, prensJack);\nend proc:\n\nlambdabar_i:= proc(composition, i, N)\n\t#Returns the eigenvalue of the operator D_i (Dunkl_i_n) \n\tlocal lalistebeta1, lalistebeta2, comparaisonbeta1, comparaisonbeta2, lalisteun, comparaisonbeta, comparaisonun, lambdai;\n\tlalistebeta1:= [seq(k, k=1..(i-1))]; \n\tlalistebeta2:= [seq(k,k=(i+1)..N)]; \n\n\tcomparaisonbeta1:= map(k-> if composition[k] >= composition[i] then 1; else NULL; end if, lalistebeta1); \n\tcomparaisonbeta2:= map(k-> if composition[k] > composition[i] then 1; else NULL; end if, lalistebeta2); \n\tlambdai:= composition[i] - beta*(nops(comparaisonbeta1) + nops(comparaisonbeta2)); \nreturn lambdai; \nend proc:\n\n\n#superJacks\nterm_fromPart:= proc(term::list,var_index)\n\tlocal thepart, thetype;\n\t#Takes a part of a superpartition and returns the partial monomial associated to it\n\tthepart:= term[1];\n\tthetype:= term[2];\n\tif thetype = \"\" then \n\t\treturn (z||var_index)^thepart;\n\telif thetype = \"T\" then\n\t\treturn phi||var_index*(z||var_index)^thepart;\n\telif thetype = \"C\" then\n\t\treturn theta||var_index*(z||var_index)^thepart;\n\tend if;\nend proc:\nns_supermonomial_sJack:= proc(spart::pN2spart, genFermProdOnly:=1)\n\tlocal Spart, themonomial, k, thetas_index, phis_index, Scomposition;\n\t#Returns the [phi;theta]_lambda that precedes the nsJack in the superJack definition\n\tSpart:= switch_notation(spart, a);\n\tScomposition:= Reverse(Spart);\n\tthemonomial:=1;\n\tphis_index:= [];\n\tthetas_index:= [];\n\tfor k from 1 to nops(Spart) do\n\t\tthemonomial:= themonomial*term_fromPart(Scomposition[k], k);\n\t\tif op(2,Scomposition[k]) = \"T\" then phis_index:= [ op(phis_index), k]; end if;\n\t\tif op(2,Scomposition[k]) = \"C\" then thetas_index:= [ op(thetas_index), k]; end if;\n\tend do:\n\tif genFermProdOnly<>0 then\n\t\tthemonomial:=subs( {seq(z||k = 1, k=1..nops(Spart))}, themonomial);\n\tend if:\n\treturn [themonomial, phis_index, thetas_index];\nend proc:\n\ngenSuperJack:= proc(spart::pN2spart, in_alpha:=1) \nlocal thesector, longest_spart, phis, thetas, zeds, scomposition, thensJack, superJack, pts, mbarbar, mbar, mubar;\noption remember;\n\t#Slow#\n\t#Generates the superJack N=2 using the non-symmetric Jack method (Slow)\n\tthesector:=giveSpartSector(spart);\n\tlongest_spart:=max(map(x-> nops(Flatten(x)), genN2spart(op(thesector))));\n\tpts:= spart[1];\n\tphis:= spart[2];\n\tthetas:= spart[3];\n\tzeds:= spart[4]; \n\tmbarbar:= nops(pts);\n\tmbar:= nops(phis);\n\tmubar:= nops(thetas);\n\tscomposition:= [op(Reverse(pts)),op(Reverse(phis)), op(Reverse(thetas)), op(Reverse(zeds))]; \n\t#scomposition:= [op(pts),op(phis), op(thetas), op(zeds)]; \n\tif longest_spart > nops(scomposition) then\n\t\tscomposition:= [op(scomposition), seq(0, k=1..(longest_spart -nops(scomposition)))];\n\tend if;\n\t#print(scomposition);\n\tthensJack:= nsJack(scomposition);\n\tthensJack:= Var_Symmetrize(thensJack, [seq(k, k=1..mbarbar)]);\n\tthensJack:= AntiSymetrize(thensJack, [ seq(k+mbarbar, k=1..mbar)]);\n\tthensJack:= AntiSymetrize(thensJack, [ seq(k+mbarbar + mbar, k=1..mubar) ]);\n\tthensJack:= mul(phi||k*theta||k, k=1..mbarbar)*mul(phi||(k+mbarbar), k=1..mbar)*mul(theta||(k+mbarbar+mbar), k=1..mubar)*thensJack;\n\tsuperJack:= Kw(thensJack, longest_spart); \n\tif in_alpha <> 0 then superJack:= subs(beta=1/alpha, superJack); end if;\n\tsuperJack:= collect_monomials(z_to_m(superJack), m[op(spart)]); \n\treturn superJack; \nend proc:\ngen2SuperJack:= proc(spart::pN2spart, in_alpha:=0)\n\tlocal n_spart, scomposition, numbering, the_symbols, nsmono_index, nsmono, antisym_indexphi, antisym_indextheta, thesector, longest_spart, thensJack, superJack;\n\tn_spart:= Reverse(switch_notation(spart));\n\tscomposition:= map(x-> x[1], n_spart);\n\tnumbering:= [seq(k, k=1..nops(n_spart))];\n\tthe_symbols:= map(x-> x[2], n_spart);\n\tnsmono_index:= map(x-> \n\t\t\tif the_symbols[x] \t= \"\" then NULL; \n\t\t\telif the_symbols[x]  \t= \"T\" then [phi||x,x,phi];\n\t\t\telif the_symbols[x]\t= \"C\" then [theta||x,x, theta];\n\t\t\tend if,\n\t\t\tnumbering);\n\tnsmono:=mul(x[1], x in nsmono_index); \n\tantisym_indexphi:=\tmap(x-> if x[3] = phi \tthen x[2]; else NULL; end if, nsmono_index);\n\tantisym_indextheta:=\tmap(x-> if x[3] = theta then x[2]; else NULL; end if, nsmono_index);\n\tthesector:=giveSpartSector(spart);\n\tlongest_spart:=max(map(x-> nops(Flatten(x)), genN2spart(thesector[1], thesector[2], thesector[3])));\n\tif longest_spart > nops(scomposition) then\n\t\tscomposition:= [op(scomposition), seq(0, k=1..(longest_spart -nops(scomposition)))];\n\tend if;\n\tthensJack:= nsJack(scomposition);\n\tthensJack:= AntiSymetrize(thensJack, antisym_indexphi);\n\tthensJack:= AntiSymetrize(thensJack, antisym_indextheta);\n\tthensJack:= nsmono*thensJack;\n\tsuperJack:= Kw(thensJack, longest_spart); \n\tif in_alpha <> 0 then superJack:= subs(beta=1/alpha, superJack); end if;\n\tsuperJack:= collect_monomials(z_to_m(superJack), m[op(spart)]); \n\treturn superJack; \nend proc:\n\n\nscalar_prod_powersum:= proc(expr_1, expr_2, param:=alpha)\n\tlocal powerSums_1, powerSums_2, non_ortho, non_ortho_spart, norms, coeff_expr1, coeff_expr2;\n\t#Given two expression in term of p[spart], it calculates and returns the p_alpha scalar product between the 2\n\tpowerSums_1 := indets(expr_1, powersum_symbolic) ; \t#[ p[spart], p[spart], ... ] \n\tpowerSums_2 := indets(expr_2, powersum_symbolic) ;\n\tnon_ortho := powerSums_1 intersect powerSums_2 ; \t#Sends back only spart which appears in both\n\tif op(non_ortho) = NULL then return 0; end if ;\t\t#Test whether they are orthogonal\n\tnon_ortho := [op(non_ortho)];\n\t#if nops(non_ortho)<2 then #Ne pas utiliser la version parrallele de map lorsqu'il n'y a qu'un element\n\t\tnon_ortho_spart := map(x -> [ op(x) ], non_ortho) ;\t\n\t\tnorms := map(x-> norm_p(x, param), non_ortho_spart) ;\t#[ norm1, norm2, norm3, ...]\n\t\tcoeff_expr1 := map(x -> coeff(expr_1,x), non_ortho);  #[ coeff_of(p[spart1]), coeff_of(p[spart2]), ...]\n\t\tcoeff_expr2 := map(x -> coeff(expr_2,x), non_ortho);\n\t#else\n#\t\tnon_ortho_spart := Map(x -> [ op(x) ], non_ortho) ;\t#[ [spart], [spart], ...]\n#\t\tnorms := Map(x-> norm_p(x), non_ortho_spart) ;\t#[ norm1, norm2, norm3, ...]\n#\t\tcoeff_expr1 := Map(x -> coeff(expr_1,x), non_ortho);  #[ coeff_of(p[spart1]), coeff_of(p[spart2]), ...]\n#\t\tcoeff_expr2 := Map(x -> coeff(expr_2,x), non_ortho);\n#\tend if;\n\treturn add(x,x in coeff_expr1*~coeff_expr2*~norms);\t\t# *~ is the symbol for element-wise multiplication\nend proc:\n\nnorm_p:= proc(spart, parameter:=alpha)\n\tlocal p_part, pt_part, t_part, zed_part, ell_lambda, big_ell, combin, partphi, partpt, parttheta, mphi, mtheta,mpt; option remember;\n\t#Given a spart, returns the value of the norm of a powersum associated with this spart\n\tif parameter = \"modeqt\" then return qt_zLambda(spart); end if; \n\tif parameter = \"modeqt2\" then return qt_zLambda2(spart); end if; \n\tif parameter = \"mode_inc\" then return N[op(spart)]; end if; \n\tpartphi:= op(1,spart);\n\tpartpt:= op(2,spart);\n\tparttheta:= op(3,spart);\n\tmphi:= nops(partphi);\n\tmtheta:= nops(parttheta);\n\tmpt:= nops(partpt); \n   \tbig_ell:= nops(Flatten(spart)); \n\treturn (parameter)^(big_ell)*zlambda(spart);\nend proc:\nzlambda:= proc(spart)\n\toption remember;\n\tlocal pt_part, zed_part, pt_distPart, zed_distPart, zlambda4, zeta1, nbZeros;\n\tzeta1:=1;\n\tzlambda4:=1:\n\t#Calculate the z_Lambda function \n\t#p_part:=spart[1];\n\tpt_part:=spart[1];\n\t#t_part:=spart[3]\n\tzed_part:=spart[4];\n\t###\n\t#nbZeros:= Occurrences(0, pt_part);\n\t#pt_part:= eliminate_zeros(pt_part);\n\t###\n\tpt_distPart:={op(pt_part)}; \t#conserve only one occurrence of each part\n\tzed_distPart:={op(zed_part)};\n\t#Occurrences(x, L) returns the number of occurrences of x in L\n\t#zeta1:=\t\tmul( factorial( Occurrences(i, pt_part)), i in pt_distPart); \n\t#zeta1:= z[op(pt_part)];\n\tzeta1:= mul(factorial(Occurrences(i,pt_part)), i in pt_distPart);\n\tzlambda4:= mul(i^(Occurrences(i,zed_part))*factorial(Occurrences(i,zed_part)), i in zed_distPart);\n\treturn zeta1*zlambda4;\t\nend proc:\n\nmonomial_scalar_prod:= proc(expr1, expr2,param:=alpha)\n\t#Give the scalar product of the expression written in terms of monomial superfunctions. It uses the fast basis transformation algorithm involving the transformation matrix. \n\treturn scalar_prod_powersum(m_to_p(expr1), m_to_p(expr2), param); \nend proc:\n\nqt_monomial_scalar_prod:= proc(expr1, expr2)\n\treturn monomial_scalar_prod(expr1, expr2, \"mode_inc\"); \nend proc:\n\n\n#### superJacks\n\nsJack_sector:= proc(n, mbar, mubar,mbarbar, mode:=[1,2,3], in_alpha:=1)\n\t#Returns all the sJacks of a sector\n\t#To obtain the spart to which each one is associated, use the give_greatest_monomial, it will return the m[hightspart in expression]. \n\treturn sJack_spart(give_greatest_spart(genN2spart(n,mbar, mubar, mbarbar, mode), mode), 1, mode, in_alpha);\nend proc:\n\nsJack_spart:= proc(spart, give_all_jacks:=0, mode:=[1,2,3], in_alpha:=1)\n\tlocal all_sparts, smaller_sparts, list_with_smaller, sjacks, sparts_in_expr, eqsyst, soln, prejack, k;\n\t#Returns the jack associated to a spart\n\t# Find every smaller sparts\n\t# For every smaller spart, find the set of their smaller sparts\n\t# Sort in terms of number of smaller sparts\n\t# Solve bottom to top using scalar product\n\tall_sparts:= genN2spart(op(giveSpartSector(spart)), mode);\n\tsmaller_sparts:= sKeep_smaller_sparts(spart, all_sparts, mode);\n\tlist_with_smaller:=sort(map(x-> [x,op(sKeep_smaller_sparts(x, smaller_sparts, mode))], smaller_sparts));\n\tlist_with_smaller:=[ op(list_with_smaller), [spart, op(smaller_sparts)]]; \n\tsjacks:= [m[op(op(1,list_with_smaller[1]))]];\n\tif nops(list_with_smaller) = 1 then \n\t\tif give_all_jacks = 0 then return op(sjacks); end if;\n\t\tif give_all_jacks <> 0 then return sjacks; end if;\n\tend if;\n\tfor k from 2 to nops(list_with_smaller) do\n\t\tsparts_in_expr:= list_with_smaller[k];\n\t\tprejack:= m[ op( sparts_in_expr[1] ) ] + add(a[k]*m[ op( sparts_in_expr[k] ) ], k=2..nops(sparts_in_expr));\n\t\teqsyst:= map(x-> monomial_scalar_prod(prejack, x), sjacks);\n\t\tsoln:= solve(eqsyst, indets(prejack, a_indet));\n\t\tprejack:= collect_monomials(subs(soln, prejack),0, mode); \n\t\tsjacks:= [op(sjacks), prejack];\n\tend do;\n\tif in_alpha <> 1 then \n\t\tsjacks:= map(collect_monomials,subs(alpha=1/beta, sjacks));\n\t\tend if;\n\tif give_all_jacks <> 0 then \n\t\treturn sjacks;\n\telse\n\t\treturn sjacks[-1]; \n\tend if;\nend proc:\n\nz_to_m:= proc(expr)\n\tlocal the_sector, sparts, sparts_notation2, part_mono, mono_coeff, out;\n\tthe_sector:= giveZPolySector(expand(expr));\t\n\tsparts:= genN2spart(op(the_sector)); \n\tsparts_notation2:= map(x-> switch_notation(x), sparts); \n\tpart_mono:= map(x-> partial_monomial(x), sparts_notation2); \n\tmono_coeff:= map(x-> sCoeff_nsMono(x, expr), part_mono ); \n\tout:= add( factor(mono_coeff[k])*m[ op(sparts[k]) ], k=1..nops(sparts)); \n\treturn out;\n\t#partial_monomials:= map(x-> partial_monomial(x), sparts_notation2); \nend proc:\n\nsCoeff_nsMono:= proc(expr_prod, expr)\n\tlocal sdegrees, zeds, zeds_deg, AC_terms, all_vars, in_deg, a_zero_list, in_expr, theSeq, PT_terms, x;\n\t#Works like coeff fonction, but instead give the coefficient of a non-symmetric monomial so for exemple : \n\t# > AA:= (beta+1)phi1 theta2 theta3 z1^2z2 + ....\n\t# > sCoeff_nsMono( phi1theta2theta3z1^2z2, AA) = (beta+1)\n\tin_expr:= expr;\n\tsdegrees:= superDegree(expr_prod, giveNbVars(expr));\n\tzeds:= \t\t[seq(z||k, k=1..nops(sdegrees))]; \n\tzeds_deg:= \tmap(x-> x[1], sdegrees);\n\ttheSeq:= \t[seq(k, k=1..nops(sdegrees))];\n\tAC_terms:=\tmap(k-> \n\t\t\t\tif op(2, sdegrees[k]) = \"C\" then theta||k;\n\t\t\t\telif op(2, sdegrees[k]) = \"T\" then phi||k;\n\t\t\t\telif op(2, sdegrees[k]) = \"\" then NULL;\n\t\t\t\telif op(2, sdegrees[k]) = \"TC\" then NULL;\n\t\t\t\tend if\n\t\t\t\t, theSeq);\n\tPT_terms:= map(k-> if op(2, sdegrees[k]) = \"TC\" then k; else NULL; end if, theSeq);\n\tfor x in PT_terms do\n\t\tin_expr:= diff(diff(in_expr, phi||x), theta||x);\n\tend do;\n\tall_vars:= \t[op(zeds), op(AC_terms)]; \n\tin_deg := \t[op(zeds_deg), seq(1, k=1..nops(AC_terms))];\n\ta_zero_list:= \t[seq(0, k=1..nops(all_vars))];\n\treturn coeftayl(in_expr, all_vars = a_zero_list, in_deg);\nend proc:\n\n\n\ngive_greatest_monomial:= proc(poly_in_m, mode:=[1,2,3])\n\tlocal monos, sparts, thespart;\n\t#Returns m[lambda], where lambda is the greatest spart in the expr. \n\tmonos:= [op(indets(poly_in_m, monomial_symbolic) )];\n\tif nops(monos) = 1 then return monos[1]; end if;\n\tsparts:= map(x-> [ op(x)], monos);\n\tthespart:= give_greatest_spart(sparts, mode);\n\treturn m[ op(thespart) ];\nend proc:\n\ngive_smallest_monomial:= proc(poly_in_m)\n\tlocal monos, sparts, thespart;\n\t#Returns m[lambda], where lambda is the greatest spart in the expr. \n\tmonos:= [op(indets(poly_in_m, monomial_symbolic) )];\n\tif nops(monos) = 1 then return monos[1]; end if;\n\tsparts:= map(x-> [ op(x)], monos);\n\tthespart:= give_smallest_spart(sparts);\n\treturn m[ op(thespart) ];\nend proc:\n\n\ngiveZPolySector:= proc(expr)\n\tlocal nbVars, a_ns_mono, thedegrees, mbar, mubar, n, mbarbar;\n\t#Given a polynomial in terms of the variables, returns the sector in which it lives.\n\tnbVars:= giveNbVars(expr);\n\ta_ns_mono:= op(1, expr);\n\tthedegrees:=superDegree(a_ns_mono, nbVars);\n\tmbarbar:= add(k, k in map(x-> if op(2,x) = \"TC\" then 1; else 0; end if, thedegrees));\n\tmbar:= add(k, k in map(x-> if op(2,x) = \"T\" then 1; else 0; end if, thedegrees));\n\tmubar:= add(k, k in map(x-> if op(2,x) = \"C\" then 1; else 0; end if, thedegrees));\n\tn:= add( k, k in map(x-> op(1,x), thedegrees)); \n\treturn [n, mbar, mubar, mbarbar]; \nend proc:\n\nsuperDegree:= proc(monoterm, nbVars)\n\tlocal phis, thetas, zeds, DegPhi, DegThe, DegZed, the_degrees, k, pts, indicesVar, DegPT;\n\t#Returns the \"superdegree\" of a non-symmetric monomial\n\tpts:= [seq(phi||k*theta||k, k=1..nbVars)];\n\tphis:= [ seq(phi||k, k=1..nbVars)]; \n\tindicesVar := [seq(k, k=1..nbVars)];\n\tthetas:= [ seq(theta||k, k=1..nbVars)]; \n\tthetas:= [ seq(theta||k, k=1..nbVars)]; \n\tzeds:= [ seq(z||k, k=1..nbVars)]; \n\tDegPhi:= map(x-> fermionic_degree(monoterm, \"phi\", x), indicesVar); \n\tDegThe:= map(x-> fermionic_degree(monoterm,\"theta\", x), indicesVar); \n\tDegPT:= map(x-> fermionic_degree(monoterm,\"phitheta\", x), indicesVar); \n\tDegZed:= map(x-> degree(monoterm, x), zeds); \n\tthe_degrees:= [];\n\tfor k from 1 to nbVars do\n\t\tif DegPhi[k] = 1 then \n\t\t\tthe_degrees:= [op(the_degrees), [DegZed[k], \"T\"]];\n\t\telif DegThe[k] = 1 then \n\t\t\tthe_degrees:= [op(the_degrees), [DegZed[k], \"C\"]];\n\t\telif DegPT[k] = 1 then \n\t\t\tthe_degrees:= [op(the_degrees), [DegZed[k], \"TC\"]];\n\t\telse \n\t\t\tthe_degrees:= [op(the_degrees), [DegZed[k], \"\"]];\n\t\tend if;\n\tend do;\n\treturn the_degrees;\nend proc:\n\nfermionic_degree:= proc(term, var, var_index)\n\tif var = \"phitheta\" then\n\t\tif diff(diff(term, phi||var_index), theta||var_index) <> 0 then \n\t\t\treturn 1;\n\t\telse\n\t\t\treturn 0;\n\t\tend if;\n\telif var = \"phi\" then\n\t\tif diff(diff(term, phi||var_index), theta||var_index) <> 0 then \n\t\t\treturn 0;\n\t\telse\n\t\t\tif diff(term, phi||var_index) <> 0 then return 1; else return 0; end if;\n\t\tend if;\n\telif var = \"theta\" then\n\t\tif diff(diff(term, phi||var_index), theta||var_index) <> 0 then \n\t\t\treturn 0;\n\t\telse\n\t\t\tif diff(term, theta||var_index) <> 0 then return 1; else return 0; end if;\n\t\tend if;\n\tend if;\nend proc:\n\nspart_monomial_product:= proc(spartA, spartB)\n\tlocal ledegree, overm, underm, maxlength, ValidSparts, ellA, ellB, FspartA, FspartB, PspartB, added_sparts, coeff_sparts, final_sparts, monomial_expansion ;\n\tprotect(a,b);\n\t#Generate valid sparts : right here\n\t#ledegree:=  add(k, k in Flatten(spartA)) + add(k, k in Flatten(spartB));\n   \t#overm:=         nops(spartA[1]) + nops(spartA[2]) + nops(spartB[1]) + nops(spartB[2]);\n   \t#underm:=        nops(spartA[2]) + nops(spartA[3]) + nops(spartB[2]) + nops(spartB[3]);\n   \t#maxlength:=     nops(Flatten(spartA)) + nops(Flatten(spartB)); \n    \t#ValidSparts:= genN2spart(overm, underm,ledegree);\n    \t#ValidSparts:= map(x -> if  nops(Flatten(x)) > maxlength then NULL; else x; end if, ValidSparts);\n    \t#Generate fillings: sub function\n    \t#order to get sign: in the previous subfunction \n    \t#Return the monomial superposition\n    \t#FspartA:= map(x-> \n\tellA:= ell(spartA);\n\tellB:= ell(spartB);\n\tFspartA:= add_zeros_spart(spartA,ellB);\n\tFspartB:= add_zeros_spart(spartB,ellA);\n\tFspartA:= switch_notation(FspartA, a);\n\tFspartB:= switch_notation(FspartB, b);\n\tPspartB:= permute(FspartB);\n\tadded_sparts:= MakeUnique(map(x-> add_sparts_notated(FspartA,x), PspartB)); #we keep only the distinct elements hence MakeUnique\n\tcoeff_sparts:= map(x-> give_coeff_sparts(x), added_sparts);\n\tadded_sparts:= map(x-> if x = [] then NULL; else x; end if, added_sparts); \n\tcoeff_sparts:= map(x-> give_coeff_sparts(x), added_sparts);\n\tfinal_sparts:= map(x-> reverse_notation(x), added_sparts);\n\tmonomial_expansion:= add(k, k in map(x-> coeff_sparts[x]*m[op(final_sparts[x])],[seq(l, l=1..nops(final_sparts))])); \n\treturn monomial_expansion;\n\nend proc:\n\nadd_sparts_notated:= proc(spartA,spartB)\n\tlocal added_sparts, thetypes;\n\tadded_sparts:= map(x-> \n\t\tif ((op(2,spartA[x]) = \"T\") and (op(2,spartB[x]) = \"C\")) or ((op(2,spartA[x]) = \"C\") and (op(2,spartB[x]) = \"T\")) then\n\t\t\t[0,\"ZERO\",0,0]; \n\t\telse\n\t\t\t[ \n\t\t\top(1,spartA[x])+op(1,spartB[x]), \n\t\t\tcat(op(2,spartA[x]),op(2,spartB[x])), \n\t\t\top(3,spartA[x])*op(3,spartB[x]), \n\t\t\top(4,spartA[x]), \n\t\t\top(4,spartB[x])\n\t\t\t];\n\t\tend if\n\t\t, \n\t\t[seq(k, k=1..nops(spartA))]);\n\tthetypes:= {op(map(x-> op(2,x), added_sparts))};\n\tif \t\"TT\" in thetypes or \t\n\t\t\"CC\" in thetypes or \n\t\t\"TCC\" in thetypes or \n\t\t\"TCT\" in thetypes or \n\t\t\"TTC\" in thetypes or \n\t\t\"CTC\" in thetypes or \n\t\t\"TCTC\" in thetypes or\n\t\t\"ZERO\" in thetypes\n\t\t#\"TC\" in thetypes or \n\t\t#\"CT\" in thetypes \n\t\tthen return NULL; \n\tend if;\n\t#added_sparts:= map(x-> if x[2] = \"CT\" then [x[1], \"TC\", x[3],x[5], x[4]]; else x; end if, added_sparts);\n\tadded_sparts:= map(x->if x[1..2] = [0, \"\"] then NULL; else x; end if, added_sparts);\n\tadded_sparts:= Reverse(sort(added_sparts));\n\treturn added_sparts;\nend proc:\n\ngive_coeff_sparts:= proc(spart)\n\tlocal skimed_spart_distparts, the_coeff, part, perm_set, fermion_permutation, Card_a, epsilon, Anti_Tensor;\n\tif type(reverse_notation(spart),pN2spart) <> true then return 0; end if;\n\tskimed_spart_distparts:= {op(map(x-> x[1..2], spart))};\n\tthe_coeff:=1;\n\tfor part in skimed_spart_distparts do\n\t\tperm_set:= map(x-> if part = x[1..2] then x[3]; else NULL; end if, spart);\n\t\tthe_coeff:= nops({op(permute(perm_set))})*the_coeff;\n\tend do:\n\tfermion_permutation:= Flatten(map(x-> x[-2..-1], spart));\n\t#fermion_permutation:= Flatten(subs({a=NULL, b=NULL}, fermion_permutation)); \n\tfermion_permutation:= map(x-> if type(x,a_indet) or type(x,b_indet) then x; else NULL; end if, fermion_permutation);\n\tCard_a:= nops(indets(fermion_permutation,a_indet));\n\tfermion_permutation:= map(x-> if type(x,a_indet) then op(x); else op(x)+Card_a; end if, fermion_permutation);\n\tepsilon:=1;\n\tif nops(fermion_permutation) >1 then \n\t\tAnti_Tensor:=table('antisymmetric'):\n\t\tepsilon:= Anti_Tensor[op(fermion_permutation)];\n\t\tif epsilon =0  then \n\t\t\tepsilon:=1;\n\t\telse\n\t\t\tepsilon:= coeff(epsilon, Anti_Tensor[op(sort(fermion_permutation))]);\n\t\tend if;\n\tend if:\n\treturn epsilon*the_coeff:\nend proc:\n\nadd_zeros_spart:= proc(spart, number_of_zeros)\n\tlocal padded_spart;\n\tpadded_spart:= [spart[1], spart[2], spart[3], [op(spart[4]),seq( 0, k=1..number_of_zeros)]];\n\treturn padded_spart;\nend proc:\n\ntwo_monomial_product:= proc(mono1, mono2)\n\toption remember;\n\tlocal monos_out;\n\tmonos_out:=spart_monomial_product([op(mono1)], [op(mono2)]); \n\treturn monos_out:\nend proc:\n\none_mono_on_expr_prod:= proc(mono, expr_monos)\n\tlocal right_prod_monos, sublist, out;\n\tright_prod_monos:= indets(expr_monos, monomial_symbolic);\n\tsublist:= map(x-> x=two_monomial_product(mono, x), right_prod_monos);\n\tout:= collect_monomials(subs(sublist, expr_monos)); \n\treturn out; \nend proc:\n\nexpr_mono_prod:= proc(expr1, expr2)\n\tlocal left_prod, sublist, out;\n\tif expr1 = 1 then return expr2; end if;\n\tif expr2 = 1 then return expr1; end if;\n\tleft_prod:= indets(expr1, monomial_symbolic); \n\tsublist:= map(x-> x=one_mono_on_expr_prod(x, expr2), left_prod); \n\tout:= collect_monomials(subs(sublist, expr1)); \n\treturn out;\nend proc:\n\nisJackFromNS:= proc(expr_m)\n\tlocal spart, thesector, longest_spart, pts, phis, thetas, zeds, mbar, mubar, mbarbar, expr_z, dexpr, theIndex, thensJack, scomposition, k; option remember;\n\tspart:= [op(give_greatest_monomial(expr_m))];\n\tthesector:= giveSpartSector(spart);\n\tlongest_spart:=max(map(x-> nops(Flatten(x)), genN2spart(op(thesector))));\n\tpts:= spart[1];\n\tphis:= spart[2];\n\tthetas:= spart[3];\n\tzeds:= spart[4];\n\tmbar:= thesector[2];\n\tmubar:= thesector[3];\n\tmbarbar:= thesector[4];\n\texpr_z:= LinBaseConvert(expr_m, `z`); \n\tdexpr:= expr_z;\n\tfor k from 1 to mbarbar do\n\t\tdexpr:= diff(diff(dexpr, phi||k), theta||k);\n\tend do;\n\tfor k from 1 to mbar do\n\t\ttheIndex:= k+mbarbar;\n\t\tdexpr:= diff(dexpr, phi||theIndex);\n\tend do;\n\tfor k from 1 to mubar do\n\t\ttheIndex:= k+mbarbar+mbar;\n\t\tdexpr:= diff(dexpr, theta||theIndex);\n\tend do;\n\tscomposition:= [op(Reverse(pts)),op(Reverse(phis)), op(Reverse(thetas)), op(Reverse(zeds))]; \n\tif longest_spart > nops(scomposition) then\n\t\tscomposition:= [op(scomposition), seq(0, k=1..(longest_spart -nops(scomposition)))];\n\tend if;\n\tthensJack:= nsJack(scomposition);\n\tthensJack:= Var_Symmetrize(thensJack, [seq(k, k=1..mbarbar)]);\n\tthensJack:= AntiSymetrize(thensJack, [ seq(k+mbarbar, k=1..mbar)]);\n\tthensJack:= AntiSymetrize(thensJack, [ seq(k+mbarbar + mbar, k=1..mubar) ]);\n\treturn [dexpr, thensJack];\nend proc:\n\nsolve_monomialeq:= proc(expr)\n\tlocal monos, indets_expr, the_coeffs;\n\tmonos:= indets(expr, monomial_symbolic);\n\tindets_expr:= indets(expr, a_indet); \n\tthe_coeffs:= map(x-> coeff(expr, x), monos);\n\treturn solve(the_coeffs, indets_expr);\nend proc:\nt_poch:= proc(n)\n\treturn mul( (1-t^k), k=1..n); \nend proc:\n\nqt_zLambda2:= proc(spart)\n\tlocal zed_part, zlambda4, qtzlambda, zed_distPart, pt_part, pt_distPart, zeta1;\n\tpt_part:= spart[1];\n\tpt_distPart:=MakeUnique(pt_part); \t#conserve only one occurrence of each part\n\t#zeta1:= q^(add(k, k in pt_part))*mul(factorial(Occurrences(i,pt_part)), i in pt_distPart);\n\t#zeta1:= zeta1*mul(factorial(Occurrences(i,pt_part))/(t_poch(Occurrences(i, pt_part))), i in pt_distPart);\n\tzeta1:=1;\n\tzeta1:= zeta1*zeta[op(pt_part)]; \n\n\tzed_part:= spart[4];\n\tzed_distPart:= MakeUnique(zed_part); \n\tzlambda4:= mul(i^(Occurrences(i,zed_part))*factorial(Occurrences(i,zed_part)), i in zed_distPart);\n\tqtzlambda:=\t#f[spart[2],spart[3]]*\n\t\t\t\t#zlambda4*q^(add(k, k in spart[3])+add(k,k in spart[2]))*c^(add(k, k in spart[2]))*d^(add(k, k in spart[3]));\n\t\t\t\tzlambda4*(q*t)^(-add(k, k in spart[3]))*q^(-add(k,k in spart[4]));\n\t#qtzlambda:=\tzlambda4*q^(add(k, k in spart[3])+add(k,k in spart[2]));\n\tqtzlambda:= qtzlambda*mul((1-q^(x))/(1-t^(x)), x in spart[4]); \n\treturn subs(zeta[]=1,qtzlambda*zeta1);\nend proc:\nqt_zLambda:= proc(spart)\n\tlocal pts, phis, thetas, spart_s, mbar, mubar, stat1, spart_pts_dist, spart_s_dist, aut_lambdas, aut_pts, qtz;\n\tpts:= \t\tspart[1];\n\tphis:= \t\tspart[2]; \n\tthetas:= \tspart[3]; \n\tspart_s:= \tspart[4]; \n\tmbar:= nops(phis);\n\tmubar:= nops(thetas); \n\n\tspart_pts_dist:= MakeUnique(pts); \n\tspart_s_dist:= MakeUnique(spart_s); \n\taut_lambdas:= mul(factorial(Occurrences(k, spart_s)), k in spart_s_dist); \n\taut_pts:= mul(factorial(Occurrences(k, pts)), k in spart_pts_dist); \n\n\tqtz:=1;\n\tqtz:= aut_pts*aut_lambdas*mul(x, x in spart_s)*mul((1-q^(x))/(1-t^(x)), x in spart_s)*qtz;\n\tqtz:= (t)^(-1*add(k, k in phis))*q^(add(k, k in thetas))*qtz; \n\tqtz:= mul((1-q^(x))/(1-t^(x)), x in subs(0=NULL, pts))*qtz;\n\t#qtz:= (q)^(add(k, k in pts))*qtz;\n\t#qtz:= factor(qtz); \n\treturn qtz; \nend proc:\n\n\nsMacdo_sector:= proc(n, mbar, mubar,mbarbar, in_alpha:=1, mode:=1) option remember;\n\t#Returns all the sJacks of a sector\n\t#To obtain the spart to which each one is associated, use the give_greatest_monomial, it will return the m[hightspart in expression]. \n\treturn sMacdo_spart(give_greatest_spart(genN2spart(n,mbar, mubar, mbarbar)), 1);\nend proc:\n\nsMacdo_spart:= proc(spart, give_all_jacks:=0, mode:=0) option remember;\n\tlocal sMacs, preMac, all_sparts, smaller_sparts, list_with_smaller, sjacks, sparts_in_expr, eqsyst, soln, prejack, k;\n\t#Returns the macdo associated to a spart\n\t# Find every smaller sparts\n\t# For every smaller spart, find the set of their smaller sparts\n\t# Sort in terms of number of smaller sparts\n\t# Solve bottom to top using scalar product\n\tall_sparts:= genN2spart(op(giveSpartSector(spart)));\n\tsmaller_sparts:= sKeep_smaller_sparts(spart, all_sparts);\n\tlist_with_smaller:=sort(map(x-> [x,op(sKeep_smaller_sparts(x, smaller_sparts))], smaller_sparts));\n\tlist_with_smaller:=[ op(list_with_smaller), [spart, op(smaller_sparts)]]; \n\tsMacs:= [m[op(op(1,list_with_smaller[1]))]];\n\tif nops(list_with_smaller) = 1 then \n\t\tif give_all_jacks = 0 then return op(sMacs); end if;\n\t\tif give_all_jacks <> 0 then return sMacs; end if;\n\tend if;\n\tfor k from 2 to nops(list_with_smaller) do\n\t\tsparts_in_expr:= list_with_smaller[k];\n\t\tpreMac:= m[ op( sparts_in_expr[1] ) ] + add(a[k]*m[ op( sparts_in_expr[k] ) ], k=2..nops(sparts_in_expr));\n\t\tif mode = 0 then eqsyst:= map(x-> monomial_scalar_prod(preMac, x, \"modeqt\"), sMacs); end if;\n\t\tif mode =1 then eqsyst:= map(x-> monomial_scalar_prod(preMac, x, \"modeqt2\"), sMacs); end if;\n\t\tsoln:= solve(eqsyst, indets(preMac, a_indet));\n\t\tpreMac:= collect_monomials(subs(soln, preMac)); \n\t\tsMacs:= [op(sMacs), preMac];\n\tend do;\n\tif give_all_jacks <> 0 then \n\t\treturn sMacs;\n\telse\n\t\treturn sMacs[-1]; \n\tend if;\nend proc:\nN2toN1spart:= proc(spart)\n\treturn [spart[3], spart[4]];\nend proc:\n\nN1toN2spart:= proc(spart)\n\treturn [[],[],spart[1], spart[2]]; \nend proc:\n\nN1convertexpr:= proc(expr)\n\tlocal base_elements, base_str, where, thebase, sublist;\n\t#\n\tbase_elements:= indets(expr, superbase);\n\tif nops(base_elements) = 0 then return expr; end if;\n\tbase_str:= convert(base_elements[1], string); \n\twhere:= StringTools:-Search(\"[\", base_str); \n\tthebase:= convert(base_str[1..where-1], symbol);\n\tsublist:= map(x-> x= thebase[op(N2toN1spart([op(x)]))], base_elements); \n\treturn subs(sublist, expr); \nend proc:\nN2convertexpr:= proc(expr)\n\tlocal base_elements, base_str, where, thebase, sublist;\n\tbase_elements:= indets(expr, superbase);\n\tif nops(base_elements) = 0 then return expr; end if;\n\tbase_str:= convert(base_elements[1], string); \n\twhere:= StringTools:-Search(\"[\", base_str); \n\tthebase:= convert(base_str[1..where-1], symbol);\n\tsublist:= map(x-> x= thebase[op(N1toN2spart([op(x)]))], base_elements); \n\treturn subs(sublist, expr); \nend proc:\n\nsSchur_en_m := proc(spart)\n\toption remember;\n\tlocal aschur;\n\taschur:= sMacdo_spart(spart);\n\taschur:= limit(limit(aschur, q=0), t=0);\n\treturn aschur;\nend proc:\n\nsSchurBar_en_m := proc(spart)\n\toption remember;\n\tlocal aschur;\n\taschur:= sMacdo_spart(spart);\n\taschur:= limit(limit(aschur, q=infinity), t=infinity);\n\treturn aschur;\nend proc:\n\nsSchurEtoile_en_m:= proc(spart)\n\toption remember;\n\treturn collect_monomials((-1)^( nops(spart[3])*(nops(spart[3])-1)/2 )*monomial_omega_alpha(sSchurBar_en_m(SuperConjugate(spart)), 1)); \nend proc:\n\nsSchurBarEtoile_en_m:= proc(spart)\n\toption remember;\n\treturn collect_monomials((-1)^(nops(spart[3])*(nops(spart[3])-1)/2)*monomial_omega_alpha(sSchur_en_m(SuperConjugate(spart)), 1)); \nend proc:\n\nsSchurJack_en_m:= proc(spart)\n\toption remember;\n\tlocal aschur;\n\taschur:= sMacdo_spart(spart);\n\taschur:= subs( q = t^alpha, aschur);\n\taschur:= limit(aschur,t=1);\n\taschur:= limit(aschur, alpha=1); \n\treturn aschur;\nend proc:\n\nep_en_m := proc(spart)\n\tlocal thetas, zeds;\n\toption remember;\n\tthetas:=1;\n\tzeds:= 1;\n\tif spart[3] <> [] then\n\t\tthetas\t:= (-1)^(add(k, k in spart[3]))*e2m(e[[],[],spart[3],[]]); \n\tend if;\n\tif spart[4] <> [] then\n\t\tzeds\t:= p_to_m(p[[],[],[],spart[4]]); \n\tend if;\n\tif thetas =1 or zeds =1 then \n\t\treturn thetas*zeds; \n\telse \n\t\treturn collect_monomials( expr_mono_prod(thetas, zeds) ); \n\tend if;\nend proc:\n\nh_en_m:= proc(spart)\n\toption remember;\n\tlocal pts, phis, thetas, zeds, sparts_zeds, sparts_thetas, the_prod, spats, the_monos, sparts;\n\tpts:= spart[1];\n\tphis:= spart[2];\n\tthetas:= spart[3];\n\tzeds:= spart[4]; \n\tif pts <> [] or phis <> [] then return \"ERROR: h_en_m not yet defined for N=2\"; end if; \n\tsparts_zeds:= Reverse(map(x-> genN2spart(x,0,0,0),zeds)); \n\tsparts_thetas:= Reverse(map(x-> genN2spart(x,0,1,0), thetas)); \n\tthe_prod:=1;\n\tfor sparts in sparts_zeds do\n\t\tthe_monos:= add(m[op(x)], x in sparts);\n\t\tthe_prod:= expr_mono_prod(the_monos, the_prod);\n\tend do:\n\tfor sparts in sparts_thetas do\n\t\tthe_monos:= add((op(x[3])+1)*m[op(x)], x in sparts);\n\t\tthe_prod:= expr_mono_prod(the_monos, the_prod);\n\tend do:\n\treturn the_prod;\nend proc:\n\nm_en_ep:= proc(spart)\n\tlocal all_sparts, ep_m, ep_ep, preAns, systeq, allindets; \n\toption remember;\n\tall_sparts:= genN2spart(op(giveSpartSector(spart)));\n\tep_m:= map(x-> a[x]*ep_en_m(all_sparts[x]), [seq(i, i=1..nops(all_sparts))]);\n\tep_ep:= map(x-> ep[op(x)], all_sparts);\n\tpreAns:= add(a[k]*ep_ep[k], k=1..nops(all_sparts));\n\tsysteq:= collect_monomials(m[op(spart)]- add(k, k in ep_m)); \n\tallindets:= solve_monomialeq(systeq);\n\treturn subs(allindets, preAns); \nend proc:\n\nm_en_sSchur:= proc(spart)\n\toption remember;\n\tlocal smallers, all_sparts, schurs_m,schurs_s, preAns, systeq, allindets;\n\tsmallers:= sKeep_smaller_sparts(spart, genN2spart(op(giveSpartSector(spart)))); \n\tall_sparts:= [spart, op(smallers)]; \n\t#schurs:= map(x-> s[op(x)], all_sparts); \n\tschurs_m:= map(x->a[x]*sSchur_en_m(all_sparts[x]), [seq(i, i=1..nops(all_sparts))]); \n\tschurs_s:= map(x-> s[op(x)], all_sparts); \n\tpreAns:= add( a[k]*schurs_s[k], k=1..nops(all_sparts)); \n\tsysteq := collect_monomials(m[op(spart)]-add(k, k in schurs_m)); \n\tallindets:= solve_monomialeq(systeq); \n\treturn subs(allindets, preAns); \nend proc:\n\nm_en_sSchurBar:= proc(spart)\n\toption remember;\n\tlocal smallers, all_sparts, schurs_m,schurs_s, preAns, systeq, allindets;\n\tsmallers:= sKeep_smaller_sparts(spart, genN2spart(op(giveSpartSector(spart)))); \n\tall_sparts:= [spart, op(smallers)]; \n\t#schurs:= map(x-> s[op(x)], all_sparts); \n\tschurs_m:= map(x->a[x]*sSchurBar_en_m(all_sparts[x]), [seq(i, i=1..nops(all_sparts))]); \n\tschurs_s:= map(x-> sbar[op(x)], all_sparts); \n\tpreAns:= add( a[k]*schurs_s[k], k=1..nops(all_sparts)); \n\tsysteq := collect_monomials(m[op(spart)]-add(k, k in schurs_m)); \n\tallindets:= solve_monomialeq(systeq); \n\treturn subs(allindets, preAns); \nend proc:\n\nm_en_sSchurEtoile:= proc(spart)\n\toption remember;\n\tlocal smallers, all_sparts, schurs_m,schurs_s, preAns, systeq, allindets;\n\t#smallers:= sKeep_smaller_sparts(spart, genN2spart(op(giveSpartSector(spart)))); \n\t#all_sparts:= [spart, op(smallers)]; \n\tall_sparts:= genN2spart(op(giveSpartSector(spart)));\n\t#schurs:= map(x-> s[op(x)], all_sparts); \n\tschurs_m:= map(x->a[x]*sSchurEtoile_en_m(all_sparts[x]), [seq(i, i=1..nops(all_sparts))]); \n\tschurs_s:= map(x-> sEt[op(x)], all_sparts); \n\tpreAns:= add( a[k]*schurs_s[k], k=1..nops(all_sparts)); \n\tsysteq := collect_monomials(m[op(spart)]-add(k, k in schurs_m)); \n\tallindets:= solve_monomialeq(systeq); \n\treturn subs(allindets, preAns); \nend proc:\n\nm_en_sSchurBarEtoile:= proc(spart)\n\toption remember;\n\tlocal smallers, all_sparts, schurs_m,schurs_s, preAns, systeq, allindets;\n\t#smallers:= sKeep_smaller_sparts(spart, genN2spart(op(giveSpartSector(spart)))); \n\t#all_sparts:= [spart, op(smallers)]; \n\tall_sparts:= genN2spart(op(giveSpartSector(spart)));\n\t#schurs:= map(x-> s[op(x)], all_sparts); \n\tschurs_m:= map(x->a[x]*sSchurBarEtoile_en_m(all_sparts[x]), [seq(i, i=1..nops(all_sparts))]); \n\tschurs_s:= map(x-> sbarEt[op(x)], all_sparts); \n\tpreAns:= add( a[k]*schurs_s[k], k=1..nops(all_sparts)); \n\tsysteq := collect_monomials(m[op(spart)]-add(k, k in schurs_m)); \n\tallindets:= solve_monomialeq(systeq); \n\treturn subs(allindets, preAns); \nend proc:\n\nSuperConjugate:= proc(spart)\n\toption remember;\n\tlocal nspart, kspart, antiSpart, symSpart, stopdo, col_one, k;\n\tnspart:= switch_notation(spart);\n\tnspart:= map(x-> x[1..2], nspart);\n\tkspart:= nspart;\n\tantiSpart:= [];\n\tsymSpart:= [];\n\tstopdo:= nspart[1][1];\n\tif nspart[1][2] = \"C\" then stopdo:= stopdo+1; end if;\n\tfor k from 1 to stopdo do\n\t\tif kspart[-1][1] = 0 then\n\t\t\tkspart:= kspart[1..-2];\n\t\t\tantiSpart:= [op(antiSpart), nops(kspart)];\n\t\t\tcol_one:= [ seq([1,0],j=1..nops(kspart))];\n\t\t\tkspart:= kspart - col_one;\n\t\t\tkspart:= map(x-> if x[1] = 0 and x[2] <> \"C\" then NULL; else x; end if, kspart);\n\t\telse\n\t\t\tcol_one:= [ seq([1,0],j=1..nops(kspart))];\n\t\t\tkspart:= kspart - col_one;\n\t\t\tsymSpart:= [op(symSpart), nops(kspart)];\n\t\t\tkspart:= map(x-> if x[1] = 0 and x[2] <> \"C\" then NULL; else x; end if, kspart);\n\t\tend if;\n\tend do:\n\treturn [[],[],antiSpart, symSpart]; \nend proc:\n\nmono_expr_to_schur:= proc(expr_m, theschur)\n\toption remember;\n\tlocal monos, subslist, thetype, expr_s;\n\tmonos:= indets(expr_m, monomial_symbolic); \n\tif\t\ttheschur = \"s\" then\n\t\tsubslist:= map(x-> x = m_en_sSchur([op(x)]), monos);\n\t\tthetype:= schur_symbolic;\n\telif\ttheschur = \"sbar\" then\n\t\tsubslist:= map(x-> x = m_en_sSchurBar([op(x)]), monos);\n\t\tthetype:= schurbar_symbolic;\n\telif\ttheschur = \"sEt\" then\n\t\tsubslist:= map(x-> x = m_en_sSchurEtoile([op(x)]), monos);\n\t\tthetype:= schurEtoile_symbolic;\n\telif\ttheschur = \"sbarEt\" then\n\t\tsubslist:= map(x-> x = m_en_sSchurBarEtoile([op(x)]), monos);\n\t\tthetype:= schurbarEtoile_symbolic;\n\telse\n\t\tprint(\"ERROR, wrong second argument\", \"Choose from s, sbar, sEt, sbarEt\"); \n\tend if;\n\texpr_s := subs(subslist, expr_m);\n\texpr_s := collect_by_type(thetype, expr_s); \n\treturn expr_s;\nend proc:\n\nmono_expr_to_ep:= proc(expr_m)\n\toption remember;\n\tlocal monos, sublist, expr_ep; \n\tmonos:= indets(expr_m, monomial_symbolic); \n\tsublist:= map(x-> x= m_en_ep([op(x)]), monos); \n\texpr_ep:= subs(sublist, expr_m); \n\texpr_ep:= collect_by_type(ep_symbolic, expr_ep); \n\treturn expr_ep; \nend proc:\n\nmono_expr_to_e:= proc(expr_m)\n\toption remember;\n\tlocal monos, sublist, expr_ep; \n\tmonos:= indets(expr_m, monomial_symbolic); \n\tsublist:= map(x-> x= m_en_e([op(x)]), monos); \n\texpr_ep:= subs(sublist, expr_m); \n\texpr_ep:= collect_by_type(elementary_symbolic, expr_ep); \n\treturn expr_ep; \nend proc:\n\nm_en_ph:= proc(spart)\n\tlocal all_sparts, ep_m, ep_ep, preAns, systeq, allindets; \n\toption remember;\n\tall_sparts:= genN2spart(op(giveSpartSector(spart)));\n\tep_m:= map(x-> a[x]*ph_expr_to_mono(ph[op(all_sparts[x])]), [seq(i, i=1..nops(all_sparts))]);\n\tep_ep:= map(x-> ph[op(x)], all_sparts);\n\tpreAns:= add(a[k]*ep_ep[k], k=1..nops(all_sparts));\n\tsysteq:= collect_monomials(m[op(spart)]- add(k, k in ep_m)); \n\tallindets:= solve_monomialeq(systeq);\n\treturn subs(allindets, preAns); \nend proc:\n\nmono_expr_to_ph:= proc(expr_m)\n\toption remember;\n\tlocal monos, sublist, expr_ep; \n\tmonos:= indets(expr_m, monomial_symbolic); \n\tsublist:= map(x-> x= m_en_ph([op(x)]), monos); \n\texpr_ep:= subs(sublist, expr_m); \n\texpr_ep:= superCollect(expr_ep); \n\treturn expr_ep; \nend proc:\nmono_expr_to_h:= proc(expr_m)\n\toption remember;\n\tlocal monos, sublist, expr_ep; \n\tmonos:= indets(expr_m, monomial_symbolic); \n\tsublist:= map(x-> x= m_en_h([op(x)]), monos); \n\texpr_ep:= subs(sublist, expr_m); \n\texpr_ep:= collect_by_type(homogeneous_symbolic, expr_ep); \n\treturn expr_ep; \nend proc:\n\nh_expr_to_mono:= proc(expr_p)\n\toption remember;\n\tlocal eps, sublist, expr_out;\n\teps:= indets(expr_p, homogeneous_symbolic); \n\tsublist:= map(x-> x = h_en_m([op(x)]), eps);\n\texpr_out:= subs(sublist, expr_p); \n\texpr_out:= collect_monomials(expr_out); \n\treturn expr_out; \nend proc:\n\nep_expr_to_mono:= proc(expr_p)\n\toption remember;\n\tlocal eps, sublist, expr_out;\n\teps:= indets(expr_p, ep_symbolic); \n\tsublist:= map(x-> x = ep_en_m([op(x)]), eps);\n\texpr_out:= subs(sublist, expr_p); \n\texpr_out:= collect_monomials(expr_out); \n\treturn expr_out; \nend proc:\n\nph_expr_to_mono:= proc(expr_ph)\n\toption remember;\n\tlocal expr_e, rho_expr_e, expr_mono;\n\texpr_e := N1convertexpr(subs(ph=e,expr_ph));\n\trho_expr_e:= rho_on_expr(expr_e);\n\texpr_mono:= N2convertexpr(N1LinBaseConvert(rho_expr_e, monomial_symbolic)); \n\treturn expr_mono;\nend proc:\n\ne_expr_to_mono:= proc(expr_p)\n\tlocal eps, sublist, expr_out;\n\teps:= indets(expr_p, elementary_symbolic); \n\tsublist:= map(x-> x = e_en_m([op(x)]), eps);\n\texpr_out:= subs(sublist, expr_p); \n\texpr_out:= collect_monomials(expr_out); \n\treturn expr_out; \nend proc:\n\nschur_expr_to_mono:= proc(expr_s)\n\tlocal schurs, sample_s, sublist, expr_out;\n\tschurs:= indets(expr_s, superbase);\n\tsample_s:= schurs[1];\n\tif\t\ttype(sample_s, schur_symbolic) then\n\t\tsublist:= map(x-> x = sSchur_en_m([op(x)]), schurs);\n\telif\ttype(sample_s, schurbar_symbolic) then\n\t\tsublist:= map(x-> x = sSchurBar_en_m([op(x)]), schurs);\n\telif\ttype(sample_s, schurEtoile_symbolic) then\n\t\tsublist:= map(x-> x = sSchurEtoile_en_m([op(x)]), schurs);\n\telif\ttype(sample_s, schurbarEtoile_symbolic) then\n\t\tsublist:= map(x-> x = sSchurBarEtoile_en_m([op(x)]), schurs);\n\telse\n\t\tprint(\"ERROR: Wrong type of argument\");\n\t\treturn NULL;\n\tend if;\n\texpr_out := subs(sublist, expr_s);\n\texpr_out := collect_monomials(expr_out); \n\treturn expr_out;\nend proc:\n\nschurLinBaseConvert:= proc(exprin_raw, totype, N1mode:=1)\n\tlocal sample, exprin, out;\n\tif N1mode = 1 then\n\t\texprin := N2convertexpr(exprin_raw);\n\telse\n\t\texprin := exprin_raw;\n\tend if;\n\tsample:= indets(exprin_raw, superbase);\n\n\tsample:= sample[1]; \n\tif type(sample, monomial_symbolic) then\n\t\tout:= mono_expr_to_schur(exprin, totype); \n\telif type(sample, elementary_symbolic) and totype = \"p\" then\n\t\tout:= e2p(exprin); \n\telif totype = \"s\" or totype = \"sbar\" or totype= \"sbarEt\" or totype = \"sEt\" then\n\t\tout:= mono_expr_to_schur(schur_expr_to_mono(exprin), totype); \n\telif totype = \"m\" then\n\t\tout:= schur_expr_to_mono(exprin);\n\telif totype = \"p\" then\n\t\tout:= m_to_p(schur_expr_to_mono(exprin)); \n\telse\n\t\tprint(\"ERROR: supported types (second argument) are s, sbar, sbarEt, sEt, m\", \"remember to use double quote marks\"); \n\t\treturn NULL;\n\tend if;\n\tif N1mode = 1 then\n\t\treturn N1convertexpr(out); \n\telse \n\t\treturn out;\n\tend if;\nend proc:\n\nLinBaseConvert:= proc(exprin_raw, totype, N1mode:=0)\n\tlocal expr_in, the_type, expr_mono, expr_out, types;\n\ttypes:= [\n\t\t\t\tpowersum_symbolic, \n\t\t\t\tmonomial_symbolic, \n\t\t\t\thomogeneous_symbolic, \n\t\t\t\telementary_symbolic, \n\t\t\t\tg_symbolic, \n\t\t\t\tschur_symbolic, \n\t\t\t\tschurEtoile_symbolic, \n\t\t\t\tschurbar_symbolic, \n\t\t\t\tschurbarEtoile_symbolic, \n\t\t\t\tep_symbolic,\n\t\t\t\tph_symbolic\n\t\t\t];\n\tif super_whattype(exprin_raw) = other then return exprin_raw; end if;\n\tif N1mode= 1 then\n\t\texpr_in:= N2convertexpr(exprin_raw);\n\telse\n\t\texpr_in:= exprin_raw;\n\tend if;\n\tif [op([op(indets(expr_in,indexed))][1])] = [[],[],[],[]] then \n\t\treturn subs(op(indets(expr_in,indexed))=1, expr_in);\n\tend if;\n\tthe_type:= super_whattype(expr_in);\n\tif the_type = totype then return exprin_raw; end if; \n\tif the_type = monomial_symbolic then\n\t\texpr_mono:= expr_in;\n\telif the_type = powersum_symbolic then\n\t\texpr_mono:= p_to_m(expr_in);\n\telif the_type = homogeneous_symbolic then\n\t\texpr_mono:= h_expr_to_mono(expr_in); \n\telif the_type = elementary_symbolic then\n\t\texpr_mono:= e2m(expr_in); \n\telif the_type = g_symbolic then\n\t\tprint(\"ERROR, not yet defined on gLambda\");\n\t\treturn NULL;\n\telif the_type = schur_symbolic then\n\t\texpr_mono:= schur_expr_to_mono(expr_in); \n\telif the_type = schurEtoile_symbolic then\n\t\texpr_mono:= schur_expr_to_mono(expr_in); \n\telif the_type = schurbar_symbolic then\n\t\texpr_mono:= schur_expr_to_mono(expr_in); \n\telif the_type = schurbarEtoile_symbolic then\n\t\texpr_mono:= schur_expr_to_mono(expr_in); \n\telif the_type = ep_symbolic then\n\t\texpr_mono := ep_expr_to_mono(expr_in);\n\telif the_type = ph_symbolic then\n\t\texpr_mono := ph_expr_to_mono(expr_in); \n\telse \n\t\tprint(\"Supported expr types are\", types); \n\t\treturn NULL;\n\tend if;\n\tif totype = monomial_symbolic then\n\t\texpr_out:= expr_mono;\n\telif totype = powersum_symbolic then\n\t\texpr_out:= superCollect(m_to_p(expr_mono)); \n\telif totype = homogeneous_symbolic then\n\t\texpr_out:= superCollect(mono_expr_to_h(expr_mono)); \n\telif totype = elementary_symbolic then\n\t\texpr_out:= superCollect(mono_expr_to_e(expr_mono)); \n\telif totype = g_symbolic then\n\t\tprint(\"ERROR, not yet defined on gLambda\");\n\t\treturn NULL;\n\telif totype = schur_symbolic then\n\t\texpr_out:=  mono_expr_to_schur(expr_mono, \"s\"); \n\telif totype = schurEtoile_symbolic then\n\t\texpr_out:=  mono_expr_to_schur(expr_mono, \"sEt\"); \n\telif totype = schurbar_symbolic then\n\t\texpr_out:=  mono_expr_to_schur(expr_mono, \"sbar\"); \n\telif totype = schurbarEtoile_symbolic then\n\t\texpr_out:=  mono_expr_to_schur(expr_mono, \"sbarEt\"); \n\telif totype = ep_symbolic then\n\t\texpr_out:=  mono_expr_to_ep(expr_mono);\n\telif totype = ph_symbolic then\n\t\texpr_out:=  mono_expr_to_ph(expr_mono);\n\telse\n\t\tprint(\"Supported out types are\", types); \n\t\treturn NULL;\n\tend if;\n\tif N1mode = 1 then \n\t\treturn N1convertexpr(expr_out);\n\telse\n\t\treturn expr_out; \n\tend if;\nend proc:\n\nN1LinBaseConvert:= proc(expr, totype)\n\treturn LinBaseConvert(expr, totype, 1); \nend proc:\n\nsuperCollect:= proc(expr)\n\tif super_whattype(expr) = other then return expr; end if;\n\treturn collect_by_type(super_whattype(expr), expr); \nend proc:\n\nN1superCollect:= proc(expr)\n\treturn N1convertexpr(superCollect(N2convertexpr(expr))); \nend proc:\n##############################################################\nN1omega_monomial:= proc(expr)\n\tlocal N2expr;\n\tN2expr:= N2convertexpr(expr); \n\treturn N1convertexpr(collect_monomials(subs(alpha=1, monomial_omega_alpha(N2expr)))); \nend proc:\n\nrhoAct_one_powersum:= proc(spart)\n\tlocal the_sign;\n\tthe_sign:= (-1)^(add(k, k in Flatten(spart)) + nops(spart[4]));\n\treturn the_sign*ep[op(spart)]; \nend proc:\n\nrhoAct_expr_powersum:= proc(N1expr)\n\tlocal expr, powersums, sublist, out;\n\texpr:= N2convertexpr(N1expr); \n\tpowersums:= indets(expr, powersum_symbolic);\n\tsublist:= map(x-> x = rhoAct_one_powersum([op(x)]), powersums); \n\tout:= superCollect(subs(sublist, expr)); \n\tout:= N1convertexpr(out);\n\treturn out;\nend proc:\n\nrho_on_expr:= proc(N1expr)\n\tlocal thetype, expr_p, rho_expr_p;\n\tthetype:= super_whattype(N2convertexpr(N1expr)); \n\texpr_p:= N1LinBaseConvert(N1expr, powersum_symbolic);\n\trho_expr_p:= rhoAct_expr_powersum(expr_p);\n\treturn N1LinBaseConvert(rho_expr_p, thetype); \nend proc:\n\nomega_on_expr:= proc(N1expr)\n\tlocal thetype, expr_p, expr_m, omega_expr;\n\tthetype:= super_whattype(N2convertexpr(N1expr)); \n\texpr_m:= N1LinBaseConvert(N1expr, monomial_symbolic);\n\tomega_expr:= N1omega_monomial(expr_m);\n\treturn N1LinBaseConvert(omega_expr, thetype); \nend proc:\n\nrhoDash_on_ph:= proc(N1spart)\n\tlocal N2spart, sparts, N1sparts, monos, rho_omega_monos, theH_in_m, the_prods, Eexpand;\n\tN2spart:= [[],[],op(N1spart)];\n\tsparts:= genN2spart(op(giveSpartSector(N2spart)));\n\tN1sparts:= map(x-> [x[3],x[4]], sparts);\n\tmonos:= map(x-> m[op(x)], N1sparts);\n\trho_omega_monos:= map(x-> rho_on_expr(omega_on_expr(x)), monos); \n\ttheH_in_m:= LinBaseConvert(ph[op(N2spart)], monomial_symbolic);\n\tthe_prods:=map(x->monomial_scalar_prod(theH_in_m, N2convertexpr(x), 1), rho_omega_monos); \n\tthe_prods:= map(factor, the_prods);\n\tEexpand:= add( the_prods[k]*e[op(N1sparts[k])], k=1..nops(N1sparts)); \n\treturn Eexpand; \nend proc:\n\nrhoDash_on_ph_expr:= proc(expr_ph)\n\tlocal phs, rhoDash_phs;\n\tphs:= indets(expr_ph, ph_symbolic); \n\trhoDash_phs:= map(x->x=rhoDash_on_ph([op(x)]), phs);\n\treturn superCollect(subs(rhoDash_phs, expr_ph));\nend proc:\n\nrhoDash:= proc(expr)\n\tlocal thetype, expr_ph, rhoDashexprph;\n\tthetype:= super_whattype(expr);\n\texpr_ph:=N1LinBaseConvert(expr, ph_symbolic);\n\trhoDashexprph:= rhoDash_on_ph_expr(expr_ph);\n\treturn N1LinBaseConvert(rhoDashexprph,thetype);\nend proc:\n\nphiDash:= proc(expr)\n\treturn rhoDash(omega_on_expr(expr));\nend proc:\n\nmphiDash:= proc(expr)\n\treturn omega_on_expr(rhoDash(expr)); \nend proc:\n\ngiveOnAllBasis:= proc(expr,give_ans:=0, with_Schur:=0)\n\tlocal types, allexpr, k:\n\ttypes:= [\n\t\t\t\tpowersum_symbolic, \n\t\t\t\tmonomial_symbolic, \n\t\t\t\thomogeneous_symbolic, \n\t\t\t\telementary_symbolic, \n\t\t\t\t#schur_symbolic, \n\t\t\t\t#schurEtoile_symbolic, \n\t\t\t\t#schurbar_symbolic, \n\t\t\t\t#schurbarEtoile_symbolic, \n\t\t\t\tep_symbolic,\n\t\t\t\tph_symbolic\n\t\t\t];\n\tallexpr:= map(x-> N1LinBaseConvert(expr, x), types);\n\tfor k in allexpr do\n\t\tprint(k);\n\tend do:\n\tif give_ans = 1 then return allexpr: end if;\nend proc:\n\nboson_diff:= proc(n,one_term, basis, timesn:=1)\n\tlocal spart, zeds, num, position, newzeds;\n\tspart:= [op(one_term)];\n\tif add(k, k in Flatten(spart)) < n then return 0; end if;\n\tzeds:= spart[2];\n\tnum:= Occurrences(n, zeds);\n\tif num = 0 then return 0; end if;\n\tposition:= Search(n, zeds);\n\tnewzeds:= subsop(position = NULL, zeds);\n\treturn n*num*basis[spart[1], newzeds];\nend proc:\n\nboson_diff_expr:= proc(n, expr, basis)\n\tlocal expr_in, terms, sublist, out;\n\texpr_in:= N1superCollect(expr);\n\tterms:= indets(expr_in, superbase);\n\tsublist:= map(x-> x=boson_diff(n,x,basis), terms);\n\tout:= subs(sublist,expr_in);\n\t#out:= subs(basis[[],[]] = 1, out);\n\treturn N1superCollect(out);\nend proc:\n\nboson_diff_list_expr:= proc(the_seq, expr, basis)\n\tlocal the_expr,k;\n\tthe_expr:= expr;\n\tfor k in the_seq do\n\t\tthe_expr := N1superCollect(boson_diff_expr(k, the_expr, basis));\n\tend do:\n\treturn the_expr;\nend proc:\n\nfermion_diff:= proc(n, expr, basis)\n\tlocal spart, position, newspart, fpart;\n\tspart:=[op(expr)];\n\tfpart:= spart[1];\n\tposition:= Search(n,fpart);\n\tif position = 0 then return 0; end if;\n\tnewspart:= [subsop(position=NULL,fpart), spart[2]];\n\treturn (-1)^(position+1)*basis[op(newspart)];\nend proc:\n\nfermion_diff_expr:= proc(n, expr, basis)\n\tlocal expr_in, terms, sublist, out;\n\texpr_in:= N1superCollect(expr);\n\tterms:= indets(expr_in, superbase);\n\tsublist:= map(x-> x=fermion_diff(n,x,basis), terms);\n\tout:= subs(sublist,expr_in);\n\t#out:= subs(basis[[],[]] = 1, out);\n\treturn N1superCollect(out);\nend proc:\n\nfermion_diff_list_expr:= proc(the_seq, expr, basis)\n\tlocal the_expr,k;\n\tthe_expr:= expr;\n\tfor k in the_seq do\n\t\tthe_expr := N1superCollect(fermion_diff_expr(k, the_expr, basis));\n\tend do:\n\treturn the_expr;\nend proc:\n\none_e_dash_n:= proc(n,expr_p)\n\tlocal el_en_p, powersums, coeffp, sparts, action, result, aterm;\n\taterm:= indets(expr_p, indexed);\n\tif nops(aterm) = 0 then return 0; end if;\n\tif type(aterm[1], powersum_symbolic) = false then return 0; end if;\n\tel_en_p:= N1LinBaseConvert(e[[],[n]], powersum_symbolic);\n\tpowersums:= [op(indets(el_en_p, powersum_symbolic))];\n\tcoeffp:= map(x-> coeff(el_en_p,x), powersums);\n\tsparts:= map(x-> [op(x)], powersums);\n\taction:= map(x-> boson_diff_list_expr(x[2],expr_p,p), sparts);\n\tresult:= add( coeffp[k]*action[k], k=1..nops(coeffp)); \n\treturn N1superCollect(result);\nend proc:\none_h_dash_n:= proc(n, expr_p)\n\tlocal el_en_p, powersums, coeffp, sparts, action, result, aterm;\n\taterm:= indets(expr_p, indexed);\n\tif nops(aterm) = 0 then return 0; end if;\n\tif type(aterm[1], powersum_symbolic) = false then return 0; end if;\n\tel_en_p:= N1LinBaseConvert(h[[],[n]], powersum_symbolic);\n\tpowersums:= [op(indets(el_en_p, powersum_symbolic))];\n\tcoeffp:= map(x-> coeff(el_en_p,x), powersums);\n\tsparts:= map(x-> [op(x)], powersums);\n\taction:= map(x-> boson_diff_list_expr(x[2],expr_p,p), sparts);\n\tresult:= add( coeffp[k]*action[k], k=1..nops(coeffp)); \n\treturn N1superCollect(result);\nend proc:\n\nhdash_n:= proc(n, expr)\n\tlocal thetype, expr_p, hdashp;\n\tif n = 0 then return expr; end if; \n\tif n < 0 then return 0; end if; \n\tthetype:= super_whattype(expr);\n\texpr_p:= N1LinBaseConvert(expr, powersum_symbolic);\n\thdashp:=one_h_dash_n(n, expr_p);\n\treturn N1LinBaseConvert(hdashp, thetype);\nend proc:\n\nedash_n:= proc(n, expr)\n\tlocal thetype, expr_p, edashp;\n\tif n = 0 then return expr; end if; \n\tif n < 0 then return 0; end if; \n\tthetype:= super_whattype(expr);\n\texpr_p:= N1LinBaseConvert(expr, powersum_symbolic);\n\tedashp:=one_e_dash_n(n, expr_p);\n\treturn N1LinBaseConvert(edashp, thetype);\nend proc:\n\n## Prendre code Olivier ##\ndel_etilde_n:=proc(n, expr)\n\tlocal out;\n\tout:= N1LinBaseConvert(expr, elementary_symbolic);\n\tout:= fermion_diff_expr(n,out,e);\n\tout:= N1LinBaseConvert(out, super_whattype(expr));\n\treturn out;\nend proc:\n\nBGamma_1_n:=proc(n, expr)\n\tlocal terms, sparts, max_ell, r, thetype, out, er_expr, es_er_expr, eexpr_m, hs_m, hs_es_er_expr, s, newterm;\n#Ne respecte pas le secteur, debugger dans les boucles. OK\n\tterms:= indets(expr, superbase); \n\tthetype:= super_whattype(terms[1]);\n\tsparts:= map(x-> [op(x)], terms); \n\tmax_ell:= max(map(x-> nops(Flatten(x)), sparts));\n\tout:=0;\n\tfor r from 0 to max_ell do\n\t\tprint(\"er_expr to go on\", expr, r, \"over \", max_ell); \n\t\ter_expr:= edash_n(r, expr);\n\t\t#print(1,er_expr); \n\t\tif er_expr <> 0 then\n\t\tfor s from (n+r) to n+r+max_ell do\n\t\t\tprint(\"s-n-r\", s-n-r, er_expr);\n\t\t\tes_er_expr:= edash_n(s-n-r, er_expr);\n\t\t\tif es_er_expr = 0 then break; end if;\n\t\t\t#print(2, es_er_expr); \n\t\t\teexpr_m:= N1LinBaseConvert(es_er_expr, monomial_symbolic); \n\t\t\t#print(3, eexpr_m); \n\t\t\t#print(h[[s],[]]);\n\t\t\t#print(es_er_expr); \n\t\t\ths_m:= N1LinBaseConvert(h[[s],[]], monomial_symbolic); \n\t\t\t#print(4,hs_m); \n\t\t\ths_es_er_expr:= (-1)^(r+s)*expr_mono_prod( N2convertexpr(hs_m), N2convertexpr(eexpr_m));\n\t\t\t#print(hs_es_er_expr);\n\t\t\ths_es_er_expr:= N1convertexpr(hs_es_er_expr); \n\t\t\t#print(5, hs_es_er_expr); \n\t\t\tnewterm:= N1LinBaseConvert(hs_es_er_expr, thetype);\n\t\t\tprint(\"term just generate\",newterm);\n\t\t\tout:= newterm + out;\n\t\t\tprint(\"new result (newterm + last term)\", out);\n\t\t\t#print(6, out, \"out\"); \n\t\tend do:\n\t\tend if:\n\tend do:\n\treturn superCollect((-1)^n*out); \nend proc:\n\nFGamma_n:= proc(n, expr)\n\tlocal terms, thetype, sparts, thedeg, out, hda_rn, thee, res, r;\n\tterms:= indets(expr, superbase);\n\tif nops(terms) = 0 then \n\t\tthedeg:=0;\n\telse\n\t\tthetype:= super_whattype(terms[1]);\n\t\tsparts:= map(x-> [op(x)], terms);\n\t\tthedeg:= add(k, k in Flatten(sparts[1]));\n\tend if;\n\tout:=0;\n\tfor r from 0 to thedeg do\n\t\thda_rn:= N1LinBaseConvert(hdash_n(r, expr), monomial_symbolic);\n\t\tif hda_rn =0 then break; end if;\n\t\tthee:= N1LinBaseConvert(e[[r+n],[]], monomial_symbolic);\n\t\tres:= N1convertexpr(expr_mono_prod(N2convertexpr(thee), N2convertexpr(hda_rn)));\n\t\tout:= superCollect(out + (-1)^(r)*res); \n\tend do:\n\tout := N1LinBaseConvert(out, thetype); \n\treturn out;\nend proc:\n\n\n#### NS Macdo #####\nnsMacdo:= proc(eta)\n#Broken\n\tlocal smallercomps, preMacdo, eigenVals, YiEs, systEq, soln,N, vars, out;\n\tsmallercomps:= give_smallerComps(eta);\n\tN:= nops(eta);\n\tvars:= {seq(z||k, k=1..N)};\n\tpreMacdo:= nsMonome(eta) + add( a[x]*nsMonome(smallercomps[x]), x=1..nops(smallercomps)); \n\teigenVals:=\t\tmap(i->eigen_val_opYi(i, eta)*preMacdo, [seq(k, k=1..N)]); \n\tYiEs:=\t\t\tmap(i->opYi(i,preMacdo,N), [seq(k, k=1..N)]); \n\tsystEq:= eigenVals-YiEs;\n\tsystEq:=map(x-> Coefficients(x, vars), systEq);\n\t#systEq:= map(x-> (collect(simplify(x), [seq(z||k, k=1..N)], 'distributed')), systEq); \n\tsoln:= solve(systEq, indets(preMacdo, a_indet)); \n\tout:= subs(soln, preMacdo); \n\t#return [soln, preMacdo];\n\treturn out;\nend proc:\n\n###### Macdo ######\nstdMacdo:= proc(part)\n\tlocal nbVars, ns_mac, mac, comp;\n\tcomp:= ListTools:-Reverse(part);\n\tnbVars:= add(k, k in part); \n\tif nops(comp) < nbVars then comp:= [seq(0, k=1..(nbVars-nops(comp))), op(comp)]; end if; \n\tns_mac:= nsMacdo(comp);\n\tmac:= tSymmetrize(ns_mac, nbVars); \n\tprint(\"tSymmetrized\");\n\tmac:= z_to_m(mac); \n\tmac:= collect_monomials(mac, m[[],[],[],[op(part)]]); \n\treturn mac;\nend proc:\n\nsMacdo_NS:= proc(spart, mode:=3)\n\tlocal stdL, stL, sdL, sLs, nbVars, ell_lambda, ns_mac, mac, N, mbarbar, mbar, mubar, bigM, comp, sector, super_mono, k;\n\tstdL:= ListTools:-Reverse(spart[1]);\n\tmbarbar:= nops(stdL);\n\tstL:= ListTools:-Reverse(spart[2]);\n\tmbar:= nops(stL);\n\tsdL:= ListTools:-Reverse(spart[3]);\n\tmubar:= nops(sdL);\n\tsLs:= ListTools:-Reverse(spart[4]);\n\tbigM:= mbar+mubar+mbarbar;\n\tnbVars := max( map(x-> nops(Flatten(x)), genN2spart(op(giveSpartSector(spart))))); \n\tN:= nbVars; \n\tell_lambda:= nops(Flatten(spart));\n\tif ell_lambda < nbVars then \n\t\tcomp:= [op(stdL), op(stL), op(sdL), op(sLs), seq(0, k=1..(nbVars-ell_lambda))]; \n\telse \n\t\tcomp:= [op(stdL), op(stL), op(sdL),  op(sLs)]; \n\tend if; \n\tns_mac:= nsMacdo(comp);\n\tsector:= giveSpartSector(spart);\n\tbigM:= sector[2]+sector[3] + sector[4];\n\tmac:= tSymmetrize(ns_mac,nbVars,bigM+1,nbVars); \n\tif mubar > 1 then\n\t\tif mode <> 3 then mac:= AntiSymetrize(mac, [seq(k+mbarbar+mbar, k=1..mubar)]); end if;\n\t\tif mode = 3 then mac:= tantiSymmetrize(mac, nbVars, mbarbar+mbar+1, mbarbar+mbar+mubar); end if;\n\tend if;\n\tif mbar > 1 then\n\t\tif mode <> 3 then mac:= AntiSymetrize(mac, [seq(k+mbarbar, k=1..mbar)]);end if;\n\t\tif mode = 3 then mac:= tantiSymmetrize(mac, nbVars, mbarbar+1, mbarbar+mbar); end if;\n\tend if;\n\tif mbarbar > 1 then\n\t\tif mode = 1 then\tmac:= Var_Symmetrize(mac, [seq(k, k=1..mbarbar)]); end if;\n\t\tif mode = 3 then\tmac:= tSymmetrize(mac, mbarbar-1); print(mode, \"engaged\");  end if;\n\tend if;\n\tsuper_mono:=1;\n\tfor k from 1 to bigM do\n\t\tif k <= mbarbar then super_mono:= phi||k*theta||k*super_mono; end if;\n\t\tif k > mbarbar and k <= mbar+mbarbar then super_mono:= phi||k*super_mono; end if;\n\t\tif k > mbarbar+mbar then super_mono:= theta||k*super_mono; end if;\n\tend do:\n\tmac:= super_mono*mac;\n\t#mac:= Kw(mac, nbVars); \n\t#last_sym:= SNcheckCoxeter(mbarbar, mbar, mubar, N); \n\t#mac:= add(apply_sigma_si(mac, last_sym[k]), k=1..nops(last_sym)); \n\t#perm_mac:= map(x->apply_sigma_si(mac,x), last_sym); \n\tmac:= Kw(mac, N); \n\t#permutations:= permute(4);\n\t#permuations:= subs([1,2,4,3]=NULL, permutations); \n\t#mac:=add(k, k in map(x-> Ksigma_j(mac,x), permutations)); \n\t#mac:= add(k, k in perm_mac); \n\tmac:= z_to_m(mac); \n\tmac:= collect_monomials(mac, m[op(spart)]); \n\treturn mac;\nend proc:\n\nget_h:= proc(spart)\n\tlocal sector, sparts, sample, eq1, eqs, systeq, soln;\n\tsector:= giveSpartSector(spart);\n\tsparts:= genN2spart(op(sector)); \n\tsample:= add( a[k]*m[op(sparts[k])], k=1..nops(sparts));\n\teq1:= monomial_scalar_prod(m[op(spart)], sample, 1) - 1;\n\teqs:= map(x-> monomial_scalar_prod(sample,m[op(x)],1), subs(spart=NULL, sparts)); \n\tsysteq:= [eq1, op(eqs)]; \n\tsoln:=solve(systeq, indets(sample, a_indet));\n\treturn collect_monomials(subs(soln, sample)); \nend proc:\n\nN2m_to_h:= proc(spart)\n\tlocal sector, sparts, homos, homos_rep, lin_comb, systeq; option remember;\n\tsector:= giveSpartSector(spart); \n\tsparts:= genN2spart(op(sector)); \n\thomos:= map(x-> get_h(x), sparts); \n\thomos_rep:= add(a[k]*h[sparts[k]], k=1..nops(sparts)); \n\tlin_comb:= add(a[k]*homos[k], k=1..nops(sparts)); \n\tsysteq:= m_systeq(m[op(spart)] - lin_comb); \n\treturn subs(solve(systeq), homos_rep);\nend proc:\n\nlinN2m2h:= proc(expr)\n\tlocal monos, sublist;\n\tmonos:= indets(expr, monomial_symbolic); \n\tsublist:= map(x-> x = N2m_to_h([op(x)]), monos);\n\treturn superCollect(subs(sublist, expr)); \nend proc:\n\nexp_fns_Jack:= proc(spart::pN2spart,sym:=\"SAAS\", in_alpha:=1) \nlocal thesector, longest_spart, phis, thetas, zeds, scomposition, thensJack, superJack, pts, mbarbar, mbar, mubar;\noption remember;\n\t#Slow#\n\t#Generates the superJack N=2 using the non-symmetric Jack method (Slow)\n\tthesector:=giveSpartSector(spart);\n\tlongest_spart:=max(map(x-> nops(Flatten(x)), genN2spart(op(thesector))));\n\tpts:= spart[1];\n\tphis:= spart[2];\n\tthetas:= spart[3];\n\tzeds:= spart[4]; \n\tmbarbar:= nops(pts);\n\tmbar:= nops(phis);\n\tmubar:= nops(thetas);\n\tif sym = \"SAAS\" then\n\t\t\tscomposition:= [op(Reverse(pts)),op(Reverse(phis)), op(Reverse(thetas)), op(Reverse(zeds))]; \n\t#elif sym = \"SAAS2\" then\n\t\t\t#scomposition:= [op(Reverse(pts)), op(Reverse(thetas)),op(Reverse(phis)), op(Reverse(zeds))]; \n\telif sym = \"AASS\" then\n\t\t\tscomposition:= [op(Reverse(phis)), op(Reverse(thetas)),op(Reverse(pts)), op(Reverse(zeds))]; \n\tend if;\n\t#scomposition:= [op(pts),op(phis), op(thetas), op(zeds)]; \n\tif longest_spart > nops(scomposition) then\n\t\tscomposition:= [op(scomposition), seq(0, k=1..(longest_spart -nops(scomposition)))];\n\tend if;\n\tthensJack:= nsJack(scomposition);\n\t#thensJack:= Var_Symmetrize(thensJack, [seq(k, k=1..mbarbar)]);\n\t#thensJack:= AntiSymetrize(thensJack, [ seq(k+mbarbar, k=1..mbar)]);\n\t#thensJack:= AntiSymetrize(thensJack, [ seq(k+mbarbar + mbar, k=1..mubar) ]);\n\tif sym = \"SAAS\" then\n\t\tthensJack:= mul(phi||k*theta||k, k=1..mbarbar)*mul(phi||(k+mbarbar), k=1..mbar)*mul(theta||(k+mbarbar+mbar), k=1..mubar)*thensJack;\n\telif sym = \"AASS\" then\n\t\tthensJack:= mul(phi||(k), k=1..mbar)*mul(theta||(k+mbar), k=1..mubar)*mul(phi||(k+mbar+mubar)*theta||(k+mbar+mubar), k=1..mbarbar)*thensJack;\n\tend if;\n\n\tsuperJack:= Kw(thensJack, longest_spart); \n\tif in_alpha <> 0 then superJack:= subs(beta=1/alpha, superJack); end if;\n\tsuperJack:= collect_monomials(z_to_m(superJack), m[op(spart)]); \n\treturn superJack; \nend proc:\n\ncheck_norms:= proc(sector, mode)\n\tlocal Jacks, sparts, norms, calc, rel;\n\tJacks:= sJack_sector(op(sector), mode); \n\tsparts:= map(x-> give_greatest_monomial(x, mode), Jacks);\n\tsparts:= map(x-> [op(x)], sparts); \n\tnorms:= map(x-> monomial_scalar_prod(x,x), Jacks); \n\tcalc:= map(x-> Jack_norm(x, mode), sparts); \n\trel := zip((x,y)-> factor(x/y), norms, calc); \n\treturn rel; \nend proc:\n\ncheck_specialize:= proc(sector, VARS:=0)\n\tlocal sparts, nb_var, Jacks,specs, calc, rati, spart_rati;\n\tJacks:= sJack_sector(op(sector)); \n\tif VARS <> 0 then\n\t\tJacks:= map(x-> if nops(Flatten([op(give_greatest_monomial(x))])) > VARS then NULL; else x; end if, Jacks); \n\tend if;\n\tsparts:= map(x-> [op(give_greatest_monomial(x))], Jacks);\n\tif VARS=0 then\n\t\tnb_var:= map(x-> nops(Flatten(x)), sparts);\n\t\tnb_var:= max(nb_var); \n\telse\n\t\tnb_var:=VARS;\n\tend if;\n\tcalc:= map(x-> calc_specialize_E(x, nb_var), sparts); \n\tspecs:= map(x-> specialize_E(x, nb_var), Jacks);\n\trati:= zip((x,y)-> factor(x/y), specs, calc); \n\tspart_rati:= zip((x,y)-> [x,y], sparts, rati); \n\treturn spart_rati; \nend proc:\n\ncalc_specialize_E:= proc(spart, nb_var, mode:=[1,2,3])\n\tlocal sector, mbar, mubar, minimal_triangle, trig_part, delta, quatuor, M3, spart3, sp3_indices, DeltaSpart_ind, num_terms, var_co, the_num, the_denom, mbarbar, plus_factor, pairs, sparts, new_pol;\n\tsector:= giveSpartSector(spart); \n\tquatuor := star_quatuor(spart, mode);\n\tM3:= spart_sector[2] + spart_sector[3] + spart_sector[4]; \n\tspart3:= quatuor[4];\n\t##\n\tmbar:=\tsector[2];\n\tmubar:= sector[3];\n\tmbarbar:= sector[4];\n\t##\n\tminimal_triangle:= [seq(k, k=1..mbar), seq(l, l=1..mubar)]; \n\ttrig_part:= sort(minimal_triangle, `>`); \n\t#lnmm:= sector[1] - add(k, k in trig_part); \n\tdelta:= [seq(seq([i,j], j=1..trig_part[i]), i=1..nops(trig_part ))]; \n\t###\n\tsp3_indices:= [seq(seq([i,j], j=1..spart3[i]), i=1..nops(spart3))];\n\tDeltaSpart_ind:= map(x-> if x in delta then NULL; else x; end if, sp3_indices); \n\tnum_terms:= map(x-> nb_var - co_leg_part(op(x), spart3) + alpha*co_arm_part(op(x), spart3), DeltaSpart_ind); \n\tplus_factor:= binomial(nb_var-mbar-mubar, mbarbar); \n\tthe_num:= mul(x, x in num_terms); \n\tthe_denom:= plus_factor*down_hook(spart, mode); \n\tprint(\"factor\", plus_factor); \n\treturn factor(the_num/the_denom); \nend proc:\n\nspecialize_E:= proc(pol, nb_var)\n\tlocal sector, mbarbar, mbar, mubar, seqbar, ijbar, sequbar, ijubar, ij, vandermonde, pol_in_z, Dpol_in_z, k, pre_spec, sublist, result, new_pol, sparts, pairs;\n\t#Tester l'\u00e9valuation\n\t#Voir si ca marche avec la formule ... \n\t#Arranger pour que ca marche avec les differentes facons de symmetriser\n\tsector:= givePolySector(pol); \n\tmbarbar:= sector[4];\n\tmbar:=\tsector[2];\n\tmubar:= sector[3];\n\t#Possible problem with the fact the M_i changes from a symmetrization to the other... \n\t#I expect only a sign difference, so I won't code it at first. \n\tseqbar:= [seq(k, k=(mbarbar+1)..(mbarbar+mbar))];\n\tpairs:= choose(seqbar, 2); \n\tijbar:= map(x-> if x[1]<x[2] then x; else NULL; end if, pairs); \n\t#ijbar:= map(i-> map(j-> if i < j then [i,j]; else NULL; end if, seqbar ), seqbar); \n\tsequbar:= [seq(k, k=(mbarbar+mbar+1)..(mbarbar+mubar+mbar))];\n\tpairs:= choose(sequbar, 2); \n\tijubar:= map(x-> if x[1]<x[2] then x; else NULL; end if, pairs); \n\tij:= [op(ijbar), op(ijubar)]; \n\tij:= map(x-> if x <> [] then x; else NULL; end if, ij); \n\tvandermonde := map(x->z||(x[1]) - z||(x[2]),ij);\n\tvandermonde := mul(x, x in vandermonde); \n\t## maping to 0 monomials that requires too many variables\n\tsparts:= genN2spart(op(sector));\n\tsublist:= map(x->if nops(Flatten(x))>nb_var then m[op(x)] = 0; else NULL; end if, sparts); \n\tnew_pol:= subs(sublist, pol); \n\t#####\n\tpol_in_z:= m2n_expr(new_pol, nb_var);\n\tDpol_in_z:= pol_in_z;\n\tfor k in Reverse(sequbar) do\n\t\tDpol_in_z := diff(Dpol_in_z, theta||k);\n\tend do:\n\tfor k in Reverse(seqbar) do\n\t\tDpol_in_z := diff(Dpol_in_z, phi||k);\n\tend do:\n\tfor k from 1 to mbarbar do\n\t\tDpol_in_z := diff(diff(Dpol_in_z, theta||k), phi||k); \n\tend do:\n\tpre_spec := simplify(Dpol_in_z/vandermonde);\n\t#print(pre_spec); \n\t#return(vandermonde); \n\tsublist:= {seq(z||k = 1, k=1..nb_var)};\n\tresult:= subs(sublist, pre_spec); \n\tresult:= factor(result); \n\treturn result;\nend proc:\n\n\nm2n_expr:= proc(expr, nbvar)\n\tlocal monos, monos_z, expr_out;\n\tmonos:= indets(expr, monomial_symbolic); \n\tmonos_z := map(x-> x = m_in_z([op(x)], nbvar), monos); \n\texpr_out:= subs(monos_z, expr); \n\treturn expr_out;\nend proc:\n\nN2omega_alpha_p_lambda:= proc(p_Lambda::powersum_symbolic)\n\tlocal Lambda, out, enn, ell;\n\tLambda := [op(p_Lambda)];\n\tenn:= add(k, k in Flatten(Lambda)); \n\tell:= add(k, k in map(x-> nops(Lambda[x]), [1,2,3,4])); \n\tout:= p_Lambda = (alpha)^(ell)*(-1)^(enn -nops(Lambda[4]))*p_Lambda;\n\treturn out;\nend proc:\n\nN2omega_alpha_p_expr:= proc(expr_p)\n\tlocal powersums, sublist;\n\tpowersums:= indets(expr_p, powersum_symbolic); \n\tsublist:= map(x-> N2omega_alpha_p_lambda(x), powersums);\n\treturn subs(sublist, expr_p); \nend proc:\n\nN2omega_m:= proc(expr_m)\n\tlocal expr_p, wexpr_p, wexpr_m;\n\texpr_p := LinBaseConvert(expr_m, powersum_symbolic); \n\twexpr_p:= N2omega_alpha_p_expr(expr_p); \n\twexpr_m:= LinBaseConvert(wexpr_p, monomial_symbolic); \n\treturn collect_monomials(wexpr_m); \nend proc:\n\nm_expr_to_jacks:= proc(expr_m)\n\tlocal sector, jacks_m, jacks_P, eq, soln, all_jacks, expr_P;\n\tsector:= givePolySector(expr_m);\n\tjacks_m:= sJack_sector(op(sector));\n\tjacks_P:= map(x->P[op(give_greatest_monomial(x))], jacks_m);\n\texpr_P := add(a[k]*jacks_P[k], k=1..nops(jacks_P)); \n\tall_jacks:= add(a[k]*jacks_m[k], k in [seq(l, l=1..nops(jacks_m))]);\n\teq:= collect_monomials(expr_m - all_jacks); \n\tsoln:= solve_monomialeq(eq); \n\treturn superCollect(subs(soln, expr_P)); \nend proc:\n", "meta": {"hexsha": "0a6a9f0d20f3a75c2cb152d5b0d9033f2cf13e31", "size": 79783, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/basis.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/basis.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/basis.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": 37.9016627078, "max_line_length": 232, "alphanum_fraction": 0.6937066794, "num_tokens": 27070, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7217431943271999, "lm_q2_score": 0.6654105521116443, "lm_q1q2_score": 0.4802555374200839}}
{"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\u00e4ngigkeit der gemessenen Winkel der Haupt-Armkinematik\n# Zu Geometrie und Winkeln, siehe Bild (Unterlagen)\n# \n# Modell m3: Kurbel N7 ist starr mit K\u00f6rper K2 gekoppelt (\u00fcber die Achse)\n# \n# Berechne alle notwendigen Winkel in kintmp in Abh\u00e4ngigkeit konstanter Gr\u00f6\u00dfen und der verallgemeinerten Koordinaten\n# \n# Berechne zuerst nur Sinus und Cosinus jedes Winkels. Diese werden f\u00fcr die Rotationsmatrizen ben\u00f6tigt.\n# Die Berechnung der Winkel selbst (zur Kontrolle) ben\u00f6tigt die arctan-Funktion, die l\u00e4ngere Ausdr\u00fccke nur sehr langsam auswertet.\n# Daher werden zun\u00e4chst alle Winkel mit %arctan (inert-Funktion berechnet) und am Ende erst ausgewertet.\n# Die Zeitableitung der Winkel (in sp\u00e4teren Skripten) wird aus der inert-Funktion berechnet.\n# \n# Hinweise:\n# Der Befehl arctan hat die Funktionalit\u00e4t von atan2\n# \n# Eingabe:\n# \"../codeexport/KAS5m3_definitions\"\n# * enth\u00e4lt die Definitionen aller Konstanten und verallgemeinerter Koordinaten\n# \n# Ausgabe:\n# \"../codeexport/%s/tmp/kinematic_constraints_maple_inert.m\"\n# * Erzeugt die Ausdr\u00fccke f\u00fcr Winkel der Parallelstruktur (kintmp), Ersetzungsausdr\u00fccke f\u00fcr sin,cos (kintmp_subsexp) und die Federl\u00e4nge (lpar) in Abh\u00e4ngigkeit der verallgemeinerten Koordinaten.\n# Quellen\n# [1] Wang, Jiegao and Gosselin, Cl\u00e9mentM.: 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\u00fcr Speicherung\n;\nwith(StringTools): # F\u00fcr 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\u00fcr Nicht-Inert-Ausdr\u00fccke\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\u00e4nkt 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\u00e4ngigkeit 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\u00fcr die Hilfswinkel\ngamma5_s := kintmp_s(5,1):\ndelta_s := kintmp_s(6..23,1):\ndelta_qs := kintmp_qs(6..23,1):\n# Ersetzungsausdr\u00fccke 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\u00fccke in der direkten Kinematik reduziert.\n# \u00c4hnliches 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\u00e4ter 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 \u00fcber Konstanten: L\u00e4ngen sind alle Positiv.\n# (Wird anscheinend f\u00fcr 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\u00fcr die Code-Generierung.\n# W\u00e4hle, ob trigonometrische arctan-Ausdr\u00fccke ausgewertet werden, oder ob Sinus- und Cosinussatz angewendet werden sollen.\n# Dies hat gro\u00dfen Einfluss auf die Rechendauer.\n# Die Optimierungen sind so gew\u00e4hlt, dass\n# * Kreisschnittpunktsfunktionen nicht mit den komplizierten Eingabedaten aufgerufen, sondern mit allgemeinen Platzhaltern, die dann ersetzt werden,\n# * Keine Zwischenoptimierungen durchgef\u00fchrt werden. Durch simplify und combine werden die symbolischen Ausdr\u00fccke gr\u00f6\u00dfer, was sp\u00e4ter die Rechenzeit enorm erh\u00f6ht\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\u00fcckt 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\u00fcckt 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\u00fcr Hebel E-F-G3\n# Zweiter Kreismittelpunkt f\u00fcr 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\u00e4ngigen Winkel delta16 auf (ohne Ersetzung mit delta16(q), da dort arctan vorkommt.\n# Ersetze sin(delta16), cos(delta16) mit Ausdr\u00fccken von oben. Bei arctan(sin(...)) entstehen kompliziertere Ausdr\u00fccke\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\u00fchrt zu einer wesentlichen Verringerungen der Rechenzeit, da das Einsetzen und Weiterrechnen der komplizierten Ausdr\u00fccke in der Unterfunktion entf\u00e4llt.\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\u00e4ngigem Ausdruck f\u00fcr 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\u00e4nge AB entspricht Federl\u00e4nge\n;\nlpar_qs := l16_c:\nprintf(\"Kompensationsfederl\u00e4nge 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\u00fccken 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\u00fcr 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\u00fccke f\u00fcr 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\u00e4ndigen 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\u00fccke 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\u00e4ngigen konstanten Kinematikparametern erstellen (wichtig f\u00fcr 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 \n`eta/trees` := (A::set) -> `if`(nops(A)=1,{A},FAIL);\n\n`gamma/trees` := (A::set,B::set) -> (p) -> proc(UU,TT)\n local F,U,V,VV,b;\n\n F := fibres(A,B)(p);\n\n VV := NULL;\n for U in UU do\n  V := `union`(seq(F[b],b in U));\n  if V <> {} then VV := VV,V; fi;\n od;\n\n for b in B do \n  VV := VV,op(TT[b]);\n od;\n\n VV := sort(map(sort,{VV}));\n\n return VV;\nend;\n", "meta": {"hexsha": "526c7d4b926643b19cc9637958aa1b450e309277", "size": 419, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/operads/trees.mpl", "max_stars_repo_name": "NeilStrickland/maple_lib", "max_stars_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/operads/trees.mpl", "max_issues_repo_name": "NeilStrickland/maple_lib", "max_issues_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/operads/trees.mpl", "max_forks_repo_name": "NeilStrickland/maple_lib", "max_forks_repo_head_hexsha": "afdc262a183c56959a7c013e38a166824f7fc3d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 17.4583333333, "max_line_length": 70, "alphanum_fraction": 0.3961813842, "num_tokens": 148, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7185943805178139, "lm_q2_score": 0.6654105653819835, "lm_q1q2_score": 0.47816029302067475}}
{"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\u00fcr allgemeinen Roboter\n# para -> Berechnung f\u00fcr 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\u00fcr Mechatronische Systeme, Universit\u00e4t Hannover\n# Sources\n# [Abdellatif2007] Modellierung, Identifikation und robuste Regelung von Robotern mit parallelkinematischen Strukturen\n# Initialization\ninterface(warnlevel=0): # Unterdr\u00fccke die folgende Warnung.\nrestart: # Gibt eine Warnung, wenn \u00fcber Terminal-Maple mit read gestartet wird.\ninterface(warnlevel=3):\nwith(LinearAlgebra):\nwith(codegen):\nwith(CodeGeneration):\nwith(StringTools):\nwith(VectorCalculus):\n# Einstellungen f\u00fcr Code-Export: Optimierungsgrad (2=h\u00f6chster) 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\u00fcr 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\u00e4ngigen Koordinaten in der H-Matrix mit zeitunabh\u00e4ngigen 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\u00fcr 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\u00fchrt. 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 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: work_mgga_x *)\n(* prefix:\n  mgga_x_m05_params *params;\n\n  assert(pt->params != NULL);\n  params = (mgga_x_m05_params * )(pt->params);\n*)\n\n$define gga_x_pbe_params\n$include \"gga_x_pbe.mpl\"\n\nf := (rs, x, t, u) ->\n  + params_a_csi_HF*f_pbe(x)*mgga_series_w(params_a_a, 12, t):\n", "meta": {"hexsha": "51ca898ad459e1098dde55469bb6b53e51783c8e", "size": 521, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "libxc-4.2.3/maple/hyb_mgga_x_m05.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/hyb_mgga_x_m05.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/hyb_mgga_x_m05.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": 23.6818181818, "max_line_length": 68, "alphanum_fraction": 0.6833013436, "num_tokens": 174, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8056321889812553, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.4774712902570752}}
{"text": "var $nan_f32 <f32> = nanf\nvar $nan_f64 <f64> = nan\nvar $inf_f32 <f32> = -inff\nvar $inf_f64 <f64> = inf\nvar $g_f32 <f32> = -1.2f\nvar $g_f64 <f64> = 1.2\nfunc $add_f32 () f32 {\n  return (\n    add f32(dread f32 $g_f32, constval f32 inff))}\nfunc $add_f64 () f64 {\n  return (\n    add f64(dread f64 $g_f64, constval f64 -inf))}\n # EXEC: %irbuild Main.mpl\n # EXEC: %irbuild Main.irb.mpl\n # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl\n", "meta": {"hexsha": "d476e46c4586f3ba3a39abfb9bae814690b0fe04", "size": 423, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "test/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/Main.mpl", "max_stars_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_stars_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_stars_repo_licenses": ["MulanPSL-1.0"], "max_stars_count": 796, "max_stars_repo_stars_event_min_datetime": "2019-08-30T16:20:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-25T14:45:06.000Z", "max_issues_repo_path": "test/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/Main.mpl", "max_issues_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_issues_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_issues_repo_licenses": ["MulanPSL-1.0"], "max_issues_count": 16, "max_issues_repo_issues_event_min_datetime": "2019-08-30T18:04:08.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-19T05:02:58.000Z", "max_forks_repo_path": "test/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/Main.mpl", "max_forks_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_forks_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_forks_repo_licenses": ["MulanPSL-1.0"], "max_forks_count": 326, "max_forks_repo_forks_event_min_datetime": "2019-08-30T16:11:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-26T12:31:17.000Z", "avg_line_length": 26.4375, "max_line_length": 50, "alphanum_fraction": 0.6359338061, "num_tokens": 186, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6859494550081925, "lm_q2_score": 0.6959583250334526, "lm_q1q2_score": 0.47739223376511125}}
{"text": "\n# Inverse Dynamics for Robot based on MDH frames\n# Einleitung\n# Berechnung der inversen Dynamik\n# \n# Dateiname:\n# robot -> Berechnung f\u00fcr allgemeinen Roboter\n# tree -> Berechnung f\u00fcr eine beliebige Baumstruktur (ohne Schleifen)\n# floatb -> floating base wird durch base twist (Geschwindigkeit der Basis) oder vollst\u00e4ndige Orientierung (Euler-Winkel) ber\u00fccksichtigt\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\u00fccke die folgende Warnung.\nrestart: # Gibt eine Warnung, wenn \u00fcber Terminal-Maple mit read gestartet wird.\ninterface(warnlevel=3):\nwith(LinearAlgebra):\nwith(ArrayTools):\nwith(codegen):\nwith(CodeGeneration):\nwith(StringTools):\n# Einstellungen f\u00fcr Code-Export: Optimierungsgrad (2=h\u00f6chster) 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\u00e4tzen der Komplexit\u00e4t\n;\n# Einstellungen f\u00fcr Term-Vereinfachungen: 0=keine, 1=Massenmatrix, 2=Coriolis-Matrix, 3=Massenmatrix-Zeitableitung, Coriolis-Vektor, Invers-Dynamik\n# Motivation: Massenmatrix ist Voraussetzung f\u00fcr andere symbolische Berechnungen (lohnt sich damit mehr)\n# Coriolis-Matrix l\u00e4sst sich besser vereinfachen, da viele Eintr\u00e4ge 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\u00e4\u00dfig aus\n  else # mit kinematischen Zwangsbedingungen\n    # pauschale Annahme f\u00fcr kinematische Zwangsbedingungen.\n    use_simplify := 1: # nur Massenmatrix\n  end if:\nelse # Benutzer-Einstellungen:\n use_simplify := simplify_options(9): # neunter Eintrag ist f\u00fcr Dynamik\nend if:\n\n# Kennung des Parametersatzes, f\u00fcr 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\u00fcr %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\u00fcr floatb_twist, da das Moment durch diese Wahl der verallgemeinerten Koordinaten (floatb_twist) nicht berechnet werden kann!)\n# Ist korrekt f\u00fcr floatb_eulxyz.\n# Die Berechnungen werden deshalb nicht f\u00fcr floatb_twist durchgef\u00fchrt.\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\u00e4nge: %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\u00e4nge: %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\u00e4nge: %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\u00e4nge: %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\u00e4ndigen 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\u00fccke 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\u00e4ngige 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\u00e4nge: %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\u00e4nge: %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\u00e4nge: %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\u00e4nge: %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\u00e4ngt sich maple durch einen Bug auf. TODO: Kl\u00e4ren.\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\u00e4nge: %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\u00e4nge: %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\u00e4nge: %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\u00e4nge: %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\u00e4nge: %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\u00e4nge: %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\u00fcr 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": "export Shape := module ()\n    export toConstraints := proc(sh_ :: DomShape, $)\n           ::specfunc({boolean,relation,specfunc(`Or`)}, `And`);\n        local sh := sh_;\n        if sh :: specfunc(`DConstrain`) then\n            And( op(sh) );\n        elif sh :: specfunc(`DSum`) then\n            sh := Or(op(map(toConstraints, sh)));\n            Domain:-simpl_relation(sh, norty='CNF');\n        elif sh :: specfunc(`DInto`) then\n            toConstraints(op(3, sh));\n        else\n            error \"don't know how to convert to constraints %1\", sh\n        end if;\n    end proc;\nend module;\n", "meta": {"hexsha": "89334fac8797b9dd0f546eea679d18e5d88db4a3", "size": 588, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "maple/Domain/Shape.mpl", "max_stars_repo_name": "zaxtax/hakaru", "max_stars_repo_head_hexsha": "03ac5b645815e99437e28d228e6c668753b2640e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2015-02-07T17:57:04.000Z", "max_stars_repo_stars_event_max_datetime": "2016-01-29T19:40:24.000Z", "max_issues_repo_path": "maple/Domain/Shape.mpl", "max_issues_repo_name": "zaxtax/hakaru", "max_issues_repo_head_hexsha": "03ac5b645815e99437e28d228e6c668753b2640e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "maple/Domain/Shape.mpl", "max_forks_repo_name": "zaxtax/hakaru", "max_forks_repo_head_hexsha": "03ac5b645815e99437e28d228e6c668753b2640e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.5882352941, "max_line_length": 67, "alphanum_fraction": 0.5323129252, "num_tokens": 152, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.7606506526772883, "lm_q2_score": 0.6261241772283034, "lm_q1q2_score": 0.47626176406573906}}
{"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\u00fcr allgemeinen Roboter\n# para -> Berechnung f\u00fcr 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\u00fcr Mechatronische Systeme, Universit\u00e4t 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\u00fccke die folgende Warnung.\nrestart: # Gibt eine Warnung, wenn \u00fcber 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\u00fcr Code-Export: Optimierungsgrad (2=h\u00f6chster) 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\u00fcr 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\u00fcr 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\u00f6schung des Roboternamens.\nend if:\nP_i := P_i: # nur diese Variable wird ben\u00f6tigt. Alle anderen zur \u00dcbersichtlichkeit l\u00f6schen. Enth\u00e4lt 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\u00e4ngigen Koordinaten in der H-Matrix mit zeitunabh\u00e4ngigen 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\u00fccke 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\u00fccke 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\u00b2+cos\u00b2 vor.\n# Im r\u00e4umlichen 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\u00b2+cos\u00b2 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": "\n# Kinematic constraints for Cloos QRC 350\n# Description\n# The robot has a coupling at the hand axes. This worksheet is necessary to fit this into the dynamics toolbox.\n# The constraints can also be declared solely in the robot_env. This however leads to some functions not working as expected\n# Sources\n# [Diekmeyer2018_S678] Diekmeyer, Jonas: Identifikation der inversen Dynamik eines seriellen Roboters im geschlossenen Regelkreis; Studienarbeit; Leibniz Universit\u00e4t Hannover\n# \n# Author\n# Moritz Schappler, moritz.schappler@imes.uni-hannover.de, 2020-06\n# (C) Institut f\u00fcr Mechatronische Systeme, Leibniz Universit\u00e4t Hannover\n# Initialisierung\ninterface(warnlevel=0): # Unterdr\u00fccke die folgende Warnung.\nrestart: # Gibt eine Warnung, wenn \u00fcber Terminal-Maple mit read gestartet wird.\ninterface(warnlevel=3):\nkin_constraints_exist := true: # F\u00fcr Speicherung\n;\nwith(StringTools): # F\u00fcr Zeitausgabe\nwith(LinearAlgebra):\nwith(codegen):\nwith(CodeGeneration):\ncodegen_act := true:\ncodegen_opt := 2: # Hoher Optimierungsgrad.\n;\nread \"../helper/proc_MatlabExport\":\nread \"../helper/proc_convert_s_t\":\nread \"../helper/proc_convert_t_s\":\nwith(RealDomain): # Schr\u00e4nkt 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 Zwangsbedingungen nur in Abh\u00e4ngigkeit der verallgemeinerten Koordinaten\nkintmp_qs := Matrix(RowDimension(kintmp_s),1):\nkintmp_qt := Matrix(RowDimension(kintmp_s),1):\n# Ersetzungsausdr\u00fccke definieren.\n# Variable zum speichern des Sinus und Cosinus der Winkel. F\u00fcr dieses System ist das eigentlich nicht notwendig. Erstelle Variable, da sie von den anderen Skripten erwartet wird\nkintmp_subsexp := Matrix(2*RowDimension(kintmp_s),2):\n# Kinematic Constraints\n# First axis is defined in negative direction\nrho1_qt := -qJ_t(1,1):\n# Hand axes 5 and 6 have a coupling via differential gear.\n# [Diekmeyer2018_S678], p. 24\nrho6_qt := qJ_t(6,1) - kDG*qJ_t(5,1):\nkintmp_qt(1,1) := rho1_qt:\nkintmp_qt(2,1) := rho6_qt:\n# Nachverarbeitung\n# Umrechnung in Substitutionsvariablen\nkintmp_qs := convert_t_s(kintmp_qt):\n# Exportiere Code f\u00fcr folgende Skripte\n# Speichere Maple-Ausdruck (Eingabe-Format und internes Format)\nsave kintmp_qs, kintmp_qt, kin_constraints_exist, kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_inert\", robot_name):\nsave kintmp_qs, kintmp_qt, kin_constraints_exist, kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_inert.m\", robot_name):\n# Liste mit abh\u00e4ngigen konstanten Kinematikparametern erstellen (wichtig f\u00fcr Matlab-Funktionsgenerierung)\nread \"../helper/proc_list_constant_expressions\";\nkc_symbols := Matrix(list_constant_expressions( kintmp_qs )):\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):\n\n", "meta": {"hexsha": "53ce6df39b7a52978d24fdb17c4765a7d9eff0c1", "size": 3072, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "robot_model/codegen_reference/CloosQRC350DE_kinematic_constraints.mpl", "max_stars_repo_name": "SchapplM/robotics-paper_icma2020", "max_stars_repo_head_hexsha": "f81c6599ec7a9341e6a467a4ff9b31091aa50e75", "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": "robot_model/codegen_reference/CloosQRC350DE_kinematic_constraints.mpl", "max_issues_repo_name": "SchapplM/robotics-paper_icma2020", "max_issues_repo_head_hexsha": "f81c6599ec7a9341e6a467a4ff9b31091aa50e75", "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_model/codegen_reference/CloosQRC350DE_kinematic_constraints.mpl", "max_forks_repo_name": "SchapplM/robotics-paper_icma2020", "max_forks_repo_head_hexsha": "f81c6599ec7a9341e6a467a4ff9b31091aa50e75", "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.0677966102, "max_line_length": 177, "alphanum_fraction": 0.7998046875, "num_tokens": 876, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7634837635542924, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.47523759284547973}}
{"text": "# float a[10];\n# void init(void) {\n#   int i;\n#   for (i=0; i<10; i++)\n#     a[i] = i*3;\n# }\n\nvar $a <[10] f32>\nvar $f1 f32\nfunc $init () void {\n  var %i i32\n  dassign %i ( constval i32 0 )\n  while (\n    lt i32 i32 ( dread i32 %i, constval i32 10) ) {\n      iassign <* [10] f32> (\n        array 1 a32 <* [10] f32> (addrof a32 $a, dread i32 %i),\n\t      mul f32 (dread f32 $f1, constval f32 3.33f) ) \n      dassign %i (\n        add i32 (dread i32 %i, constval i32 1) )} }\n # EXEC: %irbuild Main.mpl\n # EXEC: %irbuild Main.irb.mpl\n # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl\n", "meta": {"hexsha": "3b8711cb5f6b2307bf4a3e30da208114bc67be4a", "size": 572, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "test/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/Main.mpl", "max_stars_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_stars_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_stars_repo_licenses": ["MulanPSL-1.0"], "max_stars_count": 796, "max_stars_repo_stars_event_min_datetime": "2019-08-30T16:20:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-25T14:45:06.000Z", "max_issues_repo_path": "test/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/Main.mpl", "max_issues_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_issues_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_issues_repo_licenses": ["MulanPSL-1.0"], "max_issues_count": 16, "max_issues_repo_issues_event_min_datetime": "2019-08-30T18:04:08.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-19T05:02:58.000Z", "max_forks_repo_path": "test/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/Main.mpl", "max_forks_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_forks_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_forks_repo_licenses": ["MulanPSL-1.0"], "max_forks_count": 326, "max_forks_repo_forks_event_min_datetime": "2019-08-30T16:11:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-26T12:31:17.000Z", "avg_line_length": 24.8695652174, "max_line_length": 63, "alphanum_fraction": 0.5384615385, "num_tokens": 243, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.689305616785446, "lm_q2_score": 0.6893056040203135, "lm_q1q2_score": 0.47514222453288657}}
{"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": " func $foo1 (\n  var %i i32, var %j i32\n  ) i32 { \n   return (\n     add i32(dread i32 %i, dread i32 %j))}\n\n func $addi32I (\n  var %i i32\n  ) i32 { \n   return (\n     add i32(dread i32 %i,\n#constval i32 0xfff))}\n#       constval i32 0xffff))}\n       constval i32 0xfffff))}\n # EXEC: %irbuild Main.mpl\n # EXEC: %irbuild Main.irb.mpl\n # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl\n", "meta": {"hexsha": "4164e27feb5fcfc12b594bec646e87429eb9e62b", "size": 373, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "test/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/Main.mpl", "max_stars_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_stars_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_stars_repo_licenses": ["MulanPSL-1.0"], "max_stars_count": 796, "max_stars_repo_stars_event_min_datetime": "2019-08-30T16:20:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-25T14:45:06.000Z", "max_issues_repo_path": "test/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/Main.mpl", "max_issues_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_issues_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_issues_repo_licenses": ["MulanPSL-1.0"], "max_issues_count": 16, "max_issues_repo_issues_event_min_datetime": "2019-08-30T18:04:08.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-19T05:02:58.000Z", "max_forks_repo_path": "test/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/Main.mpl", "max_forks_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_forks_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_forks_repo_licenses": ["MulanPSL-1.0"], "max_forks_count": 326, "max_forks_repo_forks_event_min_datetime": "2019-08-30T16:11:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-26T12:31:17.000Z", "avg_line_length": 20.7222222222, "max_line_length": 43, "alphanum_fraction": 0.581769437, "num_tokens": 148, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7122321964553657, "lm_q2_score": 0.665410558746814, "lm_q1q2_score": 0.4739268238008355}}
{"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\u00fcr allgemeinen Roboter\n# chain -> Berechnung f\u00fcr 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\u00fccke ohne eine \"twist\"-Basis-Berechnung \u00fcbernommen.\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\u00f6glich 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\u00fccke die folgende Warnung.\nrestart: # Gibt eine Warnung, wenn \u00fcber Terminal-Maple mit read gestartet wird.\ninterface(warnlevel=3):\nwith(LinearAlgebra):\nwith(ArrayTools):\nwith(codegen):\nwith(CodeGeneration):\nwith(StringTools):\n# Einstellungen f\u00fcr Code-Export: Optimierungsgrad (2=h\u00f6chster) 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\u00e4tzen der Komplexit\u00e4t\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\u00e4\u00dfig aus\n  else # mit kinematischen Zwangsbedingungen\n    use_simplify := 1: # standardm\u00e4\u00dfig simplify-Befehle anwenden\n  end if:\nelse # Benutzer-Einstellungen:\n  use_simplify := simplify_options(10): # zehnter Eintrag ist f\u00fcr Dynamik-Regressor\nend if:\n# Mit diesem Arbeitsblatt werden die Regressor-Ausdr\u00fccke f\u00fcr 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\u00fcr 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\u00f6glich, 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\u00f6schung 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\u00fcr %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\u00fcr %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\u00fcr 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\u00fcr %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\u00fcr 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\u00e4nge: %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\u00fccksichtigt\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\u00e4ndige Massenmatrix\n# Generiere die Massenmatrix erst f\u00fcr Floating-Base-Komplettsystem, dann entnehme die Teilmatrizen f\u00fcr Gelenk-Gelenk, Gelenk-Basis zum separaten Export\nParamvec_size := ColumnDimension(t_ges):\n# Berechnung vollst\u00e4ndige 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\u00e4nge: %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\u00e4nge: %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\u00fcr zeilenweise ausgew\u00e4hlten 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 \u00fcber alle Massenmatrix-Elemente durch und entnehme die passenden Elemente f\u00fcr 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\u00fcr zeilenweise ausgew\u00e4hlten 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 \u00fcber alle Massenmatrix-Elemente durch und entnehme die passenden Elemente f\u00fcr 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\u00fcr zeilenweise ausgew\u00e4hlten 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\u00e4ngige 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\u00fcr 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\u00fcr 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\u00e4ndige 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\u00fcr 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\u00fcr Parameter k generieren (f\u00fcr Funktion mit Christoffel-Symbol-Ansatz ben\u00f6tigt)\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\u00e4nge: %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\u00e4nge: %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\u00fcr die Gelenkterme (ohne Basiseinfluss) zust\u00e4ndig 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\u00fcr zeilenweise ausgew\u00e4hltes 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\u00e4ge herausfinden und nicht weiter ber\u00fccksichtigen.\n# Dadurch wird die obere rechte Dreiecksform der Regressor-Matrix ausgenutzt.\n# Platzhalter-Vektor f\u00fcr alle Eintr\u00e4ge der Regressor-Matrix\nReg_Vector := Matrix(ColumnDimension(tau_regressor_s)*RowDimension(tau_regressor_s), 1):\n# Gelenkmoment in Abh\u00e4ngigkeit des Regressor-Vektors (RV)\ntauJ_RV := Matrix(NQJ, 1):\nkk := 0: # Z\u00e4hler f\u00fcr 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\u00fcr 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\u00fcrzen des Regressor-Vektors auf die tats\u00e4chlich benutzten Eintr\u00e4ge\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\u00fccke 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# Use this to define the canonical_labeling function in maple:\n\ncanonical_labeling := define_external('canonical_labeling', \\\ncolored_edges::(ARRAY(1..3*m, integer[4])), \\ # colored edges as array\n\\ # Format: ( va_1, vb_1, w_1, va_2, vb_2, w_2, ... )\n\\ # For a graph with edges (va_k, vb_k) having colors w_k.\next_vertices::(ARRAY(1..l,integer[4])), \\ # external vertices\n\\ # Array of vertices with another color ( ve_1, ve_2, ... )\nlab::(ARRAY(1..n,integer[4])), \\ # canonical labeling returned\n\\ # Canonical labelling is written into this. \nn::(integer[4]), \\ # number of vtcs\nm::(integer[4]), \\ # number of edges\nw::(integer[4]), \\ # number of colors\nl::(integer[4]), \\ # number of ext vertices\nLIB=\"nauty_wrapper.so\" ):\n\n# Example:\n\nlab:=Array([0,1,2,3,4],datatype=integer[4]):\next:=Array([4],datatype=integer[4]):\n\nG:=Array([0,3,0, 0,2,0, 2,1,0, 3,1,0, 3,4,0], datatype=integer[4]):\n\ncanonical_labeling(G, ext, lab, 5, 5, 1, 1);\n\nlab;\n\nG:=Array(subs([1=2,2=3,3=4,4=1],[0,3,0, 0,2,0, 2,1,0, 3,1,0, 3,4,0]), datatype=integer[4]):\n\ncanonical_labeling(G, ext, lab, 5, 5, 1, 1);\n\nlab;\n", "meta": {"hexsha": "9242588e1fd7861eeca9c3b628e62186e9722300", "size": 1086, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "script.mpl", "max_stars_repo_name": "michibo/maple-graph-canonicalization", "max_stars_repo_head_hexsha": "07d7eb1210883f7818ef656dded032e8510c40c4", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-06-06T16:34:12.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-06T16:34:12.000Z", "max_issues_repo_path": "script.mpl", "max_issues_repo_name": "michibo/maple-graph-canonicalization", "max_issues_repo_head_hexsha": "07d7eb1210883f7818ef656dded032e8510c40c4", "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": "script.mpl", "max_forks_repo_name": "michibo/maple-graph-canonicalization", "max_forks_repo_head_hexsha": "07d7eb1210883f7818ef656dded032e8510c40c4", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.9411764706, "max_line_length": 91, "alphanum_fraction": 0.6464088398, "num_tokens": 419, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891392358014, "lm_q2_score": 0.5660185351961015, "lm_q1q2_score": 0.4653742922443918}}
{"text": "$Amt:10.0\n$maxAmt:120.0\n$multipler:1.002\n$additional:0.03\n$interval:15.0\n\nmain()inline{\n\t\n\tonce{\n\t\tRemoveImages(Self());\n\t\tSetImage(Self(), \"main\", \"CustomEmitter\");\n\t\tSetTextSize(0.6);\n\t\tSetDigitalis(CurrentCoords(), 1);\n\t\tSetUnitAttribute(Self(), CONST_NULLIFIERDAMAGES, False);\n\t}\n\t\n\tif(GetDigitalis(CurrentCoords())!=1) Amt*=0.85;\n\t\n\tSetDigitalisGrowth(CurrentCoords(), True);\n\tSetDigitalis(CurrentCoords(), 1);\n\t\n\tif(Amt<5)Destroy(Self(), 2);\n\t\n\tSetPopupText(\"Amt: \" $ round(Amt, 2) $ endl() $ \"Interval: \" $ round(interval/30.0, 2));\n\tSetImageScale(Self(), \"main\", dup(Amt/maxAmt*1.7+0.3));\n\tAddCreeper(CurrentCoords(), Amt);\n\t\n\tif(Amt>=50)once enable = True;\n\t\n\tif(enable){\n\t\t[x, y] = RandCoordsInRange(CurrentCoords(), 10);\n\t\tnoEnemy=True;\n\t\tdo(GetEnemyUnitsInRange(x, y, 8)){\n\t\t\tpop(); // remove uid from stack\n\t\t\tnoEnemy=False;\n\t\t}\n\t\tif(GetCreeper(x, y)>1 && noEnemy){\n\t\t\tAmt/=1.75;\n\t\t\tuid = CreateUnit(\"CRPLCORE\", x, y);\n\t\t\tAddScriptToUnit(uid, \"emitter.crpl\");\n\t\t\tif(Amt<maxAmt/2)enable = False;\n\t\t}\n\t}\n\t\n\tif(Amt < maxAmt) Amt = Amt*multipler + additional;\n\telse once Amt = maxAmt;\n\t\n\tDelay(interval);\n}", "meta": {"hexsha": "661f3e3edd1c7beedd95bd260695ea54c6001a9c", "size": 1115, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "examples/emitter.mpl", "max_stars_repo_name": "Arin112/mplLang", "max_stars_repo_head_hexsha": "e7d41648305462d70acb6c3716283f311dd89b42", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-07-22T19:04:29.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-22T19:04:29.000Z", "max_issues_repo_path": "examples/emitter.mpl", "max_issues_repo_name": "Arin112/mplLang", "max_issues_repo_head_hexsha": "e7d41648305462d70acb6c3716283f311dd89b42", "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/emitter.mpl", "max_forks_repo_name": "Arin112/mplLang", "max_forks_repo_head_hexsha": "e7d41648305462d70acb6c3716283f311dd89b42", "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.7551020408, "max_line_length": 89, "alphanum_fraction": 0.6529147982, "num_tokens": 386, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933183101078, "lm_q2_score": 0.5660185351961015, "lm_q1q2_score": 0.4640748150469582}}
{"text": "read(\"bssn_spher.mpl\");\n\nread(\"built_eqns.mpl\");\n\nread(\"compactify.mpl\");\n\nread(\"perform_fd.mpl\");\n\nread(\"built_direct_ire_test.mpl\");\n\n\n", "meta": {"hexsha": "d5bdb9fa3da786f5907aa47028271698818071eb", "size": 137, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "bssn_main.mpl", "max_stars_repo_name": "rmanak/bssn_spher", "max_stars_repo_head_hexsha": "b91104fd6b9b7cf1ba08e35efd65ff219ab7a5a9", "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": "bssn_main.mpl", "max_issues_repo_name": "rmanak/bssn_spher", "max_issues_repo_head_hexsha": "b91104fd6b9b7cf1ba08e35efd65ff219ab7a5a9", "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": "bssn_main.mpl", "max_forks_repo_name": "rmanak/bssn_spher", "max_forks_repo_head_hexsha": "b91104fd6b9b7cf1ba08e35efd65ff219ab7a5a9", "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": 11.4166666667, "max_line_length": 34, "alphanum_fraction": 0.700729927, "num_tokens": 42, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.78793120560257, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.46400412277214736}}
{"text": "input := FileTools:-Text:-ReadFile(\"AoC-2021-17-input.txt\" ):\n", "meta": {"hexsha": "e4dbed639ecda1a5f2a33bb617d80b76e971fb6f", "size": 62, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "Day17/AoC17-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": "Day17/AoC17-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": "Day17/AoC17-Maple.mpl", "max_forks_repo_name": "johnpmay/AdventOfCode2021", "max_forks_repo_head_hexsha": "b51756bcebea662333072cf518cf040a962ef8b7", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.0, "max_line_length": 61, "alphanum_fraction": 0.6935483871, "num_tokens": 21, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.7154239957834733, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.4634503895487121}}
{"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\u00fcr Systeme mit impliziten kinematischen Zwangsbedingungen\n# Beschreibung\n# Allgemeine Berechnungen zu den impliziten Zwangsbedingungen\n# Die Bedingungen m\u00fcssen vorher in einer Roboterspezifischen Datei berechnet werden (h\u00e4ndische Erstellung der kinematischen Schleifen und sonstigen Zwangsbedingungen\n# \n# Dateiname:\n# robot -> Berechnung f\u00fcr allgemeinen Roboter\n# kinematic_constraints_calculations_implicit -> Berechnungen bez\u00fcglich 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\u00fccke die folgende Warnung.\nrestart: # Gibt eine Warnung, wenn \u00fcber Terminal-Maple mit read gestartet wird.\ninterface(warnlevel=3):\ninterface(rtablesize=30):\nwith(StringTools): # F\u00fcr 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\u00e4nkt 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\u00e4\u00dfig simplify-Befehle anwenden.\nelse\n  use_simplify := simplify_options(1): # erster Eintrag ist f\u00fcr 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\u00fcr Sichtbarkeit der Variablen\n  implconstr_t := implconstr_t: # F\u00fcr Sichtbarkeit der Variablen\n  kin_constraints_exist := kin_constraints_exist: # F\u00fcr 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\u00fcltig\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\u00e4ngigkeit der unabh\u00e4ngigen 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\u00e4ngigkeit der abh\u00e4ngigen 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\u00fccke\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\u00fcr aktive Gelenke. L\u00e4nge: %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\u00fcr passive Gelenke. L\u00e4nge: %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\u00fcr Zwangsbedingungs-Jacobis vereinfacht. L\u00e4nge (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\u00f6tigt, 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\u00fccke\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\u00fcr aktive Gelenke. L\u00e4nge: %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\u00fcr passive Gelenke. L\u00e4nge: %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\u00fcr Zwangsbedingungs-Jacobis (Zeitableitung) vereinfacht. L\u00e4nge (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\u00fcr 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\u00fccke f\u00fcr 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\u00fccke f\u00fcr Kinematische ZB gespeichert (Matlab)\\n\"):\nend if:\n\n# Invertierung der Gradientenmatrix\n# Invertiere die Gradientenmatrix bez\u00fcglich 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\u00e4ge 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\u00fcr passive Gelenke. L\u00e4nge: %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\u00e4nge: %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\u00e4nge: %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\u00e4nge: %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\u00e4nge: %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\u00e4nge: %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": "`is_element/prime_W` := (N::posint) -> (A::set) -> proc(x)\n `is_element/vector_functions`(N)(A)(x) and\n `sum/vector_functions`(N)(A)(x) = [0$N];\nend;\n\n######################################################################\n\n`is_equal/prime_W` := (N::posint) -> (A::set) -> proc(x,y) \n return `is_equal/vector_functions`(N)(A)(x,y);\nend;\n\n######################################################################\n\n`is_leq/prime_W` := NULL;\n\n######################################################################\n\n`is_zero/prime_W` := (N::posint) -> (A::set) -> proc(x) \n return `is_zero/vector_functions`(N)(A)(x);\nend;\n\n######################################################################\n\n`norm/prime_W` := (N::posint) -> (A::set) -> proc(x) \n return `norm/vector_functions`(N)(A)(x);\nend;\n\n######################################################################\n\n`normalise/prime_W` := (N::posint) -> (A::set) -> proc(x) \n local r,a;\n r := `norm/vector_functions`(N)(A)(x);\n if r = 0 then return FAIL; fi;\n return table([seq(a = simplify(x[a] /~ r),a in A)]);\nend;\n\n######################################################################\n\n`random_element/prime_W` := (N::posint) -> (A::set) -> proc()\n local x,a,u;\n\n u := [0$N];\n x := table();\n for a in A do\n  x[a] := `random_element/R`(N)();\n  u := u +~ x[a];\n od:\n u := u /~ nops(A);\n for a in A do \n  x[a] := x[a] -~ u;\n od;\n\n return eval(x);\nend;\n\n`list_elements/W` := NULL;\n`count_elements/W` := NULL;\n\n######################################################################\n# Here C is assumed to be a subset of B, and rho is the usual map \n# from W(N,B) to W(N,C).\n\n`rho/prime_W` := (B,C) -> proc(x)\n local y,z,c;\n\n y := table();\n for c in C do y[c] := x[c]; od;\n z := `normalise/W`(N)(C)(y);\n return eval(z);\nend;\n", "meta": {"hexsha": "2347de160011666891e8ca1da00c957c0e5035d4", "size": 1770, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "lib/prime_W.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/prime_W.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/prime_W.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.9295774648, "max_line_length": 70, "alphanum_fraction": 0.4016949153, "num_tokens": 487, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7401743620390163, "lm_q2_score": 0.6224593452091672, "lm_q1q2_score": 0.4607284487354192}}
{"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": "\n# 4-Achsroboter von KUKA\n# Voraussetzung:\n# Viergelenkkette muss mit der Toolbox berechnet worden sein (Arbeitsblatt \"vgk_kinematic_constraints.mw\")\n# Autor\n# Weipu Shan\n# Studienarbeit bei: Moritz Schappler, moritz.schappler@imes.uni-hannover.de, 2018-08\n# (C) Institut fuer mechatronische Systeme, Leibniz Universitaet Hannover\n# Quellen\n# SA Bejaoui: Bejaoui2018_S749; \"Modellierung kinematischer Zwangsbedingungen f\u00fcr hybride serielle Roboter mit planaren Parallelmechanismen\"\n# SA Shan: Shan2019_S828, \"Reduktion der Modellkomplexit\u00e4t von seriell-hybriden Palettierrobotern\"\n# \n# \n# Initialisierung\n# Import (Library)\ninterface(warnlevel=0): \t\t# Unterdr\u00fccke die folgende Warnung.\nrestart: \t\t\t\t# Gibt eine Warnung, wenn \u00fcber Terminal-Maple mit read gestartet wird.\ninterface(warnlevel=3):\nkin_constraints_exist := true: \t\t# F\u00fcr Speicherung\n;\nwith(StringTools): \t\t\t# F\u00fcr Zeitausgabe\nwith(LinearAlgebra):\nwith(codegen):\nwith(CodeGeneration):\n#with(ListTools):\ncodegen_act := true:\ncodegen_opt := 1: # Geringerer Optimierungsgrad. Sonst zu lange.\ncodegen_debug := 0: # Zur Code-Generierung auch f\u00fcr Nicht-Inert-Ausdr\u00fccke\n;\n\n# Import (hybriddyn)\nread \"../helper/proc_MatlabExport\": \t# Exportiert einen Term als Matlab-Code in optimierter Form\nread \"../transformation/proc_rotx\":  \t# rotation um X\nread \"../transformation/proc_roty\":  \t# rotation um Y\nread \"../transformation/proc_rotz\":  \t# rotation um Z\n;\nread \"../helper/proc_convert_s_t\":   \t# zeitabh\u00e4ngige Variable f\u00fcr Ableitung\nread \"../helper/proc_convert_t_s\":   \t# konstante Variable \nread \"../robot_codegen_constraints/proc_subs_kintmp_exp\": #substitute f\u00fcr Spalte 1 mit Spalte 2\n;\nwith(RealDomain): \t\t\t# Schr\u00e4nkt alle Funktionen auf den reellen Bereich ein. Muss nach Definition von MatlabExport kommen. Sonst geht dieses nicht.\n;\nread \"../robot_codegen_definitions/robot_env\":\t\t\t#aktuelle Roboter, MDH-Tabelle\n;\nread sprintf(\"../codeexport/%s/tmp/tree_floatb_definitions\",robot_name):\t#von Fourbar\n;\n\n# Variable Initialisierung\n# Variable mit Winkeln der Nebenstruktur nur in Abh\u00e4ngigkeit der verallgemeinerten Koordinaten\n# Ergebnisse von Trigonometrischer Elimination lesen\nread sprintf(\"../codeexport/palh3m1TE/tmp/kinematic_constraints_maple_inert.m\"):\t# von aktuellem Roboter\n;\nkin_constraints_exist := kin_constraints_exist:\nkintmp_qs := kintmp_qs:\nkintmp_qt := kintmp_qt:\nkintmp_subsexp := kintmp_subsexp:\n# Variable entfernen\nkintmp_subsexp:= Matrix(2*RowDimension(kintmp_s),2):\n# Export\nkintmp_qt := convert_s_t(kintmp_qs):\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):\n#printf(\"Ausdr\u00fccke f\u00fcr 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,kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_inert\" ,robot_name):\nsave kin_constraints_exist, kintmp_qs, kintmp_qt, kintmp_subsexp, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_maple_inert.m\", robot_name):\nsave kintmp_qs, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_kintmp_qs_maple_inert\", robot_name):\n#printf(\"Ausdr\u00fccke 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\u00e4ngigen konstanten Kinematikparametern erstellen (wichtig f\u00fcr Matlab-Funktionsgenerierung)\nread \"../helper/proc_list_constant_expressions\";\nkc_symbols := Matrix(list_constant_expressions( kintmp_qs ));\n#kc_symbols :=Transpose(kc_symbols);\nsave kc_symbols, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_symbols_list_maple\", robot_name):\nMatlabExport(kc_symbols, sprintf(\"../codeexport/%s/tmp/kinematic_constraints_symbols_list_matlab.m\",robot_name),2);\n\n#printf(\"Fertig. %s. CPU-Zeit bis hier: %1.2fs.\\n\", FormatTime(\"%Y-%m-%d %H:%M:%S\"), time()-st):\nkintmp_qs(1,1):\nkc_symbols(1,1):\nkintmp_qs(2,1):\n", "meta": {"hexsha": "39985f55fbdd480a2fa855bcf7bee86a76bff183", "size": 4292, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "systems/palh3m1/codegen/palh3m1DE_kinematic_constraints.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/palh3m1/codegen/palh3m1DE_kinematic_constraints.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/palh3m1/codegen/palh3m1DE_kinematic_constraints.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": 51.0952380952, "max_line_length": 147, "alphanum_fraction": 0.7791239515, "num_tokens": 1319, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7931059462938815, "lm_q2_score": 0.5736784074525096, "lm_q1q2_score": 0.4549877562109896}}
{"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": "IRATH:=module()\n    option  package;\n    export  findTanhSolutions;\n    local   nomalizeEqn,\n            getODE,\n            simplifyEqn,\n            findDiffOrder,\n            findElemOrder,\n            findItemOrder,\n            findOrders,\n            findInflexion,\n            solveAllOrder,\n            solveForOrder,\n            selectSolutions,\n            printSolutions,\n            solveForPS,\n            transSolution,\n            subsIeq,\n            subsSol,\n            checkSolution,\n            isEquationOf;\n\n    (*\n     * \u6c42\u89e3\u51fd\u6570\n     *)\n    findTanhSolutions:=proc(eqi)\n        local eq,ms,params,oeq,st;\n        st:=time();\n        \n        printf(\"\u8f93\u5165\u7684\u65b9\u7a0b\u4e3a\");\n        eq:=nomalizeEqn(eqi);\n        oeq:=eq;\n        print(eq);\n\n        # printf(\"\u65b9\u7a0b\u4e2d\u7684\u53c2\u6570\u4e3a\");\n        params:=indets(eq,name) minus {t,x};\n        # print(params);\n        \n        # printf(\"\u884c\u6ce2\u53d8\u6362\u540e\u7684\u65b9\u7a0b\u4e3a\");\n        eq:=getODE(eq);\n        # print(eq);\n\n        # printf(\"\u65b9\u7a0b\u5404\u9879\u9636\u6570\u4e3a\");\n        ms:=findOrders(eq);\n        # print(ms);\n\n        # printf(\"\u62d0\u70b9\u4e3a\");\n        ms:=findInflexion(ms);\n        # print(ms);\n\n        if evalb(ms={0}) then\n            printf(\"\u65e0\u89e3\\n\");\n            printf(\"\u65f6\u95f4\u5df2\u8fc7 %f \u79d2\\n\",time()-st);\n            return;\n        end if;\n        \n        # printf(\"\u5f00\u59cb\u6c42\u89e3\\n\");\n        solveAllOrder(eq,ms,params,oeq);\n\n        printf(\"\u65f6\u95f4\u5df2\u8fc7 %f \u79d2\\n\",time()-st);\n    end proc:\n\n    (*\n     * \u6807\u51c6\u5316\u65b9\u7a0b\n     * \u65b9\u7a0b\u53d8\u91cf\u662fu(x,t)\n    *)\n    nomalizeEqn:=proc(ee)\n        local e;\n        e:=expand(numer(ee));\n        return e;\n    end proc:\n\n    (*\n     * \u8fdb\u884c\u884c\u6ce2\u53d8\u6362\uff0c\u5c06\u504f\u5fae\u5206\u65b9\u7a0b\u8f6c\u5316\u4e3a\u5e38\u5fae\u5206\u65b9\u7a0b\n     * \u8981\u6c42\u51fd\u6570\u4e3au(x,t),\u66ff\u6362\u4e3au(xi),\n     * xi=k*(x-ct)\n    *)\n    getODE:=proc(eqi)\n        local eq;\n        eq:=subs(u(x,t)=u(x,t,xi),eqi);\n        eq:=PDETools[dsubs](diff(u(x,t,xi),t)=-c*k*diff(u(x,t,xi),xi),\n        diff(u(x,t,xi),x)=k*diff(u(x,t,xi),xi),\n        eq);\n        eq:=eval(subs(u(x,t,xi)=u(xi),eq));\n        return simplifyEqn(eq);\n    end proc:\n\n    (*\n     * \u5316\u7b80\u65b9\u7a0b\n    *)\n    simplifyEqn:=proc(ee)\n        local e,v,p;\n        e:=numer(ee);\n        e:=factor(e);\n        if type(e,`*`) then\n            p:=1;\n            for v in e do\n                if type(v,`+`) then\n                    p:=p*v;\n                 elif type(v,`^`) and type(expand(op(1,v)),`+`) then\n                    p:=p*(simplifyEqn(op(1,v))^op(2,v));\n                end if;\n            end do;\n            p:=expand(p);\n        else\n            p:=expand(e);\n        end if;\n        return p;\n    end proc:\n\n    (*\n     * \u8ba1\u7b97\u5bfc\u6570\u9879\u9636\u6570\n    *)\n    findDiffOrder:=proc(ee)\n        local e;\n        e:=convert(ee,'D');\n        e:=op(0,op(0,e));\n        if evalb(op(0,e)=`@@`) then\n            op(2,e);\n        else\n            1;\n        end if;\n    end proc:\n\n    (*\n     * \u8ba1\u7b97\u5143\u7d20\u7684\u9636\u6570\n    *)\n    findElemOrder:=proc(ee)\n        local e;\n        if evalb(op(0,ee)='u') then\n            e:=[1,0];\n        elif evalb(op(0,ee)='diff') then\n            e:=[1,findDiffOrder(ee)];\n        elif type(ee,`^`) then\n            e:=findElemOrder(op(1,ee))*op(2,ee);\n        else\n            e:=[0,0];\n        end if;\n        return e;\n    end proc:\n\n    (*\n     * \u8ba1\u7b97\u65b9\u7a0b\u67d0\u4e00\u9879\u7684\u9636\u6570\n    *)\n    findItemOrder:=proc(ee)\n        local e,p;\n        if type(ee,`*`) then\n            p:=[0,0];\n            for e in ee do\n                p:=p+findElemOrder(e);\n            end do;\n        else\n            p:=findElemOrder(ee);\n        end if;\n        return p;\n    end proc:\n\n    (*\n     * \u8ba1\u7b97\u65b9\u7a0b\u6bcf\u4e00\u9879\u7684\u9636\u6570\n     * \u5047\u8bbe\u81f3\u5c11\u6709\u4e24\u9879\n     * \u5047\u8bbe\u6307\u6570\u4e0a\u4e0d\u542b\u53c2\u6570\n    *)\n    findOrders:=proc(ee)\n        findItemOrder~([op(ee)]);\n    end proc:\n\n    (*\n     * \u8ba1\u7b97\u62d0\u70b9\n    *)\n    findInflexion:=proc(mss::list(list(integer)))\n        local ms,i,j,n,mm,m,fun;\n        fun:=(x,m)->x[1]*m+x[2];\n        mm:={};\n        ms:={op(mss)};\n        n:=numelems(ms);\n        for i from 1 to n-1 do\n            for j from i+1 to n do\n                if evalb(ms[i][1]<>ms[j][1]) then\n                    m:=-(ms[i][2]-ms[j][2])/(ms[i][1]-ms[j][1]);\n                    if evalb(fun(ms[i],m)=max(map(fun,ms,m))) then\n                        mm:=mm union {m};\n                    end if;\n                end if;\n            end do;\n        end do;\n        return mm;\n    end proc:\n\n    (*\n     * \u5bf9\u6240\u6709\u9636\u6570\u8fdb\u884c\u6c42\u89e3\n    *)\n    solveAllOrder:=proc(eqi,mms::set(rational),params::set(name),oeq)\n        local trans,tr,eq,ms,m;\n        # \u8ba1\u7b97\u5168\u90e8\u53d8\u6362\n        trans:=map(x->sign(x)/denom(x),mms);\n        for tr in trans do\n            eq:=eval(subs(u(xi)=u(xi)^tr,eqi));\n            eq:=simplifyEqn(eq);\n            ms:=findOrders(eq);\n            m:=select(type,findInflexion(ms),posint);\n            m:=max(m);\n            printf(\"m=%a,\u65b9\u7a0b\u4e3a:\",tr*m);\n            print(eq);\n            if not type(ms,list(list(integer))) then\n                printf(\"\u65b9\u7a0b\u4e0d\u662f\u591a\u9879\u5f0f\uff0c\u65e0\u89e3\\n\");\n                next;\n            end if;\n            solveForOrder(eq,m,params,tr,oeq);\n        end do;\n    end proc:\n\n    (*\n     * \u5bf9\u7279\u5b9a\u9636\u6570\u8fdb\u884c\u6c42\u89e3\n    *)\n    solveForOrder:=proc(eqi,m::posint,params::set(name),tr::rational,oeq)\n        local eq,f,PS,vars,sols;\n        f:=add(seq(a[i]*tanh(xi)^i,i=0..m));\n        vars:=[seq(a[i],i=0..m)];\n        eq:=eval(subs(u(xi)=f,eqi));\n        eq:=subs(tanh(xi)=T,eq);\n        eq:=collect(eq,T);\n        PS:=PolynomialTools[CoefficientList](eq,T,termorder=reverse);\n        sols:=solveForPS(PS,m,params,vars);\n        printSolutions(sols,m,tr);\n    end proc:\n\n    (*\n     * \u7b5b\u9009\u89e3\n     * \u5220\u53bbk,c=0\u7684\u89e3\n     * \u5220\u9664\u53c2\u6570\u4e3a0\u7684\u89e3\n     * \u5220\u9664a[1]..a[m]\u90fd\u4e3a0\u7684\u89e3\n    *)\n    selectSolutions:=proc(solss::{set,list},\n                         params::set(name),m::posint)\n        local zs,ps,sols,as;\n        as:={seq(a[i],i=1..m)};\n        sols:=convert(solss,set);\n        sols:=select(type,sols,equation);\n        ps:=params union {k,c};\n        zs:=lhs~(select(_x->type(_x,`=`(name,0)),sols));\n        if evalb( (zs intersect ps) <> {} ) then\n            return false;\n        else\n            return not evalb(as subset zs);\n        end if; \n    end proc:\n\n    (*\n     * \u8f93\u51fa\u89e3\n    *)\n    printSolutions:=proc(sols::set({list,set}),\n                        m::posint,tr::rational)\n        local sol;\n        if evalb(sols={}) then\n            printf(\"\u65e0\u89e3\\n\");\n            return;\n        end if;\n        printf(\"\u5171\u6709%d\u4e2a\u89e3\",numelems(sols));\n        print(u(xi)=add(seq(a[i]*tanh(xi)^i,i=0..m))^tr,xi=k*(x-ct)+xi[0]);\n        printf(\"\u5176\u4e2d\");\n        for sol in sols do\n            print(expand(simplify(sol)));\n        end do;\n    end proc:\n\n    (*\n     * \u6c42\u89e3PS\n     * \u57fa\u4e8ecsolve\u7684\u7248\u672c\n     * \u53ea\u6709\u5269\u4f59\u65b9\u7a0b\u4e0d\u80fd\u7528csolve\u6c42\u89e3\u65f6\uff0c\u624d\u4f7f\u7528solve\u6c42\u89e3\n    *)\n    solveForPS:=proc(PS,m::posint,params::set(name),vars::list(name))\n        local pa,pp,sola,sol,vs,res,np,nsol,ssol,nres,sssol;\n        res:={};# \u6240\u6709\u89e3\n        pa:=PS[1..(m+1)];\n        pp:=PS[(m+1)..-1];\n        sola:=[csolve(pa,{vars[],k,c})];# \u6c42\u89e3\u524dm+1\u4e2a\u65b9\u7a0b\n        sola:=select(selectSolutions,sola,params,m);# \u9664\u53bb\u5e73\u51e1\u7684\u89e3\n        for sol in sola do\n            # \u4ee3\u5165\u5316\u7b80\n            np:=simplify(subs(op(sol),pp));\n            np:=simplifyEqn~(np);# \u5316\u7b80\u65b9\u7a0b\uff0c\u53bb\u9664\u975e\u96f6\u9879\n            np:=remove(type,np,0);\n            \n            # \u5982\u679c\u5269\u4f59\u7684\u65b9\u7a0b\u51680\uff0c\u5219\u4e0d\u9700\u8981\u7ee7\u7eed\u6c42\u89e3\n            if evalb(np=[]) then\n                res:=res union {sol};\n                next;\n            end if;\n            \n            # \u6c42\u89e3\u5269\u4f59\u65b9\u7a0b\n            try\n                nsol:=[csolve(np,indets(np,name))];\n            catch:\n                nsol:=[RealDomain[solve](np,indets(np,name))];\n            end try;\n            \n            nsol:=select(selectSolutions,nsol,params,m);\n            \n            for ssol in nsol do\n                # \u5408\u5e76\u89e3\uff0c\u56e0\u4e3a\u524d\u9762\u7684\u89e3\uff0c\u5728\u540e\u9762\u5df2\u7ecf\u88ab\u5e26\u5165\n                # \u6240\u4ee5\uff0c\u540e\u9762\u7684\u89e3\u4e0d\u4f1a\u5305\u542b\u524d\u9762\u5df2\u6709\u7684\u7b26\u53f7\n                # \u56e0\u6b64\uff0c\u76f4\u63a5\u5408\u5e76\u5373\u53ef\n                try # \u6709\u53ef\u80fd\u51fa\u73b0\u5206\u6bcd\u4e3a0\u7684\u60c5\u51b5\n                    sssol:=simplify(subs(op(ssol),sol));\n                    res:=res union {sssol union ssol};\n                catch:\n                    next;\n                end try;\n            end do;\n        end do;\n        \n        res:=select(selectSolutions,res,params,m);\n        \n        # printf(\"\u672a\u8f6c\u6362\u7684\u89e3\");\n        # print~(res);\n        \n        nres:={};\n        map(transSolution,res,'nres',params,vars);\n        res:=select(selectSolutions,nres,params,m);\n        \n        return res;\n    end proc:\n\n\n\n    (*\n     * \u8f6c\u5316csolve\u7684\u7ed3\u679c\n    *)\n    transSolution:=proc(res::set(equation),nres::evaln(set),\n                       params::set(name),vars::list(name))\n        local r,rv,rp,np,rrv,rrp,sp,newSol;\n        # \u5148\u6c42\u89e3a[0]..a[m],k,c\n        sp:=select(isEquationOf,res,{vars[],k,c});\n        sp:=map(_x->simplifyEqn(lhs(_x)-rhs(_x)),sp);# \u5316\u7b80\u65b9\u7a0b\uff0c\u53bb\u9664\u975e\u96f6\u9879\n        rv:=RealDomain[solve](sp,[vars[],k,c]);\n\n        # \u5982\u679c\u6c42\u89e3\u5931\u8d25\u5219\u76f4\u63a5\u539f\u6837\u8fd4\u56de\n        if evalb(rv=[]) then\n            nres:=eval(nres) union {[res[]]};\n            WARNING(\"solve\u6c42\u89e3\u5931\u8d25\");\n            return;\n        end if;\n\n        # \u518d\u6c42\u89e3\u53c2\u6570\n        for rrv in rv do\n            try\n                np:=simplify(subs(op(rrv),res));\n            catch:\n                next;\n            end try;\n            np:=map(_x->simplifyEqn(lhs(_x)-rhs(_x)),np);# \u5316\u7b80\u65b9\u7a0b\uff0c\u53bb\u9664\u975e\u96f6\u9879\n            np:=select(isEquationOf,np,params);\n            rp:=RealDomain[solve](np,[params[]]);\n            for rrp in rp do\n                rrp:=subsIeq~(rrp);\n                try\n                    newSol:=[op(subsSol(rrv,rrp)),rrp[]];\n                    newSol:=simplify(rationalize(newSol));\n                    nres:=eval(nres) union {newSol};\n                catch:\n                    next;\n                end try;\n            end do;\n        end do;\n        return;\n    end proc:\n\n    (*\n     * \u6d88\u53bb\u4e0d\u7b49\u5f0f\u8303\u56f4\u7ea6\u675f\n    *)\n    subsIeq:=proc(ee)\n        local v;\n        if type(ee,equation) then\n            return ee;\n        else\n            v:=indets(ee);\n            if evalb(nops(v)=1) then\n                v:=v[1];\n                return (v=v);\n            else\n                return ee;\n            end if;\n        end if;\n    end proc:\n\n    (*\n     * \u89e3\u96c6\u5e26\u5165\n     * sol2\u4ee3\u5165sol1\n    *)\n    subsSol:=proc(sol1,sol2)\n        local sol;\n        sol:=select(type,sol2,equation);\n        expand(subs(op(sol),sol1));\n    end proc:\n\n    (*\n     * \u4ee3\u56de\u539f\u65b9\u7a0b\u8fdb\u884c\u9a8c\u8bc1\n    *)\n    checkSolution:=proc(ssol,oeq,m,tr)\n        local uxi,sol,r;\n        sol:=select(type,ssol,equation);\n        r:=subs(u(x,t)=add(seq(a[i]*tanh(xi)^i,i=0..m))^tr,oeq);\n        r:=subs(xi=k*(x-c*t),r);\n        r:=subs(op(sol),r);\n        r:=simplify(r);\n        evalb(r=0);\n    end proc:\n\n    (*\n     * \u9009\u62e9\u5173\u4e8e\u7ed9\u5b9a\u53c2\u6570\u7684\u65b9\u7a0b\n    *)\n    isEquationOf:=proc(eq,vars::set)\n        local vs;\n        vs:=indets(eq,name);\n        evalb( (vs intersect vars) <> {} );\n    end proc:\n\nend module:", "meta": {"hexsha": "e348bb83d653a3efa2effe84dc6d1fc0c3682f9c", "size": 10386, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "IRATH.mpl", "max_stars_repo_name": "yu961549745/IRATH", "max_stars_repo_head_hexsha": "e6ee1902cdc9deb7e88c15ae19c0015833ca2e4b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-03T23:03:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-03T23:03:52.000Z", "max_issues_repo_path": "IRATH.mpl", "max_issues_repo_name": "yu961549745/IRATH", "max_issues_repo_head_hexsha": "e6ee1902cdc9deb7e88c15ae19c0015833ca2e4b", "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": "IRATH.mpl", "max_forks_repo_name": "yu961549745/IRATH", "max_forks_repo_head_hexsha": "e6ee1902cdc9deb7e88c15ae19c0015833ca2e4b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-03T23:03:54.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-03T23:03:54.000Z", "avg_line_length": 24.8468899522, "max_line_length": 75, "alphanum_fraction": 0.4380897362, "num_tokens": 3326, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7431680086124812, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.4543595235945835}}
{"text": "\n# Vierachsroboter KUKA KR700PA implizit\n# Initialisierung\n# Import (Library)\ninterface(warnlevel=0): \t\t# Unterdr\u00fccke die folgende Warnung.\nrestart: \t\t\t\t# Gibt eine Warnung, wenn \u00fcber Terminal-Maple mit read gestartet wird.\ninterface(warnlevel=3):\nkin_constraints_exist := true:\t\t# F\u00fcr Speicherung\n;\nwith(StringTools): \t\t\t# F\u00fcr 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\u00fcr Nicht-Inert-Ausdr\u00fccke\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\u00e4nkt 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\u00fcr h1r\n;\ncombine(tmp);# nur anzeigen lassen f\u00fcr h1r\n;\nh1r := -(-qJ6(t)+qJ2(t)+qJ7(t)+phi79+qJ9(t)) + Pi;\n# VGK GR\u00dcN 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\u00fcr h2r\n;\ncombine(tmp);  #nur anzeigen lassen f\u00fcr 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\u00fcr 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\u00e4ndigen 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\u00e4ngigen konstanten Kinematikparametern erstellen (wichtig f\u00fcr 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}}
{"text": "sort([3,2,4,5],output = permutation);", "meta": {"hexsha": "015ac97b8c7b6868eb427655373d5ef38a9e29c1", "size": 37, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "MplTest/test.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": "MplTest/test.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": "MplTest/test.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": 37.0, "max_line_length": 37, "alphanum_fraction": 0.6756756757, "num_tokens": 14, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7025300573952054, "lm_q2_score": 0.6442251064863697, "lm_q1q2_score": 0.45258750103530154}}
{"text": "# Step 1 of 3: from Hakaru to Maple LO (linear operator)\n\ntoLO := module()\n  export\n  ModuleApply := proc(m, $)\n    local h;\n    h := gensym('h');\n    _Env_HakaruSolve := false;\n    LO(h, integrate(m, h, []))\n  end proc;\n\n  export\n  integrate := proc(m, h, loops :: list(name = range) := [], $)\n    local x, n, i, res, l, br, m0;\n\n    if m :: known_continuous then\n      integrate_known(Int, Ints, 'xx', m, h, loops)\n    elif m :: known_discrete then\n      integrate_known(Sum, Sums, 'kk', m, h, loops)\n    elif m :: 'Ret(anything)' then\n      applyintegrand(h, mk_ary(op(1,m), loops))\n    elif m :: 'Bind(anything, name, anything)' then\n      res := eval(op(3,m), op(2,m) = mk_idx(op(2,m), loops));\n      res := eval(Integrand(op(2,m), 'integrate'(res, x, loops)), x=h);\n      integrate(op(1,m), res, loops);\n    elif m :: 'specfunc(Msum)' and (nops(loops) = 0 or nops(m) = 1) then\n      `+`(op(map(integrate, [op(m)], h, loops)))\n    elif m :: 'Weight(anything, anything)' then\n      foldl(product, op(1,m), op(loops)) * integrate(op(2,m), h, loops)\n    elif m :: t_pw_or_part then\n      Partition:-AppPartOrPw\n                 ( proc(p)\n                       if not Partition:-ConditionsDepend(p, lhs~(loops)) then\n                           Partition:-Pmap(z->integrate(z,h,loops),p)\n                       end if;\n                   end proc\n                 , m);\n    elif m :: t_case and not depends(op(1,m), map(lhs, loops)) then\n      subsop(2=map(proc(b :: Branch(anything, anything))\n                     eval(subsop(2='integrate'(op(2,b), x, loops),b), x=h)\n                   end proc,\n                   op(2,m)),\n             m);\n    elif m :: 'LO(name, anything)' then\n      eval(op(2,m), op(1,m) = h)\n    elif m :: 'Plate(nonnegint, name, anything)' then\n      # Unroll Plate when the bound is known. We unroll Plate here (instead\n      # of unrolling Ints in reduce, for example) because we have no other\n      # way to integrate certain Plates, namely those whose bodies' control\n      # flows depend on the index.\n      x := mk_sym('pp', h);\n      x := [seq(cat(x,i), i=0..op(1,m)-1)];\n      if op(1,m) = 0 then\n        res := undefined;\n      else\n        if op(1,m) = 1 then\n          res := op(1,x);\n        else\n           res := idx(x,op(2,m));\n#          res := piecewise(seq(op([op(2,m)=i-1, op(i,x)]), i=2..op(1,m)),\n#                         op(1,x));\n        end if;\n        res := mk_idx(res, loops);\n      end if;\n      res := applyintegrand(h, mk_ary('ary'(op(1,m), op(2,m), res), loops));\n      for i from op(1,m) to 1 by -1 do\n        res := integrate(eval(op(3,m), op(2,m)=i-1),\n                         Integrand(op(i,x), res), loops);\n      end do;\n      res\n    elif m :: 'Plate(anything, name, anything)' then\n      integrate(op(3,m), h, [op(2,m)=0..op(1,m)-1, op(loops)])\n    elif m :: 'Context(anything, anything)' then\n      applyop(integrate, 2, m, h, loops)\n    elif h :: appliable then\n      x := gensym('xa');\n      'integrate'(m, Integrand(x, h(x)), loops)\n    else\n      'procname(_passed)'\n    end if\n  end proc;\n\n\n  local\n  integrate_known := proc(make, makes, var, m, h, loops :: list(name=range), $)\n    local x, dens, bds;\n    x := mk_sym(var, h);\n    dens := density[op(0,m)](op(m));\n    bds := bounds[op(0,m)](op(m));\n    if loops = [] then\n      make(dens(x) * applyintegrand(h, x), x = bds);\n    else\n      makes(foldl(product, dens(mk_idx(x,loops)), op(loops))\n              * applyintegrand(h, x),\n            x, bds, loops)\n    end if;\n  end proc;\nend module; #toLO\n\n", "meta": {"hexsha": "37796f50c1e8dd411ff2c93e7b64fb0d76200ff1", "size": 3529, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "maple/NewSLO/To.mpl", "max_stars_repo_name": "zaxtax/hakaru", "max_stars_repo_head_hexsha": "03ac5b645815e99437e28d228e6c668753b2640e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2015-02-07T17:57:04.000Z", "max_stars_repo_stars_event_max_datetime": "2016-01-29T19:40:24.000Z", "max_issues_repo_path": "maple/NewSLO/To.mpl", "max_issues_repo_name": "zaxtax/hakaru", "max_issues_repo_head_hexsha": "03ac5b645815e99437e28d228e6c668753b2640e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "maple/NewSLO/To.mpl", "max_forks_repo_name": "zaxtax/hakaru", "max_forks_repo_head_hexsha": "03ac5b645815e99437e28d228e6c668753b2640e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.29, "max_line_length": 79, "alphanum_fraction": 0.5211107963, "num_tokens": 1100, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624789529375, "lm_q2_score": 0.5774953651858118, "lm_q1q2_score": 0.4519839541001594}}
{"text": "kernelopts(printbytes=false);\nwith(RigidMotionsRecoverNMM);\nLaunchFindDistinctSamplePoints([a,b,c], \"N2\", [-2, -1, 0, 1, 2], \"__REPLACE__\");\ndone\n\n", "meta": {"hexsha": "9ee392c225574a7b2bcaa21cd89148a56a71f942", "size": 147, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "scripts/misc/MapleScriptExampleSP.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": "scripts/misc/MapleScriptExampleSP.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": "scripts/misc/MapleScriptExampleSP.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": 24.5, "max_line_length": 80, "alphanum_fraction": 0.7210884354, "num_tokens": 52, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8080672227971212, "lm_q2_score": 0.5583269943353745, "lm_q1q2_score": 0.45116574372525003}}
{"text": "# Maple Code Generator\n\n##\n## Copyright (C) 2015-2017 Maplesoft\n## Authors:    Behzad Samadi <bsamadi@maplesoft.com>\n## Created:    September 2017\n## Version:    0.2\n## Keywords:   Maple, Code Generation, Model Predictive Control (MPC)\n##\n## Procedures:\n##             CGMRES\n##\n\nMapleCodeGenerator := module()\ndescription \"Maple code generation for numerical optimization\";\noption package;\n\nexport DotProduct,\n       GMRES,\n       GradientDescent,\n       LMGMRES,\n       Minimize1D,\n       NewName,\n       NewtonsMethod,\n       NewtonsMethodGMRES,\n       nfGMRES,\n       Norm2;\n\n$include \"DotProduct.mm\"\n$include \"GMRES.mm\"\n$include \"GradientDescent.mm\"\n$include \"LMGMRES.mm\"\n$include \"Minimize1D.mm\"\n$include \"NewName.mm\"\n$include \"NewtonsMethod.mm\"\n$include \"NewtonsMethodGMRES.mm\"\n$include \"nfGMRES.mm\"\n$include \"Norm2.mm\"\n\nend module; # MCG\n", "meta": {"hexsha": "4344fe5e3a2672ef65356b29d4c159b8032c9211", "size": 846, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "src/MapleCodeGenerator.mpl", "max_stars_repo_name": "SymbolicNMPC/MapleCodeGenerator", "max_stars_repo_head_hexsha": "331ad63601e6b38268f47f24c3a0f3f360a4d5bc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/MapleCodeGenerator.mpl", "max_issues_repo_name": "SymbolicNMPC/MapleCodeGenerator", "max_issues_repo_head_hexsha": "331ad63601e6b38268f47f24c3a0f3f360a4d5bc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/MapleCodeGenerator.mpl", "max_forks_repo_name": "SymbolicNMPC/MapleCodeGenerator", "max_forks_repo_head_hexsha": "331ad63601e6b38268f47f24c3a0f3f360a4d5bc", "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.6341463415, "max_line_length": 69, "alphanum_fraction": 0.6773049645, "num_tokens": 241, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8128673359709796, "lm_q2_score": 0.5544704649604273, "lm_q1q2_score": 0.4507109297269729}}
{"text": " # a function returning unary(i + j) * -998\n func $foo (\n  var %i i32,\n   var %j i32) f32 { \n   return (\n     recip f32(\n       sqrt f32(  \n      cvt f32 i32(\n        mul i32 (\n         extractbits i32 1 23 ( add i32 ( bnot i32 (dread i32 %i), lnot i32 (dread i32 %j))), \n         neg i32 ( constval i32 -998))))))}\n\n # EXEC: %irbuild Main.mpl\n # EXEC: %irbuild Main.irb.mpl\n # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl\n", "meta": {"hexsha": "a6e95d9cb500cfd1abc4b544e778c26dc97f53ea", "size": 419, "ext": "mpl", "lang": "Maple", "max_stars_repo_path": "test/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/Main.mpl", "max_stars_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_stars_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_stars_repo_licenses": ["MulanPSL-1.0"], "max_stars_count": 796, "max_stars_repo_stars_event_min_datetime": "2019-08-30T16:20:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-25T14:45:06.000Z", "max_issues_repo_path": "test/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/Main.mpl", "max_issues_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_issues_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_issues_repo_licenses": ["MulanPSL-1.0"], "max_issues_count": 16, "max_issues_repo_issues_event_min_datetime": "2019-08-30T18:04:08.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-19T05:02:58.000Z", "max_forks_repo_path": "test/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/Main.mpl", "max_forks_repo_name": "harmonyos-mirror/OpenArkCompiler-test", "max_forks_repo_head_hexsha": "1755550ea22eb185cbef8cc5864fa273caebf95a", "max_forks_repo_licenses": ["MulanPSL-1.0"], "max_forks_count": 326, "max_forks_repo_forks_event_min_datetime": "2019-08-30T16:11:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-26T12:31:17.000Z", "avg_line_length": 26.1875, "max_line_length": 94, "alphanum_fraction": 0.553699284, "num_tokens": 155, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835452961425, "lm_q2_score": 0.5389832206876841, "lm_q1q2_score": 0.45031161207527953}}