Как заставить команды в Mathematica 8 использовать все ядра?

Question

Многие команды в Mathematica 8 (Integrate , Simplify и т.д.), Похоже, используют только одно ядро в моей системе. Можно ли как-то изменить сродство, чтобы оно использовало все ядра для вычислений?

Answer 1

Из раздела Распараллелить в разделе Примеры> Возможные проблемы:

Выражения, которые нельзя распараллелить, оцениваются как обычно:

Parallelize[Integrate[1/(x - 1), x]]

Answer 2

Как упоминалось в других вопросах и комментариях, такие вещи, как Integrate и Simplify было бы очень трудно распараллелить, поэтому Mathematica возвращает сообщение Parallelize::nopar1 и продолжает «с последовательной оценкой».

(Хотя, если подумать , возможно, что FullSimplify можно было бы распараллелить, поскольку он в основном работает, пробуя множество различных правил и делая для них листовые счета ...)

Если у вас есть много интегралов или упрощений, то вы можете использовать ParallelTable или ParallelMap т. Д ...

В качестве тривиального примера, если у вас есть подынтегральные

In[1]:= ints = Table[x^n, {n, 1, 10}]
Out[1]= {x, x^2, x^3, x^4, x^5, x^6, x^7, x^8, x^9, x^10}

Вы можете использовать ParallelTable

In[2]:= ParallelTable[Integrate[int, x], {int, ints}]
Out[2]= {x^2/2, x^3/3, x^4/4, x^5/5, x^6/6, x^7/7, x^8/8,\ 
         x^9/9, x^10/10, x^11/11}

или ParallelMap

In[3]:= ParallelMap[Integrate[#, x] &, ints]
Out[3]= {x^2/2, x^3/3, x^4/4, x^5/5, x^6/6, x^7/7, x^8/8,\  
         x^9/9, x^10/10, x^11/11}

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

---

Редактировать в ответ на комментарии

Учитывая действительно грязный интеграл, который интересует OP (обратите внимание: вы должны действительно упростить свои результаты по ходу работы!), Вот некоторый код, который разбивает интеграл на сумму мономов и выполняет интегралы с использованием ParallelDo .

Сначала мы импортируем интеграл из пастбина

In[1]:= import = Import["http://pastebin.com/raw.php?i=JZ0CXewJ", "Text"];

извлечь домен интеграции

In[2]:= intLimits = Rest@(2 Pi^5 ToExpression[StringReplace[import, "Integrate" -> "List"]])
        vars = intLimits[[All, 1]];

Out[2]= {{\[Theta]3, 0, 2*Pi}, {\[Theta]2, 0, 2*Pi}, 
         {\[Theta]1, 0, 2*Pi}, {\[CurlyPhi]2, 0, Pi/2}, {\[CurlyPhi]1, 0, Pi/2}}

и подынтегральное выражение, которое представляет собой сумму 21 чудовищных членов

In[4]:= integrand = First@(2 Pi^5 ToExpression[StringReplace[import, "Integrate" -> "Hold"]]);
        Length[integrand]
        LeafCount[integrand]

Out[5]= 21
Out[6]= 48111

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

In[7]:= (fns=Union[vars, Cases[integrand, (Cos|Sin|Tan|Sec|Csc|Cot)[x_]/;!FreeQ[x,Alternatives@@vars],Infinity]])//Timing
Out[7]= {0.1,{\[Theta]1, <snip> ,Tan[\[CurlyPhi]2]}}

Найдем (13849 неисчезающих) коэффициентов мономов, построенных из fns

In[8]:= coef = CoefficientRules[integrand, fns]; // Timing
         Length@coef

Out[8]= {35.63, Null}
Out[9]= 13849

Убедитесь, что все коэффициенты не содержат переменных интегрирования

In[10]:= FreeQ[coef[[All, 2]], Alternatives@@vars]
Out[10]= True

Обратите внимание, что мы можем на самом деле очистить коэффициенты с помощью Factor или Simplify и уменьшить ByteSize примерно в 5 раз ... Но поскольку интегралы большинства мономов равны нулю, мы могли бы также оставить упрощения до самого конца.

Вот как вы восстанавливаете моном, интегрируете его и рекомбинируете с его коэффициентом, например, 40-й моном дает неисчезающий интеграл:

In[11]:= monomialNum=40;
         Times@@(fns^coef[[monomialNum,1]])
         Integrate[%, Sequence@@intLimits]
         coef[[monomialNum,2]] %//Factor
Out[12]= \[Theta]1 Cos[\[Theta]1]^2 Cos[\[CurlyPhi]1]^4 Cos[4 \[CurlyPhi]1] Cos[\[CurlyPhi]2]^4 Cos[2 \[CurlyPhi]2] Sin[\[Theta]1]^2
Out[13]= \[Pi]^6/256
Out[14]= -((k1^2 (k1-k2) (k1+k2) (-2+p) p^3 \[Pi]^6 \[Sigma]^4)/(131072 \[Omega]1))

А пока я уменьшу количество терминов, поскольку все интегралы на моем двухъядерном ноутбуке будут длиться вечно. Удалите или закомментируйте следующую строку, если вы хотите оценить весь набор интегралов

In[15]:= coef = RandomChoice[coef, 100];  (* Delete me!! *)

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

In[16]:= SetSharedVariable[ints]
         ints = ConstantArray[Null, Length@coef];

Как мы выполняем интегралы, Print Num: {синхронизации, результат} для каждого мономиальных интегрирована. CellLabel каждой напечатанной ячейки говорит вам, какое ядро сделало интеграл. Печать может раздражать - если она вас раздражает, замените Print на PrintTempory или ##& . Вы также можете отслеживать вычисления, используя динамическую переменную некоторого вида: например, индикатор выполнения .

ParallelDo[Print[c, ": ", Timing[
            ints[[c]] = Integrate[Times@@(fns^coef[[c,1]]), Sequence@@intLimits]]], 
           {c, Length@coef}]

Объединить с их коэффициентами

1/(2 Pi^5) Simplify[ints.coef[[All, 2]]]

И (надеюсь) это так!