You could try something with the Explore command, to give you an idea of how the parameters affect the polar plot.

Eg,

Explore(plots:-polarplot(a+b*sin(x), x=0..T, title=evalf[3](a+b*sin(x)),
                         gridlines=true, coordinateview=[-3..3,0..2*Pi]),
        parameters=[a=-1.0..1.0, b=-2.0..2.0, T=0..2*Pi],
        initialvalues=[T=2*Pi]);

polarplot_explored.mw

Suppose that Maple is installed at a base location which is also the value of the Linux environment variable MAPLE. In that case the command-line interface can be launched on Linux in a terminal by issuing the command,

  $MAPLE/bin/maple

where that is the name of the bash script which launches the cmaple interface.

That script accepts several options, most of which can be listed by passing the -h option.

What hardware does your device have? I mean, which CPU chipset? Which OS distribution and version? Tell us how it goes.

There is no version of Maple which can read and write a proper video file format (eg. mpeg-2, etc).

Here is one way.  Note that in Maple 2018 the double-braces are not rendered around Unit calls.

Download inertform.mw

A list is not a mutable structure. When evaluation of a list entails a change in the evaluated value of an entry then a copy is made (and the address changes).

A Vector (or Matrix, Array, ie. rtable) is a mutable structure. In order for in-place semantics to work for rtables via procedure calls they are not copied under eval. Thus a procedure receives the very same rtable, when it is passed in as argument to the procedure call and evaluated up front. And so the desire for in-place semantics is one reason that rtables are not copied under eval.

Another reason is efficiency: the term "rtable" stands for "rectangular table", where hardware numeric entries (or the references to symbolic DAG entries) are stored contiguously in memory. It's a great benefit that passing the data of a float[8] rtable to an external routine only needs to pass the reference to its beginning. Full copying under normal evaluation rules for procedure calls would be a performance damper.

The functionality to force an evaluation throughout all entries of an rtable is provided by the rtable_eval command. Below you can see that command producing a copy.

Download list_rtable.mw

note: When doing such examinations it can sometimes be useful to utilize lprint and eval(...,1), so as not to be misled by evaluation occuring only during printing.

Access to individual rtable entries, via indexing, does entail full evaluation. This is natural, for programmatic purpose.

Download rtableentryeval.mw

While assignment to an entry of a list "works" (up to the 100th entry, by default), it is not true in-place semantics. The underlying list is actually replaced by a full copy whenever this occurs. This is thus a very inefficient programming practice, and should be avoided.

Here's a little more related to list evaluation,

Download list_eval.mw

You could start by reading the Programming Guide, (in particular chapter 9, Object Oriented Programming) and the help pages related to objects and modules.

See also the help pages for Topics:
  object
  object,create
  object,methods

The most up-to-date version of the Programming Guide is included in the latest release of Maple. A (possibly older) version of chapter 9 is online here.

plot3d(piecewise(x^2+y^2<=1,0,undefined), y=-1..1, x=-1..1,
       lightmodel=none,
       image=cat(kernelopts(homedir),"/mapleprimes/","penny.png"));

For this example we can discern the greatest argument in a call to F, and isolate for that up front.

Download gen.mw

Try it like this instead, in your Maple 2018,

Download animate_size.mw

That sizing is respected by the right-click context-menu export to .gif on my Maple 2018.2.

Alternatively, if you have already created the animation, you can resize it like so,

PA:=plots:-animate(P, [a], a=-0.7..1.4, frames=25):
plots:-display(PA, size=[600,300], insequence=true);

Did you forget to first load the CurveFitting package? Try executing this command first,

   with(CurveFitting):

Alternatively, you can call it by its so-called long-form name CurveFitting:-PolynomialInterpolation.

Download PolyInterp.mw

You claim that a call to EigValsVecsC executes properly when called from withing Visual Studio. So then the function LAPACKE_dsyev is being found at run time. Whence is it be found, by Visual Studio?

That missing function's name is from a suite for calling Fortran LAPACK from C. How is Visual Studio linking to a .dll that contains that function? Presumably operators.dll is being built in Visual Studio by being linked against some LAPACKe .dll(s). But only you can tell us how you set up that project.

When you try to call EigValsVecsC using Maple's define_external then it's not going to know where to find the .dll that contains that auxillary LAPACKe function LAPACKE_dsyev. Why/How should it know, if you haven't put it in a directory that is in the runtime path?

You could try adding the relevant LAPACKe .dlls (that contain LAPACKE_dsyev and any supporting functions) to the runtime path. You may need to try a few variations on that, since Maple's directory for executables and .dlls contains it own MKL LAPACK .dlls (but not LAPACKe, if I recall).

[edit] Perhaps you could provide a detailed description of what you're trying to achieve?

I'm not sure how exacty you want it to look. But here's a start.

insert_pictures_ac.mw

Below I first inline and attach a worksheet that does this in a very simple way.

Then at the end I attach another worksheet whose Startup Code contains a rough version of a package that provides some more automatic support for such things (eg. some Units support, convert/combine/evalc/Re/Im/etc, and a few context-menu items). Sorry, it's got an accidental quirk in its static evalf export that makes it a bit awkward to work with float values -- I ought to fix that.

Sorry that the 2D Math parser is so picky about brackets around floats and negative values for the infix `∠` operator. You can find that on the "Operators" palette, by the way (and you can add it to your Favorites palette). There's a bit of GUI weirdness around.

This first approach below doesn't need any add-on. [edit] Carl Love did something similar once, if I recall, but I cannot find that post at the moment.

Download Example_to_Mapleprimes_ac2.mw

And here's the other worksheet I mentioned, using a rough prototype of my "Phasors" package in the Startup Code region. [edit] To utilize this in another worksheet you'd have to copy the Startup Code, since I have not yet made it into a downloadable package from the Maple cloud.

Example_to_Mapleprimes_ac.mw

note: "Phasor" may not be the best term here. "degree-polar" might be better. Are the multiplications in your calculation meant to represent something like a phasor multiplied by a complex value? Or phasor-phasor product?
note: What was the precise result from your calculator?

Your expectation indicates that you have not read and understood the relevant part of the interface help page.

Regarding the errorbreak setting, the help page for topic interface says, "Controls Maple's behavior when an error occurs while reading Maple commands from a file or redirected standard input, as follows:..."

That description does not state that it controls the general flow of an executing worksheet.

Inside the GUI, the setting of interface(errorbreak) affects the behavior during execution of the read command. It controls the error severity level that will stop further reading of the plaintext file's Maple statements.

Let us know if you really need the appearance of the addends to be of the form wf δ θf (...)  etc.  That could be done as a visual effect, since normally some of those terms would automatically simplify (eg. wf*delta*wf automatically simplifies to delta*wf^2). The other terms could be managed using special invocation of the `sort` command. But the squares are trickier.

The addends in ans1 below are mathematically as you asked, if I understand correctly. The precise formatting is also possible -- but it'd be just that, a pretty-printing affect.

Download Final_objective_orig_ac.mw