void mod2sparse_add_col
( mod2sparse *m1, /* Matrix containing column to add to */
int col1, /* Index in this matrix of column to add to */
mod2sparse *m2, /* Matrix containing column to add from */
int col2 /* Index in this matrix of column to add from */
)
{
mod2entry *f1, *f2, *ft;
if (mod2sparse_rows(m1)<mod2sparse_rows(m2))
{ fprintf (stderr,
"mod2sparse_add_col: Column added to is shorter than column added from\n");
exit(1);
}
if (col1<0 || col1>=mod2sparse_cols(m1)
|| col2<0 || col2>=mod2sparse_cols(m2))
{ fprintf (stderr,"mod2sparse_add_col: Column index out of range\n");
exit(1);
}
f1 = mod2sparse_first_in_col(m1,col1);
f2 = mod2sparse_first_in_col(m2,col2);
while (!mod2sparse_at_end(f1) && !mod2sparse_at_end(f2))
{ if (mod2sparse_row(f1)>mod2sparse_row(f2))
{ mod2sparse_insert(m1,mod2sparse_row(f2),col1);
f2 = mod2sparse_next_in_col(f2);
}
else
{ ft = mod2sparse_next_in_col(f1);
if (mod2sparse_row(f1)==mod2sparse_row(f2))
{ mod2sparse_delete(m1,f1);
f2 = mod2sparse_next_in_col(f2);
}
f1 = ft;
}
}
while (!mod2sparse_at_end(f2))
{ mod2sparse_insert(m1,mod2sparse_row(f2),col1);
f2 = mod2sparse_next_in_col(f2);
}
}
void mod2sparse_add_row
( mod2sparse *m1, /* Matrix containing row to add to */
int row1, /* Index in this matrix of row to add to */
mod2sparse *m2, /* Matrix containing row to add from */
int row2 /* Index in this matrix of row to add from */
)
{
mod2entry *f1, *f2, *ft;
if (mod2sparse_cols(m1)<mod2sparse_cols(m2))
{ fprintf (stderr,
"mod2sparse_add_row: row added to is shorter than row added from\n");
exit(1);
}
if (row1<0 || row1>=mod2sparse_rows(m1)
|| row2<0 || row2>=mod2sparse_rows(m2))
{ fprintf (stderr,"mod2sparse_add_row: row index out of range\n");
exit(1);
}
f1 = mod2sparse_first_in_row(m1,row1);
f2 = mod2sparse_first_in_row(m2,row2);
while (!mod2sparse_at_end(f1) && !mod2sparse_at_end(f2))
{ if (mod2sparse_col(f1)>mod2sparse_col(f2))
{ mod2sparse_insert(m1,row1,mod2sparse_col(f2));
f2 = mod2sparse_next_in_row(f2);
}
else
{ ft = mod2sparse_next_in_row(f1);
if (mod2sparse_col(f1)==mod2sparse_col(f2))
{ mod2sparse_delete(m1,f1);
f2 = mod2sparse_next_in_row(f2);
}
f1 = ft;
}
}
while (!mod2sparse_at_end(f2))
{ mod2sparse_insert(m1,row1,mod2sparse_col(f2));
f2 = mod2sparse_next_in_row(f2);
}
}
int mod2sparse_decomp
( mod2sparse *A, /* Input matrix, M by N */
int K, /* Size of sub-matrix to find LU decomposition of */
mod2sparse *L, /* Matrix in which L is stored, M by K */
mod2sparse *U, /* Matrix in which U is stored, K by N */
int *rows, /* Array where row indexes are stored, M long */
int *cols, /* Array where column indexes are stored, N long */
mod2sparse_strategy strategy, /* Strategy to follow in picking rows/columns */
int abandon_number, /* Number of columns to abandon at some point */
int abandon_when /* When to abandon these columns */
)
{
int *rinv=NULL, *cinv=NULL, *acnt=NULL, *rcnt=NULL;
mod2sparse *B=NULL;
int M, N;
mod2entry *e=NULL, *f=NULL, *fn=NULL, *e2=NULL;
int i=0, j=0, k=0, cc=0, cc2=0, cc3=0, cr2=0, pr=0;
int found, nnf;
M = mod2sparse_rows(A);
N = mod2sparse_cols(A);
if (mod2sparse_cols(L)!=K || mod2sparse_rows(L)!=M
|| mod2sparse_cols(U)!=N || mod2sparse_rows(U)!=K)
{ fprintf (stderr,
"mod2sparse_decomp: Matrices have incompatible dimensions\n");
exit(1);
}
if (abandon_number>N-K)
{ fprintf(stderr,"Trying to abandon more columns than allowed\n");
exit(1);
}
rinv = (int*)chk_alloc (M, sizeof *rinv);
cinv = (int*)chk_alloc (N, sizeof *cinv);
if (abandon_number>0)
{
acnt = (int*)chk_alloc (M+1, sizeof *acnt);
}
if (strategy==Mod2sparse_minprod)
{
rcnt = (int*)chk_alloc (M, sizeof *rcnt);
}
mod2sparse_clear(L);
mod2sparse_clear(U);
/* Copy A to B. B will be modified, then discarded. */
B = mod2sparse_allocate(M,N);
mod2sparse_copy(A,B);
/* Count 1s in rows of B, if using minprod strategy. */
if (strategy==Mod2sparse_minprod)
{ for (i = 0; i<M; i++)
{ rcnt[i] = mod2sparse_count_row(B,i);
}
}
/* Set up initial row and column choices. */
for (i = 0; i<M; i++) rows[i] = rinv[i] = i;
for (j = 0; j<N; j++) cols[j] = cinv[j] = j;
/* Find L and U one column at a time. */
nnf = 0;
for (i = 0; i<K; i++)
{
/* Choose the next row and column of B. */
switch (strategy)
{
case Mod2sparse_first:
{
found = 0;
for (k = i; k<N; k++)
{ e = mod2sparse_first_in_col(B,cols[k]);
while (!mod2sparse_at_end(e))
{ if (rinv[mod2sparse_row(e)]>=i)
{ found = 1;
goto out_first;
}
e = mod2sparse_next_in_col(e);
}
}
out_first:
break;
}
case Mod2sparse_mincol:
{
found = 0;
for (j = i; j<N; j++)
{ cc2 = mod2sparse_count_col(B,cols[j]);
if (!found || cc2<cc)
{ e2 = mod2sparse_first_in_col(B,cols[j]);
while (!mod2sparse_at_end(e2))
{ if (rinv[mod2sparse_row(e2)]>=i)
{ found = 1;
cc = cc2;
e = e2;
k = j;
break;
}
e2 = mod2sparse_next_in_col(e2);
}
}
}
break;
}
case Mod2sparse_minprod:
{
found = 0;
for (j = i; j<N; j++)
{ cc2 = mod2sparse_count_col(B,cols[j]);
e2 = mod2sparse_first_in_col(B,cols[j]);
while (!mod2sparse_at_end(e2))
{ if (rinv[mod2sparse_row(e2)]>=i)
{ cr2 = rcnt[mod2sparse_row(e2)];
if (!found || cc2==1 || (cc2-1)*(cr2-1)<pr)
{ found = 1;
pr = cc2==1 ? 0 : (cc2-1)*(cr2-1);
e = e2;
k = j;
}
}
e2 = mod2sparse_next_in_col(e2);
}
}
break;
}
default:
{ fprintf(stderr,"mod2sparse_decomp: Unknown stategy\n");
exit(1);
}
}
if (!found)
{ nnf += 1;
}
/* Update 'rows' and 'cols'. Looks at 'k' and 'e' found above. */
if (found)
{
if (cinv[mod2sparse_col(e)]!=k) abort();
cols[k] = cols[i];
cols[i] = mod2sparse_col(e);
cinv[cols[k]] = k;
cinv[cols[i]] = i;
k = rinv[mod2sparse_row(e)];
if (k<i) abort();
rows[k] = rows[i];
rows[i] = mod2sparse_row(e);
rinv[rows[k]] = k;
rinv[rows[i]] = i;
}
/* Update L, U, and B. */
f = mod2sparse_first_in_col(B,cols[i]);
while (!mod2sparse_at_end(f))
{
fn = mod2sparse_next_in_col(f);
k = mod2sparse_row(f);
if (rinv[k]>i)
{ mod2sparse_add_row(B,k,B,mod2sparse_row(e));
if (strategy==Mod2sparse_minprod)
{ rcnt[k] = mod2sparse_count_row(B,k);
}
mod2sparse_insert(L,k,i);
}
else if (rinv[k]<i)
{ mod2sparse_insert(U,rinv[k],cols[i]);
}
else
{ mod2sparse_insert(L,k,i);
mod2sparse_insert(U,i,cols[i]);
}
f = fn;
}
/* Get rid of all entries in the current column of B, just to save space. */
for (;;)
{ f = mod2sparse_first_in_col(B,cols[i]);
if (mod2sparse_at_end(f)) break;
mod2sparse_delete(B,f);
}
/* Abandon columns of B with lots of entries if it's time for that. */
if (abandon_number>0 && i==abandon_when)
{
for (k = 0; k<M+1; k++)
{ acnt[k] = 0;
}
for (j = 0; j<N; j++)
{ k = mod2sparse_count_col(B,j);
acnt[k] += 1;
}
cc = abandon_number;
k = M;
while (acnt[k]<cc)
{ cc -= acnt[k];
k -= 1;
if (k<0) abort();
}
cc2 = 0;
for (j = 0; j<N; j++)
{ cc3 = mod2sparse_count_col(B,j);
if (cc3>k || cc3==k && cc>0)
{ if (cc3==k) cc -= 1;
for (;;)
{ f = mod2sparse_first_in_col(B,j);
if (mod2sparse_at_end(f)) break;
mod2sparse_delete(B,f);
}
cc2 += 1;
}
}
if (cc2!=abandon_number) abort();
if (strategy==Mod2sparse_minprod)
{ for (j = 0; j<M; j++)
{ rcnt[j] = mod2sparse_count_row(B,j);
}
}
}
}
/* Get rid of all entries in the rows of L past row K, after reordering. */
for (i = K; i<M; i++)
{ for (;;)
{ f = mod2sparse_first_in_row(L,rows[i]);
if (mod2sparse_at_end(f)) break;
mod2sparse_delete(L,f);
}
}
mod2sparse_free(B);
free(rinv);
free(cinv);
if (strategy==Mod2sparse_minprod) free(rcnt);
if (abandon_number>0) free(acnt);
return nnf;
}
void make_ldpc
( int seed, /* Random number seed */
make_method method, /* How to make it */
distrib *d, /* Distribution list specified */
int no4cycle /* Eliminate cycles of length four? */
)
{
mod2entry *e, *f, *g, *h;
int added, uneven, elim4, all_even, n_full, left;
int i, j, k, t, z, cb_N;
int *part, *u;
rand_seed(10*seed+1);
H = mod2sparse_allocate(M,N);
part = column_partition(d,N);
/* Create the initial version of the parity check matrix. */
switch (method)
{
case Evencol:
{
z = 0;
left = part[z];
for (j = 0; j<N; j++)
{ while (left==0)
{ z += 1;
if (z>distrib_size(d))
{ abort();
}
left = part[z];
}
for (k = 0; k<distrib_num(d,z); k++)
{ do
{ i = rand_int(M);
} while (mod2sparse_find(H,i,j));
mod2sparse_insert(H,i,j);
}
left -= 1;
}
break;
}
case Evenboth:
{
cb_N = 0;
for (z = 0; z<distrib_size(d); z++)
{ cb_N += distrib_num(d,z) * part[z];
}
u = chk_alloc (cb_N, sizeof *u);
for (k = cb_N-1; k>=0; k--)
{ u[k] = k%M;
}
uneven = 0;
t = 0;
z = 0;
left = part[z];
for (j = 0; j<N; j++)
{
while (left==0)
{ z += 1;
if (z>distrib_size(d))
{ abort();
}
left = part[z];
}
for (k = 0; k<distrib_num(d,z); k++)
{
for (i = t; i<cb_N && mod2sparse_find(H,u[i],j); i++) ;
if (i==cb_N)
{ uneven += 1;
do
{ i = rand_int(M);
} while (mod2sparse_find(H,i,j));
mod2sparse_insert(H,i,j);
}
else
{ do
{ i = t + rand_int(cb_N-t);
} while (mod2sparse_find(H,u[i],j));
mod2sparse_insert(H,u[i],j);
u[i] = u[t];
t += 1;
}
}
left -= 1;
}
if (uneven>0)
{ fprintf(stderr,"Had to place %d checks in rows unevenly\n",uneven);
}
break;
}
default: abort();
}
/* Add extra bits to avoid rows with less than two checks. */
added = 0;
for (i = 0; i<M; i++)
{ e = mod2sparse_first_in_row(H,i);
if (mod2sparse_at_end(e))
{ j = rand_int(N);
e = mod2sparse_insert(H,i,j);
added += 1;
}
e = mod2sparse_first_in_row(H,i);
if (mod2sparse_at_end(mod2sparse_next_in_row(e)) && N>1)
{ do
{ j = rand_int(N);
} while (j==mod2sparse_col(e));
mod2sparse_insert(H,i,j);
added += 1;
}
}
if (added>0)
{ fprintf(stderr,
"Added %d extra bit-checks to make row counts at least two\n",
added);
}
/* Add extra bits to try to avoid problems with even column counts. */
n_full = 0;
all_even = 1;
for (z = 0; z<distrib_size(d); z++)
{ if (distrib_num(d,z)==M)
{ n_full += part[z];
}
if (distrib_num(d,z)%2==1)
{ all_even = 0;
}
}
if (all_even && N-n_full>1 && added<2)
{ int a;
for (a = 0; added+a<2; a++)
{ do
{ i = rand_int(M);
j = rand_int(N);
} while (mod2sparse_find(H,i,j));
mod2sparse_insert(H,i,j);
}
fprintf(stderr,
"Added %d extra bit-checks to try to avoid problems from even column counts\n",
a);
}
/* Eliminate cycles of length four, if asked, and if possible. */
if (no4cycle)
{
elim4 = 0;
for (t = 0; t<10; t++)
{ k = 0;
for (j = 0; j<N; j++)
{ for (e = mod2sparse_first_in_col(H,j);
!mod2sparse_at_end(e);
e = mod2sparse_next_in_col(e))
{ for (f = mod2sparse_first_in_row(H,mod2sparse_row(e));
!mod2sparse_at_end(f);
f = mod2sparse_next_in_row(f))
{ if (f==e) continue;
for (g = mod2sparse_first_in_col(H,mod2sparse_col(f));
!mod2sparse_at_end(g);
g = mod2sparse_next_in_col(g))
{ if (g==f) continue;
for (h = mod2sparse_first_in_row(H,mod2sparse_row(g));
!mod2sparse_at_end(h);
h = mod2sparse_next_in_row(h))
{ if (mod2sparse_col(h)==j)
{ do
{ i = rand_int(M);
} while (mod2sparse_find(H,i,j));
mod2sparse_delete(H,e);
mod2sparse_insert(H,i,j);
elim4 += 1;
k += 1;
goto nextj;
}
}
}
}
}
nextj: ;
}
if (k==0) break;
}
if (elim4>0)
{ fprintf(stderr,
"Eliminated %d cycles of length four by moving checks within column\n",
elim4);
}
if (t==10)
{ fprintf(stderr,
"Couldn't eliminate all cycles of length four in 10 passes\n");
}
}
}
mod2sparse* CreatePchkMatrix ( int nbRows, int nbCols, make_method makeMethod, int leftDegree, int seed, bool no4cycle, SessionType type, int verbosity )
{
mod2entry *e;
#if 0
mod2entry *f, *g, *h; /* using by no4cycle mode */
int elim4;
#endif
int added, uneven;
int i, j, k, t;
int *u;
mod2sparse *pchkMatrix = NULL;
int skipCols = 0; // avoid warning
int nbDataCols = 0; // avoid warning
if (type != TypeLDGM && type != TypeSTAIRS && type != TypeTRIANGLE) {
fprintf(stderr, "unsupported code type (%d)\n", type);
return NULL;
}
skipCols = nbRows;
nbDataCols = nbCols-skipCols;
// Check for some problems.
if (leftDegree>nbRows)
{
fprintf(stderr, "ERROR, Number of checks per bit (%d) is greater than total checks (%d)\n", leftDegree, nbRows);
return NULL;
}
#if 0
if (leftDegree==nbRows && nbCols>1 && no4cycle)
{
fprintf(stderr, "ERROR, Can't eliminate cycles of length four with this many checks per bit\n");
return NULL;
}
#endif
if (no4cycle) {
fprintf(stderr, "ERROR: no4cycle mode is no longer supported!\n");
exit(-1);
}
ldpc_srand(seed);
pchkMatrix = mod2sparse_allocate(nbRows, nbCols);
/* Create the initial version of the parity check matrix. */
switch (makeMethod)
{
case Evencol:
for(j=skipCols; j<nbCols; j++)
{
for(k=0; k<leftDegree; k++)
{
do
{
i = ldpc_rand(nbRows);
}
while (mod2sparse_find(pchkMatrix,i,j));
mod2sparse_insert(pchkMatrix,i,j);
}
}
break;
case Evenboth:
u = (int*)chk_alloc (leftDegree*nbDataCols, sizeof *u);
/* initialize a list of possible choices to guarantee a homogeneous "1" distribution */
for(k = leftDegree*nbDataCols-1; k>=0; k--)
{
u[k] = k%nbRows;
}
uneven = 0;
t = 0; /* left limit within the list of possible choices, u[] */
for(j = skipCols; j<nbCols; j++) /* for each source symbol column */
{
for(k = 0; k<leftDegree; k++) /* add left_degree "1s" */
{
/* check that valid available choices remain */
for(i = t; i<leftDegree*nbDataCols && mod2sparse_find(pchkMatrix,u[i],j); i++) ;
if(i < leftDegree*nbDataCols)
{
/* choose one index within the list of possible choices */
do {
i = t + ldpc_rand(leftDegree*nbDataCols-t);
} while (mod2sparse_find(pchkMatrix,u[i],j));
mod2sparse_insert(pchkMatrix,u[i],j);
/* replace with u[t] which has never been chosen */
u[i] = u[t];
t++;
}
else
{
/* no choice left, choose one randomly */
uneven += 1;
do {
i = ldpc_rand(nbRows);
} while (mod2sparse_find(pchkMatrix,i,j));
mod2sparse_insert(pchkMatrix,i,j);
}
}
}
if(uneven > 0 && verbosity >= 1)
{
fprintf(stderr,"Had to place %d checks in rows unevenly\n",uneven);
}
free(u); /* VR: added */
break;
default: abort();
}
/* Add extra bits to avoid rows with less than two checks. */
added = 0;
for(i = 0; i<nbRows; i++)
{
e = mod2sparse_first_in_row(pchkMatrix,i);
if(mod2sparse_at_end(e))
{
j = (ldpc_rand(nbDataCols))+skipCols;
e = mod2sparse_insert(pchkMatrix,i,j);
added ++;
}
e = mod2sparse_first_in_row(pchkMatrix,i);
if(mod2sparse_at_end(mod2sparse_next_in_row(e)) && nbDataCols>1)
{
do
{
j = (ldpc_rand(nbDataCols))+skipCols;
} while (j==mod2sparse_col(e));
mod2sparse_insert(pchkMatrix,i,j);
added ++;
}
}
if(added > 0 && verbosity >= 1)
{
fprintf(stderr, "Added %d extra bit-checks to make row counts at least two\n", added);
}
/* Add extra bits to try to avoid problems with even column counts. */
if(leftDegree%2==0 && leftDegree<nbRows && nbDataCols>1 && added<2)
{
int a;
for(a = 0; added+a<2; a++)
{
do
{
i = ldpc_rand(nbRows);
j = (ldpc_rand(nbDataCols))+skipCols;
} while (mod2sparse_find(pchkMatrix,i,j));
mod2sparse_insert(pchkMatrix,i,j);
}
if (verbosity >= 1) {
fprintf(stderr, "Added %d extra bit-checks to try to avoid problems from even column counts\n", a);
}
}
#if 0
/* Eliminate cycles of length four, if asked, and if possible. */
if(no4cycle)
{
elim4 = 0;
for(t = 0; t<10; t++)
{
k = 0;
for(j = 0; j<nbCols; j++)
{
for( e=mod2sparse_first_in_col(pchkMatrix,j); !mod2sparse_at_end(e); e=mod2sparse_next_in_col(e) )
{
for( f=mod2sparse_first_in_row(pchkMatrix,mod2sparse_row(e)); !mod2sparse_at_end(f); f=mod2sparse_next_in_row(f) )
{
if(f==e) continue;
for(g=mod2sparse_first_in_col(pchkMatrix,mod2sparse_col(f)); !mod2sparse_at_end(g); g=mod2sparse_next_in_col(g) )
{
if(g==f) continue;
for( h=mod2sparse_first_in_row(pchkMatrix,mod2sparse_row(g)); !mod2sparse_at_end(h); h = mod2sparse_next_in_row(h) )
{
if(mod2sparse_col(h)==j)
{
do
{
i = ldpc_rand(nbRows);
}
while (mod2sparse_find(pchkMatrix,i,j));
mod2sparse_delete(pchkMatrix,e);
mod2sparse_insert(pchkMatrix,i,j);
elim4 += 1;
k += 1;
goto nextj;
}
}
}
}
}
nextj: ;
}
if(k==0) break;
}
if(elim4>0)
{
fprintf(stderr, "Eliminated %d cycles of length four by moving checks within column\n", elim4);
}
if(t==10)
{
fprintf(stderr, "Couldn't eliminate all cycles of length four in 10 passes\n");
}
}
#endif
switch (type) {
case TypeLDGM:
for (i = 0; i < nbRows; i++) {
/* identity */
mod2sparse_insert(pchkMatrix, i, i);
}
break;
case TypeSTAIRS:
mod2sparse_insert(pchkMatrix, 0, 0); /* 1st row */
for (i = 1; i < nbRows; i++) { /* for all other rows */
/* identity */
mod2sparse_insert(pchkMatrix, i, i);
/* staircase */
mod2sparse_insert(pchkMatrix, i, i-1);
}
break;
case TypeTRIANGLE:
mod2sparse_insert(pchkMatrix, 0, 0); /* 1st row */
for (i = 1; i < nbRows; i++) { /* for all other rows */
/* identity */
mod2sparse_insert(pchkMatrix, i, i);
/* staircase */
mod2sparse_insert(pchkMatrix, i, i-1);
/* triangle */
j = i-1;
for (int l = 0; l < j; l++) { /* limit the # of "1s" added */
j = ldpc_rand(j);
mod2sparse_insert(pchkMatrix, i, j);
}
}
break;
}
return pchkMatrix;
}
