/* ======================================================================
   David W. Aha
   NGE: printing.c: Printing file for NGE
   ====================================================================== */

#include "nge.h"

/* ======================================================================
   Prints unchanging info to outputfile.
   ====================================================================== */
void print_general_info(fp)
   FILE *fp; /* (Outputfile) */
{
  fprintf(fp,"Trainingfile: %s\n",trainingfile);
  fprintf(fp,"Testingfile: %s\n",testingfile);
  if (greedy)
    fprintf(fp,"Algorithm: Greedy NGE\n");
  else
    fprintf(fp,"Algorithm: NGE (not greedy)\n");
  fprintf(fp,"Feature adjustment rate: %4.2f\n",feature_adjustment_rate);
  fprintf(fp,"Normalization method: Linear, done before training\n");
}

/* ======================================================================
   On printing the results of the experiments.
   ====================================================================== */
void print_classification_results(output_file,num_processed)
   FILE *output_file;
   register int num_processed;
{ 
   /*==== Subfunctions ====*/
   float classify_test_set();

   /*==== Local Variables ====*/
   register int;
   float percent_correct = classify_test_set();
  
   /*==== 2. Print Testing Information to File ====*/
   fprintf(output_file,
           "%4.2f percent (after %d Training Instances, %d exemplars)\n",
           percent_correct,num_processed,
           number_of_exemplars);
   printf("%4.2f percent (after %d Training Instances, %d exemplars)\n",
           percent_correct,num_processed,
           number_of_exemplars);
   printf("Returning to training...\n");
}

/* ======================================================================
   Classifies the test set using the current set of stored exemplars. 
   Yields the percentage of test instances that were classified correctly.
   ====================================================================== */
float classify_test_set()
{
  /*==== Subfunctions ====*/
  extern int compute_distances();            /* Training.c */
  extern void find_nearest_exemplar();       /* Training.c */
  void print_instance();
  void print_exemplars_distances();
  
  /*==== Local variables ====*/
  register int num_correct_on_test_set = 0, inst_num, num_stored;
  float percent_correct;

  /*==== Setup ====*/
  printf("Testing...\n");

  /*==== 1. Compute the number of correct classifications ====*/
  for(inst_num=0; inst_num<num_testing_instances; inst_num++)
    { num_stored = compute_distances(inst_num,TESTING);
      find_nearest_exemplar(0,num_stored);  
      /* 
      printf("Test instance:\n");
      print_instance(inst_num,TESTING);
      print_exemplars_distances();
      printf("Nearest neighbor is exemplar %d\n",nearest_neighbors[0]);
      */
      if (class[nearest_neighbors[0]] ==
          (int)testing_instances[inst_num][number_of_attributes])
         { num_correct_on_test_set++;
           /* printf("Correct guess\n"); */
         }
      /* else
           printf("Wrong guess\n");  */
    }

  /*==== 2. Return the percentage correct ====*/
  percent_correct = 
    100.0 * (float)num_correct_on_test_set/(float)num_testing_instances;
  return(percent_correct);
}

/* ======================================================================
   Prints the given instance. (used for debugging)
   ====================================================================== */
void print_instance(index,mode)
  register int index, mode;
{
  /*==== Local variables ====*/
  register int a;

  if (mode == TRAINING)
    printf("Instance %d with class %d:\n",
           index,(int)training_instances[index][number_of_attributes]);
  else
    printf("Instance %d with class %d:\n",
           index,(int)testing_instances[index][number_of_attributes]);
  printf("Instance: ");
  for(a=0; a<=number_of_attributes; a++)
    { if (mode == TRAINING)
        printf("%3.1f ",training_instances[index][a]);
      else
        printf("%3.1f ",testing_instances[index][a]);
      if (((a+1) % 10) == 0)
        printf("\n          ");
    }
  printf("\n");
}

/* ======================================================================
   Prints the current set of stored exemplars in a simple manner.
   (used for debugging)
   ====================================================================== */
void print_exemplars_distances()
{
  /*==== Subfunctions ====*/
  void print_exemplar_distance();

  /*==== Local Variables ====*/
  register int e;

  for(e=0; e<number_of_exemplars; e++)
    print_exemplar_distance(e);
}

/* ======================================================================
   Same for one exemplar. (used for debugging)
   ====================================================================== */
void print_exemplar_distance(e)
  register int e;
{
  /*==== Local Variables ====*/
  register int a, i;
  
  printf("Exemplar %d of class %d at distance %4.2f:\n",
         e,class[e],distances[e]);
      printf("Lowers:   ");
  for(a=0; a<number_of_attributes; a++)
    { if (attribute_type[a] == SYMBOLIC_TYPE)
	printf("--- ");
      else
	printf("%3.1f ",exemplars[e][a][LOWER]);
      if (((a+1) % 10) == 0)
	printf("\n          ");
    }
  printf("\nUppers:   ");
  for(a=0; a<number_of_attributes; a++)
    { if (attribute_type[a] == SYMBOLIC_TYPE)
	printf("--- ");
      else
	printf("%3.1f ",exemplars[e][a][UPPER]);
      if (((a+1) % 10) == 0)
	printf("\n          ");
    }
  printf("\n");
  for(a=0; a<number_of_attributes; a++)
    if (attribute_type[a] == SYMBOLIC_TYPE)
      { printf("Symbolic attribute %d: ",a);
	for(i=0; i<num_values[a]; i++)
	  { printf("%d ",(int)exemplars[a][e][i]);
	    if (((i+1) % 10) == 0)
	      printf("\n                      ");
	  }
	printf("\n");
      }
}

/* ======================================================================
   Prints weights of all features. (used for debugging)
   ====================================================================== */
void print_feature_weights()
{
  /*==== Local variables ====*/
  register int a;

  printf("Feature weights: ");
  for(a=0; a<number_of_attributes; a++)
    { printf("%4.2f ",feature_weights[a]);
      if (((a+1) % 10) == 0)
        printf("\n                 ");
    }
  if (((a+1) % 10) != 0)
    printf("\n");
}