» Mathematica (математика)

popkov

Цитата:

In[19]:=
1.00000000000000003`18 == 1
1.00000000000000003`18 - 1 == 0
0.00000000000000003`18 == 0

Out[19]= True

Out[20]= False

Out[21]= False

Может кто-нибудь это объяснить?

Это поведение чётко документировано:

Цитата:

Approximate numbers with machine precision or higher are considered equal if they differ in at most their last seven binary digits (roughly their last two decimal digits).

For numbers below machine precision the required tolerance is reduced in proportion to the precision of the numbers.

В случае

Код:
In[1]:= 1.00000000000000003`18 == 1

Out[1]= True

r_green
Проблема в том, что Precision в нуля не определен. У него там деление на ноль получается.

Цитата:

Precision is not defined at zero, so use Accuracy as a goal.

2All
[more]
Цитата:

Table evaluates its arguments in a nonstandard way.

Код:
In[]:= Table[1.00000000000000003`n==1,{n,1,23}]
Out[]= {True,False,False,False,False,False,False,False,
False,False,False,False,False,False,False,False,False,
False,False,False,False,False,False}

In[]:= 1.00000000000000003`17==1
Out[]= True

In[]:= 1.00000000000000003`18==1
Out[]= True

In[]:= 1.00000000000000003`19==1
Out[]= False

karl_karlsson,
«Table evaluates its arguments in a nonstandard way.» А вы нигде не встречали, что это за «nonstandard way» (для сравнения чисел)? Как я понимаю, сам код Table в бинарном mx, поэтому не посмотреть.

karl_karlsson

Цитата:

Table evaluates its arguments in a nonstandard way.

Дело в том, что представление действительного числа (x.y`p``a) не является структурным выражением. Т.е. нельзя в качестве элементов этого представления (в частности, precision) использовать вычислимые объекты (переменные), а также использовать эти элементы для pattern matching.
Так, запись a.b есть не действительное число с целой частью а и дробной b, а Dot[a,b] (т.е. скалярное произведение).
Также, запись 1.00000000000000003`n интерпретируется, как
1.00000000000000003` * n или 1.00000000000000003`$MachinePrecision * n.
Из-за этого Table[] и даёт такой результат в Вашем примере.

Для получения ожидаемого результата нужно так:
Table[SetPrecision[1.00000000000000003, n] == 1, {n, 1, 23}]

2 All,
А можно ли тогда реализовать функцию, сравнивающую 2 числа так, что если точность(?) одного меньше, то она повышается?

Пример:

In[5]:= CompareWithA[a_, b_] := {a > b, a == b};
CompareWithA[1.000000000000000036, 1.]
Out[6]= {False, True}

In[9]:= SetPrecision[1.000000000000000036, 19] > SetPrecision[1., 19]
SetPrecision[1.000000000000000036, 19] == SetPrecision[1., 19]
Out[9]= True
Out[10]= False

Но

In[13]:= CompareWithA2[a_, b_] := Module[{}, SetPrecision[a, 19]; SetPrecision[b, 19];
{a > b, a == b}];
CompareWithA2[1.000000000000000036, 1.]
Out[14]= {False, True}

Добавлено:
Можно
In[13]:= CompareWithA3[a_, b_] := Module[{},
{SetPrecision[a, Precision[a] + 1] > SetPrecision[b, Precision[a] + 1],
SetPrecision[a, Precision[a] + 1] == SetPrecision[b, Precision[a] + 1]}];
CompareWithA3[1.000000000000000036, 1.]
Out[14]= {True, False}

TomasVercetti

Цитата:

А можно ли тогда реализовать функцию, сравнивающую 2 числа так, что если точность(?) одного меньше, то она повышается?

Код: MyEqual[a_, b_] :=
Module[{p = Max[Precision[a], Precision[b]]},
SetPrecision[a, p] == SetPrecision[b, p]]

r_green,
Спасибо! То, что нужно! Код в копилку

TomasVercetti
Я ошибся - для полной гарантии, что хвостик вылезет в значащий диапазон для Equal[], нужно прибавлять к precision не 1, а хотя бы Log10[2^8] (~2.5).
Т.е.:

Код: MyEqual[a_, b_] := SetPrecision[a, Precision[a] + 3] == SetPrecision[b, Precision[b] + 3]

r_green,
Как я понимаю, 8 — количество двоичных цифр, но в хелпе по equal сказано "differ in at most their last seven binary digits". «+1» — это для запаса или более глубокий смысл? Спасибо.

TomasVercetti
Для запаса.
Чтобы компенсировать возможную потерю точности при вычислении precision - ф-ция Precision[] возвращает результат с машинной точностью (MachinePrecision).
При желании можно рассчитать добавку более точно. Но, с другой стороны, это сделает ф-цию сравнения более медленной.

Добавлено:
Вот так, наверно, будет минимально необходимая добавка:

Код: MyEqual[a_, b_] := SetPrecision[a, SetPrecision[Precision[a], Infinity] + Log10[2^8 - 1]] == SetPrecision[b, SetPrecision[Precision[b], Infinity] + Log10[2^8 - 1]]

popkov
Простите за долгое отсутствие. Это не потому, что вопрос для меня неинтересен.

Цитата:

"principal root" (термин, отчетливого определения которого я так и не нашел

Возможно, я что-то не понял, но мне кажется, что тут просто недоразумение. "principal root" - это не понятие, введенное в Mathematica, а чисто математическое понятие. Мы же не требуем от Mathematica, чтобы они дали определение синуса.

Цитата:

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

Конечно, они это не предполагали. Они предполагали другое, а именно, что функции используемые в Mathematica, где это возможно, определены в пространстве комплексных чисел.

Alex_B

Цитата:

"principal root" - это не понятие, введенное в Mathematica, а чисто математическое понятие.

Это я понимаю, просто найти его четкое определение мне не удалось. Кроме того, везде подчеркивается неоднозначность определения этого термина в некоторых случаях.

Цитата:

Они предполагали другое, а именно, что функции используемые в Mathematica, где это возможно, определены в пространстве комплексных чисел.

Я это писал к тому, что в Mathematica фактически отсутствует спецификация ко всем встроенным функциям. "Предполагать", что пользователь догадается, - не спецификация! К тому же они дали хоть какое-то объяснение для комплексных чисел, а про отрицательные забыли. И впоследствии не стали шасширять объяснение, так и оставив его недоделанным. Хотя недопонимание пользователями работы функции Power имеет многолетнюю историю.

r_green

Цитата:

Вот так, наверно, будет минимально необходимая добавка:
[no]MyEqual[a_, b_] := SetPrecision[a, SetPrecision[Precision[a], Infinity] + Log10[2^8 - 1]] == SetPrecision[b, SetPrecision[Precision, Infinity] + Log10[2^8 - 1]] [/no]

Недавно был предложен простой вариант беспроблемного Clip между -1 и 1. Вот сопоставление работы его и стандартного Clip[#,{-1,1}]&:

[b][no]list = {"1.00000000000000036", "1.000000000000000360000",
"0.9999999999999966", "0.9999999999999966000"};
Clip1[x_] := Sign[x]*Min[Abs[x], 1];
TableForm[
InputForm /@ {#, v = ToExpression[#], Clip[v, {-1, 1}], Clip1[v]} & /@
list, TableHeadings -> {None, {"Input", "InputForm", "Clip",
"Clip1"}}][/no]

Input InputForm Clip Clip1

popkov

Цитата:

Недавно был предложен простой вариант беспроблемного Clip между 0 и 1.

По-моему, этот вариант не очень хорошо масштабируется на произвольный интервал.

Вот беcпроблемный(вроде бы) вариант, полностью повторяющий интерфейс стандартного Clip:

Код: Clip2[args__] := Module[{p = SetPrecision[Precision[{args}], Infinity]}, SetPrecision[Clip @@ SetPrecision[{args}, p + Log10[2^8 - 1]], p]]

r_green

Цитата:

Вот беcпроблемный(вроде бы) вариант, полностью повторяющий интерфейс стандартного Clip:
[no]Clip2[args__] := Module[{p = SetPrecision[Precision[{args}], Infinity]}, SetPrecision[Clip @@ SetPrecision[{args}, p + Log10[2^8 - 1]], p]] [/no]

Этот вариант не совсем корректно работает в ситуациях, когда границы являются целыми числами:

In[6]:= Clip2[1.00000000000000036] // InputForm

Out[6]//InputForm=
1.`17.

Хотя должно быть просто 1:

In[7]:= Clip1[1.00000000000000036] // InputForm

Out[7]//InputForm=
1

Добавлено:
Кстати, недавно сформулированный глюк функции [no]Sort[[/no]list,p[no]][/no]:

Если ordering function p не возвращает ни True, ни False или остается невыполненной, она рассматривается как вернувшая True. В результате Sort возвращает первоначальный список, вместо того чтобы остаться невыполненным:

In[1]:= Sort[{a, c, d}, True &]
Sort[{a, c, d}, UndefinedFunction &]
Sort[{a, c, d}, Greater]

Out[1]= {a, c, d}

Out[2]= {a, c, d}

Out[3]= {a, c, d}

popkov

Цитата:

найти его четкое определение мне не удалось. Кроме того, везде подчеркивается неоднозначность определения этого термина

Прежде всего это определение нужно искать в учебниках. Например, в книге "Лекции по теории функций комплексного переменного" Сидорова, Федорюка, Шабунина в параграфе 24 определяется понятие регулярной ветви аналитической функции. Principal root - это и есть одна из регулярных ветвей аналитической функции. Поскольку все регулярные ветви элементарных аналитических функций (тригонометрических, гипергеометрических, показательных и обратных к ним) определяются выбором функции Arg, то фактически выбор сводится к выбору из двух возможностей: 1) либо разрез проходит по положительной оси и тогда угол меняется от нуля до двух пи; 2) либо разрез проходит по отрицательной оси и угол меняется от минус пи до плюс пи. В Matematica принята вторая возможность.

Цитата:

в Mathematica фактически отсутствует спецификация ко всем встроенным функциям

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

Alex_B

Цитата:

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

В таком случае в грамотно продуманной документации на странице справки к Power вообще не должно быть информации о том, как она определена для комплексных аргументов - должна быть лишь ссылка на соответствующий раздел документации! А сейчас есть очень краткое и явно недостаточное объяснение для комплексных аргументов, а для отрицательных пользователь должен "догадаться" или же искать неизвестно где в документации (кстати, ткните, пожалуйста, где об этом сказано?).

popkov

Цитата:

Этот вариант не совсем корректно работает в ситуациях, когда границы являются целыми числами:

Да, Вы правы.
Тогда вот так, пожалуй:

Код: Clip2[x_, {min_, max_}] := Min[Max[x, min], max]

popkov

Цитата:

кстати, ткните, пожалуйста, где об этом сказано?

У меня сохранилось несколько цитат со времени, когда и изучал документацию Mathematica 6.

By default, Mathematica assumes that any variable or symbol that does not have an explicit value can take any complex value.

With careful attention to branch cuts, Mathematica supports trigonometric functions everywhere in the complex plane, with extensive exact and algebraic transformations, together with efficient arbitrary-precision numerical evaluation. Mathematica follows the standard mathematical convention of using radians for trigonometric function arguments.

Unique "principal" values nevertheless have to be chosen for the functions. The choices cannot be made continuous over the whole complex plane. Instead, lines of discontinuity, or branch cuts, must occur. The positions of these branch cuts are often quite arbitrary. Mathematica makes the most standard mathematical choices for them.

Alex_B

Цитата:

The positions of these branch cuts are often quite arbitrary. Mathematica makes the most standard mathematical choices for them.

Да уж... На спецификацию это явно не тянет...

Добавлено:
r_green

Цитата:

Тогда вот так, пожалуй:
Clip2[x_, {min_, max_}] := Min[Max[x, min], max]

Превосходно! Можно добавить случай единственного аргумента и атрибуты, чтобы синтаксис совпадал со встроенным Clip:
Clip1[x_] := Min[Max[x, -1], 1]
Clip1[x_, {min_, max_}] := Min[Max[x, min], max]
SetAttributes[Clip1, {Listable, NumericFunction}]

помогите пожалуйста преобразовать вектор:
{a>=x,b<y,c==z}

в набор условий вида:
a>=x&&b<y&&c==z

Вроде просто оператором And[] сделать но скобки "{" и "}" все услилия убивают на нет..
(пример упрощённый .. на самом деле количество элементов довольно большое)

никак не могу найти самую простую реализацию .. какие могут быть альтернативы ?
заранее спасибо..

vikkiv
And @@ {a >= x, b < y, c == z}

popkov

не каждому дано знать их интерфейс до такого root-командного уровня синтаксиса..

Огрумущее Спасибо !!!
Надо-же как просто, уже второй день голову ломал, в их помощи-документации как сформировать такой запрос так и непридумал ..

только по модели @@ получилось .. Действительно функция Apply[And,cond] (если cond={a>=x,b<y,c==z}) выполняет задачу просто превосходно..

2All
Блин, что они сделали с Mathematica при переходе от версии 5.2 к 7.01?
Один и тот же код в:

1) Mathematica 5.2:
[no]In[2]:=
$MinPrecision=$MaxPrecision=32;
1-0.00000000000000000000000000000001`32//RealDigits

Out[3]=
{{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},1}

In[1]:=
Block[{$MinPrecision=32,$MaxPrecision=32},
1-0.0000000000000000000000000000001`32]//RealDigits

Out[1]=
{{9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9},0}[/no]


2) Mathematica 7.01:
[no]In[1]:= $MinPrecision = $MaxPrecision = 32;
1 - 0.00000000000000000000000000000001`32 // RealDigits

Out[2]= {{9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}, 0}

In[3]:= Block[{$MinPrecision = 32, $MaxPrecision = 32},
1 - 0.0000000000000000000000000000001`32] // RealDigits

Out[3]= {{9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0}, 0}[/no]

Разница бросается в глаза. Так в чем же изменение, причина?

popkov

Цитата:

что они сделали с Mathematica при переходе от версии 5.2 к 7.01?

Насколько я понимаю - исправили баг.
В Вашем примере RealDigits для числа с точностью 32 выдаёт 31 цифру в 5-й Математике, и 32 цифры (как и положено) - в 7-й.

А вообще, на мой взгляд, такие краевые случаи нужно исследовать, рассматривая нативное двоичное (а не десятичное) представление числа.

Чтобы завершать работу MathKernel по комбинации Ctrl+Q (окно ноутбука должно быть активным), нужно добавить 1 строку в файл "KeyEventTranslations.tr".

Инструкция:
Открываете директорию
C:\Program Files\Wolfram Research\Mathematica
и ищите в ней этот файл с помощью "Поиска" Explorer'a. Найдется по одному файлу на каждую версию Mathematica.
Далее открываете нужный файл, и в нем сразу после строки

Код: [no]EventTranslations[{[/no]

Интересно:
[no]
In[1]:=[/no]
0 * "some string"

Out[1]=
0

Зачем это?! Почему бы не оставлять подобные выражения невыполненными?

Насколько я понимаю, во многих встроенных функциях есть проверка типа входного выражения, но она часто половинчатая и дырявая, как решето. В случае фундаментальных функций типа Times такой проверки вообще не делается?

In[2]:=
0*a

[no]Out[2]=
0[/no]

Все же, как ни крути, а подход разработчиков мне кажется странным. Если a=Infinity, то ответ будет другим:
In[3]:= a = Infinity;
0*a

During evaluation of In[2]:= \[Infinity]::indet: Indeterminate expression 0 \[Infinity] encountered. >>

[no]Out[4]= Indeterminate[/no]

popkov

Цитата:

Зачем это?! Почему бы не оставлять подобные выражения невыполненными?

Если исходить из математического определения Times[] как мультипликативной операции кольца, то естественно априори считать её аргументы элементами кольца. Из чего следует тождество 0 * a = 0.

Можно, конечно, абстрагироваться от математического смысла операции и считать Times не умножением, а более общей ф-цией. Но что это даст?

Так что, на мой взгляд, разработчики поступили обоснованно.

r_green

Цитата:

Если исходить из математического определения Times[]

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

---

Похоже, что проверка типа входных параметров для многих функций вообще не выполняется или же выполняется очень половинчато. Кроме того, Infinity, Indeterminate и Overflow[] очень криво и половинчато интегрированы в систему. Например, потеря знака при возникновении Overflow[]:

In[1]:= 10^80000 < Exp[1.5*^-323228465]

During evaluation of In[1]:= General::ovfl: Overflow occurred in computation. >>

Out[1]= True

popkov

Цитата:

В том-то и дело, что логика у нормального продукта должна быть единой, сквозной, а не набором "логик", каждая из которых применяется то там, то здесь. Через такую фрагментарную логику "обосновать" можно, что угодно.

Согласен, но не совсем понимаю, каким образом это касается обсуждаемого вопроса.
Всё, что я предложил - это рассматривать Times[] как модель математической операции умножения. Вряд ли это можно назвать отступлением от общей логики математического пакета вообще, а не только Mathematica...

r_green, popkov
Думаю, проблема возникает от того, что Mathematica объединяет компьютерная алгебра и численный пакет. Значит, имеются абсолютные алгебраические операции символьным переменным и те же операции, численных переменных. Но у численных переменных ни ноль ни бесконечность не единственные. Также существует неопределенный элемент - тот элемент, значение которого меньше значения вычислительной погрешности.
Численное точное преставление имеет такую особенность
1/3 = 0,3333333(3)
2/3 = 0,6666666(6)
3/3 = 0,9999999(9)
3/3 = 1,0000000(0)
целые числа можно представить двумя способами.
Если уже численным образом, то что то такое получается
0,9999999(random) уже одно и то же вне зависимости от того что имеется у random
1,0000000(random) совсем другое, также вне зависимости от того что имеется у random
А это уже множества, если надо их описывать точным алгебраическим образом.

Не знаю насколько правильно все описал, но идея вот такая - например, Times[] абсолютный алгебраический и Times[] численный, это разные операции. Один оперирует объектом, другой - его представлением у которого кроме абсолютных алгебраических явлении наблюдая свои численные явления.