September 2026
The files in this directory are part of the article

  "Conformal Parametrisation of Star-Shaped Domains and Persistence of Semilinear Elliptic Solutions"
  by G. Arioli

The files *.ads and *.adb contain the details of the proof of
Propositions 7.2 and 8.6 written in the programming language Ada.
The coefficients of the approximate solutions referred to in the
propositions can be found in the directory data.

The proof itself is divided into declarations, procedures or functions, and main programs.
(Somewhat analogous to definitions, lemmas, and theorems.)
This includes the declaration of data types (Ball, Radial, Zernike, ...)
that define enclosures in various spaces.
Procedures and functions that are centred around a given data type
are organised into

Packages
========
package (name)          declaration (file)          body (file)
-----------------------------------------------------------------
ACM_RPoly               acm_rpoly.ads               
AddEtc                  addetc.ads                  addetc.adb
Big_Numbers.Signed.NDRs big_numbers-signed-ndrs.ads big_numbers-signed-ndrs.adb
Big_Numbers.Signed      big_numbers-signed.ads      big_numbers-signed.adb
Big_Numbers             big_numbers.ads             big_numbers.adb
BigRats                 bigrats.ads                 bigrats.adb
Bisect-GSign            bisect-gsign.ads            bisect-gsign.adb
Bisect-PSign            bisect-psign.ads            bisect-psign.adb
Bisect                  bisect.ads                  bisect.adb
Bisection               bisection.ads               bisection.adb
Bytes                   bytes.ads                   bytes.adb
CG.Zerni                cg-zerni.ads                cg-zerni.adb
CG                      cg.ads                      cg.adb
Characters              characters.ads              characters.adb
Complexs                complexs.ads                complexs.adb
Constants               constants.ads               constants.adb
Eigen                   eigen.ads                   eigen.adb
EisPack1                eispack1.ads                eispack1.adb
EisPack2                eispack2.ads                eispack2.adb
Factorized_Rationals    factorized_rationals.ads    factorized_rationals.adb
Flt_AddEtc              flt_addetc.ads
Flt_Vectors             flt_vectors.ads
Flts                    flts.ads                    flts.adb
Flts.Std                flts-std.ads                flts-std.adb
Flts.Std.Balls          flts-std-balls.ads          flts-std-balls.adb
Flts.Std.EFuns          flts-std-efuns.ads          flts-std-efuns.adb
FltStr                  fltstr.ads                  fltstr.adb
Fouriers1               fouriers1.ads               fouriers1.adb
Fouriers1-GFix          fouriers1-gfix.ads          fouriers1-gfix.adb
Fun_Series              fun_series.ads              fun_series.adb
Generid_DFT             generic_dft.ads             generic_dft.adb
Globals                 globals.ads
ImproveRoots            improveroots.ads            improveroots.adb
Integer_Log             integer_log.ads             integer_log.adb
Integer_Sqrt            integer_sqrt.ads            integer_sqrt.adb
Ints                    ints.ads                    ints.adb
IPowers                 ipowers.ads                 ipowers.adb
Laurents                laurents.ads                laurents.adb
Linear.Contr            linear-contr.ads            linear-contr.adb
Linear                  linear.ads                  linear.adb
Logicals                logicals.ads                logicals.adb
Matrices                matrices.ads                matrices.adb
Messages                messages.ads                messages.adb
MGeneric                mgeneric.ads                mgeneric.adb
MPFR.Floats.Balls       mpfr-floats-balls.ads       mpfr-floats-balls.adb
MPFR.Floats.EFuns       mpfr-floats-efuns.ads       mpfr-floats-efuns.adb
MPFR.Floats             mpfr-floats.ads             mpfr-floats.adb
MPFR                    mpfr.ads
MPFR_Balls              mpfr_balls.ads
MPFR_Numerics           mpfr_numerics.ads
MPFR_Reps               mpfr_reps.ads
Newton                  newton.ads                  newton.adb
Num_Polynoms            num_polynoms.ads            num_polynoms.adb
Num_Polyroots           num_polyroots.ads           num_polyroots.adb
Params                  params.ads
Polynoms                polynoms.ads                polynoms.adb        
Polynoms.More           polynoms-more.ads           polynoms-more.adb        
Polynoms.Roots          polynoms-roots.ads          polynoms-roots.adb        
Polynoms.Soil           polynoms-soil.ads           polynoms-soil.adb        
PolyRoots               polyroots.ads               polyroots.adb
Pooling                 pooling.ads                 pooling.adb
Primes                  primes.ads                  primes.adb
Protected_Counters      protected_counters.ads      protected_counters.adb
QPowers                 qpowers.ads                 qpowers.adb
Quick_Sort              quick_sort.ads              quick_sort.adb
Rationals               rationals.ads               rationals.adb
Recycling               recycling.ads               recycling.adb
Regges.Compute          regges-compute.ads          regges-compute.adb
Regges                  regges.ads                  regges.adb
Reps                    reps.ads
Roots                   roots.ads                   roots.adb
Rounding                rounding.ads
Rounding_FPU            rounding-fpu.ads            rounding-fpu.adb
Scalars                 scalars.ads
ScalVectors             scalvectors.ads             scalvectors.adb
ScalVectors.Eigenv      scalvectors-eigenv.ads      scalvectors-eigenv.adb
ScalVectors.Eigenv.RNum scalvectors-eigenv-rnum.ads scalvectors-eigenv-rnum.adb
Std_Reps                std_reps.ads
Strings                 strings.ads                 strings.adb
Tasks                   tasks.ads                   tasks.adb
Vectors                 vectors.ads                 vectors.adb
Vectors.More            vectors-more.ads            vectors-more.adb
Vectors.Ops             vectors-ops.ads             vectors-ops.adb
Vectors.Sorting         vectors-sorting.ads         vectors-sorting.adb
VGeneric                vgeneric.ads                vgeneric.adb
Zernikes                zernikes.ads                zernikes.adb
Zernikes.GFix           zernikes-gfix.ads           zernikes-gfix.adb

The proof is organized by the

Main programs
============
procedure (name)    body (file)
-------------------------------
Check_Theo          check_theo.adb
Check_Elliptic      check_elliptic.adb
Find_Theo           find_theo.adb
Find_Elliptic       find_elliptic.adb
PrepareWH           preparewh.adb


Other
===========================
file or directory   comment
---------------------------
README.txt         this file
logX               log file of check_elliptic for solution X
logt               log file of check_theo for all solutions
data               directory for input data and some data exchanges

Inside the directory data there are 15 subdirectory, each corresponding to
one of the reference domains.
Inside each of these subdirectories there are three files:
curve contains the coefficients defining r_0
f.approx contains the coefficients of the approximate solution \bar u
fcs.approx contains the coefficients of the approximate solution w

Floating point types and portability
====================================

The basic floating point types used are
Flts.Std.LLFloat (defined indirectly as Long_Long_Float) and MPFR.Floats.MPFloat.
Both types support controlled and correct rounding.

The type (name) Long_Long_Float is specific to the gnat compiler.
It implements the IEEE 754 Extended 80 bit (64 bit mantissa) floating point format.

MPFloat is essentially the floating point type from the
multiple-precision floating-point library MPFR,
see MPFR, MPFR.Floats, and http://www.mpfr.org/
MPFR is written in C
and distributed for free under the GNU Lesser General Public License.

In the current proof, Rep is an "alias" for LLFloat.
MPFloat is used (only) for bounds on some basic functions like Sqrt Exp, Cos, ...
whose precision is not specified by IEEE 754.

Our package FPU_Rounding is specific to the x87 floating point processor.
For other processors, this package will have to be changed appropriately.
We note that only two FPU rounding modes are being used:
"rounding up" for all rigorous estimates, and
"rounding to nearest" for numerical computations.

On systems that do not recognize "/" as path separator, the variables
Globals.Input_Dir, Globals.Output_Dir, and Globals.Tmp_Dir
will have to be adapted to the system's convention.

Compiling etc.
==============

With the gnat compiler (http://gcc.gnu.org/software/gnat/),
compiling our main programs is achieved e.g. with:

cp std_reps.ads reps.ads
gnatmake -c -frounding-math check_theo
gnatbind -E check_theo.ali
gnatlink check_theo.ali -lmpfr -lgmp -lm

and similarly for the other programs, except for PrepareWH,
where the first line must be changed to

cp mpfr_reps.ads reps.ads

so that the MPFR library is used for the floating point numbers.

Do not use any optimization flags.

Running
===================================

The program Find_Theo must be run before all others.
It stores the approximate inverse of r(t) and psi(t).
Then PrepareWH must be run.
It computes and stores the approximate Wiener-Hopf
factorisation required by Check_Theo.
At this point it is possible to run Check_Theo,
which makes all the estimates required by Proposition 7.2
and prints the values of 
For the elliptic equation one must run Find_Elliptic,
which prepares the data for Check_Elliptic and also saves
numerical data for plotting the solution v,w and the
function q.
Finally Check_Elliptic can be run, which makes all the
estimates required by Proposition 8.6

The syntax for PrepareWH is "preparewh SOL",
where SOL is the solution number (1 to 15).
This is the only program that runs on a single core.

All other programs are run by

Name_of_the_program SOL NT

Here NT is the desired maximal number of concurrent tasks.
A reasonable choice for NT is the number of CPU cores available.

Remark. Some systems (shells) make too little stack size available to the programs.
This results in a STORAGE_ERROR.
If this happens, increase or unlimit the default stack size,
e.g. in the Bourne shell: ulimit -s unlimited
