fn_aux.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)





// --- General Auxuliary Functions --- //



bool
contains
  (
  const ucolvec& A,
  const u32 n,
  const u32 i
  )
  {
  for(u32 j = 0; j < n; j++)
    {
    if(A[j] == i)
      {
      return true;
      }

    }

  return false;
  }



ucolvec
complement
  (
  const ucolvec& A,
  const u32 sizeU
  )
  {
  // allocate complement set
  ucolvec C = zeros<ucolvec>(sizeU - A.n_rows);

  // allocate universal set
  ucolvec U = linspace<ucolvec>(0, sizeU - 1, sizeU);

  u32 k = 0;
  for(u32 i = 0; i < sizeU; i++)
    {
    if(accu(A == U[i]) == 0) // no common indices
      {
      C[k] = U[i]; // update complementary set to A
      k++;
      }
    }

  return C;
  }



vector<ClassData>
create_class_vector
  (
  const mat& samples,
  const icolvec& labels
  )
  {
  // vector of ClassData objects that is to be returned
  vector<ClassData> cd;

  // number of classes
  const u32 classes_n = max(labels);

  vector<u32> classIndices[classes_n];

  const u32 n_rows = labels.n_rows;

  // compute class indices of each sample
  for(u32 i = 0; i < n_rows; i++)
    {
    classIndices[labels[i] - 1].push_back(i);
    }

  // for all classes
  for(u32 i = 0; i < classes_n; i++)
    {
    // temporary matrix that will hold the samples of class i + 1
    mat tmp = zeros< mat >(classIndices[i].size(), samples.n_cols);

    // s denotes the number of samples of class i + 1
    const u32 s = classIndices[i].size();


    for(u32 j = 0; j < s; j++ )
      {
      // update temporary matrix with rows of initial samples matrix
      // that correspond to class i + 1
      tmp.row(j) = samples.row(classIndices[i].at(j));
      }

    // create ClassData object and push it back to the vector
    ClassData tmp_class(tmp, i + 1);
    cd.push_back(tmp_class);
    }

  return cd;
  }



mat
create_samples_matrix
  (
  const vector<ClassData>& v
  )
  {
  // matrix that will be created from the vector of ClassData objects
  mat samples;
  const u32 s = v.size();

  // for all ClassData objects
  for(u32 i = 0; i < s; i++)
    {
    // append the columns of each ClassData data matrix to the whole matrix
    samples = join_cols(samples, v[i].Data());
    }

  return samples;
  }



void
create_samples_matrix
  (
  const vector<ClassData>& v,
  mat& samples,
  icolvec& labels
  )
  {
  const u32 s = v.size();

  // reset samples and labels in case they aren't empty
  samples.reset();
  labels.reset();

  // for all ClassData objects
  for(u32 i = 0; i < s; i++)
    {
    // append the columns of each ClassData data matrix and
    // create label vector containing labels from 1 to s for the whole matrix
    samples = join_cols(samples, v[i].Data());
    labels = join_cols(labels, (i + 1) * ones<icolvec>(v[i].Data().n_rows));
    }

  }



void
create_samples_matrix
  (
  const ClassData& first_class,
  const ClassData& second_class,
  mat& samples,
  icolvec& labels
  )
  {
  // reset samples and labels in case they aren't empty
  samples.reset();
  labels.reset();

  // create samples by joining samples of ClassData objects
  samples = join_cols(first_class.Data(), second_class.Data());

  // create labels that contain 1 and 2 for the two classes
  labels = join_cols(ones<icolvec>(second_class.Data().n_rows), 2 * ones<icolvec>(second_class.Data().n_rows));
  }



void
create_samples_matrix
  (
  const vector<ClassData>& v,
  mat& samples,
  icolvec& labels,
  ucolvec& n_per_class
  )
  {
  const u32 s = v.size();

  // reset samples and labels in case they aren't empt
  samples.reset();
  labels.reset();

  n_per_class.set_size(s);

  // for all ClassData objects
  for(u32 i = 0; i < s; i++)
    {
    // append columns of each ClassData data matrix
    samples = join_cols(samples, v[i].Data());

    // compute number of data samples per class
    n_per_class[i] = v[i].Data().n_rows;

    // update the label vector
    labels = join_cols(labels, (i+1) * ones<icolvec>(v[i].Data().n_rows));
    }

  }



ClassData
merge_classes_vector
  (
  const vector<ClassData>& v
  )
  {
  // matrix that will contain the whole data of all ClassData objects
  mat samples;

  const u32 s = v.size();

  // for all ClassData objects
  for(u32 i = 0; i < s; i++)
    {
    // append data from each object
    samples = join_cols(samples, v[i].Data());
    }

  // create the new ClassData object with the whole data matrix
  ClassData c(samples, -2, false, -1);

  return c;
  }



ClassData
merge_selected_classes
  (
  const vector<ClassData>& v,
  const ucolvec& s
  )
  {
  const u32 bsSize = s.n_rows;

  // matrix that will contain the whole data of all ClassData objects
  mat dat;

  // for all ClassData object that belong to the subset of classes of the initial vector v
  for(u32 i = 0; i < bsSize; i++)
    {
    // append columns of data matrices that belong to the subset of ClassData objects
    dat = join_cols(dat, v[s[i]].Data());
    }

  // create a new ClassData object with the new data matrix
  ClassData c(dat, -2, false, -1);

  return c;
  }



vector<ClassData>
split_class
  (
  const ClassData& c,
  const ucolvec& indices,
  const ucolvec& samples_per_cluster,
  const int are_valid
  )
  {
  // vector of ClassData objects that will be returned
  vector< ClassData > v;

  // number of sample attributes
  const u32 n_attr = c.Data().n_cols;

  // allocate space for first class matrix
  mat tmp_mat_A = zeros<mat>(samples_per_cluster[0], n_attr);

  // allocate space for second class matrix
  mat tmp_mat_B = zeros<mat>(samples_per_cluster[1], n_attr);

  // auxuliary index counters
  u32 counter_a = 0;
  u32 counter_b = 0;

  // number of samples to extract from initial class
  const u32 indices_n = indices.n_rows;

  for(u32 i = 0; i < indices_n; i++)
    {
    if(indices[i] == 0) // first class
      {
      // update data matrix of first class
      tmp_mat_A.row(counter_a) = c.Data().row(i);

      // increase number of elements in first class
      counter_a++;
      }
    else
      {
      // update data matrix of second class
      tmp_mat_B.row(counter_b) = c.Data().row(i);

      // increase number of elements in second class
      counter_b++;
      }

     }

  // create new classes
  ClassData c1(tmp_mat_A, c.ClassLabel(), true, are_valid);
  ClassData c2(tmp_mat_B, c.ClassLabel(), true, are_valid);

  // push newly created classes to output vector
  v.push_back(c1);
  v.push_back(c2);

  return v;
  }



ucolvec
complement_sffs
  (
  const ucolvec& A,
  const u32 curSubsetSize
  )
  {
  const u32 sizeU = A.n_rows;

  // allocate complement set
  ucolvec C = zeros<ucolvec>(sizeU - curSubsetSize);

  // allocate universal set
  ucolvec U = linspace<ucolvec>(0, sizeU - 1, sizeU);

  u32 k = 0;
  for(u32 i = 0; i < sizeU; i++)
    {
    // if no element of A belongs to the universal set
    if(accu(A.rows(0, curSubsetSize - 1) == U[i]) == 0)
      {
      // the i-th element belongs to the complement of A
      C[k] = U[i];
      k++;
      }
    }

  return C;
  }