ittc.rar_LDPC_turbo_仿真 系统

# include<ittc/ittc_comm/ittc_ldpc.h> static const double infinity_llr = 1e20; static void creat_logexp_table(ittc_vec *table, int Dint1, int Dint2, int Dint3) { // by default Dint1 = 12, Dint2 = 300; Dint3 = 7; // Dint1 Determine the relation between LLR represented as real number and as integer. The relation is // QLLR = round(2^Dint1 * LLR) // Dint2 Number of entries in the table. If this is zero, then logmap becomes logmax. // Dint3 Determines the table resolution. The spacing between each entry is // 2^(-(Dint1-Dint3)) ittc_assert(table != NULL,"creat_logexp_table: null point"); ittc_assert(table->size == Dint2, "creat_logexp_table: not matched size"); for(int i = 0; i < Dint2; i++) { double x = pow(2.0, (double)(Dint3-Dint1) )*i; ittc_vec_set(table, i, log(1+exp(-x))); } } static double llr_logexp(double x, ittc_vec *table, int Dint1, int Dint2, int Dint3) { // return log(1+exp(-x)) int ind = (int)((x*(1<<(Dint1-Dint3)))+0.5); if(ind<0 || ind >=Dint2) { ind = Dint2-1; } return ittc_vec_get(table,ind); } static double max_star(double x1, double x2, ittc_vec *logexp_table, int Dint1, int Dint2, int Dint3) { double res = 0; res = (x1 > x2)?x1:x2; res += llr_logexp(fabs(x1-x2), logexp_table, Dint1, Dint2, Dint3); return res;// res = max(x1,x2) + ln(1+exp(-|x1-x2|)) } static double max_star(double x1, double x2) { double res = 0; res = (x1 > x2)?x1:x2; res += log(1+exp(-fabs(x1-x2))); return res;// res = max(x1,x2) + ln(1+exp(-|x1-x2|)) } ittc_ldpc_code *ittc_ldpc_code_alloc(ittc_sparse_imat * H_sps) { ittc_assert(H_sps!=NULL,"ittc_ldpc_code_alloc: null pointer"); ittc_assert(H_sps->col!=NULL,"ittc_ldpc_code_alloc: null pointer"); ittc_ldpc_code *ldpc = (ittc_ldpc_code *)malloc(sizeof(ittc_ldpc_code)); ittc_assert(ldpc!=NULL,"ittc_ldpc_code_alloc: ran out of memory"); /* construct an sparse representation of parity-check matrix */ int m = H_sps->n_rows; int n = H_sps->n_cols; ldpc->H = (ittc_parity_check_matrix *)malloc(sizeof(ittc_parity_check_matrix)); ittc_assert(ldpc->H!=NULL,"ittc_ldpc_code_alloc: ran out of memory"); ldpc->H->num_check = m; ldpc->H->num_symbol = n; ldpc->H->cn = (ittc_ldpc_check_node *)malloc(m*sizeof(ittc_ldpc_check_node)); ittc_assert(ldpc->H->cn!=NULL,"ittc_ldpc_code_alloc: ran out of memory"); for(int i = 0; i < ldpc->H->num_check; i++) { ldpc->H->cn[i].right = NULL; } ldpc->H->sn = (ittc_ldpc_symbol_node *)malloc(n*sizeof(ittc_ldpc_symbol_node)); ittc_assert(ldpc->H->sn!=NULL,"ittc_ldpc_code_alloc: ran out of memory"); for(int i = 0; i < ldpc->H->num_symbol; i++) { ldpc->H->sn[i].down = NULL; } ldpc->H->num_zeros = 0; // count the number of nonzero elements for(int j = 0; j < n; j++) { ittc_assert(H_sps->col[j]!=NULL, "ittc_ldpc_code_alloc: null pointer"); for(int ii = 0; ii < H_sps->col[j]->used_size; ii++) { if(H_sps->col[j]->dat[ii]!=0) { ++ldpc->H->num_zeros; } } } ldpc->H->list = (ittc_ldpc_node*)malloc( ldpc->H->num_zeros * sizeof(ittc_ldpc_node)); ittc_assert(ldpc->H->list!=NULL,"ittc_ldpc_code_alloc: ran out of memory"); for(int i = 0; i < ldpc->H->num_zeros; i++) { ldpc->H->list[i].down = NULL; ldpc->H->list[i].right = NULL; } // construct the sparse-structured H int lst_ind = 0; ittc_ldpc_node *cp; // point to current node ittc_ldpc_node *np; // point to next node for(int j = 0; j < n; j++) { for(int ii = 0; ii < H_sps->col[j]->used_size; ii++) { if(H_sps->col[j]->dat[ii]!=0) { int i = H_sps->col[j]->index[ii]; cp = &ldpc->H->list[lst_ind]; ++lst_ind; /* vertical */ np = ldpc->H->sn[j].down; if(np==NULL)/* this is the first nonzero element under sn[j] */ { ldpc->H->sn[j].down = cp; } else { while(np->down!=NULL)/* point np to the last element of sn[j] */ { np = np->down; } np->down = cp; } /* horizontal link */ np = ldpc->H->cn[i].right; if(np==NULL)/* this is the first nonzero element under cn[i] */ { ldpc->H->cn[i].right = cp; } else { while(np->right!=NULL)/* point np to the last element of cn[i] */ { np = np->right; } np->right = cp; } /* record the position */ cp->i = i; cp->j = j; cp->right = NULL; cp->down = NULL; }//endif: end of recording current node. } } ldpc->flag_dec_init = 0; ldpc->G_sps = NULL; ldpc->Gt_sps = NULL; //ldpc->H_den = ittc_imat_alloc(m,n); //ittc_imat_memcpy(H_den, ldpc->H_den); //ldpc->H_den = NULL; ldpc->H_sps = ittc_sparse_imat_alloc(m,n,1); ittc_sparse_imat_memcpy(H_sps, ldpc->H_sps ); ldpc->Ht_sps = ittc_sparse_imat_alloc(n,m,1); ittc_sparse_imat_T(ldpc->H_sps, ldpc->Ht_sps); ldpc->max_iterations = 10000;//default value ldpc->num_coded = n; ldpc->num_uncoded = n-m; ldpc->rate = (n-m)/n; ldpc->bit_order = NULL; ldpc->Dint1 = 12; ldpc->Dint2 = 1000; ldpc->Dint3 = 7; ldpc->logexp_table = ittc_vec_alloc(ldpc->Dint2); creat_logexp_table(ldpc->logexp_table, ldpc->Dint1, ldpc->Dint2, ldpc->Dint3); return ldpc; } void ittc_ldpc_code_free(ittc_ldpc_code *ldpc) { ittc_assert(ldpc!=NULL,"ittc_ldpc_code_free: null pointer"); if(ldpc->G_sps!=NULL) ittc_sparse_imat_zap(&ldpc->G_sps); if(ldpc->Gt_sps!=NULL) ittc_sparse_imat_zap(&ldpc->Gt_sps); if(ldpc->H_sps!=NULL) ittc_sparse_imat_zap(&ldpc->H_sps); if(ldpc->Ht_sps!=NULL) ittc_sparse_imat_zap(&ldpc->Ht_sps); if(ldpc->H!=NULL) { if(ldpc->H->cn!=NULL) free(ldpc->H->cn); if(ldpc->H->sn!=NULL) free(ldpc->H->sn); if(ldpc->H->list!=NULL) free(ldpc->H->list); } free(ldpc->H); if(ldpc->logexp_table!=NULL) ittc_vec_free(ldpc->logexp_table); if(ldpc->bit_order!=NULL) ittc_ivec_free(ldpc->bit_order); free(ldpc); } void ittc_ldpc_load_gmat(ittc_ldpc_code *ldpc, ittc_sparse_imat *g) { ittc_assert(ldpc!=NULL, "ittc_ldpc_load_gmat: null pointer"); ittc_assert(g!=NULL, "ittc_ldpc_load_gmat: null pointer"); ittc_assert(g->n_cols==ldpc->num_coded && g->n_rows==ldpc->num_uncoded, "ittc_ldpc_load_gmat: not matched size"); if(ldpc->G_sps==NULL) { ldpc->G_sps = ittc_sparse_imat_alloc(g->n_rows, g->n_cols, 3); } if(ldpc->Gt_sps==NULL) { ldpc->Gt_sps = ittc_sparse_imat_alloc(g->n_cols, g->n_rows, 3); } ittc_sparse_imat_memcpy(g, ldpc->G_sps); ittc_sparse_imat_T(ldpc->G_sps, ldpc->Gt_sps); } void ittc_ldpc_encoding(ittc_ivec *uncoded, ittc_ivec *coded, ittc_ldpc_code *ldpc) { ittc_assert(uncoded!=NULL, "ittc_ldpc_encoder: null pointer"); ittc_assert(coded!=NULL, "ittc_ldpc_encoder: null pointer"); ittc_assert(uncoded!=NULL, "ittc_ldpc_encoder: null pointer"); ittc_assert(ldpc!=NULL, "ittc_ldpc_encoder: null pointer"); ittc_assert(ldpc->G_sps!=NULL, "ittc_ldpc_encoder: generate matrix has not been loaded"); int k = uncoded->size; int n = coded->size; ittc_assert(k==ldpc->num_uncoded, "ittc_ldpc_encoder: not proper size of uncoded sequence"); ittc_assert(n==ldpc->num_coded, "ittc_ldpc_encoder: not proper size of coded sequence"); int tmp; if(ldpc->G_sps!=NULL) { for(int j = 0; j < n; j++ ) { tmp = 0; for(int ii = 0; ii < ldpc->G_sps->col[j]->used_size; ii++) { int i = ldpc->G_sps->col[j]->index[ii]; int gv = ldpc->G_sps->col[j]->dat[ii]; tmp += gv*ittc_ivec_get(uncoded,i); } tmp &= 1; ittc_ivec_set(coded, j, tmp); } } else { ittc_assert(0,"ittc_ldpc_encoder: not possible error"); } } void ittc_ldpc_bpsk_mapper(ittc_ivec *seq_in, ittc_vec *seq_out) { ittc_assert(seq_in!=NULL,"ittc_ldpc_bpsk_mapper: null pointer"); ittc_assert(seq_out!=NULL,"ittc_ldpc_bpsk_mapper: null pointer"); ittc_assert(seq_in->size==seq_out->size,"ittc_ldpc_bpsk_mapper: not matched size"); for(int i = 0