📄 common.c
字号:
= g(LLR1, LLR2) - g(LLR3, LLR4);
/* Second bit */
LLR1 = -pow( (Xi - 3/sqrt(10)*mui), 2 )/sigma2i + 0.5*(p_oldLLR[(n_TxAntenna*LenPerTx+i)*4+0]);
LLR2 = -pow( (Xi + 3/sqrt(10)*mui), 2 )/sigma2i - 0.5*(p_oldLLR[(n_TxAntenna*LenPerTx+i)*4+0]);
LLR3 = -pow( (Xi - 1/sqrt(10)*mui), 2 )/sigma2i + 0.5*(p_oldLLR[(n_TxAntenna*LenPerTx+i)*4+0]);
LLR4 = -pow( (Xi + 1/sqrt(10)*mui), 2 )/sigma2i - 0.5*(p_oldLLR[(n_TxAntenna*LenPerTx+i)*4+0]);
p_CodedBitLLR[(n_TxAntenna*LenPerTx+i)*4+1] //= max(LLR1, LLR2) - max(LLR3, LLR4);
//= log((exp(LLR1)+exp(LLR2))/(exp(LLR3)+exp(LLR4)));
= g(LLR1, LLR2) - g(LLR3, LLR4);
/* Third bit */
LLR1 = -pow( (Yi - 1/sqrt(10)*mui), 2 )/sigma2i - 0.5*(p_oldLLR[(n_TxAntenna*LenPerTx+i)*4+3]);
LLR2 = -pow( (Yi - 3/sqrt(10)*mui), 2 )/sigma2i + 0.5*(p_oldLLR[(n_TxAntenna*LenPerTx+i)*4+3]);
LLR3 = -pow( (Yi + 1/sqrt(10)*mui), 2 )/sigma2i - 0.5*(p_oldLLR[(n_TxAntenna*LenPerTx+i)*4+3]);
LLR4 = -pow( (Yi + 3/sqrt(10)*mui), 2 )/sigma2i + 0.5*(p_oldLLR[(n_TxAntenna*LenPerTx+i)*4+3]);
p_CodedBitLLR[(n_TxAntenna*LenPerTx+i)*4+2] //= max(LLR1, LLR2) - max(LLR3, LLR4);
//= log((exp(LLR1)+exp(LLR2))/(exp(LLR3)+exp(LLR4)));
= g(LLR1, LLR2) - g(LLR3, LLR4);
/* Forth bit */
LLR1 = -pow( (Yi - 3/sqrt(10)*mui), 2 )/sigma2i + 0.5*(p_oldLLR[(n_TxAntenna*LenPerTx+i)*4+2]);
LLR2 = -pow( (Yi + 3/sqrt(10)*mui), 2 )/sigma2i - 0.5*(p_oldLLR[(n_TxAntenna*LenPerTx+i)*4+2]);
LLR3 = -pow( (Yi - 1/sqrt(10)*mui), 2 )/sigma2i + 0.5*(p_oldLLR[(n_TxAntenna*LenPerTx+i)*4+2]);
LLR4 = -pow( (Yi + 1/sqrt(10)*mui), 2 )/sigma2i - 0.5*(p_oldLLR[(n_TxAntenna*LenPerTx+i)*4+2]);
p_CodedBitLLR[(n_TxAntenna*LenPerTx+i)*4+3] //= max(LLR1, LLR2) - max(LLR3, LLR4);
//= log((exp(LLR1)+exp(LLR2))/(exp(LLR3)+exp(LLR4)));
= g(LLR1, LLR2) - g(LLR3, LLR4);
}
}
}
free(p_oldLLR);
return n_TxAntenna*i*4;
}
/* END _MAP_C_ */
//----------------------------------------------------------------------
//----------------------_TURBO_IC_C_------------------------------------
//----------------------------------------------------------------------
int Turbo_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 Noise_Variance, COMPLEX * p_x_Intf, double * p_x_Sigma, int n_IterNum)
{
int i,l,result;
int n_Iter;
int Index;
int n_TxAntenna,n_Tx;
int n_SupDomain;
int L = n_MaskLen/TxANTENNA_NUM/TxANTENNA_NUM/MAXSUPDOM;
int n_MeanVarLen;
COMPLEX tmp1 = {0,0};
double tmp2 = 0;
int Order1[TxANTENNA_NUM];
int Order2[TxANTENNA_NUM];
double Variance[TxANTENNA_NUM];
double in_SNR[TxANTENNA_NUM];
double * p_Mask2;
double * p_curMask2;
COMPLEX * p_curMask;
COMPLEX * p_x_mean;
double * p_x_variance;
//Allocate memory
p_Mask2 = (double*)malloc(n_MaskLen*sizeof(double));
p_curMask2 = (double*)malloc(n_MaskLen/TxANTENNA_NUM*sizeof(double));
p_curMask = (COMPLEX*)malloc(n_MaskLen/TxANTENNA_NUM*sizeof(COMPLEX));
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));
//Initial
for(i=0; i<n_MaskLen; i++)
{
*(p_Mask2+i) = eng_cmx( *(p_Mask+i) );
}
for(n_TxAntenna=0; n_TxAntenna<TxANTENNA_NUM; n_TxAntenna++)
{
Variance[n_TxAntenna] = 0;
for(i=n_TxAntenna; i<n_MaskLen/MAXSUPDOM; i+=TxANTENNA_NUM)
{
Variance[n_TxAntenna] += *(p_Mask2+1*n_MaskLen/MAXSUPDOM+i);
}
Variance[n_TxAntenna] += p_Rou[1*TxANTENNA_NUM+n_TxAntenna]*Noise_Variance;
in_SNR[n_TxAntenna] = pow(p_Rou[1*TxANTENNA_NUM+n_TxAntenna], 2)/(Variance[n_TxAntenna]+0.001);
}
result = sort(in_SNR, n_TxAntenna, Order1);
for(n_TxAntenna=0; n_TxAntenna<TxANTENNA_NUM; n_TxAntenna++)
{
Variance[n_TxAntenna] = 0;
for(i=n_TxAntenna; i<n_MaskLen/MAXSUPDOM; i+=TxANTENNA_NUM)
{
Variance[n_TxAntenna] += *(p_Mask2+2*n_MaskLen/MAXSUPDOM+i);
}
Variance[n_TxAntenna] += p_Rou[2*TxANTENNA_NUM+n_TxAntenna]*Noise_Variance;
in_SNR[n_TxAntenna] = pow(p_Rou[2*TxANTENNA_NUM+n_TxAntenna], 2)/(Variance[n_TxAntenna]+0.001);
}
result = sort(in_SNR, n_TxAntenna, Order2);
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++)
{
for(n_TxAntenna=0; n_TxAntenna<TxANTENNA_NUM; n_TxAntenna++)
{
Index = (n_SupDomain<MAXSUPDOM/2) ? (Order1[n_TxAntenna]) : (Order2[n_TxAntenna]);
for(i=0; i<n_MaskLen/TxANTENNA_NUM/MAXSUPDOM; i++)
{
(p_curMask+i)->real = (p_Mask+n_SupDomain*n_MaskLen/MAXSUPDOM+Index+i*TxANTENNA_NUM)->real;
(p_curMask+i)->image = (p_Mask+n_SupDomain*n_MaskLen/MAXSUPDOM+Index+i*TxANTENNA_NUM)->image;
*(p_curMask2+i) = *(p_Mask2+n_SupDomain*n_MaskLen/MAXSUPDOM+Index+i*TxANTENNA_NUM);
}
for(i=SUP_DOM[n_SupDomain]; i<SUP_DOM[n_SupDomain+1]; i++)
{
tmp1.real = tmp1.image = tmp2 = 0;
for(n_Tx=0; n_Tx<TxANTENNA_NUM; n_Tx++)
{
for(l=0; l<L; l++)
{
tmp1 = add_cmx( tmp1, mul_cmx( *(p_x_mean+i+n_Tx*n_MeanVarLen+l), *(p_curMask+n_Tx*L+l) ) );
tmp2 += (*(p_x_variance+i+n_Tx*n_MeanVarLen+l)) * (*(p_curMask2+n_Tx*L+l));
}
}
*(p_x_Intf+Index*SUBSLOTDATA_LENGTH+i) = sub_cmx( *(p_x_Rake+Index*SUBSLOTDATA_LENGTH+i), tmp1 );
*(p_x_Sigma+Index*SUBSLOTDATA_LENGTH+i) = fabs(tmp2 + p_Rou[n_SupDomain*TxANTENNA_NUM+Index]*Noise_Variance);
result = UpdateMeanVar( (p_x_Intf+Index*SUBSLOTDATA_LENGTH+i) ,
(p_x_Sigma+Index*SUBSLOTDATA_LENGTH+i),
(p_Rou+n_SupDomain*TxANTENNA_NUM+Index),
(p_x_mean+Index*n_MeanVarLen+i+PATH_NUM-1),
(p_x_variance+Index*n_MeanVarLen+i+PATH_NUM-1)
);
}
}
}
}
//Free memory
free(p_Mask2);
free(p_curMask2);
free(p_curMask);
free(p_x_mean);
free(p_x_variance);
return n_TxAntenna*i;
}
int Turbo_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 Noise_Variance, COMPLEX * p_x_Intf, double * p_x_Sigma)
{
int i,l,result;
int Index;
int n_TxAntenna,n_Tx;
int n_SupDomain;
int L = n_MaskLen/TxANTENNA_NUM/TxANTENNA_NUM/MAXSUPDOM;
int n_MeanVarLen;
COMPLEX tmp1 = {0,0};
double tmp2 = 0;
int Order1[TxANTENNA_NUM];
int Order2[TxANTENNA_NUM];
double * p_Mask2;
double * p_curMask2;
COMPLEX * p_curMask;
COMPLEX * p_x_mean;
double * p_x_variance;
//Allocate memory
p_Mask2 = (double*)malloc(n_MaskLen*sizeof(double));
p_curMask2 = (double*)malloc(n_MaskLen/TxANTENNA_NUM/MAXSUPDOM*sizeof(double));
p_curMask = (COMPLEX*)malloc(n_MaskLen/TxANTENNA_NUM/MAXSUPDOM*sizeof(COMPLEX));
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));
//Initial
for(i=0; i<n_MaskLen; i++)
{
*(p_Mask2+i) = eng_cmx( *(p_Mask+i) );
}
result = sort(p_Rou+1*TxANTENNA_NUM, TxANTENNA_NUM, Order1);
result = sort(p_Rou+2*TxANTENNA_NUM, TxANTENNA_NUM, Order2);
result = BuiltMeanVar(p_x_mean0, p_x_variance0, p_x_mean, p_x_variance);
n_MeanVarLen = result/TxANTENNA_NUM;
//Iterate Interference Cancellation
for(n_SupDomain=0; n_SupDomain<MAXSUPDOM; n_SupDomain++)
{
for(n_TxAntenna=0; n_TxAntenna<TxANTENNA_NUM; n_TxAntenna++)
{
//Get the Mask for current Tx in current support domain.
Index = (n_SupDomain<MAXSUPDOM/2) ? (Order1[n_TxAntenna]) : (Order2[n_TxAntenna]);
for(i=0; i<n_MaskLen/TxANTENNA_NUM/MAXSUPDOM; i++)
{
(p_curMask+i)->real = (p_Mask+n_SupDomain*n_MaskLen/MAXSUPDOM+Index+i*TxANTENNA_NUM)->real;
(p_curMask+i)->image = (p_Mask+n_SupDomain*n_MaskLen/MAXSUPDOM+Index+i*TxANTENNA_NUM)->image;
*(p_curMask2+i) = *(p_Mask2+n_SupDomain*n_MaskLen/MAXSUPDOM+Index+i*TxANTENNA_NUM);
}
for(i=SUP_DOM[n_SupDomain]; i<SUP_DOM[n_SupDomain+1]; i++)
{
tmp1.real = tmp1.image = tmp2 = 0;
for(n_Tx=0; n_Tx<TxANTENNA_NUM; n_Tx++)
{
for(l=0; l<L; l++)
{
tmp1 = add_cmx( tmp1, mul_cmx( *(p_x_mean+i+n_Tx*n_MeanVarLen+l), *(p_curMask+n_Tx*L+l) ) );
tmp2 += (*(p_x_variance+i+n_Tx*n_MeanVarLen+l)) * (*(p_curMask2+n_Tx*L+l));
}
}
*(p_x_Intf+Index*SUBSLOTDATA_LENGTH+i) = sub_cmx( *(p_x_Rake+Index*SUBSLOTDATA_LENGTH+i), tmp1 );
*(p_x_Sigma+Index*SUBSLOTDATA_LENGTH+i) = tmp2 + p_Rou[n_SupDomain*TxANTENNA_NUM+Index]*Noise_Variance;
}
}
}
//Free memory
free(p_Mask2);
free(p_curMask2);
free(p_curMask);
free(p_x_mean);
free(p_x_variance);
return n_TxAntenna*i;
}
//Get the Symbol's Mean and Variance accoring to prior LLR.
int MeanVar(double * p_LLR, int n_LLR_len, COMPLEX * p_x_mean0, double * p_x_variance0)
{
int i;
int n_bit;
int n_Symbol;
int n_TxAntenna;
int SymLenPerTx = n_LLR_len/TxANTENNA_NUM/4;
static int All_d[] = {-1,-1,-1,-1, 1,-1,-1,-1, -1, 1,-1,-1, 1, 1,-1,-1, // 0 ~ 3
-1,-1, 1,-1, 1,-1, 1,-1, -1, 1, 1,-1, 1, 1, 1,-1, // 4 ~ 7
-1,-1,-1, 1, 1,-1,-1, 1, -1, 1,-1, 1, 1, 1,-1, 1, // 8 ~ 11
-1,-1, 1, 1, 1,-1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1};//12 ~ 15
static int Index[] = {0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15};
COMPLEX Symbol[16];
double Prob[16];
COMPLEX tmp1;
double tmp2;
for(i=0; i<16; i++)
{
Symbol[i].real = MapMatrix16QAM[Index[i]].real;
Symbol[i].image = MapMatrix16QAM[Index[i]].image;
}
for(n_TxAntenna=0; n_TxAntenna<TxANTENNA_NUM; n_TxAntenna++)
{
for(i=0; i<SymLenPerTx; i++)
{
tmp1.real = tmp1.image = tmp2 = 0;
for(n_Symbol=0; n_Symbol<16; n_Symbol++)
{
Prob[n_Symbol] = 1;
for(n_bit=0; n_bit<4; n_bit++)
{
Prob[n_Symbol] *= ( 1+tanh(p_LLR[(n_TxAntenna*SymLenPerTx+i)*4+n_bit]/2)*All_d[n_Symbol*4+n_bit] )/2;
}
tmp1 = add_cmx( tmp1, mul_cmxreal(Symbol[n_Symbol], Prob[n_Symbol]) );
tmp2 += Prob[n_Symbol]*eng_cmx(Symbol[n_Symbol]);
}
(p_x_mean0+n_TxAntenna*SymLenPerTx+i)->real = tmp1.real;
(p_x_mean0+n_TxAntenna*SymLenPerTx+i)->image = tmp1.image;
*(p_x_variance0+n_TxAntenna*SymLenPerTx+i) = tmp2 - eng_cmx(tmp1);
}
}
return n_TxAntenna*i;
}
//Update Mean and Var accoring to the data who had been interference cancellation.
int UpdateMeanVar(COMPLEX * curIntf, double * curSigma, double * curRou, COMPLEX * nextMean, double * nextVar)
{
int i;
double SymbolProb[16]; //Just for 16QAM
double TmpSymProb[16];
int Order[16];
int end_point = 16;
COMPLEX tmp_Mean = {0,0};
double tmp_Var = 0;
//Get Prob. of all Symbol.
for(i=0; i<16; i++)
{
SymbolProb[i] = exp( -eng_cmx(sub_cmx((*curIntf), mul_cmxreal(MapMatrix16QAM[i], (*curRou))) )/ (*curSigma) );
TmpSymProb[i] = SymbolProb[i];
}
QuickSort(TmpSymProb, Order, 16);
if(TmpSymProb[0]<0.005)
{
tmp_Mean.real = tmp_Mean.image = 0;
tmp_Var = 1;
}
else
{
for(i=1; i<end_point; i++)
{
TmpSymProb[0] += TmpSymProb[i];
}
for(i=0; i<end_point; i++)
{
SymbolProb[Order[i]] /= TmpSymProb[0];
}
for(i=end_point; i<16; i++)
{
SymbolProb[Order[i]] = 0;
}
//Update Mean and Var.
for(i=0; i<16; i++)
{
tmp_Mean = add_cmx( tmp_Mean, mul_cmxreal(MapMatrix16QAM[i], SymbolProb[i]) );
tmp_Var += SymbolProb[i]*eng_cmx(MapMatrix16QAM[i]);
}
}
nextMean->real = tmp_Mean.real;
nextMean->image = tmp_Mean.image;
*nextVar = tmp_Var - eng_cmx(tmp_Mean);
return 1;
}
//Add (PATH_NUM-1) points to both the head and tail.
int BuiltMeanVar(COMPLEX * p_x_mean0, double * p_x_variance0, COMPLEX * p_x_mean, double * p_x_variance)
{
int i;
int result;
int n_TxAntenna;
COMPLEX cmx_Pilot[PILOT_LENGTH];
COMPLEX cmx_Guard[GUARD_LENGTH];
for(n_TxAntenna=0; n_TxAntenna<TxANTENNA_NUM; n_TxAntenna++)
{
result = GenerateGP(cmx_Pilot, cmx_Guard, n_TxAntenna);
for(i=0; i<PATH_NUM-1; i++)
{
(p_x_mean+n_TxAntenna*(2*PATH_NUM-2+SUBSLOTDATA_LENGTH)+i)->real = cmx_Pilot[PILOT_LENGTH-PATH_NUM+1+i].real;
(p_x_mean+n_TxAntenna*(2*PATH_NUM-2+SUBSLOTDATA_LENGTH)+i)->image = cmx_Pilot[PILOT_LENGTH-PATH_NUM+1+i].image;
*(p_x_variance+n_TxAntenna*(2*PATH_NUM-2+SUBSLOTDATA_LENGTH)+i) = 0;
}
for(i=0; i<SUBSLOTDATA_LENGTH; i++)
{
(p_x_mean+n_TxAntenna*(2*PATH_NUM-2+SUBSLOTDATA_LENGTH)+i+PATH_NUM-1)->real = (p_x_mean0+n_TxAntenna*SUBSLOTDATA_LENGTH+i)->real;
(p_x_mean+n_TxAntenna*(2*PATH_NUM-2+SUBSLOTDATA_LENGTH)+i+PATH_NUM-1)->image = (p_x_mean0+n_TxAntenna*SUBSLOTDATA_LENGTH+i)->image;
*(p_x_variance+n_TxAntenna*(2*PATH_NUM-2+SUBSLOTDATA_LENGTH)+i+PATH_NUM-1) = *(p_x_variance0+n_TxAntenna*SUBSLOTDATA_LENGTH+i);
}
for(i=0; i<PATH_NUM-1; i++)
{
(p_x_mean+n_TxAntenna*(2*PATH_NUM-2+SUBSLOTDATA_LENGTH)+i+SUBSLOTDATA_LENGTH+PATH_NUM-1)->real = cmx_Guard[i].real;
(p_x_mean+n_TxAntenna*(2*PATH_NUM-2+SUBSLOTDATA_LENGTH)+i+SUBSLOTDATA_LENGTH+PATH_NUM-1)->image = cmx_Guard[i].image;
*(p_x_variance+n_TxAntenna*(2*PATH_NUM-2+SUBSLOTDATA_LENGTH)+i+SUBSLOTDATA_LENGTH+PATH_NUM-1) = 0;
}
}
return n_TxAntenna*(i+SUBSLOTDATA_LENGTH+PATH_NUM-1);
}
int Rou_Mask(COMPLEX * p_h_half, COMPLEX * p_Mask, double * p_Rou, int Ns)
{
int i,j;
int Lh = PATH_NUM*Ns; //16, Ns: TxAntenna_Num
int N = PATH_NUM;
int n_Path = 0;
COMPLEX * tmp_h;
tmp_h = (COMPLEX *)malloc(Ns*Ns*sizeof(COMPLEX));
//Get Rou
for(i=0; i<Ns; i++)
{
p_Rou[i] = abs_cmx( *(p_h_half+i*Lh+i) );
}
//Get Mask
for(n_Path=0; n_Path<N; n_Path++)
{
for(i=0; i<Ns; i++)
{
for(j=0; j<Ns; j++)
{
(tmp_h+i*Ns+j)->real = (p_h_half+n_Path*Ns+i*Lh+j)->real;
(tmp_h+i*Ns+j)->image = (p_h_half+n_Path*Ns+i*Lh+j)->image;
}
}
if(n_Path==0)
{
for(i=0; i<Ns; i++)
{
for(j=0; j<Ns; j++)
{
(p_Mask+(N-1)*Ns+i*(2*N-1)*Ns+j)->real = (tmp_h+j*Ns+i)->real;
(p_Mask+(N-1)*Ns+i*(2*N-1)*Ns+j)->image = (tmp_h+j*Ns+i)->image;
}
(p_Mask+(N-1)*Ns+i*(2*N-1)*Ns+i)->real = (p_Mask+(N-1)*Ns+i*(2*N-1)*Ns+i)->real - p_Rou[i];
}
}
else
{
for(i=0; i<Ns; i++)
{
for(j=0; j<Ns; j++)
{
(p_Mask+(N-n_Path-1)*Ns+i*(2*N-1)*Ns+j)->real = (tmp_h+j*Ns+i)->real;
(p_Mask+(N-n_Path-1)*Ns+i*(2*N-1)*Ns+j)->image = (tmp_h+j*Ns+i)->image;
*(p_Mask+(N+n_Path-1)*Ns+i*(2*N-1)*Ns+j) = conj_cmx( *(tmp_h+i*Ns+j) );
}
}
}
}
free(tmp_h);
return (i*j*(2*n_Path-1));
}
int NewRouMask(COMPLEX * p_h_half, COMPLEX * p_Mask, double * p_Rou, int n_InterpFactor)
{
int i;
int result;
//Pointer
COMPLEX * p_Cur_h_half;
COMPLEX * p_CurMask;
double * p_CurRou;
for(i=0; i<(n_InterpFactor+1); i++)
{
p_Cur_h_half = p_h_half + i*TxANTENNA_NUM*TxANTENNA_NUM*PATH_NUM;
p_CurMask = p_Mask + i*TxANTENNA_NUM*TxANTENNA_NUM*(2*PATH_NUM-1);
p_CurRou = p_Rou + i*TxANTENNA_NUM;
result = Rou_Mask(p_Cur_h_half, p_CurMask, p_CurRou, TxANTENNA_NUM);
}
return (i*result);
}
//sort by descending order.
int sort(double * in_SNR, int n_length, int * Order)
{
int i,j;
int count;
double eps = 1e-8;
for(i=0; i<n_length; i++)
{
count = n_length-1;
for(j=0; j<n_length; j++)
{
//if( (i != j) && (in_SNR[i]-in_SNR[j])>eps )
if( (i != j) && (in_SNR[i]>in_SNR[j]) )
{
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -