Evaluating Nested Anonymous Functions

Greetings,

I am having trouble using nested anonymous functions to return a Taylor series as a function handle. Below is the function I created to calculate the 2-variable Taylor series.

function [zeroth,first,second] = Taylor2(f,x0,y0)
    % This function calculates the second order Taylor expansion of a
    % 2-variable anonymous function. The zero-th and first order
    % approximations can also be extracted.

    zeroth = f(x0,y0);  % Zero-th order approximation

    % Define derivatives using Newton's difference quotient
    epsilon = 1e-8; 
    f1_x = @(x,y) (f(x+epsilon,y) - f(x,y)) / epsilon;
    f1_y = @(x,y) (f(x,y+epsilon) - f(x,y)) / epsilon;
    f2_x = @(x,y) (f1_x(x+epsilon,y) - f1_x(x,y)) / epsilon;
    f2_y = @(x,y) (f1_y(x,y+epsilon) - f1_y(x,y)) / epsilon;
    f2_xy = @(x,y) (f1_x(x,y+epsilon) - f1_x(x,y)) / epsilon;
 
    % First order approximation
    first = @(x,y) zeroth + (x-x0) * f1_x(x0,y0) + (y-y0) * f1_y(x0,y0);

    % Second order approximation
    second = @(x,y) first + 0.5 .* ((x-x0).^2 .* f2_x(x0,y0) + ...
        2 .* (x-x0) .* (y-y0) .* f2_xy(x0,y0) + (y-y0).^2 .* f2_y(x0,y0));
end

The trouble occurs at the first order approximation, where for an input function , x0 = 1 and y0 = 1, I would expect the result to be:

first =

  function_handle with value:

    @(x,y) 0.9048-0.0905*(x-1)-0.0905*(y-1)

But instead I get:

first =

  function_handle with value:

    @(x,y)zeroth+(x-x0)*f1_x(x0,y0)+(y-y0)*f1_y(x0,y0)

How can I force the evaluation of the nested anonmyous functions and input values? I've tried using eval and @ in various combinations with no luck, and I have not found the answer after a thorough Internet and MATLAB doc search.

Answer 1

[Jonathan Rasmussen]

Simple answer: No, MATLAB does not natively have the functionality I was seeking. However, I was able to get the results I desired by using syms:

% First order approximation
    syms x y
    first = zeroth + (x-x0) * f1_x(x0,y0) + (y-y0) * f1_y(x0,y0);

    % Second order approximation
    second = first + 0.5 .* ((x-x0).^2 .* f2_x(x0,y0) + ...
        2 .* (x-x0) .* (y-y0) .* f2_xy(x0,y0) + ...
        (y-y0).^2 .* f2_y(x0,y0));

However, I found that after calling the updated Taylor2.m function, the returned symbolic equation did not behave well with fprintf. To avoid a messy display of the expression, I had to set

sympref('FloatingPointOutput',true);

and just display the expression in the command window by calling the assigned variable.

Answer 2

[Steven Lord]

How do you get the anonymous function to display the coefficients (to four decimal places)? You don't, at least not without string manipulation and str2func. If you want this perhaps performing your calculations using the sym object from Symbolic Math Toolbox is a better option.

How do you get the anonymous function to evaluate the function correctly? Each anonymous function has a workspace where it stores the values of parameters (like zeroth, x0, and y0 in the case of your first function handle) for use when the anonymous function is evaluated. To confirm this call the functions function with one of your anonymous functions as input. Note that functions 1) does not allow you to modify those stored parameter values and 2) should be used for debugging and diagnostic purposes, not as part of your code's normal workflow (as stated on its documentation page.)

n = 3;
f = @(x) x.^n

f = function_handle with value:
    @(x)x.^n

clear n % does not affect the value f "remembers"
f(2) % 8

ans = 8

ws = functions(f)

ws = struct with fields:
            function: '@(x)x.^n'
                type: 'anonymous'
                file: '/tmp/Editor_ahhys/LiveEditorEvaluationHelperEeditorId.m'
           workspace: {[1×1 struct]}
    within_file_path: ''

ws.workspace{1}

ans = struct with fields:
    n: 3

[Jonathan Rasmussen]

I was trying to avoid using the Symbolic Toolbox, as I might not always have access to it. It's a shame that MATLAB doesn't provide a mechanism to evaluate nested anonymous functions like this. Seems like an intiutive capability to me. I do have access to the Symbolic Toolbox for now, so I will investigate that solution. But I would like to see if anyone else has other suggestions before accepting this answer.

[Steven Lord]

If one of your parameters were not a scalar but was instead a 1000-by-1000 matrix, do you really want the display of that anonymous function to expand out that matrix?

A = magic(1000);
f = @(x) A^x

f = function_handle with value:
    @(x)A^x

Also note that the function handle you've used as an example for your desired display is at best misleading. The coefficients are stored in full double precision, not to the four decimal places to which you have displayed them.

s2 = sqrt(2)

s2 = 1.4142

f1 = @(x) x*s2;
f2 = @(x) x*1.4142;
difference = f1(1e6)-f2(1e6) % Should this be 0? No.

difference = 13.5624

[Jonathan Rasmussen]

@Steven Lord, you are rebutting my comment with a non sequitur hypothetical. Obviously if MATLAB did have the functionality I was seeking, then displaying the anonymous function loaded w/ a big matrix would be undesirable. But there are already many ways that users can get undesirable outputs in MATLAB. Garbage in, garbage out, right?

As for your point about the double precision vs 4-decimal display, my desired expected result in the original post was merely an example. MATLAB already has the capability to change the output format of variables. If MATLAB had the functionality I was seeking, then I can imagine being able to change the precision of the anonymous function coefficients.

[Steven Lord]

No, I'm stating that the functionality you suggested was "intuitive" has wrinkles you hadn't considered. It's a common pattern (and not a bad one, just one that we at MathWorks need to realize and take into account): users tend to focus on what they need or want to do. MathWorks has to take into consideration not just what the user who asked for the feature wants to do but also how other users would want it to behave.

Now perhaps no user would want to display a 1000-by-1000 matrix as part of the anonymous function's display. But 10-by-10? 20-by-20? Those sound more reasonable to display in an expanded form but that would still be an awful lot of text to display. If we only display the expanded form of matrices up to a certain size, what's the threshold? Does that threshold depend on the size of your screen and/or the font you're using?

There's also a question of how much we would simplify your code. Why would we display it like this, as you showed:

@(x,y) 0.9048-0.0905*(x-1)-0.0905*(y-1)

instead of expanding out the multiplication and combining the constant terms to give this?

@(x,y) 1.0858-0.0905*x-0.0905*y

[This assumes you aren't going to call the anonymous function with data of a class that has overloaded the minus and/or mtimes operators. If you were this might not be a valid optimization depending on what those overloads do.]

At its most basic, I accept that this functionality you suggested should be part of MATLAB is intuitive. But as with most things, the devil is in the details.

Answer 3

[Walter Roberson]

I could (try to) write the function for you, given the following:

• The purpose of doing this shall be to create a readable version of the anonymous function that shall have exactly the same execution behavior as the non-readable version
• In order to have exactly the same execution behavior, every bound variable, shall be replaced by a full precision printable representation of the variable. There shall be no method provided to change the precision of the data because different precision would lead to different results but the purpose is to have exactly the same results in all cases.
• every bound variable shall be replaced in full every time it occurs. No provision for size limits shall be made. The purpose is to repair the deficiency that MATLAB does not already do all of this automatically all of the time, in a way that continues to generate exactly the same result
• every bound variable, converted to text form, shall return exactly the same value in the text form. Therefore all necessary casting of variable types shall be made. In particular, in order for single and uint64 and int64 to be certain of getting back the exact same result, if necessary, each distinct value may need to be wrapped in its type, like [single(3.891),single(-1.44)] . single and int64 and uint64 that are coded around individual values are interpreted by the parser, whereas single([3.891,-1.44]) results in the construction of a double precision vector that is converted to single at run time, which does not give the same results in all cases for the conversion of double to single (and which messes up badly for int64 and uint64)
• no abbreviations such as repmat or ones() shall be used, as those give a misleading idea of what the original code was.
• variables shall be expanded even if they are indexed. The code @(x)x+y(1)+y(2) shall expand y in both places. As you cannot immediately index the results of the list operators then there is a problem that either this needs to generate an error or else the result is going to have to be deceptive about what the user's code was
• multidimensional variables shall be handled. This is a small challenge because there is no direct syntax for entering multidimensional values. reshape() shall not be used, as that would give a misleading view of what the original code was. cat() of 2d arrays shall be used instead as that is the underlying operation for array construction
• complex values shall be handled. Complex multidimensional values with an all-zero imaginary part shall raise an error condition, as it is not possible to represent that in text without a misleading representation of the values by using a call to complex()
• negative zero shall be detected and represented, as they may be required for accurate representation of functionality (This rules out using mat2str, which does not preserve negative values)
• sparse arrays shall be converted into calls to sparse(), preserving the free-space encoded in the sparse array
• object oriented objects that are marked as not serializable shall generate an error message as those cannot be converted to text.
• in the first release, most object oriented objects will lead to an error message as an implementation limitation until such time as I might figure out how to create readable text representations of objects with hidden properties and dependent properties. This might prove to be quite difficult or even impossible in the general case
• in the first release, graphics objects based on uifigure shall not be handled, as I do not have sufficient experience with those.
• I do have experience in doing inspection of traditional graphic objects, so the first release might potentially be able to represent some graphic objects such as axes objects passed to plot() calls. However, the code involved is likely to be several thousand lines, and it might take me a couple of months to rescue from an old version (I had major disk corruption and lost recent backups). I would need to study the extent to which I can represent the graphics objects as text each time they occur and yet avoid duplication of the graphics object. For example, if an axes is passed into plot, the readable version of it designed to have exactly the same effect will need to call axes(), but can it do so without creating a new axes?? If the code has @(y)[plot(ax,x,sin(y),plot(ax,x,cos(x)] then when I expand the ax variable to fix the error that MATLAB only passes by name instead of value in the printable representation of the function handle, then can I avoid creating two copies of the axes?? I am not presently confident it can be done at all, let alone without misleading the user about what the code was.

[Walter Roberson]

In some cases, in order to represent complicated object oriented objects as text, because of private properties (only settable from within the class or sometimes within the same file as the class definition), it may be necessary to invoke a serialization method that produces something similar to a uuencoded character string, and have a call to a routine that converts the string back to an object. For example, str2obj('hsH48znHdhUQGK94Gjav') might have to appear in the code in order to recreate the object from text form. This would, however, be rather misleading about what the original code was. What is the solution here? Is the priority on the text version of the anonymous function reproducing the exact same result "through any means necessary", or is the priority on the text version not adding new calls beyond [] calls and type conversion so that the text version looks almost exactly like the original code?

[Walter Roberson]

• objects are capable of behaviour such as tracking the number of times that a method was invoked. However when an object is serialized to text that recreates the object, each occurrence is going to have to recreate with exactly the same counters, which implies that the hidden object changes from invoking an object method in one place cannot properly affect the other place. What is the specification of how this is to be dealt with?
• Consider an class that defined a C style pre-increment, a MATLAB implementation of the C expression ++x + x in which the second x refers to the already incremented value. MATLAB code might be x.preplusplus + x for example. When the anonymous function reference to the captured x is converted to a text representation of the object to repair this significant deficiency in representation of anonymous functions, the two x would each have to be replaced with code that creates the object from text... but the same object would be created in each case, and the second version would not be able to know that the first one changed the content. What is the specification for the case where the text version cannot reproduce the original behavior?

[Walter Roberson]

... So what is the specification for this facility?

• which numeric datatypes does it need to support?
• does it need support for arrays of more than 2d?
• does it need to support struct? Does it need to support non-scalar struct? does it need to support cell array? Does it need to support nested struct?
• does it need to support categorical? For categorical does it need to recreate the full set of categories, in order, not just the categories used in the subset? For categorical does it need to recreate knowledge of category aliases?
• does it need to support global variables ?
• does it need to support shared variables?
• does it need to support java objects?
• does it need to support objects? Does it need to support graphics objects? Does it need to support objects that have class properties? Does it need to support objects that have persistent variables? Does it need to support objects that have private methods? Does it need to support objects that have sealed methods? Does it need to support objects that have set methods that can change values in a way that cannot be replicated by calling the object constructor? Does it need to have logic to deduce the exact calling sequence of an object constructor to recreate an object that can be recreated by calling the constructor ?

[Walter Roberson]

To confirm: it is an axiom that the function handle fun, when invoked, should result in the exact same outputs being produced, but the captured value shared_object shall be replaced in the function handle by numeric values? And that even though it would obviously be exactly the same text being executed both times that fun() is executed, that shared_object shall be kept up-to-date? Keeping in mind that shared variables can only occur inside sealed workspaces, and that you cannot use assignin() or evalin() to change a variable in a sealed workspace?

testshared()

fun = function_handle with value:
    @()increment_mess(shared_object)+shared_object+increment_mess(shared_object)

input_object = 10

shared_object = 11

newvalue = 1011

input_object = 10

shared_object = 12

newvalue = 1012

result = 2033

input_object = 10

shared_object = 13

newvalue = 1013

input_object = 10

shared_object = 14

newvalue = 1014

result2 = 2037

shared_object = 14

function testshared()
   shared_object = 10;
   fun = @() increment_mess(shared_object) + shared_object + increment_mess(shared_object)
   result = fun()
   result2 = fun()
   shared_object
    function newvalue = increment_mess(input_object)
      input_object
      shared_object = shared_object + 1
      newvalue = input_object * 100 + shared_object
    end
end

[Jonathan Rasmussen]

...wow...you kinda made a mountain out of a mole-hill, but...thanks? I don't see how your code answers the question, and your comments are definitely information overload.

[Walter Roberson]

The code is not intended to answer the question: the code is part of a question of what your specification is .

You would like MATLAB to be able to convert anonymous functions with captured variables so that the values of the captured variables are explicit in the body of the function, instead of just showing the name of the variable.

Okay, we can potentially write that code for you. But first we need to know what the specifications are. What, exactly does the conversion function need to do?

I listed a bunch of questions at https://www.mathworks.com/matlabcentral/answers/1644275-evaluating-nested-anonymous-functions#comment_1975825 about what data types should be supported; if you could answer those, then we could get started on writing the code for you.

We will also need guideance as to the extend it is acceptable to interject new code in order for the converted function handle to have the exact same functionality as the original function handle. For example, if the code currently has

x(1) + y * x(2)

and x turns out to be a vector, then is it acceptable for the revised code to look like

subsref([3,17.3432423214121124,-3.1415926535897931,8,1.4142135623730951-1.5707963267948966j],struct('type','()','subs',1)) + y * subsref([3,17.3432423214121124,-3.1415926535897931,8,1.4142135623730951-1.5707963267948966j],struct('type','()','subs',2))

or is it acceptable if a new helper function (not written by you) were added in,

IndexAt([3,17.3432423214121124,-3.1415926535897931,8,1.4142135623730951-1.5707963267948966j],1) + y * IndexAt([3,17.3432423214121124,-3.1415926535897931,8,1.4142135623730951-1.5707963267948966j],2)

even though that could give the impression that you had coded the IndexAt call, when it is instead overhead added in to make the code work ?