- Install Lapack On Mac
- Installing Lapack On Mac Os X Mac
- Lapack Install Linux
- Installing Lapack On Mac Os X 10 11 Download Free
- Mac Os X Update
The following sections describe the installation procedures on UNIX/Linux, Mac OS X, and Windows systems.
The configuration script and Makefiles in the
Ipopt
distribution have been created using GNU's autoconf and automake. In general, you can see the list of options and variables that can be set for the configure script by typing configure --help
.Mac OS. X operating system. The following notations are used to refer to Intel MKL directories. The installation directory for the Intel® C Composer XE or Intel® Fortran Composer XE. The main directory where Intel MKL is installed: =/mkl. Installing numpy on Mac OS X Mavericks with alternate LAPACK/BLAS. Ask Question Asked 6 years, 4 months ago. So I'm trying to link an alternate LAPACK/BLAS when installing NumPy, in the hopes that my code can then be parallelized without crashes! I downloaded and compiled an alternative LAPACK/BLAS. Then, following instructions here, I did. BLAS/LAPACK 3.5.0 Install on Mac OS X 10.6.8 by dvc2509 » Tue Jul 22, 2014 8:28 am Hi, I'm brand new when it comes to BLAS and LAPACK and could use some help. If you are on Mac OS X, compile SCS with the following command: make CTRLC = 0 USEOPENMP = 0 USELAPACK = 1 BLASLDFLAGS = '-framework Accelerate' Otherwise (e.g. On Linux ), compile SCS with the following command.
Linux distributions
Many Linux distributions will come with all necessary tools. All you should need to do is check the compiler versions. On a Debian-based distribution, you can obtain all necessary tools with the following command:
Replace apt-get with your relevant package manager, e.g.
dnf
for RedHat-based distributions, pacman
for Arch, etc. The g++ and gfortran compilers may need to be specified respectively as gcc-c++
and gcc-gfortran
with some package managers.Mac OS X
You need either the Xcode Command Line Tools or a community alternative such as Homebrew to install the GNU compilers:
Further, pkg-config is required, which can be installed via Homebrew by
If you have Xcode installed, the Command Line Tools are available under Preferences, Downloads. These items unfortunately do not come with a Fortran compiler, but you can get gfortran from http://gcc.gnu.org/wiki/GFortranBinaries#MacOS. In the past, we have been able to compile
Ipopt
using default Xcode versions of gcc and g++ and a newer version of gfortran from this link, but consistent version numbers may be an issue in future cases.If you intend to use MUMPS or one of the DOWNLOAD_HSL 'HSL linear solvers', then they may profit from an installation of METIS. This can be accomplished via
Windows with MSYS2/MinGW
For Windows, one can compile
Ipopt
under MSYS2/MinGW, which is a light-weight UNIX-like environment for Windows.MSYS2/MinGW can be obtained from https://www.msys2.org/. After installation, a number of additional packages need to be installed:
(I might have forgotten something.) If you also want to use GNU compilers, then install them, too:
When using MinGW, it is convenient to install MinGW's Lapack and METIS as well:
To use MSYS2/MinGW to compile
Ipopt
with native MSVC/Intel compilers, the basic version MSYS2 version without MinGW is sufficient. To use the GNU compilers, MinGW is required.If you want to use the native MSVC or Intel compiler, you need to make sure that environment variables are setup for the compilers. One way is to create a shell script that executes the batch files that are provided by Microsoft and Intel for this purpose before starting MSYS2. For using MSVC, this script may have a form similar to
For using Intel C/C++ and Fortran compilers, the 2nd line may be replaced by something like
You might have to search around a bit. The important thing is that, after your change, you can type
cl
and it finds the Microsoft C++ compiler and, if installed, you can type ifort
and it finds the Intel Fortran compiler.- Note
- The build systems of
Ipopt
by default first looks for GCC and Clang before the Intel and MS compilers. To disable this, specify the flag--enable-msvc
as argument to configure below.
Ipopt
uses a few external packages that are not included in the Ipopt
source code distribution, for example ASL (the AMPL Solver Library if you want to compile the Ipopt
AMPL solver executable), Blas, Lapack.Ipopt
also requires at least one linear solver for sparse symmetric indefinite matrices. There are different possibilities, see below. It is important to keep in mind that usually the largest fraction of computation time in the optimizer is spent for solving the linear system, and that your choice of the linear solver impacts Ipopt
's speed and robustness. It might be worthwhile to try different linear solver to experiment with what is best for your application.Since this third party software is released under different licenses than
Ipopt
, we cannot distribute their code together with the Ipopt
packages and have to ask you to go through the hassle of obtaining it yourself. Keep in mind that it is still your responsibility to ensure that your downloading and usage of the third party components conforms with their licenses.For ASL, HSL, and MUMPS, COIN-OR provides specialized build systems that produce libraries which are easy to use with the build system of
Ipopt
. Some of the specialized build systems also come with a script that makes it easy to download the code using wget
or curl
.ASL (Ampl Solver Library)
Note that you only need to obtain the ASL if you intend to use
Ipopt
from AMPL. It is not required if you want to specify your optimization problem in a programming language (e.g., C++, C, or Fortran).The COIN-OR Tools project ThirdParty-ASL can be used to download the ASL code and build an ASL library that is recognized by Ipopt. To do so, execute
BLAS and LAPACK
Ipopt
's build system tries to find an installation of BLAS and LAPACK in your system. On Ubuntu, such libraries can be made available by installing liblapack-dev. Other Linux distributions typically also offer a way to install Blas and Lapack via its package manager. On Mac OS X, Ipopt
's build system should pick up the Blas and Lapack from the Accelerate framework.- Note
- It is highly recommended that you obtain an efficient implementation of the BLAS and LAPACK library, tailored to your hardware; Section Prerequisites lists a few options. For instance, to have configure pick up a local installation of ATLAS in $HOME/lib, one would use the
--with-lapack
flag when runningconfigure
(see Compiling and Installing Ipopt): The configure script already tries to find Intel MKL libraries on some systems. If that fails, e.g., because the libraries are not available in a standard search path, then also use the--with-lapack
flag to explictly state what flags are necessary to use MKL, e.g.,
HSL (Harwell Subroutines Library)
There are two versions of HSL available:
- HSL Archive: contains outdated codes that are freely available for personal commercial or non-commercial usage. Note that you may not redistribute these codes in either source or binary form without purchasing a licence from the authors. This version includes MA27, MA28, and MC19.
- HSL Full: contains more modern codes that are freely available for academic use only. This version includes the codes from the HSL Archive and additionally MA57, HSL_MA77, HSL_MA86, and HSL_MA97.
Ipopt
supports the HSL Full codes from 2013 and later.
To obtain the HSL code, you can follow the following steps:
- Go to http://hsl.rl.ac.uk/ipopt.
- Choose whether to download either the Archive code or the HSL Full code. To download, select the relevant 'source' link.
- Follow the instructions on the website, read the license, and submit the registration form.
- Wait for an email containing a download link (this should take no more than one working day).
You may either:
- Compile the HSL code via the COIN-OR Tools project ThirdParty-HSL. See the instructions below.
- Compile the HSL code separately either before or after the
Ipopt
code and use the shared library loading mechanism. See the documentation distributed with the HSL package for information on how to do so.
To compile the HSL code via the COIN-OR Tools project ThirdParty-HSL, run
Now unpack the HSL sources archive, move and rename the resulting directory so that it becomes
ThirdParty-HSL/coinhsl
. Then, in ThirdParty-HSL
, configure, build, and install the HSL sources: - Attention
- The build system of Ipopt currently requires that MA27 is part of a HSL library, if a HSL library is provided.
- Note
- Whereas it is essential to have at least one linear solver, the package MC19 could be omitted (with the consequence that you cannot use this method for scaling the linear systems arising inside the
Ipopt
algorithm). By default, MC19 is only used to scale the linear system when using one of the HSL solvers, but it can also be switched on for other linear solvers (which usually have internal scaling mechanisms). Further, also the package MA28 can be omitted, since it is used only in the experimental dependency detector, which is not used by default. - If you are an academic or a student, we recommend you download the HSL Full package as this ensures you have access to the full range of solvers. MA57 can be considerably faster than MA27 on some problems.
- If you have a precompiled library containing the HSL codes, you can specify the directory containing the
CoinHslConfig.h
header file and the linker flags for this library with the flags--with-hsl-cflags
and--with-hsl-lflags
flags, respectively, when runningconfigure
ofIpopt
(see Compiling and Installing Ipopt). - The linear solvers MA57, HSL_MA77, HSL_MA86, HSL_MA97 can make use of the matrix ordering algorithms implemented in METIS. ThirdParty-HSL will look automatically for a METIS installation in your system and should work with both METIS 4 and METIS 5.
MUMPS Linear Solver
You can also use the (public domain) sparse linear solver MUMPS. Please visit the MUMPS home page for more information about the solver. MUMPS is provided as Fortran 90 and C source code. You need to have a Fortran 90 compiler (e.g., the GNU compiler gfortran) to be able to use it.
The COIN-OR Tools project ThirdParty-Mumps can be used to download the MUMPS 4.10.0 code and build a MUMPS library that is recognized by Ipopt. To do so, execute
- Note
- MUMPS will perform better if the matrix ordering algorithms implemented in METIS are available on the system.
- MUMPS uses internally a fake implementation of MPI. If you are using
Ipopt
within an MPI program together with MUMPS, the code will not run. You will have to modify the MUMPS sources so that the MPI symbols inside the MUMPS code are renamed. - Branch mumps5 of project ThirdParty-Mumps can be used to build a a library of MUMPS 5.2.x that is usable with
Ipopt
. However, initial experiments on the CUTEst testset have shown that performance with MUMPS 5.2.x is worse than with Mumps 4.10.0 on average.
To compile
Ipopt
with a precompiled MUMPS library, you need to specify the -I
flag to have the compiler find the directory containing the MUMPS header files with the --with-mumps-cflags
flag of Ipopt
's configure, e.g., and you also need to provide the linker flags for MUMPS with the
--with-mumps-lflags
flag.Pardiso (Parallel Sparse Direct Linear Solver)
If you would like to compile
Ipopt
with Pardiso, you need to obtain either Intel's MKL library or the Pardiso library from http://www.pardiso-project.org for your operating system.From http://www.pardiso-project.org, you can obtain a limited time license of Pardiso for academic or evaluation purposes or buy a non-profit or commercial license. Make sure you read the license agreement before filling out the download form.
To compile
Ipopt
with the linear solver Pardiso from the Pardiso project website, you need to specify the link flags for the library with the --with-pardiso
flag, including required additional libraries (except for Lapack) and flags. For example, if you want to compile Ipopt
with the parallel version of Pardiso (located in $HOME/lib
) on a GNU/Linux system, you should add the flag For best performance on Linux, use Pardiso from the Pardiso project website together with linear algebra routines from Intel MKL (see BLAS and LAPACK).
If you are using the parallel version of Pardiso, you need to specify the number of processors it should run on with the environment variable
OMP_NUM_THREADS
, as described in the Pardiso manual.If you want to compile
Ipopt
with the Pardiso library that is included in Intel MKL, it is sufficient to ensure that MKL is used for the linear algebra routines (Blas/Lapack), see BLAS and LAPACK.WSMP (Watson Sparse Matrix Package)
If you would like to compile
Ipopt
with WSMP, you need to obtain the WSMP library for your operating system. Information about WSMP can be found at http://www.research.ibm.com/projects/wsmp.At this website you can download the library for several operating systems including a trial license key for 90 days that allows you to use WSMP for 'educational, research, and benchmarking purposes by non-profitacademic institutions' or evaluation purposes by commercial organizations; make sure you read the license agreement before using the library. Once you obtained the library and license, please check if the version number of the library matches the one on the WSMP website.
- Note
- The license included in package of the libraries may not work and a working one may need to be downloaded separately. Look out for messages about an invalid WSMP license when testing the Ipopt build.
If a newer version is announced on that website, you can (and probably should) request the current version by sending a message to
[email protected]
. Please include the operating system and other details to describe which particular version of WSMP you need.- Note
- Only the interface to the shared-memory version of WSMP is currently supported.
To compile
Ipopt
with the linear solver WSMP, you need to specify the linker flags for the library with the --with-wsmp
flag, including required additional libraries and flags. For example, if you want to compile Ipopt
with WSMP (located in $HOME/lib
) on an Intel IA32 Linux system, you may use the configure
flag But the actual flags depend on WSMP library and your preference for the Blas/Lapack libraries.
Using the Linear Solver Loader
By default,
Ipopt
will be compiled with a mechanism, the Linear Solver Loader, which can dynamically load shared libraries with MA27, MA57, HSL_MA77, HSL_MA86, HSL_MA97, or the Pardiso linear solver at runtime.This means, if you obtain one of those solvers after you compiled
Ipopt
, you don't need to recompile to use it. Instead, you can just put a shared library called libhsl.so
or libpardiso.so
into the shared library search path, LD_LIBRARY_PATH
. These are the names on most UNIX platforms, including Linux. On Mac OS X, the names are libhsl.dylib
, libpardiso.dylib
, and DYLD_LIBRARY_PATH
. On Windows, the names are libhsl.dll
, libpardiso.dll
, and PATH
.The Pardiso shared library can be downloaded from the Pardiso website. To create a shared library containing the HSL linear solvers, follow the instructions from HSL (Harwell Subroutines Library), but rename the resulting library to
libhsl.so
.If you have problems compiling this feature, you can disable this by specifying
--disable-linear-solver-loader
for the configure
script.Ipopt
is available from the COIN-OR group at GitHub. You can either download the code using git
or simply retrieve a tarball (compressed archive file). While the tarball is an easy method to retrieve the code, using the git system allows users the benefits of the version control system, including easy updates and revision control.Getting the Ipopt code via git
Of course, the git client must be installed on your system if you want to obtain the code this way (the executable is called
git
). Information about git and how to download it can be found at http://git-scm.com.To obtain the
Ipopt
source code via git, change into the directory in which you want to create a subdirectory Ipopt
with the Ipopt
source code. Then follow the steps below:- Download the code from the repository:
- Change into the root directory of the
Ipopt
distribution:
In the following,
$IPOPTDIR
will refer to the directory in which you are right now (output of pwd
).Getting the Ipopt code as a tarball
To use the tarball, follow the steps below:
- Download the desired tarball from http://www.coin-or.org/download/source/Ipopt, it has the form
Ipopt-x.y.z.tgz
, wherex.y.z
is the version number, such as 3.12.0. - Issue the following commands to unpack the archive file:
- Rename the directory you just extracted:
- Change into the root directory of the
Ipopt
distribution:
In the following,
$IPOPTDIR
will refer to the directory in which you are right now (output of pwd
).Ipopt
can be easily compiled and installed with the usual configure, make, make install commands. We follow the procedure that is used for most of the COIN-OR projects, based on the GNU autotools.Below are the basic steps for the
Ipopt
compilation that should work on most systems. For special compilations and for some troubleshooting see Flags to configure before creating an issue or sending a message to the mailing list.- Create a directory where you want to compile
Ipopt
, for exampleand change into this directory- Note
- You can choose any location, including $IPOPTDIR itself, as the location of your compilation. However, on COIN-OR we recommend to keep the source and compiled files separate as this comes in handy when you want to compile the code with different compilers, compiler options, or different operating system that share a common file system. For this to work, the directories with the
Ipopt
source must not have any configuration and compiled code.
- Run the configure script:One might have to give options to the configure script, e.g., in order to choose a non-default compiler, or to tell it where to install Ipopt eventually, see Flags to configure.If the last output line reads
configure: Main configuration of Ipopt successful
then everything worked fine. Otherwise, look at the screen output, have a look at theconfig.log
output file and/or consult Flags to configure.The default configure (without any options) is sufficient for most users that downloaded and installed the source code for the linear solver and other dependencies. If you want to see the configure options, consult Flags to configure. - Build the code:Note: If you are using GNU make, you can also try to speed up the compilation by using the
-jN
flag (e.g.,make -j3
), whereN
is the number of parallel compilation jobs. A good number forN
is the number of available processors plus one. Under some circumstances, this fails, and you might have to re-issue the command, or omit the-j
flag. - If you want, you can run a short test to verify that the compilation was successful. For this, you just enterThis will test if the AMPL solver executable works (if you got the ASL code) and if the included C++, C, Java, and Fortran examples work.
- Note
- The configure script is not able to automatically determine the C++ runtime libraries for the C++ compiler. For certain compilers we enabled default values for this, but those might not exist or be wrong for your compiler. In that case, the C and Fortran example in the test will most probably fail to compile. If you don't want to hook up the compiled
Ipopt
library to some Fortran or C code that you wrote you don't need to worry about this. If you do want to link theIpopt
library with a C or Fortran compiler, you need to find out the C++ runtime libraries (e.g., by running the C++ compiler in verbose mode for a simple example program) and runconfigure
again, and this time specify all C++ runtime libraries with theCXXLIBS
variable (see also Flags to configure).
- Install
Ipopt
:sudo
has been added here asmake install
installs files into/usr/local
, where only system administrators have write permissions. This installs- the
Ipopt
andsIpopt
AMPL solver executables (if ASL source was downloaded) in/usr/local/bin
, - the
Ipopt
andsIpopt
libraries (libipopt.so
,libipopt.a
or similar) in/usr/local/lib
, - pkg-config files for use of the
Ipopt
andsIpopt
libraries (ipopt.pc
,sipopt.pc
) in/usr/local/lib/pkgconfig
. Ipopt
andsIpopt
header files/usr/local/include/coin-or
.
You can change the default installation directory (here/usr/local
) by using the--prefix
switch forconfigure
. If this is a directory that you have write permissions for,sudo
can be omitted formake install
. - the
Flags to configure
In general, you can see the list of options and variables that can be set for the configure script by typing
configure --help
.Below a few particular options are discussed:
- If you want to specify that you want to use particular compilers, you can do so by adding the variables definitions for CXX, CC, and F77 to the
./configure
command line, to specify the C++, C, and Fortran 77 compiler, respectively. For example,In order to set the compiler flags, you should use the variablesCXXFLAGS
,CFLAGS
,FFLAGS
. Note, that theIpopt
code usesdynamic_cast
. Therefore it is necessary that the C++ code is compiled including RTTI (Run-Time Type Information). Some compilers need to be given special flags to do that (e.g.,-qrtti=dyna
for the AIXxlC
compiler). - By default, the
Ipopt
library is compiled as a shared library, on systems where this is supported. If you want to generate a static library, you need to specify the--disable-shared
flag. If you want to compile both shared and static libraries, you should specify the--enable-static
flag. This is no possible on Windows. - It is possible to compile the
Ipopt
library in a debug configuration, by specifying--enable-debug
. This switches the default compiler flags (CFLAGS, CXXFLAGS, FFLAGS) to instruct the compiler to include debug information into object files and disables compiler optimization.Also, you can tellIpopt
to do some additional runtime sanity checks, by specifying the flag--with-ipopt-checklevel=1
.This usually leads to a significant slowdown of the code, but might be helpful when debugging something. - If you want to link the
Ipopt
library with a main program written in C or Fortran, the C and Fortran compiler doing the linking of the executable needs to be told about the C++ runtime libraries. Unfortunately, the current version of autoconf does not provide the automatic detection of those libraries. We have hard-coded some default values for some systems and compilers, but this might not work all the time.If you have problems linking your Fortran or C code with theIpopt
library libipopt.a and the linker complains about missing symbols from C++ (e.g., the standard template library), you should specify the C++ libraries with theCXXLIBS
variable. To find out what those libraries are, it is probably helpful to link a simple C++ program with verbose compiler output.For example, for the Intel compilers on a Linux system, you might need to specify something like - Compilation on an AIX 64bit system sometimes requires some special consideration. We recommend the following configuration (Alternatively, a simpler solution for AIX is to set the environment variable
OBJECT_MODE
to 64.) - Ipopt's Java interface
JIpopt
uses the Java Native Interface (JNI), which is a programming framework that allows Java code running in the Java Virtual Machine (JVM) to call and be called by native applications and libraries written in languages such as C and C++.configure tries to find a Java compiler and the necessary compiler flags to locate the JNI header files automatically. You can influence this automated check by setting the environment variableJAVA_HOME
to the directory that contains your JDK.- Note
- The build procedure currently cannot deal with spaces in the path to the JDK. If you are on Windows and have Java in a path like
C:Program FilesJava
, try settingJAVA_HOME
to the DOS equivalentC:Progra~1Java
(or similar).
You can disable the checks for Java and build of the Java interface by specifying the configure flag--disable-java
. This is also the default ifJAVA_HOME
contains a space or the build of shared libraries has been disabled asJIpopt
needs to be able to load theIpopt
library dynamically at runtime. - sIpopt is build and installed together with Ipopt. If you do not need sIpopt, you can disable it via
--disable-sipopt
.
Configure flags specific to the use of
Ipopt
's dependencies were discussed in the corresponding sections of Download, build, and install dependencies.On sufficiently prepared systems, an alternative way to download, build, and install
Ipopt
with dependencies ASL, HSL, and MUMPS is to use the coinbrew script from https://coin-or.github.io/coinbrew/After obtaining the script, run
The coinbrew script will take care of building and installing the dependencies ASL and Mumps before building
Ipopt
. To use HSL sources, change to the ThirdParty/HSL
directory created by coinbrew fetch
and follow the download instructions (i.e., skip the build step) from HSL (Harwell Subroutines Library). Then proceed with the coinbrew build
step.More details on using coinbrew can be found at the instructions on Getting Started with the COIN-OR Optimization Suite.
The
ipoptr
interface can be build after Ipopt
has been build and installed. In the best case, it is sufficient to execute the following command in R: After installation of the
ipoptr
package, it should be possible to load the package in R and to view the help page: My experiences in installing IPOPT on Mac OS X
by Peter CarbonettoDept. of Computer Science
University of British Columbia
IPOPT is asoftware package for solving nonlinear objectives subject to nonlinearconstraints. It uses primal-dual interior pointmethodology. Importantly, it is open source.
After a great deal of time and trouble, I managed to get in workingon my laptop which is running the Mac OS X operating system.1 In the following, I detail myexperiences in installing the IPOPT package.
Succinctly put, the configure script did not work for IPOPT, so Ihad to install everything from scratch. While this was really quite alabourous process, I didn't know any other way of installing thepackage. On the bright side, I learned a lot about compiling fortranand C++, and linking object code, libraries and executables
1. Installing the Fortran compiler
The first problem I encounter is that I do not have a Fortran 77compiler installed on my machine. I do have the GNU C and C++compilers installed on my computer already (the programs
gcc
and g++
), but the Fortran 77 compiler isalso needed to compile the BLAS, LAPACK and HSL routines. A lot ofpeople are upset that the GNU Fortran compiler g77
wasnot included with the AppleDeveloper Tools because installing it ourselves causes many extraheadaches. But we'll have to make do.There are several ways I can install a Fortran compiler. One is bydownloading GNU Fortran compiler from the High Performance Computingwebpage. Another route is to install
g77
via Fink. Instead, I'm going tofollow the route that gives me the most control: I will download andbuild the entire GNUCompiler Collection (GCC), then put the necessary files in theappropriate places. Even though this route is considerably morecomplicated, it will allow me to ensure that I have the correctversion of the compiler. You see, since I'm running Mac OS X 10.3.9 Ialready have gcc
3.3 installed on my computer in the/usr/bin/
directory. (It is easy to check the version bytyping gcc --version
.) It is important that the compilersI'm using all belong from the same collection otherwise it is verylikely that I will undercover linking errors. I've decided todownload GCC 3.3.6 from my local university FTP mirror.It is crucial that I do not follow the default installationfor GCC, because I may end up overwriting important files. The GCCinstallation instructions advise the same thing. Suppose that I'vechosen to install to the directory . I've done so simply by passingthe option to the . I'm only really interested inthe programs and libraries necessary for compiling and linking Fortrancode. I start by installing the Fortran 77 compiler with thecommand
gcc-install
--prefix=gcc-install
configure
script. After following the correctinstallation steps and waiting a couple hours for the entire packageto be built, I now have a whole bunch of files and subdirectories ingcc-install
In the end, I had installed the following files:
2. Building the BLAS, LAPACK and HSL libraries
Install Lapack On Mac
Now that I have a Fortran 77 compiler installed on my system, Iproceed to build the libraries needed by IPOPT from scratch. First, Idownload the latest BLAS and LAPACK tarballs from the Netlib FTP repository. The BLASpackage just consists of a bunch of Fortran files. I compile each ofthe individual files into object code, starting with the file
caxpy.f
:This creates an object file
caxpy.o
. The rest of thefiles are compiled similarly. If you want to produce a shared library,you will want to include the -fPIC
option. Also, I'venoticed that the -fexceptions
option should not be usedas it causes linking errors down the road. Once I've compiled all theFortran code, I create a static library via the following commands:I create the LAPACK library in precisely the same fashion, with thesame options passed to
g77
. The only difference is thatthe files in the LAPACK tarball are strewn about in varioussubdirectories. In brief, the quickest way to build the LAPACK libraryis to use the existing Makefile and typeat the command prompt with
lapack/SRC
being thecurrent directory. Before we do that, however, we need to modify a fewof the options passed to the Makefile. First, I movelapack/make.inc.example
tolapack/make.inc
. Looking at this file, I see that itspecifies among other things the program used to compile the Fortrancode, which is g77
, exactly as I want it. Near the bottomof this text file, I change the variable LAPACKLIB
toInstalling Lapack On Mac Os X Mac
Now, I can type the
make
command in theSRC
subdirectory and it should proceed to automaticallycreate the library (this takes about ten minutes on my computer).Lastly, I create a library with the HSL subroutines. Afterfollowing the instructions in the IPOPT document for downloading thecode from the HSL Archive, I create the library with the followingcommands:
Now I'm ready to create the IPOPT library.
3. Building the IPOPT library
I will elect not to follow the standard installation instructions(since they didn't work) and instead build the IPOPT library byhand. Basically, I'm going to follow almost the same steps as I didbefore. The trickiest part is that I need to modify the file
Ipopt/inc/config_ipopt.h
manually; the configure scriptdoes this automatically. My file looked likeNext, I compile the C and C++ source files into object files. Forinstance, a create the object file
IpAdaptiveMuUpdate.o
with the commandwhere
ipopt-include-dir
is the directory containingall the .h
and .hpp
header files. And soon. Once I've compiled all the source files, I create the staticlibrary with the commandsNote that in most cases it will not make sense to archiveall the object files into the library. For instance, youshould not include
IpMa57TSolverInterface.o
unless youhave downloaded that solver (I didn't). By the same token, I didn'tinclude the code for interfacing with the AMPL and CUTEr.4. Testing the installation with an example
I can't be positive that we built the libraries correctly withouttrying to run a program that actually uses IPOPT. I try the Hock andSchittkowski nonlinear programming test example no. 71, which isincluded with the IPOPT tarball. After copying all the staticlibraries to
libhome
, I compile and link the codewith the following sequence of commands:Lapack Install Linux
Now have a program which is executed by typing
./hs071
. Note that the order in which I included theobject files and libraries in the above lines is important. Theg2c
library helps us link the Fortran object code to theC++ object code (recall that I placed this library in/usr/lib
).Installing Lapack On Mac Os X 10 11 Download Free
Footnotes
Mac Os X Update
1 More precisely, I'm using MacOS X version 10.3.9 (Panther), and I have a PowerPC G4 processor. Youmay find that the steps I follow apply to your system, even if itisn't the same process or version of the operating system.