Documentation

memoize

Add memoization semantics to function handle

所有的页面崩溃

Memoizationis an optimization technique used to speed up programs by caching the results of expensive function calls and returning the cached result when the program is called with the same inputs.

Consider memoizing a function call if all of the following are true:

  • Performance is important.

  • The function is time consuming.

  • The function has return values that are determined entirely by the input values, and has no side effects.

  • System memory is adequate to store unique input and output combinations.

Syntax

memoizedFcn = memoize(fh)

Description

example

memoizedFcn = memoize(fh)adds memoization semantics to the input function handle, and returns aMemoizedFunction对象。InvokememoizedFcnas you would invokefh. However,memoizedFcnis not a function handle.

TheMemoizedFunctionobject maintains the cache of inputs and the corresponding outputs. When it is invoked, MATLAB®returns the associated cached output values if the following conditions are true.

  1. The input arguments are numerically equal to cached inputs. When comparing input values, MATLAB treatsNaNs as equal.

  2. The number of requested output arguments matches the number of cached outputs associated with the inputs.

The memoization of a function is associated with the input function and not with theMemoizedFunction对象。因此,保持跟进ing in mind.

  • Constructing a newMemoizedFunctionobject to the same function creates another reference to the same data. Two variables that memoize the same function share a cache and object property values, such as cache size. In the following example, the variablesaandbshare a cache and have the same value for cache size.

    a = memoize(@svd); b = memoize(@svd);
    Similarly, clearing the cache forb(b.clearCache) also clears the cache fora, and any other variables that memoize thesvdfunction.clearCacheis aMemoizedFunctionobject function.

  • Assigning aMemoizedFunctionobject to a new variable creates another reference to the same data. In the following example, the variablescanddshare data.

    c = memoize(@svd); d = c;

  • Clearing a variable does not clear the cache associated with the input function. To clear the cache for aMemoizedFunctionobject that no longer exists in the workspace, create a newMemoizedFunctionobject to the same function, and use theclearCachefunction on the new object. Alternatively, you can clear caches for allMemoizedFunctionobjects using theclearAllMemoizedCachesfunction.

    Caution:AMemoizedFunctionobject is not aware of updates to the underlying function. If you modify the function associated with the memoized function, clear the cache with theclearCacheobject function.

Examples

collapse all

Open Live Script

To speed up performing a singular value decomposition when you could be operating on the same inputs multiple times, memoize thesvdfunction.

fh = @svd; memoizedFcn = memoize(fh);

Create a matrix and cache the results of the singular value decomposition. Time the function call.

X = magic(1234); tic [U,S,V]= memoizedFcn(X); preCachedTime = toc
preCachedTime = 2.9070

Call the memoized function again using the same inputs. To observe the speed improvement using cached results, time the function call again.

tic [U,S,V]= memoizedFcn(X); postCachedTime = toc
postCachedTime = 0.1465
Open Live Script

In your current working folder, create a filecomputeNumberCombinations.mthat contains the following function to compute the number of combinations ofnitems takenkat a time.

typecomputeNumberCombinations.m
function c = computeNumberCombinations(n,k) % Calculate number of combinations of n items taken k at a time c = fact(n)/(fact(n-k)*fact(k)); end function f = fact(n) f = 1; for m = 2:n f = f*m; end end

Memoize thecomputeNumberCombinationsfunction to speed up computation for repeated input values.

fh = @computeNumberCombinations; memoizedFcn = memoize(fh);

Call the memoized function and time the function call. This function call caches the results for the specified inputs.

tic c = memoizedFcn(56,42); preCachedTime = toc
preCachedTime = 0.0862

Call the memoized function and time the function call again. This function call uses the cached results and does not execute the function.

tic c = memoizedFcn(56,42); postCachedTime = toc
postCachedTime = 0.0910

Input Arguments

collapse all

Function to memoize, specified as a function handle.

Example:memoizedEigs = memoize(@eigs)

Data Types:function_handle

Tips

  • Multiple calls tomemoizewith the same function handle return the sameMemoizedFunction对象。为example:

    x = memoize(@plus); y = memoize(@plus); x == y
    ans = logical 1

  • You should not memoize a function with side effects such as setting some global state or performing I/O operations. Side effects are not repeated on subsequent calls to the memoized function with the same inputs. For example, if you memoize therandifunction, the memoized function always returns the same value when called with the same input argument.

    fh = @randi; memoized_fh = memoize(fh); fh_result = [fh(100) fh(100) fh(100)] memoized_result = [memoized_fh(100) memoized_fh(100) memoized_fh(100)]
    fh_result = 18 71 4 memoized_result = 28 28 28

See Also

Functions

Using Objects

Introduced in R2017a

Was this topic helpful?
MATLAB Documentation
Other Documentation
金宝app

Try MATLAB, Simulink, and Other Products

Get trial now