acer

alternative...

Answered: acer 32303

November 20 2022

0 2

If you keep/create your packages in the following pattern then the lib subdirectories get added to libname automatically upon relaunch.

$(HOME)/maple/toolbox/mypackage/

where the .mla for that package is put in a subdirectory named lib.

You can also put the source under that directory.

And so all the source, along with the .mla, can be under that mypackage directory.

And similarly for mypackage2, mypackage3, etc.

In new Maple sessions the kernel will pick up the lib subdirectories for all such, and add them to libname.

The key here is putting them under this special location: whatever this returns,

cat(kernelopts(homedir),"/maple/toolbox");

This approach removes the need to use any initialization file. Thus any tricky editing of an initialization file is wholly unnecessary.

And it lets you keep each package's source and .mla under its own directory. (Which you wanted, for github.)

The value of libname gets further augmented (in subsequent sessions) simply by adding another package in another such directory tree.

Side-note: You can also programatically create a self-installing file which unpacks any or all of .mla, .help, source, and build-scripts to the equivalent directory on someone else's machine. (This knows where to place these toolbox files regardless of operating system: Linux, MS-Windows, or OSX.)

This is the scheme Maple uses for its own add-on toolboxes. Why reinvent the wheel?

evaluation...

Answered: acer 32303

November 19 2022

0 0

As documented on the procedure Help page, within a procedure a reference to a local gets only single level evaluation.

In contrast a declared global gets fully evaluated.

Here are a few notes:

>

restart;

>	gen := () -> 4.5:

>	p := proc() global g; local a,b,c; g := b; c := b; b := a; a := 'gen()'; print( a, b, c, g ); end proc:

>	Inside the procedure p, a gets single level evaluation, obtaining its value, which is the unevaluated function call gen(). b gets single level evaluation, obtaining just `a` c gets single level evaluation, obtaining just `b` g gets fully evaluated, obtaining 4.5 p();

>

restart;

>	gen := () -> 4.5:

>	g := b: c := b: b := a: a := 'gen()':

>	At the top-level (ie. outside any procedure), these all get fully evaluated. a, b, c, g;

>	The following mimics the kinds of evaluation that occured within the call to procedure p. Compare with the result above of calling p(). eval(a,1), eval(b,1), eval(c,1), g;

>	Even at the top-level we can control the level of evaluation, or perform full evaluation as usual. eval(g,1), eval(g,2), eval(g,3), g;

>	eval(c,1), eval(c,2), eval(c,3), c;

>	Here's a tip for top-level programming: Suppose we want to test whether sol gets assigned a solution, or whether fsolve has returned unevaluated, (since no solution is found). sol := fsolve({x+y=0, sin(x)+sin(y)=3}, {x,y});

>	The following appears reasonable, but in fact this top-level reference to sol induces a full evaluation of sol. This makes fsolve get needlessly called again, which is inefficient. if op(0,sol) = fsolve then print("it returned unevaluated"); end if;

>	The following gets the same test, but doesn't make fsolve get called again. (You could trace(fsolve), or run in the debugger, to see that this is so.) if op(0,eval(sol,1)) = fsolve then print("it returned unevaluated"); end if;

>

In contrast, the following code -- within a
procedure, with sol declared local -- makes
only the initial call to fsolve. There is no repeated,
(inefficient) attempt by fsolve during the if...then
test since the local named sol gets only single level
evaluation.

restart;
##trace(fsolve):
h := proc()
  local sol;
  sol := fsolve({x+y=0, sin(x)+sin(y)=3}, {x,y});
  if op(0,sol) = fsolve then
     print("it returned unevaluated");
   end if;
end proc:

h();

>

Download local_eval_notes.mw

problem is adaptive=geometric...

Answered: acer 32303

November 19 2022

2 1

The problem is caused by the algorithm behind the (new to Maple 2022) default adaptive=geometric option.

You can get around this by supplying the option adaptive=true (or its shorter equivalent, merely the keyword option name, adaptive).

(I have submitted a bug report against this example.)

Download arcsin_ac1.mw

sure...

Answered: acer 32303

November 19 2022

0 0

Yes, providing a .mla file (Maple Library Archive) and a .help file (Maple Help database) is a relatively common way to share one's data/procedues/modules/help-worksheets with other people.

It's up to you whether you also wish to provide the source code for your procedures/modules, or any special script that might read such into a session.

source, and library archives...

Answered: acer 32303

November 18 2022

1 2

I suggest that you keep the .mla archive libirary files all in one common directory, and use the subdirectory structure for the various source files.

As for how to manage the subdirectories, I sometimes do it as follows:

I have my various packages' module (parent) definition files in a common location, eg.
src/pack1.mpl
src/pack2.mpl

The src/pack1.mpl file looks like this,

pack1 := module()
export f1,f2;
local f3;
$include "../pack1/src/f1.mm"
$include "../pack1/src/f2.mm"
$include "../pack1/src/f3.mm"
end module;

And similarly for the src/pack2.mpl file.

All in all, I get the following

lib/pack1.mla
lib/pack2.mla
src/pack1.mpl # module defn
src/pack2.mpl # module defn
pack1/src/f1.mm # module member, eg. proc defn or submodule defn
pack1/src/f2.mm # proc defn
pack2/src/g1.mm # proc defn
pack2/src/g1.mm # proc defn

This way I only have to have that single top "src" directory in the include-path. The other files are picked up when I read either of the two parent .mpl files because I used relative names in the $include directives. I don't ever have to concern myself with "searching" for parent source files, or adding multiple locations to the include path.

And I only have a single location added to libname.

(Eventually I move the .mla files over to a ($HOME)/maple/toolbox subdirectory on my machine, so that libname gets augmented automagically. I seldom bundle them up as a package redistributable via the Maple Cloud or someone else's Maple GUI, but if I did I would never use a Maple workbook as the only copy of my sources.)

[edit] You might wonder why I bother at all with having the files in a "src" subdirectory. It's because I also have "doc" and "tst" subdirectories at those same levels, for documention&notes and for unit test files.

sure...

Answered: acer 32303

November 17 2022

2 0

You can alter various aspects of this, to suit your taste.

Download 1d_numberline.mw

It's not the only way to get such an effect.

If you already have some existing, computed list of points (which does not simply include all the naturals up to some number), then the above code can be adjusted to get a few alternate appearances. [Thanks, dharr, for referencing this case.]

For example,

Download 1d_numberline2.mw

Arrays...

Answered: acer 32303

November 17 2022

3 3

Your syntax for creation of Arrays for A and B is faulty. Your code creates them as lists, not Arrays.

Also the approach of using of a loop to repeatedly augment a list is inefficient. And you ended up with name t being assigned a numeric value, which then makes using the F formula awkward.

Here is one (of several) ways get it:

>

restart;

>	with(SignalProcessing):with(plots):

>	omega:=102Pi:

>	F:=add(n/5cos(nomega*t),n=1..5);

>	X:=0.01;Y:=0.5

>	A:=Array([seq(0..Y,X)]);

>	B:=Array([seq(F,t=0..Y,X)]);

>	pointplot(<A,B>,connect=true);

>	DD := DFT(B);

>

Download DFT_Test_ac.mw

eliminate...

Answered: acer 32303

November 15 2022

1 2

The following might get you started, at least for steps 1-3.

Step 4 does not seem to allow for the fact that the names R__ct,R__s,R__w,C__dl, and omega can be expressed in terms of the a[i] and b[i] in more than one way. Below is a solution (with a check on it), but it may not be the same choice of representation by a[i] and b[i] that you want(?).

>

Y := 1/(R__s+1/(s*C__dl+1/(R__ct+1/(sqrt(s)/sigma+1/R__w))))

1/(R__s+1/(s*C__dl+1/(R__ct+1/(s^(1/2)/sigma+1/R__w))))

>

(C__dl*s^(3/2)*R__ct*R__w+C__dl*R__ct*s*sigma+C__dl*R__w*s*sigma+s^(1/2)*R__w+sigma)/(C__dl*s^(3/2)*R__ct*R__s*R__w+C__dl*R__ct*R__s*s*sigma+C__dl*R__s*R__w*s*sigma+s^(1/2)*R__ct*R__w+s^(1/2)*R__s*R__w+R__ct*sigma+R__s*sigma+sigma*R__w)

>	The padey2 term isn't really needed. I include it to match the given document.

(sigma+R__w*s^(1/2)+C__dl*sigma*(R__ct+R__w)*s+C__dl*R__ct*R__w*s^(3/2))/(sigma*(R__ct+R__s+R__w)+R__w*(R__ct+R__s)*s^(1/2)+C__dl*R__s*sigma*(R__ct+R__w)*s+C__dl*R__ct*R__s*R__w*s^(3/2))

>

padey3 := sort(collect(padey, s, proc (u) options operator, arrow; simplify(u/(sigma*(R__ct+R__s+R__w))) end proc), order = plex(C__dl, s), ascending)

(1/(R__ct+R__s+R__w)+R__w*s^(1/2)/(sigma*(R__ct+R__s+R__w))+(R__ct+R__w)*C__dl*s/(R__ct+R__s+R__w)+R__ct*R__w*C__dl*s^(3/2)/(sigma*(R__ct+R__s+R__w)))/(1+R__w*(R__ct+R__s)*s^(1/2)/(sigma*(R__ct+R__s+R__w))+R__s*(R__ct+R__w)*C__dl*s/(R__ct+R__s+R__w)+R__ct*R__s*R__w*C__dl*s^(3/2)/(sigma*(R__ct+R__s+R__w)))

>

>	One way to get the equations from padey3:

${a[0] = 1/(R__ct+R__s+R__w), a[1] = R__w/(sigma*(R__ct+R__s+R__w)), a[2] = (R__ct+R__w)*C__dl/(R__ct+R__s+R__w), a[3] = R__ct*R__w*C__dl/(sigma*(R__ct+R__s+R__w)), b[0] = 1, b[1] = R__w*(R__ct+R__s)/(sigma*(R__ct+R__s+R__w)), b[2] = R__s*(R__ct+R__w)*C__dl/(R__ct+R__s+R__w), b[3] = R__ct*R__s*R__w*C__dl/(sigma*(R__ct+R__s+R__w))}$

>	Another way to get the equations from padey3: $temp1 := `assuming`([map(evala, eval(N, s = s^2))], [s > 0]); temp2 := `assuming`([map(evala, eval(1/M, s = s^2))], [s > 0]); eqs := {seq(a[i] = coeff(temp1, s, i), i = 0 .. 3), seq(b[i] = coeff(temp2, s, i), i = 0 .. 3)}$

${a[0] = 1/(R__ct+R__s+R__w), a[1] = R__w/(sigma*(R__ct+R__s+R__w)), a[2] = (R__ct+R__w)*C__dl/(R__ct+R__s+R__w), a[3] = R__ct*R__w*C__dl/(sigma*(R__ct+R__s+R__w)), b[0] = 1, b[1] = R__w*(R__ct+R__s)/(sigma*(R__ct+R__s+R__w)), b[2] = R__s*(R__ct+R__w)*C__dl/(R__ct+R__s+R__w), b[3] = R__ct*R__s*R__w*C__dl/(sigma*(R__ct+R__s+R__w))}$

>

[R__s = b[2]/a[2], C__dl = -a[2]^2/(a[0]*b[2]-a[2]), R__ct = (-a[1]*b[2]+a[2]*b[1])/(a[2]*a[1]), sigma = (-a[0]*b[1]+a[1])/a[1]^2, R__w = (-a[0]*b[1]+a[1])/(a[1]*a[0])]

>

[a[2]*(a[1]*b[2]-a[2]*b[1])/(a[0]*b[2]-a[2]) = a[3], b[2]*(a[1]*b[2]-a[2]*b[1])/(a[0]*b[2]-a[2]) = b[3]]

>

Z := sort(collect(simplify(eval(N, ans), W), s), order = plex(s), ascending)/sort(collect(simplify(eval(1/M, ans), W), s), order = plex(s), ascending)

(a[0]+a[1]*s^(1/2)+a[2]*s+a[3]*s^(3/2))/(1+b[1]*s^(1/2)+b[2]*s+b[3]*s^(3/2))

Download maple_attempt_ac.mw

one way...

Answered: acer 32303

November 13 2022

1 1

The six periodic values have two sets of three, negations of each other.

The two sets of three can be alternately obtained by setting the parameter in the solve(...,allsolutions) result to either an odd or even integer.

Below I set that parameter (eg. _Z1) to 1, though I also have merged both sets of three from using both 1 and 0.

We can sort the roots of the derivative by the values that would attain by substitution into the original expression. This allows us to pick off a value of t which attains the maximal value.

There doesn't seem to be any simplification benefit to conversion to exp&ln, with a larger form as well as the presence of I the imaginary unit.

The optimal symbolic values below for both t and the expression seem reasonably compact.

>

restart;

>	expr:=sin(sqrt(3)t)cos(sqrt(3)t)(sqrt(3)cos(sqrt(3)t) - sin(sqrt(3)*t))/3;

>	S:=[solve(diff(expr,t),t,allsolutions)]: v:=indets(S,suffixed(_Z))[1];

>	plots:-display( plots:-pointplot([seq(Re~(evalf([s,eval(expr,[t=s])])),s=simplify(S,{v=1}))], symbol=solidcircle,symbolsize=15,color=blue), plot(expr,t=-2Pi..2Pi), size=[600,300])

>	H:=simplify(evalc(simplify(S,{v=1}))):

>	HH := sort(H, (a,b)->is(eval(expr,t=a)>eval(expr,t=b))):

>	t_opt := HH[1];

-(1/3)*3^(1/2)*(arctan(2^(1/2)*cos((1/3)*arctan((1/19)*503^(1/2)))+3^(1/2)*2^(1/2)*sin((1/3)*arctan((1/19)*503^(1/2)))-(2/3)*3^(1/2))-Pi)

>	evalf( eval(expr, t=t_opt) );

>	expr_opt := combine(expand(eval(expr, t=t_opt)));

-(1/9)*(-6*3^(1/2)*sin((2/3)*arctan((1/19)*503^(1/2)))+3*2^(1/2)*sin((1/3)*arctan((1/19)*503^(1/2)))+cos((1/3)*arctan((1/19)*503^(1/2)))*6^(1/2)+6*cos((2/3)*arctan((1/19)*503^(1/2)))-10)/(-(4/3)*cos((1/3)*arctan((1/19)*503^(1/2)))*6^(1/2)+2*3^(1/2)*sin((2/3)*arctan((1/19)*503^(1/2)))-4*2^(1/2)*sin((1/3)*arctan((1/19)*503^(1/2)))-2*cos((2/3)*arctan((1/19)*503^(1/2)))+19/3)^(3/2)

>

Download some_trig_opt.mw

like this?...

Answered: acer 32303

November 12 2022

0 1

The following sorts, in ascending order of exponents, by the indexed `Δy` names taken in descending order of index.

I used `collect` to first factor the coefficients of those names.

The result seems to match what you gave as target form.

(I used Maple 2015.)

>

restart;

>

expr := ((1/2)*r*(r-1)+(1/6)*r*(r-1)*(r-2))*`Δy`[-1]^3+(1/2)*r*(r-1)*`Δy`[-1]^2+(1/120)*r*(r-1)*(r-2)*(r-3)*(r-4)*`Δy`[-2]^7+((1/6)*r*(r-1)*(r-2)+(1/12)*r*(r-1)*(r-2)*(r-3)+(1/120)*r*(r-1)*(r-2)*(r-3)*(r-4))*`Δy`[-2]^5+((1/6)*r*(r-1)*(r-2)+(1/24)*r*(r-1)*(r-2)*(r-3))*`Δy`[-2]^4+((1/24)*r*(r-1)*(r-2)*(r-3)+(1/60)*r*(r-1)*(r-2)*(r-3)*(r-4))*`Δy`[-3]^7+((1/24)*r*(r-1)*(r-2)*(r-3)+(1/60)*r*(r-1)*(r-2)*(r-3)*(r-4))*`Δy`[-3]^6+r*`Δy`[0]+y[0];

>	S:=sort([indets(expr,specindex(`Δy`))[]], (a,b)->op(1,a)<=op(1,b)):

>	sort(collect(expr,S,factor), order=plex(S[]), ascending);

y[0]+r*`Δy`[0]+(1/2)*r*(r-1)*`Δy`[-1]^2+(1/6)*r*(r-1)*(r+1)*`Δy`[-1]^3+(1/24)*r*(r-1)*(r-2)*(r+1)*`Δy`[-2]^4+(1/120)*r*(r-1)*(r-2)*(r+2)*(r+1)*`Δy`[-2]^5+(1/120)*r*(r-1)*(r-2)*(r-3)*(r-4)*`Δy`[-2]^7+(1/120)*r*(r-1)*(r-2)*(r-3)*(-3+2*r)*`Δy`[-3]^6+(1/120)*r*(r-1)*(r-2)*(r-3)*(-3+2*r)*`Δy`[-3]^7

Download sort_collect.mw

tech support...

Answered: acer 32303

November 10 2022

0 0

You could send an email to Maplesoft's Technical Support team, at,
support@maplesoft.com

They'll want to know your Operating System and Maple version number.

Or you could fill out this form.

a few alternatives...

Answered: acer 32303

November 10 2022

0 4

I'd suggest that using 1D (plaintext) Maple Notation would be one good alternative. If you do that then you can use the arrow notation in the input, to enter the operator, while also using the local declaration.

If you really need to use 2D Input then you could enter it using proc()...end, and optionally throw the procedure options arrow,operator on and get it nicely pretty-printed as output.

Download warningmessage_ac.mw

As you noticed, the local declation is not yet fully supported for the arrow notation in 2D Input.

assigning to formal parameter x...

Answered: acer 32303

November 10 2022

0 1

The name x is a parameter of your procedure IPM.

But there is a statement in IPM which attempts to perform,
x := x/ix;
which is an assignment that is not allowed when x has been passed in with a value (here, a Vector).

You could change the name of the procedural parameter to, say xin, and have the procedure assign xin to a new local named x at its beginning. The rest of IPM would then be able to assign to that local x or use its running value.

IOMMcode_ac.mw