Joe Riel

7707 Reputation

22 Badges

14 years, 87 days

MaplePrimes Activity


These are answers submitted by Joe Riel

See the help page OpenMaple,C,callBackCallBack.  Then look at the source code for the example mentioned there (callBackCallBack.c); it uses a Maple-side call to callback to call the callBackCallBack C function. Basically, the purpose of callback is to invoke the user's callBackCallBack function.  

The callback function is not something you would ever call interactively from Maple.  Rather it would be called by Maple code that is being executed by an external program using OpenMaple to interact with the Maple engine. It isn't formally documented because its arguments and effect are completely determined by the callBackCallBack function, something the user defines.

How 'bout

    ModuleApply:= proc({a :: algebraic := KandR:-a,
                        b :: algebraic := KandR:-b,
                        c :: algebraic := KandR:-c,
                        e :: algebraic := KandR:-e
                       }, $)
    local opt;
        for opt in _passed do
            thismodule[lhs(opt)] := rhs(opt);
        end do;
      return NULL;
   end proc;

That is a demo of the Intermediate Axis Theorem, which can be readily modeled using MapleSim, see IAT.msim.  MapleSim uses Maple as the engine. While it is possible to extract the Maple equations that are generated, for this example they are not particularly enlightening and too large to post here.

Internally, Maple reduces the first, (x^2 + y^2 = 1)^2, to x^2 + y^2 - 1.  It doesn't modify the second, (x^2 + y^2 -1)^2 , and solving that is considerably more difficult for a numerical solver as the expression never crosses zero.

This is explained in the help page worksheet,documenting,styles.  Here's a summary

Click Format > Styles and then modify the character styles appropriately.

Click Format > Manage Style Sets and then Export your style set.  After doing so, click User-defined Style Set radio button and select the mw file to which you exported the style.  Click OK and it should then be used as the style set for new worksheets.

You have to use the tensor product to create the metric, and use, say, dtheta, to refer to the base one-form, not d(theta).

  g1 := evalDG(dr &t dr + r^2*dtheta &t dtheta);

There is a minor issue with calling rand directly in your dice procedure; each call generates a separate procedure. Doing so is more expensive than necessary.  It also isn't clear how this affects the random sequence obtained. Here's an approach that uses an appliable module to ensure that rand is only called one time.

dice := module()
local ModuleApply, ModuleLoad, die;
    ModuleLoad := proc()
        die := rand(1..6);
    end proc:
    ModuleApply := proc()
        (die(), die());
    end proc:
    ModuleLoad(); # needed because this module isn't being loaded from a library
end module:
seq([dice()], 1..4);
    [5, 2], [5, 6], [2, 3], [4, 4]

Note that the ModuleLoad isn't needed here, rather die could be directly assigned rand(1..6) in the module body, however, if this were being written to a Maple archive (library) it would probably be better to delay the assignment to when the module is loaded, versus when it is assigned.

Another possibility is to use select:

L1 := [[1],[2]]:
L2 := [[3],[1]]:                                                                                                                                                                                    L2 := [[3],[1]]:
select(member, L1, L2);
                          [[1]];

Note that the handling of repeated items is problematic, both with this and the set approach.

While there is nothing wrong with using a Vector, another approach is to use a list. For example

iterativepower := proc(base, index, n :: nonnegint)
local k;
  [seq(base^(index^k), k=0..n)];
end proc:

Unless you're interested in the discrete steps, it might be better to look at base^p, as p increases. This can be easily plotted, here with base=1+I:

plots:-complexplot((1+I)^p, p=0..25);

Before using subsindets or evalindets, it's usually a good idea to call indets to see what expressions are being operated on. Thus

x := u(i, j)^2*v(i, j)+u(i-1, j):
E := indets(x, 'specfunc(symbol, u)');         # --> {u(i, j)}
F := indets(x, 'specfunc(`+`, u)');            # --> {}
G := indets(x, 'specfunc({`+`, symbol}, u)');  # --> {u(i, j), u(i - 1, j)}

That makes sense to me (see Carl's comments for details). A variation of this is to use an unassigned symbol for the applied function in the call to subsindets:

subsindets(x, 'specfunc(symbol, u)', Z);
      Z(u(i,j))^2*v(i,j)+u(i-1,j)

I'll suggest the following.  Create a Maple module, with option package, and with exports of the desired constants, procedures.  Save this to an mla as a  Maple toolbox.  You will then be able to access any of the procedures/constants from any worksheet by using the module.  Here is example code of how you might do this (it both creates a trivial module and saves it to a toolbox).

# Code to create a simple Maple toolbox for storing constants and whatever (the exports)

MyConstants := module()
option package;
export SpeedLimit;
    SpeedLimit := 65;
end module:

# Temporary procedure to create, if needed, the toolbox directory

MakeToolbox := proc(toolbox :: string)
local dir;
uses FT = FileTools;
    dir := FT:-JoinPath([kernelopts('homedir'),"maple","toolbox", toolbox, "lib"]);
    if not FT:-Exists(dir) then
        FT:-MakeDirectory(dir, 'recurse');
    end if;
    dir;
end proc:

# Create directory and path to toolbox mla
dir := MakeToolbox("MyConstants"):
path := FileTools:-JoinPath([dir, "MyConstants.mla"]);

# Save the module (MyConstants) as a toolbox.
LibraryTools:-Save(MyConstants, path);

You can then access any of the exports (here just one, SpeedLimit) via MyConstants:-SpeedLimit, or do with(MyConstants): and then use SpeedLimit alone. In a procedure you should use a uses statement. If you save all the code above in a worksheet, and then edit the module as desired, you should be able to reexecute it to update the toolbox.

I'm assuming you have a new enough Maple that automatically picks up toolboxes put in the appropriate place.  If not, then you'll probably need to create a Maple initialization file and use it to assign the global variable libname to include the path to an mla file. That was always a sticking point for people new to Maple; the use of toolboxes simplifies the operation. 

It's not too hard to see that the only real solution for eq6 occurs at the limit when Dmax=0.  It's then easy enough to substitute that into eq7 and eq8 and solve for deltaH and de.

limit(eq6, Dmax=0);
                      0
solve(eval({eq7,eq8},Dmax=0));
              {de = -2.638478742, deltaH = 6.260000000}

I suspect that Dmax=0 is not an allowable solution, in which case there are no real solutions.

Use the :: operator rather than = to assign a property name to a variable.  While I don't know why using 'real' doesn't work, the 'realcons' property does. 

Use the method that Carl suggested, but append additional t's to the call to diff. For example,

f:= (t,y)-> -y + t*y^(1/2);
diff(f(t, y(t)), t);   # first derivative
diff(f(t, y(t)), t,t); # second derivative

Alternatively, use

diff(f(t, y(t)), [t$3]); # third derivative

You could use subs, however, you'll have to substitute for both the term and 1/term. Here's a slightly different approach, which replaces the expression of interest with the variable tmp

subsindets(X, 'anything^And(rational,(Not(integer)))', p -> tmp^signum(op(2,p)));

As a practical matter, you'd first want to inspect the elements that match the type in the subsindets call. Do that with

indets(X,'anything^And(rational,(Not(integer)))');
   {1/sqrt((n__x^2+n__y^2+n__z^2)*c^2), sqrt((n__x^2+n__y^2+n__z^2)*c^2)}

Maybe the better way is to first assign the expression of interest to a variable, then use subs

expr := sqrt((n__x^2+n__y^2+n__z^2)*c^2):
subs([expr=tmp, 1/expr=1/tmp], X);
2 3 4 5 6 7 8 Last Page 4 of 100