Download extract_data_from_the_figure.mw

here is a potential solution.

In my opinion, it is safe to use names beginning with underscore as long as you don't assign to those names.

@mmcdara You show an example with a matrix of floats. Well, of course the product of its eigenvalues is trivial! Thus it is clear that this is not what the instructor intended. They intended matrices of exact integers. Simplifying the product of the three radical-form exact roots of a cubic is not trivial. (Not too difficult either, but not trivial.)

@Muhammad Usman Having looked at your code, I know that the eta and k2 aren't explicitly present in your arguments for exp. So, I have some suspicion about the robustness of using algsubs for this, although I haven't actually tested it. Anyway, I'd always prefer a solution using subsindets or evalindets over one using algsubs, when possible. So here's the alternative, assuming that f is the expression in which you want to make the substitution:

subsindets(f, exp('anything'), e-> Z^simplify(op(e)/eta));

(This Reply is not meant in any way to be a criticism of Tom Leslie's algsubs solution, which may work perfectly well for your situation.)

@mmcdara  You can make the procedure learn and remember the parts of the input that have already been scanned so that you can make your efficiency improvement for multiple calls without needing to use three arguements. Like this:

FirstHit:= module()
local
   Maxes:= table(),
   ModuleApply:= proc(L::{Array,list}(float), C::realcons)
   local c:= evalf(C), k, n:= 1;
      if assigned(Maxes[L]) and c >= Maxes[L][1] then
         n:= Maxes[L][2]
      fi;
      for k from n to nops(L) do
         if L[k] > c then
            Maxes[L]:= [c,k]; 
            return k 
         fi
      od;
      FAIL
   end proc
;
end module:

The calling protocol is identical to the former procedure, and the learning/memory mechanism is transparent to the user.

@Markiyan Hirnyk The OP wants to know which Maple command or package is best for their system, and they mention numerous specific commands and packages. Thus, it's a very Maple-related Question.

@mmcdara I haven't heard the maxim "flee the loop like the plaque." Anyway, if you want to avoid loops for efficiency reasons rather than stylistic ones, then it shouldn't matter whether the loops are explicit or in the underlying code. Your procedure contained three full loops through the entire input Array/list: one for each ~ and one for SearchAll. On the other hand, my single loop "short circuits" upon finding the first sufficient Array/list value, so its average-case behavior is less than one full scan (usually much less).

Yes, unfortunately, most Maple commands, especially older ones such as thaw, simply ignore extra arguments that they are passed. This is easy to avoid in modern procedures by using $ as the last parameter.

Put the output of solve in a list:

expand(thaw([solve(subsindets({sys}, suffixed(_), freeze@``) ,{x})])); 

The solve in your Question gave output as a single piecewise expression rather than as a sequence of multiple sets. Sequence-form output usually needs to be put into a set or list before further processing.

@farah adanan Please read this MaplePrimes Question very carefully, including the paper that the Question's author attached to a Reply, my Answer "It's a BVP", and all the followups to that Answrer: https://www.mapleprimes.com/questions/224706-Please-I-Need-Some-One-To-Help-Me-With#answer249172

That Question is very similar to your Question, and the paper is very similar to the paper that you attached. Indeed, it's also about nanofluids. My extensively coded Answer, which replicates 56 plots and 2 tables from the paper, could be used for your problem with very small modifications.

@Kitonum Or, easier still, 1/M

@vv The problem is not caused by using a variable whose name begins with underscore. It is caused by using a variable, of any name, that is assumed integer.

@farah adanan In the linked paper, they used 40 for infinity.

Do you have some reason to think that it should converge for Z=4?

@Annonymouse Your error comes from remove(evalb, s). In order for it to work, s must be a list or set of relations (such as equations or inequalities) such that each can be determined to be true or false. Expressions such as polynomials that aren't relations won't work. When I used it in earlier code for you, we were dealing with lists of equations. If eq is an equation, then evalb(eq) returns true iff the left side and right side of eq are identically the same. Thus, I was using it to remove vacuous equations of the form x=x.