d_bin_coordinates.h

Go to the documentation of this file.

//
// 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.
//


#ifndef D_BIN_COORDINATES_H
#define D_BIN_COORDINATES_H

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

#ifndef SECTION_EVALUATOR_H
#include "SheafSystem/section_evaluator.h"
#endif

#ifndef SHEAF_H
#include "SheafSystem/sheaf.h"
#endif

#ifndef STD_CMATH_H
#include "SheafSystem/std_cmath.h"
#endif

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

namespace geometry
{

using namespace sheaf;
using namespace fiber_bundle; 

template <int DC, int DB>
class SHEAF_DLL_SPEC d_bin_coordinates
{

  // ===========================================================
  // ===========================================================

public:

  typedef section_evaluator::value_type value_type;

  typedef typename sheaf::size_type size_type;

  typedef unsigned long long int_type;

  d_bin_coordinates();

  d_bin_coordinates(const d_bin_coordinates<DC, DB>& xother);

  d_bin_coordinates(const value_type* xcoord);

  ~d_bin_coordinates();

  bool invariant() const;

  d_bin_coordinates& operator=(const d_bin_coordinates<DC, DB>& xother);

  d_bin_coordinates& operator=(const value_type* xcoord);

  bool operator==(const d_bin_coordinates<DC, DB>& xother) const;

  bool operator==(int_type xother) const;

  bool operator<(const d_bin_coordinates<DC, DB>& xother) const;

  bool operator<=(const d_bin_coordinates<DC, DB>& xother) const;

  d_bin_coordinates<DC, DB>& operator>>=(int xbits);

  d_bin_coordinates& operator-=(const d_bin_coordinates<DC, DB>& xother);

  size_type branch(size_type xbit) const;

  void put_branch(size_type xbit, size_type xbranch);

  static int_type ub();

  static size_type bits();

  static size_type leftmost_bit_id();

  static size_type rightmost_bit_id();

  static size_type degree();

  static size_type dc();

  const int_type* int_value() const;

  const int_type& operator[](size_type xi) const;

  int_type& operator[](size_type xi);


private:

  d_bin_coordinates(int_type xint_value);

  int_type _int_value[DC];


};

// ===========================================================
// NON-MEMBER FUNCTIONS
// ===========================================================

// #ifndef STD_BITSET_H
// #include "SheafSystem/std_bitset.h"
// #endif

template <int DC, int DB>
SHEAF_DLL_SPEC 
std::ostream&
operator<<(std::ostream& xos, const d_bin_coordinates<DC, DB>& xcoords);


// ===========================================================
// SPECIALIZATIONS
// ===========================================================

//
// The branch index at bit position xbit (1d specialization).
//
template<>
SHEAF_DLL_SPEC
d_bin_coordinates<1, 1>::size_type
d_bin_coordinates<1, 1>::branch(size_type xbit) const;

//
// Set the branch index at bit position xbit to xbranch (1d specialization).
//
template<>
SHEAF_DLL_SPEC
void
d_bin_coordinates<1, 1>::put_branch(size_type xbit, size_type xbranch);

//
// The branch index at bit position xbit (2d specialization).
//
template<>
SHEAF_DLL_SPEC
d_bin_coordinates<2, 2>::size_type
d_bin_coordinates<2, 2>::branch(size_type xbit) const;

//
// Set the branch index at bit position xbit to xbranch (2d specialization).
//
template<>
SHEAF_DLL_SPEC
void
d_bin_coordinates<2, 2>::put_branch(size_type xbit, size_type xbranch);

//
// The branch index at bit position xbit.
//
template<>
SHEAF_DLL_SPEC
d_bin_coordinates<3, 3>::size_type
d_bin_coordinates<3, 3>::branch(size_type xbit) const;

//
// Set the branch index at bit position xbit to xbranch (3d specialization).
//
template<>
SHEAF_DLL_SPEC
void
d_bin_coordinates<3, 3>::put_branch(size_type xbit, size_type xbranch);

//
// The branch index at bit position xbit (4d specialization).
//
template<>
SHEAF_DLL_SPEC
d_bin_coordinates<4, 4>::size_type
d_bin_coordinates<4, 4>::branch(size_type xbit) const;

//
// Set the branch index at bit position xbit to xbranch (4d specialization).
//
template<>
SHEAF_DLL_SPEC
void
d_bin_coordinates<4, 4>::put_branch(size_type xbit, size_type xbranch);

} // namespace geometry

#endif // ifndef D_BIN_COORDINATES_H