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.