A mini-quasi howto about solving an equation when the entire process is 
too big to be done in one maple file alone.

Break up the code piece wise.  Here I start by solving for the equation,
getting an algebraic result.  This result will cause xmaple to quit 
because its too big, so instead I print it to a file in maple's algebraic
format (that is what the %a is for):

Ran minimal maple code:  

restart;
with(LinearAlgebra):
v1:=-b*x + a*y -y^3:
v2:=-b*y + a*z - z^3:
v3:=-b*z + a*x - x^3:
v:=Vector(3,[v1,v2,v3]):
L:=X->v[1]*diff(X,x)+v[2]*diff(X,y)+v[3]*diff(X,z):
Lv:=Vector(3,[seq(L(v[i]),i=1..3]):
sol:=solve([seq(Lv[i]=lambda*v[i],i=1..3)],[lambda,y,z]):
fd := fopen("temp_file", WRITE):
  fprintf(fd, "%a",sol):
  fclose(fd):



---------------
OK, now I have the solution to this equation in a huge giant (half a gig)
text file, I need to break it up into a managable size (I just need
the expression for a component called R1):

Open this file and search for R1....might need this script to break the file up
a bit:
---------------
get.pl:
=========================================
#!/usr/bin/perl

open(OLDDAT, "temp_file");

$n=0;
while(<OLDDAT>){
   $nn=$n+1000;
   $file="temp.$nn";
   open(NEWDAT, ">$file");
   @data1=split(/\s+/);
   print NEWDAT (@data1, "\n" );
   close(NEWDAT);
   $n++;
   }
===========================================
One of the outputs should do fine in getting R1

Now in maple again--for example, you would cut your R1 and 
place it in the RootOf() and alias.  This is done so that
the RootOf expression that was in my solution would be 
replaced by one single variable, R1, and thus I could extract
the y=blah and z=blah solutions more easily:  

alias(R1 = RootOf()):
fr:=fopen("rootof.txt", READ);
fprintf(fr,"%a",R1):
fclose(fr):
fs:=fopen("z_is.txt",READ):
fprintf(fs,"%a",sol):
fclose(fs):

================================
Now open z_is.txt and extract the right side of the
z = blah part of the result and save this as z_is_R.txt

Our next step is to get the roots of the RootOf for 
a sequence of x values.  

================================

New maple code...

alias(R1=RootOf(blah blah blah)):
(a,b):=(1.1, 0.3):
soln:=(x,i)->allvalues(R1)[i];

now you have a result only in x...

test that you get a result, find max number of roots...

evalf(soln(0.3,28));

fz:=fopen("blah.dat",WRITE);
for x from -2 by 0.01 to 2 do 
for i from 1 to 28 do 
var := evalf(soln( x, i)); 
if Im(var) = 0 then 
fprintf(fz,"%f %f %d \n", x,var,i): %THIS PRINTS x,y,z in Thomas case since y=R
end if 
end do 
end do; 
unassign('x', 'var'); 
fclose(fz):

==========================================
OK, now you have a simple file with the values of
R1 for a sequence of x values.  Now you can
take the y and z (in this case, y = R1 so we
only need to solve for z) algebraic expressions
and plug in x and R float values to get a number 
out...thus getting float values for your solution
in x,y,z format ready to plot and analyze.
=========================================
Now run in batch

fs := fopen("z.txt", READ):
z := fscanf(fs, %a):
fclose(fs):
R:=3.0:
x:=1.2:
zz:=op(op(z));
ff := fopen("foutput.dat",WRITE):
fprintf(ff,"%f %f %f \n",x, R, zz):
fclose(ff):


ACTUAlLY THIS FILE WORKS:  
(here solutions.dat is the solutions output file from 
 the loop of maple above that outputs the value of R1
 for all roots and for given x coordinate.  I want to
 calculate z, which is a function of R1 and x, but z
 is too big to load in a file with R1 and x, so instead
 I separately get the values for x,R1, then plug those
 numbers into a batch Maple code which solves for z for
 a given x,R1...if the calculation is too big, maple
 can still do it if you break it up).

#!/usr/bin/perl

-e "foutput.dat" or system("rm foutput.dat; touch foutput.dat");
open(OLDDAT, "solutions.dat");
$n=0;
while(<OLDDAT>){
@data1=split(/\s+/);
#data 0,1,3 ---> x, y=R, i
$x=$data1[0]; $R=$data1[1];
open(NEWDAT, ">maplation.m");
print NEWDAT ("fs := fopen(\"z.txt\", READ):", "\n");
print NEWDAT ("z := fscanf(fs, %a):","\n");
print NEWDAT ("fclose(fs):","\n");
print NEWDAT ("x:=$x:  R:=$R:","\n");
print NEWDAT ("zz:=op(op(z)):","\n");
print NEWDAT ("ff := fopen(\"foutput.dat\",APPEND):","\n");
print NEWDAT ("fprintf(ff,\"%f %f %f \\n\",x, R, zz):","\n");
print NEWDAT ("fclose(ff):","\n");
system("/usr/maple11/bin/maple maplation.m");}