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

Конверсии

Существует оператор преобразования в неопределенный булевый тип (скорее всего, указатель участника). Этот оператор преобразует рациональное в<false>, если оно представляет собой ноль, и<true>в противном случае. Это преобразование позволяет рационально использовать в качестве первого аргумента оператора<?:>; в качестве либо аргумента операторов<&&>или<||>без потери оценки короткого замыкания; в качестве условия для утверждения<do>,<if>,<while>или<for>; и в качестве условного заявления для утверждений<if>,<while>или<for>. Природа используемого типа и то, что любые имена для этой природы хранятся в тайне, должны предотвращать любое ненадлежащее небулевое использование, такое как числовые или указательные операции или как<switch>условие.

Нетдругихнеявных превращений из рационального типа. Помимо явного шаблона конструктора кросс-версии, существует явная функция преобразования типаrational_cast(r). Это можно использовать следующим образом:<

    rational<int> r(22,7);
    double nearly_pi = boost::rational_cast<double>(r);

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

По существу, все требуемые преобразования должны сохранять ценность, и все операции должны вести себя «разумно». Если эти ограничения не могут быть выполнены, будет более целесообразным отдельное пользовательское преобразование.

Булева конверсия ирациональное_cast<constexpr>-включено.

Записка об осуществлении:

Реализация функции рационального кастинга<

    template <typename Float, typename Int>
    Float rational_cast(const rational<Int>& src)
    {
        return static_cast<Float>(src.numerator()) / src.denominator();
    }

Номератор и номинатор

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

Производительность

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

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

• Построение рационального — это, по существу, всего две конструкции основного целого типа плюс нормализация.
• Операции сложения и вычитания по существу так же дешевы, как сложение и вычитание по базовому целому типу.
• (В) Сравнение неравенства по существу столь же дешево, как две операции равенства по базовому целому типу.
• Операции ввода-вывода не дешевы, но их производительность в основном зависит от времени ввода-вывода.
• Обычный вызов (имплицитный) GCD по существу представляет собой повторную операцию модуля. Другими важными операциями являются строительство, присвоение и сравнение с нулевым значением IntType. Эти последние операции считаются тривиальными по сравнению с операцией модуля.
• Операция LCM по существу представляет собой GCD плюс умножение, деление и сравнение.
• Операции сложения и вычитания являются сложными. Для них потребуется приблизительно две операции gcd, 3 деления, 3 умножения и добавление к основному целому типу.
• Операции умножения и деления требуют двух операций gcd, двух умножений и четырех делений.
• Операция сравнения с целым выполняет одно целое деление & модульная пара, максимум одно дополнительное целое сложение и декремент, и максимум три целых сравнения.
• Сравнительно-рациональная операция выполняет две операции GCD двойного размера, два дополнительных дополнения и сокращения и три сравнения в худшем случае. (Операции GCD имеют двойной размер, поскольку они выполняются по частям, а промежуточные коэффициенты сохраняются и сравниваются, тогда как прямая функция GCD сохраняет и сравнивает только остальные.)
• Последняя фундаментальная операция — нормализация рационального. Эта операция выполняется всякий раз, когда рациональное построено (и назначено на месте). Все остальные операции аккуратно поддерживают рациональность в нормализованном состоянии. Нормализация обходится в сумму, эквивалентную одному ВВП и двум подразделениям.

Обратите внимание, что подразумевается, что операции на IntType имеют «обычные» эксплуатационные характеристики — в частности, что дорогостоящие операции являются умножением, делением и модулем, при этом сложение и вычитание значительно дешевле. Предполагается, что строительство (от целых букв 0 и 1, а также копирование строительства) и присвоение относительно дешевы, хотя некоторые усилия предпринимаются для уменьшения ненужного строительства и копирования. Также предполагается, что сравнение (особенно с нулем) дешево.

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

Исключения

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

Если оператор(ы) назначения уровня компонента может (могут) бросить, то инварианты рационального объекта могут быть нарушены, если во время назначения второго компонента происходит исключение. (Здесь также указана функция<assign>). Это нарушает как сильные, так и базовые гарантии.

Внутреннее представление

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

Примечания к проекту

Минимальная реализация

Области, в которых это минимальное соображение было смягчено, обеспечивают операторов ввода/вывода и rational_cast. Первый, как правило, бесспорен. Тем не менее, существует ряд случаев, когда рациональное преобразование не является наилучшим способом для преобразования рационального в значение с плавающей точкой (в частности, когда задействованы определенные пользователем типы). В этих случаях может и должно быть реализовано определенное пользователем преобразование. Нет необходимости называть такую операцию рациональной_cast, и поэтому функция рациональной_castнеобеспечивает необходимую инфраструктуру для специализации/перегрузки.

Ограниченные целочисленные типы

К сожалению, стандарт C++ не предлагает такого класса(и в настоящее время не повышает). Поэтому вполне вероятно, что класс рациональных чисел во многих случаях будет использоваться с ограниченно точными целыми типами, такими как встроенныйintтип.

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

В качестве простой иллюстрации проблем, связанных с ограниченными целыми числами точности, рассмотрим случай, когда тип C++intпредставляет собой 32-битное подписанное представление. В этом случае наименьший возможный положительный рациональныйсоставляет1/0x7FFFFFFF. Другими словами, «гранулярность» рационального представления вокруг нуля составляет приблизительно 4,66e-10. На другом конце репрезентабельного диапазона наибольший репрезентабельный рациональныйсоставляет0x7FFFFFFF/1, а следующий нижний репрезентабельный рациональныйсоставляет0x7FFFFFFE/1. Таким образом, на этом конце репрезентируемого диапазона гранулярность ia 1. Этот тип величинозависимой гранулярности типичен для представлений с плавающей точкой. Однако при использовании рационального класса чисел он не «чувствует» себя естественным.

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

Пользователю рационального типа, основанного на целочисленном типе с ограниченной точностью, необходимо знать и кодировать в ожидании таких проблем.

Преобразование из плавающей точки

Ключевой проблемой любой функции преобразования из значения с плавающей точкой является то, как справиться с потерей точности, которая участвует в операциях с плавающей точкой. Чтобы привести конкретный пример, рассмотрим следующий код:<

    // These two values could in practice be obtained from user input,
    // or from some form of measuring instrument.
    double x = 1.0;
    double y = 3.0;
    double z = x/y;
    rational<I> r = rational_from_double(z);

Фундаментальный вопрос заключается в том, что именно должно быть рациональным? Наивный ответ заключается в том, что r должно быть равно 1/3. Однако это игнорирует множество вопросов.

В первом случае z не является точно 1/3. Из-за ограничений представления с плавающей точкой 1/3 не может быть точно представлено ни в одном из общих представлений для двойного типа. Следовательно, не должен ли r содержать (точное) представление фактической величины, представленной z? Но будет ли пользователь доволен значением 333333333333331/100000000000000000000 для r?

Прежде чем даже рассматривать вышеупомянутую проблему, мы должны рассмотреть точность исходных значений, x и y. Например, если они получены из аналогового измерительного прибора, они не являются бесконечно точными. В таком случае рациональное представление, подобное вышеизложенному, обещает гораздо большую точность, чем есть какое-либо оправдание.

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

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

Абсолютное значение

    template <typename IntType>
    inline rational<IntType> abs(const rational<IntType>& r)
    {
        if (r.numerator() >= IntType(0))
            return r;
            return rational<IntType>(-r.numerator(), r.denominator());
    }