numeric

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

	class _Fn2> inline
	_OutIt partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute partial sums into _Dest, using _Func
	return (_First == _Last ? _Dest
		: _Partial_sum(_Unchecked(_First), _Unchecked(_Last),
			_Dest, _Func, _Val_type(_First)));
	}

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

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt _Partial_sum2(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func,
		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), _Func, _Val_type(_First));
	return (_Ans);
	}

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

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

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

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

		// TEMPLATE FUNCTION adjacent_difference
template<class _InIt,
	class _OutIt,
	class _Ty> inline
	_OutIt _Adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Ty *)
	{	// compute adjacent differences into _Dest
	_Ty _Val = *_First;
	for (*_Dest = _Val; ++_First != _Last; )
		{	// compute another difference
		_Ty _Tmp = *_First;
		*++_Dest = (_Ty)(_Tmp - _Val);
		_Val = _Tmp;
		}
	return (++_Dest);
	}

 #if _ITERATOR_DEBUG_LEVEL == 0
template<class _InIt,
	class _OutIt> inline
	_OutIt adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest)
	{	// compute adjacent differences into _Dest
	return (_First == _Last ? _Dest
		: _Adjacent_difference(_Unchecked(_First), _Unchecked(_Last),
			_Dest, _Val_type(_First)));
	}

 #else /* _ITERATOR_DEBUG_LEVEL == 0 */
template<class _InIt,
	class _OutIt> inline
	_OutIt _Adjacent_difference1(_InIt _First, _InIt _Last,
		_OutIt _Dest,
		input_iterator_tag, output_iterator_tag)
	{	// compute adjacent differences into _Dest, arbitrary iterators
	return (_Adjacent_difference(_First, _Last,
		_Dest, _Val_type(_First)));
	}

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

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

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

template<class _InIt,
	class _OutIt> inline
	_OutIt adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest)
	{	// compute adjacent differences into _Dest
	_DEBUG_RANGE(_First, _Last);
	_DEBUG_POINTER(_Dest);
	return (_First == _Last ? _Dest
		: _Adjacent_difference1(_Unchecked(_First), _Unchecked(_Last),
			_Dest, _Is_checked(_Dest)));
	}

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

		// TEMPLATE FUNCTION adjacent_difference WITH BINOP
template<class _InIt,
	class _OutIt,
	class _Fn2,
	class _Ty> inline
	_OutIt _Adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func, _Ty *)
	{	// compute adjacent differences into _Dest, using _Func
	_Ty _Val = *_First;
	for (*_Dest = _Val; ++_First != _Last; )
		{	// compute another difference
		_Ty _Tmp = *_First;
		*++_Dest = _Func(_Tmp, _Val);
		_Val = _Tmp;
		}
	return (++_Dest);
	}

 #if _ITERATOR_DEBUG_LEVEL == 0
template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	return (_First == _Last ? _Dest
		: _Adjacent_difference(_Unchecked(_First), _Unchecked(_Last),
			_Dest, _Func, _Val_type(_First)));
	}

 #else /* _ITERATOR_DEBUG_LEVEL == 0 */
template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt _Adjacent_difference2(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func,
		input_iterator_tag, output_iterator_tag)
	{	// compute adjacent differences into _Dest, arbitrary iterators
	return (_Adjacent_difference(_First, _Last,
		_Dest, _Func, _Val_type(_First)));
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt _Adjacent_difference2(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func,
		random_access_iterator_tag, random_access_iterator_tag)
	{	// compute adjacent differences into _Dest, random-access iterators
	_OutIt _Ans = _Dest + (_Last - _First);	// also checks range
	_Adjacent_difference(_First, _Last,
		_Unchecked(_Dest), _Func, _Val_type(_First));
	return (_Ans);
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt _Adjacent_difference2(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func, _STD tr1::true_type)
	{	// compute adjacent differences into _Dest, using _Func
	return (_Adjacent_difference2(_First, _Last,
		_Dest, _Func, _Iter_cat(_First), _Iter_cat(_Dest)));
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
_SCL_INSECURE_DEPRECATE
	_OutIt _Adjacent_difference2(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func, _STD tr1::false_type)
	{	// compute adjacent differences into _Dest, using _Func
	return (_Adjacent_difference2(_First, _Last,
		_Dest, _Func, _Iter_cat(_First), _Iter_cat(_Dest)));
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	_DEBUG_RANGE(_First, _Last);
	_DEBUG_POINTER(_Dest);
	_DEBUG_POINTER(_Func);
	return (_First == _Last ? _Dest
		: _Adjacent_difference2(_Unchecked(_First), _Unchecked(_Last),
			_Dest, _Func, _Is_checked(_Dest)));
	}

template<class _InIt,
	class _OutTy,
	size_t _OutSize,
	class _Fn2> inline
	_OutTy *adjacent_difference(_InIt _First, _InIt _Last,
		_OutTy (&_Dest)[_OutSize], _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	return (_Unchecked(
		_STD adjacent_difference(_First, _Last,
			_Array_iterator<_OutTy, _OutSize>(_Dest), _Func)));
	}
 #endif /* _ITERATOR_DEBUG_LEVEL == 0 */

 #if _HAS_CPP0X
template<class _FwdIt,
	class _Ty> inline
	void _Iota(_FwdIt _First, _FwdIt _Last, _Ty _Val)
	{	// compute increasing sequence into [_First, _Last)
	for (; _First != _Last; ++_First, ++_Val)
		*_First = _Val;
	}

template<class _FwdIt,
	class _Ty> inline
	void iota(_FwdIt _First, _FwdIt _Last, _Ty _Val)
	{	// compute increasing sequence into [_First, _Last)
	_DEBUG_RANGE(_First, _Last);
	_Iota(_Unchecked(_First), _Unchecked(_Last), _Val);
	}
 #endif /* _HAS_CPP0X */
_STD_END
 #pragma warning(pop)
 #pragma pack(pop)

#endif /* RC_INVOKED */
#endif /* _NUMERIC_ */

/*
 * This file is derived from software bearing the following
 * restrictions:
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this
 * software and its documentation for any purpose is hereby
 * granted without fee, provided that the above copyright notice
 * appear in all copies and that both that copyright notice and
 * this permission notice appear in supporting documentation.
 * Hewlett-Packard Company makes no representations about the
 * suitability of this software for any purpose. It is provided
 * "as is" without express or implied warranty.
 */

/*
 * Copyright (c) 1992-2009 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
V5.20:0009 */