Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Doc v2 n #1878

Merged
merged 5 commits into from
Jul 7, 2024
Merged

Doc v2 n #1878

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
f994b45
ns core
jtlap Jul 5, 2024
b4dff9f
newton+horner
jtlap Jul 6, 2024
4b67cf1
next nth_root
jtlap Jul 6, 2024
f27c85f
next oneminus
jtlap Jul 6, 2024
d6a23af
newton
jtlap Jul 7, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion include/eve/module/core/regular/ceil.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -37,7 +37,7 @@ namespace eve
//! @addtogroup core_arithmetic
//! @{
//! @var ceil
//! @brief `elementwise_callable` object computing the smallest integer not less than the input.
//! @brief `strict_elementwise_callable` object computing the smallest integer not less than the input.
//!
//! **Defined in Header**
//!
Expand Down
18 changes: 12 additions & 6 deletions include/eve/module/core/regular/nb_values.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,7 +33,7 @@ namespace eve
//! @addtogroup core_internal
//! @{
//! @var nb_values
//! @brief Computes the number of values representable in the type between the
//! @brief `elementwise_callable` object computing the number of values representable in the type between the
//! [arguments](@ref eve::value).
//!
//! **Defined in Header**
Expand All @@ -47,21 +47,27 @@ namespace eve
//! @code
//! namespace eve
//! {
//! template< eve::value T, eve::value U >
//! as_integer_t<common_value_t<T, U>, unsigned> nb_values(T x, T y) noexcept;
//! // Regular overloads
//! constexpr auto nb_values(eve::value auto x, eve::value auto y) noexcept; // 1
//!
//! // Lanes masking
//! constexpr auto nb_values[conditional_expr auto c](eve::value auto x, eve::value auto y) noexcept; // 2
//! constexpr auto nb_values[logical_value auto m](eve::value auto x, eve::value auto y) noexcept; // 2
//! }
//! @endcode
//!
//! **Parameters**
//!
//! * `x`, `y`: [arguments](@ref eve::value).
//! * `x`, `y`: [values](@ref value).
//! * `c`: [Conditional expression](@ref conditional_expr) masking the operation.
//! * `m`: [Logical value](@ref logical) masking the operation.
//!
//! **Return value**
//!
//! Returns the number of values representable in the type in the interval `[x, y[`
//! 1. Returns the number of values representable in the type in the interval `[x, y[`
//! 2. [The operation is performed conditionnaly](@ref conditional).
//!
//! @groupheader{Example}
//!
//! @godbolt{doc/core/nb_values.cpp}
//================================================================================================
inline constexpr auto nb_values = functor<nb_values_t>;
Expand Down
43 changes: 20 additions & 23 deletions include/eve/module/core/regular/nearest.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -35,9 +35,9 @@ namespace eve
//! @addtogroup core_arithmetic
//! @{
//! @var nearest
//! @brief Computes the nearest integer to the input.
//! @brief `strict_elementwise_callable` object computing the nearest integer to the input.
//!
//! **Defined in Header**
//! @groupheader{Header file}
//!
//! @code
//! #include <eve/module/core.hpp>
Expand All @@ -48,36 +48,33 @@ namespace eve
//! @code
//! namespace eve
//! {
//! template< eve::value T >
//! T nearest(T x) noexcept;
//! // Regular overload
//! constexpr auto nearest(value auto x) noexcept; // 1
//!
//! // Lanes masking
//! constexpr auto nearest[conditional_expr auto c](value auto x) noexcept; // 2
//! constexpr auto nearest[logical_value auto m](value auto x) noexcept; // 2
//! }
//! @endcode
//!
//! **Parameters**
//!
//! * `x` : [real](@ref eve::value) argument.
//!
//! **Return value**
//! * `x` :[value](@ref value) argument.
//! * `c`: [Conditional expression](@ref conditional_expr) masking the operation.
//! * `m`: [Logical value](@ref logical) masking the operation.
//! * `tol' [scalar_value](@ref value) tolerance.
//!
//! Computes [elementwise](@ref glossary_elementwise) the integer nearest to `x`.
//! **Return value**
//!
//! If `x` is an exact half-integer the rounding is made to the nearest even integer.
//!
//! The standard proposes 4 rounding modes namely: `FE_TONEAREST`, `FE_DOWNWARD`, `FE_UPWARD`,
//! `FE_TOWARDZERO`. This function object implements the `FE_TONEAREST` version.
//! 1. the integer nearest to `x`. If `x` is an exact half-integer the rounding is made to the
//! nearest even integer.The smallest integer not less than `x`.
//! The standard proposes 4 rounding modes namely: `FE_TONEAREST`, `FE_DOWNWARD`, `FE_UPWARD`,
//! `FE_TOWARDZERO`. This function object implements the `FE_TONEAREST` version.
//! 2. [The operation is performed conditionnaly](@ref conditional).
//!
//! @groupheader{External references}
//! * [C++ standard reference](https://en.cppreference.com/w/cpp/numeric/math/round)
//!
//! @groupheader{Example}
//!
//! @godbolt{doc/core/nearest.cpp}
//!
//! @groupheader{Semantic Modifiers}
//!
//! * Masked Call
//!
//! The call `eve;::nearest[mask](x)` provides a masked version of `eve::nearest` which is
//! equivalent to `if_else (mask, nearest(x), x)`.
//!
//! @}
//================================================================================================
inline constexpr auto nearest = functor<nearest_t>;
Expand Down
58 changes: 30 additions & 28 deletions include/eve/module/core/regular/negabsmax.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,15 +33,14 @@ namespace eve
EVE_CALLABLE_OBJECT(negabsmax_t, negabsmax_);
};


//================================================================================================
//! @addtogroup core_arithmetic
//! @{
//! @var negabsmax
//! @brief Computes the negated absolute value of the maximal element
//!
//! This is equivalent to -eve::abs ( eve::max(...) ). but can be subject to optimizations.
//! @brief `tuple_callable` computing the absolute value of the maximal element.
//!
//! **Defined in Header**
//! @groupheader{Header file}
//!
//! @code
//! #include <eve/module/core.hpp>
Expand All @@ -52,43 +51,46 @@ namespace eve
//! @code
//! namespace eve
//! {
//! template< eve::value T, eve::value... Ts>
//! eve::common_value_t<T, Ts ...> negabsmax( T x, Ts ... xs ) noexcept;
//! // Regular overloads
//! constexpr auto negabsmax(eve::value auto x, eve::value auto ... xs) noexcept; // 1
//! constexpr auto negabsmax(kumi::non_empty_product_type auto const& tup) noexcept; // 2
//!
//! // Lanes masking
//! constexpr auto negabsmax[conditional_expr auto c](/* any of the above overloads */) noexcept; // 3
//! constexpr auto negabsmax[logical_value auto m](/* any of the above overloads */) noexcept; // 3
//!
//! // Semantic option
//! constexpr auto negabsmax[saturated](/* any of the above overloads */) noexcept; // 4
//!
//! // Exclusive Semantic options - Only one of those can be set at once
//! constexpr auto negabsmax[pedantic](/* any of the above overloads */) noexcept; // 5.1
//! constexpr auto negabsmax[numeric ](/* any of the above overloads */) noexcept; // 5.2
//! }
//! @endcode
//!
//!
//! **Parameters**
//!
//! * `x`, `...xs`: [arguments](@ref eve::value).
//! * `x`, `...xs`: [real](@ref value) arguments.
//! * `tup`: [non empty tuple](@ref kumi::non_empty_product_type) of arguments.
//! * `c`: [Conditional expression](@ref conditional_expr) masking the operation.
//! * `m`: [Logical value](@ref logical) masking the operation.
//!
//! **Return value**
//!
//! The negated absolute value of the maximal element
//! is returned.
//!
//! @note
//! If any element of the inputs is a NaN,
//! the corresponding output element is system-dependent.
//! The negated absolute value of the maximal element is returned.
//! 1. If any element of the inputs is a NaN the corresponding output element is system-dependent
//! 2. equivalent to the call on the elements of the tuple.
//! 3. [The operation is performed conditionnaly](@ref conditional)
//! 4. computation internally uses `abs[saturated]` instead of `abs`
//! 5. with `numeric` (resp. `pedantic`) `max[numeric]` (5.1) (resp. `max[pedantic]` (5.2))
//! is used internally
//!
//! @groupheader{Example}
//!
//! @godbolt{doc/core/negabsmax.cpp}
//!
//! @groupheader{Semantic Modifiers}
//!
//! * Masked Call
//!
//! The call `eve::negabsmax[mask](x, ...)` provides a masked version of `eve::negabsmax` which
//! is equivalent to `eve::if_else (mask, negabsmax(x, ...), x)`
//!
//! * eve::pedantic, eve::numeric
//!
//! The call `d(eve::negabsmax)(...)`, where d is one of these two decorators, is equivalent to
//! `-eve::abs (d( eve::max )(...))`.
//!
//! @}
//================================================================================================
inline constexpr auto negabsmax = functor<negabsmax_t>;
inline constexpr auto negabsmax = functor<negabsmax_t>;
}

#include <eve/module/core/regular/impl/negabsmax.hpp>
Expand Down
54 changes: 28 additions & 26 deletions include/eve/module/core/regular/negabsmin.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -37,11 +37,9 @@ namespace eve
//! @addtogroup core_arithmetic
//! @{
//! @var negabsmin
//! @brief Computes the negated absolute value of the minimal element
//! @brief `tuple_callable` computing the absolute value of the minimal element.
//!
//! This is equivalent to -eve::abs ( eve::min(...) ). but can be subject to optimizations.
//!
//! **Defined in Header**
//! @groupheader{Header file}
//!
//! @code
//! #include <eve/module/core.hpp>
Expand All @@ -52,43 +50,47 @@ namespace eve
//! @code
//! namespace eve
//! {
//! template< eve::value T, eve::value... Ts>
//! eve::common_value_t<T, Ts ...> negabsmin( T x, Ts ... xs ) noexcept;
//! // Regular overloads
//! constexpr auto negabsmin(eve::value auto x, eve::value auto ... xs) noexcept; // 1
//! constexpr auto negabsmin(kumi::non_empty_product_type auto const& tup) noexcept; // 2
//!
//! // Lanes masking
//! constexpr auto negabsmin[conditional_expr auto c](/* any of the above overloads */) noexcept; // 3
//! constexpr auto negabsmin[logical_value auto m](/* any of the above overloads */) noexcept; // 3
//!
//! // Semantic options
//! constexpr auto negabsmin[saturated](/* any of the above overloads */) noexcept; // 4
//!
//! // Exclusive Semantic options - Only one of those can be set at once
//! constexpr auto negabsmin[pedantic](/* any of the above overloads */) noexcept; // 5.1
//! constexpr auto negabsmin[numeric ](/* any of the above overloads */) noexcept; // 5.2
//! }
//! @endcode
//!
//! **Parameters**
//!
//! * `x`, `...xs`: [arguments](@ref eve::value).
//! * `x`, `...xs`: [real](@ref value) arguments.
//! * `tup`: [non empty tuple](@ref kumi::non_empty_product_type) of arguments.
//! * `c`: [Conditional expression](@ref conditional_expr) masking the operation.
//! * `m`: [Logical value](@ref logical) masking the operation.
//!
//! **Return value**
//!
//! The negated absolute value of the minimal element
//! is returned.
//!
//! @note
//! If any element of the inputs is a NaN,
//! the corresponding output element is system-dependent.
//! The negated absolute value of the minimal element is returned.
//! 1. If any element of the inputs is a NaN the corresponding output element is system-dependent
//! 2. equivalent to the call on the elements of the tuple.
//! 3. [The operation is performed conditionnaly](@ref conditional)
//! 4. computation internally uses `abs[saturated]` instead of `abs`
//! 5. with `numeric` (resp. `pedantic`) `min[numeric]` (5.1) (resp. `min[pedantic]` (5.2))
//! is used internally
//!
//! @groupheader{Example}
//!
//! @godbolt{doc/core/negabsmin.cpp}
//!
//! @groupheader{Semantic Modifiers}
//!
//! * Masked Call
//!
//! The call `eve::negabsmin[mask](x, ...)` provides a masked version of `eve::negabsmin` which
//! is equivalent to `eve::if_else (mask, negabsmin(x, ...), x)`
//!
//! * eve::pedantic, eve::numeric
//!
//! The call `d(eve::negabsmin)(...)`, where d is one of these two decorators, is equivalent to
//! `-eve::abs (d( eve::min )(...))`.
//!
//! @}
//================================================================================================
inline constexpr auto negabsmin = functor<negabsmin_t>;
inline constexpr auto negabsmin = functor<negabsmin_t>;
}

#include <eve/module/core/regular/impl/negabsmin.hpp>
Expand Down
31 changes: 15 additions & 16 deletions include/eve/module/core/regular/negate.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,7 +14,7 @@
namespace eve
{
template<typename Options>
struct negate_t : elementwise_callable<negate_t, Options, raw_option>
struct negate_t : elementwise_callable<negate_t, Options>
{
template<value T, value U>
requires(eve::same_lanes_or_scalar<T, U>)
Expand All @@ -28,10 +28,10 @@ namespace eve
//! @addtogroup core_arithmetic
//! @{
//! @var negate
//! @brief Computes the [elementwise](@ref glossary_elementwise) product of the first parameter
//! @brief `elementwise_callable` object computing the product of the first parameter
//! by the sign of the second.
//!
//! **Defined in Header**
//! @groupheader{Header file}
//!
//! @code
//! #include <eve/module/core.hpp>
Expand All @@ -42,31 +42,30 @@ namespace eve
//! @code
//! namespace eve
//! {
//! template< eve::value T, eve::value U >
//! eve::common_value_t<T, U> negate(T x, U y) noexcept;
//! // Regular overload
//! constexpr auto negate(value auto x, value auto y) noexcept; // 1
//!
//! // Lanes masking
//! constexpr auto negate[conditional_expr auto c](value auto x, value auto y) noexcept; // 2
//! constexpr auto negate[logical_value auto m](value auto , value auto yx) noexcept; // 2
//! }
//! @endcode
//!
//! **Parameters**
//!
//! * `x`, `y`: [arguments](@ref eve::value).
//! * `tup`: [non empty tuple](@ref kumi::non_empty_product_type) of arguments.
//! * `c`: [Conditional expression](@ref conditional_expr) masking the operation.
//! * `m`: [Logical value](@ref logical) masking the operation.
//!
//! **Return value**
//!
//! The [elementwise](@ref glossary_elementwise) product of the first parameter
//! by the sign of the second is returned.
//! 1. The [elementwise](@ref glossary_elementwise) product of the first parameter
//! by the sign of the second is returned.
//! 2. [The operation is performed conditionnaly](@ref conditional)
//!
//! @groupheader{Example}
//!
//! @godbolt{doc/core/negate.cpp}
//!
//! @groupheader{Semantic Modifiers}
//!
//! * Masked Call
//!
//! The call `eve::negate[mask](x, ...)` provides a masked
//! version of `negate` which is equivalent to `if_else(mask, negate(x, ...), x)`
//!
//! @}
//================================================================================================
inline constexpr auto negate = functor<negate_t>;
Expand Down
Loading