Carl Love

Carl Love

24342 Reputation

25 Badges

9 years, 357 days
Natick, Massachusetts, United States
My name was formerly Carl Devore.

MaplePrimes Activity


These are answers submitted by Carl Love

Yes, the transformation can be done more easily and more universally like this:

`convert/atan2`:= rcurry(evalindets, ' 'arctan' '(algebraic), arctan@op@[numer,denom]@op):

You can store that in your personal library, module, or initialization file.

Example usage:
eq:= phi = arctan(A/B) - arctan(B/A):
convert(eq, atan2);

             

It makes no difference how complicated the target expression is or how many arctans it has. It'll even work on nested arctans. 

It's very likely that your integrals can be speeded up by adding the option numeric to their integration commands, for example,

int(sin(x), x= 0..Pi, numeric)

But Maple Flow is a listed choice. As you can now see in your Question's header, I edited it so that Maple Flow and MaplePrimes have been checked.

Sorry, I misunderstood your Question (due to my relative lack of familiarity with the "tabs" in MaplePrimes compared to the controls and check boxes that I often use for editing Questions and Posts). You are correct that it's missing and should be listed.

Like this:

y:= <1,2,3,4,5,6>:
x1:= <10,20,30,40,50,60>:
x2:= <0.1,0.2,0.3,0.4,0.5,0.6>:
#Note that I entered the above with angle brackets to make them vectors rather than lists.

plots:-dualaxisplot(
    plot(<y|x1>, labels= ['y', 'x1']),
    plot(<y|x2>, labels= ['y', 'x2'])
);

There are two lines plotted. It only looks like one line because, of course, in this case one line is on top of the other. You can also plot points instead of lines, or any combination of the two.

anti:= int(1/(a+x^(1/5)), x);
simplify(allvalues(combine(%)));

See the help page ?Explore. The Explore command displays its results (which could be plots, animations, regular output, or any combination thereof) in a different interface than Maple's usual. It allows for any number of parameters with on-screen controls.  

You wrote:

  • So I am guessing what happens is this: doing DEtools:-name_of_solver Maple first searched for a proc called name_of_solver inside DEtools package, and found none. So it does not work.

Correct.

  • But adding eval first, then name_of_solver is evaluated and replaced by abelsol and after that the call is made, and it then finds this proc inside the DEtools package.

Correct, although I'm surprised that that use of eval is allowed.

  • But my question is, why is eval needed here? Is it not automatically happens that a variable is replaced by its value?

Evaluation/replacement does not happen to the operand on the right side of the :- operator, with good reason, explained below. If you want the evaluation to happen, you should use DEtools[name_of_solver].

  • Why the rule of evaluation is different in this case?

A module's exports are a form of local variable. If the :- operator didn't work the way that it does, then how would someone writing a module know that the names that they used for the exports weren't being used as globals?

Here's my procedure for the lexicographic product of graphs. I made it work for any number of factors.

LexProd:= proc(G::seq(Graph), $)
uses GT= GraphTheory;
local
    LexProd2:= proc(G::Graph, H::Graph)
    local 
        (Vg,Vh):= op(GT:-Vertices~([G,H])),
        (ng,nh):= op(`..`~(1, nops~([Vg,Vh]))),
        (Ng,Nh):= op(op~(4, [G,H])),
        i, j, J,
        P:= [seq](seq([i,j], j= nh), i= ng),
        k:= 0, K:= table((p-> op(p)= ++k)~(P))
    ;
        GT:-Graph(
            (curry(nprintf, "%a:%a")@((i,j)-> (Vg[i],Vh[j]))@op)~(P),                
            (
                ((i,j)-> {
                    seq(seq(K[k,J], k= Ng[i]), J= nh), 
                    seq(K[i,k], k= Nh[j])
                })
                @op
            )~(P)            
        )
    end proc
;
    if nargs=0 then error "at least 1 graph needed"
    elif nargs=1 then G[1] 
    else foldl(LexProd2, args) 
    fi
end proc
: 

 

If you cube both sides of the equation to remove fractional exponents, then you'll get 3 solutions, 2 of which are trivial, and the 3rd is much simpler than your solution above. Using odetest~ quickly returns 0 for all 3.

restart;
ode:= diff(y(x),x)^3 = x^3*(y(x)^2-1)^2;
sol:= [dsolve](ode);
odetest~(sol);

 

If you just want to extract column j as a vector from matrix M, you could use M[.., j]. And unlike the Column command, this simple indexing also works on the left side of the assignment operator.

You are correct that the underlying issue is closely related to MutableSets being object modules. The "recommended way" would be for Maplesoft to include a ModuleType procedure in the object definition of MutableSet. It's a shame that they haven't, and it seems ridiculous to not do so for any container object (such as MutableSet).

You can use this as a workaround:

M:= MutableSet(a, b, c);
type(M, And(MutableSet, set(symbol) &under (convert, set)));

In a procedure header, that could be

proc(M::And(MutableSet, set(symbol) &under (convert, set)))

In either of the above, replace symbol with your desired type for the elements. 
 

Your method of writing to a file which you then reread to get the result of a simple computation that's been displayed as userinfo is extremely convoluted, slow, and low precision (4 digits). Instead, just do that simple computation, which in this case can be done by the command LinearAlgebra:-NullSpace. So, you have a 3-column matrix named blu. You consider each row of blu to be the normal vector of a plane. You want a basis for the vectors in that plane. If you want to do this for the ith row of blu, then the set of 2 basis vectors is simply

LinearAlgebra:-NullSpace(blu[i]);

This can be done for the entire matrix blu with a single command. There are numerous ways to do that depending on the exact output format that you want. For example, the following returns two 3x200 matrices B1 and B2 such that the ith column of B1 is the first basis vector corresponding to blu[i], and that of B2 is the second basis vector:

(B1,B2):= map(`<|>`@op@op~, [1,2], LinearAlgebra:-NullSpace~(convert(blu,listlist)))[];

That command uses 0.12 seconds on my computer to do all 200 rows.

There are a few reasons why it doesn't work, and several ways to fix it. I'm guessing that you intend for x1x2x3 to be the roots of eq? But you never substituted them in for x in eq. I think this is the simplest fix that does what I think you really want:

restart:
eq := x-> a*x^3 + b*x^2 + c*x + d;
 s := x1 + x2 + x3 = -b/a;
 sp := x1*x2 + x1*x3 + x2*x3 = c/a;
 p := x1*x2*x3 = -d/a;
sol:= ()-> solve({eq~([x1,x2,x3])[], p, s, sp}, {x1, x2, x3},explicit);
sol(); #no solution, yet                       
 a := 1;
b := -5;
c := 6;
d := -1;
 sol(); #very long solution quickly returned   

 

It seems to be a bug such that the columns of the selector matrix A are used in reverse order. You can use this instead:

eval~(`if`~(A, B, 'NULL'));

If I ignore the typeset formulas in your Question---which necessarily have errors as alreadyb pointed out---and I focus instead on the text of your Question, then I think that the command BesselJZeros is the major part of the solution. See help page ?BesselZeros.

First 6 7 8 9 10 11 12 Last Page 8 of 356