@rit You really didn't answer my queries for clarification. I'll wait for you to clarify, and answer them all, before I continue, thanks.

Let me ask another question then, in the meantime: if you had some kind of general eigenvector solution to your problem with a mix of float entries and (at least one) symbolic entry x, then what would you do with that solution?

I notice that you have not addressed my claim that the formulas you were passing to `solve` -- in your attempt to compute the eigenvectors -- was not right. Yet in at least one other thread on this site you still mention that it leads just to the all zero-Vector trivial solution.

@rit You should characterize what you will accept as an optimal solution -- it's your example, after all.

Please stop spamming this site with repetitions and variants of the same question. If you have followup comments that are relevant, then just add them here.

@rit 

restart:

obj:=f(x1,x2,x3);

with(Student:-VectorCalculus):

Hessian(obj,[x1,x2,x3]);

Jacobian(Gradient(obj,[x1,x2,x3]),[x1,x2,x3]);

@abscissa It may be pertinent. It happens quite often that people ask computer algebra systems for the general symbolic form of a solution, not realizing that such a general symbolic result might be too large or unweildy to be useful even it it could be computed.

Sometimes it turns out that the evenutal intended use would be to evaluate that (potentially huge) result at purely numeric values. In which case it might make better sense instead to construct a procedure which accepts the numeric values and returns numeric results. Or it might be that simplification or further manipulation under certain substitutions or restrictions of the (potentially unweildy) symbolic result it intended, in which case an alternative might be to utilize such prior to attempting a symbolic solution.

These and similar situations are not uncommon. That's why I asked. If you have additional information or background to the problem then providing it here might help. Or not.

@rit You have two expressions f1 and f2, both in terms of x1 and x2. It appears that you are trying to somehow optimize both, by somehow combining both into a single objective. I think that you should tell us what definitively is the single objective that you want to optimize, or at least what are all the criteria for which you would accept x1,x2 values as representing the optimum.

If you cannot do that, explicitly, then I don't see how we could do much more than guess at what you are trying to accomplish.

Suppose that Maple were to produce a symbolic representation of the general problem, and that it were say a hundred pages long. What would you do next with it?

acer

@rit I don't understand what you are saying.

What is the reason that you cannot use LinearAlgebra:-Eigenvectors? Is it because you have an unassigned symbol as well as floats in the Matrix of your actual problem? That is, your purely float Matrix posted above is just a toy example and not your actual input Matrix?

A sign difference (only) in eigenvectors is not in itself indicative of an accuracy problem. If Vector x is an eigenvector associated with eigenvalue lambda then its negation -x is also an eigenvector. That follows from the definition, and because this is linear algebra.

If you have a discipline specific reason (Physics, say) for wanting a particular sign (or leading sign?), then that's another story. How do you expect the general readership here to understand your statements that this relates to "quantum events"?

What do you mean by, "absolute values of the eigenvectors"? If <-3, 4, -5> is an eigenvector then it doesn't follow that <3, 4, 5> has to be one too.

What do you mean by, "doing multiply operation between eigenvectors"? Is your answer to that going to consist of a discipline specific answer?

@TomM You're welcome for what I believe to be accurate answers to your several questions.

I'm not going to argue with you, however.

@TomM You also wrote, "Well, none of the deimostrations for either Math Apps or Möbius Apps work on the web. There is also no information on downloading them so that I can run from my own Maple."

Worksheets can be served up over the web from a MapleNet server. If such a worksheet contains Embedded Components (ie. are an Application) then the interactive components are accessible via the web interface (browser). Here's a example, which is very slow.

Math Apps are bundled inside your Maple installation itself, and can be found via the Help system. As for obtaining Apps from the Cloud. First open the Cloud palette in your Maple 18. There is a menu item which can show a variety of Mobius apps which can be opened straight into the current GUI session (and saved from there if you want). See the Help page here and here.

Here's an example of another App served up via MapleNet. It's no as slow as the previous one I mentioned. It allows interaction with embedded slider components.

The search facility on this page seems broken, if one restricts to say "web-ready". But I found the "Vertex of a Parabola" App mentioned in the last paragraph by just selecting "All" in the left drop-menu on that page.

@TomM Embedded Components and Maplets use two completely different mechanisms to run, behave somewhat differently, and are set up by the author differently.

Maplets do not use embedded components in any way. It is a technology that came before embedded components existed.

Let's describe some things about Maplets first:

• Source for a Maplet "app" is written in Maple only (as there is no good GUI app that builds Maplets -- the MapletBuilder is inadequate at best).
  
  
• Maplets run in popup windows. They are like Maple applets.
  
  
• When Maplets run the user who interacts with them cannot alter their structure, layout, and underlying action code.
  
  
• When Maplets are launched from a GUI session they take over the focus. The main GUI document cannot be interested with until the Maple is shut down.
  
  
• A Maplet pane can launch a child pane (which takes over full interactive control until closed).
  
  
• Maplets are pretty complete... having fancy things like a FileManager, etc.
  
  
• Maplets are built from Java stuff.
  
  
• Maplets can be launched (from saved source code) and run without the whole GUI opening.
  
  
• Maplets are not really suitable for the MaplePlayer.
  
  
• There is no Maplets repository on either the Maple or the Mobius Cloud.
  
  
• A Maplet is its own (popup) interface.
  
  
• The Maple GUIs Tutors and Assistants (main menubar) are Maplets.

Now let's look at some similar things about Embedded Components, EC for short. I suppose everything can be qualified as "at the present time".

• EC are (almost entirely) formed only by mouse actions. They are inserted into a worksheet using the GUI's palettes. The action code that runs behind then (when a button is pressed, a slider moved, etc) is accessed only by opening an editing window with the mouse.
  
  
• There is (almost entirely) no way to write source that forms a collection of EC in a worksheet as as "app". Undocumented code in the `Explore` command hints that it is possible to author an EC app from source.
  
  
• EC run embedded within the currently open worksheet, just as their name suggests. Actually, EC don't "run" like Maplets do. They are just part of the worksheet, and can be manipulated.
  
  
• EC are not lockable at present, and the user can easily alter their layout, structure, and action code when they are opened in the main GUI. However they cannot be so altered when the worksheet is opened with the MaplePlayer, or when the sheet is accessed from a web browser served up by MapleNet.
  
  
• When the user interacts with EC the rest of the worksheet can still be accessed, as usual. The EC do not take over the focus.
  
  
• The action code behind EC cannot launch (well, insert seems a better term) other EC.
  
  
• There are some useful things missing from EC, such as the ability of an EC to cause the FileManager to launch (so as to Save File, select data file, etc), or a color-chooser applet to open, or even a separate yes/no dialogue. Some rare times the modality can be mimicked by temporarily hiding/revealing some of the EC in a sheet.
  
  
• EC Apps are just... worksheets with EC in them. And Mobius Apps are just... EC Apps.
  
  
• A small number of Tutors might have been re-done as EC, judging by what's available on the ipad version of the MaplePlayer.

I think that it's natural to wonder what might come next.

I would like to see a web browser plugin that would detect an installed MaplePlayer and use it for the computational kernel behind a layout-locked interactive EC App that was running in the web browser. And it could fall back to a kernel on some cloud server, if no Player were detected. But that's just me.

@Thomas Richard Yes, and I don't see how the example can work in Maple 16 unless one uses Diff instead of diff (in which case it works in Maple 18 too).

Looking at the second line of output in Kitonum's comment shows a gray d/dx which means inert Diff, so I don't see how that 1D input shown with lowercase diff could produce that shown 2D output with the inert d/dx.

@Markiyan Hirnyk That's right. The given penalty is zero over a region. That's why I bothered to mention that something might be missing, which might lead to that point suggested by the Asker (or another point along that edge).

You're just repeating (badly) what I already mentioned.

@Markiyan Hirnyk Yes, that was reasons I showed that "FWIW" plot! That is, if we disregard the `penalty` in the Question and instead focus of the multiobjective {f1,f2} and look at their optimizing directions (it's all linear) then we could expect that some answer should be tight up againt that very constraint.

In fact I bothered to point it out explicitly in my first response (I figured that the readership could recognize the constraint divided by 3). I had it (quoting as, 

# Your suggested value also lies on the edge of that region.
eval( x2<=-2/3*x1+2, [x1 = 1.551123, x2 = 0.965918] );
                           0.965918 <= 0.965918000

The interior point I referred to is the one that `Minimize` returned, for the originally posted penalty. That's the point I consider dubious, not the other two. Just read more carefully the paragraph in my Answer that appears right before the red code.

I coded for the given penalty... because that was what was asked. But the penalty itself seems off. I bothered to say all this before, but I guess that you decide to not notice.

@Markiyan Hirnyk Well, it's not very complicated, as an example. {g1<=0,g2<=0,g3<=0} define the triangle as feasible region. The LP problem of minimizing only f1 or only f2 just lead to solutions at the expected corners. Nothing surprising. And the point returned for minimizing the posted `penalty` isn't even on the boundary, while both f2 and f2 are optimized in directions as shown in my "FWIW" plot. So clearly the interior point "solution" is not good. What I wonder is whether the penalty is not correctly constructed, or some other aspect or demand not respected. The paper seems to claim their penalty will produce something which is a pareto minimum w.r.t. {f1,f2}, but that does not seem true of that interior point.

I thought it was clear that the interior point was not right, and that something related to the paper had to be cleared up. That's why I posted it.

@Markiyan Hirnyk That was obvious, I thought. Note that the result suggested by the Asker, and the one given by you and ascribed to DirectSearch, lie on the triangular region which minimizes the objective (penalty) as given.

The question originally asked has minimal value of zero as a region. Is it not so, for the question originally posed?

I just finished editing an additional paragraphs of thoughts on it, while you were responding.

FWIW,

plots:-display(
  plots:-inequal(sol,x1=-1..4,x2=-1..3,color=blue),
  plots:-pointplot([[1.551123, 0.965918]],symbol=solidcircle,
                     symbolsize=15,color=red),
  plots:-pointplot([[1.17067, 1.21955]],symbol=solidcircle,
                     symbolsize=15,color=green),
  plots:-pointplot([eval([x1,x2],ans[2])],symbol=solidcircle,
                     symbolsize=15,color=black),
  plottools:-arrow([0, 0], [3, 3/2], .05, .1, .1, color=green),
  plottools:-arrow([0, 0], [1, 4], .05, .1, .1, color=green),
  gridlines=false);