numeric::quadrature

Численное интегрирование (Квадратура)

Блокноты MuPAD® будут демонтированы в будущем релизе. Используйте live скрипты MATLAB® вместо этого.

Live скрипты MATLAB поддерживают большую часть функциональности MuPAD, хотя существуют некоторые различия. Для получения дополнительной информации смотрите, Преобразуют Notebook MuPAD в Live скрипты MATLAB.

Синтаксис

numeric::quadrature(f(x), x = a .. b, <GaussLegendre = n | GaussTschebyscheff = n | NewtonCotes = n>, <Adaptive = v>, <MaxCalls = m>)

Описание

numeric::quadrature(f(x), x = a..b) вычисляет числовое приближение.

numeric::quadrature возвращает себя символически если подынтегральное выражение f(x) содержит символьные объекты кроме переменной интегрирования x это не может быть преобразовано в численные значения через float. И т.д. приняты символьные объекты, такие как π или.

Подынтегральное выражение f(x) должно быть интегрируемым в Римановом смысле. В частности, f(x) должен быть ограничен на интервале интегрирования x = a..b. Определенные типы умеренной сингулярности обработаны, но числовая сходимость не гарантируется и будет медленной в большинстве случаев. Также разрывы и сингулярность (более высоких) производных f(x) замедлите числовую сходимость. Для подынтегральных выражений с точками неоднородности рекомендуется разделить интегрирование в несколько частей, с помощью подынтервалов, на которых является гладким подынтегральное выражение. См. Пример 4.

Могут быть обработаны подынтегральные выражения, данные пользовательскими процедурами. Смотрите Пример 4 и Пример 5.

numeric::quadrature возвращает себя символически если контуры a,b содержите символьные объекты, которые не могут быть преобразованы в численные значения через float. Символьные объекты, такие как π или и т.д. а также infinity и -infinity приняты.

Примечание

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

Контуры a> b приняты, с помощью.

Для комплексных чисел a,b, интегрирование должно быть изучено как криволинейный интеграл вдоль прямой линии от a к b. Комплексные контуры не должны включать infinity.

Многомерное интегрирование такой как

numeric::quadrature ( numeric::quadrature(f(x,y), y = A(x)..B(x)), x = a..b)

возможно. Смотрите Пример 3 и Пример 5.

Внутренне, адаптивный механизм на основе фиксированного квадратурного правила задан method = n используется. Это пытается сохранить относительную квадратурную ошибку результата ниже. Последняя цифра (цифры) результата может быть неправильной должная округлить эффекты.

Стандартный numeric::quadrature является чисто числовым: никакая символьная проверка на сингулярность и т.д. не выполняется.

Взаимодействия среды

Функция чувствительна к переменной окружения DIGITS, который определяет числовую рабочую точность.

Примеры

Пример 1

Мы демонстрируем стандартные призывы к адаптивному численному интегрированию:

numeric::quadrature(exp(x^2), x = -1..1)

numeric::quadrature(max(1/10, cos(PI*x)), x = -2..0.0123)

numeric::quadrature(exp(-x^2), x = -2..infinity)

Цель точности устанавливается DIGITS:

DIGITS := 50:
numeric::quadrature(besselJ(0, x), x = 0..PI)

Обратите внимание на то, что из-за внутреннего адаптивного механизма, выбор различных методов не должен оказывать значительное влияние на квадратурный результат:

DIGITS := 10:
numeric::quadrature(sin(x)/x, x = -1..10, GaussLegendre = 5),
numeric::quadrature(sin(x)/x, x = -1..10, GaussLegendre = 160),
numeric::quadrature(sin(x)/x, x = -1..10, NewtonCotes = 8)

Пример 2

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

numeric::quadrature(sin(x)/x, x = 0..1, NewtonCotes = 8)
Error: Division by zero. [_power]
  Evaluating: Quadsum

Можно исправить эту проблему присвоить значение f(0). Подынтегральное выражение передается интегратору как hold(f) предотвратить преждевременную оценку f(x) к sin(x)/x. Внутренне, numeric::quadrature замены x численными значениями и затем оценивает подынтегральное выражение. Обратите внимание на то, что нужно задать f(0.0) := 1 вместо f(0) := 1:

f := x -> sin(x)/x:
f(0.0) := 1:
numeric::quadrature(hold(f)(x), x = 0..1, NewtonCotes = 8)

Метод по умолчанию (Квадратура Гаусса - Лежандра) не оценивает подынтегральное выражение в конечных точках:

numeric::quadrature(sin(x)/x, x = 0..1)

Тем не менее, проблемы могут все еще возникнуть для несобственных интегралов:

numeric::quadrature(ln((1 + x^4)^2 - 1), x = 0 .. 1)
Warning: Precision goal not achieved after 10000 function calls. Increase 'MaxCalls' and try again for a more accurate result. [numeric::quadrature]

В этом примере подынтегральное выражение оценено близко к 0. Выражение (1 + x 4) 2 - 1 страдает от серьезной числовой отмены и во власти округления. Численно устойчивое представление (1 + x 4) 2 - 1 = x 4   (x 4 + 2):

numeric::quadrature(ln(x^4*(x^4 + 2)), x = 0..1)

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

delete f:

Пример 3

Мы демонстрируем многомерную квадратуру:

Q := numeric::quadrature:
Q(Q(exp(x*y), x = 0..y), y = 0..1)

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

b := y -> Q(exp(-t^2-t*y), t = y..infinity):

и

f := y -> cos(y^2) +  Q(exp(x*y), x = 0..b(y)):

для следующей квадратуры:

Q(f(y), y = 0..1)

Много размерная квадратура является в вычислительном отношении дорогой. Обратите внимание на то, что вызов numeric::quadrature оценивает подынтегральное выражение, по крайней мере, 3 n времена, где n является количеством узлов внутреннего квадратурного правила (по умолчанию, n = 20 для DIGITS ≤ 10). Следующая тройная квадратура вызвала бы функцию exp (не менее чем 3 20) 3 = 216000 раз!

Q(Q(Q(exp(x*y*z), x = 0..y+z), y = 0..z), z = 0..1)

Для низких целей точности достаточны квадратурные правила низкоуровневые. В следующем мы уменьшаем вычислительные затраты при помощи квадратуры Гаусса - Лежандра с 5 узлами. Мы используем краткое обозначение GL задавать GaussLegendre метод:

DIGITS := 4: 
Q(Q(Q(exp(x*y*z), x=0..y+z, GL=5), y=0..z, GL=5), z=0..1, GL=5)

delete Q, b, f, DIGITS:

Пример 4

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

f := proc(x) begin 
      if x<1 then sin(x^2) else cos(x^5) end_if
    end_proc:

не может быть вызван символьным аргументом:

f(x)
Error: Unable to evaluate to Boolean. [_less]
  Evaluating: f

Следовательно, нужно использовать hold предотвратить преждевременную оценку f(x):

numeric::quadrature(hold(f)(x), x = -1..PI/2)

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

numeric::quadrature(sin(x^2), x = -1..1) +
numeric::quadrature(cos(x^5), x = 1..PI/2)

Смотрите Пример 5 для многомерной квадратуры пользовательских процедур.

delete f:

Пример 5

Следующее подынтегральное выражение

f := proc(x, y) begin 
       if x<y then x-y else (x-y) + (x-y)^5 end_if
     end_proc:

может только быть вызван числовыми аргументами и должен быть задержан дважды для 2-мерной квадратуры:

Q := numeric::quadrature:
Q(Q(hold(hold(f))(x, y), x = 0..1), y = 0..1)

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

f := proc(x, y, z)
     begin
       if not testtype([args()], Type::ListOf(Type::Numeric))
          then return(procname(args()))
       end_if;
       if x^2 + y^2 + z^2 <= 1 
          then return(1) 
          else return(0) 
       end_if
     end_proc:

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

DIGITS := 2: 
Q(Q(Q(f(x, y, z), x=0..1, GL=5), y=0..1, GL=5), z=0..1, GL=5)

delete f, Q, DIGITS:

Пример 6

Следующий пример использует неадаптивную квадратуру Гаусса-Tschebyscheff с растущим числом узлов. Результаты сходятся быстро к точному значению:

a := exp(x)/sqrt(1 - x^2), x = -1..1:
numeric::quadrature(a, Adaptive = FALSE, GT = n) $ n = 3..7

delete a:

Пример 7

Несобственный интеграл существует. Числовая сходимость, однако, является довольно медленной из-за сингулярности в x = 0:

numeric::quadrature(x^(-9/10), x = 0..1)
Warning: Precision goal not achieved after 10000 function calls. Increase 'MaxCalls' and try again for a more accurate result. [numeric::quadrature]

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

numeric::quadrature(x^(-9/10), x = 0..1, MaxCalls = infinity)

Пример 8

Следующий интеграл не существует в Римановом смысле, потому что подынтегральное выражение не ограничено:

numeric::quadrature(1/x, x = -1..2)
Warning: Precision goal not achieved after 10000 function calls. Increase 'MaxCalls' and try again for a more accurate result. [numeric::quadrature]

Мы увеличиваем MaxCalls. Нет никакой сходимости числового алгоритма, потому что интеграл не существует. Следовательно, некоторая внутренняя проблема должна возникнуть: numeric::quadrature достигает его максимальной рекурсивной глубины:

numeric::quadrature(1/x, x = -1..2, MaxCalls = infinity)
Warning: Precision goal not achieved after 'MAXDEPTH=500' recursive calls. There might be a singularity of '1/x' close to 'x=3.910318545e-148'. Increase 'MAXDEPTH' and try again for a more accurate result. [adaptiveQuad]

Параметры

f(x)

Арифметическое выражение в x

x

Идентификатор или индексируемый идентификатор

aB

Действительные или комплексные численные значения или

Опции

GaussLegendre, GaussTschebyscheff, NewtonCotes

Опции, заданные как GaussLegendre = n, GaussTschebyscheff = n, NewtonCotes = n

Имя базовой квадратурной схемы. Каждое квадратурное правило может быть использовано с произвольным числом узлов, заданных положительным целочисленным n.

Обычно нет никакой потребности использовать эту опцию, чтобы изменить метод по умолчанию GaussLegendre = n с n = 20,40,80 или 160, В зависимости от цели точности, определенной переменной окружения DIGITS. Из-за соответствующих высоких квадратурных порядков 40, 80, 160 или 320, соответственно, настройки по умолчанию подходят для расчетов высокой точности.

С GaussLegendre = n, используется адаптивная версия квадратуры Гаусса - Лежандра с узлами n.

Для DIGITS ≤ 200, веса и абсциссы Гауссовой квадратуры с n = 20, 40, 80, и 160 узлов доступны, и интегрирование сразу запускается.

Для DIGITS> 200, стандартный numeric::gldata называется, чтобы вычислить Гауссовы данные, прежде чем фактическое интегрирование запустится. Это будет отмечено некоторой задержкой первого вызова numeric::quadrature.

Для DIGITS намного больше, чем 200, рекомендуется не использовать настройку по умолчанию, но использовать GaussLegendre = n с достаточно высоким n вместо этого. Разумным выбором является nDIGITS.

С GaussTschebyscheff = n, неадаптивная квадратура Гаусса-Tschebyscheff с узлами n используется. Этот метод может только использоваться в сочетании с Adaptive = FALSE.

Примечание

С NewtonCotes = n, используется адаптивная версия квадратуры Коутса Ньютона с узлами n. Обратите внимание на то, что эти квадратурные правила становятся численно неустойчивыми для большого n (n, намного больше, чем 10).

После альтернативных имен для методов приняты:

GaussLegendre, Gauss, GL,

GaussTschebyscheff&gt, GaussChebyshev, GC,

NewtonCotes, NC.

Adaptive

Опция, заданная как Adaptive = v

v может быть TRUE или FALSE. С Adaptive = FALSE, внутренний контроль ошибок выключен.

Настройкой по умолчанию является Adaptive = TRUE. Используется адаптивная квадратурная схема с автоматическим управлением квадратурной ошибки.

Вызов numeric::quadrature(f(x), x = a..b, method = n, Adaptive = FALSE) возвращает квадратурную аппроксимацию суммы без любого управления квадратурной ошибки. Веса B i и абсциссы C i определяются квадратурным правилом, данным method = n. Для методов GaussLegendre, GaussTschebyscheff и NewtonCotes, эти данные доступны через numeric::gldata, numeric::gtdata и numeric::ncdata, соответственно.

Adaptive = FALSE май только использоваться в сочетании с method = n.

Обычно нет никакой потребности выключить внутреннюю адаптивную квадратуру через Adaptive = FALSE. Эта опция предназначается, чтобы предоставить быстрый доступ к стандартным неадаптивным квадратурным правилам Гаусса - Лежандра, Гаусса-Tschebyscheff и типа Коутса Ньютона, соответственно. Пользователь может хотеть создать свою собственную адаптивную квадратуру на основе этих неадаптивных правил. См. Пример 6.

MaxCalls

Опция, заданная как MaxCalls = m

m должно быть (большое) положительное целое число или infinity. Это - максимальное количество оценок подынтегрального выражения перед numeric::quadrature сдается.

Когда названо в интерактивном режиме, numeric::quadrature возвращает приближение, которое это вычислило до сих пор и выдает предупреждение. Смотрите Пример 7. Когда названо из процедуры, numeric::quadrature возвращает FAIL.

Значением по умолчанию является m = MAXDEPTH*n. Переменная окружения MAXDEPTH (значение по умолчанию 500), представляет максимальную рекурсивную глубину функции. n количество узлов основного квадратурного правила, заданного дополнительным аргументом method = n. Если никакой такой метод не задан пользователем, то квадратура Гаусса - Лежандра используется с n = 20 для DIGITS ≤ 10, n = 40 для 10 <DIGITS ≤ 50, n = 80 для 50 <DIGITS ≤ 100, n = 160 для 100 <DIGITS. Таким образом, для DIGITS = 10, настройкой по умолчанию является MaxCalls = 10000.

Значение по умолчанию m гарантирует что MaxCalls предел достигнут перед numeric::quadrature достигает его максимальной внутренней рекурсивной глубины. Определение MaxCalls = infinity удаляет это ограничение и numeric::quadrature вычисляет, пока это не получает приближение приблизительно с DIGITS правильные цифры или пока это не сталкивается с внутренней ошибкой. Типичная ошибка, которая может произойти, является оценкой подынтегрального выражения в сингулярности. Также существует опасность numeric::quadrature достижение его максимальной внутренней рекурсивной глубины. Когда названо в интерактивном режиме, numeric::quadrature возвращает приближение, которое это вычислило до сих пор и выдает предупреждение. Смотрите Пример 8. Когда названо из процедуры, numeric::quadrature возвращает FAIL.

Возвращаемые значения

Число с плавающей точкой возвращено, если нечисловые символьные объекты в подынтегральном выражении f(x) или в контурах a,b предотвратите численную оценку. В этом случае, numeric::quadrature возвращает себя символически. Если числовые проблемы происходят, то FAIL возвращен.

Смотрите также

Функции MuPAD

Для просмотра документации необходимо авторизоваться на сайте