// truc.cpp : Defines the entry point for the console application.
//

#include "CAssocMem.h"
#include "stdafx.h"
#include <iostream.h>
#include <conio.h>

void myprint(int* tmp)
{
	unsigned long cpt;
	for (cpt = 0; cpt<64; cpt++)
	{
		if ((cpt % 8) == 0) cout << endl;
		if (tmp[cpt] == 0) cout << ' ';
		else cout << '*';

	}
	cout << endl;
}

int main(int argc, char* argv[])
{
	int * set[2];
	int pattern1[64] = {0,0,0,0,0,0,0,0,
		                0,1,1,1,1,1,1,0,
						0,1,0,0,0,0,1,0,
						0,1,0,0,0,0,1,0,
						0,1,0,0,0,0,1,0,
						0,1,0,0,0,0,1,0,
						0,1,1,1,1,1,1,0,
						0,0,0,0,0,0,0,0};

	int pattern2[64] = {1,0,0,0,0,0,0,1,
		                0,1,0,0,0,0,1,0,
						0,0,1,0,0,1,0,0,
						0,0,0,1,1,0,0,0,
						0,0,0,1,1,0,0,0,
						0,0,1,0,0,1,0,0,
						0,1,0,0,0,0,1,0,
						1,0,0,0,0,0,0,1};

	set[0] = pattern1;
	set[1] = pattern2;

	CAssocmem truc(64);

	truc.Train(set, 2);

	cout << "Recognizing:\n";
	myprint(set[0]);
		cout << "\n and \n";
		myprint(set[1]);

	cout << "\nPress a key...\n" << endl;
	getch();
		int berk[64] = {1,0,0,1,0,0,0,1,
		                0,1,0,0,0,0,1,0,
						1,1,1,0,0,1,0,1,
						0,0,0,1,1,0,1,0,
						0,0,0,1,1,0,0,0,
						1,0,1,0,0,1,0,0,
						0,1,0,0,0,0,1,0,
						1,0,0,0,1,0,0,1};

		int berk2[64] = {0,0,1,0,1,0,1,0,
		                0,1,1,1,1,1,1,1,
						1,1,0,0,0,0,1,1,
						1,1,0,0,1,0,1,1,
						1,1,0,0,0,0,1,0,
						0,1,0,1,0,0,1,0,
						1,1,1,1,1,1,1,1,
						0,0,1,0,1,0,1,0};

		cout << "Oh, my God, an ugly evil pattern...\n";
		myprint(berk);
		cout << "\nThere it goes, in fact it is a...\n";

		truc.Run(berk);
		myprint(truc.Get_Outputs());
	cout << "\nPress a key...\n" << endl;
	getch();

		cout << "Oh, my God, yet another ugly evil pattern\n";
		myprint(berk2);
		cout << "\nAH! recognized you...\n";

		truc.Run(berk2);
		myprint(truc.Get_Outputs());

		cout << "Hooray for the associative memory\nContact me: Atma samchan@club-internet.fr\n";
        cout << "Heavily inspired by the tuts at www.generation5.org\n";
		return 0;
}

 

/*****************************************/
/*  Header Hopfield pattern learner      */
/*****************************************/

#ifndef CLASS_CASSOCMEM_ATMA
#define CLASS_CASSOCMEM_ATMA

/*****************************************/

#include <stdlib.h>
#include <iostream.h>
#include <time.h>

/*****************************************/

#define LEARNING_RATE   (float)0.5

/*****************************************/

#ifndef ULONG
typedef unsigned long ULONG;
#endif

/*****************************************/

#define _go_binary(x)  ((x == -1) ? 0 : 1)
#define _go_bipolar(x) ((x) ? 1 : -1)

/*****************************************/

/*-----------------------------------------------------------------------*\
    Namespace: Atma, finally not :)
\*-----------------------------------------------------------------------*/

/*namespace Atma
{*/

class CAssocmem
{
    public:
    
        /*Constructors and destructor*/
    
        CAssocmem();
        CAssocmem(ULONG size);
        ~CAssocmem();
        
        /*Training function*/
        
        void Train(int** input, ULONG nb_patterns);
        
        void Run(int* input);
        
        int* Get_Outputs();
        
    private:

        void Process_Net();
        
        bool Process_Neuron(ULONG number);

        void Set_Treshold();
        
        ULONG   nb_neurons;
        
        int**   weights;
        int*    treshold;
        int*    outputs;
        
};        

/*-----------------------------------------------------------------------*\
    End of namespace
\*-----------------------------------------------------------------------*/

//}
/*****************************************/

#endif

/*****************************************/
/*                 EOF                   */
/*****************************************/
        
 

// stdafx.cpp : source file that includes just the standard includes
//	truc.pch will be the pre-compiled header
//	stdafx.obj will contain the pre-compiled type information

#include "stdafx.h"

// TODO: reference any additional headers you need in STDAFX.H
// and not in this file
 

// stdafx.h : include file for standard system include files,
//  or project specific include files that are used frequently, but
//      are changed infrequently
//

#if !defined(AFX_STDAFX_H__9B66AE34_4762_11D4_9F0D_00508B62A795__INCLUDED_)
#define AFX_STDAFX_H__9B66AE34_4762_11D4_9F0D_00508B62A795__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#define WIN32_LEAN_AND_MEAN		// Exclude rarely-used stuff from Windows headers

#include <stdio.h>

// TODO: reference additional headers your program requires here

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_STDAFX_H__9B66AE34_4762_11D4_9F0D_00508B62A795__INCLUDED_)
 

/*****************************************/
/*  Class Hopfield pattern learner       */
/*****************************************/

#include "CAssocmem.h"

/*****************************************/

/*-----------------------------------------------------------------------*\
    using namespace: ...
\*-----------------------------------------------------------------------*/

//using namespace Atma;
// NOT :)

// A lil' comment: this is an old version of the stuff: one should use exceptions and automatic stack unwinding
// for the class ( see www.relisoft.com -> tuts for info on automatic stack unwinding)

CAssocmem::CAssocmem()
{
    srand(time(NULL));
    
    weights     =NULL;
    treshold    =NULL;
    outputs     =NULL;
    nb_neurons  =NULL;
}

CAssocmem::CAssocmem(ULONG size)
{
    ULONG cpt;
    ULONG tmp;
    
    srand(time(NULL));
    
    nb_neurons  =size;
    treshold    =new int[size];
    
    if (treshold==NULL)
    {
        cerr << "Error allocating memory" << endl;
        nb_neurons  =0;
        weights     =NULL;
        outputs     =NULL;
        return;
    }
    
    outputs     =new int[size];
    
    if (outputs==NULL)
    {
        cerr << "Error allocating memory" << endl;
        nb_neurons  =0;
        weights     =NULL;
        delete[] treshold;
        treshold    =NULL;
        return;
    }

    weights     =new int*[size];
    
    if (weights==NULL)
    {
        cerr << "Error allocating memory" << endl;
        nb_neurons  =0;
        delete[] treshold;
        treshold    =NULL;
        delete[]  outputs;
        outputs     =NULL;
        return;
    }        

    for (cpt=0; cpt<size; cpt++)
    {
        weights[cpt]=new int[size];
        
        if (weights[cpt]==NULL)
        {
            cerr << "Error allocating memory" << endl;
            nb_neurons  =0;
            delete[] treshold;
            treshold    =NULL;
            delete[]  outputs;
            outputs     =NULL;
            for (tmp=0; tmp<cpt; tmp++)
            {
                delete[] weights[tmp];
            }
            delete[] weights;
            weights     =NULL;
            return;
        }
    }
    
    Set_Treshold();
}

CAssocmem::~CAssocmem()
{
    ULONG cpt;
    
    if (treshold!=NULL) /*We need to test just one, cause if one is, the others are too*/
    {
        delete[] treshold;
        delete[] outputs;
        for (cpt=0; cpt<nb_neurons; cpt++)
        {
            delete[] weights[cpt];
        }
        delete[] weights;
        
        treshold=NULL;
        outputs =NULL;
        weights =NULL;
        nb_neurons=0;
    }
}

/*****************************************/

void CAssocmem::Train(int** input, ULONG nb_patterns)
{
    ULONG cpt1;
    ULONG cpt2;
    ULONG nb;
    
    int cur_weight;
    
    for(cpt1=0; cpt1<nb_neurons; cpt1++)
    {
		for (cpt2=0; cpt2<nb_neurons; cpt2++)
		{
			cur_weight=0;

			if (cpt1 != cpt2)
			{
				for (nb=0; nb<nb_patterns; nb++)
				{
					cur_weight += _go_bipolar(input[nb][cpt1]) * _go_bipolar(input[nb][cpt2]);
				}
			}

			weights[cpt1][cpt2] = cur_weight;
		}
	}
}

/*****************************************/

void CAssocmem::Set_Treshold()
{
    ULONG cpt;
    
    if (treshold!=NULL)
    {
        for (cpt=0; cpt<nb_neurons; cpt++)
        {
            treshold[cpt]=0;
        }
    }
}

/*****************************************/

void CAssocmem::Process_Net()
{
    ULONG chosen_neuron;
    ULONG current;
    ULONG last;
    
    current =0;
    last    =0;
    
    do
    {
        current++;
        chosen_neuron=rand()%nb_neurons;
        
        if (Process_Neuron(chosen_neuron)==true)
        {
            last=current;
        }
    } while (current-last < 10*nb_neurons);
}

/*****************************************/

bool CAssocmem::Process_Neuron(ULONG number)
{
    ULONG cpt;
    int sum;
    int   result;
    bool is_changed;
    
    sum=0;
    is_changed=false;
    
    for (cpt=0; cpt<nb_neurons; cpt++)
    {
        sum+=weights[number][cpt]*outputs[cpt];
    }
    
    if (sum!=treshold[number])
    {
        if (sum>treshold[number]) result=1;
        else result=-1;
        
        if (result!=outputs[number])
        {
            is_changed=true;
            outputs[number]=result;
        }
    }
    
    return is_changed;
}

/*****************************************/

int* CAssocmem::Get_Outputs()
{
    ULONG cpt;
    for (cpt=0; cpt<nb_neurons; cpt++)
	{
        outputs[cpt]=_go_binary(outputs[cpt]);
	}
    return outputs;
}

/*****************************************/

void CAssocmem::Run(int* input)
{
    ULONG cpt;
    
    for (cpt=0; cpt<nb_neurons; cpt++)
    {
        outputs[cpt]=_go_bipolar(input[cpt]);
    }
	Process_Net();
}

/*****************************************/
/*                 EOF                   */
/*****************************************/