decode.cpp

程序中给出了一个和积算法的LDPC程序

#include "LR_en_de_CODE.h"
using namespace  std;

extern struct Anode_inf
{
	bool flag;
	int col_num;
	double q_dmeg;
	double r_meg0; 
	double r_meg1;
};
extern struct Bnode_inf
{
	bool flag;
	int Acol_num;
    int Arow_num;
};
extern Anode_inf Anode_inf_mat[H_row][Hmax_rowdeg];
extern Bnode_inf Bnode_inf_mat[H_col][Hmax_coldeg];

void decode(double *in_address,double N0,int *out_address)
{

	double p0[H_col],p1[H_col];
    int result[H_col];
	int i,j,k,v;
	for(i=0;i<H_col;i++)
	{
		p0[i]=1/(1+exp(-4.0*(*(in_address+i))/N0));
		p1[i]=1-p0[i];
	}
	for(i=0;i<H_row;i++)
	{
		for (j=0;j<Hmax_rowdeg;j++)
		{
			if(Anode_inf_mat[i][j].flag==true)
			{
				Anode_inf_mat[i][j].q_dmeg=p0[Anode_inf_mat[i][j].col_num]-p1[Anode_inf_mat[i][j].col_num];
			}
			else
				break;
		}	
	}
	///////////////////×××开始迭代循环×××////////////////////////	
	for(i=0;i<MAX_cycle;i++)
	{
		/////////////////横向迭代///////////////////////////
		for(j=0;j<H_row;j++)
		{
			
			for(k=0;k<Hmax_rowdeg;k++)
			{
				double drmn=1.00000;
				if(Anode_inf_mat[j][k].flag==false)
					break;
				else
				{
					for(v=0;v<Hmax_rowdeg;v++)
					{
						if(v!=k)
						{
							if(Anode_inf_mat[j][v].flag==true)
								drmn=drmn*Anode_inf_mat[j][v].q_dmeg;
							else
								break;
						}
					}
					Anode_inf_mat[j][k].r_meg0=(1+drmn)/2;
					Anode_inf_mat[j][k].r_meg1=(1-drmn)/2;
				}
			}
		}
		/////////////////////纵向迭代/////////////////////////
		for(j=0;j<H_col;j++)
		{
			double store_last0;
            double prod_rmn0,prod_rmn1,const1,const2;
			for(k=0;k<Hmax_coldeg;k++)
			{
				prod_rmn0=1.00000;
				prod_rmn1=1.00000;
				if(Bnode_inf_mat[j][k].flag==false)
					break;
				else
				{
					for(v=0;v<Hmax_coldeg;v++)
					{
						if(v!=k)
						{
							if(Bnode_inf_mat[j][v].flag==true)
							{prod_rmn0=prod_rmn0*Anode_inf_mat[Bnode_inf_mat[j][v].Arow_num][Bnode_inf_mat[j][v].Acol_num].r_meg0;
							prod_rmn1=prod_rmn1*Anode_inf_mat[Bnode_inf_mat[j][v].Arow_num][Bnode_inf_mat[j][v].Acol_num].r_meg1;}
							else
								break;
						}
					}
					const1=p0[j]*prod_rmn0;
					const2=p1[j]*prod_rmn1;
					double temp_double=1.0/(const1+const2);
					Anode_inf_mat[Bnode_inf_mat[j][k].Arow_num][Bnode_inf_mat[j][k].Acol_num].q_dmeg=temp_double*(const1-const2); 
					store_last0=Anode_inf_mat[Bnode_inf_mat[j][k].Arow_num][Bnode_inf_mat[j][k].Acol_num].r_meg0;
				}
			}
			if((const1*store_last0)>=(const2*(1-store_last0)))
				result[j]=0;
			else
				result[j]=1;
		}
		///////////////////////判决是否译码成功//////////////////////
		int not_fit_fuction=0;
		for(j=0;j<H_row;j++)
		{
			int num_1=0;
			for(k=0;k<Hmax_rowdeg;k++)
			{
				if(Anode_inf_mat[j][k].flag==true)
				{
					if(result[Anode_inf_mat[j][k].col_num]==1)
						num_1++;
				}
				else
					break;
			}
			if((num_1%2)!=0)
			{not_fit_fuction++;break;}
		}
		///////////////////////判决是否译码成功//////////////////////
		if(not_fit_fuction==0)
		{
			//cout<<"   | OK |"<<i<<"| TIME |"<<endl;
			for(j=0;j<H_col;j++)
			{
				*(out_address+j)=result[j];
			}
			break;
		}
		//else
			//cout<<enumbb<<"->";
    }//////*****迭代循环结束*****////////
	for(j=0;j<H_col;j++)
	{
		*(out_address+j)=result[j];
	}
}