@mmcdara Thanks. The methods in all of our Answers build a new copy of the Array rather than simply use a new indexing method on the existing Array. In some situations, a new indexing method might be more efficient. It would need to be coded from scratch though (not difficult, there is a help page on it).

Regarding your Answer: There's no need to suppose that the dimensions being transposed have the same bounds.

@janhardo I think that saying that it's "only a notation" understates the massive importance of this formula to Number Theory. For one thing, it shows the connection between primes and the Zeta function. Note that the sum side of the formula is by definition Zeta(s), and that s is not necessarily real.

@janhardo Okay, I now understand where you got this idea:

• There are two approaches to defining a complex function in Maple. Method 1. Make f(x, y) a function of two real variables x, y. Method 2. Make f(z) a function of the complex variable z.

The idea shown in that worksheet is correct; however, the example function used, z-> z^4, is way too trivial to illustrate the pros and cons of either method. (Perhaps the worksheet continues on to some deeper examples that you haven't shown.) But note that the two methods are being used to define the same function. 

Those two methods have nothing to do with the definitions of one-argument arctan and two-argument arctan as shown by FunctionAdvisor. As I said, those are two different functions that just happen to both be named arctan. It's this coincidence of the name that leads to your confusion.They might as well be named arctan(z) and foobar(y,x). Some simple plots should convince you that they're different. Now, of course, they are related to each other, hence the same-name thing, but that is not the same thing as being the same function defined differently.

Maple has many examples of "families" of functions with the same name that are distinguished only by their number of arguments. I'm not a fan of this practice (partly because it makes the first several lines of those procedures and many of their associated subprocedures difficult to read), but that's the way it is. Some important examples are

1. the Riemann Zeta function Zeta(...), which is of fundamental importance to the intersection of complex analysis with the study of prime numbers, and is the subject of one of the most-important (perhaps the most-important) unsolved problems in mathematics: the Riemann Hypothesis;
2. GAMMA, which generalizes factorials to complex numbers; GAMMA restricted to real numbers is of fundamental importance in statistics;
3. LambertW, the inverse function of x-> x*exp(x); like most functions defined as inverse functions, it has many branches.

Regarding the use of back quotes in that worksheet: They are simply being used to make what are essentially string literals (though the constructed objects are actually type symbol rather than string).  Any characters can be placed between them, including control characters and non-ASCII characters. Usually, but not always, their​​​​​​ prettyprinted display is italicized and without quotes. This is what's being done by the `f(x,y)`, The ` ` doesn't seem to be doing anything other than displaying ` `, for whatever that's worth.

There are many uses of back quotes in Maple, and not only for display purposes. They can seem quite different, but all can be understood in this framework:

1. The constructed object is always type symbol.
2. There is some desire or need that the characters in the symbol not be interpreted, at least initially, by the kernel. Often this is because they wouldn't make sense syntactically.
3. There is some desire that the characters be interpreted in some alternate way, perhaps at some future time. This alternate interpretation can be by the kernel, the display, the plot renderer, some other program, or perhaps simply a human reader.

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.