#define EIGEN_MAKE_SCALAR_CWISE_UNARY_FUNCTOR(OP,NAME) 				\

template<typename Scalar>							\

struct NAME {									\

  typedef typename packet_traits<Scalar>::type Packet;				\

  inline NAME(const NAME& other) : m_other(other.m_other) { }			\

  inline NAME(const Scalar& other) : m_other(other) { }				\

  inline Scalar operator() (const Scalar& a) const { return a OP m_other; }	\

  const Scalar m_other;								\

};										\

template<typename Scalar>							\

struct functor_traits<NAME<Scalar> >						\

{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = false }; };

EIGEN_MAKE_SCALAR_CWISE_UNARY_FUNCTOR(^ , scalar_bitxor_op)

EIGEN_MAKE_SCALAR_CWISE_UNARY_FUNCTOR(& , scalar_bitand_op)

EIGEN_MAKE_SCALAR_CWISE_UNARY_FUNCTOR(| , scalar_bitor_op)

#ifdef EIGEN_INCLUDE_ARRAY_BIT_SHIFT

  EIGEN_MAKE_SCALAR_CWISE_UNARY_FUNCTOR(>>, scalar_bitshr_op)

  EIGEN_MAKE_SCALAR_CWISE_UNARY_FUNCTOR(<<, scalar_bitshl_op)

#endif

#define EIGEN_MAKE_SCALAR_CWISE_BINARY_FUNCTOR(OP, NAME) 				\

template<typename Scalar>								\

struct NAME {										\

  EIGEN_EMPTY_STRUCT_CTOR(NAME)								\

  EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a, const Scalar& b) const { return a OP b; }	\

};											\

template<typename Scalar>								\

struct functor_traits<NAME<Scalar> > { enum { Cost = NumTraits<NAME<Scalar> >::AddCost, PacketAccess = false }; };

EIGEN_MAKE_SCALAR_CWISE_BINARY_FUNCTOR(|, scalar_bitor_binary_op)

EIGEN_MAKE_SCALAR_CWISE_BINARY_FUNCTOR(&, scalar_bitand_binary_op)

EIGEN_MAKE_SCALAR_CWISE_BINARY_FUNCTOR(^, scalar_bitxor_binary_op)

#ifdef EIGEN_INCLUDE_ARRAY_BIT_SHIFT

  EIGEN_MAKE_SCALAR_CWISE_BINARY_FUNCTOR(>>, scalar_bitshr_binary_op)

  EIGEN_MAKE_SCALAR_CWISE_BINARY_FUNCTOR(<<, scalar_bitshl_binary_op)

#endif

#define EIGEN_MAKE_SCALAR_CWISE_BINARY_BITOP(OP,FUNCTOR) 				\

template<typename OtherDerived>								\

  inline const CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived>	\

  operator OP(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const	\

  { return CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived>(derived(),other.derived()); }

EIGEN_MAKE_SCALAR_CWISE_BINARY_BITOP(| ,  internal::scalar_bitor_binary_op)

EIGEN_MAKE_SCALAR_CWISE_BINARY_BITOP(& ,  internal::scalar_bitand_binary_op)

EIGEN_MAKE_SCALAR_CWISE_BINARY_BITOP(^ ,  internal::scalar_bitxor_binary_op)

#ifdef EIGEN_INCLUDE_ARRAY_BIT_SHIFT

  EIGEN_MAKE_SCALAR_CWISE_BINARY_BITOP(>>,  internal::scalar_bitshr_binary_op)

  EIGEN_MAKE_SCALAR_CWISE_BINARY_BITOP(<<,  internal::scalar_bitshl_binary_op)

#endif

#define EIGEN_MAKE_SCALAR_CWISE_UNARY_BITOP(OP,FUNCTOR) 	\

  inline const CwiseUnaryOp<FUNCTOR<Scalar>, const Derived>	\

    operator OP(const Scalar& scalar) const {			\

      return CwiseUnaryOp<FUNCTOR<Scalar>, const Derived>(derived(), FUNCTOR<Scalar>(scalar)); }

#define EIGEN_MAKE_SCALAR_CWISE_UNARY_BITOP_COMMUTATIVE(OP,FUNCTOR)	\

  EIGEN_MAKE_SCALAR_CWISE_UNARY_BITOP(OP,FUNCTOR) 			\

  friend inline const CwiseUnaryOp<FUNCTOR<Scalar>, const Derived>	\

  operator OP(const Scalar& scalar,const EIGEN_CURRENT_STORAGE_BASE_CLASS<Derived>& other)\

  { return other OP scalar; }

EIGEN_MAKE_SCALAR_CWISE_UNARY_BITOP_COMMUTATIVE(^, internal::scalar_bitxor_op)

EIGEN_MAKE_SCALAR_CWISE_UNARY_BITOP_COMMUTATIVE(&, internal::scalar_bitand_op)

EIGEN_MAKE_SCALAR_CWISE_UNARY_BITOP_COMMUTATIVE(|, internal::scalar_bitor_op)

#ifdef EIGEN_INCLUDE_ARRAY_BIT_SHIFT

  EIGEN_MAKE_SCALAR_CWISE_UNARY_BITOP(>>,  internal::scalar_bitshr_op)

  EIGEN_MAKE_SCALAR_CWISE_UNARY_BITOP(<<,  internal::scalar_bitshl_op)

#endif

ei_add_test(array_bit_ops)

// This file is part of Eigen, a lightweight C++ template library

// for linear algebra.

//

// Copyright (C) 2011 John Roll <john@rkroll.com>

//

// Eigen is free software; you can redistribute it and/or

// modify it under the terms of the GNU Lesser General Public

// License as published by the Free Software Foundation; either

// version 3 of the License, or (at your option) any later version.

//

// Alternatively, you can redistribute it and/or

// modify it under the terms of the GNU General Public License as

// published by the Free Software Foundation; either version 2 of

// the License, or (at your option) any later version.

//

// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY

// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU Lesser General Public

// License and a copy of the GNU General Public License along with

// Eigen. If not, see <http://www.gnu.org/licenses/>.

#define EIGEN2_SUPPORT

#define EIGEN_NO_STATIC_ASSERT

#define EIGEN_INCLUDE_ARRAY_BIT_SHIFT

#include "main.h"

#include <functional>

#include <iostream>

using namespace std;

#ifdef min

#undef min

#endif

#ifdef max

#undef max

#endif

template<typename ArrayType> void array_bit_ops(ArrayType a)

{

  typename ArrayType::Scalar pow = 1;

  typename ArrayType::Scalar one = 1;

  a.setConstant(1);

  for ( unsigned int i = 0; i < sizeof(typename ArrayType::Scalar)*8; i++ ) {

      /* The Lhs is generated with bit shifting native types and multiplication.

	 The Rhs is generated with the array bit operations.

       */

      VERIFY(((a*((one<<i) & 1)) == ((a*(one<<i)) &            1 )).all());

      VERIFY(((a*((one<<i) & 1)) == (           1 & (a*(one<<i)) )).all());

      VERIFY(((a*((one<<i) & 1)) == ((a*(one<<i)) &        (a*1) )).all());

      VERIFY(((a*((one<<i) | 1)) == ((a*(one<<i)) |            1 )).all());

      VERIFY(((a*((one<<i) | 1)) == (           1 | (a*(one<<i)) )).all());

      VERIFY(((a*((one<<i) | 1)) == ((a*(one<<i)) |        (a*1) )).all());

      VERIFY(((a*((one<<i) ^ 1)) == ((a*(one<<i)) ^    1         )).all());

      VERIFY(((a*((one<<i) ^ 1)) == (           1 ^ (a*(one<<i)) )).all());

      VERIFY(((a*((one<<i) ^ 1)) == ((a*(one<<i)) ^        (a*1) )).all());

      VERIFY((a*pow ==  a <<    i ).all());

      VERIFY((a*pow ==  a << (a*i)).all());

      if ( i != sizeof(typename ArrayType::Scalar)*8-1 ) {	// Don't shift out of sign bit

	  VERIFY((((a*pow) >>    i ) == a).all());

	  VERIFY((((a*pow) >> (a*i)) == a).all());

      }

      pow *= 2;

  }

}

void test_array_bit_ops()

{

  for(int i = 0; i < g_repeat ; i++) {

    CALL_SUBTEST_1( array_bit_ops(Array<int, EIGEN_TEST_MAX_SIZE, EIGEN_TEST_MAX_SIZE>()) );

    CALL_SUBTEST_2( array_bit_ops(Array<short, EIGEN_TEST_MAX_SIZE, EIGEN_TEST_MAX_SIZE>()) );

    CALL_SUBTEST_3( array_bit_ops(Array<unsigned short, EIGEN_TEST_MAX_SIZE, EIGEN_TEST_MAX_SIZE>()) );

    CALL_SUBTEST_4( array_bit_ops(Array<long, EIGEN_TEST_MAX_SIZE, EIGEN_TEST_MAX_SIZE>()) );

    CALL_SUBTEST_5( array_bit_ops(Array<long long, EIGEN_TEST_MAX_SIZE, EIGEN_TEST_MAX_SIZE>()) );

  }

}