tcc_3gpp_pc.cpp

This CD-ROM is distributed by Kluwer Academic Publishers with ABSOLUTELY NO SUPPORT and NO WARRANTY

/*This program simulates 3GPP Turbo code. It uses "MAX LOG MAP ALGORITHM".   
         */
/*The size of the interleaver and data sequence is 1440 bits. The 3GPP 
encoders      */
/*of this simulation are use the first encoder termination method.           
         */
/*In this program user can change all the  parameter.                        
         */
/*The simulation will start and continue untill encountering 
(Max_n_frames_in_error) */
/*number of frames in error.                                                 
         */
/*This program has been compiled and run on Microsoft Visual C++ (ver6.0).   
         */
/*************************************************************************************/
/*                              3GPP SIMULATION                              
         */
/*************************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <iostream.h>
#include <conio.h>

#define  mag                 2
#define  limit               15                                     // Max 
number of iterations per sequence + 1
#define  SNRcode             0.5
#define  num_of_states       8
#define  N_not_punc          2                                      // 
Number of code-word bits
#define  K                   1                                      // 
Number of information bits per code-word
#define  infinit             10000
#define  num_of_registers    3
#define  Max_n_frames_in_error  10                                  // By 
reaching this number of frames in error the
                                                                     // 
simulation will end.
#define  variance sqrt(1 / (2*pow(10.0,SNRcode / 10.0)*(1.0/3.0)))  // 
Effect of SNR on variance of AWGN.
#define  Lc       (2.0 / (variance*variance))
#define  N_infobits_per_sequence    1440                            // Size 
of the block interleaever

int N_of_frames_in_error=0;                                         // The 
numger of errornous frames.
int imat[1440]=                                                     // 
Interleaver matrix for a 3GPP interleaver of the
                                                                    // 
length of 1440 bits.
{1439,718,1078,358,70,214,430,574,934,1366,790,646,1006,1294,286,142,1222,502,1150,862
,1368,648,1008,288,0,144,360,504,864,1296,720,576,936,1224,216,72,1152,432,1080,792
,1374,674,1030,346,4,196,394,520,902,1332,782,594,948,1268,262,140,1158,434,1104,814
,1394,714,1010,306,64,206,414,550,912,1312,732,584,988,1228,252,110,1178,464,1114,794
,1380,700,1052,334,8,178,428,536,870,1298,774,612,960,1242,238,138,1164,436,1128,836
,1396,676,1064,302,42,200,402,532,878,1324,776,590,992,1266,244,86,1180,488,1122,848
,1400,670,1032,294,68,188,378,566,880,1348,724,602,1000,1272,228,108,1184,466,1138,816
,1369,699,1035,321,59,211,389,565,917,1337,777,579,973,1243,247,95,1153,479,1119,819
,1386,656,1074,322,12,160,392,552,908,1334,766,630,972,1286,284,136,1170,438,1082,858
,1420,710,1012,324,58,198,398,526,890,1328,744,592,970,1232,218,78,1204,496,1148,796
,1402,702,1016,290,46,182,366,548,916,1360,768,608,1004,1240,220,84,1186,490,1146,800
,1399,689,1075,331,9,191,419,505,897,1307,737,599,963,1253,267,85,1183,489,1099,859
,1406,696,1054,352,2,170,412,512,918,1314,786,620,942,1246,274,106,1190,468,1092,838
,1407,677,1011,315,61,167,371,573,901,1355,773,623,979,1265,235,129,1191,445,1131,795
,1375,655,1057,309,63,193,423,511,885,1303,769,597,985,1287,223,93,1159,481,1143,841
,1422,672,1066,320,36,192,386,508,926,1340,788,598,974,1270,280,124,1206,450,1086,850
,1392,682,1026,310,16,212,426,568,876,1300,758,578,984,1260,260,134,1176,440,1106,810
,1417,697,1071,295,21,207,381,553,871,1345,783,583,999,1245,265,79,1201,495,1101,855
,1426,666,1034,312,62,180,362,542,928,1364,736,610,982,1276,264,76,1210,498,1102,818
,1384,694,1020,326,34,166,404,570,872,1322,722,624,968,1248,222,90,1168,484,1144,804
,1408,658,1038,348,50,164,400,564,884,1326,760,626,946,1284,266,82,1192,492,1100,822
,1395,695,1037,339,53,203,373,541,895,1353,789,587,955,1247,283,133,1179,441,1083,821
,1405,715,1027,319,13,173,383,521,865,1343,729,617,975,1227,243,83,1189,491,1123,811
,1383,713,1063,293,45,169,375,509,889,1351,735,621,1001,1229,261,137,1167,437,1105,847
,1412,652,1076,340,6,152,376,528,886,1350,778,638,954,1290,250,104,1196,470,1116,860
,1424,704,1050,316,14,186,374,560,892,1352,762,604,978,1238,272,100,1208,474,1094,834
,1413,703,1033,303,65,149,405,519,869,1321,765,641,991,1239,281,127,1197,447,1085,817
,1376,706,1014,342,52,190,382,572,868,1344,756,600,952,1236,254,116,1160,458,1112,798
,1381,681,1009,297,67,175,387,527,923,1339,761,615,997,1261,269,91,1165,483,1097,793
,1436,686,1024,292,22,150,372,522,898,1354,746,640,1002,1256,224,96,1220,478,1142,808
,1428,698,1018,308,40,174,420,524,894,1306,780,616,986,1244,256,122,1212,452,1110,802
,1379,649,1025,301,19,181,399,545,887,1327,787,609,993,1293,277,115,1163,459,1089,809
,1398,708,1048,298,20,194,390,514,914,1336,750,596,996,1234,236,132,1182,442,1130,832
,1425,685,1077,349,3,183,403,551,875,1323,749,607,945,1257,233,123,1209,451,1133,861
,1423,653,1023,353,25,189,415,569,909,1311,775,601,941,1289,241,77,1207,497,1125,807
,1397,657,1021,335,31,197,361,523,931,1365,763,593,959,1285,275,109,1181,465,1091,805
,1432,692,1056,300,66,162,396,558,896,1330,728,628,994,1250,240,74,1216,500,1126,840
,1388,688,1058,318,60,154,380,534,874,1346,740,636,976,1254,276,112,1172,462,1090,842
,1390,650,1042,314,38,148,368,516,910,1358,784,642,980,1292,268,88,1174,486,1098,826
,1433,673,1013,333,55,159,425,549,879,1301,785,631,961,1269,271,97,1217,477,1095,797
,1414,684,1060,336,54,146,36,510,922,1362,752,644,958,1258,242,80,1198,494,1124,844
,1393,663,1053,343,5,209,385,559,929,1341,745,581,951,1279,221,87,1177,487,1145,837
,1401,651,1059,327,57,185,407,557,933,1319,781,605,967,1291,259,131,1185,443,1107,843
,1416,716,1044,332,32,210,422,562,888,1304,726,580,962,1226,234,126,1200,448,1132,828
,1411,671,1049,307,17,155,417,537,903,1309,721,635,987,1271,219,81,1195,493,1147,833
,1378,668,1068,338,30,184,370,554,904,1356,730,606,956,1274,246,92,1162,482,1120,852
,1389,669,1015,351,49,151,409,525,927,1317,727,639,943,1273,237,135,1173,439,1129,799
,1377,687,1041,305,41,187,411,563,921,1315,743,603,989,1255,285,139,1161,435,1081,825
,1418,678,1028,328,10,204,410,544,924,1316,770,586,966,1264,226,102,1202,472,1140,812
,1370,680,1062,354,48,208,418,556,900,1308,764,582,940,1262,278,118,1154,456,1088,846
,1430,660,1072,304,18,168,408,506,930,1318,754,622,990,1282,248,98,1214,476,1118,856
,1373,693,1073,313,15,199,365,529,919,1361,725,591,981,1249,231,117,1157,457,1135,857
,1419,659,1055,291,69,201,369,535,907,1357,757,589,1003,1283,257,125,1203,449,1109,839
,1391,701,1069,347,27,145,397,507,893,1329,771,645,947,1241,229,111,1175,463,1137,853
,1382,662,1036,330,56,172,416,518,906,1310,748,618,964,1280,230,114,1166,460,1136,820
,1427,717,1061,345,51,177,391,533,911,1335,723,613,949,1225,225,99,1211,475,1141,845
,1387,707,1031,355,1,157,421,543,891,1305,753,633,939,1235,245,89,1171,485,1121,815
,1410,690,1022,344,28,158,388,546,920,1338,734,632,950,1252,258,128,1194,446,1108,806
,1372,712,1046,350,26,202,406,538,866,1320,738,588,944,1230,270,94,1156,480,1096,830
,1371,661,1019,317,37,205,377,547,883,1349,751,585,977,1281,239,141,1155,433,1127,803
,1434,654,1040,296,44,156,384,540,932,1342,772,634,998,1288,232,120,1218,454,1134,824
,1437,667,1051,325,11,147,401,513,881,1325,733,643,969,1275,255,119,1221,455,1111,835
,1385,675,1047,289,23,163,363,561,925,1363,779,627,1005,1267,253,113,1169,461,1113,831
,1421,691,1039,357,47,195,427,517,873,1299,731,595,937,1251,249,101,1205,473,1117,823
,1404,664,1070,356,24,176,424,530,882,1302,742,614,938,1278,282,130,1188,444,1084,854
,1435,705,1067,329,33,153,413,531,915,1313,759,637,965,1237,263,73,1219,501,1103,851
,1431,711,1029,337,7,165,367,567,913,1359,741,625,957,1231,279,121,1215,453,1087,813
,1415,665,1017,299,43,213,393,571,905,1333,739,577,995,1277,273,103,1199,471,1093,801
,1429,679,1045,341,29,171,379,515,877,1347,767,619,953,1263,217,75,1213,499,1149,829
,1409,709,1065,311,39,161,429,555,867,1297,747,629,983,1233,227,105,1193,469,1139,849
,1403,683,1043,323,35,179,395,539,899,1331,755,611,971,1259,251,107,1187,467,1115,827
,1438,719,1079,359,71,215,431,575,935,1367,791,647,1007,1295,287,143,1223,503,1151,863
};



/*************************************************************************************/
/*                                    RSC ENCODER Class                      
         */
/* The inputs are , q[0..num_of_mem], a[0..num_of_mem].                      
         */
/*************************************************************************************/
class encoder
{
private:
	int   *mem,*a,*q,enco;
	int   num_of_mem;
public:
	encoder(int nm,int *aa,int *qq);
        void resetenc(void);
	int encin(int inp);
	int encout(void);
        int encgozero(void);
	~encoder(void);
};
//-----------------------------------------------------------------------------------//
encoder::encoder(int nm,int *aa,int *qq)
{
	int counter;
	enco=0;
	num_of_mem=nm;
	mem=new int[num_of_mem+1];
	a=new int[num_of_mem+1];
	q=new int[num_of_mem+1];
	for (counter=0; counter <= num_of_mem; counter++)
		mem[counter]=0;
	for (counter=0; counter <= num_of_mem; counter++)
		a[counter]=aa[counter];
       	for (counter=0; counter <= num_of_mem; counter++)
		q[counter]=qq[counter];
};
//-----------------------------------------------------------------------------------//
int encoder::encgozero(void)
{
  int counter,acc1=0;
  for (counter=1; counter <= num_of_mem; counter++)
			acc1=(acc1+mem[counter-1]*q[counter]) % 2;
  return acc1;
};
//-----------------------------------------------------------------------------------//
void encoder::resetenc(void)
{
  int counter;
  for (counter=0; counter <= num_of_mem; counter++)
	  mem[counter]=0;
};
//-----------------------------------------------------------------------------------//
int encoder::encin(int inp)
{
	int counter,acc1=0;
	for (counter=num_of_mem; counter >= 1; counter--)
		mem[counter]=mem[counter-1];

	for (counter=1; counter <= num_of_mem; counter++)
			acc1=(acc1+mem[counter]*q[counter]) % 2;

	mem[0]=(acc1+inp) % 2;
	enco=0;
	for (counter=0; counter <= num_of_mem; counter++)
			enco=(enco+mem[counter]*a[counter]) % 2;
	return enco;
};
//-----------------------------------------------------------------------------------//
int encoder::encout(void)
{
	return enco;
};
//-----------------------------------------------------------------------------------//

encoder::~encoder(void)
{
	delete mem;
	delete a;
	delete q;
};
/*************************************************************************************/
/*                                 3GPP BLOCK INTERLEAVER                    
         */
/* This funnction interleaves a block of data with 1440 elements.            
         */
/* It has been written in overloading method to handle both int and float 
values     */
/*                                                                           
         */
/*************************************************************************************/
void interleaver(int data[])				// Interleaver for binary bits
{
    int lim=N_infobits_per_sequence;
	int c;
	int buf[N_infobits_per_sequence];
	for(c=0; c < N_infobits_per_sequence; c++)
	  buf[c]=data[c];

	for(c=0; c < N_infobits_per_sequence; c++)
	  data[c]=buf[imat[c]];

};

void deinterleaver(int data[])				// Interleaver for binary bits
{
    int lim=N_infobits_per_sequence;
	int c;
	int buf[N_infobits_per_sequence];
	for(c=0; c < N_infobits_per_sequence; c++)
	  buf[c]=data[c];

	for(c=0; c < N_infobits_per_sequence; c++)
	  data[imat[c]]=buf[c];
};

void interleaver(float data[])             // Interleaver for float bits
{
    int lim=N_infobits_per_sequence;
	int c;
	float buf[N_infobits_per_sequence];
	for(c=0; c < N_infobits_per_sequence; c++)
	  buf[c]=data[c];

	for(c=0; c < N_infobits_per_sequence; c++)
	  data[c]=buf[imat[c]];
};

void deinterleaver(float data[])				// Interleaver for binary bits
{
    int lim=N_infobits_per_sequence;
	int c;
	float buf[N_infobits_per_sequence];
	for(c=0; c < N_infobits_per_sequence; c++)
	  buf[c]=data[c];

	for(c=0; c < N_infobits_per_sequence; c++)
	  data[imat[c]]=buf[c];
};
/*************************************************************************************/
/*                              UNIFORM RANDOM VARIABLE                      
         */
/* This funnction produces a uniform random variabale in the range of (0,1), 
         */
/* the output is a float data, and it has RAND_MAX*(RAND_MAX+1.0) different 
value.   */
/*************************************************************************************/
float uniformrandom( void )
{
	float fo;
	static int init=0;

	/* Seed the random-number generator with current time so that
	* the numbers will be different every time we run.
	*/
	if (init==0)
		{	 srand( (unsigned)time( NULL ) );
			 init=1;
			 rand();		}

	fo=((rand()*RAND_MAX+1)+rand())/(RAND_MAX*(RAND_MAX+1.0));
	return fo;
}
/*************************************************************************************/
/*                              GAUSSIAN RANDOM VARIABLE                     
         */
/* This funnction produces a gaussian random variabale, using "random()", 
with       */
/* zero mean and unit variance. The output is a float value.                 
         */
/*************************************************************************************/
float gaussian( void )
{
	static int iset=0;
	static float gset;
	float v1,v2,fac,rsq;

	if (iset==0) {
		do {
			v1=2.0*uniformrandom()-1.0;
			v2=2.0*uniformrandom()-1.0;
			rsq=v1*v1+v2*v2;
		} while (rsq >= 1.0 || rsq == 0.0);
		fac=sqrt(-2.0*log(rsq)/rsq)*variance;

		gset=v1*fac;
		iset=1;
		return v2*fac;
	} else {
		iset=0;
		return gset;
	}
}
/*************************************************************************************/
/*                              BINARY RANDOM FUNCTION                       
         */
/* This funnction produces a binary random variable, using "random()".       
         */
/* The output is an integer value.                                           
         */
/*************************************************************************************/
int randombinarygenerator( void )
{
	if (uniformrandom()>=0.5)  return 1;
	else
		return 0;
};

/*************************************************************************************/
/*                                    RSC DECODER Class                      
         */
/*************************************************************************************/
class decoder
{
private:
        float (*lr);
	    float (*gamamat)[2][num_of_states][num_of_states];
    	float (*betamat)[num_of_states];
	    float (*alfamat)[num_of_states];
        int   x[num_of_states][num_of_states][N_not_punc];
        float (*r)[N_not_punc];
        float (*Pr_i);
public:
        int betainit;
	decoder(int xx[][num_of_states][N_not_punc],int b);
        float maxi(float v1,float v2);
        float gama(int i,int t,int lp,int l);
        void gamamatrix(void);
	    void alfamatrix(void);
        void betamatrix(void);
        void LRarray(void);
        void indecoder(float rr[][N_not_punc],float Pr_ii[]);
        void outdecoder(float apriori[]);
};
//------------------------------------------------------------------------------------//
decoder::decoder(int xx[][num_of_states][N_not_punc],int b)
{
  betainit=b;                  // 0:zero state is the final state.   1:we 
don't know final state.
  int *x1,*x2;
  x1=&x[0][0][0];
  x2=&xx[0][0][0];
  for(int i=0;i < num_of_states*num_of_states*N_not_punc;i++)
    x1[i]=x2[i];
};
//------------------------------------------------------------------------------------//
void decoder::indecoder(float rr[][N_not_punc],float Pr_ii[])
{
  //float (*cp)[25][10];
  //cp = new float[10][25][10];

        lr=new float[N_infobits_per_sequence];
	    gamamat=new 
float[N_infobits_per_sequence+1][2][num_of_states][num_of_states];
    	betamat=new float[N_infobits_per_sequence+1][num_of_states];
	    alfamat=new float[N_infobits_per_sequence+1][num_of_states];
        r=new float[N_infobits_per_sequence][N_not_punc];
        Pr_i=new float[N_infobits_per_sequence];




  float *f1,*f2;

  f1=&r[0][0];