/*
 * Stuff for the processing of options follows.
 *
 * Each application may define its own options in a similar fashion
 * (using the app_options variable). The columns represent
 *
 *       1)   The long form of the name of the option.
 *       2)   An abbreviated name for the option (if desired).
 *       3)   The type of the option (see options.h).
 *       4)   Whether the option is mandatory.
 *       5)   Is there a lower bound on this option?
 *       6)   If so, what is the lower bound?
 *       7)   Is there an upper bound on this option?
 *       8)   If so, what is the upper bound?
 *       9)   The address of something to operate on when the option 
 *            is found (the action is determined by the option type).
 *      10)   A USEFUL help message.
 *       
 * There are some defines in options.h that make things more readable.
 * In particular, the LIMIT defines collapse columns 5 to 8 into one.
 */


static OPTION main_options[] = {

    /* OPTION NAME               ABBREV  TYPE         REQD   LIMITS */
    
    { APP_OUTPUT_NAME, APP_OUTPUT_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
	  VADDR(output_files[APP_OUTPUT]),

#if defined(APP_VERBOSE_USAGE)
"Specify where the application's output should be sent. If you don't\n\
give an argument then the output will go to standard output. If you do\n\
give an argument, it will be taken taken as the name of an output\n\
file. The file will be appended to if it already exists, or created if\n\
not. The -overwrite option can be used to rewrite existing files. The\n\
application output is defined as whatever is printed by the application\n\
in functions such as app_generation() and app_print_statistics()."
#else
""
#endif
},

    { "crossover_method",          "cm", STRING_OPT,  FALSE, NO_LIMITS(),
	  VADDR(crossover_function_name),

#if defined(APP_VERBOSE_USAGE)
"Specify, by name, the crossover method. There are several built in\n\
crossover methods, including no_crossover, one_point, two_point and\n\
uniform.  If you write your own crossover function you will have to\n\
give it a name in your app_crossover_functions variable and you will\n\
ask Gassy to use it with this option, just like any built in method.\n\
Crossover function names may be abbreviated. To see a full list of the\n\
crossover methods available for any given application, invoke the\n\
application with the -functions option.\n\
DEFAULT VALUE       : two_point" 
#else
"DEFAULT VALUE       : two_point" 
#endif
},

    { "crossover_probability",     "cp", DOUBLE_OPT,  FALSE, LIMITS(0.0, 1.0),
	  VCADDR(crossover_prob),

#if defined(APP_VERBOSE_USAGE)
"Specify, with a 0.0 to 1.0 argument, the probability of crossover\n\
occurring. Each time crossover is to be performed, a randomly chosen\n\
value from 0.0 to 1.0 is chosen and the crossover is done if that\n\
value is less than the one you specify with this option.\n\
DEFAULT VALUE       : 0.75" 
#else
"DEFAULT VALUE       : 0.75" 
#endif
},
    
    { "data_only",                    "do", BOOLEAN_OPT, FALSE, NO_LIMITS(),
 VADDR(data_only),

#if defined(APP_VERBOSE_USAGE)
"If TRUE, files containing show_* option output will not contain any words.\n\
This is only done where it makes sense, for example in the show_best output\n\
but not in the show_population_sorted. This is useful if you want to use\n\
the output files as input to plotting programs. Things like files of sorted\n\
populations can probably not be used in this fashion, so they ignore this\n\
option.\n\
DEFAULT VALUE      : FALSE"
#else
"DEFAULT VALUE      : FALSE"
#endif
},

    { DUMP_FINAL_NAME, DUMP_FINAL_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
	  VADDR(output_files[DUMP_FINAL]),

#if defined(APP_VERBOSE_USAGE)
"Dump the final population and other relevant information so a Gassy\n\
run can be restarted from it at a later date. If you don't give an\n\
argument then the dump will go to standard output. If you do give an\n\
argument, it will be taken taken as the name of an output file. The\n\
file will be appended to if it already exists, or created if not. The\n\
-overwrite option can be used to rewrite existing files.  This is very\n\
useful when you want to run an experiment for more generations than\n\
you originally thought. Of course it helps to know this in advance :-)\n\
\n\
Note that this is different from the -show_final option which simply\n\
prints the final population. This option will dump *everything* there\n\
is to know about this run, including the final population."
#else
""
#endif
},

    { "elitist_selection",         "e",  BOOLEAN_OPT, FALSE, NO_LIMITS(),
	  VCADDR(elitist),

#if defined(APP_VERBOSE_USAGE)
"Use elitist selection (save the best individual of each generation).\n\
This option may not be available with all forms of selection. Of the\n\
builtin selection functions, it is available with tournament selection\n\
but not roulette wheel fitness proportionate selection." 
#else
""
#endif
},

    { "functions",                  "fun", FUNC0_OPT,  FALSE,  NO_LIMITS(),
	  (VOID *)show_functions,

#if defined(APP_VERBOSE_USAGE)
"This option will result in a help message describing all the functions\n\
that are selectable from the command line to control things like selection,\n\
generation gap survival, crossover, mutation and so on."
#else
""
#endif
},

    { "generations",               "g",  INT_OPT,     TRUE,  LLIMIT(1.0),
	  VCADDR(ngenerations),

#if defined(APP_VERBOSE_USAGE)
"Specify, with the next argument, the number of generations to run.\n\
This is more like the maximum number of generations to run if you\n\
have asked the program to stop at some maximum fitness value." 
#else
""
#endif
},

    { "generation_gap",            "gap", DOUBLE_OPT,  FALSE, LIMITS(0.0, 1.0),
	  VCADDR(generation_gap_prob),

#if defined(APP_VERBOSE_USAGE)
"Specify, with the next argument, generation gap. This determines what\n\
proportion of the population will be replaced from generation to generation.\n\
A value of 1.0 means that the whole population is to be replaced. 0.1 would\n\
mean that 10% of the population is to be replaced etc.\n\
DEFAULT VALUE       : 1.0" 
#else
"DEFAULT VALUE       : 1.0" 
#endif
},

    { "hashing",                   "h",  BOOLEAN_OPT, FALSE, NO_LIMITS(),
	  VCADDR(hashing),

#if defined(APP_VERBOSE_USAGE)
"Turn off hashing. Hashing can only be turned off when the hashing code\n\
was compiled into your program. You may object that this option should\n\
even exist - if you wanted hashing compiled, you probably want to use\n\
it always. But sometimes you can run out of memory if the hash table\n\
contains too much and so it is nice to be able to turn hashing off." 
#else
""
#endif
},

#if defined(APP_HASHING)
    { "hash_table_size",           "hs", INT_OPT,     FALSE, LLIMIT(1.0),
	  VADDR(hash_table_size),

#if defined(APP_VERBOSE_USAGE)
"Specify the size of the hash table to use when hashing is being done.\n\
DEFAULT VALUE       : 97"
#else
"DEFAULT VALUE       : 97"
#endif
},

#endif

    { "help",                      "he", FUNC0_OPT,   FALSE, NO_LIMITS(),
       (VOID *)usage,

#if defined(APP_VERBOSE_USAGE)
"Print a help message describing all options and their effects." 
#else
""
#endif
},

    { "initial_population_file",   "i",  STRING_OPT,  FALSE, NO_LIMITS(),
	  VADDR(initial_population_file),

#if defined(APP_VERBOSE_USAGE)
"Specify, with the next argument, a file containing an initial\n\
population. If this file does not contain enough individuals to\n\
fill the population, random ones will be created to make up the\n\
difference. If it contains too many, you will be warned but the run\n\
will continue. If your individuals do not have constant size, then\n\
each should be preceded by its size on a line by itself." 
#else
""
#endif
},

    { "interrupts",                "in", BOOLEAN_OPT, FALSE, NO_LIMITS(),
	  VADDR(catch_interrupts),

#if defined(APP_VERBOSE_USAGE)
"Enables interrupt catching and state dumping. If used, Gassy will,\n\
on receiving SIGINT or SIGHUP, write out the state of the run to a\n\
file whose name is the name of your main program with\n\
\".interrupt.XXXXXX\" appended, where XXXXXX is some six digit number\n\
(the next one available)."
#else
""
#endif
},

    { "maximum_fitness",           "mf", FITNESS_OPT, FALSE, NO_LIMITS(),
	  VADDR(max_possible_fitness),

#if defined(APP_VERBOSE_USAGE)
"Specify, with the next argument, the maximum value of your fitness\n\
function. There will be many occasions when you will not know the\n\
maximum possible fitness value in advance, but if you do, this option\n\
can be used to specify that value. If the program finds an individual\n\
with that fitness (or higher!), it will cut short the run." 
#else
""
#endif
},

    { "mutation_method",          "mm", STRING_OPT,  FALSE, NO_LIMITS(),
	  VADDR(mutation_function_name),

#if defined(APP_VERBOSE_USAGE)
"Specify, by name, the mutation method. There is currently only one\n\
built in mutation methods: simple_mutation.  If you write your own\n\
mutation function you will have to give it a name in your\n\
app_mutation_functions variable and you will ask Gassy to use it with\n\
this option, just like any built in method. To see a full list of the\n\
mutation methods available for any given application, invoke the\n\
application with the -functions option. Mutation method names\n\
may be abbreviated.\n\
DEFAULT VALUE       : simple_mutation" 
#else
"DEFAULT VALUE       : simple_mutation" 
#endif
},

    { "mutation_probability",      "mp", DOUBLE_OPT,  FALSE, LIMITS(0.0, 1.0),
	  VCADDR(mutation_prob),

#if defined(APP_VERBOSE_USAGE)
"Specify, with a 0.0 to 1.0 argument, the per bit mutation probability.\n\
Mutation on constant length character string individuals will be done\n\
automatically by Gassy - using the allele value and frequencies you\n\
can specify.\n\
DEFAULT VALUE       : 0.001" 
#else
"DEFAULT VALUE       : 0.001" 
#endif
},

    { "options",                   "op", FUNC1_OPT,   FALSE, NO_LIMITS(),
       (VOID *)read_opts_from_file,

#if defined(APP_VERBOSE_USAGE)
"Specify, with the next argument, a file containing more options.\n\
Options in files should be specified one per line in the format\n\
\"option-name : option-value\" (there may not be any value if the\n\
option does not take an argument. The option names and abbreviations\n\
are the same as the command line option names. Files of options can\n\
specify other files of options, which is very useful if you are doing\n\
a number of experiments in which many options remain the same - they\n\
can each have an experiment-specific options file that includes a file\n\
of options common to all the experiments.\n\
\n\
Options are processed left to right as they are found on the command\n\
line, and the given value for an option will reset the former value.\n\
This can be used to override options set in a default common option file.\n\
\n\
Boolean options may be given with no argument (and the colon may be\n\
omitted too), in which case their value will be toggled from TRUE to\n\
FALSE, or vice-versa, each time they are encountered. Alternately, they\n\
may be given arguments such as \"true\" or \"false\", or \"yes\" or \"no\",\n\
or \"on\" or \"off\", or even \"1\" or \"0\" - take your pick.\n\
\n\
Blank lines or lines starting with '#' in options files will be ignored,\n\
so you can comment your option files." 
#else
""
#endif
},

    { MAIN_OUTPUT_NAME, MAIN_OUTPUT_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
	  VADDR(output_files[MAIN_OUTPUT]),
#if defined(APP_VERBOSE_USAGE)
"Specify, with the next argument, a file into which output that is\n\
printed by the main program at the end of the run should go.\n\
The file will be appended to if it already exists, or created if\n\
not. The -overwrite option can be used to rewrite existing files."
#else
""
#endif
},

    { "overwrite",                    "ov", BOOLEAN_OPT, FALSE, NO_LIMITS(),
 VADDR(overwrite),

#if defined(APP_VERBOSE_USAGE)
"If TRUE, files given to show_* options for output will have their\n\
contents overwritten. The default is to append.\n\
DEFAULT VALUE      : FALSE"
#else
"DEFAULT VALUE      : FALSE"
#endif
},


    { "population_size",           "p",  INT_OPT,     TRUE,  LLIMIT(1.0),
	  VCADDR(population_size),

#if defined(APP_VERBOSE_USAGE)
"Specify, with the next argument, the population size for the run." 
#else
""
#endif
},

    { "report_interval",           "ri",  INT_OPT,    FALSE,  NO_LIMITS(),
	  VADDR(report_interval),

#if defined(APP_VERBOSE_USAGE)
"The number of generations between the printing of the current generation.\n\
This only takes effect if you are using one of the show_population* options\n\
to have the populations printed.\n\
DEFAULT VALUE      : 1"
#else
"DEFAULT VALUE      : 1"
#endif
},

    { "restore_file",              "re", FUNC1_OPT,  FALSE, NO_LIMITS(),
	  (VOID *)restore_state,

#if defined(APP_VERBOSE_USAGE)
"Specify, with the next argument, a file to restore a run from. The\n\
program will read in the state of the world and start it running\n\
again. If output was previously being redirected to some files,\n\
then the program will attempt to append to those files."
#else
""
#endif
},

    { "runs",           "ru",  INT_OPT,    FALSE,  LLIMIT(1.0),
	  VCADDR(nruns),

#if defined(APP_VERBOSE_USAGE)
"The number of runs the GA should perform. Each will consist of as\n\
many generations you specify with the -generations option. The\n\
population will be re-initialized every generation. This may be from\n\
an initial population file, or randomly generated from the alleles,\n\
or a combination of these two.\n\
DEFAULT VALUE      : 1"
#else
"DEFAULT VALUE      : 1"
#endif
},

    { "seed",                      "r",  LONG_OPT,    FALSE, LLIMIT(0.0),
	  VADDR(seed),

#if defined(APP_VERBOSE_USAGE)
"Specify, with the next argument, a seed for the random number\n\
generator. This can be used to repeat a run or to repeat and extend\n\
a run for a longer time if you specify more generations." 
#else
""
#endif
},

#if defined(SCALING)
    { "scaling_method",          "scm", STRING_OPT,  FALSE, NO_LIMITS(),
	  VADDR(scaling_function_name),

#if defined(APP_VERBOSE_USAGE)
"Specify, by name, the scaling method. There are currently no scaling\n\
methods available. Some are planned for the future.\n\
If you write your own scaling function you will have to\n\
give it a name in your app_scaling_functions variable and you will\n\
ask Gassy to use it with this option, just like any built in method.\n\
Scaling function names may be abbreviated. To see a full list of the\n\
scaling methods available for any given application, invoke the\n\
application with the -functions option.\n\
DEFAULT VALUE       : no_scaling" 
#else
"DEFAULT VALUE       : no_scaling" 
#endif
},
#endif

    { "selection_method",          "sm", STRING_OPT,  FALSE, NO_LIMITS(),
	  VADDR(selection_function_name),


#if defined(APP_VERBOSE_USAGE)
"Specify, by name, the crossover method. There are currently two built\n\
in selection methods: tournament and roulette. If you write your own\n\
selection function you will have to give it a name in your\n\
app_selection variable and you will ask Gassy to use it with this\n\
option, just like any built in method. To see a full list of the\n\
selection methods available for any given application, invoke the\n\
application with the -functions option. Selection function names may\n\
be abbreviated.\n\
DEFAULT VALUE       : tournament" 
#else
"DEFAULT VALUE       : tournament" 
#endif
},

    { "survivor_selection_method", "ssm", STRING_OPT,  FALSE, NO_LIMITS(),
	  VADDR(survivors_function_name),

#if defined(APP_VERBOSE_USAGE)
"Specify, by name, the survivor method. There are currently two built\n\
in survivor methods: random_survivors and best_survivors.  If you\n\
write your own survivor function you will have to give it a name in\n\
your app_survivor_functions variable and you will ask Gassy to use it\n\
with this option, just like any built in method. To see a full list of\n\
the survival selection methods available for any given application,\n\
invoke the application with the -functions option. Survivor selection\n\
function names may be abbreviated.\n\
DEFAULT VALUE       : random_survivors" 
#else
"DEFAULT VALUE       : random_survivors" 
#endif
},

    { SHOW_AVERAGES_NAME, SHOW_AVERAGES_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
	  VADDR(output_files[SHOW_AVERAGES]),

#if defined(APP_VERBOSE_USAGE)
"Have the average population fitness for each generation printed. If\n\
this option is given an argument, it will be taken as the name of an\n\
output file. The file will be appended to if it already exists, or or\n\
created if not. The -overwrite option can be used to rewrite existing\n\
files. If no argument is given, output will go to stdout."
#else
""
#endif
},

    { SHOW_BEST_OF_GENERATION_NAME, SHOW_BEST_OF_GENERATION_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
	  VADDR(output_files[SHOW_BEST_OF_GENERATION]),

#if defined(APP_VERBOSE_USAGE)
"Have the fitness of the best individual of each generation printed.\n\
If this option is given an argument, it will be taken as the name of an\n\
output file. The file will be appended to if it already exists, or or\n\
created if not. The -overwrite option can be used to rewrite existing\n\
files. If no argument is given, output will go to stdout."
#else
""
#endif
},

    { SHOW_BEST_OF_RUN_NAME, SHOW_BEST_OF_RUN_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
	  VADDR(output_files[SHOW_BEST_OF_RUN]),

#if defined(APP_VERBOSE_USAGE)
"Have the fitness of the best individual of each run printed at run end.\n\
If this option is given an argument, it will be taken as the name of an\n\
output file. The file will be appended to if it already exists, or or\n\
created if not. The -overwrite option can be used to rewrite existing\n\
files. If no argument is given, output will go to stdout."
#else
""
#endif
},

    { SHOW_FINAL_NAME, SHOW_FINAL_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
	  VADDR(output_files[SHOW_FINAL]),

#if defined(APP_VERBOSE_USAGE)
"Show the final population. The population will be sorted and\n\
duplicate genome individuals will be reduced to a single line of\n\
output followed by a count of their multiplicity. If this option is\n\
given an argument, it will be taken as the name of an output file. The\n\
file will be appended to if it already exists, or or created if not.\n\
The -overwrite option can be used to rewrite existing files. If no\n\
argument is given, output will go to stdout."
#else
""
#endif
},

    { SHOW_HASHING_NAME, SHOW_HASHING_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
	  VADDR(output_files[SHOW_HASHING]),

#if defined(APP_VERBOSE_USAGE)
"Have statistics on the final contents of the hash table printed once\n\
the entire run has completed. If this option is given an argument it\n\
will be taken as the name of an output file. The file will be appended\n\
to if it already exists, or or created if not. The -overwrite option\n\
can be used to rewrite existing files. If no argument is given, output\n\
will go to stdout."
#else
""
#endif
},

    { SHOW_HASHING_VERBOSE_NAME, SHOW_HASHING_VERBOSE_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
	  VADDR(output_files[SHOW_HASHING_VERBOSE]),

#if defined(APP_VERBOSE_USAGE)
"Have statistics on the final contents of the hash table printed once\n\
the entire run has completed. This option also shows the contents of\n\
every non-empty bucket. This can generate a LOT of out put (thousands\n\
of lines). If this option is given an argument, it will be taken as the\n\
name of an output file. The file will be appended to if it already\n\
exists, or or created if not. The -overwrite option can be used to\n\
rewrite existing files. If no argument is given, output will go to stdout."
#else
""
#endif
},

    { SHOW_INTERMEDIATES_NAME, SHOW_INTERMEDIATES_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
	  VADDR(output_files[SHOW_INTERMEDIATES]),

#if defined(APP_VERBOSE_USAGE)
"Have the program output the new highest fitness so far individual\n\
each time it finds one. If this option is given an argument, it will be\n\
taken as the name of an output file. The file will be appended to if\n\
it already exists, or or created if not. The -overwrite option can be\n\
used to rewrite existing files. If no argument is given, output will go\n\
to stdout."
#else
""
#endif
},

    { SHOW_POPULATIONS_NAME, SHOW_POPULATIONS_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
	  VADDR(output_files[SHOW_POPULATIONS]),

#if defined(APP_VERBOSE_USAGE)
"Print the population at the end of each generation. The population\n\
will not be sorted in any way, for this use -show_populations_sorted\n\
(or -sps). If this option is given an argument, it will be taken as the\n\
name of an output file. The file will be appended to if it already\n\
exists, or or created if not. The -overwrite option can be used to\n\
rewrite existing files. If no argument is given, output will go to stdout."
#else
""
#endif
},

    { SHOW_POPULATIONS_SORTED_BY_G_NAME, SHOW_POPULATIONS_SORTED_BY_G_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
 VADDR(output_files[SHOW_POPULATIONS_SORTED_BY_G]),

#if defined(APP_VERBOSE_USAGE)
"Print the sorted population at the end of each generation. The\n\
population will be sorted by genome. If this option is given an\n\
argument, it will be taken as the name of an output file. The file will\n\
be appended to if it already exists, or or created if not. The\n\
-overwrite option can be used to rewrite existing files. If no\n\
argument is given, output will go to stdout."
#else
""
#endif
},

    { SHOW_POPULATIONS_SORTED_BY_F_NAME, SHOW_POPULATIONS_SORTED_BY_F_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
 VADDR(output_files[SHOW_POPULATIONS_SORTED_BY_F]),

#if defined(APP_VERBOSE_USAGE)
"Print the sorted population at the end of each generation. The\n\
population will be sorted by fitness. If this option is given an\n\
argument, it will be taken as the name of an output file. The file will\n\
be appended to if it already exists, or or created if not. The\n\
-overwrite option can be used to rewrite existing files. If no argument\n\
is given, output will go to stdout."
#else
""
#endif
},

    { "show_start", "start", INT_OPT, FALSE, LLIMIT(1.0),
 VADDR(show_start),

#if defined(APP_VERBOSE_USAGE)
"Choose a starting generation after which functions that print statistics\n\
should begin to be called."
#else
""
#endif
},

    /* THIS IS A SYNONYM FOR show_start. */
    { "show_begin", "begin", INT_OPT, FALSE, LLIMIT(1.0),
 VADDR(show_start),

#if defined(APP_VERBOSE_USAGE)
"Choose a starting generation after which functions that print statistics\n\
should begin to be called. This is a synonym for -show_start."
#else
""
#endif
},

    { "show_stop", "stop", INT_OPT, FALSE, LLIMIT(0.0),
 VADDR(show_stop),

#if defined(APP_VERBOSE_USAGE)
"Choose a generation, after which functions that print statistics\n\
will no longer be called."
#else
""
#endif
},

    /* THIS IS A SYNONYM FOR show_stop. */
    { "show_end", "end", INT_OPT, FALSE, LLIMIT(0.0),
 VADDR(show_stop),

#if defined(APP_VERBOSE_USAGE)
"Choose a generation, after which functions that print statistics\n\
will no longer be called. This is a synonym for -show_stop."
#else
""
#endif
},

    { SHOW_TOTALS_NAME, SHOW_TOTALS_ABBR, OUTPUT_OPT, FALSE, NO_LIMITS(),
 VADDR(output_files[SHOW_TOTALS]),

#if defined(APP_VERBOSE_USAGE)
"Show the total fitness of the population at each generation. If this\n\
option is given an argument, it will be taken as the name of an output\n\
file. The file will be appended to if it already exists, or or created\n\
if not. The -overwrite option can be used to rewrite existing files. If\n\
no argument is given, output will go to stdout."
#else
""
#endif
},

    { "top_ranking",               "tr", INT_OPT,     FALSE, LLIMIT(0.0),
	  VADDR(top_ranking),

#if defined(APP_VERBOSE_USAGE)
"Specify how many of a population to print. The top this many ranks will\n\
be shown. This only takes effect if you are using one of the \n\
show_population* options to have the populations printed. A value of\n\
zero means to show the whole population.\n\
DEFAULT VALUE     : 0"
#else
"DEFAULT VALUE     : 0"
#endif
},

    { "tournament_probability",    "tp", DOUBLE_OPT,  FALSE, LIMITS(0.0, 1.0),
 VCADDR(tournament_prob),

#if defined(APP_VERBOSE_USAGE)
"Specify, with the next argument, the tournament selection probability.\n\
When deciding whether to select the more or less highly fit individual\n\
in a tournament, the more highly fit one will be chosen if a randomly\n\
generated number between 0.0 and 1.0 is less than the value you specify\n\
with this option.\n\
DEFAULT VALUE       : 0.75" 
#else
"DEFAULT VALUE       : 0.75" 
#endif
},

    { "unique",                    "uni", BOOLEAN_OPT, FALSE, NO_LIMITS(),
 VADDR(unique),

#if defined(APP_VERBOSE_USAGE)
"Controls whether population printing will be followed by a count of\n\
the number of unique individuals."
#else
""
#endif
},

    { "usage",                     "us", FUNC0_OPT,   FALSE, NO_LIMITS(),
 (VOID *)usage,

#if defined(APP_VERBOSE_USAGE)
"Print a help message describing all options and their effects." 
#else
""
#endif
},

    { "uniform_probability",       "up", DOUBLE_OPT,  FALSE, LIMITS(0.0, 1.0),
 VCADDR(uniform_prob),

#if defined(APP_VERBOSE_USAGE)
"Specify, with the next argument, the uniform crossover probability.\n\
When uniform crossover is being used, this probability will determine\n\
how likely it is that bits will be swapped in the offspring. The bits\n\
will be exchanged if a randomly generated number between 0.0 and 1.0 is\n\
less than the value you specify with this option.\n\
DEFAULT VALUE       : 0.5" 
#else
"DEFAULT VALUE       : 0.5" 
#endif
},

    { "verbose",                   "v",  BOOLEAN_OPT, FALSE, NO_LIMITS(),
 VADDR(verbose),

#if defined(APP_VERBOSE_USAGE)
"Turn on all of the show_* options, except the show_population* ones." 
#else
""
#endif
},

    { "version",                   "",   FUNC0_OPT,   FALSE, NO_LIMITS(),
 (VOID *)version,

#if defined(APP_VERBOSE_USAGE)
"Show the Gassy version number that was used to make this program." 
#else
""
#endif
},

    { "?",                          "",  FUNC0_OPT,   FALSE, NO_LIMITS(),
 (VOID *)usage,

#if defined(APP_VERBOSE_USAGE)
"Print a help message describing all options and their effects." 
#else
""
#endif
},

    /* END OF OPTIONS MARKER, DO NOT REMOVE! */
    { (STRING) 0,                   "",  0,           FALSE, NO_LIMITS(),        (VOID *) 0, "" }
};

/* Undefine the things in options.h - just in case... */
#undef NO_LIMITS
#undef ULIMIT
#undef LLIMIT
#undef LIMITS