AgentSet.h

/*
 *   Repast for High Performance Computing (Repast HPC)
 *
 *   Copyright (c) 2010 Argonne National Laboratory
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with
 *   or without modification, are permitted provided that the following
 *   conditions are met:
 *
 *     Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *
 *     Redistributions in binary form must reproduce the above copyright notice,
 *     this list of conditions and the following disclaimer in the documentation
 *     and/or other materials provided with the distribution.
 *
 *     Neither the name of the Argonne National Laboratory nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 *   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
 *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 *   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 *  AgentSet.h
 *
 *  Created on: Jul 16, 2010
 *      Author: nick
 */
 
#ifndef AGENTSET_H_
#define AGENTSET_H_
 
 
#define USE_RANDOM_RELOGO_SET_OPS
 
#include <vector>
#include <algorithm>
#include <iostream>
#include <limits>
 
#include "repast_hpc/Random.h"
 
namespace repast {
 
namespace relogo {
 
template<typename T, typename ValueGetter>
struct SetCmp {
 
        const ValueGetter* _getter;
 
        SetCmp(const ValueGetter* getter) :
                _getter(getter) {
        }
 
        bool operator()(T* one, T* two) {
                return (*_getter)(one) < (*_getter)(two);
        }
};
 
template<typename T>
class AgentSet {
 
public:
        typedef typename std::vector<T*>::iterator as_iterator;
        typedef typename std::vector<T*>::const_iterator const_as_iterator;
 
        AgentSet();
 
        template<typename input_iterator>
        AgentSet(input_iterator start, input_iterator end);
 
        AgentSet(const AgentSet& set);
 
        virtual ~AgentSet();
 
        template<typename input_iterator>
        void addAll(input_iterator begin, input_iterator end);
 
        void add(T* agent);
 
        template<typename Functor>
        void ask(Functor func);
 
        template<typename Functor, typename P1>
        void ask(Functor func, const P1& p1);
 
        template<typename Functor, typename P1>
        void ask(Functor func, P1& p1);
 
        template<typename Functor>
        void apply(Functor& func);
 
        template<typename Functor>
        void apply(const Functor& func);
 
        T* at(int index);
 
        size_t count() const {
                return agents.size();
        }
 
        size_t size() const {
                return agents.size();
        }
 
        T* operator[](size_t index);
 
        as_iterator begin() {
                return agents.begin();
        }
 
        const_as_iterator begin() const {
                return agents.begin();
        }
 
        as_iterator end() {
                return agents.end();
        }
 
        const_as_iterator end() const {
                return agents.end();
        }
 
        void clear() {
                agents.clear();
        }
 
        template<typename ValueGetter>
        T* minOneOf(const ValueGetter& getter);
 
        template<typename ValueGetter>
        T* maxOneOf(const ValueGetter& getter);
 
        template<typename ValueGetter>
        void withMin(const ValueGetter& getter, AgentSet<T>& set);
 
        template<typename ValueGetter>
        void withMax(const ValueGetter& getter, AgentSet<T>& set);
 
        template<typename ValueGetter>
        void minNOf(size_t count, const ValueGetter& getter, AgentSet<T>& set, bool initialSetIsSorted = false);
 
        template<typename ValueGetter>
        void maxNOf(size_t count, const ValueGetter& getter, AgentSet<T>& set, bool initialSetIsSorted = false);
 
        T* oneOf();
 
        void remove(T* agent);
 
        void shuffle();
 
//private:
        std::vector<T*> agents;
 
};
 
template<typename T>
AgentSet<T>::AgentSet() {
}
 
template<typename T>
template<typename input_iterator>
AgentSet<T>::AgentSet(input_iterator start, input_iterator end) :
        agents(start, end) {
        std::random_shuffle(agents.begin(), agents.end(), uni_random);
}
 
template<typename T>
AgentSet<T>::AgentSet(const AgentSet& set) :
        agents(set.agents.begin(), set.agents.end()) {
}
 
template<typename T>
AgentSet<T>::~AgentSet() {
}
 
template<typename T>
void AgentSet<T>::shuffle() {
        std::random_shuffle(agents.begin(), agents.end(), uni_random);
}
 
template<typename T>
template<typename input_iterator>
void AgentSet<T>::addAll(input_iterator begin, input_iterator end) {
        agents.insert(agents.end(), begin, end);
}
 
template<typename T>
T* AgentSet<T>::operator[](size_t index) {
        return agents[index];
}
 
template<typename T>
void AgentSet<T>::add(T* agent) {
        agents.push_back(agent);
}
 
template<typename T>
T* AgentSet<T>::at(int index) {
        return agents.at(index);
}
 
template<typename T>
template<typename Functor>
void AgentSet<T>::apply(Functor& func) {
        for (as_iterator iter = agents.begin(); iter != agents.end(); ++iter) {
                func(*iter);
        }
}
 
template<typename T>
template<typename Functor>
void AgentSet<T>::apply(const Functor& func) {
        for (as_iterator iter = agents.begin(); iter != agents.end(); ++iter) {
                func(*iter);
        }
}
 
template<typename T>
template<typename Functor>
void AgentSet<T>::ask(Functor func) {
        for (as_iterator iter = agents.begin(); iter != agents.end(); ++iter) {
                T* target = *iter;
                (target->*func)();
        }
}
 
template<typename T>
template<typename Functor, typename P1>
void AgentSet<T>::ask(Functor func, const P1& p1) {
        for (as_iterator iter = agents.begin(); iter != agents.end(); ++iter) {
                T* target = *iter;
                (target->*func)(p1);
        }
}
 
template<typename T>
template<typename Functor, typename P1>
void AgentSet<T>::ask(Functor func, P1& p1) {
        for (as_iterator iter = agents.begin(); iter != agents.end(); ++iter) {
                T* target = *iter;
                (target->*func)(p1);
        }
}
 
template<typename T>
template<typename ValueGetter>
T* AgentSet<T>::minOneOf(const ValueGetter& getter) {
        if (agents.size() == 0)
                return 0;
 
        std::vector<T*> mins;
        double min = std::numeric_limits<double>::max();
        for (as_iterator iter = agents.begin(); iter != agents.end(); ++iter) {
                T* agent = *iter;
                double val = getter(agent);
                if (val < min) {
                        mins.clear();
                        mins.push_back(agent);
                        min = val;
                } else if (val == min) {
                        mins.push_back(agent);
                }
        }
 
        if (mins.size() > 1) {
                int index = (int) Random::instance()->createUniIntGenerator(0, mins.size() - 1).next();
                return mins[index];
        } else
          return mins[0];
}
 
template<typename T>
template<typename ValueGetter>
T* AgentSet<T>::maxOneOf(const ValueGetter& getter) {
        if (agents.size() == 0)
                return 0;
 
        std::vector<T*> maxs;
        double max = -(std::numeric_limits<double>::max());
        for (as_iterator iter = agents.begin(); iter != agents.end(); ++iter) {
                T* agent = *iter;
                double val = getter(agent);
                if (val > max) {
                        maxs.clear();
                        maxs.push_back(agent);
                        max = val;
                } else if (val == max) {
                        maxs.push_back(agent);
                }
        }
 
        if (maxs.size() > 1) {
                int index = (int) Random::instance()->createUniIntGenerator(0, maxs.size() - 1).next();
                return maxs[index];
        } else
                return maxs[0];
}
 
template<typename T>
template<typename ValueGetter>
void AgentSet<T>::withMin(const ValueGetter& getter, AgentSet<T>& set) {
        set.clear();
        if (agents.size() == 0)
                return;
 
        double min = std::numeric_limits<double>::max();
        for (as_iterator iter = agents.begin(); iter != agents.end(); ++iter) {
                T* agent = *iter;
                double val = getter(agent);
                if (val < min) {
                        set.clear();
                        set.add(agent);
                        min = val;
                } else if (val == min) {
                        set.add(agent);
                }
        }
}
 
template<typename T>
template<typename ValueGetter>
void AgentSet<T>::withMax(const ValueGetter& getter, AgentSet<T>& set) {
  set.clear();
  if (agents.size() == 0)  return;
  //  double max = std::numeric_limits<double>::min();      // This gives smallest positive number
  double max = std::numeric_limits<double>::max() * (-1);   // CORRECTED
  for (as_iterator iter = agents.begin(); iter != agents.end(); ++iter) {
    T* agent = *iter;
    double val = getter(agent);
    if (val > max) {
      set.clear();
      set.add(agent);
      max = val;
    } else if (val == max) {
      set.add(agent);
    }
  }
}
template<typename T>
template<typename ValueGetter>
void AgentSet<T>::minNOf(size_t count, const ValueGetter& getter, AgentSet<T>& set, bool initialSetIsSorted) {
        set.clear();
        if (size() <= count) {
                set.addAll(begin(), end());
        } else {
                AgentSet<T> tmp(begin(), end());
                if(!initialSetIsSorted){
      SetCmp<T, ValueGetter> cmp(&getter);
      sort(tmp.begin(), tmp.end(), cmp);
                }
#ifdef USE_RANDOM_RELOGO_SET_OPS
                int numberToAdd = count;
                while(numberToAdd > 0){
                  double v1 = getter(tmp[0]);
                  int indx = 1;
                  while(getter(tmp[indx]) == v1) indx++;
                  if(indx <= numberToAdd){
                    for(size_t i = 0; i < indx; i++){
                      set.add(tmp[0]);
                      numberToAdd--;
                      tmp.remove(tmp[0]);
                    }
                  }
                  else{ // Must choose randomly from the remaining qualified entries
                    while(numberToAdd > 0){
          int i = (int) Random::instance()->createUniIntGenerator(0, indx - 1).next();
          set.add(tmp[i]);
          numberToAdd--;
          tmp.remove(tmp[i]);
          indx--;
                    }
                  }
                }
#else
                for (size_t i = 0; i < count; i++) {
                        set.add(tmp[i]);
                }
#endif
        }
}
 
template<typename T>
template<typename ValueGetter>
void AgentSet<T>::maxNOf(size_t count, const ValueGetter& getter, AgentSet<T>& set, bool initialSetIsSorted) {
        set.clear();
        if (size() <= count) {
                set.addAll(begin(), end());
        } else {
                AgentSet<T> tmp(begin(), end());
                if(!initialSetIsSorted){
      SetCmp<T, ValueGetter> cmp(&getter);
      sort(tmp.begin(), tmp.end(), cmp);
                }
#ifdef USE_RANDOM_RELOGO_SET_OPS
                int numberToAdd = count;
                int endIndx = tmp.size() -1;
    while(numberToAdd > 0){
      double v1 = getter(tmp[endIndx]);
      int indx = endIndx - 1;
      while(getter(tmp[indx]) == v1) indx--;
      if((endIndx - indx) <= numberToAdd){
        while( endIndx > indx){
          set.add(tmp[endIndx]);
          numberToAdd--;
          tmp.remove(tmp[endIndx]);
          endIndx--;
        }
      }
      else{ // Must choose randomly from the remaining qualified entries
        while(numberToAdd > 0){
          int i = (int) Random::instance()->createUniIntGenerator(indx + 1, endIndx).next();
          set.add(tmp[i]);
          numberToAdd--;
          tmp.remove(tmp[i]);
          endIndx--;
        }
      }
    }
#else
                for (size_t i = tmp.size() - count; i < tmp.size(); i++) {
                        set.add(tmp[i]);
                }
#endif
        }
}
 
template<typename T>
T* AgentSet<T>::oneOf() {
        size_t size = agents.size();
        if (size == 0)
                return 0;
        int index = (int) Random::instance()->createUniIntGenerator(0, size - 1).next();
        return agents[index];
}
 
template<typename T>
void AgentSet<T>::remove(T* agent) {
        typename std::vector<T*>::iterator iter = agents.begin();
        while (iter != agents.end()) {
                iter = std::find(iter, agents.end(), agent);
                if (iter != agents.end())
                        iter = agents.erase(iter);
        }
}
 
}
 
}
 
#endif /* AGENTSET_H_ */