glm/glm/core/func_integer.hpp

///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2010-03-17
// Updated : 2010-03-31
// Licence : This source is under MIT License
// File    : glm/core/func_integer.hpp
///////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef glm_core_func_integer
#define glm_core_func_integer

namespace glm
{
	/// @addtogroup core_funcs
	/// @{

	//! Adds 32-bit unsigned integer x and y, returning the sum
	//! modulo pow(2, 32). The value carry is set to 0 if the sum was
	//! less than pow(2, 32), or to 1 otherwise.
	//!
    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
    //! \li GLSL 4.00.08 specification, section 8.8
	template <typename genUType>
	genUType uaddCarry(
		genUType const & x, 
		genUType const & y, 
		genUType & carry);

	//! Subtracts the 32-bit unsigned integer y from x, returning
	//! the difference if non-negative, or pow(2, 32) plus the difference
	//! otherwise. The value borrow is set to 0 if x >= y, or to 1 otherwise.
	//!
    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
    //! \li GLSL 4.00.08 specification, section 8.8
	template <typename genUType>
	genUType usubBorrow(
		genUType const & x, 
		genUType const & y, 
		genUType & borrow);
		
	//! Multiplies 32-bit integers x and y, producing a 64-bit
	//! result. The 32 least-significant bits are returned in lsb.
	//! The 32 most-significant bits are returned in msb.
	//!
    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
    //! \li GLSL 4.00.08 specification, section 8.8
	template <typename genUType>
	void umulExtended(
		genUType const & x, 
		genUType const & y, 
		genUType & msb, 
		genUType & lsb);
		
	//! Multiplies 32-bit integers x and y, producing a 64-bit
	//! result. The 32 least-significant bits are returned in lsb.
	//! The 32 most-significant bits are returned in msb.
	//!
    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
    //! \li GLSL 4.00.08 specification, section 8.8
	template <typename genIType>
	void imulExtended(
		genIType const & x, 
		genIType const & y, 
		genIType & msb, 
		genIType & lsb);

	//! Extracts bits [offset, offset + bits - 1] from value,
	//! returning them in the least significant bits of the result.
	//! For unsigned data types, the most significant bits of the
	//! result will be set to zero. For signed data types, the
	//! most significant bits will be set to the value of bit offset + base – 1.
	//!
	//! If bits is zero, the result will be zero. The result will be
	//! undefined if offset or bits is negative, or if the sum of
	//! offset and bits is greater than the number of bits used
	//! to store the operand.
	//!
    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
    //! \li GLSL 4.00.08 specification, section 8.8
	template <typename genIUType>
	genIUType bitfieldExtract(
		genIUType const & Value, 
		int const & Offset, 
		int const & Bits);

	//! Returns the insertion the bits least-significant bits of insert into base.
	//!
	//! The result will have bits [offset, offset + bits - 1] taken
	//! from bits [0, bits – 1] of insert, and all other bits taken
	//! directly from the corresponding bits of base. If bits is
	//! zero, the result will simply be base. The result will be
	//! undefined if offset or bits is negative, or if the sum of
	//! offset and bits is greater than the number of bits used to
	//! store the operand.
	//!
    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
    //! \li GLSL 4.00.08 specification, section 8.8
	template <typename genIUType>
	genIUType bitfieldInsert(
		genIUType const & Base, 
		genIUType const & Insert, 
		int const & Offset, 
		int const & Bits);

	//! Returns the reversal of the bits of value. 
	//! The bit numbered n of the result will be taken from bit (bits - 1) - n of value, 
	//! where bits is the total number of bits used to represent value.
	//!
    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
    //! \li GLSL 4.00.08 specification, section 8.8
	template <typename genIUType>
	genIUType bitfieldReverse(genIUType const & value);
		
	//! Returns the number of bits set to 1 in the binary representation of value.
	//!
    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
    //! \li GLSL 4.00.08 specification, section 8.8
	template <typename T, template <typename> class C>
	typename C<T>::signed_type bitCount(C<T> const & Value);

	//! Returns the bit number of the least significant bit set to
	//! 1 in the binary representation of value. 
	//! If value is zero, -1 will be returned.
	//!
    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
    //! \li GLSL 4.00.08 specification, section 8.8
	template <typename T, template <typename> class C>
	typename C<T>::signed_type findLSB(C<T> const & Value);

	//! Returns the bit number of the most significant bit in the binary representation of value.
	//! For positive integers, the result will be the bit number of the most significant bit set to 1. 
	//! For negative integers, the result will be the bit number of the most significant
	//! bit set to 0. For a value of zero or negative one, -1 will be returned.
	//!
    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
    //! \li GLSL 4.00.08 specification, section 8.8
	template <typename T, template <typename> class C>
	typename C<T>::signed_type findMSB(C<T> const & Value);

	/// @}
}//namespace glm

#include "func_integer.inl"

#endif//glm_core_func_integer