King_DuckZ/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout synced 2025-08-03 12:49:50 +00:00
Code Issues Releases Wiki Activity

add compost dft, spectrum, etc

Browse source
This commit is contained in:
bolero-MURAKAMI 2012-12-03 21:48:50 +09:00
parent 6b08a81d3e
commit 24d2a229f3
45 changed files with 1490 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

103
sprout/range/adaptor/amplitude_spectrum.hpp Normal file
View file

@ -0,0 +1,103 @@
#ifndef SPROUT_RANGE_ADAPTOR_AMPLITUDE_SPECTRUM_HPP
#define SPROUT_RANGE_ADAPTOR_AMPLITUDE_SPECTRUM_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/pit.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/transform_iterator.hpp>
#include <sprout/range/adaptor/detail/adapted_range_default.hpp>
#include <sprout/range/algorithm/copy.hpp>
#include <sprout/type_traits/lvalue_reference.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include <sprout/numeric/dft/amplitude_spectrum_value.hpp>
namespace sprout {
namespace adaptors {
namespace detail {
template<typename T>
class amplitude_spectrum_value {
public:
typedef typename T::value_type result_type;
typedef T argument_type;
public:
SPROUT_CONSTEXPR result_type operator()(T const& value) const {
return sprout::amplitude_spectrum_value(value);
}
};
} // namespace detail
//
// amplitude_spectrum_range
//
template<typename Range>
class amplitude_spectrum_range
: public sprout::adaptors::detail::adapted_range_default<
Range,
sprout::transform_iterator<
sprout::adaptors::detail::amplitude_spectrum_value<typename sprout::container_traits<Range>::value_type>,
typename sprout::container_traits<Range>::iterator
>
>
{
public:
typedef sprout::adaptors::detail::adapted_range_default<
Range,
sprout::transform_iterator<
sprout::adaptors::detail::amplitude_spectrum_value<typename sprout::container_traits<Range>::value_type>,
typename sprout::container_traits<Range>::iterator
>
> base_type;
typedef typename base_type::range_type range_type;
typedef typename base_type::iterator iterator;
typedef typename base_type::value_type value_type;
public:
amplitude_spectrum_range() = default;
amplitude_spectrum_range(amplitude_spectrum_range const&) = default;
explicit SPROUT_CONSTEXPR amplitude_spectrum_range(range_type& range)
: base_type(
iterator(sprout::begin(range), typename iterator::functor_type()),
iterator(sprout::end(range), typename iterator::functor_type())
)
{}
};
//
// amplitude_spectrum_forwarder
//
class amplitude_spectrum_forwarder {};
//
// amplitude_spectrum
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::amplitude_spectrum_forwarder amplitude_spectrum{};
} // anonymous-namespace
//
// operator|
//
template<typename Range>
inline SPROUT_CONSTEXPR sprout::adaptors::amplitude_spectrum_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>
operator|(Range&& lhs, amplitude_spectrum_forwarder) {
return sprout::adaptors::amplitude_spectrum_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>(
sprout::lvalue_forward<Range>(lhs)
);
}
} // namespace adaptors
//
// container_construct_traits
//
template<typename Range>
struct container_construct_traits<sprout::adaptors::amplitude_spectrum_range<Range> >
: public sprout::container_construct_traits<typename sprout::adaptors::amplitude_spectrum_range<Range>::base_type>
{};
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_AMPLITUDE_SPECTRUM_HPP

10
sprout/range/adaptor/clamped.hpp
View file

@ -45,14 +45,14 @@ namespace sprout {
range_type& range,
value_type const& low,
value_type const& up,
compare_type comp = compare_type()
Compare comp = Compare()
)
: base_type(
iterator(sprout::begin(range), low, up, comp),
iterator(sprout::end(range), low, up, comp)
)
{}
SPROUT_CONSTEXPR compare_type compare() const {
SPROUT_CONSTEXPR Compare compare() const {
return base_type::begin().compare();
}
SPROUT_CONSTEXPR value_type lower() const {
@ -72,14 +72,14 @@ namespace sprout {
typedef Value value_type;
typedef Compare compare_type;
private:
compare_type comp_;
Compare comp_;
value_type low_;
value_type up_;
public:
SPROUT_CONSTEXPR clamp_holder(value_type const& low, value_type const& up, compare_type comp = compare_type())
SPROUT_CONSTEXPR clamp_holder(value_type const& low, value_type const& up, Compare comp = Compare())
: comp_(comp), low_(low), up_(up)
{}
SPROUT_CONSTEXPR compare_type const& compare() const {
SPROUT_CONSTEXPR Compare const& compare() const {
return comp_;
}
SPROUT_CONSTEXPR value_type const& lower() const {

83
sprout/range/adaptor/dft.hpp Normal file
View file

@ -0,0 +1,83 @@
#ifndef SPROUT_RANGE_ADAPTOR_DFT_HPP
#define SPROUT_RANGE_ADAPTOR_DFT_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/pit.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/dft_iterator.hpp>
#include <sprout/range/adaptor/detail/adapted_range_default.hpp>
#include <sprout/range/algorithm/copy.hpp>
#include <sprout/type_traits/lvalue_reference.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/utility/lvalue_forward.hpp>
namespace sprout {
namespace adaptors {
//
// dft_range
//
template<typename Range>
class dft_range
: public sprout::adaptors::detail::adapted_range_default<
Range,
sprout::dft_iterator<typename sprout::container_traits<Range>::iterator>
>
{
public:
typedef sprout::adaptors::detail::adapted_range_default<
Range,
sprout::dft_iterator<typename sprout::container_traits<Range>::iterator>
> base_type;
typedef typename base_type::range_type range_type;
typedef typename base_type::iterator iterator;
public:
dft_range() = default;
dft_range(dft_range const&) = default;
explicit SPROUT_CONSTEXPR dft_range(range_type& range)
: base_type(
iterator(sprout::begin(range), sprout::end(range)),
iterator(sprout::begin(range), sprout::end(range), sprout::size(range))
)
{}
};
//
// dft_forwarder
//
class dft_forwarder {};
//
// dft
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::dft_forwarder dft{};
} // anonymous-namespace
//
// operator|
//
template<typename Range>
inline SPROUT_CONSTEXPR sprout::adaptors::dft_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>
operator|(Range&& lhs, sprout::adaptors::dft_forwarder) {
return sprout::adaptors::dft_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>(
sprout::lvalue_forward<Range>(lhs)
);
}
} // namespace adaptors
//
// container_construct_traits
//
template<typename Range>
struct container_construct_traits<sprout::adaptors::dft_range<Range> >
: public sprout::container_construct_traits<typename sprout::adaptors::dft_range<Range>::base_type>
{};
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_DFT_HPP

8
sprout/range/adaptor/filtered.hpp
View file

@ -42,7 +42,7 @@ namespace sprout {
public:
filtered_range() = default;
filtered_range(filtered_range const&) = default;
SPROUT_CONSTEXPR filtered_range(predicate_type pred, range_type& range)
SPROUT_CONSTEXPR filtered_range(Predicate pred, range_type& range)
: base_type(
iterator(pred, sprout::begin(range), sprout::end(range)),
iterator(pred, sprout::end(range), sprout::end(range))
@ -58,14 +58,14 @@ namespace sprout {
public:
typedef Predicate predicate_type;
private:
predicate_type pred_;
Predicate pred_;
public:
filter_holder() = default;
filter_holder(filter_holder const&) = default;
SPROUT_CONSTEXPR filter_holder(predicate_type pred)
SPROUT_CONSTEXPR filter_holder(Predicate pred)
: pred_(pred)
{}
SPROUT_CONSTEXPR predicate_type predicate() const {
SPROUT_CONSTEXPR Predicate predicate() const {
return pred_;
}
};

83
sprout/range/adaptor/idft.hpp Normal file
View file

@ -0,0 +1,83 @@
#ifndef SPROUT_RANGE_ADAPTOR_IDFT_HPP
#define SPROUT_RANGE_ADAPTOR_IDFT_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/pit.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/idft_iterator.hpp>
#include <sprout/range/adaptor/detail/adapted_range_default.hpp>
#include <sprout/range/algorithm/copy.hpp>
#include <sprout/type_traits/lvalue_reference.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/utility/lvalue_forward.hpp>
namespace sprout {
namespace adaptors {
//
// idft_range
//
template<typename Range>
class idft_range
: public sprout::adaptors::detail::adapted_range_default<
Range,
sprout::idft_iterator<typename sprout::container_traits<Range>::iterator>
>
{
public:
typedef sprout::adaptors::detail::adapted_range_default<
Range,
sprout::idft_iterator<typename sprout::container_traits<Range>::iterator>
> base_type;
typedef typename base_type::range_type range_type;
typedef typename base_type::iterator iterator;
public:
idft_range() = default;
idft_range(idft_range const&) = default;
explicit SPROUT_CONSTEXPR idft_range(range_type& range)
: base_type(
iterator(sprout::begin(range), sprout::end(range)),
iterator(sprout::begin(range), sprout::end(range), sprout::size(range))
)
{}
};
//
// idft_forwarder
//
class idft_forwarder {};
//
// idft
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::idft_forwarder idft{};
} // anonymous-namespace
//
// operator|
//
template<typename Range>
inline SPROUT_CONSTEXPR sprout::adaptors::idft_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>
operator|(Range&& lhs, sprout::adaptors::idft_forwarder) {
return sprout::adaptors::idft_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>(
sprout::lvalue_forward<Range>(lhs)
);
}
} // namespace adaptors
//
// container_construct_traits
//
template<typename Range>
struct container_construct_traits<sprout::adaptors::idft_range<Range> >
: public sprout::container_construct_traits<typename sprout::adaptors::idft_range<Range>::base_type>
{};
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_IDFT_HPP

103
sprout/range/adaptor/phase_spectrum.hpp Normal file
View file

@ -0,0 +1,103 @@
#ifndef SPROUT_RANGE_ADAPTOR_PHASE_SPECTRUM_HPP
#define SPROUT_RANGE_ADAPTOR_PHASE_SPECTRUM_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/pit.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/iterator/transform_iterator.hpp>
#include <sprout/range/adaptor/detail/adapted_range_default.hpp>
#include <sprout/range/algorithm/copy.hpp>
#include <sprout/type_traits/lvalue_reference.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/utility/lvalue_forward.hpp>
#include <sprout/numeric/dft/phase_spectrum_value.hpp>
namespace sprout {
namespace adaptors {
namespace detail {
template<typename T>
class phase_spectrum_value {
public:
typedef typename T::value_type result_type;
typedef T argument_type;
public:
SPROUT_CONSTEXPR result_type operator()(T const& value) const {
return sprout::phase_spectrum_value(value);
}
};
} // namespace detail
//
// phase_spectrum_range
//
template<typename Range>
class phase_spectrum_range
: public sprout::adaptors::detail::adapted_range_default<
Range,
sprout::transform_iterator<
sprout::adaptors::detail::phase_spectrum_value<typename sprout::container_traits<Range>::value_type>,
typename sprout::container_traits<Range>::iterator
>
>
{
public:
typedef sprout::adaptors::detail::adapted_range_default<
Range,
sprout::transform_iterator<
sprout::adaptors::detail::phase_spectrum_value<typename sprout::container_traits<Range>::value_type>,
typename sprout::container_traits<Range>::iterator
>
> base_type;
typedef typename base_type::range_type range_type;
typedef typename base_type::iterator iterator;
typedef typename base_type::value_type value_type;
public:
phase_spectrum_range() = default;
phase_spectrum_range(phase_spectrum_range const&) = default;
explicit SPROUT_CONSTEXPR phase_spectrum_range(range_type& range)
: base_type(
iterator(sprout::begin(range), typename iterator::functor_type()),
iterator(sprout::end(range), typename iterator::functor_type())
)
{}
};
//
// phase_spectrum_forwarder
//
class phase_spectrum_forwarder {};
//
// phase_spectrum
//
namespace {
SPROUT_STATIC_CONSTEXPR sprout::adaptors::phase_spectrum_forwarder phase_spectrum{};
} // anonymous-namespace
//
// operator|
//
template<typename Range>
inline SPROUT_CONSTEXPR sprout::adaptors::phase_spectrum_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>
operator|(Range&& lhs, phase_spectrum_forwarder) {
return sprout::adaptors::phase_spectrum_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>(
sprout::lvalue_forward<Range>(lhs)
);
}
} // namespace adaptors
//
// container_construct_traits
//
template<typename Range>
struct container_construct_traits<sprout::adaptors::phase_spectrum_range<Range> >
: public sprout::container_construct_traits<typename sprout::adaptors::phase_spectrum_range<Range>::base_type>
{};
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_ADAPTOR_PHASE_SPECTRUM_HPP

4
sprout/range/adaptor/replaced.hpp
View file

@ -20,7 +20,7 @@ namespace sprout {
class replace_value {
public:
typedef T const& result_type;
typedef T const& first_argument_type;
typedef T const& argument_type;
private:
T old_;
T new_;
@ -61,7 +61,7 @@ namespace sprout {
public:
replaced_range() = default;
replaced_range(replaced_range const&) = default;
explicit SPROUT_CONSTEXPR replaced_range(range_type& range, value_type const& old_value, value_type const& new_value)
SPROUT_CONSTEXPR replaced_range(range_type& range, value_type const& old_value, value_type const& new_value)
: base_type(
iterator(sprout::begin(range), typename iterator::functor_type(old_value, new_value)),
iterator(sprout::end(range), typename iterator::functor_type(old_value, new_value))

10
sprout/range/adaptor/replaced_if.hpp
View file

@ -21,7 +21,7 @@ namespace sprout {
public:
typedef Predicate predicate_type;
typedef T const& result_type;
typedef T const& first_argument_type;
typedef T const& argument_type;
private:
Predicate pred_;
T new_;
@ -63,7 +63,7 @@ namespace sprout {
public:
replaced_if_range() = default;
replaced_if_range(replaced_if_range const&) = default;
explicit SPROUT_CONSTEXPR replaced_if_range(range_type& range, predicate_type pred, value_type const& new_value)
SPROUT_CONSTEXPR replaced_if_range(range_type& range, Predicate pred, value_type const& new_value)
: base_type(
iterator(sprout::begin(range), typename iterator::functor_type(pred, new_value)),
iterator(sprout::end(range), typename iterator::functor_type(pred, new_value))
@ -80,14 +80,14 @@ namespace sprout {
typedef Predicate predicate_type;
typedef T value_type;
private:
predicate_type pred_;
Predicate pred_;
value_type new_;
public:
SPROUT_CONSTEXPR replace_if_holder(predicate_type pred, value_type const& new_value)
SPROUT_CONSTEXPR replace_if_holder(Predicate pred, value_type const& new_value)
: pred_(pred)
, new_(new_value)
{}
SPROUT_CONSTEXPR predicate_type const& predicate() const {
SPROUT_CONSTEXPR Predicate const& predicate() const {
return pred_;
}
SPROUT_CONSTEXPR value_type const& new_value() const {

4
sprout/range/adaptor/wave.hpp
View file

@ -6,5 +6,9 @@
#include <sprout/range/adaptor/sawtooth_wave.hpp>
#include <sprout/range/adaptor/triangle_wave.hpp>
#include <sprout/range/adaptor/square_wave.hpp>
#include <sprout/range/adaptor/dft.hpp>
#include <sprout/range/adaptor/idft.hpp>
#include <sprout/range/adaptor/amplitude_spectrum.hpp>
#include <sprout/range/adaptor/phase_spectrum.hpp>
#endif // #ifndef SPROUT_RANGE_ADAPTOR_WAVE_HPP

2
sprout/range/numeric/dft.hpp
View file

@ -4,6 +4,8 @@
#include <sprout/config.hpp>
#include <sprout/range/numeric/dft/dft.hpp>
#include <sprout/range/numeric/dft/idft.hpp>
#include <sprout/range/numeric/dft/dft_element.hpp>
#include <sprout/range/numeric/dft/idft_element.hpp>
#include <sprout/range/numeric/dft/spectrum.hpp>
#endif // #ifndef SPROUT_RANGE_NUMERIC_DFT_HPP

22
sprout/range/numeric/dft/dft_element.hpp Normal file
View file

@ -0,0 +1,22 @@
#ifndef SPROUT_RANGE_NUMERIC_DFT_DFT_ELEMENT_HPP
#define SPROUT_RANGE_NUMERIC_DFT_DFT_ELEMENT_HPP
#include <sprout/config.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/numeric/dft/dft_element.hpp>
namespace sprout {
namespace range {
//
// dft_element
//
template<typename Input>
inline SPROUT_CONSTEXPR typename sprout::container_traits<Input>::value_type
dft_element(Input const& input, typename sprout::container_traits<Input>::difference_type i) {
return sprout::dft_element(sprout::begin(input), sprout::end(input), i);
}
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_NUMERIC_DFT_DFT_ELEMENT_HPP

3
sprout/range/numeric/dft/fit/spectrum.hpp
View file

@ -22,4 +22,7 @@ namespace sprout {
} // namespace range
} // namespace sprout
#include <sprout/range/numeric/dft/fit/amplitude_spectrum.hpp>
#include <sprout/range/numeric/dft/fit/phase_spectrum.hpp>
#endif // #ifndef SPROUT_RANGE_NUMERIC_DFT_FIT_SPECTRUM_HPP

3
sprout/range/numeric/dft/fixed/spectrum.hpp
View file

@ -24,4 +24,7 @@ namespace sprout {
} // namespace range
} // namespace sprout
#include <sprout/range/numeric/dft/fixed/amplitude_spectrum.hpp>
#include <sprout/range/numeric/dft/fixed/phase_spectrum.hpp>
#endif // #ifndef SPROUT_RANGE_NUMERIC_DFT_FIXED_SPECTRUM_HPP

22
sprout/range/numeric/dft/idft_element.hpp Normal file
View file

@ -0,0 +1,22 @@
#ifndef SPROUT_RANGE_NUMERIC_DFT_IDFT_ELEMENT_HPP
#define SPROUT_RANGE_NUMERIC_DFT_IDFT_ELEMENT_HPP
#include <sprout/config.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/functions.hpp>
#include <sprout/numeric/dft/idft_element.hpp>
namespace sprout {
namespace range {
//
// idft_element
//
template<typename Input>
inline SPROUT_CONSTEXPR typename sprout::container_traits<Input>::value_type
idft_element(Input const& input, typename sprout::container_traits<Input>::difference_type i) {
return sprout::idft_element(sprout::begin(input), sprout::end(input), i);
}
} // namespace range
} // namespace sprout
#endif // #ifndef SPROUT_RANGE_NUMERIC_DFT_IDFT_ELEMENT_HPP