#  Main body of the LANCELOT B installation makefile under GALAHAD

#  N. Gould and Ph. L. Toint.
#  This version: 2024-11-23

SHELL = /bin/$(BINSHELL)

ifeq "$(PRECIS)" "single_64"
  DPREC = -DREAL_32 -DINTEGER_64
  HSL_64 = _64
else ifeq "$(PRECIS)" "quadruple_64"
  DPREC = -DREAL_128 -DINTEGER_64
  HSL_64 = _64
else ifeq "$(PRECIS)" "double_64"
  DPREC = -DINTEGER_64
  HSL_64 = _64
else ifeq "$(PRECIS)" "single"
  DPREC = -DREAL_32
  HSL_64 =
else ifeq "$(PRECIS)" "quadruple"
  DPREC = -DREAL_128
  HSL_64 =
else
  DPREC =
  HSL_64 =
endif

ifeq "$(LINEARSOLVER)" "ma57"
 DLINEARSOLVER = -DLANCELOT_USE_MA57
else
 DLINEARSOLVER = -DLANCELOT_USE_SILS
endif

#  compiler flags

FFLAGS    = $(BASIC) $(OPTIMIZATION) $(DEBUG) $(MODULES) $(F90) $(USUAL) \
              $(DPREC) $(DLINEARSOLVER) -I $(GALAHAD)/include
FFLAGSS   = $(BASIC) $(OPTIMIZATION) $(DEBUG) $(MODULES) $(F90) $(SPECIAL) \
              $(DPREC) $(DLINEARSOLVER) -I $(GALAHAD)/include
FFLAGSN   = $(BASIC) $(NOOPTIMIZATION) $(DEBUG) $(MODULES) $(F90) \
              $(DPREC) $(DLINEARSOLVER) -I $(GALAHAD)/include
FFLAGS77  = $(BASIC) $(OPTIMIZATION) $(DEBUG) $(MODULES) $(F77) $(USUAL) \
              $(DPREC) $(DLINEARSOLVER) -I $(GALAHAD)/include
FFLAGS77S = $(BASIC) $(OPTIMIZATION) $(DEBUG) $(MODULES) $(F77) $(SPECIAL) \
              $(DPREC) $(DLINEARSOLVER) -I $(GALAHAD)/include
RUNFFLAGS =          $(OPTIMIZATION) $(DEBUG) $(MODULES)

#  names of random libraries

LG  = $(OBJ)/libgalahad.a
LGS = $(OBJS)/libgalahad.a
LGD = $(OBJD)/libgalahad.a
LGQ = $(OBJQ)/libgalahad.a
LGS64 = $(OBJS64)/libgalahad.a
LGD64 = $(OBJD64)/libgalahad.a
LGQ64 = $(OBJQ64)/libgalahad.a

CULG  = $(OBJ)/libgalahad_cutest.a
CULGS = $(OBJS)/libgalahad_cutest.a
CULGD = $(OBJD)/libgalahad_cutest.a
CULGQ = $(OBJQ)/libgalahad_cutest.a
CULGS64 = $(OBJS64)/libgalahad_cutest.a
CULGD64 = $(OBJD64)/libgalahad_cutest.a
CULGQ64 = $(OBJQ64)/libgalahad_cutest.a

#  Libraries used

ifeq "$(HSL_64)" "_64"
  LIBS = -lgalahad $(HSL) $(METIS64) $(LAPACK) $(BLAS)
else
  LIBS = -lgalahad $(HSL) $(METIS) $(LAPACK) $(BLAS)
endif

#  Archive manipulation strings

ARR = $(AR) $(ARREPFLAGS) $(LG)

CUARR = $(AR) $(ARREPFLAGS) $(CULG)
CURMARFILE = $(GALAHAD)/bin/rmarfile $(AR) $(GREP) $(CULG)

RMARFILE = $(GALAHAD)/bin/rmarfile $(AR) $(GREP) $(LG)
RMOBFILE = $(GALAHAD)/bin/rmobfile $(RM) $(OBJ)

#  compilation agenda

OBJECTSBASICS = extend basics scu band \
         $(LGS)(others_single.o) icfs hsl_lancelot linearsolver sils \
         $(LGS)(cauchy_single.o) $(LGS)(cg_single.o) \
         $(LGS)(hslint_single.o) $(LGS)(asmbl_single.o) \
         $(LGS)(hsprd_single.o)  $(LGS)(initw_single.o) \
         $(LGS)(mdchl_single.o)  $(LGS)(precn_single.o) \
         $(LGS)(frntl_single.o)  $(LGS)(strutr_single.o) \
         $(LGS)(lancelot_types_single.o)
OBJECTSS = $(OBJECTSBASICS) $(LGS)(lancelot_single.o) \
         $(LGS)(lancelot_simple_single.o)
OBJECTSSTEERINGS = $(OBJECTSBASICS) $(LGS)(lancelot_steering_single.o)
OBJECTSFILTRANES = extend band
OBJECTSPSLSS = $(OBJECTSFILTRANES) ma61 $(LGS)(hslint_single.o) \
         $(LGS)(mdchl_single.o)
USEOBJECTSS = $(OBJECTSS) $(LGS)(scaln_single.o) $(LGS)(drchg_single.o) \
         $(LGS)(drche_single.o) rand copyright \
         $(CULGS)(uselancelot_single.o)
USEOBJECTSSTEERINGS = $(OBJECTSSTEERINGS) $(LGS)(scaln_single.o) \
          $(LGS)(drchg_single.o) $(LGS)(drche_single.o) rand \
          copyright $(CULGS)(uselancelot_steering_single.o)

OBJECTSBASICD = extend basics scu band \
          $(LGD)(others_double.o) icfs hsl_lancelot linearsolver sils \
          $(LGD)(cauchy_double.o) $(LGD)(cg_double.o) \
          $(LGD)(hslint_double.o) $(LGD)(asmbl_double.o) \
          $(LGD)(hsprd_double.o)  $(LGD)(initw_double.o) \
          $(LGD)(mdchl_double.o)  $(LGD)(precn_double.o) \
          $(LGD)(frntl_double.o)  $(LGD)(strutr_double.o) \
          $(LGD)(lancelot_types_double.o)
OBJECTSD = $(OBJECTSBASICD) $(LGD)(lancelot_double.o) \
           $(LGD)(lancelot_simple_double.o)
OBJECTSSTEERINGD = $(OBJECTSBASICD) $(LGD)(lancelot_steering_double.o)
OBJECTSFILTRANED = extend band
OBJECTSPSLSD = $(OBJECTSFILTRANED) ma61 $(LGD)(hslint_double.o) \
           $(LGD)(mdchl_double.o)
USEOBJECTSD = $(OBJECTSD) $(LGD)(scaln_double.o) $(LGD)(drchg_double.o) \
           $(LGD)(drche_double.o) rand copyright \
           $(CULGD)(uselancelot_double.o)
USEOBJECTSSTEERINGD = $(OBJECTSSTEERINGD) $(LGD)(scaln_double.o) \
           $(LGD)(drchg_double.o) $(LGD)(drche_double.o) rand \
           copyright $(CULGD)(uselancelot_steering_double.o)

OBJECTSBASICQ = extend basics scu band \
          $(LGQ)(others_quadruple.o) icfs hsl_lancelot linearsolver sils \
          $(LGQ)(cauchy_quadruple.o) $(LGQ)(cg_quadruple.o) \
          $(LGQ)(hslint_quadruple.o) $(LGQ)(asmbl_quadruple.o) \
          $(LGQ)(hsprd_quadruple.o)  $(LGQ)(initw_quadruple.o) \
          $(LGQ)(mdchl_quadruple.o)  $(LGQ)(precn_quadruple.o) \
          $(LGQ)(frntl_quadruple.o)  $(LGQ)(strutr_quadruple.o) \
          $(LGQ)(lancelot_types_quadruple.o)
OBJECTSQ = $(OBJECTSBASICQ) $(LGQ)(lancelot_quadruple.o) \
           $(LGQ)(lancelot_simple_quadruple.o)
OBJECTSSTEERINGQ = $(OBJECTSBASIQD) $(LGQ)(lancelot_steering_quadruple.o)
OBJECTSFILTRANEQ = extend band
OBJECTSPSLSQ = $(OBJECTSFILTRANEQ) ma61 $(LGQ)(hslint_quadruple.o) \
           $(LGQ)(mdchl_quadruple.o)
USEOBJECTSQ = $(OBJECTSQ) $(LGQ)(scaln_quadruple.o) $(LGQ)(drchg_quadruple.o) \
           $(LGQ)(drche_quadruple.o) rand copyright \
           $(CULGQ)(uselancelot_quadruple.o)
USEOBJECTSSTEERINGQ = $(OBJECTSSTEERINGQ) $(LGQ)(scaln_quadruple.o) \
           $(LGQ)(drchg_quadruple.o) $(LGQ)(drche_quadruple.o) rand \
           copyright $(CULGQ)(uselancelot_steering_quadruple.o)

OBJECTSBASICS64 = extend basics scu band \
         $(LGS64)(others_single_64.o) icfs hsl_lancelot linearsolver sils \
         $(LGS64)(cauchy_single_64.o) $(LGS64)(cg_single_64.o) \
         $(LGS64)(hslint_single_64.o) $(LGS64)(asmbl_single_64.o) \
         $(LGS64)(hsprd_single_64.o)  $(LGS64)(initw_single_64.o) \
         $(LGS64)(mdchl_single_64.o)  $(LGS64)(precn_single_64.o) \
         $(LGS64)(frntl_single_64.o)  $(LGS64)(strutr_single_64.o) \
         $(LGS64)(lancelot_types_single_64.o)
OBJECTSS64 = $(OBJECTSBASICS64) $(LGS64)(lancelot_single_64.o) \
         $(LGS64)(lancelot_simple_single_64.o)
OBJECTSSTEERINGS64 = $(OBJECTSBASICS64) $(LGS64)(lancelot_steering_single_64.o)
OBJECTSFILTRANES64 = extend band
OBJECTSPSLSS64 = $(OBJECTSFILTRANES64) ma61 $(LGS64)(hslint_single_64.o) \
         $(LGS64)(mdchl_single_64.o)
USEOBJECTSS64 = $(OBJECTSS64) $(LGS64)(scaln_single_64.o) \
         $(LGS64)(drchg_single_64.o) $(LGS64)(drche_single_64.o) \
         rand copyright $(CULGS64)(uselancelot_single_64.o)
USEOBJECTSSTEERINGS64 = $(OBJECTSSTEERINGS64) $(LGS64)(scaln_single_64.o) \
          $(LGS64)(drchg_single_64.o) $(LGS64)(drche_single_64.o) rand \
          copyright $(CULGS64)(uselancelot_steering_single_64.o)

OBJECTSBASICD64 = extend basics scu band \
          $(LGD64)(others_double_64.o) icfs hsl_lancelot linearsolver sils \
          $(LGD64)(cauchy_double_64.o) $(LGD64)(cg_double_64.o) \
          $(LGD64)(hslint_double_64.o) $(LGD64)(asmbl_double_64.o) \
          $(LGD64)(hsprd_double_64.o)  $(LGD64)(initw_double_64.o) \
          $(LGD64)(mdchl_double_64.o)  $(LGD64)(precn_double_64.o) \
          $(LGD64)(frntl_double_64.o)  $(LGD64)(strutr_double_64.o) \
          $(LGD64)(lancelot_types_double_64.o)
OBJECTSD64 = $(OBJECTSBASICD64) $(LGD64)(lancelot_double_64.o) \
           $(LGD64)(lancelot_simple_double_64.o)
OBJECTSSTEERINGD64 = $(OBJECTSBASICD64) $(LGD64)(lancelot_steering_double_64.o)
OBJECTSFILTRANED64 = extend band
OBJECTSPSLSD64 = $(OBJECTSFILTRANED64) ma61 $(LGD64)(hslint_double_64.o) \
           $(LGD64)(mdchl_double_64.o)
USEOBJECTSD64 = $(OBJECTSD64) $(LGD64)(scaln_double_64.o) \
           $(LGD64)(drchg_double_64.o) $(LGD64)(drche_double_64.o) \
           rand copyright $(CULGD64)(uselancelot_double_64.o)
USEOBJECTSSTEERINGD64 = $(OBJECTSSTEERINGD64) $(LGD64)(scaln_double_64.o) \
           $(LGD64)(drchg_double_64.o) $(LGD64)(drche_double_64.o) rand \
           copyright $(CULGD64)(uselancelot_steering_double_64.o)

OBJECTSBASICQ64 = extend basics scu band \
          $(LGQ64)(others_quadruple_64.o) icfs hsl_lancelot linearsolver sils \
          $(LGQ64)(cauchy_quadruple_64.o) $(LGQ64)(cg_quadruple_64.o) \
          $(LGQ64)(hslint_quadruple_64.o) $(LGQ64)(asmbl_quadruple_64.o) \
          $(LGQ64)(hsprd_quadruple_64.o)  $(LGQ64)(initw_quadruple_64.o) \
          $(LGQ64)(mdchl_quadruple_64.o)  $(LGQ64)(precn_quadruple_64.o) \
          $(LGQ64)(frntl_quadruple_64.o)  $(LGQ64)(strutr_quadruple_64.o) \
          $(LGQ64)(lancelot_types_quadruple_64.o)
OBJECTSQ64 = $(OBJECTSBASICQ64) $(LGQ64)(lancelot_quadruple_64.o) \
           $(LGQ64)(lancelot_simple_quadruple_64.o)
OBJECTSSTEERINGQ64 = $(OBJECTSBASICQ64) \
                     $(LGQ64)(lancelot_steering_quadruple_64.o)
OBJECTSFILTRANEQ64 = extend band
OBJECTSPSLSQ64 = $(OBJECTSFILTRANEQ64) ma61 $(LGQ64)(hslint_quadruple_64.o) \
           $(LGQ64)(mdchl_quadruple_64.o)
USEOBJECTSQ64 = $(OBJECTSQ64) $(LGQ64)(scaln_quadruple_64.o) \
           $(LGQ64)(drchg_quadruple_64.o) $(LGQ64)(drche_quadruple_64.o) \
           rand copyright $(CULGQ64)(uselancelot_quadruple_64.o)
USEOBJECTSSTEERINGQ64 = $(OBJECTSSTEERINGQ64) $(LGQ64)(scaln_quadruple_64.o) \
           $(LGQ64)(drchg_quadruple_64.o) $(LGQ64)(drche_quadruple_64.o) rand \
           copyright $(CULGQ64)(uselancelot_steering_quadruple_64.o)

SUCC = precision version) compiled successfully
SUCC_SIF = precision version) for SIF compiled successfully

#  valgrind options if needed

VALGRIND = -v --tool=memcheck --leak-check=yes --show-reachable=yes \
#VALGRIND = --tool=memcheck --leak-check=full --show-reachable=yes \
--track-origins=yes

#  main compilations and runs

all: lancelotb_sif

lancelotb_sif: lancelotb_sif_$(PRECIS)
	@printf ' %-21s\n' "GALAHAD: LANCELOT B ($(PRECIS) $(SUCC_SIF)"
lancelotb_sif_single: $(USEOBJECTSS) $(OBJS)/runlancelot_sif_single.o
	$(RANLIB) $(LGS)
lancelotb_sif_double: $(USEOBJECTSD) $(OBJD)/runlancelot_sif_double.o
	$(RANLIB) $(LGD)
lancelotb_sif_quadruple: $(USEOBJECTSQ) $(OBJQ)/runlancelot_sif_quadruple.o
	$(RANLIB) $(LGQ)
lancelotb_sif_single_64: $(USEOBJECTSS64) $(OBJS64)/runlancelot_sif_single_64.o
	$(RANLIB) $(LGS64)
lancelotb_sif_double_64: $(USEOBJECTSD64) $(OBJD64)/runlancelot_sif_double_64.o
	$(RANLIB) $(LGD64)
lancelotb_sif_quadruple_64: $(USEOBJECTSQ64) \
                            $(OBJQ64)/runlancelot_sif_quadruple_64.o
	$(RANLIB) $(LGQ64)

lancelotb_silent: lancelotb_silent_$(PRECIS)
lancelotb_silent_single: $(OBJECTSS)
lancelotb_silent_double: $(OBJECTSD)
lancelotb_silent_quadruple: $(OBJECTSQ)
lancelotb_silent_single_64: $(OBJECTSS64)
lancelotb_silent_double_64: $(OBJECTSD64)
lancelotb_silent_quadruple_64: $(OBJECTSQ64)

lancelotb: lancelotb_$(PRECIS)
	@printf ' %-21s\n' "GALAHAD: LANCELOT B ($(PRECIS) $(SUCC)"
lancelotb_single: $(OBJECTSS)
	$(RANLIB) $(LGS)
lancelotb_double: $(OBJECTSD)
	$(RANLIB) $(LGD)
lancelotb_quadruple: $(OBJECTSQ)
	$(RANLIB) $(LGQ)
lancelotb_single_64: $(OBJECTSS64)
	$(RANLIB) $(LGS64)
lancelotb_double_64: $(OBJECTSD64)
	$(RANLIB) $(LGD64)
lancelotb_quadruple_64: $(OBJECTSQ64)
	$(RANLIB) $(LGQ64)

use_lancelotb_silent: use_lancelotb_$(PRECIS)
use_lancelotb: use_lancelotb_$(PRECIS)
	@printf ' %-21s\n' "GALAHAD: LANCELOT B ($(PRECIS) $(SUCC)"
use_lancelotb_single: $(USEOBJECTSS)
	$(RANLIB) $(LGS)
use_lancelotb_double: $(USEOBJECTSD)
	$(RANLIB) $(LGD)
use_lancelotb_quadruple: $(USEOBJECTSQ)
	$(RANLIB) $(LGQ)
use_lancelotb_single_64: $(USEOBJECTSS64)
	$(RANLIB) $(LGS64)
use_lancelotb_double_64: $(USEOBJECTSD64)
	$(RANLIB) $(LGD64)
use_lancelotb_quadruple_64: $(USEOBJECTSQ64)
	$(RANLIB) $(LGQ64)

all_steering: lancelotb_steering_sif
lancelotb_steering_sif: lancelotb_steering_sif_$(PRECIS)
	@printf ' %-21s\n' "GALAHAD: LANCELOT B STEERING ($(PRECIS) $(SUCC_SIF)"
lancelotb_steering_sif_single: $(USEOBJECTSSTEERINGS) \
           $(OBJS)/runlancelot_steering_sif_single.o
	$(RANLIB) $(LGS)
lancelotb_steering_sif_double: $(USEOBJECTSSTEERINGD) \
           $(OBJD)/runlancelot_steering_sif_double.o
	$(RANLIB) $(LGD)
lancelotb_steering_sif_quadruple: $(USEOBJECTSSTEERINGQ) \
           $(OBJQ)/runlancelot_steering_sif_quadruple.o
	$(RANLIB) $(LGQ)
lancelotb_steering_sif_single_64: $(USEOBJECTSSTEERINGS64) \
           $(OBJS64)/runlancelot_steering_sif_single_64.o
	$(RANLIB) $(LGS64)
lancelotb_steering_sif_double_64: $(USEOBJECTSSTEERINGD) \
           $(OBJD64)/runlancelot_steering_sif_double_64.o
	$(RANLIB) $(LGD64)
lancelotb_steering_sif_quadruple_64: $(USEOBJECTSSTEERINGQ) \
           $(OBJQ64)/runlancelot_steering_sif_quadruple_64.o
	$(RANLIB) $(LGQ64)

lancelotb_steering_silent: lancelotb_steering_silent_$(PRECIS)
lancelotb_steering_silent_single: $(OBJECTSS)
lancelotb_steering_silent_double: $(OBJECTSD)
lancelotb_steering_silent_quadruple: $(OBJECTSQ)
lancelotb_steering_silent_single_64: $(OBJECTSS64)
lancelotb_steering_silent_double_64: $(OBJECTSD64)
lancelotb_steering_silent_quadruple_64: $(OBJECTSQ64)

lancelotb_steering: lancelotb_steering_$(PRECIS)
	@printf ' %-21s\n' "GALAHAD: LANCELOT B ($(PRECIS) $(SUCC)"
lancelotb_steering_single: $(OBJECTSS)
	$(RANLIB) $(LGS)
lancelotb_steering_double: $(OBJECTSD)
	$(RANLIB) $(LGD)
lancelotb_steering_quadruple: $(OBJECTSQ)
	$(RANLIB) $(LGQ)
lancelotb_steering_single_64: $(OBJECTSS64)
	$(RANLIB) $(LGS64)
lancelotb_steering_double_64: $(OBJECTSD64)
	$(RANLIB) $(LGD64)
lancelotb_steering_quadruple_64: $(OBJECTSQ64)
	$(RANLIB) $(LGQ64)

use_lancelotb_steering_silent: use_lancelotb_steering_$(PRECIS)
use_lancelotb_steering: use_lancelotb_steering_$(PRECIS)
	@printf ' %-21s\n' "GALAHAD: LANCELOT B ($(PRECIS) $(SUCC)"
use_lancelotb_steering_single: $(USEOBJECTSS)
	$(RANLIB) $(LGS)
use_lancelotb_steering_double: $(USEOBJECTSD)
	$(RANLIB) $(LGD)
use_lancelotb_steering_quadruple: $(USEOBJECTSQ)
	$(RANLIB) $(LGQ)
use_lancelotb_steering_single_64: $(USEOBJECTSS64)
	$(RANLIB) $(LGS64)
use_lancelotb_steering_double_64: $(USEOBJECTSD64)
	$(RANLIB) $(LGD64)
use_lancelotb_steering_quadruple_64: $(USEOBJECTSQ64)
	$(RANLIB) $(LGQ64)

lancelotb_psls_silent: lancelotb_silent_psls_$(PRECIS)
lancelotb_silent_psls_single: $(OBJECTSPSLSS)
lancelotb_silent_psls_double: $(OBJECTSPSLSD)
lancelotb_silent_psls_quadruple: $(OBJECTSPSLSQ)
lancelotb_silent_psls_single_64: $(OBJECTSPSLSS64)
lancelotb_silent_psls_double_64: $(OBJECTSPSLSD64)
lancelotb_silent_psls_quadruple_64: $(OBJECTSPSLSQ64)

lancelotb_psls: lancelotb_psls_$(PRECIS)
	@printf ' %-21s\n' "GALAHAD: LANCELOT B ($(PRECIS) $(SUCC)"
lancelotb_psls_single: $(OBJECTSPSLSS)
	$(RANLIB) $(LGS)
lancelotb_psls_double: $(OBJECTSPSLSD)
	$(RANLIB) $(LGD)
lancelotb_psls_quadruple: $(OBJECTSPSLSQ)
	$(RANLIB) $(LGQ)
lancelotb_psls_single_64: $(OBJECTSPSLSS64)
	$(RANLIB) $(LGS64)
lancelotb_psls_double_64: $(OBJECTSPSLSD64)
	$(RANLIB) $(LGD64)
lancelotb_psls_quadruple_64: $(OBJECTSPSLSQ64)
	$(RANLIB) $(LGQ64)

lancelotb_filtrane_silent: lancelotb_silent_filtrane_$(PRECIS)
lancelotb_silent_filtrane_single: $(OBJECTSFILTRANES)
lancelotb_silent_filtrane_double: $(OBJECTSFILTRANED)
lancelotb_silent_filtrane_quadruple: $(OBJECTSFILTRANEQ)
lancelotb_silent_filtrane_single_64: $(OBJECTSFILTRANES64)
lancelotb_silent_filtrane_double_64: $(OBJECTSFILTRANED64)
lancelotb_silent_filtrane_quadruple_64: $(OBJECTSFILTRANEQ64)

lancelotb_filtrane: lancelotb_filtrane_$(PRECIS)
	@printf ' %-21s\n' "GALAHAD: LANCELOT B ($(PRECIS) $(SUCC)"
lancelotb_filtrane_single: $(OBJECTSFILTRANES)
	$(RANLIB) $(LGS)
lancelotb_filtrane_double: $(OBJECTSFILTRANED)
	$(RANLIB) $(LGD)
lancelotb_filtrane_quadruple: $(OBJECTSFILTRANEQ)
	$(RANLIB) $(LGQ)
lancelotb_filtrane_single_64: $(OBJECTSFILTRANES64)
	$(RANLIB) $(LGS64)
lancelotb_filtrane_double_64: $(OBJECTSFILTRANED64)
	$(RANLIB) $(LGD64)
lancelotb_filtrane_quadruple_64: $(OBJECTSFILTRANEQ64)
	$(RANLIB) $(LGQ64)

tests: test test_cutest

tests_all: lancelotss lancelotst lancelotds lancelotdt
tests_all_64: lancelotss_64 lancelotst_64 lancelotds_64 lancelotdt_64
tests_steering: lancelot_steeringss lancelot_steeringst \
                lancelot_steeringds lancelot_steeringdt
tests_steering_64: lancelot_steeringss_64 lancelot_steeringst_64 \
                   lancelot_steeringds_64 lancelot_steeringdt_64
tests_simple_64: lancelot_simpless_64 lancelot_simplest_64 \
                 lancelot_simpleds_64 lancelot_simpledt_64

test: test_$(PRECIS)
test_single: lancelotst
	echo " Tests for LANCELOT B complete"
test_double: lancelotdt
	echo " Tests for LANCELOT B complete"
test_quadruple: lancelotqt
	echo " Tests for LANCELOT B complete"
test_single_64: lancelotst_64
	echo " Tests for LANCELOT B complete"
test_double_64: lancelotdt_64
	echo " Tests for LANCELOT B complete"
test_quadruple_64: lancelotqt_64
	echo " Tests for LANCELOT B complete"

test_sif: test_cutest
test_cutest: test_cutest_$(PRECIS)
test_cutest_single: $(USEOBJECTSS) $(OBJS)/runlancelot_sif_single.o
	echo ""
	echo " Testing SIF interface to LANCELOT B"
	cd $(GALAHAD)/examples ; sdgal $(VERSION) lancelot -s ALLINITC
	echo ""
	echo " Tests for LANCELOT B complete"
test_cutest_double: $(USEOBJECTSD) $(OBJD)/runlancelot_sif_double.o
	echo ""
	echo " Testing SIF interface to LANCELOT B"
	cd $(GALAHAD)/examples ; sdgal $(VERSION) lancelot ALLINITC
	echo ""
	echo " Tests for LANCELOT B complete"
test_cutest_quadruple: $(USEOBJECTSQ) $(OBJQ)/runlancelot_sif_quadruple.o
	echo ""
	echo " Testing SIF interface to LANCELOT B"
	cd $(GALAHAD)/examples ; sdgal $(VERSION) lancelot -q ALLINITC
	echo ""
	echo " Tests for LANCELOT B complete"
test_cutest_single_64: $(USEOBJECTSS64) $(OBJS64)/runlancelot_sif_single_64.o
	echo ""
	echo " Testing SIF interface to LANCELOT B"
	cd $(GALAHAD)/examples ; sdgal $(VERSION) lancelot -s ALLINITC
	echo ""
	echo " Tests for LANCELOT B complete"
test_cutest_double_64: $(USEOBJECTSD64) $(OBJD64)/runlancelot_sif_double_64.o
	echo ""
	echo " Testing SIF interface to LANCELOT B"
	cd $(GALAHAD)/examples ; sdgal $(VERSION) lancelot ALLINITC
	echo ""
	echo " Tests for LANCELOT B complete"
test_cutest_quadruple_64: $(USEOBJECTSQ64) \
                          $(OBJQ64)/runlancelot_sif_quadruple_64.o
	echo ""
	echo " Testing SIF interface to LANCELOT B"
	cd $(GALAHAD)/examples ; sdgal $(VERSION) lancelot -q ALLINITC
	echo ""
	echo " Tests for LANCELOT B complete"

test_full: test_full_$(PRECIS)
test_full_single: lancelotst
	echo ""
	echo " Tests for LANCELOT B complete"
test_full_double: lancelotdt
	echo ""
	echo " Tests for LANCELOT B complete"
test_full_quadruple: lancelotqt
	echo ""
	echo " Tests for LANCELOT B complete"
test_full_single_64: lancelotst_64
	echo ""
	echo " Tests for LANCELOT B complete"
test_full_double_64: lancelotdt_64
	echo ""
	echo " Tests for LANCELOT B complete"
test_full_quadruple_64: lancelotqt_64
	echo ""
	echo " Tests for LANCELOT B complete"

test_spec: test_spec_$(PRECIS)
test_spec_single: lancelotss
	echo ""
	echo " Tests for LANCELOT B complete"
test_spec_double: lancelotds
	echo ""
	echo " Tests for LANCELOT B complete"
test_spec_quadruple: lancelotqs
	echo ""
	echo " Tests for LANCELOT B complete"
test_spec_single_64: lancelotss_64
	echo ""
	echo " Tests for LANCELOT B complete"
test_spec_double_64: lancelotds_64
	echo ""
	echo " Tests for LANCELOT B complete"
test_spec_quadruple_64: lancelotqs_64
	echo ""
	echo " Tests for LANCELOT B complete"

lancelotss: $(OBJECTSS) $(OBJS)/lancelots_single.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
            $(OBJS)/lancelots_single.o -L$(OBJS) $(LIBS)
	- ./run_lancelot > lancelotss.output 2>&1
	cat lancelotss.output
	rm ./run_lancelot

lancelotst: $(OBJECTSS) $(OBJS)/lancelott_single.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
           $(OBJS)/lancelott_single.o -L$(OBJS) $(LIBS)
	- ./run_lancelot > lancelotst.output 2>&1
	cat lancelotst.output
	rm ./run_lancelot

lancelot_steeringss: $(OBJECTSSTEERINGS) $(OBJS)/lancelot_steerings.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
            $(OBJS)/lancelot_steerings.o -L$(OBJS) $(LIBS)
	- ./run_lancelot_steering > lancelot_steeringss.output 2>&1
	cat lancelot_steeringss.output
	rm ./run_lancelot_steering

lancelot_steeringst: $(OBJECTSSTEERINGS) $(OBJS)/lancelot_steeringt_single.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
          $(OBJS)/lancelot_steeringt_single.o -L$(OBJS) $(LIBS)
	- ./run_lancelot_steering > lancelot_steeringst.output 2>&1
	cat lancelot_steeringst.output
	rm ./run_lancelot_steering

lancelot_simpless: $(OBJECTSS) $(OBJS)/lancelot_simples.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_simple \
           $(OBJS)/lancelot_simples.o -L$(OBJS) $(LIBS)
	- ./run_lancelot_simple > lancelot_simpless.output 2>&1
	cat lancelot_simpless.output
	rm ./run_lancelot_simple

lancelot_simplest: $(OBJECTSS) $(OBJS)/lancelot_simplet_single.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_simple \
           $(OBJS)/lancelot_simplet_single.o -L$(OBJS) $(LIBS)
	- ./run_lancelot_simple > lancelot_simplest.output 2>&1
	cat lancelot_simplest.output
	rm ./run_lancelot_simple

lancelotds: $(OBJECTSD) $(OBJD)/lancelots_double.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
            $(OBJD)/lancelots_double.o -L$(OBJD) $(LIBS)
	- ./run_lancelot > lancelotds.output 2>&1
	cat lancelotds.output
	rm ./run_lancelot

lancelotdt: $(OBJECTSD) $(OBJD)/lancelott_double.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
           $(OBJD)/lancelott_double.o -L$(OBJD) $(LIBS)
	- ./run_lancelot > lancelotdt.output 2>&1
	cat lancelotdt.output
	rm ./run_lancelot

lancelotdt_valgrind: $(OBJECTSD) $(OBJD)/lancelott_double.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
            $(OBJD)/lancelott_double.o -L$(OBJD) $(LIBS)
	- valgrind $(VALGRIND) ./run_lancelot > \
           lancelotdt_valgrind.output 2>&1
	cat lancelotdt_valgrind.output
	rm ./run_lancelot

lancelot_steeringds: $(OBJECTSSTEERINGD) $(OBJD)/lancelot_steerings.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
          $(OBJD)/lancelot_steerings.o -L$(OBJD) $(LIBS)
	- ./run_lancelot_steering > lancelot_steeringds.output 2>&1
	cat lancelot_steeringds.output
	rm ./run_lancelot_steering

lancelot_steeringdt: $(OBJECTSSTEERINGD) $(OBJD)/lancelot_steeringt_double.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
          $(OBJD)/lancelot_steeringt_double.o -L$(OBJD) $(LIBS)
	- ./run_lancelot_steering > lancelot_steeringdt.output 2>&1
	cat lancelot_steeringdt.output
	rm ./run_lancelot_steering

lancelot_steeringdt_valgrind: $(OBJECTSSTEERINGD) \
          $(OBJD)/lancelot_steeringt_double.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
          $(OBJD)/lancelot_steeringt_double.o -L$(OBJD) $(LIBS)
	- valgrind $(VALGRIND) run_lancelot_steering \
           > lancelot_steeringdt_valgrind.output 2>&1
	cat lancelot_steeringdt_valgrind.output
	rm ./run_lancelot_steering

lancelot_simpleds: $(OBJECTSD) $(OBJD)/lancelot_simples.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_simple \
           $(OBJD)/lancelot_simples.o -L$(OBJD) $(LIBS)
	- ./run_lancelot_simple > lancelot_simpleds.output 2>&1
	cat lancelot_simpleds.output
	rm ./run_lancelot_simple

lancelot_simpledt: $(OBJECTSD) $(OBJD)/lancelot_simplet_double.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_simple \
            $(OBJD)/lancelot_simplet_double.o -L$(OBJD) $(LIBS)
	- ./run_lancelot_simple > lancelot_simpledt.output 2>&1
	cat lancelot_simpledt.output
	rm ./run_lancelot_simple

lancelotqs: $(OBJECTSq) $(OBJQ)/lancelots_quadruple.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
            $(OBJQ)/lancelots_quadruple.o -L$(OBJQ) $(LIBS)
	- ./run_lancelot > lancelotqs.output 2>&1
	cat lancelotqs.output
	rm ./run_lancelot

lancelotqt: $(OBJECTSq) $(OBJQ)/lancelott_quadruple.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
           $(OBJQ)/lancelott_quadruple.o -L$(OBJQ) $(LIBS)
	- ./run_lancelot > lancelotqt.output 2>&1
	cat lancelotqt.output
	rm ./run_lancelot

lancelotqt_valgrind: $(OBJECTSq) $(OBJQ)/lancelott_quadruple.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
            $(OBJQ)/lancelott_quadruple.o -L$(OBJQ) $(LIBS)
	- valgrind $(VALGRIND) ./run_lancelot > \
           lancelotqt_valgrind.output 2>&1
	cat lancelotqt_valgrind.output
	rm ./run_lancelot

lancelot_steeringqs: $(OBJECTSSTEERINGq) $(OBJQ)/lancelot_steerings.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
          $(OBJQ)/lancelot_steerings.o -L$(OBJQ) $(LIBS)
	- ./run_lancelot_steering > lancelot_steeringqs.output 2>&1
	cat lancelot_steeringqs.output
	rm ./run_lancelot_steering

lancelot_steeringqt: $(OBJECTSSTEERINGq) $(OBJQ)/lancelot_steeringt_quadruple.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
          $(OBJQ)/lancelot_steering_quadruple.o -L$(OBJQ) $(LIBS)
	- ./run_lancelot_steering > lancelot_steeringqt.output 2>&1
	cat lancelot_steeringqt.output
	rm ./run_lancelot_steering

lancelot_steeringqt_valgrind: $(OBJECTSSTEERINGQ) \
          $(OBJQ)/lancelot_steeringt_quadruple.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
          $(OBJQ)/lancelot_steeringt_quadruple.o -L$(OBJQ) $(LIBS)
	- valgrind $(VALGRIND) run_lancelot_steering \
           > lancelot_steeringqt_valgrind.output 2>&1
	cat lancelot_steeringqt_valgrind.output
	rm ./run_lancelot_steering

lancelot_simpleqs: $(OBJECTSQ) $(OBJQ)/lancelot_simples.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_simple \
           $(OBJQ)/lancelot_simples.o -L$(OBJQ) $(LIBS)
	- ./run_lancelot_simple > lancelot_simpleqs.output 2>&1
	cat lancelot_simpleqs.output
	rm ./run_lancelot_simple

lancelot_simpleqt: $(OBJECTSQ) $(OBJQ)/lancelot_simplet_quadruple.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_simple \
            $(OBJQ)/lancelot_simplet_quadruple.o -L$(OBJQ) $(LIBS)
	- ./run_lancelot_simple > lancelot_simpleqt.output 2>&1
	cat lancelot_simpleqt.output
	rm ./run_lancelot_simple

lancelotss_64: $(OBJECTSS64) $(OBJS64)/lancelots_single_64.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
           $(OBJS64)/lancelots_single_64.o -L$(OBJS64) $(LIBS)
	- ./run_lancelot > lancelotss_64.output 2>&1
	cat lancelotss_64.output
	rm ./run_lancelot

lancelotst_64: $(OBJECTSS64) $(OBJS64)/lancelott_single_64.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
           $(OBJS64)/lancelott_single_64.o -L$(OBJS64) $(LIBS)
	- ./run_lancelot > lancelotst_64.output 2>&1
	cat lancelotst_64.output
	rm ./run_lancelot

lancelot_steeringss_64: $(OBJECTSSTEERINGS64) $(OBJS64)/lancelot_steerings.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
            $(OBJS64)/lancelot_steerings.o -L$(OBJS64) $(LIBS)
	- ./run_lancelot_steering > lancelot_steeringss_64.output 2>&1
	cat lancelot_steeringss_64.output
	rm ./run_lancelot_steering

lancelot_steeringst_64: $(OBJECTSSTEERINGS64) \
                       $(OBJS64)/lancelot_steeringt_single_64.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
          $(OBJS64)/lancelot_steeringt_single_64.o -L$(OBJS64) $(LIBS)
	- ./run_lancelot_steering > lancelot_steeringst_64.output 2>&1
	cat lancelot_steeringst_64.output
	rm ./run_lancelot_steering

lancelot_simpless_64: $(OBJECTSS64) $(OBJS64)/lancelot_simples.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_simple \
           $(OBJS64)/lancelot_simples.o -L$(OBJS64) $(LIBS)
	- ./run_lancelot_simple > lancelot_simpless_64.output 2>&1
	cat lancelot_simpless_64.output
	rm ./run_lancelot_simple

lancelot_simplest_64: $(OBJECTSS64) $(OBJS64)/lancelot_simplet_single_64.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_simple \
           $(OBJS64)/lancelot_simplet_single_64.o -L$(OBJS64) $(LIBS)
	- ./run_lancelot_simple > lancelot_simplest_64.output 2>&1
	cat lancelot_simplest_64.output
	rm ./run_lancelot_simple

lancelotds_64: $(OBJECTSD64) $(OBJD64)/lancelots_double_64.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
            $(OBJD64)/lancelots_double_64.o -L$(OBJD64) $(LIBS)
	- ./run_lancelot > lancelotds_64.output 2>&1
	cat lancelotds_64.output
	rm ./run_lancelot

lancelotdt_64: $(OBJECTSD64) $(OBJD64)/lancelott_double_64.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
           $(OBJD64)/lancelott_double_64.o -L$(OBJD64) $(LIBS)
	- ./run_lancelot > lancelotdt_64.output 2>&1
	cat lancelotdt_64.output
	rm ./run_lancelot

lancelotdt_valgrind_64: $(OBJECTSD64) $(OBJD64)/lancelott_double_64.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
            $(OBJD64)/lancelott_double_64.o -L$(OBJD64) $(LIBS)
	- valgrind $(VALGRIND) ./run_lancelot > \
           lancelotdt_valgrind.output 2>&1
	cat lancelotdt_valgrind.output
	rm ./run_lancelot

lancelot_steeringds_64: $(OBJECTSSTEERINGD64) $(OBJD64)/lancelot_steerings.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
          $(OBJD64)/lancelot_steerings.o -L$(OBJD64) $(LIBS)
	- ./run_lancelot_steering > lancelot_steeringds_64.output 2>&1
	cat lancelot_steeringds_64.output
	rm ./run_lancelot_steering

lancelot_steeringdt_64: $(OBJECTSSTEERINGD64) \
                       $(OBJD64)/lancelot_steeringt_double_64.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
          $(OBJD64)/lancelot_steeringt_double_64.o -L$(OBJD64) $(LIBS)
	- ./run_lancelot_steering > lancelot_steeringdt_64.output 2>&1
	cat lancelot_steeringdt_64.output
	rm ./run_lancelot_steering

lancelot_simpleds_64: $(OBJECTSD64) $(OBJD64)/lancelot_simples.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_simple \
           $(OBJD64)/lancelot_simples.o -L$(OBJD64) $(LIBS)
	- ./run_lancelot_simple > lancelot_simpleds_64.output 2>&1
	cat lancelot_simpleds_64.output
	rm ./run_lancelot_simple

lancelot_simpledt_64: $(OBJECTSD64) $(OBJD64)/lancelot_simplet_double_64.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_simple \
            $(OBJD64)/lancelot_simplet_double_64.o -L$(OBJD64) $(LIBS)
	- ./run_lancelot_simple > lancelot_simpledt_64.output 2>&1
	cat lancelot_simpledt_64.output
	rm ./run_lancelot_simple

lancelotqs_64: $(OBJECTSQ64) $(OBJQ64)/lancelots_quadruple_64.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
            $(OBJQ64)/lancelots_quadruple_64.o -L$(OBJQ64) $(LIBS)
	- ./run_lancelot > lancelotqs_64.output 2>&1
	cat lancelotqs_64.output
	rm ./run_lancelot

lancelotqt_64: $(OBJECTSQ64) $(OBJQ64)/lancelott_quadruple_64.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
           $(OBJQ64)/lancelott_quadruple_64.o -L$(OBJQ64) $(LIBS)
	- ./run_lancelot > lancelotqt_64.output 2>&1
	cat lancelotqt_64.output
	rm ./run_lancelot

lancelotqt_valgrind_64: $(OBJECTSQ64) $(OBJQ64)/lancelott_quadruple_64.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot \
            $(OBJQ64)/lancelott_quadruple_64.o -L$(OBJQ64) $(LIBS)
	- valgrind $(VALGRIND) ./run_lancelot > \
           lancelotqt_valgrind.output 2>&1
	cat lancelotqt_valgrind.output
	rm ./run_lancelot

lancelot_steeringqs_64: $(OBJECTSSTEERINGQ64) $(OBJQ64)/lancelot_steerings.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
          $(OBJQ64)/lancelot_steerings.o -L$(OBJQ64) $(LIBS)
	- ./run_lancelot_steering > lancelot_steeringqs_64.output 2>&1
	cat lancelot_steeringqs_64.output
	rm ./run_lancelot_steering

lancelot_steeringqt_64: $(OBJECTSSTEERINGQ64) \
                       $(OBJQ64)/lancelot_steeringt_quadruple_64.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_steering \
          $(OBJQ64)/lancelot_steeringt_quadruple_64.o -L$(OBJQ64) $(LIBS)
	- ./run_lancelot_steering > lancelot_steeringqt_64.output 2>&1
	cat lancelot_steeringqt_64.output
	rm ./run_lancelot_steering

lancelot_simpleqs_64: $(OBJECTSQ64) $(OBJQ64)/lancelot_simples.o
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_simple \
           $(OBJQ64)/lancelot_simples.o -L$(OBJQ64) $(LIBS)
	- ./run_lancelot_simple > lancelot_simpleqs_64.output 2>&1
	cat lancelot_simpleqs_64.output
	rm ./run_lancelot_simple

lancelot_simpleqt_64: $(OBJECTSQ64) $(OBJQ64)/lancelot_simplet_quadruple_64.o
	echo ""
	echo " Exhaustive test of subroutine interface to LANCELOT B"
	$(FORTRAN) $(RUNFFLAGS) $(SPECIAL) -o run_lancelot_simple \
            $(OBJQ64)/lancelot_simplet_quadruple_64.o -L$(OBJQ64) $(LIBS)
	- ./run_lancelot_simple > lancelot_simpleqt_64.output 2>&1
	cat lancelot_simpleqt_64.output
	rm ./run_lancelot_simple

#  basic packages

extend:
	( cd ../extend ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            extend_silent PRECIS=$(PRECIS) PWD=$(PWD)/../extend )
basics:
	( cd ../general ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            basic_silent PRECIS=$(PRECIS) PWD=$(PWD)/../general )
linearsolver:
	( cd ../general ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            linearsolver_silent PRECIS=$(PRECIS) PWD=$(PWD)/../general )
sils:
	( cd ../sils ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            sils_silent PRECIS=$(PRECIS) PWD=$(PWD)/../sils )
scu:
	( cd ../scu ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            scu_silent  PRECIS=$(PRECIS) PWD=$(GALAHAD)/src/scu )
band:
	( cd ../band ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            band_silent  PRECIS=$(PRECIS) PWD=$(GALAHAD)/src/band )
rand:
	( cd ../rand ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            rand.o PRECIS=$(PRECIS) PWD=$(PWD)/../rand )
copyright:
	( cd ../copyright ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            copyright.o PRECIS=$(PRECIS) PWD=$(PWD)/../copyright )
hsl_lancelot:
	( cd ../external/hsl ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            hsl_lancelot_silent PRECIS=$(PRECIS) PWD=$(PWD)/../external/hsl )
ma61:
	( cd ../external/hsl ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            ma61_silent PRECIS=$(PRECIS) PWD=$(PWD)/../external/hsl )
icfs:
	( cd ../icfs ; $(MAKE) -f $(GALAHAD)/makefiles/$(VERSION) \
            icfs_silent PRECIS=$(PRECIS) PWD=$(PWD)/../icfs )

#  constituent packages

others.o: $(LG)(others_$(PRECIS).o)

$(LG)(others_$(PRECIS).o): ../lancelot/others.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "others"
	$(CP) ../lancelot/others.F90 $(OBJ)/others.F90
	cd $(OBJ); $(FORTRAN) -o others_$(PRECIS).o $(FFLAGSS) others.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o others_$(PRECIS).o $(FFLAGSN) others.F90 )
	cd $(OBJ); $(ARR) others_$(PRECIS).o; \
          $(RM) others.F90 others_$(PRECIS).o
	$(RMARFILE) initw.o
	$(MVMODS)
	@printf '[ OK ]\n'

strutr.o: $(LG)(strutr_$(PRECIS).o)

$(LG)(strutr_$(PRECIS).o): ../lancelot/strutr.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "strutr"
	$(CP) ../lancelot/strutr.F90  $(OBJ)/strutr.F90
	cd $(OBJ); $(FORTRAN) -o strutr_$(PRECIS).o $(FFLAGSS) strutr.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o strutr_$(PRECIS).o $(FFLAGSN) strutr.F90 )
	cd $(OBJ); $(ARR) strutr_$(PRECIS).o; \
          $(RM) strutr.F90 strutr_$(PRECIS).o
	$(RMARFILE) lancelot_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

cauchy.o: $(LG)(cauchy_$(PRECIS).o)

$(LG)(cauchy_$(PRECIS).o): ../lancelot/cauchy.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "cauchy "
	$(CP) ../lancelot/cauchy.F90 $(OBJ)/cauchy.F90
	cd $(OBJ); $(FORTRAN) -o cauchy_$(PRECIS).o $(FFLAGSS) cauchy.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o cauchy_$(PRECIS).o $(FFLAGSN) cauchy.F90 )
	cd $(OBJ); $(ARR) cauchy_$(PRECIS).o; \
          $(RM) cauchy.F90 cauchy_$(PRECIS).o
	$(RMARFILE) lancelot_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

cg.o: $(LG)(cg_$(PRECIS).o)

$(LG)(cg_$(PRECIS).o): ../lancelot/cg.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "cg    "
	$(CP) ../lancelot/cg.F90 $(OBJ)/cg.F90
	cd $(OBJ); $(FORTRAN) -o cg_$(PRECIS).o $(FFLAGSS) cg.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o cg_$(PRECIS).o $(FFLAGSN) cg.F90 )
	cd $(OBJ); $(ARR) cg_$(PRECIS).o; $(RM) cg.F90 cg_$(PRECIS).o
	$(RMARFILE) lancelot_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

hslint.o: $(LG)(hslint_$(PRECIS).o)

$(LG)(hslint_$(PRECIS).o): ../lancelot/hslint.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "hslint"
	$(CP) ../lancelot/hslint.F90 $(OBJ)/hslint.F90
	cd $(OBJ); $(FORTRAN) -o hslint_$(PRECIS).o $(FFLAGSS) hslint.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o hslint_$(PRECIS).o $(FFLAGSN) hslint.F90 )
	cd $(OBJ); $(ARR) hslint_$(PRECIS).o; \
          $(RM) hslint.F90 hslint_$(PRECIS).o
	$(RMARFILE) mdchl_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

asmbl.o: $(LG)(asmbl_$(PRECIS).o)

$(LG)(asmbl_$(PRECIS).o): ../lancelot/asmbl.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "asmbl "
	$(CP) ../lancelot/asmbl.F90 $(OBJ)/asmbl.F90
	cd $(OBJ); $(FORTRAN) -o asmbl_$(PRECIS).o $(FFLAGSS) asmbl.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o asmbl_$(PRECIS).o $(FFLAGSN) asmbl.F90 )
	cd $(OBJ); $(ARR) asmbl_$(PRECIS).o; $(RM) asmbl.F90 asmbl_$(PRECIS).o
	$(RMARFILE) precn_$(PRECIS).o
	$(RMARFILE) frntl_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

drchg.o: $(LG)(drchg_$(PRECIS).o)

$(LG)(drchg_$(PRECIS).o): ../lancelot/drchg.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "drchg "
	$(CP) ../lancelot/drchg.F90 $(OBJ)/drchg.F90
	cd $(OBJ); $(FORTRAN) -o drchg_$(PRECIS).o $(FFLAGSS) drchg.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o drchg_$(PRECIS).o $(FFLAGSN) drchg.F90 )
	cd $(OBJ); $(ARR) drchg_$(PRECIS).o; $(RM) drchg.F90 drchg_$(PRECIS).o
	$(CURMARFILE) uselancelot_$(PRECIS).o
	$(CURMARFILE) uselancelot_steering_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

drche.o: $(LG)(drche_$(PRECIS).o)

$(LG)(drche_$(PRECIS).o): ../lancelot/drche.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "drche "
	$(CP) ../lancelot/drche.F90 $(OBJ)/drche.F90
	cd $(OBJ); $(FORTRAN) -o drche_$(PRECIS).o $(FFLAGSS) drche.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o drche_$(PRECIS).o $(FFLAGSN) drche.F90 )
	cd $(OBJ); $(ARR) drche_$(PRECIS).o; $(RM) drche.F90 drche_$(PRECIS).o
	$(CURMARFILE) uselancelot_$(PRECIS).o
	$(CURMARFILE) uselancelot_steering_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

hsprd.o: $(LG)(hsprd_$(PRECIS).o)

$(LG)(hsprd_$(PRECIS).o): ../lancelot/hsprd.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "hsprd "
	$(CP) ../lancelot/hsprd.F90 $(OBJ)/hsprd.F90
	cd $(OBJ); $(FORTRAN) -o hsprd_$(PRECIS).o $(FFLAGSS) hsprd.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o hsprd_$(PRECIS).o $(FFLAGSN) hsprd.F90 \ )
	cd $(OBJ); $(ARR) hsprd_$(PRECIS).o; $(RM) hsprd.F90 hsprd_$(PRECIS).o
	$(RMARFILE) lancelot_$(PRECIS).o
	@printf '[ OK ]\n'
	$(MVMODS)

initw.o: $(LG)(initw_$(PRECIS).o)

$(LG)(initw_$(PRECIS).o): ../lancelot/initw.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "initw "
	$(CP) ../lancelot/initw.F90 $(OBJ)/initw.F90
	cd $(OBJ); $(FORTRAN) -o initw_$(PRECIS).o $(FFLAGSS) initw.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o initw_$(PRECIS).o $(FFLAGSN) initw.F90 )
	cd $(OBJ); $(ARR) initw_$(PRECIS).o; $(RM) initw.F90 initw_$(PRECIS).o
	$(RMARFILE) lancelot_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

scaln.o: $(LG)(scaln_$(PRECIS).o)

$(LG)(scaln_$(PRECIS).o): ../lancelot/scaln.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "scaln "
	$(CP) ../lancelot/scaln.F90 $(OBJ)/scaln.F90
	cd $(OBJ); $(FORTRAN) -o scaln_$(PRECIS).o $(FFLAGSS) scaln.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o scaln_$(PRECIS).o $(FFLAGSN) scaln.F90 )
	cd $(OBJ); $(ARR) scaln_$(PRECIS).o; $(RM) scaln.F90 scaln_$(PRECIS).o
	$(CURMARFILE) uselancelot_$(PRECIS).o
	$(CURMARFILE) uselancelot_steering_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

mdchl.o: $(LG)(mdchl_$(PRECIS).o)

$(LG)(mdchl_$(PRECIS).o): ../lancelot/mdchl.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "mdchl "
	$(CP) ../lancelot/mdchl.F90 $(OBJ)/mdchl.F90
	cd $(OBJ); $(FORTRAN) -o mdchl_$(PRECIS).o $(FFLAGSS) mdchl.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o mdchl_$(PRECIS).o $(FFLAGSN) mdchl.F90 )
	cd $(OBJ); $(ARR) mdchl_$(PRECIS).o; $(RM) mdchl.F90 mdchl_$(PRECIS).o
	$(RMARFILE) precn_$(PRECIS).o
	$(RMARFILE) frntl_$(PRECIS).o
	$(RMARFILE) psls_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

precn.o: $(LG)(precn_$(PRECIS).o)

$(LG)(precn_$(PRECIS).o): ../lancelot/precn.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "precn "
	$(CP) ../lancelot/precn.F90 $(OBJ)/precn.F90
	cd $(OBJ); $(FORTRAN) -o precn_$(PRECIS).o $(FFLAGSS) precn.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o precn_$(PRECIS).o $(FFLAGSN) precn.F90 )
	cd $(OBJ); $(ARR) precn_$(PRECIS).o; $(RM) precn.F90 precn_$(PRECIS).o
	$(RMARFILE) lancelot_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

frntl.o: $(LG)(frntl_$(PRECIS).o)

$(LG)(frntl_$(PRECIS).o): ../lancelot/frntl.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "frntl "
	$(CP) ../lancelot/frntl.F90 $(OBJ)/frntl.F90
	cd $(OBJ); $(FORTRAN) -o frntl_$(PRECIS).o $(FFLAGSS) frntl.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o frntl_$(PRECIS).o $(FFLAGSN) frntl.F90 )
	cd $(OBJ); $(ARR) frntl_$(PRECIS).o; $(RM) frntl.F90 frntl_$(PRECIS).o
	$(RMARFILE) lancelot_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

lancelot_types.o: $(LG)(lancelot_types_$(PRECIS).o)

$(LG)(lancelot_types_$(PRECIS).o): ../lancelot/lancelot_types.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "lancelot_types"
	$(CP) ../lancelot/lancelot_types.F90 $(OBJ)/lancelot_types.F90
	cd $(OBJ); $(FORTRAN) -o lancelot_types_$(PRECIS).o $(FFLAGSS) \
                     lancelot_types.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o lancelot_types_$(PRECIS).o $(FFLAGSN) \
                     lancelot_types.F90 )
	cd $(OBJ); $(ARR) lancelot_types_$(PRECIS).o; \
                     $(RM) lancelot_types.F90 lancelot_types_$(PRECIS).o
	$(RMARFILE) lancelot_$(PRECIS).o
	$(RMARFILE) lancelot_steering_$(PRECIS).o
	$(RMARFILE) drche_$(PRECIS).o
	$(RMARFILE) drchg_$(PRECIS).o
	$(RMARFILE) scaln_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

lancelot.o: $(LG)(lancelot_$(PRECIS).o)

$(LG)(lancelot_$(PRECIS).o): ../lancelot/lancelot.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "lancelot"
	$(CP) ../lancelot/lancelot.F90 $(OBJ)/lancelot.F90
	cd $(OBJ); $(FORTRAN) -o lancelot_$(PRECIS).o $(FFLAGSS) lancelot.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o lancelot_$(PRECIS).o $(FFLAGSN) lancelot.F90 )
	cd $(OBJ); $(ARR) lancelot_$(PRECIS).o; \
           $(RM) lancelot.F90 lancelot_$(PRECIS).o
	$(RMARFILE) lancelot_simple_$(PRECIS).o
	$(RMARFILE) drche_$(PRECIS).o
	$(RMARFILE) drchg_$(PRECIS).o
	$(RMARFILE) scaln_$(PRECIS).o
	$(RMOBFILE) lancelots.o
	$(RMOBFILE) lancelott_$(PRECIS).o
	$(RMOBFILE) galahad_ampl.o
	$(MVMODS)
	@printf '[ OK ]\n'

lancelot_steering.o: $(LG)(lancelot_steering_$(PRECIS).o)

$(LG)(lancelot_steering_$(PRECIS).o): ../lancelot/lancelot_steering.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "lancelot_steering"
	$(CP) ../lancelot/lancelot_steering.F90 \
          $(OBJ)/lancelot_steering.F90
	cd $(OBJ); $(FORTRAN) -o lancelot_steering_$(PRECIS).o $(FFLAGSS) \
          lancelot_steering.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o lancelot_steering_$(PRECIS).o $(FFLAGSN) \
                     lancelot_steering.F90 )
	cd $(OBJ); $(ARR) lancelot_steering_$(PRECIS).o ; \
                     $(RM) lancelot_steering.F90 lancelot_steering_$(PRECIS).o
	$(RMARFILE) drche_$(PRECIS).o
	$(RMARFILE) drchg_$(PRECIS).o
	$(RMARFILE) scaln_$(PRECIS).o
	$(RMOBFILE) lancelot_steerings.o
	$(RMOBFILE) lancelot_steeringt_$(PRECIS).o
	$(RMOBFILE) galahad_ampl.o
	$(MVMODS)
	@printf '[ OK ]\n'

lancelot_simple.o: $(LG)(lancelot_simple_$(PRECIS).o)

$(LG)(lancelot_simple_$(PRECIS).o): ../lancelot_simple/lancelot_simple.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "lancelot_simple"
	$(CP) ../lancelot_simple/lancelot_simple.F90 \
           $(OBJ)/lancelot_simple.F90
	cd $(OBJ); $(FORTRAN) -o lancelot_simple_$(PRECIS).o $(FFLAGSS) \
                   lancelot_simple.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o lancelot_simple_$(PRECIS).o $(FFLAGSN) \
                   lancelot_simple.F90 )
	cd $(OBJ); $(ARR) lancelot_simple_$(PRECIS).o; \
             $(RM) lancelot_simple.F90 lancelot_simple_$(PRECIS).o
	$(RMOBFILE) lancelot_simples.o
	$(RMOBFILE) lancelot_simplet_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

#  SIF interfaces

uselancelot.o: $(CULG)(uselancelot_$(PRECIS).o)

$(CULG)(uselancelot_$(PRECIS).o): ../lancelot/uselancelot.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "uselancelot "
	$(CP) ../lancelot/uselancelot.F90 $(OBJ)/uselancelot.F90
	cd $(OBJ); $(FORTRAN) -o uselancelot_$(PRECIS).o \
                     $(FFLAGSS) uselancelot.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o uselancelot_$(PRECIS).o \
                     $(FFLAGSN) uselancelot.F90 )
	cd $(OBJ); $(CUARR) uselancelot_$(PRECIS).o ; \
          $(RM) uselancelot.F90 uselancelot_$(PRECIS).o
	$(RMOBFILE) runlancelot_sif_$(PRECIS)_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

uselancelot_steering.o: $(CULG)(uselancelot_steering_$(PRECIS).o)

$(CULG)(uselancelot_steering_$(PRECIS).o): ../lancelot/uselancelot_steering.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "uselancelot_steering "
	$(CP) ../lancelot/uselancelot_steering.F90 \
          $(OBJ)/uselancelot_steering.F90
	cd $(OBJ); $(FORTRAN) -o uselancelot_steering_$(PRECIS).o $(FFLAGSS) \
          uselancelot_steering.F90 \
                || ( printf ' %-26s' "=> Disabling optimization " ; \
                   $(FORTRAN) -o uselancelot_steering_$(PRECIS).o $(FFLAGSN) \
                     uselancelot_steering.F90 )
	cd $(OBJ); $(CUARR) uselancelot_steering_$(PRECIS).o ; \
          $(RM) uselancelot_steering.F90 uselancelot_steering_$(PRECIS).o
	$(RMOBFILE) runlancelot_steering_sif_$(PRECIS).o
	$(MVMODS)
	@printf '[ OK ]\n'

#  main program

runlancelot_sif.o: $(OBJ)/runlancelot_sif_$(PRECIS).o

$(OBJ)/runlancelot_sif_$(PRECIS).o: ../lancelot/runlancelot_sif.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "runlancelot_sif"
	$(CP) ../lancelot/runlancelot_sif.F90 \
          $(OBJ)/runlancelot_sif.F90
	cd $(OBJ); $(FORTRAN) -o runlancelot_sif_$(PRECIS).o $(FFLAGSS) \
           runlancelot_sif.F90
	$(RM) $(OBJ)/runlancelot_sif.F90
	@printf '[ OK ]\n'

runlancelot_steering_sif.o: $(OBJ)/runlancelot_steering_sif_$(PRECIS).o

$(OBJ)/runlancelot_steering_sif_$(PRECIS).o: ../lancelot/runlancelot_steering_sif.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "runlancelot_steering_sif"
	$(CP) ../lancelot/runlancelot_steering_sif.F90 \
          $(OBJ)/runlancelot_steering_sif.F90
	cd $(OBJ); $(FORTRAN) -o runlancelot_steering_sif_$(PRECIS).o \
          $(FFLAGSS) runlancelot_steering_sif.F90
	$(RM) $(OBJ)/runlancelot_steering_sif.F90
	@printf '[ OK ]\n'

#  main program for spec example

lancelots.o: $(OBJ)/lancelots_$(PRECIS).o

$(OBJ)/lancelots_$(PRECIS).o: ../lancelot/lancelots.f90
	@printf ' %-9s %-15s\t\t' "Compiling" "lancelots"
	$(SED) -f $(SEDS) ../lancelot/lancelots.f90 > $(OBJ)/lancelots.f90
	cd $(OBJ); $(FORTRAN) -o lancelots_$(PRECIS).o $(FFLAGSS) lancelots.f90
	$(RM) $(OBJ)/lancelots.f90
	@printf '[ OK ]\n'

lancelot_steerings.o: $(OBJ)/lancelot_steerings_$(PRECIS).o

$(OBJ)/lancelot_steerings_$(PRECIS).o: ../lancelot/lancelot_steerings.f90
	@printf ' %-9s %-15s\t\t' "Compiling" "lancelot_steerings"
	$(SED) -f $(SEDS) ../lancelot/lancelot_steerings.f90 > \
          $(OBJ)/lancelot_steerings.f90
	cd $(OBJ); $(FORTRAN) -o lancelot_steerings_$(PRECIS).o $(FFLAGSS) \
           lancelot_steerings.f90
	$(RM) $(OBJ)/lancelot_steerings.f90
	@printf '[ OK ]\n'

lancelot_simples.o: $(OBJ)/lancelot_simples_$(PRECIS).o

$(OBJ)/lancelot_simples_$(PRECIS).o: ../lancelot_simple/lancelot_simples.f90
	@printf ' %-9s %-15s\t\t' "Compiling" "lancelot_simples"
	$(SED) -f $(SEDS) \
          ../lancelot_simple/lancelot_simples.f90 > $(OBJ)/lancelot_simples.f90
	cd $(OBJ); $(FORTRAN) -o lancelot_simples_$(PRECIS).o $(FFLAGSS) \
           lancelot_simples.f90
	$(RM) $(OBJ)/lancelot_simples.f90
	@printf '[ OK ]\n'

#  main program for exhaustive test deck

lancelott.o: $(OBJ)/lancelott_$(PRECIS).o

$(OBJ)/lancelott_$(PRECIS).o: ../lancelot/lancelott.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "lancelott"
	$(CP) lancelott.F90 $(OBJ)/lancelott.F90
	cd $(OBJ); $(FORTRAN) -o lancelott_$(PRECIS).o $(FFLAGSS) lancelott.F90
	$(RM) $(OBJ)/lancelott.F90
	@printf '[ OK ]\n'

lancelot_steeringt.o: $(OBJ)/lancelot_steeringt_$(PRECIS).o

$(OBJ)/lancelot_steeringt_$(PRECIS).o: ../lancelot/lancelot_steeringt.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "lancelot_steeringt"
	$(CP) lancelot_steeringt.F90 $(OBJ)/lancelot_steeringt.F90
	cd $(OBJ); $(FORTRAN) -o lancelot_steeringt_$(PRECIS).o $(FFLAGSS) \
              lancelot_steeringt.F90
	$(RM) $(OBJ)/lancelot_steeringt.F90
	@printf '[ OK ]\n'

lancelot_simplet.o: $(OBJ)/lancelot_simplet_$(PRECIS).o

$(OBJ)/lancelot_simplet_$(PRECIS).o: ../lancelot_simple/lancelot_simplet.F90
	@printf ' %-9s %-15s\t\t' "Compiling" "lancelot_simplet"
	$(CP) ../lancelot_simple/lancelot_simplet.F90 \
          $(OBJ)/lancelot_simplet.F90
	cd $(OBJ); $(FORTRAN) -o lancelot_simplet_$(PRECIS).o $(FFLAGSS) \
           lancelot_simplet.F90
	$(RM) $(OBJ)/lancelot_simplet.F90
	@printf '[ OK ]\n'

#  book keeping

clean:
	@printf ' %-9s\t\t' "Cleaning"
	$(RM) $(LGS) $(LGD) $(LGQ) $(LGS64) $(LGD64) $(LGQ64) \
                            $(OBJS)/runlancelot_sif_$(PRECIS).o \
                            $(OBJD)/runlancelot_sif_$(PRECIS).o \
                            $(OBJQ)/runlancelot_sif_$(PRECIS).o \
                            $(OBJS64)/runlancelot_sif_$(PRECIS).o \
                            $(OBJD64)/runlancelot_sif_$(PRECIS).o \
                            $(OBJQ64)/runlancelot_sif_$(PRECIS).o
	@printf '[ OK ]\n'

cleanall:
	@printf ' %-14s\t\t' "Removing all $(PRECIS) precision object and module files"
	$(RM) -r $(OBJ)/* $(MOD)/*
	@printf '[ OK ]\n'
