//-*-C++-*-//由autodoc自动生成//======头文件src/convolution/complexconvolution.h：==========//复杂卷积：//-----SRCFILE=src/卷积/fftocnvl.cc：-----//调谐参数：#定义USE_SPLRX 0//是否使用split-radix DIF/DIT FFT（默认值=0）#if（USE_SPLRX==1）//#警告“供参考：complex_（auto）_convolution（）use split-radix FFTs”#定义DIT_FFT_CORE split_radix_FFT_DIT_CORE//isign=-1#定义DIF_FFT_CORE split_radix_FFT_DIF_CORE//isign=+1#其他//#警告“仅供参考：complex_（auto）_convolution（）使用基数-4 FFT”#定义DIT_FFT_CORE FFT_dit4_CORE_m1//isign=-1#定义DIF_FFT_CORE FFT_dif4_CORE_p1//isign=+1#结尾void fft_complex_auto_convolution（复数*f，ulong ldn，双v/*=0.0*/）；//（复数，循环）自进化：f[]：=f[]（*）f[]//线性卷积使用零填充数据。//ldn：=数组长度的以2为底的对数。//如果标准化因子为//应与1/n不同void fft_complex_convolution（复杂*限制f，复杂*限制g，ulong ldn，双v/*=0.0*/）；//（复数，循环）卷积：g[]：=f[]（*）g[]//使用零填充数据进行常规卷积。//ldn：=数组长度的以2为底的对数。//如果标准化因子为//应与1/n不同void fft_complex自动卷积（double*restrict fr，double*restrict fi，ulong ldn，双v/*=0.0*/）；//（复杂、循环）自我进化：//（fr，fi）[]：=//线性卷积使用零填充数据。//ldn：=数组长度的以2为底的对数。//如果标准化因子为//应与1/n不同void fft_complex_convolution（双*restrict fr、双*restrict fi，双*限制gr，双*限制gi，ulong ldn，双v/*=0.0*/）；//（复数，循环）卷积：//（gr，gi）[]：=（fr，fi）[）（*）（gr、gi）[]//使用零填充数据进行常规卷积。//ldn：=数组长度的以2为底的对数。//如果标准化因子为//应与1/n不同//-----SRCFILE=src/卷积/矩阵fftcocnvla.cc：-----//调谐参数：#定义USE_OLD_ALGORITHM 0//0（默认值，转置的revbin_permute）或1#定义USE_SPLRX 0//是否使用split-radix DIF/DIT FFT（默认值=0）//#if（USE_OLD_ALGORITHM==1）//#警告“仅供参考：对矩阵_fft_auto_convolution使用简单算法（复杂*f，…）”#else//USE_OLD_ALGORITHM//#警告“仅供参考：使用revbin_permute转换矩阵_fft_auto_convolution（复杂*f，…）”#if（USE_SPLRX==1）//#警告“仅供参考：matrix_fft_complex_auto_convolution（）使用split-radix fft”#定义DIT_FFT_CORE split_radix_FFT_DIT_CORE//isign=-1#定义DIF_FFT_CORE split_radix_FFT_DIF_CORE//isign=+1#其他//#警告“仅供参考：matrix_fft_complex_auto_convolution（）使用基数-4 fft”#定义DIT_FFT_CORE FFT_dit4_CORE_m1//isign=-1#定义DIF_FFT_CORE FFT_dif4_CORE_p1//isign=+1#结尾#endif//USE_OLD_ALGORITHMvoid矩阵_fft_auto_convolution（复数*f，ulong ldn）；//（复数，循环）自进化：f[]：=f[]（*）f[]//ldn：=数组长度的以2为底的对数void矩阵_fft_auto_convolution0（复数*f，ulong ldn）；//（复杂，线性）自进化：f[]：=f[]（*0）f[]//ldn：=数组长度的以2为底的对数//输入数据必须为零填充：f[n/2]。。f[n-1]==0//n=2**ldn，必须>=2void矩阵_fft_auto_convolution（复数*f，ulong-nr，ulong-nc，int zp/*=0*/）；//通过矩阵FFT进行复杂自进化的辅助例程。//如果数据的上半部分为零，则调用zp==1（对于线性卷积）。void矩阵_fft_complex自动卷积（双*fr，双*fi，ulong-ldn）；//（复杂、循环）自我进化：//（fr，fi）[]：=//ldn：=数组长度的以2为底的对数。void matrix_fft_complex_auto_convolution0（双*fr，双*fi，ulong ldn）；//（复杂、线性）自我进化：//（fr，fi）[]：=（fr，fi）[]（*0）（fr，fi）[]//ldn：=数组长度的以2为底的对数。//输入数据必须用零填充：f[n/2]。。f[n-1]==0//n=2**ldn，必须>=2void矩阵_fft_complex自动卷积（双*fr，双*fi，ulong-nr，ulong-nc，int zp/*=0*/）；//通过矩阵FFT计算复杂卷积的辅助例程。//如果数据的上半部分为零，则调用zp==1（对于线性卷积）//-----SRCFILE=src/convolution/cfhtcnvlcore.cc：-----void fht_convolution_core（const复杂*限制f，复杂*限制g，ulong ldn，双v/*=0.0*/）；//辅助的//卷积计算的辅助例程//通过快速哈特利变换。//ldn：=数组长度的以2为底的对数。//v=0.0选择替代规格化。void fht_convolution_revbin_permuted_core（常量复数*限制f，复杂*限制g，ulong ldn、，双v/*=0.0*/）；//辅助的//卷积计算的辅助例程//通过快速哈特利变换。//ldn：=数组长度的以2为底的对数。//v=0.0选择替代规格化。//与fht_convolution_core（）相同，但具有revbin顺序的数据访问。//此版本避免调用revbin_permute（）。//与以下内容相同：//revbin_permute（f，n）；//revbin_permute（g，n）；//fht卷积核（f，g，ldn）；//revbin_permute（g，n）；//-----SRCFILE=src/convolution/cfhtcnvlacore.cc：-----void fht_auto_convolution_core（复杂*f，ulong ldn，双v/*=0.0*/）；//辅助的//计算自进化的辅助例程//通过快速哈特利变换。//ldn：=数组长度的以2为底的对数//v=0.0选择替代标准化void fht_auto_convolution_revbin_permuted_core（复杂*f，ulong ldn，双v/*=0.0*/）；//辅助的//卷积计算的辅助例程//通过快速哈特利变换。//ldn：=数组长度的以2为底的对数//v=0.0选择替代标准化//与fht_auto_convolution_core（）相同，但以revbin顺序进行数据访问。//此版本避免了对revbin_permute（）的两次调用。//-----SRCFILE=src/convolution/cfhtcnvl.cc：-----//调谐参数：#define USE_REVBIN_CORE//默认值：是#如果定义为USE_REVBIN_CORE//#警告“仅供参考：fht_convolution（double*，ulong）using revbin_permuted_core”#其他#警告“fht_convolution（Complex*，ulong）using normal core”#结尾void fht_convolution（复杂*限制f，复杂*限制g，ulong ldn）；//（循环，实）卷积：g[]：=f[]（*）g[]//ldn：=数组长度的以2为底的对数void fht_convolution0（复杂*限制f，复杂*限制g，ulong ldn）；//（线性，实）卷积：g[]：=f[]（*）g[]//ldn：=数组长度的以2为底的对数//输入数据必须填充零：//f[n/2]。。f[n-1]==0和g[n/2]。。g[n-1]==0//n=2**ldn必须>=2//-----SRCFILE=src/convolution/cfhtcnvla.cc：-----//调谐参数：#定义USE_REVBIN_CORE//#如果定义为USE_REVBIN_CORE//#警告“仅供参考：fht_auto_convolution（double*，ulong）using revbin_permuted_core”#其他#警告“fht_auto_convolution（复杂*，ulong）使用普通内核”#结尾void fht_auto_convolution（复数*f，ulong ldn）；//（循环，实）自进化：f[]：=f[]（*）f[]//ldn：=数组长度的以2为底的对数void fht_auto_convolution0（复数*f，ulong ldn）；//（线性，实）自进化：f[]：=f[]（*0）f[]//ldn：=数组长度的以2为底的对数//零填充数据的版本：//对于k=n/2，f[k]==0。。。n-1个//n=2**ldn必须>=2//====~====头文件src/convolution/fhtmulsqr.h:==========//基于FHT卷积的辅助例程。静态内联void fht_sqr（类型&xi，类型&xj，双v）；//xi<--v*（2*xi*xj+xi*xi-xj*xj）//xj<--v*（2*xi*xj-xi*xi+xj*xj）静态内联void fht_mul（类型xi，类型xj，类型&yi，类型&yj，双v）；//yi<--v*（（yi+yj）*xi+（yi-yj）*xj）==v*（[xi+xj）*yi+（xi-xj）*yj）//yj<--v*（（-yi+yj）*xi+（yi+yj）*xj）==v*（-xi+xj）*yi+（xi+xj）*yj）//====~====头文件src/convolution/realconvolution.h：==========//真实卷积//-----SRCFILE=src/convolution/fhtcnvlcore.cc：-----void fht_convolution_core（const double*restrict f、double*restrict g、ulong ldn、，双v/*=0.0*/）；//辅助的//卷积计算的辅助例程//通过快速哈特利变换。//ldn：=数组长度的以2为底的对数。//v=0.0选择替代规格化。void fht_convolution_revbin_permuted_core（const double*restrict f，双*限制g，ulong ldn、，双v/*=0.0*/）；//辅助的//卷积计算的辅助例程//通过快速哈特利变换。//ldn：=数组长度的以2为底的对数。//v=0.0选择替代规格化。//与fht_convolution_core（）相同，但具有revbin顺序的数据访问。//此版本避免调用revbin_permute（）。//与以下内容相同：//revbin_permute（f，n）；//revbin_permute（g，n）；//fht卷积核（f，g，ldn）；//revbin_permute（g，n）；//-----SRCFILE=src/convolution/fhtcnvlacore.cc：-----void fht_auto_convolution_core（双*f，ulong ldn，双v/*=0.0*/）；//辅助的//计算自进化的辅助例程//通过快速哈特利变换。//ldn：=数组长度的以2为底的对数//v=0.0选择替代标准化void fht_auto_convolution_revbin_permuted_core（双*f，ulong ldn，双v/*=0.0*/）；//辅助的//卷积计算的辅助例程//通过快速哈特利变换。//ldn：=数组长度的以2为底的对数//v=0.0选择替代标准化//与fht_auto_convolution_core（）相同，但以revbin顺序进行数据访问。//此版本避免了对revbin_permute（）的两次调用。//-----SRCFILE=src/convolution/fhtcnvl.cc：-----//调谐参数：#define USE_REVBIN_CORE//默认值：是#如果定义为USE_REVBIN_CORE//#警告“仅供参考：fht_convolution（double*，ulong）using revbin_permuted_core”#其他#警告“fht_convolution（double*，ulong）using normal core”#结尾void fht_convolution（double*restrict f，double*restrict g，ulong ldn）；//（循环，实）卷积：g[]：=f[]（*）g[]//ldn：=数组长度的以2为底的对数void fht_convolution0（double*restrict f，double*restrict g，ulong ldn）；//（线性，实）卷积：g[]：=f[]（*）g[]//ldn：=数组长度的以2为底的对数//输入数据必须填充零：//f[n/2]。。f[n-1]==0和g[n/2]。。g[n-1]==0//n=2**ldn必须>=2//-----SRCFILE=src/卷积/fhtcnvla.cc：-----//调谐参数：#定义USE_REVBIN_CORE//#如果定义为USE_REVBIN_CORE//#警告“仅供参考：fht_auto_convolution（double*，ulong）using revbin_permuted_core”#其他#警告“fht_auto_convolution（double*，ulong）using normal core”#结尾void fht自动卷积（双*f，ulong ldn）；//（循环，实）自进化：f[]：=f[]（*）f[]//ldn：=数组长度的以2为底的对数无效fht_auto_convolution0（双*f，ulong ldn）；//（线性，实）自进化：f[]：=f[]（*0）f[]//ldn：=数组长度的以2为底的对数//零填充数据的版本：//对于k=n/2，f[k]==0。。。n-1个//n=2**ldn必须>=2//-----SRCFILE=src/convolution/fhtloccnvl.cc：-----//调谐参数：#define USE_REVBIN_CORE//默认值：是#定义ZP_USE_REVBIN_CORE//默认值：是void loc_fht_convolution（double*restrict f，double*restrict g，ulong ldn）；//（循环，实）卷积：g[]：=f[]（*）g[]//ldn：=数组长度的以2为底的对数void loc_fht_convolution 0（双*限制f，双*限制g，ulong ldn）；//（线性，实）卷积：g[]：=f[]（*）g[]//ldn：=数组长度的以2为底的对数//输入数据必须填充零：//f[n/2]。。f[n-1]==0和g[n/2]。。g[n-1]==0//n=2**ldn必须>=2//-----SRCFILE=src/convolution/fhtloccnvla.cc：-----//调谐参数：#define USE_REVBIN_CORE//默认值：是#定义ZP_USE_REVBIN_CORE//默认值：是无效loc_fht_auto_convolution（双*f，ulong-ldn）；//（循环，实）自进化：f[]：=f[]（*）f[]//ldn：=数组长度的以2为底的对数无效loc_fht_auto_convolution0（双*f，ulong ldn）；//（线性，实）自进化：f[]：=f[]（*0）f[]//ldn：=数组长度的以2为底的对数//零填充数据的版本：//对于k=n/2，f[k]==0。。。n-1个//n=2**ldn必须>=2//-----SRCFILE=src/卷积/fftcnvl.cc：-----void fht_fft_卷积（double*restrict f，double*restrict g，ulong ldn）；//（循环，实）卷积：g[]：=f[]（*）g[]//ldn：=数组长度的以2为底的对数void split_radix_fft_convolution（双*限制f，双*限制g，ulong ldn）；//（循环，实）卷积：g[]：=f[]（*）g[]//ldn：=数组长度的以2为底的对数//n=2*ldn必须>=2void fht_fft_convolution0（double*restrict f，double*restrict g，ulong ldn）；//（线性，实）卷积：g[]：=f[]（*）g[]//ldn：=数组长度的以2为底的对数//输入数据必须填充零：//f[n/2]。。f[n-1]==0和g[n/2]。。g[n-1]==0//n=2**ldn必须>=2void split_radix_fft_convolution0（双*限制f，双*限制g，ulong ldn）；//（线性，实）卷积：g[]：=f[]（*）g[]//ldn：=数组长度的以2为底的对数//输入数据必须填充零：//f[n/2]。。f[n-1]==0和g[n/2]。。g[n-1]==0//n=2**ldn必须>=2void fft卷积core1（const double*restrict f，double*restrict g，ulong ldn，双v/*=0.0*/）；//辅助的//基于FFT卷积的辅助例程。//为归一化因子提供v的值！=1/n个void fft卷积core2（const double*restrict f，double*restrict g，ulong ldn，双v/*=0.0*/）；//辅助的//基于FFT卷积的辅助例程。//提供归一化因子v的值！=1/n个//-----SRCFILE=src/convolution/fftcnvla.cc：-----void fht_fft_auto_convolution（双*f，ulong-ldn）；//（循环，实）自进化：f[]：=f[]（*）f[]//ldn：=数组长度的以2为底的对数void split_radix_fft_auto_convolution（双*f，ulong ldn）；//（循环，实）自卷积：f[]：=f[]（*）f[]//ldn：=数组长度的以2为底的对数无效fht_fft_auto_convolution0（双*f，ulong ldn）；//（线性，实）自进化：f[]：=f[]（*0）f[]//ldn：=数组长度的以2为底的对数//输入数据必须用零填充：f[n/2]。。f[n-1]==0//n=2**ldn必须>=2void split_radix_fft_auto_convolution0（双*f，ulong ldn）；//（线性，实）自进化：f[]：=f[]（*0）f[]//ldn：=数组长度的以2为底的对数//输入数据必须用零填充：f[n/2]。。f[n-1]==0//n=2**ldn必须>=2void fft_auto_convolution_cre1（双*f，ulong ldn，双v/*=0.0*/）；//辅助的//基于FFT（真实）自进化的辅助例程//为v提供一个归一化因子值！=1/n个void fft_auto_convolution_core2（双*f，ulong ldn，双v/*=0.0*/）；//辅助的//基于FFT（真实）自进化的辅助例程//为v提供一个归一化因子值！=1/n个//-----SRCFILE=src/convolution/twodimfhtcnvl.cc：-----inline void fht_cnvl_core_core（const double*fp，const douple*fm，double*gp，double*gm）；//辅助的//twodim_fht_convolution_core（）的辅助例程void twodim_fht_convolution_core（const double*f，double*g，ulong nr，ulong-nc）；//辅助的//基于FHT的二维卷积卷积核//nr:=行数//nc:=列数//-----SRCFILE=src/卷积/矩阵fftcnvla.cc：-----void矩阵_fft_auto_convolution（双*f，ulong-ldn）；//（循环，实）自进化：f[]：=f[]（*）f[]//ldn：=数组长度的以2为底的对数void矩阵_fft_auto_convolution0（双*f，ulong ldn）；//（线性，实）自进化：f[]：=f[]（*0）f[]//ldn：=数组长度的以2为底的对数//零填充数据的版本：//对于k=n/2，f[k]==0。。。n-1个//n=2*ldn必须>=2//调整参数，定义为使用暂存空间：#define CP_ROWS//默认为on，避免缓存问题void矩阵_fft_auto_convolution（double*f，ulong-nr，ulong-nc，int zp/*=0*/）；//通过矩阵FFT实现实际自进化的辅助例程//如果数据的上半部分为零，则调用zp==1（对于线性卷积）//-----SRCFILE=src/卷积/矩阵fftcnvl.cc：-----void矩阵_fft_卷积（双*限制f，双*限制g，ulong-ldn）；//（循环，实）卷积：g[]：=f[]（*）g[]//ldn：=数组长度的以2为底的对数void matrix_fft_convolution0（双*限制f，双*限制g，ulong ldn）；//（线性，实）卷积：g[]：=f[]（*）g[]//ldn：=数组长度的以2为底的对数//输入数据必须填充零：//f[n/2]。。f[n-1]==0和g[n/2]。。g[n-1]==0//n=2**ldn必须>=2//调谐参数：#定义CP_ROWS 1//0或1（默认使用暂存空间）void矩阵_fft_卷积（双*限制f，双*限制g，ulong nr，ulong nc，int zp/*=0*/）；//基于矩阵FFT的实卷积辅助程序//如果数据的高半部分为零（对于线性卷积），则调用zp==1//====~====头文件src/convolution/slowcnvl-lin.h：==========void slow_linear_convolution（常数类型*f，常数类型*g，类型*h，ulong n）；//线性（非循环）卷积。//n：=a[]和b[]的数组长度//数组h[]必须有2*n个元素。//====~====头文件src/convolution/slowcnvl.h：==========void slow_convolution（常数类型*f，常数类型*g，类型*h，ulong n）；//（循环）卷积：h[]：=f[]（*）g[]//n：=数组长度void slow_auto_convolution（常数类型*f，类型*g，ulong n）；//（循环）卷积：g[]：=f[]（*）g[]//n：=数组长度void slow_convolution（常数类型*f，类型*g，ulong n）；//（循环）卷积：g[]：=f[]（*）g[]//n：=数组长度void slow_auto_convolution（类型*f，ulong n）；//（循环）自进化：f[]：=f[]（*）f[]//n：=数组长度//====~====头文件src/convolution/slowcnvla.h：==========void slow_convolution0（常数类型*f，常数类型*g，类型*h，ulong n）；//（线性）卷积：h[]：=f[]（*0）g[]//n：=数组长度//输入数据必须为零填充：//f[n/2]。。f[n-1]==0和g[n/2]。。g[n-1]==0void slow_auto_convolution0（常量类型*f，类型*g，ulong n）；//（线性）自进化：g[]：=f[]（*0）g[]//n：=数组长度//输入数据必须填充零：//f[n/2]。。f[n-1]==0和g[n/2]。。g[n-1]==0//n必须大于等于2void slow_convolution0（常数类型*f，类型*g，ulong n）；//（线性）卷积：g[]：=f[]（*0）g[]//n：=数组长度////输入数据必须填充零：//f[n/2]。。f[n-1]==0和g[n/2]。。g[n-1]==0//n必须大于等于2void slow_auto_convolution0（类型*f，ulong n）；//（线性）自进化：g[]：=f[]（*0）g[]//n：=数组长度//输入数据必须为零填充：//f[n/2]。。f[n-1]==0//n必须大于等于2//====~====头文件src/convolution/slowcnvlhalf.h：==========void slow_half_convolution（常数类型*f，常数类型*g，类型*h，ulong n，int h01）；//半循环卷积。//由h01确定的部分，必须为0或1。//n：=数组长度void slow_half_auto_convolution（常量类型*f，类型*g，ulong n，int h01）；//半周期自我进化。//由h01确定的部分，必须为0或1。//n：=数组长度//（循环）卷积：g[]：=f[]（*）g[]//n：=数组长度void slow_half_convolution（常数类型*f，类型*g，ulong n，int h01）；//半循环卷积。//由h01确定的部分，必须为0或1。//n：=数组长度void slow_half_auto_convolution（类型*f，ulong n，int h01）；//半周期自我进化。//由h01确定的部分，必须为0或1。//n：=数组长度//===========标题文件src/convolution/slowconvolution.h：==========//-----SRCFILE=src/convolution/slowcocnvl.cc：-----void slow_complex卷积（const double*fr，const douple*fi，双*gr、双*gi、ulong）；//（循环，复）卷积：（gr，gi）[]：=（fr，fi）[】（*）（gr、gi）[]//（线性卷积使用零填充数据）void slow_complex自动卷积（双*fr，双*fi，ulong n）；//（循环，复数）自进化//（线性卷积使用零填充数据）//==============标题文件src/convolution/slowtwodimcnvl.h：==========void slow_twodim_convolution（常数类型*f，常数类型*g，；键入*restrict h，ulong编号，ulong nc）//（循环）二维卷积：h[][]//nr:=行数，nc:=列数//线性卷积使用零填充数据。void slow_twodim_convolution（常量类型*f，类型*g，ulong-nr，ulong nc）；//（循环）二维卷积：g[][]：=f[][[]（*）g[][]//nr:=行数，nc:=列数//线性卷积使用零填充数据。//f可能与g重叠//====~====头文件src/convolution/slowweightedcnvl.h：==========void slow_weighted_convolution（常数类型*f，常数类型*g，类型*h，ulong n，类型w）；//加权（循环）卷积：h[]：=f[]（*）_w g[]//n：=数组长度void slow_weighted_auto_convolution（常数类型*f，类型*g，ulong n）；//加权（循环）卷积：g[]：=f[]（*）_w g[]//n：=数组长度void slow_weighted_convolution（常数类型*f，类型*g，ulong n）；//加权（循环）卷积：g[]：=f[]（*）_w g[]//n：=数组长度void slow_weighted_auto_convolution（类型*f，ulong n）；//加权（循环）自进化：f[]：=f[]（*）_w f[]//n：=数组长度//======头文件src/convolution/weightedconvolution.h：==========//-----SRCFILE=src/convolution/fhtnegacnvl.cc：-----void fht_negacyclic_auto_convolution（双*f，ulong-ldn，双v/*=0.0*/）；//使用FHT的负循环（真实）自进化。//ldn：=数组长度的以2为底的对数。//v=0.0选择替代规格化。void fht_negacyclic_convolution（双*限制f，双*限制g，ulong ldn）；//使用FHT的负循环（实）卷积。//ldn：=数组长度的以2为底的对数。//-----SRCFILE=src/convolution/weightedconv.cc：-----void weighted_complet_auto_convolution（双*fr，双*fi，ulong ldn，双w，双v/*=0.0*/）；//w=重量：//直角卷积为+0.25（fi[]中-0.25取反）//负循环卷积为+0.5（也为-0.5）//循环卷积为+1.0（也为-1.0）//v=0.0选择替代标准化void negacyclic_complex自动卷积（双*fr，双*fi，ulong ldn，双v/*=0.0*/）；//fr[]，fi[]的负循环自卷积//v=0.0选择替代标准化void right_angle_complex_auto_convolution（双*fr，双*fi，ulong ldn，双v/*=0.0*/）；//fr[]，fi[]的直角自卷积//如果fi[]全部为零，则很有用：那么结果是//fr[]的非循环自卷积//结果以fr[]（索引0，1，…，n-1）和fi[]（指数n，…，2*n-1）表示//v=0.0选择替代标准化void weighted_complex_auto_convolution（复数*f，ulong ldn，双w，双v/*=0.0*/）；//w=重量：//直角卷积为+0.25（fi[]中-0.25取反）//负循环卷积为+0.5（也为-0.5）//循环卷积为+1.0（也为-1.0）//v=0.0选择替代标准化void negacyclic_complex_auto_convolution（复数*f，ulong ldn，双v/*=0.0*/）；//f[]的负循环自卷积//v=0.0选择替代标准化void right_angle_complex_auto_convolution（复数*f，ulong ldn，双v/*=0.0*/）；//f[]的直角自卷积//v=0.0选择替代标准化