Target.h

#ifndef _theplu_yat_classifier_target_ 
#define _theplu_yat_classifier_target_ 

// $Id: Target.h 2119 2009-12-12 23:11:43Z peter $

/*
  Copyright (C) 2005 Peter Johansson
  Copyright (C) 2006 Jari Häkkinen, Peter Johansson, Markus Ringnér
  Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 3 of the
  License, or (at your option) any later version.

  The yat library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "yat/utility/deprecate.h"
#include "yat/utility/Exception.h"

#include <iosfwd>
#include <map>
#include <stdexcept>
#include <string>
#include <vector>

namespace theplu {
namespace yat {
  namespace utility {
    class Index;
  }
namespace classifier {  

  class Target
  {
  
  public:
    Target(void);

    explicit Target(const std::vector<std::string>& labels);

    Target(const std::vector<std::string>& labels, const Target&);

    Target(std::istream&, char sep='\0') 
      throw (utility::IO_error,std::exception);

    Target(const Target& org, const utility::Index& vec);

    ~Target();

    const std::map<std::string,size_t>& classes(void) const;
    
    size_t nof_classes(void) const;

    bool binary(size_t i) const;
    
    const std::vector<std::string>& labels(void);

    void set_binary(size_t i, bool b);

    void random_shuffle(void);

    size_t size(void) const;

    size_t size(const std::string& label) const;

    size_t size(size_t cl) const;


    size_t operator()(size_t sample) const;
    
    size_t operator[](size_t sample) const YAT_DEPRECATE;

    const Target& operator=(const Target&);

  private:
    // using compiler generated constructor
    //Target(const Target& other); 

    // binary target for class i
    std::vector<char> binary_; // avoid using vector<bool>
    std::vector<size_t> classes_; // class of sample i
    // map between class label and class index (inverse of labels_)
    std::map<std::string,size_t> class_map_;  
    std::vector<std::string> labels_; // label of class i
    
    void init(const std::vector<std::string>&);

  };  
  
  std::ostream& operator<<(std::ostream&, const Target& );

}}} // of namespace classifier, yat, and theplu

#endif