Download ent_seq.mw

Those are just Maple names which line-print like the unicode decimal codes and pretty-print (2D Output) like the typeset lowercase Greek letters.

For example, the Maple name `α` gets typeset in 2D Output as the symbol for the Greek letter alpha.

You don't need to wrap in any MathML style markup (eg. mo(...), mi(...) ) for that basic effect.

ps. It's not entirely clear exactly what you wanted to accomplish. Perhaps you're trying to do something different. Are you looking for a way to programmatically generate the literal names alpha, beta,...,omega as written in the Latin alphabet?

Download type_chk_ex.mw

That is the behavior of evalb, which is the default mechanism for if..then conditional testing. (That Help page describes the kinds of equivalence it tests.)

For such polynomial comparison you have a few alternatives -- to get a mathematical equivalence test of the kind needed here -- including expanding (or putting the difference into normal form) before comparing, or using is, or testeq,

Download evalb_et_alia.mw

In general some such mathematical tests for equivalence are potentially more expensive than others. The user gets to decide which might be used.

In Maple 2021 and later the form you want is produced directly. (You haven't told us what older version you are using.)

Here are three different ways to get that integration result.

Download int_old_ex.mw

ps. In Maple 2021 and later the result,
   1/3*x^6*cos(x^6)+1/6*(x^12-2)*sin(x^6)
is produced by default (no method) and by method=risch, and a close trig form by method=meijerg. In Maple 2020 and earlier the method option was not supported for indefinite integration (hence my 3rd workaround above).

You appear to have made two kinds of mistake.

The first is that it looks like you've forgotten to put either an explicit multiplication symbol or a space (to denote multiplication implicitly) between the name a and the left open-parenthesis.

The result is that you've entered a(x-a) which is a function call of a (some as yet undefined operator...). You haven't used any syntax for a*(x-a) a product of a and x-a.

The second mistake is that you subtracted instead of added.

Download 2d_mul_ex.mw

There are several things you can do with that in Maple. For example,

Download sum_ex.mw

ps. I converted your Post into a Question.

The following code shows how you can programmatically turn equations into such scalar expressions, or vice versa.

It also let's you do that if you have a mix of both. But it can also work if you have just all one type, or the other.

It's a simple task, so the code to handle it ought to be simple. I've tried to make this code straightforward, so that a Maple beginner could learn a bit from it. I deliberately didn't make it as super terse as possible.

Download type_equals.mw

The following is a glossed-over over-simplification.

Personal computers that one could purchase today have CPUs with associated hardware (circuits) specialized for the task of performing arithmetic on floating-point numbers stored/encoded in a mere 64 bits (double precision) or 32 bits (single precision) of memory.

Such so-called "hardware floats" are restricted in range, both in terms of the number of decimal places of the mantissa (roughly 15 decimal digits for double precision) and exponent.

If your machine's Operating System is made aware via some program (eg. compiled C, Maple, etc) of such floats in memory then it can make calls to have the relevant hardware chip perform such "direct" arithmetic operations. The hardware chips of personal computers made today can do billions of such operations per second (provided the program and OS can supply them that fast).

The essence of this speed is due to the numbers being stored in (64, or 32) bits that are encoded in a form that the hardware arithmetic unit understands directly, and the fact that the range in which these hardware floats exist is quite restricted. The restricted possible range of these floats allows for adequately accurate yet very fast dedicated circuitry or algorithms to be possible.

But Maple can also handle floating-point numbers from a much wider range -- with many more possible decimal digits, and much smaller/greater exponent. The floating-point arithmetic on such so-called "software float" numbers is emulated by the software program, and the numbers are stored in another kind of specialized encoding, ie. a more involved, higher level, dedicated data structure. These operations are considerably slower than those so-called hardware float operations mentioned earlier. Such software floats also require additional overhead (eg. memory-management).

Maple is an interpreted language, and the Maple program has a core interpreter that performs symbolic computations as well as performs/dispatches integer and software-float computations. Maple also has an alternate interpreter, available as the evalhf command, which can do float arithmetic more quickly because it uses the very compact hardware float representation and the mentioned low-level computations that the machine's chips can perform directly. Sometimes the relative performance benefit is as high as a factor of 15-30. The evalhf benefit is mostly restricted to a relatively smaller assortment of numeric operations, however.

Throughout the above, I've just written "arithmetic". But the situation is similar for elementary operations such as sqrt, sin, exp, etc. Either the Operating System's runtime math library or the hardware chipset offers dedicated mechanisms to compute those operations accurately and quickly for hardware floats. Computing those for arbitrary precision software floats is computationally more expensive.

There are a couple of other ways to get some speed benefits of hardware float computation, from within Maple. Eg. the Compiler, and option hfloat on a procedure. (See also these two articles [1], [2], now old.)

There are cleverer mathematical ways to determine whether there are real roots, but the following is (deliberately) a minor adjustment to your existing code.

S5AléatoireParaboleSommetGraphe_ac.mw

The cited solution holds for complex x & y, including the real case where either is real and negative.

Download solve_res.mw

[edit] In general, if for some reason you wanted to restrict the solution to x>0, y>0 then you could impose that as extra conditions. Here, fortunately your desired formulation attains. (These steps are deliberately split.)

Download solve_ex_conds.mw

The lists [ [1], [1,1], [2], [1,2], [2,2] ] could be padded by 0 on the right, each then with two elements.

Then the list of D terms could reindexed (sorted) by using the permutation of sorting that lists of padded lists.

Then that newly sorted list of D terms could be used to sort the original expression with a plex ordering.

Download sort_D.mw

There is a large Section of the Help system, entitled "Applications and Example Worksheets". It is organized mainly by subject, and its worksheets often use multiple commands to accomplish more involved computations (differential equations, statistics, plotting, etc, etc). This is quite different from the kinds of example usually seen in any single command's Help-page.

Also, if you're new to Maple then something to consider is what kind of environment do you want?

There is marked-up 2D Input versus plaintext 1D Maple Notation input mode. A Help-page's Examples Section can be toggled from one to the other using an icon in a menu-bar at top.

The defaults for Maple include 2D Input mode and Documents (as opposed to 1D input and Worksheets), and those aspects can both be changed and set as new preferences.

The User Manual has a great deal of 2D Input in Worksheets. The input is marked-up math, entered using left panel palettes or command-completion. It also has many basic examples that are solved using the right context-panel menus. It also has a great deal of Equation-label style of reference to previous statements. It also points users at Tutors and Assistants (popup solvers). Some people love all those convenient and powerful things, and some people gladly get by (easily) without any of them.

It's difficult to describe just how very different two people's work can look. You should probably try out the alternative modes, so that you don't miss out on something that you might prefer.

In my opinion the User Manual has quite a lot of focus on approaches and functionality and convenience that would be useful to a student.

A decent, inexpensive 3rd-party book that uses only 1D input (my own preference, in a Worksheet) is Understanding Maple by Ian Thompson. Perhaps it's fair to suggest that this focuses more on programming, and could be useful for scientific computation work in Maple.

You have attempted to use the syntax for plotting solutions from pdsolve(...,numeric), but your solutions are produced by dsolve(...,numeric) which are handled differently.

Also, your solutions contain f1(eta), but no f(eta).

sachi_stream_error_3d_ac.mw

You code attempts to find the general symbolic formula for the result, which seems like a bad decision.

Instead, you might construct a re-usable procedure which does the linear-algebra computations as a purely numeric computation for each numeric input value of z and v.

By the way, did you really intend that the first three columns of P3 and P4 be all zero? That doesn't seem to make doing the eigen-solving very interesting... Perhaps you might check your earlier formulas and methodology?

The numeric linear-algebra could be made even faster, but it might not be worthwhile unless you could first confirm that the formulas and overall approach are correct.

Download RASTDFFAM_ac.mw

I am not aware of any shortcut syntax in Maple for linear-solving, or that is equivalent to Matlab's A\b.

Computing inv(A)*b is not a good "standard" way to solve a floating-point linear system, and it's not what Matlab does when you enter A\b. One reason for that is that explicitly forming the matrix inverse and then multiplying by it is not generally as accurate.

IIRC, the A\b syntax in Matlab is a shortcut for its mldivide command. And mldivide differs from its linsolve by doing some extra tests (possibly expensive for larger matrices).

If A is square then Matlab's linsolve will do an LU decomposition, otherwise it may use do QR (like a least-squares approach).

And that's what I'd recommend for you in Maple too. If A is a square floating-point Matrix then try the LinearSolve command, and otherwise try LeastSquares. But I suggest not using MatrixInverse (or a shortcut like A^(-1)), followed by multiplication.

note. Those Maple commands also have options. Eg. method=LU as default for LinearSolve in the square float case.

Download LSexample.mw

ps. Some of the extra tests that Matlab's mldivide does (ie. more than what linsolve does) involve checks for various special forms (symmetry, etc).

Maple's LinearSolve and LUDecomposition do some of that -- but quickly -- checking the Matrix for special shape/storage applied as options at Matrix creation time. Scan's of the data are not done.