Я хочу интерполировать функцию в математике.
Функция зависит от параметра a, на самом деле это обратная функция F, которая также зависит от a, поэтому я строю свое приближение следующим образом:
approx = Interpolation[Table[{F[0.1 n, a], 0.1 n}, {n, -100, 100}]]
теперь я могу просто вызвать approx[x] для оценки обратной функции в точке.
Вместо этого я хотел бы сделать что-то вроде этого: Определить функцию, которая принимает параметр,
G[x_,a_] = "construct the interpolating function,
and return the value of the function at x"
Затем запишите G [x, a] для оценки функции. В противном случае мне пришлось бы повторить интерполяцию для всех параметров, которые меня интересуют, и вокруг них много переменных. Я попытался поместить вызов Interpolation [] внутри модуля, но он просто конструирует интерполяцию каждый раз, когда я называю G [x, a]! Как мне избежать этого?
Спасибо за чтение.
Попробуйте что-то в этом направлении:
G[a_]:=G[a]=Interpolation[Table[{F[0.1 n, a], 0.1 n}, {n, -100, 100}]]
G[0.2] (* particular value of G[a] *)
G[0.2][0.3] (* the value you want *)
Вы оцениваете только G при первом вызове для каждого конкретного значения a.
Первым шагом является параметризация approx с помощью a:
approx[a_] := Interpolation[Table[{F[0.1 n,a],0.1 n},{n,-100,100}]]
С помощью этого определения G можно определить таким образом:
G[x_, a_] := approx[a][x]
Но, как замечено в вопросе, это заканчивает реконструкцию интерполяции каждый раз, когда вызывается G. Один из способов избежать этого - переопределить approx с помощью memoization:
m: approx[a_] := m = Interpolation[Table[{F[0.1 n,a],0.1 n},{n,-100,100}]]
Теперь approx сохранит функцию интерполяции для любого заданного a, избегая реконструкции в последующих вызовах с тем же a. Конечно, это использует память, поэтому, если имеется большое количество различных значений a, тогда память может работать коротко. Локализовать кеш, используемый approx, можно локализовать, связав сохраненные значения с другим символом (cache в этом случае):
approx[a_] := cache[a] /.
_cache :> (cache[a] = Interpolation[Table[{F[0.1` n,a],0.1` n},{n,-100,100}]])
С помощью этой версии approx, cache можно локализовать, используя Block, например:
Block[{cache}
, Table[G[x, a], {x, 0, 5}, {a, 0, 1, 0.1}]
]
Функции интерполяции по-прежнему временно сохраняются для каждого отдельного значения a, но теперь эти сохраненные определения освобождаются после выхода Block.
Для получения дополнительной информации о функциях с памятью в Mathematica см. вопросы SO:
Вы можете использовать определение CacheIndex, которое я разместил в Что входит в сумку для инструментов Mathematica?. Одна из хороших особенностей использования этой функции заключается в том, что вы можете кэшировать значения или части кода без необходимости определять новую функцию (хотя мы здесь, чтобы соответствовать этому примеру).
G[x_,a_] :=
CacheIndex[a,
Pause[3];
Interpolation[Table[{F[0.1 n,a],0.1 n},{n,-100,100}]]
][x];
Я добавил Pause [3], чтобы дать понять, что определение Interpolation кэшируется для каждого a после того, как оно было вычислено один раз.
Затем вы можете удалить кешированные значения интерполяции в CacheIndex, используя
DeleteCachedValues[CacheIndex] (*or*)
DeleteCachedValues[CacheIndex,1].
Я адаптировал функции Cache и CacheIndex, чтобы сделать их совместимыми с идеей WReach использования отдельного символа, определенного в блоке. Здесь нет ничего практического, поскольку вам нужно определить атрибуты Hold для символа, используемого в качестве кеша, но идея все же интересна.
Вот определение CacheSymbol
SetAttributes[CacheSymbol,HoldAll];
CacheSymbol[cacheSymbol_,expr_]:=cacheSymbol[expr]/.(_cacheSymbol:>(cacheSymbol[expr]=expr));
Вы можете протестировать эту реализацию, используя следующие инструкции, в реальном примере кеш будет определен в блоке.
ClearAll[cache]
SetAttributes[cache,HoldFirst]
CacheSymbol[cache,Pause[3];2+2]
?cache
CacheSymbol[cache,Pause[3];2+2]
Вот определение CacheSymbolIndex
SetAttributes[CacheIndexSymbol,HoldAll];
CacheIndexSymbol[cacheSymbol_,index_,expr_]:=cacheSymbol[index,expr]/.(_cacheSymbol:>(cacheSymbol[index,expr]=expr));
Вы можете протестировать эту реализацию, используя следующие инструкции, в реальном примере кеш будет определен в блоке.
ClearAll[cache]
SetAttributes[cache,HoldRest]
CacheIndexSymbol[cache,2+2,Pause[3];2+2]
?cache
CacheIndexSymbol[cache,2+2,Pause[3];2+2]
и аналогично примеру WReach, мы имели бы
G[x_,a_] :=
CacheIndexSymbol[cache,a,
Print["Caching"];
Interpolation[Table[{F[0.1 n,a],0.1 n},{n,-100,100}]]
][x]
Block[{cache},
SetAttributes[cache,HoldRest];
Table[G[x, a], {x, 0, 5}, {a, 0, 1, 0.1}]
]