@Mariusz Iwaniuk 
It's not a workaround. MMA probably did the same.

@Mariusz Iwaniuk 

restart;
de := diff(u(x), x, x)+u(x)*(diff(u(x), x))-u(x) = exp(2*x):
bc := u(0) = exp(0), u(1) = exp(1):
dsol := dsolve({bc, de}, numeric):
du0 := D(u)(0)=eval(diff(u(x),x),dsol(0)):
DSOL := dsolve({de,bc[1],du0}, numeric):
plots:-odeplot(DSOL, x = -1 .. 2, view = 0 .. 3);

@mmcdara 

You took Ruben's first definition but with distances wrt a focus F (instead of the center). So, you have FM, not OM.

@Christopher2222 

Probably you are thinking to take a sequence of partitions (having the norm --> 0, as in Riemann sums)  and then compute
limit  ( r₁+r₂+..+r_n)/n   for n --> oo.

Unfortunately it can be proved that this limit does not necessarily exist
(i.e. there exists a sequence of such partitions for which the limit does not exist).
So, it's mandatory to define the mentioned measure [or adopt a similar definition].

@herclau 

Consider the following analogy.

If you want to compute the average (or mean, see https://en.wikipedia.org/wiki/Mean) of 10 positive numbers then the default one is the arithmetic mean (x1+...+x10)/10. But there are many other: geometric, harmonic, quadratic etc.
(note that the arithmetic mean corresponds to the counting measure in my previous comment).

But for your question there is no default. So, you must specify the measure!

@Mariusz Iwaniuk 

Maple uses laplace with a formal approach. But this approach does not work here as Markyian has noticed.
For a mathematical approach one must specify in what distribution space is the Laplace transform defined.

If (X,m) is a finite measure space and f : X --> R is an integrable function then the average of f is usually defined as

1/m(X) * int_X f(x) dm(x).

In your case f(x) = dist(x,0) but you must say what is the measure you are using. It could be e.g. the Hausdorff measure.

These type of results occur when "engineering maths" instead of "maths" is used.
And also because Maple is not careful enough.

inttrans:-laplace( diff(Dirac(t-a),t)*cos(t), t, s);
   

eval(%, a=0);
      s

But:
inttrans:-laplace( diff(Dirac(t-0),t)*cos(t), t, s);
    0

@tomleslie 

For OP's tables eval()  matters:

restart;
A:=table([1=x]):
B:=eval(A):
addressof(A)-addressof(B);
                              -160
addressof(eval(A))-addressof(eval(B));
                               0

@Carl Love

Yes, now it is as you said.

I suspect that instead of a "link", it could be the order of creation which is saved in a .m file.

@Carl Love 

I don's see the relation with OP's situation. Here it's a simple matter of evaluation which works the same for "FC.mpl".

The first part is true. Inserting
diffaddr=addressof(eval(A))-addressof(eval(B));
==> in the second attempt diffaddr <> 0, (but = 0 in the rest).

@Markiyan Hirnyk 
OK, I'll include this time the mathematical part (even if I have non seen many math proofs in this forum!).

@Markiyan Hirnyk 
The fact that a product of powers of A and B has the provided form is not proved too. Both must be done by hand but are simple. (Maple was useful to guess the result and this is the essential step.)

@Carl Love 

"Functional form" is of course ok, my point was the consistency.
`!` is a protected symbol in Maple so it cannot be assigned. Even unprotected, it will not work (I've just checked). It can be overloaded, but this is not discussed here.

P.S. I want to congratulate you for the very clear and useful syntheses you post sometimes. They should appear on top when searching mapleprimes (but unfortunately the indexing mechanism is not able to do this).

@Carl Love 

Unfortunately the terminology is not very consistent in the documentation.
If f is a binary operator, the infix notation is x f y of course (x,y being the operands).
The prefix notation would be  f x y  but in Maple this notation is not used.
f(x,y) is the functional notation.
The prefix notation is used for unary operators, e.g.  not x. The associated functional notation used in Maple is `not`(x).
The unary operator ! is used with a postfix notation:  x!. The corresponding Maple procedure in Maple is factorial (`!` is not a procedure) so the functional notation is factorial(x).
 

@asa12 

Your aa0  is actually  []  i.e.  the identity (but in an incorrect Maple notation). In this case if you want to use orbit  construct the permgroup first:

pg:=permgroup(9, {[]});
                    pg := permgroup(9, {[]})
orbit(pg,2);
                      {2}

P.S. You can use your phone to create a “Personal Hotspot” for the laptop ("tethering"). It's simple.