Can you describe exactly what happens---from your perspective---when it "suddenly crashes"? Do you get a message about a lost "kernel" connection? Any other message? Or does your Maple display, worksheet, everything, suddenly disappear? 

@Joe Riel You wrote:

• [I]t is generally best if the initialization file produces no printable output.

I totally disagree with that, but perhaps you can state some reason that I haven't considered.

If I want to suppress the output of my initialization file (the usual case), I invoke it with restart:  If I want to see it (because, say, I forgot some detail of what was in it), I invoke it with restart;  That's a one-character decision---trivial. If, instead, my initialization file had all commands ending with colons, I wouldn't have that kind of on-the-fly flexibility.

@janhardo You've misinterpreted what FunctionAdvisor is saying about arctan, and then using that misinterpretation as the basis for an overgeneralization about complex functions.

In Maple, there are two different functions named arctan. In some other languages they have different names, such as ATAN and ATAN2. In Maple, they are only distinguished by their number of arguments. In English, they are sometimes called "one-argument arctan" and "two-argument arctan". Since they are different functions, they have different definitions. All of this is still true if you only consider these functions restricted to real arguments.

You can easily verify numerically that even for real x and y, the equation arctan(x + y*I) = arctan(y, x) is almost always false.

@perr7 You wrote

• Numerically it seems to me that the sum is exp(1/x), not exp(x) as the formula claims. Is that your conclusion as well?

For m=0, it's totally obvious to me that the series converges to exp(1/x). I don't need numerical confirmation of that for any x. I make no claim whatsoever for any other m.

@The function I set the value of Opts in the first line of my code. It's two options that I wanted added to all the plots, and could be added to any 2d plotting command:

Opts:= labels= [Re,Im](z), scaling= constrained:

@C_R When you put my code in as 2D Input, the string literals "&equals;", "&lt;", and "&le;" were changed to "=", "<", and "<=". Try it in 1D input (aka Maple Input).

@janhardo I don't think that that can be done by any ordinary-user commands in a web browser. But perhaps it wouldn't be too difficult via some Maple code.

@perr7 For m=0, all the LaguerreL polynomials in your series are identically 1. Thus, this series is clearly equal to exp(1/x), not exp(x). Since exp(1/x) = exp(x) for x=1, it's a quite unfortunate choice as a test value for x.

@The function Note that the book answer has a factor like this: (1 + ... - 1). Those 1s cancel. If you distribute the coefficient, you get simply (1/2)*m__0*v^2, which Maple shows as the first nonzero term of the Taylor series.

The typeset formula that you hand-circled contains L(m, n-m, x), but the formula that you entered into Maple contains L(n, m-n, x). So, which formula do you mean?

@janhardo The example of comparing expressions in your most-recent Reply is much simpler than your earlier comparison. Since the argument of ln is identical in both expressions, the comparison is entirely based on trivial rules of precedence of multiplication and division. In other words, expr1 = A/B*C/D and expr2 = A/(B*D)*C where A = -I, B = 2, C = ln(...), D = b.

Your earlier comparison is essentially the same as comparing -ln((b+z*I)/(b-z*I)) with ln((b*I+z)/(b*I-z)).

@janhardo The double back quotes are used to introduce a pair of what I'll call "hard" parentheses, that is, parentheses that can't be removed by any normal mathematical simplification and which permanently separate what's inside them from from what's outside. The structure ``(...) is viewed by Maple as a function; it's just like f(...) except that nothing is displayed in front of the parentheses in the prettyprinted (2D) output.

I may have had the wrong idea about what you wanted. I originally thought that you wanted to display expressions in certain forms in 2D output. The Typesetting package offers extensive options for that, but it is awkward to use. The purpose of my module TS is to provide a few shortcuts to Typesetting to display the things that you've been asking about.

But now I think that you want to verify that expressions are mathematically equal, such as Maple's form versus your book's form. My module as well as the whole Typesetting package and 2D output itself are all worthless for that purpose.

Regarding the expression -I/2*ln((b + z*I)/(b - z*I))/b: It is NOT equal to the book's form for all complex z and b due to branch issues. As has been discussed extensively in other recent threads, some Maple simplification commands have a symbolic option that allows you to ignore those issues. Using that, the expressions can be shown to be equal, but you'd need to figure out the appropriate ranges for z and b for which equality holds.

If you have expressions A and B that you want to verify are equal, it's much much easier to simplify A-B to 0 than to convert A into B. On the other hand, if you want to verify that they're not equal, the easiest thing is to usually to find numeric values of the variables for which they're not equal.

Regarding "splitting" an expression: Use the command op.

@AlexeyK Please let me know if you've been able to put any of these ideas into use, or whether you need further assistance and/or deeper explanations.

@janhardo Using the module TS from above, you can get your "book form" via

TS:-Mn(2):
TS:-Mn(i):
TS(i/(2*b))*ln(``(b*i+z)/(b*i-z));

And that can be reverted to Maple/math/active form via

subs(i=I, TS:-Value(%));

However, I think that you're also asking whether the "book form" can be produced via some automatic "simplification" process starting from Maple's output. No, because the book form has arbitrarily placed extra parentheses. There's no sensible and unambiguous rule that would place extra parentheses around b*i+z but not also around b*i-z or 2*b.

@Carl Love Here is some exposition of the "behind-the-scenes magic" that I referred to, as well as proof that the overridden method (move in this case) is a static export of the child class (dog in this case) distinct from its parent method (animal:-move), even though the method is not explicitly declared static in the child.

restart
:
animal:= module()
option object;
export 
    data1,
    move::static:= proc(_self, $) print("In Animal") end proc
;
end module:
 
#create class/module which extends the above
dog:= module()
option object(animal);
    move:= proc(_self, $) print("In Dog") end proc  
end module
:
Bear:= Object(animal):  Bear:-data1:= "bear":
Daisy:= Object(dog):  Jake:= Object(dog):
Daisy:-data1:= "beagle":  Jake:-data1:= "spaniel":
move(Daisy); move(Jake);
                            "In Dog"
                            "In Dog"
ToInert(Daisy);
_Inert_MODULE(_Inert_EXPSEQ(_Inert_ASSIGNEDLOCALNAME("data1", 
  "STRING", 36893491093222321372)), _Inert_MODDEF(
  _Inert_PARAMSEQ(_Inert_NAME("thismodule")), _Inert_LOCALSEQ(), 
  _Inert_OPTIONSEQ(_Inert_FUNCTION(_Inert_NAME("object"), 
  _Inert_EXPSEQ(_Inert_ASSIGNEDNAME("animal", "MODULE", 
  _Inert_ATTRIBUTE(_Inert_EXPSEQ(_Inert_NAME("protected", 
  _Inert_ATTRIBUTE(_Inert_NAME("protected"))), _Inert_NAME(
  "protected", _Inert_ATTRIBUTE(_Inert_NAME("protected"))))))))), 
  _Inert_EXPORTSEQ(_Inert_NAME("data1")), 
  _Inert_STATSEQ(_Inert_EXPSEQ()), _Inert_DESCRIPTIONSEQ(), 
  _Inert_GLOBALSEQ(), _Inert_LEXICALSEQ(), _Inert_EXPSEQ(), 
  _Inert_STATICLOCALSEQ(), _Inert_STATICEXPORTSEQ(
  _Inert_ASSIGNEDLOCALNAME("move", "PROC", 36893491093222288092))), 
  _Inert_EXPSEQ())

ToInert(Jake);
_Inert_MODULE(_Inert_EXPSEQ(_Inert_ASSIGNEDLOCALNAME("data1", 
  "STRING", 36893491093222321500)), _Inert_MODDEF(
  _Inert_PARAMSEQ(_Inert_NAME("thismodule")), _Inert_LOCALSEQ(), 
  _Inert_OPTIONSEQ(_Inert_FUNCTION(_Inert_NAME("object"), 
  _Inert_EXPSEQ(_Inert_ASSIGNEDNAME("animal", "MODULE", 
  _Inert_ATTRIBUTE(_Inert_EXPSEQ(_Inert_NAME("protected", 
  _Inert_ATTRIBUTE(_Inert_NAME("protected"))), _Inert_NAME(
  "protected", _Inert_ATTRIBUTE(_Inert_NAME("protected"))))))))), 
  _Inert_EXPORTSEQ(_Inert_NAME("data1")), 
  _Inert_STATSEQ(_Inert_EXPSEQ()), _Inert_DESCRIPTIONSEQ(), 
  _Inert_GLOBALSEQ(), _Inert_LEXICALSEQ(), _Inert_EXPSEQ(), 
  _Inert_STATICLOCALSEQ(), _Inert_STATICEXPORTSEQ(
  _Inert_ASSIGNEDLOCALNAME("move", "PROC", 36893491093222288092))), 
  _Inert_EXPSEQ())

ToInert(Bear);
_Inert_MODULE(_Inert_EXPSEQ(_Inert_ASSIGNEDLOCALNAME("data1", 
  "STRING", 36893491093222319868)), _Inert_MODDEF(
  _Inert_PARAMSEQ(_Inert_NAME("thismodule")), _Inert_LOCALSEQ(), 
  _Inert_OPTIONSEQ(_Inert_NAME("object")), 
  _Inert_EXPORTSEQ(_Inert_NAME("data1")), 
  _Inert_STATSEQ(_Inert_EXPSEQ()), _Inert_DESCRIPTIONSEQ(), 
  _Inert_GLOBALSEQ(), _Inert_LEXICALSEQ(), _Inert_EXPSEQ(), 
  _Inert_STATICLOCALSEQ(), _Inert_STATICEXPORTSEQ(
  _Inert_ASSIGNEDLOCALNAME("move", "PROC", 36893491093222287868))), 
  _Inert_EXPSEQ())

Note that the address of procedure move is the same for the two dogs, but different than the address of move in the animal.