Do either of these get the kind of effect that you want in your Maple 13, with exact integer multiples of Pi/2 as the displayed tickmarks?

plot(sin(x), x=-2*Pi..2*Pi,
     axis[1]=[tickmarks=[seq(i/2*Pi=i/2*Pi,i=-4..4)]]);

plot(sin(x), x=-2*Pi..2*Pi,
     xtickmarks=[seq(i/2*Pi=i/2*Pi,i=-4..4)]);

The result of calling the ImageTools:-Read command is an m-by-n-by-3 Array, where the three layers are the red, green, and blue components of the pixel colors.

In the code below, you don't necessarily have to wrap the extracted layers with calls to Matrix as I did, ie. you could also just leave them as three m-by-n Arrays.

You also don't need to rescale; I only did that to make the example fit nicer in the page.

note: the embedded images look cleaner in the actual Maple GUI. This forum site doesn't render them as nicely.

image_rgb.mw

Do you care whether there are other roots outside lambda=-1..1, eg. approximately lambda=1.163 and lambda=-1.332?

What kind of evidence would "confirm" matters acceptably to you?

You haven't shown how the expression was constructed, so we cannot know whether rounding or other numeric error occurred, and whether the floating-point coefficients within it are adequately accurate.

Download Help_ac.mw

From your description, you could use regular Matrix indexing and in-place assignment, on a copy of the original.

Eg, for to copy column i into column k,
    M[..,k]:=M[..,i]:

And, in detail,

Download rowcol_copyinto.mw

If your Matrices have a hardware datatype such as float[8] and are very large, and you want high efficiency, you could also use the ArrayTools:-BlockCopy command.

Download Q20201014_ac.mw

The very first line of the Description of the Help page for Topic error refers to it as the "error statement".

There are other kinds of statement, for example the selection (conditional) statement and the repetition statement. Those also do not require brackets in that they are not called like functions (though delimiting brackets to establish grouping or operator precedence may be used).

There is also an older (deprecated) ERROR function, which is called with brackets denoting the functional application.

So I disagree with your claims, citing the above as evidence. You don't call error with a functional application because it is offered as a statement rather than a functional call. And there are indeed other kinds of statements which also can be made without a functional call, and which also do not always require bracketing (either as delimiters or to denote a functional call).

[edit] You wrote that the syntax for error is, "...different from all other Maple functions". That's because error is not called like a function, so it doesn't make sense to compare it with "other" functions. The brackets in your second example don't change the nature of the statement.

Perhaps it would help to think of error as a language keyword.

You could consider the error statement and the (old, deprecated) ERROR function along with the return statement and the (old, deprecated) RETURN function.

You can save a few characters with,

    ['A'[..,i]$i=1..4]

If you want a re-usable procedure (for Matrices of general size) then you can do as follows (this too is shorter than using seq, and so is terser than Kitonum's suggestion).

Download cols_list_proc.mw

You wrote, "...i assign stepsize to have accurate results". That is untrue -- a small fixed step-size does not -- in itself -- guarantee better accuracy.

If you are going to do something as forcing and, in my opinion, unjustified as fix a very small step-size then you may well have to raise the limit on functional evaluations.

Your call to plot of GAM(tau) suppresses the warnings about exceeding the maxfun value. You could do better here to instead use the plots:-odeplot command, which as seen below would have informed you through a warning of the problem stemming from your forced small step-size, even without raising infolevel.

But even calling GAM for tau values further toward the right end-point can show you that problem. It makes sense to test your solution, when you encounter difficulties.

Download dsolve_stepsize.mw

note: There are other reasons to use plots:-odeplot. It contains some extra smarts to try and use independent variable values dictated in part by the solver, as opposed to just calling plot and having its adaptive algorithm try and pepper the space as it wants. Just my opinion.

You have mentioned doing the "operation in reverse by hand". If that entails applying tan both sides of the equation (after isolating) then note that is not generally valid.

It does not following that A=B just because tan(A)=tan(B).

Is this the kind of thing you are trying to accomplish?

Note that (the way the conditional if..then inside your procedure lambda22sol is set up), if you call procedure lambda22sol a second time without unassigning __old_a then it will return NULL. I suspect that is why you got that error message, because you were calling it twice and so the middle column of matrix1 from the call lambda22sol(0.9) was NULL.

Download lambda22sol.mw

Download int_ex.mw

In a sense, that could be broken down into steps:  int_ex2.mw
There I replaced the numbers 2018 and 2019 by symbolic names, temporarily, to prevent awkward expansion. The following also works directly:

simplify(int(1/(x-1)+sum((k+1)*x^k,k=0..N)
                     /sum(x^k,k=0..N+1),x));

               ln(x^(N+2)-1)

There is a form, on the Software Change Request page (linked from the Mapleprimes top "More" tab).

(Rewritten question is now asked here.)

The axis mode is part of the generated plot structure (set altogether as the value property of the embedded component), and not a property of the embedded component.

You can add axis[2]=[mode=log] to the dataplot command.

>  restart; >  DetAnalysisNx2:=[seq(0..2,0.1)]: >  DetAnalysisDeterm2:=map(x->exp(x^2),DetAnalysisNx2): >  DocumentTools:-SetProperty("DeterminantenRaumPlot1",                            value,                            dataplot(DetAnalysisNx2, DetAnalysisDeterm2)); >  DocumentTools:-SetProperty("DeterminantenRaumPlot1",                            value,                            dataplot(DetAnalysisNx2,DetAnalysisDeterm2,                                     axis[2]=[mode=log]));

Download log_mode.mw

Download trig_phaseamp.mw

Yes, it can be done using plottools:-transform as follows,

f,g := 1,min(3,1/x):
P:=plot(f-g,x=0..maximize(1/y,y=1..3),filled):
plottools:-transform(unapply([x,y+g],[x,y]))(P);

Of course, you might be able to see that the upper end-point of the x-range is just 1, without having to compute that from maximize(1/y,y=1..3).

And so you might also write down either of these, directly. They each produce a plot with the region shaded.

plottools:-transform((x,y)->[x,y+min(3,1/x)])(plot(1-min(3,1/x),x=0..1,filled));

plottools:-transform((x,y)->[x,y+1])(plot(min(3,1/x)-1,x=0..1,filled));