You do not need to assign to the varuable names v1,v2,etc which would have the drawback that you'd need to unassign them in order to re-use then conveniently as names. You can accomplish the same effects using a list of equations or a table, either of which can be used to associate the names with the values.

This is a common and important usage scenario in Maple.

Download funcsubs.mw

The leading term is determined lexicographically (here, alphabetically, but where lower/uppercase matters).

And so what matters for -v1+a is the coefficient of a , while what matters for -V1+a is the coefficient of V1.  The capital letters are taken first.

Maple needs to use some convention in your usage case where no variable list is supplied as additonal argument. It might make sense (albeit tiresomely) to complain about the particular convention used, but it would make no sense to complain that it has to have some convention.

[edit] I should point out that for important efficiency concerns Maple stores only one instance of a polynomial in memory, regardless of whether it is entered as -v1+a or later as a-v1 . Moreover a polynomial can have its subterms sorted inplace in memory, but that structural change should not affect the result from sign which is mathematical. Therefore its leading term cannot be determined by the order in which you later re-type it or the order in which the subterms are stored in memory. So a convention that considers the leading term lexicographically lets things work.

restart;
p := -V1 + a;
                          p := -V1 + a

sign(p);
                               -1

sort(p,order=plex(V1,a),ascending);
                             a - V1

p;
                             a - V1

sign(p);
                               -1

sort(p,order=plex(V1,a),descending);
                            -V1 + a

p;
                            -V1 + a

sign(p);
                               -1

Since Maple 15 it is even easier to set the default unit for a particular dimension with the UseUnit command. I mean easier than having to use the commands AddSystem and UseSystem as you did above.

This allows other scales of power to be simplified to your desired kWh/day.

You can utilize it with or without loading Units:-Standard, depending on whether you want arithmetic with units to resolve/combine automatically. Or in recent versions you can utilize it alongside Units:-Simple, which does that automatic combining of units while also allow mixed arithmetic of quantities with units attached and unknown quantities (eg. names) without units specified.

Download useunit.mw

There are also facilities for right-click units re-formatting in the Maple 2018 GUI. You can also use that (or convert(...,units,W) ) to force display in Watts alone.

@primogen Have you tried,

Physics:-diff~(SimplifiedMassMatrixDot, theta[2](t));

a_ac.mw

I toggled this Question to be marked as "Maple 2017", since that's the release in which your attachment was last saved. (You had it as "Maple 17" which is four major releases earlier.)

I don't know of any easy way to handle 2D Input of units (ie. typeset via command-completion, or from the Units palette).

The following affects 2D Output. (I doubt it will work alongside right-click unit-formatting.)

Download unitcolorbold.mw

Download inertanother.mw

Download inertsurd.mw

The multiple assignment functionality was added in Maple V R5 which was released in 1997.

Have you tried,

display(Array([ display(A,B), C ]));

More importantly, Shouldn't you call it like,

Explore( P(a), parameters=[a=-1.0..1.0] );

so that it explores a function call to P?

Yes, you should be to accomplish this using Embedded Components, as long as the data exists before the plotting begins.

If you're hoping for an asynchronous process that sits there waiting for newly computed data points to be added to the file then the task is much more complicated (if possible at all).

Do you have a sample of data? What kind of plot do you want?

You can map the diff command over the Matrix.

step1calshelper_ac.mw

Make a Matrix with the two lists as its columns (ie. column Vectors).

A := [[0, 1, 2, 3, 4, 5], [0, 2, 4, 6, 8, 10]]:
M:=<<A[1]>|<A[2]>>:
ExportMatrix(test, M, delimiter=" "):

Alternatively, create the Matrix with the lists as the rows, and export its transpose.

A := [[0, 1, 2, 3, 4, 5], [0, 2, 4, 6, 8, 10]]:
M:=Matrix(A):
ExportMatrix(test, M^%T, delimiter=" "):

It cannot be done straight from Maple, AFAIK.

It would be interesting if someone proved me wrong by showing a way using the Maple's HTTP or URL (or lower level via Sockets). Its not clear to me how login or authentification might work.

It'd be trickier still, since uploads to Mapleprimes are attachments to posts. It might be more effort to upload without a post (and then somehow post separately and attach the prior raw upload) or to effect both directly from Maple.

Upload and insertion of a link to the worksheet, or inlining of the worksheet, is available from within Mapleprimes using the green up-arrow that appears in the menubar of the Question/Reply/Post editor.

Upload to the Maplecloud is possible, directly from Maple. But I'm not aware that Mapleprimes and the Maplecloud have any functional interchange.

The easiest way is to put both subpackages within a single parent package.

If you really want them distinct then you can utilize an abbreviation scheme. Here are two choices for that:

1) Utilize the $define preprocessor directive in the source. (I prefer to load all my packages from source code stored in plaintext files outside of any worksheet.) For example,

$define OPFCN OriginalPackage:-Function

# alternatively
$define OP OriginalPackage
$define FCN Function

The second of those would be utilized by accessing OP:-FCN in the subsequent code.

At the end of the source file you can utilize the corresponding $undef directives.

2) Utilize the uses syntax at the start of the source for each procedure in the dependent (2nd) package. For example,

NewFunction := proc(x)
  local blah,blech;
  uses OP=OriginalPackage,
       OPFCN=OriginalPackage:-Function;

  blah := OP:-OtherFunction(x);
  blech := OPFCN(blah*x);
end proc;

If the whole equation is assigned to the name eqn , then how about,

collect( expand(lhs(eqn)), Rm, simplify ) = rhs(eqn);