Content-Type: text/enriched
Text-Width: 70

<bold>mpLeaves class</bold>
1. finds two leaves given char* for head and tail
2. finds center in MP
3. finds location of points on leaves w.r.t. center


<bold>mpLorenz class</bold>
1. finds po in multiple precision
2. mpLorenz(char* s, int f) and mpLorenz(char* s, char* dir, int index, int f)
are the two constructors. 
3. the first constructor loads library, calls returnPO, which calls 
returnApprox, which uses f as FourierFactor.
4. Second constructor loads po directly and then uses f as FourierFactor.
5. Both constructors call initmpLorenz() which uses f to set shooting intvl.
5a. there is a third constructor which loads mp data.
6. refineGuess() does one correction.
7. refinePO() corrects until tolerance is met.
8. refineNshft() = refinePO() + shift2front().


<bold>maple code</bold>


1. <bold>utils.mpl</bold>: from asym expansion of nth Taylor coeff to a log singularity

modulated by a power series. Verified using a procedure to generate Taylor

coeffs given logarithmic singularity.


2. <bold>x.mpl</bold>: 




<bold>Changes</bold>
1. int savepo(const char* outdir) to save x,y,z,T and return mpVector size.
2. function for (s, dir, index, f) --> output to outdir

3.<bold> </bold>mpFourierAsym.hh and mpFourierAsym.cpp  get the asymptotics using Wynn's extrapolation.

   Nothing in mpBPH is used any more.



<bold>TOL
1. The same quantity is set in </bold>mpFourierAsym<bold>.cpp, mpfun++. 


2. TOL in </bold>mpFourierAsym<bold>.cpp must be scaled 1e10. TOLEXP is +10.


3. It is also used for computing PO.


4. <x-color><param>red</param>TOLEXP must be -540 for AB and -500 for the others</x-color>.</bold>



Residual error scaling factor (read 0& 7 & 8 first)
0.<bold> changes to handle tolerances so low that IEEE double underflows</bold>


1. introduced reserrscalefac in class mpLorenz


2. changed computation of Res in mpLorenz::computeRes()


3. scale result in mpLorenz::residualError()


4. scale result in mpLorenz::relativeResidualError()


5. changed update of w, mpx, mpy, mpz in mpLorenz::refineGuess()


6. changed computation of e1 and e2 in mpLorenz::smooth(double alpha)


7.<bold> changed mpLorenz::settolerance(tolerance) to settolerance(tolexp)</bold>


8. made a change for #7 in mpLorenz::initmpLorenz()



<bold>Keeping track of errors:</bold>


1. fourier mode errors are all set to a constant 


2. Invert: relative errors do not change under inversion


3. Log: dy = dx/x


4. Ratio: sum of rel errors * abs(odata)


5. SecondRatio: same as above


6. Diff: sum of errors


7. Got rid of this code (July 08)


<bold>Must analyze x, y, z components separately.</bold>


1. Changed Invert, ArgList, Log, Ratio, SecondRatio and Diff.


2. Changed mpfindFourierSave to output errors for x,y,z separately 


3. Changes in mpBPH.hh, mpBPH.cpp, mpDriver.cpp



<bold>Changes todo</bold>


1. change out so that in = 'z' means out = 'A' in mpBPH.cpp
2. change output of error to ErrXA.dat to Exa.dat and so on in mpBPH.cpp
3. done


<bold>Lesson learnt</bold>


1. one must first look at the number of Fourier coeffs to see a particular
trend in a particular level of the BPH algorithm


2. The deeper the level the more coeffs one needs


3. One must think of the number of digits one needs to have in each
coeff after #1, not the other way around



<bold>Check to do:</bold>


1. Check how the errors change with BPH level



<bold>How many coeffs and how accurate?</bold>


1. For AB, about 1000/1500 would be plenty.


2. For AAB, at least 1500/2000 would be needed to get off the ground.


3. Extrapolation of coeff size: AB 1024*4=-613 
                               AAB 2048*2=-385 and 4096*2=-773


4. mpipl = 620 for AB


5. AB computed using 4096 Fouries points, rel accuracy = 6.5e-548


6. mpipl = 390 for AAB


<bold>BUG<bold> to watch out for</bold>:


1.<bold> mpVector's input uses "numsize." This may need to be increased as
the precision is increased.
(numsize is now 1000)</bold>


</bold>To improve efficiency:


1. Try smoothing less at each iteration


2. In mpLorenz::refinePO(), count estimates number of iterations.


3. The count above is used to smooth, instead of stage-by-stage smoothing.


4. to do: change refineNshift() and refinePO() to take estimated count
as an argument. can break old code.


5. to do: make it possible to save state and resume?


6. to do: make it possible to increase number of digits gradually?


7. Added new constructor for #5 above, #6 yet to be implemented. See
BUGs below.<bold>



<bold>EVERY RUN FOR </bold><x-color><param>red</param>COMPUTING</x-color><bold> PO


1. count and smoothing in mpLorenz::refinePO()


2. TOL for mpipl and mpiou in mpfun.cpp


3. TOLEXP in mpBPH.cpp</bold>



<bold>BUGs</bold>


</bold>1. Do not save N.dat in mpLorenz::savepo(), but is used by one of the
consturctors. The third constructors of that class which uses REPEATFAC.<bold>


2. <bold>Another bug with the same constructor: symstr is not set</bold>


</bold>3. Both bugs have to be fixed.


a1. Bug in mpLorenz::savepo() is now fixed. T.dat has info on N as
well because of the bug. made changes manually to AB, AAB, ...<bold><bold>



CHANGES:


</bold></bold>a1. Get rid of xaa, yaa, zaa. It is best to save Fourier data once
in xa, ya, za with 548 digits. 


a2. For the later transforms, transform a vector repeatedly by making
idata an input vector and idata = odata at the end. Save the vector
using only 200 digits. 


a3. Eliminate asymptotics from mpDriver.cpp, move to mpAB.cpp and so on.


a4. Have to change mpBPH.cpp, mpBPH.hh, and makefile.mak


a5. modify xasym2() to verify the results of xasym1() + maple.


a6. xVerify.dat reused.


a7. N and nn


a8. epts and x,y,z


a9. mpDebyePF


a10. mpDebyePF and debyepf.mpl work perfectly in tandem.<bold><bold>


<bold>ANALYSIS:


</bold></bold></bold>1. Obtain an asymptotic expansion for the constants computed by the
BPH algorithm


2. Such an analysis will give a preliminary idea of the accuracy of
the coefficients.


3. Once the form of the singularity is known, one can use the Lorenz equation
to compute coeffcients more accurately.


4. The form of the singularity and its connection to symbolic dynamics could
open the door to a mathematical analysis of the Lorenz equation.<bold>

<bold>


<bold>SINGULARITY LOCATIONS in t plane


1. AB = -0.1714501006*i
2. AAB = -0.1617621257*i
3. AAAB = -0.156342626*i
4. AABB = -0.1636066901*i</bold>


<bold>PLAN to complete paper</bold>:


0. Tabor and Weiss


1. Verify the expansions near singularity satisfy Lorenz.


2. Find out the location of the complex singularity for other orbits (easy).


3. Is there a way to develop the expansion using recurrences?


4. describe why the computations need to be so accurate carefully. a
low mode will mask the high modes otherwise.
</bold></bold>