Перейти из форума на сайт.

НовостиФайловые архивы
ПоискАктивные темыТоп лист
ПравилаКто в on-line?
Вход Забыли пароль? Первый раз на этом сайте? Регистрация
Компьютерный форум Ru.Board » Компьютеры » Программы » Wolfram Mathematica | Математика

Модерирует : gyra, Maz

 Версия для печати • ПодписатьсяДобавить в закладки
Страницы: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

Открыть новую тему     Написать ответ в эту тему

xy



ХУдератор
Редактировать | Профиль | Сообщение | Цитировать | Сообщить модератору
Wolfram Mathematica 14

Загрузка и поиск "лекарств"в "Варезнике"


 
Здесь обсуждаем вопросы языка Mathematica и программы, которая ИМХО лучше других выполняет свою задачу и, кроме, того очень точно соответствует своему названию, хотя там не забыли и про физиков и химиков и всех остальных:)

Всего записей: 10530 | Зарегистр. 28-05-2003 | Отправлено: 16:00 01-12-2003 | Исправлено: zAlAn711, 18:21 10-01-2024
r_green



Junior Member
Редактировать | Профиль | Сообщение | Цитировать | Сообщить модератору
popkov

Цитата:
такова стратегия развития корпорации. Большей части пользователей нужны "свистелки и перделки", они же и приносят доход

Хотя, IMHO, надо отдать им должное - "свистелки" прикручивают довольно аккуратно, без нарушения основных концепций продукта.  
Распыление ресурсов, видимо, сказывается...
Вообще, при достижении программым продуктом некоторого порога сложности необходимо радикально менять внутреннюю архитектуру, иначе управляемость падает, а сложность разработки начинает расти неадекватно... а радикальные шаги требуют серьёзных инвестиций...

Всего записей: 145 | Зарегистр. 17-09-2004 | Отправлено: 13:19 28-11-2010
popkov

Advanced Member
Редактировать | Профиль | Сообщение | ICQ | Цитировать | Сообщить модератору
r_green

Цитата:
Вообще, при достижении программым продуктом некоторого порога сложности необходимо радикально менять внутреннюю архитектуру, иначе управляемость падает, а сложность разработки начинает расти неадекватно... а радикальные шаги требуют серьёзных инвестиций...

Согласен в большинстве случаев, но по отношению к системе Mathematica - лишь отчасти. Дело в том, что эта система - исключительный пример продукта, первоначально создававшегося действительно грамотными специалистами именно так, как им хочется! Я подчеркиваю: выдающиеся профессионалы для самих себя создавали и создали инструмент, концепция которого была ими же с самого начала продумана, без давления со стороны руководства, без строгой отчетности, при наличии избытка времени. И при возможности учитывать опыт предыдущих также весьма успешных разработок, в первую очередь системы Macsyma, потомок которой Maxima жив до сих пор и все еще имеет множество пользователей. В общем, не часто творческим и высокообразованным людям выпадает шанс делать, что хочется, имея время и деньги. Главная заслуга Вольфрама - именно в этом: он не давил, ничего не навязывал, не торопил, не требовал отчетности. Люди наслаждались творческим процессом. Получился продукт, изначально и в самой своей основе едва ли не гениально устроенный. Его изначальную архитектуру не нужно менять: она чудесна и разработана с учетом весьма далекой перспективы! Другое дело, что, как и в любую кормушку, в этот проект постепенно пролезало все больше ничтожеств с бюрократическим мышлением. В результате накапливалось все больше кривых решений, а изначальная перспектива уходила из мышления разработчиков, её все меньше понимали (вероятно, и разработчиков также постепенно "уходили"). В настоящее время имеет место тупая эксплуатация языка, потому что его цельность многократно и на разные лады нарушена. Фактически, надо откатываться к первым версиям системы и переделывать все заново, восстановив изначальную перспективу краткости, ясности и гибкости, без бюрократизма. Возмножно, и там уже были зачатки позднейшего замутнения языка, но на них в то время легко было закрыть глаза. Сейчас - все знают - Вольфрам открыто измеряет развитие Mathematica количеством встроенных функций и числом строк исходного кода на СИ (см. его биографический сайт). Он уже не способен понять, насколько позорна и отвратительна такая позиция по отношению к продукту, созданному математиками! Математики всегда стремились описать максимально широкий диапазон явлений минимумом понятий и формул. Теперь же в системе Mathematica чем дальше, тем больше дублирующих друг друга функций с разными названиями и зачастую не вполне совместимым синтаксисом. И весь этот мусор пользователь должен помнить!

Всего записей: 1833 | Зарегистр. 22-03-2003 | Отправлено: 19:50 28-11-2010 | Исправлено: popkov, 20:09 28-11-2010
popkov

Advanced Member
Редактировать | Профиль | Сообщение | ICQ | Цитировать | Сообщить модератору
Кстати, Daniel Lichtblau (Wolfram Research) вчера вступил (сугубо лично, т.е. не от лица корпорации, конечно) в дискусию о возможности создания официального Mathematica bug list и изложил свои аргументы против:
 

Цитата:
I will make some comments on various social and technical aspects.
 
(1) It is difficult to navigate between bugs vs. intentional and justifiable changes (with new "features" falling in the middle). I generally can address such things when writing replies as an individual. I am not so sure how well this transfers to corporate "official responsa", so to speak.
 
(2) It is easy to get into awkward situations where some users will claim that changes in behavior are bugs, when we at WRI opine otherwise. While I agree that having a publicly available set of workarounds can be useful (and recently posted one such), I do not like the idea of appearing to endorse that some changes are bugs. Obviously, the ones we agree are bugs do not fall prey to this problem. But I can say from past experience that a lot of energy and patience can be spent on such issues, and I'd not want to see that sort of problem elevated to corporate status.
 
(3) It is not easy to get this information to users who might need it. We do not always recognize when a question involves an issue in this territory. And most people who have such questions are not likely to be MathGroup readers (specifically, your "we could check out the fixes" is far from "most users would..."). The upshot is we might often face ignorance on both our end (when we fail to recognize this type of an FAQ) and the user's. This of course does not make having a workaround list a bad idea: it simply indicates why it might be of limited use.
 
(4) It can be difficult to write an FAQ in such a way that it is clear to most readers. So we could end up doing work that has little applicability. I believe our experience is that this is an issue, but not a serious one (meaning, an FAQ can be generally useful as a first line of defense).
 
I myself tend to be neutral on this. I simply want to indicate reasons why it could cause more work than it is worth (both for WRI and users).
 
I should mention explicitly that I am not speaking for Wolfram Research on this matter.
 
Daniel Lichtblau
Wolfram Research  

 
Как видите, ответ откровенен настолько, насколько вообще может быть откровенным официальное лицо (если не более!). Как и следовало ожидать, главная причина нежелания создавать FAQ - трудности для сотрудников компании, к которым это приведет. Однако этот человек остается открытым для конструктивной дискуссии!

Всего записей: 1833 | Зарегистр. 22-03-2003 | Отправлено: 06:44 29-11-2010
r_green



Junior Member
Редактировать | Профиль | Сообщение | Цитировать | Сообщить модератору
popkov
Спасибо за обстоятельный ответ.

Цитата:
Сейчас - все знают - Вольфрам открыто измеряет развитие Mathematica количеством встроенных функций и числом строк исходного кода на СИ (см. его биографический сайт). Он уже не способен понять, насколько позорна и отвратительна такая позиция по отношению к продукту, созданному математиками! Математики всегда стремились описать максимально широкий диапазон явлений минимумом понятий и формул.

Мне кажется, вряд ли Вольфрам не понимает таких простых истин. Это просто "замануха" для пользователей, далёких от программирования и использующих Mathematica в бытовых целях, всё в рамках политики по расширению целевой аудитории продукта.  
Само по себе увеличение количества ф-ций не представляет угрозы архитектуре, пока соблюдается их наращивание в составе отдельных модулей или, по крайней мере, на базе ограниченного, самодостаточного и  "взаимно ортогонального" ядра. Такое захламление неизбежно, так же, как возникновение жаргона в любой профессиональной области. Правда, плохо то, что в документации они подаются без ранжирования, трудно понять, какие ф-ции составляют это самое самодостаточное ядро.
 
Кстати, какое из нововведений в Mathematica, на Ваш взгляд, было характерно кривым?

Всего записей: 145 | Зарегистр. 17-09-2004 | Отправлено: 21:04 29-11-2010
popkov

Advanced Member
Редактировать | Профиль | Сообщение | ICQ | Цитировать | Сообщить модератору
r_green

Цитата:
Кстати, какое из нововведений в Mathematica, на Ваш взгляд, было характерно кривым?  

 
Очень кривым было добавление "symbolic preprocessing" в функции, являющиеся по определению числовыми, не символьными. Уже в 5-й версии это часто создавало проблемы с такими базовыми функциями, как Plot[] и FindRoot[]. Начиная с 6-ки, можно было уже рвать на себе волосы: перестали нормально работать едва ли не все встроенные числовые функции! Теперь у каждой из них имеется встроенный "symbolic preprocessing", который обычно не отключается никакой опцией (в единичных случаях имеется недокументированная опция) и приводит к зависанию на простейших задачах, мгновенно решавшихся в предыдущих версиях. Да, обходной путь существует (и наконец-то иногда документирован, хоть вскользь) - но он замедляет работу, удлинняет код и просто является "граблями". Причем обнаружить причину зависания программы, написанной для старой версии системы, пользователю, не знающему об этой "фиче", может стоит больших нервов!  
 
Но самые серьезные проблемы создает, конечно, далеко не полная и далеко не всегда адекватная документация.
Сам я (в практическом плане) знаком с системой только начиная с 5-й версии. Если не отвлекаться на мелочи, то, пожалуй, мало кто поспорит, что реализация важнейшего в Mathematica механизма - pattern matсhing - на котором основана работа в т.ч. и "обычных" функций типа  
f[x_]:=x^2;
(такие функции Леонид Шифрин называют "rule-based functions" в противоположность "pure functions") как минимум столь плохо документирована, что является теми "граблями", на которые неизбежно наступает многократно не только начинающий, но также и опытный пользователь. Характерно, что документация по паттернам самая ясная в The Mathematica book для системы версии... 1 (доступна на оффсайте). Там коротко, но ясно дается хотя бы введение в эту область. Уже документация к версии 2 мутновата. В документации к новым версиям просто черт ногу сломит. Например, неясно, зачем в 3-й версии понадобилось вводить дополнительную функцию HoldPattern, единственное предназначение которой - препятствовать "выполнению" паттернов, хотя того же (вроде бы) можно достичь с помощью Unevaluated, а иногда и вовсе без подобных ухищрений (зачем такие выражения как x_*x_ превращаются в x_^2 при выполнении - отдельный вопрос; само по себе это столь интуитивно неочевидно, что даже опытные пользователи регулярно наступают на эти "грабли"). Грамотная работа даже с такой обычной функцией как Cases[] требует глубокого понимания работы паттернов, которого документация не дает. А ведь паттерны - это базис всего языка!..
 
На протяжении всего времени существования системы она не имела адекватной документации даже по важнейшим функциям и содержала огромное количество и вовсе недокументированных. Такая тенденция к скрывательству в конечном счете нанесла удар по самим разработчикам: новые сотрудники компании просто не знают многих "фокусов", позволяющих эффективно пользоваться важнейшими функциями! И уж тем более нигде не прописаны особенности реализации, делающие одни функции более совместимыми с другими - но не с их дубликатами, обладающими сходным функционалом. То, что новые функции почти все неадекватно тормозные и зачастую обладают запутанной системой опций (яркий пример - Histogram[], но то же можно сказать и о новых NIntegrate[], DSolve[] и др.) - одно из следствий.

Всего записей: 1833 | Зарегистр. 22-03-2003 | Отправлено: 14:19 30-11-2010 | Исправлено: popkov, 09:24 03-08-2013
r_green



Junior Member
Редактировать | Профиль | Сообщение | Цитировать | Сообщить модератору
popkov

Цитата:
очень кривым было добавление "symbolic preprocessing" в функции, являющиеся по определению числовыми, не символьными.

Мне кажется, этот шаг в принципе оправдан. Любой численный алгоритм, оперующий входной ф-цией как чёрным ящиком (т.е. фактически табличным представлением этой ф-ции), сильно ограничен. Другими словами, достаточно сложный алгоритм в вынужден строить  (хотя бы частично и неявно) аналитическое представление входной ф-ции, выполняя своего рода reverse engineering. Чего можно избежать, сразу дав ему ф-цию в виде выражения.
Например, тот же NIntegrate для быстро осциллирующих ф-ций. Насколько мне известно, благодаря "symbolic preprocessing" Mathematica значительно продвинулась в интегрировании таких ф-ций, опередив Maple.
 

Цитата:
неясно, зачем в 3-й версии понадобилось вводить дополнительную функцию HoldPattern, единственное предназначение которой - препятствовать "выполнению" паттернов, хотя того же (вроде бы) можно достичь с помощью Unevaluated

Насколько я понимаю, это всё-таки разные ф-ции. Unevaluated/Evaluate служат для явного переопределения Hold-атрибутов ф-ции, применительно к её аргументам. Т.е. они определяют то, что получит целевая ф-ция после вычисления(evaluation) её аргументов. Напротив, Hold, HoldPattern позволяют контролировать обработку аргумента самой этой ф-цией. Оборачивая аргумент в Hold-подобные ф-ции, мы как бы делаем ему оболочку, которую может "снять" только нужная нам ф-ция. Например, Hold - по сути безусловная защита от вычисления, HoldPattern - "снимается" ф-циями, оперирующими паттернами.
 
 
 
 
 
 

Всего записей: 145 | Зарегистр. 17-09-2004 | Отправлено: 18:08 30-11-2010 | Исправлено: r_green, 18:14 30-11-2010
popkov

Advanced Member
Редактировать | Профиль | Сообщение | ICQ | Цитировать | Сообщить модератору
Кстати, вот один баг, перекочевавший еще из самой первой версии Mathematica:
 
In[1]:= f[Infinity] - f[Infinity]
 
Out[1]= 0
 
In[2]:= f[x_] = x;
f[Infinity] - f[Infinity]
 
During evaluation of In[2]:= \[Infinity]::indet: Indeterminate expression -\[Infinity]+\[Infinity] encountered. >>
 
Out[3]= Indeterminate
 
Очевидно, первый результат неверен.  
 
Или вот еще один древнейший баг:
 
In[1]:= N[Sin[3141592653589793238]]
 
Out[1]= -0.64475
 
In[2]:= N[Sin[3141592653589793238], 6]
 
Out[2]= -0.446315
 
Здесь в обоих случаях берется синус точной величины. Причем единственный способ узнать, чему же равен синус такой величины, - использовать N[], т.к.
 
In[3]:= Sin[3141592653589793238]
 
Out[3]= Sin[3141592653589793238]
 
Однако, как легко видеть, здесь-то мы и попадаем в ловушку: результат такого очевидного (и предписанного документацией) действия оказывается неверен, если мы не зададим значение Precision для результата! Глядя на такие чудеса, начинаешь думать: имеет ли вообще смысл использовать N[] без указания целевой точности? Результат никем не гарантирован...
 
Добавлено:
r_green

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

Для этого есть символьный Integrate[]. В практических задачах обычно никакой символьный анализ помочь не может - NIntegrate просто не должен совать нос не в свою область. Его задача - работать с функцией именно как с "черным ящиком". Редкие случаи (по сути, единичные классы задач), когда и правда возможно некоторое ускорение или увеличение точности за счет символьного анализа, должны быть частью символьной функции. Или уж, если на то пошло, этот дополнительный "мозг" должен быть легко отключаем без потерь, чего не наблюдается.  
 
Ну да ладно с NIntegrate. А как насчет Plot[] (и всех остальных: ContourPlot[] и т.д.)? Как насчет FindMinimum[], да еще если однозначно указан метод, не требующий взятия производных, например "QuasiNewton" или "PrincipalAxis"? Зачем тут символьный анализ? Пользователь ожидает, что система будет действовать по известному алгоритму. Лишний "мозг" только вызывает недоумение и головную боль. В том, что поведение именно таково, нетрудно убедиться:
 
f[x_ /; Not@NumericQ[x]] := (Print["Symbolic evaluation"]; 2);
f[x_?NumericQ] := 1
Plot[f[x], {x, 1, 2}]
 
f[x_?NumericQ] := (Print["Numerical evaluation"]; 1)
Attributes[FindMinimum]
FindMinimum[f[x], {x, 0, 1}, Method -> "PrincipalAxis"]
FindMinimum[f[x], {x, 0, 1}, Method -> "QuasiNewton"]
(обратите внимание, что FindMinimum вообще не пытается изучить функцию численно, он уже все "знает". )
 

Цитата:
мы как бы делаем ему оболочку, которую может "снять" только нужная нам ф-ция.  

А почему бы не присвоить атрибут HoldRest тому же MatchQ[], чтобы не нужно было по любому поводу использовать HoldPattern? Да и вообще, зачем нужно "выполнять" выражения типа x_*x_ или, например, Times[___, Power[___], ___] (т.е. явно состоящие из паттернов)?  
 
Вот пример реально возникшей у пользователя проблемы (False в первом случае) и несколько вариантов её решения:
x = 2;
MatchQ[Times[-1, Power[s, -1]], Times[___, Power[___ /; x == 2], ___]]
MatchQ[Times[-1, Power[s, -1]],  
 HoldPattern@Times[___, Power[___ /; x == 2], ___]]
MatchQ[Times[-1, Power[s, -1]],  
 Unevaluated@Times[___, Power[___ /; x == 2], ___]]
Unprotect[MatchQ];
SetAttributes[MatchQ, HoldRest];
MatchQ[Times[-1, Power[s, -1]], Times[___, Power[___ /; x == 2], ___]]
(*проверка, что условие в паттерне работает*)
x = 3;
MatchQ[Times[-1, Power[s, -1]], Times[___, Power[___ /; x == 2], ___]]
Quit[]

Всего записей: 1833 | Зарегистр. 22-03-2003 | Отправлено: 22:31 30-11-2010 | Исправлено: popkov, 00:32 01-12-2010
r_green



Junior Member
Редактировать | Профиль | Сообщение | Цитировать | Сообщить модератору
popkov

Цитата:
Кстати, вот один баг, перекочевавший еще из самой первой версии Mathematica:
 
In[1]:= f[Infinity] - f[Infinity]
 
Out[1]= 0
 
In[2]:= f[x_] = x;
f[Infinity] - f[Infinity]
 
During evaluation of In[2]:= \[Infinity]::indet: Indeterminate expression -\[Infinity]+\[Infinity] encountered. >>
 
Out[3]= Indeterminate
 
Очевидно, первый результат неверен.  

 
Не могу согласиться, что такое поведение следует считать багом.
Ведь тогда нужно считать багом и следующее:

Код:
In[1]:= a - a
 
Out[1]= 0
 
In[2]:= a = Infinity
 
Out[2]= \[Infinity]
 
In[3]:= a - a
 
During evaluation of In[3]:= \[Infinity]::indet: Indeterminate expression -\[Infinity]+\[Infinity] encountered. >>
 
Out[3]= Indeterminate

Если значение символа не определено, Математика исходит из того, что это объект, для которого определена проводимая операция. Это единственное конструктивное поведение, на мой взгляд.  
Ну разве что завести для символа атрибут принадлежности к группе, над которой определена операция. Тогда присваивание a=Infinity будет давать ошибку для такого символа. А операция будет давать ошибку для символов без соответствующего атрибута. Но такое усложнение излишне.
 
 

Цитата:
Или вот еще один древнейший баг:
 
In[1]:= N[Sin[3141592653589793238]]
 
Out[1]= -0.64475
 
In[2]:= N[Sin[3141592653589793238], 6]
 
Out[2]= -0.446315
 
Здесь в обоих случаях берется синус точной величины. Причем единственный способ узнать, чему же равен синус такой величины, - использовать N[], т.к.
 
In[3]:= Sin[3141592653589793238]
 
Out[3]= Sin[3141592653589793238]
 
Однако, как легко видеть, здесь-то мы и попадаем в ловушку: результат такого очевидного (и предписанного документацией) действия оказывается неверен, если мы не зададим значение Precision для результата! Глядя на такие чудеса, начинаешь думать: имеет ли вообще смысл использовать N[] без указания целевой точности? Результат никем не гарантирован...

 
Это тоже не баг. По умолчанию (с одним аргументом) N[] работает на уровне машинной точности, т.е. напрямую с машинным представлением чисел. Это значительно ускоряет работу, но может приводить к искажению результата. Что явно указано в документации:

Цитата:
machine numbers work by making direct use of the numerical capabilities of your underlying computer system. As a result, computations with them can often be done more quickly. They are however much less flexible than arbitrary-precision numbers, and difficult numerical analysis can be needed to determine whether results obtained with them are correct.  

В приведённом примере Sin слишком быстро меняется для машинной точности вычисления.
Ещё более характерный результат можно получить с тангенсом:

Код:
In[56]:= res = Tan[157079632679489661923132169163975144209];
 
In[57]:= N[res]
 
Out[57]= 5.86236
 
In[58]:= N[res, 6]
 
Out[58]= -1.15797

 
 
Добавлено:

Цитата:
Для этого есть символьный Integrate[]. В практических задачах обычно никакой символьный анализ помочь не может - NIntegrate просто не должен совать нос не в свою область. Его задача - работать с функцией именно как с "черным ящиком". Редкие случаи (по сути, единичные классы задач), когда и правда возможно некоторое ускорение или увеличение точности за счет символьного анализа, должны быть частью символьной функции.

Я плохо представляю, как можно символьный анализ, необходимый для NIntegrate, вынести в Integrate. Ведь это "резать по живому", что называется... Либо надо вводить в Integrate численные опции, либо светить детали алгоритма NIntegrate, касающиеся символьного анализа.

Цитата:
Или уж, если на то пошло, этот дополнительный "мозг" должен быть легко отключаем без потерь, чего не наблюдается.  

Полностью согласен. Или, по крайней мере, предоставлять возможность отключения до тех пор, пока есть случаи, когда символьный анализ даёт негативный эффект.
 

Цитата:
f[x_ /; Not@NumericQ[x]] := (Print["Symbolic evaluation"]; 2);
f[x_?NumericQ] := (Print["Numerical evaluation"]; 1)
Attributes[FindMinimum]
FindMinimum[f[x], {x, 0, 1}, Method -> "PrincipalAxis"]
FindMinimum[f[x], {x, 0, 1}, Method -> "QuasiNewton"]
(обратите внимание, что FindMinimum вообще не пытается изучить функцию численно, он уже все "знает". )  

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

Всего записей: 145 | Зарегистр. 17-09-2004 | Отправлено: 01:44 01-12-2010
popkov

Advanced Member
Редактировать | Профиль | Сообщение | ICQ | Цитировать | Сообщить модератору
r_green

Цитата:
По умолчанию (с одним аргументом) N[] работает на уровне машинной точности, т.е. напрямую с машинным представлением чисел. Это значительно ускоряет работу, но может приводить к искажению результата.  

Однако это нарушает математическую строгость языка и приводит к двусмысленностям:
 
In[1]:= 3141592653589793238. == 3141592653589793238.00
3141592653589793238. === 3141592653589793238.00
Sin[3141592653589793238] == Sin[3141592653589793238.00]
Sin[3141592653589793238] === Sin[3141592653589793238.00]
N[Sin[3141592653589793238.]] == N[Sin[3141592653589793238.00]]
N[Sin[3141592653589793238.]] === N[Sin[3141592653589793238.00]]
 
Out[1]= True
 
Out[2]= True
 
Out[3]= True
 
Out[4]= False
 
Out[5]= False
 
Out[6]= False
 
Другими словами, если a=b, да к тому же они еще и тождественны как объекты в системе Mathematica, то должно быть f[a]=f[b] и g[f[a]]=g[f[b]]. Или же они как минимум должны быть не тождественны, а по-хорошему - и не равны друг другу!  
 
Добавлено:

Цитата:
Ведь тогда нужно считать багом и следующее:  

На самом деле, так оно и есть: это изначальный дефект архитектуры языка. Суть в том, что система обращается с 'a' так, будто бы это - обозначение настоящей математической величины, когда 'a' не определено:
 
In[19]:= a - a
 
Out[19]= 0
 
Однако, как только 'a' определено, вдруг выясняется, что оно не эквивалентво самому себе, чего для математической величины быть не может:
 
In[20]:= a = Infinity
a - a
 
Out[20]= \[Infinity]
 
During evaluation of In[20]:= \[Infinity]::indet: Indeterminate expression -\[Infinity]+\[Infinity] encountered. >>
 
Out[21]= Indeterminate
 
В математике, строго говоря, нет никаких "бесконечностей": это - жаргон. Под ним понимается сколь угодно большая величина. И, как бы она ни была велика, она все равно останется равной самой себе!
 
Добавлено:
С другой стороны, 'a' равно и тождественно самому себе:
 
In[24]:= a = Infinity
a == a
a === a
 
Out[24]= \[Infinity]
 
Out[25]= True
 
Out[26]= True
 
Вот это я и называю замутнением языка. Оказывается, это было с самого начала...

Всего записей: 1833 | Зарегистр. 22-03-2003 | Отправлено: 11:31 01-12-2010 | Исправлено: popkov, 11:46 01-12-2010
r_green



Junior Member
Редактировать | Профиль | Сообщение | Цитировать | Сообщить модератору
popkov

Цитата:
Однако это нарушает математическую строгость языка и приводит к двусмысленностям:  
...
Другими словами, если a=b, да к тому же они еще и тождественны как объекты в системе Mathematica, то должно быть f[a]=f[b] и g[f[a]]=g[f[b]]. Или же они как минимум должны быть не тождественны, а по-хорошему - и не равны друг другу!  

 
Дело в том, что язык и объекты Mathematica - это всего лишь удобные модели (или средства для моделирования) математических объектов. Более того, пользователь должен сам решать какую конструкцию языка можно выбрать для адекватного моделирования его математической системы. И если выбранная модель начинает давать недопустимые отклонения от поведения моделируемой системы, это в первую очередь ошибка пользователя, выбравшего данную модель. Претензии к средствам моделирования могут быть лишь при нарушении спецификации, определяющей их поведение.
Возьмём, к примеру, тот же оператор сравнения == (ф-ция Equal[]).
По спецификации, он не всегда обязан возвращать False для неравных по значению объектов - для действительных чисел ограниченной точности он проверяет равенство только в пределах точности:

Код:
 
In[1]:= a = 123456789012345.0;
 
In[2]:= b = 123456789012345.9;
 
In[3]:= a == b
 
Out[3]= True
 
In[4]:= a - b == b - b
 
Out[4]= False
 
In[5]:= a - b
 
Out[5]= -0.90625
 

 

Цитата:
На самом деле, так оно и есть: это изначальный дефект архитектуры языка. Суть в том, что система обращается с 'a' так, будто бы это - обозначение настоящей математической величины, когда 'a' не определено:
 
In[19]:= a - a
 
Out[19]= 0  
 

Я считаю, что это скорее рациональное упрощение языка, а не дефект.
Допустим, мы ввели дополнительную категорию объектов, (определяемую атрибутом, скажем) для которых допустима операция (Subtract[] в нашем случае). Т.е. для объектов без этого атрибута операция будет возвращать ошибку. Возникает вопрос - насколько полезны будут объекты без этого атрибута? Не придётся ли во всех практических случаях сразу же добавлять для нового объекта этот атрибут?
Т.е. то, что Mathematica априори полагает объект допустимым для применяемой к нему операции, пока не установлено обратное, считаю целесообразным.
И не вижу здесь покушения на математические принципы - в конце концов, объект Mathematica - это лишь модель, и именно Вы выбираете моделируемый им  математический объект, разве нет?

Всего записей: 145 | Зарегистр. 17-09-2004 | Отправлено: 18:39 01-12-2010
popkov

Advanced Member
Редактировать | Профиль | Сообщение | ICQ | Цитировать | Сообщить модератору
r_green

Цитата:
Я считаю, что это скорее рациональное упрощение языка, а не дефект.  

Дефектом является то, что величина перестает быть тождественна самой себе, если устремляется к бесконечности.
Цитата:
И не вижу здесь покушения на математические принципы - в конце концов, объект Mathematica - это лишь модель, и именно Вы выбираете моделируемый им  математический объект, разве нет?  
Вы издеватесь? Какому математическому объекту соответствует объект Mathematica и её язык с таким двусмысленным поведением?

Всего записей: 1833 | Зарегистр. 22-03-2003 | Отправлено: 19:08 01-12-2010 | Исправлено: popkov, 20:48 01-12-2010
r_green



Junior Member
Редактировать | Профиль | Сообщение | Цитировать | Сообщить модератору
popkov

Цитата:
Дефектом является то, что величина перестает быть тождественна самой себе, если устремляется к бесконечности.  

Понятно. Простите, я почему-то подумал, что Вы против вычислимости Subtract[a, a] для неопределённого а.
 
Здесь согласен - дефект. Но дефект скорее не в Mathematica, а в неопределённости самого понятия  бесконечности как значения величины.
С математической точки зрения: с одной стороны, результат inf - inf неопределён, а с другой -  
a - a = 0 при a = inf. Получаем нарушение симметричности отношения равенства...
Таким образом, понятие бесконечности в математике не менее двусмысленно, чем в Mathematica. Стоит ли усложнять язык, моделируя все причуды этого полужаргонного понятия? А усложнять придётся - как минимум, нужно отазаться от декомпозиции вычисления ф-ции и её аргументов, на случай если аргумент равен inf.
 

Всего записей: 145 | Зарегистр. 17-09-2004 | Отправлено: 21:31 01-12-2010
popkov

Advanced Member
Редактировать | Профиль | Сообщение | ICQ | Цитировать | Сообщить модератору

Цитата:
С математической точки зрения: с одной стороны, результат inf - inf неопределён, а с другой -  
a - a = 0 при a = inf.

C математической точки зрения, каждая "бесконечность" индивидуальна, это не просто inf, а предел функции при стремлении её аргумента к некой величине (в т.ч. и ко "сколь угодно большой" величине, т.е. при неограниченном возрастании аргумента). Поэтому с такими объектами можно работать. Эту проблему и метод её решения обсуждает Richard Fateman (один из ключевых разработчиков Maxima) в своей недавней статье (см. раздел 4). Решение, которое он предлагает, - нумеровать "бесконечности" в рамках одной программы и не объединять разные (а также "бесконечности" и константы) до окончания вычисления. При этом одинаковые "бесконечности" могут вычитаться (получится ноль), складываться и т.д. Вероятно, при дальнейшем развитии CAS станет возможно работать с "бесконечностями" именно как с пределами, а не просто нумеровать их. Но пока - хоть так бы...

Всего записей: 1833 | Зарегистр. 22-03-2003 | Отправлено: 06:44 02-12-2010 | Исправлено: popkov, 07:03 02-12-2010
r_green



Junior Member
Редактировать | Профиль | Сообщение | Цитировать | Сообщить модератору
popkov

Цитата:
Какому математическому объекту соответствует объект Mathematica и её язык с таким двусмысленным поведением?

Например, Mathematica полностью моделирует кольцо целых чисел (Z).

Цитата:
Решение, которое он предлагает, - нумеровать "бесконечности" в рамках одной программы

Мне кажется, это не очень хорошее решение. Оно подходит для простых присваиваний a = inf,
но как быть с
a = Limit[expr]
b = Limit[expr]
?
Если просто каждый раз генерировать уникальную бесконечность, то нельзя будет вычислять a-b в этом случае.
 
Или ещё проще:
a := Limit[expr]
a-a
 
 
 
 

Всего записей: 145 | Зарегистр. 17-09-2004 | Отправлено: 13:14 02-12-2010 | Исправлено: r_green, 13:37 02-12-2010
popkov

Advanced Member
Редактировать | Профиль | Сообщение | ICQ | Цитировать | Сообщить модератору
r_green

Цитата:
Если просто каждый раз генерировать уникальную бесконечность

Не каждый раз, а только если такой еще не появлялось.  
 

Всего записей: 1833 | Зарегистр. 22-03-2003 | Отправлено: 06:10 03-12-2010
popkov

Advanced Member
Редактировать | Профиль | Сообщение | ICQ | Цитировать | Сообщить модератору
Замечательное откровение одного из сотрудников WRI, по-видимому имеющего отношение к разработке функций линейной алгебры в MMa в ответ на вопрос об одной странности пакета LinearAlgebra` в 8-ке:
 
Вот вопрос:

Цитата:
This is version 8:
 
I'd like to use LinearAlgebra`MatrixConditionNumber to find
condition number of some matrix.
 
btw, This command lists the functions in linear algebra.
Names["LinearAlgebra`*"]
 
But Mathematica says this package is now obsolete, and
functionality is now in the kernel.
 
<<LinearAlgebra`
General::obspkg: {At Line = 3, the input was:,
<<LinearAlgebra`,LinearAlgebra`} is now obsolete. The
legacy version being loaded may conflict with current
Mathematica functionality. See the Compatibility Guide for
updating information. >>
 
But When I follow the above, I get to page, where at the bottom
it shows 3 functions, one of them is MatrixConditionNumber,
but it does not show what replaced it in the kernel, instead
it points to a link to MathSource article:
 
"These functions were available in previous versions of Mathematica
and are now available on the web at
library.wolfram.com/infocenter/MathSource/6770"
 
?
 
So, is there no build-in function to compute condition number now
in Mathematica?
 
I know I can find the max eigenvalue, divide it by the min
eigenvalue (absolute values), and this gives me the condition
number. But should not such a function be part of the system?
 
Or may be I overlooked it? I did search for it, can't find it
in the documenation center.
 
btw, I did also try the natural language interface also, and I asked
W/ALpha by typing
 
      = matrix condition number
 
but it replied back with a chemical formula C16 H13 C1 N2 O, named diazepam, which is not what I wanted.
 
thanks,
--Nasser  

(особенно забавен ответ Wolfram|Alpha ).
 
И вот ответ разработчика:

Цитата:
I made the suggestion that MatrixConditionNumber become a true kernel
function.
 
I still use the LinearAlgebra`MatrixConditionNumber to find the condition
number.
 
> I know I can find the max eigenvalue, divide it by the min
> eigenvalue (absolute values), and this gives me the condition
> number. But should not such a function be part of the system?
 
Yes, I agree.
 
Oliver  

 
Т.е. разработчик, программируя системное сообщение о том, что функция LinearAlgebra`MatrixConditionNumber является частью устаревшего пакета, исключенного из стандартного инсталлятора Mathematica, и теперь внесена в ядро системы, даже не удосужился это проверить! Оказывается, она вовсе не внесена в ядро, а пакет по-прежнему устанавливается вместе с системой (по крайней мере, та его часть, где определена данная функция - не могу проверить сам ввиду отсутствия 8-ки)! И сам разработчик пользуется ею!.. До чего дошел "прогресс"...
 
Добавлено:
Ё-мое, в 7.0.1 на странице Compatibility/tutorial/LinearAlgebra/MatrixManipulation внизу написано то же самое, только ссылка на mathsource неверная, в отличие от 8-ки:

Цитата:
These functions were available in previous versions of Mathematica and are now available on the web at library.wolfram.com/infocenter/MathSource/6777:
LinearEquationsToMatrices
InverseMatrixNorm
MatrixConditionNumber

А на странице tutorial/LinearAlgebraMatrixComputations написано:
Цитата:
Additional functionality related to this tutorial has been introduced in subsequent versions of Mathematica. For the latest information, see Matrices and Linear Algebra.
Зашибись!.. Это всё - лишь иллюзии разработчика, который лишь предполагал, что это правда... Но внес в 7-ке в документацию,а в 8-ке даже системное сообщение зафигачил!

Всего записей: 1833 | Зарегистр. 22-03-2003 | Отправлено: 16:08 03-12-2010
r_green



Junior Member
Редактировать | Профиль | Сообщение | Цитировать | Сообщить модератору

Цитата:
I asked W/ALpha by typing
 
      = matrix condition number
 
but it replied back with a chemical formula C16 H13 C1 N2 O, named diazepam

Превосходный образец машинного юмора!
 

Всего записей: 145 | Зарегистр. 17-09-2004 | Отправлено: 17:56 03-12-2010
popkov

Advanced Member
Редактировать | Профиль | Сообщение | ICQ | Цитировать | Сообщить модератору
Еще парочка недавно опубликованных фундаментальных глюков Mathematica (проверил присутствие в версиях 5.2 и 7.0.1, но, вероятно, они есть во всех версиях, где есть данные функции).
 
Глюк первый: "зомби" вылезают из Module[]!
Как вы думаете, почему MathKernel.exe, даже при выставленном
$HistoryLength = 0
, все равно в процессе вычислений (даже если вызывается одна и та же функция, а результаты её работы только экспортируются в файл) постоянно накапливает оперативную память, которую нельзя сбросить (и даже замедлить её наращивание) никакими встроенными функциями? Отчасти на этот вопрос проливает свет недавно обнаруженный баг функции Module[], введенной в версии 2 как альтернатива кривоватому Block[]. Так вот, оказывается, эта функция с легкостью может начать генерировать при каждом её вызове "вечные" мусорные переменные с атрибутом Temporary, в совершенно неограниченном количестве. Причем к каждой такой переменной могут быть привязаны ещё её Definition[] и Attributes[]. Вот уж пример универсальности поговорки: "Нет ничего более постоянного, чем временное (Temporary)!"
 
Рассмотрим "нормальное" поведение Module[]. Определим простую функцию:
 
In[1]:=
a[b_] := Module[{c, d}, c := 1; d := 9; d];
 
Теперь посмотрим, какие переменные появились в текущем контексте:
 
In[2]:=
Names[$Context<>"*"]
 
Out[2]=
{a,b,c,d}
 
Это - "нормально", т.е. by design.
 
А теперь введем внутрь Module[] условие (Condition[]):
 
In[1]:=
a[b_] := Module[{c, d}, c := 1; d := 9; d /; b === 1];
 
Что же мы имеем теперь в текущем контексте?
 
In[2]:=
Names[$Context<>"*"]
 
Out[2]=
{a,b,c,c$,d,d$}
 
При введении Condition ("/;") появилась мусорная переменная "c$" c атрибутом Temporary, которая к тому же отказывается удаляться через Remove[c$]. Но она хотя бы не размножается. Переменная "d$" вроде как и правда должна появляться из-за Condition.
 
А теперь посмотрим, что происходит при вызове функции, если условие выполняется:
 
In[3]:=
a[1];
Names[$Context <> "*"]
{#,ToString[Definition[#]]}&/@Select[%,MemberQ[Attributes[#],Temporary]&]//ColumnForm
 
Out[4]=
{a,b,c,c$,d,d$,d$16}
 
Out[5]=
{"c$","Attributes[c$] = {Temporary}"}
{"d$","Attributes[d$] = {Temporary}"}
{"d$16","Attributes[d$16] = {Temporary}"}
 
Если условие в Condition выполняется, происходит генерация "зомби" - мусорных переменных с атрибутом Temporary, которые, согласно документации, должны автоматически удаляться после завершения выполнения Module[]. При каждом выполнении Module[] генерируется новая такая переменная, причем по завершении работы Module[] она не удаляется:
 
In[6]:=
Table[a[1],{1000}];
Length@Names[$Context <> "*"]
 
Out[7]=
1007
 
Надо, правда, признать, что при выставлении $HistoryLength = 0 такое поведение воспроизводится только в том случае, если все вызовы a[1] происходили в одной и той же ячейке (см. последний пример). При выполнении новой ячейки лишние мусорные переменные (кроме c$) и в самом деле удаляются, если $HistoryLength = 0. Однако в практических задачах все вызовы как раз и происходят в пределах одной ячейки, поэтому данный баг вылезает "во всей красе". Следует также напомнить, что Module[] активно используется не только в дополнительных пакетах, поставляемых с системой, но и, несомненно, в высокоуровневом коде втроенных в ядро функций.
 
===============================================
Глюк второй: "шутливый" Compile[].
 
На этот раз - рандомные результаты работы скомпилированной функции в версиях 5.2 и 7.0.1 (в 8.0 при компиляции возникает runtime error).
 
Вот несколько функций, которые должны возвращать одно и то же. Однако первая из них (самая простая) оказывается с "чувством юмора":
 
abc1 = Compile[{}, Module[{a, b, c}, a = 1.0;
    b = {1.0, 2.0};
    c = {{1.0, 2.0}, {3.0, 4.0}};
    a*b*c]];
abc2 = Compile[{}, Module[{a, b, c}, a = 1.0;
    b = {1.0, 2.0};
    c = {{1.0, 2.0}, {3.0, 4.0}};
    (a*b)*c]];
abc3 = Compile[{}, Module[{a, b, c}, a = 1.0;
    b = {1.0, 2.0};
    c = {{1.0, 2.0}, {3.0, 4.0}};
    a*(b*c)]];
 
Попробуйте теперь несколько раз последовательно выполнить ячейку:
 
abc1[]
abc2[]
abc3[]
 
и сравните результаты!

Всего записей: 1833 | Зарегистр. 22-03-2003 | Отправлено: 20:17 09-12-2010 | Исправлено: popkov, 20:24 09-12-2010
popkov

Advanced Member
Редактировать | Профиль | Сообщение | ICQ | Цитировать | Сообщить модератору
Дополнение по поводу первого бага.
 
Даже при выставлении $HistoryLength = 0 мусорные переменные не удаляются при выполнении другой ячейки, если результаты вызовов Module[] были хотя бы на время запомнены в какой-либо переменной:
 
In[1]:=
$HistoryLength=0;
a[b_]:=Module[{c,d},c:=1;d:=9;d/;b===1];
 
In[3]:=
lst=Table[a[1],{1000}];
Length@Names[$Context<>"*"]
 
Out[4]=
1007
 
In[5]:=
lst=.
Length@Names[$Context<>"*"]
 
Out[6]=
1007
 
Т.е. этот баг действительно может быть причиной неограниченного роста потребления памяти ядром системы...

Всего записей: 1833 | Зарегистр. 22-03-2003 | Отправлено: 08:30 10-12-2010
popkov

Advanced Member
Редактировать | Профиль | Сообщение | ICQ | Цитировать | Сообщить модератору
r_green

Цитата:
Я плохо представляю, как можно символьный анализ, необходимый для NIntegrate, вынести в Integrate. Ведь это "резать по живому", что называется... Либо надо вводить в Integrate численные опции, либо светить детали алгоритма NIntegrate, касающиеся символьного анализа.  

Недавно в официальной группе новостей появилось очередное сообщение о проблеме, вызванной "symbolic preprocessing" числовых функций. Такие проблемы всегда являются камнем преткновения для новичков, поскольку никаких адекватных сведений в документации по ним нет, и человек должен искать наощупь, пробуя все мыслимые варианты обходных путей - причем наиболее очевидные и документированные оказываются ложны! Даже опытным пользователям приходится тратить дни в бесплодных поисках решения проблемы, которой, по определению, просто быть не должно. Проблема в том, что функции, предназначенные для поиска числовых решений, зачем-то пытаются искать их символьно, заводя новичка в ловушку ложности описанного в документации численного предназначения!
 
Вот очередной крик души:

Цитата:
Тема: Desperate due to NMinimize
 
I am working with Mathematica 7. I want to use NMinimize to find the
minimum of a function that is calculated by an external program. It is
called by Run with some arguments and it writes the result into a
file. I then use Import to read the value. Such a situation can be
mimicked by:
 
dd[x_]:=(Export["test.dat",x^2];Import["test.dat"])[[1, 1]]
NMinimize[dd[x],x]
 
If you give the function dd a value it returns the result correctly
(and writes a file). But NMinimize does not specify a value for x but
tries to evaluate the expression generally for a global x. I tried
everything that I could possibly think of using HoldAll, Unevaluated,
With[{x=x},], ... Nothing worked.
 
Is there anybody that can help me?
 

 
Повторяю, что сообщения о подобных проблемах появляются регулярно, но по ключевым словам их не найти, т.к. авторы таких сообщений и понятия не имеют о "symbolic preprocessing" числовых функций, не упоминающемся в документации нигде в явном виде!

Всего записей: 1833 | Зарегистр. 22-03-2003 | Отправлено: 15:25 11-12-2010 | Исправлено: popkov, 15:31 11-12-2010
Открыть новую тему     Написать ответ в эту тему

Страницы: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

Компьютерный форум Ru.Board » Компьютеры » Программы » Wolfram Mathematica | Математика


Реклама на форуме Ru.Board.

Powered by Ikonboard "v2.1.7b" © 2000 Ikonboard.com
Modified by Ru.B0ard
© Ru.B0ard 2000-2024

BitCoin: 1NGG1chHtUvrtEqjeerQCKDMUi6S6CG4iC

Рейтинг.ru