diff options
Diffstat (limited to 'libcxx/test/numerics/numeric.ops')
10 files changed, 897 insertions, 0 deletions
diff --git a/libcxx/test/numerics/numeric.ops/accumulate/accumulate.pass.cpp b/libcxx/test/numerics/numeric.ops/accumulate/accumulate.pass.cpp new file mode 100644 index 00000000000..d3724ba1b9a --- /dev/null +++ b/libcxx/test/numerics/numeric.ops/accumulate/accumulate.pass.cpp @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <numeric> + +// template <InputIterator Iter, MoveConstructible T> +// requires HasPlus<T, Iter::reference> +// && HasAssign<T, HasPlus<T, Iter::reference>::result_type> +// T +// accumulate(Iter first, Iter last, T init); + +#include <numeric> +#include <cassert> + +#include "../iterators.h" + +template <class Iter, class T> +void +test(Iter first, Iter last, T init, T x) +{ + assert(std::accumulate(first, last, init) == x); +} + +template <class Iter> +void +test() +{ + int ia[] = {1, 2, 3, 4, 5, 6}; + unsigned sa = sizeof(ia) / sizeof(ia[0]); + test(Iter(ia), Iter(ia), 0, 0); + test(Iter(ia), Iter(ia), 10, 10); + test(Iter(ia), Iter(ia+1), 0, 1); + test(Iter(ia), Iter(ia+1), 10, 11); + test(Iter(ia), Iter(ia+2), 0, 3); + test(Iter(ia), Iter(ia+2), 10, 13); + test(Iter(ia), Iter(ia+sa), 0, 21); + test(Iter(ia), Iter(ia+sa), 10, 31); +} + +int main() +{ + test<input_iterator<const int*> >(); + test<forward_iterator<const int*> >(); + test<bidirectional_iterator<const int*> >(); + test<random_access_iterator<const int*> >(); + test<const int*>(); +} diff --git a/libcxx/test/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp b/libcxx/test/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp new file mode 100644 index 00000000000..35313500865 --- /dev/null +++ b/libcxx/test/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp @@ -0,0 +1,55 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <numeric> + +// template <InputIterator Iter, MoveConstructible T, +// Callable<auto, const T&, Iter::reference> BinaryOperation> +// requires HasAssign<T, BinaryOperation::result_type> +// && CopyConstructible<BinaryOperation> +// T +// accumulate(Iter first, Iter last, T init, BinaryOperation binary_op); + +#include <numeric> +#include <functional> +#include <cassert> + +#include "../iterators.h" + +template <class Iter, class T> +void +test(Iter first, Iter last, T init, T x) +{ + assert(std::accumulate(first, last, init, std::multiplies<T>()) == x); +} + +template <class Iter> +void +test() +{ + int ia[] = {1, 2, 3, 4, 5, 6}; + unsigned sa = sizeof(ia) / sizeof(ia[0]); + test(Iter(ia), Iter(ia), 1, 1); + test(Iter(ia), Iter(ia), 10, 10); + test(Iter(ia), Iter(ia+1), 1, 1); + test(Iter(ia), Iter(ia+1), 10, 10); + test(Iter(ia), Iter(ia+2), 1, 2); + test(Iter(ia), Iter(ia+2), 10, 20); + test(Iter(ia), Iter(ia+sa), 1, 720); + test(Iter(ia), Iter(ia+sa), 10, 7200); +} + +int main() +{ + test<input_iterator<const int*> >(); + test<forward_iterator<const int*> >(); + test<bidirectional_iterator<const int*> >(); + test<random_access_iterator<const int*> >(); + test<const int*>(); +} diff --git a/libcxx/test/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp b/libcxx/test/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp new file mode 100644 index 00000000000..8e14a90f4f6 --- /dev/null +++ b/libcxx/test/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp @@ -0,0 +1,72 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <numeric> + +// template <InputIterator InIter, +// OutputIterator<auto, const InIter::value_type&> OutIter> +// requires HasMinus<InIter::value_type, InIter::value_type> +// && Constructible<InIter::value_type, InIter::reference> +// && OutputIterator<OutIter, +// HasMinus<InIter::value_type, InIter::value_type>::result_type> +// && MoveAssignable<InIter::value_type> +// OutIter +// adjacent_difference(InIter first, InIter last, OutIter result); + +#include <numeric> +#include <cassert> + +#include "../iterators.h" + +template <class InIter, class OutIter> +void +test() +{ + int ia[] = {15, 10, 6, 3, 1}; + int ir[] = {15, -5, -4, -3, -2}; + const unsigned s = sizeof(ia) / sizeof(ia[0]); + int ib[s] = {0}; + OutIter r = std::adjacent_difference(InIter(ia), InIter(ia+s), OutIter(ib)); + assert(base(r) == ib + s); + for (unsigned i = 0; i < s; ++i) + assert(ib[i] == ir[i]); +} + +int main() +{ + test<input_iterator<const int*>, output_iterator<int*> >(); + test<input_iterator<const int*>, forward_iterator<int*> >(); + test<input_iterator<const int*>, bidirectional_iterator<int*> >(); + test<input_iterator<const int*>, random_access_iterator<int*> >(); + test<input_iterator<const int*>, int*>(); + + test<forward_iterator<const int*>, output_iterator<int*> >(); + test<forward_iterator<const int*>, forward_iterator<int*> >(); + test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); + test<forward_iterator<const int*>, random_access_iterator<int*> >(); + test<forward_iterator<const int*>, int*>(); + + test<bidirectional_iterator<const int*>, output_iterator<int*> >(); + test<bidirectional_iterator<const int*>, forward_iterator<int*> >(); + test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >(); + test<bidirectional_iterator<const int*>, random_access_iterator<int*> >(); + test<bidirectional_iterator<const int*>, int*>(); + + test<random_access_iterator<const int*>, output_iterator<int*> >(); + test<random_access_iterator<const int*>, forward_iterator<int*> >(); + test<random_access_iterator<const int*>, bidirectional_iterator<int*> >(); + test<random_access_iterator<const int*>, random_access_iterator<int*> >(); + test<random_access_iterator<const int*>, int*>(); + + test<const int*, output_iterator<int*> >(); + test<const int*, forward_iterator<int*> >(); + test<const int*, bidirectional_iterator<int*> >(); + test<const int*, random_access_iterator<int*> >(); + test<const int*, int*>(); +} diff --git a/libcxx/test/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp b/libcxx/test/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp new file mode 100644 index 00000000000..2a9135525a1 --- /dev/null +++ b/libcxx/test/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp @@ -0,0 +1,74 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <numeric> + +// template <InputIterator InIter, +// OutputIterator<auto, const InIter::value_type&> OutIter, +// Callable<auto, const InIter::value_type&, const InIter::value_type&> BinaryOperation> +// requires Constructible<InIter::value_type, InIter::reference> +// && OutputIterator<OutIter, BinaryOperation::result_type> +// && MoveAssignable<InIter::value_type> +// && CopyConstructible<BinaryOperation> +// OutIter +// adjacent_difference(InIter first, InIter last, OutIter result, BinaryOperation binary_op); + +#include <numeric> +#include <functional> +#include <cassert> + +#include "../iterators.h" + +template <class InIter, class OutIter> +void +test() +{ + int ia[] = {15, 10, 6, 3, 1}; + int ir[] = {15, 25, 16, 9, 4}; + const unsigned s = sizeof(ia) / sizeof(ia[0]); + int ib[s] = {0}; + OutIter r = std::adjacent_difference(InIter(ia), InIter(ia+s), OutIter(ib), + std::plus<int>()); + assert(base(r) == ib + s); + for (unsigned i = 0; i < s; ++i) + assert(ib[i] == ir[i]); +} + +int main() +{ + test<input_iterator<const int*>, output_iterator<int*> >(); + test<input_iterator<const int*>, forward_iterator<int*> >(); + test<input_iterator<const int*>, bidirectional_iterator<int*> >(); + test<input_iterator<const int*>, random_access_iterator<int*> >(); + test<input_iterator<const int*>, int*>(); + + test<forward_iterator<const int*>, output_iterator<int*> >(); + test<forward_iterator<const int*>, forward_iterator<int*> >(); + test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); + test<forward_iterator<const int*>, random_access_iterator<int*> >(); + test<forward_iterator<const int*>, int*>(); + + test<bidirectional_iterator<const int*>, output_iterator<int*> >(); + test<bidirectional_iterator<const int*>, forward_iterator<int*> >(); + test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >(); + test<bidirectional_iterator<const int*>, random_access_iterator<int*> >(); + test<bidirectional_iterator<const int*>, int*>(); + + test<random_access_iterator<const int*>, output_iterator<int*> >(); + test<random_access_iterator<const int*>, forward_iterator<int*> >(); + test<random_access_iterator<const int*>, bidirectional_iterator<int*> >(); + test<random_access_iterator<const int*>, random_access_iterator<int*> >(); + test<random_access_iterator<const int*>, int*>(); + + test<const int*, output_iterator<int*> >(); + test<const int*, forward_iterator<int*> >(); + test<const int*, bidirectional_iterator<int*> >(); + test<const int*, random_access_iterator<int*> >(); + test<const int*, int*>(); +} diff --git a/libcxx/test/numerics/numeric.ops/inner.product/inner_product.pass.cpp b/libcxx/test/numerics/numeric.ops/inner.product/inner_product.pass.cpp new file mode 100644 index 00000000000..810d66e752f --- /dev/null +++ b/libcxx/test/numerics/numeric.ops/inner.product/inner_product.pass.cpp @@ -0,0 +1,82 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <numeric> + +// template <InputIterator Iter1, InputIterator Iter2, MoveConstructible T> +// requires HasMultiply<Iter1::reference, Iter2::reference> +// && HasPlus<T, HasMultiply<Iter1::reference, Iter2::reference>::result_type> +// && HasAssign<T, +// HasPlus<T, +// HasMultiply<Iter1::reference, +// Iter2::reference>::result_type>::result_type> +// T +// inner_product(Iter1 first1, Iter1 last1, Iter2 first2, T init); + +#include <numeric> +#include <cassert> + +#include "../iterators.h" + +template <class Iter1, class Iter2, class T> +void +test(Iter1 first1, Iter1 last1, Iter2 first2, T init, T x) +{ + assert(std::inner_product(first1, last1, first2, init) == x); +} + +template <class Iter1, class Iter2> +void +test() +{ + int a[] = {1, 2, 3, 4, 5, 6}; + int b[] = {6, 5, 4, 3, 2, 1}; + unsigned sa = sizeof(a) / sizeof(a[0]); + test(Iter1(a), Iter1(a), Iter2(b), 0, 0); + test(Iter1(a), Iter1(a), Iter2(b), 10, 10); + test(Iter1(a), Iter1(a+1), Iter2(b), 0, 6); + test(Iter1(a), Iter1(a+1), Iter2(b), 10, 16); + test(Iter1(a), Iter1(a+2), Iter2(b), 0, 16); + test(Iter1(a), Iter1(a+2), Iter2(b), 10, 26); + test(Iter1(a), Iter1(a+sa), Iter2(b), 0, 56); + test(Iter1(a), Iter1(a+sa), Iter2(b), 10, 66); +} + +int main() +{ + test<input_iterator<const int*>, input_iterator<const int*> >(); + test<input_iterator<const int*>, forward_iterator<const int*> >(); + test<input_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<input_iterator<const int*>, random_access_iterator<const int*> >(); + test<input_iterator<const int*>, const int*>(); + + test<forward_iterator<const int*>, input_iterator<const int*> >(); + test<forward_iterator<const int*>, forward_iterator<const int*> >(); + test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<forward_iterator<const int*>, random_access_iterator<const int*> >(); + test<forward_iterator<const int*>, const int*>(); + + test<bidirectional_iterator<const int*>, input_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, const int*>(); + + test<random_access_iterator<const int*>, input_iterator<const int*> >(); + test<random_access_iterator<const int*>, forward_iterator<const int*> >(); + test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); + test<random_access_iterator<const int*>, const int*>(); + + test<const int*, input_iterator<const int*> >(); + test<const int*, forward_iterator<const int*> >(); + test<const int*, bidirectional_iterator<const int*> >(); + test<const int*, random_access_iterator<const int*> >(); + test<const int*, const int*>(); +} diff --git a/libcxx/test/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp b/libcxx/test/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp new file mode 100644 index 00000000000..c906310cc10 --- /dev/null +++ b/libcxx/test/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp @@ -0,0 +1,85 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <numeric> + +// template <InputIterator Iter1, InputIterator Iter2, MoveConstructible T, +// class BinaryOperation1, +// Callable<auto, Iter1::reference, Iter2::reference> BinaryOperation2> +// requires Callable<BinaryOperation1, const T&, BinaryOperation2::result_type> +// && HasAssign<T, BinaryOperation1::result_type> +// && CopyConstructible<BinaryOperation1> +// && CopyConstructible<BinaryOperation2> +// T +// inner_product(Iter1 first1, Iter1 last1, Iter2 first2, +// T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2); + +#include <numeric> +#include <functional> +#include <cassert> + +#include "../iterators.h" + +template <class Iter1, class Iter2, class T> +void +test(Iter1 first1, Iter1 last1, Iter2 first2, T init, T x) +{ + assert(std::inner_product(first1, last1, first2, init, + std::multiplies<int>(), std::plus<int>()) == x); +} + +template <class Iter1, class Iter2> +void +test() +{ + int a[] = {1, 2, 3, 4, 5, 6}; + int b[] = {6, 5, 4, 3, 2, 1}; + unsigned sa = sizeof(a) / sizeof(a[0]); + test(Iter1(a), Iter1(a), Iter2(b), 1, 1); + test(Iter1(a), Iter1(a), Iter2(b), 10, 10); + test(Iter1(a), Iter1(a+1), Iter2(b), 1, 7); + test(Iter1(a), Iter1(a+1), Iter2(b), 10, 70); + test(Iter1(a), Iter1(a+2), Iter2(b), 1, 49); + test(Iter1(a), Iter1(a+2), Iter2(b), 10, 490); + test(Iter1(a), Iter1(a+sa), Iter2(b), 1, 117649); + test(Iter1(a), Iter1(a+sa), Iter2(b), 10, 1176490); +} + +int main() +{ + test<input_iterator<const int*>, input_iterator<const int*> >(); + test<input_iterator<const int*>, forward_iterator<const int*> >(); + test<input_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<input_iterator<const int*>, random_access_iterator<const int*> >(); + test<input_iterator<const int*>, const int*>(); + + test<forward_iterator<const int*>, input_iterator<const int*> >(); + test<forward_iterator<const int*>, forward_iterator<const int*> >(); + test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<forward_iterator<const int*>, random_access_iterator<const int*> >(); + test<forward_iterator<const int*>, const int*>(); + + test<bidirectional_iterator<const int*>, input_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, const int*>(); + + test<random_access_iterator<const int*>, input_iterator<const int*> >(); + test<random_access_iterator<const int*>, forward_iterator<const int*> >(); + test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); + test<random_access_iterator<const int*>, const int*>(); + + test<const int*, input_iterator<const int*> >(); + test<const int*, forward_iterator<const int*> >(); + test<const int*, bidirectional_iterator<const int*> >(); + test<const int*, random_access_iterator<const int*> >(); + test<const int*, const int*>(); +} diff --git a/libcxx/test/numerics/numeric.ops/iterators.h b/libcxx/test/numerics/numeric.ops/iterators.h new file mode 100644 index 00000000000..01b0e336be6 --- /dev/null +++ b/libcxx/test/numerics/numeric.ops/iterators.h @@ -0,0 +1,314 @@ +#ifndef ITERATORS_H +#define ITERATORS_H + +#include <iterator> + +template <class It> +class output_iterator +{ + It it_; + + template <class U> friend class output_iterator; +public: + typedef std::output_iterator_tag iterator_category; + typedef typename std::iterator_traits<It>::value_type value_type; + typedef typename std::iterator_traits<It>::difference_type difference_type; + typedef It pointer; + typedef typename std::iterator_traits<It>::reference reference; + + It base() const {return it_;} + + explicit output_iterator(It it) : it_(it) {} + template <class U> + output_iterator(const output_iterator<U>& u) :it_(u.it_) {} + + reference operator*() const {return *it_;} + + output_iterator& operator++() {++it_; return *this;} + output_iterator operator++(int) + {output_iterator tmp(*this); ++(*this); return tmp;} +}; + +template <class Iter> +inline +Iter +base(output_iterator<Iter> i) +{ + return i.base(); +} + +template <class It> +class input_iterator +{ + It it_; + + template <class U> friend class input_iterator; +public: + typedef std::input_iterator_tag iterator_category; + typedef typename std::iterator_traits<It>::value_type value_type; + typedef typename std::iterator_traits<It>::difference_type difference_type; + typedef It pointer; + typedef typename std::iterator_traits<It>::reference reference; + + It base() const {return it_;} + + explicit input_iterator(It it) : it_(it) {} + template <class U> + input_iterator(const input_iterator<U>& u) :it_(u.it_) {} + + reference operator*() const {return *it_;} + pointer operator->() const {return it_;} + + input_iterator& operator++() {++it_; return *this;} + input_iterator operator++(int) + {input_iterator tmp(*this); ++(*this); return tmp;} +}; + +template <class T, class U> +inline +bool +operator==(const input_iterator<T>& x, const input_iterator<U>& y) +{ + return x.base() == y.base(); +} + +template <class T, class U> +inline +bool +operator!=(const input_iterator<T>& x, const input_iterator<U>& y) +{ + return !(x == y); +} + +template <class Iter> +inline +Iter +base(input_iterator<Iter> i) +{ + return i.base(); +} + +template <class It> +class forward_iterator +{ + It it_; + + template <class U> friend class forward_iterator; +public: + typedef std::forward_iterator_tag iterator_category; + typedef typename std::iterator_traits<It>::value_type value_type; + typedef typename std::iterator_traits<It>::difference_type difference_type; + typedef It pointer; + typedef typename std::iterator_traits<It>::reference reference; + + It base() const {return it_;} + + forward_iterator() : it_() {} + explicit forward_iterator(It it) : it_(it) {} + template <class U> + forward_iterator(const forward_iterator<U>& u) :it_(u.it_) {} + + reference operator*() const {return *it_;} + pointer operator->() const {return it_;} + + forward_iterator& operator++() {++it_; return *this;} + forward_iterator operator++(int) + {forward_iterator tmp(*this); ++(*this); return tmp;} +}; + +template <class T, class U> +inline +bool +operator==(const forward_iterator<T>& x, const forward_iterator<U>& y) +{ + return x.base() == y.base(); +} + +template <class T, class U> +inline +bool +operator!=(const forward_iterator<T>& x, const forward_iterator<U>& y) +{ + return !(x == y); +} + +template <class Iter> +inline +Iter +base(forward_iterator<Iter> i) +{ + return i.base(); +} + +template <class It> +class bidirectional_iterator +{ + It it_; + + template <class U> friend class bidirectional_iterator; +public: + typedef std::bidirectional_iterator_tag iterator_category; + typedef typename std::iterator_traits<It>::value_type value_type; + typedef typename std::iterator_traits<It>::difference_type difference_type; + typedef It pointer; + typedef typename std::iterator_traits<It>::reference reference; + + It base() const {return it_;} + + bidirectional_iterator() : it_() {} + explicit bidirectional_iterator(It it) : it_(it) {} + template <class U> + bidirectional_iterator(const bidirectional_iterator<U>& u) :it_(u.it_) {} + + reference operator*() const {return *it_;} + pointer operator->() const {return it_;} + + bidirectional_iterator& operator++() {++it_; return *this;} + bidirectional_iterator operator++(int) + {bidirectional_iterator tmp(*this); ++(*this); return tmp;} + + bidirectional_iterator& operator--() {--it_; return *this;} + bidirectional_iterator operator--(int) + {bidirectional_iterator tmp(*this); --(*this); return tmp;} +}; + +template <class T, class U> +inline +bool +operator==(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y) +{ + return x.base() == y.base(); +} + +template <class T, class U> +inline +bool +operator!=(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y) +{ + return !(x == y); +} + +template <class Iter> +inline +Iter +base(bidirectional_iterator<Iter> i) +{ + return i.base(); +} + +template <class It> +class random_access_iterator +{ + It it_; + + template <class U> friend class random_access_iterator; +public: + typedef std::random_access_iterator_tag iterator_category; + typedef typename std::iterator_traits<It>::value_type value_type; + typedef typename std::iterator_traits<It>::difference_type difference_type; + typedef It pointer; + typedef typename std::iterator_traits<It>::reference reference; + + It base() const {return it_;} + + random_access_iterator() : it_() {} + explicit random_access_iterator(It it) : it_(it) {} + template <class U> + random_access_iterator(const random_access_iterator<U>& u) :it_(u.it_) {} + + reference operator*() const {return *it_;} + pointer operator->() const {return it_;} + + random_access_iterator& operator++() {++it_; return *this;} + random_access_iterator operator++(int) + {random_access_iterator tmp(*this); ++(*this); return tmp;} + + random_access_iterator& operator--() {--it_; return *this;} + random_access_iterator operator--(int) + {random_access_iterator tmp(*this); --(*this); return tmp;} + + random_access_iterator& operator+=(difference_type n) {it_ += n; return *this;} + random_access_iterator operator+(difference_type n) const + {random_access_iterator tmp(*this); tmp += n; return tmp;} + friend random_access_iterator operator+(difference_type n, random_access_iterator x) + {x += n; return x;} + random_access_iterator& operator-=(difference_type n) {return *this += -n;} + random_access_iterator operator-(difference_type n) const + {random_access_iterator tmp(*this); tmp -= n; return tmp;} + + reference operator[](difference_type n) const {return it_[n];} +}; + +template <class T, class U> +inline +bool +operator==(const random_access_iterator<T>& x, const random_access_iterator<U>& y) +{ + return x.base() == y.base(); +} + +template <class T, class U> +inline +bool +operator!=(const random_access_iterator<T>& x, const random_access_iterator<U>& y) +{ + return !(x == y); +} + +template <class T, class U> +inline +bool +operator<(const random_access_iterator<T>& x, const random_access_iterator<U>& y) +{ + return x.base() < y.base(); +} + +template <class T, class U> +inline +bool +operator<=(const random_access_iterator<T>& x, const random_access_iterator<U>& y) +{ + return !(y < x); +} + +template <class T, class U> +inline +bool +operator>(const random_access_iterator<T>& x, const random_access_iterator<U>& y) +{ + return y < x; +} + +template <class T, class U> +inline +bool +operator>=(const random_access_iterator<T>& x, const random_access_iterator<U>& y) +{ + return !(x < y); +} + +template <class T, class U> +inline +typename std::iterator_traits<T>::difference_type +operator-(const random_access_iterator<T>& x, const random_access_iterator<U>& y) +{ + return x.base() - y.base(); +} + +template <class Iter> +inline +Iter +base(random_access_iterator<Iter> i) +{ + return i.base(); +} + +template <class Iter> +inline +Iter +base(Iter i) +{ + return i; +} + +#endif diff --git a/libcxx/test/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp b/libcxx/test/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp new file mode 100644 index 00000000000..812eba367cc --- /dev/null +++ b/libcxx/test/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp @@ -0,0 +1,70 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <numeric> + +// template <InputIterator InIter, OutputIterator<auto, const InIter::value_type&> OutIter> +// requires HasPlus<InIter::value_type, InIter::reference> +// && HasAssign<InIter::value_type, +// HasPlus<InIter::value_type, InIter::reference>::result_type> +// && Constructible<InIter::value_type, InIter::reference> +// OutIter +// partial_sum(InIter first, InIter last, OutIter result); + +#include <numeric> +#include <cassert> + +#include "../iterators.h" + +template <class InIter, class OutIter> +void +test() +{ + int ia[] = {1, 2, 3, 4, 5}; + int ir[] = {1, 3, 6, 10, 15}; + const unsigned s = sizeof(ia) / sizeof(ia[0]); + int ib[s] = {0}; + OutIter r = std::partial_sum(InIter(ia), InIter(ia+s), OutIter(ib)); + assert(base(r) == ib + s); + for (unsigned i = 0; i < s; ++i) + assert(ib[i] == ir[i]); +} + +int main() +{ + test<input_iterator<const int*>, output_iterator<int*> >(); + test<input_iterator<const int*>, forward_iterator<int*> >(); + test<input_iterator<const int*>, bidirectional_iterator<int*> >(); + test<input_iterator<const int*>, random_access_iterator<int*> >(); + test<input_iterator<const int*>, int*>(); + + test<forward_iterator<const int*>, output_iterator<int*> >(); + test<forward_iterator<const int*>, forward_iterator<int*> >(); + test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); + test<forward_iterator<const int*>, random_access_iterator<int*> >(); + test<forward_iterator<const int*>, int*>(); + + test<bidirectional_iterator<const int*>, output_iterator<int*> >(); + test<bidirectional_iterator<const int*>, forward_iterator<int*> >(); + test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >(); + test<bidirectional_iterator<const int*>, random_access_iterator<int*> >(); + test<bidirectional_iterator<const int*>, int*>(); + + test<random_access_iterator<const int*>, output_iterator<int*> >(); + test<random_access_iterator<const int*>, forward_iterator<int*> >(); + test<random_access_iterator<const int*>, bidirectional_iterator<int*> >(); + test<random_access_iterator<const int*>, random_access_iterator<int*> >(); + test<random_access_iterator<const int*>, int*>(); + + test<const int*, output_iterator<int*> >(); + test<const int*, forward_iterator<int*> >(); + test<const int*, bidirectional_iterator<int*> >(); + test<const int*, random_access_iterator<int*> >(); + test<const int*, int*>(); +} diff --git a/libcxx/test/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp b/libcxx/test/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp new file mode 100644 index 00000000000..4f7053ee062 --- /dev/null +++ b/libcxx/test/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp @@ -0,0 +1,72 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <numeric> + +// template<InputIterator InIter, +// OutputIterator<auto, const InIter::value_type&> OutIter, +// Callable<auto, const InIter::value_type&, InIter::reference> BinaryOperation> +// requires HasAssign<InIter::value_type, BinaryOperation::result_type> +// && Constructible<InIter::value_type, InIter::reference> +// && CopyConstructible<BinaryOperation> +// OutIter +// partial_sum(InIter first, InIter last, OutIter result, BinaryOperation binary_op); + +#include <numeric> +#include <functional> +#include <cassert> + +#include "../iterators.h" + +template <class InIter, class OutIter> +void +test() +{ + int ia[] = {1, 2, 3, 4, 5}; + int ir[] = {1, -1, -4, -8, -13}; + const unsigned s = sizeof(ia) / sizeof(ia[0]); + int ib[s] = {0}; + OutIter r = std::partial_sum(InIter(ia), InIter(ia+s), OutIter(ib), std::minus<int>()); + assert(base(r) == ib + s); + for (unsigned i = 0; i < s; ++i) + assert(ib[i] == ir[i]); +} + +int main() +{ + test<input_iterator<const int*>, output_iterator<int*> >(); + test<input_iterator<const int*>, forward_iterator<int*> >(); + test<input_iterator<const int*>, bidirectional_iterator<int*> >(); + test<input_iterator<const int*>, random_access_iterator<int*> >(); + test<input_iterator<const int*>, int*>(); + + test<forward_iterator<const int*>, output_iterator<int*> >(); + test<forward_iterator<const int*>, forward_iterator<int*> >(); + test<forward_iterator<const int*>, bidirectional_iterator<int*> >(); + test<forward_iterator<const int*>, random_access_iterator<int*> >(); + test<forward_iterator<const int*>, int*>(); + + test<bidirectional_iterator<const int*>, output_iterator<int*> >(); + test<bidirectional_iterator<const int*>, forward_iterator<int*> >(); + test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >(); + test<bidirectional_iterator<const int*>, random_access_iterator<int*> >(); + test<bidirectional_iterator<const int*>, int*>(); + + test<random_access_iterator<const int*>, output_iterator<int*> >(); + test<random_access_iterator<const int*>, forward_iterator<int*> >(); + test<random_access_iterator<const int*>, bidirectional_iterator<int*> >(); + test<random_access_iterator<const int*>, random_access_iterator<int*> >(); + test<random_access_iterator<const int*>, int*>(); + + test<const int*, output_iterator<int*> >(); + test<const int*, forward_iterator<int*> >(); + test<const int*, bidirectional_iterator<int*> >(); + test<const int*, random_access_iterator<int*> >(); + test<const int*, int*>(); +} diff --git a/libcxx/test/numerics/numeric.ops/version.pass.cpp b/libcxx/test/numerics/numeric.ops/version.pass.cpp new file mode 100644 index 00000000000..f2f9d48ba1f --- /dev/null +++ b/libcxx/test/numerics/numeric.ops/version.pass.cpp @@ -0,0 +1,20 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <numeric> + +#include <numeric> + +#ifndef _LIBCPP_VERSION +#error _LIBCPP_VERSION not defined +#endif + +int main() +{ +} |
