grid_agent_mapping.h

Go to the documentation of this file.

#ifndef FPMAS_GRID_AGENT_MAPPING_G
#define FPMAS_GRID_AGENT_MAPPING_G
 
#include "fpmas/api/model/spatial/grid.h"
#include "fpmas/random/distribution.h"
#include "fpmas/random/random.h"
#include "spatial_agent_mapping.h"
 
 
namespace fpmas { namespace model {
    using api::model::DiscretePoint;
    using api::model::DiscreteCoordinate;
 
    class RandomGridAgentMapping : public api::model::SpatialAgentMapping<api::model::GridCell> {
        private:
            std::unordered_map<DiscreteCoordinate, std::unordered_map<DiscreteCoordinate, std::size_t>> count_map;
        public:
            template<typename DistributionX, typename DistributionY>
            RandomGridAgentMapping(
                    DistributionX&& x,
                    DistributionY&& y,
                    std::size_t agent_count
                    );
 
            std::size_t countAt(api::model::GridCell* cell) override {
                // When values are not in the map, 0 (default initialized) will
                // be returned
                return count_map[cell->location().x][cell->location().y];
            }
    };
 
    template<typename DistributionX, typename DistributionY>
        RandomGridAgentMapping::RandomGridAgentMapping(
                DistributionX&& x,
                DistributionY&& y,
                std::size_t agent_count) {
 
            for(std::size_t i = 0; i < agent_count; i++) {
                DiscretePoint p {x(RandomMapping::rd), y(RandomMapping::rd)};
                count_map[p.x][p.y]++;
            }
        }
 
 
    class UniformGridAgentMapping : public RandomGridAgentMapping {
        public:
            UniformGridAgentMapping(
                    DiscreteCoordinate grid_width,
                    DiscreteCoordinate grid_height,
                    std::size_t agent_count
                    ) 
                : RandomGridAgentMapping(
                        random::UniformIntDistribution<DiscreteCoordinate>(0, grid_width-1),
                        random::UniformIntDistribution<DiscreteCoordinate>(0, grid_height-1),
                        agent_count) {}
    };
 
    class ConstrainedGridAgentMapping : public api::model::SpatialAgentMapping<api::model::GridCell> {
        private:
            std::unordered_map<DiscreteCoordinate, std::unordered_map<DiscreteCoordinate, std::size_t>>
                count_map;
        public:
            ConstrainedGridAgentMapping(
                    DiscreteCoordinate grid_width,
                    DiscreteCoordinate grid_height,
                    std::size_t agent_count,
                    std::size_t max_agent_by_cell
                    );
 
        std::size_t countAt(api::model::GridCell* cell) override;
    };
 
}}
#endif