Symbiont.h

#ifndef SYMBIONT_H
#define SYMBIONT_H

#include "../../Empirical/include/emp/math/Random.hpp"
#include "../../Empirical/include/emp/tools/string_utils.hpp"
#include "SymWorld.h"
#include <set>
#include <iomanip> // setprecision
#include <sstream> // stringstream
#include <optional>

class Symbiont: public Organism {
protected:
  /**
    *
    * Purpose: Represents the interaction value between the host and symbiont.
    * A negative interaction value represent antagonism, while a positive
    * one represents mutualism. Zero is a neutral value.
    *
  */
  double interaction_val = 0;

  /**
    *
    * Purpose: Represents the resource points possessed by a symbiont.
    * This is what host's must collect to reproduce.
    *
  */
  double points = 0;

  /**
    *
    * Purpose: Represents if a symbiont is alive.
    * This is set to true when a symbiont is killed.
    *
  */
  bool dead = false;

  /**
    *
    * Purpose: Represents the chance (between 0 and 1) that
    * a free-living sym will infect a parallel host on process
    *
  */
  double infection_chance = 0.0;

  /**
    *
    * Purpose: Represents the number of updates the symbiont
    * has lived through; at birth is set to 0.
    *
  */
  int age = 0;

  /**
    *
    * Purpose: Tracks the number of reproductive events in this symbiont's lineage.
    *
  */
  size_t reproductions = 0;

  /**
   *
   * Purpose: Tracks the number of tag flips towards partner in this symbiont's lineage.
   *
 */
  size_t towards_partner_count = 0;

  /**
    *
    * Purpose: Tracks the number of tag flips away from partner in this symbiont's lineage.
    *
  */
  size_t from_partner_count = 0;

  /**
    *
    * Purpose: Represents an instance of random.
    *
  */
  emp::Ptr<emp::Random> random = NULL;

  /**
    *
    * Purpose: Represents the world that the hosts are living in.
    *
  */
  emp::Ptr<SymWorld> my_world = NULL;

  /**
    *
    * Purpose: Represents the symbiont's host.
    *
  */
  emp::Ptr<Organism> my_host = NULL;

  /**
    *
    * Purpose: Represents the configuration settings for a particular run.
    *
  */
  emp::Ptr<SymConfigBase> my_config = NULL;

  /**
    *
    * Purpose: Tracks the taxon of this organism.
    *
  */
  emp::Ptr<taxon_t::base_taxon_t> my_taxon = NULL;

  /**
    *
    * Purpose: Represents the tag for this organism
    *
  */
  emp::BitSet<TAG_LENGTH> tag;

  /**
   *
   * Purpose: To track location in the world
   * id/Index is position in the host's symbiont vector if the symbiont is hosted, and 0 if the symbiont is free-living
   * If the symbiont is hosted, the population id is the host's location in the world. If the symbiont is free-living, it is the location in the sym pop
   */
  emp::WorldPosition location;

public:
  /**
   * The constructor for symbiont
   */
  Symbiont(emp::Ptr<emp::Random> _random, emp::Ptr<SymWorld> _world, emp::Ptr<SymConfigBase> _config, double _intval=0.0, double _points = 0.0) :  interaction_val(_intval), points(_points), random(_random), my_world(_world), my_config(_config) {
    infection_chance = my_config->SYM_INFECTION_CHANCE();
    if (infection_chance == -2) infection_chance = random->GetDouble(0,1); //randomized starting infection chance
    if (infection_chance > 1 || infection_chance < 0) throw "Invalid infection chance. Must be between 0 and 1"; //exception for invalid infection chance
    if (_intval == -2) {
      interaction_val = random->GetDouble(-1, 1);
    }
   if (interaction_val > 1 || interaction_val < -1) {
       throw "Invalid interaction value. Must be between -1 and 1";   // Exception for invalid interaction value
    };
  }


  /**
   * Input: None
   *
   * Output: None
   *
   * Purpose: To force a copy constructor to be generated by the compiler.
   */
  Symbiont(const Symbiont &) = default;


  /**
   * Input: None
   *
   * Output: None
   *
   * Purpose: To force a move constructor to be generated by the compiler
   */
  Symbiont(Symbiont &&) = default;


  /**
   * Input: None
   *
   * Output: None
   *
   * Purpose: To tell the compiler to use its default generated variants of the constructor
   */
  Symbiont() = default;


  /**
   * Input: None
   *
   * Output: None
   *
   * Purpose: To force a copy assignment operator to be generated by the compiler.
   */
  Symbiont & operator=(const Symbiont &) = default;


  /**
   * Input: None
   *
   * Output: None
   *
   * Purpose: To force a move assignment operator to be generated by the compiler.
   */
  Symbiont & operator=(Symbiont &&) = default;

  /**
   * Input: None
   *
   * Output: None
   *
   * Purpose: To destruct the symbiont and remove the symbiont from the systematic.
   */
  ~Symbiont() {
    if(my_config->PHYLOGENY() == 1) {
      my_world->GetSymSys()->RemoveOrg(my_taxon.Cast<taxon_t::sym_taxon_t>());
      if (my_config->STORE_EXTINCT() && my_taxon->GetOriginationTime() == my_taxon->GetDestructionTime() && my_taxon->GetTotalOffspring() == 0) {
        my_world->GetSymSys()->outside_taxa.erase(my_taxon.Cast<taxon_t::sym_taxon_t>());
        my_taxon.Delete();
      }
    }
  }

    /**
    * Input: None
    *
    * Output: Name of class as string, Symbiont
    *
    * Purpose: To know which subclass the object is
    */
    std::string const GetName() const {
      return  "Symbiont";
    }

  /**
   * Input: Set the reproduction counter
   *
   * Output: None
   *
   * Purpose: To set the count of reproductions in this lineage.
   */
  void SetReproCount(size_t _in) { reproductions = _in; }


  /**
   * Input: None.
   *
   * Output: The reproduction count
   *
   * Purpose: To get the count of reproductions in this lineage.
   */
  size_t GetReproCount() const { return reproductions; }

  /**
   * Input: Set the flips towards a partner counter
   *
   * Output: None
   *
   * Purpose: To set the count of flips towards a partner in this lineage.
   */
  void SetTowardsPartnerCount(size_t _in) { towards_partner_count = _in; }


  /**
   * Input: None.
   *
   * Output: The flips towards a partner count
   *
   * Purpose: To get the count of flips towards a partner in this lineage.
   */
  size_t GetTowardsPartnerCount() const { return towards_partner_count; }


  /**
   * Input: Set the flips from a partner counter
   *
   * Output: None
   *
   * Purpose: To set the count of flips from a partner in this lineage.
   */
  void SetFromPartnerCount(size_t _in) { from_partner_count = _in; }


  /**
   * Input: None.
   *
   * Output: The flips from a partner count
   *
   * Purpose: To get the count of flips from a partner in this lineage.
   */
  size_t GetFromPartnerCount() const { return from_partner_count; }

  /**
   * Input: None
   *
   * Output: The double representing the symbiont's interaction value
   *
   * Purpose: To get a symbiont's interaction value.
   */
  double GetIntVal() const {return interaction_val;}


  /**
   * Input: None
   *
   * Output: The double representing the symbiont's points
   *
   * Purpose: To get a symbiont's points.
   */
  double GetPoints() const { return points; }

  /**
   * Input: None
   *
   * Output: The world position of the organism
   *
   * Purpose: To get the world position of the organism
   */
  emp::WorldPosition GetLocation() const { return location; }


  /**
   * Input: None
   *
   * Output: The bool representing if a symbiont is a phage
   *
   * Purpose: To determine if a symbiont is a phage
   */
  bool IsPhage() const { return false; }


  /**
   * Input: None
   *
   * Output: The bool representing if a symbiont is a host
   *
   * Purpose: To determine if a symbiont is a host
   */
  bool IsHost() const { return false; }


 /**
   * Input: None
   *
   * Output: The chance of a symbiont infecting a parallel
   * host during process
   *
   * Purpose: To determine a symbiont's infection chance
   */
  double GetInfectionChance() const { return infection_chance; }


  /**
   * Input: None
   *
   * Output: The pointer to a symbiont's host
   *
   * Purpose: To retrieve a symbiont's host
   */
  emp::Ptr<Organism> GetHost() { return my_host; }


  /**
   * Input: None
   *
   * Output: The pointer to the symbiont's taxon
   *
   * Purpose: To retrieve the symbiont's taxon
   */
   emp::Ptr<taxon_t::base_taxon_t> GetTaxon() { return my_taxon; }

   /**
    * Input: A pointer to the taxon that this organism should belong to.
    *
    * Output: None
    *
    * Purpose: To set the symbiont's taxon
    */
  void SetTaxon(emp::Ptr<taxon_t::base_taxon_t> _in) { my_taxon = _in; }

  /**
   * Input: The new tag
   *
   * Output: None
   *
   * Purpose: To set a symbiont's tag.
   */
  void SetTag(const emp::BitSet<TAG_LENGTH>& _in) { tag.Import(_in); }

  /**
   * Input: None
   *
   * Output: The symbiont's tag.
   *
   * Purpose: To get a symbiont's tag.
   */
  emp::BitSet<TAG_LENGTH>& GetTag() { return tag; }

  /**
   * Input: None
   *
   * Output: const reference to the symbiont's tag.
   *
   * Purpose: To get a symbiont's tag.
   */
  const emp::BitSet<TAG_LENGTH>& GetTag() const { return tag; }

  /**
   * Input: None
   *
   * Output: None
   *
   * Purpose: To set a symbiont to dead
   */
  void SetDead() {
    dead = true;
  }


  /**
   * Input: None
   *
   * Output: The bool representing if a symbiont is dead
   *
   * Purpose: To determine if a symbiont is dead
   */
  bool GetDead() const { return dead; }


  /**
   * Input: The double representing the new interaction value of a symbiont
   *
   * Output: None
   *
   * Purpose: To set a symbiont's interaction value
   */
  void SetIntVal(double _in) {
    emp_assert(_in <= 1 && _in >= -1, "Invalid interaction value. Must be between -1 and 1");
    interaction_val = _in;
  }


  /**
   * Input: The double representing the points to be set as a symbiont's points
   *
   * Output: None
   *
   * Purpose: To set a symbiont's points
   */
  void SetPoints(double _in) { points = _in; }


  /**
   * Input: The double representing the points to be added to a symbiont's points
   *
   * Output: None
   *
   * Purpose: To increment a symbiont's points
   */
  void AddPoints(double _in) { points += _in; }

  /**
   * Input: A new world position
   *
   * Output: None
   *
   * Purpose: To set the organism's world position
   */
  void SetLocation(emp::WorldPosition _in) { location = _in; }

  /**
   * Input: None
   *
   * Output: an int representing the current age of the Symbiont
   *
   * Purpose: To get the Symbiont's age.
   */
  int GetAge() const { return age; }

  /**
   * Input: An int of what age the Symbiont should be set to
   *
   * Output: None
   *
   * Purpose: To set the Symbiont's age for testing purposes.
   */
  void SetAge(int _in) {age = _in;}

  /**
   * Input: The pointer to an organism that will be set as the symbiont's host
   *
   * Output: None
   *
   * Purpose: To set a symbiont's host
   */
  void SetHost(emp::Ptr<Organism> _in) { my_host = _in; }

  /**
   * Input: The double that will be the symbiont's infection chance
   *
   * Output: None
   *
   * Purpose: To set a symbiont's infection host and check that the proposed value is valid.
   */
  void SetInfectionChance(double _in) {
    if(_in > 1 || _in < 0) throw "Invalid infection chance. Must be between 0 and 1 (inclusive)";
    else infection_chance = _in;
  }


  /**
   * Input: None
   *
   * Output: None
   *
   * Purpose: Does nothing for now, added for backwards compatibility from phage to symbiont
   */
  void UponInjection() {
    //does nothing for now, added for backwards compatibility from phage to symbiont
  }

  /**
   * Input: None
   *
   * Output: None
   *
   * Purpose: Increments age by one and kills it if too old.
   */
  void GrowOlder() {
    age = age + 1;
    if(age > my_config->SYM_AGE_MAX() && my_config->SYM_AGE_MAX() > 0) {
      SetDead();
    }
  }


  /**
   * Input: None
   *
   * Output: None
   *
   * Purpose: To mutate a symbiont's interaction value. The mutation value is chosen
   * from a normal distribution centered on 0 with the mutation size as the standard
   * deviation.
   */
  void Mutate() {
    double local_rate = my_config->MUTATION_RATE();
    double local_size = my_config->MUTATION_SIZE();

    if (random->GetDouble(0.0, 1.0) <= local_rate) {
      interaction_val += random->GetNormal(0.0, local_size);
      if(interaction_val < -1) interaction_val = -1;
      else if (interaction_val > 1) interaction_val = 1;

      //also modify infection chance, which is between 0 and 1
      if(my_config->FREE_LIVING_SYMS()) {
        infection_chance += random->GetNormal(0.0, local_size);
        if (infection_chance < 0) infection_chance = 0;
        else if (infection_chance > 1) infection_chance = 1;
      }
    }
    if (my_config->TAG_MATCHING()) {
      tag.FlipRandom(my_world->GetRandom(), my_config->TAG_MUTATION_SIZE());
    }
  }

  /**
   * Input: The double representing the resources to be distributed to the symbiont
   * and (optionally) the host from whom it comes; if no host is provided, the
   * symbiont's host variable is used.
   *
   * Output: The double representing the host's resources
   *
   * Purpose: To process and distribute resources.
   */
  double ProcessResources(double host_donation, emp::Ptr<Organism> host = nullptr) {
    if(host == nullptr) {
      host = my_host;
    }
    double sym_int_val = GetIntVal();
    double sym_portion = 0;
    double host_portion = 0;
    double synergy = my_config->SYNERGY();

    if (sym_int_val<0) {
      double stolen = host->StealResources(sym_int_val);
      host_portion = 0;
      sym_portion = stolen + host_donation;
    }
    else if (sym_int_val >= 0) {
      host_portion = host_donation * sym_int_val;
      sym_portion = host_donation - host_portion;
    }
    AddPoints(sym_portion);
    return host_portion * synergy;
  }


  /**
   * Input: None
   *
   * Output: The boolean representing if a symbiont
   * will seek out to infect a host.
   *
   * Purpose: To determine if a symbiont wants to
   * infect a host based upon its infection chance
   */
  bool WantsToInfect() {
    bool result = random->GetDouble(0.0, 1.0) < infection_chance;
    return result;
  }


  /**
   * Input: None
   *
   * Output: The boolean representing if a symbiont
   * will survive crossing over into the host world.
   *
   * Purpose: To determine if a symbiont will survive
   * crossing over into the host world based on infection risk.
   */
  bool InfectionFails() {
    //note: this can be returned true, and an infecting sym can then be killed by a host that is already infected.
    bool sym_dies = random->GetDouble(0.0, 1.0) < my_config->SYM_INFECTION_FAILURE_RATE();
    return sym_dies;
  }

  /**
   * Input: The double representing the resources given by the world.
   *
   * Output: None
   *
   * Purpose:  Free living symbionts specialized to interact with hosts
   * (extreme interaction value in either direction) lose some of the resources that they get from the world.
   */
  void LoseResources(double resources) {
    double int_val = interaction_val;
    if(my_host.IsNull()) { // this method should only be called on free-living syms, but double check!

      if(int_val >= 0) {
	      double spent = resources * int_val;
        this->AddPoints(resources - spent);
      }
      else {
        double attack = -1.0 * int_val * resources;
        this->AddPoints(resources - attack);
      }
    }
  }

  /**
   * Input: A WorldPosition parameter describing the location of the symbiont;
   * ID is where they are in the world, INDEX is where they are in the host's symbiont
   * list (or 0 if they're free living).
   *
   * Output: None
   *
   * Purpose: To process a symbiont, meaning to check for reproduction, distribute resources,
   * and to allow for movement
   */
  void Process(emp::WorldPosition location) {
    // if doing tag-based or individual phylogenies, track int val of this organism
    if (my_config->PHYLOGENY() && my_world->GetPhylogenyTaxonType() == SymWorld::PHYLO_TAXON_TYPE::TAG) {
      my_taxon->GetData().RecordIntVal(GetIntVal());
    }

    if (my_host.IsNull() && my_config->FREE_LIVING_SYMS()) { //free living symbiont
      double resources = my_world->PullResources(my_config->FREE_SYM_RES_DISTRIBUTE()); //receive resources from the world
      LoseResources(resources);
    }
    //Check if independent reproduction can occur and do it (either horizontal transmission or free-living reproduction, depending on config)
    IndependentReproduction(location);
    //Age the organism
    GrowOlder();
    if (my_config->SYM_WITHIN_LIFETIME_MUTATION_RATE()) {
      if (random->P(my_config->SYM_WITHIN_LIFETIME_MUTATION_RATE())) {
        Mutate();
      }
    }
    //Check if the organism should move and do it
    if (my_host.IsNull() && my_config->FREE_LIVING_SYMS() && !dead) {
      //if the symbiont should move, and hasn't been killed
      my_world->MoveFreeSym(location);
    }
  }

  /**
   * Input: None
   *
   * Output: The pointer to the newly created organism
   *
   * Purpose: To produce a new symbiont, identical to the original
   */
  emp::Ptr<Organism> MakeNew() {
    emp::Ptr<Symbiont> new_sym = emp::NewPtr<Symbiont>(random, my_world, my_config, GetIntVal());
    new_sym->SetInfectionChance(GetInfectionChance());
    if (my_config->TAG_MATCHING()) {
      new_sym->SetTag(GetTag());
    }
    return new_sym;
  }

  /**
   * Input: None
   *
   * Output: The pointer to the newly created organism
   *
   * Purpose: To produce a new symbiont; does not remove resources from the parent, assumes that is handled by calling function
   */
  emp::Ptr<Organism> Reproduce() {
    emp::Ptr<Organism> sym_baby = MakeNew();
    sym_baby->Mutate();
    sym_baby->SetReproCount(reproductions + 1);
    if(my_config->PHYLOGENY() == 1) {
      my_world->AddSymToSystematic(sym_baby, my_taxon);
      //baby's taxon will be set in AddSymToSystematic
    }

    if (my_config->TAG_MATCHING() && my_host) {
      // do not xor to get 1 where bits are matching
      emp::BitSet<TAG_LENGTH> host_sym_parent_matching = my_host->GetTag().XOR(tag).NOT();
      emp::BitSet<TAG_LENGTH> host_sym_baby_matching = my_host->GetTag().XOR(sym_baby->GetTag()).NOT();

      // difference in matching-ness, with match in child
      emp::BitSet<TAG_LENGTH> child_towards = host_sym_baby_matching.XOR(host_sym_parent_matching).AND(host_sym_baby_matching);

      // difference in matching-ness, with match in parent
      emp::BitSet<TAG_LENGTH> child_from = host_sym_baby_matching.XOR(host_sym_parent_matching).AND(host_sym_parent_matching);

      sym_baby->SetTowardsPartnerCount(child_towards.CountOnes() + towards_partner_count);
      sym_baby->SetFromPartnerCount(child_from.CountOnes() + from_partner_count);
    }
    return sym_baby;
  }

  /**
   * Input: None
   *
   * Output: Whether the potential parent symbiont meets requirements individually to vertically transmit
   *
   * Purpose: To answer if this symbiont has enough points to vertically transmit.
   * Only tests requirements that are strictly based on the symbiont parent's internal state.
   */
  virtual bool MeetsVTRequirements() {
    if (GetPoints() >= my_config->SYM_VERT_TRANS_RES()) {
      return true;
    }
    return false;
  }

  /**
  * Input: emp::Ptr<Organism> to host offspring, emp::Ptr<Organism> to symbiont offspring
  *
  * Output: boolean, whether or not sym/sym offspring meets requirements to successfully vertically transmit
  *
  * Purpose: To test for compatibility between sym parent/offspring and host parent/offspring, such as tags
  * */
  virtual bool SuccessfulVT(emp::Ptr<Organism> host_baby, emp::Ptr<Organism> sym_baby) {
    if (my_config->TAG_MATCHING()) {
      const double tag_distance = (*my_world->GetTagMetric())(host_baby->GetTag(), sym_baby->GetTag())* TAG_LENGTH;
      const double permissiveness_mean = (my_config->HOST_TAG_PERMISSIVENESS_EVOLVES()) ? host_baby->GetTagPermissiveness() : my_config->TAG_PERMISSIVENESS();
      const double cutoff = random->GetPoisson(permissiveness_mean * TAG_LENGTH);
      if (tag_distance > cutoff) {
        return false;
      }
    }
    return true;
  }

  /**
   * Input: The pointer to the organism that is the new host baby
   *
   * Output: Return symbiont offspring on success; std::nullopt otherwise.
   *
   * Purpose: To allow for vertical transmission to occur
   */
  std::optional<emp::Ptr<Organism>> VerticalTransmission(emp::Ptr<Organism> host_baby) {
    bool success = false;
    emp::Ptr<Organism> sym_baby;
    if(my_world->WillTransmit()) {

      //vertical transmission data node
      emp::DataMonitor<double, emp::data::Histogram>& data_node_attempts_verttrans = my_world->GetVerticalTransmissionAttemptCount();
      data_node_attempts_verttrans.AddDatum(GetIntVal());
      if (MeetsVTRequirements()) {
        sym_baby = Reproduce();
        if (!SuccessfulVT(host_baby, sym_baby)) {
          sym_baby.Delete();
          return std::nullopt;
        }
        points = points - my_config->SYM_VERT_TRANS_RES();
        success = host_baby->AddSymbiont(sym_baby);

        emp::DataMonitor<double, emp::data::Histogram>& data_node_successes_verttrans = my_world->GetVerticalTransmissionSuccessCount();
        data_node_successes_verttrans.AddDatum(GetIntVal());
      }
    }
    return success ? std::optional<emp::Ptr<Organism>>{sym_baby} : std::nullopt;
  }


  /*
  * Input: None
  *
  * Output: Boolean representing whether or not the symbiont meets requirements to independently reproduce (horizontally transmission or free-living reproduction, depending on config)
  *
  * Purpose: To check if the symbiont meets requirements to independently reproduce, based on its own internal state, without considering the host or host baby. This is intended to be used in the horizontal transmission and free-living reproduction process, to determine if the symbiont can attempt to horizontally transmit/independently reproduce.
  * Adjusts the requirements to free-living symbionts if enabled and the free sym repro resources is different than the horizontal transmission resources.
  * Currently just checks point requirement.
  */
  bool MeetsIndependentReproRequirements() {
    double required_points = my_config->SYM_HORIZ_TRANS_RES();
    if (my_config->FREE_LIVING_SYMS() && my_host == nullptr && my_config->FREE_SYM_REPRO_RES() > -1) {
        required_points = my_config->FREE_SYM_REPRO_RES();
      }
    return GetPoints() >= required_points;
  }

  /*
  * Input: sym_pos, world position
  *
  * Output: None
  *
  * Purpose: Start the process for independent reproduction, generally through horizontal transmission, by marking in progress repo and removing points
  */
  bool AttemptIndependentReproduction(emp::WorldPosition sym_pos) {
    if (my_config->HORIZ_TRANS()) { //non-lytic horizontal transmission enabled
      if (MeetsIndependentReproRequirements()) {
        emp::DataMonitor<double, emp::data::Histogram>& data_node_attempts_horiztrans = my_world->GetHorizontalTransmissionAttemptCount();
        data_node_attempts_horiztrans.AddDatum(GetIntVal());

        // symbiont reproduces independently (horizontal transmission) if it has enough resources
        //TODO: try just subtracting points to be consistent with vertical transmission
        //points = points - my_config->SYM_HORIZ_TRANS_RES();


        if(!my_config->TAG_MATCHING() && !my_config->FREE_HT_FAILURE()) SetPoints(0);
        // removing the above for tag matching--sym parent points are
        // now set to 0 in symdobirth
        return true;
      }
    }
    return false;
  }


  void AfterIndependentReproduction(const emp::WorldPosition& sym_baby_pos) {
    emp::DataMonitor<double, emp::data::Histogram>& data_node_successes_horiztrans = my_world->GetHorizontalTransmissionSuccessCount();
    if(sym_baby_pos.IsValid()) {
      data_node_successes_horiztrans.AddDatum(GetIntVal());
    }

  }

  /**
   * Input: The location of the organism as a emp::WorldPosition(<index of sym in host +1>, <index of host in world>)
   *
   * Output: None
   *
   * Purpose: To check and allow for independent reproduction to occur (eiter horizontal transmission or free-living reproduction)
   */
  void IndependentReproduction(emp::WorldPosition location) {
    if (AttemptIndependentReproduction(location)) {
      emp::Ptr<Organism> sym_baby = Reproduce();
      if (my_config->TAG_MATCHING() || my_config->FREE_HT_FAILURE()) sym_baby->SetPoints(0);
      emp::WorldPosition new_pos = my_world->SymDoBirth(sym_baby, this, location);

      AfterIndependentReproduction(new_pos);

    }
  }
};
#endif