That message (about int being protected) can occur with Grid:-Map in at least in some old versions, eg. Maple 16.

You might pass a user-defined procedure instead, eg.

Download Gr_M16.mw

You could find both tangents to the hyperbola at x=0.504244923, and then select which touches close to y=0.3781836925.

Download hyp_tang.mw

The Compiler does not know how to handle the syntax ++n and val += FN, and that's where that error message arises.

But it hardly matters, since the Compiler is not aware of combinat:-fibonnacci. You could have that problematic statement "escape" temporarily back to Maple proper, by wrapping in an eval call.

But adjusting the syntax and escaping the combinat:-fibonacci call will not -- in itself -- result in faster performance.

This looks like a contrived example, perhaps constructed to investigate compilation, etc. If so, then it might be better to tell us any other goals in detail.

It can be shown to be true (via is and combine) in a 1-line statement for your conditions r>0, r<1. (Also for the wider r>-1, r<1.)

C1 := sqrt(r+1)*sqrt(1/(r-1)):
C2 := -sqrt(r^2-1)/(r-1):

is(combine(C1-C2)=0) assuming r>0, r<1;

             true

is(combine(C1-C2)=0) assuming r>-1, r<1;

             true

note: Such situations in which an extra call to combine (or simplify, say) is needed (in order for is to get the result) are quite rare in my experience. Like obscure corners of lepidopterology. I have reported only a few such, over the years. I'll submit a report for this one too.

I prefer solutions in which the "4" does not get rendered in italics (as if it were a name...).

plots:-loglogplot(x, x = 0.1*10^(-5) .. 10,
                  title = 10^Typesetting:-Typeset(-4));

plots:-loglogplot(x, x = 0.1*10^(-5) .. 10,
                  title = 10^(-`#mn(4)`));

plots:-loglogplot(x, x = 0.1*10^(-5) .. 10,
                  title = `#msup(mn("10"),mrow(mo("&uminus0;"),mn("4")));`);

plots:-loglogplot(x, x = 0.1*10^(-5) .. 10,
                  title = InertForm:-Display(`%^`(10,-4),inert=false));

You won't be able to get 23333.33 after rounding to 6 digits, since that requires 7 digits.

Here are a few ways:

Download Matrix_dec.mw

You could use a kind of identity procedure that has its first procedural parameter declared with the uneval modifier.

Download expr_equals_evalexpr_ac.mw

It works in Maple 2017 onwards.

If you copy&paste that pretty-printed output then what you get pasted in contains,

    1/(4*(x - 2))

And that becomes 1/(4*x - 8) due to automatic simplification.

However, if instead you line-print rf using the lprint command then you can get a (more correct and accurate) input form, which here happens to not automatically simplify.

Download lprint_pasted.mw

ps. As a long-standing habit I almost never copy&paste from 2D Output, due to various historical issues and problems with doing so. I usually copy from line-printed form.

Those are available in my Maple 2021.1 from the Large Operators palette.

Here's a way that doesn't require the ad hoc steps either of having to enter 3/100 manually or of having to refer to subexpression position via subsop. (It's so ad hoc that one might as well manually and explicitly write out the desired result, with protection against automatic simplification.)

Retaining the number of trailing zeroes (or not) is possible, but more effort.

Download some_float_thing.mw

Also, we don't know whether you want a result that can be further manipulated (I guess so), or just a nice printing of the desired form. That can affect how some approaches are set up. Please provide the context.

An alternative is to freeze (or equivalent) the floats, after pulling off their sign. Then factor, revert while protecting against automatic simplification, etc. The trick there is ensuring that any minus-sign doesn't accidentally also get factored out front...

Your worksheet seems to have been last saved by you in Maple 13.

Using Maple 16.02 (the oldest I have at hand) it succeeds for your tau_l=0.8 if Digits is raised for the computations done prior to the problematic fsolve call, and if Digits is temporarily reduced for that call.

Download ACCOLLEY_Delali_-_Demographics_3_ac.mw

Download mover_ex.mw

In the last example above the result is an actual expression (which you could further manipulate programmatically if you wanted). It is an unevaluated function call to the unassigned global name queryequal.

In 2D Math entry mode you could get a similar rendering effect directly on input, by using the Layout palette for placing ? above =, etc. Here's what I got with that approach. I put in an extra space on either side of the symbol, and the result was this multiplication of terms. (I don't find that useful for further manipulation. But you could also just use the palette approach for non-executable 2D Math used for discourse rather than further computation.)

Download mover_2dinput.mw

Your original expression assigned to r is or type `+`.

Hence when you map something over that the result will also be a call to `+`. The new summands will be whatever is returned by f, when passed the operands of r. That's some fundamental behaviour of map.

When your procedure f has a call to print as its last statement then it will return NULL, because print returns NULL. That's the difference. In your second example (using print) the result from your map call is NULL, as the addition of the various NULL return values from f.

When you have your procedure f return lists then they too will be added under `+`, when f gets mapped over r. But the manner in which you repeatedly concatenate global list L makes the lists be of different lengths, so adding them is not sensible.

Perhaps you would rather have the procedure f return the operand Z itself, or perhaps NULL explicitly forced, or perhaps Z^2 the result of the action.

different.mw

I leave it to you to decide what reasonable thing you want procedure f to return. (That changing list L is not such a choice...)

The 5rd bullet point in the Description of the Help page for map states,

   "The result of a call to map (unless the fold or reduce option
    described below is used) is a copy of expr with the ith
    operand of expr replaced by the result of applying fcn to the
    ith operand. This is done for all the operands of expr. For
    expressions of type atomic, map(fcn, expr) is identical to
    fcn(expr). For a table or rtable (Array, Matrix, or Vector), fcn
    is applied to each element instead of each operand."

So if you map f over a sum then the result is the sum of f applied to the operands (summands). If you map f over a product then the result is a product of f applied to the operands (multiplicands). And if you map f over another function call then the result is that same kind of call, now made over f applied to its original operands (arguments). Ie,

map(F, a*b*c/d);

  F(a)*F(b)*F(c)*F(1/d)

map(F, a+b+c);

      F(a)+F(b)+F(c)

map(F, g(a,b,c));

    g(F(a),F(b),F(c))

By the way, I don't see why you want to build list L in such a recursive (augmenting) manner. More efficient could be something like, say,

I prefer the first approach below (as Tom suggested) since it's a very easy way to avoid the inefficiency of recomputing h(a) multiple times.

Download ds_rf.mw