I am using Maple 2023.

When using PDE Numeric Help Side the text sides is not smooth moving when scrolling downwards or upwards.

Any advice what to do????

Kjell

The so-called look-and-say sequence is something like:

Rosetta Code gives an example of how to generate such sequences in Maple; however, the code in that example is lengthy. More to the point, compared to the subsequent Mathematica analogue, it is rather inefficient (though more readable, but that's not the point). 
I slightly modify the original code, and now the modified version is significantly faster than the original one: 
 

Download LookAndSay.mw

For the sake of convenience, I paste the original Maple code from the page above into here:

generate_seq := proc(s)
	local times, output, i;
	times := 1;
	output := "";
	for i from 2 to StringTools:-Length(s) do
		if (s[i] <> s[i-1]) then
			output := cat(output, times, s[i-1]);
			times := 1; # re-assign
		else 
			times ++;
		end if;
	end do;
	cat(output, times, s[i - 1]);
end proc:

Look_and_Say :=proc(n)
	local value, i;
	value := "1";
	print(value);
	for i from 2 to n do
		value := generate_seq(value);
		print(value);
	end do;
end proc:

#Test:
Look_and_Say(10);

Below is a modified version by me: 

LookAndSay := proc(m::posint, n::nonnegint := 1, $)::'Vector'(nonnegint);
    uses StringTools;
    local delete::'equationlist' := Repeat~(Explode(ExpandCharacterClass(":digit:")), 2), aux::procedure[nonnegint](posint) := proc(_::posint)::nonnegint;
        options cache;
        description "https://rosettacode.org/wiki/Look-and-say_sequence#Maple";
        if _ = 1 then
            n
        else
            local char::'nonemptystring' := String(thisproc(_ - 1)), temp::list(string)(*, str*);
            try
                temp := RegSplit(sprintf("(?=[%s])(?<=(?!%s)[%s])", Unique(char), Join(select[2](foldr, eval(apply), delete, rcurry(OrMap, Unique(char)), curry(curry, Has)), "|"), Unique(char)), char)
            catch "cannot compile regular expression: repetition-operator operand invalid":
                local rule::'equationlist' := (str -> str = Insert(str, 1, " "))~(subs(delete =~ NULL, Generate(2, Support(char))));
                temp := StringSplit(Subs(rule, char), " ") # to be replaced
            end;
            parse(String(seq('length(str), str[1]', str in temp)))
        fi;
    end;
    forget(aux);
    Vector[column](m, aux, datatype = nonnegint)
end:

The form LookAndSay(m, n); produces the first m terms in a "look-and-say" sequence starting with n (which is by default 1). Unfortunately, even if "the modified version is significantly faster than the original one", it is still much slower (25s versus 2.5s) than the uncompiled Mathematica implementation (on the same modern computer):

So, is there a workaround to evaluate LookAndSay(50, 1): in about three seconds (instead of half a minute) in the first call (without looking up a pre-calculated table) (on the same computer) as well? 

how I can extract data from plot3d such as x, y, phi2?

thanks

tez-1.mw

Download tez-1.mw
 

Download tez-1.mw

While Maple itself is a pleasure to work with, the multitude and persistance of bugs in the Units package doesn't stop to surprise.

Especially as the same bugs come up again and again, after having been fixed i older versions.

In general, working with units and 0 is a pain in the ass. And this one doesn't even need a unit to compare with.

This one works in Maple 2022 - does not work in Maple 2023.

with(Units[Simple]);
min(0, 0);

Hi, 

Im trying to solve a system of 4 non-linear equations using the fsolve function. When i compute the command i seemingly dont get an answer to the system. Maple only prompts the command itself, can any of you locate my mistake or give any input on how to solve the issue. 

My code is as follows: 

restart;
r__C := 400;
r__D := 600;
r__E := 800;
a := 100;
p := 0.7;
q := Pi*a^2*p;
h__eq := 0.9*h__1*(E__1/E__2)^(1/3);
R__Ceq := sqrt(h__eq^2 + r__C^2);
R__C := sqrt(r__C^2 + h__1);
R__Deq := sqrt(h__eq^2 + r__D^2);
R__D := sqrt(r__D^2 + h__1);
R__Eeq := sqrt(h__eq^2 + r__E^2);
R__E := sqrt(r__C^2 + h__1);

eqC := 174.5*10^(-3) = q*(1 + nu)/(2*Pi*E__2*R__Ceq)*(2*(1 - nu) + h__eq^2/R__Ceq^2) + q*(1 + nu)/(2*Pi*E__1*r__C)*(2*(1 - nu) + 0) - q*(1 + nu)/(2*Pi*E__1*R__C)*(2*(1 - nu) + h__1^2/R__C^2);
eqD := 151.7*10^(-3) = q*(1 + nu)/(2*Pi*E__2*R__Deq)*(2*(1 - nu) + h__eq^2/R__Deq^2) + q*(1 + nu)/(2*Pi*E__1*r__D)*(2*(1 - nu) + 0) - q*(1 + nu)/(2*Pi*E__1*R__D)*(2*(1 - nu) + h__1^2/R__D^2);
eqE := 133.2*10^(-3) = q*(1 + nu)/(2*Pi*E__2*R__Eeq)*(2*(1 - nu) + h__eq^2/R__Eeq^2) + q*(1 + nu)/(2*Pi*E__1*r__E)*(2*(1 - nu) + 0) - q*(1 + nu)/(2*Pi*E__1*R__E)*(2*(1 - nu) + h__1^2/R__E^2);
eqA := 401.7*10^(-3) = 2*q*a*(-nu^2 + 1)*(sqrt(1 + (h__eq/a)^2) - h__eq/a)/E__2 + 2*(-nu^2 + 1)*q*a/E__1 - 2*q*a*(-nu^2 + 1)*(sqrt(1 + (h__1/a)^2) - h__1/a)/E__1;

fsolve({eqA, eqC, eqD, eqE}, {E__1, E__2, h__1, nu}, {E__1 = 0 .. 5000, E__2 = 0 .. 5000, h__1 = 0 .. 1000, nu = 0 .. 0.5});
 

Picture for refference: 

The attached worksheet shows a simple operator to calculaute the cartesian product of a set. The code is executed in both 1D and 2D notation in the worksheet.  The code is also placed in a code edit region and in the startup code area if the worksheet.  When entered into a worksheet is either notation, it produces an error message,  Without the local designation, it executes with a warning message. When entered into a code edit region it executes without error or warning.

I assume that this behavior reflects a limitation of the 2d notation or is there a workaround to the problem?

error4.mw

For instance, given nine integer x₁, x₂, …, x₉ satisfying x₁, x₂, …, x₉ ≥ -5 and x₁³＋x₂³＋…＋x₉³＝0, the goal is to maximize x₁ + x₂ + … + x₉. However, according to Optimization/Options,  is not accepted by the Optimization:-Maximize command. A probable method is applying floor into the optimization variables; unfortunately, I can only get: Error, (in Optimization:-NLPSolve) no improved point could be found. 

(*restart;*)
vars := [x || (1 .. 9)]:
Optimization:-Maximize(`?()`(`+`, floor~(expr)), [add(floor~(expr) ^~ 3) = 0, expr[] >=~ -5], initialpoint = (unapply~(expr) =~ rand(-5 .. 10))()); # Alternatives to exhaustive search?
Error, (in Optimization:-NLPSolve) no improved point could be found

Is there any workaround to solve this problem? 

Hafiz_basin_of_attraction_.mw

[moderator: see also this earlier Question]

The code below runs as expected up through the 4th line. At that point ans_all should contain all the multipule ansers to the equation being looked at. I want to look at just the first solution and I would expect the way to do this would be ans_all[1]. However the command ans_all[999999999] is valid, which indicates to me that that's not how you do that. So.... how do I get just the first answer?

equ := sqrt(1 + (-4 + 4*sqrt(2))*x + (16 - 12*sqrt(2))*x^2 + (-24 + 16*sqrt(2))*x^3 + (15 - 8*sqrt(2))*x^4)/(1 + (-4 + 4*sqrt(2))*x + (22 - 12*sqrt(2))*x^2 + (-36 + 28*sqrt(2))*x^3 + (33 - 20*sqrt(2))*x^4):
anit_dev_equ := int(equ,x):
ans_root := eval(anit_dev_equ, [x = 1]) - eval(anit_dev_equ, [x = 0]):
ans_all := allvalues(ans_root):
ans_all[999999999]

How does a user retain existing inline output (for example, computational output or inline plots) when re-executing an execution group in recent versions of Maple?  The "Replace existing output when re-executing groups" option is not available in Maple 2023 or in Maple 2020.

For example, I want to execute the same execution group 2 times to generate 2 different inline plots as the output. I want to retain the first inline plot when I generate the second inline plot.  However, the default Maple 2023 behavior is to overwrite the first inline plot with the second inline plot.

Several Maple versions ago (for example, Maple 18), there was the Tools > Option > Display > "Replace existing output when re-executing groups" option. When that option is checked, the second plot overwrites the first plot. In contrast, when that option is unchecked, the second plot appears after the retained first plot.

Where is the "Replace existing output when re-executing groups" option in recent Maple versions? Or do recent versions, like Maple 2023, use a different method to retain existing output when re-executing an execution group?

I think that the following worksheet is self-explaining: 
 

Download funm.mws

How do you confirm the validity of the last output? 

> op(3, eval(LinearAlgebra:-MatrixFunction));
 = 
  Copyright (c) 2002 Waterloo Maple Inc. All rights reserved.

And does this mean that LinearAlgebra['MatrixFunction'] is so out-dated that the return value is less effective in certain cases?

Wolfram's marketing literature states that a compiled function may generate the dates for the years 1 through 5.7 million in a couple of seconds rather than in minutes (comparing to the "uncompiled implementation").
The given function in this link can be translated into Maple language as follows: 

(*
  Note that this is only a mathematical program that outputs some data,
   hence 'Easter(-2, 1)' will never return real Gregorian Easter dates!
*)
Easter:=proc(BEGIN::integer[4],END::integer[4],$)::Array(BEGIN..END,[integer[1..12],integer[1..31]]);# the parent function
	description "https://www.wolfram.com/language/12/code-compilation/compute-the-date-of-easter.html";
	local computus::procedure[[integer[1 .. 12], integer[1 .. 31]]](integer):=proc(Year::integer,` $`)::[integer[1..12],integer[1..31]];# the child function
		options threadsafe;
		local a::nonnegint,b::integer,c::nonnegint,d::integer,e::nonnegint,f::integer,g::nonnegint,h::nonnegint,i::nonnegint,j::nonnegint,k::nonnegint,Month::integer[1..12],Day::integer[1..31];
		(* For compatibility, when `Year` is nonpositive, the command `iquo` must be replaced with slower `floor`. *)
		if Year<=0 then
			a,b,c:=Year mod 19,floor(Year/100),Year mod 100;
			d,e,f:=floor(b/4),b mod 4,floor((8*b+13)/25);
			g,h,i:=19*a+b-d-f+15 mod 30,floor(c/4),c mod 4;
			j:=floor((a+11*g)/319);k:=2*e+2*h-i-g+j+32 mod 7;
			Month:=floor((g-j+k+90)/25);Day:=g-j+k+Month+19 mod 32
		else
			a,b,c:=irem(Year,19),iquo(Year,100),irem(Year,100):
			d,e,f:=iquo(b,4),irem(b,4),iquo(8*b+13,25);
			g,h,i:=irem(19*a+b-d-f+15,30),iquo(c,4),irem(c,4);
			j:=iquo(a+11*g,319);k:=irem(2*e+2*h-i-g+j+32,7);
			Month:=iquo(g-j+k+90,25);Day:=irem(g-j+k+Month+19,32)
		fi;
		[Month,Day]
	end;
	Array(BEGIN..END,computus)
end:

However, as "no nested procedures can be translated" to optimized native machine code (cf. ), executing Easter(1, 5700000) has to take at least two minutes: 

Is there some workaround that can provide improved performance for such a numerical procedure that contains a nested procedure? In other words, is it possible to produce the `result` (without modifying the algorithm) in two seconds in modern Maple as that Wolfram marketing literature claims?

What am I doing wrong, why cant I get the result correct?

Hello

I have programs below for the cases n=3 and n=4. If n is increasing by 1, then there is one loop more. As you can see, that additional loop has always the structure:

x[i+1] from ceil(((n-2)*24-d[i])/(n-i)) to x[i]

whereas d[i] is the sum of the values of x before.

Now I want to write "nequaln":=proc(k), which goes through all the values for n from 3 to k and produces a list [a_3,a_4,a_5,...,a_n].

I guess that I need to program a kind of dynamical loop, but I failed completely. May someone help me? That would be very kind.

nequal3:=proc()
    local u,v,a_3;
    a_3:=0;
    for u from ceil((3-2)*24/(3-0)) to (3-2)*24-3+1 do
        for v from ceil(((3-2)*24-u)/(3-1)) to u do
            if (3-2)*24-u-v>=1 then
                a_3:=a_3+1;
            end if;
        end do;
    end do;
    print(a_3);
end proc:

nequal4:=proc()
    local u,v,w,a_4;
    a_4:=0;
    for u from ceil((4-2)*24/(4-0)) to (4-2)*24-4+1 do
        for v from ceil(((4-2)*24-u)/(4-1)) to u do
            for w from ceil(((4-2)*24-u-v)/(4-2)) to v do
                if (4-2)*24-u-v-w>=1 then
                    a_4:=a_4+1;
                end if;
            end do;
        end do;
    end do;
    print(a_4);
end proc:

The old question "Longest distance in a graph via Maple code" offers some general methods to find longest paths in a given graph, while for directed acyclic graphs, the longest paths can be found much more directly via built-in functions. However, it apprears that even for small dags, Maple cannot solve this in an acceptable time. In the following example, I'd like to count the number of nodes that on longest paths for certain source and target vertexes.
 

Download longest_paths_in_a_DAG.mw

Unfortunately, I have to wait for almost four minutes in the above instance. Can this task be done in 0.4s?