Most of the options to configure (which are to do with building) are similar for every program which uses this script. Here the options that are particular to Gnuastro are discussed. The next topics explain the usage of other configure options which can be applied to any program using the GNU build system (through the configure script).
Only build and install progname along with any other program that is enabled in this fashion. progname is the name of the executable without the ast, for example crop for Crop (with the executable name of astcrop). If this option is called for any of the programs in Gnuastro, any program which is not explicitly enabled will not be built or installed.
Do not build or install the program named progname. This is very similar to the --enable-progname, but will build and install all the other programs except this one.
Enable the binary data-structure operators to work natively on the
respective type of data (u stands for unsigned types, see
Numeric data types). Some are compiled by default, to disable them
(or disable any other type), either run enable-bin-op-TYPE=no, or
run --disable-bin-op-TYPE. The final list of enabled/disabled
types can be inspected in the outputs of
./configure (close to
Binary operators, for example
> (greater than), are some
of the most common operators to the Arithmetic program or the
data_arithmetic function in Gnuastro library. To operate
most efficiently (as fast as possible without using extra memory or CPU
resources), it is best to rely on the native types of the input data. For
example, if you want to add an integer array with a floating point array,
using the native types, means relying the system’s internal type conversion
for each array element, see Invoking Arithmetic. If we don’t use
the native conversion, then the integer array has to be converted to the
same type as the floating point array to do the conversion. This will
consume memory (to copy the integer array into a new float array) and CPU
(integer types need much less processing) resources and ultimately slow
down the running.
There are many binary operators and in order to have them operate natively
on of each of the above types, the compiler has to prepare for all the
different combinations of these types. This can greatly slow down the
compilation35 (when you run
make). For example, with only one type,
finish in less than a minute, but if you enable all types, it can take
roughly half an hour. However, the profits of this one-time investment at
compilation time will be directly felt (more significantly on large
images/datasets) each time you run Gnuastro programs or libraries, because
no internal type conversion will be necessary.
If build time is important for you (mainly developers), disabling shared
libraries and optimizations (as in Building and debugging) is the
first step to take. If you commonly work with very specific data-types, you
can enable them (and disable the default types that you don’t need) with
these configuration options. Since the outputs of comparison operators are
unsigned char (or
uint8_t) type and most astronomical
datasets are in single precision (32-bit) floating point (
the recommended minimum enabled types are
GNU/Linux distribution package managers who compile once, for a large audience of users who just download the compiled programs and executables, are recommended to enable all types to help their users.
Enable native binary arithmetic operation on all types, see the description
above for the various types for a full discussion. As discussed there,
enabling all types can greatly speed up arithmetic operations on any
arbitrary dataset, but will also slow down the building time of
Gnuastro. Recall that in practice this only affects the Arithmetic
program and the
gal_arithmetic library binary operators, nothing
else. This option is strongly recommended when you are building Gnuastro to
be included in a package manager of a GNU/Linux distribution (or other
Enable checks on the GNU Portability Library (Gnulib). Gnulib is used
by Gnuastro to enable users of non-GNU based operating systems (that
don’t use GNU C library or glibc) to compile and use the advanced
features that this library provides. We make extensive use of such
functions. If you give this option to
$ ./configure, when
$ make check, first the functions in Gnulib will be
tested, then the Gnuastro executables. If your operating system does
not support glibc or has an older version of it and you have problems
in the build process (
$ make), you can give this flag to
configure to see if the problem is caused by Gnulib not supporting
your operating system or Gnuastro, see Known issues.
Do not print a guiding message during the GNU Build process of Quick start. By default, after each step, a message is printed guiding the user
what the next command should be. Therefore, after
will suggest running
make, it will suggest
make check and so on. If Gnuastro is configured with this
option, for example
$ ./configure --disable-guide-message
Then these messages will not be printed after any step (like most programs). For people who are not yet fully accustomed to this build system, these guidelines can be very useful and encouraging. However, if you find those messages annoying, use this option.
Note: If some programs are enabled and some are disabled, it is equivalent to simply enabling those that were enabled. Listing the disabled programs is redundant.
Note that the tests of some programs might require other programs to
have been installed and tested. For example MakeProfiles is the first
program to be tested when you run
$ make check, it provides
the inputs to all the other tests. So if you don’t install
MakeProfiles, then the tests for all the other programs will be
skipped or fail. To avoid this, in one run, you can install all the
packages and run the tests but not install. If everything is working
correctly, you can run configure again with only the packages you want
but not run the tests and directly install after building.
It can also greatly increase the file size of the library, from a few hundred kilobytes to a few megabytes.