VacuumWorld.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------*/
/*--------------------------- File VacuumWorld.h ---------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*------------------------------ DEFINITIONS -------------------------------*/
/*--------------------------------------------------------------------------*/
 
#ifndef __PBeFS_VacuumWorld
 #define __PBeFS_VacuumWorld
                      /* self-identification: #endif at the end of the file */
 
/*--------------------------------------------------------------------------*/
/*-------------------------------- INCLUDES --------------------------------*/
/*--------------------------------------------------------------------------*/
 
#include <bit>
 
#include <cstddef>
 
#include <cstdint>
 
#include <stdexcept>
 
#include "PBeFS/astar/Domain.h"
 
/*--------------------------------------------------------------------------*/
/*------------------------------- NAMESPACE --------------------------------*/
/*--------------------------------------------------------------------------*/

namespace PBeFS_di_unipi_it
{
 
/*--------------------------------------------------------------------------*/
/*--------------------------- CLASS VacuumWorld ----------------------------*/
/*--------------------------------------------------------------------------*/

 
class VacuumWorld {
 
/*------------------------ PUBLIC PART OF THE CLASS ------------------------*/
 
 public:
 
/*------------------------------ PUBLIC TYPES ------------------------------*/
 
 using state_type = std::uint64_t;               
 using cost_type = int;                          
 
/*------------------------------ CONSTRUCTOR -------------------------------*/

 
 VacuumWorld( int n , int start , std::uint32_t dirty )
  : f_n( n ) , f_start( start ) , f_dirty( dirty ) {
  if( ( n < 1 ) || ( n > 32 ) || ( start < 0 ) || ( start >= n ) )
   throw( std::invalid_argument( "VacuumWorld::VacuumWorld: bad sizes" ) );
  if( ( n < 32 ) && ( dirty >> n ) )
   throw( std::invalid_argument( "VacuumWorld::VacuumWorld: dirt out of "
                                 "the row" ) );
  }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
 [[nodiscard]] static int robot( std::uint64_t s ) noexcept {
  return( int( s >> 32 ) );
  }

 
 [[nodiscard]] static std::uint32_t dirt( std::uint64_t s ) noexcept {
  return( std::uint32_t( s ) );
  }
 
/*------------------------- METHODS OF THE DOMAIN --------------------------*/
 
 [[nodiscard]] std::uint64_t initial_state( void ) const noexcept {
  return( pack( f_start , f_dirty ) );
  }
 
 [[nodiscard]] bool is_goal( std::uint64_t s ) const noexcept {
  return( dirt( s ) == 0 );
  }
 
 [[nodiscard]] std::uint64_t hash( std::uint64_t s ) const noexcept {
  return( ADS::splitmix64( s ) );
  }
 
 [[nodiscard]] int heuristic( std::uint64_t s ) const noexcept {
  return( std::popcount( dirt( s ) ) );
  }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
 template< class F >
 void for_each_successor( std::uint64_t s , int h , F && f ) const {
  const int r = robot( s );
  const std::uint32_t d = dirt( s );
  if( d & ( std::uint32_t( 1 ) << r ) )                       // Suck
   f( pack( r , d & ~( std::uint32_t( 1 ) << r ) ) , 1 , h - 1 );
  if( r > 0 )                                                 // Left
   f( pack( r - 1 , d ) , 1 , h );
  if( r + 1 < f_n )                                           // Right
   f( pack( r + 1 , d ) , 1 , h );
  }
 
/*---------------------- FEATURES FOR ZOBRIST HASHING ----------------------*/
 
 [[nodiscard]] std::size_t num_features( void ) const noexcept {
  return( 2 * std::size_t( f_n ) );
  }

 
 template< class F >
 void for_each_feature( std::uint64_t s , F && f ) const {
  for( std::uint32_t d = dirt( s ) ; d ; d &= d - 1 )
   f( std::size_t( std::countr_zero( d ) ) );
  f( std::size_t( f_n + robot( s ) ) );
  }

 
 [[nodiscard]] std::size_t num_abstract_features( void ) const noexcept {
  return( std::size_t( f_n ) + 1 );
  }

 
 [[nodiscard]] std::size_t abstract_feature( std::size_t i ) const noexcept
 {
  return( i < std::size_t( f_n ) ? i : std::size_t( f_n ) );
  }
 
/*--------------------------- STATE ABSTRACTIONS ---------------------------*/
 
 [[nodiscard]] std::uint64_t abstract_state( std::uint64_t s ) const noexcept
 {
  return( dirt( s ) );
  }

 
 [[nodiscard]] std::size_t num_nblocks( void ) const noexcept {
  return( std::size_t( f_n ) );
  }

 
 [[nodiscard]] std::size_t nblock( std::uint64_t s ) const noexcept {
  return( std::size_t( robot( s ) ) );
  }

 
 template< class F >
 void for_each_nblock_successor( std::size_t b , F && f ) const {
  if( b > 0 )
   f( b - 1 );
  if( b + 1 < std::size_t( f_n ) )
   f( b + 1 );
  }
 
/*---------------------- OTHER HEURISTICS AND HASHES -----------------------*/
 
 [[nodiscard]] int pairwise_heuristic( std::uint64_t s , std::uint64_t t )
  const noexcept {
  return( std::popcount( dirt( s ) & ~dirt( t ) ) );
  }

 
 [[nodiscard]] std::uint64_t perfect_hash( std::uint64_t s ) const noexcept {
  return( s );
  }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
 [[nodiscard]] int size( void ) const noexcept { return( f_n ); }
 
/*----------------------- PRIVATE PART OF THE CLASS ------------------------*/
 
 private:
 
 // the state with the robot in the cell r and the dirty cells d
 static std::uint64_t pack( int r , std::uint32_t d ) noexcept {
  return( ( std::uint64_t( r ) << 32 ) | d );
  }
 
 int f_n;                                        
 int f_start;                                    
 std::uint32_t f_dirty;                          
 
 };  // end( class( VacuumWorld ) )
 
/*--------------------------------------------------------------------------*/
 
}  // end( namespace PBeFS_di_unipi_it )
 
/*--------------------------------------------------------------------------*/
 
#endif  /* __PBeFS_VacuumWorld */
 
/*--------------------------------------------------------------------------*/
/*------------------------- End File VacuumWorld.h -------------------------*/
/*--------------------------------------------------------------------------*/