hamming.cpp

Go to the documentation of this file.

#ifndef HAMMING_IMPLEMENTATION_FILE
#define HAMMING_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : hamming network                                                   *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1992-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

static const char *NAME = "hamming";

#include "hamming.h"

#include <basis/guards.h>

#include <ctype.h>
#include <stdlib.h>
#include <string.h>

// the bit on/off represent binary information.
#define BIT_ON   1
#define BIT_OFF -1

hamming::hamming()
{
}

hamming::~hamming()
{
}

void hamming::corrupter(int ex[], int faults)
{
  int fault_location;
  bit_pattern flip_record;   // keeps track of bits already flipped.

  if (faults > N)
    non_continuable_error(NAME, "corrupter", "more faults than bits");

  for (int j = 0; j < N; j++) flip_record[j] = false;
  for (int i = 0; i < faults; i++) {
    do
      fault_location = randomizer.inclusive(0, N-1);
    while (flip_record[fault_location]);
    flip_record[fault_location] = true;
    ex[fault_location] = -ex[fault_location];
  }
}

void hamming::init_lower_subnet(int faults)
{
  if (faults > N * M)
    non_continuable_error(NAME, "init_lower_subnet", "more faults than weights");

  // corruption is the list of weights that are incorrect
  int corruption [MAXIMUM_BITS_IN_PATTERN] [MAXIMUM_EXEMPLARS];

  int m;
  int n;
  for (n = 0; n < N; n++)
    for (m = 0; m < M; m++)
      corruption [n] [m] = false;  // clear all corruptions

  for (int pos = 0; pos < faults; pos++) {
    do {
      n = randomizer.inclusive(0, N-1);
      m = randomizer.inclusive(0, M-1);
    } while (corruption [n] [m]);
    corruption [n] [m] = true;
  }

  for (int i = 0; i < N; i++)
    for (int j = 0; j < M; j++) {
      w [i] [j] = exemplars [j] [i] / 2.0;
      if (corruption [i] [j]) {
        w [i] [j] = ((double)randomizer.inclusive
            (0, 30000) / 30000.0) - 0.5;
        // a value from 0 to 30000, divided by 30000, is from 0 to 1.
        // then subtracting 1/2 gives us a value in the right weight range.
      }
    }
}

void hamming::init_upper_subnet(int faults)
{
  if (faults > M * M)
    non_continuable_error(NAME, "init_upper_subnet", "more faults than Maxnet connections");

  // the list of weights incorrect in maxnet
  int corruption [MAXIMUM_BITS_IN_PATTERN] [MAXIMUM_EXEMPLARS];

  int m1, m2;
  for (m1 = 0; m1 < M; m1++)
    for (m2 = 0; m2 < M; m2++)
      corruption [m1] [m2] = false;  // clear all corruptions

  for (int pos = 0; pos < faults; pos++) {
    do {
      m1 = randomizer.inclusive(0, M-1);
      m2 = randomizer.inclusive(0, M-1);
    } while (corruption [m1] [m2]);
    corruption [m1] [m2] = true;
  }

  for (int k = 0; k < M; k++)
    for (int l = 0; l < M; l++) {
      if (!corruption [k] [l]) {
        if (k == l) maxnet [k] [l] = 1.0;
        else maxnet [k] [l] = -EPSILON;
      } else {
        w [k] [l] = ((double)randomizer.inclusive
                     (0, 30000) / 15000.0) - 1.0;
        // a value from 0 to 30000, divided by 15000, is from 0 to 2.
        // then subtracting 1 gives us a value in the right range.
      }
    }
}

double hamming::weighted_sum(int j)
{
  double sum = 0;
  for (int i = 0; i < N; i++)
    sum = sum + (w [i] [j] * (double)x[i]);
  return sum;
}

double hamming::corrupted_sum()
{
  return -(double)N * ((double)randomizer.inclusive(0, 30000) / 60000.0);
    // range is from N over 2 to -N over 2.
}

double hamming::f_thresh(double alpha)
{
  if (alpha <= 0.0) return 0.0;
  else return alpha;
}

void hamming::init_with_unknown_pattern(int faults)
{
  int corruption[MAXIMUM_EXEMPLARS];
  int fault_location;

  if (faults > M)
    non_continuable_error(NAME, "init_with_unknown_pattern", "more faults than exemplars");

  t = 0;  // set clock to starting time

  for (int l = 0; l < M; l++) corruption[l] = false;
  for (int i = 0; i < faults; i++) {
    do
      fault_location = randomizer.inclusive(0, M-1);
    while (corruption[fault_location]);
    corruption[fault_location] = true;
  }

  for (int j = 0; j < M; j++) {
    if (!corruption[j])
      mu [t] [j] = f_thresh(weighted_sum(j) - THETA);
    else
      mu [t] [j] = f_thresh(corrupted_sum() - THETA);
  }
}

double hamming::maxnet_output_sum(int j)
{
  double sum = 0.0;
  int k;
  for (k = 0; k < j; k++) sum += mu [t] [k];
  for (k = j+1; k < M; k++) sum += mu [t] [k];
  return sum;
}

void hamming::converge()
{
  for (int j = 0; j < M; j++)
    mu [t+1] [j] = f_thresh( mu [t] [j] - EPSILON * maxnet_output_sum(j) );
  t++;  // time marches on....
}

int hamming::only_one_positive_output_left()
{
  int standing = -1;
  for (int i = 0; i < M; i++) {
    if ( (mu [t] [i] > 0.0) && (standing < 0) )
      // no output was standing previously, so this is current hope.
      standing = i;
    else if (mu [t] [i] > 0.0)
      // a value was already standing, so return a failure.
      return -1;
  }
  if (standing == -1)
    non_continuable_error(NAME, "only_one_positive_output_left", "no positive outputs are left at all");
  return standing;   // the winner.
}

int hamming::iterate_until_convergence()
{
  int converged = false;
  int answer;

  while (!converged) {
    converge();
    answer = only_one_positive_output_left();
    if (answer >= 0) converged = true;
    else if (t >= MAXIMUM_ITERATION)
      return -1;
  }
  return answer;
}

void hamming::show_pattern_line(int ex[], int line)
{
  for (int i = line * cols; i < line * cols + cols; i++) {
    if (ex[i] == BIT_OFF) { printf("."); fflush(stdout); }
    else { printf("*"); fflush(stdout); }
  }
}

void hamming::show_pattern_line(int ex[], int line, FILE *print_to)
{
  for (int i = line * cols; i < line * cols + cols; i++) {
    if (ex[i] == BIT_OFF) fprintf(print_to, ".");
    else fprintf(print_to, "*");
  }
}

void hamming::dump_pattern(int ex[])
{
  for (int i = 0; i < rows; i++) {
    show_pattern_line(ex, i);
    printf("\n");
  }
}

void hamming::show_exemplars()
{
  int exemplars_that_fit = SCREEN_WIDTH / (cols + 2);
  for (int i = 0; i < M; i += exemplars_that_fit) {
    // looping over the set of exemplars
    for (int k = 0; k < rows; k++) {
      // looping over each row of the current set
      for (int j = i; j < i + exemplars_that_fit; j++) {
        // looping over each exemplar's current row
        if (j < M) {
          show_pattern_line(exemplars[j], k);
          printf("  "); fflush(stdout);
        }
      }
      printf("\n");
    }
    printf("\n");
  }
}

void hamming::get_sample()
{
  char temp[MAXIMUM_BITS_IN_PATTERN];
  printf("Please enter a %d x %d sample for the hamming net.\n",
      rows, cols);
  printf("Use \"*\" to turn a bit on and \".\" to turn a bit off.\n");
  for (int i = 0; i < rows; i++) {
    printf("Enter pattern for row %d:", i + 1); fflush(stdout);
    fgets(temp, MAXIMUM_BITS_IN_PATTERN - 2, stdin);
    for (int j = 0; j < cols; j++)
      if (temp[j] == '*') x[ cols*i + j] = BIT_ON;
      else x[ cols*i + j] = BIT_OFF;
  }
}

void hamming::save_sample()
{
  int status;
  FILE *fp;
  char save[20];

  printf("\nWould you like to save your example? (Y/N): ");
  fflush(stdout);
  fgets(save, 18, stdin);
  if (save[0] == 'Y' || save[0] == 'y') {
    printf("\nEnter filename for saving: "); fflush(stdout);
    scanf("%s", save);
    fp = fopen(save, "w");
    if (fp) {
      for (int i = 0; i < rows * cols; i++) {
        status = fprintf(fp, "%d%c", x[i], ' ');
        if (status < 1)
          non_continuable_error(NAME, "save_sample", "bad write");
      }
      fclose(fp);
    } else
      printf("\nCould not open file %s\n", save);
  }
}

void hamming::read_file(char *filename, int pattern[])
{
  int status;
  FILE *fp;

  fp = fopen(filename, "r");
  if (!fp) {
    char error_msg[50];
    strcpy(error_msg, "could not open file '");
    strcat(error_msg, filename);
    strcat(error_msg, "'");
    non_continuable_error(NAME, "read_file", error_msg);
  } else {
     for (int i = 0; i < rows * cols; i++) {
       status = fscanf(fp, "%d", &pattern[i]);
       if (status != 1)
         non_continuable_error(NAME, "read_file", "read failed");
     }
     fclose (fp);
  }
}

void hamming::copy_pattern(bit_pattern destination, bit_pattern source)
{
  for (int i = 0; i < N; i++) destination[i] = source[i];
}

void hamming::get_defaults()
{
  FILE *defaults_file = fopen(DEFAULTS_FILE_NAME, "r");

  if (defaults_file == NIL)
    non_continuable_error(NAME, "get_defaults", "missing defaults file");

  fscanf(defaults_file, "%d\n", &M);     // first is number of patterns
  fscanf(defaults_file, "%d\n", &rows);  // second is number of rows
  fscanf(defaults_file, "%d\n", &cols);  // third is number of columns
  fclose(defaults_file);

  if (M > MAXIMUM_EXEMPLARS)
    non_continuable_error(NAME, "get_defaults", "too many exemplars");

  N = rows * cols;                       // bits per exemplar
  if (N > MAXIMUM_BITS_IN_PATTERN)
    non_continuable_error(NAME, "get_defaults", "too many bits in pattern size");

  EPSILON = 1.0 / (double)(M+2);
  THETA   = - (double)N / 2.0;
}

void hamming::get_exemplars()
{
  char filename[90];

  strcpy(filename, EXEMPLAR_PREFIX);
  int posn = int(strlen(filename));
  strcat(filename, "00.dat");  // add suffix for first

  for (int i = 0; i < M; i++) {
    // fix filename up to get current exemplar
    filename[posn] = (char)( (int)'0' + i / 10);
    filename[posn+1] = (char)( (int)'0' + i % 10);
    // read file name into the exemplar storage
    read_file(filename, exemplars[i]);
  }
}

int hamming::current_time()
{
  return t;
}

int hamming::pattern_rows()
{
  return rows;
}

int hamming::pattern_cols()
{
  return cols;
}

void hamming::show_pattern_line(int exemplar_number, int line, FILE *print_to)
{
  show_pattern_line(exemplars[exemplar_number], line, print_to);
}

#endif //HAMMING_IMPLEMENTATION_FILE

---