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

popkov

Цитата:

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

Calculus WIZ ?
Mathematica CalcCenter ?

TomasVercetti

Цитата:

где вы про это прочитали?

Кстати, часть этого написана в справке ref/CompoundExpression (просто набираешь в поиске точку с запятой).


Цитата:

А как в математике наиболее правильно сделать функции локальными?

По правде говоря, этим никогда не заморачивался. Мои задачи "вылизывания" кода не требуют. Но ключевыми словами при поиске в справке будут Module[] и Block[]. Ещё, возможно, полезно обратить внимание на Compile[] (это для оптимизации выполнения кода).

Добавлено:
karl_karlsson
Я уже не помню, как он назывался. Делал выводы по описаниям пакетов от сторонних разработчиков на сайте wolfram.com .

Добавлено:

Цитата:

Желательно, чтобы после evaluation'а только конечная функция стала глобальной, а имена остальных остались бы (глобально) свободными.

Можно создать процедуру, в которой определяется функция.
Затем просто удалить символ с помощью Clear[] или Remove[] или просто Unset[]. Однако предупреждаю, что в Mathematica с очисткой памяти дела обстоят очень плохо: все эти функции толком не освобождают память, и мусор постоянно накапливается.

Понял. Пошёл читать и экспериментировать. Просто накопилась целая куча многократно используемого по разным ноутбукам кода - поэтому и решил всё это "причесать" и описать.

TomasVercetti

Цитата:

Просто накопилась целая куча многократно используемого по разным ноутбукам кода

Для этих случаев есть такая штука, как пакет. Встроенных пакетов много (например, Combinatorica), но их можно создавать и самостоятельно, хотя документация на эту тему неполная. Если же не так уж много постоянно используемых функций, то их можно просто добавить в файл init.m, выполняемый при запуске Kernel.exe, и тогда эти функции станут как бы аналогом встроенных, то есть будут доступны всегда. Им можно даже добавить атрибут Protected - и тогда они станут совсем как встроенные, то есть их нельзя будет просто так переопределить или удалить.

Спасибо - это будет полезно!

В Mathematica 7.0 Win (смотрел и Student, и Pro версии) в справке отсутствует tutorial/NIntegrateIntegrationStrategies. Одноимённого файла вообще нету в \Wolfram Research\Mathematica\7.0\Documentation\English\System\Tutorials. Видимо баг - на сайте в интернете этот раздел есть. Может люди, обладающие лицензией, сообщат куда нужно?

Нашёл в интернете файл для 6й версии математики (для линукса). Кинул его в \Tutorials, но help его не подхватывает - ссылки на этот файл по-прежнему не работают. Что делать?

TomasVercetti
Друг,а я то думал что я что-то напортачил при упаковке WIM-архива.
Та же байда - отсутствуют файлы справки ( конкретно попался на Tutorials\NIntegrateIntegrationStrategies.nb)

Скачал по адресу (хттп: / / linux.iingen.unam.mx/pub/Documentacion/Cluster_TONATIUH/Mathematica/v6/Mathematica/System/Tutorials/) (это единственный что был в интернете, правда версия для шестой математики, но думаю что не очень страшно).

Короче, зазеркалировал я всю эту папку Documentation и стал стравнивать в ExamDiff'e. В скачанных доках от шестерки даты файлов новее (показывает 9-02-2009, в то время как у моей домашней семерки - 11-11-08), но внутри написано (created with Mathematica6), размеры больше у февральской шестерки...



Вот сейчас сижу и думаю, качать ли новый дистр с варезника, или синхронизировать со скачанными доками...

eriik

Я оттуда же этот файл скачал. При беглом сравнении содержание не отличается от статьи на официальном сайте.

Про даты и размеры файлов сложно что-либо сказать, не зная специфик версий.

Дистрибутивы 7ки с варезника я уже все попробовал. Так что хотелось бы этот файл интегрировать в систему справки. Видимо, кроме подсовывания файла, нужно ещё какой-то индекс перестроить.

Новое начинание Wolfram'а: http://blog.wolfram.com/2009/03/05/wolframalpha-is-coming/

А какая в Mathematica самая короткая запись для вычисления
Plot[ {f1[x], f2[ f1[x], x ], f3[ f1[x], x ]}, {x, xmin, xmax} ] так, чтобы при каждом x f1[x] вычислялась бы только один раз? (Или создание аналогичных списков для ListPlot. И без переопределений типа f21[x_]:=f2[ f1[x], x ].)

Цитата:

Или создание аналогичных списков для ListPlot

Ну, это-то понятно:
Table[{y=f1[x], f2[ y, x ], f3[ y, x ]}, {x, xmin, xmax}]

Например:
Table[{y = x^2, y*x}, {x, 1, 10}]
сравни с
Table[{x^2, x^3}, {x, 1, 10}]
- результат идентичен!

Однако
Plot[{y = x^2, y*x}, {x, 1, 10}]
и
Plot[{x^2, x^3}, {x, 1, 10}]
- по не ясной мне причине - совсем не одно и то же!

popkov,
спасибо - сейчас воспользуюсь таким вариантом. Не знал, что переменную внутри списка можно так использовать.

Я вначале сделал внутри Plot'а Module, возвращающий список значений, - строит все три кривые как надо, но считает всё полученное одним графиком, строит одним цветом, и через PlotStyle установить цвета не получается. Вообще, интересная эта птица - Plot, нужно научиться её готовить.

Глядя на функциональный язык математики, интересно, можно ли в итерации изнутри списка сослаться на текущее (Evaluated) значение другого элемента этого же списка?

TomasVercetti
Я бы и сам хотел, чтобы нашёлся человек, способный разъяснить некоторые вещи. Например:

In[1]:= Table[{y*x, y = x^2}, {x, 1, 10}]

Out[1]= {{100, 1}, {2, 4}, {12, 9}, {36, 16}, {80, 25}, {150,
36}, {252, 49}, {392, 64}, {576, 81}, {810, 100}}

Каким образом первое значение оказалось 100???

Добавлено:
Хотя при более вдумчивом анализе всё становится понятно (используем [no]On[][/no]):

[more=Результат при включённом On][no]In[1]:= On[];
Table[{y*x, y = x^2}, {x, 1, 10}]

During evaluation of In[1]:= On::trace: On[] --> Null. >>

During evaluation of In[1]:= CompoundExpression::trace: On[]; --> Null. >>

During evaluation of In[1]:= x::trace: x --> 1. >>

During evaluation of In[1]:= Times::trace: y x --> y 1. >>

During evaluation of In[1]:= Times::trace: y 1 --> y. >>

During evaluation of In[1]:= x::trace: x --> 1. >>

During evaluation of In[1]:= Power::trace: x^2 --> 1^2. >>

During evaluation of In[1]:= Power::trace: 1^2 --> 1. >>

During evaluation of In[1]:= Set::trace: y=x^2 --> y=1. >>

During evaluation of In[1]:= Set::trace: y=1 --> 1. >>

During evaluation of In[1]:= List::trace: {y x,y=x^2} --> {y,1}. >>

During evaluation of In[1]:= y::trace: y --> 1. >>

During evaluation of In[1]:= x::trace: x --> 2. >>

During evaluation of In[1]:= Times::trace: y x --> 1 2. >>

During evaluation of In[1]:= Times::trace: 1 2 --> 2. >>

During evaluation of In[1]:= x::trace: x --> 2. >>

During evaluation of In[1]:= Power::trace: x^2 --> 2^2. >>

During evaluation of In[1]:= Power::trace: 2^2 --> 4. >>

During evaluation of In[1]:= Set::trace: y=x^2 --> y=4. >>

During evaluation of In[1]:= Set::trace: y=4 --> 4. >>

During evaluation of In[1]:= List::trace: {y x,y=x^2} --> {2,4}. >>

During evaluation of In[1]:= y::trace: y --> 4. >>

During evaluation of In[1]:= x::trace: x --> 3. >>

During evaluation of In[1]:= Times::trace: y x --> 4 3. >>

During evaluation of In[1]:= Times::trace: 4 3 --> 12. >>

During evaluation of In[1]:= x::trace: x --> 3. >>

During evaluation of In[1]:= Power::trace: x^2 --> 3^2. >>

During evaluation of In[1]:= Power::trace: 3^2 --> 9. >>

During evaluation of In[1]:= Set::trace: y=x^2 --> y=9. >>

During evaluation of In[1]:= Set::trace: y=9 --> 9. >>

During evaluation of In[1]:= List::trace: {y x,y=x^2} --> {12,9}. >>

During evaluation of In[1]:= y::trace: y --> 9. >>

During evaluation of In[1]:= x::trace: x --> 4. >>

During evaluation of In[1]:= Times::trace: y x --> 9 4. >>

During evaluation of In[1]:= Times::trace: 9 4 --> 36. >>

During evaluation of In[1]:= x::trace: x --> 4. >>

During evaluation of In[1]:= Power::trace: x^2 --> 4^2. >>

During evaluation of In[1]:= Power::trace: 4^2 --> 16. >>

During evaluation of In[1]:= Set::trace: y=x^2 --> y=16. >>

During evaluation of In[1]:= Set::trace: y=16 --> 16. >>

During evaluation of In[1]:= List::trace: {y x,y=x^2} --> {36,16}. >>

During evaluation of In[1]:= y::trace: y --> 16. >>

During evaluation of In[1]:= x::trace: x --> 5. >>

During evaluation of In[1]:= Times::trace: y x --> 16 5. >>

During evaluation of In[1]:= Times::trace: 16 5 --> 80. >>

During evaluation of In[1]:= x::trace: x --> 5. >>

During evaluation of In[1]:= Power::trace: x^2 --> 5^2. >>

During evaluation of In[1]:= Power::trace: 5^2 --> 25. >>

During evaluation of In[1]:= Set::trace: y=x^2 --> y=25. >>

During evaluation of In[1]:= Set::trace: y=25 --> 25. >>

During evaluation of In[1]:= List::trace: {y x,y=x^2} --> {80,25}. >>

During evaluation of In[1]:= y::trace: y --> 25. >>

During evaluation of In[1]:= x::trace: x --> 6. >>

During evaluation of In[1]:= Times::trace: y x --> 25 6. >>

During evaluation of In[1]:= Times::trace: 25 6 --> 150. >>

During evaluation of In[1]:= x::trace: x --> 6. >>

During evaluation of In[1]:= Power::trace: x^2 --> 6^2. >>

During evaluation of In[1]:= Power::trace: 6^2 --> 36. >>

During evaluation of In[1]:= Set::trace: y=x^2 --> y=36. >>

During evaluation of In[1]:= Set::trace: y=36 --> 36. >>

During evaluation of In[1]:= List::trace: {y x,y=x^2} --> {150,36}. >>

During evaluation of In[1]:= y::trace: y --> 36. >>

During evaluation of In[1]:= x::trace: x --> 7. >>

During evaluation of In[1]:= Times::trace: y x --> 36 7. >>

During evaluation of In[1]:= Times::trace: 36 7 --> 252. >>

During evaluation of In[1]:= x::trace: x --> 7. >>

During evaluation of In[1]:= Power::trace: x^2 --> 7^2. >>

During evaluation of In[1]:= Power::trace: 7^2 --> 49. >>

During evaluation of In[1]:= Set::trace: y=x^2 --> y=49. >>

During evaluation of In[1]:= Set::trace: y=49 --> 49. >>

During evaluation of In[1]:= List::trace: {y x,y=x^2} --> {252,49}. >>

During evaluation of In[1]:= y::trace: y --> 49. >>

During evaluation of In[1]:= x::trace: x --> 8. >>

During evaluation of In[1]:= Times::trace: y x --> 49 8. >>

During evaluation of In[1]:= Times::trace: 49 8 --> 392. >>

During evaluation of In[1]:= x::trace: x --> 8. >>

During evaluation of In[1]:= Power::trace: x^2 --> 8^2. >>

During evaluation of In[1]:= Power::trace: 8^2 --> 64. >>

During evaluation of In[1]:= Set::trace: y=x^2 --> y=64. >>

During evaluation of In[1]:= Set::trace: y=64 --> 64. >>

During evaluation of In[1]:= List::trace: {y x,y=x^2} --> {392,64}. >>

During evaluation of In[1]:= y::trace: y --> 64. >>

During evaluation of In[1]:= x::trace: x --> 9. >>

During evaluation of In[1]:= Times::trace: y x --> 64 9. >>

During evaluation of In[1]:= Times::trace: 64 9 --> 576. >>

During evaluation of In[1]:= x::trace: x --> 9. >>

During evaluation of In[1]:= Power::trace: x^2 --> 9^2. >>

During evaluation of In[1]:= Power::trace: 9^2 --> 81. >>

During evaluation of In[1]:= Set::trace: y=x^2 --> y=81. >>

During evaluation of In[1]:= Set::trace: y=81 --> 81. >>

During evaluation of In[1]:= List::trace: {y x,y=x^2} --> {576,81}. >>

During evaluation of In[1]:= y::trace: y --> 81. >>

During evaluation of In[1]:= x::trace: x --> 10. >>

During evaluation of In[1]:= Times::trace: y x --> 81 10. >>

During evaluation of In[1]:= Times::trace: 81 10 --> 810. >>

During evaluation of In[1]:= x::trace: x --> 10. >>

During evaluation of In[1]:= Power::trace: x^2 --> 10^2. >>

During evaluation of In[1]:= Power::trace: 10^2 --> 100. >>

During evaluation of In[1]:= Set::trace: y=x^2 --> y=100. >>

During evaluation of In[1]:= Set::trace: y=100 --> 100. >>

During evaluation of In[1]:= List::trace: {y x,y=x^2} --> {810,100}. >>

During evaluation of In[1]:= Table::trace: Table[{y x,y=x^2},{x,1,10}] --> {{y,1},{2,4},{12,9},{36,16},{80,25},{150,36},{252,49},{392,64},{576,81},{810,100}}. >>

During evaluation of In[1]:= y::trace: y --> 100. >>

During evaluation of In[1]:= List::trace: {y,1} --> {100,1}. >>

During evaluation of In[1]:= List::trace: {{y,1},{2,4},{12,9},{36,16},{80,25},{150,36},{252,49},{392,64},{576,81},{810,100}} --> {{100,1},{2,4},{12,9},{36,16},{80,25},{150,36},{252,49},{392,64},{576,81},{810,100}}. >>

Out[2]= {{100, 1}, {2, 4}, {12, 9}, {36, 16}, {80, 25}, {150,
36}, {252, 49}, {392, 64}, {576, 81}, {810, 100}}[/no][/more]

Добавлено:

Цитата:

Глядя на функциональный язык математики, интересно, можно ли в итерации изнутри списка сослаться на текущее (Evaluated) значение другого элемента этого же списка?

Можно, если этот элемент выполняется раньше - думаю, после моих примеров это должно быть очевидно.

TomasVercetti
Нужно ввести локальную переменную с помощью Module, With или Block, в которой и хранить текущее значение f1[x]. Вариант с Module наиболее универсален:
Plot[Module[{f1x=f1[x]}, {f1x, f2[ f1x, x ], f3[ f1x, x ]}], {x, xmin, xmax}]

popkov,

Цитата:

думаю, после моих примеров это должно быть очевидно.

Что через локальную переменную можно - да, очевидно. А вот что-нибудь наподобие Plot[ {f1[x], f2[ @1, x ], f3[ @1, x ]}, {x, xmin, xmax} ], где я за "@1" условно обозначил текущее значение первого элемента?

Griefin,
Я именно так и сделал вначале, но Plot строит все графики одним цветом, и через PlotStyle также устанавливается цвет на все графики сразу.

TomasVercetti

Цитата:

где я за "@1" условно обозначил текущее значение первого элемента?

Пожалуй, я не настолько ас, чтобы дать ответ. Вполне вероятно, для реализации твоей затеи надо переопределять функцию Plot... В общем, блатные разработчики новой Mathematica далеко не всё способны оказались предусмотреть...

TomasVercetti
Plot, как и Table, использует Block для формирования массива точек. Block делает Hold на все аргументы, это нужно отменить с помощью Evaluate, чтобы Plot видел массив функций и корректно определял его размерность.

Plot[Evaluate[Module[{f1x=f1[x]}, {f1x, f2[ f1x, x ], f3[ f1x, x ]}]], {x, xmin, xmax}]

popkov,
либо, в свете значительного расширения возможностей языков ФП в последние годы, им нужно снова обратить свой взор на дальнейшее развитие такового, либо-таки дополнить документацию, либо исправить баги в некоторых функциях...

Griefin,
да - так работает.

All,
но я запутался : )

Вот это понятно:

(1)
Plot[ { f1[x] }, {x, xmin, xmax}, PlotPoints->10, MaxRecursion->0 ] // Timing
Plot[ { f2[ "число", x ] }, {x, xmin, xmax}, PlotPoints->10, MaxRecursion->0 ] // Timing
Plot[ { f3[ "число", x ]}, {x, xmin, xmax}, PlotPoints->10, MaxRecursion->0 ] // Timing

12.656
0.407
0.141
---------

(2)
Plot[ { f1[x] }, {x, xmin, xmax}, PlotPoints->10, MaxRecursion->0 ] // Timing
Plot[ { f2[ f1[x] , x ] }, {x, xmin, xmax}, PlotPoints->10, MaxRecursion->0 ] // Timing
Plot[ { f3[ f1[x] , x ]}, {x, xmin, xmax}, PlotPoints->10, MaxRecursion->0 ] // Timing

11.813
12.046
11.703
---------

(3)
Plot[ { f1[x], f2[ f1[x] , x ], f3[ f1[x] , x ] }, {x, xmin, xmax}, PlotPoints->10, MaxRecursion->0 ] // Timing

35.421
---------

Вот это непонятно:

(4)
Plot[Module[{f1x=f1[x]}, {f1x, f2[ f1x, x ], f3[ f1x, x ]}], {x, xmin, xmax}, PlotPoints->10, MaxRecursion->0 ] // Timing

34.718
---------

(5)
Plot[Evaluate[Module[{f1x=f1[x]}, {f1x, f2[ f1x, x ], f3[ f1x, x ]}]], {x, xmin, xmax}, PlotPoints->10, MaxRecursion->0 ] // Timing

110.219
---------

Видимо какие-то внутренние оптимизации нарушаются из-за Evaluate. Если Mathematica сама успешно кэширует и подставляет результат вычисления f1[x], то стоит оставить вариант без Module.

Как я понимаю, успешно было бы порядка 12.656 + 0.407 + 0.141 секунд (первый пример). А из 2го, 3го и 4го видно, что Module "игнорируется".

Друзья, пакет гомеза (quantum) с дираковской нотацией кто-нибудь использовал? Есть ли ему альтернатива с точки зрения работы с кетами?

Да, еще, как записать выражение | <a|M|b> |^2
в традиционной нотации, чтобы закрывающий знак модуля был такого же размера как и открывающий (математика напрямую не дает этого делать, хочет либо скобки, либо Abs[], что неприемлемо с эстетической точки зрения). Конструкции типа Abs[x]^2 равно как и (Abs[x])^2 выглядят неуклюже. Формулы подразумеваются не вычисляемые, а "мертвые", так сказать повествовательные...

eriik,
По поводу нотаций. Palettes -> Special Characters -> Symbols -> 'x', там будут внизу Left/Right AngleBracket и BracketingBar. Как я понимаю, они существуют специально для этого. По крайней мере - это самая лицеприятная запись подобных выражений, которую я нашёл.

TomasVercetti
Спасибо, супер, именно то что я искал! Все заработало. А с MatchingSingleVerticalLines что с палитры BasicMath выходило именно так как я описывал - при возведении в степень открывающая увличивается в размере, а закрывающая уменьшается, и как ни прыгай, ничего не изменить.

Интересно,
какие-нибудь издательства принимают к публикации статьи, целиком набранные в Mathematica©? Я имею в виду типа Physica Status Solidi, Journal of Chemical Physics, Advances in Quantum Chemistry, Journal of Physics, J. Noncryst. Solids, J.Lumin, Phys. Rev.(x) ?
Может, есть какие темплейты или стили, наподобие как для The Mathematica Journal (это единственные user styles, что я нашел в интернете). Встоенных маловато как-то...

eriik,

Насколько я помню, Wolfram Publicon имеет, кроме много чего ещё, встроенные стили Phys. Rev и Journal of Chemical Physics. И может цеплять стили LaTeX. Да и в Mathematica самому стили не так сложно писать - фактически, тот же css.

Цитата:

Интересно, какие-нибудь издательства принимают к публикации статьи, целиком набранные в Mathematica©? Я имею в виду типа...

Мне тоже интересно. Года полтора тому назад я их сайты смотрел - нельзя было.

так набирайте в математике, а потом экспорт в ТЕХ..

Народ, кто-нить 7.0.1 пробовал? что там реально вкусного добавили?

28111981,

Цитата:

Mathematica 7.0.1 includes more than 600 improvements, such as enhanced performance of image processing functions and integration with the upcoming release of gridMathematica Server. Other highlights of Mathematica 7.0.1:
Right-click menu for quick image manipulation
New tutorials, "How to" guides, and screencasts
Thousands of new examples in the documentation
Improved documentation search
Integration with mathematical handwriting-recognition features of Windows 7

Если что-то по вашему вкусу - пробуйте. : )

Очередной жуткий баг Mathematica 7 (и 7.0.1 тоже...):

[no]In[1]:= FullSimplify[n*Exp[-n*0.]]

Out[1]= n/2[/no]

"Весело"...

Добавлено:
Версия 5.2 выдаёт корректный ответ (кстати, не помню какая, но есть всё же опция, чтобы Mathematica считала "0." настоящим нулём):

[no]In[1]:= FullSimplify[n*Exp[-n*0.]]
Out[1]= \!\(\[ExponentialE]\^\(0.`\ n\)\ n\)[/no]

UPDATE:
Любопытно, как Andrzej Kozlowski прокомментировал этот баг:
Цитата:

Anyone who uses Simplify or FullSimplify with approximate numbers
fully deserves the consequences.

То есть, типа, Simplify и FullSimplify вообще нельзя использовать по отношению к выражениям, содержащим неточные (т.е. не целые и не рациональные) числа. Н-да... версия 5.2 почему-то не глючила...

Как в Mathematica (я пользуюсь 5 ой) оптимально вычислять несобственные интегралы? В Helpe не нашел ничего.

Цитата:

Очередной жуткий баг Mathematica 7 (и 7.0.1 тоже...):

In[1]:= FullSimplify[n*Exp[-n*0.]]

Out[1]= n/2

"Весело"...

Интересно, а можно как-нибудь включить трассировку функции FullSimplify и посмотреть какое правило было применено, чтобы получился такой результат?

egorovshura
Не знаю такого способа. Скорее всего, это доступно только в специальной "отладочной" версии Mathematica, которую используют сами разработчики.

2All
Кстати, вот ещё один (не столь жуткий) баг Simplify и FullSimplify (просто дисфункциональность): Mathematica почему-то не может упростить x^2/y^2 до (x/y)^2, даже если указать конкретную ComplexityFunction:

[no]In[1]:= Simplify[x^2/y^2, ComplexityFunction -> LeafCount]

Out[1]= x^2/y^2

In[2]:= LeafCount[Hold[x^2/y^2]]

Out[2]= 10

In[3]:= LeafCount[Hold[(x/y)^2]]

Out[3]= 8

И даже хуже (что уже совсем непонятно):

In[5]:= Simplify[(x/y)^2, ComplexityFunction -> LeafCount]

Out[5]= x^2/y^2

Однако в наиболее общем случае поведение становится "половинчато верным":

In[12]:= Simplify[(x/y)^n, ComplexityFunction -> LeafCount]

Out[12]= (x/y)^n

In[15]:= Simplify[x^n/y^n, ComplexityFunction -> LeafCount]

Out[15]= x^n y^-n[/no]

Баг присутствует как в верси 5.2, так и в версии 7.0.1.

Добавлено:
Только что пришла в голову слабая догадка.
Дело в том, что в 6-й (лишь только для указананного ниже случая) и окончательно в 7-й версии Mathematica исправлена недоработка функции FullSimplify, из-за которой она не могла упростить, например, такое выражение:

In[8]:= Simplify[2*4^z-4^z]
Out[8]= 2^(1 + 2 z) - 4^z
(это в Mathematica 5.2)

В 7.0.1 все подобные выражения упрощаются корректно:

[no]In[5]:= Table[{2*m^z-m^z,FullSimplify[2*m^z-m^z]},{m,1,21}]//TableForm
Out[5]//TableForm= [/no]
1 1