bit vector in c

// bitmap.h - header file for basic bitmap manipulation types and functions

#ifndef ___BITMAP_H___
#define ___BITMAP_H___

typedef enum {CLEAR = 0, SET = 1} BIT;
typedef unsigned int BITMAP;
#define MAXBITS 32

BIT testbit(BITMAP* map, int index);
void setbit(BITMAP* map, int index);
void clearbit(BITMAP* map, int index); 

#endif

// bitmap.c - basic bitmap functions
// based on code from _Programming Pearls_, 2nd Ed. by Jon Bentley

#include "bitmap.h"
#define SHIFT 5
#define MASK 0x1F

BIT testbit(BITMAP* map, int index)
{
    return (BIT) (map[index >> SHIFT] & (1 << (index & MASK)));
}

void setbit(BITMAP* map, int index)
{
    map[index >> SHIFT] |= (1 << (index & MASK));
}

void clearbit(BITMAP* map, int index)
{
    map[index >> SHIFT] &= ~(1 << (index & MASK));
}

// convolution.c

#include <stdio.h>

int main(){

  // input vectors
  int A[5]={1,2,3,4,5};
  int B[5]={3,2,1,0,1};

  // working matrix 
  int C[20][20]={0};

  //result
  int R[20]={0};

  int k,i;

  //populate the working matrix
  for( k = 0; k < 5; k++)
    for( i = 0; i < 5; i++)
      C[i+k][k] = A[i] * B[k];

  //save in R
  for(k = 0; k < 19; k++)
    for(i = 0; i < 19; i++)
      R[k] += C[k][i];  

/*
   3  6  9   12   15                   B[0]*A[]
      2  4   6    8   10               B[1]*A[]
         1   2    3   4   5            B[2]*A[]
             0    0   0   0  0         B[3]*A[]
                  1   2   3  4   5     B[4]*A[]
   --------------------------------    ++++++++
   3  8  14  20   27  16  8  4   5     R[]
*/

  //send output to screen
  for(i = 0; i <= 5+5-2; i++)
    printf("%i ",R[i]);

  printf("\n");

  return 0;
}

/*
this program demonstrates the workings of a convolutional 
encoder with K=3 (2,1)

this is an example taken from "Digital Communications" 
ISBN 0-13-091722-2 page 387. There are n = 2 modulo-2 (XOR gate)
 adders; thus the code rate is k/n = 1/2.

                   -----------
                  |           |
       top XOR   (+)          o u1
                -----        
               |  |  |       
 INPUT 101--> [0][0][0]   o----x(flips up and down)---> OUTPUT    
               |     |
                -----
    bottom XOR   (+)          o u2
                  |           |
                   ----------- 

*/

int main(){

  /* 
     our intended input is 101, which translates into 5 decimal. 
     however, the 3 bit register initially contains [0][0][0]. 
     so our input will be 101000 instead of 101 because the last three
     bits will be represent our working register.
     101000 will be shifted to the right as time advances and we 
     will be checking the least significant three bits.
     we start with 101000 = 8+32 = 40 decimal
  */
 
  unsigned int input = 40;        // 101000

  // we create three masks to isolate each of the three last bits of our register.

  unsigned int m0 = 1;            // ...0000001 = 1 decimal
  unsigned int m1 = 2;            // ...0000010 = 2 decimal
  unsigned int m2 = 4;            // ...0000100 = 4 decimal

  // we declare an array that will store the value of the working register.
  
  unsigned int regi[3]={0,0,0};

  // we declare an array to store the output (20 is plenty for this example). 

  unsigned int output[20] = {0};

  // we start the encoder by shifting the input to the right -> 101[0][0][0]
  // if we shift 1 bit to the right the register looks like  10 ---->[1][0][0]

  input = input >> 1;

  // we take a reading into the register

  regi[0] = (input & m0)?1:0;
  regi[1] = (input & m1)?1:0;
  regi[2] = (input & m2)?1:0;

  //now we apply the top XOR gate (all three inputs)

  output[0] = regi[0] ^ regi[1] ^ regi[2];   // 1 ^ 0 ^ 0 = 1

  //we should now apply the bottom XOR gate (from the diagram, bits 0 and 2)

  output[1] = regi[0] ^ regi[2];

  /*
    since the rest looks all the same (repetitive), we do a for loop 
    so the computer does all the work for us at least 18 more times  ;)
  */

  int i;
  for(i = 2; i < 20; i += 2){
  input = input >> 1;
  regi[0] = (input & m0)?1:0;
  regi[1] = (input & m1)?1:0;
  regi[2] = (input & m2)?1:0;
  output[i] = regi[0] ^ regi[1] ^ regi[2];
  output[i+1] = regi[0] ^ regi[2]; 
  }

  // we send the output to the screen
  for(i = 0; i <20; i++)
    printf("%u ",output[i]);

  printf("/n");

  return 0;
}