vcl_algorithm.h

DTMK软件开发包,此为开源软件,是一款很好的医学图像开发资源.

    __stl_debug_check(__check_range(first, last));
    first = vcl_find(first, last, value);
    ForwardIterator next = first;
    return first == last ? first : vcl_remove_copy(++next, last, first, value);
}

template <class ForwardIterator, class Predicate>
inline
ForwardIterator vcl_remove_if(ForwardIterator first, ForwardIterator last, Predicate pred) {
    __stl_debug_check(__check_range(first, last));
    first = vcl_find_if(first, last, pred);
    ForwardIterator next = first;
    return first == last ? first : vcl_remove_copy_if(++next, last, first, pred);
}

template <class InputIterator, class ForwardIterator>
inline
ForwardIterator __unique_copy(InputIterator first, InputIterator last,
                              ForwardIterator result, vcl_forward_iterator_tag) {
    *result = *first;
    while (++first != last)
        if (*result != *first) *++result = *first;
    return ++result;
}

template <class InputIterator, class BidirectionalIterator>
inline BidirectionalIterator __unique_copy(InputIterator first,
                                           InputIterator last,
                                           BidirectionalIterator result,
                                           vcl_bidirectional_iterator_tag) {
    return __unique_copy(first, last, result, vcl_forward_iterator_tag());
}

template <class InputIterator, class RandomAccessIterator>
inline RandomAccessIterator __unique_copy(InputIterator first,
                                          InputIterator last,
                                          RandomAccessIterator result,
                                          vcl_random_access_iterator_tag) {
    return __unique_copy(first, last, result, vcl_forward_iterator_tag());
}

template <class InputIterator, class OutputIterator, class T>
inline
OutputIterator __unique_copy(InputIterator first, InputIterator last,
                             OutputIterator result, T*) {
    T value = *first;
    *result = value;
    while (++first != last)
        if (value != *first) {
            value = *first;
            *++result = value;
        }
    return ++result;
}

template <class InputIterator, class OutputIterator>
inline OutputIterator __unique_copy(InputIterator first, InputIterator last,
                                    OutputIterator result,
                                    vcl_output_iterator_tag) {
    return __unique_copy(first, last, result, value_type(first));
}

template <class InputIterator, class OutputIterator>
inline OutputIterator vcl_unique_copy(InputIterator first, InputIterator last,
                                      OutputIterator result) {
    __stl_debug_check(__check_range(first, last));
    if (first == last) return result;
    return __unique_copy(first, last, result, iterator_category(result));
}
template <class InputIterator, class ForwardIterator, class BinaryPredicate>
inline
ForwardIterator __unique_copy(InputIterator first, InputIterator last,
                              ForwardIterator result,
                              BinaryPredicate binary_pred,
                              vcl_forward_iterator_tag) {
    *result = *first;
    while (++first != last)
        if (!binary_pred(*result, *first)) *++result = *first;
    return ++result;
}

template <class InputIterator, class BidirectionalIterator, class BinaryPredicate>
inline BidirectionalIterator __unique_copy(InputIterator first,
                                           InputIterator last,
                                           BidirectionalIterator result,
                                           BinaryPredicate binary_pred,
                                           vcl_bidirectional_iterator_tag) {
    return __unique_copy(first, last, result, binary_pred,
                         vcl_forward_iterator_tag());
}

template <class InputIterator, class RandomAccessIterator, class BinaryPredicate>
inline RandomAccessIterator __unique_copy(InputIterator first,
                                          InputIterator last,
                                          RandomAccessIterator result,
                                          BinaryPredicate binary_pred,
                                          vcl_random_access_iterator_tag) {
    return __unique_copy(first, last, result, binary_pred,
                         vcl_forward_iterator_tag());
}

template <class InputIterator, class OutputIterator, class BinaryPredicate, class T>
inline
OutputIterator __unique_copy(InputIterator first, InputIterator last,
                             OutputIterator result,
                             BinaryPredicate binary_pred, T*) {
    T value = *first;
    *result = value;
    while (++first != last)
        if (!binary_pred(value, *first)) {
            value = *first;
            *++result = value;
        }
    return ++result;
}

template <class InputIterator, class OutputIterator, class BinaryPredicate>
inline OutputIterator __unique_copy(InputIterator first, InputIterator last,
                                    OutputIterator result,
                                    BinaryPredicate binary_pred,
                                    vcl_output_iterator_tag) {
    return __unique_copy(first, last, result, binary_pred, value_type(first));
}

template <class InputIterator, class OutputIterator, class BinaryPredicate>
inline OutputIterator vcl_unique_copy(InputIterator first, InputIterator last,
                                      OutputIterator result,
                                      BinaryPredicate binary_pred) {
    __stl_debug_check(__check_range(first, last));
    if (first == last) return result;
    return __unique_copy(first, last, result, binary_pred,
                         iterator_category(result));
}

template <class ForwardIterator>
inline
ForwardIterator vcl_unique(ForwardIterator first, ForwardIterator last) {
    __stl_debug_check(__check_range(first, last));
    first = vcl_adjacent_find(first, last);
    return vcl_unique_copy(first, last, first);
}

template <class ForwardIterator, class BinaryPredicate>
inline
ForwardIterator vcl_unique(ForwardIterator first, ForwardIterator last,
                           BinaryPredicate binary_pred) {
    __stl_debug_check(__check_range(first, last));
    first = vcl_adjacent_find(first, last, binary_pred);
    return vcl_unique_copy(first, last, first, binary_pred);
}

template <class BidirectionalIterator>
inline
void __reverse(BidirectionalIterator first, BidirectionalIterator last,
               vcl_bidirectional_iterator_tag) {
    while (true)
        if (first == last || first == --last)
            return;
        else {
            iter_swap(first, last);
            ++first;
        }
}

template <class RandomAccessIterator>
inline
void __reverse(RandomAccessIterator first, RandomAccessIterator last,
               vcl_random_access_iterator_tag) {
    for (; first < last; ++first) iter_swap(first, --last);
}

template <class BidirectionalIterator>
inline void vcl_reverse(BidirectionalIterator first, BidirectionalIterator last) {
    __stl_debug_check(__check_range(first, last));
    __reverse(first, last, iterator_category(first));
}

template <class BidirectionalIterator, class OutputIterator>
INLINE_LOOP OutputIterator vcl_reverse_copy(BidirectionalIterator first,
                                            BidirectionalIterator last,
                                            OutputIterator result) {
    __stl_debug_check(__check_range(first, last));
    for (; first != last; ++result) *result = *--last;
    return result;
}

template <class ForwardIterator, class Distance>
inline
void __rotate(ForwardIterator first, ForwardIterator middle,
              ForwardIterator last, Distance*, vcl_forward_iterator_tag) {
    for (ForwardIterator i = middle; true; ) {
        iter_swap(first, i);
        ++first;
        ++i;
        if (first == middle) {
            if (i == last) return;
            middle = i;
        } else if (i == last)
            i = middle;
    }
}

template <class BidirectionalIterator, class Distance>
inline
void __rotate(BidirectionalIterator first, BidirectionalIterator middle,
              BidirectionalIterator last, Distance*,
              vcl_bidirectional_iterator_tag) {
    vcl_reverse(first, middle);
    vcl_reverse(middle, last);
    vcl_reverse(first, last);
}

template <class EuclideanRingElement>
inline
EuclideanRingElement __gcd(EuclideanRingElement m, EuclideanRingElement n)
{
    while (n != 0) {
        EuclideanRingElement t = m % n;
        m = n;
        n = t;
    }
    return m;
}

template <class RandomAccessIterator, class Distance, class T>
inline
void __rotate_cycle(RandomAccessIterator first, RandomAccessIterator last,
                    RandomAccessIterator initial, Distance shift, T*) {
    T value = *initial;
    RandomAccessIterator ptr1 = initial;
    RandomAccessIterator ptr2 = ptr1 + shift;
    while (ptr2 != initial) {
        *ptr1 = *ptr2;
        ptr1 = ptr2;
        if (last - ptr2 > shift)
            ptr2 += shift;
        else
            ptr2 = first + (shift - (last - ptr2));
    }
    *ptr1 = value;
}

template <class RandomAccessIterator, class Distance>
INLINE_LOOP void __rotate(RandomAccessIterator first, RandomAccessIterator middle,
                          RandomAccessIterator last, Distance*,
                          vcl_random_access_iterator_tag) {
    Distance n = __gcd(last - first, middle - first);
    while (n--)
        __rotate_cycle(first, last, first + n, middle - first,
                       value_type(first));
}

template <class ForwardIterator>
inline void vcl_rotate(ForwardIterator first, ForwardIterator middle,
                       ForwardIterator last) {
    __stl_debug_check(__check_range(middle,first, last));
    if (first == middle || middle == last) return;
    __rotate(first, middle, last, distance_type(first),
             iterator_category(first));
}

template <class ForwardIterator, class OutputIterator>
inline
OutputIterator vcl_rotate_copy(ForwardIterator first, ForwardIterator middle,
                               ForwardIterator last, OutputIterator result) {
    __stl_debug_check(__check_range(middle, first, last));
    return vcl_copy(first, middle, vcl_copy(middle, last, result));
}

template <class RandomAccessIterator, class Distance>
inline
void __random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
                      Distance*) {
    if (first == last) return;
    for (RandomAccessIterator i = first + 1; i != last; ++i)
        iter_swap(i, first + Distance(__rand() % ((i - first) + 1)));
}

template <class RandomAccessIterator>
inline void vcl_random_shuffle(RandomAccessIterator first,
                               RandomAccessIterator last) {
    __stl_debug_check(__check_range(first, last));
    __random_shuffle(first, last, distance_type(first));
}

template <class RandomAccessIterator, class RandomNumberGenerator>
inline
void vcl_random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
                        RandomNumberGenerator& rand) {
    __stl_debug_check(__check_range(first, last));
    if (first == last) return;
    for (RandomAccessIterator i = first + 1; i != last; ++i)
        iter_swap(i, first + rand((i - first) + 1));
}

template <class ForwardIterator, class OutputIterator, class Distance>
inline
OutputIterator vcl_random_sample_n(ForwardIterator first, ForwardIterator last,
                                   OutputIterator out, const Distance n)
{
    __stl_debug_check(__check_range(first, last));
    Distance remaining = 0;
    vcl_distance(first, last, remaining);
    Distance m = vcl_min(n, remaining);

    while (m > 0) {
        if (__rand() % remaining < m) {
            *out = *first;
            ++out;
            --m;
        }

        --remaining;
        ++first;
    }
    return out;
}

template <class ForwardIterator, class OutputIterator, class Distance, class RandomNumberGenerator>
inline
OutputIterator vcl_random_sample_n(ForwardIterator first, ForwardIterator last,
                                   OutputIterator out, const Distance n,
                                   RandomNumberGenerator& rand)
{
    __stl_debug_check(__check_range(first, last));
    Distance remaining = 0;
    vcl_distance(first, last, remaining);
    Distance m = vcl_min(n, remaining);

    while (m > 0) {
        if (rand(remaining) < m) {
            *out = *first;
            --m;
            ++out;
        }

        --remaining;
        ++first;
    }
    return out;
}

template <class InputIterator, class RandomAccessIterator, class Distance>
inline
RandomAccessIterator __random_sample(InputIterator first, InputIterator last,
                                     RandomAccessIterator out,
                                     const Distance n)
{
    Distance m = 0;
    Distance t = n;
    for (; first != last && m < n; ++m,++first)
        out[m] = *first;

    while (first != last) {
        ++t;