BinDFTInv User Guide Version 1-1, March 25, 2021 Vadim Markel, vmarkel@upenn.edu http://whale.seas.upenn.edu/vmarkel/CODES/BinDFTInv/BinDFTInv-1.1.tar.gz http://whale.seas.upenn.edu/vmarkel/CODES/BinDFTInv/BinDFTInv-1.1.zip TABLE OF CONTENTS 0. Data generation 1. Purpose and Methods 2. Language and Operating System 3. Compilation and Quick Start 4. Directory structure 5. Input and Output 6. Application 7. Performance and Tuning 8. Changing p in Lp Norm 9. Errors 10. Sample Data and Testing 0. DATA GENERATION ===================================================================== 0.0. This version of the codes requires that the vector length N be odd. 0.1. Users can generate their own DFT data to be stored in the file "phi.dat" whose format is described below, or use the code MakeData to create a model stored in the file "mod.dat" and the corresponding DFT data in the required format stored in the file "phi.dat". 0.2. The exectutable MakeData.exe is located in $root/bin/ directory. This Guide does not provide a detailed description of MakeData, but the code is interactive and will print all instructions and questions on the monitor. 0.3. MakeData can create DFT data by one of the following three methods: (a) Using a binary model stored in the file "mod.dat" (first column - sequential number of an element from 1 to N and second column the binary element equal to either 0 or 1) (b) Randomly places r 1s in a vector of length N, where r<=M=(N-1)/2 (c) Randomly assigns 1 with the probability p or 0 with the probability 1-p to each element of a vector of length N, with the constraint that realizations in which more 1s than M=(N-1)/2 are not allowed. 0.4. If the file "mod.dat" exists in the working directory, the inversion code Inv.exe will compare the obtained solution to the model in "mod.dat". The model vector is denoted by mod. If solution x is exact, the distance to model dist[x,mod] should be zero. 1. PURPOSE AND METHODS ===================================================================== 1.1. BinDFTInv seeks to find a binary vector x of given length N and popcount r that fits a limited set of DFT coefficients, which are supplied in the input file "phi.dat". Not all DFT coefficients are known; otherwise, the problem would be trivial. 1.2. BinDFTInv implements two inversion methods: (a) CombSolver: Combinatorial optimization of the Fourier-space distance chi[x] between DFT[x] and DFT[mod]. Here DFT[mod] are the data that are stored in "phi.dat" (b) OptFSolver: Global optimization of a continuous non-convex functional F[v], where v is a non-binary vector, which is consistent with the DFT[mod] data in "phi.dat". Here F[v] quantifies how close its argument v is to being binary. Once a minimizer of F[v] is found, it is usually very close to binary and its binary approximation, x=R[v] is returned as the solution. Here R[v] is the "roughening" operator defined in the Paper. 1.3. Stop conditions. BinDFTInv stops when one of the following occurs: (a) A binary vector x is found such that the selected metric is <= eps, where eps is a pre-determined constant. Typically, eps<<1.0. The metric that is compared to eps can be one of the following: (i) Fourier-space distance between DFT[x] and the data, chi[x]; (ii) The functional F[v] defined in the Paper and briefly mentioned in Point 1.2.b above (b) The number of iterations or the depth of recursion reach the allowed maximum. In this case, the vector x that minimizes one of the metrics in Point 1.3.a over all the iterations already performed is returned as the solution, even if this metric is not small enough to meet the condition of Point 1.3.a. (c) A numerical error has occurred. In this case, no solution is returned. Numerical errors are rare and should not normally happen. However, if an error occurs, tuning optional parameters described below and re-running the code may solve the problem. See Section 9. 1.4. BinDFTInv does not require exact data and can handle data with limited precision and noise. The examples in Section 10 (also included in the demo directory of BinDFTInv distribution) demonstrate this capability. 1.5. BinDFTInv does not guarantee that the true solution is always found. In some cases, this is not possible in principle. However, BinDFTInv always reports the metric such as chi[x] for the reported solution. Assuming that it is known theoretically that the solution is unique, and if chi[x] is numerically small (say, chi[x]<1.0E-8), one can have high confidence that x is the exact solution. If the above assumptions do not hold, one of the following can happen: (a) If chi[x] is not numerically small, but we know for sure that the data correspond to some binary vector, and that the data are known with the precision that is in some sense better than the obtained chi[x], we conclude that the solution was just not found. Either the recursion depth for CombSolver was not enough, or OptFSolver did not sample all the local minima. It should be emphasized that, if CombSolver was run with depth_max=r, the returned solution has the smallest possible chi[x] over all binary x with given N and r. If this chi[r] is not small enough, it can only be due to imprecision in data. (b) If solution to the inverse problem is not unique or is quasi-nonunique (there exist vectors x=/=mod with very small Fourier-space distance to the data chi[x]), one can not hope to find the true solution, except by chance. Any solver can return some x with a very small chi[x], but we can not be sure that it is the true solution. 1.6. Increasing the band width of DFT data, L, is always helpful for finding the true solution in a more efficient manner and with a better reliability. 1.7. Performance of BinDFTInv can be fine-tuned by changing the required parameter eps the optional parameters in Comb.par and OptF.par; read Section 5 below. If BinDFTInv can not find the true solution, or if it takes too long to find the true solution, tuning these parameters can improve the performance dramatically or even allow one to find the true solution. 1.8. Using the optional parameters intelligently requires some understanding of how BinDFTInv works. This User Guide contains some useful but limited information. Reading the Paper is required for a deeper understanding. In the future, a more detailed optimization guide will be released. 2. LANGUAGE AND OPERATING SYSTEM ===================================================================== 2.1. BinDFTInv is written in the modern Fortran language and tested with both Gnu Fortran (gfortran) and Intel's Fortran (ifort) compilers. The required language features include dynamic memory allocation, modules, random_number() intrinsic procedure, and recursive procedures. However, non-standard language extensions have been avoided, and any modern Fortran compiler should work. 2.2. BinDFTInv was developed and tested under Linux (Centos 7). It should be possible to compile and run BinDFTInv under other operating systems, but this User Guide does not provide any guidance towards that end. 3. COMPILATION AND QUICK START ===================================================================== 3.1. The following instructions are applicable to Linux or Unix operating systems. It is assumed that "zip/unzip", "make" and either "gfortran" or "ifort" commands are available. 3.2. Unpack the archive using the command unzip BinDFTInv.zip This will create the directory $root/ = ./BinDFTInv/ 3.3. Change to the root directory using the command cd BinDFTInv/ 3.4. Edit the first 4 lines of Makefile. If the first two lines are uncommented and the next two lines are commented, then ifort will be used. This option is often preferable and results in much faster executables. To use gfortran, comment the first two lines and uncomment lines 3 and 4. Then compile the codes by issuing the command make all This will create the executable Inv.exe in $root/bin/ Always run "make clean" before compiling the codes with a different compiler. 3.5. To clean the executable and auxiliary files, type (from the root directory): make clean 3.6. The command in Point 3.4 will try to compile the codes using gfortran. If Intel's Fortran (ifort) is desired, edit $root/Makefile. Specifically, uncomment the first two lines and comment the 3rd and 4th lines in this file. Then clean the auxiliary files by typing "make clean" and re-build the executable by typing "make all". 3.7. To test the code with the provided sample data files, go to the demo directory $root/demo/. I.e., from the root directory, type cd demo 3.8. Copy one of the data files in $root/demo/SampleData/ to $/root/demo/phi.dat. For example, from the $root/demo/ directory, type cp SampleData/phi_N=31_r=15_L=1_hp.dat ./phi.dat Description of the available sample data files and a summary of reconstructions is provided in Section 10. 3.9. Edit the file Inv.par. Make sure that the parameters N and r in this file correspond to those in "phi.dat". Also, choose the appropriate Method. 3.10. Run the executable by issuing the command ../bin/Inv.exe and read carefully the output in the terminal window. 3.11. The solution will be written to the file "sol.dat". It can be compared to one of the model files "x*.dat" in the $root/demo/SampleData/ directory, which were used to generate the DFT data in the "phi_*.dat" files. Referring to the example in Point 3.8, comparison should be made to xa_N=31_r=15.dat, which corresponds to Model (a) in the Paper. 3.12. The executable can be moved (copied) to another location. It can be run from any working directory, but the working directory must contain the parameter file Inv.par and the data file phi.dat. Names of these two files can not be changed. The working directory can also contain optional parameter files OptF.par and Comb.par. If these files are not present in the working directory, then default values for the optional parameters will be used. Examples of the optional parameter files are located in $root/par/ 4. DIRECTORY STRUCTURE ===================================================================== 4.1. The directory structure of BinDFTInv after unpacking and compilation is the following (here $root = ./BinDFTInv): $root/Makefile /README /bin/Inv.exe /demo/Inv.par /SampleData/phi*.dat /x*.dat /doc/UserGuide.txt /inc/*.f /mod/*.mod /obj/*.o /par/*.par /src/*.f /sub/*.f 4.2. The sub-directories $root/inc/, $root/src/ and $root/sub/ contain the source code. 4.3. The sub-directory $root/mod/ contains compiled modules 4.4. The sub-directory $root/obj/ contains object files and optimization reports 4.5. The sub-directory $root/bin/ contains the executables Inv.exe and MakeData.exe 4.6. The sub-directory $root/doc/ contains this User Guide and any other documentation files that might be added in the future 4.7. The sub-directory $root/par/ contains examples of parameter files. The files in this directory should not be edited or removed; they should only be copied to other locations and THEN edited 4.8. Sub-directory $root/demo/ is for testing; $root/demo/SampleData/ contains sample data files 5. INPUT AND OUTPUT ===================================================================== 5.1. All input and output files should be located in the working directory. The executable may be located elsewhere. 5.2. Input consists of parameter files (extension .par) and data files (extension .dat). Templates for parameter files are located in $root/par/. Sample data files are located in $root/demo/SampleData/. The sample data files are provided for testing. Before the executable Inv.exe is run, the data file called "phi.dat" must be created in the working directory, for example, by copying it from SampleData, i.e., from $root/demo/, type: cp SampleData/phi_N=31_r=15_L=5_hp.dat ./phi.dat In practical applications, data are supplied by users independently. 5.3. There are two kinds of parameter files used by BinDFTInv: required (Inv.par) and optional (OptF.par and Comb.par). Required parameters are always read from Inv.par and are never assumed. The optional parameters have default values. If the optional parameter files are not present in the working directory, these default values are assumed. If some of the optional parameter files are present in the working directory but are corrupted or otherwise incorrect, Inv.exe will return errors. 5.4. Required parameter file Inv.par contains the following lines: Method -- String, case Sensitive Method for solving the inverse problem. Allowed values: CombSolver [for combinatorial optimization] OptFSolver [for non-convex optimization of F[v]] N -- Integer Length of the binary vector x; must be odd and greater than 1 r -- Integer Popcount (number of ones in x); Must satisfy 0 < r <= M=(N-1)/2 L -- Integer Band limit of the DFT data. Must satisfy 0 < L <= M=(N-1)/2 NOTE: L=M is permitted but corresponds to full (invertible) DFT; A warning will be issued eps -- Real Requested precision. Inv.exe will stop when one of the metrics described in Point 1.3 becomes <= eps 5.5. Optional parameter file "Comb.par" contains the single parameter depth_max -- Integer Maximum depth of recursion used by CombSolver. By default, depth_max = min(10,r). Placing "Comb.par" in the working directory allows the user to set depth_max to a custom value in the range 1 <= depth_max <= r. 5.6. Optional parameter file "OptF.par". This file can be used to fine-tune OptFSolver. It contains the following parameters (only a brief description is given here; the file OptSolver.par has additional information on the allowed ranges of the parameters). Default Value cfc_ini -- Initial value of the step length cfc of random jumps [1.0] cfc_inc -- Increment by which cfc is increased when mod(iter,iter_inc)=0 [1.0] cfc_max -- Maximum allowed value of cfc [1.0d4] iter_inc -- Number of iterations to try before incrementing cfc [1000] iter_max -- Maximum number of iterations before Inv.exe stops [1000000] rmprec -- A precision-related parameter. Changing is not recommended [5.0d-16] rmcerr -- Precision of verifying a local minimum. May be changed in case of errors; see Section 9 [1.0d-08] IndStartRandom -- Random jumps from the deepest local minimum found (1), [1] or from the initial guess (2), or the from latest position (3) IndStopIterCnd -- Use chi[x] or F[v] in the stop condition [1] IndLocalMinVer -- Whether to ignore errors related to failure to verify a [1] local minimum. If =1, strict verification, if =2, will continue in spite of errors. 5.7. The required DFT data file contain lines of the following form: First line : N r Consecutive lines: m Re[xF(m)] Im[xF(m)] for m=1,2,...,L where xF(m) is the m-th complex DFT coefficient of x(i) as defined by Eq.1 5.8. Output. (a) The file "rig.dat" contains the low-path filtered inverse DFT of the data, g (Eq.17 of the paper). The vector in "rig.dat" is not binary; (b) The file "big.dat" contains binary approximation to the low-path filtered inverse DFT of the data, b=R[g]; see bottom of p.9, second column of the Paper; (a) If Inv.exe runs without errors, the solution is written into the file "sol.dat". If this file already exists in the working directory, it will be over-written. The output file consists of the lines i x(i) where i=1,2,...,N and x(i) is either 0 or 1. 6. APPLICATION ===================================================================== 6.1. The correct values of N and r are required in the "Inv.par" file. These values must be the same as in the binary vector whose DFT data are provided by "phi.dat". To avoid errors, every "phi.dat" file must contain, as the first line, the values of N and r. There two numbers are compared to the numbers in Inv.par before the reconstruction is started. 6.2 CombSolver is best used for relatively small N and extreme small L, especially, if the data are known with good precision (i.e., more than 4 significant figures). All problems with L=1 and prime N<~ 37, and some problems with L=1 and 33 and 35, 39, etc., are solvable exactly with CombSolver in relatively small time, even though the inverse problems for N=33,N=35 and N=39 are not uniquely solvable (as discussed in the Paper, some vectors can still be uniquely recovered). 6.3. OptFSolver is best used for larger values of N and when L >~ M/3, where M=(N-1)/2. Often, OptFSolver will not return desired precision. In such cases it is recommended to vary some of the optional parameters as discussed in Section 7 below. 7. PERFORMANCE AND TUNING ===================================================================== 7.1. Using CombSolver (a) CombSolver is applicable to relatively short vectors, roughly, for N<61, depending on the value of r. N=61 and r=30 may be too much for combinatorial optimization by N=61 and r=15 still manageable. (b) CombSolver will search all binary vectors that are no further from the initial guess than depth_max. It will stop when chi[x] <= eps. Note that this vector x is not necessarily the true solution (c) The Point (b) underscores the importance of starting with a good initial guess. BinDFTInv starts from a band-limited inversion rounded off to binary. While this is not a bad guess, there are strategies for improving it, which will be realized in subsequent releases. (d) If CombSolver does not find an x satisfying the condition in Point 7.1.b, it will return the vector that minimizes chi[x] over all the vectors that have been tried (e) In case of low-precision data, the condition of Point 7.1.b may never be reached. However, the true (or optimal) solution may be found at a relatively small depth. To avoid pointless search over a large set of x'es, increase the value of eps in "Inv.par". The terminal output will be useful for determining what to choose for eps. Another methods for avoiding a pointless search over a very large set is to decrease depth_max using the optional parameter file "Comb.par" (f) If depth_max is set to the numerical value of r in "Comb.par", the entire set of binary vectors with given N and r will be searched 7.2. Using OptFSolver (a) OptFSolver is an iterative method, which is not guaranteed to find the true solution even if this solution is unique and CombSolver can find it (b) However, OptFSolver is applicable to much larger values of N, up to a few hundred. (c) OptFSolver will report progress. It will be clear whether OptFSolver has found a vector with required chi[x] and if not what is chi[x] for the vector reported as the solution. (d) If OptFSolver runs for a lot time without reporting progress, it is probably the time to stop it and change some of the optional parameter. Look at the achieved levels of chi[x]. If these are sufficient, the most straightforward way to get a solution is to increase eps (e) If an x with satisfactorily small chi[x] has not been found, one can use the optional parameter file "OptF.par" to change the search and, in many cases, find the true solution. See Table of Sec.10 for particular examples of optional parameter use. Some suggested changes to optimal parameters include: (i) Reduce cfc_ini and cfc_inc. This will make random jumps "sample" the multi-dimensional space more densely (ii) Increase iter_inc and iter_max. This will achieve the same effect as (i) (iii) Change IndStartRandom from the default value of 1 to 2 (or to 3, but 2 should be the first choice). It is advantageous to use IndStartRandom=2 if there are many very shallow local minima that are quite far apart in real space (quasi-nonuniqueness). This usually happens when the solution is theoretically unique but L is small and there exist "quasi-false solutions" with very small but non-zero chi[x]. (iv) Use a combination of the above methods (e) Execution of OptFSolver depends on the stream of quasi-random numbers used. Sometimes changing this stream can result in significantly faster or slower performance. This, in turn, depends on the compiler. In this version, BinDFTInv does not allow users to define their own random streams. However, read the information in Section 10 about the particular SEED values that were used to generate the examples; programmers familiar with Fortran can edit a commented-out section in $root/src/OptFSolver.f to set their own streams or make sure that the same streams as in Section 10 are used. (f) Generally, convergence properties of OptFSolver improve dramatically when L is increased. It has been observed that OptFSolver becomes efficient when L >~ M/3, where M=(N-1)/2 8. CHANGING p IN Lp NORM ===================================================================== 8.1. Currently, the Fourier-space distance chi[x] between DFT[x] and the data in "phi.dat" is computed using the L2 norm (see Eq.8 in the Paper). 8.2. The L2 norm can be changed to either L1 or LInfinity norms. 8.3. To make the change, go to $root/sub/ and issue the following commands rm fchi.f Confirm that you wish to delete this symbolic link by answering "y" and then ln -s fchi1.f fchi.f (for L1 norm) or ln -s fchiI.f fchi.f (for LInfinity norm) 8.4. Then go to $root/ and recompile the codes by issuing the commands make clean make all 9. ERRORS ===================================================================== 9.1. Most errors will come with explanations and suggestions how to fix them. Error codes (info) are needed mostly for debugging. However, the following information can be useful for fixing potential problems 9.2. Errors while reading parameter files info<0 : The supplied parameters are readable but semantically wrong, that is, outside of the range or otherwise do not make sense. An explaining message will be issued info=100 : The parameter file is present in the working directory but can not be opened (wrong permissions, blocked by other processes, etc.) info>100 : The parameter file was opened but one of the lines is incorrectly formatted or absent and therefore can not be read 9.3. Errors while reading data file "phi.dat" info=-10 : Error opening "phi.dat" info=-11 : Error reading the first line in "phi.dat" (with constants N and r) info=-11 : Error reading one of the data lines in "phi.dat" info=-1 : N in "phi.dat" mismatches that in "Inv.par" info=-2 : r in "phi.dat" mismatches that in "Inv.par" info=-3 : Number of lines in "phi.dat" is greater than L in "Inv.par" (a warning) info=-4 : Number of lines in "phi.dat" is smaller than L in "Inv.par" (an error) info=i>0 : Incorrect entry in line i of "phi.dat" 9.4. CombSolver has only two error codes: 0 (solution satisfying the condition chi[x]<=eps has been found) or 1 (solution satisfying the above condition has not been found). 9.5. OptFSolver can produce the following error codes: info=-1 : OptFSolver Failed to verify a local minimum. Solutions include: (i) Increase the parameter rmcerr in OptF.par (ii) Change IndLocalMinVer from 1 (default) to 2 to completely disregard this error info=0 : Solution was found with required precision info=1 : Required precision was not reached info <-100 : Programming errors (these should not happen and did not happen during extensive testing) 10. SAMPLE DATA AND TESTING ===================================================================== 10.1. Sample model vectors and corresponding DFT data files are provided in the directory $root/demo/SampleData/ 10.2. The model vector file names and the DFT data file names are of the following form: Model vectors : x_N=_r=.dat Data : phi_N=_r=_L=_

.dat where is "a", "b", "c" or "d". The first three letters correspond to Models (a),(b) and (c) discussed in the Paper is the vector length is the popcount, r is the band-limit of data

is precision of the data:

=lp : low precision (4 significant figures)

=mp : medium precision (8 significant figures)

=hp : high precision (15 significant figures) 10.3. DFT data were generated by applying the direct DFT to the model vectors according to the convention given by Eq.1 of the Paper and using double-precision floating-point arithmetic. The high-precision data (

=hp) correspond to the decimal representation of the results thus obtained. Medium-precision data (

=mp) have been rounded off to 8 significant figures not counting any leading zeros and the low-precision data (

=lp) were obtained by rounding off to 4 significant figures. 10.4. DFT data files with larger values of L supersede (contain as subsets) data with smaller L, as long as all other parameters are the same. As an example, the data in "phi_N=33_r=16_L=5_hp.dat" contain and supersede the data in "phi_N=33_r=16_L=3_hp.dat" and "phi_N=33_r=16_L=1_hp.dat". It is possible to use "phi_N=33_r=16_L=5_hp.dat" for any value of L<=5 in "Inv.par". However, if "phi.dat" has more data lines than the value of L in "Inv.par", a warning will be issued, and the code will wait for input from the keyboard. For timing purposes, it is necessary to use the data file with exactly the same number of data lines as the value of L in "Inv.par". 10.5. The Table below has been assembled by applying BinDFTInv to the data in $root/demo/SampleData/. Executable Inv.exe was run on Lenovo T470s laptop with Intel(R) Core(TM) i5-6300U CPU @ 2.40GHz using a single thread. Inversion were performed using default parameters except as indicated in the right-most column (applicable to OptFSolver) (a) For CombSolver, the default value depth_max=min(10,r)-->10 was used (b) The required precision was set to eps=5.0d-8 for all reconstructions EXCEPT FOR the lower-precision versions of the N=199 10.6. Quasi-random numbers. The generated quasi-random numbers depend on the compiler and other factors. The current codes do not allow user to define custom random streams. Therefore, the results are not strictly reproducible. Since the elapsed time and convergence of inversion with N=199 might depend on the quasi-random number choice, below are listed the SEED values used to initialize the Fortran intrinsic procedure random_number(). A programmer familiar with the language and wishing to set these or different values for SEED should edit the commented section in $root/src/OptFSolver.f Seeds for random_number() used in the tests reported below: (i) Gnu compiler gfortran: SIZE = 12 SEED = ( 287027030, -719361131, 574274270, 292048305, 185733336, -1598963619, 572469522, 1446716853, 437591706, 1398099429, 570932571, -1177695979 ) (ii) Intel compiler ifort SIZE = 2 SEED = (2147483562, 2147483398) 10.7. Notations. In the Table below: chi -- The achieved Fourier distance to data (0.0 if less than 1.0d-8) depth -- Recursion depth at which the solution was found. Can be smaller than depth_max (only applicable to CombSolver) dist -- Distance of the obtained solution to the model. Distance is 0 if the model was recovered exactly even if chi>0; this is due to rounding-off (imprecision) of the data used hp -- High-precision data (15 significant figures not counting leading 0s) mp -- Medium-precision data (8 significant figures not counting leading 0s) lp -- Low-precision data (4 significant figures not counting leading 0s) ============================================================================================\/ || CombSolver || OptFSolver || ============================================================================================== N r L p || T[sec] | chi | depth | dist || T[sec] | chi | d | Opt Pars used || ============================================================================================|| 31 15 1 hp || 8 | 0.0 | 7 | 0 || 52 | 0.0 | 0 | || (a) 1 mp || 8 | 4.3E-8 | 7 | 0 || 54 | 4.3E-8 | 0 | || 1 lp || 32 | 1.2E-4 | 7 | 3 || 118 | 1.2E-4 | 3 | || ------||--------|--------|-------|------||--------|--------|-----| || 3 hp || 2 | 0.0 | 5 | 0 || 10 | 0.0 | 0 | || 3 mp || 2 | 4.0E-8 | 5 | 0 || 11 | 4.0E-8 | 0 |iter_inc=1e4 || 3 lp || 54 | 3.7E-4 | 5 | 0 || 209 | 3.7E-4 | 0 |IndStartRandom=2 || ------||--------|--------|-------|------||--------|--------|------ || 5 hp || 0.2 | 0.0 | 4 | 0 || 0.2 | 0.0 | 0 | || 5 mp || 0.2 | 4.5E-8 | 4 | 0 || 0.2 | 4.5E-8 | 0 | || 5 lp || 74 | 4.0E-4 | 4 | 0 || 322 | 4.0$-4 | 0 | || ============================================================================================|| 33 16 1 hp || 40 | 0.0 | 7 | 0 || 120 | 8.1E-4 | 8 | || (b) 1 mp || 40 | 5.5E-9 | 7 | 0 || 120 | 8.1E-4 | 8 | Footnote (a) || 1 lp || 138 | 5.1E-5 | 7 | 3 || 120 | 8.1E-4 | 8 | || ------||--------|--------|-------|------||--------|--------|--------- || 3 hp || 85 | 0.0 | 8 | 0 || 30 | 0.0 | 0 | || 3 mp || 79 | 3.4E-8 | 8 | 0 || 31 | 3.4E-8 | 0 |iter_inc=1e4 || 3 lp || 225 | 4.8E-4 | 8 | 0 || 214 | 4.8E-4 | 0 | || ------||--------|--------|-------|------||--------|--------|-----| || 5 hp || 48 | 0.0 | 7 | 0 || 13 | 0.0 | 0 | || 5 mp || 48 | 3.2E-8 | 7 | 0 || 13 | 3.2E-8 | 0 | || 5 lp || 298 | 2.5E-4 | 7 | 0 || 390 | 2.5E-4 | 0 | || ============================================================================================|| 35 17 1 hp || 209 | 0.0 | 8 | 0 || 209 | 5.4E-4 | 7 | Footnote (b) || (c) 1 mp || 218 | 0.0 | 8 | 0 || 209 | 5.4E-4 | 7 | || 1 lp || 508 | 5.5E-5 | 8 | 0 || 209 | 5.4E-4 | 7 | || ------||--------|--------|-------|------||--------|--------|-----------------------|| 3 hp || 31 | 0.0 | 6 | 0 || 20 | 0.0 | 0 |cfc_ini=0.5 || 3 mp || 31 | 2.7E-8 | 6 | 0 || 21 | 2.7E-8 | 0 |cfc_inc=0.5 || 3 lp || 865 | 3.5E-4 | 6 | 0 || 164 | 3.5E-4 | 0 |iter_inc=1e4 || ------||--------|--------|-------|------||--------|--------|-----------------------|| 5 hp || 1 | 0.0 | 4 | 0 || 0.5 | 0.0 | 0 | || 5 mp || 1 | 4.1E-8 | 4 | 0 || 0.2 | 4.1E-8 | 0 |cfc_inc=0.5 || 5 lp ||1179 | 3.2E-4 | 4 | 0 || 600 | 3.2E-4 | 0 | || ============================================================================================|| 199 90 29 hp || CombSolver is too slow || 93(g) | 0.0 | 0 | || || for this N || 18(i) | 0.0 | 0 | || --------------------------------------------------------------------------------|| mp || (g)=gfortran =========> || 98(g) | 1.7E-7 | 0 | eps=2.0E-7 || || (i)=ifort =========> || 18(i) | 1.7E-7 | 0 | || --------------------------------------------------------------------------------|| lp || CombSolver is too slow || 88(g) | 1.6E-3 | 0 | eps=2.0E-3 || || for this N || 19(i) | 1.6E-3 | 0 | || ============================================================================================/\ Footnotes (a) This case (N=33,r=16,L=1) is hard to solve with OptFSolver. There is a deep local minimum, which is close to the initial guess but far from the true solution (d=8=11-3, where 11 and 3 are factors of 33), and the random jumps strategy becomes inefficient. Increasing L to L=3 and especially to L=5 solves the problem. (b) This case (N=35,r=17,L=1) is hard to solve with OptFSolver. The vector OptFSolver tends to find differs from the true solution by d=7 or d=5, which are factors of N=35. In this case, even though the model vector does not truly contain 5- or 7-gons and therefore can be found uniquely by CombSolver, OptFSolver end up in a deep local minimum, and the true solution is very far from it in the multi-dimensional space. In this case, random jumps are inefficient. Increasing L to L=3 solves the problem.