You already have the exact value. (The cube root of 2 is irrational, and a positive integer multiple of it is also irrational and cannot be expressed exactly as a rational -- if that's what you were expecting. That's mathematics, not just Maple.)

You can get a floating-point approximation using the evalf command.

C__temp1:=2^((105-25)/6);                                                         

                                 (1/3)
               C__temp1 := 8192 2

evalf(C__temp1);                                                                  

                    10321.27324

evalf[20](C__temp1);                                                              

                10321.273240738800966

When you load a package using the with command Maple rebinds the global name, such that a newly parsed expression will use whatever is the current binding of the name.

Several people throw around the term "overload" for this rebinding process, but that is a mistake. In Maple the term overload has quite a different technical meaning, and it's incorrect and wrong to mix up the two.

There is a procedure VectorCalculus:-`.` which is one of the package exports of the VectorCalculus package. When the VectorCalculus package is loaded, say by executing with(VectorCalculus) the name `.` is rebound to VectorCalculus:-`.` and that is what then gets called in your second example.

Your second example called with(VectorCalculus); but you omitted to show  the output displayed by that call. It contains a list of all the name that have been rebound to the package exports. One of those names printed is `.`, and by looking at that output and by reading the Help page for the with command you should be able to figure out that there is a VectorCalculus:-`.` export.

You can even utilize that export directly, without the whole package being loaded (as a prefix call rather that a infix call, however):

restart;
VC:=VectorCalculus:
f:=y*sin(x)+y^2:
VC:-`.`( VC:-Nabla, VC:-Nabla(f,[x,y]) );

                    2 - y sin(x)

The act of rebinding the name is done via the (undocumented) bind command, which the with command utilizes. Similarly the unwith command utilizes the (undocumented) unbind command. These work like a stack, such that calling unwith will restore the previous binding. I don't recommend anyone using bind and unbind directly; utilize with and unwith instead.

In this stack model, the last rebinding is what gets used. If you load the plots package then Maple rebinds the name arrow to plots:-arrow. If you subsequently load the plottools package then Maple futher rebinds the name arrow to plottools:-arrow, replacing the previous binding. If you then unload the plottools package then the binding of arrow reverts to the previous binding to plots:-arrow.

The name management functionality offered by with/unwith is there to assist people and make common operations easier. It cannot offer perfect management of the namespace because such a thing is impossible: there are cases where two different people want two different behaviors under otherwise identical circumstances.

So there will always be cases where qualifying commands names (using the colon-minus syntax to distinguish between different exports from different packages, and the global names) is necessary or highly preferable.

The mechanisms for "overloading" a name so that a procedure is able to dispatch according to the type of the arguments are different and distinct from rebinding. But the rebinding mechanism and the overloading mechanisms can be constructively utilized together, and together they make for even more power and flexibility of managing the command namespace.

In current Maple there is an overload option for procedures which can allow for a dynamic dispatch functionality according to argument type, say. In other words the code's branches off, according to the type of the arguments. But even before that option was introduced a procedure could be written to examine its arguments and dispatch dynamically.

Several packages have exports which examine the type of the arguments and, according to what is discovered, either do a computation or return a call to the global instance of the same or similar name. For example, Units:-Standard:-`+` will eventually return an expression in terms of the usual global :-`+` after dealing with units or if no units were detected. But some other commands (whose name happens to match a global version) will return as an unevaluated call to themselves rather than to as a call to the global version. There are no hard and fast rules -- the functionality needs, implementations, strengths and weaknesses vary.

Another related piece of functionality for dynamic dispatch involves the static exports of an object.

There is a great deal that could be written about these topics, and I'm not about to write a book here. I suggest reading the Programming Guide and relevant Help pages, and then asking specific questions about specific examples as wanted.

Hopefully I have not misunderstood your intention.

Once I'd set up cartesian coordinates under VectorCalculus I used command-completion in 2D Input.

I typed Del and pressed the Escape key (for Maple GUI command-completion on my Linux), and picked the entry "Del (divergence)" which shows the Nabla-dor markup.

Then I typed Gradient and pressed the Escape key, and picked gthe entry "PhysicsGriadient" because, well, because it seemed to show the right 2D markup.

Here's the result. I used 2D Input only for the line in question. I also include what the input converted to as 1D Notation.

Download VC.mw

It also worked for me if (in 2D Input mode) I used the "Del" entry from the "Common Symbols" palette, along with either a typed period or the center-dot from the same pallete. But I used just f, having already set the coordinates.

Escape the doublequotes, eg.

-c 'path:=\"/home/eduardo/examples\";'

@janhardo Your procedures are named InflectionF which is capitalized, but you accidentally tried to call them as uncapitalized inflectionF.

You should generally not have your procedures rely on having loaded a package at the top-level by the with command. It's better (IMO) to utilize the uses facility within a procedure body, or to utilzie the fully qualified names for commands. I show one way to do that below.

Your declaration of G as local is enough. Your attempt to declare G[1..6,1] as local is invalid. I corrected that.

I leave it to you to add the interval as an additional parameter for your procedures.

Download betounes_ex_set_2_opg_6_ac.mw

I suggest that you also add the name x as a local to your procedure, if you intend to continue to utilize it as a dummy name therein. Otherwise your procedure will not work if the name x has been assigned, say, a numeric value at the higher level.

You can use the maplemint command to get an idea of which names in your procedure should be guarded against colliding with assigned values at the higher level. I include this attachment, for some ideas on making your procedures robust against collision with assigned global names.
  betounes_ex_set_2_opg_6_maplemint.mw

Your procedure foo returns an unevaluated name if it is passed a name and is not passed an actual table. And not just any name. Your procedure foo returns the very same name that it is passed (when passed a name).

Even though the formal parameter of foo is specified to have be of type table, it also accepts any name which evaluates to a table. It allows that because tables have last-name-eval, so that they can be operated on in-place as a usefully behaving mutable structure.

The returned name happens to evaluate to a table, unless you somehow unassign it -- which can be done in a few ways.

In your first example B does not get assigned a table per se, but rather B gets assigned the returned, unevaluated global name A which was passed as argument in the call to foo. Your first example unhelpfully used a colon to suppress the output. I change that to a semicolon, which shows that a call to procedure foo returns the name that was passed. Since that A evaluates to a table then a subsequent, full evaluation of B does also. But notice that a 1-level evaluation of B returns just A the name.

restart;

foo:=proc(A::table)
  A["c"]:=3; #add new field
  return A;
end proc:

A:=table():
A["a"]:=1:
A["b"]:=2:

B:=foo(A);
                      B := A

eval(B);
          TABLE(["a" = 1, "c" = 3, "b" = 2])

eval(B,1);
                         A

In your second example you are assigning the unevaluated name A (both passed in the call to foo and also returned by that call to foo) to A itself. You are not explicitly (re)assigning any table to A, but rather you are assigning a name that would evaluate to a table (unless it were reassigned something else -- which is precicely what's happening here!). Recall, foo returns a name, not an actual table.

In the second example your call,

   A:=foo(A);

is assigning the unevaluated name A to A itself. You have probably seen that kind of thing before. It is a common way to unassign a name:

   A := 'A';

In other words, your second example happens to assign to A its very own name, unevaluated. That unassigns it.

That should be enough to explain your second example. It assigns the unevaluated name A to itself. And so A no longer evaluates to anything else.

Of course, if you passed foo an actual table (for example, the value to which A evaluated after its original assignment) then it would also return an actual table.

A:=table():
A["a"]:=1:
A["b"]:=2:

eval(A);
                   TABLE(["a" = 1, "b" = 2])

A:=foo(eval(A)):
eval(A);

               TABLE(["a" = 1, "c" = 3, "b" = 2])

As I mentioned at the start, your procedure foo returns the same name as it gets passed. I think that your examples would be a bit less confusing if it used another name for the formal parameter of the procedure foo. The examples would behave the same if foo were defined as follows:

foo:=proc(H::table)
  H["c"]:=3; #add new field
  return H;
end proc:

Lastly, there are other things with last-name-eval which would also be unassigned by your second kind of example. For instance, procedures also have last-name-eval, so your procedure foo also unassigns f below.

Download LNE_example.mw

Is this adequate?

Download type_list.mw

Was the "extra" information to ban repeats there when I first answered this? I don't recall seeing it. But perhaps I didn't notice. If I'd noticed then my answer would include a check for nops of the list. The key thing is the identical(a,b,c,d) I suppose.

The implicit declaration of `a` as local happens when the procedure is created, as opposed to when it is run. In your second example both `a` and `b` are implicitly declared local variables.

So, after the procedure is created, it is the same as if it were defined using,

   local a,b;

So the line

   b:=a+10;

will access the local instance of `a`.

It's unclear to me why you would expect 20 for the second example's returned value. (You didn't explain your reasoning.)

The following behaves just as you have originally described. The originally posted question was this:

   How can I create an even function in Maple—i.e. g(−x) = g(x)—so
   that g(−3) returns g(3), g(10) returns g(−10), and so on?

I'm, not sure that's really what you after, though. Did you want it to compute anything more concretely?

g:=proc(ee)                                        
   return 'procname'(-ee);                          
end proc:

g(-3);
                g(3)

g(10);
                g(-10)

g(-x);
                g(x)

g(x); 
                g(-x)

g(0);
                g(0)

Here are three ways to deal with the issue. They each require providing a numeric value for a, but they proceed in different ways. See the comments.

(I merged the plots only to keep the sheet short. You can do as you prefer, of course.)

Download Help_ac.mw

The error message explains the problem. You are passing as invalid argument to the rhs command.

You are passing den1 to rhs, but the value of den1 is not an equation or something with a right-hand side.

The problem is not with the plot3d command. It is within the subs call that you are passing as its first argument.

Perhaps you meant to substitute values for lambda and w into den1 as follows:

Download 23May_1_ac.mw

By the way, there is no package plot so your call   with(plot)  is incorrect.  But note that you do not need to load   with(plots)   in order to call the plot3d command.

ps. Your attachment was saved in Maple 18, not Maple 2018 which is  much later version. I have adjusted your Question's header appropriately.

You make the loop work more complicated that it has to be, I think.

There's no reason to use a loop to contruct the Array of colors. It just makes unnecessary clutter.

Don't use a set with {} inside the call to plots:-display if you want a particular order for the plot legends to appear. Use a list instead (or no container) for which you can force the order.

Here are two ways to get a prime effect in the legend. There is a typesetting entity `⁗` which renders as four close prime symbols, but for derivatives higher than 4th that it normally renders as (5) etc in the superscript. There are also several ways to supress the (x) function application in the legend -- let me know if it really matters to you. You may find it a tradeoff, between convenience and appearance.

Download betounes_ex_set_task_4def_acc.mw

The following is slightly terser, using a loop only for the derivative construction (as asked).  betounes_ex_set_task_4def_accc.mw

This can be done quite nicely with the plots:-inequal command.

You can also use the result alongside other plots, or redisplay it with different choices for options view, size, etc.

Download inequal_plot.mw

Naturally, I could also have used sqrt(2) instead of maximize(sec(x),x=-Pi/4..Pi/4). I put it in to show a concept.

The symbol for sqrt(-1) is I, not lowercase i. You could change this using the command
  interface(imaginaryunit=i):
But note that setting is not reset in the GUI by restart.

You need to either put a space (2D Input, implicit multiplication) or an explicit multiplication symbol between the brackets (or terms before them), or else your examples will be parsed a function application instead of multiplication. Your first three examples incurred this mistake (and so Carl's suggestion to correct the imaginary unit is insufficient alone to fix your examples).

Download Multiplying_Complex_num_ac.mw

You can use the plots:-odeplot and dsolve commands, in a straightforward manner, to obtain a plot. 

I have removed the extra factors of y as just a name from the second equation. If those were supposed to be calls to y[o2](t) or y[co2](t) then you should replace them with the corrections. Any final plot could look different, of course, but if solvable then the plotting technique could be similar.

Download SAL_ac.mw