int j = int((double)i*Fs0/Fs1)-3;    // пересчитываю индекс исходного сигнала

int j = int((double)i*Fs0/Fs1)-Kp+1;    // пересчитываю индекс исходного сигнала

if(j<0) j =0;                        // если индекс отрицательный то приравниваю его к 0

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define M_PI       3.14159265358979323846 

// Функция сохранения результатов анализа в текстовый файл для
// построения графиков.
void saveToTXT(double* t, double* s, int n, char* fileName){
	FILE *file = fopen(fileName, "w");
	if(!file) return;
	for(int i = 0; i < n; i++)
    fprintf(file,"%e\t%e\n",t[i],s[i]);
	fclose(file);
}

// Функция расчета полинома 1-ой степени
// на основе модифицированного фильтра Фарроу
double farrow1(double *y, double x){   
    double a1 = y[1] - y[0];
    return x*a1 + y[0];
}

// Функция расчета полинома 2-ой степени
// на основе модифицированного фильтра Фарроу
double farrow2(double *y, double x){   
    double a2 = (y[0] + y[2])/2.0 - y[1];
    double a1 = y[2]-y[1] - a2;
    return x*(x*a2+a1)+y[1];
}

// Функция расчета кубического полинома 
// на основе модифицированного фильтра Фарроу
double farrow3(double *y, double x){
	double a3 = (y[3]-y[0])/6.0+(y[1]-y[2])/2.0;
	double a1 = (y[3]-y[1])/2.0-a3;
	double a2 = y[3]-a3-a1-y[2];
	return x*(x*(x*a3+a2)+a1)+y[2];
}

// Функция расчета полинома 4-ой степени
// на основе модифицированного фильтра Фарроу
double farrow4(double *y, double x){
    double a4 = (y[0] + y[4])/24.0 - (y[1] + y[3])/6.0 + y[2]/4.0;
    double a3 = (y[4] - y[0])/12.0 + (y[1] - y[3])/6.0;
    double a2 = -(y[0] + y[4])/24.0+2.0*(y[1] + y[3])/3.0-1.25*y[2];
	double a1 =  (y[0] - y[4])/12.0+2.0*(y[3] - y[1])/3.0;
    return x*(x*(x*(x*a4+a3)+a2)+a1)+y[2];
}

// Функция ресамплинга при помощи фильтра фарроу заданного порядка
void resample(double* y0, // массив исходных данных до ресамплинга
    	  double *t0, // время исходных данных  до ресамплинга
    	  double Fs0, // частота дискретизации  до ресамплинга
    	  int N,	  // количество отсчетов    до ресамплинга
    	  double* y1, // массив данных    	после ресамплинга
    	  double* t1, // время            после ресамплинга
    	  double Fs1, // частота дискретизации  после ресамплинга
    	  int K,	  // количество отсчетов    после ресамплинга
    	  int Nfilter)// порядок фильтра фарроу от 1 до 4
{
	double dx;
	if(Nfilter == 1) dx = 0;	// соответствующая поправка для пересчета времени
	if(Nfilter == 2) dx = 1;
	if(Nfilter == 3) dx = 2;
	if(Nfilter == 4) dx = 2;

	for(int i = 0; i<K; i++){
        t1[i] = (double)i/Fs1;        	  // текущий момент дискретизации
        int j = (int)((double)i*Fs0/Fs1)-(int)dx; // пересчитываю индекс исходного сигнала
        if(j<0) j =0;            	  // если индекс отрицателььный то приравниваю его к 0
        double x = (t1[i]-t0[j])*Fs0-dx;      // пересчитываю значение x
        if(Nfilter == 1) y1[i] = farrow1(y0+j,x); // интерполяция заданным фильтром
    if(Nfilter == 2) y1[i] = farrow2(y0+j,x);
    if(Nfilter == 3) y1[i] = farrow3(y0+j,x);
    if(Nfilter == 4) y1[i] = farrow4(y0+j,x);
    }	
}


int main(){
	double Fs0  = 300;    	// исходная частота дискретизации
	double Fs1  = 2400.0;    // частота дискретизации после ресэмплинга
	
	int K = 512;        // количество отсчетов после ресэмплинга
	int N = (int)K*Fs0/Fs1;    // количество исходных отсчетов
	
	// выделяю память под исходный сигнал
	double* y0 = (double*) malloc(N*sizeof(double));
	double* t0 = (double*) malloc(N*sizeof(double));
	
	// выделяю память под результат ресэмплинга
	double* tint = (double*) malloc(K*sizeof(double));  // время после ресамплинга
	double* yint = (double*) malloc(K*sizeof(double));	// идеальный сигнал при частоте дискретизации Fs1 
	
	double* y1 = (double*) malloc(K*sizeof(double));    // результат ресамплинга 	
	double* e  = (double*) malloc(K*sizeof(double));    // ошбика при инетрполяции
	
	// формирую исходный сигнал до ресамплинга
	for(int i = 0; i<N; i++){
    t0[i] = double(i)/Fs0;
    y0[i] = cos(2*M_PI*40*t0[i]);
	} 
	saveToTXT(t0,y0, N,"исходный сигнал.txt");        //сохраняю исходный сигнал в файл

	// формирую идеальный сигнал с которым буду сравнивать ошибку
	for(int i = 0; i<K; i++){
    tint[i] = double(i)/Fs1;
    yint[i] = cos(2*M_PI*40*tint[i]);    
	}
	saveToTXT(tint,   yint, N,   "идеальный сигнал.txt");	//сохраняю идеальный сигнал в файл
	
	// ресамплнг фильтром 1 порядка
	resample(y0,t0,Fs0,N,y1,tint,Fs1,K,1);
	for(int i = 0; i<K; i++) e[i] = yint[i] - y1[i];  // ошбика равна идеальный сигнал - результат ресамплинга
	saveToTXT(tint, y1, K, "resampling1.txt");      // сохраняю результат ресамплинга в файл
	saveToTXT(tint, e, K,  "e1.txt");          // сохраняю ошибку ресамплинга в файл
	
	// ресамплнг фильтром 2 порядка
	resample(y0,t0,Fs0,N,y1,tint,Fs1,K,2);
	for(int i = 0; i<K; i++) e[i] = yint[i] - y1[i];  // ошбика равна идеальный сигнал - результат ресамплинга
	saveToTXT(tint, y1, K, "resampling2.txt");      // сохраняю результат ресамплинга в файл
	saveToTXT(tint, e, K,  "e2.txt");          // сохраняю ошибку ресамплинга в файл

	// ресамплнг фильтром 3 порядка
	resample(y0,t0,Fs0,N,y1,tint,Fs1,K,3);
	for(int i = 0; i<K; i++) e[i] = yint[i] - y1[i];  // ошбика равна идеальный сигнал - результат ресамплинга
	saveToTXT(tint, y1, K, "resampling3.txt");      // сохраняю результат ресамплинга в файл
	saveToTXT(tint, e, K,  "e3.txt");          // сохраняю ошибку ресамплинга в файл


	// ресамплнг фильтром 4 порядка
	resample(y0,t0,Fs0,N,y1,tint,Fs1,K,4);
	for(int i = 0; i<K; i++) e[i] = yint[i] - y1[i];  // ошбика равна идеальный сигнал - результат ресамплинга
	saveToTXT(tint, y1, K, "resampling4.txt");      // сохраняю результат ресамплинга в файл
	saveToTXT(tint, e, K,  "e4.txt");          // сохраняю ошибку ресамплинга в файл

	// чищу память
	free(y0);
	free(t0);

	free(yint);
	free(tint);

	free(y1);
	free(e);

	system("Pause");
	return 0;
}