viterbi_soft.cpp

有关卷积编码的维特比算法,是硬判决的啊,希望大家

#include "VITERBI_soft.h"
#include<stdlib.h>
#include<math.h>
#include<iostream.h>

#include"define.h"

//#define Ntap 9//9
//#define rate 3
//#define Nreg 8//8
//#define Nstate pow(2,Nreg)


VITERBI_soft::VITERBI_soft()
{	
}

VITERBI_soft::~VITERBI_soft()
{
}	

void VITERBI_soft::encode(int G[rate][Ntap],int *indata,int *outdata,int N)
{
	int i,j,k;
	int *x,*sum_code;

	x=new int [Ntap];
	sum_code=new int [rate];

	for(j=0;j<Ntap;j++)
		x[j]=0;

	for(i=0;i<N;i++)
	{
		for(j=0;j<rate;j++)
		{
			sum_code[j]=0;
			for(k=0;k<Ntap;k++)
			{
				x[0]=indata[i];
				sum_code[j]+=x[k]*G[j][k];
			}

			outdata[i*rate+j]=(sum_code[j]%2);
		}
		for(k=Ntap-1;k>0;k--)
			x[k]=x[k-1];
	}
	delete [] x;
	delete [] sum_code;
}

void VITERBI_soft::decode(double *coded,int *decod,int G[rate][Ntap],int Nbit,int EBN0)
{
	int i,j,k,f,g=0,stage,order,order1,m;
	int **x,**h,*mod;
	double SNR,**state,**sum_decode,**sum0,**sum1,*quan_coded;

	x=new int *[Nstate];
	for(i=0;i<Nstate;i++)
		x[i]=new int [Nreg];

	mod=new int [2];

	state=new double *[Nstate];
	for(i=0;i<Nstate;i++)
		state[i]=new double [2];

	sum_decode=new double *[Nbit/rate+1];
	for(i=0;i<Nbit/rate+1;i++)
		sum_decode[i]=new double [Nstate];

	sum0=new double *[Nbit/rate+1];
	for(i=0;i<Nbit/rate+1;i++)
		sum0[i]=new double [Nstate];

	sum1=new double *[Nbit/rate+1];
	for(i=0;i<Nbit/rate+1;i++)
		sum1[i]=new double [Nstate];

	quan_coded=new double [Nbit];

	h=new int *[Nbit/rate];
	for(i=0;i<Nbit/rate;i++)
		h[i]=new int [Nstate];

    quantize(coded,quan_coded,Nbit);//quantization

	for(i=0;i<Nstate;i++)
	{
			m=i;
			for(j=0;j<Nreg;j++)
		{
			x[i][j]=m%2;//the register state
			m/=2;
		}
	}

	sum_decode[0][0]=0;
	for(order=1;order<Nstate;order++)
		sum_decode[0][order]=-1000;

	SNR=pow(10,EBN0*0.1);

	for(stage=1;stage<Nbit/rate+1;stage++)
	{
		for(order=0;order<Nstate;order++)
		{
			state[order][0]=0;
			state[order][1]=0;
			order1=(int)(order/2);

			for(j=0;j<rate;j++)
			{
				mod[0]=0;
				mod[1]=0;
				for(k=0;k<Nreg;k++)
				{
					mod[0]+=x[order1][k]*G[j][k+1];
					mod[1]+=x[order1+(int)(Nstate/2)][k]*G[j][k+1];
				}
			
				mod[0]+=(order%2)*G[j][0];
				mod[1]+=(order%2)*G[j][0];
                
				mod[0]=(mod[0]%2)*2-1;
				mod[1]=(mod[1]%2)*2-1;
		

				state[order][0]+=4*SNR*quan_coded[(stage-1)*rate+j]*mod[0];
				state[order][1]+=4*SNR*quan_coded[(stage-1)*rate+j]*mod[1];
			}
			
			sum0[stage][order]=sum_decode[stage-1][order1]+state[order][0];
			sum1[stage][order]=sum_decode[stage-1][order1+(int)(Nstate/2)]+state[order][1];

			if(sum0[stage][order]>sum1[stage][order])
			{
				sum_decode[stage][order]=sum0[stage][order];
				h[stage-1][order]=0;
			}
			else
			{
				sum_decode[stage][order]=sum1[stage][order];
				h[stage-1][order]=1;
			}
		}
	}
	for(order=0;order<Nstate;order++)
	{
		f=0;
		for(i=0;i<Nstate;i++)
			if(sum_decode[Nbit/rate][order]<sum_decode[Nbit/rate][i])
				f++;
			if(f==0)
			{
				g=order;
			}
	}
	
	for(stage=Nbit/rate-1;stage>=0;stage--)
	{
		decod[stage]=g%2;
		g=g/2+h[stage][g]*(int)(Nstate/2);
	}

    delete [] mod;
	delete [] quan_coded;

	for(i=0;i<Nstate;i++)
		delete x[i];

    for(i=0;i<Nstate;i++)
		delete state[i];
	
	for(i=0;i<Nbit/rate+1;i++)
		delete sum_decode[i];

	for(i=0;i<Nbit/rate;i++)
		delete sum0[i];

	for(i=0;i<Nbit/rate;i++)
		delete sum1[i];

	for(i=0;i<Nbit/rate;i++)
		delete h[i];
	
}

void VITERBI_soft::quantize(double *indata,double *quan_data,int Nbit)//8-level quantization
{
	int i;
	for(i=0;i<Nbit;i++)
	{
		if(indata[i]<=-2.5)
			quan_data[i]=-3.5;
	    else if(indata[i]>-2.5&&indata[i]<=-1.5)
			quan_data[i]=-2.5;
		else if(indata[i]>-1.5&&indata[i]<=-0.5)
			quan_data[i]=-1.5;
        else if(indata[i]>-0.5&&indata[i]<=0)
			quan_data[i]=-0.5;
		else if(indata[i]>0&&indata[i]<=0.5)
			quan_data[i]=0.5;
		else if(indata[i]>0.5&&indata[i]<=1.5)
			quan_data[i]=1.5;
		else if(indata[i]>1.5&&indata[i]<=2.5)
			quan_data[i]=2.5;
		else if(indata[i]>2.5)
		    quan_data[i]=3.5;
		else cout<<"error"<<endl;
	}
}