DIGITSЗначительные цифры чисел с плавающей запятой
Блокноты MuPAD® будут демонтированы в будущем релизе. Используйте live скрипты MATLAB® вместо этого.
Live скрипты MATLAB поддерживают большую часть функциональности MuPAD, хотя существуют некоторые различия. Для получения дополнительной информации смотрите, Преобразовывают Notebook MuPAD в Live скрипты MATLAB.
Переменная окружения DIGITS определяет количество значительных десятичных цифр в числах с плавающей запятой. Значением по умолчанию является DIGITS = 10.
Возможные значения: положительное целое число, больше, чем 1 и меньший, чем 229 + 1.
Числа с плавающей точкой создаются путем применения функционального float к точным числам или числовым выражениям. Элементарные объекты аппроксимированы получившимися плаваниями с относительной точностью 10^(-DIGITS), т.е. первые десятичные цифры DIGITS правильны. Смотрите Пример 1.
В арифметических операциях с числами с плавающей запятой только учтены первые десятичные цифры DIGITS. Числовая ошибка распространяет и может вырасти в ходе вычислений. Смотрите Пример 2.
Если действительное число с плавающей запятой вводится непосредственно (например, x := 1.234), номер, по крайней мере, с DIGITS создаются, внутренние десятичные цифры.
Если действительное плавание вводится с больше, чем цифрами DIGITS, внутреннее представление хранит дополнительные цифры. Однако они не учтены в арифметических операциях, если DIGITS не увеличен соответственно. Смотрите Пример 3.
В частности, комплексные числа с плавающей запятой создаются путем добавления действительной и мнимой части. Это сложение обрезает дополнительные десятичные разряды в действительной и мнимой части.
Значение DIGITS может быть изменено в любое время во время вычисления. Если DIGITS уменьшен, только ведущие цифры существующих плавающих чисел учтены в следующих арифметических операциях. Если DIGITS увеличен, существующие числа с плавающей запятой внутренне дополнены запаздывающим двоичным файлом, обнуляет. Смотрите Пример 4.
В зависимости от DIGITS определенные функции, такие как тригонометрические функции могут дать неправильные результаты, если плавания в качестве аргументов слишком неточны. Смотрите Пример 5.
В зависимости от DIGITS только значительные цифры чисел с плавающей запятой отображены на экране. Настройки Pref::floatFormat и Pref::trailingZeroes могут использоваться, чтобы изменить экран вывод. Смотрите Пример 4.
По крайней мере одна цифра после десятичной точки отображена; если это незначительно, это заменяется нулем. Смотрите Пример 6.
Внутренне, числа с плавающей запятой создаются и хранятся некоторыми дополнительными “защитными цифрами”. Они также учтены основными арифметическими операциями.
Например, для DIGITS = 10, функциональный float преобразовывает точные числа в плавания еще с некоторыми десятичными цифрами. Количество защитных цифр зависит от DIGITS.
По крайней мере 2 внутренних защитных цифры доступны для любого значения DIGITS.
Переменные окружения, такие как DIGITS являются глобальными переменными. По возврату из процедуры, которая изменяет DIGITS, новое значение допустимо вне контекста процедуры также! Используйте save DIGITS, чтобы ограничить измененное значение DIGITS к процедуре. Смотрите Пример 8.
Значением по умолчанию DIGITS является 10; DIGITS имеет это значение после запуска или сброса системы через reset. Также команда delete DIGITS; восстанавливает значение по умолчанию.
Смотрите helppage float для получения дополнительной информации.
Мы преобразовываем некоторые точные числа и числовые выражения к приближениям с плавающей точкой:
DIGITS := 10: float(PI), float(1/7), float(sqrt(2) + exp(3)), float(exp(-20))
DIGITS := 20: float(PI), float(1/7), float(sqrt(2) + exp(3)), float(exp(-20))
delete DIGITS:
Мы иллюстрируем передачу ошибок в численных расчетах. Следующее рациональное число аппроксимирует exp(2) к 17 десятичным цифрам:
r := 738905609893065023/100000000000000000:
Следующий вызов float преобразовывает exp(2) и r к приближениям с плавающей точкой. Ошибки приближения распространяют и усилены в следующем числовом выражении:
DIGITS := 6: float(10^20*(r - exp(2)))
Ни одна из цифр в этом результате не правильна. Лучший результат получен путем увеличения DIGITS:
DIGITS := 20: float(10^20*(r - exp(2)))
delete r, DIGITS:
В следующем только 10 из вводимых 30 цифр рассматриваются как значительные. Дополнительные цифры хранятся внутренне, так или иначе:
DIGITS := 10: a := 1.23456789666666666666666666666; b := 1.23456789444444444444444444444
Мы увеличиваем DIGITS. Поскольку внутреннее представление a и b правильно к 30 десятичным разрядам, различие может быть вычислено правильно к 20 десятичным разрядам:
DIGITS := 30: a - b
delete a, b, DIGITS:
Мы вычисляем число с плавающей запятой с точностью 10 цифр. Внутренне, этот номер хранится с некоторыми защитными цифрами. Увеличивая DIGITS до 30, правильные защитные цифры становятся видимыми. С вызов Pref::trailingZeroes(TRUE), конечные нули десятичного представления становятся видимыми:
DIGITS := 10: a := float(1/9)
Pref::trailingZeroes(TRUE): DIGITS := 100: a
0.1111111111111111110147375846679551614215597510337829589843750000000000000000000000000000000000000000
Pref::trailingZeroes(FALSE): delete a, DIGITS:
Для оценки плавающей синусоидальной функции аргумент уменьшается до стандартного интервала [0, 2 π]. Для этого сокращения аргумент должен быть известен некоторым цифрам после десятичной точки. Для маленького DIGITS, цифры после десятичной точки чистое округление, если аргумент является большим числом с плавающей запятой:
DIGITS := 10: sin(float(2*10^30))
Увеличивая DIGITS до 50, аргумент синусоидальная функция имеет приблизительно 30 правильных цифр после десятичной точки. Первые 30 цифр следующего результата надежны:
DIGITS := 50: sin(float(2*10^30))
delete DIGITS:
По крайней мере одна цифра после десятичной точки всегда отображается. В следующем примере номер 39.9 отображен как 40,0 потому что “40”. не быть допустимым входом MuPAD®:
DIGITS := 2: float(10*PI), 39.9, -30.2
delete DIGITS:
Мы вычисляем float(10^40*8/9) с различными значениями DIGITS. Округление учитывает все защитные цифры, т.е. получившееся целое число делает все защитные цифры видимыми:
for DIGITS in [7, 8, 9, 17, 18, 19, 26, 27, 28] do
print("DIGITS" = DIGITS, round(float(10^40*8/9)))
end_for:
Следующая процедура позволяет вычислять числовые приближения с заданной точностью, не изменяя DIGITS как глобальную переменную. Внутренне, DIGITS установлен в желаемую точность, и приближение плавающее вычисляется. Из-за save DIGITS значение DIGITS не изменяется вне процедуры:
myfloat := proc(x, digits)
save DIGITS;
begin
DIGITS := digits:
float(x);
end_proc:Приближение плавающее следующего значения x страдает от числовой отмены. Процедура myloat используется, чтобы аппроксимировать x с 30 цифрами. Результат отображен только с 7 цифрами из-за значения DIGITS = 7 допустимых вне процедуры. Однако все отображенные цифры правильны:
x := PI^7 - exp(8013109200945801/1000000000000000): DIGITS := 7: float(x), myfloat(x, 30)
delete myfloat, x, DIGITS:
Если число с плавающей запятой, x был создан с высокой точностью и вычислением, должно продолжиться в более низкой точности, самым легким методом, чтобы избавиться от использующих память незначительных цифр является x := x + 0.0.