zn_to_bool.h

//
// Copyright (c) 2014 Limit Point Systems, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

// Interface for class ZN_TO_BOOL


#ifndef ZN_TO_BOOL_H
#define ZN_TO_BOOL_H

#ifndef SHEAF_DLL_SPEC_H
#include "SheafSystem/sheaf_dll_spec.h"
#endif

#include "SheafSystem/assert_contract.h"

#ifndef STD_IOSTREAM_H
#include "SheafSystem/std_iostream.h"
#endif

#ifndef STD_LIMITS_H
#include "SheafSystem/std_limits.h"
#endif

namespace sheaf
{

template <typename T>
class block;

class zn_to_bool;
class index_iterator;
class subposet;  

class SHEAF_DLL_SPEC zn_to_bool
{


  friend SHEAF_DLL_SPEC std::ostream & operator << (std::ostream &os, zn_to_bool& zn);
  friend SHEAF_DLL_SPEC size_t deep_size(const zn_to_bool& zn, bool xinclude_shallow);
  friend class index_iterator;
  friend class subposet;

  // ===========================================================
  // ZN_TO_BOOL FACET
  // ===========================================================
 
public:

  bool  invariant() const;

  zn_to_bool();

  zn_to_bool(const zn_to_bool& xother);

  zn_to_bool(int xub, bool xinitialize = true);

  zn_to_bool(int xub, unsigned *values);

  ~zn_to_bool();

  // ===========================================================
  // DOMAIN FACET
  // ===========================================================
 
  bool domain_is_valid() const;

  int ub() const;

  bool index_in_bounds(int i) const;

  bool index_in_bounds(const block<int>* indices) const;

  int ct() const;

  int true_ct() const;

  int false_ct() const;

  void extend_to(int xub);

  size_t capacity() const;

  // $$ISSUE: If this typedef is private, then there is no access
  // to it in other classes once they are inserted into the sheaf
  // namespace. JEB 090408

  typedef unsigned int word_t;

  enum static_const_int {BITS_PER_WORD = std::numeric_limits<word_t>::digits};

protected:
private:

  int _ub;

  int _word_ub;

  inline int word_ub()
  {
    return _word_ub;
  }

  word_t* _values;

  inline word_t* values()
  {
    return _values;
  };
  
  int _values_ub;

  // ===========================================================
  // CHARACTERISTIC FUNCTION FACET
  // =========================================================== 

public:

  inline bool operator [] (int i) const
  {
    // preconditions:

    require(index_in_bounds(i));

    // body:

    bool result = (get_word(i) & get_mask(i)) != 0;

    return result;
  }

  bool is_true_for(const block<int>* indices) const;

  bool is_false_for(const block<int>* indices) const;

  void put(int i, bool value);

  void put(const block<int>* indices, bool value);

  void force(int i, bool value);

  void put_not(int i);

  void put_not(const block<int>* indices);

protected:
private:

  inline word_t& get_word(int xindex)
  {
    return(*(_values+(xindex/BITS_PER_WORD)));
  }

  inline const word_t& get_word(int xindex) const
  {
    return(*(_values+(xindex/BITS_PER_WORD)));
  }

  inline word_t get_mask(int xindex) const
  {
    return( 1 << (xindex%BITS_PER_WORD) );
  }

  // ===========================================================
  // BOOLEAN ALGEBRA FACET
  // ===========================================================

public:
 
  bool is_true() const;

  bool is_false() const;

  bool is_equal_to(const zn_to_bool* other) const;

  bool operator==(const zn_to_bool& other) const;

  bool includes(const zn_to_bool* other) const;

  bool is_not(const zn_to_bool* other) const;

  zn_to_bool* make_true();

  void make_true_sa();

  // pre-allocated version not needed for unary operators

  zn_to_bool* make_false();

  void make_false_sa();

  // pre-allocated version not needed for unary operators

  zn_to_bool* equal();

  void equal_pa(const zn_to_bool* result);

  zn_to_bool& operator=(const zn_to_bool& xother);


  // The operators below have 'b_' prefix.  This indicates that
  // these operators are boolean operators.  The need for this
  // prefix arises from 'not', 'and' & 'or' being reserved words
  // in the ansi C++ standard.

  zn_to_bool* b_not();

  void b_not_pa(const zn_to_bool* other);

  void b_not_sa();

  zn_to_bool* b_and(const zn_to_bool* other);

  void b_and_pa(const zn_to_bool* other, zn_to_bool* result);

  void b_and_sa(const zn_to_bool* other);

  zn_to_bool* b_or(const zn_to_bool* other);

  void b_or_pa(const zn_to_bool* other, zn_to_bool* result);

  void b_or_sa(const zn_to_bool* other);

  zn_to_bool* b_and_not(const zn_to_bool* other);

  void b_and_not_pa(const zn_to_bool* other, zn_to_bool* result);

  void b_and_not_sa(const zn_to_bool* other);

protected:
private:
};


// ===========================================================
// NON-MEMBER FUNCTIONS
// ===========================================================
 
SHEAF_DLL_SPEC 
std::ostream & operator << (std::ostream &os, zn_to_bool& zn);

SHEAF_DLL_SPEC 
size_t deep_size(const zn_to_bool& xp, bool xinclude_shallow = true);
 
} // namespace sheaf

#endif // ifndef ZN_TO_BOOL_H