Функция функции

Question

Скажите, у меня есть какая-то функция f[a_,b_,c_]=a+b+c. Теперь мне нужно определить другую функцию, g[f_,d_]=f+d, где f здесь должно быть заменено определением f, в результате чего a+b+c+d.

Как мне это сделать? Я попробовал g[f_,d_]=f+d/.f->Definition[f], но это не сработало.

Answer 1

Итак, ваша установка требует, чтобы g был функцией от a, b и c, поскольку вы явно сделали функцию f их. Может вместо этого сделать:

f[a_,b_,c_]=a+b+c;

g[f_,a_,b_,c_,d_] = f[a,b,c]+d

Out [2] = a + b + c + d

Даниэль Лихтблау

Answer 2

Просто примечание.

Все это имеет больше смысла, когда обе функции имеют одинаковые аргументы или аргументы для второй функции неявны в первой.

Например:

f[x_] := 1 + 1/x;

g[h_, x_] := h[x]^x;

Limit[g[f, x], x -> +Infinity]  
-> E

Или что-то вроде

f[x_] := EuclideanDistance[x, #] &

g[f_, x_] := If[f[2 x]@x < 3, x, 2 x]

g[f, 3]
->6

g[f,2]
->2

Answer 3

В определении

 f[a_, b_, c_] := a+b+c

посмотрите на a, b и c как первый , второй и третий аргумент при вызове функции и символы NOT a, b или c. Как и в f := (#1 + #2 + #3)&, вызов самого f (без аргументов) не даст желаемых результатов.

Возможно, вы хотели сделать что-то вроде этого:

f := a+b+c

Теперь f ассоциируется как сумма a, b и c, которые являются глобальными символами, а не аргументами функций. Тогда,

f+d

даст a + b + c + d, и вы можете использовать ReplaceAll (или /.) для замены:

f + d /. a->2x

дает b+c+d+2x. 2 f даст 2 (a+b+c), Sin[f] даст Sin[a+b+c], f-c даст a+b и т.д ...

Answer 4

Мне также трудно понять ваше намерение, но это моя интерпретация:

f[a_, b_, c_] := a + b + c
g[f_, d_] := f[##] + d &;

g[f, 3]

  (* Out=  f[##1] + 3 &     *)

%[q, r, s]

  (* Out=  3 + q + r + s    *)

g[f, 5][1, 2, 3]

  (* Out=  11    *)

Таким образом, g[f, x] возвращает функцию, которая передает свои аргументы f.

Answer 5

Ответ Даниэля правильный - он отвечает на то, что должен был задать ваш вопрос!

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

f[a_,b_,c_] := a + b + c

g[f_, d_] := Catch[Module[{dv},
  Check[dv = DownValues[f], Throw[$Failed], {DownValues::sym}];
  Switch[Length[dv],
         0, Print["No DownValues"]; $Failed,
         1, dv[[1, 2]] + d,
         _?(# > 1 &), Print["More than one DownValue - using the first!"]; 
                      dv[[1, 2]] + d,
         _, Print["huh?!"]; $Failed]]]

протестируйте его:

In[3]:= g[f, d]
Out[3]= a + b + c + d

Определите другую функцию:

ff[a_, b_, c_] := a b c

In[5]:= g[ff, d]
Out[5]= a b c + d

и дайте ему второе определение:

In[6]:= ff[a_, b_] := a + b
In[7]:= DownValues[ff]
Out[7]= {HoldPattern[ff[a_,b_,c_]] :> a b c, HoldPattern[ff[a_,b_]] :> a+b}

In[8]:= g[ff, d]
During evaluation of In[8]:= More than one DownValue - using the first!
Out[8]= a b c + d

Конечно, тот факт, что вы не передаете никаких аргументов f в g[f_,d_], сделает (в большинстве случаев) этот типвещь довольно бессмысленная ...