# This makefile starts off with the general directory structure
# of the library of PHCpack, then comes the MPI set up, followed
# by a listing of all the targets, grouped by library.

PHCLib=../Lib
PHCAda=../Ada
MPILib=../MPI
BIN=../bin
INCLULIBS=-I$(PHCAda)/System -I$(PHCAda)/System/Unix_Timer \
 -I$(PHCAda)/Math_Lib/Numbers -I$(PHCAda)/Math_Lib/Matrices \
 -I$(PHCAda)/Math_Lib/Polynomials -I$(PHCAda)/Math_Lib/Supports \
 -I$(PHCAda)/Homotopy -I$(PHCAda)/Newton -I$(PHCAda)/Continuation \
 -I$(PHCAda)/Root_Counts/Product -I$(PHCAda)/Root_Counts/Fewnomials \
 -I$(PHCAda)/Root_Counts/Implift -I$(PHCAda)/Root_Counts/Stalift \
 -I$(PHCAda)/Root_Counts/Dynlift -I$(PHCAda)/Root_Counts/Symmetry \
 -I$(PHCAda)/Root_Counts/MixedVol \
 -I$(PHCAda)/Schubert/SAGBI -I$(PHCAda)/Schubert/Pieri \
 -I$(PHCAda)/Schubert/Induction \
 -I$(PHCAda)/Components/Samplers -I$(PHCAda)/Components/Interpolators \
 -I$(PHCAda)/Components/Factorization -I$(PHCAda)/Components/Decomposition \
 -I$(PHCAda)/Components/Solver \
 -I$(PHCAda)/Differentials -I$(PHCAda)/Main \
 -I$(PHCAda)/CtoPHC/Funky -I$(PHCAda)/CtoPHC/State -I$(MPILib)
GNATFLAGS=-gnatv -O3 -gnatp -gnatf --GNATBIND="gnatbind -static"
# try to use gprof...
# CLARGS = -cargs -pg -largs -pg
#GNATFLAGS=-gnatv
#GNATFLAGS=-gnatv --GNATBIND="gnatbind -static"

# for using mpi on copper :

CC          = /usr/bin/mpcc
CLINKER     = /usr/bin/mpcc /u/ac/janv/GNATpower/lib/libgcc_s.a

# Notice that executables with MPI are placed here.
# how to make the executables with MPI:

adatest:
	$(CC) -c $(MPILib)/call_hello.c
	$(CC) -c $(MPILib)/adatest.c
	gnatmake -c $(MPILib)/hello.adb
	gnatbind -n -C hello
#	gcc -c b_hello.c
#	$(CC) b_hello.o call_hello.o adatest.o ./hello.o -o ../bin/adatest \
#-L./ -L/u/ac/janv/GNATpower/lib/gcc/powerpc-ibm-aix5.1.0.0/3.4.4/adalib/ \
#/u/ac/janv/GNATpower/lib/gcc/powerpc-ibm-aix5.1.0.0/3.4.4/adalib/libgnat.a \
#/u/ac/janv/GNATpower/lib/libgcc_s.a
	gnatlink -C hello call_hello.o adatest.o -o ../bin/adatest \
                --LINK=$(CLINKER)

mpi2sys:
	$(CC) -c $(MPILib)/mpi2sys.c
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_syscon.adb
	gnatbind -n -C -static use_syscon
#	gcc -c b_use_syscon.c
#	$(CC) b_use_syscon.o mpi2sys.o *.o ./use_syscon.o -o ../bin/mpi2sys \
#-L./ -L/u/ac/janv/GNATpower/lib/gcc/powerpc-ibm-aix5.1.0.0/3.4.4/adalib/ \
#/u/ac/janv/GNATpower/lib/gcc/powerpc-ibm-aix5.1.0.0/3.4.4/adalib/libgnat.a \
#/u/ac/janv/GNATpower/lib/libgcc_s.a -lm
	gnatlink -C use_syscon mpi2sys.o -o ../bin/mpi2sys \
                 --LINK=$(CLINKER)

mpi2sol:
	$(CC) -c $(MPILib)/mpi2sol.c
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_solcon.adb
	gnatbind -n -C use_solcon
	gnatlink -C use_solcon mpi2sol.o -o ../bin/mpi2sol \
                 --LINK=$(CLINKER)

mpi2hom:
	$(CC) -c $(MPILib)/mpi2hom.c
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc mpi2hom.o -o ../bin/mpi2hom \
                 --LINK=$(CLINKER)

mpi2phc_s:
	$(CC) -c $(MPILib)/mpi2phc_s.c
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc mpi2phc_s.o -o ../bin/mpi2phc_s \
                 --LINK=$(CLINKER)

mpi2phc_d:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	$(CC) -c $(PHCLib)/phcpack.c
	$(CC) -c $(PHCLib)/syscon.c
	$(CC) -c $(PHCLib)/solcon.c
	$(CC) -c $(MPILib)/parallel_phcpack.c
	$(CC) -c $(MPILib)/mpi2phc_d.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o solcon.o syscon.o \
                    parallel_phcpack.o mpi2phc_d.o -o ../bin/mpi2phc_d \
                 --LINK=$(CLINKER)

mpi2track:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	$(CC) -c $(PHCLib)/phcpack.c
	$(CC) -c $(PHCLib)/syscon.c
	$(CC) -c $(PHCLib)/solcon.c
	$(CC) -c $(MPILib)/parallel_phcpack.c
	$(CC) -c $(MPILib)/mpi2track.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o solcon.o syscon.o \
                    parallel_phcpack.o mpi2track.o -o ../bin/mpi2track \
                 --LINK=$(CLINKER)

mpi2phc_d2:
	$(CC) -c $(MPILib)/mpi2phc_d2.c
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc mpi2phc_d2.o -o ../bin/mpi2phc_d2 \
                 --LINK=$(CLINKER)

parallel_pieri:
	$(CC) -c $(MPILib)/parallel_pieri.c $(MPILib)/parallel_tree.c \
	         $(MPILib)/queue.c $(PHCAda)/CtoPHC/ts_use_c2phc.c
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2pieri.adb
	gnatbind -n -C use_c2pieri
	gnatlink -C use_c2pieri parallel_pieri.o parallel_tree.o queue.o \
                 -o $(BIN)/parallel_pieri --LINK=$(CLINKER)

mpi2fac:
	$(CC) -c $(MPILib)/mpi2fac.c
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc mpi2fac.o -o ../bin/mpi2fac \
                 --LINK=$(CLINKER)

mpi2fac_s:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	$(CC) -c $(PHCLib)/phcpack.c
	$(CC) -c $(PHCLib)/syscon.c
	$(CC) -c $(PHCLib)/solcon.c
	$(CC) -c $(MPILib)/parallel_phcpack.c
	$(CC) -c $(MPILib)/parallel_monodromy.c
	$(CC) -c $(MPILib)/mpi2fac_s.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o solcon.o syscon.o \
                    parallel_phcpack.o parallel_monodromy.o mpi2fac_s.o \
                 -o ../bin/mpi2fac_s --LINK=$(CLINKER)

mpi2fac_d:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	$(CC) -c $(PHCLib)/phcpack.c
	$(CC) -c $(PHCLib)/syscon.c
	$(CC) -c $(PHCLib)/solcon.c
	$(CC) -c $(MPILib)/parallel_phcpack.c
	$(CC) -c $(MPILib)/parallel_monodromy.c
	$(CC) -c $(MPILib)/manage_components.c
	$(CC) -c $(MPILib)/mpi2fac_d.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o solcon.o syscon.o \
                    parallel_phcpack.o parallel_monodromy.o \
		    manage_components.o mpi2fac_d.o \
                 -o ../bin/mpi2fac_d --LINK=$(CLINKER)

monodromyMPI:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	$(CC) -c $(PHCLib)/phcpack.c
	$(CC) -c $(PHCLib)/syscon.c
	$(CC) -c $(PHCLib)/solcon.c
	$(CC) -c $(MPILib)/parallel_phcpack.c
	$(CC) -c $(MPILib)/parallel_monodromy.c
	$(CC) -c $(MPILib)/manage_components.c
	$(CC) -c $(MPILib)/monodromyMPI.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o solcon.o syscon.o \
                    parallel_phcpack.o parallel_monodromy.o \
		    manage_components.o monodromyMPI.o \
                 -o ../bin/monodrom --LINK=$(CLINKER)

stat_cell:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	$(CC) -c $(PHCLib)/phcpack.c
	$(CC) -c $(PHCLib)/syscon.c
	$(CC) -c $(PHCLib)/solcon.c
	$(CC) -c $(PHCLib)/celcon.c
	$(CC) -c $(MPILib)/parallel_phcpack.c
	$(CC) -c $(MPILib)/stat_cell.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o solcon.o syscon.o celcon.o \
                    parallel_phcpack.o stat_cell.o \
		-o ../bin/stat_cell --LINK=$(CLINKER)

mpi2cell:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	$(CC) -c $(PHCLib)/phcpack.c
	$(CC) -c $(PHCLib)/syscon.c
	$(CC) -c $(PHCLib)/solcon.c
	$(CC) -c $(PHCLib)/celcon.c
	$(CC) -c $(MPILib)/parallel_phcpack.c
	$(CC) -c $(MPILib)/mpi2cell.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o solcon.o syscon.o celcon.o \
                    parallel_phcpack.o mpi2cell.o \
		-o ../bin/mpi2cell --LINK=$(CLINKER)

mpi2cell_s:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	$(CC) -c $(PHCLib)/phcpack.c
	$(CC) -c $(PHCLib)/syscon.c
	$(CC) -c $(PHCLib)/solcon.c
	$(CC) -c $(PHCLib)/celcon.c
	$(CC) -c $(MPILib)/parallel_phcpack.c
	$(CC) -c $(MPILib)/parallel_cells.c
	$(CC) -c $(MPILib)/mpi2cell_s.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o solcon.o syscon.o celcon.o \
                    parallel_phcpack.o parallel_cells.o mpi2cell_s.o \
		-o ../bin/mpi2cell_s --LINK=$(CLINKER)

mpi2cell_d:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	$(CC) -c $(PHCLib)/phcpack.c
	$(CC) -c $(PHCLib)/syscon.c
	$(CC) -c $(PHCLib)/solcon.c
	$(CC) -c $(PHCLib)/celcon.c
	$(CC) -c $(MPILib)/parallel_phcpack.c
	$(CC) -c $(MPILib)/parallel_cells.c
	$(CC) -c $(MPILib)/mpi2cell_d.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o solcon.o syscon.o celcon.o \
                    parallel_phcpack.o parallel_cells.o mpi2cell_d.o \
		-o ../bin/mpi2cell_d --LINK=$(CLINKER)

# Test program to see if compiler works, "hello world" :

hello:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) hello.adb
	gnatbl -o $(BIN)/hello hello.ali

ada_hello:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ada_hello.adb
	gnatbl -o $(BIN)/ada_hello ada_hello.ali

# Test programs for the System library :

ts_time:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_time.adb
	gnatbl -o $(BIN)/ts_time ts_time.ali

ts_clock:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_clock.adb
	gnatbl -o $(BIN)/ts_clock ts_clock.ali

ts_stamps:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_stamps.adb
	gnatbl -o $(BIN)/ts_stamps ts_stamps.ali

ts_timer:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_timer.adb
	gnatbl -o $(BIN)/ts_timer ts_timer.ali

get_clock.o:
	gcc -c $(PHCAda)/System/Basic_Timer/get_clock.c

get_clocks_per_sec.o:
	gcc -c $(PHCAda)/System/Basic_Timer/get_clocks_per_sec.c

ts_ctimer: get_clock.o get_clocks_per_sec.o
	gnatmake -o $(BIN)/ts_ctimer $(INCLULIBS) ts_ctimer.adb \
                 -largs get_clock.o get_clocks_per_sec.o

ts_wintimer: get_clock.o get_clocks_per_sec.o
	gnatmake -o $(BIN)/ts_wintimer $(INCLULIBS) ts_wintimer.adb \
                 -largs get_clock.o get_clocks_per_sec.o

ts_syscall:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_syscall.adb
	gnatbl -o $(BIN)/ts_syscall ts_syscall.ali

ts_mach:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_mach.adb
	gnatbl -o $(BIN)/ts_mach ts_mach.ali

ts_cmdline:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_cmdline.adb
	gnatbl -o $(BIN)/ts_cmdline ts_cmdline.ali

ts_byemess:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_byemess.adb
	gnatbl -o $(BIN)/ts_byemess ts_byemess.ali

ts_commuser:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_commuser.adb
	gnatbl -o $(BIN)/ts_commuser ts_commuser.ali

ts_filescan:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_filescan.adb
	gnatbl -o $(BIN)/ts_filescan ts_filescan.ali

# Test programs for the library Numbers :

ts_strnum:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_strnum.adb
	gnatbl -o $(BIN)/ts_strnum ts_strnum.ali

ts_printf:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_printf.adb
	gnatbl -o $(BIN)/ts_printf ts_printf.ali

ts_intnum:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_intnum.adb
	gnatbl -o $(BIN)/ts_intnum ts_intnum.ali

ts_natnum:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_natnum.adb
	gnatbl -o $(BIN)/ts_natnum ts_natnum.ali

ts_karat:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_karat.adb
	gnatbl -o $(BIN)/ts_karat ts_karat.ali

ts_fltnum:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_fltnum.adb
	gnatbl -o $(BIN)/ts_fltnum ts_fltnum.ali

ts_cmpnum:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_cmpnum.adb
	gnatbl -o $(BIN)/ts_cmpnum ts_cmpnum.ali

ts_random:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_random.adb
	gnatbl -o $(BIN)/ts_random ts_random.ali

ts_extran:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_extran.adb
	gnatbl -o $(BIN)/ts_extran ts_extran.ali

ts_matfun:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_matfun.adb
	gnatbl -o $(BIN)/ts_matfun ts_matfun.ali

ts_fraflt:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_fraflt.adb
	gnatbl -o $(BIN)/ts_fraflt ts_fraflt.ali

# Test programs for vectors, Matrices and linear-system solvers :

ts_natvec:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_natvec.adb
	gnatbl -o $(BIN)/ts_natvec ts_natvec.ali

ts_intvec:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_intvec.adb
	gnatbl -o $(BIN)/ts_intvec ts_intvec.ali

ts_fltvec:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_fltvec.adb
	gnatbl -o $(BIN)/ts_fltvec ts_fltvec.ali

ts_cmpvec:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_cmpvec.adb
	gnatbl -o $(BIN)/ts_cmpvec ts_cmpvec.ali

ts_natmat:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_natmat.adb
	gnatbl -o $(BIN)/ts_natmat ts_natmat.ali

ts_intmat:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_intmat.adb
	gnatbl -o $(BIN)/ts_intmat ts_intmat.ali

ts_fltmat:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_fltmat.adb
	gnatbl -o $(BIN)/ts_fltmat ts_fltmat.ali

ts_fltdls:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_fltdls.adb
	gnatbl -o $(BIN)/ts_fltdls ts_fltdls.ali

ts_cmpmat:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_cmpmat.adb
	gnatbl -o $(BIN)/ts_cmpmat ts_cmpmat.ali

ts_gcd:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_gcd.adb
	gnatbl -o $(BIN)/ts_gcd ts_gcd.ali

ts_qrd:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_qrd.adb
	gnatbl -o $(BIN)/ts_qrd ts_qrd.ali

ts_svd:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_svd.adb
	gnatbl -o $(BIN)/ts_svd ts_svd.ali

ts_nesvec:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_nesvec.adb
	gnatbl -o $(BIN)/ts_nesvec ts_nesvec.ali

ts_smith:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_smith.adb
	gnatbl -o $(BIN)/ts_smith ts_smith.ali

# Test programs for Polynomials :

ts_expvec:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_expvec.adb
	gnatbl -o $(BIN)/ts_expvec ts_expvec.ali

ts_poly:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_poly.adb
	gnatbl -o $(BIN)/ts_poly ts_poly.ali

ts_rpol:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_rpol.adb
	gnatbl -o $(BIN)/ts_rpol ts_rpol.ali

ts_polmat:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_polmat.adb
	gnatbl -o $(BIN)/ts_polmat ts_polmat.ali

ts_jaco:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_jaco.adb
	gnatbl -o $(BIN)/ts_jaco ts_jaco.ali

ts_evaline:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_evaline.adb
	gnatbl -o $(BIN)/ts_evaline ts_evaline.ali

ts_lineva:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_lineva.adb
	gnatbl -o $(BIN)/ts_lineva ts_lineva.ali

ts_parse:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_parse.adb
	gnatbl -o $(BIN)/ts_parse ts_parse.ali

ts_subs:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_subs
	gnatbl -o $(BIN)/ts_subs ts_subs.ali

# Test programs for Supports :

ts_basex:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_basex.adb
	gnatbl -o $(BIN)/ts_basex ts_basex.ali

ts_feasi:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_feasi.adb
	gnatbl -o $(BIN)/ts_feasi ts_feasi.ali

ts_enurs:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_enurs.adb
	gnatbl -o $(BIN)/ts_enurs ts_enurs.ali

ts_diclp:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_diclp.adb
	gnatbl -o $(BIN)/ts_diclp ts_diclp.ali

ts_givrot:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_givrot.adb
	gnatbl -o $(BIN)/ts_givrot ts_givrot.ali

ts_lstvec:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_lstvec.adb
	gnatbl -o $(BIN)/ts_lstvec ts_lstvec.ali

ts_fvector:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_fvector.adb
	gnatbl -o $(BIN)/ts_fvector ts_fvector.ali

# Test programs for the Homotopy library :

ts_sols:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_sols.adb
	gnatbl -o $(BIN)/ts_sols ts_sols.ali

ts_solfilt:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_solfilt.adb
	gnatbl -o $(BIN)/ts_solfilt ts_solfilt.ali

ts_solar:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_solar.adb
	gnatbl -o $(BIN)/ts_solar ts_solar.ali

ts_mapsols_io:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_mapsols_io.adb
	gnatbl -o $(BIN)/ts_mapsols_io ts_mapsols_io.ali

ts_grepsols:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_grepsols.adb
	gnatbl -o $(BIN)/ts_grepsols ts_grepsols.ali

mergesols:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) mergesols.adb
	gnatbl -o $(BIN)/mergesols mergesols.ali

ts_splitjoin:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_splitjoin.adb
	gnatbl -o $(BIN)/ts_splitjoin ts_splitjoin.ali

ts_quad:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_quad.adb
	gnatbl -o $(BIN)/ts_quad ts_quad.ali

ts_contab:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_contab.adb
	gnatbl -o $(BIN)/ts_contab ts_contab.ali

ts_drivscal:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_drivscal.adb
	gnatbl -o $(BIN)/ts_drivscal ts_drivscal.ali

ts_scal:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_scal.adb
	gnatbl -o $(BIN)/ts_scal ts_scal.ali

ts_drivred:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_drivred.adb
	gnatbl -o $(BIN)/ts_drivred ts_drivred.ali

ts_homotopy:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_homotopy.adb
	gnatbl -o $(BIN)/ts_homotopy ts_homotopy.ali

ts_homline:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_homline.adb
	gnatbl -o $(BIN)/ts_homline ts_homline.ali

# Test programs for the Newton library :

ts_mreseva:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_mreseva.adb
	gnatbl -o $(BIN)/ts_mreseva ts_mreseva.ali

ts_rootrefi:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_rootrefi.adb
	gnatbl -o $(BIN)/ts_rootrefi ts_rootrefi.ali

ts_newton:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_newton.adb
	gnatbl -o $(BIN)/ts_newton ts_newton.ali

ts_numdif:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_numdif.adb
	gnatbl -o $(BIN)/ts_numdif ts_numdif.ali

ts_jactrees:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_jactrees.adb
	gnatbl -o $(BIN)/ts_jactrees ts_jactrees.ali

ts_deftrees:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_deftrees.adb
	gnatbl -o $(BIN)/ts_deftrees ts_deftrees.ali

ts_deflate:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_deflate.adb
	gnatbl -o $(BIN)/ts_deflate ts_deflate.ali

ts_straight:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_straight.adb
	gnatbl -o $(BIN)/ts_straight ts_straight.ali

ts_stair:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_stair.adb
	gnatbl -o $(BIN)/ts_stair ts_stair.ali

ts_defmat:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_defmat.adb
	gnatbl -o $(BIN)/ts_defmat ts_defmat.ali

ts_multip:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_multip.adb
	gnatbl -o $(BIN)/ts_multip ts_multip.ali

ts_muldef:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_muldef.adb
	gnatbl -o $(BIN)/ts_muldef ts_muldef.ali

# Test programs for the Continuation library :

ts_pactun:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_pactun.adb
	gnatbl -o $(BIN)/ts_pactun ts_pactun.ali

ts_preco:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_preco.adb
	gnatbl -o $(BIN)/ts_preco ts_preco.ali

ts_path:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_path.adb
	gnatbl -o $(BIN)/ts_path ts_path.ali

ts_vlprs:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_vlprs.adb
	gnatbl -o $(BIN)/ts_vlprs ts_vlprs.ali

ts_track:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_track.adb
	gnatbl -o $(BIN)/ts_track ts_track.ali

ts_poco:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_poco.adb
	gnatbl -o $(BIN)/ts_poco ts_poco.ali

ts_exp:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_exp.adb
	gnatbl -o $(BIN)/ts_exp ts_exp.ali

ts_parcon:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_parcon.adb
	gnatbl -o $(BIN)/ts_parcon ts_parcon.ali

mypoco:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) mypoco.adb
	gnatbl -o $(BIN)/mypoco mypoco.ali

# Test programs for the Root_Counts/Product homotopies library :

ts_startsys:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_startsys.adb
	gnatbl -o $(BIN)/ts_startsys ts_startsys.ali

ts_permanent:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_permanent
	gnatbl -o $(BIN)/ts_permanent ts_permanent.ali

ts_prodsys:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_prodsys.adb
	gnatbl -o $(BIN)/ts_prodsys ts_prodsys.ali

ts_drivmhom:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_drivmhom.adb
	gnatbl -o $(BIN)/ts_drivmhom ts_drivmhom.ali

ts_drivmuho:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_drivmuho.adb
	gnatbl -o $(BIN)/ts_drivmuho ts_drivmuho.ali

ts_drivss:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_drivss.adb
	gnatbl -o $(BIN)/ts_drivss ts_drivss.ali

# Test programs in the Root_Counts/Fewnomials library :

ts_binwit:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_binwit.adb
	gnatbl -o $(BIN)/ts_binwit ts_binwit.ali

ts_fewsys:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_fewsys.adb
	gnatbl -o $(BIN)/ts_fewsys ts_fewsys.ali

ts_spasol:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_spasol.adb
	gnatbl -o $(BIN)/ts_spasol ts_spasol.ali

# Test programs for the Implicit lifting library :

ts_powlis:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_powlis.adb
	gnatbl -o $(BIN)/ts_powlis ts_powlis.ali

ts_drivpts:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_drivpts.adb
	gnatbl -o $(BIN)/ts_drivpts ts_drivpts.ali

ts_impvol:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_impvol.adb
	gnatbl -o $(BIN)/ts_impvol ts_impvol.ali

ts_durker:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_durker.adb
	gnatbl -o $(BIN)/ts_durker ts_durker.ali

ts_drivimpl:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_drivimpl.adb
	gnatbl -o $(BIN)/ts_drivimpl ts_drivimpl.ali

# Test programs for the static lifting library :

ts_rndcff:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_rndcff.adb
	gnatbl -o $(BIN)/ts_rndcff ts_rndcff.ali

ts_supsub:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_supsub.adb
	gnatbl -o $(BIN)/ts_supsub ts_supsub.ali

ts_conint:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_conint.adb
	gnatbl -o $(BIN)/ts_conint ts_conint.ali

ts_mixture:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_mixture.adb
	gnatbl -o $(BIN)/ts_mixture ts_mixture.ali

ts_mixvol:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_mixvol.adb
	gnatbl -o $(BIN)/ts_mixvol ts_mixvol.ali

ts_drivcrit:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_drivcrit.adb
	gnatbl -o $(BIN)/ts_drivcrit ts_drivcrit.ali

ts_drivstal:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_drivstal.adb
	gnatbl -o $(BIN)/ts_drivstal ts_drivstal.ali

# Test programs for the Dynamic lifting library :

ts_dyntri:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_dyntri.adb
	gnatbl -o $(BIN)/ts_dyntri ts_dyntri.ali

ts_drivmink:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_drivmink.adb
	gnatbl -o $(BIN)/ts_drivmink ts_drivmink.ali

ts_drivdynl:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_drivdynl.adb
	gnatbl -o $(BIN)/ts_drivdynl ts_drivdynl.ali

# Test programs for the Symmetry library :

ts_equpol:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_equpol.adb
	gnatbl -o $(BIN)/ts_equpol ts_equpol.ali

ts_drivsss:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_drivsss.adb
	gnatbl -o $(BIN)/ts_drivsss ts_drivsss.ali

# Target program for the ExtSoft library :

convsub:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) convsub.adb
	gnatbl -o $(BIN)/convsub convsub.ali

# Test programs for the embedded lifting library :

ts_trees:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_trees.adb
	gnatbl -o $(BIN)/ts_trees ts_trees.ali

ts_circuits:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_circuits.adb
	gnatbl -o $(BIN)/ts_circuits ts_circuits.ali

ts_balancers:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_balancers.adb
	gnatbl -o $(BIN)/ts_balancers ts_balancers.ali

# Test programs for SAGBI library in numerical Schubert calculus :

ts_subsets:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_subsets.adb
	gnatbl -o $(BIN)/ts_subsets ts_subsets.ali

ts_brackets:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_brackets.adb
	gnatbl -o $(BIN)/ts_brackets ts_brackets.ali

ts_brackmons:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_brackmons.adb
	gnatbl -o $(BIN)/ts_brackmons ts_brackmons.ali

ts_brackpols:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_brackpols.adb
	gnatbl -o $(BIN)/ts_brackpols ts_brackpols.ali

ts_straighten:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_straighten.adb
	gnatbl -o $(BIN)/ts_straighten ts_straighten.ali

ts_expand:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_expand.adb
	gnatbl -o $(BIN)/ts_expand ts_expand.ali

ts_local:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_local.adb
	gnatbl -o $(BIN)/ts_local ts_local.ali

ts_mathom:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_mathom.adb
	gnatbl -o $(BIN)/ts_mathom ts_mathom.ali

ts_cheby:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_cheby.adb
	gnatbl -o $(BIN)/ts_cheby ts_cheby.ali

ts_shapiro:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_shapiro.adb
	gnatbl -o $(BIN)/ts_shapiro ts_shapiro.ali

ts_eremenko:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_eremenko.adb
	gnatbl -o $(BIN)/ts_eremenko ts_eremenko.ali

ts_detrock:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_detrock.adb
	gnatbl -o $(BIN)/ts_detrock ts_detrock.ali

ts_sagbi:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_sagbi.adb
	gnatbl -o $(BIN)/ts_sagbi ts_sagbi.ali

ts_topos:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_topos.adb
	gnatbl -o $(BIN)/ts_topos ts_topos.ali

# Test programs for Pieri library in numerical Schubert calculus :

ts_org_pieri:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_org_pieri.adb
	gnatbl -o $(BIN)/ts_org_pieri ts_org_pieri.ali

ts_canocurv:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_canocurv.adb
	gnatbl -o $(BIN)/ts_canocurv ts_canocurv.ali

ts_matinv:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_matinv.adb
	gnatbl -o $(BIN)/ts_matinv ts_matinv.ali

ts_pieri:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_pieri.adb
	gnatbl -o $(BIN)/ts_pieri ts_pieri.ali

ts_posets:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_posets.adb
	gnatbl -o $(BIN)/ts_posets ts_posets.ali

ts_detsys:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_detsys.adb
	gnatbl -o $(BIN)/ts_detsys ts_detsys.ali

ts_defpos:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_defpos.adb
	gnatbl -o $(BIN)/ts_defpos ts_defpos.ali

ts_piroco:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_piroco.adb
	gnatbl -o $(BIN)/ts_piroco ts_piroco.ali

# Test programs for Induction library in numerical Schubert calculus :

ts_checkers:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_checkers.adb
	gnatbl -o $(BIN)/ts_checkers ts_checkers.ali

ts_induce:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_induce.adb
	gnatbl -o $(BIN)/ts_induce ts_induce.ali

# Test programs for the evaluators :

ts_cyclic7:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_cyclic7.adb
	gnatbl -o $(BIN)/ts_cyclic7 ts_cyclic7.ali

solve_cyclic7:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) solve_cyclic7.adb
	gnatbl -o $(BIN)/solve_cyclic7 solve_cyclic7.ali

# Test programs for the Experiments/ERMCC :

ts_rbasex:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_rbasex.adb
	gnatbl -o $(BIN)/ts_basex ts_rbasex.ali

ts_rfeasi:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_rfeasi.adb
	gnatbl -o $(BIN)/ts_rfeasi ts_rfeasi.ali

ts_mcc:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_mcc.adb
	gnatbl -o $(BIN)/ts_mcc ts_mcc.ali

ts_circuits1:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_circuits.adb
	gnatbl -o $(BIN)/ts_circuits ts_circuits.ali

ts_enum:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_enum.adb
	gnatbl -o $(BIN)/ts_enum ts_enum.ali

# Test programs for the Experiments/ToricNewt :

ts_ransup:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_ransup.adb
	gnatbl -o $(BIN)/ts_ransup ts_ransup.ali

ts_norfan:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_norfan.adb
	gnatbl -o $(BIN)/ts_norfan ts_norfan.ali

ts_facnor:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_facnor.adb
	gnatbl -o $(BIN)/ts_facnor ts_facnor.ali

rancond:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) rancond.adb
	gnatbl -o $(BIN)/rancond rancond.ali

ts_torsys:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_torsys.adb
	gnatbl -o $(BIN)/ts_torsys ts_torsys.ali

ts_binpow:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_binpow.adb
	gnatbl -o $(BIN)/ts_binpow ts_binpow.ali

# Test programs for the Components/Samplers library :

ts_roots:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_roots.adb
	gnatbl -o $(BIN)/ts_roots ts_roots.ali

ts_hypsam:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_hypsam.adb
	gnatbl -o $(BIN)/ts_hypsam ts_hypsam.ali

ts_hyprts:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_hyprts.adb
	gnatbl -o $(BIN)/ts_hyprts ts_hyprts.ali

ts_hyppts:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_hyppts.adb
	gnatbl -o $(BIN)/ts_hyppts ts_hyppts.ali

ts_unisam:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_unisam.adb
	gnatbl -o $(BIN)/ts_unisam ts_unisam.ali

ts_planes:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_planes.adb
	gnatbl -o $(BIN)/ts_planes ts_planes.ali

ts_flag:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_flag.adb
	gnatbl -o $(BIN)/ts_flag ts_flag.ali

ts_coords:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_coords.adb
	gnatbl -o $(BIN)/ts_coords ts_coords.ali

ts_itrack:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_itrack.adb
	gnatbl -o $(BIN)/ts_itrack ts_itrack.ali

ts_ispan:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_ispan.adb
	gnatbl -o $(BIN)/ts_ispan ts_ispan.ali

ts_inewt:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_inewt.adb
	gnatbl -o $(BIN)/ts_inewt ts_inewt.ali

ts_iwset:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_iwset.adb
	gnatbl -o $(BIN)/ts_iwset ts_iwset.ali

ts_sampar:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_sampar.adb
	gnatbl -o $(BIN)/ts_sampar ts_sampar.ali

ts_sample:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_sample.adb
	gnatbl -o $(BIN)/ts_sample ts_sample.ali

ts_mulsam:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_mulsam.adb
	gnatbl -o $(BIN)/ts_mulsam ts_mulsam.ali

ts_mulhom:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_mulhom.adb
	gnatbl -o $(BIN)/ts_mulhom ts_mulhom.ali

ts_endgm:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_endgm.adb
	gnatbl -o $(BIN)/ts_endgm ts_endgm.ali

ts_locdim:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_locdim.adb
	gnatbl -o $(BIN)/ts_locdin ts_locdim.ali

# Test programs for the Components/Interpolators libary :

ts_stpolin:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_stpolin.adb
	gnatbl -o $(BIN)/ts_stpolin ts_stpolin.ali

ts_mupolin:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_mupolin.adb
	gnatbl -o $(BIN)/ts_mupolin ts_mupolin.ali

ts_adpolin:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_adpolin.adb
	gnatbl -o $(BIN)/ts_adpolin ts_adpolin.ali

ts_project:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_project.adb
	gnatbl -o $(BIN)/ts_project ts_project.ali

ts_span:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_span.adb
	gnatbl -o $(BIN)/ts_span ts_span.ali

ts_filter:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_filter.adb
	gnatbl -o $(BIN)/ts_filter ts_filter.ali

ts_nbterms:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_nbterms.adb
	gnatbl -o $(BIN)/ts_nbterms ts_nbterms.ali

ts_divdif:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_divdif.adb
	gnatbl -o $(BIN)/ts_divdif ts_divdif.ali

ts_dvdexp:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_dvdexp.adb
	gnatbl -o $(BIN)/ts_dvdexp ts_dvdexp.ali

ts_newint:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_newint.adb
	gnatbl -o $(BIN)/ts_newint ts_newint.ali

ts_powtrc:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_powtrc.adb
	gnatbl -o $(BIN)/ts_powtrc ts_powtrc.ali

ts_traces:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_traces.adb
	gnatbl -o $(BIN)/ts_traces ts_traces.ali

ts_trapol:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_trapol.adb
	gnatbl -o $(BIN)/ts_trapol ts_trapol.ali

ts_rewrite:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_rewrite.adb
	gnatbl -o $(BIN)/ts_rewrite ts_rewrite.ali

ts_elim:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_elim.adb
	gnatbl -o $(BIN)/ts_elim ts_elim.ali

ts_embed:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_embed.adb
	gnatbl -o $(BIN)/ts_embed ts_embed.ali

ts_square:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_square.adb
	gnatbl -o $(BIN)/ts_square ts_square.ali

ts_squemb:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_squemb.adb
	gnatbl -o $(BIN)/ts_squemb ts_squemb.ali

# Test programs in the Components/Factorization library :

ts_rwpoly:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_rwpoly.adb
	gnatbl -o $(BIN)/ts_rwpoly ts_rwpoly.ali

ts_irco:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_irco.adb
	gnatbl -o $(BIN)/ts_irco ts_irco.ali

ts_combfac:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_combfac.adb
	gnatbl -o $(BIN)/ts_combfac ts_combfac.ali

ts_newfac:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_newfac.adb
	gnatbl -o $(BIN)/ts_newfac ts_newfac.ali

ts_factor:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_factor.adb
	gnatbl -o $(BIN)/ts_factor ts_factor.ali

ts_ifactor:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_ifactor.adb
	gnatbl -o $(BIN)/ts_ifactor ts_ifactor.ali

ts_randpoly:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_randpoly.adb
	gnatbl -o $(BIN)/ts_randpoly ts_randpoly.ali

ts_mulfac:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_mulfac.adb
	gnatbl -o $(BIN)/ts_mulfac ts_mulfac.ali

ts_hypfac:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_hypfac.adb
	gnatbl -o $(BIN)/ts_hypfac ts_hypfac.ali

ts_monfac:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_monfac.adb
	gnatbl -o $(BIN)/ts_monfac ts_monfac.ali

# Test programs in the Components/Decomposition library :

ts_irdeco:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_irdeco.adb
	gnatbl -o $(BIN)/ts_irdeco ts_irdeco.ali

ts_breakup:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_breakup.adb
	gnatbl -o $(BIN)/ts_breakup ts_breakup.ali

ts_cascade:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_cascade.adb
	gnatbl -o $(BIN)/ts_cascade ts_cascade.ali

ts_intcas:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_intcas.adb
	gnatbl -o $(BIN)/ts_intcas ts_intcas.ali

ts_intdia:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_intdia.adb # $(CLARGS)
	gnatbl -o $(BIN)/ts_intdia ts_intdia.ali

ts_sqem:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_sqem.adb
	gnatbl -o $(BIN)/ts_sqem ts_sqem.ali

ts_reorder:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_reorder.adb
	gnatbl -o $(BIN)/ts_reorder ts_reorder.ali

ts_filfac:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_filfac.adb
	gnatbl -o $(BIN)/ts_filfac ts_filfac.ali

ts_squeeze:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_squeeze.adb
	gnatbl -o $(BIN)/ts_squeeze ts_squeeze.ali

ts_dimred:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_dimred.adb
	gnatbl -o $(BIN)/ts_dimred ts_dimred.ali

ts_mbthom:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_mbthom.adb
	gnatbl -o $(BIN)/ts_mbthom ts_mbthom.ali

ts_diahom:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_diahom.adb
	gnatbl -o $(BIN)/ts_diahom ts_diahom.ali

ts_fillit:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_fillit.adb
	gnatbl -o $(BIN)/ts_fillit ts_fillit.ali

# Test programs in the Components/Solver library :

ts_hypwit:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_hypwit.adb
	gnatbl -o $(BIN)/ts_hypwit ts_hypwit.ali

ts_solver:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_solver.adb
	gnatbl -o $(BIN)/ts_solver ts_solver.ali

testnine:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) testnine.adb
	gnatbl -o $(BIN)/testnine testnine.ali

# Test programs in the Differentials library :

ts_prolong:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_prolong.adb
	gnatbl -o $(BIN)/ts_prolong ts_prolong.ali

ts_dae:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_dae.adb
	gnatbl -o $(BIN)/ts_dae ts_dae.ali

# test programs for CtoPHC/Funky directory :

ts_arrays:
	gnatmake -o $(BIN)/ts_arrays $(INCLULIBS) $(GNATFLAGS) ts_arrays.adb

pass_poly:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) print_poly.adb
	gcc -c $(PHCAda)/CtoPHC/Funky/pass_poly.c
	gnatbind -n -C print_poly
	gnatlink -C print_poly pass_poly.o -o $(BIN)/pass_poly

ts_cosup:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_cosup.adb
	gnatbl -o $(BIN)/ts_cosup ts_cosup.ali

ts_cosupoly:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) cosupoly.adb
	gcc -c $(PHCAda)/CtoPHC/Funky/ts_cosupoly.c
	gnatbind -n -C cosupoly
	gnatlink -C cosupoly ts_cosupoly.o -o $(BIN)/ts_cosupoly

ts_cosupsys:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) cosupsys.adb
	gcc -c $(PHCAda)/CtoPHC/Funky/ts_cosupsys.c
	gnatbind -n -C cosupsys
	gnatlink -C cosupsys ts_cosupsys.o -o $(BIN)/ts_cosupsys

cosupoly_to_c.o:
	gcc -c $(PHCAda)/CtoPHC/Funky/cosupoly_to_c.c

cosupsys_to_c.o:
	gcc -c $(PHCAda)/CtoPHC/Funky/cosupsys_to_c.c

ts_cosuptoc: cosupoly_to_c.o cosupsys_to_c.o
	gnatmake -o $(BIN)/ts_cosuptoc $(INCLULIBS) $(GNATFLAGS) \
                  ts_cosuptoc.adb -largs cosupoly_to_c.o cosupsys_to_c.o

ts_getsys:
	gcc -c $(PHCAda)/CtoPHC/Funky/getsys2.c
	gcc -c $(PHCAda)/CtoPHC/Funky/ts_getsys.c
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) getsys1.adb
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) getsys3.adb
	gnatbind -n -C getsys1 getsys3
	gnatlink -C getsys3 ts_getsys.o getsys2.o -o $(BIN)/ts_getsys

ts_phc_sys_rw:
	gcc -c $(PHCAda)/CtoPHC/Funky/ts_phc_sys_rw.c
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) phc_sys_rw.adb
	gnatbind -n -C phc_sys_rw
	gnatlink -C phc_sys_rw ts_phc_sys_rw.o -o $(BIN)/ts_phc_sys_rw

ts_phc_sol_rw:
	gcc -c $(PHCAda)/CtoPHC/Funky/ts_phc_sol_rw.c
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) phc_sol_rw.adb
	gnatbind -n -C phc_sol_rw
	gnatlink -C phc_sol_rw ts_phc_sol_rw.o -o $(BIN)/ts_phc_sol_rw

ts_cpm:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_cpm.adb
	gnatbl -o $(BIN)/ts_cpm ts_cpm.ali

ts_pieri_count:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) pieri_count.adb
	gcc -c $(PHCAda)/CtoPHC/Funky/ts_pieri_count.c
	gnatbind -n -C pieri_count
	gnatlink -C pieri_count ts_pieri_count.o -o $(BIN)/ts_pieri_count

ts_pieri_solver:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) pieri_solver.adb
	gcc -c $(PHCAda)/CtoPHC/Funky/ts_pieri_solver.c
	gcc -c $(PHCAda)/CtoPHC/Funky/pieri_sols.c
	gnatbind -n -C pieri_solver
	gnatlink -C pieri_solver ts_pieri_solver.o pieri_sols.o \
                 -o $(BIN)/ts_pieri_solver -lm

ts_phc_solver:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) phc_solver.adb
	gcc -c $(PHCAda)/CtoPHC/Funky/ts_phc_solver.c
	gcc -c $(PHCAda)/CtoPHC/Funky/phc_sols.c
	gnatbind -n -C phc_solver
	gnatlink -C phc_solver ts_phc_solver.o phc_sols.o \
                 -o $(BIN)/ts_phc_solver

ts_csols:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_csols.adb
	gnatbl -o $(BIN)/ts_csols ts_csols.ali

path_tracker.o:
	gcc -c $(PHCAda)/CtoPHC/path_tracker.c

path_sols.o:
	gcc -c $(PHCAda)/CtoPHC/path_sols.c

ts_path_tracker: path_tracker.o path_sols.o
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_path_tracker.adb
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) track_paths.adb
	gnatmake -o $(BIN)/ts_path_tracker $(INCLULIBS) $(GNATFLAGS) \
        ts_path_tracker.adb -largs path_tracker.o track_paths.o path_sols.o

# test programs for the CtoPHC/State directory :

ts_solcon:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_solcon.adb
	gnatbl -o $(BIN)/ts_solcon ts_solcon.ali

ts_use_solcon:
	gcc -c $(PHCAda)/CtoPHC/State/ts_use_solcon.c
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_solcon.adb
	gnatbind -n -C use_solcon
	gnatlink -C use_solcon ts_use_solcon.o -o $(BIN)/ts_use_solcon

ts_syscon:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_syscon.adb
	gnatbl -o $(BIN)/ts_syscon ts_syscon.ali

ts_use_syscon:
	gcc -c $(PHCAda)/CtoPHC/State/ts_use_syscon.c
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_syscon.adb
	gnatbind -n -C use_syscon
	gnatlink -C use_syscon ts_use_syscon.o -o $(BIN)/ts_use_syscon

ts_c2phc:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) c_to_phcpack.adb
	gcc -c $(PHCAda)/CtoPHC/State/ts_c2phc.c
	gnatbind -n -C c_to_phcpack
	gnatlink -C c_to_phcpack ts_c2phc.o -o $(BIN)/ts_c2phc

ts_c2str:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gcc -c $(PHCAda)/CtoPHC/State/ts_c2str.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc ts_c2str.o -o $(BIN)/ts_c2str

ts_use_c2phc:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gcc -c $(PHCAda)/CtoPHC/State/ts_use_c2phc.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc ts_use_c2phc.o -o $(BIN)/ts_use_c2phc

ts_pirhom:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_pirhom.adb
	gnatbl -o $(BIN)/ts_pirhom ts_pirhom.ali

ts_use_c2pieri:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2pieri.adb
	gcc -c $(PHCAda)/CtoPHC/State/ts_use_c2pieri.c
	gnatbind -n -C use_c2pieri
	gnatlink -C use_c2pieri ts_use_c2pieri.o -o $(BIN)/ts_use_c2pieri

ts_use_c2fac:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2fac.adb
	gcc -c $(PHCAda)/CtoPHC/State/ts_use_c2fac.c
	gnatbind -n -C use_c2fac
	gnatlink -C use_c2fac ts_use_c2fac.o -o $(BIN)/ts_use_c2fac

ts_celcon:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_celcon.adb
	gnatbl -o $(BIN)/ts_celcon ts_celcon.ali

ts_use_celcon:
	gcc -c $(PHCAda)/CtoPHC/State/ts_use_celcon.c
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_celcon.adb
	gnatbind -n -C use_celcon
	gnatlink -C use_celcon ts_use_celcon.o -o $(BIN)/ts_use_celcon

# files in feedback :

lib.a:$(PHCAda)/../Feedback/*.c $(PHCAda)/../Feedback/*.h
	gcc -c $(PHCAda)/../Feedback/*.c
	ar ruv lib.a    dc_interpolation.o  dcmplx.o       poly_matrix.o\
       append_dcmatrix.o    dc_inverse.o        pieri_sols.o   poly_smith.o\
       c2ada_dc_matrix.o    dc_matrix.o         poly_dcmplx.o  realization.o\
       c2ada_poly_matrix.o  dc_roots.o          poly_gcd.o     ts_feedback.o\
       poly_hermite.o       append_polymatrix.o timer.o
	ranlib lib.a

ts_feedback: lib.a get_clock.o get_clocks_per_sec.o
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) pieri_solver.adb
	gnatbind -n -C pieri_solver
	gnatlink -C pieri_solver lib.a \
                 -o $(BIN)/ts_feedback  -lm \
                 get_clock.o get_clocks_per_sec.o

feedback.o:
	gcc -c $(PHCAda)/../Feedback/feedback.c

# Test programs for the Main interactive drivers :

ts_drivroco:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) ts_drivroco.adb
	gnatbl -o $(BIN)/ts_drivroco ts_drivroco.ali

convert_formats:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) convert_formats.adb
	gnatbl -o $(BIN)/convert_formats convert_formats.ali

use_phc:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_phc.adb
	gnatbl -o $(BIN)/use_phc use_phc.ali

phc: lib.a feedback.o get_clock.o get_clocks_per_sec.o
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) pieri_solver.adb
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) dispatch.adb
	gnatmake -o $(BIN)/phc $(INCLULIBS) $(GNATFLAGS) dispatch.adb \
                 -largs lib.a pieri_solver.o feedback.o \
                        get_clock.o get_clocks_per_sec.o -lm

# Test programs for the Library Lib :

phcpack.o:
	gcc -c $(PHCLib)/phcpack.c

use_c2phc.o:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb

lib_read:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gcc -c $(PHCLib)/phcpack.c
	gcc -c $(PHCLib)/lib_read.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o lib_read.o -o ../bin/lib_read

lib_syscon:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gcc -c $(PHCLib)/syscon.c
	gcc -c $(PHCLib)/lib_syscon.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc syscon.o lib_syscon.o -o ../bin/lib_syscon

lib_solcon:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gcc -c $(PHCLib)/solcon.c
	gcc -c $(PHCLib)/lib_solcon.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc solcon.o lib_solcon.o -o ../bin/lib_solcon

lib_newton:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gcc -c $(PHCLib)/phcpack.c
	gcc -c $(PHCLib)/lib_newton.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o lib_newton.o \
                 -o ../bin/lib_newton

lib_celcon:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gcc -c $(PHCLib)/phcpack.c
	gcc -c $(PHCLib)/solcon.c
	gcc -c $(PHCLib)/celcon.c
	gcc -c $(PHCLib)/lib_celcon.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o solcon.o celcon.o lib_celcon.o \
                 -o ../bin/lib_celcon

lib_conpar:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gcc -c $(PHCLib)/phcpack.c
	gcc -c $(PHCLib)/lib_conpar.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o lib_conpar.o -o ../bin/lib_conpar

lib_track:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gcc -c $(PHCLib)/phcpack.c
	gcc -c $(PHCLib)/syscon.c
	gcc -c $(PHCLib)/solcon.c
	gcc -c $(PHCLib)/lib_track.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o lib_track.o solcon.o syscon.o \
                 -o ../bin/lib_track

lib_poco:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gcc -c $(PHCLib)/phcpack.c
	gcc -c $(PHCLib)/lib_poco.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o lib_poco.o -o ../bin/lib_poco

lib_factor:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gcc -c $(PHCLib)/phcpack.c
	gcc -c $(PHCLib)/solcon.c
	gcc -c $(PHCLib)/lib_factor.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc phcpack.o solcon.o lib_factor.o \
                 -o ../bin/lib_factor

phc_solve:
	gnatmake -c $(INCLULIBS) $(GNATFLAGS) use_c2phc.adb
	gcc -c $(PHCLib)/syscon.c
	gcc -c $(PHCLib)/solcon.c
	gcc -c $(PHCLib)/phcpack.c
	gcc -c $(PHCLib)/phc_solve.c
	gnatbind -n -C use_c2phc
	gnatlink -C use_c2phc syscon.o solcon.o phcpack.o phc_solve.o \
                 -o ../bin/phc_solve

# cleaning up the object files :

clean:
	/bin/rm -f  b*
	/bin/rm -f  *.o
	/bin/rm -f  *.ali
	/bin/rm -f  lib.a
