Plotting can be done with two basic approaches: expressions, or procedures.

Here is an example of plotting an expression `f`. Notice that for this way of calling the `plot` command the second argument (which gives the range) has the name of the indeterminate variable on the left hand side of an equation. Note that expression `f` will evaluate differently if you happen to also assign to the name `x`.

f := x^2 - x;

eval( f, x=1.1 );  # evaluation at a single point

plot( f, x=-3..3 );

Here is an example of plotting with a procedure (an `arrow` operator is just a convenient way to define a simple procedure). Notice that the `x` in the definition of procedure `g` is just a dummy name. That dummy name `x` used in the definition of `g` has nothing to do with the global variable `x`, which you can still assign to without affecting how procedure `g` works.

g := x -> x^2 - x;

g( 1.1 );  # evaluation at a single point

plot( g, -3..3);

Read the manuals. I suggest you start with commands (here) rather than Clickable Math (here or here). Look for a copy of Andre Heck's book. Have a read through Robert Israel's list of Top Ten Errors (and, in this case, pay close attention to his item 1 of the 10).

If you have a problem with understanding an error message from Maple in future, and ask here for advice, then please provide detail about the error message. It's not reasonable to expect accurate help if you provide no detail. Good Luck.

I believe that an example such as,

f := x -> x^2 - x;
plot( f(x), x=-3..3 );

may confuse some new users, and is not so useful. I believe that it unnecessarily conflates the concepts of expression and procedure/operator. It is fundamental that new users get that distinction crystal clear. Slightly better is,

f := x -> x^2 - x;
plot( f(t), t=-3..3 );

but it's still not great form (IMO) to introduce an operator simply to make an expression from a function call to it. I see new users who create operators only to use them just once, to form an expression. This often devolves to something like,

f := unapply( x^2 - x, x );
plot( f(x), x=-3..3 );

where `f` is only used for that single plot. It works, but so often the new user who codes this way has little or no idea just why it works or what might break it.

acer

restart:

f:=evalf[10](Pi);
                          3.141592654

convert(f, rational);

                             104348
                             ------
                             33215 

evalf[20](%);

                     3.1415926539214210447

convert(f, rational, exact);

                           1570796327
                           ----------
                           500000000 

evalf[20](%);

                     3.1415926540000000000

acer

I see the same results in 64bit Maple 18.01, as well as 32bit/64bit Maple 16.02 and Maple 11.02, all for Windows.

I suppose that you may have already figured out that for a univariate polynomial p with real coefficients fsolve(p,x) will invoke RootFinding:-Isolate (with the method being RS by default).

If you execute fsolve(p,x,complex) then at default working precision this gets done successfully by the modified Laguerre method via the NAG c02agc function. And the root near 1.018 is in the returned sequence of roots. It doesn't resort to `fsolve/polyill`.

Offhand I don't know why Isolate's RS method goes wrong on your particular example.

I wonder whether fsolve should try both of Isolate's methods in such a case. (Well, it should certainly try something else, for an odd degree univariate polynomial with real coefficients if Isolate's method=RS returns null, since there must be one real root, as you say!).

For what it may be worth, you can reduce the typing a little, as I believe that the behaviour is the same for

-65658-18554*x-186255*x^2-97616*x^3-238885*x^4+582426*x^5

acer

Here is an attempt. This is an interesting topic, and a generalized methodology (that accomodates the limitations of how ISOSURFACE 3D plot structures work) would be useful.

(Sorry that this site renders the inlined plots poorly. They look a bit better in the GUI, and manually rotating them reveals more detail.)

Download ineq3dz.mw

acer

Why do you have to compute all the permutations before you classify them?

Why do you keep spamming this site with duplicates of the same question?

acer

Yes, it is possible.

acer

Issue the command time[real]() at the start, and assign the result to a name. Then issue it again when the student clicks, and subtract.

acer

solve does not like solve for unevaluated function calls such as your n(SPF) and n(SPH).

So change those to just name like say nSPF and nSPH (or n*SPF and n*SPH if that's what you intended). Both succeed for me in M18.01.

For example,

ineq:=-s*(-n(SPF)*tau+n(SPH))/(tau-1) <= n(SPH):
soln := solve(subs([n(SPF)=nSPF,n(SPH)=nSPH],ineq),nSPH) assuming (tau<1,s>0,s<1,tau>0):
subs([nSPF=n(SPF),nSPH=n(SPH)],soln);

acer

Do not introduce `k` and `x` with floats. Use exact quantities instead. That should get around the discrepancy in Maple 9.5.

restart;
k:=99/100:
m:=1:
x:=(Pi*csc(Pi*(k-m)))/(693/1000*GAMMA(k)*GAMMA(m)):
m1:=MeijerG([[-m],[1-m]],[[0,-m,-m],[k-m]],(-m*k)/snr):
m2:=MeijerG([[-k],[1-k]],[[0,-k,-k],[m-k]],(-m*k)/snr):
c:=x*((((m*k)/snr)^m)*m1-(((m*k)/snr)^k)*m2):
plot([Re(c),Im(c)], snr=-5..10, color=[red,blue]);

In particular, when using those floats in the definitions of `k` and `x` as you had it originally, Maple 9.5 will produce this,

restart;
k:=.99:
m:=1:
x:=(Pi*csc(Pi*(k-m)))/(.693*GAMMA(k)*GAMMA(m)):
m2:=MeijerG([[-k],[1-k]],[[0,-k,-k],[m-k]],(-m*k)/snr):

evalf(eval(m2,snr=5));

                  259.8556695 + 5.313756679 I

exactm2:=convert(m2,rational,exact):
evalf(eval(exactm2,snr=5));

                  6.225950422 - 2.656878345 I

The above may not just be a roundoff issue -- ie. increasing precision might not fix it. You might have to use exact rationals in the arguments to MeijerG.

An alternative workaround for Maple 9.5 could be to convert your `c` (or perhaps just `m2`) expression to exact rational prior to plotting, manipulating expression `c`, or querying `c` at float values of `snr`.

acer

You can do this by first creating a PlotComponent (say, with identity/name of "Plot0") and then pushing a revised plot to it with each new value computed.

In ths attached example I include a `Sleep` call merely to mimic a computation that takes some time.

ticker.mw

acer

If you intend that expression as a multiplication (and not as a compound function application) then insert an explicit multiplication sign (ie. the * on you keyboard) between the two bracketed terms.

(x-4)*(x-4);

                                   2
                            (x - 4) 


(x-4)(x-4);

                          x(x - 4) - 4

Otherwise your input would can get parsed as the function application x(x-a) - a(x-a). That is, the compound operator (x-a) applied to the argument x-a.

Note that 4 applied to x-4 (or pretty much anything) produces a result of 4.

There are some situations, including your example, where an extra blank space between the two bracketed terms would also get interpreted implicitly as a multiplication, if you used 2D Math input mode. In 1D Notation that would produce a parsing error. It can get more confusing still. I suggest getting in the habit of always using an explicit multiplication symbol, to avoid ambiguous situations with implicit multiplication.

acer

One way is to make your absolutely qualified filenames be a concatenation of a base location and some relative paths.

# Uncomment the line you want, and comment out the line you don't want.
#base:="C:/officeplace/location 1/":
#base:="C:/homecomputer/location 2/":

datafileA:=cat(base,"fileA.txt");
datafileB:=cat(base,"../../folderQ/fileB.txt");

readdata(..., datafileA, ...);
...
readdata(..., datafileB, ...);
...

Another way could be to use the currentdir command to set the current working directory.

acer

I see white grid line artefacts using f=1 for that densityplot in Maple 14.00, but they do not appear for me in Maple 14.01.

I am using 64bit Linux.

You might have to contact Maplesoft Tech Support in order to get the point-release update to 14.01, as it's no longer available here I believe.

[edited] You might be able to get the 14.01 update from here.

acer

If I understand what you want then here are two ways to form the block diagonal Matrix result, using repeats of the Matrix Q as the blocks.

restart:                 
Q:=Matrix([[1,2],[3,4]]):
N:=3:                    

LinearAlgebra:-DiagonalMatrix([Q$N]);

                         [1    2    0    0    0    0]
                         [                          ]
                         [3    4    0    0    0    0]
                         [                          ]
                         [0    0    1    2    0    0]
                         [                          ]
                         [0    0    3    4    0    0]
                         [                          ]
                         [0    0    0    0    1    2]
                         [                          ]
                         [0    0    0    0    3    4]

Matrix([Q$N],scan=diagonal);

                         [1    2    0    0    0    0]
                         [                          ]
                         [3    4    0    0    0    0]
                         [                          ]
                         [0    0    1    2    0    0]
                         [                          ]
                         [0    0    3    4    0    0]
                         [                          ]
                         [0    0    0    0    1    2]
                         [                          ]
                         [0    0    0    0    3    4]

acer

There are formatting options for sprintf (and friends) which support this directly. It is fast and lean on memory use. The code below also works in Maple 12.

> M:=Matrix(3,[[1,2,3],[4,5,6],[7,8,9]]);           

                                   [1    2    3]
                                   [           ]
                              M := [4    5    6]
                                   [           ]
                                   [7    8    9]

> parse(sprintf("%{ns}ld\n",M));                     

                                   123456789

See the help-page on topic rtable_printf for details. Within the {} brackets the qualifier `n` suppresses new lines between rows, and the qualifier `s` suppresses any space between entries.

acer