Rounding Policies

Boost , ,

Rounding Policies

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

По умолчанию этоинтервал_lib::rounded_math. Классинтервал_lib::rounded_mathуже специализируется на стандартных плавающих типахплавающих,двойныхидлинных двойных. Таким образом, если базовый тип интервалов не является одним из них, хорошим решением будет обеспечить специализацию этого класса. Но если по умолчанию специализацияrounded_mathдляfloat,doubleилиlong double- это не то, что вы ищете, или вы не хотите специализироватьсяinterval_lib::rounded_math(скажем, потому, что вы предпочитаете работать в своем собственном пространстве имен) вы также можете определить свою собственную политику округления и передать ее непосредственноinterval_lib::policies.

Requirements

Вот что должен предоставить класс. Домены пишутся рядом с соответствующими функциями (как видите, функции не должны беспокоиться о недействительных значениях, но они должны обрабатывать бесконечные аргументы).

/* Rounding requirements */
struct rounding {
  // default constructor, destructor
  rounding();
  ~rounding();
  // mathematical operations
  T add_down(T, T); // [-∞;+∞][-∞;+∞]
  T add_up  (T, T); // [-∞;+∞][-∞;+∞]
  T sub_down(T, T); // [-∞;+∞][-∞;+∞]
  T sub_up  (T, T); // [-∞;+∞][-∞;+∞]
  T mul_down(T, T); // [-∞;+∞][-∞;+∞]
  T mul_up  (T, T); // [-∞;+∞][-∞;+∞]
  T div_down(T, T); // [-∞;+∞]([-∞;+∞]-{0})
  T div_up  (T, T); // [-∞;+∞]([-∞;+∞]-{0})
  T sqrt_down(T);   // ]0;+∞]
  T sqrt_up  (T);   // ]0;+∞]
  T exp_down(T);    // [-∞;+∞]
  T exp_up  (T);    // [-∞;+∞]
  T log_down(T);    // ]0;+∞]
  T log_up  (T);    // ]0;+∞]
  T cos_down(T);    // [0;2π]
  T cos_up  (T);    // [0;2π]
  T tan_down(T);    // ]-π/2;π/2[
  T tan_up  (T);    // ]-π/2;π/2[
  T asin_down(T);   // [-1;1]
  T asin_up  (T);   // [-1;1]
  T acos_down(T);   // [-1;1]
  T acos_up  (T);   // [-1;1]
  T atan_down(T);   // [-∞;+∞]
  T atan_up  (T);   // [-∞;+∞]
  T sinh_down(T);   // [-∞;+∞]
  T sinh_up  (T);   // [-∞;+∞]
  T cosh_down(T);   // [-∞;+∞]
  T cosh_up  (T);   // [-∞;+∞]
  T tanh_down(T);   // [-∞;+∞]
  T tanh_up  (T);   // [-∞;+∞]
  T asinh_down(T);  // [-∞;+∞]
  T asinh_up  (T);  // [-∞;+∞]
  T acosh_down(T);  // [1;+∞]
  T acosh_up  (T);  // [1;+∞]
  T atanh_down(T);  // [-1;1]
  T atanh_up  (T);  // [-1;1] 
  T median(T, T);   // [-∞;+∞][-∞;+∞]
  T int_down(T);    // [-∞;+∞]
  T int_up  (T);    // [-∞;+∞]
  // conversion functions
  T conv_down(U);
  T conv_up  (U);
  // unprotected rounding class
  typedef ... unprotected_rounding;
};

Конструктор и деструктор класса округления имеют очень важное семантическое требование: они отвечают за настройку и сброс режимов округления вычислений на Т. Например, если T является стандартным типом с плавающей точкой и вычисление с плавающей точкой выполняется в соответствии со стандартом IEEE 754, конструктор может сохранить текущее состояние округления, каждая_up(resp._down) функция округлит (resp. down), и деструктор восстановит сохраненное состояние округления. Действительно, это поведение политики округления по умолчанию.

Значение всех математических функций доatanh_upясно: каждая функция возвращает число, представленное в типеT, который является нижней границей (для_down) или верхней границей (для_up) на истинном математическом результате соответствующей функции. Функциямедианавычисляет среднее из двух аргументов, округленных до ближайшего репрезентабельного числа. Функцииint_downиint_upвычисляют ближайшее целое число меньше или больше их аргумента. Наконец,conv_downиconv_upотвечают за преобразование значений других типов в базовый тип числа: первый должен округлять значение, а второй должен округлять его.

Типunprotected_roundingпозволяет удалить все элементы управления. По причинам, по которым можно это сделать, см. ниже пункто защите.

Overview of the provided classes

Предусмотрено множество классов. Занятия организованы по уровням. Внизу находится классrounding_control. На следующем уровне идутrounded_arith_exact,rounded_arith_stdиrounded_arith_opp. Далее следуютrounded_transc_dummy,rounded_transc_exact,rounded_transc_stdиrounded_transc_opp. И, наконец,save_stateиsave_state_nothing. Каждый из этих классов предоставляет набор членов, которые необходимы классам следующего уровня. Например, классrounded_transc_...нуждается в членахrounded_arith_...Класс.

Когда они существуют в двух версиях_stdи_opp, первый каждый раз переключает режим округления, а второй пытается держать его ориентированным на плюс бесконечность. Основная цель версии_opp— ускорить вычисления с помощью «противоположного трюка» (см. примечанияк производительности). Эта версия требует, чтобы режим округления был вверх, прежде чем вводить какие-либо вычислительные функции класса. Это гарантирует, что режим округления будет по-прежнему вверх при выходе функций.

Обратите внимание, что это действительно очень плохая идея, чтобы смешать_oppверсия с_std, поскольку они не имеют совместимых свойств.

Существует третья версия под названием_exact, которая вычисляет функции без изменения режима округления. Это точная версия, потому что она предназначена для базового типа, который дает точные результаты.

Последняя версия_dummy. Он не выполняет никаких вычислений, но все же дает совместимые результаты.

Обратите внимание, что можно использовать «точную» версию для неточного базового типа, напримерfloatилиdouble. В этом случае свойство включения больше не гарантируется, но это может быть полезно для ускорения вычислений, когда свойство включения не требуется строго. Например, в компьютерной графике небольшая ошибка из-за округления с плавающей запятой допустима до тех пор, пока существует приблизительная версия свойства включения.

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

template <class T>
struct rounding_control
{
  typedef ... rounding_mode;
  void set_rounding_mode(rounding_mode);
  void get_rounding_mode(rounding_mode&);
  void downward ();
  void upward   ();
  void to_nearest();
  T to_int(T);
  T force_rounding(T);
};
template <class T, class Rounding>
struct rounded_arith_... : Rounding
{
  void init();
  T add_down(T, T);
  T add_up  (T, T);
  T sub_down(T, T);
  T sub_up  (T, T);
  T mul_down(T, T);
  T mul_up  (T, T);
  T div_down(T, T);
  T div_up  (T, T);
  T sqrt_down(T);
  T sqrt_up  (T);
  T median(T, T);
  T int_down(T);
  T int_up  (T);
};
template <class T, class Rounding>
struct rounded_transc_... : Rounding
{
  T exp_down(T);
  T exp_up  (T);
  T log_down(T);
  T log_up  (T);
  T cos_down(T);
  T cos_up  (T);
  T tan_down(T);
  T tan_up  (T);
  T asin_down(T);
  T asin_up  (T);
  T acos_down(T);
  T acos_up  (T);
  T atan_down(T);
  T atan_up  (T);
  T sinh_down(T);
  T sinh_up  (T);
  T cosh_down(T);
  T cosh_up  (T);
  T tanh_down(T);
  T tanh_up  (T);
  T asinh_down(T);
  T asinh_up  (T);
  T acosh_down(T);
  T acosh_up  (T);
  T atanh_down(T);
  T atanh_up  (T);
};
template <class Rounding>
struct save_state_... : Rounding
{
  save_state_...();
  ~save_state_...();
  typedef ... unprotected_rounding;
};

Synopsis

namespace boost {
namespace numeric {
namespace interval_lib {
/* basic rounding control */
template <class T>  struct rounding_control;
/* arithmetic functions rounding */
template <class T, class Rounding = rounding_control<T> > struct rounded_arith_exact;
template <class T, class Rounding = rounding_control<T> > struct rounded_arith_std;
template <class T, class Rounding = rounding_control<T> > struct rounded_arith_opp;
/* transcendental functions rounding */
template <class T, class Rounding> struct rounded_transc_dummy;
template <class T, class Rounding = rounded_arith_exact<T> > struct rounded_transc_exact;
template <class T, class Rounding = rounded_arith_std<T> > struct rounded_transc_std;
template <class T, class Rounding = rounded_arith_opp<T> > struct rounded_transc_opp;
/* rounding-state-saving classes */
template <class Rounding> struct save_state;
template <class Rounding> struct save_state_nothing;
/* default policy for type T */
template <class T>  struct rounded_math;
template <>  struct rounded_math<float>;
template <>  struct rounded_math<double>;
/* some metaprogramming to convert a protected to unprotected rounding */
template <class I> struct unprotect;
} // namespace interval_lib
} // namespace numeric
} // namespace boost

Description of the provided classes

Теперь мы описываем каждый класс в том порядке, в котором они появляются в определении политики округления (этот самый внешний и самый внутренний порядок является обратным порядком из синопсиса).

Protection control

Защита относится к тому факту, что интервальные операции будут окружены контролем режима округления. Незащита класса означает удаление всех элементов управления округлением. Каждая политика округления обеспечивает типunprotected_rounding. Требуемый типunprotected_roundingдает другой класс округления, который позволяет работать при вложении внутрь округления. Например, первые три строки ниже должны давать один и тот же результат (поскольку первая операция - это конструктор округления, а последняя - его деструктор, который заботится о настройке режимов округления); и последней линии разрешено иметь неопределенное поведение (поскольку ни один конструктор округления или деструктор никогда не называется).

T c; { rounding rnd; c = rnd.add_down(a, b); }
T c; { rounding rnd1; { rounding rnd2; c = rnd2.add_down(a, b); } }
T c; { rounding rnd1; { rounding::unprotected_rounding rnd2; c = rnd2.add_down(a, b); } }
T d; { rounding::unprotected_rounding rnd; d = rnd.add_down(a, b); }

Естественноокругление::unprotected_roundingможет быть простоокруглением. Но он может улучшить производительность, если это упрощенная версия с пустым конструктором и деструктором. Чтобы избежать неопределенного поведения, в библиотеке объект типаокругления::unprotected_roundingгарантированно создается только тогда, когда объект типаокругленияуже жив. См.примечания к исполнениюдля некоторых дополнительных деталей.

Библиотека поддержки определяет шаблон класса метапрограммированияunprotect, который принимает тип интервалаIи возвращает тип интервалаunprotect::type, где политика округления была незащищена. Некоторая информация о типах:интервал>::traits_type::roundingявляетсятем же типом, что иRounding, иunprotect>>::typeявляетсятем же типом, что иинтервал>.

template <class T> struct rounded_math<T> : save_state_nothing<rounded_arith_exact<T> > {};

template <> struct rounded_math<float>       : save_state<rounded_arith_opp<float> >       {};
template <> struct rounded_math<double>      : save_state<rounded_arith_opp<double> >      {};
template <> struct rounded_math<long double> : save_state<rounded_arith_opp<long double> > {};

init_rounding_mode();    // rounding object construction during the first addition
t1 = -(-a - c);
t2 = b + d;
restore_rounding_mode(); // rounding object destruction
init_rounding_mode();    // rounding object construction during the second addition
x = -(-t1 - e);
y = t2 + f;
restore_rounding_mode(); // rounding object destruction
// the result is the interval [x,y]

init_rounding_mode();    // done by the user
x = -(-a - c - e);
y = b + d + f;
restore_rounding_mode(); // done by the user

// I is an interval class, the polynom is a simple array
template<class I>
I horner(const I& x, const I p[], int n) {
  // save and initialize the rounding mode
  typename I::traits_type::rounding rnd;
  // define the unprotected version of the interval type
  typedef typename boost::numeric::interval_lib::unprotect<I>::type R;
  const R& a = x;
  R y = p[n - 1];
  for(int i = n - 2; i >= 0; i--) {
    y = y * a + (const R&)(p[i]);
  }
  return y;
  // restore the rounding mode with the destruction of rnd
}