Your attachment had an invalid Equation blob of XML, just after the "Kronecker Delta" text.

Removing that I get the following, which opens ok in Maple 2022.2.

Lecture_2_notes_ac.mw

ps. Maple 2024 seems to have much less of this kind of problem (and might even be able to itself recover your attachment acceptably...). If your school offers it then I suggest you upgrade.

ps. The Mapleprimes posting editor's toolbar has a green up-arrow that allows on to upload and attach worksheet documents to posts. In future you could use that instead of a 3rd-party download site.

Your code snippet shows the name shift being used both as an optional parameter of F as well as for an equation in each of the lists passed for the Q, vec, and point parameter of F. It seems that you want to be able to pass those independently, when calling F.

You might also want one of those to override the other, ie. either the instances inside the lists, or the separate parameter. I've made a guess as to which that might be, since you haven't really explained your goal. (You should easily be able to switch which might be an override, or instead utilize them wholly separately, and/or assign the values to three different locals, etc.)

Using variants on the code below you should be able to access the shift equations (and their rhs values) specified by each of your Q, vec, or point lists. Accessing each of those simply involves using the eval command.

Eg., inside F, you can do any of,
   eval(':-shift',Q)
   eval(':-shift',vec)
   eval(':-shift',point)

One of your queries here is about how to access the rhs of shift=something when that appears in a list. That was also in a Reply of another recent Question of yours on this site. And I used the same approach above as previously recommended -- 2-argument eval -- the only difference is that now you have different local/param vs global references of the name hanging about.

(Again, you didn't state whether you wanted the separate shift optional parameter of F be subordinate, or an override, or unrelated to those three. I've made a guess, and demonstrated a way in which they could inter-relate. Remove that aspect, if not desired.)

Download param_pr_2.mw

I think that you could make it more clear and explicit what behavior you want an expect here. Showing a representative variety of function calls and corresponding expected results (even if the proc code is not given) is a basic thing. You should be explicit about the functionality you want.

ps. I suggest that you run maplemint on your procedures. I expect that you might find that it reports quite a few cases where global names are being used without protection against having prior values. (Eg. Try to run your example with :-shift assigned a float value at the top-level, and see what breaks, etc, etc.) I've tried to make the above "mint-clean".

pps. I understand that your actual procedures might be too long to include here. But you really ought to at least try to write a shorter proc and example that is self-contained and illustrates your query and runs stand-alone. In this case it wouldn't take long.

You wrote that you wanted to solve the pde numerically, so I'll address that methodology.

In that case you could try setting up that BC with a call to a black-box procedure, by which I mean a procedure that returns the numeric integration result when passed a numeric input, but for which a symbolic function call returns unevaluated.

This technique can also be used for some other flavors of example; ie. the black-box procedure doesn't necessarily involve an integral.

Download pds_bb.mw

That region can be shaded using the plots:-shadebetween command. (There are several other ways, using say plots:-inequal or plots:-implicitplot)

Just for fun, I played with some other options for the overall look&feel. Adust to taste.

shb.mw

See here the response about disabling scrollable rtables.

Disabling that GUI preference seems to have fixed a similar instance of the problem.

Is this the kind of effect that you're after?

(There might be a terser way; I just edited what you had before...)

Download minhthien_ts.mw

I have used Maple 2024.1 below.

You can use fprintf instead of printf, if you want to write to a file.

(please check for typos.)

Download minhthien_latex.mw

Does this behavior get affected/improved if you change the interface(rtablesize) setting?

Does this behaviour get affected/improved if you manage to disable the (new in M2024) so-called scrollable rtable/Matrix/Vector display?

ps. I have changed your Post into a Question.

See the Comparing sum and add section on the ?sum,details Help page.

And also note that the add command has special evaluation rules on its first parameter.

Also, your myfac procedure can be done using mul (or add of the powers), instead of a loop. A symbolic formula for it can also be constructed using the product (or sum) commands.

Here is an explanation of how it was going wrong for you (note the error message's meaning), as well as alternatives mentioned.

Download sum_of_geometric_sequence_ac.mw

Is this more what you're after? (Using Maple 2021.2)

I notice that your 2D Input is actually entered using the sqrt command. So one alternative (to fixing it up after the fact) might be to instead enter those with (...)^(1/2) instead of sqrt(...).

Download latex2_ac.mw

I don't see num_steps defined or assigned. Perhaps you intend that as, say, ceil((tmax - 0)/dt) or similar.

You don't ever evalf the contents of U0, so everything blows up as enormous symbolic expressions. That's the basic reason why it appeared to take forever. I expect that you intended to utilize floating-point values.

You can use Tabulate to overwrite (in-place) an output of the running plotU. If you want all the intermediate plots shown then you could use print(plotU) instead of your original display(plotU). But note that your original display(plotU) wasn't being assigned to anything. If instead you were to assign all the individual plotU plots as entries in a table TT then after the loop you could display(entries(TT),insequence) and get an animation.

Numerical_Simulation_of_discrete_Klein-Gordon_Equation_ac.mw

ps. I have not revised or examined the underlying algorithm or its implementation. Commenting the code better might be useful.

It is more generally straightforward to programmatically access the results from the ifactors command, rather than from the ifactor command.

Download ifactors_ex.mw

One aspect that makes it more sensible is that the methodology can be consistent whether the factors have multiplicity 1 or greater than 1. Eg, whether the original is say 6, or 72. But with ifactor the deconstruction would need a separate case for whether the power was 1 (in which case not actually present) or greater than 1.

Download regsplit_ex.mw

The codegen:-cost command does this computation (with addition and subtraction having the same "cost").

The individual numbers can be extracted in a usual manner, using coeff.

Download Count_the_number_of_operations_in_A_ac.mw

note: If you do it by way of conversion to string then be wary of any special names that might contain the characters of the relevant operators. (That doesn't affect your example, of course.)

You might also be interested in some means of reducting of these numbers.

Download Count_the_number_of_operations_in_A_acc.mw

Sometimes one can beat simplify(...,size) for this kind of thing through special use of collect.

The applyrule command is not receiving what you think, due to usual evaluation rules for procedure calls.

You could do this, instead,

Download applyrule_defer.mw

You can use trace to see what applyrule was actually receiving, for your example.

e1 := sin(2*sqrt(a*b)*(t+mu)):
trace(applyrule):

applyrule( sin(x::anything) = cos(expand(x)), e1 );

{--> enter applyrule, args = sin(x::anything) = cos(x), sin(2*(a*b)^(1/2)*(t+mu))
...

The above trace details show that applyrule was actually receiving the first of these next two results as its first argument. But you want it to receive something like the second.

sin(x::anything) = cos(expand(x))
                   sin(x::anything) = cos(x)

sin(x::anything) = cos('expand'(x))
               sin(x::anything) = cos(expand(x))