Synopsis

#включает </мат/специальные_функции/воздушные.hpp>

Функции для получения как одного нуля, так и корня функций Airy, и размещения нескольких нулей в контейнере, как std::вектор, путем предоставления выходного итератора.

Сигнатурой единичных функций значений являются:

template <class T>
T airy_ai_zero(
         int m);         // 1-based index of zero.
template <class T>
T airy_bi_zero(
         int m);         // 1-based index of zero.

для нескольких нулей:

template <class T, class OutputIterator>
OutputIterator airy_ai_zero(
                     int start_index,           // 1-based index of first zero.
                     unsigned number_of_zeros,  // How many zeros to generate.
                     OutputIterator out_it);    // Destination for zeros.
template <class T, class OutputIterator>
OutputIterator airy_bi_zero(
                     int start_index,           // 1-based index of zero.
                     unsigned number_of_zeros,  // How many zeros to generate
                     OutputIterator out_it);    // Destination for zeros.

Существуют также версии, которые позволяют управлять Политиками для обработки ошибок и точности.

 template <class T>
 T airy_ai_zero(
          int m,          // 1-based index of zero.
          const Policy&); // Policy to use.
 template <class T>
 T airy_bi_zero(
          int m,          // 1-based index of zero.
          const Policy&); // Policy to use.
template <class T, class OutputIterator>
OutputIterator airy_ai_zero(
                     int start_index,           // 1-based index of first zero.
                     unsigned number_of_zeros,  // How many zeros to generate.
                     OutputIterator out_it,     // Destination for zeros.
                     const Policy& pol);        // Policy to use.
template <class T, class OutputIterator>
OutputIterator airy_bi_zero(
                     int start_index,           // 1-based index of zero.
                     unsigned number_of_zeros,  // How many zeros to generate.
                     OutputIterator out_it,     // Destination for zeros.
                     const Policy& pol);        // Policy to use.

Description

Функции Эйри Ай и Би имеют бесконечное число нулей на отрицательной реальной оси. Реальные нули на отрицательной реальной оси можно найти, решая для корней

  Ai(x_m) = 0

  Bi(y_m) = 0

Здесь x_m представляет собой m^th корень функции Airy Ai, а y_m представляет собой m^th корень функции Airy Bi.

Нули или корни (значения x, где функция пересекает горизонтальную y = 0 ось) функций Airy Ai и Bi вычисляются двумя функциями, airy_ai_zero и airy_bi_zero.

В каждом случае индекс или ранг нуля возвращается на основе 1, что означает:

airy_ai_zero(1);

возвращает первый ноль Ai.

Прохождение start_index <= 0 приводит к повышению domain_error.

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

Examples of finding Airy Zeros

Этот пример демонстрирует вычисление нулей функций Эйри. Это также показывает, как увеличить. Математика и рост. Многоточность может быть объединена, чтобы обеспечить точность многих десятичных цифр. Для точности 50 десятичных цифр мы должны включить

#include <boost/multiprecision/cpp_dec_float.hpp>

и typedef для float_type может быть удобным (что позволяет быстро переключаться на повторные вычисления при встроенном double или другой точности)

typedef boost::multiprecision::cpp_dec_float_50 float_type;

Чтобы использовать функции для поиска нулей функций, которые нам нужны

#include <boost/math/special_functions/airy.hpp>

Этот пример показывает получение как одного нуля функций Airy, так и размещение нескольких нулей в контейнере, таком как std::vector, путем предоставления итератора. Подпись однозначной функции Airy Ai:

template <class T>
T airy_ai_zero(unsigned m); // 1-based index of the zero.

Подпись нескольких нулей Эйри Функция Ai:

template <class T, class OutputIterator>
OutputIterator airy_ai_zero(
                         unsigned start_index, // 1-based index of the zero.
                         unsigned number_of_zeros, // How many zeros to generate.
                         OutputIterator out_it); // Destination for zeros.

Существуют также версии, которые позволяют управлять Политиками для обработки ошибок и точности.

template <class T, class OutputIterator, class Policy>
OutputIterator airy_ai_zero(
                         unsigned start_index, // 1-based index of the zero.
                         unsigned number_of_zeros, // How many zeros to generate.
                         OutputIterator out_it, // Destination for zeros.
                         const Policy& pol);  // Policy to use.

	Tip
	Всегда целесообразно размещать код с помощью Boost. Математика внутри блоков try'n'catch; это обеспечит отображение полезных сообщений об ошибках при возникновении исключительных условий.

Сначала оцените один ноль Эйри.

Точность контролируется параметром шаблона T, поэтому этот пример имеет точность double, по меньшей мере 15, но до 17 десятичных цифр (для обычного 64-битного двойника).

double aiz1 = boost::math::airy_ai_zero<double>(1);
std::cout << "boost::math::airy_ai_zero<double>(1) = " << aiz1 << std::endl;
double aiz2 = boost::math::airy_ai_zero<double>(2);
std::cout << "boost::math::airy_ai_zero<double>(2) = " << aiz2 << std::endl;
double biz3 = boost::math::airy_bi_zero<double>(3);
std::cout << "boost::math::airy_bi_zero<double>(3) = " << biz3 << std::endl;

Другие версии airy_ai_zero и airy_bi_zero позволяют вычислить несколько нулей одним вызовом, помещая результаты в контейнер, часто std::vector. Например, сгенерируйте и отобразите первые пять корней double Wolfram Airy Functions Zeros.

unsigned int n_roots = 5U;
std::vector<double> roots;
boost::math::airy_ai_zero<double>(1U, n_roots, std::back_inserter(roots));
std::cout << "airy_ai_zeros:" << std::endl;
std::copy(roots.begin(),
          roots.end(),
          std::ostream_iterator<double>(std::cout, "\n"));

Первые несколько реальных корней Ai(x) приблизительно -2.33811, -4.08795, -5.52056, -6.7867144, -7.94413, -9.02265 ...

Или мы можем использовать Boost. Многоточность для генерации 50 десятичных цифр корней.

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

std::cout.precision(std::numeric_limits<float_type>::digits10); // float_type has 50 decimal digits.
std::cout << std::showpoint << std::endl; // Show trailing zeros too.
unsigned int m = 1U;
float_type r = boost::math::airy_ai_zero<float_type>(1U); // 1st root.
std::cout << "boost::math::airy_bi_zero<float_type>(" << m << ")  = " << r << std::endl;
m = 2;
r = boost::math::airy_ai_zero<float_type>(2U); // 2nd root.
std::cout << "boost::math::airy_bi_zero<float_type>(" << m << ")  = " << r << std::endl;
m = 7U;
r = boost::math::airy_bi_zero<float_type>(7U); // 7th root.
std::cout << "boost::math::airy_bi_zero<float_type>(" << m << ")  = " << r << std::endl;
std::vector<float_type> zeros;
boost::math::airy_ai_zero<float_type>(1U, 3, std::back_inserter(zeros));
std::cout << "airy_ai_zeros:" << std::endl;
// Print the roots to the output stream.
std::copy(zeros.begin(), zeros.end(),
          std::ostream_iterator<float_type>(std::cout, "\n"));

Производит выход программы:

boost::math::airy_ai_zero<double>(1) = -2.33811
boost::math::airy_ai_zero<double>(2) = -4.08795
boost::math::airy_bi_zero<double>(3) = -4.83074
airy_ai_zeros:
-2.33811
-4.08795
-5.52056
-6.78671
-7.94413
boost::math::airy_bi_zero<float_type>(1)  = -2.3381074104597670384891972524467354406385401456711
boost::math::airy_bi_zero<float_type>(2)  = -4.0879494441309706166369887014573910602247646991085
boost::math::airy_bi_zero<float_type>(7)  = -9.5381943793462388866329885451560196208390720763825
airy_ai_zeros:
-2.3381074104597670384891972524467354406385401456711
-4.0879494441309706166369887014573910602247646991085
-5.5205598280955510591298555129312935737972142806175

Полный код (и выход) для этого примера находится по адресу airy_zeros_example.cpp,

Implementation

С учетом следующей функции (A&S 10.4.105):

Тогда начальная оценка для n^th ноль a_n Ai приведена (A&S 10.4.94):

и начальная оценка для n^th ноль b_n Би приведена (A&S 10.4.98):

После этого корни очищаются с помощью итерации Ньютона.

Testing

Точность оценки нулей была протестирована на 50 десятичных цифрах с использованием cpp_dec_float_50 и найдена идентичной с точечными значениями, вычисленными Wolfram Alpha.