Избегайте повторных вызовов в Интерполяцию - PullRequest
Новая
       13

Избегайте повторных вызовов в Интерполяцию

8 голосов
/ 16 октября 2011

Я хочу интерполировать функцию в Mathematica.

Функция зависит от параметра 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]! Как бы мне этого избежать?

Спасибо за чтение.

Ответы [ 3 ]

12 голосов
/ 16 октября 2011

Первый шаг заключается в параметризации 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, используя памятку: 

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:

Лучший способ построить функцию с памятью

Динамическое программирование в Mathematica: как автоматически локализовать и / или очистить определения запомненной функции

6 голосов
/ 16 октября 2011

Вы можете использовать определение 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] просто чтобы прояснить, что определение Интерполяции кэшируется для каждого 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}]
]
6 голосов
/ 16 октября 2011

Попробуйте что-нибудь вроде этого: 

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.

...