Добавление функций

Question

Так что, как правило, если у вас есть две функции f, g: X -> Y, и если есть некоторая двоичная операция +, определенная для Y, то f + g имеет каноническое определение как функция x -> f ( х) + г (х).

Какой лучший способ реализовать это в Mathematica?

f[x_] := x^2
g[x_] := 2*x
h = f + g;
h[1]

выходы

(f + g)[1]

в качестве вывода

конечно,

H = Function[z, f[z] + g[z]];
H[1]

Выход '3'.

Answer 1

Рассмотрим:

In[1]:= Through[(f + g)[1]]

Out[1]= f[1] + g[1]

Чтобы уточнить, вы можете определить h следующим образом:

h = Through[ (f + g)[#] ] &;

Если у вас ограниченное количество функций и операндов, то UpSet в соответствии с рекомендациями yoda, безусловно, синтаксически чище. Тем не менее, Through является более общим. Без каких-либо новых определений, включающих Times или h, можно легко сделать:

i = Through[ (h * f * g)[#] ] &
i[7]

43218

Answer 2

Другой способ сделать то, что вы пытаетесь сделать, это использовать UpSetDelayed.

f[x_] := x^2;
g[x_] := 2*x;

f + g ^:= f[#] + g[#] &; (*define upvalues for the operation f+g*)

h[x_] = f + g;

h[z]

Out[1]= 2 z + z^2

Также см. этот очень хороший ответ от rcollyer (а также от Леонида и Вербеи), чтобы узнать больше о UpValues и когда их использовать

Answer 3

Я добавлю полный код для Грамма-Шмидта и пример для добавления функций и т. Д., Так как я случайно написал этот код около 4 лет назад.Хотя не тестировал экстенсивно.Я не изменил ни единой строчки этого сейчас, поэтому отказ от ответственности (в то время я был намного хуже в ММА).Тем не менее, вот реализация процедуры Грама - Шмидта, которая является немного обобщенной версией кода, который я обсуждал здесь :

oneStepOrtogonalizeGen[vec_, {}, _, _, _] := vec;

oneStepOrtogonalizeGen[vec_, vecmat_List, dotF_, plusF_, timesF_] := 
    Fold[plusF[#1, timesF[-dotF[vec, #2]/dotF[#2, #2], #2]] &, vec,  vecmat];

GSOrthogonalizeGen[startvecs_List, dotF_, plusF_, timesF_] := 
    Fold[Append[#1,oneStepOrtogonalizeGen[#2, #1, dotF, plusF, timesF]] &, {},  startvecs];

normalizeGen[vec_, dotF_, timesF_] := timesF[1/Sqrt[dotF[vec, vec]], vec];

GSOrthoNormalizeGen[startvecs_List, dotF_, plusF_, timesF_] := 
  Map[normalizeGen[#, dotF, timesF] &, GSOrthogonalizeGen[startvecs, dotF, plusF, timesF]];

Функции, описанные выше, параметризованы 3 функциями, реализуясложение, умножение на число и произведение точек в заданном векторном пространстве.Пример для иллюстрации будет найти Hermite полиномов путем ортонормирования одночленов.Это возможные реализации для трех необходимых нам функций:

hermiteDot[f_Function, g_Function] := 
   Module[{x}, Integrate[f[x]*g[x]*Exp[-x^2], {x, -Infinity, Infinity}]];

SetAttributes[functionPlus, {Flat, Orderless, OneIdentity}];
functionPlus[f__Function] :=   With[{expr = Plus @@ Through[{f}[#]]}, expr &];

SetAttributes[functionTimes, {Flat, Orderless, OneIdentity}];
functionTimes[a___, f_Function] /; FreeQ[{a}, # | Function] := 
      With[{expr = Times[a, f[#]]}, expr &];

Эти функции могут быть немного наивными, но они проиллюстрируют идею (и да, я также использовал Through).Вот несколько примеров, иллюстрирующих их использование:

In[114]:= hermiteDot[#^2 &, #^4 &]
Out[114]= (15 Sqrt[\[Pi]])/8

In[107]:= functionPlus[# &, #^2 &, Sin[#] &]
Out[107]= Sin[#1] + #1 + #1^2 &

In[111]:= functionTimes[z, #^2 &, x, 5]
Out[111]= 5 x z #1^2 &

Теперь основной тест:

In[115]:= 
results = 
  GSOrthoNormalizeGen[{1 &, # &, #^2 &, #^3 &, #^4 &}, hermiteDot, 
      functionPlus, functionTimes]

Out[115]= {1/\[Pi]^(1/4) &, (Sqrt[2] #1)/\[Pi]^(1/4) &, (
  Sqrt[2] (-(1/2) + #1^2))/\[Pi]^(1/4) &, (2 (-((3 #1)/2) + #1^3))/(
  Sqrt[3] \[Pi]^(1/4)) &, (Sqrt[2/3] (-(3/4) + #1^4 - 
  3 (-(1/2) + #1^2)))/\[Pi]^(1/4) &}

Это действительно правильно нормированные полиномы Эрмита, что легко проверить.Нормализация встроенного HermiteH отличается.Наши результаты нормированы, как если бы можно было бы нормализовать, скажем, волновые функции гармонического осциллятора.Получить список полиномов в виде выражений, зависящих от переменной, тривиально, скажем, x:

In[116]:= Through[results[x]]
Out[116]= {1/\[Pi]^(1/4),(Sqrt[2] x)/\[Pi]^(1/4),(Sqrt[2] (-(1/2)+x^2))/\[Pi]^(1/4),
(2 (-((3 x)/2)+x^3))/(Sqrt[3] \[Pi]^(1/4)),(Sqrt[2/3] (-(3/4)+x^4-3 (-(1/2)+x^2)))/\[Pi]^(1/4)}

.

Answer 4

Я бы предложил определить для этой цели оператор, отличный от встроенного Plus. Mathematica предоставляет ряд операторов, которые зарезервированы для пользовательских определений в таких случаях, как этот. Одним из таких операторов является CirclePlus, который не имеет заранее определенного значения, но который имеет хорошее компактное представление (по крайней мере, он компактен в записной книжке - не так компактен на веб-странице StackOverflow). Вы можете определить CirclePlus, чтобы выполнить добавление функции таким образом:

(x_ \[CirclePlus] y_)[args___] := x[args] + y[args]

Имея это определение, вы теперь можете выполнять добавление функции:

h = f \[CirclePlus] g;
h[x]
(* Out[3]= f[x]+g[x] *)

Если кому-то нравится жить на краю, тот же прием можно использовать со встроенным оператором Plus, если он сначала не защищен:

Unprotect[Plus];
(x_ + y_)[args___] := x[args] + y[args]
Protect[Plus];

h = f + g;
h[x]
(* Out[7]= f[x]+g[x] *)

Я бы вообще не советовал изменять поведение встроенных функций, особенно таких фундаментальных, как Plus. Причина в том, что нет гарантии, что добавленные пользователем определения к Plus будут соблюдаться другими встроенными функциями или функциями ядра. В некоторых случаях вызовы Plus оптимизируются, и эти оптимизации могут не учитывать пользовательские определения. Однако это соображение может не повлиять на какое-либо конкретное приложение, поэтому этот вариант все же остается допустимым, хотя и рискованным, выбором дизайна.