state_probability_pair.h

Go to the documentation of this file.

// Author(s): Jan Friso Groote
// Copyright: see the accompanying file COPYING or copy at
// https://github.com/mCRL2org/mCRL2/blob/master/COPYING
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
 
#ifndef MCRL2_LPS_STATE_PROBABILITY_PAIR_H
#define MCRL2_LPS_STATE_PROBABILITY_PAIR_H
 
#include <cassert>
#include <iostream>
#include "mcrl2/utilities/hash_utility.h"
#include "mcrl2/atermpp/aterm.h"
 
namespace mcrl2
{
namespace lps
{
 
template < class STATE, class PROBABILITY >
class state_probability_pair
{
  protected:
    // A state 
    STATE m_state;
    // A data expression of sort Real that indicates the probability of this state
    PROBABILITY m_probability;
  public:
 
    state_probability_pair(const STATE& state, const PROBABILITY& probability)
     : m_state(state), 
       m_probability(probability)
    {
      assert(probability!=PROBABILITY::zero());
    } 
 
    state_probability_pair(const state_probability_pair& p)=default; 
    state_probability_pair(state_probability_pair&& p)=default; 
 
    state_probability_pair& operator=(const state_probability_pair& p)=default; 
    state_probability_pair& operator=(state_probability_pair&& p)=default; 
 
    bool operator==(const state_probability_pair& other) const
    {
      if constexpr(std::is_convertible<PROBABILITY,atermpp::aterm>::value)
      {
        // The probabilities are compared as aterms, and not based on their value, as comparing
        // probabilities using their value is expensive as it requires an application of the rewriter. 
        return m_state==other.m_state && 
               static_cast<atermpp::aterm>(m_probability)==static_cast<atermpp::aterm>(other.m_probability);
      }
      else
      {
        static_assert(!std::is_convertible<PROBABILITY,atermpp::aterm>::value);
        return m_state==other.m_state && m_probability==other.m_probability;
      }
    }
 
    const STATE& state() const
    {
      return m_state;
    }
 
    STATE& state() 
    {
      return m_state;
    }
 
    const PROBABILITY& probability() const
    {
      return m_probability;
    }
 
    PROBABILITY& probability() 
    {
      return m_probability;
    }
 
};
 
} // namespace lps
} // namespace mcrl2 
 
namespace std
{
 
template < class STATE, class PROBABILITY >
struct hash<mcrl2::lps::state_probability_pair<STATE,PROBABILITY> >
{
  std::size_t operator()(const mcrl2::lps::state_probability_pair<STATE,PROBABILITY>& p) const
  {
    hash<STATE> state_hasher;
    hash<PROBABILITY> probability_hasher;
    return mcrl2::utilities::detail::hash_combine(state_hasher(p.state()), probability_hasher(p.probability()));
  }
};
 
} // end namespace std
 
#endif // MCRL2_LPS_STATE_PROBABILITY_PAIR_H