The following *seems* to work irrespective of whether the worksheets contain the character sequence 'Variational Calculus' in plaintext or not - so it works when 'grep' or 'editor-based' approaches do not.

Structure is similar to the code I posted before, but rather than using FileTools:-ReadFile, the main difference is to use WorksheetToMapleText() from the Worksheet package.

On the tests I have run (in both 1D input and 2D-input), it will detect any files using

with(VariationalCalculus)

as well as any case where commands in the VariationalCalculus package have been referenced in 'long form', eg

VariationalCalculus[someCommand], or

VariationalCalculus:-someCommand

What it will not detect is the case where the VariationalCalculus package is loaded by the target worksheet reading/referring to additional files.

Download search2.mw

Maple has two major types of commands  - one of which is 'builtin' and the other is not usually named, but can be thought of as 'not builtin'. It is actually slightly easier to explain what a 'not builtin' function is!!

A function which is 'not builtin is actually written as a procedure in the Maple language, and the code of this procedure can be examined. For example you might think that the sine function sin() is a very low-level function which just 'gets evaluated". However if you execute the command

showstat(sin);

this will display the Maple procedure which is run every time you use sin(). This procedure mainly does a lot of argument checking whilst it figures out what to do with whatever argument you have supplied. It may call sub-procedures etc etc until eventually a decision  can be made on exactly what calls to the kernel (if any) are necessary.

Consider as a trivial example the simple case where the argument of sin() is the unassigned name 'x'. Simply passing this directly to C would just result in an error, because the latter (like most programming languages)generally doesn't know what to do with the 'sine' of an 'unknown'

On the other hand 'builtin' commands are not written as Maple procedures: They can access sort-of-equivalent C commands in the kernel more or less direclty, because it is safe to do so

I tend to agree with Joe Riel that other tools may be more appropriate for the job.

As well as 'grep', assorted hack tools like perl/python would work. In fact any decent programmer's editor (emacs/notepad++) would do the job very efficiently - and one of those previously mentioned would probably be my first choice!

But it can be done using only Maple, if you really want to.

Consider a "toy" example where I have two Maple (ie .mw) files

with(VariationalCalculus):
f := (diff(x(t),t)^2 + diff(y(t),t)^2)^(1/2):
EulerLagrange( f, t, [x(t),y(t)]):
g := (1 + diff(y(t),t)^2)^(1/2)/y(t)^(1/2):

and

f := (diff(x(t),t)^2 + diff(y(t),t)^2)^(1/2):
EulerLagrange( f, t, [x(t),y(t)]):
g := (1 + diff(y(t),t)^2)^(1/2)/y(t)^(1/2):

stored as foo.mw and bar.mw respectively - so one want to "read" these with Maple, figure out which one contains the 'with(VariationalCalculus)' command, and return the file name, in this case 'foo.mw'  This can be achieved with the attached, although there are a few provisos

1. The directory where the files are stored, specified as dirName in the attached will have to be chenged to something appropriate for your machine: ie the directory where all your files are stored
2. It would not be difficult to modify the following to handle files in multiple directories - just needs two loops rather than one, with the outer loop being a list of directories
3. The code makes no distinction between Maple files and any other files you might have the same directory(ies). Again it would not be very difficult to restrict the file processing to only those files with .mw, .mws, .mpl extensions

Download search.mw

1. Lists can contain duplicate elements, but sets cannot, so Maple will preserve the list [1,1,2,3], but if you enter the set {1,1,2,3}, then Maple will 'simplify' this to {1,2,3}. An element is either a 'member' of a set or it is not: it makes no sense to say that an element is a member of set "more than once"
2. Lists preserve order of elements, but sets do not. Generally, set elements will be displayed in lexicographic order, although it is always bad programming practice to rely on element ordering in sets, the only thing whihc can be guaranteed is membership

There are other, (more subtle) differences: for example you can reassign the values of elements in a set with

a:=[1,2,3,4];
a[1]:=7;
a;

but this is not possible with sets: probably because Maple considers it bad practice to do anything *significant* to a set, based on element ordering

with a few edits to your original (assuming I haven't made a type somewhere!), you can use pdetest(), but this suggests that your supplied function is not a solution of the pde! See attached

Download pdtest.mw

On the Maple toolbar

File->Export as->

In the pop-up window use "Files as type" and choose pdf

for determining how Maple deals with branch cuts. This is explaine don the help page for LegendreQ(), LegendreP() - although you have to read very, very carefully (at least I did!). However if one sets _EnvLegendreCut:=1..infinity, then the answer you desire is obtained. See attached.

 

Download LegProb.mw

and usually one cannot just choose ics - they are a fundamental part of the problem. Having said that, solutions are possible for some ics - for example the following

restart;

sys := [6*(diff(a(t), t))^2+12*a(t)*(diff(a(t), t$2))-3*a(t)^2*phi(t)^(-2*c)*sqrt(1-alpha*(diff(phi(t), t))^2), 2*c*a(t)^3*phi(t)^(-2*c-1)*sqrt(1-alpha*(diff(phi(t), t))^2)-3*alpha*a(t)^2*phi(t)^(-2*c)*(diff(a(t), t))*(diff(phi(t), t))/sqrt(1-alpha*(diff(phi(t), t))^2)-alpha*a(t)^3*phi(t)^(-2*c)*(diff(phi(t), t$2))/sqrt(1-alpha*(diff(phi(t), t))^2)+2*c*alpha*a(t)^3*phi(t)^(-2*c-1)*(diff(phi(t), t))^2/sqrt(1-alpha*(diff(phi(t), t))^2)-alpha^2*a(t)^3*phi(t)^(-2*c)*(diff(phi(t), t))^2*(diff(phi(t), t$2))/(1-alpha*(diff(phi(t), t))^2)^(3/2), R(t) = 6*((diff(a(t), t))^2/a(t)^2+(diff(a(t), t$2))/a(t)), W(t) = -phi(t)^(-2*c)*sqrt(1-alpha*(diff(phi(t), t))^2)/(1/a(t)^3+a(t)^3+phi(t)^(-2*c)/sqrt(1-alpha*(diff(phi(t), t))^2))]:

ics:=[a(0)=1, D(a)(0)=1, phi(0)=1, D(phi)(0)=0];

sol:=dsolve( [eval(sys, {c=1, alpha=1})[], ics[]], numeric);
plots:-odeplot( sol,
                [ [t, a(t), color=red],
                  [t, phi(t), color=green],
                  [t, R(t), color=blue],
                  [t, W(t), color=black]
                ],
                t=0..10
              );

The attached code will return the minimum value attained by each curve, but

1. I'm not sure if this is what you want
2. There are probably better ways to do this, but until (1) above is resolved.....

Download getmins.mw

I stored your Matlab script on my "Desktop", as C:/Users/TomLeslie/Desktop/covMarket.m.

I executed the the following code in Maple

restart;
with(Matlab):
FromMFile("C:/Users/TomLeslie/Desktop/covMarket.m",
                    "C:/Users/TomLeslie/Desktop/covMarket.mpl");

This created the following ".mpl" file on my desktop

covMarket := proc( x, shrink )
    uses ArrayTools, LinearAlgebra;
    local sigma, shrinkage;
    # function sigma=covmarket(x)
    # x (t*n): t iid observations on n random variables
    # sigma (n*n): invertible covariance matrix estimator
    #
    # This estimator is a weighted average of the sample
    # covariance matrix and a "prior" or "shrinkage target".
    # Here, the prior is given by a one-factor model.
    # The factor is equal to the cross-sectional average
    # of all the random variables.
    # The notation follows Ledoit and Wolf (2003)
    # This version: 04/2014
    #%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    # This file is released under the BSD 2-clause license.
    # Copyright (c) 2014, Olivier Ledoit and Michael Wolf
    # All rights reserved.
    #
    # Redistribution and use in source and binary forms, with or without
    # modification, are permitted provided that the following conditions are
    # met:
    #
    # 1. Redistributions of source code must retain the above copyright notice,
    # this list of conditions and the following disclaimer.
    #
    # 2. Redistributions in binary form must reproduce the above copyright
    # notice, this list of conditions and the following disclaimer in the
    # documentation and/or other materials provided with the distribution.
    #
    # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
    # IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
    # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
    # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
    # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
    # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
    # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
    # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
    # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
    # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
    # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    #%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    # de-mean returns
    t := ArrayTools[Size](x, 1);
    n := ArrayTools[Size](x, 2);
    meanx := mean(x);
    x := x -~ meanx(rtable(proc(A)
    local j, n;
    if A :: rtable[row] then
       n := ArrayTools:-NumElems(A);
       if n = 1 then
           1..A(1), 1..A(1), fill = 1, subtype = Matrix;
       elif n = 2 then
           1..A(1), 1..A(2), fill = 1, subtype = Matrix;
       else
           seq(1..A(j), j = 1..n), fill = 1, subtype = Array;
       end if;
    else
       seq(1..args[i], i = 1..2), fill = 1, subtype = Array;
    end if;
end proc(t, 1)), ..);
    xmkt := HermitianTranspose(mean((HermitianTranspose(x))));
    sample := MTM[mrdivide](cov(Concatenate(2, x, xmkt)) . (t -~ 1),t);
    covmkt := sample(1..n, (n +~ 1));
    varmkt := sample((n +~ 1), (n +~ 1));
    sample(.., (n +~ 1)) := Vector();
    sample((n +~ 1), ..) := Vector();
    prior := covmkt . HermitianTranspose(covmkt) /~ varmkt;
    prior(map(proc(x) if not x::realcons then error("real input expected"); fi; `if`(x = 0, 0, 1); end, LinearAlgebra[IdentityMatrix]((A->`if`(A::rtable,entries(A,'nolist'),A))(n),'compact'=false))) := evalf(ArrayTools:-Diagonal(sample));
    if ArrayTools[AllNonZero]((evalhf(zip(`or`,eval((evalhf(zip(`<`,eval(nargs),eval(2))))),eval((evalhf(zip(`=`,eval(shrink),eval((-1)))))))))) then
        c := evalf(LinearAlgebra[MatrixNorm]((sample -~ prior),'Frobenius'))^2;
        y := x ^~ 2;
        p := MTM[mrdivide](1,t) . AddAlongDimension(AddAlongDimension(((HermitianTranspose(y)) . y))) -~ AddAlongDimension(AddAlongDimension((sample ^~ 2)));
        # r is divided into diagonal
        # and off-diagonal terms, and the off-diagonal term
        # is itself divided into smaller terms
        rdiag := MTM[mrdivide](1,t) . AddAlongDimension(AddAlongDimension((y ^~ 2))) -~ AddAlongDimension((evalf(ArrayTools:-Diagonal(sample)) ^~ 2));
        z := x *~ xmkt(.., rtable(1..1, 1..n, fill = 1, subtype = Matrix));
        v1 := MTM[mrdivide](1,t) . HermitianTranspose(y) . z -~ covmkt(.., rtable(1..1, 1..n, fill = 1, subtype = Matrix)) *~ sample;
        roff1 := MTM[mrdivide](AddAlongDimension(AddAlongDimension((v1 *~ (HermitianTranspose(covmkt(.., rtable(1..1, 1..n, fill = 1, subtype = Matrix))))))),varmkt) -~ MTM[mrdivide](AddAlongDimension((evalf(ArrayTools:-Diagonal(v1)) *~ covmkt)),varmkt);
        v3 := MTM[mrdivide](1,t) . HermitianTranspose(z) . z -~ varmkt . sample;
        roff3 := MTM[mrdivide](AddAlongDimension(AddAlongDimension((v3 *~ (covmkt . (HermitianTranspose(covmkt)))))),varmkt^2) -~ MTM[mrdivide](AddAlongDimension((evalf(ArrayTools:-Diagonal(v3)) *~ (covmkt ^~ 2))),varmkt^2);
        roff := 2 . roff1 -~ roff3;
        r := rdiag +~ roff;
        # compute shrinkage constant
        k := MTM[mrdivide]((p -~ r),c);
        shrinkage := max(0, min(1, (MTM[mrdivide](k,t))));
    else
        shrinkage := copy(shrink);
    end if;
    # compute the estimator
    sigma := shrinkage . prior +~ (1 -~ shrinkage) . sample;
    # compute the estimator
    if _nresults = 2 then
        return sigma, shrinkage;
    else
        return sigma;
    end if;
end proc;

Does it work? No idea, because I don't know what arguments to provide:-(

I assume that when you write e^() you mean exp() - OK?

With this assumption, you can produce a basic field plot over the required range with

with(VectorCalculus):
F := VectorField( < y*z*exp(x*y*z)+3*x^(2),
                                x*z*exp(x*y*z)+2*y*z+cos(y),
                                x*y*exp(x*y*z)+y^(2)+1
                             >
                          ):
plots:-fieldplot3d( F,
                                x=-1..1,
                                y=-1..1,
                                z=-1..1
                           );

Ther are many options available for the fieldplot3d() which you can play with

as in the following. This will provide one solution. If you believe there are further solutions (and there may be) then post back here and someone will take another look at it.

Download getSols.mw

but since you can't be bothered, I will try to summarise for you. Given

H:=[0, 4, 8, 1, 2, 1, 4, 2, 8];

it is rather obvious (to me at least) that H is of type list. So

type(H, list);

will return true. But you can't be both a list and an integer - so which would you expect? Now if you want to check whether the list contains entries of type integer, then that would be a completely different question - and relatively easy to test

Now if you read the help entry for the has() command, it checks whether the first expression 'contains' the second expression. Importantly, the second argument has to be an expression, not a type. Thus has(h,2) will return true and has(h, integer) will return false. What is difficult about this distinction?

approxint := proc (expr, r::(name = numeric .. numeric), { numsamples::integer := 1000 })
                  local f, randvals;
                  f := `if`(type(expr, procedure), expr, unapply(expr, lhs(r)));
                  randomize();
                  randvals := LinearAlgebra:-RandomVector(numsamples, generator = evalf(rhs(r)), datatype = float[8]);
                  add(f(randvals[i]), i = 1 .. numsamples)*(rhs(rhs(r))-lhs(rhs(r)))/numsamples
             end proc;
approxint(x^2, x = 1 .. 3);

In your original (2D) input, it seems as if you inadvertently inserted multiple "implied multiplications" by having spaces in the wrong places

latex(a[p, q] = Sum(cos(2*Pi*(p+1)*(n-1)/q), n = 1 .. q));

a_{{p,q}}=\sum _{n=1}^{q}\cos \left( 2\,{\frac {\pi\, \left( p+1
 \right)  \left( n-1 \right) }{q}} \right)