float
Преобразуйте в число с плавающей запятой
Блокноты MuPAD® будут демонтированы в будущем релизе. Используйте live скрипты MATLAB® вместо этого.
Live скрипты MATLAB поддерживают большую часть функциональности MuPAD, хотя существуют некоторые различия. Для получения дополнительной информации смотрите, Преобразовывают Notebook MuPAD в Live скрипты MATLAB.
float(object
) float(object
,n
)
float(object)
преобразовывает объектные или числовые подвыражения объекта к числам с плавающей запятой.
float
преобразовывает числа и числовые выражения, такие как sqrt(sin(2))
или sqrt(3) + sin(PI/17)*I
к действительным или комплексным числам с плавающей запятой типа DOM_FLOAT
или DOM_COMPLEX
, соответственно. Если символьные объекты кроме специальных констант, CATALAN, E, ЭЙЛЕР и PI существуют, только числовые подвыражения, преобразованы в плавания. В частности, идентификаторы и индексированные идентификаторы возвращены неизменные float
. Cf. Пример 1.
Вызов float
сопоставлен рекурсивно с операндами выражения. Когда числа (или константы, такие как PI) найдены, они преобразованы в приближения с плавающей точкой. Количество значительных десятичных цифр дано переменной окружения DIGITS
; значение по умолчанию равняется 10. Конвертированные операнды объединены арифметическими операциями или вызовами функции согласно структуре выражения. Например, вызов, такой как float(PI - 314/100)
может рассматриваться как последовательность числовых операций:
t1 := float(PI); t2 := float(314/100); result := t1 - t2
float
может подвергнуться передаче ошибок. Cf. Пример 2.Второй аргумент n
в float(object, n)
временно перезаписывает текущую установку для DIGITS
. Смотрите Пример 3.
float
автоматически сопоставлен с элементами наборов и списков. Однако это автоматически не сопоставлено с записями массивов, hfarrays, таблиц и операндов вызовов функции. Используйте map(object, float)
для быстрого преобразования с плавающей точкой всех записей массива или таблицы. Используйте mapcoeffs(p, float)
, чтобы преобразовать коэффициенты полиномиального p
типа DOM_POLY
. Чтобы управлять поведением float
на вызове функции, используйте функциональную среду, обеспечивающую слот "float"
. Cf. Пример 4 и Пример 5.
Настройки Pref::floatFormat
и Pref::trailingZeroes
могут использоваться, чтобы изменить экран вывод чисел с плавающей запятой.
Рациональные приближения чисел с плавающей запятой могут быть вычислены функциональным numeric::rationalize
.
MuPAD® специальные функции, такие как sin
, exp
, besselJ
и т.д. реализован как функциональные среды. Через перегрузку атрибут "float"
(слот) функциональной среды f
, скажем, называется для оценки плавающей символьных вызовов f(x1, x2, ...)
, содержавшимся в выражении.
Пользователь может расширить функциональность системной функции float
к его собственным функциям. Для этого функциональный f
, который будет обработан, должен быть объявлен как функциональная среда через funcenv
. Атрибут "float"
должен быть записан, который вызван системной функцией float
в форме f::float(x1, x2, ...)
каждый раз, когда символьный вызов f(x1, x2, ...)
в выражении найден. Аргументы, переданные f::float
, не преобразованы в плавания, ни один не возвращаемое значение слота, подвергающегося дальнейшей оценке плавающей. Таким образом преобразование плавающее символьных вызовов функций f
полностью определяется стандартной программой слота. Cf. Пример 5.
Также доменный d
, скажем, написанный в языке MuPAD, может перегрузить float
, чтобы задать оценку плавающую его элементов. Слот d::float
должен быть реализован. Если элемент, x
, скажем, этой области подвергается оценке плавающей, слот, называется в форме d::float(x)
. Что касается функциональных сред, ни x
, ни возвращаемое значение слота не подвергаются дальнейшей оценке плавающей.
Если область не имеет слота "float"
, системная функция, float
возвращает свои неизменные элементы.
Обратите внимание на то, что числа с плавающей запятой MuPAD ограничиваются в размере. На архитектуре на 32 бита происходит переполнение/потеря значимости, если с количествами абсолютного размера, большего/меньшего, чем о, сталкиваются. На архитектуре на 64 бита пределы о.
См. документацию для DIGITS
для получения дополнительной информации.
Функция чувствительна к переменной окружения DIGITS
, который определяет числовую рабочую точность.
Мы преобразовываем некоторые числа и числовые выражения к плаваниям:
float(17), float(PI/7 + I/4), float(4^(1/3) + sin(7))
float
чувствителен к DIGITS
:
DIGITS := 20: float(17), float(PI/7 + I/4), float(4^(1/3) + sin(7))
Символьные объекты, такие как идентификаторы возвращены неизменные:
DIGITS := 10: float(2*x + sin(3))
Мы иллюстрируем передачу ошибок в численных расчетах. Следующее рациональное число аппроксимирует exp(2)
к 17 десятичным цифрам:
r := 738905609893065023/100000000000000000:
Следующий вызов float
преобразовывает exp(2)
и r
к приближениям с плавающей точкой. Ошибки приближения распространяют и усилены в следующем числовом выражении:
DIGITS := 10: float(10^20*(r - exp(2)))
Ни одна из цифр в этом результате не правильна! Чтобы получить лучший результат, используйте второй аргумент в float
, чтобы увеличить число цифр для этого конкретного вызова функции:
float(10^20*(r - exp(2)), 20)
Для дальнейших вычислений освободите переменную r
:
delete r:
Второй аргумент в float
позволяет вам временно перезаписать текущую установку для количества значительных десятичных цифр. Например, вычислите следующее выражение с 10 и 30 значительными десятичными цифрами. Чтобы отобразить числа с плавающей запятой с количеством цифр, что MuPAD раньше вычислял их, установите значение Pref::outputDigits
к InternalPrecision
:
Pref::outputDigits(InternalPrecision):
Вычислите следующее выражение со значением по умолчанию DIGITS = 10
:
x := 10^8: float(sqrt(x^2 + 1) - x)
Вычислите то же выражение с 30 значительными десятичными цифрами:
float(sqrt(x^2 + 1) - x, 30)
После оценки float
MuPAD восстанавливает значение DIGITS
:
DIGITS
Для дальнейших вычислений восстановите выходную точность и освободите переменную x
:
Pref::outputDigits(UseDigits): delete x
float
сопоставлен с элементами наборов и списков:
float([PI, 1/7, [1/4, 2], {sin(1), 7/2}])
Для таблиц и массивов, функциональный map
должен использоваться, чтобы передать float
записям:
T := table("a" = 4/3, 3 = PI): float(T), map(T, float)
A := array(1..2, [1/7, PI]): float(A), map(A, float)
Матричные области перегружают функциональный float
. В отличие от массивов, float
работает непосредственно над матрицей:
float(matrix(A))
Используйте mapcoeffs
, чтобы применить float
к коэффициентам полинома, сгенерированного poly
:
p := poly(9/4*x^2 + PI, [x]): float(p), mapcoeffs(p, float)
delete A, T, p:
Мы демонстрируем перегрузку float
функциональной средой. Следующий функциональный Sin
должен представлять синусоидальную функцию. В отличие от функции sin
в MuPAD, Sin
измеряет свой аргумент в градусах, а не в радианах (т.е. Sin(x)
= sin(PI/180*x)
). Единственная функциональность Sin
должна произвести значения с плавающей точкой, если аргумент является действительным плаванием. Для всех других видов аргументов состоит в том, чтобы быть возвращен символьный вызов функции:
Sin := proc(x) begin if domtype(x) = DOM_FLOAT then return(Sin::float(x)); else return(procname(args())) end_if; end_proc:
Функция превращена в функциональную среду через funcenv
:
Sin := funcenv(Sin):
Наконец, атрибут "float"
реализован. Если аргумент может быть преобразован в действительное число с плавающей запятой, к результату с плавающей точкой приводят. Во всех других случаях отвечают на символьный звонок Sin
:
Sin::float := proc(x) begin x := float(x): if domtype(x) = DOM_FLOAT then return(float(sin(PI/180*x))); else return(Sin(x)) end_if; end_proc:
Теперь, оценка плавающая произвольных выражений, включающих Sin
, возможна:
Sin(x), Sin(x + 0.3), Sin(120)
Sin(120.0), float(Sin(120)), float(Sin(x + 120))
float(sqrt(2) + Sin(120 + sqrt(3)))
delete Sin:
|
Любой объект MuPAD |
|
Целое число, больше, чем 1 |
Число с плавающей точкой типа DOM_FLOAT
или DOM_COMPLEX
или входной объект с точными числами, замененными числами с плавающей запятой.
object