pow is a stdlib function, but to use it you should link the stdlib itself (math lib).

Usually gcc does it automatically, but try adding -lm link flag:

gcc -lm Update.o ScanData.o <..the rest of object files..>

Also make sure that libc is present in system (on debian/ubuntu - dpkg -s libc6-dev should tell that it is installed)

Not directly related to question: does main.o really depend on all the sources? it only builds from main.c

This happens because your Makefile doesn’t explain how to build tema1 (from Make’s perspective), so it uses its built-in rules:

• run depends on tema1;
• tema1 doesn’t have a definition, but there’s a C file, so Make tries to compile it using its default rule, which doesn’t specify -lm.

To fix this, say

tema1: tema1.c
        gcc tema1.c -o tema1 -lm

instead of build: tema1.c etc.

You can reduce repetition by using automatic variables:

tema1: tema1.c
        gcc @ -lm

To keep “named” rules (run, build etc.), make them depend on concrete artifacts (apart from clean, since it doesn’t produce anything), add separate rules for the concrete artifacts, and mark the “named” rules as phony (so Make won’t expect a corresponding on-disk artifact):

build: tema1

tema1: tema1.c
        gcc @ -lm

.PHONY: run build clean

It’s also worth changing clean so it doesn’t fail when there’s nothing to clean:

clean:
        rm -f *.o tema1

You have not specified a rule for calc, but are generating it in your rule for calc.o. Try altering your Makefile to include these rules:

calc: calc.o
  gcc -o calc calc.o -lm

calc.o: calc.c calc.h
  gcc -Wall -std=c99 -c calc.c

-lm should go into LDLIBS, not CFLAGS in the Makefile.

LDLIBS = -lm

See https://www.gnu.org/software/make/manual/html_node/Implicit-Variables.html

Although, CFLAGS is also passed to the compiler, ``-lmneeds to be at the *end* of the commandline. That's why specifying it inCFLAGSdoesn't work because it needs to be passed at the *linking* stage (specifying-lm` at the end provides equivalent functionality).

Your research has led you along the right lines.

Examination of the software's Makefile shows that the rules for creating target parsefish are

parsefsh: parsefsh.o fshfunc.o projection.o

parsefsh.o: parsefsh.c fshfunc.h

fshfunc.o: fshfunc.c fshfunc.h

projection.o: projection.c projection.h

Because there are no explicit actions for these rules, GNU Make uses its built-in rules. For the compile phase (.c to .o) that's

$(CC) $(CPPFLAGS) $(CFLAGS) -c

which works fine, given the Makefile's definitions

CC = gcc
CFLAGS = -Wall -Wextra -g -std=gnu99 -DHAVE_VLOG

however in the link phase, the rule is of the form

$(CC) $(LDFLAGS) n.o $(LOADLIBES) $(LDLIBS)

Note that $(LDFLAGS) comes before the object code file n.o, whereas $(LOADLIBES) and $(LDLIBS) come after. In the Makefile, only LDFLAGS is defined:

LDFLAGS = -lm

which puts -lm in the wrong place (references are resolved from left to right).

The simplest solution is simply to change LDFLAGS = -lm to LDLIBS = -lm.

The problem here is the order you link with the math library (the -lm option). Libraries should be after the sources or object files on the command line when building.

So if you ran the command to build manually, it should look like

gcc p1.c -o p1 -lm

The problem is that your makefile doesn't really do anything, and it lives on implicit rules alone. The implicit rules use certain variables in a certain order which do not place the library in the right position in your makefile.

Try instead something like this makefile:

# The C compiler to use.
CC = gcc

# The C compiler flags to use.
# The -g flag is for adding debug information.
# The -Wall flag is to enable more warnings from the compiler
CFLAGS = -g -Wall

# The linker flags to use, none is okay.
LDFLAGS = 

# The libraries to link with.
LDLIBS = -lm

# Define the name of the executable you want to build.
EXEC = p1

# List the object files needed to create the executable above.
OBJECTS = p1.o

# Since this is the first rule, it's also the default rule to make
# when no target is specified. It depends only on the executable
# being built.
all: $(EXEC)

# This rule tells make that the executable being built depends on
# certain object files. This will link using $(LDFLAGS) and $(LDLIBS).
$(EXEC): $(OBJECTS)

# No rule needed for the object files. The implicit rules used
# make together with the variable defined above will make sure
# they are built with the expected flags.

# Target to clean up. Removes the executable and object files.
# This target is not really necessary but is common, and can be
# useful if special handling is needed or there are many targets
# to clean up.
clean:
    -rm -f *.o $(EXEC)

If you run make using the above makefile, the make program should first build the object file p1.o from the source file p1.c. Then is should use the p1.o object file to link the executable p1 together with the standard math library.

The libraries being linked to should be specified after there is a reference to them. Thus, you will change the command to:

gcc  -g -O2 -fopenmp -L/usr/lib  -o lenstool_tab e_nfwg.o lenstool_tab.o midpnt.o nrutil.o polint.o qromo.o read_bin.o lenstool_tab.o -lcfitsio -lm

This should fix your problem. You can possibly fix the problem in your Makefile so that the libraries are specified later.