Карта сайта Kansoftware
НОВОСТИУСЛУГИРЕШЕНИЯКОНТАКТЫ
Разработка программного обеспечения

Boost.Hana: Orderable

Boost , ,

Boost.Hana  1.0.1
Your standard library for metaprogramming
Концепция<Orderable>представляет собой полностью упорядоченные типы данных.

Интуитивно<Orderable>объекты должны определить двоичный предикат, названный<less>, возвращая, следует ли считать первый аргумент меньше, чем второй аргумент. Слово «полный» означает, чторазличныеобъекты всегда должны быть упорядочены; если<a>и<b>не равны, то точно один из<less(a, b)>и<less(b, a)>должен быть истинным. Это контрастирует с более слабыми типами порядков, которые позволяют некоторым объектам быть несравнимыми (ни меньше, ни больше). Также обратите внимание, что нестрогий общий заказ всегда может быть получен из строгого общего заказа (и наоборот) путем установки.

a <= b = !(b < a)
a < b = !(b <= a)

Нестрогая версия используется в описании законов, потому что она облегчает их разбор для людей, но они могут быть сформулированы эквивалентно с использованием строгого порядка.

Minimal complete definition

<less>

Когда<less>определено, из него определяются другие методы с использованием того же определения, которое предусмотрено в нижеследующих законах.

Laws

Строго говоря,полный порядок<<=>на множестве<S>является двоичным предикатом \(<= \;: S \times S \to bool \) таким, что для всех<a>,<b>,<c>в<S>,

if a <= b and b <= a then a == b // Antisymmetry
if a <= b and b <= c then a <= c // Transitivity
either a <= b or b <= a // Totality

Кроме того, методы<less>,<greater>и<greater_equal>должны иметь следующие интуитивные значения:

a < b if and only if !(b <= a)
a > b if and only if b < a
a >= b if and only if !(a < b)

Refined concept

  1. Comparable(бесплатная модель)
    ПослеOrderableтребует, чтобыless_equalбыло полным порядком, модельComparableвсегда может быть получена путем установки[ORIG_END] -->

Concrete models

<hana::integral_constant>,<hana::optional>,<hana::pair>,<hana::string>,<hana::tuple>

Free model for LessThanComparable data types

Два типа данных<T>и<U>, которые моделируют кросс-типную версию обычнойконцепции LessThanComparableC++, автоматически являются моделью<Orderable>, устанавливая

less(x, y) = (x < y)

Кросс-версия концепции LessThanComparable аналогична кросс-версии концепции EqualityComparable, представленной вN3351, которая совместима с обычным однотипным определением. Однако обратите внимание, что концепция LessThanComparable требует только<<>бытьстрогим слабым упорядочением, что является более слабым требованием, чем быть полным заказом. Следовательно, если<less>используется с объектами типа данных, которые не определяют общий порядок, некоторые алгоритмы могут иметь неожиданное поведение. По мнению автора, определение<operator<>как неполного порядка является плохой идеей, но это спорно, и поэтому выбор дизайна для предоставления модели для типов данных LessThanComparable открыт для обсуждения. В ожидании ввода пользователя.

Order-preserving functions

Пусть<A>и<B>будут двумя<Orderable>типами данных. Функция \(f: A \to B\) называется упорядоченно-сохраняющей (также называемой монотонной), если она сохраняет структуру концепции<Orderable>, которая может быть строго указана следующим образом. Для всех объектов<x>,<y>типа данных<A>,

if less(x, y) then less(f(x), f(y))

Другим важным свойством является способность отражать порядок, которая может быть определена как

if less(f(x), f(y)) then less(x, y)

Мы говорим, что функция является встраиванием порядка, если она одновременно и сохраняет порядок, и отражает порядок, т.е. если

less(x, y) if and only if less(f(x), f(y))

Cross-type version of the methods

Методы сравнения<less>,<less_equal>,<greater>и<greater_equal>«перегружены» для обработки различных типов данных с определенными свойствами. В частности, они определены дляразличныхтипов данных<A>и<B>, так что

  1. AиBимеют общий тип данныхC, определяемый метафункциейcommon.
  2. A,BиC- всеOrderable, если принимать индивидуально
  3. \(\mathrm{to} : A \to C\) и \(\mathrm{to} : B \to C\) являются порядковыми вставками, определяемыми метафункциейis_embedding.

Определения методов для типов данных, удовлетворяющих вышеуказанным свойствам, являются

less(x, y) = less(to<C>(x), to<C>(y))
less_equal(x, y) = less_equal(to<C>(x), to<C>(y))
greater_equal(x, y) = greater_equal(to<C>(x), to<C>(y))
greater(x, y) = greater(to<C>(x), to<C>(y))

Partial application of the methods

Методы<less>,<greater>,<less_equal>и<greater_equal>можно назвать двумя различными способами. Во-первых, их можно назвать нормальными функциями:

less(x, y)
greater(x, y)

Однако они также могут быть частично применены к следующему аргументу:

less.than(x)(y) == less(y, x)
greater.than(x)(y) == greater(y, x)
less_equal.than(x)(y) == less_equal(y, x)
greater_equal.than(x)(y) == greater_equal(y, x)

Обратите внимание, что порядок аргументов обратный, поэтому, например<less.than(x)(y)>эквивалентен<less(y, x)>, а не<less(x, y)>. Это связано с тем, что эти варианты предназначены для использования с алгоритмами более высокого порядка, где выбранный порядок приложения имеет смысл.

Variables

constexpr auto boost::hana::greater
 Returns a Logical representing whether x is greater than y. More...
 
constexpr auto boost::hana::greater_equal
 Returns a Logical representing whether x is greater than or equal to y. More...
 
constexpr auto boost::hana::less
 Returns a Logical representing whether x is less than y. More...
 
constexpr auto boost::hana::less_equal
 Returns a Logical representing whether x is less than or equal to y. More...
 
constexpr auto boost::hana::max
 Returns the greatest of its arguments according to the less ordering. More...
 
constexpr auto boost::hana::min
 Returns the smallest of its arguments according to the less ordering. More...
 
constexpr auto boost::hana::ordering
 Returns a function performing less after applying a transformation to both arguments.ordering creates a total order based on the result of applying a function to some objects, which is especially useful in conjunction with algorithms that accept a custom predicate that must represent a total order. More...
 

Variable Documentation

constexpr auto boost::hana::greater

<#include <boost/hana/fwd/greater.hpp>>

Initial value:
= [](auto&& x, auto&& y) -> decltype(auto) {
return tag-dispatched;
}

Возвращает<Logical>представление о том, больше ли<x><y>.

Signature

При наличии логических<Bool>и двух упорядоченных<A>и<B>с общим встраиванием подпись \(\mathrm{Greater} : A \times B \to Bool \

Parameters
x,yДва объекта для сравнения.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
namespace hana = boost::hana;
static_assert(hana::greater(4, 1), "");
BOOST_HANA_CONSTANT_CHECK(!hana::greater(hana::int_c<1>, hana::int_c<3>));
int main() { }
constexpr auto boost::hana::greater_equal

<#include <boost/hana/fwd/greater_equal.hpp>>

Initial value:
= [](auto&& x, auto&& y) -> decltype(auto) {
return tag-dispatched;
}

Возвращает<Logical>представление о том, больше ли<x><y>.

Signature

При наличии логических<Bool>и двух упорядоченных<A>и<B>с общим встраиванием подпись \(\mathrm{Greater\_equal} : A \times B \to Bool \

Parameters
x,yДва объекта для сравнения.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
namespace hana = boost::hana;
static_assert(hana::greater_equal(4, 1), "");
static_assert(hana::greater_equal(1, 1), "");
BOOST_HANA_CONSTANT_CHECK(!hana::greater_equal(hana::int_c<1>, hana::int_c<2>));
int main() { }
constexpr auto boost::hana::less

<#include <boost/hana/fwd/less.hpp>>

Initial value:
= [](auto&& x, auto&& y) {
return tag-dispatched;
}

Возвращает<Logical>представление о том, больше ли<x><y>.

Signature

При наличии логических<Bool>и двух упорядоченных<A>и<B>с общим встраиванием подпись \(\mathrm{less} : A \times B \to Bool \

Parameters
x,yДва объекта для сравнения.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
namespace hana = boost::hana;
static_assert(hana::less(1, 4), "");
BOOST_HANA_CONSTANT_CHECK(!hana::less(hana::int_c<3>, hana::int_c<2>));
// less.than is syntactic sugar
static_assert(hana::all_of(hana::tuple_c<int, 1, 2, 3, 4>, hana::less.than(5)), "");
BOOST_HANA_CONSTANT_CHECK(hana::all_of(hana::tuple_c<int, 1, 2, 3, 4>, hana::less_equal.than(hana::int_c<4>)));
int main() { }
constexpr auto boost::hana::less_equal

<#include <boost/hana/fwd/less_equal.hpp>>

Initial value:
= [](auto&& x, auto&& y) {
return tag-dispatched;
}

Возвращает<Logical>представление о том, больше ли<x><y>.

Signature

При наличии логических<Bool>и двух упорядоченных<A>и<B>с общим встраиванием подпись \(\mathrm{less\_equal} : A \times B \to Bool \

Parameters
x,yДва объекта для сравнения.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
namespace hana = boost::hana;
static_assert(hana::less_equal(1, 4), "");
static_assert(hana::less_equal(1, 1), "");
BOOST_HANA_CONSTANT_CHECK(!hana::less_equal(hana::int_c<3>, hana::int_c<2>));
int main() { }
constexpr auto boost::hana::max

<#include <boost/hana/fwd/max.hpp>>

Initial value:
= [](auto&& x, auto&& y) -> decltype(auto) {
return tag-dispatched;
}

Возвращает наибольший из своих аргументов согласно<less>приказу.

Todo:
Can't specify the signature here either. See min for details.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
namespace hana = boost::hana;
static_assert(hana::max(1, 4) == 4, "");
BOOST_HANA_CONSTANT_CHECK(hana::max(hana::int_c<7>, hana::int_c<5>) == hana::int_c<7>);
int main() { }
constexpr auto boost::hana::min

<#include <boost/hana/fwd/min.hpp>>

Initial value:
= [](auto&& x, auto&& y) -> decltype(auto) {
return tag-dispatched;
}

Возвращает наименьший из своих аргументов в соответствии с приказом<less>.

Todo:
We can't specify the signature right now, because the tag of the returned object depends on whether x < y or not. If we wanted to be mathematically correct, we should probably ask that if_(cond, x, y) returns a common data type of x and y, and then the behavior of min would follow naturally. However, I'm unsure whether this is desirable because that's a big requirement.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
namespace hana = boost::hana;
static_assert(hana::min(1, 4) == 1, "");
BOOST_HANA_CONSTANT_CHECK(hana::min(hana::int_c<7>, hana::int_c<5>) == hana::int_c<5>);
int main() { }
constexpr auto boost::hana::ordering

<#include <boost/hana/fwd/ordering.hpp>>

Initial value:
= [](auto&& f) {
return [perfect-capture](auto&& x, auto&& y) -> decltype(auto) {
return less(f(forwarded(x)), f(forwarded(y)));
};
}
constexpr auto less
Returns a Logical representing whether x is less than y.
Definition: less.hpp:37
constexpr auto capture
Create a function capturing the given variables.
Definition: capture.hpp:45

Возвращает функцию, выполняющуюся<less>после применения преобразования к обоим аргументам.<ordering>создает полный порядок, основанный на результате применения функции к некоторым объектам, что особенно полезно в сочетании с алгоритмами, которые принимают пользовательский предикат, который должен представлять полный порядок.

В частности,<ordering>является

ordering(f) == less ^on^ f

или, эквивалентно,

ordering(f)(x, y) == less(f(x), f(y))
Note
This is not a tag-dispatched method (hence it can't be customized), but just a convenience function provided with the Orderable concept.

Signature

При наличии логических<Bool>и упорядоченных<B>подпись \(\mathrm{ordering} : (A \to B) \to (A \times A \to Bool) \).

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
namespace hana = boost::hana;
constexpr auto sorted = hana::sort.by(hana::ordering(hana::sizeof_),
hana::tuple_t<char[3], char[1], char[2], char[15]>
);
BOOST_HANA_CONSTANT_CHECK(sorted == hana::tuple_t<char[1], char[2], char[3], char[15]>);
int main() { }

Статья Boost.Hana: Orderable раздела может быть полезна для разработчиков на c++ и boost.




Материалы статей собраны из открытых источников, владелец сайта не претендует на авторство. Там где авторство установить не удалось, материал подаётся без имени автора. В случае если Вы считаете, что Ваши права нарушены, пожалуйста, свяжитесь с владельцем сайта.



:: Главная :: ::


реклама


©KANSoftWare (разработка программного обеспечения, создание программ, создание интерактивных сайтов), 2007
Top.Mail.Ru

Время компиляции файла: 2024-08-30 11:47:00
2025-05-19 21:44:40/0.010828971862793/1