ci_instances.c

source codes for ltr

long int CiJoinValues\
(CiDs *ds, int Att, int value, unsigned long Low, unsigned long High)
{
  register unsigned long i, Pos = Low;

  if (CiTypeAttr(ds->domain, Att) == integer)
    value = atoi(ValsAttr(ds->domain,Att)[value]);

  for (i = Low ; i <= High ; i++) {
    if (DValAttEx(Ci_AttVal(ds, i), Att) == value) { 
      if (i != Pos ) CiExchange(Ci_Examples(ds), Pos, i);
      Pos++; 
    }
  }
  return Pos;
}
/*************************************************** 
   Goal:  Join all examples with unknown value for an Attribute
   Input: Domain Info
          Array of arrays of instances
	  Attribute 
	  Limits of examples
   Output:  First non Unknown Value
****************************************************/
long int CiJoinUnknowns(CiDs *ds, int Att, unsigned long Low, unsigned long High)
{
  register unsigned long i, Pos = Low;
  
  for (i = Low ; i <= High ; i++) {
    if (!NormalVal(Ci_AttVal(ds, i)[Att])) { 
      if (i != Pos ) CiExchange(Ci_Examples(ds), Pos, i);
      Pos++; 
    }
  }
  return Pos;
}

long int CiMoveUnknowns\
(CiDs *ds, int Att, unsigned long Low, unsigned long High,unsigned long Pos)
{
  register unsigned long i;
  for(i = Low; i < High; i++) {
    CiExchange(Ci_Examples(ds), i, Pos);
    Pos--;
  }
  return Pos;
}
/*************************************************** 
   Goal:  Cut points (quantitative attributes)
   Input: Domain Info
          Array of arrays of instances
	  Attribute 
	  Limits of examples
	  Spliting value
   Output:  Spliting point
   Remarks: Assumes the examples ordered by Attribute value
****************************************************/
long int CiSplitingPosition\
(CiDs *ds, int Att, unsigned long Low, unsigned long High, double value)
{
  register unsigned long i = Low;
  if(CiTypeAttr(ds->domain, Att) == continuous)
    for(i = Low; i <= High && value > CValAttEx(Ci_AttVal(ds, i), Att); i++) ;
  else
    for(i = Low; i <= High && value > DValAttEx(Ci_AttVal(ds, i), Att); i++) ;
  return i-1;
}

/*************************************************** 
   Goal:  Change positions between ex1 and ex2
   Input: Array of arrays of instances
          position of examples ex1 and ex2
   Output: void
****************************************************/
static void CiExchange(CiExample **examples, unsigned long ex1, unsigned long ex2)
{
  CiExample *aux;

  aux = examples[ex1];
  examples[ex1] = examples[ex2];
  examples[ex2] = aux;
}
/*************************************************** 

****************************************************/
DomainInfo *_ReadDomain(char *Name, char *Ext)
{
  FILE            *f;
  DomainInfo      *Info = NULL;
  int             *nr_words;
  long            dummy2;
  char            ***lines, *DF;

  DF = new_strcat(Name, Ext);
  if ((f = fopen(DF,"r")) != NULL) {
    lines = SReadFile(f, &dummy2, &nr_words, ":");
    Info =  GenerateDomainInfo(lines, nr_words, dummy2, 1, 0); 
    Info->root_name=Name; 
    fclose(f);
  }
  return Info;
}

static DomainInfo *GenerateDomainInfo\
(char ***lines, int *nr_words, int nr_lines, int line, int natt)
{
  char *name;
  void *vals = NULL;
  int type = 0, nr_vals = 0;
  DomainInfo *Info = NULL;
  AttrInfo   *ats = NULL;
  
  if (line > nr_lines) {
    Info = (DomainInfo *) malloc(sizeof(DomainInfo));
    Info->nr_attrs = natt;
    ats =(AttrInfo *) calloc(Info->nr_attrs,sizeof(AttrInfo));
    Info->attrs = --ats;   
    return Info;
  }
  if (Processa_atributo(lines[line], nr_words[line], natt, &name, &type, &vals, &nr_vals) != FALSE) {
    Info = GenerateDomainInfo(lines, nr_words, nr_lines, ++line, ++natt);
    Info->attrs[natt].name = name;
    Info->attrs[natt].type_attr = type;
    Info->attrs[natt].nr_vals = nr_vals;
    Info->attrs[natt].vals = vals;
    return Info;
  }
  else
    return GenerateDomainInfo(lines, nr_words, nr_lines, ++line, natt);
}

static int Processa_atributo\
(char **lines, int nr_words, int natt, char **name, int *type, void **vals, int *nr_vals) 
{ 
  int dummy = 0;
  char sdummy[MAX_STR_SIZE], **s;

/*===== values restriction only =====*/
  if (nr_words == 1) { 
    sprintf(sdummy, "attr%d", natt + 1);
    s = v_split(lines[1],", \t:; ",&dummy);
    if (dummy) {
      *name = new_strcpy(sdummy);
      *type = nominal;
      *vals = v_split(lines[1],",; \t", nr_vals);
    }
    else 
      return FALSE;
  }
/*===== name + type  OR   name + values  restriction =====*/
  if (nr_words == 2) { 
    s = v_split(lines[1],",; \t",&dummy);
    *name = s[1];
    s = v_split(lines[2],",; \t",&dummy);
    if (dummy == 1) { /* name + type */
      if (!strcmp(s[1],"continuous"))
	*type = continuous;
      else if (!strcmp(s[1],"nominal"))
	*type = nominal;
      else if (!strcmp(s[1],"integer"))
	*type = integer;
      else if (!strcmp(s[1],"ordered")) {
	fprintf(stderr, "ReadDomain: Error on attribute %s. Ordered attributes need values restriction.\n",*name);
	return FALSE;
      }
      else { 
	fprintf(stderr, "ReadDomain: Error on attribute %s. Unknown type, %s.\n", *name, s[1]);
	return FALSE;
      }
    } 
    else {     /* name + values restriction (nominal or integer attr) */
      *nr_vals = dummy;
      if (all_integers(s, *nr_vals)) {
	*type = integer;
	qsort(s + 1, *nr_vals, sizeof(char *), compare_chars);
	*vals = s;
      }
      else {
	*type = nominal;
	*vals = s;
      }
    }
  }  
  /*===== name + type + values restriction =====*/
  if (nr_words == 3) { 
    s = v_split(lines[1],",; \t",&dummy);
    *name = s[1];
    s = v_split(lines[2],",; \t",&dummy);
    if (!strcmp(s[1],"nominal")) {
      *type = nominal;
      *vals = v_split(lines[3],",; \t", nr_vals);
    } 
    else if (!strcmp(s[1],"ordered")) {
      *type = ordered;
      *vals = v_split(lines[3],",; \t", nr_vals);
    } 
    else if (!strcmp(s[1],"integer")) {
      *type = integer;
      s = v_split(lines[3],",; \t", nr_vals);
      qsort(s+1, *nr_vals, sizeof(char *), compare_chars);
      *vals = s;
    } 
  }
  return TRUE;
}

/* =================================================================
   DISPLAYS THE INFORMATION ON A DOMAIN.
   ----------------------------------------------------------------- */
void ShowDomain(DomainInfo *D)
{
  register int i,v;

  printf("\nPROBLEM NAME :: %s\nNR.ATTRIBUTES :: %d\n\n",D->root_name,D->nr_attrs);
  ForAllAttributes(D,i) {
    printf("Attribute n.%d : %s\n",i,NameAttr(D,i));
    printf("\tType : ");
    if (NomAttr(D,i))
      printf("nominal\n");
    else if (ContAttr(D,i))
      printf("continuous\n");
    else if (OrdAttr(D,i))
      printf("ordered\n");
    else if (IntAttr(D,i))
      printf("integer\n");
    if (NValsAttr(D,i) > 0) {
      printf("\tNr.Different Values : %d\n",NValsAttr(D,i));
      printf("\tValues :: %s",LblValId(D,i,1));
      for(v=2;v<=NValsAttr(D,i);v++) printf(", %s",LblValId(D,i,v));
      printf("\n");
    }
    printf("\n");
  }
}

/* =================================================================
   OBTAINS THE INTERNAL ID OF AN ATTRIBUTE VALUE.
   ----------------------------------------------------------------- */
unsigned int IdValLbl(DomainInfo *D, unsigned int IdAttr, char *Value)
{
  unsigned int pos=1;
  char **values;

  if (ContAttr(D,IdAttr)) return(0);

  values = (char **) D->attrs[IdAttr].vals;
  for(pos = 1; pos <= NValsAttr(D,IdAttr); pos++) 
    if (!strcmp(values[pos], Value)) return pos;

  return 0;
}
/* =================================================================
   OBTAINS THE EXTERNAL LABEL THAT CORRESPONDS TO AN INTERNAL 
   ATTRIBUTE ID.
   ----------------------------------------------------------------- */
char *LblValId(DomainInfo *D, unsigned int IdAttr, unsigned int IdVal)
{
  char **values;

  values = (char **) D->attrs[IdAttr].vals;
  return(values[IdVal]);
}  

/* =================================================================
   OBTAINS THE INTERNAL ID CORRESPONDING TO AN ATTRIBUTE NAME.
   ----------------------------------------------------------------- */
unsigned int IdAttr(DomainInfo *D, char *name)
{
  int i;

  ForAllAttributes(D,i) 
    if (!strcmp(name,NameAttr(D,i))) return(i);
  return 0;
}