source: trunk/test/iterator.cc @ 3375

// $Id: iterator.cc 3375 2015-02-11 09:25:39Z peter $

/*
  Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson, Markus Ringnér
  Copyright (C) 2009, 2010, 2012, 2013, 2014, 2015 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 <config.h>

#include "Suite.h"
#include "weighted_iterator_archetype.h"

#include "yat/classifier/DataLookup1D.h"

#include "yat/classifier/DataLookupWeighted1D.h"
#include "yat/classifier/KernelLookup.h"
#include "yat/classifier/MatrixLookup.h"
#include "yat/classifier/MatrixLookupWeighted.h"
#include "yat/utility/Container2DIterator.h"
#include "yat/utility/DataWeight.h"
#include "yat/utility/DataWeightProxy.h"
#include "yat/utility/DataIterator.h"
#include "yat/utility/Matrix.h"
#include "yat/utility/MatrixWeighted.h"
#include "yat/utility/stl_utility.h"
#include "yat/utility/Vector.h"
#include "yat/utility/VectorView.h"
#include "yat/utility/VectorConstView.h"
#include "yat/utility/WeightedIterator.h"
#include "yat/utility/WeightIterator.h"

#include <boost/concept_archetype.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>

#include <algorithm>
#include <fstream>
#include <iterator>
#include <map>
#include <set>
#include <string>
#include <vector>

using namespace theplu::yat;

void old_main(test::Suite&);

template<typename Iterator>
void is_weighted(Iterator, test::Suite&);

bool is_weighted(utility::unweighted_iterator_tag x) { return false; } 
bool is_weighted(utility::weighted_iterator_tag x) { return true; }

void test_boost_util(test::Suite&);
void test_pair_second_iterator(test::Suite&);

void test_data_iterator(test::Suite& suite);
void test_weight_iterator(test::Suite& suite);
void test_weighted_iterator_traits(test::Suite& suite);
void test_iterator_traits(test::Suite& suite);
void test_stride_iterator(test::Suite& suite);
void test_weighted_iterator(test::Suite& suite);
void test_matrix_lookup_iterator(test::Suite& suite);

int main(int argc, char* argv[])
{
  test::Suite suite(argc, argv);
  suite.err() << "testing iterator" << std::endl;

  test_stride_iterator(suite);
  old_main(suite);
  suite.out() << "testing boost_util\n";
  test_boost_util(suite);
  suite.out() << "testing iterator_traits\n";
  test_iterator_traits(suite);
  suite.out() << "testing pair_second_iterator\n";
  test_pair_second_iterator(suite);
  suite.out() << "testing weighted iterator\n";
  test_weighted_iterator(suite);
  test_data_iterator(suite);
  test_weight_iterator(suite);
  test_weighted_iterator_traits(suite);
  return suite.return_value();
}

template<typename Iterator>
void is_weighted(Iterator i, test::Suite& suite)
{
  suite.err() << "testing that iterator is unweighted... ";
  typename utility::weighted_iterator_traits<Iterator>::type tag;
  if (is_weighted(tag))
    suite.err() << "ok.\n";
  else {
    suite.err() << "failed.\n";
    suite.add(false);
  }
}


void old_main(test::Suite& suite)
{
  suite.err() << "testing utility::Vector::iterator" << std::endl;
  utility::Vector vec(12);
  classifier::DataLookup1D lookup(vec);
  utility::Vector::iterator begin=vec.begin();
  suite.test_random_access_iterator(begin);
  // test iterator to const_iterator conversion
  utility::Vector::const_iterator ci = vec.begin();
  suite.test_random_access_iterator(ci);
  ci = begin;
  if (begin!=ci)
    suite.add(false);

  suite.err() << "sorting...";
  utility::Vector::iterator end=vec.end();
  std::sort(begin, end);
  suite.err() << " sorting done\n";

  suite.err() << "testing classifier::DataLookup1D::const_iterator" << std::endl;
  classifier::DataLookup1D::const_iterator lbegin=lookup.begin();
  classifier::DataLookup1D::const_iterator lend=lookup.end();
  suite.test_random_access_iterator(lbegin);

  suite.err() << "copy from DataLookup1D to Vector" << std::endl;
  std::copy(lbegin, lend, begin);
  suite.err() << "copy from Vector to Vector" << std::endl;
  std::copy(begin, end, begin);
  suite.err() << "sort Vector" << std::endl;
  std::sort(begin, end);

  // test std algorithm on IteratorWeighted
  utility::MatrixWeighted m_w(1, 3, 1, 1);
  m_w(0,1).data()=2.0;
  classifier::MatrixLookupWeighted mw(m_w);
  classifier::DataLookupWeighted1D aw(mw,0,true);
  size_t nof1=std::count(aw.begin(),aw.end(),utility::DataWeight(1.0, 1.0));
  if(nof1!=2) {
    suite.err() << "std algoritm with IteratorWeighted failed" << std::endl;
    suite.add(false);
  }
  if (aw.begin()!=mw.begin_row(0))
    suite.add(false);
  if (aw.end()!=mw.end_row(0))
    suite.add(false);
  classifier::DataLookupWeighted1D aw2(mw,0,false);
  if (aw2.begin()!=mw.begin_column(0))
    suite.add(false);
  if (aw2.end()!=mw.end_column(0))
    suite.add(false);

  utility::DataIterator<classifier::DataLookupWeighted1D::const_iterator> 
    data_iter(aw2.begin());
  suite.out() << "testing data_iter\n";
  test::test_readable_iterator(data_iter);
  test::test_random_access_traversal_iterator(data_iter);
  suite.out() << "testing weight_iter\n";
  test::test_readable_iterator(weight_iterator(aw2.begin()));
  test::test_random_access_traversal_iterator(weight_iterator(aw2.begin()));
  suite.add(*data_iter == 1.0);
  suite.add(*data_iterator(aw2.begin()) == 1.0);
  std::vector<double> stl_vec(1,0);
  utility::DataIterator<std::vector<double>::iterator>
    data_iter2(stl_vec.begin());
  suite.add(*data_iter2 == 0.0);
  *data_iter2 = 3.14;
  suite.add(*data_iter2 == 3.14);
  utility::WeightIterator<std::vector<double>::iterator>
    data_iter3(stl_vec.begin());
  suite.add(*data_iter3 == 1.0);

  // testing constness conversion
  suite.out() << "testing const conversion\n";
  std::vector<double>::const_iterator c_iter(stl_vec.begin());
  std::vector<double>::iterator iter(stl_vec.begin());
  suite.add(iter==c_iter);
  utility::DataIterator<std::vector<double>::const_iterator>
    data_iter4(c_iter);
  utility::DataIterator<std::vector<double>::iterator>
    data_iter5(iter);
  suite.add(data_iter2 == data_iter5);
  suite.add(data_iter4 == data_iter5);
  utility::StrideIterator<std::vector<double>::const_iterator> stride_ci(c_iter);
  utility::StrideIterator<std::vector<double>::iterator> stride_i(iter);
  suite.add(stride_ci==stride_i);
  suite.add(stride_i==stride_ci);

  utility::MatrixWeighted x_weighted(3,4);
  x_weighted.begin();
  *x_weighted.begin();
  utility::DataWeight element = *x_weighted.begin();
  *(x_weighted.begin()+1) = element;
  double element_data = *data_iterator(x_weighted.begin());
  suite.add(element_data==x_weighted.begin()->data());

  utility::Matrix m(mw.rows(), mw.columns());
  classifier::MatrixLookup ml(m);
  classifier::DataLookup1D dl1(ml,0,true);
  if (dl1.begin()!=ml.begin_row(0))
    suite.add(false);
  if (dl1.end()!=ml.end_row(0))
    suite.add(false);
  classifier::DataLookup1D dl2(ml,0,false);
  if (dl2.begin()!=ml.begin_column(0))
    suite.add(false);
  if (dl2.end()!=ml.end_column(0))
    suite.add(false);

}

void test_boost_util(test::Suite& suite)
{
  bool ok_cached=suite.ok();
  utility::PairFirst<std::pair<std::string, int> > pf;
  std::pair<std::string, int> p("July", 31);
  std::string str=pf(p);
  suite.add(str=="July");
  pf(p)="juli";
  suite.add(pf(p)=="juli");

  typedef utility::PairFirst<std::pair<const std::string, int> > PF2;
  PF2 pf2;
  std::pair<const std::string, int> p2("July", 31);
  suite.add(pf2(p2)=="July");

  utility::PairFirst<const std::pair<std::string, int> > pf3;
  std::pair<std::string, int> p3("July", 31);
  suite.add(pf3(p3)=="July");

  utility::PairFirst<std::pair<std::string, const int> > pf4;
  std::pair<std::string, const int> p4("July", 31);
  suite.add(pf4(p4)=="July");
  pf4(p4)="juli";
  suite.add(pf4(p4)=="juli");

  utility::PairFirst<std::pair<const std::string, const int> > pf5;
  std::pair<const std::string, const int> p5("July", 31);
  suite.add(pf5(p5)=="July");

  typedef std::map<std::string, int> Map;
  Map m;
  m["July"]=31;
  m["September"]=30;
  m["June"]=30;
  m["April"]=30;

  boost::transform_iterator<PF2, Map::iterator> first_iterator(m.begin(), pf2);
  boost::transform_iterator<PF2, Map::iterator> first_iterator_end(m.end(), pf2);
  std::vector<std::string> vec(m.size());
  std::copy(first_iterator, first_iterator_end, vec.begin());
  std::vector<std::string> correct;
  correct.push_back("April");
  correct.push_back("July");
  correct.push_back("June");
  correct.push_back("September");
  for (size_t i=0; i<vec.size(); ++i)
    if (!suite.add(vec[i]==correct[i]))
      suite.err() << "Error: vec[" << i << "] = " << vec[i]
                  << " expected " << correct[i] << "\n";

  std::vector<std::string> vec2(m.size());
  std::copy(utility::pair_first_iterator(m.begin()),
            utility::pair_first_iterator(m.end()),
            vec2.begin());
  suite.add(vec2==vec);

  std::vector<int> days;
  days.resize(m.size());
  std::copy(utility::pair_second_iterator(m.begin()),
            utility::pair_second_iterator(m.end()),
            days.begin());
  std::vector<int> days_correct;
  days_correct.push_back(30);
  days_correct.push_back(31);
  days_correct.push_back(30);
  days_correct.push_back(30);
  for (size_t i=0; i<days.size(); ++i)
    if (!suite.add(days[i]==days_correct[i]))
      suite.err() << "Error: days[" << i << "] = " << days[i]
                  << " expected " << days_correct[i] << "\n";
  days = std::vector<int>(days.size(), 0);
  std::copy(days.begin(), days.end(), utility::pair_second_iterator(m.begin()));
  for (std::map<std::string, int>::const_iterator i=m.begin(); i!=m.end(); ++i)
    if (!suite.add(i->second==0) )
      suite.err() << "Error: m[" << i->first << "] = " << i->second
                  << " expected 0\n";

  if (ok_cached && !suite.ok())
    suite.err() << "test_bool_util failed" << std::endl;
}


void test_data_iterator(test::Suite& suite)
{
  // do not run compile test
  return;

  using utility::DataIterator;
  using boost::input_iterator_archetype;
  input_iterator_archetype<double> input_it;
  using boost::mutable_forward_iterator_archetype;
  mutable_forward_iterator_archetype<double> forward_it;

  using utility::data_iterator;
  std::copy(data_iterator(input_it),
            data_iterator(input_it),
            data_iterator(forward_it));

  boost::input_iterator_archetype_no_proxy<utility::DataWeight> input_it_w;
  mutable_forward_iterator_archetype<utility::DataWeight> forward_it_w;
  std::copy(data_iterator(input_it_w),
            data_iterator(input_it_w),
            data_iterator(forward_it_w));

}


void test_weight_iterator(test::Suite& suite)
{
  // do not run compile test
  return;

  using utility::WeightIterator;
  using boost::input_iterator_archetype;
  input_iterator_archetype<double> input_it;
  using boost::mutable_forward_iterator_archetype;

  // we are using weighted here because unweighted WeightIterator is
  // always const (not mutable)
  mutable_forward_iterator_archetype<utility::DataWeight> forward_it_w;

  using utility::weight_iterator;
  std::copy(weight_iterator(input_it),
            weight_iterator(input_it),
            weight_iterator(forward_it_w));

  boost::input_iterator_archetype_no_proxy<utility::DataWeight> input_it_w;
  std::copy(weight_iterator(input_it_w),
            weight_iterator(input_it_w),
            weight_iterator(forward_it_w));
}


void test_weighted_iterator_traits(test::Suite& suite)
{
  typedef boost::iterator_archetypes::readable_iterator_t Access;
  typedef boost::incrementable_traversal_tag Traversal;
  if (false) {
    typedef test::weighted_iterator_archetype<Access, Traversal> I;
    // test that boost trait class works
    typedef boost::iterator_value<I>::type value_type;
    // test that value type is DataWeight
    using utility::DataWeight;
    BOOST_STATIC_ASSERT((boost::is_same<value_type, DataWeight>::type::value));
    theplu::yat::utility::weighted_iterator_traits<I>::type tag;
    test::avoid_compiler_warning(tag);
  }
  if (false) {
    typedef double Value;
    typedef boost::iterator_archetype<Value, Access, Traversal> I;
    // test that boost trait class works
    typedef boost::iterator_value<I>::type value_type;
    // test that value type is double
    BOOST_STATIC_ASSERT((boost::is_same<value_type, double>::type::value));
    theplu::yat::utility::weighted_iterator_traits<I>::type tag;
    test::avoid_compiler_warning(tag);
  }
}


void test_iterator_traits(test::Suite& suite)
{
  typedef std::vector<utility::DataWeight>::iterator Iter;
  suite.add(utility::detail::iter_has_mutable_weight<Iter>::value);
  typedef std::vector<utility::DataWeight>::const_iterator Iter2;
  suite.add(!utility::detail::iter_has_mutable_weight<Iter2>::value);

  typedef std::vector<utility::DataWeight> WeightVector;
  WeightVector vec(1);
  utility::iterator_traits<WeightVector::iterator> traits;
  double w = traits.weight(vec.begin());
  traits.weight(vec.begin()) = w;
  suite.add(suite.equal(w, 1.0));

  utility::iterator_traits<WeightVector::const_iterator> c_traits;
  w = c_traits.weight(vec.begin());
  suite.add(suite.equal(w, 1.0));

  utility::iterator_traits<utility::DataWeight*>().weight(&vec[0]);

  double* trivial_iter = new double(1.0);
  utility::DataWeightProxy<double*, double*> dwp(trivial_iter,trivial_iter); 
  typedef utility::DataWeightProxy<double*, double*> Proxy;
  utility::iterator_traits<Proxy*> traits2;
  w = traits2.weight(&dwp);
  delete trivial_iter;

  // do not run compile test
  if (false) {
    using utility::DataWeight;
    using utility::iterator_traits;

    // test unweighted iterator
    typedef boost::iterator_archetypes::readable_iterator_t Access;
    typedef boost::incrementable_traversal_tag Traversal;
    // test unweighted iterator
    {
      typedef double Value;
      typedef boost::input_iterator_archetype<Value> I;
      I iter;
      iterator_traits<I> traits;
      double x = traits.data(iter);
      x = traits.weight(iter);
      test::avoid_compiler_warning(x);
    }
    // test weighted iterator
    {
      typedef test::weighted_iterator_archetype<Access, Traversal> I;
      test::ctor_arg arg;
      I iter(arg);
      iterator_traits<I> traits;
      double x = traits.data(iter);
      test::avoid_compiler_warning(x);
      double w = traits.weight(iter);
      test::avoid_compiler_warning(w);
    }
    // test with mutable weighted
    {
      typedef
        boost::iterator_archetypes::readable_writable_iterator_t MutableAccess;
      typedef test::weighted_iterator_archetype<MutableAccess, Traversal> I;
      test::ctor_arg arg;
      I iter(arg);
      iterator_traits<I> traits;
      double x = traits.data(iter);
      test::avoid_compiler_warning(x);
      double w = traits.weight(iter);
      test::avoid_compiler_warning(w);
      // test that return types are non-const
      traits.data(iter) = 0.5;
      traits.weight(iter) = 0.5;
    }
  }
}


void test_stride_iterator(test::Suite& suite)
{
  suite.err() << "testing StrideIterator" << std::endl;
  using utility::Vector;
  Vector a(10);
  // stride 2
  utility::VectorConstView b(a, 0, 5, 2);
  if (!suite.add(b.end()-b.begin()==5))
    suite.err() << "ERROR: StrideIterator::operator- returned: "
                << b.end()-b.begin()
                << " expected 5\n";
  utility::VectorView c(a, 0, 3, 2);
  Vector::iterator begin = c.begin();
  Vector::iterator end = c.end();
  Vector::const_iterator cbegin = begin;
  Vector::const_iterator cend = end;

  if (!suite.add(c.size()==3))
    suite.err() << "c.size() incorrect" << std::endl;
  if (!suite.add(cend-cbegin == 3))
    suite.err() << "cend-cbegin failed\n";

  typedef utility::Vector::iterator iterator;
  typedef std::reverse_iterator<iterator> reverse_iterator;

  reverse_iterator rbegin(c.end());
  reverse_iterator rend(c.begin());
  // some pointless usage of the iterators
  std::copy(rbegin, rend, rbegin);

  // do not run compile test
  if (false) {
    using utility::StrideIterator;
    StrideIterator<boost::random_access_iterator_archetype<double> > iter;
    suite.test_random_access_iterator(iter);
    double x = *iter;
    x *= 2; // avoid compiler warning

    // ticket #623
    typedef utility::Container2DIterator<const classifier::KernelLookup, 
      double, const double> c2dIter;
    BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<c2dIter>));

    typedef StrideIterator<c2dIter> StrideIter;
    StrideIter::iterator_category x623;
    std::random_access_iterator_tag y623(x623);
    BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<StrideIter>));
  }
}

void test_weighted_iterator(test::Suite& suite)
{
  std::vector<double> vec(3,1);
  typedef std::vector<double>::iterator Iter;
  typedef utility::WeightedIterator<Iter, Iter> WIter;
  WIter iter(vec.begin(), vec.begin());

  utility::DataWeight tmp = *iter;

  suite.test_bidirectional_iterator(iter);
  suite.test_random_access_iterator(iter);
  std::vector<double> data(vec.size());
  std::vector<double> weight(vec.size());
  WIter iter2(data.begin(), weight.begin());
  utility::DataWeight tmp2(6.89, 0.79);
  *iter2 = tmp2;
  if (!suite.add(tmp2==*iter2))
    suite.err() << "error: tmp2==*iter2" << std::endl;
  utility::DataWeight tmp3(*iter2);
  suite.add(suite.equal(tmp3.data(), tmp2.data()));
  suite.add(suite.equal(tmp3.weight(), tmp2.weight()));
  *iter2 = *iter;
  if (!suite.add(*iter2 == *iter))
    suite.err() << "error: *iter2 == *iter\n";
  tmp = *iter2;
  suite.add(suite.equal(tmp.data(), 1));
  std::copy(iter, iter+3, iter2);
  suite.add(suite.equal(vec.front(), 1));
  suite.add(suite.equal(data.front(), 1));

  suite.err() << "  testing const conversion\n";
  typedef std::vector<double>::const_iterator const_Iter;
  typedef utility::WeightedIterator<const_Iter, const_Iter> const_WIter;
  const_WIter const_iter(vec.begin(), vec.begin());
  const_iter = iter;

  suite.err() << "  testing assignment between different iterators\n";
  const std::vector<double> const_vec(10, 10.7);
  const_WIter const_iter2(const_vec.begin(), const_vec.begin());
  utility::DataWeight tmp4;
  tmp4 = *const_iter2;
  *iter = *const_iter2;
  suite.add(*iter==*const_iter2);
  *iter = *const_iter;
  suite.add(*iter==*const_iter);

  double x=101;
  utility::WeightedIterator<double*, double*> iter_p(&x, &x);
  *iter_p = *iter;
  suite.add(*iter_p==*iter);

  (*iter_p).data() = 99;
  suite.add(suite.equal(99, (*iter_p).data()));
  (*iter_p).weight() = 98;
  suite.add(suite.equal(98, (*iter_p).weight()));
}

void test_matrix_lookup_iterator(test::Suite& suite)
{
  classifier::MatrixLookup ml(10, 10);
  suite.test_random_access_iterator(ml.begin());
  std::vector<double> vec(ml.rows()*ml.columns());
  std::copy(ml.begin(), ml.end(), vec.begin());
}

void test_pair_second_iterator(test::Suite& suite)
{
  typedef std::map<std::string, std::string> C;
  C person2color;
  person2color["me"] = "yellow";
  person2color["you"] = "orange";

  C::const_iterator cbegin = person2color.begin();
  C::const_iterator cend = person2color.end();

  std::set<std::string> colors;
  colors.insert(utility::pair_second_iterator(cbegin),
               utility::pair_second_iterator(cend));

  suite.test_bidirectional_iterator(utility::pair_second_iterator(cbegin));
  suite.test_bidirectional_iterator(utility::pair_first_iterator(cbegin));
}