classifierlist.h

Simple GA code (Pascal code from Goldberg, D. E. (1989), Genetic Algorithms in Search, Optimization,

/*
/       (XCS-C 1.2)
/	------------------------------------
/	Learning Classifier System based on accuracy
/
/     by 
/     Martin V. Butz
/     Illinois Genetic Algorithms Laboratory (IlliGAL)
/     University of Illinois at Urbana/Champaign
/     [e-mail]
/
/     Last modified: 09-30-2003
/
/     Header for all actions on xClassifier and xClassifierSet.
*/

/**
 * The conditon of a classifier is coded as a linked list which speeds up the matching process
 * significantely especially in large problems. 
 */

/* Condition of Classifier */
struct xCList{
  int pos;
  char c;
  struct xCList *next;
};

/* Condition of Classifier */
struct xCondition{
  int size;
  struct xCList *l;
};

int addXCPos(struct xCondition *con, int pos, char c);
void removeXCPos(struct xCondition *con, int pos);
struct xCondition *copyXC(struct xCondition *cOld);
void emptyXCondition(struct xCondition *con);
void resetXCSize(struct xCondition *con);
int isEqualXC(struct xCondition *c1, struct xCondition *c2);
void printXC(FILE *fp, struct xCondition *con);


struct xClassifier{
  struct xCondition *con;
  int act;

  double pre;
  double preer;
  double acc;
  double fit;
  int num;
  int exp;
  double peerssest;
  int gaIterationTime;
};

struct xClassifierSet{
  struct xClassifier *cl;
  struct xClassifierSet *next;
};

struct XCS;

struct xClassifierSet * createRandomClassifierSet(int condLength, int maxPopSize, double dontCareProb);
void createRandomCondition(struct xCondition *con, int condLength, double dontCareProb);
void createMatchingCondition(struct xCondition *con,char *mstring, double dontCareProb);
void createRandomAction(int *act);
void setInitialVariables(struct xClassifier *cl,int itTime);

struct xClassifierSet * getMatchSet(struct XCS *xcs, char *state, struct xClassifierSet **pop, struct xClassifierSet **killset, int itTime);
int match(char *m, struct xCondition *c);
int compareStateWithClassifier(char *state, struct xCondition *c);
/* Added on the 05/24/2000 to figure out how many actions are covered! */
int nrActionsInSet(struct xClassifierSet *set, int *coveredActions);
int getActionNr(char *action);
/* added on the 05/24/2000 to always cover all actions in one match set */
struct xClassifier * createNewCoverMatch(char *state, int itTime, struct xClassifierSet *set, int action, double dontCareProb);
/* added on the 05/24/2000 to always cover all actions in one match set */
int actionIsCovered(int action, struct xClassifierSet *set);

struct xClassifierSet * getActionSet(int action, struct xClassifierSet *ms);
void adjustActionSet(struct XCS *xcs, struct xClassifierSet **aset, double maxP, double reward, struct xClassifierSet **pop, struct xClassifierSet **killset);
void updateFitness(struct xClassifierSet *aset, struct XCS *xcs);
void discoveryComponent(struct xClassifierSet **set,struct xClassifierSet **pop,struct xClassifierSet **killset,int itTime,char *situation, struct XCS *xcs, double reward);
void getDiscoversSums(struct xClassifierSet *set, double *fitSum, int *mssum, int *gaitsum);
void setTimeStamps(struct xClassifierSet *set, int itTime);
void selectTwoClassifiers(struct xClassifier **cl, struct xClassifier **parents, struct xClassifierSet *set, double fitsum, int setsum, struct XCS *xcs, char *situation);
struct xClassifier * selectClassifierUsingTournamentSelection(struct xClassifierSet *set, int setsum, struct XCS *xcs, struct xClassifier *notMe);
struct xClassifier * selectClassifierUsingRWS(struct xClassifierSet *set,double sum);
void insertDiscoveredClassifier(struct xClassifier **cl, struct xClassifier **parents, struct xClassifierSet **set,
				struct xClassifierSet **pop, struct xClassifierSet **killset, int len, 
				struct XCS *xcs);

void doActionSetSubsumption(struct xClassifierSet **aset, struct xClassifierSet **pop, struct xClassifierSet **killset, int thetaSub);
void subsumeClassifier(struct xClassifier *cl,struct xClassifier **parents,struct xClassifierSet *locset,struct xClassifierSet **pop, int maxPopSize, int thetaSub);
int subsumeClassifierToSet(struct xClassifier *cl, struct xClassifierSet *set, int maxPopSize, int thetaSub);
int subsumes(struct xClassifier *cl1, struct xClassifier * cl2, int thetaSub);
int isSubsumer(struct xClassifier *cl, int thetaSub);
int isMoreGeneral (struct xCondition *first, struct xCondition *second);

int crossover(struct xClassifier **cl, int crossoverType, double chi);
int uniformCrossover(struct xClassifier **cl);
int onePointCrossover(struct xClassifier **cl);
int twoPointCrossover(struct xClassifier **cl);

int mutation(struct xClassifier *cl, char *situation, struct XCS *xcs);
int mutate(char *c, char s, int doGeneralizationMutation, int doNicheMutation);
void mutateAction(int *action);

void generalize(struct xCondition *condition);
void specialize(struct xCondition *condition, char *situation);
int getSpecificity(struct xClassifier *cl);
void getPosSpecificity(struct xClassifierSet *cll, double *specPos);


int addClassifierToPointerSet(struct xClassifier *cl,struct xClassifierSet **pointerset);
int addClassifierToSet(struct xClassifier *cl,struct xClassifierSet **pop);
void addNewClassifierToSet(struct xClassifier *cl,struct xClassifierSet **pop);

struct xClassifier * deleteStochClassifier(struct xClassifierSet **pop, double delta, int thetaExp, int delType);
struct xClassifier * deleteTypeOfClassifier(struct xClassifierSet *setp,struct xClassifierSet *setpl,struct xClassifierSet **pop);
double getDelPropMikro(struct xClassifier *cl, double meanf, double meane, double delta, int thetaExp, int delType);
int updateSet(struct xClassifierSet **uset,struct xClassifierSet *killset);
int deleteClassifierPointerFromSet(struct xClassifierSet **set, struct xClassifier *clp);

void freeSet(struct xClassifierSet **head);
void freeClassifierSet(struct xClassifierSet **head);
void freeClassifier(struct xClassifier *cl);

void printClassifier(struct xClassifier*c);
void fprintClassifier(FILE *fp,struct xClassifier *c);
void printClassifierSet(struct xClassifierSet *head);	/*letzter Eintrag zu Testzwecken!!!*/
void fprintClassifierSet(FILE *fp,struct xClassifierSet *head);

struct xClassifierSet * sortClassifierSet(struct xClassifierSet **cls,int type);

double absDouble(double value);

/* deletion stochastic with increase of deletion probability based on error
 * rather than on fitness
 */
struct xClassifier * deleteClassifier(struct xClassifierSet **pop, struct XCS *xcs);