/[dtapublic]/projs/dtats/trunk/projs/2018/20180707_cgi_web_tools_aux_exe/subfunc_cfbrap.c
ViewVC logotype

Diff of /projs/dtats/trunk/projs/2018/20180707_cgi_web_tools_aux_exe/subfunc_cfbrap.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 170 by dashley, Sun Jul 8 21:12:48 2018 UTC revision 172 by dashley, Sun Jul 8 21:17:26 2018 UTC
# Line 1  Line 1 
1  //$Header: /cvsroot/esrg/sfesrg/esrgnxpj/sfnthcgi0304/subfunc_cfbrap.c,v 1.3 2003/07/01 03:46:58 dtashley Exp $  //$Header$
2  //  //
3  //********************************************************************************  //********************************************************************************
4  //Copyright (C) 2003 David T. Ashley  //Copyright (C) 2003 David T. Ashley
5  //********************************************************************************  //********************************************************************************
6  //This program or source file is free software; you can redistribute it and/or  //This program or source file is free software; you can redistribute it and/or
7  //modify it under the terms of the GNU General Public License as published by  //modify it under the terms of the GNU General Public License as published by
8  //the Free Software Foundation; either version 2 of the License, or (at your  //the Free Software Foundation; either version 2 of the License, or (at your
9  //option) any later version.  //option) any later version.
10  //  //
11  //This program or source file is distributed in the hope that it will  //This program or source file is distributed in the hope that it will
12  //be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of  //be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
13  //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  //GNU General Public License for more details.  //GNU General Public License for more details.
15  //  //
16  //You may have received a copy of the GNU General Public License  //You may have received a copy of the GNU General Public License
17  //along with this program; if not, write to the Free Software  //along with this program; if not, write to the Free Software
18  //Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  //Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  //********************************************************************************  //********************************************************************************
20  //  //
21  //This module finds the best rational approximations to a rational number  //This module finds the best rational approximations to a rational number
22  //subject to constraints on the numerator and denominator using continued  //subject to constraints on the numerator and denominator using continued
23  //fraction techniques.  All of the algorithms employed are O(log N) so  //fraction techniques.  All of the algorithms employed are O(log N) so
24  //there should be no problem obtaining results for any practical problem.  //there should be no problem obtaining results for any practical problem.
25  //This module is based on a paper written by Dave Ashley and others providing  //This module is based on a paper written by Dave Ashley and others providing
26  //best rational approximation algorithms.  //best rational approximation algorithms.
27  //  //
28  //INPUT PARAMETERS  //INPUT PARAMETERS
29  //----------------  //----------------
30  //This subfunction accepts the following parameters, in order.  //This subfunction accepts the following parameters, in order.
31  //  //
32  // (a) The numerator of the number whose best rational approximation is to  // (a) The numerator of the number whose best rational approximation is to
33  //     be found (max 1000 digits).  //     be found (max 1000 digits).
34  //  //
35  // (b) The denominator of the number whose best rational approximation is to  // (b) The denominator of the number whose best rational approximation is to
36  //     be found (max 1000 digits).  //     be found (max 1000 digits).
37  //  //
38  // (c) The largest allowable numerator of the approximations, or "0" if the numerator  // (c) The largest allowable numerator of the approximations, or "0" if the numerator
39  //     is unconstrained (max 1000 digits).  //     is unconstrained (max 1000 digits).
40  //  //
41  // (d) The largest allowable denominator of the approximations, or "0" if the denominator  // (d) The largest allowable denominator of the approximations, or "0" if the denominator
42  //     is unconstrained (max 1000 digits).  //     is unconstrained (max 1000 digits).
43  //  //
44  // (e) The number of neighbors to the left of the specified number to return (max 1000).  // (e) The number of neighbors to the left of the specified number to return (max 1000).
45  //  //
46  // (f) The number of neighbors to the right of the specified number to return (max 1000).  // (f) The number of neighbors to the right of the specified number to return (max 1000).
47  //  //
48  // (g) The number of significant figures to use in floating-point results (note that  // (g) The number of significant figures to use in floating-point results (note that
49  //     "significant figures" includes the numbers before the decimal point as well as  //     "significant figures" includes the numbers before the decimal point as well as
50  //     after).  The maximum value here is 1000.  //     after).  The maximum value here is 1000.
51  //  //
52  // (h) The maximum number of CPU seconds to expend calculating (max 1000).  // (h) The maximum number of CPU seconds to expend calculating (max 1000).
53  //  //
54  // NOTE (1):  Numerator and denominator may not both be unconstrained.  // NOTE (1):  Numerator and denominator may not both be unconstrained.
55  //  //
56  //OUTPUT RESULTS  //OUTPUT RESULTS
57  //--------------  //--------------
58  //The notation below gives the outputs of the program.  In some cases, [i] notation  //The notation below gives the outputs of the program.  In some cases, [i] notation
59  //is used to indicate line numbers.  //is used to indicate line numbers.
60  //  //
61  //[01] An overall success or failure code for the operation, as a string.  //[01] An overall success or failure code for the operation, as a string.
62  //     Valid responses are:  //     Valid responses are:
63  //        S       : Success.  //        S       : Success.
64  //        FNPAR   : The number of command-line parameters was wrong.  //        FNPAR   : The number of command-line parameters was wrong.
65  //        FCPU    : The operation failed because ran out of CPU time.  //        FCPU    : The operation failed because ran out of CPU time.
66  //        FNUM    : The operation failed because the numerator of the rational number whose  //        FNUM    : The operation failed because the numerator of the rational number whose
67  //                  neighbors are to be found was invalid or too large.  //                  neighbors are to be found was invalid or too large.
68  //        FDEN    : The operation failed because the denominator of the rational number whose  //        FDEN    : The operation failed because the denominator of the rational number whose
69  //                  neighbors are to be found was invalid or too large.  //                  neighbors are to be found was invalid or too large.
70  //        FNUMMAX : The operation failed because the numerator limit was invalid or  //        FNUMMAX : The operation failed because the numerator limit was invalid or
71  //                  too large.  //                  too large.
72  //        FDENMAX : The operation failed because the denominator limit was invalid  //        FDENMAX : The operation failed because the denominator limit was invalid
73  //                  or too large.  //                  or too large.
74  //        FLEFT   : The operation failed because the number of left neighbors requested  //        FLEFT   : The operation failed because the number of left neighbors requested
75  //                  was invalid or too large.  //                  was invalid or too large.
76  //        FRIGHT  : The operation failed because the number of right neighbors requested  //        FRIGHT  : The operation failed because the number of right neighbors requested
77  //                  was invalid or too large.  //                  was invalid or too large.
78  //        FSIG    : The number of significant figures specified was invalid.  //        FSIG    : The number of significant figures specified was invalid.
79  //        FCPU    : The CPU time limit was invalid.  //        FCPU    : The CPU time limit was invalid.
80  //        FGEN    : General failure code (catchall, if anything else is possible).  //        FGEN    : General failure code (catchall, if anything else is possible).
81  //  //
82  //     For all failure codes, there will be no additional output if a failure code  //     For all failure codes, there will be no additional output if a failure code
83  //     appears on the first line.  //     appears on the first line.
84  //[02] The total number of lines in the output from the program, including the start  //[02] The total number of lines in the output from the program, including the start
85  //     and ending lines.  //     and ending lines.
86  //[03] The fully normalized numerator entered.  This means it has been  //[03] The fully normalized numerator entered.  This means it has been
87  //     stripped of all weird characters, etc.  This can be used by the  //     stripped of all weird characters, etc.  This can be used by the
88  //     PHP script to repopulate form boxes.  //     PHP script to repopulate form boxes.
89  //[04] The fully normalized denominator entered.  //[04] The fully normalized denominator entered.
90  //[05] The fully normalized maximum numerator entered.  //[05] The fully normalized maximum numerator entered.
91  //[06] The fully normalized maximum denominator entered.  //[06] The fully normalized maximum denominator entered.
92  //[07] The fully normalized number of left neighbors entered.  //[07] The fully normalized number of left neighbors entered.
93  //[08] The fully normalized number of right neighbors entered.  //[08] The fully normalized number of right neighbors entered.
94  //[09] The fully normalized number of significant figures requested.  //[09] The fully normalized number of significant figures requested.
95  //[10] The fully normalized number of CPU seconds allowed.  //[10] The fully normalized number of CPU seconds allowed.
96  //  //
97  //The next section of the output contains the decimal form of the number that is to  //The next section of the output contains the decimal form of the number that is to
98  //be approximated and also slightly more data about the number to be approximated.    //be approximated and also slightly more data about the number to be approximated.  
99  //The PHP script may receive a number which is either specified as  //The PHP script may receive a number which is either specified as
100  //a rational number or as a decimal number, and the PHP script must convert it to a  //a rational number or as a decimal number, and the PHP script must convert it to a
101  //rational number so this program can process it.  Depending on what the PHP script  //rational number so this program can process it.  Depending on what the PHP script
102  //was given as input, it may not have the decimal form.  //was given as input, it may not have the decimal form.
103  //  //
104  //[11] Decimal equivalent of number entered, avoiding scientific notation if  //[11] Decimal equivalent of number entered, avoiding scientific notation if
105  //     possible but using it if necessary.  //     possible but using it if necessary.
106  //[12] Scientific notation equivalent of number entered.  //[12] Scientific notation equivalent of number entered.
107  //[13] GCD of numerator and denominator of [04] and [05].  //[13] GCD of numerator and denominator of [04] and [05].
108  //[14] Numerator of reduced rational form.  //[14] Numerator of reduced rational form.
109  //[15] Denominator of reduced rational form.  //[15] Denominator of reduced rational form.
110  //  //
111  //This secion contains "pointers" to the major sections which may follow.  //This secion contains "pointers" to the major sections which may follow.
112  //All line numbers below are engineered so that "1" is the first line number  //All line numbers below are engineered so that "1" is the first line number
113  //in the output block and "0" represents the non-existence of the section.  //in the output block and "0" represents the non-existence of the section.
114  //[16] Index to results section (code "NEIGHBORS").  //[16] Index to results section (code "NEIGHBORS").
115  //[17] Index to CF decomp of number to approximate (code "CFINPUT").  //[17] Index to CF decomp of number to approximate (code "CFINPUT").
116  //[18] Index to CF decomp of reciprocal of number to approximate (code "CFINPUTRECIP").  //[18] Index to CF decomp of reciprocal of number to approximate (code "CFINPUTRECIP").
117  //[19] Index to CF decomp of corner point (code "CFCORNER").  //[19] Index to CF decomp of corner point (code "CFCORNER").
118  //[20] Index to CF decomp of reciprocal of corner point (code "CFCORNERRECIP").  //[20] Index to CF decomp of reciprocal of corner point (code "CFCORNERRECIP").
119  //  //
120  //This section contains the neighbors of the number to approximate.  The number of  //This section contains the neighbors of the number to approximate.  The number of
121  //neighbors is strongly influenced by the number of neighbors specified on the  //neighbors is strongly influenced by the number of neighbors specified on the
122  //CGI-BIN form.  However, there may be fewer neighbors returned if 0/1 or the last  //CGI-BIN form.  However, there may be fewer neighbors returned if 0/1 or the last
123  //formable rational number is encountered.  //formable rational number is encountered.
124  //[N+ 0] Constant "NEIGHBORS".  //[N+ 0] Constant "NEIGHBORS".
125  //[N+ 1] Number of neighbors to follow.  //[N+ 1] Number of neighbors to follow.
126  //[N+ 2] Subscript of first neighbor, from left to right.  Subscripts are assigned so they rank  //[N+ 2] Subscript of first neighbor, from left to right.  Subscripts are assigned so they rank
127  //       the neighbors in relation to the number to approximate.  "0" indicates that the number  //       the neighbors in relation to the number to approximate.  "0" indicates that the number
128  //       is the number to approximate, i.e. the number is present in the rectangular region of  //       is the number to approximate, i.e. the number is present in the rectangular region of
129  //       the integer lattice being considered.  //       the integer lattice being considered.
130  //[N+ 3] 1 if the number is the corner point, or 0 otherwise.  //[N+ 3] 1 if the number is the corner point, or 0 otherwise.
131  //[N+ 4] Numerator of number, irreducible with respect to denominator.  //[N+ 4] Numerator of number, irreducible with respect to denominator.
132  //[N+ 5] Denominator of number, irreducible with respect to numerator.  //[N+ 5] Denominator of number, irreducible with respect to numerator.
133  //[N+ 6] Decimal form of neighbor, avoiding scientific notation if possible.  //[N+ 6] Decimal form of neighbor, avoiding scientific notation if possible.
134  //[N+ 7] Decimal form of neighbor, using scientific notation.  //[N+ 7] Decimal form of neighbor, using scientific notation.
135  //[N+ 8] Sign of error.  Will be "-" for negative error or "+" otherwise.  //[N+ 8] Sign of error.  Will be "-" for negative error or "+" otherwise.
136  //[N+ 9] Numerator of absolute value of error, irreducible with respect to denominator.  //[N+ 9] Numerator of absolute value of error, irreducible with respect to denominator.
137  //[N+10] Denominator of absolute value of error, irreducible with respect to numerator.  //[N+10] Denominator of absolute value of error, irreducible with respect to numerator.
138  //[N+11] Decimal form of absolute value of error, avoiding scientific notation if possible.  //[N+11] Decimal form of absolute value of error, avoiding scientific notation if possible.
139  //[N+12] Decimal form of absolute value of error, using scientific notation.  //[N+12] Decimal form of absolute value of error, using scientific notation.
140  //[N+13] Repeats at [N+2] for next neighbor, out to as many neighbors specified in  //[N+13] Repeats at [N+2] for next neighbor, out to as many neighbors specified in
141  //       [N+1]  //       [N+1]
142  //  //
143  //The next section of the output contains the continued fraction decomposition  //The next section of the output contains the continued fraction decomposition
144  //of the number to approximate.  //of the number to approximate.
145  //[N+ 0] Constant "CFINPUT".  //[N+ 0] Constant "CFINPUT".
146  //[N+ 1] Number of partial quotients to follow.  //[N+ 1] Number of partial quotients to follow.
147  //[N+ 2] k, subscript of iteration (first subscript is 0).  //[N+ 2] k, subscript of iteration (first subscript is 0).
148  //[N+ 3] dividend_k  //[N+ 3] dividend_k
149  //[N+ 4] divisor_k  //[N+ 4] divisor_k
150  //[N+ 5] a_k  //[N+ 5] a_k
151  //[N+ 6] remainder_k  //[N+ 6] remainder_k
152  //[N+ 7] p_k  //[N+ 7] p_k
153  //[N+ 8] q_k  //[N+ 8] q_k
154  //[N+ 9] k+1 ... repeats as with element [N+2] out to as many partial  //[N+ 9] k+1 ... repeats as with element [N+2] out to as many partial
155  //       quotients specified in [N+1].  //       quotients specified in [N+1].
156  //  //
157  //The next section of the output contains the continued fraction decomposition  //The next section of the output contains the continued fraction decomposition
158  //of the reciprocal of the number to approximate.  If the number to approximate is 0,  //of the reciprocal of the number to approximate.  If the number to approximate is 0,
159  //this entire section will be omitted.  //this entire section will be omitted.
160  //[N+ 0] Constant "CFINPUTRECIP".  //[N+ 0] Constant "CFINPUTRECIP".
161  //[N+ 1] Number of partial quotients to follow.  //[N+ 1] Number of partial quotients to follow.
162  //[N+ 2] k, subscript of iteration (first subscript is 0).  //[N+ 2] k, subscript of iteration (first subscript is 0).
163  //[N+ 3] dividend_k  //[N+ 3] dividend_k
164  //[N+ 4] divisor_k  //[N+ 4] divisor_k
165  //[N+ 5] a_k  //[N+ 5] a_k
166  //[N+ 6] remainder_k  //[N+ 6] remainder_k
167  //[N+ 7] p_k  //[N+ 7] p_k
168  //[N+ 8] q_k  //[N+ 8] q_k
169  //[N+ 9] k+1 ... repeats as with element [N+2] out to as many partial  //[N+ 9] k+1 ... repeats as with element [N+2] out to as many partial
170  //       quotients specified in [N+1].  //       quotients specified in [N+1].
171  //  //
172  //The next section of the output contains the continued fraction decomposition of the  //The next section of the output contains the continued fraction decomposition of the
173  //the corner point.  If the numerator and denominator were not both constrained,  //the corner point.  If the numerator and denominator were not both constrained,
174  //this section will be omitted.  //this section will be omitted.
175  //[N+ 0] Constant "CCORNER".  //[N+ 0] Constant "CCORNER".
176  //[N+ 1] Number of partial quotients to follow.  //[N+ 1] Number of partial quotients to follow.
177  //[N+ 2] k, subscript of iteration (first subscript is 0).  //[N+ 2] k, subscript of iteration (first subscript is 0).
178  //[N+ 3] dividend_k  //[N+ 3] dividend_k
179  //[N+ 4] divisor_k  //[N+ 4] divisor_k
180  //[N+ 5] a_k  //[N+ 5] a_k
181  //[N+ 6] remainder_k  //[N+ 6] remainder_k
182  //[N+ 7] p_k  //[N+ 7] p_k
183  //[N+ 8] q_k  //[N+ 8] q_k
184  //[N+ 9] k+1 ... repeats as with element [N+2] out to as many partial  //[N+ 9] k+1 ... repeats as with element [N+2] out to as many partial
185  //       quotients specified in [N+1].  //       quotients specified in [N+1].
186  //  //
187  //The next section of the output contains the continued fraction decomposition of the  //The next section of the output contains the continued fraction decomposition of the
188  //reciprocal of the corner point.  If the numerator and denominator were not both constrained,  //reciprocal of the corner point.  If the numerator and denominator were not both constrained,
189  //this section will be omitted.  //this section will be omitted.
190  //[N+ 0] Constant "CCORNERRECIP".  //[N+ 0] Constant "CCORNERRECIP".
191  //[N+ 1] Number of partial quotients to follow.  //[N+ 1] Number of partial quotients to follow.
192  //[N+ 2] k, subscript of iteration (first subscript is 0).  //[N+ 2] k, subscript of iteration (first subscript is 0).
193  //[N+ 3] dividend_k  //[N+ 3] dividend_k
194  //[N+ 4] divisor_k  //[N+ 4] divisor_k
195  //[N+ 5] a_k  //[N+ 5] a_k
196  //[N+ 6] remainder_k  //[N+ 6] remainder_k
197  //[N+ 7] p_k  //[N+ 7] p_k
198  //[N+ 8] q_k  //[N+ 8] q_k
199  //[N+ 9] k+1 ... repeats as with element [N+2] out to as many partial  //[N+ 9] k+1 ... repeats as with element [N+2] out to as many partial
200  //       quotients specified in [N+1].  //       quotients specified in [N+1].
201  //  //
202  //The next section is the footer.  //The next section is the footer.
203  //[N]    Constant "S", terminator line.  //[N]    Constant "S", terminator line.
204    
205  //The return value (exit code) from this subfunction is always 0.  //The return value (exit code) from this subfunction is always 0.
206  //  //
207    
208  #define MODULE_SUBFUNC_CFBRAP  #define MODULE_SUBFUNC_CFBRAP
209    
210  #include <assert.h>  #include <assert.h>
211  #include <ctype.h>  #include <ctype.h>
212  #include <stddef.h>  #include <stddef.h>
213  #include <stdio.h>  #include <stdio.h>
214  #include <stdlib.h>  #include <stdlib.h>
215  #include <string.h>  #include <string.h>
216  #include <time.h>  #include <time.h>
217    
218  #include <gmp.h>  #include <gmp.h>
219    
220  #include "auxfuncs.h"  #include "auxfuncs.h"
221  #include "subfunc_cfbrap.h"  #include "subfunc_cfbrap.h"
222  #include "sieve_eratosthenes.h"  #include "sieve_eratosthenes.h"
223    
224    
225  /****************************************************************************/  /****************************************************************************/
226  /* MODULE CONSTANTS                                                         */  /* MODULE CONSTANTS                                                         */
227  /****************************************************************************/  /****************************************************************************/
228  #define SUBFUNC_CFBRAP_MAX_IN_DIGITS               (1000)  #define SUBFUNC_CFBRAP_MAX_IN_DIGITS               (1000)
229     //The maximum number of decimal digits that will be allowed in input rational     //The maximum number of decimal digits that will be allowed in input rational
230     //numbers and limits.     //numbers and limits.
231  #define SUBFUNC_CFBRAP_MAX_NEIGHBORS               (1000)  #define SUBFUNC_CFBRAP_MAX_NEIGHBORS               (1000)
232     //The maximum number of integer lattice rectangular region neighbors that will     //The maximum number of integer lattice rectangular region neighbors that will
233     //be allowed.     //be allowed.
234    
235  /****************************************************************************/  /****************************************************************************/
236  /* MODULE DATA STRUCTURES                                                   */  /* MODULE DATA STRUCTURES                                                   */
237  /****************************************************************************/  /****************************************************************************/
238  //A structure to hold all input parameters from the command-line.  //A structure to hold all input parameters from the command-line.
239  //  //
240  struct SUBFUNC_CFBRAP_input_par_struct  struct SUBFUNC_CFBRAP_input_par_struct
241     {     {
242     mpz_t num;     mpz_t num;
243     mpz_t den;     mpz_t den;
244     mpz_t num_max;     mpz_t num_max;
245     mpz_t den_max;     mpz_t den_max;
246     int lneighbors;     int lneighbors;
247     int rneighbors;     int rneighbors;
248     int sig_fig;     int sig_fig;
249     int max_cpu;     int max_cpu;
250     };     };
251    
252  //A structure to hold a single line that might be output from this  //A structure to hold a single line that might be output from this
253  //program.  //program.
254  struct SUBFUNC_CFBRAP_line_buffer  struct SUBFUNC_CFBRAP_line_buffer
255     {     {
256     char *line;     char *line;
257        //The line itself, with zero terminator.        //The line itself, with zero terminator.
258     };     };
259    
260  //A structure to hold the collection of lines that will eventually be  //A structure to hold the collection of lines that will eventually be
261  //output from this program.  These must be buffered because it is  //output from this program.  These must be buffered because it is
262  //not known how many there will be.  //not known how many there will be.
263  //  //
264  struct SUBFUNC_CFBRAP_program_output_buffer  struct SUBFUNC_CFBRAP_program_output_buffer
265     {     {
266     int nlines;     int nlines;
267        //The number of lines.        //The number of lines.
268     struct SUBFUNC_CFBRAP_line_buffer *lines;     struct SUBFUNC_CFBRAP_line_buffer *lines;
269        //Pointer to the first element of array of line structures.        //Pointer to the first element of array of line structures.
270     };     };
271    
272    
273  /****************************************************************************/  /****************************************************************************/
274  /* PROGRAM OUTPUT BUFFER MANIPULATION FUNCTIONS                             */  /* PROGRAM OUTPUT BUFFER MANIPULATION FUNCTIONS                             */
275  /****************************************************************************/  /****************************************************************************/
276  void SUBFUNC_CFBRAP_pob_init(struct SUBFUNC_CFBRAP_program_output_buffer *arg)  void SUBFUNC_CFBRAP_pob_init(struct SUBFUNC_CFBRAP_program_output_buffer *arg)
277     {     {
278     arg->nlines  = 0;     arg->nlines  = 0;
279     arg->lines   = NULL;     arg->lines   = NULL;
280     }     }
281    
282  void SUBFUNC_CFBRAP_pob_destroy(struct SUBFUNC_CFBRAP_program_output_buffer *arg)  void SUBFUNC_CFBRAP_pob_destroy(struct SUBFUNC_CFBRAP_program_output_buffer *arg)
283     {     {
284     int i;     int i;
285    
286     for (i=0; i<arg->nlines; i++)     for (i=0; i<arg->nlines; i++)
287        {        {
288        free(arg->lines[i].line);        free(arg->lines[i].line);
289        }        }
290    
291     if (i)     if (i)
292        free(arg->lines);        free(arg->lines);
293    
294     arg->nlines = 0;     arg->nlines = 0;
295     arg->lines = NULL;     arg->lines = NULL;
296     }     }
297    
298  //Tacks a line onto the output buffer.  //Tacks a line onto the output buffer.
299  //  //
300  void SUBFUNC_CFBRAP_pob_tack_line(struct SUBFUNC_CFBRAP_program_output_buffer *arg,  void SUBFUNC_CFBRAP_pob_tack_line(struct SUBFUNC_CFBRAP_program_output_buffer *arg,
301                                    const char *line)                                    const char *line)
302     {     {
303     int tack_strlen;     int tack_strlen;
304        //String length of the line to tack.  Must allocate one more space for it.        //String length of the line to tack.  Must allocate one more space for it.
305    
306     //Figure out how long the input string is.     //Figure out how long the input string is.
307     tack_strlen = strlen(line);     tack_strlen = strlen(line);
308    
309     //If there are no lines in the buffer, allocate space for 1 else realloc.     //If there are no lines in the buffer, allocate space for 1 else realloc.
310     if (!arg->nlines)     if (!arg->nlines)
311        arg->lines = malloc(sizeof(struct SUBFUNC_CFBRAP_line_buffer));        arg->lines = malloc(sizeof(struct SUBFUNC_CFBRAP_line_buffer));
312     else     else
313        arg->lines = realloc(arg->lines, (arg->nlines + 1) * sizeof(struct SUBFUNC_CFBRAP_line_buffer));        arg->lines = realloc(arg->lines, (arg->nlines + 1) * sizeof(struct SUBFUNC_CFBRAP_line_buffer));
314    
315     //Set up for the line itself.     //Set up for the line itself.
316     arg->lines[arg->nlines].line = malloc(tack_strlen + 1);     arg->lines[arg->nlines].line = malloc(tack_strlen + 1);
317    
318     //Copy in the line.     //Copy in the line.
319     strcpy(arg->lines[arg->nlines].line, line);     strcpy(arg->lines[arg->nlines].line, line);
320    
321     //We now have one more line.     //We now have one more line.
322     arg->nlines++;     arg->nlines++;
323     }     }
324    
325    
326  //Changes a line in the buffer to be something different.  The first line is "1".  If the line  //Changes a line in the buffer to be something different.  The first line is "1".  If the line
327  //does not already exist, this function does nothing.  //does not already exist, this function does nothing.
328  //  //
329  void SUBFUNC_CFBRAP_pob_modify_line(struct SUBFUNC_CFBRAP_program_output_buffer *arg,  void SUBFUNC_CFBRAP_pob_modify_line(struct SUBFUNC_CFBRAP_program_output_buffer *arg,
330                                      int which_line,                                      int which_line,
331                                      const char *new_line)                                      const char *new_line)
332     {     {
333     int modify_strlen;     int modify_strlen;
334        //String length of the line to swap in.  Must allocate one more space for it.        //String length of the line to swap in.  Must allocate one more space for it.
335    
336     //Figure out how long the input string is.     //Figure out how long the input string is.
337     modify_strlen = strlen(new_line);     modify_strlen = strlen(new_line);
338    
339     //The line number specified must be at least number 1 and the line must already     //The line number specified must be at least number 1 and the line must already
340     //exist, else do nothing.     //exist, else do nothing.
341     if ((which_line >= 1) && (which_line <= arg->nlines))     if ((which_line >= 1) && (which_line <= arg->nlines))
342        {        {
343        //Reallocate the space to hold the new line and copy it in.        //Reallocate the space to hold the new line and copy it in.
344        arg->lines[which_line-1].line = realloc(arg->lines[which_line-1].line, modify_strlen + 1);        arg->lines[which_line-1].line = realloc(arg->lines[which_line-1].line, modify_strlen + 1);
345        strcpy(arg->lines[which_line-1].line, new_line);        strcpy(arg->lines[which_line-1].line, new_line);
346        }        }
347     }     }
348    
349    
350  //Dumps the entire output buffer to the standard output.  //Dumps the entire output buffer to the standard output.
351  //  //
352  void SUBFUNC_CFBRAP_pob_dump(struct SUBFUNC_CFBRAP_program_output_buffer *arg)  void SUBFUNC_CFBRAP_pob_dump(struct SUBFUNC_CFBRAP_program_output_buffer *arg)
353     {     {
354     int i;     int i;
355    
356     for (i=0; i<arg->nlines; i++)     for (i=0; i<arg->nlines; i++)
357       {       {
358         printf("%s\n", arg->lines[i].line);         printf("%s\n", arg->lines[i].line);
359       }       }
360     }     }
361    
362    
363  /****************************************************************************/  /****************************************************************************/
364  /* INPUT PARAMETER BLOCK MANIPULATION                                       */  /* INPUT PARAMETER BLOCK MANIPULATION                                       */
365  /****************************************************************************/  /****************************************************************************/
366  //Initializes the input parameter block (allocates initial storage).    //Initializes the input parameter block (allocates initial storage).  
367  //  //
368  void SUBFUNC_CFBRAP_ipblock_init(struct SUBFUNC_CFBRAP_input_par_struct *arg)  void SUBFUNC_CFBRAP_ipblock_init(struct SUBFUNC_CFBRAP_input_par_struct *arg)
369     {     {
370     mpz_init(arg->num);     mpz_init(arg->num);
371     mpz_init(arg->den);     mpz_init(arg->den);
372     mpz_init(arg->num_max);     mpz_init(arg->num_max);
373     mpz_init(arg->den_max);     mpz_init(arg->den_max);
374     arg->lneighbors         =  1;     arg->lneighbors         =  1;
375     arg->rneighbors         =  1;     arg->rneighbors         =  1;
376     arg->sig_fig            =  9;     arg->sig_fig            =  9;
377     arg->max_cpu            = 20;     arg->max_cpu            = 20;
378     }     }
379    
380  //Deallocates the input parameter block (deallocates storage).    //Deallocates the input parameter block (deallocates storage).  
381  //  //
382  void SUBFUNC_CFBRAP_ipblock_destroy(struct SUBFUNC_CFBRAP_input_par_struct *arg)  void SUBFUNC_CFBRAP_ipblock_destroy(struct SUBFUNC_CFBRAP_input_par_struct *arg)
383     {     {
384     mpz_clear(arg->num);     mpz_clear(arg->num);
385     mpz_clear(arg->den);     mpz_clear(arg->den);
386     mpz_clear(arg->num_max);     mpz_clear(arg->num_max);
387     mpz_clear(arg->den_max);     mpz_clear(arg->den_max);
388     arg->lneighbors         =  1;     arg->lneighbors         =  1;
389     arg->rneighbors         =  1;     arg->rneighbors         =  1;
390     arg->sig_fig            =  9;     arg->sig_fig            =  9;
391     arg->max_cpu            = 20;     arg->max_cpu            = 20;
392     }     }
393    
394    
395  /****************************************************************************/  /****************************************************************************/
396  /* ERROR PATH OUTPUT                                                        */  /* ERROR PATH OUTPUT                                                        */
397  /****************************************************************************/  /****************************************************************************/
398  //Dumps an error code and associated proper information out to the output stream  //Dumps an error code and associated proper information out to the output stream
399  //and returns.  //and returns.
400  //  //
401  int SUBFUNC_CFBRAP_error_dump(int argc, char *argv[])  int SUBFUNC_CFBRAP_error_dump(int argc, char *argv[])
402     {     {
403       return 0;       return 0;
404     }     }
405    
406    
407  /****************************************************************************/  /****************************************************************************/
408  /* INPUT PARAMETER PARSING                                                  */  /* INPUT PARAMETER PARSING                                                  */
409  /****************************************************************************/  /****************************************************************************/
410  //Parses input parameters, stuffs the structure containing these parameters,  //Parses input parameters, stuffs the structure containing these parameters,
411  //and in the event of an error will return 1 and will stuff the output  //and in the event of an error will return 1 and will stuff the output
412  //buffer with only the error code.  //buffer with only the error code.
413  int SUBFUNC_CFBRAP_parse_input_pars(  int SUBFUNC_CFBRAP_parse_input_pars(
414                                      int argc,                                      int argc,
415                                      char *argv[],                                          char *argv[],    
416                                      struct SUBFUNC_CFBRAP_input_par_struct *ipb,                                      struct SUBFUNC_CFBRAP_input_par_struct *ipb,
417                                      struct SUBFUNC_CFBRAP_program_output_buffer *pob                                      struct SUBFUNC_CFBRAP_program_output_buffer *pob
418                                      )                                      )
419     {     {
420     char *scratch = NULL;     char *scratch = NULL;
421    
422     //There should be 8 input parameters in addition to the 2 required (the     //There should be 8 input parameters in addition to the 2 required (the
423     //program name plus the subfunction code.  Error out if wrong.     //program name plus the subfunction code.  Error out if wrong.
424     if (argc != 10)     if (argc != 10)
425        {        {
426        SUBFUNC_CFBRAP_pob_tack_line(pob, "FNPAR");        SUBFUNC_CFBRAP_pob_tack_line(pob, "FNPAR");
427        return(1);        return(1);
428        }        }
429    
430     //The first input parameter should be the numerator of the rational number to     //The first input parameter should be the numerator of the rational number to
431     //approximate.  We can parse this out and place it into the input parameter     //approximate.  We can parse this out and place it into the input parameter
432     //block.     //block.
433     scratch = malloc(strlen(argv[2]) + 1);     scratch = malloc(strlen(argv[2]) + 1);
434     strcpy(scratch, argv[2]);     strcpy(scratch, argv[2]);
435     AUXFUNCS_remove_non_digits(scratch);     AUXFUNCS_remove_non_digits(scratch);
436     AUXFUNCS_remove_leading_zeros(scratch);     AUXFUNCS_remove_leading_zeros(scratch);
437    
438     if (!strlen(scratch))     if (!strlen(scratch))
439        {        {
440        //The only possibility is that this was zero.  Assign zero.        //The only possibility is that this was zero.  Assign zero.
441        mpz_set_ui(ipb->num, 0);        mpz_set_ui(ipb->num, 0);
442        }        }
443     else     else
444        {        {
445        //What is left must be a valid integer.  We need to be sure it is not too        //What is left must be a valid integer.  We need to be sure it is not too
446        //long.        //long.
447        if (strlen(scratch) > SUBFUNC_CFBRAP_MAX_IN_DIGITS)        if (strlen(scratch) > SUBFUNC_CFBRAP_MAX_IN_DIGITS)
448           {           {
449           SUBFUNC_CFBRAP_pob_tack_line(pob, "FNUM");           SUBFUNC_CFBRAP_pob_tack_line(pob, "FNUM");
450           return(1);           return(1);
451           }           }
452        else        else
453           {           {
454           mpz_set_str(ipb->num, scratch, 10);           mpz_set_str(ipb->num, scratch, 10);
455           }           }
456        }        }
457    
458     //The second input parameter should be the denominator of the rational number to     //The second input parameter should be the denominator of the rational number to
459     //approximate.  We can parse this out and place it into the input parameter     //approximate.  We can parse this out and place it into the input parameter
460     //block.     //block.
461     scratch = realloc(scratch, strlen(argv[3]) + 1);     scratch = realloc(scratch, strlen(argv[3]) + 1);
462     strcpy(scratch, argv[3]);     strcpy(scratch, argv[3]);
463     AUXFUNCS_remove_non_digits(scratch);     AUXFUNCS_remove_non_digits(scratch);
464     AUXFUNCS_remove_leading_zeros(scratch);     AUXFUNCS_remove_leading_zeros(scratch);
465    
466     if (!strlen(scratch))     if (!strlen(scratch))
467        {        {
468        //The only possibility is that this was zero.  This is a no-no.        //The only possibility is that this was zero.  This is a no-no.
469        SUBFUNC_CFBRAP_pob_tack_line(pob, "FDEN");        SUBFUNC_CFBRAP_pob_tack_line(pob, "FDEN");
470        return(1);        return(1);
471        }        }
472     else     else
473        {        {
474        //What is left must be a valid integer.  We need to be sure it is not too        //What is left must be a valid integer.  We need to be sure it is not too
475        //long.        //long.
476        if (strlen(scratch) > SUBFUNC_CFBRAP_MAX_IN_DIGITS)        if (strlen(scratch) > SUBFUNC_CFBRAP_MAX_IN_DIGITS)
477           {           {
478           SUBFUNC_CFBRAP_pob_tack_line(pob, "FDEN");           SUBFUNC_CFBRAP_pob_tack_line(pob, "FDEN");
479           return(1);           return(1);
480           }           }
481        else        else
482           {           {
483           mpz_set_str(ipb->den, scratch, 10);           mpz_set_str(ipb->den, scratch, 10);
484           }           }
485        }        }
486    
487     //The third input parameter should be the max numerator value for approximations.     //The third input parameter should be the max numerator value for approximations.
488     //We can parse this out and place it into the input parameter     //We can parse this out and place it into the input parameter
489     //block.     //block.
490     scratch = malloc(strlen(argv[4]) + 1);     scratch = malloc(strlen(argv[4]) + 1);
491     strcpy(scratch, argv[4]);     strcpy(scratch, argv[4]);
492     AUXFUNCS_remove_non_digits(scratch);     AUXFUNCS_remove_non_digits(scratch);
493     AUXFUNCS_remove_leading_zeros(scratch);     AUXFUNCS_remove_leading_zeros(scratch);
494    
495     if (!strlen(scratch))     if (!strlen(scratch))
496        {        {
497        //The only possibility is that this was zero.  Assign zero.        //The only possibility is that this was zero.  Assign zero.
498        mpz_set_ui(ipb->num_max, 0);        mpz_set_ui(ipb->num_max, 0);
499        }        }
500     else     else
501        {        {
502        //What is left must be a valid integer.  We need to be sure it is not too        //What is left must be a valid integer.  We need to be sure it is not too
503        //long.        //long.
504        if (strlen(scratch) > SUBFUNC_CFBRAP_MAX_IN_DIGITS)        if (strlen(scratch) > SUBFUNC_CFBRAP_MAX_IN_DIGITS)
505           {           {
506           SUBFUNC_CFBRAP_pob_tack_line(pob, "FNUMMAX");           SUBFUNC_CFBRAP_pob_tack_line(pob, "FNUMMAX");
507           return(1);           return(1);
508           }           }
509        else        else
510           {           {
511           mpz_set_str(ipb->num_max, scratch, 10);           mpz_set_str(ipb->num_max, scratch, 10);
512           }           }
513        }        }
514    
515     //The fourth input parameter should be the max denominator value for approximations.     //The fourth input parameter should be the max denominator value for approximations.
516     //We can parse this out and place it into the input parameter     //We can parse this out and place it into the input parameter
517     //block.     //block.
518     scratch = malloc(strlen(argv[5]) + 1);     scratch = malloc(strlen(argv[5]) + 1);
519     strcpy(scratch, argv[5]);     strcpy(scratch, argv[5]);
520     AUXFUNCS_remove_non_digits(scratch);     AUXFUNCS_remove_non_digits(scratch);
521     AUXFUNCS_remove_leading_zeros(scratch);     AUXFUNCS_remove_leading_zeros(scratch);
522    
523     if (!strlen(scratch))     if (!strlen(scratch))
524        {        {
525        //The only possibility is that this was zero.  Assign zero.        //The only possibility is that this was zero.  Assign zero.
526        mpz_set_ui(ipb->den_max, 0);        mpz_set_ui(ipb->den_max, 0);
527        }        }
528     else     else
529        {        {
530        //What is left must be a valid integer.  We need to be sure it is not too        //What is left must be a valid integer.  We need to be sure it is not too
531        //long.        //long.
532        if (strlen(scratch) > SUBFUNC_CFBRAP_MAX_IN_DIGITS)        if (strlen(scratch) > SUBFUNC_CFBRAP_MAX_IN_DIGITS)
533           {           {
534           SUBFUNC_CFBRAP_pob_tack_line(pob, "FDENMAX");           SUBFUNC_CFBRAP_pob_tack_line(pob, "FDENMAX");
535           return(1);           return(1);
536           }           }
537        else        else
538           {           {
539           mpz_set_str(ipb->den_max, scratch, 10);           mpz_set_str(ipb->den_max, scratch, 10);
540           }           }
541        }        }
542    
543     //The fifth input parameter should be the number of desired left neighbors.     //The fifth input parameter should be the number of desired left neighbors.
544     //We can parse this out and place it into the input parameter     //We can parse this out and place it into the input parameter
545     //block.     //block.
546     scratch = malloc(strlen(argv[6]) + 1);     scratch = malloc(strlen(argv[6]) + 1);
547     strcpy(scratch, argv[6]);     strcpy(scratch, argv[6]);
548     AUXFUNCS_remove_non_digits(scratch);     AUXFUNCS_remove_non_digits(scratch);
549     AUXFUNCS_remove_leading_zeros(scratch);     AUXFUNCS_remove_leading_zeros(scratch);
550    
551     if (!strlen(scratch))     if (!strlen(scratch))
552        {        {
553        //The only possibility is that this was zero.  Assign 0.        //The only possibility is that this was zero.  Assign 0.
554        ipb->lneighbors = 0;        ipb->lneighbors = 0;
555        }        }
556     else     else
557        {        {
558        //What is left must be a valid integer.  Scan it in.        //What is left must be a valid integer.  Scan it in.
559        //        //
560        if (strlen(scratch) > SUBFUNC_CFBRAP_MAX_IN_DIGITS)        if (strlen(scratch) > SUBFUNC_CFBRAP_MAX_IN_DIGITS)
561           {           {
562           SUBFUNC_CFBRAP_pob_tack_line(pob, "FDENMAX");           SUBFUNC_CFBRAP_pob_tack_line(pob, "FDENMAX");
563           return(1);           return(1);
564           }           }
565        else        else
566           {           {
567           mpz_set_str(ipb->den_max, scratch, 10);           mpz_set_str(ipb->den_max, scratch, 10);
568           }           }
569        }        }
570    
571     return(0);     return(0);
572     }     }
573    
574    
575  /****************************************************************************/  /****************************************************************************/
576  /* MAIN CALCULATION FUNCTION                                                */  /* MAIN CALCULATION FUNCTION                                                */
577  /****************************************************************************/  /****************************************************************************/
578  //Carries out the best rational approximation calculation and display, knowing that  //Carries out the best rational approximation calculation and display, knowing that
579  //all parameters have been validated.  //all parameters have been validated.
580  //  //
581  int SUBFUNC_CFBRAP_calc_brap(int argc, char *argv[])  int SUBFUNC_CFBRAP_calc_brap(int argc, char *argv[])
582     {     {
583       return 0;       return 0;
584     }     }
585    
586    
587    
588  //Main function.  Checks parameters and carries out the calculations.  //Main function.  Checks parameters and carries out the calculations.
589  //  //
590  int SUBFUNC_CFBRAP_main(int argc, char *argv[])  int SUBFUNC_CFBRAP_main(int argc, char *argv[])
591     {     {
592     //The time snapshot against which we compare to see if we're over     //The time snapshot against which we compare to see if we're over
593     //time budget.     //time budget.
594     time_t time_snapshot;     time_t time_snapshot;
595    
596     struct SUBFUNC_CFBRAP_input_par_struct ipb;     struct SUBFUNC_CFBRAP_input_par_struct ipb;
597     //The input parameters.     //The input parameters.
598    
599     struct SUBFUNC_CFBRAP_program_output_buffer pob;     struct SUBFUNC_CFBRAP_program_output_buffer pob;
600     //The program output.  Output is buffered because there are some lines     //The program output.  Output is buffered because there are some lines
601     //early that point to later lines.     //early that point to later lines.
602    
603     //Scratch structure.     //Scratch structure.
604     char *scratchstr = NULL;     char *scratchstr = NULL;
605    
606     //Initialize the input parameter structure.     //Initialize the input parameter structure.
607     SUBFUNC_CFBRAP_ipblock_init(&ipb);     SUBFUNC_CFBRAP_ipblock_init(&ipb);
608    
609     //Initialize the output buffer.     //Initialize the output buffer.
610     SUBFUNC_CFBRAP_pob_init(&pob);     SUBFUNC_CFBRAP_pob_init(&pob);
611    
612     //Parse, check, etc. the input parameters.  If there are any issues,     //Parse, check, etc. the input parameters.  If there are any issues,
613     //Jump to the end and just dump what we have.     //Jump to the end and just dump what we have.
614     if (SUBFUNC_CFBRAP_parse_input_pars(argc, argv, &ipb, &pob))     if (SUBFUNC_CFBRAP_parse_input_pars(argc, argv, &ipb, &pob))
615        goto error_return;        goto error_return;
616    
617    
618     //This is a success event.  What this means is that we should store the output,     //This is a success event.  What this means is that we should store the output,
619     //which will then be send to stdout.     //which will then be send to stdout.
620     //     //
621     //Initial success code.     //Initial success code.
622     SUBFUNC_CFBRAP_pob_tack_line(&pob, "S");     SUBFUNC_CFBRAP_pob_tack_line(&pob, "S");
623     //     //
624     //Total number of lines in the program.  This is just a placeholder, until we know how     //Total number of lines in the program.  This is just a placeholder, until we know how
625     //many.     //many.
626     SUBFUNC_CFBRAP_pob_tack_line(&pob, "NUMLINES_PLACEHOLDER");     SUBFUNC_CFBRAP_pob_tack_line(&pob, "NUMLINES_PLACEHOLDER");
627     //     //
628     //Numerator of number to be approximated.     //Numerator of number to be approximated.
629     scratchstr = realloc(scratchstr, mpz_sizeinbase(ipb.num, 10) + 20);     scratchstr = realloc(scratchstr, mpz_sizeinbase(ipb.num, 10) + 20);
630     gmp_sprintf(scratchstr, "%Zd", ipb.num);     gmp_sprintf(scratchstr, "%Zd", ipb.num);
631     SUBFUNC_CFBRAP_pob_tack_line(&pob, scratchstr);     SUBFUNC_CFBRAP_pob_tack_line(&pob, scratchstr);
632     //     //
633     //Denominator of number to be approximated.     //Denominator of number to be approximated.
634     scratchstr = realloc(scratchstr, mpz_sizeinbase(ipb.den, 10) + 20);     scratchstr = realloc(scratchstr, mpz_sizeinbase(ipb.den, 10) + 20);
635     gmp_sprintf(scratchstr, "%Zd", ipb.den);     gmp_sprintf(scratchstr, "%Zd", ipb.den);
636     SUBFUNC_CFBRAP_pob_tack_line(&pob, scratchstr);     SUBFUNC_CFBRAP_pob_tack_line(&pob, scratchstr);
637     //     //
638     //Maximum numerator of approximations.     //Maximum numerator of approximations.
639     scratchstr = realloc(scratchstr, mpz_sizeinbase(ipb.num_max, 10) + 20);     scratchstr = realloc(scratchstr, mpz_sizeinbase(ipb.num_max, 10) + 20);
640     gmp_sprintf(scratchstr, "%Zd", ipb.num_max);     gmp_sprintf(scratchstr, "%Zd", ipb.num_max);
641     SUBFUNC_CFBRAP_pob_tack_line(&pob, scratchstr);     SUBFUNC_CFBRAP_pob_tack_line(&pob, scratchstr);
642     //     //
643     //Maximum denominator of approximations.     //Maximum denominator of approximations.
644     scratchstr = realloc(scratchstr, mpz_sizeinbase(ipb.den_max, 10) + 20);     scratchstr = realloc(scratchstr, mpz_sizeinbase(ipb.den_max, 10) + 20);
645     gmp_sprintf(scratchstr, "%Zd", ipb.den_max);     gmp_sprintf(scratchstr, "%Zd", ipb.den_max);
646     SUBFUNC_CFBRAP_pob_tack_line(&pob, scratchstr);     SUBFUNC_CFBRAP_pob_tack_line(&pob, scratchstr);
647     //     //
648     //Fill in the number of lines that we have.  This replaces the placeholder.     //Fill in the number of lines that we have.  This replaces the placeholder.
649        {        {
650        char buf[100];        char buf[100];
651    
652        sprintf(buf, "%d", pob.nlines);        sprintf(buf, "%d", pob.nlines);
653        SUBFUNC_CFBRAP_pob_modify_line(&pob, 2, buf);        SUBFUNC_CFBRAP_pob_modify_line(&pob, 2, buf);
654        }        }
655        
656    
657    
658     error_return:     error_return:
659    
660     //Destroy the input parameter structure.     //Destroy the input parameter structure.
661     SUBFUNC_CFBRAP_ipblock_destroy(&ipb);     SUBFUNC_CFBRAP_ipblock_destroy(&ipb);
662    
663     //Dump the output to STDOUT.     //Dump the output to STDOUT.
664     SUBFUNC_CFBRAP_pob_dump(&pob);     SUBFUNC_CFBRAP_pob_dump(&pob);
665    
666     //Destroy the output buffer.     //Destroy the output buffer.
667     SUBFUNC_CFBRAP_pob_destroy(&pob);     SUBFUNC_CFBRAP_pob_destroy(&pob);
668    
669     //Always return 0.     //Always return 0.
670     return(0);     return(0);
671     }     }
672    
673  //********************************************************************************  //********************************************************************************
674  // $Log: subfunc_cfbrap.c,v $  // $Log: subfunc_cfbrap.c,v $
675  // Revision 1.3  2003/07/01 03:46:58  dtashley  // Revision 1.3  2003/07/01 03:46:58  dtashley
676  // Edits towards working continued fraction best rational approximation  // Edits towards working continued fraction best rational approximation
677  // functionality.  // functionality.
678  //  //
679  // Revision 1.2  2003/06/29 22:58:55  dtashley  // Revision 1.2  2003/06/29 22:58:55  dtashley
680  // Extra log line removed.  // Extra log line removed.
681  //  //
682  // Revision 1.1  2003/06/29 22:56:47  dtashley  // Revision 1.1  2003/06/29 22:56:47  dtashley
683  // Initial checkin.  // Initial checkin.
684  //********************************************************************************  //********************************************************************************
685  // End of SUBFUNC_CFBRAP.C.  // End of SUBFUNC_CFBRAP.C.
686  //********************************************************************************  //********************************************************************************

Legend:
Removed from v.170  
changed lines
  Added in v.172

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25