@ceight1 Where did you get the function (x,y)->y and exp(x) from, in your attempt? How do you think that those relate to this example's differential equation? [Perhaps your instructor or your textbook used a previous example like that. But this example's differential equation involves a different right-hand side formula. It is not the differential equation y'(x)=y(x) here.]

Download HELP_CODE_ac.mw

Don't post this same problem more than once.

If you have followup queries of details for the example (in addition to the syntax issue with writing x*y(x) as xy) then put them in a Comment/Reply here.

Here's that other way (substitution into a template procedure, and nicer error message).

Download functionB_rev2.mw

@Maple_lover1 The interesting bit is making the first generated procedure (the first result from calling functionB) issue nice error messages if subsequently called with either n greater than the precomputed K or m greater than M-1.

I see two ways to accomplish that. The first (which I've done below) is have the n and m parameters be specified using the satisfies parameter-processing modifier. This is easier to code, although as you may see when there is a violation the error message is slightly awkward.

Another way (which I have not done here) is to substitute the piecewise into a template procedure that is coded to emit a more graceful error message. The piecewise itself can contain the protected global name equivalents for n,m,x after another substitution.

Download functionB_rev1.mw

By the way, how do you expect functionB to be used by someone? If it is to be invoked many times on-the-fly in the same session with (occasionally, or often) the exact same arguments then it might benefit performancewise to give option remember to functionB. (Ie, memoization)

@Maple_lover1 The reworking of the mechanisms to allow the old table=based orthopoly package to be used more like a module-based package is somewhat goofy. But then, so are table-based packages themseleves.

You could experiment with it done as follows:

FunctionC:=proc(k,M) local K,n,m,x;
uses O=orthopoly: 
    K:=2^(k-1);

    unapply(piecewise((n-1)/K <= x and x <= n/K,
            2^((k+1)/2)/sqrt(Pi)*O['':-H''](m,2^(k)*x-2*n+1), 0),
            [n,m,x])
  end proc:

Have a look at the output from a call like, say, FunctionC(3) and test it. (You may wish to stress-test against possibilities of the variable name H being previously assigned.) I don't much care for the procedure generated by the call orthopoly:-H(m,...) where m is an unassigned name.

There's no real difference between between w:=(x)->1; and w:=x->1; except for source tidiness and legibility.

I prefer to pass the independent variable names into unapply in a list, for clarity and legibility. I don't care for passing them as an unadorned sequence -- partially because unapply can also take some other option(s). If one's code has so many unapply calls that garbage collection of the extra list is even noticeable -- or if that list of variables is huge -- then there are surely far more other serious programming difficulties to handle.

@jrive I had replaced the link in the Reply/Comment above (to the worksheet with its name ending in "3").

@jrive I added some variants. With the radicals "frozen" they become temporary names, thus allowing algsubs or simplify-with-side-relations to operate.

@jrive Here are a few ways to get that, using algsubs with the radicals frozen.

The first way uses frontend, and the second uses freeze/thaw. The second of those can also utilize simplify-with-side-relations rather than algsubs.

new_filter_solution_ac3.mw

@love-algebra Do you think that an explicit, exact, closed form solution exists, in the general case that a root other than t=0 exists?

How about a "black box" procedure that can take numeric values for parameters and return a numeric value for `t` (if such then exists...)?

What were you planning on doing with an explicit, exact symbolic answer?

@Carl Love I have edited the Answer and changed it from
  `%.`(A,b)
to
  A %. b
which is nicer, thanks.

(The precedence doesn't affect this example -- as it is -- even in Maple 2017.2.)

@vroomZOOM You have not informed Maple of the units of time that t would take. (In your mind the quantities might be in seconds, but it doesn't have to be so merely from what you coded so far, and hence Maple cannot sensibly guess it -- guessing it would be wrong.)

You can supply units of time in the range of the plot command, or in the formulas where t appears, but you ought to double check other aspects of the results.

@mmcdara There are several examples using last (and initial and method) on the Help page for Topic dsolve,numeric,IVP .

As I showed, you could supply just one, inverted "view" to odeplot, or you could supply several "views". As shown, if you supply just the one inverted arrangement then the axis labels correspond and are as expected. If you supply multiple "views" and the axes serve differing purposes then the axis labels illustrate that fact. Of course you can always explicitly specifiy the axes labels.

@Carl Love Yes, thanks, I hadn't noticed that the Question was marked Maple 2020. The infix form should work in 1D input in versions from Maple 2017 onward.

How about uploading a worksheet that contains the various definitions? (Green up-arrow in Mapleprimes editor.)

@emendes I don't understand what you mean  sorry.

You two methods may not produce results which are always equivalent for all values of the parameters (despite your hope or expectation, though they might be Top Secret because you didnt share them...). How do you expect or hope to deal with that situation?

Perhaps there is something about your (undisclosed) solving methods which might allow you to generate programmatically or know some sufficient assumptions.