Smart way to remove rules from lists, leaving just values, specifically from FindMinimum output

Question

I would like to know if there is a direct way to remove the rules from a list of rules.

I know that, simply, this can be done with:

 [in]  := {a,b} /. {a->1,b->2}
 [out] := {1,2}

But the output from FindMinimum returns a list with the second element as a list of rules. i.e.:

 [in]  := FindMinimum[f,x]
 [out] := {0.1234,{x->321}}

Successfully, I got rid of it the rule by using Map (/.)

 [in]  := { #[[1]], x /. #[[2]] } & @ FindMinimum[f,x]
 [out] := {0.1234,321}

But is there any other, more elegant, way?

Scratch ideas of my desired output:

Does exist a function to remove all the rules and leave behind just the values? Kind of a "RemoveRules" function

 [in]  := RemoveRules[ FindMinimum[f,x] ]
 [out] := {0.1234,321}

I've observed in more advanced coding, that _ does "nothing" over mapped lists. Maybe like this?

 [in]  := {_,x} /. FindMinimum[f,x] 
 [out] := {0.1234,321}

Answer 1

I want to add this reply in response to the comment written under the OP.

The function Values does not work, as all the elements of the list are not rules. (the first element is a value, the second is a rule)

Well, it works if you Apply appropriately

Values @@@ FindMinimum[x Cos[x], {x, 2}]

Answer 2

Let

ruleNixer = Rule[_, v_] :> v;

Example1 from the docs:

FindMinimum[x Cos[x], {x, 2}]

{-3.28837, {x -> 3.42562}}

FindMinimum[x Cos[x], {x, 2}] /. ruleNixer

{-3.28837, {3.42562}}

This can be flattened as needed.

Example 2:

FindMinimum[{x + y, 
   x + 2 y >= 3 && x >= 0 && y >= 0 && y \[Element] Integers}, {x, 
   y}] /. ruleNixer

{2., {0., 2}}

The second example clearly shows that getting rid of rules has limited usefulness. For instance, there are two variables x and y and the 0, 2 are values for those variables respectively. Removing rules removes that information too. This looks like an XY-Problem.

Answer 3

If you're needing to handle output from FindMinimum specifically, then since you know that structure you know how to "re-structure" it:

Extract[FindMinimum[x Cos[x], {x, 2}], {{1}, {2, 1, 2}}]

or

MapAt[Last@*First, FindMinimum[x Cos[x], {x, 2}], -1]

or any number of such variants.

If you're asking more generally, "how to extract the 'value' part from a Rule", then that's the same as asking, "how to extract the second part from a Rule", or equivalently, "how to extract the last part of a Rule". And so given any ruleExpr, you can do any of these (or any equivalent thing with related list-aware functions):

Last[ruleExpr]
ruleExpr[[2]]
ruleExpr[[-1]]

EDIT

Since you discovered Values, here is one way you could use that:

MapAt[First@*Values, FindMinimum[x Cos[x], {x, 2}], -1]

Answer 4

These methods work correctly with any number of variables of any dimensionality:

f1 = Last[#, #] & /@ Flatten@# &;
f2[{m_, r_}] := Flatten[{m, Values[r]}, 1]

Examples:

min1 = FindMinimum[{x . {1, 2, 3}, x \[Element] Sphere[]}, x]
min2 = FindMinimum[{x + y, {x, y} \[Element] Disk[]}, {x, y}]

{-3.74166, {x -> {-0.267261, -0.534522, -0.801784}}}

{-1.41422, {x -> -0.707108, y -> -0.707108}}

f1@min1
f1@min2
f2@min1
f2@min2

{-3.74166, {-0.267261, -0.534522, -0.801784}}

{-1.41422, -0.707108, -0.707108}

{-3.74166, {-0.267261, -0.534522, -0.801784}}

{-1.41422, -0.707108, -0.707108}

Answer 5

Odds and ends

Single and two-variable examples:

out = FindMinimum[Sin[x], x]
out2 = FindMinimum[Sin[x] + Cos[y], {x, y}]
(*
{-1., {x -> -1.5708}}
{-2., {x -> -1.5708, y -> 3.14159}}
*)

Unflattened results (can always Flatten[] them):

out /. Rule -> (#2 &)
out2 /. Rule -> (#2 &)
Apply[#2 &, out2, {2}] (* N.B. #2& @@@ -2. yields -2. *)
Extract[out2, {{1}, {2, All, 2}}]
FoldList[Values[#2] &, out2]
(*
{-1., {-1.5708}}
{-2., {-1.5708, 3.14159}}
...
*)

Flattened results (works on both one- and two-variable):

Flatten[out2 /. Rule -> (#2 &)] (* see previous set of examples *)
Cases[out2, _?NumericQ, 3](* or Cases[out2,_Real,3] for FindMinimum *)
Extract[out2, Join[{{1}}, Table[{2, j, 2}, {j, Length@Last[out2]}]]]
FoldList[Sequence @@ Values@#2 &, out2]
Level[out2, {-1}][[;; ;; 2]]
{#, ## & @@ (#2 & @@@ #2)} & @@ out2 
(*  {-2., -1.5708, 3.14159}  *)

One-variable only:

Extract[out, {{1}, {2, 1, 2}}]
(*  {-1., -1.5708}  *)

See previous see for multivariable Extract method. Often when working in a multivariable project, I define vars to be the variables and use it so I don't have to type the variables out every time:

vars = {x, y};
out2 = FindMinimum[Sin[x] + Cos[y], vars];
Extract[out2, Join[{{1}}, Thread[{2, Range@Length@vars, 2}]]]
(*  {-2., -1.5708, 3.14159}  *)

Don't forget this unasked-for method of dealing with deconstructing the solution (I'd prefer to keep the independent variable solution component as replacement rules and just separate them from the optimum):

{ymin, xmin} = FindMinimum[Sin[x], x];

Update: Another way:

sol = Last@FindMinimum[f[x, y], {x, y}];
{f, x, y} /. sol (* or {x, y, f} /. sol *)

But I wouldn't use it if reevaluating f is expensive. FindArgMin[f, vars] returns a "solution" but not in the standard form of replacement rules. So if you want neither the value of f nor a Rule-form solution, use

FindArgMin[Sin[x], x]
FindArgMin[Sin[x] + Cos[y], {x, y}];
(*  {-1.5708}  <-- N.B. a 1-vector, not a scalar *)
(*  {-1.5708, 3.14159}  *)

And complementarily, for the function value without the argument values, there is

FindMinValue[f[x], x]