decodehelpers.c

This a framework to test new ideas in transmission technology. Actual development is a LDPC-coder in

#include "decodehelpers.h"
#include "lookup.h"
#define DBG_LVL 0

/*
#define MAXMESSAGE 20
#define EXPMAXMESSAGE 485165000
#define EXPNEGMAXMESSAGE 0.00000000206115
*/

#define MAXMESSAGE 25
#define EXPMAXMESSAGE 7.20049e10
#define EXPNEGMAXMESSAGE 1.38879e-11


/************************************
* copy the received values into the *
* appropriate places in the graph   *
************************************/
void initializegraph(graphs *graph, double *received) {
  int node, socket;

  for (node=0; node<(*graph).vnodenum; node++)
    vnodevalue=*(received+node);

  /* set all messages to zero */
  for (node=0; node<(*graph).vnodenum; node++)
    for (socket=0; socket<vnodedegree; socket++)
      vnodeedge.message=0.0;
  for (node=0; node<(*graph).cnodenum; node++)
    for (socket=0; socket<cnodedegree; socket++)
      cnodeedge.message=0.0;
}


/**********************************
* make decisions on current graph *
**********************************/
void makedecisions(graphs *graph, int *decisions)   {
  int node, socket;
  double sum;

  for (node=0; node<(*graph).vnodenum; node++) {
    /* take sum over all inputs */
    sum=vnodevalue;
    for (socket=0; socket<vnodedegree; socket++)
      sum+=vnodeedge.message;

    /*            if (sum>0)
                   *(decisions+node)=1.0;
                else
                   *(decisions+node)=-1.0;*/
    if (sum>0)
      *(decisions+node)=0.0;
    else
      *(decisions+node)=1.0;
  }
}

/************************************
* sum vnode to f                    *
*                                   *
************************************/
void sumtograph(graphs *graph)
   {
   int node, socket;
   int tonode, tosocket;
   double sum, newmessage;

	/* loop over all nodes */
         for (node=0; node<(*graph).vnodenum; node++)
            {
            sum=0;
            /* take sum over all edges */
            for (socket=0; socket<vnodedegree; socket++)
               sum+=vnodeedge.message;

            /* bound the size of the messages */
            if (fabs(sum)>MAXMESSAGE)
               {
               if (sum>0)
                  newmessage=MAXMESSAGE;
               else
                  newmessage=-MAXMESSAGE;
               }
            else
               newmessage=sum;

            vnodevalue=newmessage;
            }
   }

/************************************
* message map at the variable nodes *
* send to other graph               *
*                                   *
************************************/
void graphtographmessagemap(graphs *graph, graphs *tograph, double *received, double *temp, double variance, int indic, double a1, double a2)
   {
   int node;
   double newmessage;
   double cst;  
   double prob1, prob2, prob3, prob4;

   cst=sqrt(1/(2*M_PI*variance));

   for (node=0; node<(*graph).vnodenum; node++)
      {
      prob1=cst*exp(-pow((*(received+node)-a1-a2),2)/(2*variance))*exp(vnodevalue);
      prob2=cst*exp(-pow((*(received+node)-a1+a2),2)/(2*variance));
      prob3=cst*exp(-pow((*(received+node)+a1-a2),2)/(2*variance))*exp(vnodevalue);
      prob4=cst*exp(-pow((*(received+node)+a1+a2),2)/(2*variance));

      newmessage=log((prob1+prob2)/(prob3+prob4));

      if (fabs(newmessage)>MAXMESSAGE)
               {
               if (newmessage>0)
                  newmessage=MAXMESSAGE;
               else
                  newmessage=-MAXMESSAGE;
               }

      if(indic)
         {
         tovnodevalue=newmessage;
         vnodevalue=*(temp+node);
         }
      else
         {
         *(temp+node)=newmessage;
         }
      }
   }

/************************************
* message map at the variable nodes *
* schedule can be used if we want   *
* the decoder to be time variant    *
* currently it is not used          *
************************************/
void variablemessagemap(graphs *graph)   {
  int node, socket;
  int tonode, tosocket;
  double sum, newmessage;

  for (node=0; node<(*graph).vnodenum; node++) {
    /* take sum over all inputs */
    sum=vnodevalue;
    for (socket=0; socket<vnodedegree; socket++)
      sum+=vnodeedge.message;

    /* now determine all the outgoing messages */
    for (socket=0; socket<vnodedegree; socket++) {
      tonode=vnodeedge.dest;
      tosocket=vnodeedge.socket;
      newmessage=(sum-vnodeedge.message);

      /* bound the size of the messages */
      if (fabs(newmessage)>MAXMESSAGE) {
        if (newmessage>0)
          cnodetoedge.message=EXPMAXMESSAGE;
        else
          cnodetoedge.message=EXPNEGMAXMESSAGE;
      } else
        cnodetoedge.message=exp(newmessage);
    }
  }
}

/*********************************
* message map at the check nodes *
*********************************/
void checkmessagemap(graphs *graph)
   {
   int node, socket;
   int tonode, tosocket;
   int unreliable, erasurenum, pos, flag=1;
   double prod, rel1, rel2, mes, mesrel, messign;
   double shift;

   /* loop over all nodes */
   for (node=0; node<(*graph).cnodenum; node++)
      {
      /* combine all non-erasure inputs */
      prod=EXPMAXMESSAGE;
      for (socket=0; socket<cnodedegree; socket++)
         {
         prod=(1.0+prod*cnodeedge.message)/(prod+cnodeedge.message);
         }
	  
      /* now determine all outgoing messages */
      for (socket=0; socket<cnodedegree; socket++)
         {
         tonode=cnodeedge.dest;
         tosocket=cnodeedge.socket;
         vnodetoedge.message=log((1.0-prod*cnodeedge.message)/(prod-cnodeedge.message));
      /* check overflow */
         if (fabs(vnodetoedge.message)>MAXMESSAGE)
            if (vnodetoedge.message>0)
               vnodetoedge.message=MAXMESSAGE;
            else
               vnodetoedge.message=-MAXMESSAGE;
         }
      }  
   }
/* /\********************************* */
/* * message map at the check nodes * */
/* *********************************\/ */
/* void checkmessagemap(graphs *graph)   { */
/*   int node, socket; */
/*   int tonode, tosocket; */
/*   int erasurenum; */
/*   //   int unreliable, pos; */
/*   double prod, x; */
/*   //   double shift, rel1, rel2, mes, mesrel, messign; */

/*   for (node=0; node<(*graph).cnodenum; node++) { */
/*     /\* combine all non-erasure inputs *\/ */
/*     prod=EXPMAXMESSAGE; */
/*     erasurenum=0; */
/*     for (socket=0; socket<cnodedegree; socket++) { */
/*       if (cnodeedge.message!=1.0) */
/*         prod=(1.0+prod*cnodeedge.message)/(prod+cnodeedge.message); */
/*       else */
/*         erasurenum++; */
/*     } */

/*     switch (erasurenum) { */
/*     case 0: */
/*       /\* now determine all outgoing messages *\/ */
/*       for (socket=0; socket<cnodedegree; socket++) { */
/*         tonode=cnodeedge.dest; */
/*         tosocket=cnodeedge.socket; */
/*         if ( prod - cnodeedge.message != 0 ) { */
/*           x = (1.0-prod*cnodeedge.message)/(prod-cnodeedge.message); */
/*           if ( x > 0 ) { */
/*             vnodetoedge.message=log((1.0-prod*cnodeedge.message)/(prod-cnodeedge.message)); */

/*           } else { */
/*             PR_DBG( 2, "x <= 0!\n" ); */
/*           } */
/*         } else { */
/*           PR_DBG( 2, "prod - cnodeedge.message == 0!\n" ); */
/*         } */

/*         /\* check overflow *\/ */
/*         if (fabs(vnodetoedge.message)>20.0) { */
/*           if (vnodetoedge.message>0) */
/*             vnodetoedge.message=20.0; */
/*           else */
/*             vnodetoedge.message=-20.0; */
/*         } */
/*       } */
/*       break; */
/*     case 1: */
/*       /\* if there is exactly on erasure input then *\/ */
/*       /\* then all but one output is an erasure     *\/ */
/*       for (socket=0; socket<cnodedegree; socket++) { */
/*         tonode=cnodeedge.dest; */
/*         tosocket=cnodeedge.socket; */

/*         if (cnodeedge.message!=1.0) */
/*           vnodetoedge.message=0.0; */
/*         else { */
/*           if ( prod > 0 ) { */
/*             vnodetoedge.message=log(prod); */
/*           } else { */
/*             PR_DBG( 2, "prod <= 0!\n" ); */
/*           } */

/*           /\* check overflow *\/ */
/*           if (fabs(vnodetoedge.message)>20.0) { */
/*             if (vnodetoedge.message>0) */
/*               vnodetoedge.message=20.0; */
/*             else */
/*               vnodetoedge.message=-20.0; */
/*           } */
/*         } */
/*       } */
/*       break; */
/*     default: */
/*       /\* if we have two or more erasure inputs *\/ */
/*       /\* then all outputs are erasures         *\/ */
/*       for (socket=0; socket<cnodedegree; socket++) { */
/*         tonode=cnodeedge.dest; */
/*         tosocket=cnodeedge.socket; */
/*         vnodetoedge.message=0.0; */
/*       } */
/*       break; */
/*     } */
/*   } */
/*}*/