📄 common.c
字号:
count--;
}
}
Order[count] = i;
}
return i;
}
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
int GetCurTxMask(COMPLEX * p_CurSdMask, COMPLEX * p_CurWeight, COMPLEX * p_CurTxMask, int n_CurTxAntenna)
{
int i,j;
int n_Path;
//Memory
COMPLEX * p_tmpCurSdMask;
COMPLEX * p_tmpCurTxMask;
//Allocate memory
p_tmpCurSdMask = (COMPLEX *)malloc(TxANTENNA_NUM*TxANTENNA_NUM*(2*PATH_NUM-1)*sizeof(COMPLEX));
p_tmpCurTxMask = (COMPLEX *)malloc(TxANTENNA_NUM*(2*PATH_NUM-1)*sizeof(COMPLEX));
//Initialization: Block Reshape p_CurSdMask
for(n_Path=0; n_Path<2*PATH_NUM-1; n_Path++)
{
for(i=0; i<TxANTENNA_NUM; i++)
{
for(j=0; j<TxANTENNA_NUM; j++)
{
(p_tmpCurSdMask+(n_Path*TxANTENNA_NUM+i)*TxANTENNA_NUM+j)->real = (p_CurSdMask+i*TxANTENNA_NUM*(2*PATH_NUM-1)+n_Path*TxANTENNA_NUM+j)->real;
(p_tmpCurSdMask+(n_Path*TxANTENNA_NUM+i)*TxANTENNA_NUM+j)->image = (p_CurSdMask+i*TxANTENNA_NUM*(2*PATH_NUM-1)+n_Path*TxANTENNA_NUM+j)->image;
}
}
}
//Matrix Product
for(i=0; i<TxANTENNA_NUM*(2*PATH_NUM-1); i++)
{
(p_tmpCurTxMask+i)->real = (p_tmpCurTxMask+i)->image = 0;
for(j=0; j<TxANTENNA_NUM; j++)
{
*(p_tmpCurTxMask+i) = add_cmx( *(p_tmpCurTxMask+i), mul_cmx( *(p_tmpCurSdMask+i*TxANTENNA_NUM+j), *(p_CurWeight+j) ) );
}
}
//Output
for(i=0; i<TxANTENNA_NUM; i++)
{
for(j=0; j<(2*PATH_NUM-1); j++)
{
(p_CurTxMask+i*(2*PATH_NUM-1)+j)->real = (p_tmpCurTxMask+j*TxANTENNA_NUM+i)->real;
(p_CurTxMask+i*(2*PATH_NUM-1)+j)->image = (p_tmpCurTxMask+j*TxANTENNA_NUM+i)->image;
}
}
(p_CurTxMask+n_CurTxAntenna*(2*PATH_NUM-1)+(PATH_NUM-1))->real = 0;
(p_CurTxMask+n_CurTxAntenna*(2*PATH_NUM-1)+(PATH_NUM-1))->image = 0;
//Free memory
free(p_tmpCurSdMask);
free(p_tmpCurTxMask);
return (i*j);
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
int GetWeightMatrix(COMPLEX * p_CurSdCentralMask, COMPLEX * p_VarMatrix, COMPLEX * p_Weight)
{
int i,j,result;
COMPLEX * p_tmpCentralMask;
//Allocate memory
p_tmpCentralMask = (COMPLEX *)malloc(TxANTENNA_NUM*TxANTENNA_NUM*sizeof(COMPLEX));
//Initialization
for(i=0; i<TxANTENNA_NUM*TxANTENNA_NUM; i++)
{
(p_tmpCentralMask+i)->real = (p_CurSdCentralMask+i)->real;
(p_tmpCentralMask+i)->image = -(p_CurSdCentralMask+i)->image;
}
result = cholsky_solve_equation(p_VarMatrix, TxANTENNA_NUM*TxANTENNA_NUM, p_tmpCentralMask, TxANTENNA_NUM*TxANTENNA_NUM, p_Weight);
//Output
for(i=0; i<TxANTENNA_NUM; i++)
{
for(j=0; j<TxANTENNA_NUM; j++)
{
(p_Weight+i*TxANTENNA_NUM+j)->image *= -1;
}
}
//Free memory
free(p_tmpCentralMask);
return(i*j);
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
int UpdateRou(COMPLEX * p_CurSdCentralMask, COMPLEX * p_Weight, double * p_CurSdRou, double * p_RouNoise)
{
int i,j,k;
COMPLEX tmp;
COMPLEX * p_MidResult;
//Allocate memory
p_MidResult = (COMPLEX *)malloc(TxANTENNA_NUM*TxANTENNA_NUM*sizeof(COMPLEX));
for(i=0; i<TxANTENNA_NUM; i++)
{
for(j=0; j<TxANTENNA_NUM; j++)
{
(p_MidResult+i*TxANTENNA_NUM+j)->real = (p_MidResult+i*TxANTENNA_NUM+j)->image = 0;
for(k=0; k<TxANTENNA_NUM; k++)
{
*(p_MidResult+i*TxANTENNA_NUM+j) = add_cmx( *(p_MidResult+i*TxANTENNA_NUM+j), mul_cmx( *(p_Weight+i*TxANTENNA_NUM+k), *(p_CurSdCentralMask+k*TxANTENNA_NUM+j) ) );
}
}
*(p_CurSdRou+i) = (p_MidResult+i*TxANTENNA_NUM+i)->real;
}
for(i=0; i<TxANTENNA_NUM; i++)
{
tmp.real = tmp.image = 0;
for(k=0; k<TxANTENNA_NUM; k++)
{
tmp = add_cmx( tmp, mul_cmx( *(p_MidResult+i*TxANTENNA_NUM+k), conj_cmx(*(p_Weight+i*TxANTENNA_NUM+k)) ) );
}
*(p_RouNoise+i) = tmp.real;
}
//Free memory
free(p_MidResult);
return i;
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
int GetVarMatrix(COMPLEX * p_CurSdMask, COMPLEX * p_CurSdCentralMask, double * p_VarMean, COMPLEX * p_VarMatrix, double * NoiseVariance)
{
int i,j,k;
int n_Tx;
int n_Path;
//Memory
double * p_DiagVarMean;
//Allocate memory
p_DiagVarMean = (double *)malloc(TxANTENNA_NUM*(2*PATH_NUM-1)*sizeof(double));
//Initialization
for(n_Path=0; n_Path<(2*PATH_NUM-1); n_Path++)
{
for(n_Tx=0; n_Tx<TxANTENNA_NUM; n_Tx++)
{
*(p_DiagVarMean+n_Path*TxANTENNA_NUM+n_Tx) = *(p_VarMean+n_Tx);
}
}
//Matrix Product
for(i=0; i<TxANTENNA_NUM; i++)
{
for(j=0; j<TxANTENNA_NUM; j++)
{
(p_VarMatrix+i*TxANTENNA_NUM+j)->real = (p_VarMatrix+i*TxANTENNA_NUM+j)->image = 0;
for(k=0; k<TxANTENNA_NUM*(2*PATH_NUM-1); k++)
{
*(p_VarMatrix+i*TxANTENNA_NUM+j) =
add_cmx( *(p_VarMatrix+i*TxANTENNA_NUM+j),
mul_cmxreal( mul_cmx( *(p_CurSdMask+i*TxANTENNA_NUM*(2*PATH_NUM-1)+k),
conj_cmx( *(p_CurSdMask+j*TxANTENNA_NUM*(2*PATH_NUM-1)+k)) ),
*(p_DiagVarMean+k)
)
);
}
(p_VarMatrix+i*TxANTENNA_NUM+j)->image *= -1;
}
(p_VarMatrix+i*TxANTENNA_NUM+i)->image = 0;
}
//Add Initial value
for(i=0; i<TxANTENNA_NUM; i++)
{
for(j=0; j<TxANTENNA_NUM; j++)
{
*(p_VarMatrix+i*TxANTENNA_NUM+j) = add_cmx( *(p_VarMatrix+i*TxANTENNA_NUM+j), mul_cmxreal( *(p_CurSdCentralMask+i*TxANTENNA_NUM+j), *NoiseVariance ) );
}
(p_VarMatrix+i*TxANTENNA_NUM+i)->image = 0;
}
//Free memory
free(p_DiagVarMean);
return (i*j);
}
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
int Turbo_SF_IC(COMPLEX * p_x_Rake, int n_x_RakeLen, double * p_Rou, COMPLEX * p_Mask, int n_MaskLen, COMPLEX * p_x_mean0, double * p_x_variance0, double NoiseVariance, COMPLEX * p_x_Intf, double * p_x_Sigma, int n_IterNum)
{
int result;
int i,j,l;
int n_Tx;
int n_TxAntenna;
int n_Iter;
int n_SupDomain;
int n_MeanVarLen;
COMPLEX tmp1,tmp3;
double tmp2;
//Pointer
COMPLEX * p_CurSdMask;
double * p_CurSdRou;
//Memory
COMPLEX * p_x_mean;
double * p_x_variance;
double * p_VarMean;
COMPLEX * p_CurSdCentralMask;
COMPLEX * p_CurTxMask;
COMPLEX * p_Weight;
COMPLEX * p_VarMatrix;
double * p_RouNoise;
//Allocate memory
p_x_mean = (COMPLEX *)malloc(TxANTENNA_NUM*(2*PATH_NUM-2+SUBSLOTDATA_LENGTH)*sizeof(COMPLEX));
p_x_variance = (double *)malloc(TxANTENNA_NUM*(2*PATH_NUM-2+SUBSLOTDATA_LENGTH)*sizeof(double));
p_VarMean = (double *)malloc(TxANTENNA_NUM*sizeof(double));
p_CurTxMask = (COMPLEX *)malloc(TxANTENNA_NUM*(2*PATH_NUM-1)*sizeof(COMPLEX));
p_CurSdCentralMask = (COMPLEX *)malloc(TxANTENNA_NUM*TxANTENNA_NUM*sizeof(COMPLEX));
p_Weight = (COMPLEX *)malloc(TxANTENNA_NUM*TxANTENNA_NUM*sizeof(COMPLEX));
p_VarMatrix = (COMPLEX *)malloc(TxANTENNA_NUM*TxANTENNA_NUM*sizeof(COMPLEX));
p_RouNoise = (double *)malloc(TxANTENNA_NUM*sizeof(double));
//Main peogram
result = BuiltMeanVar(p_x_mean0, p_x_variance0, p_x_mean, p_x_variance);
n_MeanVarLen = result/TxANTENNA_NUM;
//Iterate Interference Cancellation
for(n_Iter=0; n_Iter<n_IterNum; n_Iter++)
{
for(n_SupDomain=0; n_SupDomain<MAXSUPDOM; n_SupDomain++)
{
//Get Variance mean for current support domain
for(n_Tx=0; n_Tx<TxANTENNA_NUM; n_Tx++)
{
*(p_VarMean+n_Tx) = 0;
for(i=SUP_DOM[n_SupDomain]; i<SUP_DOM[n_SupDomain+1]; i++)
{
*(p_VarMean+n_Tx) += *(p_x_variance+n_Tx*n_MeanVarLen+(PATH_NUM-1)+i);
}
*(p_VarMean+n_Tx) /= (double)(SUP_DOM[n_SupDomain+1]-SUP_DOM[n_SupDomain]);
}
//Get current support domain's Mask and its central block's transpose.
p_CurSdMask = p_Mask + n_SupDomain*n_MaskLen/MAXSUPDOM;
for(i=0; i<TxANTENNA_NUM; i++)
{
for(j=0; j<TxANTENNA_NUM; j++)
{
(p_CurSdCentralMask+i*TxANTENNA_NUM+j)->real = (p_CurSdMask+j*TxANTENNA_NUM*(2*PATH_NUM-1)+TxANTENNA_NUM*(PATH_NUM-1)+i)->real;
(p_CurSdCentralMask+i*TxANTENNA_NUM+j)->image = (p_CurSdMask+j*TxANTENNA_NUM*(2*PATH_NUM-1)+TxANTENNA_NUM*(PATH_NUM-1)+i)->image;
}
}
//Get Variance Matrix
result = GetVarMatrix(p_CurSdMask, p_CurSdCentralMask, p_VarMean, p_VarMatrix, &NoiseVariance);
//Get Weight Matrix
result = GetWeightMatrix(p_CurSdCentralMask, p_VarMatrix, p_Weight);
//Update Rou
p_CurSdRou = p_Rou + n_SupDomain*TxANTENNA_NUM;
result = UpdateRou(p_CurSdCentralMask, p_Weight, p_CurSdRou, p_RouNoise);
//Begin Interference Cancellation
for(n_TxAntenna=0; n_TxAntenna<TxANTENNA_NUM; n_TxAntenna++)
{
result = GetCurTxMask(p_CurSdMask, p_Weight+n_TxAntenna*TxANTENNA_NUM, p_CurTxMask, n_TxAntenna);
for(i=SUP_DOM[n_SupDomain]; i<SUP_DOM[n_SupDomain+1]; i++)
{
tmp1.real = tmp1.image = tmp2 = 0;
tmp3.real = tmp3.image = 0;
for(n_Tx=0; n_Tx<TxANTENNA_NUM; n_Tx++)
{
for(l=0; l<(2*PATH_NUM-1); l++)
{
tmp1 = add_cmx( tmp1, mul_cmx( *(p_x_mean+i+n_Tx*n_MeanVarLen+l), *(p_CurTxMask+n_Tx*(2*PATH_NUM-1)+l) ) );
tmp2 += (*(p_x_variance+i+n_Tx*n_MeanVarLen+l)) * (eng_cmx(*(p_CurTxMask+n_Tx*(2*PATH_NUM-1)+l)));
}
tmp3 = add_cmx( tmp3, mul_cmx( *(p_Weight+n_TxAntenna*TxANTENNA_NUM+n_Tx), *(p_x_Rake+n_Tx*SUBSLOTDATA_LENGTH+i) ) );
}
*(p_x_Intf+n_TxAntenna*SUBSLOTDATA_LENGTH+i) = sub_cmx( tmp3, tmp1 );
*(p_x_Sigma+n_TxAntenna*SUBSLOTDATA_LENGTH+i) = fabs(tmp2 + p_RouNoise[n_TxAntenna]*NoiseVariance);
result = UpdateMeanVar( (p_x_Intf+n_TxAntenna*SUBSLOTDATA_LENGTH+i) ,
(p_x_Sigma+n_TxAntenna*SUBSLOTDATA_LENGTH+i),
(p_CurSdRou+n_TxAntenna),
(p_x_mean+n_TxAntenna*n_MeanVarLen+i+PATH_NUM-1),
(p_x_variance+n_TxAntenna*n_MeanVarLen+i+PATH_NUM-1)
);
}
}
}//End of n_SupDomain
}//End of n_Iter
//Free memory
free(p_x_mean);
free(p_x_variance);
free(p_VarMean);
free(p_CurTxMask);
free(p_CurSdCentralMask);
free(p_Weight);
free(p_VarMatrix);
free(p_RouNoise);
return 1;
}
int Turbo_SF_ICC(COMPLEX * p_x_Rake, int n_x_RakeLen, double * p_Rou, COMPLEX * p_Mask, int n_MaskLen, COMPLEX * p_x_mean0, double * p_x_variance0, double NoiseVariance, COMPLEX * p_x_Intf, double * p_x_Sigma)
{
int result;
int i,j,l;
int n_Tx;
int n_TxAntenna;
int n_Iter;
int n_SupDomain;
int n_MeanVarLen;
COMPLEX tmp1,tmp3;
double tmp2;
//Pointer
COMPLEX * p_CurSdMask;
double * p_CurSdRou;
//Memory
COMPLEX * p_x_mean;
double * p_x_variance;
double * p_VarMean;
COMPLEX * p_CurSdCentralMask;
COMPLEX * p_CurTxMask;
COMPLEX * p_Weight;
COMPLEX * p_VarMatrix;
double * p_RouNoise;
//Allocate memory
p_x_mean = (COMPLEX *)malloc(TxANTENNA_NUM*(2*PATH_NUM-2+SUBSLOTDATA_LENGTH)*sizeof(COMPLEX));
p_x_variance = (double *)malloc(TxANTENNA_NUM*(2*PATH_NUM-2+SUBSLOTDATA_LENGTH)*sizeof(double));
p_VarMean = (double *)malloc(TxANTENNA_NUM*sizeof(double));
p_CurTxMask = (COMPLEX *)malloc(TxANTENNA_NUM*(2*PATH_NUM-1)*sizeof(COMPLEX));
p_CurSdCentralMask = (COMPLEX *)malloc(TxANTENNA_NUM*TxANTENNA_NUM*sizeof(COMPLEX));
p_Weight = (COMPLEX *)malloc(TxANTENNA_NUM*TxANTENNA_NUM*sizeof(COMPLEX));
p_VarMatrix = (COMPLEX *)malloc(TxANTENNA_NUM*TxANTENNA_NUM*sizeof(COMPLEX));
p_RouNoise = (double *)malloc(TxANTENNA_NUM*sizeof(double));
//Main peogram
result = BuiltMeanVar(p_x_mean0, p_x_variance0, p_x_mean, p_x_variance);
n_MeanVarLen = result/TxANTENNA_NUM;
//Iterate Interference Cancellation
for(n_Iter=0; n_Iter<1; n_Iter++)
{
for(n_SupDomain=0; n_SupDomain<MAXSUPDOM; n_SupDomain++)
{
//Get Variance mean for current support domain
for(n_Tx=0; n_Tx<TxANTENNA_NUM; n_Tx++)
{
*(p_VarMean+n_Tx) = 0;
for(i=SUP_DOM[n_SupDomain]; i<SUP_DOM[n_SupDomain+1]; i++)
{
*(p_VarMean+n_Tx) += *(p_x_variance+n_Tx*n_MeanVarLen+(PATH_NUM-1)+i);
}
*(p_VarMean+n_Tx) /= (double)(SUP_DOM[n_SupDomain+1]-SUP_DOM[n_SupDomain]);
}
//Get current support domain's Mask and its central block's transpose.
p_CurSdMask = p_Mask + n_SupDomain*n_MaskLen/MAXSUPDOM;
for(i=0; i<TxANTENNA_NUM; i++)
{
for(j=0; j<TxANTENNA_NUM; j++)
{
(p_CurSdCentralMask+i*TxANTENNA_NUM+j)->real = (p_CurSdMask+j*TxANTENNA_NUM*(2*PATH_NUM-1)+TxANTENNA_NUM*(PATH_NUM-1)+i)->real;
(p_CurSdCentralMask+i*TxANTENNA_NUM+j)->image = (p_CurSdMask+j*TxANTENNA_NUM*(2*PATH_NUM-1)+TxANTENNA_NUM*(PATH_NUM-1)+i)->image;
}
}
//Get Variance Matrix
result = GetVarMatrix(p_CurSdMask, p_CurSdCentralMask, p_VarMean, p_VarMatrix, &NoiseVariance);
//Get Weight Matrix
result = GetWeightMatrix(p_CurSdCentralMask, p_VarMatrix, p_Weight);
//Update Rou
p_CurSdRou = p_Rou + n_SupDomain*TxANTENNA_NUM;
result = UpdateRou(p_CurSdCentralMask, p_Weight, p_CurSdRou, p_RouNoise);
//Begin Interference Cancellation
for(n_TxAntenna=0; n_TxAntenna<TxANTENNA_NUM; n_TxAntenna++)
{
result = GetCurTxMask(p_CurSdMask, p_Weight+n_TxAntenna*TxANTENNA_NUM, p_CurTxMask, n_TxAntenna);
for(i=SUP_DOM[n_SupDomain]; i<SUP_DOM[n_SupDomain+1]; i++)
{
tmp1.real = tmp1.image = tmp2 = 0;
tmp3.real = tmp3.image = 0;
for(n_Tx=0; n_Tx<TxANTENNA_NUM; n_Tx++)
{
for(l=0; l<(2*PATH_NUM-1); l++)
{
tmp1 = add_cmx( tmp1, mul_cmx( *(p_x_mean+i+n_Tx*n_MeanVarLen+l), *(p_CurTxMask+n_Tx*(2*PATH_NUM-1)+l) ) );
tmp2 += (*(p_x_variance+i+n_Tx*n_MeanVarLen+l)) * (eng_cmx(*(p_CurTxMask+n_Tx*(2*PATH_NUM-1)+l)));
}
tmp3 = add_cmx( tmp3, mul_cmx( *(p_Weight+n_TxAntenna*TxANTENNA_NUM+n_Tx), *(p_x_Rake+n_Tx*SUBSLOTDATA_LENGTH+i) ) );
}
*(p_x_Intf+n_TxAntenna*SUBSLOTDATA_LENGTH+i) = sub_cmx( tmp3, tmp1 );
*(p_x_Sigma+n_TxAntenna*SUBSLOTDATA_LENGTH+i) = fabs(tmp2 + p_RouNoise[n_TxAntenna]*NoiseVariance);
}
}
}//End of n_SupDomain
}//End of n_Iter
//Free memory
free(p_x_mean);
free(p_x_variance);
free(p_VarMean);
free(p_CurTxMask);
free(p_CurSdCentralMask);
free(p_Weight);
free(p_VarMatrix);
free(p_RouNoise);
return 1;
}
/* END _TURBO_IC_C_ */
//----------------------------------------------------------------------
//----------------------_CODE_C_----------------------------------------
//----------------------------------------------------------------------
int dot(g, s, Len)
{
int i;
int xor,r;
xor = 0;
r = (g&s);
for(i=0; i<Len; i++)
{
xor ^= ((r>>i)&1);
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -