fn_subclass_encoding.hpp

Go to the documentation of this file.

// Copyright (C) 2011 the authors listed below
// http://ecocpak.sourceforge.net
//
// Authors:
// - Dimitrios Bouzas (bouzas at ieee dot org)
// - Nikolaos Arvanitopoulos (niarvani at ieee dot org)
// - Anastasios Tefas (tefas at aiia dot csd dot auth dot gr)
//
// This file is part of the ECOC PAK C++ library. It is
// provided without any warranty of fitness for any purpose.
//
// You can redistribute this file and/or modify it under
// the terms of the GNU Lesser General Public License (LGPL)
// as published by the Free Software Foundation, either
// version 3 of the License or (at your option) any later
// version.
// (see http://www.opensource.org/licenses for more info)





Classifier*
create_classifier
  (
  const ClassData& A,
  const ClassData& B,
  const u32 classifiers_option,
  double& training_error
  )
  {
  switch(classifiers_option)
    {
    // Nearest Class Centroid Classifier
    case NCC:
      {
      Classifier_ncc* tmp = new Classifier_ncc(A.Data(), B.Data());

      // number of feature vectors in first class
      const u32 n_samplesA = A.Samples();

      // number of feature vectors in second class
      const u32 n_samplesB = B.Samples();

      // test classifier
      u32 n_missed = 0;

      // find misclassified for first class
      for(u32 i = 0; i < n_samplesA; i++)
        {
        if(tmp->predict(A.Data().row(i)) < 0)
          {
          n_missed++;
          }
        }

      // find misclassified for second class
      for(u32 i = 0; i < n_samplesB; i++)
        {
        if(tmp->predict(B.Data().row(i)) > 0)
          {
          n_missed++;
          }
        }

      // compute training error
      training_error =
        (double(n_missed) / double(n_samplesA + n_samplesB));

      return tmp;
      }

    // Fisher Linear Discriminant Analysis followed by NCC
    case FLDA:
      {
      Classifier_flda* tmp = new Classifier_flda(A.Data(), B.Data());

      // number of feature vectors in first class
      const u32 n_samplesA = A.Samples();

      // number of feature vectors in second class
      const u32 n_samplesB = B.Samples();

      // test classifier
      u32 n_missed = 0;

      // find misclassified for first class
      for(u32 i = 0; i < n_samplesA; i++)
        {
        if(tmp->predict(A.Data().row(i)) < 0)
          {
          n_missed++;
          }
        }

      // find misclassified for second class
      for(u32 i = 0; i < n_samplesB; i++)
        {
        if(tmp->predict(B.Data().row(i)) > 0)
          {
          n_missed++;
          }
        }

      // compute training error
      training_error =
        (double(n_missed) / double(n_samplesA + n_samplesB));

      return tmp;
      }

    // Support Vector Machine
    case SVM:
      {
      Classifier_svm* tmp = new Classifier_svm(A.Data(), B.Data());

      // number of feature vectors in first class
      const u32 n_samplesA = A.Samples();

      // number of feature vectors in second class
      const u32 n_samplesB = B.Samples();

      // test classifier
      u32 n_missed = 0;

      // find misclassified for first class
      for(u32 i = 0; i < n_samplesA; i++)
        {
        if(tmp->predict(A.Data().row(i)) < 0)
          {
          n_missed++;
          }
        }

      // find misclassified for second class
      for(u32 i = 0; i < n_samplesB; i++)
        {
        if(tmp->predict(B.Data().row(i)) > 0)
          {
          n_missed++;
          }
        }

      // compute training error
      training_error =
        (double(n_missed) / double(n_samplesA + n_samplesB));

      return tmp;
      }

    // AdaBoost
    case ADABOOST:
      {
      Classifier_adaBoost* tmp =
        new Classifier_adaBoost(A.Data(), B.Data());

      // number of feature vectors in first class
      const u32 n_samplesA = A.Samples();

      // number of feature vectors in second class
      const u32 n_samplesB = B.Samples();

      // test classifier
      u32 n_missed = 0;

      // find misclassified for first class
      for(u32 i = 0; i < n_samplesA; i++)
        {
        if(tmp->predict(A.Data().row(i)) < 0)
          {
          n_missed++;
          }
        }

      // find misclassified for second class
      for(u32 i = 0; i < n_samplesB; i++)
        {
        if(tmp->predict(B.Data().row(i)) > 0)
          {
          n_missed++;
          }
        }

      // compute training error
      training_error =
        (double(n_missed) / double(n_samplesA + n_samplesB));

      return tmp;
      }

    // Sum of Error Squares Classifier
    case LEAST_SQUARES:
      {
      Classifier_ls* tmp =
        new Classifier_ls(A.Data(), B.Data());

      // number of feature vectors in first class
      const u32 n_samplesA = A.Samples();

      // number of feature vectors in second class
      const u32 n_samplesB = B.Samples();

      // test classifier
      u32 n_missed = 0;

      // find misclassified for first class
      for(u32 i = 0; i < n_samplesA; i++)
        {
        if(tmp->predict(A.Data().row(i)) < 0)
          {
          n_missed++;
          }
        }

      // find misclassified for second class
      for(u32 i = 0; i < n_samplesB; i++)
        {
        if(tmp->predict(B.Data().row(i)) > 0)
          {
          n_missed++;
          }
        }

      // compute training error
      training_error =
        (double(n_missed) / double(n_samplesA + n_samplesB));

      return tmp;
      }

    // Custom Classifier
    case CUSTOM_CLASSIFIER:
      {
      Classifier_custom* tmp =
        new Classifier_custom(A.Data(), B.Data());

      // number of feature vectors in first class
      const u32 n_samplesA = A.Samples();

      // number of feature vectors in second class
      const u32 n_samplesB = B.Samples();

      // test classifier
      u32 n_missed = 0;

      // find misclassified for first class
      for(u32 i = 0; i < n_samplesA; i++)
        {
        if(tmp->predict(A.Data().row(i)) < 0)
          {
          n_missed++;
          }
        }

      // find misclassified for second class
      for(u32 i = 0; i < n_samplesB; i++)
        {
        if(tmp->predict(B.Data().row(i)) > 0)
          {
          n_missed++;
          }
        }

      // compute training error
      training_error =
        (double(n_missed) / double(n_samplesA + n_samplesB));

      return tmp;
      }

    default:
      {
      arma_debug_print
        (
        "create_classifier(): Unknown classifier's option"
        );

      }

    }

  }



Classifier*
create_classifier
  (
  const ClassData& A,
  const ClassData& B,
  const u32 classifiers_option
  )
  {
  switch(classifiers_option)
    {
    // Nearest Class Centroid Classifier
    case NCC:
      {
      return new Classifier_ncc(A.Data(), B.Data());
      }

    // Fisher Linear Discriminant Analysis followed by NCC
    case FLDA:
      {
      return new Classifier_flda(A.Data(), B.Data());
      }

    // Support Vector Machine
    case SVM:
      {
      return new Classifier_svm(A.Data(), B.Data());
      }

    // AdaBoost
    case ADABOOST:
      {
      return new Classifier_adaBoost(A.Data(), B.Data());
      }

    // Sum of Error Squares Classifier
    case LEAST_SQUARES:
      {
      return new Classifier_ls(A.Data(), B.Data());
      }

    // Custom Classifier
    case CUSTOM_CLASSIFIER:
      {
      return new Classifier_custom(A.Data(), B.Data());
      }

    default:
      {
      arma_debug_print
        (
        "create_classifier(): Unknown classifier's option"
        );

      }

    }

  }



Classifier*
create_classifier
  (
  const mat& A,
  const mat& B,
  const u32 classifiers_option
  )
  {
  switch(classifiers_option)
    {
    // Nearest Class Centroid Classifier
    case NCC:
      {
      return new Classifier_ncc(A, B);
      }

    // Fisher Linear Discriminant Analysis followed by NCC
    case FLDA:
      {
      return new Classifier_flda(A, B);
      }

    // Support Vector Machine
    case SVM:
      {
      return new Classifier_svm(A, B);
      }

    // AdaBoost
    case ADABOOST:
      {
      return new Classifier_adaBoost(A, B);
      }

    // Sum of Error Squares Classifier
    case LEAST_SQUARES:
      {
      return new Classifier_ls(A, B);
      }

    // Custom Classifier
    case CUSTOM_CLASSIFIER:
      {
      return new Classifier_custom(A, B);
      }

    default:
      {
      arma_debug_print
        (
        "create_classifier(): Unknown classifier's option"
        );

      }

    }

  }



void
coding_matrix_update
  (
  imat& coding_matrix,
  const vector<ClassData>& class_vector,
  vector<ClassData>& split_classes_vector,
  u32 indx
  )
  {
  const u32 n_rows = coding_matrix.n_rows;
  bool found = false;
  imat tmp;

  // for all the rows of the coding matrix (== number of subclasses
  // created so far)
  for(u32 i = 0; i < n_rows; i++)
    {
    // class index == class vector index
    if(coding_matrix(i, 1) == class_vector[indx].ClassIndex())
      {
      // the new tmp matrix will have one more row than the previous
      // coding matrix
      tmp = zeros<imat>(coding_matrix.n_rows + 1, coding_matrix.n_cols);

      // until row i the matrix remains the same
      tmp.rows(0, i) = coding_matrix.rows(0, i);

      // in row i we assign the class label and class index of
      // the first element in the new split classes vector
      tmp(i, 1) = split_classes_vector[0].ClassIndex();
      tmp(i, 0) = split_classes_vector[0].ClassLabel();

      // row i is copied to row i + 1
      tmp.row(i + 1) = tmp.row(i);

      // in row i + 1 we assign the class label and class index
      // of the second element in the new split classes vector
      tmp(i + 1, 1) = split_classes_vector[1].ClassIndex();
      tmp(i + 1, 0) = split_classes_vector[1].ClassLabel();

      // i is not the last class index
      if(i < (coding_matrix.n_rows - 1))
        {
        // the remaining rows of the coding matrix do not change
        tmp.rows(i + 2, tmp.n_rows - 1) =
          coding_matrix.rows(i + 1, coding_matrix.n_rows - 1);
        }

      // update the coding matrix with the new changes
      coding_matrix = tmp;
      found = true;
      break;
      }

    }

  // the class index of the class specified by indx is not equal to any
  // class index in the second column of the coding matrix
  if(found == false)
    {
    // the new coding matrix will have two more rows
    tmp = zeros<imat>(coding_matrix.n_rows + 2, coding_matrix.n_cols);

    // while i runs through the rows of the coding matrix
    // and the class label of each row of the matrix is not equal
    // to the class label of the class specified by the index indx
    u32 i = 0;
    while
      (
      i < coding_matrix.n_rows && coding_matrix(i, 0) !=
      (class_vector[indx].ClassLabel() + 1)
      )
      {
      // increment the row counter
      i++;
      }

    // i is not the last row
    if(i < coding_matrix.n_rows)
      {
      // the first i - 1 rows of the coding matrix remain the same
      tmp.rows(0, i - 1) = coding_matrix.rows(0, i - 1);

      // row i - 1 is copied to row i
      tmp.row(i) = tmp.row(i - 1);

      // in row i we assign the class label and class index of
      // the first element in the new split classes vector
      tmp(i, 0) = split_classes_vector[0].ClassLabel();
      tmp(i, 1) = split_classes_vector[0].ClassIndex();

      // row i - 1 is copied to row i + 1
      tmp.row(i + 1) = tmp.row(i - 1);

      // in row i + 1 we assign the class label and class index
      // of the second element in the new split classes vector
      tmp(i + 1, 0) = split_classes_vector[1].ClassLabel();
      tmp(i + 1, 1) = split_classes_vector[1].ClassIndex();

      // the remaining rows are the same until the end
      tmp.rows(i + 2, tmp.n_rows - 1) =
        coding_matrix.rows(i, coding_matrix.n_rows - 1);
      }
    else // i is the last row
      {
      // the first (n - 1) rows are the same
      tmp.rows(0, coding_matrix.n_rows - 1) = coding_matrix;

      // row i - 1 is copied to row i
      tmp.row(i) = tmp.row(i - 1);

      // in row i we assign the class label and class index of
      // the first element in the new split classes vector
      tmp(i, 0) = split_classes_vector[0].ClassLabel();
      tmp(i, 1) = split_classes_vector[0].ClassIndex();

      // row i - 1 is copied to row i + 1
      tmp.row(i + 1) = tmp.row(i - 1);

      // in row i + 1 we assign the class label and class index
      // of the second element in the new split classes vector
      tmp(i + 1, 0) = split_classes_vector[1].ClassLabel();
      tmp(i + 1, 1) = split_classes_vector[1].ClassIndex();
      }

    // update the coding matrix
    coding_matrix = tmp;
    }

  }



void
update_class_tracker
  (
  vector<colvec>& class_tracker,
  const vector<ClassData>& class_vector,
  const u32 indx,
  vector<ClassData>& split_classes_vector,
  vector<ClassData>& classes_created_vector
  )
  {
  // vector which will update the class tracker
  colvec newVec;

  // size of class tracker
  const u32 sz = class_tracker.size();

  // iterate through class tracker size
  for(u32 i = 0; i < sz; i++)
    {
    // for each row of class tracker i
    for(u32 j = 0; j < class_tracker[i].n_rows; j++)
      {
      // class index of class specified by indx equal the respective
      // class tracker value
      if(class_vector[indx].ClassIndex() == (u32)(class_tracker[i](j)))
        {
        // the new vector will contain two more rows than class
        // tracker i
        newVec = zeros< colvec >(class_tracker[i].n_rows + 2);

        // until row n - 1 the class tracker i remains the same
        newVec.rows(0, newVec.n_rows - 3) = class_tracker[i];

        // rows n - 1 and n are filled with the indices of the
        // subclasses
        newVec(newVec.n_rows - 2) =
          split_classes_vector[0].ClassIndex();

        newVec(newVec.n_rows - 1) =
          split_classes_vector[1].ClassIndex();

        // update class tracker i with the new vector and free memory
        class_tracker[i].reset();
        class_tracker[i] = newVec;
        newVec.reset();
        break;
        }

      }

    }

  // create two values with the class indices of the two subclasses
  colvec vec1 = zeros<colvec>(1);
  vec1(0) = split_classes_vector[0].ClassIndex();

  colvec vec2 = zeros<colvec>(1);
  vec2(0) = split_classes_vector[1].ClassIndex();

  // push them back to the class tracker vector
  class_tracker.push_back(vec1);
  class_tracker.push_back(vec2);

  // Update classes vector
  classes_created_vector.push_back(split_classes_vector[0]);
  classes_created_vector.push_back(split_classes_vector[1]);
  }



bool
save_classifier
  (
  Classifier* c,
  const vector<ClassData>& class_vector,
  const ucolvec& best_set_indices,
  const ucolvec& complement_set_indices,
  vector<Classifier*>& classifiers_vector
  )
  {
  const u32 class_vector_size = class_vector.size();

  // for the total size of the classes vector
  for(u32 i = 0; i < class_vector_size; i++)
    {
    // iterate through the best set
    for(u32 j = 0; j < best_set_indices.n_rows; j++)
      {
      // class indices of class i and class j of the best set agree
      if(
        class_vector[i].ClassIndex() ==
        class_vector[best_set_indices[j]].ClassIndex()
        )
        {
        // the plus label of the classifier is updated with the class
        // index of the i-th class
        ClassData* tmp = new ClassData(class_vector[i]);
        c->pos.push_back(tmp);

        c->n_pos += class_vector[i].Samples();

        }

      }

    // iterate through the complement set
    for(u32 j = 0; j < class_vector_size - best_set_indices.n_rows; j++)
      {
      // class indices of class i and class j of the complement set
      // agree
      if(
        class_vector[i].ClassIndex() ==
        class_vector[complement_set_indices[j]].ClassIndex()
        )
        {
        // the minus label of the classifier is updated with the class
        // index of the i-th class

        ClassData* tmp = new ClassData(class_vector[i]);
        c->neg.push_back(tmp);

        c->n_neg += class_vector[i].Samples();
        }

      }

    }

  // check if c is already in the initial vector of classifiers
  for(u32 i = 0; i < classifiers_vector.size(); i++)
    {
    if(*classifiers_vector[i] == *c)
      {
      return false;
      }

    }

  // push classifier object to the vector of classifiers
  classifiers_vector.push_back(c);

  return true;
  }



bool
save_classifier
  (
  Classifier* c,
  const vector<ClassData>& class_vector,
  vector<Classifier*>& classifiers_vector
  )
  {
  // update the plus and minus labels of the classifier
  // with the class indices of the two classes in the vector
  ClassData* tmpA = new ClassData(class_vector[0]);
  c->pos.push_back(tmpA);

  ClassData* tmpB = new ClassData(class_vector[1]);
  c->neg.push_back(tmpB);

  // update number of positive and negative samples of classifier
  c->n_pos = class_vector[0].Samples();
  c->n_neg = class_vector[1].Samples();

  // size of the classifiers vector
  const u32 classifiers_vector_size = classifiers_vector.size();

  // iterate through number of classifiers
  for(u32 i = 0; i < classifiers_vector_size; i++)
    {
    // classifier already in the vector
    if(*classifiers_vector[i] == *c)
      {
      return false;
      }

    }

  // push classifier object to the vector of classifiers
  classifiers_vector.push_back(c);

  return true;
  }



bool
contain_same_classes
  (
  const ucolvec& A,
  const vector<ClassData>& B
  )
  {
  const u32 n_rows = A.n_rows;

  // if the sizes disagree return false
  if(n_rows != B.size())
    {
    return false;
    }

  for(u32 i = 0; i < n_rows; i++)
    {
    // class indices disagree return false
    if(A[i] != B[i].ClassIndex())
      {
      return false;
      }

    }

  return true;
  }



void
direct_subclass_encoding
  (
  const vector<ClassData>& class_vector,
  const Threshold& thres,
  const int criterion_option,
  const int classifiers_option,
  imat& coding_matrix,
  vector<Classifier*>& classifiers_vector,
  vector<ClassData>& classes_created_vector,
  vector<colvec>& class_tracker,
  vector<ucolvec>& problem_tracker
  )
  {
  // search through problem_tracker to check if current
  // problem has already been examined
  for(u32 i = 0; i < problem_tracker.size(); i++)
    {

    // initial class vector contains the same class indices
    // as the current problem_tracker's vector the exit
    // recursion branch because problem has been already
    // examined in another recursion branch
    if(contain_same_classes(problem_tracker[i], class_vector) == true)
      {
      return;
      }

    }

  // number of initial classes
  const u32 class_vector_size = class_vector.size();

  // current problem's class indices
  ucolvec cur_class_indices = zeros<ucolvec>(class_vector_size);

  // copy current class indices
  for(u32 i = 0; i < class_vector_size; i++)
    {
    cur_class_indices[i] = class_vector[i].ClassIndex();
    }

  // push current class indices into the problem tracker
  problem_tracker.push_back(cur_class_indices);

  // Trivial recursion condition just return
  if(class_vector_size == 1)
    {
    return;
    }
  else // Else class_vector vector contains more than one class
    {
    // temporary samples matrix and labels vector for on spot problem
    // construction
    mat current_samples;
    icolvec current_labels;

    // If class_vector vector contains only two classes
    if(class_vector_size == 2)
      {
      // evaluate training error of specific problem
      double error;
      Classifier* first_level_classifier =
        create_classifier
          (
          class_vector[0],
          class_vector[1],
          classifiers_option,
          error
          );

      // if error of classification is larger than specified threshold
      if(error > thres.Performance())
        {
        // --- Split both classes to find clusters with maximoum  --- //
        // --- distance                                           --- //

        // indices of first class clustering
        ucolvec ind_a;

        // number of samples in each cluster
        ucolvec clust_num_a;

        // split first class into two subclasses
        mat centers_a =
          subClasses(ind_a, clust_num_a, class_vector[0].Data());

        // indices of second class clustering
        ucolvec ind_b;

        // number of samples in each cluster
        ucolvec clust_num_b;

        // split second class into two subclasses
        mat centers_b =
          subClasses(ind_b, clust_num_b, class_vector[1].Data());

        // ------------------- End of splitting --------------------- //

        // if the clusters of the first class have the largest distance
        if(
        norm(centers_a.row(0) - centers_a.row(1), 2) >=
        norm(centers_b.row(0) - centers_b.row(1), 2)
          )
          {
          // if the created clusters sizes are less than specified
          // threshold
          if(
            clust_num_a[0] < thres.Size() ||
            clust_num_a[1] < thres.Size()
            )
            {
            // Create and save a classifier for initial problem
            save_classifier
              (
              first_level_classifier,
              class_vector,
              classifiers_vector
              );

            }
          else // else split the first class
            {
            // split the first class into two clusters
            vector<ClassData> split_classes_vector =
              split_class
                (
                class_vector[0],
                ind_a,
                clust_num_a,
                thres.Size()
                );

            // construct and evaluate first problem
            vector<ClassData> tmp_class_vector_a;
            tmp_class_vector_a.push_back(split_classes_vector[0]);
            tmp_class_vector_a.push_back(class_vector[1]);


            // evaluate training error of first cluster against rest of
            // the classes
            double error_a;
            Classifier* tmp_classifier_a =
              create_classifier
                (
                split_classes_vector[0],
                class_vector[1],
                classifiers_option,
                error_a
                );

            // construct and evaluate second problem
            vector<ClassData> tmp_class_vector_b;
            tmp_class_vector_b.push_back(split_classes_vector[1]);
            tmp_class_vector_b.push_back(class_vector[1]);


            // evaluate training error of second cluster against rest of
            // the classes
            double error_b;
            Classifier* tmp_classifier_b =
              create_classifier
                (
                split_classes_vector[1],
                class_vector[1],
                classifiers_option,
                error_b
                );

            // clean up temporary created classifiers
            delete tmp_classifier_a;
            delete tmp_classifier_b;

            // --- Check if the we have improvement according to  --- //
            // --- specified threshold for at least one of the    --- //
            // --- created problems                               --- //

            // If improvement of both the new problems was  satisfying
            // according to specified threshold (comparison is done
            // with respect the error percentage)
            if(
              ((100.0 * (error - error_a)) / error) >=
              thres.Improvement() &&
              ((100.0 * (error - error_b)) / error) >=
              thres.Improvement()
              )
              {
              // encoding matrix update
              coding_matrix_update
                (
                coding_matrix,
                class_vector,
                split_classes_vector,
                0
                );

              // update class tracker
              update_class_tracker
                (
                class_tracker,
                class_vector,
                0,
                split_classes_vector,
                classes_created_vector
                );

              // delete first level classifier since is not needed
              delete first_level_classifier;

              // recursive calls to direct_subclass_encoding
              direct_subclass_encoding
                (
                tmp_class_vector_a,
                thres, criterion_option,
                classifiers_option,
                coding_matrix,
                classifiers_vector,
                classes_created_vector,
                class_tracker,
                problem_tracker
                );

              direct_subclass_encoding
                (
                tmp_class_vector_b,
                thres,
                criterion_option,
                classifiers_option,
                coding_matrix,
                classifiers_vector,
                classes_created_vector,
                class_tracker,
                problem_tracker
                );

              }
            else // Impovement wasn't good
               {
               // Reduce the static global index of the classes created
               // because
               // the two new subclasses created were rejected
               ClassData::globalIndex -= 2;

               // Create and save a classifier for initial problem
               save_classifier
                 (
                 first_level_classifier,
                 class_vector,
                 classifiers_vector
                 );

               } // end of if-else for improvement

            } // end of if-else for clusters sizes

          }
        else // if second class is to be splitted
          {
          // if cluster size is less than threshold
          if(
            clust_num_b[0] < thres.Size() ||
            clust_num_b[1] < thres.Size()
            )
            {
            // Create and save a classifier for initial problem
            save_classifier
              (
              first_level_classifier,
              class_vector,
              classifiers_vector
              );

            }
          else // split the second class
            {
            // split class_vector[1] class and store the two new created
            // subclasses - clusters in a vector split_classes_vector
            vector<ClassData> split_classes_vector =
              split_class
                (
                class_vector[1],
                ind_b,
                clust_num_b,
                thres.Size()
                );

            // construct and evaluate first problem
            vector<ClassData> tmp_class_vector_a;
            tmp_class_vector_a.push_back(split_classes_vector[0]);
            tmp_class_vector_a.push_back(class_vector[0]);


            // evaluate training error of first cluster against rest of
            // the classes
            double error_a;
            Classifier* tmp_classifier_a =
              create_classifier
                 (
                 split_classes_vector[0],
                 class_vector[0],
                 classifiers_option,
                 error_a
                 );

            // construct and evaluate second problem
            vector<ClassData> tmp_class_vector_b;
            tmp_class_vector_b.push_back(split_classes_vector[1]);
            tmp_class_vector_b.push_back(class_vector[0]);


            // evaluate training error of second cluster against rest of
            // the classes
            double error_b;
            Classifier* tmp_classifier_b =
              create_classifier
              (
              split_classes_vector[1],
              class_vector[0],
              classifiers_option,
              error_b
              );

            // clean up temporary created classifiers
            delete tmp_classifier_a;
            delete tmp_classifier_b;

            // If improvement of both the new problems was satisfying
            // according to specified threshold -- (comparison is done
            // with respect the error percentage)
            if(
              ((100.0 * (error - error_a)) / error) >=
              thres.Improvement() &&
              ((100.0 * (error - error_b)) / error) >=
              thres.Improvement()
              )
              {
              // --- encoding matrix update --- //
              coding_matrix_update
                (
                coding_matrix,
                class_vector,
                split_classes_vector,
                1
                );

              // update class tracker
              update_class_tracker
                (
                class_tracker,
                class_vector,
                1,
                split_classes_vector,
                classes_created_vector
                );

              // delete first level classifier since is not needed
              delete first_level_classifier;

              // recursive calls to direct_subclass_encoding
              direct_subclass_encoding
                (
                tmp_class_vector_a,
                thres,
                criterion_option,
                classifiers_option,
                coding_matrix,
                classifiers_vector,
                classes_created_vector,
                class_tracker,
                problem_tracker
                );

              direct_subclass_encoding
                (
                tmp_class_vector_b,
                thres,
                criterion_option,
                classifiers_option,
                coding_matrix,
                classifiers_vector,
                classes_created_vector,
                class_tracker,
                problem_tracker
                );

              }
            else // improvement was not good
              {
              // Reduce the static global index of the classes created
              // because two new subclasses created were rejected
              ClassData::globalIndex -= 2;

              // Create and save a classifier for initial problem
              save_classifier
                (
                first_level_classifier,
                class_vector,
                classifiers_vector
                );

              }

            }

          }

        }
      else // if performance is good
        {
        // Create and save a classifier for initial problem
        save_classifier
          (
          first_level_classifier,
          class_vector,
          classifiers_vector
          );

        }

      }
    else // classes more than two
      {
      // run SFFS to configure binary decomposition of classes
      ucolvec best_set_indices = sffs(class_vector, criterion_option);

      // number of classes in the best subset of classes yield by SFFS
      const u32 bestSetSize = best_set_indices.n_rows;

      // The SFFS algorithm returned a problem configuration that one
      // partition contained one class and the other partition contained
      // many classes

      // If problem configuration is one against many
      if(bestSetSize == 1 || (class_vector_size - bestSetSize) == 1)
        {
        // If the partition of the best set contains one class
        if(bestSetSize == 1)
          {
          ucolvec complement_set_indices = complement
                                             (
                                             best_set_indices,
                                             class_vector_size
                                             );

          // merge classes of complement set
          ClassData merged_class = merge_selected_classes
                                     (class_vector,
                                     complement_set_indices
                                     );

          vector<ClassData> tmp_class_vector;
          tmp_class_vector.push_back(class_vector[best_set_indices[0]]);
          tmp_class_vector.push_back(merged_class);


          // evaluate training error of specific problem
          double error;
          Classifier* first_level_classifier =
            create_classifier
              (
              class_vector[best_set_indices[0]],
              merged_class,
              classifiers_option,
              error
              );

          // if error of classification is larger than threshold
          if(error > thres.Performance())
            {
            ucolvec ind_a; // indices of first clustering
            ucolvec clust_num_a; // number of samples in each cluster

            // split class1 into two subclasses
            mat centers_a = subClasses
                              (
                              ind_a,
                              clust_num_a,
                              class_vector[best_set_indices[0]].Data()
                              );

            // if cluster size is less than threshold
            if(
              clust_num_a[0] < thres.Size() ||
              clust_num_a[1] < thres.Size()
              )
              {
              // Create and save a classifier
              save_classifier
                (
                first_level_classifier,
                class_vector,
                best_set_indices,
                complement_set_indices,
                classifiers_vector
                );

              // create the new ClassData vectors according to the best
              // set
              vector<ClassData> class_vector_a;
              vector<ClassData> class_vector_b;
              for(u32 i = 0; i < class_vector_size; i++)
                {
                if(contains(best_set_indices, bestSetSize, i))
                  {
                  class_vector_a.push_back(class_vector[i]);
                  }
                else
                  {
                  class_vector_b.push_back(class_vector[i]);
                  }
                }

              // recursive calls to direct_subclass_encoding
              direct_subclass_encoding
                (
                class_vector_a,
                thres,
                criterion_option,
                classifiers_option,
                coding_matrix,
                classifiers_vector,
                classes_created_vector,
                class_tracker,
                problem_tracker
                );

              direct_subclass_encoding
                (
                class_vector_b,
                thres,
                criterion_option,
                classifiers_option,
                coding_matrix,
                classifiers_vector,
                classes_created_vector,
                class_tracker,
                problem_tracker
                );

              }
            else // else split first class
              {
              // Split the unary class
              vector<ClassData> split_classes_vector =
                split_class
                  (
                  class_vector[best_set_indices[0]],
                  ind_a, clust_num_a, thres.Size()
                  );

              // construct and evaluate first problem
              vector<ClassData> tmp_class_vector_a;
              tmp_class_vector_a.push_back(split_classes_vector[0]);
              tmp_class_vector_a.push_back(merged_class);

              // evaluate training error of first cluster against rest
              // of the classes
              double error_a;
              Classifier* tmp_classifier_a =
              create_classifier
                (
                split_classes_vector[0],
                merged_class,
                classifiers_option,
                error_a
                );

              // construct and evaluate second problem
              vector<ClassData> tmp_class_vector_b;
              tmp_class_vector_b.push_back(split_classes_vector[1]);
              tmp_class_vector_b.push_back(merged_class);

              // evaluate training error of second cluster against rest
              // of the classes
              double error_b;
              Classifier* tmp_classifier_b =
              create_classifier
                (
                split_classes_vector[1],
                merged_class,
                classifiers_option,
                error_b
                );

              // clean up temporary created classifiers
              delete tmp_classifier_a;
              delete tmp_classifier_b;

              // If improvement of at least one of the problems was
              // satisfying (comparison is done with respect the error
              // percentage)
              if(
                ((100.0 * (error - error_a)) / error) >=
                thres.Improvement() &&
                ((100.0 * ( error - error_b )) / error) >=
                thres.Improvement()
                )
                {
                // --- encoding matrix update --- //
                coding_matrix_update
                  (
                  coding_matrix,
                  class_vector,
                  split_classes_vector,
                  best_set_indices[0]
                  );

                // create the new ClassData vectors according to the
                // best set
                vector<ClassData> class_vector_a;
                class_vector_a.push_back(split_classes_vector[0]);

                vector<ClassData> class_vector_b;
                class_vector_b.push_back(split_classes_vector[1]);

                for(u32 i = 0; i < class_vector_size; i++)
                  {
                  if(!contains(best_set_indices, bestSetSize, i))
                    {
                    class_vector_a.push_back(class_vector[i]);
                    class_vector_b.push_back(class_vector[i]);
                    }
                  }

                // update class tracker
                update_class_tracker
                  (
                  class_tracker,
                  class_vector,
                  best_set_indices[0],
                  split_classes_vector,
                  classes_created_vector
                  );

                // delete first level classifier since is not needed
                delete first_level_classifier;

                // recursive calls to direct_subclass_encoding
                direct_subclass_encoding
                  (
                  class_vector_a,
                  thres,
                  criterion_option,
                  classifiers_option,
                  coding_matrix,
                  classifiers_vector,
                  classes_created_vector,
                  class_tracker,
                  problem_tracker
                  );

                direct_subclass_encoding
                  (
                  class_vector_b,
                  thres,
                  criterion_option,
                  classifiers_option,
                  coding_matrix,
                  classifiers_vector,
                  classes_created_vector,
                  class_tracker,
                  problem_tracker
                  );

                }
              else // Impovement wasn't good
                {
                // Reduce static class counter because the 2 new created
                // subclasses were rejected
                ClassData::globalIndex -= 2;

                // Create and save a classifier
                save_classifier
                  (
                  first_level_classifier,
                  class_vector,
                  best_set_indices,
                  complement_set_indices,
                  classifiers_vector
                  );

                // create the new ClassData vectors according to the
                // best set
                vector<ClassData> class_vector_a;
                vector<ClassData> class_vector_b;
                for(u32 i = 0; i < class_vector_size; i++)
                  {
                  if(contains(best_set_indices, bestSetSize, i))
                    {
                    class_vector_a.push_back(class_vector[i]);
                    }
                  else
                    {
                    class_vector_b.push_back(class_vector[i]);
                    }
                  }

                  // recursive calls to direct_subclass_encoding
                  direct_subclass_encoding
                    (
                    class_vector_a,
                    thres,
                    criterion_option,
                    classifiers_option,
                    coding_matrix,
                    classifiers_vector,
                    classes_created_vector,
                    class_tracker,
                    problem_tracker
                    );

                  direct_subclass_encoding
                    (
                    class_vector_b,
                    thres, criterion_option,
                    classifiers_option,
                    coding_matrix,
                    classifiers_vector,
                    classes_created_vector,
                    class_tracker,
                    problem_tracker
                    );

                  } // end of if - else improvement

                } // end of if - else clusters size

              }
            else // Performance was good
              {
              // Create and save a classifier for specified problem
              // configuration
              save_classifier
                (
                first_level_classifier,
                class_vector,
                best_set_indices,
                complement_set_indices,
                classifiers_vector
                );

              // create the new ClassData vectors according to the best
              // set
              vector<ClassData> class_vector_a;
              vector<ClassData> class_vector_b;
              for(u32 i = 0; i < class_vector_size; i++)
                {
                if(contains(best_set_indices, bestSetSize, i))
                  {
                  class_vector_a.push_back(class_vector[i]);
                  }
                else
                  {
                  class_vector_b.push_back(class_vector[i]);
                  }
                }

              // recursive calls to direct_subclass_encoding
              direct_subclass_encoding
                (
                class_vector_a,
                thres,
                criterion_option,
                classifiers_option,
                coding_matrix,
                classifiers_vector,
                classes_created_vector,
                class_tracker,
                problem_tracker
                );

              direct_subclass_encoding
                (
                class_vector_b,
                thres,
                criterion_option,
                classifiers_option,
                coding_matrix,
                classifiers_vector,
                classes_created_vector,
                class_tracker,
                problem_tracker
                );

              } // end of if - else performance

            }
          else // The unary partition is the complement set
            {
            ClassData merged_class = merge_selected_classes
                                       (
                                       class_vector,
                                       best_set_indices
                                       );

            ucolvec complement_set_indices = complement
                                               (
                                               best_set_indices,
                                               class_vector_size
                                               );

            vector<ClassData> tmp_class_vector;
            tmp_class_vector.push_back(merged_class);
            tmp_class_vector.push_back
              (
              class_vector[complement_set_indices[0]]
              );

            // evaluate training error for specific problem
            double error;
            Classifier* first_level_classifier =
              create_classifier
                (
                merged_class,
                class_vector[complement_set_indices[0]],
                classifiers_option,
                error
                );

            // if error of classification is larger than threshold
            if(error > thres.Performance())
              {
              ucolvec ind_a; // indices of first clustering
              ucolvec clust_num_a; // number of samples in each cluster

              // split first class into two subclasses
              mat centers_a =
                subClasses
                  (
                  ind_a,
                  clust_num_a,
                  class_vector[complement_set_indices[0]].Data()
                  );

              // if clusters sizes are less than threshold
              if(
                clust_num_a[0] < thres.Size() ||
                clust_num_a[1] < thres.Size()
                )
                {
                // Create and save a classifier specified problem
                // configuration
                save_classifier
                  (
                  first_level_classifier,
                  class_vector,
                  best_set_indices,
                  complement_set_indices,
                  classifiers_vector
                  );

                // create the new ClassData vectors according to the
                // best set
                vector<ClassData> class_vector_a;
                vector<ClassData> class_vector_b;
                for(u32 i = 0; i < class_vector_size; i++)
                  {
                  if(contains(best_set_indices, bestSetSize, i))
                    {
                    class_vector_b.push_back(class_vector[i]);
                    }
                  else
                    {
                    class_vector_a.push_back(class_vector[i]);
                    }
                  }

                // recursive calls to direct_subclass_encoding
                direct_subclass_encoding
                  (
                  class_vector_a,
                  thres,
                  criterion_option,
                  classifiers_option,
                  coding_matrix,
                  classifiers_vector,
                  classes_created_vector,
                  class_tracker,
                  problem_tracker
                  );

                direct_subclass_encoding
                  (
                  class_vector_b,
                  thres,
                  criterion_option,
                  classifiers_option,
                  coding_matrix,
                  classifiers_vector,
                  classes_created_vector,
                  class_tracker,
                  problem_tracker
                  );

                }
              else // else split first class
                {
                // Split the unary class and store its clusters in
                // vector split_classes_vector
                vector<ClassData> split_classes_vector =
                  split_class
                    (
                    class_vector[complement_set_indices[0]],
                    ind_a,
                    clust_num_a,
                    thres.Size()
                    );

                // construct and evaluate first problem
                vector<ClassData> tmp_class_vector_a;
                tmp_class_vector_a.push_back(split_classes_vector[0]);
                tmp_class_vector_a.push_back(merged_class);

                // evaluate training error of first cluster against rest
                // of the classes
                double error_a;
                Classifier* tmp_classifier_a =
                  create_classifier
                    (
                    split_classes_vector[0],
                    merged_class,
                    classifiers_option,
                    error_a
                    );

                // construct and evaluate second problem
                vector<ClassData> tmp_class_vector_b;
                tmp_class_vector_b.push_back(split_classes_vector[1]);
                tmp_class_vector_b.push_back(merged_class);

                // evaluate training error of second cluster against
                // rest of the classes
                double error_b;
                Classifier* tmp_classifier_b =
                  create_classifier
                    (
                    split_classes_vector[1],
                    merged_class,
                    classifiers_option,
                    error_b
                    );

                // clean up temporary created classifiers
                delete tmp_classifier_a;
                delete tmp_classifier_b;

                // If at least both of the new created problems give
                // better improvement than the improvement threshold
                // specified (comparison is done with respect the error
                // percentage)
                if(
                  ((100.0 * (error - error_a)) / error) >=
                  thres.Improvement() &&
                  ((100.0 * (error - error_b)) / error) >=
                  thres.Improvement()
                  )
                  {
                  // encoding matrix update
                  coding_matrix_update
                    (
                    coding_matrix,
                    class_vector,
                    split_classes_vector,
                    complement_set_indices[0]
                    );

                  // create the new ClassData vectors according to the
                  // best set
                  vector<ClassData> class_vector_a;
                  class_vector_a.push_back(split_classes_vector[0]);

                  vector<ClassData> class_vector_b;
                  class_vector_b.push_back(split_classes_vector[1]);

                  // load rest of the classes to each of the vectors
                  for(u32 i = 0; i < class_vector_size; i++)
                    {
                    if(contains(best_set_indices, bestSetSize, i))
                      {
                      class_vector_a.push_back(class_vector[i]);
                      class_vector_b.push_back(class_vector[i]);
                      }
                    }

                  // update class tracker
                  update_class_tracker
                    (
                    class_tracker,
                    class_vector,
                    complement_set_indices[0],
                    split_classes_vector,
                    classes_created_vector
                    );

                  // delete first level classifier since is not needed
                  delete first_level_classifier;

                  // recursive calls to direct_subclass_encoding
                  direct_subclass_encoding
                    (
                    class_vector_a,
                    thres,
                    criterion_option,
                    classifiers_option,
                    coding_matrix,
                    classifiers_vector,
                    classes_created_vector,
                    class_tracker,
                    problem_tracker
                    );

                  direct_subclass_encoding
                    (
                    class_vector_b,
                    thres,
                    criterion_option,
                    classifiers_option,
                    coding_matrix,
                    classifiers_vector,
                    classes_created_vector,
                    class_tracker,
                    problem_tracker
                    );

                  }
                else // Impovement wasn't good
                  {
                  // Reduce static class counter by 2 because two new
                  // creater clusters were rejected
                  ClassData::globalIndex -= 2;

                  // Create and save a classifier specified problem
                  // configuration
                  save_classifier
                    (
                    first_level_classifier,
                    class_vector,
                    best_set_indices,
                    complement_set_indices,
                    classifiers_vector
                    );

                  // create the new ClassData vectors according to the
                  // best set
                  vector<ClassData> class_vector_a;
                  vector<ClassData> class_vector_b;
                  for(u32 i = 0; i < class_vector_size; i++)
                    {
                    if(contains(best_set_indices, bestSetSize, i))
                      {
                      class_vector_b.push_back(class_vector[i]);
                      }
                    else
                      {
                      class_vector_a.push_back(class_vector[i]);
                      }
                    }

                  // recursive calls to direct_subclass_encoding
                  direct_subclass_encoding
                    (
                    class_vector_a,
                    thres,
                    criterion_option,
                    classifiers_option,
                    coding_matrix,
                    classifiers_vector,
                    classes_created_vector,
                    class_tracker,
                    problem_tracker
                    );

                  direct_subclass_encoding
                    (
                    class_vector_b,
                    thres,
                    criterion_option,
                    classifiers_option,
                    coding_matrix,
                    classifiers_vector,
                    classes_created_vector,
                    class_tracker,
                    problem_tracker
                    );

                  } // end of if - else improvement

                } // end of if - else clusters size

              }
            else // Performance is good
              {
              // Create and save a classifier specified problem
              // configuration
              save_classifier
                (
                first_level_classifier,
                class_vector,
                best_set_indices,
                complement_set_indices,
                classifiers_vector
                );

              // create the new ClassData vectors according to the best
              // set
              vector<ClassData> class_vector_a;
              vector<ClassData> class_vector_b;
              for(u32 i = 0; i < class_vector_size; i++)
                {
                if(contains(best_set_indices, bestSetSize, i))
                  {
                  class_vector_b.push_back(class_vector[i]);
                  }
                else
                  {
                  class_vector_a.push_back(class_vector[i]);
                  }
                }

              // recursive calls to direct_subclass_encoding
              direct_subclass_encoding
                (
                class_vector_a,
                thres,
                criterion_option,
                classifiers_option,
                coding_matrix,
                classifiers_vector,
                classes_created_vector,
                class_tracker,
                problem_tracker
                );

              direct_subclass_encoding
                (
                class_vector_b,
                thres,
                criterion_option,
                classifiers_option,
                coding_matrix,
                classifiers_vector,
                classes_created_vector,
                class_tracker,
                problem_tracker
                );

              } // end of if - else performance

            } // end of if - else bestset = 1 class else complementary
              // = 1 class

          }
        else // Both partitions of that were returned by SFFS contained
             // more than one class
          {
          // compute complements set's labels
          ucolvec complement_set_indices= complement
                                            (
                                            best_set_indices,
                                            class_vector_size
                                            );

          // merge classes of best set
          ClassData best_set_merged = merge_selected_classes
                                        (
                                        class_vector,
                                        best_set_indices
                                        );

          // merge classes rest classes
          ClassData complement_set_merged = merge_selected_classes
                                              (
                                              class_vector,
                                              complement_set_indices
                                              );

          // construct and evaluate first problem
          vector<ClassData> tmp_class_vector;
          tmp_class_vector.push_back(best_set_merged);
          tmp_class_vector.push_back(complement_set_merged);

          // create classifier to attack specific problem for specific
          // problem
          double error;
          Classifier* first_level_classifier = create_classifier
                                                (
                                                best_set_merged,
                                                complement_set_merged,
                                                classifiers_option,
                                                error
                                                );

          // Create and save a classifier specified problem
          // configuration
          save_classifier
            (
            first_level_classifier,
            class_vector,
            best_set_indices,
            complement_set_indices,
            classifiers_vector
            );

          // create the new ClassData vectors according to the best set
          vector<ClassData> class_vector_a;
          vector<ClassData> class_vector_b;
          for(u32 i = 0; i < class_vector_size; i++)
            {
            if(contains(best_set_indices, bestSetSize, i))
              {
              class_vector_a.push_back(class_vector[i]);
              }
            else
              {
              class_vector_b.push_back(class_vector[i]);
              }

            }

          // recursive calls to direct_subclass_encoding
          direct_subclass_encoding
            (
            class_vector_a,
            thres,
            criterion_option,
            classifiers_option,
            coding_matrix,
            classifiers_vector,
            classes_created_vector,
            class_tracker,
            problem_tracker
            );

          direct_subclass_encoding
            (
            class_vector_b,
            thres,
            criterion_option,
            classifiers_option,
            coding_matrix,
            classifiers_vector,
            classes_created_vector,
            class_tracker,
            problem_tracker
            );

          }

        }

    }

  }



void
subclass_encoding
  (
  const mat& samples,
  const icolvec& labels,
  const Threshold& thres,
  const int criterion_option,
  const int classifiers_option,
  imat& coding_matrix,
  vector<Classifier*>& classifiers_vector,
  vector<ClassData>& classes_created_vector
  )
  {
  // split the main sub problem into the corresponding classes
  vector<ClassData> initial_classes_vector = create_class_vector
                                               (
                                               samples,
                                               labels
                                               );

  // number of initial classes
  const u32 n_classes = initial_classes_vector.size();

  // intermediate class vector
  vector<ClassData> intermediate_classes_vector =
    initial_classes_vector;

  // vector that keeps track of splitting
  vector<colvec> class_tracker;

  // initialize class_tracker
  for(u32 i = 0; i < n_classes; i++)
    {
    colvec temp = zeros<colvec>(1);
    temp[0] = intermediate_classes_vector[i].ClassIndex();
    class_tracker.push_back(temp);
    }

  // initialize coding matrix
  coding_matrix = zeros<imat>(n_classes, 2);
  for(u32 i = 0; i < n_classes; i++)
    {
    coding_matrix(i, 0) = i + 1;
    coding_matrix(i, 1) = i + 1;
    }

  // problem tracker vector -- used to store problem examined so far
  // in order to prune the unnecessary recursive steps of the
  // direct_subclass_encoding procedure
  vector<ucolvec> problem_tracker;



  // engage recursive subclass creation procedure
  direct_subclass_encoding
    (
    initial_classes_vector,
    thres,
    criterion_option,
    classifiers_option,
    coding_matrix,
    classifiers_vector,
    intermediate_classes_vector,
    class_tracker,
    problem_tracker
    );

  // number of intermediate classes created in recursive procedure
  const u32 n_intermediate_classes = intermediate_classes_vector.size();

  // create the final subclasses vector from the intermediate
  // subclasses vector, by discarding the unnecessary created classes
  for(u32 k = 0; k < coding_matrix.n_rows; k++)
    {
    for(u32 l = 0; l < n_intermediate_classes; l++)
      {
      if(
        coding_matrix(k,1) ==
        intermediate_classes_vector[l].ClassIndex()
        )
        {
        classes_created_vector.push_back
           (
           intermediate_classes_vector[l]
           );

        break;
        }

      }

    }


  // by now the coding matrix is consisted of 2 columns. 1st column
  // represents initial class labels and 2nd colum represents resulting
  // classes indices (if label and index is the same then the initial
  // class didn't split into subclasses, if else the initial class
  // has been split into subclasses).

  // the next step is to use all the available information from the
  // recursive procedure direct_subclass_encoding in order to create the
  // codewords for each of the created classes (note: a class that has
  // been split into subclasses will be represented by as many codewords
  // in the coding matrix as the the number of its created subclasses)

  // create a temporary matrix to hold the codewords as well as the
  // class labels and indices (i.e., the first two rows of temp will be
  // the coding matrix so far)
  imat temp = zeros<imat>
                (
                coding_matrix.n_rows,
                coding_matrix.n_cols + classifiers_vector.size()
                );

  temp.cols(0, 1) = coding_matrix;

  // number of classifiers created
  const u32 n_classifiers = classifiers_vector.size();

  // number of encoding matrix rows
  const u32 n_rows = coding_matrix.n_rows;

  // for each classifier
  for(u32 i = 0; i < n_classifiers; i++)
    {
    // find the subclasses that the classifier recognizes and update the
    // corresponding column of the coding matrix with +1 or -1 according
    // to which set the subclass is contained (minus or plus subclass
    // set of classifier)

    // number of classes marked with +1 in current classifier
    const u32 n_plus_classes = classifiers_vector[i]->pos.size();

    // for plus subclasses
    for(u32 j = 0; j < n_plus_classes; j++)
      {

      // for each row of coding matrix
      for(u32 k = 0; k < n_rows; k++)
        {

        for
          (
          u32 l = 0;
          l < class_tracker[classifiers_vector[i]->pos[j]->ClassIndex() - 1].n_rows;
          l++
          )
          {
          // check if the subclass in the corresponding position of
          // class_tracker contains to the classifier
          if(
            class_tracker[classifiers_vector[i]->pos[j]->ClassIndex() - 1](l) ==
            coding_matrix(k, 1)
            )
            {
            temp(k, i + 2) = 1;
            }

          }

        }

      }

    // number of classes marked with -1 in current classifier
    const u32 n_minus_classes = classifiers_vector[i]->neg.size();

    // for minus subclasses
    for(u32 j = 0; j < n_minus_classes; j++)
      {

      // for each row of coding matrix
      for(u32 k = 0; k < n_rows; k++)
        {

        for
          (
          u32 l = 0;
          l < class_tracker[classifiers_vector[i]->neg[j]->ClassIndex() - 1].n_rows;
          l++
          )
          {

          // check if the subclass in the corresponding position of
          // class_tracker is contained in the classifier
          if(
            class_tracker[classifiers_vector[i]->neg[j]->ClassIndex() - 1](l) ==
            coding_matrix(k, 1)
            )
            {
            temp(k, i + 2) = -1;
            }

          }

        }

      }

    }

  // final coding matrix
  // each column represents a classifier
  // each row represents a codeword
  coding_matrix = temp.cols(2, temp.n_cols - 1);
  }



void
direct_decoc_encoding
  (
  const vector<ClassData>& class_vector,
  const int criterion_option,
  const int classifiers_option,
  vector<Classifier*>& classifiers_vector
  )
  {
  // number of initial classes
  const u32 n_classes = class_vector.size();

  // trivial recursion step
  if(n_classes == 1)
    {
    return;
    }
  else
    {
    // If class_vector vector contains only two classes
    // (trivial recursion step)
    if(n_classes == 2)
      {
      // create classifier
      Classifier* first_level_classifier =
        create_classifier
          (
          class_vector[0],
          class_vector[1],
          classifiers_option
          );

      // save classifier
      save_classifier
        (
        first_level_classifier,
        class_vector,
        classifiers_vector
        );


      }
    else // classes more than two
      {
      // run SFFS to configure binary decomposition of classes
      ucolvec best_set_indices = sffs(class_vector, criterion_option);

      // number of classes in the best subset of classes yield by SFFS
      const u32 bestSetSize = best_set_indices.n_rows;

      // The SFFS algorithm returned a problem configuration that one
      // partition contained one class and the other partition contained
      // many classes


      // compute complements set's labels
      ucolvec complement_set_indices= complement
                                        (
                                        best_set_indices,
                                        n_classes
                                        );

      // merge classes of best set
      ClassData best_set_merged = merge_selected_classes
                                    (
                                    class_vector,
                                    best_set_indices
                                    );

      // merge classes rest classes
      ClassData complement_set_merged = merge_selected_classes
                                          (
                                          class_vector,
                                          complement_set_indices
                                          );

      // construct and evaluate first problem
      vector<ClassData> tmp_class_vector;
      tmp_class_vector.push_back(best_set_merged);
      tmp_class_vector.push_back(complement_set_merged);

      // create classifier to attack specific problem for specific
      // problem
      Classifier* first_level_classifier = create_classifier
                                            (
                                            best_set_merged,
                                            complement_set_merged,
                                            classifiers_option
                                            );

      // Create and save a classifier specified problem
      // configuration
      save_classifier
        (
        first_level_classifier,
        class_vector,
        best_set_indices,
        complement_set_indices,
        classifiers_vector
        );

      // create the new ClassData vectors according to the best set
      vector<ClassData> class_vector_a;
      vector<ClassData> class_vector_b;
      for(u32 i = 0; i < n_classes; i++)
        {
        if(contains(best_set_indices, bestSetSize, i))
          {
          class_vector_a.push_back(class_vector[i]);
          }
        else
          {
          class_vector_b.push_back(class_vector[i]);
          }

        }

      // recursive calls to direct_subclass_encoding
      direct_decoc_encoding
        (
        class_vector_a,
        criterion_option,
        classifiers_option,
        classifiers_vector
        );

      direct_decoc_encoding
        (
        class_vector_b,
        criterion_option,
        classifiers_option,
        classifiers_vector
        );

      }

    }

  }




void
decoc_coding
  (
  const vector<ClassData>& class_vector,
  const int criterion_option,
  const int classifiers_option,
  imat& coding_matrix,
  vector<Classifier*>& classifiers_vector
  )
  {
  // number of initial classes
  const u32 n_classes = class_vector.size();

  // engage recursive DECOC tree creation procedure
  direct_decoc_encoding
    (
    class_vector,
    criterion_option,
    classifiers_option,
    classifiers_vector
    );

  // initialize coding matrix
  coding_matrix = zeros<imat>(n_classes, classifiers_vector.size());

  // fill in values of coding matrix
  for(u32 i = 0; i < classifiers_vector.size(); i++)
    {

    for(u32 j = 0; j < classifiers_vector[i]->pos.size(); j++)
      {
      coding_matrix(classifiers_vector[i]->pos[j]->ClassLabel() - 1, i) = 1;
      }

    for(u32 j = 0; j < classifiers_vector[i]->neg.size(); j++)
      {
      coding_matrix(classifiers_vector[i]->neg[j]->ClassLabel() - 1, i) = -1;
      }

    }

  }