Цикл ForEach в Mathematica

Я опоздал на вечеринку на несколько лет, и это, возможно, скорее ответ на «мета-вопрос», но многие люди поначалу испытывают затруднения, когда программирование на Mathematica (или других функциональных языках) приближается к проблеме из функциональной, а не структурной точки зрения. Язык Mathematica имеет структурные конструкции, но по своей сути он функционален.

Рассмотрим ваш первый пример:

ForEach[i_, {1,2,3},
  Print[i]
]

Как отметили несколько человек, функционально это может быть выражено как Scan[Print, {1,2,3}] или Print /@ {1,2,3} (хотя по возможности следует отдавать предпочтение Scan, а не Map, как объяснялось ранее, но иногда это может раздражать, поскольку для Scan нет инфиксного оператора).

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

ForEach[{i_, j_}, {{1,10}, {2,20}, {3,30}},
  Print[i*j]
]

... что более интересно с функциональной точки зрения.

Одним из возможных функциональных решений является использование замены списка, например:

In[1]:= {{1,10},{2,20},{3,30}}/.{i_,j_}:>i*j
Out[1]= {10,40,90}

... но если бы список был очень большим, это было бы излишне медленным, поскольку мы делаем так называемое «сопоставление с образцом» (например, ищем экземпляры {a, b} в списке и присваиваем их i и j) без необходимости.

Учитывая большой массив из 100 000 пар, array = RandomInteger[{1, 100}, {10^6, 2}], мы можем посмотреть на некоторые тайминги:

Замена правила выполняется довольно быстро:

In[3]:= First[Timing[array /. {i_, j_} :> i*j;]]
Out[3]= 1.13844

... но мы можем сделать немного лучше, если воспользуемся структурой выражения, в которой каждая пара действительно List[i,j], и применим Times в качестве заголовка каждой пары, превратив каждое {i,j} в Times[i,j]:

In[4]:= (* f@@@list is the infix operator form of Apply[f, list, 1] *)
    First[Timing[Times @@@ array;]]
Out[4]= 0.861267

Как используется в реализации ForEach[...] выше, Cases явно неоптимален:

In[5]:= First[Timing[Cases[array, {i_, j_} :> i*j];]]
Out[5]= 2.40212

... так как Cases выполняет больше работы, чем просто замена правила, необходимо построить вывод совпадающих элементов один за другим. Оказывается, мы можем сделать намного лучше, разложив задачу по-другому и воспользовавшись тем фактом, что Times равно Listable и поддерживает векторизованную операцию.

Атрибут Listable означает, что функция f будет автоматически обрабатывать любые аргументы списка:

In[16]:= SetAttributes[f,Listable]
In[17]:= f[{1,2,3},{4,5,6}]
Out[17]= {f[1,4],f[2,5],f[3,6]}

Итак, поскольку Times равно Listable, если бы вместо этого у нас были пары чисел в виде двух отдельных массивов:

In[6]:= a1 = RandomInteger[{1, 100}, 10^6];
        a2 = RandomInteger[{1, 100}, 10^6];

In[7]:= First[Timing[a1*a2;]]
Out[7]= 0.012661

Вау, немного быстрее! Даже если ввод не был предоставлен как два отдельных массива (или у вас более двух элементов в каждой паре), мы все равно можем сделать что-то оптимальное:

In[8]:= First[Timing[Times@@Transpose[array];]]
Out[8]= 0.020391

Мораль этой эпопеи не в том, что ForEach не является ценной конструкцией вообще или даже в Mathematica, а в том, что вы часто можете получить те же результаты более эффективно и изящно, если работаете с функциональным, а не структурным мышлением. .

Более новые версии Mathematica (6.0+) имеют обобщенные версии Do[] и Table[], которые почти точно делают то, что вам нужно, используя альтернативную форму аргумента итератора. Например,

Do[
  Print[i],
  {i, {1, 2, 3}}]

точно такой же, как твой

ForEach[i_, {1, 2, 3,},
  Print[i]]

В качестве альтернативы, если вам действительно нравится конкретный синтаксис ForEach, вы можете создать функцию HoldAll, которая его реализует, например:

Attributes[ForEach] = {HoldAll};

ForEach[var_Symbol, list_, expr_] :=
  ReleaseHold[
    Hold[
      Scan[
        Block[{var = #},
         expr] &,
      list]]];

ForEach[vars : {__Symbol}, list_, expr_] :=
  ReleaseHold[
    Hold[
      Scan[
        Block[vars,
          vars = #;
          expr] &,
      list]]];

Здесь в качестве имен переменных используются символы, а не шаблоны, но именно так работают различные встроенные управляющие структуры, такие как Do[] и For[].

Функции HoldAll[] позволяют создавать довольно широкий спектр пользовательских структур управления. ReleaseHold[Hold[...]] — обычно самый простой способ собрать кучу кода Mathematica для последующего вычисления, а Block[{x = #}, ...]& позволяет привязать переменные в теле выражения к любые значения, которые вы хотите.

В ответ на вопрос dreeves ниже вы можете изменить этот подход, чтобы разрешить более произвольную деструктуризацию с использованием DownValues ​​​​уникального символа.

ForEach[patt_, list_, expr_] := 
  ReleaseHold[Hold[
     Module[{f}, 
       f[patt] := expr; 
       Scan[f, list]]]]

На данный момент, однако, я думаю, вам лучше создать что-то поверх кейсов.

ForEach[patt_, list_, expr_] :=
  With[{bound = list},
    ReleaseHold[Hold[
       Cases[bound,
         patt :> expr]; 
       Null]]]

Мне нравится делать Null явным, когда я подавляю возвращаемое значение функции. EDIT: я исправил ошибку, указанную ниже; Мне всегда нравится использовать With для интерполяции оцененных выражений в Hold* формы.

Встроенная функция Scan в основном делает это, хотя и уродливее:

    Scan[Print[#]&, {1,2,3}]

Это особенно уродливо, когда вы хотите деструктурировать элементы:

    Scan[Print[#[[1]] * #[[2]]]&, {{1,10}, {2,20}, {3,30}}]

Следующая функция позволяет избежать уродства, преобразовывая pattern в body для каждого элемента list.

SetAttributes[ForEach, HoldAll];
ForEach[pat_, lst_, bod_] :=  Scan[Replace[#, pat:>bod]&, Evaluate@lst]

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

PS: Принятый ответ побудил меня переключиться на это, что я использую с тех пор, и, похоже, он отлично работает (за исключением оговорки, которую я добавил к вопросу):

SetAttributes[ForEach, HoldAll];             (* ForEach[pattern, list, body]   *)
ForEach[pat_, lst_, bod_] := ReleaseHold[    (*  converts pattern to body for  *)
  Hold[Cases[Evaluate@lst, pat:>bod];]];     (*   each element of list.        *)

Встроенная функция Map делает именно то, что вам нужно. Его можно использовать в длинной форме:

Карта[Печать, {1,2,3}]

или сокращенно

Печать / @ {1,2,3}

Во втором случае вы должны использовать "Print[Times@@#]&/@{{1,10}, {2,20}, {3,30}}"

Я бы порекомендовал прочитать справку Mathematica по Map, MapThread, Apply и Function. К ним можно немного привыкнуть, но как только вы это сделаете, вы никогда не захотите вернуться!

Вот небольшое улучшение, основанное на последнем ответе dreeves, которое позволяет указать шаблон без пробела (что делает синтаксис похожим на другие функции, такие как Table или Do) и использует аргумент уровня Cases

SetAttributes[ForEach,HoldAll];
ForEach[patt_/; FreeQ[patt, Pattern],list_,expr_,level_:1] :=
   Module[{pattWithBlanks,pattern},
      pattWithBlanks = patt/.(x_Symbol/;!MemberQ[{"System`"},Context[x]] :> pattern[x,Blank[]]);
      pattWithBlanks = pattWithBlanks/.pattern->Pattern;

      Cases[Unevaluated@list, pattWithBlanks :> expr, {level}];
      Null
   ];

Тесты:

ForEach[{i, j}, {{1, 10}, {2, 20}, {3, 30}}, Print[i*j]]
ForEach[i, {{1, 10}, {2, 20}, {3, 30}}, Print[i], 2]

В Mathematica есть функции отображения, поэтому, допустим, у вас есть функция Funcпринимающая один аргумент. Тогда просто напиши

Func /@ list

Print /@ {1, 2, 3, 4, 5}

Возвращаемое значение представляет собой список функций, примененных к каждому элементу в списке.

PrimeQ /@ {10, 2, 123, 555}

вернется {False,True,False,False}

Благодаря Pillsy и Леонид Шифрин, вот что я сейчас использую:

SetAttributes[each, HoldAll];               (* each[pattern, list, body]      *)
each[pat_, lst_List, bod_] :=               (*  converts pattern to body for  *)
  (Cases[Unevaluated@lst, pat:>bod]; Null); (*   each element of list.        *)
each[p_, l_, b_] := (Cases[l, p:>b]; Null); (* (Break/Continue not supported) *)