@Markiyan Hirnyk I agree with Carl and Kitonum about the specifics of what's going on in your example.

Given that fsolve does not allow options to control working precision separately from tolerance (for x, or for forward error of g(x)) then if you expect a specific number of correct digits in the result then the problem must be formulated to allow that to happen.

Your originally created piecewise never gets close enough to VP[14]. The piecewise you created has jump dicontinuities and  never gets close enough to VP[14] for any x value to be accepted as a root.

Your original piecewise minus VP[14] never attains a value smaller in absolute value than 1e-7 for any x, unless the expression is evaluated at very low (yes, low) working precision. Eg,

forget(evalf);
evalf[7]( g(0.02612015) - VP[14] );

                                     0.

So Carl and Kitonum are correct in the sense that your originally constructed piecewise does not attain -- closely enough -- some of the VP[i] values for any x value to be taken as a root with say 10 correct digits.

But the problem is that fsolve does not allow one to specify absolute or relative tolerance on x, or a tolerance on f(x). Instead fsolve uses Digits to construct its tolerances internally, and provides no finer control or specification by the user of what close enough means. I believe that it is resonable to object to this narrow behaviour by fsolve; it would be better if tolerances were allowed as separate options, so that acceptance criteria did not just depend on Digits.

With the current way that fsolve accepts a value as being a root, you have two choices: 1) Temporarily increase Digits when forming g, so that acceptable roots exists at your current Digits, or 2) Construct g at your current Digits but note that acceptable roots then exist when the expression is evaluated at low enough Digits.

Note that when you increase Digits just a little, for initially forming the piecewise, the places where problematic jump discontinities cause problems can appear  more relatively severely at x values different than before.

On my 64bit Maple 2015 for Linux a value of Digits=13 for initial construction of the piecewise where the jump discontinuities were insignificant enough that fsolve found 15 roots when Digits=10. On another OS it may be necessary to go higher, for the initial construction to actually have acceptable roots.

I've tried to illustrate some of this below.

Download fsolveex.mw

I learned a lot by reading closely the solutions and answers given by experts, to questions posted in public forums. For me that included reading everything that Robert Israel and Joe Riel posted on the USENET newsgroup sci.math.symbolic in the early 1990s (and later, in comp.soft-sys.math.maple).

There are also lots of great answers archived on this Mapleprimes forum. You could do a lot worse that start with the Answers posted here by Joe and Robert. Of course there are several other members here who frequently post great answers.

Another thing that I believe has helped some people gain in their advanced understanding of Maple is reading the source code of stock Library routines. Some packages, such as Statistics and Finance, are dense thickets of OO methods. And some other packages have a completely differenct style. Some routines are old, and some are new. Even without comments I find them fascinating to read. Commands that can help in looking at them include showstat, kernelopts(opaquemodules=false), interface(verboseproc=3), and print.

acer

In Maple 2015.1 this works (for me) as you expected,

indets(expr, HODD &under (convert, compose, `D`, `global`));

Maybe the next step is poking inside it, while using something like,

indets(expr, HODD &under (proc(q) local orig, res; orig:=convert(q,D); res:=convert(orig,`global`); end proc));

The conversion to `global` might be a red herring. But what is the difference between `orig` and `res` inside that custom procedure? Inside that custom proc both orig and res appear to be of type HODD. Time for hackware... but no time right now for me...

I understand that you know several other ways to get the desired answer. I interpret your question as being about what is going wrong, specifically, when it's done under AddType. On that note I'd first change the dummy name `D` in this to something else, even though it's very likely of no consequence. (One has to start somewhere, before digging into AddType...)

satisfies(D-> nops([op(D)]) > 1)

acer

The Programming Manual included in Maple 2015, in PDF format.

The Programming Manual included in Maple 18, in PDF format.

See the Documentation Center for such material.

acer

This problem is #8 on Robert Israel's list of Top Ten Maple Errors.

acer

Look in the Startup Code of a MathApp, to see the definitions of the procedures, modules, etc, accessed by its embedded components.

If you right-click on an embedded component you'll see a popup menu with an item like "Edit Value Changed Action". Selecting that menu items raises a popup editing window with the "action code" of the component. This is the code that gets executed when you move a Slider, press a Button, etc.

Most of the MathApps have very brief "action code", mostly function calls to procedures or modules that are defined elsewhere, in the Startup Code region of the App worksheet.

MathApps are worksheets that are stored in the Help database, rather than in the Library archives. That's not relevant to finding the action code. I just wanted to clarify the wording.

acer

Download discrim.mw

acer

There are some situations where one does not want any expansion (or simplification) to occur other than the simplest arithmetic changes necessary to find a polynomial pattern by algsubs.

In some such cases it can help to frontend the expand call.

In the following example, I'd prefer that the 1-cos(y+v)^2 is left alone, say.

Download frontend.mw

acer

int((a/2)*exp(-a*abs(x)),x=-infinity..infinity) assuming Re(a)>0;

                               1

Or, if a is to be real, then under the assumption that a>0.

acer

If you don't want to use the right-click context-menus then... just type out your command instead.

Also, it looks to me as if you wanted to map the commands over the whole Matrix and not over just the [1,1] entry. Yes?

Download matrixmap.mw

acer

Yes, you can inline 2D Math into text sentences in a Document.

Use Ctl-t to toggle into text mode. In that mode you can type sentences. In mid-sentence you can use Ctl-r to toggle into 2D Input mode. And then you can toggle back to text. 

Such inlined 2D Math will not evaluate, unless you cause it to be evaluated. That is, by default it is inert 2D Math. The way to evaluate it inline is to select it (or have the cursor inside it) and then to use the keystrokes Ctl-=.

Ctl-t means the Control key and the lowercase `t` key pressed simultaneously. Similalry, Ctl-= means the Control key and the `=` key. That's on MS_Windows. On OS X (Mac) it is Command-= instead of Control-=. See here.

Here's a Document that I just made in Maple 2015 on Windows.

Download textandinlinedmath.mw

Note that once such inlined math is evaluated inline (within some text) it cannot be turned back into inert 2D Math. In can be deleted, though. If you change the code which assigns to `f` say, and then reevaluate the whole worksheet then the previously evaluated inline math involving `f` gets reevealuated and shows the new assigned value.

You can change the style used for displayed 2D Math output so that it appears black instead of blue. That's just part of the usual customizing of styles (character, paragraph, etc) that can be done within a Document,

acer

I'm not sure how you (or Maple TA) is generating the random aspects of the assignments. But you might try forcing the random seed which is used by several of Maple's internal random number generators. (Ie, the TA process might fortuitously happen to rely on this. You could at least try it..)

See the randomize comand. The idea is that you could try forcing its r parameter (the random seed) according to each student, at the start of the code which generates the assignments.

acer

On way to get that effect is via piecewise structures.

Download 2Dplotcolor.mw

plot3d supports a colorfunc option to use a procedure for coloring. The plot command should be given that as well.

acer

You might prefer the result if you used inert Sum instead of active sum. The latter is producing the GAMMA calls which you had trouble getting rid of.

Download LW.mw

acer

You could try something like this, with alias.

Download aliasedlatex.mw

acer