Created
February 12, 2025 01:25
-
-
Save emaballarin/2898787b1c18a30aa5090aa37b5b7529 to your computer and use it in GitHub Desktop.
Transformations of Integer Sequences (Mathematica Version)
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| (* seqtranslib.m -- version batch 0.10 -- 10 Jan 1998 *) | |
| (* Integer Sequences Transformations Mathematica Library *) | |
| (* by Olivier Gerard from original Maple code and ideas by N. J. A. Sloane *) | |
| (* Batch code *) | |
| (* List of meaningful transformed sequences prefixed with indice of transform and without signs *) | |
| SuperTrans[seq_List] := Abs[Cases[MapIndexed[ {First[#2],#1[seq]} & , EISTransTable ],{_Integer,{__Integer}}]] | |
| (* Formatting routines *) | |
| SeqString[seq_List] := StringTake[ToString[seq], {2, -2}]<>"\n"; | |
| WriteSeekerList[transeq_List,sortie_:$Output]:=Scan[ WriteString[sortie,"T",StringDrop[ToString[1000+#1[[1]]],1]," ",SeqString[#1[[2]]]]&, transeq] | |
| WriteSeqList[transeq_List,sortie_:$Output]:=(MapIndexed[ WriteString[sortie,SeqString[#]]&, transeq];) | |
| (* Utility and Transform Code *) | |
| (* All programs are designed to work for Mathematica 2.0 and higher but Mathematica 3.0 is recommended and may be necessary in future versions. *) | |
| (* Number Theory utilities *) | |
| did[m_Integer, n_Integer] := If[Mod[m, n] == 0, 1, 0]; | |
| didsigned[m_Integer, n_Integer] := If[Mod[m, n] == 0, (-1)^(m/n), 0]; | |
| mob[m_Integer, n_Integer] := If[Mod[m, n] == 0, MoebiusMu[m/n], 0]; | |
| GCDNormalize[{}]:= {}; | |
| GCDNormalize[seq_List]:= seq/GCD@@seq; | |
| LCMNormalize[{}]:={}; | |
| LCMNormalize[seq_List]:=DeleteCases[seq,0] // (LCM@@#/Reverse[#])&; | |
| IntegerSequenceQ[seq_List]:= Union[IntegerQ/@seq]=={True} | |
| FilterSequence[{}]:= {}; | |
| FilterSequence[seq_List]:=If[And@@(IntegerQ/@seq),seq,{}]; | |
| (* Difference Table utilities *) | |
| GetDiff[{}] = {}; | |
| GetDiff[{elem_}] = {}; | |
| GetDiff[seq_List]:=Drop[seq,1]-Drop[seq,-1]; | |
| GetDiff[seq_List,n_Integer]:={}/;n>=Length[seq] | |
| GetDiff[seq_List,n_Integer]:= | |
| Plus@@Table[(-1)^(n+i)Binomial[n,i]Take[seq,{i+1,Length[seq]-n+i}],{i,0,n}] | |
| GetOffsetDiff[seq_List]:=GetDiff[seq]; | |
| GetOffsetDiff[seq_List,n_Integer]:={}/;n>=Length[seq] | |
| GetOffsetDiff[seq_List,n_Integer]:= | |
| Take[seq,{n+1,-1}]-Take[seq,{1,-n-1}] | |
| GetIntervalDiff[seq_List]:=GetDiff[seq]; | |
| GetIntervalDiff[seq_List,n_Integer]:={}/;n>=Length[seq] | |
| GetIntervalDiff[seq_List,n_Integer]:= | |
| Take[seq,{n+1,-1}]-Plus@@Table[Take[seq,{i+1,Length[seq]-n+i}],{i,0,n-1}] | |
| GetSum[{}] = {}; | |
| GetSum[{elem_}] = {}; | |
| GetSum[seq_List]:=Drop[seq,1]+ Drop[seq,-1]; | |
| GetSum[seq_List,n_Integer]:={}/;n>=Length[seq] | |
| GetSum[seq_List,n_Integer]:= | |
| Plus@@Table[Binomial[n,i]Take[seq,{i+1,Length[seq]-n+i}],{i,0,n}] | |
| GetOffsetSum[seq_List]:=GetSum[seq]; | |
| GetOffsetSum[seq_List,n_Integer]:={}/;n>=Length[seq] | |
| GetOffsetSum[seq_List,n_Integer]:= | |
| Take[seq,{1,-n-1}]+Take[seq,{n+1,-1}] | |
| GetIntervalSum[seq_List]:=GetSum[seq]; | |
| GetIntervalSum[seq_List,n_Integer]:={}/;n>=Length[seq] | |
| GetIntervalSum[seq_List,n_Integer]:= | |
| Plus@@Table[Take[seq,{i+1,Length[seq]-n+i}],{i,0,n}] | |
| DiffTable[{},___]={}; | |
| DiffTable[seq_List,1] := NestList[GetDiff,seq,Length[seq]-1]; | |
| DiffTable[seq_List,n_Integer] := NestList[GetDiff,DiffTable[seq,n-1][[Range[Length[seq]],1]],Length[seq]-1] /; n>1 | |
| PartialProducts[{}]={}; | |
| PartialProducts[seq_List]:=Rest[FoldList[#1 #2&,1,seq]]; | |
| PartialSums[{}]={}; | |
| PartialSums[seq_List]:=Rest[FoldList[#1+#2&,0,seq]]; | |
| (* Generating Function utilities *) | |
| SeqToPoly[{}, ___] = {}; | |
| SeqToPoly[seq_List, var_Symbol:n] := | |
| Expand[Plus @@ | |
| (Table[Sum[(-1)^(i - 1 - k)*Binomial[i - 1, k]*seq[[k + 1]], {k, 0, i - 1}], | |
| {i, 1, Length[seq]}]*Array[Binomial[var, #1 - 1] & , Length[seq]])]; | |
| GetPowerCoeffs[f_,var_Symbol:x,n_Integer]:= | |
| Block[{g=ExpandAll[f]},DeleteCases[Table[Coefficient[g,var,i],{i,0,n}],0]] | |
| ListToSeries::unkn = | |
| "This kind of generating function is unknown."; | |
| ListToSeries::nimp = | |
| "This kind of generating function is not yet implemented. \ | |
| Sorry."; | |
| ListToSeries[seq_List, var_Symbol:x, kind_String:"ogf"] := | |
| Switch[kind, | |
| "ogf", SeriesData[var, 0, seq, 0, Length[seq], 1], | |
| "egf", SeriesData[var, 0, seq/Array[#1! & , Length[seq], 0], 0, Length[seq], 1], | |
| "lap", SeriesData[var, 0, seq*Array[#1! & , Length[seq], 0], 0, Length[seq], 1], | |
| "lgdogf", ListToSeries::nimp, | |
| "lgdegf", ListToSeries::nimp, _, ListToSeries::unkn]; | |
| SeriesToList::unkn = ListToSeries::unkn; | |
| SeriesToList::nimp = ListToSeries::nimp; | |
| SeriesToList[ser_SeriesData, kind_String:"ogf"] := | |
| Switch[kind, | |
| "ogf", Array[SeriesCoefficient[ser, #1] & , ser[[5]], 0], | |
| "egf", | |
| Array[SeriesCoefficient[ser, #1]*#1! & , ser[[5]], 0], | |
| "lap", | |
| Array[SeriesCoefficient[ser, #1]/#1! & , ser[[5]], 0], | |
| "lgdogf", SeriesToList::nimp, | |
| "lgdegf", SeriesToList::nimp, | |
| _, SeriesToList::unkn]; | |
| SeriesToSeries::unkn = ListToSeries::unkn; | |
| SeriesToSeries[ser_SeriesData, kind_String] := | |
| If[kind == "ogf", ser, ListToSeries[Array[(SeriesCoefficient[ser, #1] & )* | |
| ser[[5]], 0], ser[[1]], kind], Null]; | |
| GetSeriesCoeff::"unkn"=ListToSeries::"unkn"; | |
| GetSeriesCoeff::"nimp"=ListToSeries::"nimp"; | |
| GetSeriesCoeff[ser_SeriesData,j_Integer, kind_String:"ogf"]:= | |
| Switch[kind, | |
| "ogf", SeriesCoefficient[ser,j], | |
| "egf", SeriesCoefficient[ser,j ]*(j-1)!, | |
| "lap",SeriesCoefficient[ser,j]/(j-1)!, | |
| "lgdogf", GetSeriesCoeff::"nimp", | |
| "lgdegf", GetSeriesCoeff::"nimp", | |
| _,GetSeriesCoeff::"unkn"]; | |
| ListToListDiv[{}] := {}; | |
| ListToListDiv[seq_List] := seq/Array[#1! & , Length[seq], 0]; | |
| ListToListMult[{}] := {}; | |
| ListToListMult[seq_List] := seq*Array[#1! & , Length[seq], 0]; | |
| SeriesToListDiv[ser_SeriesData] := SeriesToList[ser, "egf"]; | |
| SeriesToListMult[ser_SeriesData] := SeriesToList[ser, "lap"] | |
| SeriesToSeriesDiv[ser_SeriesData] := SeriesToSeries[ser, "egf"] | |
| SeriesToSeriesMult[ser_SeriesData] := SeriesToList[ser, "lap"] | |
| (* Binary and other bases utilities *) | |
| MatchDigits[x_Integer,y_Integer,base_Integer:10]:= | |
| Block[{bx,by,lx,ly}, | |
| {lx,ly}=Length/@( | |
| {bx,by}=(IntegerDigits[#1,base]&)/@{x,y}); | |
| If[lx-ly==0, | |
| {bx,by}, | |
| (Join[Array[0&,Max[lx,ly]-Length[#1]],#1]&)/@{bx,by}]]; | |
| MatchBinary[x_Integer,y_Integer]:=MatchDigits[x,y,2]; | |
| DigitsToInteger[thedigits_List,base_Integer:10]:= | |
| Plus@@(Reverse[thedigits] Array[base^#1&,Length[thedigits],0]) | |
| BinaryToInteger[bindig_List]:=DigitsToInteger[bindig,2] | |
| Xcl[twodig_List]:=Length[Union[twodig]]-1; | |
| NumAND[x_Integer,y_Integer]:=BinaryToInteger[Min/@Transpose[MatchBinary[x,y]]]; | |
| NumOR[x_Integer,y_Integer]:=BinaryToInteger[Max/@Transpose[MatchBinary[x,y]]]; | |
| Off[General::spell1] | |
| NumXOR[x_Integer,y_Integer]:=BinaryToInteger[Xcl/@Transpose[MatchBinary[x,y]]]; | |
| On[General::spell1] | |
| NimSum[numOne_Integer,numTwo_Integer]:=BinaryToInteger[Plus@@MatchBinary[numOne,numTwo]/.{2->0}] | |
| DigitSum[n_Integer,b_Integer:10]:=Plus@@IntegerDigits[n,b]; | |
| DigitRev[n_Integer,b_Integer:10]:=DigitsToInteger[Reverse[IntegerDigits[n,b]],b]; | |
| (* Set-Theoretical Transforms *) | |
| $EISShortComplementSize=60; | |
| $EISLongComplementSize=1000; | |
| $EISUnsameCount=10; | |
| $EISMaxCharSeq=100; | |
| MinExcluded[seq_List]:= | |
| Module[{theset=Union[seq]}, | |
| Select[Range[0,Max[seq]+1],!(MemberQ[theset,#1])&,1]] | |
| Monotonous[{}]={}; | |
| Monotonous[seq_List]:=Union[Abs[seq]]; | |
| MonotonousDiff[{}]={}; | |
| MonotonousDiff[seq_List]:=Block[{seqres},If[seq==(seqres=Union[Abs[seq]])||Length[seq]-Length[seqres]<$EISUnsameCount,{},seqres]]; | |
| CompSequence[{}]={}; | |
| CompSequence[seq_List]:=Block[{seqres}, | |
| If[ | |
| Length[seqres=Complement[Range[Min[Max[seq],$EISShortComplementSize]], | |
| Monotonous[seq]] | |
| ]< $EISUnsameCount|| | |
| Length[seqres]>$EISShortComplementSize-$EISUnsameCount, | |
| {}, | |
| seqres]]; | |
| CompSequenceLong[{}]={}; | |
| CompSequenceLong[seq_List]:=Complement[Range[Min[Max[seq],$EISLongComplementSize]],Monotonous[seq]] | |
| TwoValuesQ[seq_List]:= (Length[Union[seq]]==2) | |
| CharSequence[{}]={}; | |
| CharSequence[seq_List]:=Block[{b,reslen},b=Monotonous[seq];reslen=Min[Max[b],$EISMaxCharSeq]; | |
| Last[Transpose[Sort[Transpose[ | |
| {Join[b,Complement[Range[0,reslen],b]],Join[Array[1&,Length[b]],Array[0&,1+reslen-Length[b]]]}]]]]] | |
| (* SubSequence Extraction *) | |
| SeqExtract[{}, ___] = {}; | |
| SeqExtract[seq_List, period_Integer:1, start_Integer:1] := | |
| seq[[start + period*Range[0, Floor[(Length[seq] - start)/period]]]] | |
| Decimate[{}, ___] = {}; | |
| Decimate[seq_List, k_Integer, j_Integer] := | |
| With[{l = Floor[(Length[seq] + k - 1 - j)/k]}, | |
| If[l < 1, {}, seq[[1 + j + k*Range[0, l - 1]]]]] | |
| Bisect[seq_List, 0] := Decimate[seq, 2, 0]; | |
| (Bisect[seq_List, 1] := Decimate[seq, 2, 1]; ) | |
| Bisect[seq_List, start_Integer] = {}; Trisect[seq_List, 0] := Decimate[seq, 3, 0]; | |
| (Trisect[seq_List, 1] := Decimate[seq, 3, 1]; ) | |
| Trisect[seq_List, 2] := Decimate[seq, 3, 2]; | |
| Trisect[seq_List, start_Integer] = {}; | |
| (* Elementary Transforms *) | |
| LeftTransform[{}]:={}; | |
| LeftTransform[seq_List]:=Rest[seq]; | |
| RightTransform[{}]:={}; | |
| RightTransform[seq_List]:=Prepend[seq,1]; | |
| MulTwoTransform[{}]={}; | |
| MulTwoTransform[seq_List]:=Join[{First[seq]},Rest[seq] 2]; | |
| DivTwoTransform[{}]={}; | |
| DivTwoTransform[seq_List]:=Join[{First[seq]},Rest[seq]/2]; | |
| NegateTransform[{}]={}; | |
| NegateTransform[seq_List]:=Join[{First[seq]},-Rest[seq]]; | |
| (* Difference Table (Binomial) Transforms *) | |
| BinomialTransform[{},___]={}; | |
| BinomialTransform[seq_List,way_:1]:=Table[Sum[way^(i - 1 - k)*Binomial[i - 1, k]*seq[[k + 1]], {k, 0, i - 1}],{i,1,Length[seq]}]; | |
| BinomialInvTransform[{},___]={}; | |
| BinomialInvTransform[seq_List,way_:1]:=BinomialTransform[seq,-way] | |
| (* Rational Generating Function Transforms *) | |
| GFProdaaaTransform[{},___]:={}; | |
| GFProdaaaTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[1/ListToSeries[seq,var,gftype]^2,gftype]] | |
| GFProdbbbTransform[{},___]:={}; | |
| GFProdbbbTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]^2,gftype]] | |
| GFProdcccTransform[{},___]:={}; | |
| GFProdcccTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[1/ListToSeries[seq,var,gftype],gftype]] | |
| GFProddddTransform[{},___]:={}; | |
| GFProddddTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]*(1+var)/(1-var),gftype]] | |
| GFProdeeeTransform[{},___]:={}; | |
| GFProdeeeTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]*(1-var)/(1+var),gftype]] | |
| GFProdfffTransform[{},___]:={}; | |
| GFProdfffTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]/(1-var),gftype]] | |
| GFProdgggTransform[{},___]:={}; | |
| GFProdgggTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]/(1-var)^2,gftype]] | |
| GFProdhhhTransform[{},___]:={}; | |
| GFProdhhhTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]/(1-var)^3,gftype]] | |
| GFProdiiiTransform[{},___]:={}; | |
| GFProdiiiTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]/(1+var),gftype]] | |
| GFProdjjjTransform[{},___]:={}; | |
| GFProdjjjTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]/(1+var^2),gftype]] | |
| GFProdkkkTransform[{},___]:={}; | |
| GFProdkkkTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]/(1+var+var^2),gftype]] | |
| GFProdlllTransform[{},___]:={}; | |
| GFProdlllTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]/(1-var^2),gftype]] | |
| GFProdmmmTransform[{},___]:={}; | |
| GFProdmmmTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]/(1-var-var^2),gftype]] | |
| GFProdnnnTransform[{},___]:={}; | |
| GFProdnnnTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]/(1-var+var^2),gftype]] | |
| GFProdoooTransform[{},___]:={}; | |
| GFProdoooTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]/(1+var-var^2),gftype]] | |
| GFProdpppTransform[{},___]:={}; | |
| GFProdpppTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]/(1+var)^2,gftype]] | |
| GFProdqqqTransform[{},___]:={}; | |
| GFProdqqqTransform[seq_List,gftype_String:"ogf"]:=Module[{var},SeriesToList[ListToSeries[seq,var,gftype]/(1+var)^3,gftype]] | |
| (* Diagonal Generating Function Transforms *) | |
| GFDiagaaaTransform[{},___]:={}; | |
| GFDiagaaaTransform[seq_List,gftype_String:"ogf"]:=Module[{var,baseser},baseser = ListToSeries[Prepend[seq,0],var,gftype]; | |
| Table[GetSeriesCoeff[baseser*(1-var)^j,j,gftype],{j,1,Length[seq]}]] | |
| GFDiagbbbTransform[{},___]:={}; | |
| GFDiagbbbTransform[seq_List,gftype_String:"ogf"]:=Module[{var,baseser},baseser = ListToSeries[Prepend[seq,0],var,gftype]; | |
| Table[GetSeriesCoeff[baseser*(1+var)^j,j,gftype],{j,1,Length[seq]}]] | |
| GFDiagcccTransform[{},___]:={}; | |
| GFDiagcccTransform[seq_List,gftype_String:"ogf"]:=Module[{var,baseser},baseser = ListToSeries[Prepend[seq,0],var,gftype]; | |
| Table[GetSeriesCoeff[baseser/(1-var)^j,j,gftype],{j,1,Length[seq]}]] | |
| GFDiagdddTransform[{},___]:={}; | |
| GFDiagdddTransform[seq_List,gftype_String:"ogf"]:=Module[{var,baseser},baseser = ListToSeries[Prepend[seq,0],var,gftype]; | |
| Table[GetSeriesCoeff[baseser/(1+var)^j,j,gftype],{j,1,Length[seq]}]] | |
| (* Classical (Euler, M\[ODoubleDot]bius, Stirling) *) | |
| EulerTransform[{}]={}; | |
| EulerTransform[seq_List]:=Module[{coeff,final={}}, | |
| coeff=Table[Sum[d*did[i, d]*seq[[d]], {d, 1, i}],{i,1,Length[seq]}]; | |
| For[i=1,i<=Length[seq],i++,AppendTo[final,(coeff[[i]] + Sum[coeff[[d]]*final[[i - d]], {d, 1, i - 1}])/i]];final]; | |
| EulerInvTransform[{}]={}; | |
| EulerInvTransform[seq_List]:=Module[{final={}}, | |
| For[i=1,i<=Length[seq],i++,AppendTo[final,i*seq[[i]] - Sum[final[[d]]*seq[[i - d]], {d, 1, i - 1}]]]; | |
| Table[Sum[mob[i, d]*final[[d]], {d, 1, i}]/i, {i, 1, Length[seq]}]]; | |
| MobiusTransform[{}]={}; | |
| MobiusTransform[seq_List]:=Table[Sum[mob[i, d]*seq[[d]], {d, 1, i}],{i,1,Length[seq]}] | |
| MobiusInvTransform[{}]={}; | |
| MobiusInvTransform[seq_List]:=Table[Sum[did[i, d]*seq[[d]], {d, 1, i}],{i,1,Length[seq]}] | |
| StirlingTransform[{}]={}; | |
| StirlingTransform[seq_List]:=Table[Sum[StirlingS2[i, k]*seq[[k]], {k, 1, i}],{i,1,Length[seq]}] | |
| StirlingInvTransform[{}]={}; | |
| StirlingInvTransform[seq_List]:=Table[Sum[StirlingS1[i, k]*seq[[k]], {k, 1, i}],{i,1,Length[seq]}] | |
| (* Number Theory Convolutions *) | |
| LCMConvTransform[___List,{},___List]:={}; | |
| LCMConvTransform[seq_List]:=Table[Sum[LCM[seq[[k]], seq[[i - k + 1]]], {k, 1, i}],{i,1,Length[seq]}]; | |
| LCMConvTransform[seqOne_List,seqTwo_List]:=Table[Sum[LCM[seqOne[[k]], seqTwo[[i - k + 1]]], {k, 1, i}], | |
| {i,1,Min@@(Length/@{seqOne,seqTwo})}]; | |
| GCDConvTransform[___List,{},___List]:={}; | |
| GCDConvTransform[seq_List]:=Table[Sum[GCD[seq[[k]], seq[[i - k + 1]]], {k, 1, i}],{i,1,Length[seq]}]; | |
| GCDConvTransform[seqOne_List,seqTwo_List]:=Table[Sum[GCD[seqOne[[k]], seqTwo[[i - k + 1]]], {k, 1, i}],{i,1,Min@@(Length/@{seqOne,seqTwo})}]; | |
| (* Generating Function Transforms | |
| (Cameron, Revert, RevertExp, Exp, Log) *) | |
| CameronTransform[{}]:={}; | |
| CameronTransform[seq_List]:=Module[{var},Rest[SeriesToList[1/(1 - var*ListToSeries[seq, var, "ogf"]),"ogf"]]]; | |
| CameronInvTransform[{}]:={}; | |
| CameronInvTransform[seq_List]:=Module[{var},Rest[SeriesToList[-1/(1 + var*ListToSeries[seq, var, "ogf"]),"ogf"]]]; | |
| RevertTransform[{}]:={}; | |
| RevertTransform[seq_List]:=Module[{var,l=Length[seq]},If[seq[[1]]=!=1,{},Rest[SeriesToList[InverseSeries[ListToSeries[seq,var,"ogf"]],"ogf"] Array[(-1)^#1 &,l]]]] | |
| RevertExpTransform[{}]:={}; | |
| RevertExpTransform[seq_List]:=Module[{var,l=Length[seq]},If[seq[[1]]=!=1,{},Rest[SeriesToList[InverseSeries[ListToSeries[seq,var,"egf"]],"ogf"] Array[(-1)^#1 (#1-1)!&,l]]]]; | |
| ExpTransform[{}]:={}; | |
| ExpTransform[seq_List]:=Module[{var},Rest[SeriesToList[Exp[ListToSeries[Prepend[seq,0],var,"egf"]],"egf"]]] | |
| LogTransform[{}]:={}; | |
| LogTransform[seq_List]:=Module[{var},Rest[SeriesToList[Log[ListToSeries[Prepend[seq,1],var,"egf"]],"egf"]]] | |
| (* Convolution Transforms *) | |
| ConvTransform[___List,{},___List]:={}; | |
| ConvTransform[seq_List]:=Table[Sum[seq[[k]]*seq[[i - k + 1]], {k, 1, i}], {i, 1, Length[seq]}]; | |
| ConvTransform[seqOne_List,seqTwo_List]:=Table[Sum[seqOne[[k]]*seqTwo[[i - k + 1]], {k, 1, i}], | |
| {i, 1, Min @@ Length /@ {seqOne, seqTwo}}]; | |
| ConvInvTransform[seq_List]:=If[First[seq]=!=0, | |
| Module[{a,aaseq=Table[a[i],{i,Length[seq]}]}, | |
| aaseq/.Last[Solve[ConvTransform[aaseq]==seq,aaseq]]]] | |
| ExpConvTransform[___List,{},___List]:={}; | |
| ExpConvTransform[seq_List]:=Module[{var},SeriesToList[ListToSeries[seq, var, "egf"]^2,"egf"]] | |
| ExpConvTransform[seqOne_List,seqTwo_List]:= | |
| Module[{var,tmplen=Min@@(Length/@{seqOne,seqTwo})}, | |
| SeriesToList[Times@@(ListToSeries[Take[#1,tmplen],var,"egf"]&)/@{seqOne,seqTwo},"egf"] | |
| ] | |
| LogConvTransform[{}]:={}; | |
| LogConvTransform[seq_List]:=Module[{var},SeriesToList[ListToSeries[seq, var, "lap"]^2,"ogf"]] | |
| LogConvTransform[seqOne_List,seqTwo_List]:= | |
| Module[{var,tmplen=Min[Length/@{seqOne,seqTwo}]}, | |
| SeriesToList[Times@@(ListToSeries[Take[#1,tmplen],var,"lap"]&)/@{seqOne,seqTwo},"ogf"] | |
| ] | |
| (* Binary and other bases related Transforms *) | |
| ANDConvTransform[{}]={}; | |
| ANDConvTransform[seq_List]:=Table[Sum[NumAND[seq[[k + 1]], seq[[i - k + 1]]], {k, 0, i}],{i,0,Length[seq]-1}] | |
| ORConvTransform[{}]={}; | |
| ORConvTransform[seq_List]:=Table[Sum[NumOR[seq[[k + 1]], seq[[i - k + 1]]], {k, 0, i}],{i,0,Length[seq]-1}] | |
| Off[General::spell1] | |
| XORConvTransform[{}]={}; | |
| XORConvTransform[seq_List]:=Table[Sum[NumXOR[seq[[k + 1]], seq[[i - k + 1]]], {k, 0, i}], {i, 0, Length[seq] - 1}] | |
| On[General::spell1] | |
| DigitSumTransform[{},___]:={}; | |
| DigitSumTransform[seq_List,b_Integer:10]:= | |
| DigitSum[#,b]&/@seq; | |
| DigitRevTransform[{},___]:={}; | |
| DigitRevTransform[seq_List,b_Integer:10]:=DigitRev[#,b]&/@seq; | |
| (* Boustrophedon Transforms *) | |
| $EISMaxTableWidth=60; | |
| BoustrophedonBisTransformTable[{}]={}; | |
| BoustrophedonBisTransformTable[seq_List,way_Integer:1]:=Module[{n=Min[Length[seq],$EISMaxTableWidth],tritab},tritab=Transpose[{Take[seq,n]}];Table[tritab[[i]]=Nest[Append[#1,#1[[-1]]+way tritab[[i-1,i-Length[#1]]]]&,tritab[[i]],i-1],{i,1,n}]] | |
| BoustrophedonTransformTable[seq_List]:=BoustrophedonBisTransformTable[Prepend[seq,1]] | |
| BoustrophedonTransform[seq_List]:=Last/@BoustrophedonTransformTable[seq] | |
| BoustrophedonBisTransform[seq_List]:=Last/@BoustrophedonBisTransformTable[seq] | |
| BoustrophedonBisInvTransform[seq_List]:=Last/@BoustrophedonBisTransformTable[seq,-1] | |
| BoustrophedonInvTransform[seq_List]:=Last/@Rest[BoustrophedonBisTransformTable[seq,-1]] | |
| (* Partition and related Transforms *) | |
| PartitionTransform[{},___]:={}; | |
| PartitionTransform[seq_List,n_Integer:-1]:= | |
| Module[{var,valueset,lastindex,lastvalue}, | |
| valueset=Union[seq]; | |
| {lastindex,lastvalue}=If[n==-1, | |
| {Length[valueset],Max@@valueset}, | |
| {First[Flatten[Position[Union[Append[valueset,n]],n]]],n}]; | |
| Rest[SeriesToList[Series[ | |
| Product[1/(1-var^valueset[[i]]),{i,1,lastindex}], | |
| {var,0,lastvalue}],"ogf"]]]; | |
| PartitionInvTransform[{}]:={}; | |
| PartitionInvTransform[seq_List]:= | |
| Flatten[MapIndexed[ Table[#2[[1]],{#1}]&, EulerInvTransform[seq]]] | |
| (* Other Transforms (weigh, weighbisout, eulerbis) *) | |
| WeighTransform[{},___]:={}; | |
| WeighTransform[seq_List,n_Integer:-1,gftype_String:"ogf"]:=Module[{var,lastvalue},lastvalue=If[n==-1,Max@@seq,n];Rest[SeriesToList[Series[Product[1 - var^seq[[i]], {i, 1, Length[seq]}], {var, 0, lastvalue + 1}],gftype]]] | |
| WeighBisOutTransform[{}]={}; | |
| WeighBisOutTransform[seq_List]:=Module[{var},SeriesToList[Series[Product[(var^(-k) + 1 + var^k)^seq[[k]], {k, 1, Length[seq]}], | |
| {var, 0, Length[seq] + 1}],"ogf"]]; | |
| EulerBisTransform[{}]={}; | |
| EulerBisTransform[seq_List]:=Module[{var},SeriesToList[Series[Sum[seq[[k]]*(var/(1 + var))^k, {k, 1, Length[seq]}]/(1 + var), | |
| {var, 0, Length[seq]}],"ogf"]]; | |
| (* To be made: weighout, weighouti, etrans, ptrans, pairtrans *) | |
| (* Function Management *) | |
| RegularTransList = | |
| {"Binomial", "Euler", "Mobius", "Stirling", "Cameron", "Boustrophedon", | |
| "BoustrophedonBis", "Partition"}; | |
| ((InverseFunction[Evaluate[ToExpression[StringJoin[#1, "Transform"]]]] ^= | |
| ToExpression[StringJoin[#1, "InvTransform"]]; | |
| InverseFunction[Evaluate[ToExpression[StringJoin[#1, "InvTransform"]]]] ^= | |
| ToExpression[StringJoin[#1, "Transform"]]; ) & ) /@ RegularTransList; | |
| (* Superseeker Transforms list *) | |
| (* Transforms 095,096,097,098 are currently not implemented and | |
| return {} *) | |
| (* Transform 008 must be executed before any other transform needing | |
| the exp gen fun *) | |
| EISTransTable = { Clear[vexpseq]; | |
| Trans[001]= Identity, | |
| Trans[002]= CompSequence, | |
| Trans[003]= GCDNormalize, | |
| Trans[004]= (Rest[#]// Trans[003] )&, | |
| Trans[005]= (Drop[#,2]// Trans[004]) &, | |
| Trans[006]= Bisect[#,0]&, | |
| Trans[007]= Bisect[#,1]&, | |
| Trans[008]= (vexpseq = #/Array[#1!&,Length[#],0])&, | |
| Trans[009]= #*Range[Length[#]]&, | |
| Trans[010]= #/Array[#1!&,Length[#],1]&, | |
| Trans[011]= 2#&, | |
| Trans[012]= 3#&, | |
| Trans[013]= GFProdaaaTransform, | |
| Trans[014]= GFProdbbbTransform, | |
| Trans[015]= GFProdcccTransform, | |
| Trans[016]= GFProddddTransform, | |
| Trans[017]= GFProdeeeTransform, | |
| Trans[018]= GetDiff, | |
| Trans[019]= GetDiff[#,2]&, | |
| Trans[020]= GetDiff[#,3]&, | |
| Trans[021]= GFProdfffTransform, | |
| Trans[022]= GFProdgggTransform, | |
| Trans[023]= GFProdhhhTransform, | |
| Trans[024]= GetSum, | |
| Trans[025]= GetOffsetSum[#,2]&, | |
| Trans[026]= GFProdiiiTransform, | |
| Trans[027]= GFProdjjjTransform, | |
| Trans[028]= GetIntervalSum[#,2]&, | |
| Trans[029]= GFProdkkkTransform, | |
| Trans[030]= GetOffsetDiff[#,2]&, | |
| Trans[031]= GFProdlllTransform, | |
| Trans[032]= Take[#,{3,-1}]- Take[#,{2,-2}]-Take[#,{1,-3}]&, | |
| Trans[033]= GFProdmmmTransform, | |
| Trans[034]= # + Range[Length[#]]&, | |
| Trans[035]= # +2&, | |
| Trans[036]= # +3&, | |
| Trans[037]= # - Range[Length[#]]&, | |
| Trans[038]= # -2&, | |
| Trans[039]= # -3&, | |
| Trans[040]= # +1&, | |
| Trans[041]= # -1&, | |
| Trans[042]= GFProdnnnTransform, | |
| Trans[043]= Take[#,{3,-1}]- Take[#,{2,-2}]+Take[#,{1,-3}]&, | |
| Trans[044]= GFProdoooTransform, | |
| Trans[045]= Take[#,{1,-3}]+ Take[#,{2,-2}]-Take[#,{3,-1}]&, | |
| Trans[046]= GetSum[#,2]&, | |
| Trans[047]= GetSum[#,3]&, | |
| Trans[048]= GFProdpppTransform, | |
| Trans[049]= GFProdqqqTransform, | |
| Trans[050]= GFDiagaaaTransform, | |
| Trans[051]= GFDiagbbbTransform, | |
| Trans[052]= GFDiagcccTransform, | |
| Trans[053]= GFDiagdddTransform, | |
| Trans[054]= GFProdaaaTransform[#,"egf"]&, | |
| Trans[055]= GFProdbbbTransform[#,"egf"]&, | |
| Trans[056]= GFProdcccTransform[#,"egf"]&, | |
| Trans[057]= GFProddddTransform[#,"egf"]&, | |
| Trans[058]= GFProdeeeTransform[#,"egf"]&, | |
| Trans[059]= GetDiff[vexpseq]&, | |
| Trans[060]= GetDiff[vexpseq,2]&, | |
| Trans[061]= GetDiff[vexpseq,3]&, | |
| Trans[062]= GFProdfffTransform[#,"egf"]&, | |
| Trans[063]= GFProdgggTransform[#,"egf"]&, | |
| Trans[064]= GFProdhhhTransform[#,"egf"]&, | |
| Trans[065]= GetSum[vexpseq]&, | |
| Trans[066]= GetOffsetSum[vexpseq,2]&, | |
| Trans[067]= GFProdiiiTransform[#,"egf"]&, | |
| Trans[068]= GFProdjjjTransform[#,"egf"]&, | |
| Trans[069]= GetIntervalSum[vexpseq,2]&, | |
| Trans[070]= GFProdkkkTransform[#,"egf"]&, | |
| Trans[071]= GetOffsetDiff[vexpseq,2]&, | |
| Trans[072]= GFProdlllTransform[#,"egf"]&, | |
| Trans[073]=(Take[#,{3,-1}]- Take[#,{2,-2}]-Take[#,{1,-3}]&[vexpseq])&, | |
| Trans[074]= GFProdmmmTransform[#,"egf"]&, | |
| Trans[075]= vexpseq+Range[Length[vexpseq]]&, | |
| Trans[076]= vexpseq +2&, | |
| Trans[077]= vexpseq +3&, | |
| Trans[078]= vexpseq-Range[Length[vexpseq]]&, | |
| Trans[079]= vexpseq -2&, | |
| Trans[080]= vexpseq -3&, | |
| Trans[081]= #+Table[j!,{j,Length[#]}]&, | |
| Trans[082]= #-Table[j!,{j,Length[#]}]&, | |
| Trans[083]= GFProdnnnTransform[#,"egf"]&, | |
| Trans[084]= (Take[#,{3,-1}]- Take[#,{2,-2}]+Take[#,{1,-3}]&[vexpseq])&, | |
| Trans[085]= GFProdoooTransform[#,"egf"]&, | |
| Trans[086]= (Take[#,{1,-3}]+ Take[#,{2,-2}]-Take[#,{3,-1}]&[vexpseq])&, | |
| Trans[087]= GetSum[vexpseq,2]&, | |
| Trans[088]= GetSum[vexpseq,3]&, | |
| Trans[089]= GFProdpppTransform[#,"egf"]&, | |
| Trans[090]= GFProdqqqTransform[#,"egf"]&, | |
| Trans[091]= GFDiagaaaTransform[#,"egf"]&, | |
| Trans[092]= GFDiagbbbTransform[#,"egf"]&, | |
| Trans[093]= GFDiagcccTransform[#,"egf"]&, | |
| Trans[094]= GFDiagdddTransform[#,"egf"]&, | |
| Trans[095]={}& (* WeighTransform and alii: not implemented yet *), | |
| Trans[096]={}&, | |
| Trans[097]={}& (* WeighTransform[vexpseq]& *), | |
| Trans[098]={}&, | |
| Trans[099]= Monotonous, | |
| Trans[100]= BinomialTransform, | |
| Trans[101]= BinomialInvTransform, | |
| Trans[102]= BoustrophedonTransform, | |
| Trans[103]= BoustrophedonInvTransform, | |
| Trans[104]= EulerTransform, | |
| Trans[105]= EulerInvTransform, | |
| Trans[106]= ExpTransform, | |
| Trans[107]= ExpConvTransform, | |
| Trans[108]= CameronTransform, | |
| Trans[109]= CameronInvTransform, | |
| Trans[110]= LogTransform, | |
| Trans[111]= MobiusTransform, | |
| Trans[112]= MobiusInvTransform, | |
| Trans[113]= MulTwoTransform, | |
| Trans[114]= StirlingTransform, | |
| Trans[115]= StirlingInvTransform | |
| }; |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment