Yes, a 3D space-curve can be colored.

(I dug this out of an old directory in which I had worksheets that colored space-curves of knots, eg. by torsion and curvature. The procedure SC constructs a space-curve substructure as well as its corresponding color substructure. Apart from adjusting the cfunc for your example I had to make no other changes. That's because coloring a space-curve is a pretty basic goal. I have previously submitted a request for it in the plots:-spacecurve command.)

I prefer this over using tubeplot -- at least for my purposes -- for aesthetic, performance, and memory considerations.

Download spacecurve_shaded.mw

I used an hfarray for some backwards compatibility, but in more recent Maple I could have used a Array with datatype=float[8].

I didn't use the px(t) and pv(t) and their piecewises, only because they weren't strictly necessary. I'm sure that you could see how they might be incorporated instead.

note: If you don't need to alter Digits while calling these, you can squeeze out faster performance by adding these lines after extracting X and V from sol.
   X:=subsop(3=[remember,system][],eval(X)):
   V:=subsop(3=[remember,system][],eval(V)):
This memoization improves performance in such code as this which invokes X and V more than once at the same t values.

edit: I'll mention that I deliberately made cfunc less efficient than necessary. It could instead have the RGB values (range 0..1) hard coded in the piecewise. Instead it needlessly calls Color and rips those values out, each time it is called. I just wanted to illustrate using the colors by name. So it could be faster, though for this example I expect the DE computation to dominate the cost of color generation. Let me know if you'd like me to show such an edit. The particular RGB values -- or the piecewise -- could even be substituted programmatically into the cfunc proc (once, up front). You could also call that cfunc yourself, and see what it returns directly.

A different and efficient approach for SC would be to have it call `spacecurve` or odeplot itself, rip out the numeric data from its resulting CURVES substructure, and then compute the COLOR substructure using that numeric data directly. That is how Library improved revisions to those routines would ideally be extended to implement the usual coloring options.

The angle-bracket shortcut syntax for Matrix construction supports this functionality. For example,

Download Matrix_stack_augment.mw

That syntax is so simple that having dedicated commands for it would be overkill.

You may also use this to stack/augment a Matrix by a Vector (of the appropriate orientation).

You can suppress the visual display of results by using a fill colon (instead of semicolon) as the statement terminator.

For sorting there are various kinds of example. You should explain the specific goals, explicitly.

You can pass the extra option  output=string  to the CodeGeneration:-Matlab command.

Eg,
   CodeGeneration:-Matlab(func, output=string);

Then you can write that string to a file, using fprintf, or FileTools:-Text:-WriteString, etc.

It sounds like you are looking for a 2D parametric plot.

For example (using made up values for the other parameters),

plot([eval([x(t),y(t)],[A=0.9,v=2,m=1,n=1,alpha=1,beta=1])[], t=0.3..1.5],
        labels=["x","y"]);

With the code you supplied, the following both work:

  ribbonplot5([cos, sin, cos + sin], -Pi .. Pi,numpoints=20);
  ribbonplot5([cos(x), sin(x), cos(x) + sin(x)],x=-Pi .. Pi,numpoints=20);

Consider this simpler plotting example, and these two different kinds of calling sequence,

  plot(sin, 0..Pi);
  plot(sin(x), x=0..Pi);

The first uses a so-called operator-form calling calling sequence syntax, and the second uses a so-called expression-form calling sequence. (Also see the calling sequences shown on this Help page.)

The first passes an operator (procedure), which the second passes an expression with an unknown (here, the name x).

It does not make good sense to mix and match those two distinct kinds of usage. It does not make good sense to pass an operator (procedure) as the first argument and a name in the second argument. That would be muddled up and poor programming.

That ribbonplot5 procedure simply doesn't do as good a job as plot at checking for such a mismatch and producing a helpful error message. Eg,

  plot([sin, cos], x=0..Pi);
Error, (in plot) expected a range but received x = 0 .. Pi

note: This kind of distinction between expression-form and operator-form calling sequence is present elsewhere, eg. for fsolve, evalf(Int(...)), Optimization:-Minimize, etc.

You might use the orientation 3D plotting option.

For example,

Download tareaclase6_ac.mw

An imported image (as float[8] Array) can be used for the coloring in a density-plot structure.

Once appropriately scaled, this can be translated to arbitrary x-y positions.

The following code could be made more efficient (and easy, with a re-usable procedure to scale/translate/etc). But I'd like to know whether it will suffice, before making the effort.

Naturally one can change the Read line below, to instead use some other external image file. (The OP didn't provide an image file.) All the code below needs is the usefully scaled (70x70x3 works ok) Array assigned to img.

Download image_plot.mw

I suspect that the GUI will be generally less sluggish using such density-plots than it would with, say, colored point-plot assemblies.

That density-plot structure could actually be formed via the plots:-densityplot command, using the Array from the image. I simply found it easier to form it directly, as above.

The Fractals:-EscapeTime commands produce images (in the float[8] rtable sense), not plots.

You can "animate" a discrete number of images (or even calls to the Mandelbrot command at modest size, it's that fast) using Explore.

But you cannot nicely export that animated rendering to an external file. Maple's directly export functionality is limited to exporting a sequence of actual plots. Converting those images (rtables) into, say, densityplots would produce results too large and unwieldy for the GUI and its export drivers to handle well (if at all).

What you could do, instead, is export the images (rtables) directly to separate external image files (.gif, .png, what have you), using the ImageTools:-Write command. And then use an external 3rd party tool on your OS to assemble a movie format file (mpeg2, mp4, .gif, etc) from those.

Here are two alternatives to plots:-display, one using DocumentTools:-Tabulate and the other using DocumentTools primitives.

If you really want you could use more Table nesting (and suppressed borders) to get precisely the layout you showed. Perhaps more effort than it's worth...

(Sorry, I don't think that this forum will properly inline this worksheet here.)

question5_ac.mw

I don't why you wouldn't expect a(i)=0 and c(i)=0 to follow from your given a(0)=0 and c(0)=0. Perhaps you (or I) have made a mistake?

For fun, procedures Ap and Cp below take a0,c0 initial values as 2nd and 3rd arguments respectively.

The procedures Ap and Cp are programmatically generated from the recurrence equations. (I didn't feel like wrestling with rsolve.) So you can regenerate them for some modest edits of the equations.

In the example I use a0=0.1 and c0=0.1.

Download rsolve_for_system_of_recursive_equations_acc.mw

There are various ways to programmatically make the result appear in terms of J/mol as units. See attachment below for three of them.

It numerically better to round final results to 3 digits instead of calling evalf(...,3) or evalf[3](...) which do computations at lower precision and can incur unnecessarily greater roundoff error than usual.

I am deliberately avoiding using right-click units-formatting or numeric (float) formatting via the GUI.

(For some reason this forum is not letting me inline my revised Document, sorry).
Download question4_ac.mw

In terms of programmatically determining significant digits you might try either the Tolerances or the ScientificErrorAnalysis packages, depending on your concept of error in the supplied input float values.

You wrote that you knew how to construct the filled 2D plot. Great.

You can transform a 2D plot to 3D, for some terse code for your goal.

I shift (before and after, to positive y) to allow the filled portion to survive the transformation more nicely.

Download 2Dfill_transf_3D.mw

You asked about doing the loop without the list from 1 to 5 for the index. Here below is another common loop syntax choice.

The rest is also done more simply, without duplicated input of those multiples of Pi, etc.

Download exp_seq.mw

Your examples (so far) don't require evalc or convert(...,radical).

If you want it terser you could also begin that loop as,
     for i to 5 do
which would start by default from 1.

The problem is that you've made several mistakes. It's not a configuration issue.

Your list li is created with roll, but it ought to be calls like roll() .

You call solve on f(x), but the procedure you created was assigned to g, not f.

If you want floating-point results then you can use fsolve here, rather than solve.

Download rand_usage.mw

You may use expand for Q2.

Both Q1 and Q2 require fixing the problem of the erroneous multiplication syntax.

Download Q20220110_ac.mw