我来我网
https://5come5.cn
 
您尚未 登录  注册 | 菠菜 | 软件站 | 音乐站 | 邮箱1 | 邮箱2 | 风格选择 | 更多 » 
 

本页主题: 一个具有很好编程风格的代码 显示签名 | 打印 | 加为IE收藏 | 收藏主题 | 上一主题 | 下一主题

jianghejie





性别: 帅哥 状态: 该用户目前不在线
等级: 初出茅庐
发贴: 13
威望: 0
浮云: 1048
在线等级:
注册时间: 2010-09-28
最后登陆: 2011-12-18

5come5帮你背单词 [ airline /'/əlain/ n. (飞机的)航线,航空公司 ]


一个具有很好编程风格的代码

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



                      ===========================

        Network:      Adaptive Resonance Theory 1

                      ===========================



        Application:  Brain Modeling

                      Stability-Plasticity Demonstration



        Author:      Karsten Kutza

        Date:        27.6.96



        Reference:    G.A. Carpenter, S. Grossberg

                      A Massively Parallel Architecture

                      for a Self-Organizing Neural Pattern Recognition Machine

                      Computer Vision, Graphics, and Image Processing, 37,

                      pp. 54-115, 1987



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









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

                            D E C L A R A T I O N S

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





#include <stdlib.h>

#include <stdio.h>

#include <math.h>





typedef int          BOOL;

typedef char          CHAR;

typedef int          INT;

typedef double        REAL;



#define FALSE        0

#define TRUE          1

#define NOT          !

#define AND          &&

#define OR            ||



#define MIN_REAL      -HUGE_VAL

#define MAX_REAL      +HUGE_VAL





typedef struct {                    /* A LAYER OF A NET:                    */

        INT          Units;        /* - number of units in this layer      */

        BOOL*        Output;        /* - output of ith unit                  */

        REAL**        Weight;        /* - connection weights to ith unit      */

        BOOL*        Inhibited;    /* - inhibition status of ith F2 unit    */

} LAYER;



typedef struct {                    /* A NET:                                */

        LAYER*        F1;            /* - F1 layer                            */

        LAYER*        F2;            /* - F2 layer                            */

        INT          Winner;        /* - last winner in F2 layer            */

        REAL          A1;            /* - A parameter for F1 layer            */

        REAL          B1;            /* - B parameter for F1 layer            */

        REAL          C1;            /* - C parameter for F1 layer            */

        REAL          D1;            /* - D parameter for F1 layer            */

        REAL          L;            /* - L parameter for net                */

        REAL          Rho;          /* - vigilance parameter                */

} NET;





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

              A P P L I C A T I O N - S P E C I F I C  C O D E

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





#define N            10

#define M            10



#define NO_WINNER    M



#define NUM_DATA      30



CHAR                  Pattern[NUM_DATA][N] = { "  O ",

                                              "  O O",

                                              "    O",

                                              "  O O",

                                              "    O",

                                              "  O O",

                                              "    O",

                                              " OO O",

                                              " OO  ",

                                              " OO O",

                                              " OO  ",

                                              "OOO  ",

                                              "OO  ",

                                              "O    ",

                                              "OO  ",

                                              "OOO  ",

                                              "OOOO ",

                                              "OOOOO",

                                              "O    ",

                                              " O  ",

                                              "  O  ",

                                              "  O ",

                                              "    O",

                                              "  O O",

                                              " OO O",

                                              " OO  ",

                                              "OOO  ",

                                              "OO  ",

                                              "OOOO ",

                                              "OOOOO"  };



BOOL                  Input [NUM_DATA][N];

BOOL                  Output[NUM_DATA][M];



FILE*                f;





void InitializeApplication(NET* Net)

{

  INT n,i,j;



  for (n=0; n<NUM_DATA; n++) {

    for (i=0; i<N; i++) {

      Input[n] = (Pattern[n] == 'O');

    }

  }

  Net->A1  = 1;

  Net->B1  = 1.5;

  Net->C1  = 5;

  Net->D1  = 0.9;

  Net->L  = 3;

  Net->Rho = 0.9;

  for (i=0; i<Net->F1->Units; i++) {

    for (j=0; j<Net->F2->Units; j++) {

      Net->F1->Weight[j] = (Net->B1 - 1) / Net->D1 + 0.2;

      Net->F2->Weight[j] = Net->L / (Net->L - 1 + N) - 0.1;

    }

  }

  f = fopen("c:\ART1.txt", "w");

}





void WriteInput(NET* Net, BOOL* Input)

{

  INT i;

 

  for (i=0; i<N; i++) {

    fprintf(f, "%c", (Input) ? 'O' : ' ');

  }

  fprintf(f, " -> ");

}





void WriteOutput(NET* Net, BOOL* Output)

{

  if (Net->Winner != NO_WINNER)

    fprintf(f, "Class %i\n", Net->Winner);

  else

    fprintf(f, "new Input and all Classes exhausted\n");

}





void FinalizeApplication(NET* Net)

{

  fclose(f);

}





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

                          I N I T I A L I Z A T I O N

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





void GenerateNetwork(NET* Net)

{

  INT i;



  Net->F1 = (LAYER*) malloc(sizeof(LAYER));

  Net->F2 = (LAYER*) malloc(sizeof(LAYER));

     

  Net->F1->Units    = N;

  Net->F1->Output    = (BOOL*)  calloc(N, sizeof(BOOL));

  Net->F1->Weight    = (REAL**) calloc(N, sizeof(REAL*));



  Net->F2->Units    = M;

  Net->F2->Output    = (BOOL*)  calloc(M, sizeof(BOOL));

  Net->F2->Weight    = (REAL**) calloc(M, sizeof(REAL*));

  Net->F2->Inhibited = (BOOL*)  calloc(M, sizeof(BOOL));



  for (i=0; i<N; i++) {

    Net->F1->Weight = (REAL*) calloc(M, sizeof(REAL));

  }

  for (i=0; i<M; i++) {

    Net->F2->Weight = (REAL*) calloc(N, sizeof(REAL));

  }

}





void SetInput(NET* Net, BOOL* Input)

{

  INT  i;

  REAL Activation;

 

  for (i=0; i<Net->F1->Units; i++) {

    Activation = Input / (1 + Net->A1 * (Input + Net->B1) + Net->C1);

    Net->F1->Output = (Activation > 0);

  }

}





void GetOutput(NET* Net, BOOL* Output)

{

  INT i;

 

  for (i=0; i<Net->F2->Units; i++) {

    Output = Net->F2->Output;

  }

}





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

                    P R O P A G A T I N G  S I G N A L S

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





void PropagateToF2(NET* Net)

{

  INT  i,j;

  REAL Sum, MaxOut;

 

  MaxOut = MIN_REAL;

  Net->Winner = NO_WINNER;

  for (i=0; i<Net->F2->Units; i++) {

    if (NOT Net->F2->Inhibited) {

      Sum = 0;

      for (j=0; j<Net->F1->Units; j++) {

        Sum += Net->F2->Weight[j] * Net->F1->Output[j];

      }

      if (Sum > MaxOut) {

        MaxOut = Sum;

        Net->Winner = i;

      }

    }

    Net->F2->Output = FALSE;

  }

  if (Net->Winner != NO_WINNER)

    Net->F2->Output[Net->Winner] = TRUE;

}





void PropagateToF1(NET* Net, BOOL* Input)

{

  INT  i;

  REAL Sum, Activation;

 

  for (i=0; i<Net->F1->Units; i++) {

    Sum = Net->F1->Weight[Net->Winner] * Net->F2->Output[Net->Winner];

    Activation = (Input + Net->D1 * Sum - Net->B1) /

                (1 + Net->A1 * (Input + Net->D1 * Sum) + Net->C1);

    Net->F1->Output = (Activation > 0);

  }

}





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

                        A D J U S T I N G  W E I G H T S

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





REAL Magnitude(NET* Net, BOOL* Input)

{

  INT  i;

  REAL Magnitude;



  Magnitude = 0;

  for (i=0; i<Net->F1->Units; i++) {

    Magnitude += Input;

  }

  return Magnitude;

}





void AdjustWeights(NET* Net)

{

  INT  i;

  REAL MagnitudeInput_;



  for (i=0; i<Net->F1->Units; i++) {

    if (Net->F1->Output) {

      MagnitudeInput_ = Magnitude(Net, Net->F1->Output);

      Net->F1->Weight[Net->Winner] = 1;

      Net->F2->Weight[Net->Winner] = Net->L / (Net->L - 1 + MagnitudeInput_);

    }

    else {

      Net->F1->Weight[Net->Winner] = 0;

      Net->F2->Weight[Net->Winner] = 0;

    }

  }

}





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

                      S I M U L A T I N G  T H E  N E T

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





void SimulateNet(NET* Net, BOOL* Input, BOOL* Output)

{

  INT  i;

  BOOL Resonance, Exhausted;

  REAL MagnitudeInput, MagnitudeInput_;



  WriteInput(Net, Input);     

  for (i=0; i<Net->F2->Units; i++) {

    Net->F2->Inhibited = FALSE;

  }

  Resonance = FALSE;

  Exhausted = FALSE;

  do {

    SetInput(Net, Input);

    PropagateToF2(Net);

    GetOutput(Net, Output);

    if (Net->Winner != NO_WINNER) {

      PropagateToF1(Net, Input);

      MagnitudeInput = Magnitude(Net, Input);

      MagnitudeInput_ = Magnitude(Net, Net->F1->Output);

      if ((MagnitudeInput_ / MagnitudeInput) < Net->Rho)

        Net->F2->Inhibited[Net->Winner] = TRUE;

      else

        Resonance = TRUE;

    }

    else Exhausted = TRUE;

  } while (NOT (Resonance OR Exhausted));

  if (Resonance)

    AdjustWeights(Net);

  WriteOutput(Net, Output);     

}





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

                                    M A I N

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





void main()

{

  NET Net;

  INT n;



  GenerateNetwork(&Net);

  InitializeApplication(&Net);



  for (n=0; n<NUM_DATA; n++) {

    SimulateNet(&Net, Input[n], Output[n]);

  }



  FinalizeApplication(&Net);

}
顶端 Posted: 2010-11-07 17:41 | [楼 主]
我来我网·5come5 Forum » 程序员之家

Total 0.013943(s) query 4, Time now is:04-20 06:17, Gzip enabled
Powered by PHPWind v5.3, Localized by 5come5 Tech Team, 黔ICP备16009856号