C语言做互相关

最新推荐文章于 2024-06-22 23:53:28 发布
最新推荐文章于 2024-06-22 23:53:28 发布
阅读量3.4k 收藏 15
点赞数 1 
#include <math.h>
#define M_PI    3.14159265358979323846
#define FALSE    0
#define TRUE    1
#define BIG    1e10
#define SMALL    1e-10

typedef struct {
    float r, i;
} complex;

/* FAST CORRELATION OF X(0:L) AND Y(0:L).  FINDS RXY(0) THRU RXY(NMAX). */
/* L=LAST INDEX IN BOTH X AND Y.  MUST BE (POWER OF 2)+1 AND AT LEAST 5. */
/* ITYPE=TYPE OF CORRELATION=0 IF X AND Y ARE THE SAME VECTOR (AUTO- */
/*         CORRELATION), OR NOT 0 IF X AND Y ARE DIFFERENT VECTORS. */
/* NMAX=MAXIMUM LAG OF INTEREST IN THE CORRELATION FUNCTION. */
/* FFT LENGTH ,N, USED INTERNALLY, IS L-1. */
/* LET K=INDEX OF FIRST NONZERO SAMPLE IN Y(0)---Y(N-1).  THEN X(0) */
/*  到 X(N-1) MUST INCLUDE PADDING OF AT LEAST NMAX-K ZEROS. */
/* CORRELATION FUNCTION, RXY, REPLACES X(0) THRU X(NMAX). */
/* Y(0) THRU Y(L) IS REPLACED BY ITS FFT, COMPUTED USING SPFFTR. */
/* IERROR=0  NO ERROR DETECTED */
/*        1  L-1 NOT A POWER OF 2 */
/*        2  NMAX OUT OF RANGE */
/*        3  INADEQUATE ZERO  */

void spcorr(float *x, float *y, long *l, long *type, long *nmax, long *error)
/*
x:序列X；
y：序列Y；
l:序列X与序列Y的长度，不小5，且要为2的幂次方；
type:相关的类型，0：表示X与Y序列相同，其它值：X与Y序列不相同
nmax:相关的最大时延；
error:运行出错提示；0：无错；1：数据长度不是2的幂次方；2：时延超界；3：无足够零填充出错
*/

{
     long j, k, m, n;//n:FFT长度；k:序列Y中的首个非零样本的位置序号；在序列Y中必须最少包含有(nmax-k)零填充。
    complex cx;
    float test;

    n = *l - 1;
    if (*nmax < 0 || *nmax >= n)
    {
    *error = 2;
    return;
    }

    test = (float) n;
    test /= 2.0;

    while ((test - 2.0) > 0.0)
    {
    test /= 2.0;
    }

    if ((test - 2.0) == 0)
    {
    for (k = 0 ; k < n && y[k] == 0.0 ; ++k) ;

    for (j = n - 1 ; j >= 0 && x[j] == 0.0 ; --j) ;

    if ((n - 1 - j) < (*nmax - k))
    {
        *error = 3;
        return;
    }

    spfftr(x, &n);//对X序列FFT变换
    if (*type != 0)
    {
        spfftr(y, &n);//如果X、Y是相同序列，则对Y序列也进行FFT
    }

    for (m = 0 ; m <= (n / 2) ; ++m)
    {
        cx.r = x[m * 2] * y[m * 2] - -x[(m * 2) + 1] * y[(m * 2) + 1];
        cx.i = x[m * 2] * y[(m * 2) + 1] + -x[(m * 2) + 1] * y[m * 2];

        x[m * 2] = cx.r / n;
        x[(m * 2) + 1] = cx.i / n;
    }

    spiftr(x, &n);

    *error = 0;
    }
    else if ((test - 2.0) < 0.0)
    {
    *error = 1;
    }

    return;
} /* spcorr */

/* SPFFTR     11/12/85 */
/* FFT ROUTINE FOR REAL TIME SERIES (X) WITH N=2**K SAMPLES. */
/* COMPUTATION IS IN PLACE, OUTPUT REPLACES INPUT. */
/* INPUT:  REAL VECTOR X(0:N+1) WITH REAL DATA SEQUENCE IN FIRST N */
/*         ELEMENTS; ANYTHING IN LAST 2.  NOTE: X MAY BE DECLARED */
/*         REAL IN MAIN PROGRAM PROVIDED THIS ROUTINE IS COMPILED  */
/*         SEPARATELY ... COMPLEX OUTPUT REPLACES REAL INPUT HERE. */
/* OUTPUT: COMPLEX VECTOR XX(O:N/2), SUCH THAT X(0)=REAL(XX(0)),X(1)= */
/*         IMAG(XX(0)), X(2)=REAL(XX(1)), ..., X(N+1)=IMAG(XX(N/2). */
/* IMPORTANT:  N MUST BE AT LEAST 4 AND MUST BE A POWER OF 2. */

//FFT计算函数
void spfftr(complex *x, long *n)
{
    /* Builtin functions */
    void r_cnjg();

    /* Local variables */
    void spfftc();

    long m, tmp_int;
    complex u, tmp, tmp_complex;
    float tpn, tmp_float;

    tpn = (float) (2.0 * M_PI / (double) *n);

    tmp_int = *n / 2;
    spfftc(x, &tmp_int, &neg_i1);

    x[*n / 2].r = x[0].r;
    x[*n / 2].i = x[0].i;

    for (m = 0 ; m <= (*n / 4) ; ++m)
    {
    u.r = (float) sin((double) m * tpn);
    u.i = (float) cos((double) m * tpn);

    r_cnjg(&tmp_complex, &x[*n / 2 - m]);

    tmp.r = (((1.0 + u.r) * x[m].r - u.i * x[m].i)
        + (1.0 - u.r) * tmp_complex.r - -u.i * tmp_complex.i) / 2.0;

    tmp.i = (((1.0 + u.r) * x[m].i + u.i * x[m].r)
        + (1.0 - u.r) * tmp_complex.i + -u.i * tmp_complex.r) / 2.0;

    tmp_float = ((1.0 - u.r) * x[m].r - -u.i * x[m].i
            + (1.0 + u.r) * tmp_complex.r - u.i * tmp_complex.i) / 2.0;
    x[m].i = ((1.0 - u.r) * x[m].i + -u.i * x[m].r
         + (1.0 + u.r) * tmp_complex.i + u.i * tmp_complex.r) / 2.0;
    x[m].r = tmp_float;

    r_cnjg(&x[*n / 2 - m], &tmp);
    }

    return;
} /* spfftr */

/* SPIFTR     02/20/87 */
/* INVERSE FFT OF THE COMPLEX SPECTRUM OF A REAL TIME SERIES. */
/* X AND N ARE THE SAME AS IN SPFFTR.  IMPORTANT: N MUST BE A POWER */
/* OF 2 AND X MUST BE DIMENSIONED X(0:N+1) (REAL ARRAY, NOT COMPLEX). */
/* THIS ROUTINE TRANSFORMS THE OUTPUT OF SPFFTR BACK INTO THE INPUT, */
/* SCALED BY N.  COMPUTATION IS IN PLACE, AS IN SPFFTR. */

//逆FFT变换函数
void spiftr(complex *x, long *n)
{
    long m, tmp_int;
    complex u, tmp_complex, tmp;
    float tpn, tmp_float;

    tpn = (float) (2.0 * M_PI / (double) *n);

    for (m = 0 ; m <= (*n / 4) ; ++m)
    {
    u.r = (float) sin((double) m * tpn);
    u.i = (float) -cos((double) m * tpn);

    r_cnjg(&tmp_complex, &x[*n / 2 - m]);

tmp.r = ((1.0 + u.r) * x[m].r - u.i * x[m].i)
        + ((1.0 - u.r) * tmp_complex.r - -u.i * tmp_complex.i);
    tmp.i = ((1.0 + u.r) * x[m].i + u.i * x[m].r)
        + ((1.0 - u.r) * tmp_complex.i + -u.i * tmp_complex.r);

    r_cnjg(&tmp_complex, &x[*n / 2 - m]);

    tmp_float = ((1.0 - u.r) * x[m].r - -u.i * x[m].i)
            + ((1.0 + u.r) * tmp_complex.r - u.i * tmp_complex.i);
    x[m].i = ((1.0 - u.r) * x[m].i + -u.i * x[m].r)
        + ((1.0 + u.r) * tmp_complex.i + u.i * tmp_complex.r);

    x[m].r = tmp_float;

    r_cnjg(&x[*n / 2 - m], &tmp);
    }
    tmp_int = *n / 2;

    spfftc(x, &tmp_int, &pos_i1);

    return;
} /* spiftr *

void r_cnjg(complex *r, complex *z)
{
    r->r = z->r;
    r->i = -z->i;
}
 

 

#include"iostream.h"
void main()

{   
        int M,N,i,j;
        cout<<"a[]数组的大小：";
        cin>>M;
        cout<<"b[]数组的大小：";
        cin>>N;
        int *a=new int [M]; // 为a[]申请动态存储空间
        int *b=new int [N];
        int *c=new int [M+N-1];
        cout<<"输入a[]数组:";
        for(i=0;i<M;i++)
        cin>>a[i];        
        cout<<"输入b[]数组:";
        for(i=0;i<N;i++)
                cin>>b[i];
        if(M>=N)
for( i=0;i<M+N-1;i++)
        {
          c[i]=0;
          for( j=0;j<=M;j++)
          { if(i-j>=0&i-j<N&j<M)
                          c[i]=c[i]+a[j]*b[j-i+N-1];
                  }
        }
        else 
        for( i=0;i<M+N-1;i++)
        {
          c[i]=0;
          for( j=0;j<=N;j++)
          { if(i-j>=0&i-j<M&j<N)
                          c[i]=c[i]+b[j]*a[j-i+M-1];
                  }
        }
    cout<<"大数组与小数组的互相关：";
        for(i=0;i<M+N-1;i++)
                cout<<c[i]<<' ';
        cout<<endl;
}

 

 


                

        

        

    

  


    

      

        

            

              
                
                  jianson199
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
互相关函数实现（c语言完整工程，利用cmake编译）

				
			

			

				

					youzjuer的博客
				

				

					05-23
					
					1064
					
				

			

		

		

			
				
1、整数版本



#include "corr.h"

int * corr(int a [] ,int b[], int la, int lb)

{

		int *result;

		result = (int *)malloc ((la+lb-1)*sizeof(int));

		int i,j;

		for (i = 0; i < la+lb-1; i++){
			if(i<=lb){
				for(j = 1; j <= i; j++){
            	

			
		

	



                

              
                



	

		

			

				
					
两函数之间的互相关计算与自相关运算

				
			

			

				

					04-04
				

			

		

		

			
				
包含两个信号之间的运算，自相关与互相关运算

			
		

	



                


  
              

                


	

		

			

				
					
C语言互相关函数

				
			

			

				

					Bonner1的博客
				

				

					01-30
					
					9127
					
				

			

		

		

			
				
C语言中编写自定义的互相关函数



代码块



//互相关函数_from word 
//该函数可以生成out_xcorr.txt文件
#include 
#include 
#include 

#define NN 10

void xcorr(float *r, unsigned short *x, unsigned short *y, int N);

int main()
{

			
		

	





	

		

			

				
					
使用C++实现互相关和自相关算法详解及应用

					
最新发布

				
			

			

				

					qq_38334677的博客
				

				

					06-22
					
					1185
					
				

			

		

		

			
				
互相关（Cross-correlation）是一种用于衡量两个信号或序列之间相似程度的统计量。它是通过滑动一个信号相对于另一个信号，并计算不同位置上的点积来实现的。互相关常用于信号匹配、图像配准等应用中，通过分析两个信号或图像在不同位置的相关性，找到最佳匹配位置。自相关（Autocorrelation）是信号与其自身不同时间延迟之间的相关性。自相关用于分析信号的周期性特征和重复模式，是时间序列分析中的重要工具。通过计算信号在不同延迟下的自相关，可以揭示信号中的周期性结构和重复模式。

			
		

	



		

			
		



	

		

			

				
					
互相关C语言程序xcorr

				
			

			

				

					08-19
				

			

		

		

			
				
用C编的互相关程序,与matlab中的xcorr相对应，correlation

			
		

	





	

		

			

				
					
用fft求互相关，速度更快，c语言实现

				
			

			

				

					12-27
				

			

		

		

			
				
可以用fft实现互相关计算，c语言实现，速度更快，易于硬件实现

			
		

	





	

		

			

				
					
C语言卷积和C语言互相关:数字信号处理中的卷积和互相关的C语言代码

				
			

			

				

					xuanyu321的博客
				

				

					09-26
					
					8938
					
				

			

		

		

			
				
自己编写的数字信号处理中卷积和互相关运算的C语言代码，调试可用

			
		

	





	

		

			

				
					
C语言GBK、Unicode与UTF8互转代码，含转码表及接口函数

				
			

			

				

					09-06
				

			

		

		

			
				
本文将深入探讨C语言中GBK、Unicode和UTF-8之间的转换，并提供相关的转码表和接口函数。  首先，让我们了解一下这三种编码标准：  1. **GBK编码**：GBK是中国大陆广泛使用的汉字编码标准，它是GB2312的扩展，兼容GB...

			
		

	





	

		

			

				
					
自相关c语言代码,简单实用

				
			

			

				

					04-30
				

			

		

		

			
				
很好的函数自相关程序代码,适合信号处理相干人士学习

			
		

	





	

		

			

				
					
C++实现离散序列自相关与互相关

				
			

			

				

					11-09
				

			

		

		

			
				
为了在接受机端完成仿真，计算接收序列的自相关与互相关是必不可少的，而实际C++没有提供专门用于计算相关运算的函数，因此手动写了个代码，下网会有帮助。如有更好实现，请私下交流。

			
		

	





	

		

			

				
					
互相关函数

				
			

			

				

					05-03
				

			

		

		

			
				
互相关函数

			
		

	





	

		

			

				
					
广义互相关算法用FFT加速的C语言实现

				
			

			

				

					weixin_46582567的博客
				

				

					08-29
					
					8144
					
				

			

		

		

			
				
广义互相关算法如何用C语言实现?
在声音测距的原理中，我们可以利用麦克风对采集的声音信号利用互相关算法测出音源与麦克风距离的差值，而大致求出音源的方位。这也是第十五届智能车竞赛声音信标组寻灯的基础，因为我参加的是这个组别，所以当时在这方面找了很多相关的资料互相关的原理基本上懂，但是用C语言实现起来感觉和书本上的知识结合不了，但是真的运气好，试了很多很多次，终于写出来了，可能是乐于分享的人运气都不会太差吧，O(∩_∩)O哈哈~
小说明：我的这个代码不是完整的工程，只是把核心的互相关算法及一些相关的代码分享出来

			
		

	





	

		

			

				
					
一个简易的c语言卷积或互相关函数写法

				
			

			

				

					m0_52876068的博客
				

				

					01-29
					
					883
					
				

			

		

		

			
				
一个简易的c语言卷积或互相关函数写法

			
		

	





	

		

			

				
					
C语言相关

				
			

			

				

					qq_22329595的博客
				

				

					06-11
					
					268
					
				

			

		

		

			
				
1.结构体与结构体变量

（1）结构体：

struct student{
　　char name[10];
　　int age;
　　int student_number;
};

（2）结构体变量

struct student{
　　char name[10];
　　int age;
　　int student_number;
}s1,s2;


			
		

	





	

		

			

				
					
【嵌入式 C】广义互相关算法用FFT加速的C语言实现

				
			

			

				

					Nonoas的博客
				

				

					04-11
					
					3392
					
				

			

		

		

			
				
在声音测距的原理中，我们可以利用麦克风对采集的声音信号利用互相关算法测出音源与麦克风距离的差值，而大致求出音源的方位。这也是第十五届智能车竞赛声音信标组定位的基础，因为我参加的是这个组别，所以当时在这方面找了很多相关的资料。

			
		

	





	

		

			

				
					
请用c语言帮我写一个理想的插值互相关算法的代码

				
			

			

				

					09-10
				

			

		

		

			
				
### 回答1：
以下是一个简单的插值互相关算法的C语言实现：

```c
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MAX_SIZE 1000

double interpolate(double x, double x1, double x2, double y1, double y2) {
    return y1 + ((y2 - y1) / (x2 - x1)) * (x - x1);
}

void cross_correlation(double *x, int N, double *y, int M, double *result) {
    int i, j, k;
    double sum;

    for (i = 0; i < N + M - 1; i++) {
        sum = 0;
        for (j = 0; j < N; j++) {
            k = i - j;
            if (k >= 0 && k < M) {
                sum += x[j] * interpolate(k, 0, M - 1, y[k], y[k + 1]);
            }
        }
        result[i] = sum;
    }
}

int main() {
    int i, N, M;
    double x[MAX_SIZE], y[MAX_SIZE], result[MAX_SIZE];

    printf("Enter the size of x: ");
    scanf("%d", &N);

    printf("Enter the values of x: ");
    for (i = 0; i < N; i++) {
        scanf("%lf", &x[i]);
    }

    printf("Enter the size of y: ");
    scanf("%d", &M);

    printf("Enter the values of y: ");
    for (i = 0; i < M; i++) {
        scanf("%lf", &y[i]);
    }

    cross_correlation(x, N, y, M, result);

    printf("Result:\n");
    for (i = 0; i < N + M - 1; i++) {
        printf("%lf ", result[i]);
    }
    printf("\n");

    return 0;
}
```

该代码实现了一个简单的插值互相关算法，其中使用了双线性插值来估计y序列中的值。用户需要输入x序列和y序列，然后程序会计算它们的互相关结果并输出。请注意，该代码没有进行任何错误检查，例如输入的序列大小是否超过了MAX_SIZE等。实际应用中，请根据需要进行适当修改和完善。  

### 回答2：
插值互相关（Interpolation Cross-Correlation）是一种信号处理技术，用于分析两个信号之间的相似性和延迟。下面是使用C语言编写的理想的插值互相关算法的示例代码：

```c
#include <stdio.h>
#include <stdlib.h>

#define SIGNAL_LENGTH 100
#define REFERENCE_LENGTH 50
#define INTERPOLATION_FACTOR 4

int main() {
    int signal[SIGNAL_LENGTH]; // 输入信号
    int reference[REFERENCE_LENGTH]; // 参考信号
    int interpolated_reference[REFERENCE_LENGTH * INTERPOLATION_FACTOR]; // 插值后的参考信号

    // 生成随机信号和参考信号
    for (int i = 0; i < SIGNAL_LENGTH; i++) {
        signal[i] = rand() % 100;
    }
    for (int i = 0; i < REFERENCE_LENGTH; i++) {
        reference[i] = rand() % 100;
    }

    // 插值参考信号
    for (int i = 0; i < REFERENCE_LENGTH; i++) {
        for (int j = 0; j < INTERPOLATION_FACTOR; j++) {
            interpolated_reference[i * INTERPOLATION_FACTOR + j] = reference[i];
        }
    }

    // 计算理想的插值互相关
    int max_correlation = 0;
    int best_delay = 0;
    for (int delay = 0; delay < SIGNAL_LENGTH - REFERENCE_LENGTH * INTERPOLATION_FACTOR; delay++) {
        int correlation = 0;
        for (int i = 0; i < REFERENCE_LENGTH * INTERPOLATION_FACTOR; i++) {
            correlation += signal[delay + i] * interpolated_reference[i];
        }
        if (correlation > max_correlation) {
            max_correlation = correlation;
            best_delay = delay;
        }
    }

    printf("最大互相关值: %d\n", max_correlation);
    printf("最佳延迟: %d\n", best_delay);

    return 0;
}
```

该代码首先生成随机的输入信号和参考信号，然后使用线性插值法对参考信号进行插值操作，将每个参考样本扩展为INTERPOLATION_FACTOR（这里设定为4）个样本。

接下来，代码计算理想的插值互相关。它使用两层嵌套循环，外层循环迭代信号延迟值，内层循环计算互相关值。互相关值通过将信号与插值后的参考信号逐个样本相乘并累加得到。

最后，代码输出最大的互相关值以及对应的最佳延迟。

请注意，此示例只是一个基本的框架，实际上可能需要根据要求进行优化或调整。  

### 回答3：
插值互相关算法是一种常用于信号处理和图像处理的算法，用于估算一个信号在给定数据点之间的值。下面是一个简单的用C语言编写的插值互相关算法的示例代码：

```c
#include <stdio.h>

// 定义插值互相关函数
double interpolate_correlation(double *x, double *y, int n, double t)
{
    double result = 0.0;

    for (int i = 0; i < n; i++)
    {
        double product = 1.0;
        for (int j = 0; j < n; j++)
        {
            if (j != i)
            {
                product *= (t - x[j]) / (x[i] - x[j]);
            }
        }
        result += product * y[i];
    }

    return result;
}

int main()
{
    // 定义输入数据数组
    double x[] = {1.0, 2.0, 3.0, 4.0}; // 数据点横坐标
    double y[] = {2.0, 4.0, 1.0, 5.0}; // 数据点纵坐标
    int n = sizeof(x) / sizeof(double); // 数据点个数

    // 定义插值目标点
    double t = 2.5; // 目标点横坐标

    // 调用插值互相关函数进行插值计算
    double result = interpolate_correlation(x, y, n, t);

    // 输出插值结果
    printf("在 t = %.1f 处的插值结果为 %.1f\n", t, result);

    return 0;
}
```

在这个示例代码中，使用了一个自定义的插值互相关函数`interpolate_correlation`。该函数接受两个数组`x`和`y`，分别表示数据点的横坐标和纵坐标，以及数据点的个数`n`和目标点的横坐标`t`。函数利用拉格朗日插值公式计算出目标点的纵坐标值，并返回该值。

在`main`函数中，定义了一个示例的数据点数组`x`和`y`，然后调用插值函数`interpolate_correlation`进行计算并输出结果。

请注意，这只是一个简单的示例代码，实际使用中可能需要增加错误处理和边界情况的判断等。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值