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;
  }
}

/************************************
* 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 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;
    }
  }
}