numeric

C语言库函数的原型,有用的拿去

// numeric standard header
#pragma once
#ifndef _NUMERIC_
#define _NUMERIC_
#ifndef RC_INVOKED
#include <xutility>

 #pragma pack(push,_CRT_PACKING)
 #pragma warning(push,3)
_STD_BEGIN
		// TEMPLATE FUNCTION accumulate
template<class _InIt,
	class _Ty> inline
	_Ty _Accumulate(_InIt _First, _InIt _Last, _Ty _Val)
	{	// return sum of _Val and all in [_First, _Last)
	for (; _First != _Last; ++_First)
		_Val = (_Ty)(_Val + *_First);
	return (_Val);
	}

template<class _InIt,
	class _Ty> inline
	_Ty accumulate(_InIt _First, _InIt _Last, _Ty _Val)
	{	// return sum of _Val and all in [_First, _Last)
	_DEBUG_RANGE(_First, _Last);
	return (_Accumulate(_Unchecked(_First), _Unchecked(_Last), _Val));
	}

		// TEMPLATE FUNCTION accumulate WITH BINOP
template<class _InIt,
	class _Ty,
	class _Fn2> inline
	_Ty _Accumulate(_InIt _First, _InIt _Last, _Ty _Val, _Fn2 _Func)
	{	// return sum of _Val and all in [_First, _Last), using _Func
	for (; _First != _Last; ++_First)
		_Val = _Func(_Val, *_First);
	return (_Val);
	}

template<class _InIt,
	class _Ty,
	class _Fn2> inline
	_Ty accumulate(_InIt _First, _InIt _Last, _Ty _Val, _Fn2 _Func)
	{	// return sum of _Val and all in [_First, _Last), using _Func
	_DEBUG_RANGE(_First, _Last);
	_DEBUG_POINTER(_Func);
	return (_Accumulate(_Unchecked(_First), _Unchecked(_Last), _Val, _Func));
	}

		// TEMPLATE FUNCTION inner_product
template<class _InIt1,
	class _InIt2,
	class _Ty> inline
	_Ty _Inner_product(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val)
	{	// return inner product of sequences
	for (; _First1 != _Last1; ++_First1, ++_First2)
		_Val = (_Ty)(_Val + *_First1 * *_First2);
	return (_Val);
	}

 #if _ITERATOR_DEBUG_LEVEL == 0
template<class _InIt1,
	class _InIt2,
	class _Ty> inline
	_Ty inner_product(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val)
	{	// return inner product of sequences
	_DEBUG_RANGE(_First1, _Last1);
	_DEBUG_POINTER(_First2);
	return (_Inner_product(_Unchecked(_First1), _Unchecked(_Last1),
		_First2, _Val));
	}

 #else /* _ITERATOR_DEBUG_LEVEL == 0 */
template<class _InIt1,
	class _InIt2,
	class _Ty> inline
	_Ty _Inner_product1(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val, _STD tr1::true_type)
	{	// return inner product of sequences
	return (_Inner_product(_First1, _Last1,
		_First2, _Val));
	}

template<class _InIt1,
	class _InIt2,
	class _Ty> inline
_SCL_INSECURE_DEPRECATE
	_Ty _Inner_product1(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val, _STD tr1::false_type)
	{	// return inner product of sequences
	return (_Inner_product(_First1, _Last1,
		_First2, _Val));
	}

template<class _InIt1,
	class _InIt2,
	class _Ty> inline
	_Ty inner_product(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val)
	{	// return inner product of sequences
	_DEBUG_RANGE(_First1, _Last1);
	_DEBUG_POINTER(_First2);
	return (_Inner_product1(_Unchecked(_First1), _Unchecked(_Last1),
		_First2, _Val, _Is_checked(_First2)));
	}

template<class _InIt1,
	class _InTy,
	size_t _InSize,
	class _Ty> inline
	_Ty inner_product(_InIt1 _First1, _InIt1 _Last1,
		_InTy (&_First2)[_InSize], _Ty _Val)
	{	// return inner product of sequences
	return (inner_product(_First1, _Last1,
		_Array_iterator<_InTy, _InSize>(_First2), _Val));
	}
 #endif /* _ITERATOR_DEBUG_LEVEL == 0 */

		// TEMPLATE FUNCTION inner_product WITH BINOPS
template<class _InIt1,
	class _InIt2,
	class _Ty,
	class _Fn21,
	class _Fn22> inline
	_Ty _Inner_product(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{	// return inner product of sequences, using _Func1 and _Func2
	for (; _First1 != _Last1; ++_First1, ++_First2)
		_Val = _Func1(_Val, _Func2(*_First1, *_First2));
	return (_Val);
	}

 #if _ITERATOR_DEBUG_LEVEL == 0
template<class _InIt1,
	class _InIt2,
	class _Ty,
	class _Fn21,
	class _Fn22> inline
	_Ty inner_product(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{	// return inner product of sequences, using _Func1 and _Func2
	_DEBUG_RANGE(_First1, _Last1);
	_DEBUG_POINTER(_First2);
	_DEBUG_POINTER(_Func1);
	_DEBUG_POINTER(_Func2);
	return (_Inner_product(_Unchecked(_First1), _Unchecked(_Last1),
		_First2, _Val,
		_Func1, _Func2));
	}

 #else /* _ITERATOR_DEBUG_LEVEL == 0 */
template<class _InIt1,
	class _InIt2,
	class _Ty,
	class _Fn21,
	class _Fn22> inline
	_Ty _Inner_product2(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2, _STD tr1::true_type)
	{	// return inner product of sequences, using _Func1 and _Func2
	return (_Inner_product(_First1, _Last1,
		_First2, _Val,
		_Func1, _Func2));
	}

template<class _InIt1,
	class _InIt2,
	class _Ty,
	class _Fn21,
	class _Fn22> inline
_SCL_INSECURE_DEPRECATE
	_Ty _Inner_product2(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2, _STD tr1::false_type)
	{	// return inner product of sequences, using _Func1 and _Func2
	return (_Inner_product(_First1, _Last1,
		_First2, _Val,
		_Func1, _Func2));
	}

template<class _InIt1,
	class _InIt2,
	class _Ty,
	class _Fn21,
	class _Fn22> inline
	_Ty inner_product(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{	// return inner product of sequences, using _Func1 and _Func2
	_DEBUG_RANGE(_First1, _Last1);
	_DEBUG_POINTER(_First2);
	_DEBUG_POINTER(_Func1);
	_DEBUG_POINTER(_Func2);
	return (_Inner_product2(_Unchecked(_First1), _Unchecked(_Last1),
		_First2, _Val,
		_Func1, _Func2, _Is_checked(_First2)));
	}

template<class _InIt1,
	class _InTy,
	size_t _InSize,
	class _Ty,
	class _Fn21,
	class _Fn22> inline
	_Ty inner_product(_InIt1 _First1, _InIt1 _Last1,
		_InTy (&_First2)[_InSize], _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{	// return inner product of sequences, using _Func1 and _Func2
	return (inner_product(_First1, _Last1,
		_Array_iterator<_InTy, _InSize>(_First2), _Val,
		_Func1, _Func2));
	}
 #endif /* _ITERATOR_DEBUG_LEVEL == 0 */

		// TEMPLATE FUNCTION partial_sum
template<class _InIt,
	class _OutIt,
	class _Ty> inline
	_OutIt _Partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Ty *)
	{	// compute partial sums into _Dest
	_Ty _Val = *_First;
	for (*_Dest = _Val; ++_First != _Last; *++_Dest = _Val)
		_Val = (_Ty)(_Val + *_First);
	return (++_Dest);
	}

 #if _ITERATOR_DEBUG_LEVEL == 0
template<class _InIt,
	class _OutIt> inline
	_OutIt partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest)
	{	// compute partial sums into _Dest
	return (_First == _Last ? _Dest
		: _Partial_sum(_Unchecked(_First), _Unchecked(_Last),
			_Dest, _Val_type(_First)));
	}

 #else /* _ITERATOR_DEBUG_LEVEL == 0 */
template<class _InIt,
	class _OutIt> inline
	_OutIt _Partial_sum1(_InIt _First, _InIt _Last,
		_OutIt _Dest,
		input_iterator_tag, output_iterator_tag)
	{	// compute partial sums into _Dest, arbitrary iterators
	return (_Partial_sum(_First, _Last,
		_Dest, _Val_type(_First)));
	}

template<class _InIt,
	class _OutIt> inline
	_OutIt _Partial_sum1(_InIt _First, _InIt _Last,
		_OutIt _Dest,
		random_access_iterator_tag, random_access_iterator_tag)
	{	// compute partial sums into _Dest, random-access iterators
	_OutIt _Ans = _Dest + (_Last - _First);	// also checks range
	_Partial_sum(_First, _Last,
		_Unchecked(_Dest), _Val_type(_First));
	return (_Ans);
	}

template<class _InIt,
	class _OutIt> inline
	_OutIt _Partial_sum1(_InIt _First, _InIt _Last,
		_OutIt _Dest, _STD tr1::true_type)
	{	// compute partial sums into _Dest
	return (_Partial_sum1(_First, _Last,
		_Dest, _Iter_cat(_First), _Iter_cat(_Dest)));
	}

template<class _InIt,
	class _OutIt> inline
_SCL_INSECURE_DEPRECATE
	_OutIt _Partial_sum1(_InIt _First, _InIt _Last,
		_OutIt _Dest, _STD tr1::false_type)
	{	// compute partial sums into _Dest
	return (_Partial_sum1(_First, _Last,
		_Dest, _Iter_cat(_First), _Iter_cat(_Dest)));
	}

template<class _InIt,
	class _OutIt> inline
	_OutIt partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest)
	{	// compute partial sums into _Dest
	_DEBUG_RANGE(_First, _Last);
	_DEBUG_POINTER(_Dest);
	return (_First == _Last ? _Dest
		: _Partial_sum1(_Unchecked(_First), _Unchecked(_Last),
			_Dest, _Is_checked(_Dest)));
	}

template<class _InIt,
	class _OutTy,
	size_t _OutSize> inline
	_OutTy *partial_sum(_InIt _First, _InIt _Last,
		_OutTy (&_Dest)[_OutSize])
	{	// compute partial sums into _Dest
	return (_Unchecked(
		_STD partial_sum(_First, _Last,
			_Array_iterator<_OutTy, _OutSize>(_Dest))));
	}
 #endif /* _ITERATOR_DEBUG_LEVEL == 0 */

		// TEMPLATE FUNCTION partial_sum WITH BINOP
template<class _InIt,
	class _OutIt,
	class _Fn2,
	class _Ty> inline
	_OutIt _Partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func, _Ty *)
	{	// compute partial sums into _Dest, using _Func
	_Ty _Val = *_First;
	for (*_Dest = _Val; ++_First != _Last; *++_Dest = _Val)
		_Val = _Func(_Val, *_First);
	return (++_Dest);
	}

 #if _ITERATOR_DEBUG_LEVEL == 0
template<class _InIt,
	class _OutIt,