/*版权所有（C）2007 Christian G.Bowertransforms_pari.txt版本0.9这个文件是自由软件；您可以重新发布和/或在自由软件发布的GNU通用公共许可条款基金会。它被分发是为了希望它会有用，但没有任何担保。有关详细信息，请查看许可证。您可以在以下位置找到它：http://www.gnu.org/licenses/gpl-3.0.txt*//*这是序列变换（或函数）的文件。序列编码为向量。如果向量A代表序列A，则A[1]=A_0，A[n+1]=A_n有些变换对矩阵进行运算。*//*核心转型和运营*首先是最基本和最常用的功能*//*二项式变换*/{trv_bin（A）=对于步骤（i=#A-1,0，-1，A[i+1]=总和（j=0，i，二项式（i，j）*A[j+1））；A类}/*二项式逆变换*/｛trv_i_bin（A）=对于（i=1，#A-1，对于（j=0，i-1，A[i+1]-=二项式（i，j）*A[j+1]））；A类}/*A的特征函数*如果存在n，则输出序列b_n=1 k:a_k==n*否则b_n=0*第二个参数是输出序列的长度*/{trv_char（A，n）=局部（B=向量（n），v）；对于（i=1，#A，v=A[i]；如果（类型（v）==“t_INT”&&v>=0&v1，A[2]=A[2]*A[1]+1）；对于（i=3，#A，A[i]=A[i]*A[i-1]+A[i-2]）；A类}/*连分母变换*连分式估计分母的输出序列*输入序列中的分数系数*/{trv_cofr_den（A）=A[1]=1；对于（i=3，#A，A[i]=A[i]*A[i-1]+A[i-2]）；A类}/*循环变换*将循环结构应用于未标记对象序列*此函数忽略a0（a[1]）并假定其为0*输出序列总是b0=1*函数使用trv_imoebius和trv_lyndon*函数间接使用trv_i_euler*/{trv_cycle（A）=A=trv_i_moebius（trv_lindon（A））；A[1]=1；A类}/*逆循环变换*此函数忽略a0（a[1]）并假定它为1*输出序列总是b0=0*函数使用trv_moebius和trv_i_lyndon*函数间接使用trv_euler*/{trv_i_cycle（A）=trv_i_lindon（trv_moebius（A））；}/*差分变换*bn=an-a{n-1}*trv_psum的逆*/{trv_diff（A）=向量（#A，i，如果（i==1，A[1]，A[i]-A[i-1]））}/*欧拉变换*将集合结构应用于未标记对象序列*该函数忽略a_0（a[1]）并假定它为0*输出序列总是b0=1*/{trv_euler（A）=局部（B=向量（#A-1，n，1/n），C）；B=dirmul（向量提取（A，“2..”），B）；C=exp（Ser（concat（0，B）））；对于（i=1，#A，A[i]=polceoff（C，i-1））；A类}/*逆欧拉变换*此函数忽略a0（a[1]）并假定它为1*输出序列总是b0=0*/{trv_i_euler（A）=局部（B=向量（#A-1，n，1/n），C）；A[1]=1；C=对数（Ser（A））；A=向量提取（A，“2..”）；对于（i=1，#A，A[i]=polceoff（C，i））；A=dirdiv（A，B）；concat（0，A）}/*euler2变换*将（2元素集）结构应用于未标记对象的序列*aka对称正方形*此函数不可逆*/{trv_euler_2（A）=本地（x='x，B=序列（A，x））；B=（B^2+subst（B，x，x^2））/2；对于（i=1，#A，A[i]=polceoff（B，i-1））；A类}/*矩阵的euler2变换*/｛trm_euler_2（A）=局部（x='x，y='y，m=matsize（A）[1]，n=matsice（A）[2]，B=O（x^m）+O（y^n），B2=O（x^m）+O（y^n））；对于（i=0，m-1，对于（j=0，n-1，B+=A[i+1，j+1]*x^i*y^j）；);对于（i=0，（m-1）\2，对于（j=0，（n-1）\2，B2+=A[i+1，j+1]*x^（2*i）*y^（2*j））；);B=（B^2+B2）/2；对于（i=0，m-1，对于（j=0，n-1，A[i+1，j+1]=polceoff（polceof（B，j，y），i，x））；);A类}/*欧拉积变换*将集合结构应用于未标记对象序列*根据产品的尺寸进行组装*此函数忽略a0、a1（a[0]、a[1]）并假定它们为0*输出序列总是b_0=0，b_1=1*/{trv_euler_p（A）=局部（B=向量（#A-1），j，s）；A=向量提取（A，“2..”）；对于（i=2，#A，s=大ω（i）*A[i]；j=i；而（j<=#A，B[j]+=秒；j*=i；););A[1]=1；对于（i=2，#A，A[i]=总和（i，j，A[j]*B[i/j]）/最大值（i）；);concat（0，A）}/*逆欧拉积变换*此函数忽略a0、a1（a[0]、a[1]）并假定它们为0、1*输出序列总是b0=b1=0*/{trv_i_euler_p（A）=局部（B=矢量（#A-1），j）；A=向量提取（A，“2..”）；对于（i=2，#A，B[i]=大ω（i）*A[i]-总和（i，j，A[j]*B[i/j]）；);对于（i=2，平方（#A），j=i^2；而（j<=#A，B[j]-=B[i]；j*=i；););对于（i＝2，#A，A[i]＝B[i]/bigmomega（i））；A[1]=0；concat（0，A）}/*指数变换*将集合结构应用于标记对象的序列*逆为trv_log（对数变换）*此函数忽略a0（a[1]）并假定其为0*输出序列总是b_0=1*/{trv_exp（A）=本地（x='x，B）；B=总和（i=1，#A-1，A[i+1]*x^i/i！）；B=经验（B+O（x^#A））；对于（i=0，#A-1，A[i+1]=polceoff（B，i）*i！）；A类}/*逆变换*将列表结构应用于未标记对象的序列*该函数忽略a_0（a[1]）并假定它为0*输出序列总是b0=1*trv_invert_x是一个没有做出这种假设的版本*/{trv_invert（A）=本地（x='x，B=Ser（A，x）-A[1]）；B=1/（1-B）；对于（i=1，#A，A[i]=polceoff（B，i-1））；A类}/*逆逆变换*此函数忽略a0（a[1]）并假定它为1*输出序列总是b0=0*/{trv_i_invert（A）=本地（x='x，B=Ser（A，x）-A[1]+1）；B=1-1/B；对于（i=1，#A，A[i]=polceoff（B，i-1））；A类}/*逆积变换*将列表结构应用于未标记对象的序列*根据产品的尺寸进行组装*此函数忽略a0、a1（a[0]、a[1]）并假定它们为0*输出序列总是b0=0，b1=1*/{trv_invert_p（A）=A=-vecextract（A，“2..”）；A[1]=1；A=dirdiv（向量（#A，n，n==1），A）；concat（0，A）}/*逆逆积变换*此函数忽略a0、a1（a[0]、a[1]）并假定它们为0、1*输出序列总是b0=b1=0*/｛trv_i_inver_p（A）=A=向量提取（A，“2..”）；A[1]=1；A=-dirdiv（向量（#A，n，n==1），A）；A[1]=0；concat（0，A）}/*反转标记变换*将列表结构应用于标记对象的序列*该函数忽略a_0（a[1]）并假定它为0*输出序列总是b0=1*/{trv_invert_l（A）=本地（x='x，B）；B=总和（i=1，#A-1，A[i+1]*x^i/i！）；B=1/（1-B+O（x^#A））；对于（i=0，#A-1，A[i+1]=polceoff（B，i）*i！）；A类}/*逆逆标记变换*该函数忽略a_0（a[1]）并假定它为1*输出序列总是b0=0*/{trv_i_invert_l（A）=本地（x='x，B）；B=总和（i=1，#A-1，A[i+1]*x^i/i！）；B=1-1/（1+B+O（x^#A））；对于（i=0，#A-1，A[i+1]=polceoff（B，i）*i！）；A类}/*最小逆变换*b_n是最小的k：ak==n或填充值（如果不存在这样的k）*第二个参数是输出序列的长度*第三个参数是填充值*/{trv_leastinv（A，n，f=-1）=局部（B=向量（n，x，-1），v）；对于（i=1，#A，v=A[i]；如果（类型（v）==“t_INT”&&v>=0&vb{k-1}*此函数不可逆*输出长度由函数决定*/{trv_record（A）=本地（B=[A[1]）；对于（i=2，#A，如果（A[i]>B[#B]，B=连接（B，A[i]））；);B}/*A的记录值指数*输出序列bn是a的索引，其中记录值*发生trv_record的*此函数不可逆*输出长度由函数决定*/{trv_record_ix（A）=本地（B=[0]，j=1，k=A[1]）；对于（i=2，#A，如果（A[i]>k，B=连接（B，i-1）；j=i；k=A[i]；););B}/*还原变换*应用级数反转作为ogf*这个函数是它自己的逆函数*此函数忽略a0（a[1]）并假定其为0*输出序列总是b0=0*/{trv_revert（A）=本地（x='x，B=Ser（A，x）-A[1]）；B=serreverse（B）；对于（i＝1，#A，A[i]＝polcoeff（B，i-1））；A类}/*revert_egf变换*应用序列反转作为egf*这个函数是它自己的逆函数*此函数忽略a0（a[1]）并假定其为0*输出序列总是b0=0*/{trv_revert_egf（A）=本地（x='x，B）；B=总和（i=1，#A-1，A[i+1]*x^i/i！）；B=serreverse（B+O（x^#A））；对于（i=0，#A-1，A[i+1]=polceoff（B，i）*i！）；A类}/*斯特林变换*将给定的标记结构应用于非空集*/{trv_stirling（A）=本地（x='x，B）；B=总和（i=0，#A-1，A[i+1]*x^i/i！）；B=子集（B+O（x^#A），x，exp（x+O（x^#A；对于（i=0，#A-1，A[i+1]=polceoff（B，i）*i！）；A类}/*逆斯特林变换*/{trv_i_stirling（A）=本地（x='x，B）；B=总和（i=0，#A-1，A[i+1]*x^i/i！）；B=subst（B+O（x^#A），x，log（1+x+O（x^#A））；对于（i=0，#A-1，A[i+1]=polceoff（B，i）*i！）；A类}/*加权变换*将集合结构应用于未标记对象序列*注入（或不对称）*该函数忽略a_0（a[1]）并假定它为0*输出序列总是b0=1*trvweighx是一个没有做出这种假设的版本*/{trv_weight（A）=局部（i=-1，B=矢量（#A-1，n，i=-i；i/n），C）；B=dirmul（向量提取（A，“2..”），B）；C=exp（Ser（concat（0，B）））；对于（i=1，#A，A[i]=polceoff（C，i-1））；A类}/*反加权变换*此函数忽略a0（a[1]）并假定它为1*输出序列总是b0=0*trv_i_weighx是一个没有做出这种假设的版本*/{trv_i_weight（A）=局部（i=-1，B=向量（#A-1，n，i=-i；i*1/n），C）；A[1]=1；C=对数（Ser（A））；A=向量提取（A，“2.”）；对于（i=1，#A，A[i]=polceoff（C，i））；A=dirdiv（A，B）；concat（0，A）}/*加权标记变换*将集合结构应用于标记对象的序列*注入（或L物种不对称）*此函数忽略a0（a[1]）并假定其为0*输出序列总是b0=1*函数使用trv_exp*/{trv_weigh_l（A）=局部（B=向量（#A-1），i，s）；A=向量提取（A，“2..”）；对于（k=1，#A，s=1；i=1；对于步骤（j=k，#A，k，如果（i>1，s*=（1-i）*二项式（j-1，j-k））；B[j]+=s*A[k]；i++；););trv_exp（连接（0，B））}/*逆加权标记变换*此函数忽略a0（a[1]）并假定它为1*输出序列总是b0=0*函数使用trv_log*/{trv_i_weigh_l（A）=本地（i，s）；A=trv_log（A）；A=向量提取（A，“2..”）；对于（k=1，#A\2，s=1；i=2；对于步骤（j=k+k，#A，k，s*=（1-i）*二项式（j-1，j-k）；A[j]-=s*A[k]；i++；););concat（0，A）}/*egf到序列*指数母函数序列的输出向量*由输入序列（“t_SER”）给出*/{trsv_egf（A）=向量（#A，i，polceoff（A，i-1）*（i-1）！）}/*ogf乘法运算*乘序列的ogf*序列长度是2中较短的*/{opv_mul_ogf（A，B）=局部（C=Ser（A，x）*Ser（B，x））；A=矢量（最小值（#A，#B））；对于（i=1，#A，A[i]=polceoff（C，i-1））；A类}/*ogf分区操作*划分序列的ogf*序列长度是2中较短的*/{opv_div_ogf（A，B）=局部（C=血清（A，x）/血清（B，x））；A=矢量（最小值（#A，#B））；对于（i=1，#A，A[i]=polceoff（C，i-1））；A类}/*egf乘法运算*乘以序列的egf*序列长度是2中较短的*/{opv_mul_egf（A，B）=局部（C=矢量（最小值（#A，#B）））；对于步骤（i=#C-1,0，-1，C[i+1]=总和（j=0，i，二项式（i，j）*A[j+1]）*B[i-j+1）；C类}/*egf:dgf乘法运算*返回egf为b_1*A（x）+b_2*A（x^2/2！）+…的序列。。。*序列长度是2中较短的*注意，此操作不是可交换的*/{opv_mul_ed（A，B）=本地（C，i，s）；C=矢量（最小值（#A，#B））；对于（k=1，#C-1，s=1；i＝1；对于步骤（j=k，#C-1，k，s*=二项式（j-1，j-k）；C[j+1]+=s*A[i+1]*B[k+1]；i++；););C类}/*其他变换*以下是其他更专业的功能*//*boutrophedon变换*/{trv_bous（A）=局部（x='x，B）；B=总和（i=0，#A-1，A[i+1]*x^i/i！）；B=（tan（x+O（x^#A））+1/cos（x+0（x^#1）））*（B+O（x^#A；对于（i=0，#A-1，A[i+1]=polceoff（B，i）*i！）；A类}/*逆boutrophedon变换*/{trv_i_bus（A）=本地（x='x，B）；B=总和（i=0，#A-1，A[i+1]*x^i/i！）；B=（B+O（x^#A））/（tan（x+O（x^#A））+1/cos（x+O（x^#A））；对于（i=0，#A-1，A[i+1]=polceoff（B，i）*i！）；A类}/*卡里茨变换*将列表结构应用于未标记对象的序列*坚持邻居是不同的对象类型*此函数忽略a0（a[1]）并假定其为0*输出序列总是b0=1*trv_carlitzx是一个没有做出这种假设的版本*函数使用trv_invert*/{trv_carlitz（A）=局部（i=-1，B=向量（#A-1，n，i=-i；i））；A=连接（0，dirmul（vecextract（A，“2..”），B））；转换（A）}/*逆carlitz变换*此函数忽略a0（a[1]）并假定它为1*输出序列总是b0=0*函数使用trv_i_invert*/{trv_i_carlitz（A）=局部（i=-1，B=向量（#A-1，n，i=-i；i），C）；A=trv_i_invert（A）；concat（0，dirdiv（向量提取（A，“2..”），B））；}/*carlitz变换的扩展形式*它不假设a_0=a[1]==0*函数使用trv_invert_x*/{trv_carlitz_x（A）=局部（i=-1，B=向量（#A-1，n，i=-i；i））；A=连接（A[1]/2，dirmul（vecextract（A，“2..”），B））；trv_反转_x（A）}/*链变换*将链（无向列表）结构应用于*未标记的对象*此函数忽略a0（a[1]）并假定其为0*输出序列总是b0=1*/{trv_chain（A）=局部（x='x，B=Ser（A，x）-A[1]，B2=subst（B，x，x^2））；B=（2-B^2）/（2*（1-B））+B2*（1+B）/（2*（1-B2））；对于（i=1，#A，A[i]=polceoff（B，i-1））；A类}/*矩阵的链变换*此函数忽略a_0,0（a[1,1]）并假定其为0*输出序列总是b0,0=1*/{trm_chain（A）=局部（x='x，y='y，m=matsize（A）[1]，n=matsice（A）[2]，B=O（x^m）+O（y^n），B2=O（x^m）+O（y^n），j=1）；对于（i=0，m-1，对于（j=j，n-1，B+=A[i+1，j+1]*x^i*y^j）；j=0；);对于（i=0，（m-1）\2，对于（j=j，（n-1）\2，B2+=A[i+1，j+1]*x^（2*i）*y^（2*j））；j=0；);B=（2-B^2）/（2*（1-B））+B2*（1+B）/（2*（1-B2））；对于（i=0，m-1，对于（j=0，n-1，A[i+1，j+1]=polceoff（polceof（B，j，y），i，x））；);A类}/*链内射变换*将链（无向列表）结构应用于*注入（或非对称）未标记对象*此函数忽略a0（a[1]）并假定其为0*输出序列总是b0=1*/{trv_chain_j（A）=本地（x='x，B=序列（A，x）-A[1]）；B2=子项（B，x，x^2）；B=（2-B^2）/（2*（1-B））-B2*（1+B）/（2*（1-B2））；对于（i=1，#A，A[i]=polceoff（B，i-1））；A类}/*矩阵的链内射变换*此函数忽略a_0,0（a[1,1]）并假定其为0*输出序列总是b0,0=1*/{trm_chain_j（A）=局部（x='x，y='y，m=matsize（A）[1]，n=matsice（A）[2]，B=O（x^m）+O（y^n），B2=O（x^m）+O（y^n），j=1）；对于（i=0，m-1，对于（j=j，n-1，B+=A[i+1，j+1]*x^i*y^j）；j=0；);对于（i=0，（m-1）\2，对于（j=j，（n-1）\2，B2+=A[i+1，j+1]*x^（2*i）*y^（2*j））；j=0；);B=（2-B^2）/（2*（1-B））-B2*（1+B）/（2*（1-B2））；对于（i=0，m-1，对于（j=0，n-1，A[i+1，j+1]=polceoff（polceof（B，j，y），i，x））；);A类}/*链标记变换*将链（无向列表）结构应用于标记对象的序列*此函数忽略a0（a[1]）并假定其为0*输出序列总是b0=1*/{trv_chain_l（A）=局部（x='x，B）；B=总和（i=1，#A-1，A[i+1]*x^i/i！）；B=（1/（1-B+O（x^#A））+1+B）/2；对于（i=0，#A-1，A[i+1]=polceoff（B，i）*i！）；A类}/*逆链标记变换*此函数忽略a0（a[1]）并假定它为1*输出序列总是b0=0*/{trv_i_chain_l（A）=本地（x='x，B）；B=总和（i=1，#A-1，A[i+1]*x^i/i！）；B=1+B-sqrt（1+B^2+O（x^#A））；对于（i=0，#A-1，A[i+1]=polceoff（B，i）*i！）；A类}/*链“boy-girl”变换*将链（无向列表）结构应用于*未标记的对象*坚持邻居是不同的对象类型*此函数忽略a0（a[1]）并假定其为0*输出序列总是b0=1*函数使用trv_carlitz、opv_mul_ogf*/{trv_chain_bg（A）=本地（B，C，D=[0,1,0，-1]）；B=trv_carlitz（A）；C=dirmul（向量提取（B，“2..”），向量（#B-1，n，n==2））；A=向量提取（A，“2..”）；A=dirmul（A，向量（#A，n，D[1+位和（n，3）]）；A=opv_mul_ogf（连接（0，A），连接（1，C））；A[1]＝1；（A+B）/2}/*切比雪夫变换*G.f.B（x）=（1-x^2）/（1+x^2*Paul Barry用于A100047*/{trv_chebyshev（A）=局部（x='x，B=Ser（A，x））；B=子集（B，x，x/（1+x^2+O（x^#A）））*；对于（i＝1，#A，A[i]＝polcoeff（B，i-1））；A类}/*逆切比雪夫变换*/{trv_i_chebyshev（A）=本地（x='x，B=Ser（A，x））；B=subst（B*（1+x^2+O（x^#A））/（1-x^2+0（x^#A）），x，serreverse（x/（1+x^2+0（x^#1）））；对于（i=1，#A，A[i]=polceoff（B，i-1））；A类}/*连续变换*/{trv_continuant（A）=局部（B=矢量（#A+1））；B[1]＝1；B[2]=A[1]；对于（i=2，#A，B[i+1]=A[i]*B[i]+A[i-1]）；B}/*逆连续变换*/{trv_i_continuant（A）=局部（B=矢量（#A-1））；A[1]=1；B[1]=A[2]；对于（i=2，#A-1，B[i]=（A[i+1]-B[i-1]）/A[i]）；B}/*矩阵的循环变换*此函数忽略a_0,0（a[1,1]）并假定其为0*输出序列总是b0,0=1*函数使用trmimoebius和trmlyndon*函数间接使用trmi_euler*/{trm_cycle（A）=A=trm_i_moebius（trm_lyndon（A））；A[1,1]=1；A类}/*矩阵的逆循环变换*此函数忽略a_0,0（a[1,1]）并假定它为1*输出序列始终具有b0,0=0*函数使用trm_moebius和trm_i_lyndon*函数间接使用trmeuler*/{trm_i_cycle（A）=trm_il_lyndon（trm_moebius（A））；}/*循环乘积变换*将循环结构应用于未标记对象序列*根据产品的尺寸进行组装*该函数忽略a_0、a_1（a[0]、a[1]），并假定它们为0*输出序列总是b0=0，b1=1*函数使用trv_i_moebius_p和trv_lyndon_p*函数间接使用trv_i_eulerp*/{trv_cycle_p（A）=A=trv_i_moebius_p（trv_lyndon_p（A））；A[2]=1；A类}/*逆循环乘积变换*此函数忽略a0、a1（a[0]、a[1]）并假定它们为0、1*输出序列总是b0=b1=0*函数使用trv_moebius_p和trv_i_lyndon_p*函数间接使用trv_eulerp*/{trv_i_cycle_p（A）=trv_i _lyndon_p（trv_moebius_p（B））；}/*循环标记变换*将循环结构应用于已标记对象的序列*此函数忽略a0（a[1]）并假定其为0*输出序列总是b0=1*函数使用trv_log*/{trv_cycle_l（A）=A=-trv_log（-A）；A[1]=1；A类}/*逆循环标记变换*此函数忽略a0（a[1]）并假定它为1*输出序列总是b0=0*函数使用trv_exp*/{trv_i_cycle_l（A）=A=-trv_exp（-A）；A[1]=0；A类}/*循环“boy-girl”变换*将循环结构应用于未标记对象序列*坚持邻居是不同的对象类型*此函数忽略a0（a[1]）并假定其为0*输出序列总是b0=1*函数使用trv_carlitz、trv_ieuler和trv_i_moebius*/{trv_cycle_bg（A）=局部（B=dirmul（向量提取（A，“2..”），向量（#A-1，n，（n==1）-（n==2）））；A+trv_i _ moebius（trv_i_euler（trv_carlitz（A））-连接（0，B））}/*矩阵的欧拉变换*此函数忽略a_0,0（a[1,1]）并假定其为0*输出序列总是b_0,0=1*/{trm_euler（A）=局部（x='x，y='y，m=matsize（A）[1]，n=matsice（A）[2]，B=O（x^m）+O（y^n），j=1，k，ki，kj）；对于（i=0，m-1，对于（j=j，n-1，k=1；ki=i；kj＝j；while（ki）时1，M[j，i]+=M[j-1，i-1]）；););M（M）}/*高斯（序列）变换*前一变换的行和序列*输出比输入长的序列1*/{trv_gauss（A）=本地（M=trv_gouss_M（A））；向量（#A+1，i，sum（j=1，i，M[i，j]））}/*逆高斯（序列）变换*它处理输入向量的第一个期望值*为1。（它这样对待它，忽略了值）*输出比输入短的序列1*/{trv_i_gauss（A）=局部（M=匹配（#A），B=矢量（#A-1））；对于（i=1，#A-1，B[i]=M[i+1，i]=A[i+1]-总和（j=1，i-1，M[i+1,j]）-1；如果（i>1，B[i]-=M[i，i-1]）；对于（j=i+2，#A，M[j，i]=B[i]*M[j-1，i]；如果（i>1，M[j，i]+=M[j-1，i-1]）；););B}/*汉克尔变换*/{trv_hankel（A）=局部（B=向量（1+#A\2））；对于（i=1，#B-1，B[i+1]=矩阵（矩阵（i，i，x，y，A[x+y-1]）；);B}/*小汉克尔变换*/{trv_hankel_little（A）=局部（B=矢量（#A-1））；B[1]=0；对于（i=2，#A-1，B[i]=A[i]^2-A[i+1]*A[i-1]；);B}/*矩阵的逆变换*此函数忽略a_0,0（a[1,1]）并假定其为0*输出序列总是b_0,0=1*/{trm_invert（A）=局部（x='x，y='y，m=matsize（A）[1]，n=matsice（A）[2]，B=O（x^m）+O（y^n），j=1）；对于（i=0，m-1，对于（j=j，n-1，B+=A[i+1，j+1]*x^i*y^j）；j=0；);B=1/（1-B）；对于（i＝0，对于（j=0，n-1，A[i+1，j+1]=polceoff（polceof（B，j，y），i，x））；);A类}/*矩阵的逆逆变换*此函数忽略a_0,0（a[1,1]）并假定它为1*输出序列始终具有b0,0=0*/{trm_i_invert（A）=局部（x='x，y='y，m=matsize（A）[1]，n=matsice（A）[2]，B=1+O（x^m）+O（y^n），j=1）；对于（i＝0，对于（j=j，n-1，B+=A[i+1，j+1]*x^i*y^j）；j=0；);B=1-1/B；对于（i=0，m-1，对于（j=0，n-1，A[i+1，j+1]=polceoff（polceof（B，j，y），i，x））；);A类}/*逆变换的扩展形式*它不假设a_0=a[1]==0*/{trv_invert_x（A）=本地（x='x，B=序列（A，x））；B=1/（1-B）；对于（i=1，#A，A[i]=polceoff（B，i-1））；A类}/*拉赫变换*将给定的标记结构应用于非空集*/{trv_lah（A）=本地（x='x，B）；B=总和（i=0，#A-1，A[i+1]*x^i/i！）；B=子集（B+O（x^#A），x，x/（1-x+O（x^#A；对于（i=0，#A-1，A[i+1]=polceoff（B，i）*i！）；A类}/*lah逆变换*/{trv_i_lah（A）=本地（x='x，B）；B=总和（i=0，#A-1，A[i+1]*x^i/i！）；B=子集（B+O（x^#A），x，x/（1+x+O（x^#A；对于（i=0，#A-1，A[i+1]=polceoff（B，i）*i！）；A类}/*矩阵的lyndon变换*此函数忽略a_0,0（a[1,1]）并假定其为0*输出序列总是b_0,0=1*函数使用trm_i_uler*/{trm_lyndon（A）=A=-trm_i_euler（-A）；A[1,1]=1；A类}/*矩阵的逆lyndon变换*此函数忽略a_0,0（a[1,1]）并假定它为1*输出序列总是b_0,0=0*函数使用trmeuler*/{trm_i_lyndon（A）=A=-trm_euler（-A）；A[1,1]=0；A类}/*林登积变换*应用lyndon单词结构（或非周期循环或*项链）到未标记对象的序列*根据产品的尺寸进行组装*此函数忽略a0、a1（a[0]、a[1]）并假定它们为0*输出序列总是b0=0，b1=1*函数使用trv_i_eulerp*/{trv_lyndon_p（A）=A=-trv_i_euler_p（-A）；A[2]=1；A类}/*逆lyndon积变换*此函数忽略a0、a1（a[0]、a[1]）并假定它们为0、1*输出序列总是b0=b1=0*函数使用trv_eulerp*/{trv_i_lyndon_p（A）=A=-trv_euler_p（-A）；A[2]=0；A类}/*掩模变换*来自Marc LeBrun发布的2001年6月9日seqfan*/{trv_任务（A）=对于步骤（i=#A-1,0，-1，A[i+1]=总和（j=0，i，（位和（i，j）==j）*A[j+1]））；A类}/*逆掩模变换*/{任务（A）=对于（i=1，#A-1，对于（j=0，i-1，A[i+1]-=（位和（i，j）==j）*A[j+1]））；A类}/*矩阵的moebius变换*此函数忽略a_0,0（a[1,1]）并假定其为0*输出序列总是b_0,0=0*/{trm_moebius（A）=局部（m=矩阵大小（A）[1]，n=矩阵大小[2]，j=1，ki，kj）；对于（i=0，（m-1）\2，对于（j=j，（n-1）\2，ki=i+i；kj=j+j；而（ki1，A[j]-=C[j]/k）；对于步骤（m=j+j，#A，j，C[m]-=C[j]）；k++；v*=A[i]；););concat（0，A）}/*逆witt变换*lyndon变换的切片及其与somos变换的关系*该函数忽略a_0（a[1]）并假定它为0*输出序列总是b0=0*/{trv_i_witt（A）=局部（B=向量（#A-1），C=向量（#B），k，v）；对于（i=1，#B，对于步骤（j=i，#B，i，C[j]=0）；v=A[i+1]；k=1；对于步骤（j=i，#B，i，C[j]+=v；B[j]+=C[j]/k；对于步骤（m=j+j，#B，j，C[m]-=C[j]）；k++；v*=A[i+1]；););concat（0，B）}/*和卷积运算*这个操作是不可逆的*/{opv_conv_and（A，B）=局部（C=向量（最小值（#A，#B）））；对于步骤（i=#C-1,0，-1，C[i+1]=总和（j=0，i，位和（A[j+1]，B[i-j+1]））；C类}/*gcd卷积运算*这个操作是不可逆的*/{opv_conv_gcd（A，B）=局部（C=矢量（最小值（#A，#B）））；对于步骤（i=#C-1,0，-1，C[i+1]=总和（j=0，i，gcd（A[j+1]，B[i-j+1]））；C类}/*lcm卷积运算*这个操作是不可逆的*/{opv_conv_lcm（A，B）=局部（C=矢量（最小值（#A，#B）））；对于步骤（i=#C-1,0，-1，C[i+1]=总和（j=0，i，lcm（A[j+1]，B[i-j+1]））；C类}/*或卷积运算*这个操作是不可逆的*/{opv_conv_or（A，B）=局部（C=矢量（最小值（#A，#B）））；对于步骤（i=#C-1,0，-1，C[i+1]=总和（j=0，i，位（A[j+1]，B[i-j+1]））；C类}/*异或卷积运算*/{opv_conv_xor（A，B）=局部（C=向量（最小值（#A，#B）））；对于步骤（i=#C-1,0，-1，C[i+1]=总和（j=0，i，位异或（A[j+1]，B[i-j+1]））；C类}/*异或除法运算*/{opv_div_xor（A，B）=局部（C=向量（最小值（#A，#B）））；对于（i=0，#C-1，C[i+1]=bitxor（A[1]，B[i+1]）-和（j=0，i-1，bitxor（A[i-j+1]，C[j+1]））；C类}/*循环“boy-girl”操作*将循环结构应用于未标记对象的序列B*而序列A控制邻居可以是相同对象类型的时间*序列长度是2中较短的*该函数假定a_0（a[1]）==1和b_0（b[1]）==0*忽略其实际值*输出序列总是c0=1*函数使用opv_invert_bg、trv_ieuler和trv_i_moebius*/{opv_cycle_bg（A，B）=本地（C=trv_i_euler（A））；C=dirmul（向量提取（B，“2..”），向量提取（C，“2...”））；C=trv_i_moebius（trv_ieuler（opv_invert_bg（A，B））-concat（0，C））；C[1]=1；C+concat（0，dirmul（向量提取（A，“2..”），向量提取（B，“2...”））；}/*欧拉“类型”操作*A为“基数”，B为“指数”*将集合结构应用于未标记对象的序列（B），允许*a_n表示有n个相同类型的对象*序列长度是2中较短的*此函数假定a0（a[1]）==1和b_0（b[1]）==0*忽略其实际值*输出序列总是c0=1*函数使用trv_euler和trv_i_euler*/{操作规则类型（A，B）=A=trv_i_euler（A）；A=dirmul（向量提取（A，“2..”），向量提取（B，“2...”））；trv_euler（连接（0，A））}/*指数型操作*A为“基数”，B为“指数”*将集合结构应用于标记对象的序列（B），允许*a_n表示有n个相同类型的对象*（作为L物种）*序列长度是2中较短的*此函数假定a0（a[1]）==1和b_0（b[1]）==0*忽略其实际值*输出序列总是c0=1*函数使用trv_exp、trv_log和opv_mul_ed*/{opv_exp_type（A，B）=trv_exp（opv_mul_ed（trv_log（A），B））}/*反转“boy-girl”操作*将列表结构应用于未标记对象的序列B*而序列A控制邻居可以是相同对象类型的时间*序列长度是2中较短的*此函数假定a0（a[1]）==1和b_0（b[1]）==0*忽略它们的实际值*输出序列总是c0=1*函数使用trv_invert和trv_iinvert*/{opv_invert_bg（A，B）=A=trv_i_invert（A）；A=dirmul（向量提取（A，“2..”），向量提取（B，“2...”））；trv_invert（连接（0，A））}