Joe Riel

9520 Reputation

23 Badges

18 years, 218 days

MaplePrimes Activity

These are answers submitted by Joe Riel

I've seen that more than a few times. Am not sure the origin (it's a kernel thing).

The emacs maple debugger (mdcs) doesn't resolve that issue.  Am working on updating the github site for mdcs, will post a message to MaplePrimes when it is ready.

Followup Got a response from the kernel group. Some Maple procedure do, in fact, change in place, which causes issues with the debugger.  I had submitted SCRs for this years ago and was kindly pointed to them. One case where a procedure can change in place is if it modifies itself to add a remember table. I think that now can be done in an alternative way that avoid the change in place, but the example was in some rather old library code.

To use the debugger to step through code, the code has to be in a procedure.  However, you did say that the code was crashing. Am not sure what that means, but if it is raising an error, than you can use that to launch the debugger. For example,

(**) stoperror('all'):
(**) for i to 10 do 1/(i-3); end do:

Executing that will launch the debugger when the error is raised and display the expression raising the error.  Inside the debugger you can inspect the variable i. Maybe this will suffice for your problem.

Is this what you have in mind

(**) with(DynamicSystems):
(**) tf1 := TransferFunction(z/(z^2+z+1),'discrete'):
(**) de1 := DiffEquation(tf1):
(**) de1:-de;
           [x1(q + 1) = -x2(q), x2(q + 1) = x1(q) - x2(q) - u1(q), y1(q) = -x2(q)]

This is consistent with your other issue.  Apparently the Maple version launched by emacs is not reading the .mapleinit file.  Am investigating [it works for me].  Will contact you separately but report any results here. 

Note that it is generally best if the initialization file produces no printable output.  So it is better to terminate the assignment with a colon (vs a semicolon).  That won't matter here.

Rather than use the maplev-mode on git (which I haven't updated in a while, if memory serves), use the one available on the Maple Cloud.  That is, in Maple Standard, click the icon in the upper left that opens the cloud interface.  Search for maplev, then follow the instructions. 

An alternative is to use

s := "   string with   various    spaces    ":
StringTools:-RegSplit(" +", StringTools:-TrimLeft(s));
                        "string", "with", "various", "spaces"

TrimLeft is used to remove a prefix of white space, which would otherwise be returned as an empty string in the sequence.

I assume you are running this in Standard.  In tty Maple (cmaple) it behaves better (no lockup) but still somewhat strangely as it doesn't debug the second call.  This is on linux.  I assume the lockup occurs in Standard because the debugger window was killed.  If I use my Emacs-based Maple debugger, it works fine in both tty Maple and Standard: no lockup and one can debug either call. 

You may be able to use the liesymm package to handle this.  The difforms package can also be used, but I believe the lieysmm package is easier to use.

(**) with(liesymm):
(**) setup(x,y):
(**) eq := 2*x*y^3 + 3*x^2*y = 1;
(**) isolate(d(eq),d(x));
                       d(x) = (-6*x*y^2*d(y)-3*x^2*d(y))/(2*y^3+6*x*y)
(**) factor(%);
                       d(x) = -3/2*d(y)*x*(2*y^2+x)/y/(y^2+3*x)


There are a couple issues, at least if you are doing this in 1D input.  The following works.  Note that I replaced Zeta with zeta, the former is assigned a procedure and won't work.


Nx := 200;
Nt := 200;
dx := 0.5e-2;
dt := 0.2e-1;
A := Matrix(Nx, Nx);

for k to Nx do A[k, k] := -2.0 end do:
for j to Nx-1 do A[j+1, j] := 1.0 end do:
for j to Nx-1 do A[j, j+1] := 1.0 end do:

zeta := (.1*dt/dx)^2;
phi || 0 := Matrix(Nx, Nx);

fin := proc (t) options operator, arrow; cos(4*Pi*t) end proc;
phi || 0[(1/2)*Nx, (1/2)*Nx] := fin(0);
phi || 1 := (1/2)*zeta^2 . A . phi || 0;
phi || 1[(1/2)*Nx, (1/2)*Nx] := fin(dt);

phinow := Matrix(Nx, Nx);
phinext := Matrix(Nx, Nx);
phibefore := Matrix(Nx, Nx);

phinow := phi || 1;
phibefore := phi || 0;

for j from 2 to Nt do
    phinext := zeta^2 * (A . phinow + phinow . A) + 2.*phinow - phibefore;
    phi || j := Matrix(Nx, Nx);
    phinext[(1/2)*Nx, (1/2)*Nx] := fin(j*dt);
    phi || j := phinext;
    phibefore := phi || (j-1);
    phinow := phi || j
end do;


Put it into a zip file and attach that.

As Acer suggests, one way to do this is to first check whether the expression is a sum.  If so, use select, otherwise check whether it matches your target; if so return it, otherwise return 0.  An alternative method, probably not ideal but interesting, is to ensure your expression is a sum by adding a dummy term to it then using select.  An appropriate dummy term is an otherwise unused local variable to the procedure. Actually, adding a dummy term and then calling select fails for a particular corner case, can you figure out what that is, what would be returned, and devise a way to avoid it, without using a conditional?

I'm not sure what your issue is.  Do the separate worksheets share a common kernel?  That is, are you making assignments in one worksheet that are used in another?  If you are assigning procedures that are reused, you might be better served saving them to a Maple archive so they can be used by any worksheet. 

The type anything matches either factor.  Note that the type '{anything,...}', where the ellipsis indicates any types, is equivalent to the type 'anything'.  Try changing anything to indexed, then try identical(x) and identical(x^2).

When in doubt, check the manual.  In this case, the help page for type,local. See, in particular, the second paragraph.  Only symbols can be of type local. The table reference A[99] won't collide with other such expression.

Interesting question.  I may have to add an option for that, as currently Syrup does not provide a means to return the parameter values.  An alternative approach is to leave the numerical values out and substitute them afterwards. For pedagogical purposes I'll use Maple to transform your Ckt to a suitable ladder and list of parameter equations.

(**) Ckt := [v1(4), R1(50) &+ L2(0.9600), Cp(0.8200), L1(0.5000) &+ R2(0.2000), RL(1.3430) &+ LL(0.1550)]:
(**) params := map(f -> op(0,f) = op(f), indets(Ckt, 'function(numeric)'));
          params := {Cp = 0.8200, L1 = 0.5000, L2 = 0.9600, LL = 0.1550, R1 = 50, R2 = 0.2000, RL = 1.3430, v1 = 4}

(**) ckt := subsindets(Ckt, 'function(numeric)', f -> (op(0,f)));
                                        ckt := [v1, R1 &+ L2, Cp, L1 &+ R2, RL &+ LL]

(**) (sol,rest) := Syrup:-Solve(ckt, ac, returnall):
(**) P_R1_ave := (v[R1]/sqrt(2))^2/R1;
                                                    P_R1_ave := 1/2 ------

(**) subs(rest, params, P_R1_ave);
                                                            2                    2
                                           400 (0.53710000 s  + 1.26526000 s + 1)
                                               3                2                           2
                                (0.5156160000 s  + 28.06964960 s  + 64.87800000 s + 51.5430)

Actually, it wasn't necessary to transform Ckt to ckt; instead you could pass Solve the symbolic option, which tells the solver to ignore the numeric values and use the default values (the names of the parts).  You do have to be careful there, since you can use the same name for multiple parts; they will be assigned different symbols but their values will be identical.  This is useful for creating, say, an LC delay line:

(**) ckt := [V,seq('(L,C)',1..4)];
                                              ckt := [V, L, C, L, C, L, C, L, C]

(**) subs(Syrup:-Solve(ckt), v[4]);
                                              3  3  6      2  2  4          2
                                             C  L  s  + 6 C  L  s  + 9 C L s  + 1



5 6 7 8 9 10 11 Last Page 7 of 114