which is why I asked him/her.

But I'm running 64-bit Maple (all versions from Maple 18 to Maple 2018) on 64-bit Windows 7, and the code I posted works on all of these

Trying my original code (developed in Maple 2018, because that is my current default) in Maple 2016, everything still works. I added the kernelopts(version) command just to output Maple version and OS: Maple 2016.2 running on 64-bit Windows 7

As can be seen from the code below, everything still works

Download dragCurve2.mw

I have to admit that I'm struggling for suggestions as to why this code might not work on your installation - so excuse me if I'm stating the obvious things for you to check

1. When you post code which doesn't work, it is in 2D input mode. How did my original code get converted to 2D input? Just don't! Download the code given in the above link and park it somewhere convenient. Shut down all Maple sessions. Start a new Maple session. Use the File->Open dialog to load the downloaded worksheet from wherever you parked it - and use the !!! toolbar button to execute it
2. If this appears as 2D-input (which it shouldn't) then shut down the Maple session, and start it again. Go to Tools->Options->Display and ensure that "Input Display" is set to Maple Notation. Also check that Tools->Options->Interface->Default Format for New Worksheets is set to Worksheet. Having made these changes, hit the "Apply to Session" button at the bottom of Tools->Options popup.
3. Now use the File->Open dialog, repeating stage1 above. Code should now at least appear in 1D-input mode. Execute using the !!! toolbar button
4. If execution still fails with the same error message, then there would seem to be only two solutions
   1. It is a Maple installation problem - rare but possible: a Maple reinstallation might be required
   2. It is OS specific: I'm running 64-bit Win 7. If you are running anything else, that might be the issue

The dragon curve is one of the examples in Maple's Fractals() package, so can be plotted in a couple of lines of code.

If you consider this to be "cheating", then you can use the Lindemayer Systems subpackage to define your own dragon curve (and plot it).

The attached does it both ways, althoug for reasons I haven't worked out, the final plot for the second is rotated by Pi/2 compared with the first

Download dragCurve.mw

You have produced the most garbled, meaningless, code, I have seen in a long time!

Your first code sequence defines a procedure called 'dragon1()' - you then call something called 'dragon()' which is completely undefined! Am I supposed to assume that when you write

dragon(7, 1/4)

you actually want to call the procedure you have defined as dragon1()? If not, please supply code for the procedure dragon()

Actually, you won't get far calling the defined procedure dragon1(). It has multiple instances of unbalanced parentheses (ie '()' ) and brackets ( ie '[]'), as well as incorrect numbers and types of of arguments for the various plot commands which it contains. I'm usually fairly good at guessing what the intention of code might be, but this has so many logical and syntax errors, that I have absolutely no idea what you are trying to achieve. The following is the closest I can get to your original code, which actually executes - although I wouldn't say that it does anything particularly meaningful. It just produces a lot of pretty random plots.

Download oddPlot.mw

I did nothing with code you posted as dragon2(), since you chose to post this as a 'picture'. Since it is a 'picture', I can't load it, execute it, or in fact do anything meaningful with it. And I am sure as hell not going to retype it!

LOading code on this site should always be done using the big green up-arrow in the toolbar - that way people like me at least get something we can work with. Uploading 'pictures/images' is just totally useless

axiom:="FX":newf:="F":newx:="X+YF+":newy:="-FX-Y":

you define the variables 'axiom', 'newf', 'newx' and 'newy' as various strings. Since none of the variables 'axiom', 'newf', 'newx' and 'newy' are actually used by anything in your subsequent code, all of these definitions are totally and completely pointless

W:=l_system(12);

You define the variable 'W' in terms of the function l_system() evaluated with the argument '12'. Since the function l_system() is undefined in the code you supply, then l_system(12) cannot be evaluated, and hence 'W' is equally undefined. However since 'W' is not actually used anywhere in this code snippet, the fact that it is undefined just makes this line  totally and completely pointless

l:=turtle(0,Pi/2);

The function 'turtle()' is undefined in this code snippet and therefore cannot be evaluated, Hence 'l' is also undefined

In the future, instead of using cut-and-paste to insert more or less meaningless code snippets, I suggest you use the big green up-arrow in the toolbar to upload complete Maple worksheets. That way, somebody here might have some chance of guessing what your problem is

The attached works for me in Maple 2016

Download sierp.mw

Excerpt from the help for the RootFinding() package (emphasis added)

The RootFinding package is a suite of advanced commands for finding roots numerically. The routines in this package augment the root-finding functionality provided by fsolve, especially with respect to finding several roots concurrently.

Thus the RootFinding:-Analytic() command will numerically attempt to find all complex roots of the function given as its first argument, over the region of the complex plane specified by the subsequent arguments.

This numerical process will work provided the given function is 'analytic'. Roughly speaking, a complex analytic function has a complex derivative at every point of its domain, and in consequence has derivatives of all orders and agreeing with its Taylor series locally. (Wikipedia has a more detailed definition of 'analytic function').

1) Why does solve & RootFinding not concur in the case of chek?

RootFinding generates numerical solutions: solve() attempts to find analytic solutions. If you wish to explore the difference between these concepts, consider the problem of 5-th (or higher order) univariate polynomials. There is no known analytic solution - see for example https://en.wikipedia.org/wiki/Quintic_function. However numerical solution can usually be determined. Just because you want a problem to be solved analytically, does meean that it can be done

2) solve seems to overlap the RootFinding solutions ONLY AFTER definition to the parameter values are specified, why is that?

Because as the number of unknowns is reduced, the probability of finding some (but not all?) analytic solutions will (probably) increase. Basically you are making the problem "simpler". Although if you consider the case of the quintic (mentioned above), it doesn't matter whether the coefficients are numeric or symbolic - no analytic solution is possible - however much you want one.

3) Is there a way for the RootFinidng package to express the solutions analytically?

No! RootFinding generates numerical solutions

You have a choice - decide exactly what you want.

Numerical solutions for your problem are trivial to generate. A complete listing of corresponding analytic solutions is (probably?) unobtainable, although you are free to spend the rest of your life lookng for them

called X01A. You do not provide this file. Where does it exist?

I mean that some of the '+' and '-' signs in the second identity were wrong, so I fixed them to match the first identity - vv had also noted this issue

I have no idea why nearly every term got multiplied by '1' - some *feature* of using 2-D input (which as a general rule I never use!). Version without the superfluous '1*' operations is attached below

Download KDR2.mw

When you say

" I employed the sort command to sort through 10 solutions to a series of order 10 "

There is no sort command in the attached worksheet - clarify your problem

You have written an infinite 'do' loop in the 'proc' option of your examples, for reasons which escape me. If I correct this, then both the procedure and the functional operator version work equally well. Check the following

Download procFunc.mw

There is absoutely nothing which can be done using arrow notation, which cannot be done by using a procedure - so don't waste your time trying to find something!

My best solution for this is to ignore the 'datatype=sfloat' suggestion I gave you last time(!), and use 'datype=anything'.

With this option, expressions will be returned as strings, but that can be fixed with the careful use of an elementwise 'parse()' statement, as in the following.

Obviously you will have to fix the file path/name to something relevant for your machine

   restart;
#
# Return Version
#
   kernelopts(version);
#
# Generate a vector containging an expression and
# a random 50-digit number, then export it to a
# text file
#
   Digits:=50:
   p:=rand(0.0..1.0):
   V:=Vector( [1234*x+5467, p()]);
   ExportVector( "C:/Users/TomLeslie/Desktop/vectest.txt",
                             V
                         );
#
# Import the same file and parse() anything whose
# datatype is 'string'
#
   fixexpr:= x -> `if`(type(x, string), parse(x), x):
   V2:=fixexpr~( ImportVector
                           ( "C:/Users/TomLeslie/Desktop/vectest.txt",
                               datatype=anything
                          )
                       );

I'm still surprised you had this working "seamlessly" in Maple 18 ?!

is the use of option remember - in the case of the calculating a Fibonacci sequence, it means that for Fib(30), Fib(29) and Fib(28) are known - so calculating Fib(30) becomes trivial.

You will not always achieve improvements like this when using the proc() form rhather than the functional operator form.

My intention was to illustrate that using the proc() form allows more capability for code optimisation than the simple functional operator - you can do just som much more to make your code fast/efficient.

If you don't yet have these, I would recommend downloading/reading the pdf versions of the User and Programming manuals from the MapleSoft website at

https://www.maplesoft.com/documentation_center/

As an example - consider generating the Fibonacci sequence. The attached does this

1. Using the relevant command from the combinat package - quick/efficient
2. Using functional operator form, aka arrow notation - slow/inefficient
3. Using a 'dumb' procedure - equally slow/inefficient
4. Using a 'clever' procedure - about as quick/efficient as (1) above

Download proctest.mw