Depending on what the data looks like. Is it 'text' or an Excel file, or maybe from another application eg Matlab?

If it is text - is it space -separated, comma-separated, tab-separated what?

Alternative is to post the file here (using the big green up-arrow in the MaplePrimes toolbar), preferably with some sort of description of how the data is organized. Then I'm pretty sure someone will figure out how it can be imported into Maple

The code which you say need a "common exit" doesn't because your example

foo:=proc(x)
                   if x=10
                   then ..... final_result :=...
                                 goto common_exit;
                   fi;
                   if x=12
                   then ..... final_result :=...
                                 goto common_exit;
                   fi;
                   common_exit:
                   close file;
                   print common message;
                   return(final_result);
       end proc;

is entirely equivalent to

foo:=proc(x)
                   if x=10
                   then ..... final_result :=...
                   fi;
                   if x=12
                   then ..... final_result :=...
                   fi;
                   close file;
                   print common message;
                   return(final_result);
       end proc;

So why do you need goto?!!! Last time I used used a 'goto' was in FORTRAN (probably) and that would be about 40 years ago. (Yes I really am that old!)

It is unclear to me what you are expecting, and the structure of your code makes it difficult to read, but I'm going to make a wild guess that you are being caught out by the precedence of logical operators.

Your piecewise condition may be essentially written as

(c1 or c2 or c3 and c4 and c5)

Without parentheses, evaluation of this condition is entirely dependent on the precedence of the logical operators 'and' and 'or' The logical 'and' has higher precedence than 'or' so the above will be evaluated as

(c1 or c2 or `and`(c3,  c4, c5))

which becomes

`or`( c1, c2, `and`(c3,  c4, c5))

Note that for your case c4 corresponds to x<>1, and c5 corresponds to y<>1. However if the 'and' condition returns false, you will have

`or`( c1, c2, false)

So provided either c1 or c2 returns true, then the 'or' condition will return true and I'm guessing that this is not what you want! I'll make another guess, that what you actually want is

`and`( c3, c4, c5, `or`(c1,c2) );

I have rewritten your worksheet, to implement this latter condition, with a few other 'clean-ups' mainly to make it easier (at least for me) to read

Download logicProb.mw

is a rectangular 'rod' - so you can use the geom3d() package, as in

Download rod.mw

You can change dx, dy, dz to any values you want.

There are many other ways to do the same thing

1. Ensure that there is a restart() command at the top of the worksheet, and exists as the only command in an execution group
2. Does the behaviour persist when re-executing the whole worksheet, with the restart command as above. NB executing a part of the worksheet containing the pdsolve() command can be very misleading - so don't
3. If anything in your worksheet involves floating-point calculations, then increase the setting of Digits() at the head of your worksheet. It is possible that you may be running into some kind of floating point rounding issue.
4. Are yu using any knid of parallel processing anywhere (Grid or threads) - If you are, consider running single-threaded in case you have some kind of 'race' condition somewhere
5. insert something like an lprint(whatever_your_pdsyytem_is_called) command immediately prior to the pdsolve() command. Is the output of the lprint() command the same regardless of whether the subsequent pdsolve() command fails or not?
6. If the lprint() output is the same whether pdsolve() fails or not, then cut/paste its output into a new worksheet which will then allow you to check the pdsolve() command on the pdesystem without running the whole worksheet. Should(?) avoid/sidestep any memory issues, Does it still fail intermittently?
7. If it still fails randomly, upload (big green arrow in the Mapleprimes toolbar)  to here the slimmed-down worksheet produced at (6) above

At some point Maple changed "help" files from  hdb format to help format.

The only way to access info in the former, is to convert them

Ignore this response - it's crap. See vv's later posts if you need to know why

1. I'm assuming that these edge lengths are given in no particular "order"
2. One (more-or-less) standard way of ordering edges in a tetrahedron is to not that any given edge shares a vertex with four other edges, and hence there is one edge with which there is no shared vertex. Hence the six edges can be grouped in three pairs, as [a, b, c, abar, bbar, cbar], where 'a' and 'abar' do not share a vertex
3. Note that the above notation is still "ambiguous" because one could equally well write [b, a, c,bbar, abar, cbar], so that there are six ways to present information for the same tetrahedron. Some of these *may* be identical, for example if all edges are the same length
4. A little googling suggests that a set of 6 numbers will be the edges of a tetrahedron if something called the "McCrea determinant" is positive. You might want to verify this statement - I am just assuming it to be true.
5. The attached code evaluates this determinant for all possible combinations of a supplied list of 6 numbers, and outputs those combinations which give a resultl >0. Note that because of the ambiguity mentioned in (3) above, if one of the combinations represents a tetrahedron, then there will be multiple (equivalent) outputs. I have made no attempt to eliminate these "cyclic" variations. You seem to be more interested in a true/false answer

Try the attached

Download tetra.mw

A couple of issues, which explain the problem

1. the typesetting() command only suppresses the display not the underlying expression - so if you send the expression anywhere other than the display, eg to the MathML() command, the functional dependence will reappear.
2. one way to get around this is to actually substitute 'f(t)' with 'f'. However, when Maple processes the subsequent expression, containing diff(f, t), it will "simplify" this to 0, because 'f' no longer depends on 't'.
3. One can circumvent the undesirable behaviour in (2) above by first onverting the input expression to 'inert/Diff' form, becuase Diff(f,t) will not be "simplified"

So check the difference between the two returned MathML() commands in the following

restart;
Typesetting:-Suppress(f(t)):
eq:=diff(f(t),t)=f(t);
MathML:-Export(eq);
MathML:-Export(subs( f(t)='f',convert(eq, Diff)));

I have limited ability to check this, because I don't happen to have a seriously good, stand-alone, mathML reader

Although dsolve(..., numeric)  has an output=Array() option, pdsolve(....., numeric) does not.

Probably the most efficient(?) way to generate the required Arrays is to 'plot3d' method, with the 'grid' option, the latter (along with the 'range' settings) will determine the points used for the plot. One can then access the resulting grid of values using plottools:-getdata(). as shown in the attached

Download pdeArr.mw

One could also use the 'value' method returned in the module returned by the pdsolve() command, to genrate the same data, although I generally find that this is considerably slower

restart;
with(ListTools):
A := 11:
B := 21:
a := Reverse(convert(A, base, 3));   # returns [1, 0, 2]
b := Reverse(convert(B, base, 3));   # returns [0, 1, 2]
convert( Reverse(a+~b mod 3), base, 3, 10);

Having obtained an 'exact' solution for your ODE, I have no idea why you would want to find a power series solution, which would only ever be approximate. Seems pointless!

Having said that, he attached computes the exact solution, and the power series solution (in two different ways, although for "practical" purposes, the two power series are identical). It produces plots of the exact and power series solutions as well as errors between the two

Download odePow.mw

You define private_proc as 'local' to the module, hence Maple will never look 'outside the module' for private_proc(), even if the latter is not defined within the module. So

restart;
private_proc:= proc()
    print("Opps, should not be calling this, global copy");
end proc;

foo :=module()
    local private_proc;
    export public_proc;

   # private_proc:=proc()
   #     print("inside private");
   # end proc;

   public_proc:= proc()
        private_proc(); #will this always call foo:-private_proc() and not
                        #any other global proc with that name?                 
   end proc;

end module;
foo:-public_proc();

will just return (unevaluated) -  private_proc()

On the other hand, if you delete the 'local' statement, or replace it with 'global', then the module will call the 'externally defined' private_proc(). Try

restart;
private_proc:= proc()
    print("Opps, should not be calling this, global copy");
end proc;

foo :=module()
    export public_proc;

   # private_proc:=proc()
   #     print("inside private");
   # end proc;

   public_proc:= proc()
        private_proc(); #will this always call foo:-private_proc() and not
                        #any other global proc with that name?                 
   end proc;

end module;
foo:-public_proc();

which will return

"Opps, should not be calling this, global copy"

Depending on 'global' scope is always poor programming style. In the case of modules, one of whose purposes is 'encapsulation', I'd call it poor^2 programming style - but you can do it if you want.

1. assign some values to a[1] and b[1]
2. select a few values for 'x' and 't' in order to generate the values of the function f(x,t) with the given parameter values a[1] and b[1]. This is just numerical test data to be used for the fitting process
3. unassign the parameters a[1] and b[1]
4. Fit the test data to the model function, in order to compute values for a[1] and b[1] If the process is successful then one should get (very close to) the same values as used in (1) above

The attached worksheet implements the process for the first of your functions. (The second is left as an exercise for the reader!)

Download doFit.mw

piecewise( seq( [x<j/10, (x-cat(x,j)+j)/0.1][], j=1..10));

note that you have ten conditions, x<0.1, x<0.2....x<1, but only nine values, so I guessed your intent

A long time ago, someone started to use the term 'lint', see https://en.wikipedia.org/wiki/Lint_(software). A 'linter', or 'lint' command is generally used to "analyze source code to flag programming errors, bugs, stylistic errors, and suspicious constructs"

Many (particularly interpreted?) languages have an equivalent function - as example try typing "Python lint" in your favourite search engine

I suspect that once upon a time the command 'maple lint' got shortened to 'mint' -so in what follows I'm going to use the terms 'lint', 'linter' 'linting' etc.

1. Some linters report syntax errors, although since these should(?) be caught by your interpreter/compiler, this is sometimes seen as unnecessary duplication. Hence some/many other linters focus on issues of programming style and 'suspicious' constructs. I notice from Maple's help, that maplemint does not report syntax errors, whereas the standalone mint does.
2. So maplemint is a linter, which focuses on "bad programming style". This is often a pretty subjective assessment, Just because a linter reports an issue
   1. don't take it personally!!!
   2. you don't have to fix/change anything, but you might want to think about it
   3. if you are happy, then it is fine just to leave it
3. Not only do linters have to make a "fairly subjective" assessment, my experience is that they have a tendeny to "overreport". The latter is presumably a result of attempting to catch all instances of "bad programming style". Almost inevitably some perfectly acceptable constructs will be flagged. The alternative would probably be a "less aggressive" linter which missed the occasional (potential?) issue. Which of the two would you prefer, because the 'perfect' linter is probably impossible!
4. Also remember that  one allowed to use  a linter in private. No-one else will ever know about my/your "bad programming style". So don't take it personally :-)