source: trunk/c++_tools/classifier/Target.cc @ 675

// $Id$

/*
  Copyright (C) The authors contributing to this file.

  This file is part of the yat library, http://lev.thep.lu.se/trac/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 2 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 this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#include "yat/classifier/Target.h"
#include "yat/random/random.h"
#include "yat/utility/stl_utility.h"
#include "yat/utility/utility.h"

#include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <string>
#include <sstream>
#include <utility>
#include <vector>

namespace theplu {
namespace classifier {

  Target::Target(const std::vector<std::string>& label)
  {
    init(label);
  }
  
  Target::Target(const Target& t, 
                 const std::vector<size_t>& index)
    : class_map_(t.class_map_)
  {
    binary_=t.binary_;
    classes_.resize(index.size());
    for (size_t i=0; i<index.size(); i++) {
      assert(index[i]<t.size());
      classes_[i]=t.classes_[index[i]];
    }
    labels_ = t.labels_;
  }


  Target::Target(std::istream& is, char sep) 
    throw (utility::IO_error,std::exception)
  {
    std::vector<std::string> vec;
    std::string word;
    bool ok=true;
    while(ok) {
      if(sep=='\0')
        ok=(is>>word);
      else 
        ok=getline(is, word, sep);

      // ignore empty words
      if (!word.size() || !ok )
        continue;
      
      vec.push_back(word);
    }

    // manipulate the state of the stream to be good
    is.clear(std::ios::goodbit);

    init(vec);
  }
  
  Target::~Target(void)
  {
  }

  void Target::init(const std::vector<std::string>& label) 
  {
    classes_.clear();
    classes_.reserve(label.size());
    class_map_.clear();
    labels_.clear();
    
    for (size_t i=0; i<label.size(); i++) {
      std::map<std::string,size_t>::iterator iter = 
        class_map_.lower_bound(label[i]);

      // label in map
      if (iter != class_map_.end() && 
          !(class_map_.key_comp()(label[i],iter->first)) ){

        classes_.push_back(iter->second);
      }
      // label not found in map
      else{
        classes_.push_back(class_map_.size());
        class_map_.insert(iter, std::make_pair(label[i],classes_[i])); 
        labels_.push_back(label[i]);
      }
    }
    // setting binary to false for every class
    binary_=std::vector<char>(nof_classes(),false);
    
    set_binary(0,true);
  }

  void Target::random_shuffle(void)
  {
    random::DiscreteUniform d;
    std::random_shuffle(classes_.begin(), classes_.end(),d);
  }

  const size_t Target::size(const std::string& label) const 
  {
    std::map<std::string,size_t>::const_iterator i=class_map_.find(label);    
    if(i==class_map_.end())
      return 0;
    assert(i->first==label);
    return size(i->second);
  }
  
  const size_t Target::size(size_t cl) const
  {
    return std::count(classes_.begin(),classes_.end(),cl);
  }


  std::ostream& operator<<(std::ostream& s, const Target& a)
  {
    for (size_t j = 0; j < a.size(); ++j) {
      s << a(j);
      if ( (j+1)<a.size() )
        s << " ";
    }

    return s;
  }


  const Target& Target::operator=(const Target& other)
  {
    binary_ = other.binary_;
    classes_ = other.classes_;
    class_map_ = other.class_map_;
    labels_ = other.labels_;
    return *this;
  }


}} // of namespace classifier and namespace theplu