整数序列的变换N.J.A.斯隆这是一个纯文本文件，提供了许多Maple过程用于对序列和数字执行转换。这是整数序列在线百科全书（参见http://oeis.org)它广泛使用了这些转换。枫树程序下载这些程序的说明：下载此文件，去掉“####1#####”上面的所有内容（下面大约8行），将结果存储在一个名为transforms的文件中。然后可以通过说（在Maple中）将其直接读入Maple读取转换；#### 1 #####这是转换的官方版本#2020年5月10日：添加MP、COMPl2、二进制#2020年5月9日：修正POLY，WEIGH#2017年5月26日：新增运营、固定收入等#2013年10月12日：增加了digprod、digprod0、改进了digsum#2013年1月5日：Michael Somos的更正和测试代码（文件末尾）#2011年11月26日：增加FREQ#2011年7月16日：添加LAGRANGE#2010年10月22日：增加了两个Van Eck变换#2010年10月16日：理查德·马塔尔（Richard Mathar）发送了AERATE、DIRICHLETi、LODUMO、digcat2和digcatL#新增RUNS Nov 29 2009#2009年6月27日添加了粗壮#添加了来自Richard Mathar的ConvOffs和ConvOffsStoT，2008年2月1日#添加了INVERSE 2005年10月20日#添加INVERSE2 2017年2月16日#2004年7月1日：我必须做很多更改才能运行#在新的Maple（9.5）下正确。我真的很喜欢#Maple进行了更改，以便用旧的#版本永远不会在新版本下运行。#添加了LAH和LAHi，2003年10月5日#新增记录2002年9月17日#添加了SHADOW 2002年8月2日#补充大陆2002年7月18日#添加了Antti Karttunen的变换，2002年7月12日#添加了汉克尔，汉克尔，CONTINUANT，2002年6月10日#添加了目录排序2002年1月19日#2001年12月24日：REVERT和REVEGF转换中更正的标志。#修改日期：2001年6月17日#给自己的提示：创建文件transforms.txt do#生成转换.txt#用于转换序列的Maple程序集合#这些主要用于列表。例子：#a：=[1,1,2,3,5,8,13,21]；## [1, 1, 2, 3, 5, 8, 13, 21]##二项（a）；## [1, 2, 5, 13, 34, 89, 233, 610]#如果出现问题，它们将返回空列表[]，而不是错误消息。#要求您已经完成：使用（numtheory，mobius）：#带有（组合，斯特林1，斯特林2）和加载的gfun：with（numtheory，mobius）：with（组合，斯特林1，斯特林2）：#对于maple6，我在4/11/00将以下行从#with（share）：with（gfun）：#到带有（gfun）：#（实际上gfun包使用得不多，而且#这些转换中的大多数都将在没有它的情况下工作）#参考文献：M.Bernstein和NJAS，一些标准整数序列，#线性代数及其应用1995年第226-228卷第57-72页#可通过我的主页访问# http://neilsloane.com/doc/eigen.pdf#总结：#AERATE通过在序列中插入零来充气#ALLDIFFS所有差异a（j）-a（i），j>i#AND CONV AND卷积，求和a（k）。和.a（n-k）#从差异表的第一个对角线到顶行的BINOMIAL#BINOMIALi逆：从序列到diff表的前导图#BIN1是Zagier使用的BINOMIAL的变体#BISECT（a，0），BISECT#BOUS boutrophedon变换#BOUS2 boustrophedon变换（官方boust.transform）#BOUS2i投资。布斯特变换（官方布斯特变换）#序列的CHAR特征函数#序列的COMP补码#序列的COMPl补码（长版本）#COMPl2计算序列的补码（长版本2）#COMPOSE组合两个序列#COMPSQRT函数平方根#CONTINUANT连续变换，参见混凝土数学。第301页#CONTINUANTi逆连续变换（不总是积分）#CONV简单卷积，展开A（x）*B（x）#CONVi卷积的平方根，不总是整数#ConvOffs参见代码了解说明#ConvOffsStoT有关说明，请参阅代码#小数（a，k，0），小数（a、k，1）。。。抽取序列#DIFF第一差#DIGREV反向数字（对单个数字使用DIGREV）#DIGSUM数字和（对单个数字使用数字和）#两个序列的DIRICHLET-DIRICHLET卷积#DIRICHLETi算术序列的Dirichlet逆#ECKb向后Van Eck变换#ECKf Forwards Van Eck变换#欧拉-欧拉-Xfm#EULERi逆Euler Xfm#b的EXP egf=EXP（a的egf）#EXPCONV指数卷积，展开E1（x）*E2（x#EXTRACT提取子序列#FREQ b[n]=i的数量<=n，因此a[i]=a[n]#GCDCONV GCD卷积，SUM a（k）.GCD.a（n-k）#汉克尔-汉克尔变换#HEAP给定一个，从堆1开始，将a中最大的条目添加到堆中；b给出堆的连续大小#排列的逆#INVERSE2 a中n的最小倒数，如果缺少值，则为0#在1+SUM a_i x ^i=1/（1-SUM b_i x*i）中从b's求反a#逆i逆，b来自a#拉格朗日求和到n需要a的多少项#LAH b的egf=x处a的egf/（1-x）#LAHi b=x/（1+x）时a的egf#LCMCONV LCM卷积，和a（k）.LCM.a（n-k）#LEFT左移#lHANKEL小汉克尔变换#LISTTOLISTDIV将第n项除以n！#LISTTOLISTMULT将第n项乘以n！#LODUMO Deleham的LODUMO_m变换#b的日志egf=LOG（a的egf）#MASKCONV掩模卷积#具有全1序列的MASKTRANS掩码卷积#MASKTRANSi逆#MOBIUS MOBIUS（或Lambert）变换#MOBIUSi逆Mobius（或除数和）变换#MONO排序，丢弃重复项#MONO2排序，丢弃重复项，但前提是与原始值不同。#MP Maple Print（在一条长线上打印序列）#序列的myhead第一个L（默认值100）项#序列的mytail最后L（默认值100）项#M2将除第1项外的所有项乘以2#M2i将除第一学期外的所有学期除以2#否定除第一项外的所有项#ORCONV或卷积，和a（k）。或.a（n-k）#PARTITION分区Xfm（无重复）#PARTITIONi逆分区Xfm（无重复）#POLY从差分表的前导对角线获得序列的多项式#POWERS提取x在f中的幂到n次#部分产品的PRODS序列#PSUM部分总和#PSUMSIGN交替符号部分和#RECORDS从列表中提取记录#REVERT反转#REVEGF例如f.的撤销。#右移右，在前面加1#相同术语连续运行的长度#SEQPI产生单调序列a[]的pi函数#SERIESTOLISTDIV将第n项除以n！#SERIESTOLISTMULT将第n项乘以n！#SERIESTOSERIESDIV将第n项除以n！#SERIESTOSERIESMULT将第n项乘以n！#SERIES2双变量函数的级数展开#SERIES2TOLIST将SERIES2的输出转换为列表，顺序为00、10、01、20、11、02，。。。#SERIES2TOLISTMULT同上，将x^i*y^j的系数乘以i*j！#SERIES2HTOLIST将SERIES2的输出转换为列表，顺序为00、10、11、20、21、22，。。。#SERIES2HTOLISTMULT同上，将x^i*y^j的系数乘以i*j！#SHADOW参见A000522下序列数据库中的Lorenz Halbeisen和Norbert Hungerbuehler参考#斯特林-斯特林Xfm（第二类）#STIRLINGi逆Stirling Xfm（等价于第一类Stirling变换）#STIRB斯特林-伯努利变换#列表非零的支撑位置#三角形（a，0）。。TRISECT（a，2）三等分序列#UNBASE与convert（n，base，b）相反#1中a的权重b+总和b_n x ^n=产品（1+x ^a_n）#XORCONV XOR卷积，和a（k）。异或.a（n-k）#其他：#使用二进制展开式对两个数字进行ANDnos逻辑与运算#n的二进制表示，按人类顺序#delta delta（f，n，k）=f的第n个差值的第k项#用二元展开法求数字的导数#它分裂了吗？#它（用符号）分开了吗？#数字2连接两个数字#digcatL连接数字列表#数字反转数字#数字的数字乘积#非零数字的digprod0乘积#按递增顺序对数字进行数字排序#digsortrev将数字按降序排序#数字和#它遮住了吗？#Etrans-Euler Xfm（再次）#eultrans2来自Donaghey和Shapiro论文的第二次欧拉变换#但这和BINOMIALi一样#mex最小排除数#myconvert（n，b）=按正确顺序转换（n，base，b）#尼姆和尼姆和#使用二进制展开式对两个数字进行“或”逻辑“或”运算#pairtrans b（n）=a（n）+a（n-1）#pairtransi a（n）=b（n）-b（n-1）+b（n-2）-。。。#ptrans分区Xfm（带重复）#stoint将字符串转换为整数#traptrans逆分区Xfm（带重复）#在1+SUM b_n x^n=PI（1+x^n）^a_n中从a称量b#1中b的weighouti a+SUM b_n x ^n=PI（1+x ^n）^a_n#1中b的加权a+总和b_n x ^n=PI（1+x ^a_n）#1中a的称重2 b+总和b_n x ^n=PI（x ^-n+1+x ^n）^a_n#1中b的权重2outi a+总和b_n x ^n=PI（x ^-n+1+x ^n）^a_n#1中a的称重2in b+总和b_n x ^n=PI（x^-a_n+1+x^a_n）#从1中的b开始称重2ini a+总和b_n x ^n=PI（x^-a_n+1+x^a_n）#wt计算n的二进制展开式中1的权重或数量：#使用二进制展开的两个数字的异或逻辑异或δ：=过程（f，n，k）局部i；加（（-1）^（n-i）*二项式（n，i）*f（k+i），i=0..n）；结束时间：did：=进程（m，n）如果irem（m，n）=0，则1其他0:fi：结束：dids:=proc（m，n）如果irem（m，n）=0，则（-1）^（m/n）否则0:fi：结束：#它会遮罩（j over i）吗？dim:=proc（j，i），如果ANDnos（j，i）=i，则为1；否则为0；fi；结束时间：mob:=proc（m，n）如果irem（m，n）=0，则mobius（m/n）否则0:fi:end：#参考：Marc LeBrun(mlb@well.com)信息#“半生不熟的广义卷积序列变换”#于2001年6月9日发布在SeqFan邮件列表上(seqfan@ext.jussieu.fr)#网址：http://www.ccr.jussieu.fr/gmpib/seqfan/seqfan.html#此外网址：http://www.megabaud.fi/~karttu/matikka/findnext.txtMASKCONV：=进程（a，b）局部c，i，j，n；如果是whattype（a）<>列表，则返回（[]）；fi；如果是whattype（b）<>列表，则返回（[]）；fi；n：=最小值（nops（a），nops（b））；c:=[]；对于从0到n-1的j做c：=[op（c），加上（dim（j，i）*a[i+1]*b[（j-i）+1]，i=0..j）]；od；返回（c）；结束时间：#MASKTRANS（a）相当于MASKCONV（a，A000012），其中A000012为#全1的序列。MASKTRANS：=proc（a）局部c，i，j，n；如果是whattype（a）<>列表，则返回（[]）；fi；n：=nops（a）；c:=[]；对于从0到n-1的j做c：=[op（c），加上（dim（j，i）*a[i+1]，i=0..j）]；od；返回（c）；结束时间：MASKTRANSi:=a->MASKCONV（a，[seq（（-1）^（wt（j）mod 2），j=0..nops（a）-1）]）：#HEAP转换。假设a是单调的，以0或1开头HEAP:=proc（a）本地pttemp，pt，la，lb，MAXLEN，HEAP，b，i，k:如果是whattype（a）<>列表，则返回（[]）；图1：如果a[1]<0或a[1]>1，则返回（[]）；图1：la：=nops（a）；磅：=1；堆：=1；b： =[堆]：pt:=1；最大值：=最小值（50，la）；；对于从1到MAXLEN do的k#我们可以提高pt吗？pttemp:=pt；对于i，从pt+1到la do如果a[i]<=堆，则pttemp：=i；否则断裂；fi；od；pt：=pttemp；#延伸b？如果lb<MAXLEN，则堆：=堆+a[pt]；b： =[op（b），堆]；磅：=磅+1；否则返回（b）；fi；od；返回（b）；结束时间：#支持列表非零的位置，从1开始计数支持：=proc（a）local b，i；如果是whattype（a）<>列表，则返回（[]）；图1：b： =[]；对于i从1到nops（a）do如果a[i]<>0，则b:=[op（b），i]；fi；日期：返回（b）；结束时间：#MONO：对abs值排序，丢弃重复项单声道：=程序（a）：如果是whattype（a）<>列表，则返回（[]）；图1：排序（转换（转换（map（abs，a），set），list））；结束时间：#MONO2：对abs值排序，丢弃重复项，除非seq，否则返回null。已更改MONO2:=程序（a）局部b，bu:如果是whattype（a）<>列表，则返回（[]）；图1：b： =排序（转换（转换（map（abs，a），set），list））；如果a=b，则返回（[]）；否则返回（b）；fi；结束时间：#COMP：计算序列的补码#即向量[a[0]。。。a[i]。。。[maxn]]是不按顺序排列的数字#如果N<maxn是max|term|，则在N处停止COMP:=proc（a）局部maxn，notmember，b，c，n1，n，m：如果是whattype（a）<>列表，则返回（[]）；图1：最大值：=80：#获得单调且唯一的版本bb： =单（a）；n1：=nops（b）；如果n1=0，则返回（[]）；图1：n： =b[n1]；m： =最小值（maxn，n）；notmember:=子项（_WZ=b，进程（x）非成员（x，_WZ）结束）；c： =选择（notmember，[1..m]）；#如果补码太长或太短，则不返回任何内容#如果nops（c）<10或nops（c）>50，则返回（[]）；否则返回（c）；fi；结束时间：#COMPl：计算序列的补码（长版本）#即向量[a[0]。。。a[i]。。。[maxn]]是不按顺序排列的数字#小心使用！！！COMPl:=proc（a）局部notmember，b，n1，m:如果是whattype（a）<>列表，则返回（[]）；图1：#获得单调唯一的版本bb： =单（a）；n1：=nops（b）；如果n1=0，则返回（[]）；图1：m： =最小值（b[n1]，1000）；notmember:=子项（_WZ=b，进程（x）非成员（x，_WZ）结束）；选择（非成员，[1..m]美元）；结束时间：#CHAR：计算序列的特征函数#即向量[a[0]。。。a[i]。。。a[100]，如果|i|按顺序为1，如果不是，则为0#如果N<100是顺序中的max|term|，则在N处停止CHAR:=proc（a）局部maxn，ap，b，i，k，n，m：如果是whattype（a）<>列表，则返回（[]）；图1：最大值：=100：对于从0到maxn的n，do b[n]：=0；od；m： =0：对于n从1到nops（a）doap:=abs（a[n]）：如果ap<=maxn，则b[ap]：=1；fi；如果ap>m，则m:=ap；fi；od；[seq（b[n]，n=0..分钟（最大值，m）]；结束时间：#返回序列S的子序列，开始于/开始于/有周期/周期/抽取：=proc（S，period，start）局部i，a，b；如果whattype（S）<>列表，则返回（[]）；图1：a:=nops（S）-启动；b： =楼层（a/周期）；[seq（S[周期*i+开始]，i=0..b）]；结束时间：#b[n]=i≤n的数量，使得a[i]=a[n]。#参见A200779、A200780频率：=proc（a）局部b，i，c，n，t1：如果是whattype（a）<>列表，则返回（[]）；图1：b： =[]；对于n从1到nops（a）doc： =0；t1:=a[n]；对于i从1到n，do如果a[i]=t1，则c：=c+1；fi；日期：b： =[op（b），c]；od；返回（b）；结束时间：#返回项的子序列==j mod k小数：=proc（a，k，j）局部b，i，l：如果是whattype（a）<>列表，则返回（[]）；图1：l： =trunc（（nops（a）+k-1-j）/k）：如果l<1，则返回（[]）；传真：b： =[]：对于i到l做b:=[op（b），a[k*（i-1）+j+1]]：od：返回（b）；结束时间：BISECT:=进程（a，j）局部b，i，l：如果是whattype（a）<>列表，则返回（[]）；图1：如果j＜0或j＞1，则返回（[]）；图1：l： =trunc（（nops（a）+1-j）/2）：如果l<1，则返回（[]）；图1：b： =[]：对于i到l做b:=[op（b），a[2*（i-1）+j+1]]：od：返回（b）；结束时间：TRISECT:=程序（a，j）局部b，i，l：如果是whattype（a）<>列表，则返回（[]）；图1：如果j＜0或j＞2，则返回（[]）；图1：l： =trunc（（nops（a）+2-j）/3）：如果l<1，则返回（[]）；图1：b： =[]：对于i到l做b:=[op（b），a[3*（i-1）+j+1]]：od：返回（b）；结束时间：#计算序列的第一个差异DIFF:=程序（a）局部b，i:如果是whattype（a）<>列表，则返回（[]）；图1：如果nops（a）<=1，则返回（[]）；图1：b： =[]：对于i从2到nops（a），dob:=[op（b），a[i]-a[i-1]]：od：返回（b）；结束时间：#计算序列的所有差异。#警告：除非原始序列快速增加，#在随后的序列中可能会有小的差异#错过了！ALLDIFFS:=进程（a）局部b，i，j：如果是whattype（a）<>列表，则返回（[]）；图1：如果nops（a）<=1，则返回（[]）；图1：b： ={}：对于i从1到nops（a）-1 do对于从i+1到nops（a）的j，做b:={op（b），a[j]-a[i]}:od:od：RETURN（排序（转换（b，列表）））；结束时间：#PRODS部分产品的形式序列b[n]=a[1]**a【n】产品：=proc（a）局部n，b，i，t1；如果是whattype（a）<>列表，则返回（[]）；图1：n： =nops（a）；b： =[]；如果n>0，则t1:=1；对于i从1到n dot1:=t1*a[i]；b： =[op（b），t1]；od；fi；返回（b）；结束时间：PSUM:=进程（a）局部b，i，s：如果是whattype（a）<>列表，则返回（[]）；图1：如果nops（a）<=0，则返回（[]）；图1：b： =[]：s： =0：对于i从1到nops（a）dos： =s+a[i]：b： =[操作（b），s]：日期：返回（b）；结束时间：PSUMSIGN:=进程（a）局部b，i，s：如果是whattype（a）<>列表，则返回（[]）；图1：如果nops（a）<=0，则返回（[]）；图1：b： =[]：s： =0：对于i从1到nops（a）dos： =a[i]-s：b： =[操作（b），s]：日期：返回（b）；结束时间：二进制：=进程（a）局部b，i，k：如果whattype（a）<>列表，则返回（[]）；图1：b： =[]：对于i到nops（a）do b:=[op（b），加上（二项式（i-1，k）*a[k+1]，k=0..i-1）]：od：返回（b）；结束时间：BINOMIALi:=进程（a）局部b，i，k：如果是whattype（a）<>列表，则返回（[]）；图1：b： =[]：对于i到nops（a）do b:=[op（b），添加（（-1）^（i-1-k）*二项式（i-1，k）*a[k+1]，k=0..i-1）]：od：返回（b）；结束时间：#BIN1是由Don Zagier引入的（参见M.Kaneko，#“伯努利数的递推公式”，#程序。日本科学院。，71 A（1995），192-193）。这是一种内卷化#关于序列a=[a_0，a_1，a_2，…]的类，#将a发送到b，其中b_n=（-1）^n和{i=0..n}二项式（n+1，i+1）a_i。BIN1：=进程（a）局部b，i，j，k：如果是whattype（a）<>列表，则返回（[]）；图1：b： =[]：对于i到nops（a），做j:=i-1；b： =[op（b），（-1）^j*加（二项式（j+1，k+1）*a[k+1]，k=0..j）]：日：返回（b）；结束时间：#EULER取[a_1，a_2，a_3，…]并用#1+Sum_{n=1..inf}b_nx^n=1/Product_{n=1..inf}（1-x^n）^a_n。欧拉：=proc（a）局部b，c，i，d：如果是whattype（a）<>列表，则返回（[]）；传真：c： =[]：对于i到nops（a）do c:=[op（c），添加（d*did（i，d）*a[d]，d=1..i）]：od：b： =[]：对于i到nops（a）dob： =[操作（b），（1/i）*（c[i]+添加（c[d]*b[i-d]，d=1..i-1）]：od：返回（b）；结束时间：EULERi:=proc（b）局部a，c，i，d:如果是whattype（b）<>列表，则返回（[]）；图1：c： =[]：对于i到nops（b）do c:=[op（c），i*b[i]-加（c[d]*b[i-d]，d=1..i-1）]：od：a： =[]：对于i到nops（b），执行a:=[op（a），（1/i）*add（mob（i，d）*c[d]，d=1..i）]：od:返回（a）；结束时间：MOBIUS:=程序（a）局部b，i，d：如果是whattype（a）<>列表，则返回（[]）；图1：b： =[]：对于i到nops（a）dob:=[op（b），添加（mob（i，d）*a[d]，d=1..i）]：od:返回（b）；结束时间：MOBIUSi:=程序（a）局部b，i，d：如果是whattype（a）<>列表，则返回（[]）；图1：b： =[]：对于i到nops（a）do b:=[op（b），添加（did（i，d）*a[d]，d=1..i）]：od：返回（b）；结束时间：#POLY从差分表的前导对角线获得序列的多项式#njas于2020年5月9日修正POLY:=程序（a）局部t1，b，i，k：如果是whattype（a）<>列表，则返回（[]）；图1：排序（展开（加法（二项式（n，k）*a[k+1]，k=0..nops（a）-1））；结束时间：#POWERS从f到n次提取x的幂权力：=proc（f，x，n）局部i，g，lis；利斯：=[]：g： =集合（展开（f），x）；对于i从0到n do如果coeff（g，x，i）<>0，则lis:=[op（lis），i]；fi；od；回报（lis）；结束时间：STIRLING:=程序（a）局部b，i，k，n：如果是whattype（a）<>列表，则返回（[]）；图1：n： =无（a）：b： =[]：对于i从1到n，do b:=[op（b），add（combint[stirling2]（i，k）*a[k]，k=1..i）]：od：返回（b）；结束时间：STIRLINGi:=程序（a）局部b，i，k，n：如果是whattype（a）<>列表，则返回（[]）；图1：n： =无（a）：b： =[]：对于i从1到n做b:=[op（b），加（组合[stirling1]（i，k）*a[k]，k=1..i）]：od：返回（b）；结束时间：#“Stirling-Bernoulli变换”映射序列b_0、b_1、b_2。。。#序列c0，c1，c2。。。，其中，如果B具有o.g.f.B（x），则c具有#例如，f.exp（x）*B（1-exp（x））。更明确地说，#c_n=和{m=0..n}（-1）^m*m*箍筋2（n+1，m+1）*b_m。#感谢Masanobu Kaneko告诉我这件事。STIRB:=程序（a）局部b，j，k，n：如果是whattype（a）<>列表，则返回（[]）；图1：n： =无（a）：b： =[]：对于从0到n-1的j dob： =[op（b），加法（（-1）^k*k！*组合[stirling2]（j+1，k+1）*a[k+1]，k=0..j）]：日期：返回（b）；结束时间：#Cameron的A和逆：1+SUM A_n x ^n=1/（1-SUM b_n x*n）；n=1..inf#即1+A（x）=1/（1-B（x））#a来自b：反转：=程序（a）局部t1，t2，x，b，n：如果是whattype（a）<>列表，则返回（[]）；传真：n： =nops（a）+1：b： =列表系列（a，x，'ogf'）：t1:=系列（1/（1-x*b），x，n）：t2:=底图（1=NULL，序列列表（t1，'ogf'））：如果类型为（t2，list（integer）），则返回（t2），否则返回（[]）：fi:结束时间：#相反，b来自a：反演：=proc（a）局部t1，x，b，n：如果是whattype（a）<>列表，则返回（[]）；图1：n： =nops（a）+1：b： =列表系列（a，x，'ogf'）：t1:=系列（-1/（1+x*b），x，n）：返回（子图（1=NULL，序列列表（t1，'ogf'））：结束时间：#反转序列的反转。#已更正（以便与最新版本的Maple一起使用），2017年5月26日#要对此进行测试，请设置a:=[1,3,5,7,9,11,13,15,17]；则REVERT（a）应产生# [1, -3, 13, -67, 381, -2307, 14589, -95235, 636925]反转：=程序（a）局部灰化，t1，t2，x，b，n：如果是whattype（a）<>列表，则返回（[]）；图1：如果a[1]<>1，则返回（[]）；图1：灰化：=[0，op（a）]；b： =列表系列（ashift，x，'ogf'）：t1:=系列（b，‘evogf’）；t2:=底图（1=NULL，序列列表（t1，'ogf'））：如果类型为（t2，list（integer）），则返回（t2），否则返回（[]）：fi:结束时间：#REVEGF序列的指数反转。#已更正（以便与最新版本的Maple一起使用），2017年5月26日#要对此进行测试，请设置a:=[1,3,5,7,9,11,13,15,17]；则REVEGF（a）应产生# [1, -3, 22, -262, 4336, -91984, 2381408, ...]版本：=proc（a）局部灰化，t0，t3，i，t1，t2，x，b，n：如果是whattype（a）<>列表，则返回（[]）；图1：如果a[1]<>1，则返回（[]）；传真：灰化：=[0，op（a）]；b： =列表系列（ashift，x，'egf'）：t0:=系列（b，'revogf'）：t1:=系列列表（t0，‘ogf’）；t3:=[seq（t1[i]*（i-1）！，i=1…nops（t1）]；t2：=亚音速（1=空，t3）；如果类型为（t2，list（integer）），则返回（t2），否则返回（[]）：fi:结束时间：复合：=proc（a，b）局部t1，n，f，g，T，U，x，i，j；如果是whattype（a）<>列表，则返回（[]）；图1：如果是whattype（b）<>列表，则返回（[]）；图1：n： =最小值（nops（a），nops（b））：f： =不适用（转换（[seq（op（i，a）*T^i，i=1..n）]，`+`），T）；g： =不适用（转换（[seq（op（j，b）*U^j，j=1..n）]，`+`），U）；t1:=系列列表（系列（f（g（x）），x，n+1））；返回（亚音速（1=空，t1））；结束时间：COMPSQRT:=进程（b，M）#b（x）的合成平方根=总和b[i]*x^i，i=1..M#求出a（x）=和b[i]*x^i，i=1..M，这样a（a（x））=b（x）。#示例：COMPSQRT（sin（x），10）；应该产生#x-1/12*x^3-1/160*x^5-53/40320*x^7-23/71680*x^9+。。。局部i，j，a1，t1，t2，t3，a，e，s，a，B；#建立方程式B： =系列（B，x，M+1）；a1:=abs（sqrt（系数（B，x，1）））；A： =a1*x+加法（A[i]*x^i，i=2..M）；t1:=不适用（A，x）；t2：=t1（t1（x））；t3：=系列（t2-B，x，M+1）；对于从2到M的i，e[i]：=系数（t3，x，i）；日期：#解决它们对于i从2到M dos[i]：=求解（e[i]，a[i]）；对于从2到M的j，do e[j]：=eval（subs（a[i]=s[i]，e[j]））；日期：日期：#计算答案级数（a1*x+add（s[i]*x^i，i=2..M），x，M+1）；结束时间：CONV:=进程（a，b）局部c，i，k，n：如果是whattype（a）<>列表，则返回（[]）；图1：如果是whattype（b）<>列表，则返回（[]）；图1：n： =最小值（nops（a），nops（b））：c： =[]：对于i从0到n-1 doc： =[op（c），加上（a[k+1]*b[i-k+1]，k=0..i）]：od；返回（c）；结束时间：CONVi:=进程（b）局部n、b、a、a、i、t1、t2、t3：如果是whattype（b）<>列表，则返回（[]）；图1：如果b[1]=0，则返回（[]）；图1：n： =无（b）：B： =列表系列（B，x，‘ogf’）：a： =[]：对于从0到n-1的i，执行a:=[op（a），a|i]：od:A： =列表系列（A，x，'ogf'）：t1:=系列（A^2-B，x，n）：对于i从0到n-1 dot2：=求解（系数（t1，x，i），a | | i）：如果whattype（t2）=exprseq，则t3：=t2[1]：否则t3：=t2:fi：t1:=子（a|i=t3，t1）：A： =子项（A||i=t3，A）：日期：返回（序列列表（A，'ogf'））：结束时间：LCMCONV:=程序（a）局部b，i，k，n：如果是whattype（a）<>列表，则返回（[]）；图1：n： =无（a）：b： =[]：对于从0到n-1的i，做b:=[op（b），加上（lcm（a[k+1]，a[i-k+1]），k=0..i）]：od：返回（b）；结束时间：GCDCONV:=程序（a）局部b，i，k，n：如果是whattype（a）<>列表，则返回（[]）；传真：n： =无（a）：b： =[]：对于从0到n-1的i，做b:=[op（b），加上（gcd（a[k+1]，a[i-k+1]），k=0..i）]：od：返回（b）；结束时间：ANDCONV：=进程（a）局部b，i，k，n：如果whattype（a）<>列表，则返回（[]）；图1：n： =无（a）：b： =[]：对于从0到n-1的i，做b:=[op（b），加上（ANDnos（a[k+1]，a[i-k+1]），k=0..i）]：od：返回（b）；结束时间：ORCONV:=进程（a）局部b，i，k，n：如果是whattype（a）<>列表，则返回（[]）；图1：n： =无（a）：b： =[]：对于从0到n-1的i，做b:=[op（b），加上（ORnos（a[k+1]，a[i-k+1]），k=0..i）]：od：返回（b）；结束时间：XORCONV:=进程（a）局部b，i，k，n：如果是whattype（a）<>列表，则返回（[]）；图1：n： =无（a）：b： =[]：对于从0到n-1的i，做b:=[op（b），加上（异或数（a[k+1]，a[i-k+1]），k=0..i）]：od：返回（b）；结束时间：#使用二进制展开形式对两个整数进行AND、OR或XOR运算ANDnos:=进程（n，m）局部ans，n1，m1，k1，k2，q1，q2，sc；如果n<0或m<0，则ERROR（“负参数”）：fi:答：=0:n1:=n:m1:=m:sc:=1：而n1≤0或m1≤0k1：=irem（n1,2，'q1'）：k2：=irem（m1,2，'q2'）：ans:=ans+sc*k1*k2；sc:=2*sc；n1：=q1：m1：=q 2：od；返回（ans）；结束时间：O数：=过程（n，m）局部k、ans、n1、m1、k1、k2、q1、q2、sc；如果n<0或m<0，则ERROR（“负参数”）：fi:ans:=0:n1:=n:m1:=m:sc:=1:而n1≤0或m1≤0k1：=irem（n1,2，'q1'）：k2：=irem（m1,2，'q2'）：如果k1=1或k2=1，则k:=1；否则k:=0；fi；ans：=ans+sc*k；sc:=2*sc；n1：=q1：m1：=q 2：od；返回（ans）；结束时间：异或数：=进程（n，m）局部k，ans，n1，m1，k1，k2，q1，q2，sc；如果n<0或m<0，则ERROR（“负参数”）：fi:答：=0:n1:=n:m1:=m:sc:=1：而n1≤0或m1≤0k1：=irem（n1,2，'q1'）：k2：=irem（m1,2，'q2'）：如果k1+k2=1，则k:=1；否则k:=0；fi；ans：=ans+sc*k；sc:=2*sc；n1：=q1：m1：=q 2：od；返回（ans）；结束时间：#定义的长度为n的二进制字符串的导数#通过u的二进制展开#示例：u=5被视为长度为4的二进制字符串是#0101带导数（或差值）111，所以是导数（5,4）#返回7。导数：=proc（u，n）局部t0，t1，t2；t0:=2^n+u；t1:=地板（t0/2）；t2:=异或数（t0，t1）；ANDnos（t2,2^（n-1）-1）；结束时间：#LISTTOLISTDIV通过将第n项除以n！将列表转换为列表！LISTTOLISTDIV:=程序（a）局部n，b，i；如果是whattype（a）<>列表，则返回（[]）；图1：n： =nops（a）；b： =[]；对于i从1到n，做b:=[op（b），a[i]/（i-1）！]；od；结束时间：#LISTTOLISTMULT通过将第n项乘以n将列表转换为列表！LISTTOLISTMULT:=程序（a）局部n，b，i；如果是whattype（a）<>列表，则返回（[]）；图1：n： =nops（a）；b： =[]；对于i从1到n，做b:=[op（b），a[i]*（i-1）！]；od；结束时间：#SERIESTOLISTDIV通过将第n项除以n！将序列转换为列表！SERIESTOLISTDIV:=程序（a）局部t1，n，b，i；如果whattype（a）<>系列，则RETURN（[]）；图1：t1:=系列列表（a）；n： =nops（t1）；b： =[]；对于i从1到n，做b:=[op（b），t1[i]/（i-1）！]；od；结束时间：#SERIESTOLISTMULT将序列转换为列表，方法是将第n项乘以n！SERIESTOLISTMULT:=程序（a）局部t1，n，b，i；如果是whattype（a）<>series，则返回（[]）；图1：t1:=系列列表（a）；n： =nops（t1）；b： =[]；对于i从1到n，做b:=[op（b），t1[i]*（i-1）！]；od；结束时间：#SERIESTOSERIESDIV通过将第n项除以n！SERIESTOSERIESDIV:=进程（a）局部x，t1，n，b，i；如果是whattype（a）<>series，则返回（0）；图1：x： =op（0，a）；t1:=系列列表（a）；n： =nops（t1）；b： =0；对于i从1到n，做b:=b+t1[i]*x^（i-1）/（i-1！；od；级数（b，x，n+1）；结束时间：#SERIESTOSERIESMULT通过将第n项乘以n将级数转换为级数！SERIESTOSERIESMULT:=进程（a）局部x，t1，n，b，i；如果是whattype（a）<>series，则返回（0）；图1：x： =运算（0，a）；t1:=系列列表（a）；n： =nops（t1）；b： =0；对于从1到n的i，做b:=b+t1[i]*x^（i-1）*（i-1）！；od；级数（b，x，n+1）；结束时间：#程序PARTITION采用列表l，#并确定方法的数量P（i）#将1到max（list）之间的整数i划分为列表中的数字#（不计算重复次数）。输出是列表[P（1），P（2），…]。#l应该以1开头，否则将跳过输出中的0。#第二个参数可以用来缩短输出的长度，这可以#否则在迭代下会很快变得无法管理：参数是#number>=0，指定输出列表应比#输入列表。分区：=proc（）局部f，g，i，translist，n，lp，l：l： =参数[1]：如果whattype（l）<>列表，则返回（[]）；图1：l： =转换（l，集合）；lp:=转换（l，list）；如果nargs=1，则n：=max（op（lp）），否则n：=args[2]fi：f:=1：对于i到nops（lp）而lp[i]<=n dof： =f/（1-t^op（i，lp））od：g： =泰勒（f，t=0，n+1）：translist:=[]：对于i从2到nops（g）/2-1 dotranslist:=[op（translist），op（2*i-1，g）]：日期：转列表；结束时间：PARTITIONi:=过程（l）局部t，i，j，l1：如果whattype（l）<>列表，则返回（[]）；图1：t： =欧元（l）；l1：=[]：对于i到nops（t）do对于从1到t[i]的j，do l1：=[op（l1），i]od：日期：l1；结束时间：#权重转换：b来自1中的a+SUM b_n x ^n=PROD（1+x ^a_n）#用法：WEIGH（[1,2,4,8]）；将生成[1,1,1,1,1，1,1，1]重量：=proc（）局部a、x、f、n、g、i：a： =参数[1]：如果是whattype（a）<>列表，则返回（[]）；图1：如果nargs=1，则n：=max（op（a）），否则n：=args[2]fi：f:=1:对于i到nops（a）dof:=f*（1+x^a[i]）od:g： =泰勒（f，x=0，n+1）：返回（子图（1=NULL，序列列表（g，'ogf'））：#返回（序列列表（g））：结束时间：#EXP将[a_1、a_2…]转换为[b_1、b_2…]，其中#1+EGF_B（x）=exp EGF_A（x）（参考Eigen Seq论文第61页）EXP:=程序（a）局部i，t0，t1，t2，x，b，n：如果是whattype（a）<>列表，则返回（[]）；图1：b： =[0，op（a）]；n： =无（b）+1：t0：=系列（exp（列表系列（b，x，‘egf’）），x，n）：t1:=系列列表（t0，‘ogf’）；t2:=[seq（t1[i]*（i-1）！，i=1…nops（t1）]；返回（底图（1=NULL，t2））；结束时间：EXPCONV：=程序（a，b）局部i，t0，t1，x，n：如果是whattype（a）<>列表，则返回（[]）；图1：如果whattype（b）<>列表，则返回（[]）；图1：n： =最小值（nops（a），nops（b））：t0：=系列（列表系列（a，x，‘egf’）*列表系列（b，x，’egf‘），x，n）；t1:=系列列表（t0，‘ogf’）；[seq（t1[i]*（i-1）！，i=1…nops（t1）]；结束时间：#LOG将[a_1，a_2，…]转换为[b_1，b_2，…]，其中#1+EGF_A（x）=exp EGF_B（x）（参考Eigen Seq论文第61页）#即EGF_A（x）=对数（1+EGF_B（x））。日志：=proc（a）局部t2，t0，i，t1，x，b，n：如果是whattype（a）<>列表，则返回（[]）；图1：b： =[1，op（a）]；n： =无（b）+1：t0：=系列（对数（列表系列（b，x，‘egf’）），x，n）：t1:=系列列表（t0，‘ogf’）；t2:=[seq（t1[i]*（i-1）！，i＝1..nops（t1））]；返回（底图（1=NULL，t2））；结束时间：#向左移位左：=进程（a）返回（子进程（1=NULL，a））：结束：#右移右：=proc（a）RETURN（[1，op（a）]）：结束：#计算相同项的运行长度序列运行：=proc（a）local b，i，prev，ct：如果是whattype（a）<>列表，则返回（[]）；图1：如果nops（a）=1，则返回（[1]）；fi；b： =[]：对于i从1到nops（a）do如果i=1，则上一个：=a[1]；ct：=1；其他的如果a[i]=上一个，则ct：=ct+1；否则b:=[op（b），ct]；ct：=1；上一个：=a[i]；fi；fi；如果i=nops（a），则b:=[op（b），ct]；fi；od；返回（b）；结束时间：M2:=程序（a）局部i，b，n：如果是whattype（a）<>列表，则返回（[]）；图1：n： =无（a）：b： =[a[1]：如果n=1，则返回（b）；传真：对于i从2到n的dob:=[op（b），2*a[i]]；日期：返回（b）；结束时间：M2i:=程序（a）局部i，b，n：如果是whattype（a）<>列表，则返回（[]）；图1：n： =无（a）：b： =[a[1]：如果n=1，则返回（b）；图1：对于i从2到n的dob:=[op（b），a[i]/2]；日期：返回（b）；结束时间：负数：=proc（a）局部i，b，n：如果是whattype（a）<>列表，则返回（[]）；图1：n： =无（a）：b： =[a[1]：如果n=1，则返回（b）；图1：对于i从2到n，dob:=[op（b），-a[i]]；日期：返回（b）；结束时间：#其他变换：#称重2：b来自a的输入#1+SIGMA b_n x^n=PI的非负部分（x^-n+1+x^n）^a_n#a_n-->b_n称重2：=程序（a）局部t0，n，x，f，i：如果是whattype（a）<>列表，则返回（[]）；图1：n： =nops（a）+1：f： =1：对于i到nops（a）do f:=f*（x^（-i）+1+x^i）^a[i]：od：t0：=系列（系列（展开（f），x，n），'ogf'）：返回（序列列表（t0，'ogf'））：结束时间：#欧拉事务2eultrans2:=过程（a）局部t0，x，n：如果是whattype（a）<>列表，则返回（[]）；图1：n： =无（a）+1：t0：=系列（（1/（1+x））*子（x=x/（1+x），列表系列（a，x，'ogf'）），x，n）：返回（序列列表（t0，'ogf'））：结束时间：#威霍特：b来自a的#1+SIGMA b_n x ^n=PI（1+x ^n）^a_n#（曾是Etrans2）：a_n--->b_nweighout:=进程（l）局部x，f，g，i：如果whattype（l）<>列表，则返回（[]）；图1：f:=1：对于i到nops（l）do f:=f*（1+x^i）^l[i]od：g： =泰勒（f，x=0，nops（l）+1）：返回（子图（1=NULL，序列列表（g，'ogf'））：结束时间：#威古提：a来自b的in#1+SIGMA b_n x ^n=PI（1+x ^n）^a_n#b_n-->n_nweighouti:=进程（b）本地c、i、d、a：如果是whattype（b）<>列表，则返回（[]）；图1：c： =[]：对于i到nops（b）do c:=[op（c），i*b[i]-加（c[d]*b[i-d]，d=1..i-1）]：od：a： =[c[1]；对于i从2到nops（b），执行a:=[op（a），c[i]/i-（1/i）*添加（-dids（i，d）*a[d]*d，d=1..i-1）]：od：返回（a）：结束时间：#EULER（再次）#过程Etrans获取列表l并确定Euler变换#列表中的。输出列表以中的第一个系数开始#泰勒系列。Etrans:=进程（l）局部f，g，i，j，translist：如果whattype（l）<>列表，则返回（[]）；图1：f:=1：对于i到nops（l）dof:=f/（（1-t^i）^op（i，l））od：g： =泰勒（f，t=0，nops（l）+1）：translist:=[]：对于i从2到nops（g）/2-1 do对于从op（2*i-2，g）+1到op（2*1，g）-1 do的jtranslist:=[op（translist），0]：日期：translist:=[op（translist），op（2*i-1，g）]：日期：转列表；结束时间：#过程ptrans接受列表l，#并确定在1之间划分整数i的方法的数量P（i）#和max（list）从列表中输入数字（WITH REPETIONS）。输出为#列表[P（1），P（2），…，P（m）]。l应该以1开头，否则为0#将跳过输出中的。#第二个参数可用于缩短输出的长度，这可以#否则在迭代下会很快变得无法管理：参数是#number>=0，指定输出列表应比#输入列表。ptrans:=进程（）局部f，g，i，translist，n，l：l： =参数[1]：如果whattype（l）<>列表，则返回（[]）；图1：如果nargs=1，则n：=max（op（l）），否则n：=args[2]+nops（l）fi：f:=1：对于i到nops（l）dof:=f/（1-t^op（i，l））od:g： =泰勒（f，t=0，n+1）：translist:=[]：对于i从2到nops（g）/2-1 dotranslist:=[op（translist），op（2*i-1，g）]：日期：转列表；结束时间：#双反式pairtrans:=进程（a）局部i，b，n；如果是whattype（a）<>列表，则返回（[]）；图1：n： =无（a）：b： =[a[1]：如果n=1，则返回（b）；传真：对于i从2到n的dob:=[op（b），a[i]+a[i-1]]；日期：返回（b）；结束时间：#我澄清了这些定义：#BOUS转换将[a1，a2，a3，…]转换为[b0=1，b1，b2，…]，#三角形在哪里#b0=1#a1-->b1#b2*<---a2#a3-->**b3#等。# #BOUS2变换取[a0，a1，a2，a3，…]到[b0，b1，b2，…]，#三角形在哪里#a0=b0#a1-->b1#b2*<---a2#a3-->**b3#等。BOUS:=proc（a）局部c，i，j，n：如果是whattype（a）<>列表，则返回（[]）；图1：n： =最小值（nops（a），60）；c[0,0]：=1；对于i到n做c[i，0]：=a[i]；od；对于我来说对我来说是jc[i，j]：=c[i、j-1]+c[i-1、i-j]；od；od；返回（[seq（c[i，i]，i=0..n）]）；结束时间：BOUS2:=进程（a）局部c，i，j，n：如果是whattype（a）<>列表，则返回（[]）；图1：n： =最小值（nops（a），60）；对于从0到n-1的i，做c[i，0]：=a[i+1]；od；对于i到n-1 do对我来说是jc[i，j]：=c[i、j-1]+c[i-1、i-j]；od；od；返回（[seq（c[i，i]，i=0..n-1）]）；结束时间：BOUS2i:=进程（b）局部c，i，j，n：如果whattype（b）<>列表，则返回（[]）；图1：n： =最小值（nops（b），60）；对于从0到n-1的i，做c[i，0]：=b[i+1]；od；对于i到n-1 do对我来说是jc[i，j]：=c[i、j-1]-c[i-1、i-j]；od；od；返回（[seq（c[i，i]，i=0..n-1）]）；结束时间：CONTINUANT:=proc（a）选项记忆；局部i，n，t0；#变换序列的第n项是K_n（a_1，a_2，…，a_n）#-参见Graham，Knuth和Patashnik，混凝土数学。，第二。编辑，第302页。#关于continuant的定义，请参见A072347。如果是whattype（a）<>列表，则返回（[]）；图1：n： =nops（a）；如果n=0，则返回（[]）；fi；如果n=1，则返回（a）；fi；t0:=[1，a[1]；对于我从2到n dot0：=[op（t0），a[i]*t0[i]+t0[i-1]]；od；展开（底土（1=NULL，t0））；结束时间：CONTINUANTi:=proc（a）选项记忆；局部i，n，t0，t1；#逆CONTINUANT变换#警告：通常不生成整数如果是whattype（a）<>列表，则返回（[]）；图1：n： =nops（a）；如果n=0，则返回（[]）；fi；如果n＝1，则RETURN（a）；fi；t0:=[a[1]；t1:=[1，op（a）]；对于我从2到n dot0：=[op（t0），（t1[i+1]-t1[i-1]）/t1[i]]；od；展开（t0）；结束时间：数字和：=过程（n）加（d，d=转换（n，基数，10））；结束过程：#A007953digprod:=进程（n）mul（d，d=转换（n，基数，10））；结束程序：#A007954digprod0:=proc（n）局部d，j:d:=convert（n，base，10）：返回mul（`if`（d[j]=0，1，d[j]），j=1..nops（d））：结束：#A051801digrev:=进程（n）局部b，i，j，n1，m；m： =0；b： =[]；n1:=abs（n）；而n1<>0做i:=n1 mod 10；b： =[op（b），i]；n1:=（n1-i）/10；od；对于从1到nops的j（b）do m:＝10*m+b[j]；od；回程（m）；结束时间：digsort：=进程（n）局部b，i，j，n1，m；m： =0；b： =[]；n1:=abs（n）；而n1<>0做i:=n1 mod 10；b： =[op（b），i]；n1:=（n1-i）/10；od；b： =排序（b）；对于从1到nops（b）的j，做m:=10*m+b[j]；od；回程（m）；结束时间：digsortrev:=进程（n）局部b，i，j，n1，m；m： =0；b： =[]；n1:=abs（n）；而n1<>0做i:=n1 mod 10；b： =[op（b），i]；n1:=（n1-i）/10；od；b： =排序（b）；b： =ListTools[反向]（b）；对于从1到nops（b）的j，做m:=10*m+b[j]；od；回程（m）；结束时间：DIGSUM:=进程（a）局部b，i:如果是whattype（a）<>列表，则返回（[]）；图1：b： =[]：对于i到nops（a）do b：=[op（b），digsum（a[i]）]：od：返回（b）；结束时间：DIRICHLET:=proc（a，b）局部c，i，d，s：#[a_1，…]和[b_1，..]的Dirichlet卷积#参考Apostol，简介。解析数论，第11.4节，第228页。如果是whattype（a）<>列表，则返回（[]）；图1：如果是whattype（b）<>列表，则返回（[]）；图1：c： =[]：对于i到min（nops（a），nops（b））dos： =0；对于从1到i的d如果did（i，d）=1，则s：=s+a[d]*b[i/d]；fi；日期：c： =[操作（c），秒]：日期：返回（c）；结束时间：DIGREV:=程序（a）局部b，i:如果是whattype（a）<>列表，则返回（[]）；图1：b： =[]：对于i到nops（a）do b:=[op（b），digrev（a[i]）]：od：返回（b）；结束时间：#mex=集合的最小排除成员mex:=进程局部n；对于0中的n，而成员（n，s）执行od；n个结束时间：#两个数字的极值#写为2的幂和，相加以抵消相等的对nimsum：=进程（n1，n2）本地v1，v2，l1，l2，i，ans，t1，t2；ans：=0；v1：=转换（n1，基数，2）；v2:=转换（n2，基数，2）；l1:=nops（v1）；l2:=nops（v2）；如果l1>l2，则t1:=v1；v1：=v2；v2：=t1；t2：=l1；l1:=l2；l2:=t2；fi；#现在l1较短如果l1>0，则因为我从1到11做如果v1[i]<>v2[i]，则ans：=ans+2^（i-1）；fi；od；fi；如果l2>l1，则对于i从l1+1到l2 do如果v2[i]<>0，则ans:=ans+2^（i-1）；fi；od；fi；ans；结束时间：#计算n的二进制展开中1的权重或数量：wt:=proc（n）局部w，m，i；w： =0；m： =n；当m>0时，i：=m mod 2；w： =w+i；m： =（m-i）/2；od；w；结束时间：#小汉克尔lHANKEL:=进程（a）局部b，i，k：如果是whattype（a）<>列表，则返回（[]）；图1：b： =[]：对于i从2到nops（a）-1做b:=[op（b），a[i]^2-a[i+1]*a[i-1]]；日期：返回（b）；结束时间：#汉克尔汉克尔：=proc（a）局部h，M，b，i，j，n，m0：如果是whattype（a）<>列表，则返回（[]）；图1：m0：=地板（（nops（a））/2）；b： =[]：h： =（i，j）->a[i+j-1]；对于从1到m0的n doM： =直线[矩阵]（n，n，h）；b： =[op（b），linalg[det]（M）]；日期：返回（b）；结束时间：#阴影-参见A000522下序列数据库中的Lorenz Halbeisen和Norbert Hungerbuehler参考#给定一个序列a（0），a（1）。。。阴影是序列s（0）、s（1）。。。#其中s（n）=i的数量，其中0<=i<n，使得n除以a（i）。阴影：=程序（a）局部n，b，t，j，t1：如果是whattype（a）<>列表，则返回（[]）；图1：n： =nops（a）；如果n=0，则返回（[]）；图1：如果n=1，则返回（[0]）；图1：b： =[0]：对于t从1到n-1 dot1:=0；对于从0到t-1的j，如果a[j+1]mod t=0，则t1:=t1+1；fi；日期：b： =[op（b），t1]：日期：返回（b）；结束时间：#SERIES2（f，x，y，n）返回所有单项式x^i*y^j的和#在f中，i<n和j<n。序列2:=进程（f，x，y，n）局部i，j，t0，t1，t2，t3，t4；t0:=0；t1:=系列（f，x，n）；对于i从0到n-1 dot2:=系数（t1，x，i）；t3：=系列（t2，y，n）；对于从0到n-1的j dot4：=系数（t3，y，j）；如果i+j<n，则t0：=t0+t4*x^i*y^j；fi:od；od；排序（t0，[x，y]，tdeg）；结束时间：#SERIES2TOLIST（f，x，y，n）获取SERIES2（f，x，y，n）的输出#并生成通过读取f中的单项式获得的列表#顺序为00、10、01、20、11、02、30、21、12、03。。。#其中总度数<n序列2列表：=proc（f，x，y，n）局部i，j，k，t0，t1，t2；t0:=[]；对于k从0到n-1 do对于从0到k的j doi： =k-j；t1:=系数（f，x，i）；t2:=系数（t1，y，j）；t0：=[op（t0），t2]；od；od；t0；结束时间：#SERIES2TOLISTMULT（f，x，y，n）接受SERIES2（f，x，y，n）的输出#并生成通过读取f中的单项式获得的列表#顺序为00、10、01、20、11、02、30、21、12、03。。。#其中总度数<n#将x^i*y^j的系数乘以i*j！。SERIES2TOLISTMULT:=进程（f，x，y，n）局部i，j，k，t0，t1，t2；t0:=[]；对于k从0到n-1 do对于从0到k的j doi： =k-j；t1:=系数（f，x，i）；t2:=我*j*系数（t1，y，j）；t0：=[op（t0），t2]；od；od；t0；结束时间：#SERIES2HTOLIST（f，x，y，n）接受SERIES2（f，x，y，n）的输出#并生成通过读取f中的单项式获得的列表#顺序为00、10、11、20、21、22、30、31、32、33。。。#其中两个指数均<n#如果省略了任何术语，它将提出投诉-如果有术语x^i*y^j#用j>i表示i0然后lprint（“SERIES2HTOLIST中的错误：行中缺少术语”，i，t2*x^i*y^j）；错误“可能尝试SERIES2TOLIST？”；fi；日期：od；t0；结束时间：#SERIES2HTOLISTMULT（f，x，y，n）接受SERIES2（f，x，y，n）的输出#并生成通过读取f中的单项式获得的列表#顺序为00、10、11、20、21、22、30、31、32、33。。。#将x^i*y^j的系数乘以i*j！#其中两个指数均<n#如果省略了任何术语，它将提出投诉-如果有术语x^i*y^j#用j>i表示i0然后lprint（“SERIES2HTOLISTMULT错误：行中缺少术语”，i，t2*x^i*y^j）；错误“可能尝试SERIES2TOLISTMULT？”；fi；日期：od；t0；结束时间：#转换ADDONE、RIGHT0、SUMTABL、RAST和RASTxx#Antti Karttunen 12号。2002年7月。添加1:=n->n+1：ADDONE:=a->map（add1，a）：#将每个项递增一。RIGHT0:=a->[0，op（a）]：#右移，加上0。#SUMTABL（A001477，A00147七）给出A003056。#SUMTABL（A00027，A00027）给出A003057。#SUMTABL（A000027，A001477）和SUMTABI（A001477,A000027）给出A002024。A025581:=n->二项式（1+楼层（（1/2）+平方（2*（1+n）），2）-（n+1）：#X投影&A002262:=n->n-二项式（楼层（1/2）+平方（2*（1+n）），2）：#Y-投影（A001477的）SUMTABL:=进程（a，b）局部c，i，u；u：=二项式（min（nops（a），nops（b））+1,2）；c:=[]；对于从0到u-1的i做c:=[操作（c），a[A025581（i）+1]+b[A002262（i）+1]]；od；返回（c）；结束时间：#定理：每个n>=0出现A000108（n）次的序列集#（即A072643的置换）在这两个变换下是闭合的。#RASTxx的不动点是A071673。RAST:=（a，b）->右0（ADDONE（SUMTABL（a，b）））：RASTxx:=a->RIGHT0（ADDONE（SUMTABL（a，a）））：#Antti Karttunen 12捐款结束。2002年7月。#记录：从列表中提取记录及其位置#返回对b，c，其中b=记录，c=它们发生的位置（从1开始）#示例：with（numtheory）：t1:=[seq（sigma（n），n=1..200）]#给出A0000203；记录（t1）；#给出[A034885，A002093]；记录：=程序（a）局部i、n、b、c、rec；如果是whattype（a）<>列表，则返回（[[]，[]]）；图1：n： =无（a）；如果n=0，则返回（[[]，[]]）；图1：如果n=1，则返回（[[a[1]，[1]）；fi；记录：=a[1]；b： =[记录]；c： =[1]；对于我从2到n do如果a[i]>rec，则rec:=a[i]；b： =[op（b），rec]；c： =[op（c），i]；fi；日期：返回（[b，c]）；结束时间：#LAH和LAHi由Vladeta Jovovic（Vladeta（AT）Eunet.yu）于2003年10月3日提出#“LAH变换”映射序列a_0、a_1、a_2。。。#序列b0、b1、b2。。。，其中，如果A有例如f.A（x），b有#例如，f.A（x/（1-x））。更明确地说，#b_n=和{m=0..n}（n！/m！）*二项式（n-1，m-1）*a_m。#例如序列A084357（来自A000110）和A084358（来自A000670）。LAH:=程序（a）局部b，i，m：如果是whattype（a）<>列表，则返回（[]）；图1：b： =[]：对于i到nops（a）做b:=[op（b），加上（（i-1）！/m！）*二项式（i-2，m-1）*a[m+1]，m=0..i-1）]：外径：返回（b）；结束时间：#LAH和LAHi由Vladeta Jovovic（Vladeta（AT）Eunet.yu）于2003年10月3日提出#“LAHi变换”映射序列a_0、a_1、a_2。。。#序列b0、b1、b2。。。，其中，如果A有例如f.A（x），b有#例如f.A（x/（1+x））。更明确地说，#b_n=和{m=0..n}（-1）^（n-m）*（n！/m！）*二项式（n-1，m-1）*a_m。#例如序列A000110（来自A084357）和A000670（来自A084 358）。LAHi:=proc（a）局部b，i，m：如果是whattype（a）<>列表，则返回（[]）；图1：b： =[]：对于i到nops（a）do b:=[op（b），加上（（-1）^（i-1-m）*（（i-1）！/m！）*二项式（i-2，m-1）*a[m+1]，m=0..i-1）]：外径：返回（b）；结束时间：#SEQPI：为单调序列a[]生成pi函数#返回列表b[]，其中b[n+1}给出范围为0到n的项数。#生成b的至少M项（如果可能），然后在下一个方便的停止点停止。SEQPI:=程序（a，M）局部b，la，L，i，s，at，ct：如果是whattype（a）<>列表，则返回（[]）；图1：la：=nops（a）；b： =[]：L:=min（a[la]，M）；ct：=0；s： =0；从1点到la do对于i从s到a[at]-1做b:=[op（b），ct]；日期：ct：=ct+1；s： =a【at】；如果s>L，则断裂；fi；日期：b： =[op（b），ct]；返回（b）；结束时间：#UNBASE：与convert（n，base，b）相反UNBASE:=程序（a）局部N，i；如果是whattype（a）<>列表，则返回（[]）；图1：N： =加（a[i]*10^（i-1），i=1..nops（a））；返回（N）；结束时间：反转：=proc（a）局部b，c，i，n，hit，ulim；如果是whattype（a）<>列表，则返回（[]）；图1：c： =排序（a）；b： =[]；ulim:=最小值（1000，c[nops（c）]）；从c[1]到ulim-do的n命中：=0；对于i从1到nops（a）do如果a[i]=n，则b:=[op（b），i]；命中：=1；断裂；fi；od；如果命中=0，则返回（b）；fi；od；返回（b）；结束时间：#INVERSE2 a中n的最小倒数，如果缺少值，则为0#ff=a的偏移INVERSE2:=proc（a，ff）local nov，b，c，i，n，llim，ulim；如果是whattype（a）<>列表，则返回（[]）；图1：c： =排序（a）；nov：=nops（转换（c，集合））；lprint（“Contains”，nov，“values，in the range”，c[1]，“to”，c[-1]）；llim：=最大值（-1000，c[1]）；ulim:=最小值（1000，c[-1]）；b： =数组（llim..ulim，0）；从llim到ulim-do的n如果成员（n，a），则对于i从1到nops（a），如果a[i]=n，则b[n]：=i+ff-1；断裂；fi；日期：fi；od；返回（[seq（b[n]，n=llim..ulim）]）；结束时间：#说服：来自Richard J.Mathar，2008年1月10日#输入：#L a列表#输出：#比L.C[1]=L[1]多一个元素的列表C。#C[2]=L[-1]。递归C[i]=C[i-1]*L[1-i]/L[i-1]，3<=i。#如果L为空，则返回列表[1]。##示例：L=[1,4,10,20]返回[1,20,50,20,1]#示例：L=[1,2,3]返回[1,3,3,1]#示例：L=[1]返回[1,1]#示例：L=[]返回[1]#定罪：=程序（L）局部C，i；如果nops（L）>0，则C:=[op（1，L），op（-1，L）]；对于i从2到nops（L）doC:=[op（C），op（-i，L）*op（i，C）/op（i，L）]；日期：其他的C:=[1]；fi；返回（C）；结束时间：#ConvOffsetStoT：来自Richard J.Mathar，2008年1月10日#输入：#S一个列表（即实际上无限序列的第一个成员）##verb verbosity参数：如果设置为true，则打印输出#以行对行的方式由逗号分隔的数字流。##输出：#列表列表，其中每个列表代表一行n#一个三角形，n=0，长度为S，是由定义的列表#ConvOffs（S的前n个元素的子列表）。# #示例A056939:L=[1,4,10,20]返回# [[1], [1, 1], [1, 4, 1], [1, 10, 10, 1], [1, 20, 50, 20, 1]]#其中[1]由ConvOffs（[]）生成，[1,1]由#ConvOffs（[1]），[1,4,1]由ConvOff（[1,4]）生成，#[1,10,10,1]由ConvOffs（[1,4,10]）等生成。# #测试：#定罪（[1,2,3]）；#ConvOffsStoT（[1,4,10,20]，真）；#ConvOffsStoT:=proc（S，动词）局部T，n，nrow，c；#第一行来自空子列表T:=[[1]；对于n从1到nops（S）donrow：=转换（[op（1..n，S）]）；if动词then对于nrow do中的cprintf（“%d，”，c）；日期：fi；T:=[op（T），nrow]；日期：返回（T）；结束时间：#stoint：将字符串转换为整数stoint:=进程局部n，a，a0，i；n： =长度（s）；a： =转换（s，‘字节’）；a0:=0:对于i从1到n doa0:=（a[i]-48）*10^（n-i）+a0:结束do：a0；结束时间：#算术函数的Dirichlet逆。#输入列表L表示[a1，a2，a3，a4，…]，原始值#1、2、3等整数值的算术函数。a1的值必须#非零。#返回的列表与Dirichlet卷积[b1，b2，b3，…]相反。#这意味着DIRICHLET（.，.）函数返回#如果使用两个等于的输入和输出参数调用#DIRICHLETi（.）。# #示例：#L:=[seq（n mod 2，n=1..50）]；#这是A000035#DIRICHLETi（左）；#这是A087003#理查德·马塔尔（Richard J.Mathar），2010年7月15日DIRICHLETi:=进程（L）本地Linv，n，d，finv；如果不是类型（L，'list'），则错误（“需要列表类型参数而不是”，whattype（L））；结束条件：；线性：=[1/op（1，L）]；n从2到nops（L）dofinv:=0；对于（numtheory[除数]（n）减去{n}）do中的dop（n/d，L）*op（d，Linv）；finv:=finv-%*op（1，Linv）；结束do：Linv:=[op（Linv），finv]；结束do：返回Linv；结束进程：#序列L的Deleham的Lodumo_m变换。#返回列表a（n），并由中尚未包含的最小数字定义#满足a（n）=L（n）（mod m）的列表a（.）。#@param L非负数的输入列表#@param m模运算的剩余部分。这只是有用的#如果是一个大于1的数字。#@返回非负数字的序列a（n）##示例：从A159833生成A160016：#A159833：=[序列（n^2*（n^2+15）/4，n=0..100）]；#洛杜莫（A159833,2）；##示例：从A000045生成A160081：#A000045:=[组合[fibonacci]（n），n=0..100）]；#LODUMO（A000045,5）；##理查德·马塔尔，2009-04-30LODUMO:=过程（L，m）局部a、n、an；如果不是类型（L，'list'），则错误（“需要列表类型参数，而不是”，whattype（L））；结束条件：；a:=[]；对于n从1到nops（L）do对于从op（n，L）mod m by m do如果不是a中的，则a:=[op（a），an]；断裂；fi；日期：结束do；a；结束进程：#两个整数的十进制十进制表示的串联a//b的整数值。#参数a和b是非负整数。#@param a表示结果的前导十进制数字的整数#@param b表示结果的尾随（低有效）小数位数的整数#@return通过a和b的十进制数字串联获得的整数#@作者N·J·A·斯隆#@自2010年10月16日起#示例：#数字2（3,4）；#返回34#数字2（3,40）；#返回340#数字2（3,0）；#返回30#数字2（37,0）；#返回370#数字2（0800）；#返回800#数字2（-4,8）；#错误：参数的负值数字2:=进程（a，b）如果a＜0或b＜0，则错误（“否定参数”，a，“或”，b）；结束条件：；解析（cat（a，b））；结束进程：#列表中整数的十进制十进制表示形式的串联整数值。#@param L非负整数列表[a，b，c，d，…]#@return通过将以10为基数的数字a//b//c//串联而获得的整数。。。#@自2010年10月16日起#@作者N.J.A.Sloane#示例：#数字L（[3,4]）；#返回34#数字L（[3,0,4]）；#返回304#数字L（[123456]）；#返回123456#数字L（[3]）；#返回3#数字L（[]）；#空列表返回0#数字L（3/4）；#错误：参数不是列表类型数字L:=进程（L）局部ret，i；如果不是类型（L，'list'），则错误（“需要列表类型参数而不是”，whattype（L））；结束条件：；ret:=0；对于i从1到nops（L）doret：=数字2（ret，op（i，L））；结束do；返回ret；结束进程：#通过在原始列表中插入零进行充气。#列表L（1），0,0,0，。。。，L（2），0,0，。。返回，其中#列表原始成员之间的零间距由参数控制。#@param L输入列表#@param n要插入的零的非负计数。#@返回#@自Richard J.Mathar以来，2009-06-23#@作者Richard J.Mathar空气流速：=proc（L，n）局部a、i、j；如果不是类型（L，'list'），则错误（“需要列表类型参数而不是”，whattype（L））；结束条件：；a:=[]；对于i从1到nops（L）doa：=[op（a），op（i，L），seq（0，j=1..n）]；结束do；a；结束进程：#向后Van Eck变换。A181391建议。#如果a[n]较早出现在a中，则a[m]是最新的#发生，并设置b[n]=n-m；否则b[n]=0。ECKb:=程序（a）局部b，i，m，n；如果是whattype（a）<>列表，则返回（[]）；图1：b： =[0]；n从2到nops（a）do#a（n）以前出现过吗？m： =0；对于i从n-1乘-1到1 do如果（a[i]=a[n]），则m:=n-i；断裂；fi（菲涅耳）日期：b： =[op（b），m]；日期：返回（b）；结束进程：#转发Van Eck变换。由A181391建议。#如果a中再次出现[n]，则让a[m]成为下一个#发生，并设置b[n]=m-n；否则b[n]=0。#警告：应该提供足够的术语！ECKf:=程序（a）局部b，i，m，n；如果是whattype（a）<>列表，则返回（[]）；图1：b： =[]；n从1到nops（a）-1 do#a（n）会再次出现吗？m： =0；对于i从n+1到nops（a）do如果（a[i]=a[n]），则m:=i-n；断裂；fi（菲涅耳）日期：b： =[op（b），m]；日期：b： =[操作（b），0]；返回（b）；结束进程：#序列{a（n）}的拉格朗日变换#根据拉格朗日定理，最多需要4个平方和才能得到n。#返回b（n）=求和到n所需的{a}的最小项数（1<=n<=M）。#C=试图构建n的{a}的最大项数#M=n的上限#在内部，a和b的初始项都取为0，但由于这是一个数论函数，输出从n=1开始#示例。生产A002828：#平方：=[seq（n^2，n=1..20）]；#拉格朗日（4120平方米）；生产# [1, 2, 3, 1, 2, 3, 4, 2, 1, 2, 3, 3, ...拉格朗日：=程序（a，C，M）局部t1、ip、i、j、a1、a2、b、c、N1、N2、Nc；如果是whattype（a）<>列表，则返回（[]）；图1：#排序a，删除重复项，包括0t1:=排序（a）；a1:=排序（转换（转换（a，集合），列表））；如果不是成员（0，a1），则a1:=[0，op（a1）]；fi；N1：=nops（a1）；b： =阵列（1..M+1，-1）；对于i从1到N1，而a1[i]<=M do b[a1[i]+1]：=1；od；a2:=a1；N2:=N1；从2到C do的ipc： ={}：i从1到N1，而a1[i]<=M do当a1[i]+a2[j]<=M do时，j从1到N2c： ={op（c），a1[i]+a2[j]}；od；od；c： =排序（转换（c，列表））；Nc:=nops（c）；对于i从1到Nc do如果b[c[i]+1]=-1，则b[c[1]+1]：=ip；fi；od；a2:=c；N2:=Nc；od；返回（[seq（b[i]，i=2..M+1）]）；结束：myhead:=proc（s，L:：integer:=100）局部s2，n；如果whattype（s）<>list，则s2:=转换（s，list）；否则s2:=s:fi；[seq（s2[n]，n=1..分钟（L，nops（s2））]；结束时间：mytail:=proc（s，L:：integer:=100）局部s2，n；如果whattype（s）＜＞list，则s2：＝convert（s，list）；否则s2:=s:fi；[seq（s2[n]，n=最大值（1，nops（s2）-L+1）。。nops（s2）]；结束时间：#myconvert（n，b）=转换（n，base，b），但将数字按人类的顺序排列myconvert:=proc（n，b）局部t1，t2，len，i；如果n=0，则返回（[0]）；fi；t1:=换算（n，基数，b）；长度：=nops（t1）；t2:=[seq（t1[len+1-i]，i=1..len）]；结束时间：#Maple Print（在一条长线上打印序列）于2018年2月添加MP:=进程界面（屏幕宽度=1200）：lprint（序列[i]，i=1..nops（s））；界面（屏幕宽度=79）：结束时间：#COMPl2：计算序列的补码（长版本）#即向量[a[0]。。。a[i]。。。[maxn]]是不按顺序排列的数字#小心使用！！！COMPl2:=proc（a，M）本地非成员，b，n1，M：如果是whattype（a）<>列表，则返回（[]）；图1：#获得单调唯一的版本bb： =单（a）；n1：=nops（b）；如果n1=0，则返回（[]）；传真：m： =最小值（b[n1]，m）；notmember:=子项（_WZ=b，进程（x）非成员（x，_WZ）结束）；选择（非成员，[1..m]美元）；结束时间：#binary：n的二进制表示，按人类顺序二进制：=proc（n）局部t1，L；如果n<0，则ERROR（“n必须为非负”）；fi；如果n=0，则返回（[0]）；fi；t1:=换算（n，基数，2）；五十： =nops（t1）；[seq（t1[L+1-i]，i=1..L）]；结束时间：### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%### ####2013年1月5日添加：Michael Somos非常友好地提供了####以下代码用于检查这些过程。####要运行它，请将其保存为一个文件，并从每行的开头去掉###字符### ####OEIS转换的Maple测试代码，Michael Somos 2012年12月31日### ###读取（“转换”）；### ###chk：=进程（ex）###如果不是evalb（parse（ex，statement）），则printf（“%s:false\n”，ex）结束if；###结束时间：### ###chk（“δ（x->x^3,2,2）=18”）；###chk（“did（8,3）=0”）；###chk（“did（9,3）=1”）；###chk（“dids（8,3）=0”）；###chk（“dids（9,3）=-1”）；###chk（“尺寸（26,10）=1”）；###chk（“dim（10,26）=0”）；###chk（“mob（10,2）=-1”）；###chk（“mob（10,3）=0”）；####0索引MASKCONV###chk（“MASKCONV（[1,2,3,4]，[5,6,7,8]）=[5,16,22,60]”）；####0索引MASKTRANS###chk（“屏蔽层（[1,2,3,4]）=[1,3,4,10]”）；###chk（“MASKTRANS（[a0，a1，a2，a3，a4]）=[a0，a0+a1，a0+a2，a0+a1+a2+a3，a0+a4]”）；####0索引MASKTRANSi###chk（“MASKTRANSi（[1,2,3,4]）=[1,1,2,0]”）；###chk（“MASKTRANSi（[a0，a0+a1，a0+2，a0+31+a2+a3，a0+a4]）=[a0、a1、a2、a3、a4]”）；####1索引支持###chk（“支架（[0,1,2,0,5,4,0，-3]）=[2,3,5,6,8]”）；###chk（“支架（[a1，a2,0，a4,0，a6，a7,0,0，al10]）=[1,2,4,6,7,10]”）；####无索引MONO。中只有数字。###chk（“MONO（[10,3，-2，-3，-10]）=[2,3,10]”）；####MONO2末尾有“abs（bu-nops（b））<10”测试。不要使用！TODO公司####1索引出COMP。中只有数字。###chk（“COMP（[6,4,2,10,7]）=[1,3,5,8,9]”）；####0索引CHAR。中只有数字。###chk（“查尔（[6,4,2,10,7]）=[0,0,1,0,1,1,0,0,1]”）；####以下是硬编码的“sequence”函数###序列：=[[a]，[b，c]，[d]，[x1，x2，x3，x4，x5，x6]]：####1索引EXTRACT###chk（“提取（4,3,2）=[x2，x5]”）；####0索引小数###chk（“小数（[0,0,2,0,0,5,0]，3,2）=[2,5]”）；###chk（“小数（[a0，a1，a2，a3，a4，a5，a6]，3,2）=[a2，a5]”）；####0索引BISECT###chk（“BISECT（[a0，a1，a2，a3，a4，a5，a6]，0）=[a0、a2、a4、a6]”）；###chk（“BISECT（[a0，a1，a2，a3，a4，a5，a6]，1）=[a1，a3，a5]”）；####0索引TRISECT###chk（“三角（[a0，a1，a2，a3，a4，a5，a6]，0）=[a0、a3，a6]”）；###chk（“三角（[a0，a1，a2，a3，a4，a5，a6]，1）=[a1，a4]”）；###chk（“TRISECT（[a0，a1，a2，a3，a4，a5，a6]，2）=[a2，a5]”）；####无索引DIFF###chk（“DIFF（[9,4,1,0,1,4,9]）=[-5，-3，-1,1,3,5]”）；###chk（“DIFF（[a，b，c，d，e，f]）=[b-a，c-b，d-c，e-d，f-e]”）；####无索引PRODS。关于b[n]=a[1]*的注释是错误的*待办事项###chk（“PRODS（[1，2，3，4，5]）=[1，2，6，24120]”）；###chk（“产品（[a，b，c，d，e]）=[a，a*b，a*b*c，a*c*d，a*b2*c*d*e]”）；####无索引PSUM。###chk（“PSUM（[1,2,3,4,5]）=[1,3,6,10,15]”）；###chk（“PSUM（[a，b，c，d，e]）=[a，a+b，a+b+c，a+b+c+d，a+b2+c+d+e]”）；####无索引PSUSSIGN。###chk（“符号（[1,2,3,4,5]）=[1,1,2,2,3]”）；###chk（“符号（[a，b，c，d，e]）=[a，b-a，c-b+a，d-c+b-a，e-d+c-b+a]”）；####0索引BINOMIAL###chk（“二进制（[1,2,4,8,16]）=[1,3,9,27,81]”）；###chk（“二进制（[a0，a1，a2，a3]）=[a0、a0+a1、a0+2*a1+a2、a0+3*a1+3*a2+a3]”）；###索引为#0的二进制###chk（“BINOMIALi（[1,3,9,27,81]）=[1,2,4,8,16]”）；###chk（“BINOMIALi（[a0，a0+a1，a0+2*a1+a2，a0+3*a1+3*a2+a3]）=[a0、a1、a2、a3]”）；####1索引BIN1###chk（“BIN1（[a1、a2、a3、a4]）=[a1，-2*a1-a2,3*a1+3*a2+a3，-4*a1-6*a2-4*a3-a4]”）；###chk（“BIN1（[2,4,8,16]）=[2,8,26，-80]”）；###指数EULER排名第一。###chk（“欧拉（[1,1,0,0,0，0,0]）=[1,2,2,3,3,4,4]”）；###chk（“简化（欧拉（[a1、a2、a3]））=[a1，a2+a1/2+a1^2/2，a3+a1*a2+al1/3+a1*2/2+a1 ^3/6]”）；###索引EULERi排名第一###chk（“欧元（[1,2,2,3,3,4,4]）=[1,1,0,0,0，0,0]”）；###chk（“简化（EULERi（[a1，a2+a1/2+a1^2/2，a3+a1*a2+al1/3+a1*2/2+a1 ^3/6]））=[a1、a2、a3]”）；###索引MOBIUS排名第一###chk（“莫比乌斯（[1,3,4,7,6,12]）=[1,2,3,4,1,6]”）；###chk（“莫比乌斯（[a1，a2，a3，a4，a5，a6]）=[a1、a2-a1，a-a1，a4-a2，a5-a1，a6-a3-a2+a1]”）；###索引MOBIUSi排名第一###chk（“MOBIUSi（[1,2,3,4,5,6]）=[1,3,4,12,6,12]”）；###chk（“MOBIUSi（[a1，a2-a1，a3-a1，a4-a2，a5-a1，a6-a3-a2+a1]）=[a1、a2、a3、a4、a5、a6]”）；####1索引STIRLING###chk（“斯特林（[1,2,3,4,5]）=[1,3,10,37151]”）；###chk（“STIRLING（[a1，a2，a3，a4]）=[a1，a1+a2，a1+3*a2+a3，a1+7*a2+6*a3+a4]”）；####1索引STIRLINGi###chk（“STIRLINGi（[1,3,10,37151]）=[1,2,3,4,5]”）；###chk（“STIRLINGi（[a1，a1+a2，a1+3*a2+a3，a1%7*a2+6*a3+a4]）=[a1、a2、a3、a4]”）；####1索引STIRB###chk（“STIRB（[1,2,3,4,5,6]）=[1，-1,1，-1,1，-1]”）；###chk（“STIRB（[a1、a2、a3、a4]）=[a1，a1-a2，a1-3*a2+2*a3，a1-7*a2+12*a3-6*a4]”）；####1索引反向。仅数字错误。应为INVERT:=proc（b）。TODO公司###chk（“反向（[1,2,3,4,5]）=[1,3,8,21,55]”）；####1索引INVERTi。仅数字错误。###chk（“逆变器（[1,3,8,21,55]）=[1,2,3,4,5]”）；####1索引REVERT。仅数字错误。###chk（“反向（[1,2,3,4,5]）=[1，-2,5，-14,42]”）；####1索引REVEGF。仅限数字错误。###chk（“版次（[1,2,3,4,5]）=[1，-4,39，-61613505]”）；####1索引复合。###chk（“复合（[4,3,2,1]，[1,2,3,4]）=[4,11,26,59]”）；###chk（“复合（[a1，a2，a3]，[b1，b2，b3]）=[a1*b1，a1*b2+a2*b1^2，a1*b3+2*a2*b2+a3*b1*b2”）；####0索引CONV。###chk（“形态（[4,3,2,1,0]，[0,1,2,3,4]）=[0,4,11,20,30]”）；###chk（“形态（[a0，a1，a2]，[b0，b1，b2]）=[a0*b0，a0*b1+a1*b0、a0*b2+a1*1+a2*b0]”）；####0索引CONVi。###chk（“CONVi（[1,4,10,20,35]）=[1,2,3,4,5]”）；###chk（“CONVi（[a0*a0,2*a0*al1,2*a0*a2+a1*a1]）=[a0，a1，a2]”）；####0索引LISTTOLSITDIV。###chk（“LISTTOLISTDIV（[1,4,9,16,25]）=[1,4.9/2,8/3,25/24]”）；###chk（“LISTTOLISTDIV（[a0，a1，a2，a3，a4]）=[a0、a1、a2/2、a3/6、a4/24]”）；####0索引LISTTOLSITMUL。###chk（“LISTTOLISTMULT（[1,4,9,16,25]）=[1,4,18,96600]”）；###chk（“LISTTOLISTMULT（[a0，a1，a2，a3，a4]）=[a0、a1,2*a2,6*a3,24*a4]”）；####无索引PARTITION。1已索引出。数字输入只能正常。###chk（“分割（[1,3,5,13]）=[1,1,2,2,3,4,5,6,7,8,9,11]”）；###排名第一的索引PARITITION1。数字输入只能正常。###chk（“分区（[1,1,2,2,3,4,4,5,6,7,8,9,11]）=[1,3,5,13]”）；###索引EXP排名第一。###chk（“EXP（[1,2,3,4]）=[1,3,10,41]”）；###chk（“EXP（[a1，a2，a3]）=[a1、a2+a1*a1、a3+3*a1*a2+a1*a1]”）；####1索引日志。###chk（“日志（[1,3,10,41]）=[1,2,3,4]”）；###chk（“简化（LOG（[a1，a2+a1*a1，a3+3*a1*a2+a1*a1]））=[a1、a2、a3]”）；####0索引EXPCONV。###chk（“EXPCONV（[1,2,3,4]，[4,3,2,1]）=[4,11,26,56]”）；###chk（“EXPCONV（[a0，a1，a2]，[b0，b1，b2]）=[a0*b0，a0*b1+a1*b0、a0*b2+2*a1*b1+a2*b0]”）；####no索引LEFT。###chk（“左（[4,3,2,1]）=[3,2,1'”）；###chk（“左（[a，b，c，d，e]）=[b，c；####no索引RIGHT。###chk（“右（[4,3,2,1]）=[1,4,3,1]”）；###chk（“右（[a，b，c，d，e]）=[1，a，b，c，d，e]”）；####无索引运行。###chk（“运行（[4,3,2,2,2,1,3,4]）=[1,1,3,1,2,1]”）；###chk（“运行（[a，b，c，c，c，c，d，b，b，a]）=[1,1,3,1,2,1]”）；####0索引M2。###chk（“M2（[5,4,3,2,1]）=[5,8,6,4,2]”）；###chk（“M2（[a，b，c，d，e]）=[a，2*b，2*c，2*d，2*e]”）；####0索引M2i。###chk（“M2i（[5,8,6,4,2]）=[5,4,3,2,1]”）；###chk（“M2i（[a，2*b，2*c，2*d，2*e]）=[a，b，c，d，e]”）；####0索引负数。###chk（“负值（[5,4,3,2,1]）=[5，-4，-3，-2，-1]”）；###chk（“负数（[a，b，c，d，e]）=[a，-b，-c，-d，-e]”）；####0索引eultrans2。（=比诺米亚利）###chk（“eultrans2（[1,1,2,3,5,8,13]）=[1,0,1，-1,2，-3,5]”）；###chk（“eultrans2（[a0，a1，a2，a3]）=[a0、a1-a0、a-2*a1+a0、3-3*a2+3*a1-a0]”）；###索引Etrans排名第一。###chk（“Etrans（[1,1,0,0,0-0,0]）=[1,2,2,3,3,4,4]”）；###chk（“简化（Etrans（[a1、a2、a3]））=[a1，a2+a1/2+a1^2/2，a3+a1*a2+al1/3+a1^3/2+a1 ^3/6]”）；####没有索引pairtrans。###chk（“pairtrans（[5,4,3,2,1]）=[5,9,7,5,3]”）；###chk（“pairtrans（[a，b，c，d，e]）=[a，a+b，b+c，c+d，d+e]”）；####1索引BOUS in。0索引out。b0=1总是。###chk（“BOUS（[5,4,3,2,1]）=[1,6,15,32,83262]”）；###chk（“BOUS（[a1，a2，a3，a4]）=[1,1+a1,1+2*a1+a2,2+3*a1+3*a2+a5+8*a1+6*a2+4*a3+a4]”）；####0索引BOUS2。###chk（“BOUS2（[5，4，3，2，1]）=[5，9，16，33，84]”）；###chk（“BOUS2（[a0、a1、a2、a3]）=[a0，a1+a0，a2+2*a1+a 0，a3+3*a2+3*a1+2*a0]”）；####0索引BOUS2i。###chk（“BOUS2i（[5,4,3,2,1]）=[5，-1,0，-5,4]”）；###chk（“BOUS2i（[a0，a1，a2，a3]）=[a0、a1-a0、a-2*a1+a0、3-3*a2+3*a1-2*a0]”）；####1索引CONTINUANT。###chk（“连续（[5,4,3,2,1]）=[5,21,68157225]”）；###chk（“连续（[a，b，c，d]）=[a，a*b+1，a*c+a+c，a*b*c*d+a*b+a*d+c*d+1]”）；####1索引CONTINUANTi。###chk（“CONTINUANTi（[5,21,68157225]）=[5,4,3,2,1]”）；###chk（“大陆（[a，b，c，d]）=[a，b/a-1/a，c/b-a/b，d/c-b/c]”）；####1索引DIRICHLET。###chk（“DIRICHLET（[5,4,3,2,1]，[1,2,3,4,5]）=[5,14,18,30,26]”）；###chk（“DIRICHLET（[a1，a2，a3，a4]，[b1，b2，b3，b4]；####1索引DIRICHLETi。###chk（“DIRICHLETi（[1,2,3,4,5,6]）=[1，-2，-3,0，-5,6]”）；###chk（“DIRICHLETi（[1/a，b，c，d，e]）=[a，-a^2*b，-a^2%c，a^3*b^2-a^2*d，-a^2]”）；####无索引lHANKEL。###chk（“汉克尔（[1,4,9,16,25,36]）=[7,17,31,49]”）；###chk（“汉克尔（[a，b，c，d，e]）=[b*b-a*c，c*c-b*d，d*d-c*e]”）；####无索引HANKEL。###chk（“汉克尔（[6,5,4,3,2,1]）=[6，-1,0]”）；###chk（“汉克尔（[a，b，c，d，e，f]）=[a，a*c-b*b，a*c*e-a*d*d-b*b*e+2*b*c*d-c*c*c]]”）；####无索引SERIES2TOLIST。###chk（“序列2策略（a+b*x+c*y+d*x*x+e*x*y+f*y*y，x，y，3）=[a，b，c，d，e，f]”）；####无索引SERIES2TOLISTMULT。###chk（“序列2TOLISTMULT（a+b*x+c*y+d*x*x+e*x*y+f*y*y，x，y，3）=[a，b，c，2*d，e，2*f]”）；####无索引RIGHT0。###chk（“右0（[5,4,3,2,1]）=[0,5,4,1,2,1'”）；###chk（“权利0（[a，b，c，d，e]）=[0，a，b、c，d、e]”）；###索引为#0的SUMTABL。###chk（“SUMTABL（[4,3,2,1]，[1,2,3,4]）=[5,4,6,3,5,7,2,4,6,1]”）；###chk（“SUMTABL（[a0，a1，a2]，[b0，b1，b2]）=[a0+b0，a1+b0、a0+b1，a2+b0；a1+b1；a0+b2]”）；####0索引LAH。###chk（“LAH（[5,4,3,2,1]）=[5,4，11,44229]”）；###chk（“LAH（[a0，a1，a2，a3，a4]）=[a0、a1、a2+2*a1、a3+6*a2+6*a1，a4+12*a3+36*a2+24*a1]”）；####0索引LAHi。###chk（“LAHi（[5,4,3,2.1]）=[5,4，-5,8，-11]”）；###chk（“LAHi（[a0，a1，a2，a3，a4]）=[a0、a1、a2-2*a1、a-6*a2+6*a1，a-4-12*a3+36*a2-24*a1]”）；####1索引的INVERSE。仅限数字输入。RETURN（b）缺少错误###chk（“反向（[4,5,3,2,1]）=[5,4,3,1,2]”）；####无索引digcatL。仅限数字输入。###chk（“数字L（[5,43210]）=543210”）；####0索引AERATE。###chk（“AERATE（[5,4,3,2,1]，1）=[5,0,4,0,3,0,2,0,1,0]”）；###chk（“AERATE（[a，b，c，d]，2）=[a，0,0，b，0,0.，c，0,0,0）”）；### ###printf（“完成”）；### ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%