ANSI C
- » Variable handling
- » Miscellaneous
- » POSIX
- » Date/Time
- » Math
- » Strings
- » PCRE
- » Arrays
- » Classes
- » Program execution
- » Directories
- » Filesystem
- » Memory
- » GD
- » Network
- » menu_code_ansiccode_socket
PERL
PHP
JavaScript

CONTENT

CHANGES

Szukaj

#top Math¶

[<<]|[<]|[^]|[v]|[>]|[>>]|[Zwiń]|[#top]|[X]

code / ansic / Math

#top Makefile¶

Dla ułatwienia korzystania z przykładów został utworzony jeden zbiorczy plik Makefile kompilujący przykłady użycia poniżej wymienionych funkcji związanych z operacjami matematycznymi.

Poniższe pliki Makefile zakładają obecność wszystkich plików przykładów, w przypadku chęci kompilacji za pomocą Makefile tylko wybranego przykładu należy zakomentować w pliku Makefile ostatnią pozycję zawierającą listę wszystkich targetów do wykonania make: $(ABS) ..., a następnie odkomentować powyżej komendę make zawierającą nazwę targetu dla bieżącego przykładu, np: w przypadku chęci kompilacji tylko przykładu abs należy zakomentować ostatnią pozycję rozpoczynającą się od make: $(ABS) ... (wstawić na początku przed make znak #), a następnie odkomentować pozycję: #make: $(ABS) (usunąć znak #).

#top Makefile (linux)¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_EXP2=1 -DHAVE_LOG2=1 -DHAVE_FDIM=1 -DHAVE_FMIN=1 -DHAVE_FMAX=1 -DHAVE_FPCLASSIFY=1 -DHAVE_ISFINITE=1 -DHAVE_ISNORMAL=1 -DHAVE_ISNAN=1 -DHAVE_ISINF=1 -DHAVE_SIGNBIT=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long
LIBS        = -lm
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

ABS         = abs
ACOS        = acos
ACOSH       = acosh
ASIN        = asin
ASINH       = asinh
ATAN2       = atan2
ATAN        = atan
ATANH       = atanh
CBRT        = cbrt
CEIL        = ceil
COPYSIGN    = copysign
COS         = cos
COSH        = cosh
DIV         = div
DREM        = drem
ERF         = erf
ERFC        = erfc
EXP10       = exp10
EXP2        = exp2
EXP         = exp
EXPM1       = expm1
FABS        = fabs
FDIM        = fdim
FLOOR       = floor
FMA         = fma
FMAX        = fmax
FMIN        = fmin
FMOD        = fmod
FPCLASSIFY  = fpclassify
FREXP       = frexp
GAMMA       = gamma
HYPOT       = hypot
INITSTATE   = initstate
ISFINITE    = isfinite
ISINF       = isinf
ISNAN       = isnan
ISNORMAL    = isnormal
LABS        = labs
LDEXP       = ldexp
LDIV        = ldiv
LGAMMA      = lgamma
LLABS       = llabs
LLDIV       = lldiv
LLRINT      = llrint
LLROUND     = llround
LOG10       = log10
LOG1P       = log1p
LOG2        = log2
LOGB        = logb
LOG         = log
LRINT       = lrint
LROUND      = lround
MODF        = modf
NEARBYINT   = nearbyint
NEXTAFTER   = nextafter
NEXTTOWARD  = nexttoward
POW10       = pow10
POW         = pow
RAND        = rand
RANDOM      = random
REMAINDER   = remainder
REMQUO      = remquo
RINT        = rint
ROUND       = round
SCALB       = scalb
SCALBLN     = scalbln
SCALBN      = scalbn
SETSTATE    = setstate
SIGNBIT     = signbit
SIN         = sin
SINH        = sinh
SQRT        = sqrt
SRAND1      = srand1
SRAND2      = srand2
SRANDOM1    = srandom1
SRANDOM2    = srandom2
TAN         = tan
TANH        = tanh
TGAMMA      = tgamma
TRUNC       = trunc



all: objdir make

objdir:
	$(MKDCMD) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(ABS)
#make: $(ACOS)
#make: $(ACOSH)
#make: $(ASIN)
#make: $(ASINH)
#make: $(ATAN2)
#make: $(ATAN)
#make: $(ATANH)
#make: $(CBRT)
#make: $(CEIL)
#make: $(COPYSIGN)
#make: $(COS)
#make: $(COSH)
#make: $(DIV)
#make: $(DREM)
#make: $(ERF)
#make: $(ERFC)
#make: $(EXP10)
#make: $(EXP2)
#make: $(EXP)
#make: $(EXPM1)
#make: $(FABS)
#make: $(FDIM)
#make: $(FLOOR)
#make: $(FMA)
#make: $(FMAX)
#make: $(FMIN)
#make: $(FMOD)
#make: $(FPCLASSIFY)
#make: $(FREXP)
#make: $(GAMMA)
#make: $(HYPOT)
#make: $(INITSTATE)
#make: $(ISFINITE)
#make: $(ISINF)
#make: $(ISNAN)
#make: $(ISNORMAL)
#make: $(LABS)
#make: $(LDEXP)
#make: $(LDIV)
#make: $(LGAMMA)
#make: $(LLABS)
#make: $(LLDIV)
#make: $(LLRINT)
#make: $(LLROUND)
#make: $(LOG10)
#make: $(LOG1P)
#make: $(LOG2)
#make: $(LOGB)
#make: $(LOG)
#make: $(LRINT)
#make: $(LROUND)
#make: $(MODF)
#make: $(NEARBYINT)
#make: $(NEXTAFTER)
#make: $(NEXTTOWARD)
#make: $(POW10)
#make: $(POW)
#make: $(RAND)
#make: $(RANDOM)
#make: $(REMAINDER)
#make: $(REMQUO)
#make: $(RINT)
#make: $(ROUND)
#make: $(SCALB)
#make: $(SCALBLN)
#make: $(SCALBN)
#make: $(SETSTATE)
#make: $(SIGNBIT)
#make: $(SIN)
#make: $(SINH)
#make: $(SQRT)
#make: $(SRAND1)
#make: $(SRAND2)
#make: $(SRANDOM1)
#make: $(SRANDOM2)
#make: $(TAN)
#make: $(TANH)
#make: $(TGAMMA)
#make: $(TRUNC)
make: $(ABS) $(ACOS) $(ACOSH) $(ASIN) $(ASINH) $(ATAN2) $(ATAN) $(ATANH) $(CBRT) $(CEIL) $(COPYSIGN) $(COS) $(COSH) $(DIV) $(DREM) $(ERF) $(ERFC) $(EXP10) $(EXP2) $(EXP) $(EXPM1) $(FABS) $(FDIM) $(FLOOR) $(FMA) $(FMAX) $(FMIN) $(FMOD) $(FPCLASSIFY) $(FREXP) $(GAMMA) $(HYPOT) $(INITSTATE) $(ISFINITE) $(ISINF) $(ISNAN) $(ISNORMAL) $(LABS) $(LDEXP) $(LDIV) $(LGAMMA) $(LLABS) $(LLDIV) $(LLRINT) $(LLROUND) $(LOG10) $(LOG1P) $(LOG2) $(LOGB) $(LOG) $(LRINT) $(LROUND) $(MODF) $(NEARBYINT) $(NEXTAFTER) $(NEXTTOWARD) $(POW10) $(POW) $(RAND) $(RANDOM) $(REMAINDER) $(REMQUO) $(RINT) $(ROUND) $(SCALB) $(SCALBLN) $(SCALBN) $(SETSTATE) $(SIGNBIT) $(SIN) $(SINH) $(SQRT) $(SRAND1) $(SRAND2) $(SRANDOM1) $(SRANDOM2) $(TAN) $(TANH) $(TGAMMA) $(TRUNC)



$(ABS): $(ABS).o
	$(GCC) -o $(ABS) obj/$(ABS).o $(LDFLAGS)
$(ABS).o:
	$(GCC) -o obj/$(ABS).o -c $(ABS).c $(CFLAGS)

$(ACOS): $(ACOS).o
	$(GCC) -o $(ACOS) obj/$(ACOS).o $(LDFLAGS)
$(ACOS).o:
	$(GCC) -o obj/$(ACOS).o -c $(ACOS).c $(CFLAGS)

$(ACOSH): $(ACOSH).o
	$(GCC) -o $(ACOSH) obj/$(ACOSH).o $(LDFLAGS)
$(ACOSH).o:
	$(GCC) -o obj/$(ACOSH).o -c $(ACOSH).c $(CFLAGS)

$(ASIN): $(ASIN).o
	$(GCC) -o $(ASIN) obj/$(ASIN).o $(LDFLAGS)
$(ASIN).o:
	$(GCC) -o obj/$(ASIN).o -c $(ASIN).c $(CFLAGS)

$(ASINH): $(ASINH).o
	$(GCC) -o $(ASINH) obj/$(ASINH).o $(LDFLAGS)
$(ASINH).o:
	$(GCC) -o obj/$(ASINH).o -c $(ASINH).c $(CFLAGS)

$(ATAN2): $(ATAN2).o
	$(GCC) -o $(ATAN2) obj/$(ATAN2).o $(LDFLAGS)
$(ATAN2).o:
	$(GCC) -o obj/$(ATAN2).o -c $(ATAN2).c $(CFLAGS)

$(ATAN): $(ATAN).o
	$(GCC) -o $(ATAN) obj/$(ATAN).o $(LDFLAGS)
$(ATAN).o:
	$(GCC) -o obj/$(ATAN).o -c $(ATAN).c $(CFLAGS)

$(ATANH): $(ATANH).o
	$(GCC) -o $(ATANH) obj/$(ATANH).o $(LDFLAGS)
$(ATANH).o:
	$(GCC) -o obj/$(ATANH).o -c $(ATANH).c $(CFLAGS)

$(CBRT): $(CBRT).o
	$(GCC) -o $(CBRT) obj/$(CBRT).o $(LDFLAGS)
$(CBRT).o:
	$(GCC) -o obj/$(CBRT).o -c $(CBRT).c $(CFLAGS)

$(CEIL): $(CEIL).o
	$(GCC) -o $(CEIL) obj/$(CEIL).o $(LDFLAGS)
$(CEIL).o:
	$(GCC) -o obj/$(CEIL).o -c $(CEIL).c $(CFLAGS)

$(COPYSIGN): $(COPYSIGN).o
	$(GCC) -o $(COPYSIGN) obj/$(COPYSIGN).o $(LDFLAGS)
$(COPYSIGN).o:
	$(GCC) -o obj/$(COPYSIGN).o -c $(COPYSIGN).c $(CFLAGS)

$(COS): $(COS).o
	$(GCC) -o $(COS) obj/$(COS).o $(LDFLAGS)
$(COS).o:
	$(GCC) -o obj/$(COS).o -c $(COS).c $(CFLAGS)

$(COSH): $(COSH).o
	$(GCC) -o $(COSH) obj/$(COSH).o $(LDFLAGS)
$(COSH).o:
	$(GCC) -o obj/$(COSH).o -c $(COSH).c $(CFLAGS)

$(DIV): $(DIV).o
	$(GCC) -o $(DIV) obj/$(DIV).o $(LDFLAGS)
$(DIV).o:
	$(GCC) -o obj/$(DIV).o -c $(DIV).c $(CFLAGS)

$(DREM): $(DREM).o
	$(GCC) -o $(DREM) obj/$(DREM).o $(LDFLAGS)
$(DREM).o:
	$(GCC) -o obj/$(DREM).o -c $(DREM).c $(CFLAGS)

$(ERF): $(ERF).o
	$(GCC) -o $(ERF) obj/$(ERF).o $(LDFLAGS)
$(ERF).o:
	$(GCC) -o obj/$(ERF).o -c $(ERF).c $(CFLAGS)

$(ERFC): $(ERFC).o
	$(GCC) -o $(ERFC) obj/$(ERFC).o $(LDFLAGS)
$(ERFC).o:
	$(GCC) -o obj/$(ERFC).o -c $(ERFC).c $(CFLAGS)

$(EXP10): $(EXP10).o
	$(GCC) -o $(EXP10) obj/$(EXP10).o $(LDFLAGS)
$(EXP10).o:
	$(GCC) -o obj/$(EXP10).o -c $(EXP10).c $(CFLAGS)

$(EXP2): $(EXP2).o
	$(GCC) -o $(EXP2) obj/$(EXP2).o $(LDFLAGS)
$(EXP2).o:
	$(GCC) -o obj/$(EXP2).o -c $(EXP2).c $(CFLAGS)

$(EXP): $(EXP).o
	$(GCC) -o $(EXP) obj/$(EXP).o $(LDFLAGS)
$(EXP).o:
	$(GCC) -o obj/$(EXP).o -c $(EXP).c $(CFLAGS)

$(EXPM1): $(EXPM1).o
	$(GCC) -o $(EXPM1) obj/$(EXPM1).o $(LDFLAGS)
$(EXPM1).o:
	$(GCC) -o obj/$(EXPM1).o -c $(EXPM1).c $(CFLAGS)

$(FABS): $(FABS).o
	$(GCC) -o $(FABS) obj/$(FABS).o $(LDFLAGS)
$(FABS).o:
	$(GCC) -o obj/$(FABS).o -c $(FABS).c $(CFLAGS)

$(FDIM): $(FDIM).o
	$(GCC) -o $(FDIM) obj/$(FDIM).o $(LDFLAGS)
$(FDIM).o:
	$(GCC) -o obj/$(FDIM).o -c $(FDIM).c $(CFLAGS)

$(FLOOR): $(FLOOR).o
	$(GCC) -o $(FLOOR) obj/$(FLOOR).o $(LDFLAGS)
$(FLOOR).o:
	$(GCC) -o obj/$(FLOOR).o -c $(FLOOR).c $(CFLAGS)

$(FMA): $(FMA).o
	$(GCC) -o $(FMA) obj/$(FMA).o $(LDFLAGS)
$(FMA).o:
	$(GCC) -o obj/$(FMA).o -c $(FMA).c $(CFLAGS)

$(FMAX): $(FMAX).o
	$(GCC) -o $(FMAX) obj/$(FMAX).o $(LDFLAGS)
$(FMAX).o:
	$(GCC) -o obj/$(FMAX).o -c $(FMAX).c $(CFLAGS)

$(FMIN): $(FMIN).o
	$(GCC) -o $(FMIN) obj/$(FMIN).o $(LDFLAGS)
$(FMIN).o:
	$(GCC) -o obj/$(FMIN).o -c $(FMIN).c $(CFLAGS)

$(FMOD): $(FMOD).o
	$(GCC) -o $(FMOD) obj/$(FMOD).o $(LDFLAGS)
$(FMOD).o:
	$(GCC) -o obj/$(FMOD).o -c $(FMOD).c $(CFLAGS)

$(FPCLASSIFY): $(FPCLASSIFY).o
	$(GCC) -o $(FPCLASSIFY) obj/$(FPCLASSIFY).o $(LDFLAGS)
$(FPCLASSIFY).o:
	$(GCC) -o obj/$(FPCLASSIFY).o -c $(FPCLASSIFY).c $(CFLAGS)

$(FREXP): $(FREXP).o
	$(GCC) -o $(FREXP) obj/$(FREXP).o $(LDFLAGS)
$(FREXP).o:
	$(GCC) -o obj/$(FREXP).o -c $(FREXP).c $(CFLAGS)

$(GAMMA): $(GAMMA).o
	$(GCC) -o $(GAMMA) obj/$(GAMMA).o $(LDFLAGS)
$(GAMMA).o:
	$(GCC) -o obj/$(GAMMA).o -c $(GAMMA).c $(CFLAGS)

$(HYPOT): $(HYPOT).o
	$(GCC) -o $(HYPOT) obj/$(HYPOT).o $(LDFLAGS)
$(HYPOT).o:
	$(GCC) -o obj/$(HYPOT).o -c $(HYPOT).c $(CFLAGS)

$(INITSTATE): $(INITSTATE).o
	$(GCC) -o $(INITSTATE) obj/$(INITSTATE).o $(LDFLAGS)
$(INITSTATE).o:
	$(GCC) -o obj/$(INITSTATE).o -c $(INITSTATE).c $(CFLAGS)

$(ISFINITE): $(ISFINITE).o
	$(GCC) -o $(ISFINITE) obj/$(ISFINITE).o $(LDFLAGS)
$(ISFINITE).o:
	$(GCC) -o obj/$(ISFINITE).o -c $(ISFINITE).c $(CFLAGS)

$(ISINF): $(ISINF).o
	$(GCC) -o $(ISINF) obj/$(ISINF).o $(LDFLAGS)
$(ISINF).o:
	$(GCC) -o obj/$(ISINF).o -c $(ISINF).c $(CFLAGS)

$(ISNAN): $(ISNAN).o
	$(GCC) -o $(ISNAN) obj/$(ISNAN).o $(LDFLAGS)
$(ISNAN).o:
	$(GCC) -o obj/$(ISNAN).o -c $(ISNAN).c $(CFLAGS)

$(ISNORMAL): $(ISNORMAL).o
	$(GCC) -o $(ISNORMAL) obj/$(ISNORMAL).o $(LDFLAGS)
$(ISNORMAL).o:
	$(GCC) -o obj/$(ISNORMAL).o -c $(ISNORMAL).c $(CFLAGS)

$(LABS): $(LABS).o
	$(GCC) -o $(LABS) obj/$(LABS).o $(LDFLAGS)
$(LABS).o:
	$(GCC) -o obj/$(LABS).o -c $(LABS).c $(CFLAGS)

$(LDEXP): $(LDEXP).o
	$(GCC) -o $(LDEXP) obj/$(LDEXP).o $(LDFLAGS)
$(LDEXP).o:
	$(GCC) -o obj/$(LDEXP).o -c $(LDEXP).c $(CFLAGS)

$(LDIV): $(LDIV).o
	$(GCC) -o $(LDIV) obj/$(LDIV).o $(LDFLAGS)
$(LDIV).o:
	$(GCC) -o obj/$(LDIV).o -c $(LDIV).c $(CFLAGS)

$(LGAMMA): $(LGAMMA).o
	$(GCC) -o $(LGAMMA) obj/$(LGAMMA).o $(LDFLAGS)
$(LGAMMA).o:
	$(GCC) -o obj/$(LGAMMA).o -c $(LGAMMA).c $(CFLAGS)

$(LLABS): $(LLABS).o
	$(GCC) -o $(LLABS) obj/$(LLABS).o $(LDFLAGS)
$(LLABS).o:
	$(GCC) -o obj/$(LLABS).o -c $(LLABS).c $(CFLAGS)

$(LLDIV): $(LLDIV).o
	$(GCC) -o $(LLDIV) obj/$(LLDIV).o $(LDFLAGS)
$(LLDIV).o:
	$(GCC) -o obj/$(LLDIV).o -c $(LLDIV).c $(CFLAGS)

$(LLRINT): $(LLRINT).o
	$(GCC) -o $(LLRINT) obj/$(LLRINT).o $(LDFLAGS)
$(LLRINT).o:
	$(GCC) -o obj/$(LLRINT).o -c $(LLRINT).c $(CFLAGS)

$(LLROUND): $(LLROUND).o
	$(GCC) -o $(LLROUND) obj/$(LLROUND).o $(LDFLAGS)
$(LLROUND).o:
	$(GCC) -o obj/$(LLROUND).o -c $(LLROUND).c $(CFLAGS)

$(LOG10): $(LOG10).o
	$(GCC) -o $(LOG10) obj/$(LOG10).o $(LDFLAGS)
$(LOG10).o:
	$(GCC) -o obj/$(LOG10).o -c $(LOG10).c $(CFLAGS)

$(LOG1P): $(LOG1P).o
	$(GCC) -o $(LOG1P) obj/$(LOG1P).o $(LDFLAGS)
$(LOG1P).o:
	$(GCC) -o obj/$(LOG1P).o -c $(LOG1P).c $(CFLAGS)

$(LOG2): $(LOG2).o
	$(GCC) -o $(LOG2) obj/$(LOG2).o $(LDFLAGS)
$(LOG2).o:
	$(GCC) -o obj/$(LOG2).o -c $(LOG2).c $(CFLAGS)

$(LOGB): $(LOGB).o
	$(GCC) -o $(LOGB) obj/$(LOGB).o $(LDFLAGS)
$(LOGB).o:
	$(GCC) -o obj/$(LOGB).o -c $(LOGB).c $(CFLAGS)

$(LOG): $(LOG).o
	$(GCC) -o $(LOG) obj/$(LOG).o $(LDFLAGS)
$(LOG).o:
	$(GCC) -o obj/$(LOG).o -c $(LOG).c $(CFLAGS)

$(LRINT): $(LRINT).o
	$(GCC) -o $(LRINT) obj/$(LRINT).o $(LDFLAGS)
$(LRINT).o:
	$(GCC) -o obj/$(LRINT).o -c $(LRINT).c $(CFLAGS)

$(LROUND): $(LROUND).o
	$(GCC) -o $(LROUND) obj/$(LROUND).o $(LDFLAGS)
$(LROUND).o:
	$(GCC) -o obj/$(LROUND).o -c $(LROUND).c $(CFLAGS)

$(MODF): $(MODF).o
	$(GCC) -o $(MODF) obj/$(MODF).o $(LDFLAGS)
$(MODF).o:
	$(GCC) -o obj/$(MODF).o -c $(MODF).c $(CFLAGS)

$(NEARBYINT): $(NEARBYINT).o
	$(GCC) -o $(NEARBYINT) obj/$(NEARBYINT).o $(LDFLAGS)
$(NEARBYINT).o:
	$(GCC) -o obj/$(NEARBYINT).o -c $(NEARBYINT).c $(CFLAGS)

$(NEXTAFTER): $(NEXTAFTER).o
	$(GCC) -o $(NEXTAFTER) obj/$(NEXTAFTER).o $(LDFLAGS)
$(NEXTAFTER).o:
	$(GCC) -o obj/$(NEXTAFTER).o -c $(NEXTAFTER).c $(CFLAGS)

$(NEXTTOWARD): $(NEXTTOWARD).o
	$(GCC) -o $(NEXTTOWARD) obj/$(NEXTTOWARD).o $(LDFLAGS)
$(NEXTTOWARD).o:
	$(GCC) -o obj/$(NEXTTOWARD).o -c $(NEXTTOWARD).c $(CFLAGS)

$(POW10): $(POW10).o
	$(GCC) -o $(POW10) obj/$(POW10).o $(LDFLAGS)
$(POW10).o:
	$(GCC) -o obj/$(POW10).o -c $(POW10).c $(CFLAGS)

$(POW): $(POW).o
	$(GCC) -o $(POW) obj/$(POW).o $(LDFLAGS)
$(POW).o:
	$(GCC) -o obj/$(POW).o -c $(POW).c $(CFLAGS)

$(RAND): $(RAND).o
	$(GCC) -o $(RAND) obj/$(RAND).o $(LDFLAGS)
$(RAND).o:
	$(GCC) -o obj/$(RAND).o -c $(RAND).c $(CFLAGS)

$(RANDOM): $(RANDOM).o
	$(GCC) -o $(RANDOM) obj/$(RANDOM).o $(LDFLAGS)
$(RANDOM).o:
	$(GCC) -o obj/$(RANDOM).o -c $(RANDOM).c $(CFLAGS)

$(REMAINDER): $(REMAINDER).o
	$(GCC) -o $(REMAINDER) obj/$(REMAINDER).o $(LDFLAGS)
$(REMAINDER).o:
	$(GCC) -o obj/$(REMAINDER).o -c $(REMAINDER).c $(CFLAGS)

$(REMQUO): $(REMQUO).o
	$(GCC) -o $(REMQUO) obj/$(REMQUO).o $(LDFLAGS)
$(REMQUO).o:
	$(GCC) -o obj/$(REMQUO).o -c $(REMQUO).c $(CFLAGS)

$(RINT): $(RINT).o
	$(GCC) -o $(RINT) obj/$(RINT).o $(LDFLAGS)
$(RINT).o:
	$(GCC) -o obj/$(RINT).o -c $(RINT).c $(CFLAGS)

$(ROUND): $(ROUND).o
	$(GCC) -o $(ROUND) obj/$(ROUND).o $(LDFLAGS)
$(ROUND).o:
	$(GCC) -o obj/$(ROUND).o -c $(ROUND).c $(CFLAGS)

$(SCALB): $(SCALB).o
	$(GCC) -o $(SCALB) obj/$(SCALB).o $(LDFLAGS)
$(SCALB).o:
	$(GCC) -o obj/$(SCALB).o -c $(SCALB).c $(CFLAGS)

$(SCALBLN): $(SCALBLN).o
	$(GCC) -o $(SCALBLN) obj/$(SCALBLN).o $(LDFLAGS)
$(SCALBLN).o:
	$(GCC) -o obj/$(SCALBLN).o -c $(SCALBLN).c $(CFLAGS)

$(SCALBN): $(SCALBN).o
	$(GCC) -o $(SCALBN) obj/$(SCALBN).o $(LDFLAGS)
$(SCALBN).o:
	$(GCC) -o obj/$(SCALBN).o -c $(SCALBN).c $(CFLAGS)

$(SETSTATE): $(SETSTATE).o
	$(GCC) -o $(SETSTATE) obj/$(SETSTATE).o $(LDFLAGS)
$(SETSTATE).o:
	$(GCC) -o obj/$(SETSTATE).o -c $(SETSTATE).c $(CFLAGS)

$(SIGNBIT): $(SIGNBIT).o
	$(GCC) -o $(SIGNBIT) obj/$(SIGNBIT).o $(LDFLAGS)
$(SIGNBIT).o:
	$(GCC) -o obj/$(SIGNBIT).o -c $(SIGNBIT).c $(CFLAGS)

$(SIN): $(SIN).o
	$(GCC) -o $(SIN) obj/$(SIN).o $(LDFLAGS)
$(SIN).o:
	$(GCC) -o obj/$(SIN).o -c $(SIN).c $(CFLAGS)

$(SINH): $(SINH).o
	$(GCC) -o $(SINH) obj/$(SINH).o $(LDFLAGS)
$(SINH).o:
	$(GCC) -o obj/$(SINH).o -c $(SINH).c $(CFLAGS)

$(SQRT): $(SQRT).o
	$(GCC) -o $(SQRT) obj/$(SQRT).o $(LDFLAGS)
$(SQRT).o:
	$(GCC) -o obj/$(SQRT).o -c $(SQRT).c $(CFLAGS)

$(SRAND1): $(SRAND1).o
	$(GCC) -o $(SRAND1) obj/$(SRAND1).o $(LDFLAGS)
$(SRAND1).o:
	$(GCC) -o obj/$(SRAND1).o -c $(SRAND1).c $(CFLAGS)

$(SRAND2): $(SRAND2).o
	$(GCC) -o $(SRAND2) obj/$(SRAND2).o $(LDFLAGS)
$(SRAND2).o:
	$(GCC) -o obj/$(SRAND2).o -c $(SRAND2).c $(CFLAGS)

$(SRANDOM1): $(SRANDOM1).o
	$(GCC) -o $(SRANDOM1) obj/$(SRANDOM1).o $(LDFLAGS)
$(SRANDOM1).o:
	$(GCC) -o obj/$(SRANDOM1).o -c $(SRANDOM1).c $(CFLAGS)

$(SRANDOM2): $(SRANDOM2).o
	$(GCC) -o $(SRANDOM2) obj/$(SRANDOM2).o $(LDFLAGS)
$(SRANDOM2).o:
	$(GCC) -o obj/$(SRANDOM2).o -c $(SRANDOM2).c $(CFLAGS)

$(TAN): $(TAN).o
	$(GCC) -o $(TAN) obj/$(TAN).o $(LDFLAGS)
$(TAN).o:
	$(GCC) -o obj/$(TAN).o -c $(TAN).c $(CFLAGS)

$(TANH): $(TANH).o
	$(GCC) -o $(TANH) obj/$(TANH).o $(LDFLAGS)
$(TANH).o:
	$(GCC) -o obj/$(TANH).o -c $(TANH).c $(CFLAGS)

$(TGAMMA): $(TGAMMA).o
	$(GCC) -o $(TGAMMA) obj/$(TGAMMA).o $(LDFLAGS)
$(TGAMMA).o:
	$(GCC) -o obj/$(TGAMMA).o -c $(TGAMMA).c $(CFLAGS)

$(TRUNC): $(TRUNC).o
	$(GCC) -o $(TRUNC) obj/$(TRUNC).o $(LDFLAGS)
$(TRUNC).o:
	$(GCC) -o obj/$(TRUNC).o -c $(TRUNC).c $(CFLAGS)

#top Makefile.obsd¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_ISNAN=1 -DHAVE_ISINF=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long
LIBS        = -lm
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

ABS         = abs
ACOS        = acos
ACOSH       = acosh
ASIN        = asin
ASINH       = asinh
ATAN2       = atan2
ATAN        = atan
ATANH       = atanh
CBRT        = cbrt
CEIL        = ceil
COPYSIGN    = copysign
COS         = cos
COSH        = cosh
DIV         = div
DREM        = drem
ERF         = erf
ERFC        = erfc
EXP10       = exp10
EXP2        = exp2
EXP         = exp
EXPM1       = expm1
FABS        = fabs
FDIM        = fdim
FLOOR       = floor
FMA         = fma
FMAX        = fmax
FMIN        = fmin
FMOD        = fmod
FPCLASSIFY  = fpclassify
FREXP       = frexp
GAMMA       = gamma
HYPOT       = hypot
INITSTATE   = initstate
ISFINITE    = isfinite
ISINF       = isinf
ISNAN       = isnan
ISNORMAL    = isnormal
LABS        = labs
LDEXP       = ldexp
LDIV        = ldiv
LGAMMA      = lgamma
LLABS       = llabs
LLDIV       = lldiv
LLRINT      = llrint
LLROUND     = llround
LOG10       = log10
LOG1P       = log1p
LOG2        = log2
LOGB        = logb
LOG         = log
LRINT       = lrint
LROUND      = lround
MODF        = modf
NEARBYINT   = nearbyint
NEXTAFTER   = nextafter
NEXTTOWARD  = nexttoward
POW10       = pow10
POW         = pow
RAND        = rand
RANDOM      = random
REMAINDER   = remainder
REMQUO      = remquo
RINT        = rint
ROUND       = round
SCALB       = scalb
SCALBLN     = scalbln
SCALBN      = scalbn
SETSTATE    = setstate
SIGNBIT     = signbit
SIN         = sin
SINH        = sinh
SQRT        = sqrt
SRAND1      = srand1
SRAND2      = srand2
SRANDOM1    = srandom1
SRANDOM2    = srandom2
TAN         = tan
TANH        = tanh
TGAMMA      = tgamma
TRUNC       = trunc



all: objdir make

objdir:
	$(MKDCMD) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(ABS)
#make: $(ACOS)
#make: $(ACOSH)
#make: $(ASIN)
#make: $(ASINH)
#make: $(ATAN2)
#make: $(ATAN)
#make: $(ATANH)
#make: $(CBRT)
#make: $(CEIL)
#make: $(COPYSIGN)
#make: $(COS)
#make: $(COSH)
#make: $(DIV)
#make: $(DREM)
#make: $(ERF)
#make: $(ERFC)
#make: $(EXP10)
#make: $(EXP2)
#make: $(EXP)
#make: $(EXPM1)
#make: $(FABS)
#make: $(FDIM)
#make: $(FLOOR)
#make: $(FMA)
#make: $(FMAX)
#make: $(FMIN)
#make: $(FMOD)
#make: $(FPCLASSIFY)
#make: $(FREXP)
#make: $(GAMMA)
#make: $(HYPOT)
#make: $(INITSTATE)
#make: $(ISFINITE)
#make: $(ISINF)
#make: $(ISNAN)
#make: $(ISNORMAL)
#make: $(LABS)
#make: $(LDEXP)
#make: $(LDIV)
#make: $(LGAMMA)
#make: $(LLABS)
#make: $(LLDIV)
#make: $(LLRINT)
#make: $(LLROUND)
#make: $(LOG10)
#make: $(LOG1P)
#make: $(LOG2)
#make: $(LOGB)
#make: $(LOG)
#make: $(LRINT)
#make: $(LROUND)
#make: $(MODF)
#make: $(NEARBYINT)
#make: $(NEXTAFTER)
#make: $(NEXTTOWARD)
#make: $(POW10)
#make: $(POW)
#make: $(RAND)
#make: $(RANDOM)
#make: $(REMAINDER)
#make: $(REMQUO)
#make: $(RINT)
#make: $(ROUND)
#make: $(SCALB)
#make: $(SCALBLN)
#make: $(SCALBN)
#make: $(SETSTATE)
#make: $(SIGNBIT)
#make: $(SIN)
#make: $(SINH)
#make: $(SQRT)
#make: $(SRAND1)
#make: $(SRAND2)
#make: $(SRANDOM1)
#make: $(SRANDOM2)
#make: $(TAN)
#make: $(TANH)
#make: $(TGAMMA)
#make: $(TRUNC)
make: $(ABS) $(ACOS) $(ACOSH) $(ASIN) $(ASINH) $(ATAN2) $(ATAN) $(ATANH) $(CBRT) $(CEIL) $(COPYSIGN) $(COS) $(COSH) $(DIV) $(DREM) $(ERF) $(ERFC) $(EXP10) $(EXP2) $(EXP) $(EXPM1) $(FABS) $(FDIM) $(FLOOR) $(FMA) $(FMAX) $(FMIN) $(FMOD) $(FPCLASSIFY) $(FREXP) $(GAMMA) $(HYPOT) $(INITSTATE) $(ISFINITE) $(ISINF) $(ISNAN) $(ISNORMAL) $(LABS) $(LDEXP) $(LDIV) $(LGAMMA) $(LLABS) $(LLDIV) $(LLRINT) $(LLROUND) $(LOG10) $(LOG1P) $(LOG2) $(LOGB) $(LOG) $(LRINT) $(LROUND) $(MODF) $(NEARBYINT) $(NEXTAFTER) $(NEXTTOWARD) $(POW10) $(POW) $(RAND) $(RANDOM) $(REMAINDER) $(REMQUO) $(RINT) $(ROUND) $(SCALB) $(SCALBLN) $(SCALBN) $(SETSTATE) $(SIGNBIT) $(SIN) $(SINH) $(SQRT) $(SRAND1) $(SRAND2) $(SRANDOM1) $(SRANDOM2) $(TAN) $(TANH) $(TGAMMA) $(TRUNC)



$(ABS): $(ABS).o
	$(GCC) -o $(ABS) obj/$(ABS).o $(LDFLAGS)
$(ABS).o:
	$(GCC) -o obj/$(ABS).o -c $(ABS).c $(CFLAGS)

$(ACOS): $(ACOS).o
	$(GCC) -o $(ACOS) obj/$(ACOS).o $(LDFLAGS)
$(ACOS).o:
	$(GCC) -o obj/$(ACOS).o -c $(ACOS).c $(CFLAGS)

$(ACOSH): $(ACOSH).o
	$(GCC) -o $(ACOSH) obj/$(ACOSH).o $(LDFLAGS)
$(ACOSH).o:
	$(GCC) -o obj/$(ACOSH).o -c $(ACOSH).c $(CFLAGS)

$(ASIN): $(ASIN).o
	$(GCC) -o $(ASIN) obj/$(ASIN).o $(LDFLAGS)
$(ASIN).o:
	$(GCC) -o obj/$(ASIN).o -c $(ASIN).c $(CFLAGS)

$(ASINH): $(ASINH).o
	$(GCC) -o $(ASINH) obj/$(ASINH).o $(LDFLAGS)
$(ASINH).o:
	$(GCC) -o obj/$(ASINH).o -c $(ASINH).c $(CFLAGS)

$(ATAN2): $(ATAN2).o
	$(GCC) -o $(ATAN2) obj/$(ATAN2).o $(LDFLAGS)
$(ATAN2).o:
	$(GCC) -o obj/$(ATAN2).o -c $(ATAN2).c $(CFLAGS)

$(ATAN): $(ATAN).o
	$(GCC) -o $(ATAN) obj/$(ATAN).o $(LDFLAGS)
$(ATAN).o:
	$(GCC) -o obj/$(ATAN).o -c $(ATAN).c $(CFLAGS)

$(ATANH): $(ATANH).o
	$(GCC) -o $(ATANH) obj/$(ATANH).o $(LDFLAGS)
$(ATANH).o:
	$(GCC) -o obj/$(ATANH).o -c $(ATANH).c $(CFLAGS)

$(CBRT): $(CBRT).o
	$(GCC) -o $(CBRT) obj/$(CBRT).o $(LDFLAGS)
$(CBRT).o:
	$(GCC) -o obj/$(CBRT).o -c $(CBRT).c $(CFLAGS)

$(CEIL): $(CEIL).o
	$(GCC) -o $(CEIL) obj/$(CEIL).o $(LDFLAGS)
$(CEIL).o:
	$(GCC) -o obj/$(CEIL).o -c $(CEIL).c $(CFLAGS)

$(COPYSIGN): $(COPYSIGN).o
	$(GCC) -o $(COPYSIGN) obj/$(COPYSIGN).o $(LDFLAGS)
$(COPYSIGN).o:
	$(GCC) -o obj/$(COPYSIGN).o -c $(COPYSIGN).c $(CFLAGS)

$(COS): $(COS).o
	$(GCC) -o $(COS) obj/$(COS).o $(LDFLAGS)
$(COS).o:
	$(GCC) -o obj/$(COS).o -c $(COS).c $(CFLAGS)

$(COSH): $(COSH).o
	$(GCC) -o $(COSH) obj/$(COSH).o $(LDFLAGS)
$(COSH).o:
	$(GCC) -o obj/$(COSH).o -c $(COSH).c $(CFLAGS)

$(DIV): $(DIV).o
	$(GCC) -o $(DIV) obj/$(DIV).o $(LDFLAGS)
$(DIV).o:
	$(GCC) -o obj/$(DIV).o -c $(DIV).c $(CFLAGS)

$(DREM): $(DREM).o
	$(GCC) -o $(DREM) obj/$(DREM).o $(LDFLAGS)
$(DREM).o:
	$(GCC) -o obj/$(DREM).o -c $(DREM).c $(CFLAGS)

$(ERF): $(ERF).o
	$(GCC) -o $(ERF) obj/$(ERF).o $(LDFLAGS)
$(ERF).o:
	$(GCC) -o obj/$(ERF).o -c $(ERF).c $(CFLAGS)

$(ERFC): $(ERFC).o
	$(GCC) -o $(ERFC) obj/$(ERFC).o $(LDFLAGS)
$(ERFC).o:
	$(GCC) -o obj/$(ERFC).o -c $(ERFC).c $(CFLAGS)

$(EXP10): $(EXP10).o
	$(GCC) -o $(EXP10) obj/$(EXP10).o $(LDFLAGS)
$(EXP10).o:
	$(GCC) -o obj/$(EXP10).o -c $(EXP10).c $(CFLAGS)

$(EXP2): $(EXP2).o
	$(GCC) -o $(EXP2) obj/$(EXP2).o $(LDFLAGS)
$(EXP2).o:
	$(GCC) -o obj/$(EXP2).o -c $(EXP2).c $(CFLAGS)

$(EXP): $(EXP).o
	$(GCC) -o $(EXP) obj/$(EXP).o $(LDFLAGS)
$(EXP).o:
	$(GCC) -o obj/$(EXP).o -c $(EXP).c $(CFLAGS)

$(EXPM1): $(EXPM1).o
	$(GCC) -o $(EXPM1) obj/$(EXPM1).o $(LDFLAGS)
$(EXPM1).o:
	$(GCC) -o obj/$(EXPM1).o -c $(EXPM1).c $(CFLAGS)

$(FABS): $(FABS).o
	$(GCC) -o $(FABS) obj/$(FABS).o $(LDFLAGS)
$(FABS).o:
	$(GCC) -o obj/$(FABS).o -c $(FABS).c $(CFLAGS)

$(FDIM): $(FDIM).o
	$(GCC) -o $(FDIM) obj/$(FDIM).o $(LDFLAGS)
$(FDIM).o:
	$(GCC) -o obj/$(FDIM).o -c $(FDIM).c $(CFLAGS)

$(FLOOR): $(FLOOR).o
	$(GCC) -o $(FLOOR) obj/$(FLOOR).o $(LDFLAGS)
$(FLOOR).o:
	$(GCC) -o obj/$(FLOOR).o -c $(FLOOR).c $(CFLAGS)

$(FMA): $(FMA).o
	$(GCC) -o $(FMA) obj/$(FMA).o $(LDFLAGS)
$(FMA).o:
	$(GCC) -o obj/$(FMA).o -c $(FMA).c $(CFLAGS)

$(FMAX): $(FMAX).o
	$(GCC) -o $(FMAX) obj/$(FMAX).o $(LDFLAGS)
$(FMAX).o:
	$(GCC) -o obj/$(FMAX).o -c $(FMAX).c $(CFLAGS)

$(FMIN): $(FMIN).o
	$(GCC) -o $(FMIN) obj/$(FMIN).o $(LDFLAGS)
$(FMIN).o:
	$(GCC) -o obj/$(FMIN).o -c $(FMIN).c $(CFLAGS)

$(FMOD): $(FMOD).o
	$(GCC) -o $(FMOD) obj/$(FMOD).o $(LDFLAGS)
$(FMOD).o:
	$(GCC) -o obj/$(FMOD).o -c $(FMOD).c $(CFLAGS)

$(FPCLASSIFY): $(FPCLASSIFY).o
	$(GCC) -o $(FPCLASSIFY) obj/$(FPCLASSIFY).o $(LDFLAGS)
$(FPCLASSIFY).o:
	$(GCC) -o obj/$(FPCLASSIFY).o -c $(FPCLASSIFY).c $(CFLAGS)

$(FREXP): $(FREXP).o
	$(GCC) -o $(FREXP) obj/$(FREXP).o $(LDFLAGS)
$(FREXP).o:
	$(GCC) -o obj/$(FREXP).o -c $(FREXP).c $(CFLAGS)

$(GAMMA): $(GAMMA).o
	$(GCC) -o $(GAMMA) obj/$(GAMMA).o $(LDFLAGS)
$(GAMMA).o:
	$(GCC) -o obj/$(GAMMA).o -c $(GAMMA).c $(CFLAGS)

$(HYPOT): $(HYPOT).o
	$(GCC) -o $(HYPOT) obj/$(HYPOT).o $(LDFLAGS)
$(HYPOT).o:
	$(GCC) -o obj/$(HYPOT).o -c $(HYPOT).c $(CFLAGS)

$(INITSTATE): $(INITSTATE).o
	$(GCC) -o $(INITSTATE) obj/$(INITSTATE).o $(LDFLAGS)
$(INITSTATE).o:
	$(GCC) -o obj/$(INITSTATE).o -c $(INITSTATE).c $(CFLAGS)

$(ISFINITE): $(ISFINITE).o
	$(GCC) -o $(ISFINITE) obj/$(ISFINITE).o $(LDFLAGS)
$(ISFINITE).o:
	$(GCC) -o obj/$(ISFINITE).o -c $(ISFINITE).c $(CFLAGS)

$(ISINF): $(ISINF).o
	$(GCC) -o $(ISINF) obj/$(ISINF).o $(LDFLAGS)
$(ISINF).o:
	$(GCC) -o obj/$(ISINF).o -c $(ISINF).c $(CFLAGS)

$(ISNAN): $(ISNAN).o
	$(GCC) -o $(ISNAN) obj/$(ISNAN).o $(LDFLAGS)
$(ISNAN).o:
	$(GCC) -o obj/$(ISNAN).o -c $(ISNAN).c $(CFLAGS)

$(ISNORMAL): $(ISNORMAL).o
	$(GCC) -o $(ISNORMAL) obj/$(ISNORMAL).o $(LDFLAGS)
$(ISNORMAL).o:
	$(GCC) -o obj/$(ISNORMAL).o -c $(ISNORMAL).c $(CFLAGS)

$(LABS): $(LABS).o
	$(GCC) -o $(LABS) obj/$(LABS).o $(LDFLAGS)
$(LABS).o:
	$(GCC) -o obj/$(LABS).o -c $(LABS).c $(CFLAGS)

$(LDEXP): $(LDEXP).o
	$(GCC) -o $(LDEXP) obj/$(LDEXP).o $(LDFLAGS)
$(LDEXP).o:
	$(GCC) -o obj/$(LDEXP).o -c $(LDEXP).c $(CFLAGS)

$(LDIV): $(LDIV).o
	$(GCC) -o $(LDIV) obj/$(LDIV).o $(LDFLAGS)
$(LDIV).o:
	$(GCC) -o obj/$(LDIV).o -c $(LDIV).c $(CFLAGS)

$(LGAMMA): $(LGAMMA).o
	$(GCC) -o $(LGAMMA) obj/$(LGAMMA).o $(LDFLAGS)
$(LGAMMA).o:
	$(GCC) -o obj/$(LGAMMA).o -c $(LGAMMA).c $(CFLAGS)

$(LLABS): $(LLABS).o
	$(GCC) -o $(LLABS) obj/$(LLABS).o $(LDFLAGS)
$(LLABS).o:
	$(GCC) -o obj/$(LLABS).o -c $(LLABS).c $(CFLAGS)

$(LLDIV): $(LLDIV).o
	$(GCC) -o $(LLDIV) obj/$(LLDIV).o $(LDFLAGS)
$(LLDIV).o:
	$(GCC) -o obj/$(LLDIV).o -c $(LLDIV).c $(CFLAGS)

$(LLRINT): $(LLRINT).o
	$(GCC) -o $(LLRINT) obj/$(LLRINT).o $(LDFLAGS)
$(LLRINT).o:
	$(GCC) -o obj/$(LLRINT).o -c $(LLRINT).c $(CFLAGS)

$(LLROUND): $(LLROUND).o
	$(GCC) -o $(LLROUND) obj/$(LLROUND).o $(LDFLAGS)
$(LLROUND).o:
	$(GCC) -o obj/$(LLROUND).o -c $(LLROUND).c $(CFLAGS)

$(LOG10): $(LOG10).o
	$(GCC) -o $(LOG10) obj/$(LOG10).o $(LDFLAGS)
$(LOG10).o:
	$(GCC) -o obj/$(LOG10).o -c $(LOG10).c $(CFLAGS)

$(LOG1P): $(LOG1P).o
	$(GCC) -o $(LOG1P) obj/$(LOG1P).o $(LDFLAGS)
$(LOG1P).o:
	$(GCC) -o obj/$(LOG1P).o -c $(LOG1P).c $(CFLAGS)

$(LOG2): $(LOG2).o
	$(GCC) -o $(LOG2) obj/$(LOG2).o $(LDFLAGS)
$(LOG2).o:
	$(GCC) -o obj/$(LOG2).o -c $(LOG2).c $(CFLAGS)

$(LOGB): $(LOGB).o
	$(GCC) -o $(LOGB) obj/$(LOGB).o $(LDFLAGS)
$(LOGB).o:
	$(GCC) -o obj/$(LOGB).o -c $(LOGB).c $(CFLAGS)

$(LOG): $(LOG).o
	$(GCC) -o $(LOG) obj/$(LOG).o $(LDFLAGS)
$(LOG).o:
	$(GCC) -o obj/$(LOG).o -c $(LOG).c $(CFLAGS)

$(LRINT): $(LRINT).o
	$(GCC) -o $(LRINT) obj/$(LRINT).o $(LDFLAGS)
$(LRINT).o:
	$(GCC) -o obj/$(LRINT).o -c $(LRINT).c $(CFLAGS)

$(LROUND): $(LROUND).o
	$(GCC) -o $(LROUND) obj/$(LROUND).o $(LDFLAGS)
$(LROUND).o:
	$(GCC) -o obj/$(LROUND).o -c $(LROUND).c $(CFLAGS)

$(MODF): $(MODF).o
	$(GCC) -o $(MODF) obj/$(MODF).o $(LDFLAGS)
$(MODF).o:
	$(GCC) -o obj/$(MODF).o -c $(MODF).c $(CFLAGS)

$(NEARBYINT): $(NEARBYINT).o
	$(GCC) -o $(NEARBYINT) obj/$(NEARBYINT).o $(LDFLAGS)
$(NEARBYINT).o:
	$(GCC) -o obj/$(NEARBYINT).o -c $(NEARBYINT).c $(CFLAGS)

$(NEXTAFTER): $(NEXTAFTER).o
	$(GCC) -o $(NEXTAFTER) obj/$(NEXTAFTER).o $(LDFLAGS)
$(NEXTAFTER).o:
	$(GCC) -o obj/$(NEXTAFTER).o -c $(NEXTAFTER).c $(CFLAGS)

$(NEXTTOWARD): $(NEXTTOWARD).o
	$(GCC) -o $(NEXTTOWARD) obj/$(NEXTTOWARD).o $(LDFLAGS)
$(NEXTTOWARD).o:
	$(GCC) -o obj/$(NEXTTOWARD).o -c $(NEXTTOWARD).c $(CFLAGS)

$(POW10): $(POW10).o
	$(GCC) -o $(POW10) obj/$(POW10).o $(LDFLAGS)
$(POW10).o:
	$(GCC) -o obj/$(POW10).o -c $(POW10).c $(CFLAGS)

$(POW): $(POW).o
	$(GCC) -o $(POW) obj/$(POW).o $(LDFLAGS)
$(POW).o:
	$(GCC) -o obj/$(POW).o -c $(POW).c $(CFLAGS)

$(RAND): $(RAND).o
	$(GCC) -o $(RAND) obj/$(RAND).o $(LDFLAGS)
$(RAND).o:
	$(GCC) -o obj/$(RAND).o -c $(RAND).c $(CFLAGS)

$(RANDOM): $(RANDOM).o
	$(GCC) -o $(RANDOM) obj/$(RANDOM).o $(LDFLAGS)
$(RANDOM).o:
	$(GCC) -o obj/$(RANDOM).o -c $(RANDOM).c $(CFLAGS)

$(REMAINDER): $(REMAINDER).o
	$(GCC) -o $(REMAINDER) obj/$(REMAINDER).o $(LDFLAGS)
$(REMAINDER).o:
	$(GCC) -o obj/$(REMAINDER).o -c $(REMAINDER).c $(CFLAGS)

$(REMQUO): $(REMQUO).o
	$(GCC) -o $(REMQUO) obj/$(REMQUO).o $(LDFLAGS)
$(REMQUO).o:
	$(GCC) -o obj/$(REMQUO).o -c $(REMQUO).c $(CFLAGS)

$(RINT): $(RINT).o
	$(GCC) -o $(RINT) obj/$(RINT).o $(LDFLAGS)
$(RINT).o:
	$(GCC) -o obj/$(RINT).o -c $(RINT).c $(CFLAGS)

$(ROUND): $(ROUND).o
	$(GCC) -o $(ROUND) obj/$(ROUND).o $(LDFLAGS)
$(ROUND).o:
	$(GCC) -o obj/$(ROUND).o -c $(ROUND).c $(CFLAGS)

$(SCALB): $(SCALB).o
	$(GCC) -o $(SCALB) obj/$(SCALB).o $(LDFLAGS)
$(SCALB).o:
	$(GCC) -o obj/$(SCALB).o -c $(SCALB).c $(CFLAGS)

$(SCALBLN): $(SCALBLN).o
	$(GCC) -o $(SCALBLN) obj/$(SCALBLN).o $(LDFLAGS)
$(SCALBLN).o:
	$(GCC) -o obj/$(SCALBLN).o -c $(SCALBLN).c $(CFLAGS)

$(SCALBN): $(SCALBN).o
	$(GCC) -o $(SCALBN) obj/$(SCALBN).o $(LDFLAGS)
$(SCALBN).o:
	$(GCC) -o obj/$(SCALBN).o -c $(SCALBN).c $(CFLAGS)

$(SETSTATE): $(SETSTATE).o
	$(GCC) -o $(SETSTATE) obj/$(SETSTATE).o $(LDFLAGS)
$(SETSTATE).o:
	$(GCC) -o obj/$(SETSTATE).o -c $(SETSTATE).c $(CFLAGS)

$(SIGNBIT): $(SIGNBIT).o
	$(GCC) -o $(SIGNBIT) obj/$(SIGNBIT).o $(LDFLAGS)
$(SIGNBIT).o:
	$(GCC) -o obj/$(SIGNBIT).o -c $(SIGNBIT).c $(CFLAGS)

$(SIN): $(SIN).o
	$(GCC) -o $(SIN) obj/$(SIN).o $(LDFLAGS)
$(SIN).o:
	$(GCC) -o obj/$(SIN).o -c $(SIN).c $(CFLAGS)

$(SINH): $(SINH).o
	$(GCC) -o $(SINH) obj/$(SINH).o $(LDFLAGS)
$(SINH).o:
	$(GCC) -o obj/$(SINH).o -c $(SINH).c $(CFLAGS)

$(SQRT): $(SQRT).o
	$(GCC) -o $(SQRT) obj/$(SQRT).o $(LDFLAGS)
$(SQRT).o:
	$(GCC) -o obj/$(SQRT).o -c $(SQRT).c $(CFLAGS)

$(SRAND1): $(SRAND1).o
	$(GCC) -o $(SRAND1) obj/$(SRAND1).o $(LDFLAGS)
$(SRAND1).o:
	$(GCC) -o obj/$(SRAND1).o -c $(SRAND1).c $(CFLAGS)

$(SRAND2): $(SRAND2).o
	$(GCC) -o $(SRAND2) obj/$(SRAND2).o $(LDFLAGS)
$(SRAND2).o:
	$(GCC) -o obj/$(SRAND2).o -c $(SRAND2).c $(CFLAGS)

$(SRANDOM1): $(SRANDOM1).o
	$(GCC) -o $(SRANDOM1) obj/$(SRANDOM1).o $(LDFLAGS)
$(SRANDOM1).o:
	$(GCC) -o obj/$(SRANDOM1).o -c $(SRANDOM1).c $(CFLAGS)

$(SRANDOM2): $(SRANDOM2).o
	$(GCC) -o $(SRANDOM2) obj/$(SRANDOM2).o $(LDFLAGS)
$(SRANDOM2).o:
	$(GCC) -o obj/$(SRANDOM2).o -c $(SRANDOM2).c $(CFLAGS)

$(TAN): $(TAN).o
	$(GCC) -o $(TAN) obj/$(TAN).o $(LDFLAGS)
$(TAN).o:
	$(GCC) -o obj/$(TAN).o -c $(TAN).c $(CFLAGS)

$(TANH): $(TANH).o
	$(GCC) -o $(TANH) obj/$(TANH).o $(LDFLAGS)
$(TANH).o:
	$(GCC) -o obj/$(TANH).o -c $(TANH).c $(CFLAGS)

$(TGAMMA): $(TGAMMA).o
	$(GCC) -o $(TGAMMA) obj/$(TGAMMA).o $(LDFLAGS)
$(TGAMMA).o:
	$(GCC) -o obj/$(TGAMMA).o -c $(TGAMMA).c $(CFLAGS)

$(TRUNC): $(TRUNC).o
	$(GCC) -o $(TRUNC) obj/$(TRUNC).o $(LDFLAGS)
$(TRUNC).o:
	$(GCC) -o obj/$(TRUNC).o -c $(TRUNC).c $(CFLAGS)

#top Makefile.fbsd¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_EXP2=1 -DHAVE_FDIM=1 -DHAVE_FMIN=1 -DHAVE_FMAX=1 -DHAVE_ISFINITE=1 -DHAVE_ISNORMAL=1 -DHAVE_ISNAN=1 -DHAVE_ISINF=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long
LIBS        = -lm
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

ABS         = abs
ACOS        = acos
ACOSH       = acosh
ASIN        = asin
ASINH       = asinh
ATAN2       = atan2
ATAN        = atan
ATANH       = atanh
CBRT        = cbrt
CEIL        = ceil
COPYSIGN    = copysign
COS         = cos
COSH        = cosh
DIV         = div
DREM        = drem
ERF         = erf
ERFC        = erfc
EXP10       = exp10
EXP2        = exp2
EXP         = exp
EXPM1       = expm1
FABS        = fabs
FDIM        = fdim
FLOOR       = floor
FMA         = fma
FMAX        = fmax
FMIN        = fmin
FMOD        = fmod
FPCLASSIFY  = fpclassify
FREXP       = frexp
GAMMA       = gamma
HYPOT       = hypot
INITSTATE   = initstate
ISFINITE    = isfinite
ISINF       = isinf
ISNAN       = isnan
ISNORMAL    = isnormal
LABS        = labs
LDEXP       = ldexp
LDIV        = ldiv
LGAMMA      = lgamma
LLABS       = llabs
LLDIV       = lldiv
LLRINT      = llrint
LLROUND     = llround
LOG10       = log10
LOG1P       = log1p
LOG2        = log2
LOGB        = logb
LOG         = log
LRINT       = lrint
LROUND      = lround
MODF        = modf
NEARBYINT   = nearbyint
NEXTAFTER   = nextafter
NEXTTOWARD  = nexttoward
POW10       = pow10
POW         = pow
RAND        = rand
RANDOM      = random
REMAINDER   = remainder
REMQUO      = remquo
RINT        = rint
ROUND       = round
SCALB       = scalb
SCALBLN     = scalbln
SCALBN      = scalbn
SETSTATE    = setstate
SIGNBIT     = signbit
SIN         = sin
SINH        = sinh
SQRT        = sqrt
SRAND1      = srand1
SRAND2      = srand2
SRANDOM1    = srandom1
SRANDOM2    = srandom2
TAN         = tan
TANH        = tanh
TGAMMA      = tgamma
TRUNC       = trunc



all: objdir make

objdir:
	$(MKDCMD) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(ABS)
#make: $(ACOS)
#make: $(ACOSH)
#make: $(ASIN)
#make: $(ASINH)
#make: $(ATAN2)
#make: $(ATAN)
#make: $(ATANH)
#make: $(CBRT)
#make: $(CEIL)
#make: $(COPYSIGN)
#make: $(COS)
#make: $(COSH)
#make: $(DIV)
#make: $(DREM)
#make: $(ERF)
#make: $(ERFC)
#make: $(EXP10)
#make: $(EXP2)
#make: $(EXP)
#make: $(EXPM1)
#make: $(FABS)
#make: $(FDIM)
#make: $(FLOOR)
#make: $(FMA)
#make: $(FMAX)
#make: $(FMIN)
#make: $(FMOD)
#make: $(FPCLASSIFY)
#make: $(FREXP)
#make: $(GAMMA)
#make: $(HYPOT)
#make: $(INITSTATE)
#make: $(ISFINITE)
#make: $(ISINF)
#make: $(ISNAN)
#make: $(ISNORMAL)
#make: $(LABS)
#make: $(LDEXP)
#make: $(LDIV)
#make: $(LGAMMA)
#make: $(LLABS)
#make: $(LLDIV)
#make: $(LLRINT)
#make: $(LLROUND)
#make: $(LOG10)
#make: $(LOG1P)
#make: $(LOG2)
#make: $(LOGB)
#make: $(LOG)
#make: $(LRINT)
#make: $(LROUND)
#make: $(MODF)
#make: $(NEARBYINT)
#make: $(NEXTAFTER)
#make: $(NEXTTOWARD)
#make: $(POW10)
#make: $(POW)
#make: $(RAND)
#make: $(RANDOM)
#make: $(REMAINDER)
#make: $(REMQUO)
#make: $(RINT)
#make: $(ROUND)
#make: $(SCALB)
#make: $(SCALBLN)
#make: $(SCALBN)
#make: $(SETSTATE)
#make: $(SIGNBIT)
#make: $(SIN)
#make: $(SINH)
#make: $(SQRT)
#make: $(SRAND1)
#make: $(SRAND2)
#make: $(SRANDOM1)
#make: $(SRANDOM2)
#make: $(TAN)
#make: $(TANH)
#make: $(TGAMMA)
#make: $(TRUNC)
make: $(ABS) $(ACOS) $(ACOSH) $(ASIN) $(ASINH) $(ATAN2) $(ATAN) $(ATANH) $(CBRT) $(CEIL) $(COPYSIGN) $(COS) $(COSH) $(DIV) $(DREM) $(ERF) $(ERFC) $(EXP10) $(EXP2) $(EXP) $(EXPM1) $(FABS) $(FDIM) $(FLOOR) $(FMA) $(FMAX) $(FMIN) $(FMOD) $(FPCLASSIFY) $(FREXP) $(GAMMA) $(HYPOT) $(INITSTATE) $(ISFINITE) $(ISINF) $(ISNAN) $(ISNORMAL) $(LABS) $(LDEXP) $(LDIV) $(LGAMMA) $(LLABS) $(LLDIV) $(LLRINT) $(LLROUND) $(LOG10) $(LOG1P) $(LOG2) $(LOGB) $(LOG) $(LRINT) $(LROUND) $(MODF) $(NEARBYINT) $(NEXTAFTER) $(NEXTTOWARD) $(POW10) $(POW) $(RAND) $(RANDOM) $(REMAINDER) $(REMQUO) $(RINT) $(ROUND) $(SCALB) $(SCALBLN) $(SCALBN) $(SETSTATE) $(SIGNBIT) $(SIN) $(SINH) $(SQRT) $(SRAND1) $(SRAND2) $(SRANDOM1) $(SRANDOM2) $(TAN) $(TANH) $(TGAMMA) $(TRUNC)



$(ABS): $(ABS).o
	$(GCC) -o $(ABS) obj/$(ABS).o $(LDFLAGS)
$(ABS).o:
	$(GCC) -o obj/$(ABS).o -c $(ABS).c $(CFLAGS)

$(ACOS): $(ACOS).o
	$(GCC) -o $(ACOS) obj/$(ACOS).o $(LDFLAGS)
$(ACOS).o:
	$(GCC) -o obj/$(ACOS).o -c $(ACOS).c $(CFLAGS)

$(ACOSH): $(ACOSH).o
	$(GCC) -o $(ACOSH) obj/$(ACOSH).o $(LDFLAGS)
$(ACOSH).o:
	$(GCC) -o obj/$(ACOSH).o -c $(ACOSH).c $(CFLAGS)

$(ASIN): $(ASIN).o
	$(GCC) -o $(ASIN) obj/$(ASIN).o $(LDFLAGS)
$(ASIN).o:
	$(GCC) -o obj/$(ASIN).o -c $(ASIN).c $(CFLAGS)

$(ASINH): $(ASINH).o
	$(GCC) -o $(ASINH) obj/$(ASINH).o $(LDFLAGS)
$(ASINH).o:
	$(GCC) -o obj/$(ASINH).o -c $(ASINH).c $(CFLAGS)

$(ATAN2): $(ATAN2).o
	$(GCC) -o $(ATAN2) obj/$(ATAN2).o $(LDFLAGS)
$(ATAN2).o:
	$(GCC) -o obj/$(ATAN2).o -c $(ATAN2).c $(CFLAGS)

$(ATAN): $(ATAN).o
	$(GCC) -o $(ATAN) obj/$(ATAN).o $(LDFLAGS)
$(ATAN).o:
	$(GCC) -o obj/$(ATAN).o -c $(ATAN).c $(CFLAGS)

$(ATANH): $(ATANH).o
	$(GCC) -o $(ATANH) obj/$(ATANH).o $(LDFLAGS)
$(ATANH).o:
	$(GCC) -o obj/$(ATANH).o -c $(ATANH).c $(CFLAGS)

$(CBRT): $(CBRT).o
	$(GCC) -o $(CBRT) obj/$(CBRT).o $(LDFLAGS)
$(CBRT).o:
	$(GCC) -o obj/$(CBRT).o -c $(CBRT).c $(CFLAGS)

$(CEIL): $(CEIL).o
	$(GCC) -o $(CEIL) obj/$(CEIL).o $(LDFLAGS)
$(CEIL).o:
	$(GCC) -o obj/$(CEIL).o -c $(CEIL).c $(CFLAGS)

$(COPYSIGN): $(COPYSIGN).o
	$(GCC) -o $(COPYSIGN) obj/$(COPYSIGN).o $(LDFLAGS)
$(COPYSIGN).o:
	$(GCC) -o obj/$(COPYSIGN).o -c $(COPYSIGN).c $(CFLAGS)

$(COS): $(COS).o
	$(GCC) -o $(COS) obj/$(COS).o $(LDFLAGS)
$(COS).o:
	$(GCC) -o obj/$(COS).o -c $(COS).c $(CFLAGS)

$(COSH): $(COSH).o
	$(GCC) -o $(COSH) obj/$(COSH).o $(LDFLAGS)
$(COSH).o:
	$(GCC) -o obj/$(COSH).o -c $(COSH).c $(CFLAGS)

$(DIV): $(DIV).o
	$(GCC) -o $(DIV) obj/$(DIV).o $(LDFLAGS)
$(DIV).o:
	$(GCC) -o obj/$(DIV).o -c $(DIV).c $(CFLAGS)

$(DREM): $(DREM).o
	$(GCC) -o $(DREM) obj/$(DREM).o $(LDFLAGS)
$(DREM).o:
	$(GCC) -o obj/$(DREM).o -c $(DREM).c $(CFLAGS)

$(ERF): $(ERF).o
	$(GCC) -o $(ERF) obj/$(ERF).o $(LDFLAGS)
$(ERF).o:
	$(GCC) -o obj/$(ERF).o -c $(ERF).c $(CFLAGS)

$(ERFC): $(ERFC).o
	$(GCC) -o $(ERFC) obj/$(ERFC).o $(LDFLAGS)
$(ERFC).o:
	$(GCC) -o obj/$(ERFC).o -c $(ERFC).c $(CFLAGS)

$(EXP10): $(EXP10).o
	$(GCC) -o $(EXP10) obj/$(EXP10).o $(LDFLAGS)
$(EXP10).o:
	$(GCC) -o obj/$(EXP10).o -c $(EXP10).c $(CFLAGS)

$(EXP2): $(EXP2).o
	$(GCC) -o $(EXP2) obj/$(EXP2).o $(LDFLAGS)
$(EXP2).o:
	$(GCC) -o obj/$(EXP2).o -c $(EXP2).c $(CFLAGS)

$(EXP): $(EXP).o
	$(GCC) -o $(EXP) obj/$(EXP).o $(LDFLAGS)
$(EXP).o:
	$(GCC) -o obj/$(EXP).o -c $(EXP).c $(CFLAGS)

$(EXPM1): $(EXPM1).o
	$(GCC) -o $(EXPM1) obj/$(EXPM1).o $(LDFLAGS)
$(EXPM1).o:
	$(GCC) -o obj/$(EXPM1).o -c $(EXPM1).c $(CFLAGS)

$(FABS): $(FABS).o
	$(GCC) -o $(FABS) obj/$(FABS).o $(LDFLAGS)
$(FABS).o:
	$(GCC) -o obj/$(FABS).o -c $(FABS).c $(CFLAGS)

$(FDIM): $(FDIM).o
	$(GCC) -o $(FDIM) obj/$(FDIM).o $(LDFLAGS)
$(FDIM).o:
	$(GCC) -o obj/$(FDIM).o -c $(FDIM).c $(CFLAGS)

$(FLOOR): $(FLOOR).o
	$(GCC) -o $(FLOOR) obj/$(FLOOR).o $(LDFLAGS)
$(FLOOR).o:
	$(GCC) -o obj/$(FLOOR).o -c $(FLOOR).c $(CFLAGS)

$(FMA): $(FMA).o
	$(GCC) -o $(FMA) obj/$(FMA).o $(LDFLAGS)
$(FMA).o:
	$(GCC) -o obj/$(FMA).o -c $(FMA).c $(CFLAGS)

$(FMAX): $(FMAX).o
	$(GCC) -o $(FMAX) obj/$(FMAX).o $(LDFLAGS)
$(FMAX).o:
	$(GCC) -o obj/$(FMAX).o -c $(FMAX).c $(CFLAGS)

$(FMIN): $(FMIN).o
	$(GCC) -o $(FMIN) obj/$(FMIN).o $(LDFLAGS)
$(FMIN).o:
	$(GCC) -o obj/$(FMIN).o -c $(FMIN).c $(CFLAGS)

$(FMOD): $(FMOD).o
	$(GCC) -o $(FMOD) obj/$(FMOD).o $(LDFLAGS)
$(FMOD).o:
	$(GCC) -o obj/$(FMOD).o -c $(FMOD).c $(CFLAGS)

$(FPCLASSIFY): $(FPCLASSIFY).o
	$(GCC) -o $(FPCLASSIFY) obj/$(FPCLASSIFY).o $(LDFLAGS)
$(FPCLASSIFY).o:
	$(GCC) -o obj/$(FPCLASSIFY).o -c $(FPCLASSIFY).c $(CFLAGS)

$(FREXP): $(FREXP).o
	$(GCC) -o $(FREXP) obj/$(FREXP).o $(LDFLAGS)
$(FREXP).o:
	$(GCC) -o obj/$(FREXP).o -c $(FREXP).c $(CFLAGS)

$(GAMMA): $(GAMMA).o
	$(GCC) -o $(GAMMA) obj/$(GAMMA).o $(LDFLAGS)
$(GAMMA).o:
	$(GCC) -o obj/$(GAMMA).o -c $(GAMMA).c $(CFLAGS)

$(HYPOT): $(HYPOT).o
	$(GCC) -o $(HYPOT) obj/$(HYPOT).o $(LDFLAGS)
$(HYPOT).o:
	$(GCC) -o obj/$(HYPOT).o -c $(HYPOT).c $(CFLAGS)

$(INITSTATE): $(INITSTATE).o
	$(GCC) -o $(INITSTATE) obj/$(INITSTATE).o $(LDFLAGS)
$(INITSTATE).o:
	$(GCC) -o obj/$(INITSTATE).o -c $(INITSTATE).c $(CFLAGS)

$(ISFINITE): $(ISFINITE).o
	$(GCC) -o $(ISFINITE) obj/$(ISFINITE).o $(LDFLAGS)
$(ISFINITE).o:
	$(GCC) -o obj/$(ISFINITE).o -c $(ISFINITE).c $(CFLAGS)

$(ISINF): $(ISINF).o
	$(GCC) -o $(ISINF) obj/$(ISINF).o $(LDFLAGS)
$(ISINF).o:
	$(GCC) -o obj/$(ISINF).o -c $(ISINF).c $(CFLAGS)

$(ISNAN): $(ISNAN).o
	$(GCC) -o $(ISNAN) obj/$(ISNAN).o $(LDFLAGS)
$(ISNAN).o:
	$(GCC) -o obj/$(ISNAN).o -c $(ISNAN).c $(CFLAGS)

$(ISNORMAL): $(ISNORMAL).o
	$(GCC) -o $(ISNORMAL) obj/$(ISNORMAL).o $(LDFLAGS)
$(ISNORMAL).o:
	$(GCC) -o obj/$(ISNORMAL).o -c $(ISNORMAL).c $(CFLAGS)

$(LABS): $(LABS).o
	$(GCC) -o $(LABS) obj/$(LABS).o $(LDFLAGS)
$(LABS).o:
	$(GCC) -o obj/$(LABS).o -c $(LABS).c $(CFLAGS)

$(LDEXP): $(LDEXP).o
	$(GCC) -o $(LDEXP) obj/$(LDEXP).o $(LDFLAGS)
$(LDEXP).o:
	$(GCC) -o obj/$(LDEXP).o -c $(LDEXP).c $(CFLAGS)

$(LDIV): $(LDIV).o
	$(GCC) -o $(LDIV) obj/$(LDIV).o $(LDFLAGS)
$(LDIV).o:
	$(GCC) -o obj/$(LDIV).o -c $(LDIV).c $(CFLAGS)

$(LGAMMA): $(LGAMMA).o
	$(GCC) -o $(LGAMMA) obj/$(LGAMMA).o $(LDFLAGS)
$(LGAMMA).o:
	$(GCC) -o obj/$(LGAMMA).o -c $(LGAMMA).c $(CFLAGS)

$(LLABS): $(LLABS).o
	$(GCC) -o $(LLABS) obj/$(LLABS).o $(LDFLAGS)
$(LLABS).o:
	$(GCC) -o obj/$(LLABS).o -c $(LLABS).c $(CFLAGS)

$(LLDIV): $(LLDIV).o
	$(GCC) -o $(LLDIV) obj/$(LLDIV).o $(LDFLAGS)
$(LLDIV).o:
	$(GCC) -o obj/$(LLDIV).o -c $(LLDIV).c $(CFLAGS)

$(LLRINT): $(LLRINT).o
	$(GCC) -o $(LLRINT) obj/$(LLRINT).o $(LDFLAGS)
$(LLRINT).o:
	$(GCC) -o obj/$(LLRINT).o -c $(LLRINT).c $(CFLAGS)

$(LLROUND): $(LLROUND).o
	$(GCC) -o $(LLROUND) obj/$(LLROUND).o $(LDFLAGS)
$(LLROUND).o:
	$(GCC) -o obj/$(LLROUND).o -c $(LLROUND).c $(CFLAGS)

$(LOG10): $(LOG10).o
	$(GCC) -o $(LOG10) obj/$(LOG10).o $(LDFLAGS)
$(LOG10).o:
	$(GCC) -o obj/$(LOG10).o -c $(LOG10).c $(CFLAGS)

$(LOG1P): $(LOG1P).o
	$(GCC) -o $(LOG1P) obj/$(LOG1P).o $(LDFLAGS)
$(LOG1P).o:
	$(GCC) -o obj/$(LOG1P).o -c $(LOG1P).c $(CFLAGS)

$(LOG2): $(LOG2).o
	$(GCC) -o $(LOG2) obj/$(LOG2).o $(LDFLAGS)
$(LOG2).o:
	$(GCC) -o obj/$(LOG2).o -c $(LOG2).c $(CFLAGS)

$(LOGB): $(LOGB).o
	$(GCC) -o $(LOGB) obj/$(LOGB).o $(LDFLAGS)
$(LOGB).o:
	$(GCC) -o obj/$(LOGB).o -c $(LOGB).c $(CFLAGS)

$(LOG): $(LOG).o
	$(GCC) -o $(LOG) obj/$(LOG).o $(LDFLAGS)
$(LOG).o:
	$(GCC) -o obj/$(LOG).o -c $(LOG).c $(CFLAGS)

$(LRINT): $(LRINT).o
	$(GCC) -o $(LRINT) obj/$(LRINT).o $(LDFLAGS)
$(LRINT).o:
	$(GCC) -o obj/$(LRINT).o -c $(LRINT).c $(CFLAGS)

$(LROUND): $(LROUND).o
	$(GCC) -o $(LROUND) obj/$(LROUND).o $(LDFLAGS)
$(LROUND).o:
	$(GCC) -o obj/$(LROUND).o -c $(LROUND).c $(CFLAGS)

$(MODF): $(MODF).o
	$(GCC) -o $(MODF) obj/$(MODF).o $(LDFLAGS)
$(MODF).o:
	$(GCC) -o obj/$(MODF).o -c $(MODF).c $(CFLAGS)

$(NEARBYINT): $(NEARBYINT).o
	$(GCC) -o $(NEARBYINT) obj/$(NEARBYINT).o $(LDFLAGS)
$(NEARBYINT).o:
	$(GCC) -o obj/$(NEARBYINT).o -c $(NEARBYINT).c $(CFLAGS)

$(NEXTAFTER): $(NEXTAFTER).o
	$(GCC) -o $(NEXTAFTER) obj/$(NEXTAFTER).o $(LDFLAGS)
$(NEXTAFTER).o:
	$(GCC) -o obj/$(NEXTAFTER).o -c $(NEXTAFTER).c $(CFLAGS)

$(NEXTTOWARD): $(NEXTTOWARD).o
	$(GCC) -o $(NEXTTOWARD) obj/$(NEXTTOWARD).o $(LDFLAGS)
$(NEXTTOWARD).o:
	$(GCC) -o obj/$(NEXTTOWARD).o -c $(NEXTTOWARD).c $(CFLAGS)

$(POW10): $(POW10).o
	$(GCC) -o $(POW10) obj/$(POW10).o $(LDFLAGS)
$(POW10).o:
	$(GCC) -o obj/$(POW10).o -c $(POW10).c $(CFLAGS)

$(POW): $(POW).o
	$(GCC) -o $(POW) obj/$(POW).o $(LDFLAGS)
$(POW).o:
	$(GCC) -o obj/$(POW).o -c $(POW).c $(CFLAGS)

$(RAND): $(RAND).o
	$(GCC) -o $(RAND) obj/$(RAND).o $(LDFLAGS)
$(RAND).o:
	$(GCC) -o obj/$(RAND).o -c $(RAND).c $(CFLAGS)

$(RANDOM): $(RANDOM).o
	$(GCC) -o $(RANDOM) obj/$(RANDOM).o $(LDFLAGS)
$(RANDOM).o:
	$(GCC) -o obj/$(RANDOM).o -c $(RANDOM).c $(CFLAGS)

$(REMAINDER): $(REMAINDER).o
	$(GCC) -o $(REMAINDER) obj/$(REMAINDER).o $(LDFLAGS)
$(REMAINDER).o:
	$(GCC) -o obj/$(REMAINDER).o -c $(REMAINDER).c $(CFLAGS)

$(REMQUO): $(REMQUO).o
	$(GCC) -o $(REMQUO) obj/$(REMQUO).o $(LDFLAGS)
$(REMQUO).o:
	$(GCC) -o obj/$(REMQUO).o -c $(REMQUO).c $(CFLAGS)

$(RINT): $(RINT).o
	$(GCC) -o $(RINT) obj/$(RINT).o $(LDFLAGS)
$(RINT).o:
	$(GCC) -o obj/$(RINT).o -c $(RINT).c $(CFLAGS)

$(ROUND): $(ROUND).o
	$(GCC) -o $(ROUND) obj/$(ROUND).o $(LDFLAGS)
$(ROUND).o:
	$(GCC) -o obj/$(ROUND).o -c $(ROUND).c $(CFLAGS)

$(SCALB): $(SCALB).o
	$(GCC) -o $(SCALB) obj/$(SCALB).o $(LDFLAGS)
$(SCALB).o:
	$(GCC) -o obj/$(SCALB).o -c $(SCALB).c $(CFLAGS)

$(SCALBLN): $(SCALBLN).o
	$(GCC) -o $(SCALBLN) obj/$(SCALBLN).o $(LDFLAGS)
$(SCALBLN).o:
	$(GCC) -o obj/$(SCALBLN).o -c $(SCALBLN).c $(CFLAGS)

$(SCALBN): $(SCALBN).o
	$(GCC) -o $(SCALBN) obj/$(SCALBN).o $(LDFLAGS)
$(SCALBN).o:
	$(GCC) -o obj/$(SCALBN).o -c $(SCALBN).c $(CFLAGS)

$(SETSTATE): $(SETSTATE).o
	$(GCC) -o $(SETSTATE) obj/$(SETSTATE).o $(LDFLAGS)
$(SETSTATE).o:
	$(GCC) -o obj/$(SETSTATE).o -c $(SETSTATE).c $(CFLAGS)

$(SIGNBIT): $(SIGNBIT).o
	$(GCC) -o $(SIGNBIT) obj/$(SIGNBIT).o $(LDFLAGS)
$(SIGNBIT).o:
	$(GCC) -o obj/$(SIGNBIT).o -c $(SIGNBIT).c $(CFLAGS)

$(SIN): $(SIN).o
	$(GCC) -o $(SIN) obj/$(SIN).o $(LDFLAGS)
$(SIN).o:
	$(GCC) -o obj/$(SIN).o -c $(SIN).c $(CFLAGS)

$(SINH): $(SINH).o
	$(GCC) -o $(SINH) obj/$(SINH).o $(LDFLAGS)
$(SINH).o:
	$(GCC) -o obj/$(SINH).o -c $(SINH).c $(CFLAGS)

$(SQRT): $(SQRT).o
	$(GCC) -o $(SQRT) obj/$(SQRT).o $(LDFLAGS)
$(SQRT).o:
	$(GCC) -o obj/$(SQRT).o -c $(SQRT).c $(CFLAGS)

$(SRAND1): $(SRAND1).o
	$(GCC) -o $(SRAND1) obj/$(SRAND1).o $(LDFLAGS)
$(SRAND1).o:
	$(GCC) -o obj/$(SRAND1).o -c $(SRAND1).c $(CFLAGS)

$(SRAND2): $(SRAND2).o
	$(GCC) -o $(SRAND2) obj/$(SRAND2).o $(LDFLAGS)
$(SRAND2).o:
	$(GCC) -o obj/$(SRAND2).o -c $(SRAND2).c $(CFLAGS)

$(SRANDOM1): $(SRANDOM1).o
	$(GCC) -o $(SRANDOM1) obj/$(SRANDOM1).o $(LDFLAGS)
$(SRANDOM1).o:
	$(GCC) -o obj/$(SRANDOM1).o -c $(SRANDOM1).c $(CFLAGS)

$(SRANDOM2): $(SRANDOM2).o
	$(GCC) -o $(SRANDOM2) obj/$(SRANDOM2).o $(LDFLAGS)
$(SRANDOM2).o:
	$(GCC) -o obj/$(SRANDOM2).o -c $(SRANDOM2).c $(CFLAGS)

$(TAN): $(TAN).o
	$(GCC) -o $(TAN) obj/$(TAN).o $(LDFLAGS)
$(TAN).o:
	$(GCC) -o obj/$(TAN).o -c $(TAN).c $(CFLAGS)

$(TANH): $(TANH).o
	$(GCC) -o $(TANH) obj/$(TANH).o $(LDFLAGS)
$(TANH).o:
	$(GCC) -o obj/$(TANH).o -c $(TANH).c $(CFLAGS)

$(TGAMMA): $(TGAMMA).o
	$(GCC) -o $(TGAMMA) obj/$(TGAMMA).o $(LDFLAGS)
$(TGAMMA).o:
	$(GCC) -o obj/$(TGAMMA).o -c $(TGAMMA).c $(CFLAGS)

$(TRUNC): $(TRUNC).o
	$(GCC) -o $(TRUNC) obj/$(TRUNC).o $(LDFLAGS)
$(TRUNC).o:
	$(GCC) -o obj/$(TRUNC).o -c $(TRUNC).c $(CFLAGS)

#top Makefile.sol¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_EXP2=1 -DHAVE_LOG2=1 -DHAVE_FDIM=1 -DHAVE_FMIN=1 -DHAVE_FMAX=1 -DHAVE_ISNAN=1 -DHAVE_ISINF=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long
LIBS        = -lm
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

ABS         = abs
ACOS        = acos
ACOSH       = acosh
ASIN        = asin
ASINH       = asinh
ATAN2       = atan2
ATAN        = atan
ATANH       = atanh
CBRT        = cbrt
CEIL        = ceil
COPYSIGN    = copysign
COS         = cos
COSH        = cosh
DIV         = div
DREM        = drem
ERF         = erf
ERFC        = erfc
EXP10       = exp10
EXP2        = exp2
EXP         = exp
EXPM1       = expm1
FABS        = fabs
FDIM        = fdim
FLOOR       = floor
FMA         = fma
FMAX        = fmax
FMIN        = fmin
FMOD        = fmod
FPCLASSIFY  = fpclassify
FREXP       = frexp
GAMMA       = gamma
HYPOT       = hypot
INITSTATE   = initstate
ISFINITE    = isfinite
ISINF       = isinf
ISNAN       = isnan
ISNORMAL    = isnormal
LABS        = labs
LDEXP       = ldexp
LDIV        = ldiv
LGAMMA      = lgamma
LLABS       = llabs
LLDIV       = lldiv
LLRINT      = llrint
LLROUND     = llround
LOG10       = log10
LOG1P       = log1p
LOG2        = log2
LOGB        = logb
LOG         = log
LRINT       = lrint
LROUND      = lround
MODF        = modf
NEARBYINT   = nearbyint
NEXTAFTER   = nextafter
NEXTTOWARD  = nexttoward
POW10       = pow10
POW         = pow
RAND        = rand
RANDOM      = random
REMAINDER   = remainder
REMQUO      = remquo
RINT        = rint
ROUND       = round
SCALB       = scalb
SCALBLN     = scalbln
SCALBN      = scalbn
SETSTATE    = setstate
SIGNBIT     = signbit
SIN         = sin
SINH        = sinh
SQRT        = sqrt
SRAND1      = srand1
SRAND2      = srand2
SRANDOM1    = srandom1
SRANDOM2    = srandom2
TAN         = tan
TANH        = tanh
TGAMMA      = tgamma
TRUNC       = trunc



all: objdir make

objdir:
	$(MKDCMD) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(ABS)
#make: $(ACOS)
#make: $(ACOSH)
#make: $(ASIN)
#make: $(ASINH)
#make: $(ATAN2)
#make: $(ATAN)
#make: $(ATANH)
#make: $(CBRT)
#make: $(CEIL)
#make: $(COPYSIGN)
#make: $(COS)
#make: $(COSH)
#make: $(DIV)
#make: $(DREM)
#make: $(ERF)
#make: $(ERFC)
#make: $(EXP10)
#make: $(EXP2)
#make: $(EXP)
#make: $(EXPM1)
#make: $(FABS)
#make: $(FDIM)
#make: $(FLOOR)
#make: $(FMA)
#make: $(FMAX)
#make: $(FMIN)
#make: $(FMOD)
#make: $(FPCLASSIFY)
#make: $(FREXP)
#make: $(GAMMA)
#make: $(HYPOT)
#make: $(INITSTATE)
#make: $(ISFINITE)
#make: $(ISINF)
#make: $(ISNAN)
#make: $(ISNORMAL)
#make: $(LABS)
#make: $(LDEXP)
#make: $(LDIV)
#make: $(LGAMMA)
#make: $(LLABS)
#make: $(LLDIV)
#make: $(LLRINT)
#make: $(LLROUND)
#make: $(LOG10)
#make: $(LOG1P)
#make: $(LOG2)
#make: $(LOGB)
#make: $(LOG)
#make: $(LRINT)
#make: $(LROUND)
#make: $(MODF)
#make: $(NEARBYINT)
#make: $(NEXTAFTER)
#make: $(NEXTTOWARD)
#make: $(POW10)
#make: $(POW)
#make: $(RAND)
#make: $(RANDOM)
#make: $(REMAINDER)
#make: $(REMQUO)
#make: $(RINT)
#make: $(ROUND)
#make: $(SCALB)
#make: $(SCALBLN)
#make: $(SCALBN)
#make: $(SETSTATE)
#make: $(SIGNBIT)
#make: $(SIN)
#make: $(SINH)
#make: $(SQRT)
#make: $(SRAND1)
#make: $(SRAND2)
#make: $(SRANDOM1)
#make: $(SRANDOM2)
#make: $(TAN)
#make: $(TANH)
#make: $(TGAMMA)
#make: $(TRUNC)
make: $(ABS) $(ACOS) $(ACOSH) $(ASIN) $(ASINH) $(ATAN2) $(ATAN) $(ATANH) $(CBRT) $(CEIL) $(COPYSIGN) $(COS) $(COSH) $(DIV) $(DREM) $(ERF) $(ERFC) $(EXP10) $(EXP2) $(EXP) $(EXPM1) $(FABS) $(FDIM) $(FLOOR) $(FMA) $(FMAX) $(FMIN) $(FMOD) $(FPCLASSIFY) $(FREXP) $(GAMMA) $(HYPOT) $(INITSTATE) $(ISFINITE) $(ISINF) $(ISNAN) $(ISNORMAL) $(LABS) $(LDEXP) $(LDIV) $(LGAMMA) $(LLABS) $(LLDIV) $(LLRINT) $(LLROUND) $(LOG10) $(LOG1P) $(LOG2) $(LOGB) $(LOG) $(LRINT) $(LROUND) $(MODF) $(NEARBYINT) $(NEXTAFTER) $(NEXTTOWARD) $(POW10) $(POW) $(RAND) $(RANDOM) $(REMAINDER) $(REMQUO) $(RINT) $(ROUND) $(SCALB) $(SCALBLN) $(SCALBN) $(SETSTATE) $(SIGNBIT) $(SIN) $(SINH) $(SQRT) $(SRAND1) $(SRAND2) $(SRANDOM1) $(SRANDOM2) $(TAN) $(TANH) $(TGAMMA) $(TRUNC)



$(ABS): $(ABS).o
	$(GCC) -o $(ABS) obj/$(ABS).o $(LDFLAGS)
$(ABS).o:
	$(GCC) -o obj/$(ABS).o -c $(ABS).c $(CFLAGS)

$(ACOS): $(ACOS).o
	$(GCC) -o $(ACOS) obj/$(ACOS).o $(LDFLAGS)
$(ACOS).o:
	$(GCC) -o obj/$(ACOS).o -c $(ACOS).c $(CFLAGS)

$(ACOSH): $(ACOSH).o
	$(GCC) -o $(ACOSH) obj/$(ACOSH).o $(LDFLAGS)
$(ACOSH).o:
	$(GCC) -o obj/$(ACOSH).o -c $(ACOSH).c $(CFLAGS)

$(ASIN): $(ASIN).o
	$(GCC) -o $(ASIN) obj/$(ASIN).o $(LDFLAGS)
$(ASIN).o:
	$(GCC) -o obj/$(ASIN).o -c $(ASIN).c $(CFLAGS)

$(ASINH): $(ASINH).o
	$(GCC) -o $(ASINH) obj/$(ASINH).o $(LDFLAGS)
$(ASINH).o:
	$(GCC) -o obj/$(ASINH).o -c $(ASINH).c $(CFLAGS)

$(ATAN2): $(ATAN2).o
	$(GCC) -o $(ATAN2) obj/$(ATAN2).o $(LDFLAGS)
$(ATAN2).o:
	$(GCC) -o obj/$(ATAN2).o -c $(ATAN2).c $(CFLAGS)

$(ATAN): $(ATAN).o
	$(GCC) -o $(ATAN) obj/$(ATAN).o $(LDFLAGS)
$(ATAN).o:
	$(GCC) -o obj/$(ATAN).o -c $(ATAN).c $(CFLAGS)

$(ATANH): $(ATANH).o
	$(GCC) -o $(ATANH) obj/$(ATANH).o $(LDFLAGS)
$(ATANH).o:
	$(GCC) -o obj/$(ATANH).o -c $(ATANH).c $(CFLAGS)

$(CBRT): $(CBRT).o
	$(GCC) -o $(CBRT) obj/$(CBRT).o $(LDFLAGS)
$(CBRT).o:
	$(GCC) -o obj/$(CBRT).o -c $(CBRT).c $(CFLAGS)

$(CEIL): $(CEIL).o
	$(GCC) -o $(CEIL) obj/$(CEIL).o $(LDFLAGS)
$(CEIL).o:
	$(GCC) -o obj/$(CEIL).o -c $(CEIL).c $(CFLAGS)

$(COPYSIGN): $(COPYSIGN).o
	$(GCC) -o $(COPYSIGN) obj/$(COPYSIGN).o $(LDFLAGS)
$(COPYSIGN).o:
	$(GCC) -o obj/$(COPYSIGN).o -c $(COPYSIGN).c $(CFLAGS)

$(COS): $(COS).o
	$(GCC) -o $(COS) obj/$(COS).o $(LDFLAGS)
$(COS).o:
	$(GCC) -o obj/$(COS).o -c $(COS).c $(CFLAGS)

$(COSH): $(COSH).o
	$(GCC) -o $(COSH) obj/$(COSH).o $(LDFLAGS)
$(COSH).o:
	$(GCC) -o obj/$(COSH).o -c $(COSH).c $(CFLAGS)

$(DIV): $(DIV).o
	$(GCC) -o $(DIV) obj/$(DIV).o $(LDFLAGS)
$(DIV).o:
	$(GCC) -o obj/$(DIV).o -c $(DIV).c $(CFLAGS)

$(DREM): $(DREM).o
	$(GCC) -o $(DREM) obj/$(DREM).o $(LDFLAGS)
$(DREM).o:
	$(GCC) -o obj/$(DREM).o -c $(DREM).c $(CFLAGS)

$(ERF): $(ERF).o
	$(GCC) -o $(ERF) obj/$(ERF).o $(LDFLAGS)
$(ERF).o:
	$(GCC) -o obj/$(ERF).o -c $(ERF).c $(CFLAGS)

$(ERFC): $(ERFC).o
	$(GCC) -o $(ERFC) obj/$(ERFC).o $(LDFLAGS)
$(ERFC).o:
	$(GCC) -o obj/$(ERFC).o -c $(ERFC).c $(CFLAGS)

$(EXP10): $(EXP10).o
	$(GCC) -o $(EXP10) obj/$(EXP10).o $(LDFLAGS)
$(EXP10).o:
	$(GCC) -o obj/$(EXP10).o -c $(EXP10).c $(CFLAGS)

$(EXP2): $(EXP2).o
	$(GCC) -o $(EXP2) obj/$(EXP2).o $(LDFLAGS)
$(EXP2).o:
	$(GCC) -o obj/$(EXP2).o -c $(EXP2).c $(CFLAGS)

$(EXP): $(EXP).o
	$(GCC) -o $(EXP) obj/$(EXP).o $(LDFLAGS)
$(EXP).o:
	$(GCC) -o obj/$(EXP).o -c $(EXP).c $(CFLAGS)

$(EXPM1): $(EXPM1).o
	$(GCC) -o $(EXPM1) obj/$(EXPM1).o $(LDFLAGS)
$(EXPM1).o:
	$(GCC) -o obj/$(EXPM1).o -c $(EXPM1).c $(CFLAGS)

$(FABS): $(FABS).o
	$(GCC) -o $(FABS) obj/$(FABS).o $(LDFLAGS)
$(FABS).o:
	$(GCC) -o obj/$(FABS).o -c $(FABS).c $(CFLAGS)

$(FDIM): $(FDIM).o
	$(GCC) -o $(FDIM) obj/$(FDIM).o $(LDFLAGS)
$(FDIM).o:
	$(GCC) -o obj/$(FDIM).o -c $(FDIM).c $(CFLAGS)

$(FLOOR): $(FLOOR).o
	$(GCC) -o $(FLOOR) obj/$(FLOOR).o $(LDFLAGS)
$(FLOOR).o:
	$(GCC) -o obj/$(FLOOR).o -c $(FLOOR).c $(CFLAGS)

$(FMA): $(FMA).o
	$(GCC) -o $(FMA) obj/$(FMA).o $(LDFLAGS)
$(FMA).o:
	$(GCC) -o obj/$(FMA).o -c $(FMA).c $(CFLAGS)

$(FMAX): $(FMAX).o
	$(GCC) -o $(FMAX) obj/$(FMAX).o $(LDFLAGS)
$(FMAX).o:
	$(GCC) -o obj/$(FMAX).o -c $(FMAX).c $(CFLAGS)

$(FMIN): $(FMIN).o
	$(GCC) -o $(FMIN) obj/$(FMIN).o $(LDFLAGS)
$(FMIN).o:
	$(GCC) -o obj/$(FMIN).o -c $(FMIN).c $(CFLAGS)

$(FMOD): $(FMOD).o
	$(GCC) -o $(FMOD) obj/$(FMOD).o $(LDFLAGS)
$(FMOD).o:
	$(GCC) -o obj/$(FMOD).o -c $(FMOD).c $(CFLAGS)

$(FPCLASSIFY): $(FPCLASSIFY).o
	$(GCC) -o $(FPCLASSIFY) obj/$(FPCLASSIFY).o $(LDFLAGS)
$(FPCLASSIFY).o:
	$(GCC) -o obj/$(FPCLASSIFY).o -c $(FPCLASSIFY).c $(CFLAGS)

$(FREXP): $(FREXP).o
	$(GCC) -o $(FREXP) obj/$(FREXP).o $(LDFLAGS)
$(FREXP).o:
	$(GCC) -o obj/$(FREXP).o -c $(FREXP).c $(CFLAGS)

$(GAMMA): $(GAMMA).o
	$(GCC) -o $(GAMMA) obj/$(GAMMA).o $(LDFLAGS)
$(GAMMA).o:
	$(GCC) -o obj/$(GAMMA).o -c $(GAMMA).c $(CFLAGS)

$(HYPOT): $(HYPOT).o
	$(GCC) -o $(HYPOT) obj/$(HYPOT).o $(LDFLAGS)
$(HYPOT).o:
	$(GCC) -o obj/$(HYPOT).o -c $(HYPOT).c $(CFLAGS)

$(INITSTATE): $(INITSTATE).o
	$(GCC) -o $(INITSTATE) obj/$(INITSTATE).o $(LDFLAGS)
$(INITSTATE).o:
	$(GCC) -o obj/$(INITSTATE).o -c $(INITSTATE).c $(CFLAGS)

$(ISFINITE): $(ISFINITE).o
	$(GCC) -o $(ISFINITE) obj/$(ISFINITE).o $(LDFLAGS)
$(ISFINITE).o:
	$(GCC) -o obj/$(ISFINITE).o -c $(ISFINITE).c $(CFLAGS)

$(ISINF): $(ISINF).o
	$(GCC) -o $(ISINF) obj/$(ISINF).o $(LDFLAGS)
$(ISINF).o:
	$(GCC) -o obj/$(ISINF).o -c $(ISINF).c $(CFLAGS)

$(ISNAN): $(ISNAN).o
	$(GCC) -o $(ISNAN) obj/$(ISNAN).o $(LDFLAGS)
$(ISNAN).o:
	$(GCC) -o obj/$(ISNAN).o -c $(ISNAN).c $(CFLAGS)

$(ISNORMAL): $(ISNORMAL).o
	$(GCC) -o $(ISNORMAL) obj/$(ISNORMAL).o $(LDFLAGS)
$(ISNORMAL).o:
	$(GCC) -o obj/$(ISNORMAL).o -c $(ISNORMAL).c $(CFLAGS)

$(LABS): $(LABS).o
	$(GCC) -o $(LABS) obj/$(LABS).o $(LDFLAGS)
$(LABS).o:
	$(GCC) -o obj/$(LABS).o -c $(LABS).c $(CFLAGS)

$(LDEXP): $(LDEXP).o
	$(GCC) -o $(LDEXP) obj/$(LDEXP).o $(LDFLAGS)
$(LDEXP).o:
	$(GCC) -o obj/$(LDEXP).o -c $(LDEXP).c $(CFLAGS)

$(LDIV): $(LDIV).o
	$(GCC) -o $(LDIV) obj/$(LDIV).o $(LDFLAGS)
$(LDIV).o:
	$(GCC) -o obj/$(LDIV).o -c $(LDIV).c $(CFLAGS)

$(LGAMMA): $(LGAMMA).o
	$(GCC) -o $(LGAMMA) obj/$(LGAMMA).o $(LDFLAGS)
$(LGAMMA).o:
	$(GCC) -o obj/$(LGAMMA).o -c $(LGAMMA).c $(CFLAGS)

$(LLABS): $(LLABS).o
	$(GCC) -o $(LLABS) obj/$(LLABS).o $(LDFLAGS)
$(LLABS).o:
	$(GCC) -o obj/$(LLABS).o -c $(LLABS).c $(CFLAGS)

$(LLDIV): $(LLDIV).o
	$(GCC) -o $(LLDIV) obj/$(LLDIV).o $(LDFLAGS)
$(LLDIV).o:
	$(GCC) -o obj/$(LLDIV).o -c $(LLDIV).c $(CFLAGS)

$(LLRINT): $(LLRINT).o
	$(GCC) -o $(LLRINT) obj/$(LLRINT).o $(LDFLAGS)
$(LLRINT).o:
	$(GCC) -o obj/$(LLRINT).o -c $(LLRINT).c $(CFLAGS)

$(LLROUND): $(LLROUND).o
	$(GCC) -o $(LLROUND) obj/$(LLROUND).o $(LDFLAGS)
$(LLROUND).o:
	$(GCC) -o obj/$(LLROUND).o -c $(LLROUND).c $(CFLAGS)

$(LOG10): $(LOG10).o
	$(GCC) -o $(LOG10) obj/$(LOG10).o $(LDFLAGS)
$(LOG10).o:
	$(GCC) -o obj/$(LOG10).o -c $(LOG10).c $(CFLAGS)

$(LOG1P): $(LOG1P).o
	$(GCC) -o $(LOG1P) obj/$(LOG1P).o $(LDFLAGS)
$(LOG1P).o:
	$(GCC) -o obj/$(LOG1P).o -c $(LOG1P).c $(CFLAGS)

$(LOG2): $(LOG2).o
	$(GCC) -o $(LOG2) obj/$(LOG2).o $(LDFLAGS)
$(LOG2).o:
	$(GCC) -o obj/$(LOG2).o -c $(LOG2).c $(CFLAGS)

$(LOGB): $(LOGB).o
	$(GCC) -o $(LOGB) obj/$(LOGB).o $(LDFLAGS)
$(LOGB).o:
	$(GCC) -o obj/$(LOGB).o -c $(LOGB).c $(CFLAGS)

$(LOG): $(LOG).o
	$(GCC) -o $(LOG) obj/$(LOG).o $(LDFLAGS)
$(LOG).o:
	$(GCC) -o obj/$(LOG).o -c $(LOG).c $(CFLAGS)

$(LRINT): $(LRINT).o
	$(GCC) -o $(LRINT) obj/$(LRINT).o $(LDFLAGS)
$(LRINT).o:
	$(GCC) -o obj/$(LRINT).o -c $(LRINT).c $(CFLAGS)

$(LROUND): $(LROUND).o
	$(GCC) -o $(LROUND) obj/$(LROUND).o $(LDFLAGS)
$(LROUND).o:
	$(GCC) -o obj/$(LROUND).o -c $(LROUND).c $(CFLAGS)

$(MODF): $(MODF).o
	$(GCC) -o $(MODF) obj/$(MODF).o $(LDFLAGS)
$(MODF).o:
	$(GCC) -o obj/$(MODF).o -c $(MODF).c $(CFLAGS)

$(NEARBYINT): $(NEARBYINT).o
	$(GCC) -o $(NEARBYINT) obj/$(NEARBYINT).o $(LDFLAGS)
$(NEARBYINT).o:
	$(GCC) -o obj/$(NEARBYINT).o -c $(NEARBYINT).c $(CFLAGS)

$(NEXTAFTER): $(NEXTAFTER).o
	$(GCC) -o $(NEXTAFTER) obj/$(NEXTAFTER).o $(LDFLAGS)
$(NEXTAFTER).o:
	$(GCC) -o obj/$(NEXTAFTER).o -c $(NEXTAFTER).c $(CFLAGS)

$(NEXTTOWARD): $(NEXTTOWARD).o
	$(GCC) -o $(NEXTTOWARD) obj/$(NEXTTOWARD).o $(LDFLAGS)
$(NEXTTOWARD).o:
	$(GCC) -o obj/$(NEXTTOWARD).o -c $(NEXTTOWARD).c $(CFLAGS)

$(POW10): $(POW10).o
	$(GCC) -o $(POW10) obj/$(POW10).o $(LDFLAGS)
$(POW10).o:
	$(GCC) -o obj/$(POW10).o -c $(POW10).c $(CFLAGS)

$(POW): $(POW).o
	$(GCC) -o $(POW) obj/$(POW).o $(LDFLAGS)
$(POW).o:
	$(GCC) -o obj/$(POW).o -c $(POW).c $(CFLAGS)

$(RAND): $(RAND).o
	$(GCC) -o $(RAND) obj/$(RAND).o $(LDFLAGS)
$(RAND).o:
	$(GCC) -o obj/$(RAND).o -c $(RAND).c $(CFLAGS)

$(RANDOM): $(RANDOM).o
	$(GCC) -o $(RANDOM) obj/$(RANDOM).o $(LDFLAGS)
$(RANDOM).o:
	$(GCC) -o obj/$(RANDOM).o -c $(RANDOM).c $(CFLAGS)

$(REMAINDER): $(REMAINDER).o
	$(GCC) -o $(REMAINDER) obj/$(REMAINDER).o $(LDFLAGS)
$(REMAINDER).o:
	$(GCC) -o obj/$(REMAINDER).o -c $(REMAINDER).c $(CFLAGS)

$(REMQUO): $(REMQUO).o
	$(GCC) -o $(REMQUO) obj/$(REMQUO).o $(LDFLAGS)
$(REMQUO).o:
	$(GCC) -o obj/$(REMQUO).o -c $(REMQUO).c $(CFLAGS)

$(RINT): $(RINT).o
	$(GCC) -o $(RINT) obj/$(RINT).o $(LDFLAGS)
$(RINT).o:
	$(GCC) -o obj/$(RINT).o -c $(RINT).c $(CFLAGS)

$(ROUND): $(ROUND).o
	$(GCC) -o $(ROUND) obj/$(ROUND).o $(LDFLAGS)
$(ROUND).o:
	$(GCC) -o obj/$(ROUND).o -c $(ROUND).c $(CFLAGS)

$(SCALB): $(SCALB).o
	$(GCC) -o $(SCALB) obj/$(SCALB).o $(LDFLAGS)
$(SCALB).o:
	$(GCC) -o obj/$(SCALB).o -c $(SCALB).c $(CFLAGS)

$(SCALBLN): $(SCALBLN).o
	$(GCC) -o $(SCALBLN) obj/$(SCALBLN).o $(LDFLAGS)
$(SCALBLN).o:
	$(GCC) -o obj/$(SCALBLN).o -c $(SCALBLN).c $(CFLAGS)

$(SCALBN): $(SCALBN).o
	$(GCC) -o $(SCALBN) obj/$(SCALBN).o $(LDFLAGS)
$(SCALBN).o:
	$(GCC) -o obj/$(SCALBN).o -c $(SCALBN).c $(CFLAGS)

$(SETSTATE): $(SETSTATE).o
	$(GCC) -o $(SETSTATE) obj/$(SETSTATE).o $(LDFLAGS)
$(SETSTATE).o:
	$(GCC) -o obj/$(SETSTATE).o -c $(SETSTATE).c $(CFLAGS)

$(SIGNBIT): $(SIGNBIT).o
	$(GCC) -o $(SIGNBIT) obj/$(SIGNBIT).o $(LDFLAGS)
$(SIGNBIT).o:
	$(GCC) -o obj/$(SIGNBIT).o -c $(SIGNBIT).c $(CFLAGS)

$(SIN): $(SIN).o
	$(GCC) -o $(SIN) obj/$(SIN).o $(LDFLAGS)
$(SIN).o:
	$(GCC) -o obj/$(SIN).o -c $(SIN).c $(CFLAGS)

$(SINH): $(SINH).o
	$(GCC) -o $(SINH) obj/$(SINH).o $(LDFLAGS)
$(SINH).o:
	$(GCC) -o obj/$(SINH).o -c $(SINH).c $(CFLAGS)

$(SQRT): $(SQRT).o
	$(GCC) -o $(SQRT) obj/$(SQRT).o $(LDFLAGS)
$(SQRT).o:
	$(GCC) -o obj/$(SQRT).o -c $(SQRT).c $(CFLAGS)

$(SRAND1): $(SRAND1).o
	$(GCC) -o $(SRAND1) obj/$(SRAND1).o $(LDFLAGS)
$(SRAND1).o:
	$(GCC) -o obj/$(SRAND1).o -c $(SRAND1).c $(CFLAGS)

$(SRAND2): $(SRAND2).o
	$(GCC) -o $(SRAND2) obj/$(SRAND2).o $(LDFLAGS)
$(SRAND2).o:
	$(GCC) -o obj/$(SRAND2).o -c $(SRAND2).c $(CFLAGS)

$(SRANDOM1): $(SRANDOM1).o
	$(GCC) -o $(SRANDOM1) obj/$(SRANDOM1).o $(LDFLAGS)
$(SRANDOM1).o:
	$(GCC) -o obj/$(SRANDOM1).o -c $(SRANDOM1).c $(CFLAGS)

$(SRANDOM2): $(SRANDOM2).o
	$(GCC) -o $(SRANDOM2) obj/$(SRANDOM2).o $(LDFLAGS)
$(SRANDOM2).o:
	$(GCC) -o obj/$(SRANDOM2).o -c $(SRANDOM2).c $(CFLAGS)

$(TAN): $(TAN).o
	$(GCC) -o $(TAN) obj/$(TAN).o $(LDFLAGS)
$(TAN).o:
	$(GCC) -o obj/$(TAN).o -c $(TAN).c $(CFLAGS)

$(TANH): $(TANH).o
	$(GCC) -o $(TANH) obj/$(TANH).o $(LDFLAGS)
$(TANH).o:
	$(GCC) -o obj/$(TANH).o -c $(TANH).c $(CFLAGS)

$(TGAMMA): $(TGAMMA).o
	$(GCC) -o $(TGAMMA) obj/$(TGAMMA).o $(LDFLAGS)
$(TGAMMA).o:
	$(GCC) -o obj/$(TGAMMA).o -c $(TGAMMA).c $(CFLAGS)

$(TRUNC): $(TRUNC).o
	$(GCC) -o $(TRUNC) obj/$(TRUNC).o $(LDFLAGS)
$(TRUNC).o:
	$(GCC) -o obj/$(TRUNC).o -c $(TRUNC).c $(CFLAGS)

#top Makefile.beos¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_EXP2=1 -DHAVE_LOG2=1 -DHAVE_FDIM=1 -DHAVE_FMIN=1 -DHAVE_FMAX=1 -DHAVE_ISFINITE=1 -DHAVE_ISNORMAL=1 -DHAVE_ISNAN=1 -DHAVE_ISINF=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wno-long-long
LIBS        =
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

ABS         = abs
ACOS        = acos
ACOSH       = acosh
ASIN        = asin
ASINH       = asinh
ATAN2       = atan2
ATAN        = atan
ATANH       = atanh
CBRT        = cbrt
CEIL        = ceil
COPYSIGN    = copysign
COS         = cos
COSH        = cosh
DIV         = div
DREM        = drem
ERF         = erf
ERFC        = erfc
EXP10       = exp10
EXP2        = exp2
EXP         = exp
EXPM1       = expm1
FABS        = fabs
FDIM        = fdim
FLOOR       = floor
FMA         = fma
FMAX        = fmax
FMIN        = fmin
FMOD        = fmod
FPCLASSIFY  = fpclassify
FREXP       = frexp
GAMMA       = gamma
HYPOT       = hypot
INITSTATE   = initstate
ISFINITE    = isfinite
ISINF       = isinf
ISNAN       = isnan
ISNORMAL    = isnormal
LABS        = labs
LDEXP       = ldexp
LDIV        = ldiv
LGAMMA      = lgamma
LLABS       = llabs
LLDIV       = lldiv
LLRINT      = llrint
LLROUND     = llround
LOG10       = log10
LOG1P       = log1p
LOG2        = log2
LOGB        = logb
LOG         = log
LRINT       = lrint
LROUND      = lround
MODF        = modf
NEARBYINT   = nearbyint
NEXTAFTER   = nextafter
NEXTTOWARD  = nexttoward
POW10       = pow10
POW         = pow
RAND        = rand
RANDOM      = random
REMAINDER   = remainder
REMQUO      = remquo
RINT        = rint
ROUND       = round
SCALB       = scalb
SCALBLN     = scalbln
SCALBN      = scalbn
SETSTATE    = setstate
SIGNBIT     = signbit
SIN         = sin
SINH        = sinh
SQRT        = sqrt
SRAND1      = srand1
SRAND2      = srand2
SRANDOM1    = srandom1
SRANDOM2    = srandom2
TAN         = tan
TANH        = tanh
TGAMMA      = tgamma
TRUNC       = trunc



all: objdir make

objdir:
	$(MKDCMD) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(ABS)
#make: $(ACOS)
#make: $(ACOSH)
#make: $(ASIN)
#make: $(ASINH)
#make: $(ATAN2)
#make: $(ATAN)
#make: $(ATANH)
#make: $(CBRT)
#make: $(CEIL)
#make: $(COPYSIGN)
#make: $(COS)
#make: $(COSH)
#make: $(DIV)
#make: $(DREM)
#make: $(ERF)
#make: $(ERFC)
#make: $(EXP10)
#make: $(EXP2)
#make: $(EXP)
#make: $(EXPM1)
#make: $(FABS)
#make: $(FDIM)
#make: $(FLOOR)
#make: $(FMA)
#make: $(FMAX)
#make: $(FMIN)
#make: $(FMOD)
#make: $(FPCLASSIFY)
#make: $(FREXP)
#make: $(GAMMA)
#make: $(HYPOT)
#make: $(INITSTATE)
#make: $(ISFINITE)
#make: $(ISINF)
#make: $(ISNAN)
#make: $(ISNORMAL)
#make: $(LABS)
#make: $(LDEXP)
#make: $(LDIV)
#make: $(LGAMMA)
#make: $(LLABS)
#make: $(LLDIV)
#make: $(LLRINT)
#make: $(LLROUND)
#make: $(LOG10)
#make: $(LOG1P)
#make: $(LOG2)
#make: $(LOGB)
#make: $(LOG)
#make: $(LRINT)
#make: $(LROUND)
#make: $(MODF)
#make: $(NEARBYINT)
#make: $(NEXTAFTER)
#make: $(NEXTTOWARD)
#make: $(POW10)
#make: $(POW)
#make: $(RAND)
#make: $(RANDOM)
#make: $(REMAINDER)
#make: $(REMQUO)
#make: $(RINT)
#make: $(ROUND)
#make: $(SCALB)
#make: $(SCALBLN)
#make: $(SCALBN)
#make: $(SETSTATE)
#make: $(SIGNBIT)
#make: $(SIN)
#make: $(SINH)
#make: $(SQRT)
#make: $(SRAND1)
#make: $(SRAND2)
#make: $(SRANDOM1)
#make: $(SRANDOM2)
#make: $(TAN)
#make: $(TANH)
#make: $(TGAMMA)
#make: $(TRUNC)
make: $(ABS) $(ACOS) $(ACOSH) $(ASIN) $(ASINH) $(ATAN2) $(ATAN) $(ATANH) $(CBRT) $(CEIL) $(COPYSIGN) $(COS) $(COSH) $(DIV) $(DREM) $(ERF) $(ERFC) $(EXP10) $(EXP2) $(EXP) $(EXPM1) $(FABS) $(FDIM) $(FLOOR) $(FMA) $(FMAX) $(FMIN) $(FMOD) $(FPCLASSIFY) $(FREXP) $(GAMMA) $(HYPOT) $(INITSTATE) $(ISFINITE) $(ISINF) $(ISNAN) $(ISNORMAL) $(LABS) $(LDEXP) $(LDIV) $(LGAMMA) $(LLABS) $(LLDIV) $(LLRINT) $(LLROUND) $(LOG10) $(LOG1P) $(LOG2) $(LOGB) $(LOG) $(LRINT) $(LROUND) $(MODF) $(NEARBYINT) $(NEXTAFTER) $(NEXTTOWARD) $(POW10) $(POW) $(RAND) $(RANDOM) $(REMAINDER) $(REMQUO) $(RINT) $(ROUND) $(SCALB) $(SCALBLN) $(SCALBN) $(SETSTATE) $(SIGNBIT) $(SIN) $(SINH) $(SQRT) $(SRAND1) $(SRAND2) $(SRANDOM1) $(SRANDOM2) $(TAN) $(TANH) $(TGAMMA) $(TRUNC)



$(ABS): $(ABS).o
	$(GCC) -o $(ABS) obj/$(ABS).o $(LDFLAGS)
$(ABS).o:
	$(GCC) -o obj/$(ABS).o -c $(ABS).c $(CFLAGS)

$(ACOS): $(ACOS).o
	$(GCC) -o $(ACOS) obj/$(ACOS).o $(LDFLAGS)
$(ACOS).o:
	$(GCC) -o obj/$(ACOS).o -c $(ACOS).c $(CFLAGS)

$(ACOSH): $(ACOSH).o
	$(GCC) -o $(ACOSH) obj/$(ACOSH).o $(LDFLAGS)
$(ACOSH).o:
	$(GCC) -o obj/$(ACOSH).o -c $(ACOSH).c $(CFLAGS)

$(ASIN): $(ASIN).o
	$(GCC) -o $(ASIN) obj/$(ASIN).o $(LDFLAGS)
$(ASIN).o:
	$(GCC) -o obj/$(ASIN).o -c $(ASIN).c $(CFLAGS)

$(ASINH): $(ASINH).o
	$(GCC) -o $(ASINH) obj/$(ASINH).o $(LDFLAGS)
$(ASINH).o:
	$(GCC) -o obj/$(ASINH).o -c $(ASINH).c $(CFLAGS)

$(ATAN2): $(ATAN2).o
	$(GCC) -o $(ATAN2) obj/$(ATAN2).o $(LDFLAGS)
$(ATAN2).o:
	$(GCC) -o obj/$(ATAN2).o -c $(ATAN2).c $(CFLAGS)

$(ATAN): $(ATAN).o
	$(GCC) -o $(ATAN) obj/$(ATAN).o $(LDFLAGS)
$(ATAN).o:
	$(GCC) -o obj/$(ATAN).o -c $(ATAN).c $(CFLAGS)

$(ATANH): $(ATANH).o
	$(GCC) -o $(ATANH) obj/$(ATANH).o $(LDFLAGS)
$(ATANH).o:
	$(GCC) -o obj/$(ATANH).o -c $(ATANH).c $(CFLAGS)

$(CBRT): $(CBRT).o
	$(GCC) -o $(CBRT) obj/$(CBRT).o $(LDFLAGS)
$(CBRT).o:
	$(GCC) -o obj/$(CBRT).o -c $(CBRT).c $(CFLAGS)

$(CEIL): $(CEIL).o
	$(GCC) -o $(CEIL) obj/$(CEIL).o $(LDFLAGS)
$(CEIL).o:
	$(GCC) -o obj/$(CEIL).o -c $(CEIL).c $(CFLAGS)

$(COPYSIGN): $(COPYSIGN).o
	$(GCC) -o $(COPYSIGN) obj/$(COPYSIGN).o $(LDFLAGS)
$(COPYSIGN).o:
	$(GCC) -o obj/$(COPYSIGN).o -c $(COPYSIGN).c $(CFLAGS)

$(COS): $(COS).o
	$(GCC) -o $(COS) obj/$(COS).o $(LDFLAGS)
$(COS).o:
	$(GCC) -o obj/$(COS).o -c $(COS).c $(CFLAGS)

$(COSH): $(COSH).o
	$(GCC) -o $(COSH) obj/$(COSH).o $(LDFLAGS)
$(COSH).o:
	$(GCC) -o obj/$(COSH).o -c $(COSH).c $(CFLAGS)

$(DIV): $(DIV).o
	$(GCC) -o $(DIV) obj/$(DIV).o $(LDFLAGS)
$(DIV).o:
	$(GCC) -o obj/$(DIV).o -c $(DIV).c $(CFLAGS)

$(DREM): $(DREM).o
	$(GCC) -o $(DREM) obj/$(DREM).o $(LDFLAGS)
$(DREM).o:
	$(GCC) -o obj/$(DREM).o -c $(DREM).c $(CFLAGS)

$(ERF): $(ERF).o
	$(GCC) -o $(ERF) obj/$(ERF).o $(LDFLAGS)
$(ERF).o:
	$(GCC) -o obj/$(ERF).o -c $(ERF).c $(CFLAGS)

$(ERFC): $(ERFC).o
	$(GCC) -o $(ERFC) obj/$(ERFC).o $(LDFLAGS)
$(ERFC).o:
	$(GCC) -o obj/$(ERFC).o -c $(ERFC).c $(CFLAGS)

$(EXP10): $(EXP10).o
	$(GCC) -o $(EXP10) obj/$(EXP10).o $(LDFLAGS)
$(EXP10).o:
	$(GCC) -o obj/$(EXP10).o -c $(EXP10).c $(CFLAGS)

$(EXP2): $(EXP2).o
	$(GCC) -o $(EXP2) obj/$(EXP2).o $(LDFLAGS)
$(EXP2).o:
	$(GCC) -o obj/$(EXP2).o -c $(EXP2).c $(CFLAGS)

$(EXP): $(EXP).o
	$(GCC) -o $(EXP) obj/$(EXP).o $(LDFLAGS)
$(EXP).o:
	$(GCC) -o obj/$(EXP).o -c $(EXP).c $(CFLAGS)

$(EXPM1): $(EXPM1).o
	$(GCC) -o $(EXPM1) obj/$(EXPM1).o $(LDFLAGS)
$(EXPM1).o:
	$(GCC) -o obj/$(EXPM1).o -c $(EXPM1).c $(CFLAGS)

$(FABS): $(FABS).o
	$(GCC) -o $(FABS) obj/$(FABS).o $(LDFLAGS)
$(FABS).o:
	$(GCC) -o obj/$(FABS).o -c $(FABS).c $(CFLAGS)

$(FDIM): $(FDIM).o
	$(GCC) -o $(FDIM) obj/$(FDIM).o $(LDFLAGS)
$(FDIM).o:
	$(GCC) -o obj/$(FDIM).o -c $(FDIM).c $(CFLAGS)

$(FLOOR): $(FLOOR).o
	$(GCC) -o $(FLOOR) obj/$(FLOOR).o $(LDFLAGS)
$(FLOOR).o:
	$(GCC) -o obj/$(FLOOR).o -c $(FLOOR).c $(CFLAGS)

$(FMA): $(FMA).o
	$(GCC) -o $(FMA) obj/$(FMA).o $(LDFLAGS)
$(FMA).o:
	$(GCC) -o obj/$(FMA).o -c $(FMA).c $(CFLAGS)

$(FMAX): $(FMAX).o
	$(GCC) -o $(FMAX) obj/$(FMAX).o $(LDFLAGS)
$(FMAX).o:
	$(GCC) -o obj/$(FMAX).o -c $(FMAX).c $(CFLAGS)

$(FMIN): $(FMIN).o
	$(GCC) -o $(FMIN) obj/$(FMIN).o $(LDFLAGS)
$(FMIN).o:
	$(GCC) -o obj/$(FMIN).o -c $(FMIN).c $(CFLAGS)

$(FMOD): $(FMOD).o
	$(GCC) -o $(FMOD) obj/$(FMOD).o $(LDFLAGS)
$(FMOD).o:
	$(GCC) -o obj/$(FMOD).o -c $(FMOD).c $(CFLAGS)

$(FPCLASSIFY): $(FPCLASSIFY).o
	$(GCC) -o $(FPCLASSIFY) obj/$(FPCLASSIFY).o $(LDFLAGS)
$(FPCLASSIFY).o:
	$(GCC) -o obj/$(FPCLASSIFY).o -c $(FPCLASSIFY).c $(CFLAGS)

$(FREXP): $(FREXP).o
	$(GCC) -o $(FREXP) obj/$(FREXP).o $(LDFLAGS)
$(FREXP).o:
	$(GCC) -o obj/$(FREXP).o -c $(FREXP).c $(CFLAGS)

$(GAMMA): $(GAMMA).o
	$(GCC) -o $(GAMMA) obj/$(GAMMA).o $(LDFLAGS)
$(GAMMA).o:
	$(GCC) -o obj/$(GAMMA).o -c $(GAMMA).c $(CFLAGS)

$(HYPOT): $(HYPOT).o
	$(GCC) -o $(HYPOT) obj/$(HYPOT).o $(LDFLAGS)
$(HYPOT).o:
	$(GCC) -o obj/$(HYPOT).o -c $(HYPOT).c $(CFLAGS)

$(INITSTATE): $(INITSTATE).o
	$(GCC) -o $(INITSTATE) obj/$(INITSTATE).o $(LDFLAGS)
$(INITSTATE).o:
	$(GCC) -o obj/$(INITSTATE).o -c $(INITSTATE).c $(CFLAGS)

$(ISFINITE): $(ISFINITE).o
	$(GCC) -o $(ISFINITE) obj/$(ISFINITE).o $(LDFLAGS)
$(ISFINITE).o:
	$(GCC) -o obj/$(ISFINITE).o -c $(ISFINITE).c $(CFLAGS)

$(ISINF): $(ISINF).o
	$(GCC) -o $(ISINF) obj/$(ISINF).o $(LDFLAGS)
$(ISINF).o:
	$(GCC) -o obj/$(ISINF).o -c $(ISINF).c $(CFLAGS)

$(ISNAN): $(ISNAN).o
	$(GCC) -o $(ISNAN) obj/$(ISNAN).o $(LDFLAGS)
$(ISNAN).o:
	$(GCC) -o obj/$(ISNAN).o -c $(ISNAN).c $(CFLAGS)

$(ISNORMAL): $(ISNORMAL).o
	$(GCC) -o $(ISNORMAL) obj/$(ISNORMAL).o $(LDFLAGS)
$(ISNORMAL).o:
	$(GCC) -o obj/$(ISNORMAL).o -c $(ISNORMAL).c $(CFLAGS)

$(LABS): $(LABS).o
	$(GCC) -o $(LABS) obj/$(LABS).o $(LDFLAGS)
$(LABS).o:
	$(GCC) -o obj/$(LABS).o -c $(LABS).c $(CFLAGS)

$(LDEXP): $(LDEXP).o
	$(GCC) -o $(LDEXP) obj/$(LDEXP).o $(LDFLAGS)
$(LDEXP).o:
	$(GCC) -o obj/$(LDEXP).o -c $(LDEXP).c $(CFLAGS)

$(LDIV): $(LDIV).o
	$(GCC) -o $(LDIV) obj/$(LDIV).o $(LDFLAGS)
$(LDIV).o:
	$(GCC) -o obj/$(LDIV).o -c $(LDIV).c $(CFLAGS)

$(LGAMMA): $(LGAMMA).o
	$(GCC) -o $(LGAMMA) obj/$(LGAMMA).o $(LDFLAGS)
$(LGAMMA).o:
	$(GCC) -o obj/$(LGAMMA).o -c $(LGAMMA).c $(CFLAGS)

$(LLABS): $(LLABS).o
	$(GCC) -o $(LLABS) obj/$(LLABS).o $(LDFLAGS)
$(LLABS).o:
	$(GCC) -o obj/$(LLABS).o -c $(LLABS).c $(CFLAGS)

$(LLDIV): $(LLDIV).o
	$(GCC) -o $(LLDIV) obj/$(LLDIV).o $(LDFLAGS)
$(LLDIV).o:
	$(GCC) -o obj/$(LLDIV).o -c $(LLDIV).c $(CFLAGS)

$(LLRINT): $(LLRINT).o
	$(GCC) -o $(LLRINT) obj/$(LLRINT).o $(LDFLAGS)
$(LLRINT).o:
	$(GCC) -o obj/$(LLRINT).o -c $(LLRINT).c $(CFLAGS)

$(LLROUND): $(LLROUND).o
	$(GCC) -o $(LLROUND) obj/$(LLROUND).o $(LDFLAGS)
$(LLROUND).o:
	$(GCC) -o obj/$(LLROUND).o -c $(LLROUND).c $(CFLAGS)

$(LOG10): $(LOG10).o
	$(GCC) -o $(LOG10) obj/$(LOG10).o $(LDFLAGS)
$(LOG10).o:
	$(GCC) -o obj/$(LOG10).o -c $(LOG10).c $(CFLAGS)

$(LOG1P): $(LOG1P).o
	$(GCC) -o $(LOG1P) obj/$(LOG1P).o $(LDFLAGS)
$(LOG1P).o:
	$(GCC) -o obj/$(LOG1P).o -c $(LOG1P).c $(CFLAGS)

$(LOG2): $(LOG2).o
	$(GCC) -o $(LOG2) obj/$(LOG2).o $(LDFLAGS)
$(LOG2).o:
	$(GCC) -o obj/$(LOG2).o -c $(LOG2).c $(CFLAGS)

$(LOGB): $(LOGB).o
	$(GCC) -o $(LOGB) obj/$(LOGB).o $(LDFLAGS)
$(LOGB).o:
	$(GCC) -o obj/$(LOGB).o -c $(LOGB).c $(CFLAGS)

$(LOG): $(LOG).o
	$(GCC) -o $(LOG) obj/$(LOG).o $(LDFLAGS)
$(LOG).o:
	$(GCC) -o obj/$(LOG).o -c $(LOG).c $(CFLAGS)

$(LRINT): $(LRINT).o
	$(GCC) -o $(LRINT) obj/$(LRINT).o $(LDFLAGS)
$(LRINT).o:
	$(GCC) -o obj/$(LRINT).o -c $(LRINT).c $(CFLAGS)

$(LROUND): $(LROUND).o
	$(GCC) -o $(LROUND) obj/$(LROUND).o $(LDFLAGS)
$(LROUND).o:
	$(GCC) -o obj/$(LROUND).o -c $(LROUND).c $(CFLAGS)

$(MODF): $(MODF).o
	$(GCC) -o $(MODF) obj/$(MODF).o $(LDFLAGS)
$(MODF).o:
	$(GCC) -o obj/$(MODF).o -c $(MODF).c $(CFLAGS)

$(NEARBYINT): $(NEARBYINT).o
	$(GCC) -o $(NEARBYINT) obj/$(NEARBYINT).o $(LDFLAGS)
$(NEARBYINT).o:
	$(GCC) -o obj/$(NEARBYINT).o -c $(NEARBYINT).c $(CFLAGS)

$(NEXTAFTER): $(NEXTAFTER).o
	$(GCC) -o $(NEXTAFTER) obj/$(NEXTAFTER).o $(LDFLAGS)
$(NEXTAFTER).o:
	$(GCC) -o obj/$(NEXTAFTER).o -c $(NEXTAFTER).c $(CFLAGS)

$(NEXTTOWARD): $(NEXTTOWARD).o
	$(GCC) -o $(NEXTTOWARD) obj/$(NEXTTOWARD).o $(LDFLAGS)
$(NEXTTOWARD).o:
	$(GCC) -o obj/$(NEXTTOWARD).o -c $(NEXTTOWARD).c $(CFLAGS)

$(POW10): $(POW10).o
	$(GCC) -o $(POW10) obj/$(POW10).o $(LDFLAGS)
$(POW10).o:
	$(GCC) -o obj/$(POW10).o -c $(POW10).c $(CFLAGS)

$(POW): $(POW).o
	$(GCC) -o $(POW) obj/$(POW).o $(LDFLAGS)
$(POW).o:
	$(GCC) -o obj/$(POW).o -c $(POW).c $(CFLAGS)

$(RAND): $(RAND).o
	$(GCC) -o $(RAND) obj/$(RAND).o $(LDFLAGS)
$(RAND).o:
	$(GCC) -o obj/$(RAND).o -c $(RAND).c $(CFLAGS)

$(RANDOM): $(RANDOM).o
	$(GCC) -o $(RANDOM) obj/$(RANDOM).o $(LDFLAGS)
$(RANDOM).o:
	$(GCC) -o obj/$(RANDOM).o -c $(RANDOM).c $(CFLAGS)

$(REMAINDER): $(REMAINDER).o
	$(GCC) -o $(REMAINDER) obj/$(REMAINDER).o $(LDFLAGS)
$(REMAINDER).o:
	$(GCC) -o obj/$(REMAINDER).o -c $(REMAINDER).c $(CFLAGS)

$(REMQUO): $(REMQUO).o
	$(GCC) -o $(REMQUO) obj/$(REMQUO).o $(LDFLAGS)
$(REMQUO).o:
	$(GCC) -o obj/$(REMQUO).o -c $(REMQUO).c $(CFLAGS)

$(RINT): $(RINT).o
	$(GCC) -o $(RINT) obj/$(RINT).o $(LDFLAGS)
$(RINT).o:
	$(GCC) -o obj/$(RINT).o -c $(RINT).c $(CFLAGS)

$(ROUND): $(ROUND).o
	$(GCC) -o $(ROUND) obj/$(ROUND).o $(LDFLAGS)
$(ROUND).o:
	$(GCC) -o obj/$(ROUND).o -c $(ROUND).c $(CFLAGS)

$(SCALB): $(SCALB).o
	$(GCC) -o $(SCALB) obj/$(SCALB).o $(LDFLAGS)
$(SCALB).o:
	$(GCC) -o obj/$(SCALB).o -c $(SCALB).c $(CFLAGS)

$(SCALBLN): $(SCALBLN).o
	$(GCC) -o $(SCALBLN) obj/$(SCALBLN).o $(LDFLAGS)
$(SCALBLN).o:
	$(GCC) -o obj/$(SCALBLN).o -c $(SCALBLN).c $(CFLAGS)

$(SCALBN): $(SCALBN).o
	$(GCC) -o $(SCALBN) obj/$(SCALBN).o $(LDFLAGS)
$(SCALBN).o:
	$(GCC) -o obj/$(SCALBN).o -c $(SCALBN).c $(CFLAGS)

$(SETSTATE): $(SETSTATE).o
	$(GCC) -o $(SETSTATE) obj/$(SETSTATE).o $(LDFLAGS)
$(SETSTATE).o:
	$(GCC) -o obj/$(SETSTATE).o -c $(SETSTATE).c $(CFLAGS)

$(SIGNBIT): $(SIGNBIT).o
	$(GCC) -o $(SIGNBIT) obj/$(SIGNBIT).o $(LDFLAGS)
$(SIGNBIT).o:
	$(GCC) -o obj/$(SIGNBIT).o -c $(SIGNBIT).c $(CFLAGS)

$(SIN): $(SIN).o
	$(GCC) -o $(SIN) obj/$(SIN).o $(LDFLAGS)
$(SIN).o:
	$(GCC) -o obj/$(SIN).o -c $(SIN).c $(CFLAGS)

$(SINH): $(SINH).o
	$(GCC) -o $(SINH) obj/$(SINH).o $(LDFLAGS)
$(SINH).o:
	$(GCC) -o obj/$(SINH).o -c $(SINH).c $(CFLAGS)

$(SQRT): $(SQRT).o
	$(GCC) -o $(SQRT) obj/$(SQRT).o $(LDFLAGS)
$(SQRT).o:
	$(GCC) -o obj/$(SQRT).o -c $(SQRT).c $(CFLAGS)

$(SRAND1): $(SRAND1).o
	$(GCC) -o $(SRAND1) obj/$(SRAND1).o $(LDFLAGS)
$(SRAND1).o:
	$(GCC) -o obj/$(SRAND1).o -c $(SRAND1).c $(CFLAGS)

$(SRAND2): $(SRAND2).o
	$(GCC) -o $(SRAND2) obj/$(SRAND2).o $(LDFLAGS)
$(SRAND2).o:
	$(GCC) -o obj/$(SRAND2).o -c $(SRAND2).c $(CFLAGS)

$(SRANDOM1): $(SRANDOM1).o
	$(GCC) -o $(SRANDOM1) obj/$(SRANDOM1).o $(LDFLAGS)
$(SRANDOM1).o:
	$(GCC) -o obj/$(SRANDOM1).o -c $(SRANDOM1).c $(CFLAGS)

$(SRANDOM2): $(SRANDOM2).o
	$(GCC) -o $(SRANDOM2) obj/$(SRANDOM2).o $(LDFLAGS)
$(SRANDOM2).o:
	$(GCC) -o obj/$(SRANDOM2).o -c $(SRANDOM2).c $(CFLAGS)

$(TAN): $(TAN).o
	$(GCC) -o $(TAN) obj/$(TAN).o $(LDFLAGS)
$(TAN).o:
	$(GCC) -o obj/$(TAN).o -c $(TAN).c $(CFLAGS)

$(TANH): $(TANH).o
	$(GCC) -o $(TANH) obj/$(TANH).o $(LDFLAGS)
$(TANH).o:
	$(GCC) -o obj/$(TANH).o -c $(TANH).c $(CFLAGS)

$(TGAMMA): $(TGAMMA).o
	$(GCC) -o $(TGAMMA) obj/$(TGAMMA).o $(LDFLAGS)
$(TGAMMA).o:
	$(GCC) -o obj/$(TGAMMA).o -c $(TGAMMA).c $(CFLAGS)

$(TRUNC): $(TRUNC).o
	$(GCC) -o $(TRUNC) obj/$(TRUNC).o $(LDFLAGS)
$(TRUNC).o:
	$(GCC) -o obj/$(TRUNC).o -c $(TRUNC).c $(CFLAGS)

#top Makefile.win¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_EXP2=1 -DHAVE_LOG2=1 -DHAVE_FDIM=1 -DHAVE_FMIN=1 -DHAVE_FMAX=1 -DHAVE_ISFINITE=1 -DHAVE_ISNORMAL=1 -DHAVE_ISNAN=1 -DHAVE_ISINF=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long
LIBS        = -lm
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = del /q /s
MKDCMD      = mkdir

ABS         = abs
ACOS        = acos
ACOSH       = acosh
ASIN        = asin
ASINH       = asinh
ATAN2       = atan2
ATAN        = atan
ATANH       = atanh
CBRT        = cbrt
CEIL        = ceil
COPYSIGN    = copysign
COS         = cos
COSH        = cosh
DIV         = div
DREM        = drem
ERF         = erf
ERFC        = erfc
EXP10       = exp10
EXP2        = exp2
EXP         = exp
EXPM1       = expm1
FABS        = fabs
FDIM        = fdim
FLOOR       = floor
FMA         = fma
FMAX        = fmax
FMIN        = fmin
FMOD        = fmod
FPCLASSIFY  = fpclassify
FREXP       = frexp
GAMMA       = gamma
HYPOT       = hypot
INITSTATE   = initstate
ISFINITE    = isfinite
ISINF       = isinf
ISNAN       = isnan
ISNORMAL    = isnormal
LABS        = labs
LDEXP       = ldexp
LDIV        = ldiv
LGAMMA      = lgamma
LLABS       = llabs
LLDIV       = lldiv
LLRINT      = llrint
LLROUND     = llround
LOG10       = log10
LOG1P       = log1p
LOG2        = log2
LOGB        = logb
LOG         = log
LRINT       = lrint
LROUND      = lround
MODF        = modf
NEARBYINT   = nearbyint
NEXTAFTER   = nextafter
NEXTTOWARD  = nexttoward
POW10       = pow10
POW         = pow
RAND        = rand
RANDOM      = random
REMAINDER   = remainder
REMQUO      = remquo
RINT        = rint
ROUND       = round
SCALB       = scalb
SCALBLN     = scalbln
SCALBN      = scalbn
SETSTATE    = setstate
SIGNBIT     = signbit
SIN         = sin
SINH        = sinh
SQRT        = sqrt
SRAND1      = srand1
SRAND2      = srand2
SRANDOM1    = srandom1
SRANDOM2    = srandom2
TAN         = tan
TANH        = tanh
TGAMMA      = tgamma
TRUNC       = trunc



all: make

objdir:
	$(MKDCMD) obj\

clean:
	$(RM) obj\*.o *.o *~

#make: $(ABS)
#make: $(ACOS)
#make: $(ACOSH)
#make: $(ASIN)
#make: $(ASINH)
#make: $(ATAN2)
#make: $(ATAN)
#make: $(ATANH)
#make: $(CBRT)
#make: $(CEIL)
#make: $(COPYSIGN)
#make: $(COS)
#make: $(COSH)
#make: $(DIV)
#make: $(DREM)
#make: $(ERF)
#make: $(ERFC)
#make: $(EXP10)
#make: $(EXP2)
#make: $(EXP)
#make: $(EXPM1)
#make: $(FABS)
#make: $(FDIM)
#make: $(FLOOR)
#make: $(FMA)
#make: $(FMAX)
#make: $(FMIN)
#make: $(FMOD)
#make: $(FPCLASSIFY)
#make: $(FREXP)
#make: $(GAMMA)
#make: $(HYPOT)
#make: $(INITSTATE)
#make: $(ISFINITE)
#make: $(ISINF)
#make: $(ISNAN)
#make: $(ISNORMAL)
#make: $(LABS)
#make: $(LDEXP)
#make: $(LDIV)
#make: $(LGAMMA)
#make: $(LLABS)
#make: $(LLDIV)
#make: $(LLRINT)
#make: $(LLROUND)
#make: $(LOG10)
#make: $(LOG1P)
#make: $(LOG2)
#make: $(LOGB)
#make: $(LOG)
#make: $(LRINT)
#make: $(LROUND)
#make: $(MODF)
#make: $(NEARBYINT)
#make: $(NEXTAFTER)
#make: $(NEXTTOWARD)
#make: $(POW10)
#make: $(POW)
#make: $(RAND)
#make: $(RANDOM)
#make: $(REMAINDER)
#make: $(REMQUO)
#make: $(RINT)
#make: $(ROUND)
#make: $(SCALB)
#make: $(SCALBLN)
#make: $(SCALBN)
#make: $(SETSTATE)
#make: $(SIGNBIT)
#make: $(SIN)
#make: $(SINH)
#make: $(SQRT)
#make: $(SRAND1)
#make: $(SRAND2)
#make: $(SRANDOM1)
#make: $(SRANDOM2)
#make: $(TAN)
#make: $(TANH)
#make: $(TGAMMA)
#make: $(TRUNC)
make: $(ABS) $(ACOS) $(ACOSH) $(ASIN) $(ASINH) $(ATAN2) $(ATAN) $(ATANH) $(CBRT) $(CEIL) $(COPYSIGN) $(COS) $(COSH) $(DIV) $(DREM) $(ERF) $(ERFC) $(EXP10) $(EXP2) $(EXP) $(EXPM1) $(FABS) $(FDIM) $(FLOOR) $(FMA) $(FMAX) $(FMIN) $(FMOD) $(FPCLASSIFY) $(FREXP) $(GAMMA) $(HYPOT) $(INITSTATE) $(ISFINITE) $(ISINF) $(ISNAN) $(ISNORMAL) $(LABS) $(LDEXP) $(LDIV) $(LGAMMA) $(LLABS) $(LLDIV) $(LLRINT) $(LLROUND) $(LOG10) $(LOG1P) $(LOG2) $(LOGB) $(LOG) $(LRINT) $(LROUND) $(MODF) $(NEARBYINT) $(NEXTAFTER) $(NEXTTOWARD) $(POW10) $(POW) $(RAND) $(RANDOM) $(REMAINDER) $(REMQUO) $(RINT) $(ROUND) $(SCALB) $(SCALBLN) $(SCALBN) $(SETSTATE) $(SIGNBIT) $(SIN) $(SINH) $(SQRT) $(SRAND1) $(SRAND2) $(SRANDOM1) $(SRANDOM2) $(TAN) $(TANH) $(TGAMMA) $(TRUNC)



$(ABS): $(ABS).o
	$(GCC) -o $(ABS) obj/$(ABS).o $(LDFLAGS)
$(ABS).o:
	$(GCC) -o obj/$(ABS).o -c $(ABS).c $(CFLAGS)

$(ACOS): $(ACOS).o
	$(GCC) -o $(ACOS) obj/$(ACOS).o $(LDFLAGS)
$(ACOS).o:
	$(GCC) -o obj/$(ACOS).o -c $(ACOS).c $(CFLAGS)

$(ACOSH): $(ACOSH).o
	$(GCC) -o $(ACOSH) obj/$(ACOSH).o $(LDFLAGS)
$(ACOSH).o:
	$(GCC) -o obj/$(ACOSH).o -c $(ACOSH).c $(CFLAGS)

$(ASIN): $(ASIN).o
	$(GCC) -o $(ASIN) obj/$(ASIN).o $(LDFLAGS)
$(ASIN).o:
	$(GCC) -o obj/$(ASIN).o -c $(ASIN).c $(CFLAGS)

$(ASINH): $(ASINH).o
	$(GCC) -o $(ASINH) obj/$(ASINH).o $(LDFLAGS)
$(ASINH).o:
	$(GCC) -o obj/$(ASINH).o -c $(ASINH).c $(CFLAGS)

$(ATAN2): $(ATAN2).o
	$(GCC) -o $(ATAN2) obj/$(ATAN2).o $(LDFLAGS)
$(ATAN2).o:
	$(GCC) -o obj/$(ATAN2).o -c $(ATAN2).c $(CFLAGS)

$(ATAN): $(ATAN).o
	$(GCC) -o $(ATAN) obj/$(ATAN).o $(LDFLAGS)
$(ATAN).o:
	$(GCC) -o obj/$(ATAN).o -c $(ATAN).c $(CFLAGS)

$(ATANH): $(ATANH).o
	$(GCC) -o $(ATANH) obj/$(ATANH).o $(LDFLAGS)
$(ATANH).o:
	$(GCC) -o obj/$(ATANH).o -c $(ATANH).c $(CFLAGS)

$(CBRT): $(CBRT).o
	$(GCC) -o $(CBRT) obj/$(CBRT).o $(LDFLAGS)
$(CBRT).o:
	$(GCC) -o obj/$(CBRT).o -c $(CBRT).c $(CFLAGS)

$(CEIL): $(CEIL).o
	$(GCC) -o $(CEIL) obj/$(CEIL).o $(LDFLAGS)
$(CEIL).o:
	$(GCC) -o obj/$(CEIL).o -c $(CEIL).c $(CFLAGS)

$(COPYSIGN): $(COPYSIGN).o
	$(GCC) -o $(COPYSIGN) obj/$(COPYSIGN).o $(LDFLAGS)
$(COPYSIGN).o:
	$(GCC) -o obj/$(COPYSIGN).o -c $(COPYSIGN).c $(CFLAGS)

$(COS): $(COS).o
	$(GCC) -o $(COS) obj/$(COS).o $(LDFLAGS)
$(COS).o:
	$(GCC) -o obj/$(COS).o -c $(COS).c $(CFLAGS)

$(COSH): $(COSH).o
	$(GCC) -o $(COSH) obj/$(COSH).o $(LDFLAGS)
$(COSH).o:
	$(GCC) -o obj/$(COSH).o -c $(COSH).c $(CFLAGS)

$(DIV): $(DIV).o
	$(GCC) -o $(DIV) obj/$(DIV).o $(LDFLAGS)
$(DIV).o:
	$(GCC) -o obj/$(DIV).o -c $(DIV).c $(CFLAGS)

$(DREM): $(DREM).o
	$(GCC) -o $(DREM) obj/$(DREM).o $(LDFLAGS)
$(DREM).o:
	$(GCC) -o obj/$(DREM).o -c $(DREM).c $(CFLAGS)

$(ERF): $(ERF).o
	$(GCC) -o $(ERF) obj/$(ERF).o $(LDFLAGS)
$(ERF).o:
	$(GCC) -o obj/$(ERF).o -c $(ERF).c $(CFLAGS)

$(ERFC): $(ERFC).o
	$(GCC) -o $(ERFC) obj/$(ERFC).o $(LDFLAGS)
$(ERFC).o:
	$(GCC) -o obj/$(ERFC).o -c $(ERFC).c $(CFLAGS)

$(EXP10): $(EXP10).o
	$(GCC) -o $(EXP10) obj/$(EXP10).o $(LDFLAGS)
$(EXP10).o:
	$(GCC) -o obj/$(EXP10).o -c $(EXP10).c $(CFLAGS)

$(EXP2): $(EXP2).o
	$(GCC) -o $(EXP2) obj/$(EXP2).o $(LDFLAGS)
$(EXP2).o:
	$(GCC) -o obj/$(EXP2).o -c $(EXP2).c $(CFLAGS)

$(EXP): $(EXP).o
	$(GCC) -o $(EXP) obj/$(EXP).o $(LDFLAGS)
$(EXP).o:
	$(GCC) -o obj/$(EXP).o -c $(EXP).c $(CFLAGS)

$(EXPM1): $(EXPM1).o
	$(GCC) -o $(EXPM1) obj/$(EXPM1).o $(LDFLAGS)
$(EXPM1).o:
	$(GCC) -o obj/$(EXPM1).o -c $(EXPM1).c $(CFLAGS)

$(FABS): $(FABS).o
	$(GCC) -o $(FABS) obj/$(FABS).o $(LDFLAGS)
$(FABS).o:
	$(GCC) -o obj/$(FABS).o -c $(FABS).c $(CFLAGS)

$(FDIM): $(FDIM).o
	$(GCC) -o $(FDIM) obj/$(FDIM).o $(LDFLAGS)
$(FDIM).o:
	$(GCC) -o obj/$(FDIM).o -c $(FDIM).c $(CFLAGS)

$(FLOOR): $(FLOOR).o
	$(GCC) -o $(FLOOR) obj/$(FLOOR).o $(LDFLAGS)
$(FLOOR).o:
	$(GCC) -o obj/$(FLOOR).o -c $(FLOOR).c $(CFLAGS)

$(FMA): $(FMA).o
	$(GCC) -o $(FMA) obj/$(FMA).o $(LDFLAGS)
$(FMA).o:
	$(GCC) -o obj/$(FMA).o -c $(FMA).c $(CFLAGS)

$(FMAX): $(FMAX).o
	$(GCC) -o $(FMAX) obj/$(FMAX).o $(LDFLAGS)
$(FMAX).o:
	$(GCC) -o obj/$(FMAX).o -c $(FMAX).c $(CFLAGS)

$(FMIN): $(FMIN).o
	$(GCC) -o $(FMIN) obj/$(FMIN).o $(LDFLAGS)
$(FMIN).o:
	$(GCC) -o obj/$(FMIN).o -c $(FMIN).c $(CFLAGS)

$(FMOD): $(FMOD).o
	$(GCC) -o $(FMOD) obj/$(FMOD).o $(LDFLAGS)
$(FMOD).o:
	$(GCC) -o obj/$(FMOD).o -c $(FMOD).c $(CFLAGS)

$(FPCLASSIFY): $(FPCLASSIFY).o
	$(GCC) -o $(FPCLASSIFY) obj/$(FPCLASSIFY).o $(LDFLAGS)
$(FPCLASSIFY).o:
	$(GCC) -o obj/$(FPCLASSIFY).o -c $(FPCLASSIFY).c $(CFLAGS)

$(FREXP): $(FREXP).o
	$(GCC) -o $(FREXP) obj/$(FREXP).o $(LDFLAGS)
$(FREXP).o:
	$(GCC) -o obj/$(FREXP).o -c $(FREXP).c $(CFLAGS)

$(GAMMA): $(GAMMA).o
	$(GCC) -o $(GAMMA) obj/$(GAMMA).o $(LDFLAGS)
$(GAMMA).o:
	$(GCC) -o obj/$(GAMMA).o -c $(GAMMA).c $(CFLAGS)

$(HYPOT): $(HYPOT).o
	$(GCC) -o $(HYPOT) obj/$(HYPOT).o $(LDFLAGS)
$(HYPOT).o:
	$(GCC) -o obj/$(HYPOT).o -c $(HYPOT).c $(CFLAGS)

$(INITSTATE): $(INITSTATE).o
	$(GCC) -o $(INITSTATE) obj/$(INITSTATE).o $(LDFLAGS)
$(INITSTATE).o:
	$(GCC) -o obj/$(INITSTATE).o -c $(INITSTATE).c $(CFLAGS)

$(ISFINITE): $(ISFINITE).o
	$(GCC) -o $(ISFINITE) obj/$(ISFINITE).o $(LDFLAGS)
$(ISFINITE).o:
	$(GCC) -o obj/$(ISFINITE).o -c $(ISFINITE).c $(CFLAGS)

$(ISINF): $(ISINF).o
	$(GCC) -o $(ISINF) obj/$(ISINF).o $(LDFLAGS)
$(ISINF).o:
	$(GCC) -o obj/$(ISINF).o -c $(ISINF).c $(CFLAGS)

$(ISNAN): $(ISNAN).o
	$(GCC) -o $(ISNAN) obj/$(ISNAN).o $(LDFLAGS)
$(ISNAN).o:
	$(GCC) -o obj/$(ISNAN).o -c $(ISNAN).c $(CFLAGS)

$(ISNORMAL): $(ISNORMAL).o
	$(GCC) -o $(ISNORMAL) obj/$(ISNORMAL).o $(LDFLAGS)
$(ISNORMAL).o:
	$(GCC) -o obj/$(ISNORMAL).o -c $(ISNORMAL).c $(CFLAGS)

$(LABS): $(LABS).o
	$(GCC) -o $(LABS) obj/$(LABS).o $(LDFLAGS)
$(LABS).o:
	$(GCC) -o obj/$(LABS).o -c $(LABS).c $(CFLAGS)

$(LDEXP): $(LDEXP).o
	$(GCC) -o $(LDEXP) obj/$(LDEXP).o $(LDFLAGS)
$(LDEXP).o:
	$(GCC) -o obj/$(LDEXP).o -c $(LDEXP).c $(CFLAGS)

$(LDIV): $(LDIV).o
	$(GCC) -o $(LDIV) obj/$(LDIV).o $(LDFLAGS)
$(LDIV).o:
	$(GCC) -o obj/$(LDIV).o -c $(LDIV).c $(CFLAGS)

$(LGAMMA): $(LGAMMA).o
	$(GCC) -o $(LGAMMA) obj/$(LGAMMA).o $(LDFLAGS)
$(LGAMMA).o:
	$(GCC) -o obj/$(LGAMMA).o -c $(LGAMMA).c $(CFLAGS)

$(LLABS): $(LLABS).o
	$(GCC) -o $(LLABS) obj/$(LLABS).o $(LDFLAGS)
$(LLABS).o:
	$(GCC) -o obj/$(LLABS).o -c $(LLABS).c $(CFLAGS)

$(LLDIV): $(LLDIV).o
	$(GCC) -o $(LLDIV) obj/$(LLDIV).o $(LDFLAGS)
$(LLDIV).o:
	$(GCC) -o obj/$(LLDIV).o -c $(LLDIV).c $(CFLAGS)

$(LLRINT): $(LLRINT).o
	$(GCC) -o $(LLRINT) obj/$(LLRINT).o $(LDFLAGS)
$(LLRINT).o:
	$(GCC) -o obj/$(LLRINT).o -c $(LLRINT).c $(CFLAGS)

$(LLROUND): $(LLROUND).o
	$(GCC) -o $(LLROUND) obj/$(LLROUND).o $(LDFLAGS)
$(LLROUND).o:
	$(GCC) -o obj/$(LLROUND).o -c $(LLROUND).c $(CFLAGS)

$(LOG10): $(LOG10).o
	$(GCC) -o $(LOG10) obj/$(LOG10).o $(LDFLAGS)
$(LOG10).o:
	$(GCC) -o obj/$(LOG10).o -c $(LOG10).c $(CFLAGS)

$(LOG1P): $(LOG1P).o
	$(GCC) -o $(LOG1P) obj/$(LOG1P).o $(LDFLAGS)
$(LOG1P).o:
	$(GCC) -o obj/$(LOG1P).o -c $(LOG1P).c $(CFLAGS)

$(LOG2): $(LOG2).o
	$(GCC) -o $(LOG2) obj/$(LOG2).o $(LDFLAGS)
$(LOG2).o:
	$(GCC) -o obj/$(LOG2).o -c $(LOG2).c $(CFLAGS)

$(LOGB): $(LOGB).o
	$(GCC) -o $(LOGB) obj/$(LOGB).o $(LDFLAGS)
$(LOGB).o:
	$(GCC) -o obj/$(LOGB).o -c $(LOGB).c $(CFLAGS)

$(LOG): $(LOG).o
	$(GCC) -o $(LOG) obj/$(LOG).o $(LDFLAGS)
$(LOG).o:
	$(GCC) -o obj/$(LOG).o -c $(LOG).c $(CFLAGS)

$(LRINT): $(LRINT).o
	$(GCC) -o $(LRINT) obj/$(LRINT).o $(LDFLAGS)
$(LRINT).o:
	$(GCC) -o obj/$(LRINT).o -c $(LRINT).c $(CFLAGS)

$(LROUND): $(LROUND).o
	$(GCC) -o $(LROUND) obj/$(LROUND).o $(LDFLAGS)
$(LROUND).o:
	$(GCC) -o obj/$(LROUND).o -c $(LROUND).c $(CFLAGS)

$(MODF): $(MODF).o
	$(GCC) -o $(MODF) obj/$(MODF).o $(LDFLAGS)
$(MODF).o:
	$(GCC) -o obj/$(MODF).o -c $(MODF).c $(CFLAGS)

$(NEARBYINT): $(NEARBYINT).o
	$(GCC) -o $(NEARBYINT) obj/$(NEARBYINT).o $(LDFLAGS)
$(NEARBYINT).o:
	$(GCC) -o obj/$(NEARBYINT).o -c $(NEARBYINT).c $(CFLAGS)

$(NEXTAFTER): $(NEXTAFTER).o
	$(GCC) -o $(NEXTAFTER) obj/$(NEXTAFTER).o $(LDFLAGS)
$(NEXTAFTER).o:
	$(GCC) -o obj/$(NEXTAFTER).o -c $(NEXTAFTER).c $(CFLAGS)

$(NEXTTOWARD): $(NEXTTOWARD).o
	$(GCC) -o $(NEXTTOWARD) obj/$(NEXTTOWARD).o $(LDFLAGS)
$(NEXTTOWARD).o:
	$(GCC) -o obj/$(NEXTTOWARD).o -c $(NEXTTOWARD).c $(CFLAGS)

$(POW10): $(POW10).o
	$(GCC) -o $(POW10) obj/$(POW10).o $(LDFLAGS)
$(POW10).o:
	$(GCC) -o obj/$(POW10).o -c $(POW10).c $(CFLAGS)

$(POW): $(POW).o
	$(GCC) -o $(POW) obj/$(POW).o $(LDFLAGS)
$(POW).o:
	$(GCC) -o obj/$(POW).o -c $(POW).c $(CFLAGS)

$(RAND): $(RAND).o
	$(GCC) -o $(RAND) obj/$(RAND).o $(LDFLAGS)
$(RAND).o:
	$(GCC) -o obj/$(RAND).o -c $(RAND).c $(CFLAGS)

$(RANDOM): $(RANDOM).o
	$(GCC) -o $(RANDOM) obj/$(RANDOM).o $(LDFLAGS)
$(RANDOM).o:
	$(GCC) -o obj/$(RANDOM).o -c $(RANDOM).c $(CFLAGS)

$(REMAINDER): $(REMAINDER).o
	$(GCC) -o $(REMAINDER) obj/$(REMAINDER).o $(LDFLAGS)
$(REMAINDER).o:
	$(GCC) -o obj/$(REMAINDER).o -c $(REMAINDER).c $(CFLAGS)

$(REMQUO): $(REMQUO).o
	$(GCC) -o $(REMQUO) obj/$(REMQUO).o $(LDFLAGS)
$(REMQUO).o:
	$(GCC) -o obj/$(REMQUO).o -c $(REMQUO).c $(CFLAGS)

$(RINT): $(RINT).o
	$(GCC) -o $(RINT) obj/$(RINT).o $(LDFLAGS)
$(RINT).o:
	$(GCC) -o obj/$(RINT).o -c $(RINT).c $(CFLAGS)

$(ROUND): $(ROUND).o
	$(GCC) -o $(ROUND) obj/$(ROUND).o $(LDFLAGS)
$(ROUND).o:
	$(GCC) -o obj/$(ROUND).o -c $(ROUND).c $(CFLAGS)

$(SCALB): $(SCALB).o
	$(GCC) -o $(SCALB) obj/$(SCALB).o $(LDFLAGS)
$(SCALB).o:
	$(GCC) -o obj/$(SCALB).o -c $(SCALB).c $(CFLAGS)

$(SCALBLN): $(SCALBLN).o
	$(GCC) -o $(SCALBLN) obj/$(SCALBLN).o $(LDFLAGS)
$(SCALBLN).o:
	$(GCC) -o obj/$(SCALBLN).o -c $(SCALBLN).c $(CFLAGS)

$(SCALBN): $(SCALBN).o
	$(GCC) -o $(SCALBN) obj/$(SCALBN).o $(LDFLAGS)
$(SCALBN).o:
	$(GCC) -o obj/$(SCALBN).o -c $(SCALBN).c $(CFLAGS)

$(SETSTATE): $(SETSTATE).o
	$(GCC) -o $(SETSTATE) obj/$(SETSTATE).o $(LDFLAGS)
$(SETSTATE).o:
	$(GCC) -o obj/$(SETSTATE).o -c $(SETSTATE).c $(CFLAGS)

$(SIGNBIT): $(SIGNBIT).o
	$(GCC) -o $(SIGNBIT) obj/$(SIGNBIT).o $(LDFLAGS)
$(SIGNBIT).o:
	$(GCC) -o obj/$(SIGNBIT).o -c $(SIGNBIT).c $(CFLAGS)

$(SIN): $(SIN).o
	$(GCC) -o $(SIN) obj/$(SIN).o $(LDFLAGS)
$(SIN).o:
	$(GCC) -o obj/$(SIN).o -c $(SIN).c $(CFLAGS)

$(SINH): $(SINH).o
	$(GCC) -o $(SINH) obj/$(SINH).o $(LDFLAGS)
$(SINH).o:
	$(GCC) -o obj/$(SINH).o -c $(SINH).c $(CFLAGS)

$(SQRT): $(SQRT).o
	$(GCC) -o $(SQRT) obj/$(SQRT).o $(LDFLAGS)
$(SQRT).o:
	$(GCC) -o obj/$(SQRT).o -c $(SQRT).c $(CFLAGS)

$(SRAND1): $(SRAND1).o
	$(GCC) -o $(SRAND1) obj/$(SRAND1).o $(LDFLAGS)
$(SRAND1).o:
	$(GCC) -o obj/$(SRAND1).o -c $(SRAND1).c $(CFLAGS)

$(SRAND2): $(SRAND2).o
	$(GCC) -o $(SRAND2) obj/$(SRAND2).o $(LDFLAGS)
$(SRAND2).o:
	$(GCC) -o obj/$(SRAND2).o -c $(SRAND2).c $(CFLAGS)

$(SRANDOM1): $(SRANDOM1).o
	$(GCC) -o $(SRANDOM1) obj/$(SRANDOM1).o $(LDFLAGS)
$(SRANDOM1).o:
	$(GCC) -o obj/$(SRANDOM1).o -c $(SRANDOM1).c $(CFLAGS)

$(SRANDOM2): $(SRANDOM2).o
	$(GCC) -o $(SRANDOM2) obj/$(SRANDOM2).o $(LDFLAGS)
$(SRANDOM2).o:
	$(GCC) -o obj/$(SRANDOM2).o -c $(SRANDOM2).c $(CFLAGS)

$(TAN): $(TAN).o
	$(GCC) -o $(TAN) obj/$(TAN).o $(LDFLAGS)
$(TAN).o:
	$(GCC) -o obj/$(TAN).o -c $(TAN).c $(CFLAGS)

$(TANH): $(TANH).o
	$(GCC) -o $(TANH) obj/$(TANH).o $(LDFLAGS)
$(TANH).o:
	$(GCC) -o obj/$(TANH).o -c $(TANH).c $(CFLAGS)

$(TGAMMA): $(TGAMMA).o
	$(GCC) -o $(TGAMMA) obj/$(TGAMMA).o $(LDFLAGS)
$(TGAMMA).o:
	$(GCC) -o obj/$(TGAMMA).o -c $(TGAMMA).c $(CFLAGS)

$(TRUNC): $(TRUNC).o
	$(GCC) -o $(TRUNC) obj/$(TRUNC).o $(LDFLAGS)
$(TRUNC).o:
	$(GCC) -o obj/$(TRUNC).o -c $(TRUNC).c $(CFLAGS)

#top Predefined Constants¶

#top EDOM¶

Deklaracja stałej EDOM znajduje się w pliku nagłówkowym asm-generic/errno-base.h.
Deklaracja stałej EDOM jest następująca:

#define EDOM        33  /* Math argument out of domain of func */

#top ERANGE¶

Deklaracja stałej ERANGE znajduje się w pliku nagłówkowym asm-generic/errno-base.h.
Deklaracja stałej ERANGE jest następująca:

#define ERANGE      34  /* Math result not representable */

#top FP_INFINITE¶

Deklaracja stałej FP_INFINITE znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej FP_INFINITE jest następująca:

/* All floating-point numbers can be put in one of these categories.  */
enum
  {
[...]
    FP_INFINITE,
# define FP_INFINITE FP_INFINITE
[...]
  };

#top FP_NAN¶

Deklaracja stałej FP_NAN znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej FP_NAN jest następująca:

/* All floating-point numbers can be put in one of these categories.  */
enum
  {
[...]
    FP_NAN,
# define FP_NAN FP_NAN
[...]
  };

#top FP_NORMAL¶

Deklaracja stałej FP_NORMAL znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej FP_NORMAL jest następująca:

/* All floating-point numbers can be put in one of these categories.  */
enum
  {
[...]
    FP_NORMAL
# define FP_NORMAL FP_NORMAL
[...]
  };

#top FP_SUBNORMAL¶

Deklaracja stałej FP_SUBNORMAL znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej FP_SUBNORMAL jest następująca:

/* All floating-point numbers can be put in one of these categories.  */
enum
  {
[...]
    FP_SUBNORMAL,
# define FP_SUBNORMAL FP_SUBNORMAL
[...]
  };

#top FP_ZERO¶

Deklaracja stałej FP_ZERO znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej FP_ZERO jest następująca:

/* All floating-point numbers can be put in one of these categories.  */
enum
  {
[...]
    FP_ZERO,
# define FP_ZERO FP_ZERO
[...]
  };

#top M_1_PI¶

Deklaracja stałej M_1_PI znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej M_1_PI jest następująca:

# define M_1_PI     0.31830988618379067154  /* 1/pi */

#top M_2_PI¶

Deklaracja stałej M_2_PI znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej M_2_PI jest następująca:

# define M_2_PI     0.63661977236758134308  /* 2/pi */

#top M_2_SQRTPI¶

Deklaracja stałej M_2_SQRTPI znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej M_2_SQRTPI jest następująca:

# define M_2_SQRTPI 1.12837916709551257390  /* 2/sqrt(pi) */

#top M_E¶

Deklaracja stałej M_E znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej M_E jest następująca:

# define M_E        2.7182818284590452354   /* e */

#top M_LN10¶

Deklaracja stałej M_LN10 znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej M_LN10 jest następująca:

# define M_LN10     2.30258509299404568402  /* log_e 10 */

#top M_LN2¶

Deklaracja stałej M_LN2 znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej M_LN2 jest następująca:

# define M_LN2      0.69314718055994530942  /* log_e 2 */

#top M_LOG10E¶

Deklaracja stałej M_LOG10E znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej M_LOG10E jest następująca:

# define M_LOG10E   0.43429448190325182765  /* log_10 e */

#top M_LOG2E¶

Deklaracja stałej M_LOG2E znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej M_LOG2E jest następująca:

# define M_LOG2E    1.4426950408889634074   /* log_2 e */

#top M_PI¶

Deklaracja stałej M_PI znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej M_PI jest następująca:

# define M_PI       3.14159265358979323846  /* pi */

#top M_PI_2¶

Deklaracja stałej M_PI_2 znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej M_PI_2 jest następująca:

# define M_PI_2     1.57079632679489661923  /* pi/2 */

#top M_PI_4¶

Deklaracja stałej M_PI_4 znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej M_PI_4 jest następująca:

# define M_PI_4     0.78539816339744830962  /* pi/4 */

#top M_SQRT1_2¶

Deklaracja stałej M_SQRT1_2 znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej M_SQRT1_2 jest następująca:

# define M_SQRT1_2  0.70710678118654752440  /* 1/sqrt(2) */

#top M_SQRT2¶

Deklaracja stałej M_SQRT2 znajduje się w pliku nagłówkowym math.h.
Deklaracja stałej M_SQRT2 jest następująca:

# define M_SQRT2    1.41421356237309504880  /* sqrt(2) */

#top RAND_MAX¶

Deklaracja stałej RAND_MAX znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja stałej RAND_MAX jest następująca:

/* The largest number rand will return (same as INT_MAX).  */
#define RAND_MAX    2147483647

#top Datatypes / MACROS¶

#top __CONCAT¶

Definicja typu __CONCAT znajduje się w pliku nagłówkowym sys/cdefs.h.
Definicja typu __CONCAT jest następująca:

/* For these things, GCC behaves the ANSI way normally,
   and the non-ANSI way under -traditional.  */

#define __CONCAT(x,y)   x ## y

#top __MATHCALL¶

Definicja typu __MATHCALL znajduje się w pliku nagłówkowym math.h.
Definicja typu __MATHCALL jest następująca:

/* The file <bits/mathcalls.h> contains the prototypes for all the
   actual math functions.  These macros are used for those prototypes,
   so we can easily declare each function as both `name' and `__name',
   and can declare the float versions `namef' and `__namef'.  */

#define __MATHCALL(function,suffix, args)   \
  __MATHDECL (_Mdouble_,function,suffix, args)

#top __MATHCALLX¶

Definicja typu __MATHCALLX znajduje się w pliku nagłówkowym math.h.
Definicja typu __MATHCALLX jest następująca:

/* The file <bits/mathcalls.h> contains the prototypes for all the
   actual math functions.  These macros are used for those prototypes,
   so we can easily declare each function as both `name' and `__name',
   and can declare the float versions `namef' and `__namef'.  */

#define __MATHCALLX(function,suffix, args, attrib)  \
  __MATHDECLX (_Mdouble_,function,suffix, args, attrib)

#top __MATHDECL¶

Definicja typu __MATHDECL znajduje się w pliku nagłówkowym math.h.
Definicja typu __MATHDECL jest następująca:

/* The file <bits/mathcalls.h> contains the prototypes for all the
   actual math functions.  These macros are used for those prototypes,
   so we can easily declare each function as both `name' and `__name',
   and can declare the float versions `namef' and `__namef'.  */

#define __MATHDECL(type, function,suffix, args) \
  __MATHDECL_1(type, function,suffix, args); \
  __MATHDECL_1(type, __CONCAT(__,function),suffix, args)

#top __MATHDECLX¶

Definicja typu __MATHDECLX znajduje się w pliku nagłówkowym math.h.
Definicja typu __MATHDECLX jest następująca:

/* The file <bits/mathcalls.h> contains the prototypes for all the
   actual math functions.  These macros are used for those prototypes,
   so we can easily declare each function as both `name' and `__name',
   and can declare the float versions `namef' and `__namef'.  */

#define __MATHDECLX(type, function,suffix, args, attrib) \
  __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); \
  __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)

#top __MATHDECL_1¶

Definicja typu __MATHDECL_1 znajduje się w pliku nagłówkowym math.h.
Definicja typu __MATHDECL_1 jest następująca:

/* The file <bits/mathcalls.h> contains the prototypes for all the
   actual math functions.  These macros are used for those prototypes,
   so we can easily declare each function as both `name' and `__name',
   and can declare the float versions `namef' and `__namef'.  */

#define __MATHDECL_1(type, function,suffix, args) \
  extern type __MATH_PRECNAME(function,suffix) args __THROW

#top __MATH_PRECNAME¶

Definicja typu __MATH_PRECNAME znajduje się w pliku nagłówkowym math.h.
Definicja typu __MATH_PRECNAME jest następująca:

/* The file <bits/mathcalls.h> contains the prototypes for all the
   actual math functions.  These macros are used for those prototypes,
   so we can easily declare each function as both `name' and `__name',
   and can declare the float versions `namef' and `__namef'.  */

#define __MATH_PRECNAME(name,r) __CONCAT(name,r)

#top _Mdouble_¶

Definicja typu _Mdouble_ znajduje się w pliku nagłówkowym math.h.
Definicja typu _Mdouble_ jest następująca:

/* Include the file of declarations again, this time using `float'
   instead of `double' and appending f to each function name.  */

# define _Mdouble_      _Mfloat_

#top _Mfloat_¶

Definicja typu _Mfloat_ znajduje się w pliku nagłówkowym math.h.
Definicja typu _Mfloat_ jest następująca:

/* Include the file of declarations again, this time using `float'
   instead of `double' and appending f to each function name.  */

# ifndef _Mfloat_
#  define _Mfloat_      float
# endif

#top div_t¶

Definicja typu div_t znajduje się w pliku nagłówkowym stdlib.h.
Definicja typu div_t jest następująca:

/* Returned by `div'.  */
typedef struct
  {
    int quot;           /* Quotient.  */
    int rem;            /* Remainder.  */
  } div_t;

#top ldiv_t¶

Definicja typu ldiv_t znajduje się w pliku nagłówkowym stdlib.h.
Definicja typu ldiv_t jest następująca:

/* Returned by `ldiv'.  */
typedef struct
  {
    long int quot;      /* Quotient.  */
    long int rem;       /* Remainder.  */
  } ldiv_t;

#top lldiv_t¶

Definicja typu lldiv_t znajduje się w pliku nagłówkowym stdlib.h.
Definicja typu lldiv_t jest następująca:

/* Returned by `lldiv'.  */
__extension__ typedef struct
  {
    long long int quot;     /* Quotient.  */
    long long int rem;      /* Remainder.  */
  } lldiv_t;

#top size_t¶

Definicja typu size_t znajduje się w pliku nagłówkowym /usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h.
Definicja typu size_t jest następująca:

/* Unsigned type of `sizeof' something.  */

/* Define this type if we are doing the whole job,
   or if we want this type in particular.  */
#if defined (_STDDEF_H) || defined (__need_size_t)
#ifndef __size_t__	/* BeOS */
#ifndef __SIZE_T__	/* Cray Unicos/Mk */
#ifndef _SIZE_T	/* in case <sys/types.h> has defined it. */
#ifndef _SYS_SIZE_T_H
#ifndef _T_SIZE_
#ifndef _T_SIZE
#ifndef __SIZE_T
#ifndef _SIZE_T_
#ifndef _BSD_SIZE_T_
#ifndef _SIZE_T_DEFINED_
#ifndef _SIZE_T_DEFINED
#ifndef _BSD_SIZE_T_DEFINED_	/* Darwin */
#ifndef _SIZE_T_DECLARED	/* FreeBSD 5 */
#ifndef ___int_size_t_h
#ifndef _GCC_SIZE_T
#ifndef _SIZET_
#ifndef __size_t
#define __size_t__	/* BeOS */
#define __SIZE_T__	/* Cray Unicos/Mk */
#define _SIZE_T
#define _SYS_SIZE_T_H
#define _T_SIZE_
#define _T_SIZE
#define __SIZE_T
#define _SIZE_T_
#define _BSD_SIZE_T_
#define _SIZE_T_DEFINED_
#define _SIZE_T_DEFINED
#define _BSD_SIZE_T_DEFINED_	/* Darwin */
#define _SIZE_T_DECLARED	/* FreeBSD 5 */
#define ___int_size_t_h
#define _GCC_SIZE_T
#define _SIZET_
#if defined (__FreeBSD__) && (__FreeBSD__ >= 5)
/* __size_t is a typedef on FreeBSD 5!, must not trash it. */
#else
#define __size_t
#endif
#ifndef __SIZE_TYPE__
#define __SIZE_TYPE__ long unsigned int
#endif
#if !(defined (__GNUG__) && defined (size_t))
typedef __SIZE_TYPE__ size_t;
#ifdef __BEOS__
typedef long ssize_t;
#endif /* __BEOS__ */
#endif /* !(defined (__GNUG__) && defined (size_t)) */
#endif /* __size_t */
#endif /* _SIZET_ */
#endif /* _GCC_SIZE_T */
#endif /* ___int_size_t_h */
#endif /* _SIZE_T_DECLARED */
#endif /* _BSD_SIZE_T_DEFINED_ */
#endif /* _SIZE_T_DEFINED */
#endif /* _SIZE_T_DEFINED_ */
#endif /* _BSD_SIZE_T_ */
#endif /* _SIZE_T_ */
#endif /* __SIZE_T */
#endif /* _T_SIZE */
#endif /* _T_SIZE_ */
#endif /* _SYS_SIZE_T_H */
#endif /* _SIZE_T */
#endif /* __SIZE_T__ */
#endif /* __size_t__ */
#undef	__need_size_t
#endif /* _STDDEF_H or __need_size_t.  */

#top Math Functions¶

#top abs¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji abs() znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja funkcji abs() jest następująca:

/* Return the absolute value of X.  */
extern int abs (int __x) __THROW __attribute__ ((__const__)) __wur;

Powiązane:
abs(), fabs(), labs(), llabs(),

Opis:

Funkcja abs() zwraca wartość bezwględną (wartość bez znaku) liczby całkowitej przekazanej jako argument.

Argumenty:
int __x - liczba całkowita dla której zostanie zwrócona wartość bezwględna (wartość bez znaku).

Zwracana wartość:
int - wartość bezwzględna (wartość bez znaku) liczby całkowitej przekazanej jako argument.

Example:
zawartość pliku abs.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	int value;
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage:   %s <int-value>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 123\n", argv[0]);
		printf("         %s -123\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value=atoi(argv[1]);
	printf("%s: value=atoi(argv[1]=%s): value=%d\n", self, argv[1], value);
	
	result=abs(value);
	printf("%s: result=abs(value=%d): result=%d\n", self, value, result);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/abs

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/abs <int-value>
Examples:
         /home/local/code/ansiccode/math/abs 123
         /home/local/code/ansiccode/math/abs -123

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/abs 123
/home/local/code/ansiccode/math/abs +123
/home/local/code/ansiccode/math/abs ++123
/home/local/code/ansiccode/math/abs -123
/home/local/code/ansiccode/math/abs --123
/home/local/code/ansiccode/math/abs +-123
/home/local/code/ansiccode/math/abs -+123

rezultat będzie zależny od podanych argumentów wywołania programu:

abs: argv[1]=123
abs: value=atoi(argv[1]=123): value=123
abs: result=abs(value=123): result=123

abs: argv[1]=+123
abs: value=atoi(argv[1]=+123): value=123
abs: result=abs(value=123): result=123

abs: argv[1]=++123
abs: value=atoi(argv[1]=++123): value=0
abs: result=abs(value=0): result=0

abs: argv[1]=-123
abs: value=atoi(argv[1]=-123): value=-123
abs: result=abs(value=-123): result=123

abs: argv[1]=--123
abs: value=atoi(argv[1]=--123): value=0
abs: result=abs(value=0): result=0

abs: argv[1]=+-123
abs: value=atoi(argv[1]=+-123): value=0
abs: result=abs(value=0): result=0

abs: argv[1]=-+123
abs: value=atoi(argv[1]=-+123): value=0
abs: result=abs(value=0): result=0

#top acos¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji acos() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji acos() jest następująca:

/* Arc cosine of X.  */
__MATHCALL (acos,, (_Mdouble_ __x));

Powiązane:
acos(), asin(), atan(), atan2(), cos(), sin(), tan(),

Opis:

Funkcja acos() (arcus cosinus) oblicza wartość arcus cosinus dla liczby podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której jest obliczany arcus cosinus.

Zwracana wartość:
_Mdouble_ - arcus cosinus dla wartości podanej jako argument wywołania funkcji.

#top acosh¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji acosh() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji acosh() jest następująca:

/* Hyperbolic arc cosine of X.  */
__MATHCALL (acosh,, (_Mdouble_ __x));

Powiązane:
acosh(), asinh(), atanh(), cosh(), sinh(), tanh(),

Opis:

Funkcja acosh() (hyperbolic arcus cosinus) oblicza wartość arcus cosinus hiperboliczny dla liczby podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której jest obliczany arcus cosinus hiperboliczny.

Zwracana wartość:
_Mdouble_ - arcus cosinus hiperboliczny dla wartości podanej jako argument wywołania funkcji.

#top asin¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji asin() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji asin() jest następująca:

/* Hyperbolic arc sine of X.  */
__MATHCALL (asinh,, (_Mdouble_ __x));

Powiązane:
acos(), asin(), atan(), atan2(), cos(), sin(), tan(),

Opis:

Funkcja asin() (arcus sinus) oblicza wartość arcus sinus dla liczby podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której jest obliczany arcus sinus.

Zwracana wartość:
_Mdouble_ - arcus sinus dla wartości podanej jako argument wywołania funkcji.

#top asinh¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji asinh() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji asinh() jest następująca:

/* Hyperbolic arc sine of X.  */
__MATHCALL (asinh,, (_Mdouble_ __x));

Powiązane:
acosh(), asinh(), atanh(), cosh(), sinh(), tanh(),

Opis:

Funkcja asinh() (hyperbolic arcus sinus) oblicza wartość arcus sinus hiperboliczny dla liczby podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której jest obliczany arcus sinus hiperboliczny.

Zwracana wartość:
_Mdouble_ - arcus sinus hiperboliczny dla wartości podanej jako argument wywołania funkcji.

#top atan¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji atan() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji atan() jest następująca:

/* Arc tangent of X.  */
__MATHCALL (atan,, (_Mdouble_ __x));

Powiązane:
acos(), asin(), atan(), atan2(), cos(), sin(), tan(),

Opis:

Funkcja atan() (arcus tangens) oblicza wartość arcus tangens dla liczby podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której jest obliczany arcus tangens.

Zwracana wartość:
_Mdouble_ - arcus tangens dla wartości podanej jako argument wywołania funkcji.

#top atan2¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji atan2() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji atan2() jest następująca:

/* Arc tangent of Y/X.  */
__MATHCALL (atan2,, (_Mdouble_ __y, _Mdouble_ __x));

Powiązane:
acos(), asin(), atan(), atan2(), cos(), sin(), tan(),

Opis:

Funkcja atan2() (arcus tangens) oblicza wartość arcus tangens dla ilorazu liczb podanych jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __y - wartość będąca dzielną ilorazu dla którego jest obliczany arcus tangens.
_Mdouble_ __x - wartość będąca dzielinikiem ilorazu dla którego jest obliczany arcus tangens.

Zwracana wartość:
_Mdouble_ - arcus tangens dla ilorazu liczb podanych jako argumenty wywołania funkcji.

#top atanh¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji atanh() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji atanh() jest następująca:

/* Hyperbolic arc tangent of X.  */
__MATHCALL (atanh,, (_Mdouble_ __x));

Powiązane:
acosh(), asinh(), atanh(), cosh(), sinh(), tanh(),

Opis:

Funkcja atanh() (hyperbolic arcus tangens) oblicza wartość arcus tangens hiperboliczny dla liczby podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której jest obliczany arcus tangens hiperboliczny.

Zwracana wartość:
_Mdouble_ - arcus tangens hiperboliczny dla wartości podanej jako argument wywołania funkcji.

#top cbrt¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji cbrt() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji cbrt() jest następująca:

/* Return the cube root of X.  */
__MATHCALL (cbrt,, (_Mdouble_ __x));

Powiązane:
cbrt(), hypot(), pow(), pow10(), sqrt(),

Opis:

Funkcja cbrt() zwraca pierwiastek sześcienny liczby __x podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - liczba, której pierwiastek sześcienny zostanie zwrócony.

Zwracana wartość:
_Mdouble_ - pierwiastek sześcienny dla liczby __x podanej jako argument wywołania funkcji.

#top ceil¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji ceil() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji ceil() jest następująca:

/* Smallest integral value not less than X.  */
__MATHCALLX (ceil,, (_Mdouble_ __x), (__const__));

Powiązane:
ceil(), floor(), llrint(), llround(), lrint(), lround(), nearbyint(), rint(), round(), trunc(),

Opis:

Funkcja ceil() zwraca największą możliwą wartość zaokrągloną do wartości całkowitej, jednakże nie wiekszą niż liczba przekazana w argumencie __x (wartość jest zaokrąglana "w dół" do najbliższej wartości całkowitej). W przypadku wystąpienia błędu ustawiana jest globalna zmienna errno zawierająca powód występienia błędu. W przypadku, gdy przekazana wartość jako argument jest nieskończona kod występienia błędu to EDOM, funkcja może również ustawić kod występienia błędu na ERANGE.

Argumenty:
_Mdouble_ __x - wartość która ma zostać zaokrąglona "w dół" do najbliższej wartości całkowitej.

Zwracana wartość:
_Mdouble_ - wartość zaokrąglona "w dół" do najbliższej wartości całkowitej liczby przekazanej jako argument wywołania. Jeśli przekazana wartość jako argument jest całkowita lub nieskończona to zwracana jest przekazan wartość bez modyfikacji.

#top copysign¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji copysign() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji copysign() jest następująca:

/* Return X with its signed changed to Y's.  */
__MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));

Powiązane:

Opis:

Funkcja copysign() dla liczby __x przekazanej jako argument kopiuje (przypisuje/ustawia) znak taki sam jaki posiada liczba __y przekazana jako argument.

Argumenty:
_Mdouble_ __x - liczba, która zostanie zwrócona ze znakiem pobranym z argumentu __y.
_Mdouble_ __y - liczba, która określa znak z jakim zostanie zwrócona liczba przekazana w argumencie __x.

Zwracana wartość:
_Mdouble_ - liczba o wartości przekazanej w argumencie __x i znaku przekazanym w argumencie __y.

copysign() using the equivalent of the following algorithm:

SELECT ALL

double copysign(double __x, double __y) {
	if (__y>=0) {
		if (__x>=0) return __x;
		else        return -__x;
	} else {
		if (__x>=0) return -__x;
		else        return __x;
	}
}

Example:
zawartość pliku copysign.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double value1;
	double value2;
	double result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage:   %s <longintvalue>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 10.0 5.0\n", argv[0]);
		printf("         %s 10.0 -5.0\n", argv[0]);
		printf("         %s 10.0 -5.0\n", argv[0]);
		printf("         %s -10.0 -5.0\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value1=atof(argv[1]);
	printf("%s: value1=atol(argv[1]=%s): value1=%f\n", self, argv[1], value1);
	
	printf("%s: argv[2]=%s\n", self, argv[1]);
	value2=atof(argv[2]);
	printf("%s: value2=atol(argv[2]=%s): value2=%f\n", self, argv[2], value2);
	
	result=copysign(value1, value2);
	printf("%s: result=copysign(value1=%f, value2=%f): result=%f\n", self, value1, value2, result);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/copysign

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/copysign <longintvalue>
Examples:
         /home/local/code/ansiccode/math/copysign 10.0 5.0
         /home/local/code/ansiccode/math/copysign 10.0 -5.0
         /home/local/code/ansiccode/math/copysign 10.0 -5.0
         /home/local/code/ansiccode/math/copysign -10.0 -5.0

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/copysign 10.0 5.0
/home/local/code/ansiccode/math/copysign 10.0 -5.0
/home/local/code/ansiccode/math/copysign 10.0 -5.0
/home/local/code/ansiccode/math/copysign -10.0 -5.0

rezultat będzie zależny od podanych argumentów wywołania programu:

copysign: argv[1]=10.0
copysign: value1=atol(argv[1]=10.0): value1=10.000000
copysign: argv[2]=10.0
copysign: value2=atol(argv[2]=5.0): value2=5.000000
copysign: result=copysign(value1=10.000000, value2=5.000000): result=10.000000

copysign: argv[1]=10.0
copysign: value1=atol(argv[1]=10.0): value1=10.000000
copysign: argv[2]=10.0
copysign: value2=atol(argv[2]=-5.0): value2=-5.000000
copysign: result=copysign(value1=10.000000, value2=-5.000000): result=-10.000000

copysign: argv[1]=10.0
copysign: value1=atol(argv[1]=10.0): value1=10.000000
copysign: argv[2]=10.0
copysign: value2=atol(argv[2]=-5.0): value2=-5.000000
copysign: result=copysign(value1=10.000000, value2=-5.000000): result=-10.000000

copysign: argv[1]=-10.0
copysign: value1=atol(argv[1]=-10.0): value1=-10.000000
copysign: argv[2]=-10.0
copysign: value2=atol(argv[2]=-5.0): value2=-5.000000
copysign: result=copysign(value1=-10.000000, value2=-5.000000): result=-10.000000

#top cos¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji cos() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji cos() jest następująca:

/* Cosine of X.  */
__MATHCALL (cos,, (_Mdouble_ __x));

Powiązane:
acos(), asin(), atan(), atan2(), cos(), sin(), tan(),

Opis:

Funkcja cos() (cosinus) oblicza wartość cosinus dla liczby podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której jest obliczany cosinus.

Zwracana wartość:
_Mdouble_ - cosinus dla wartości podanej jako argument wywołania funkcji.

#top cosh¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji cosh() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji cosh() jest następująca:

/* Hyperbolic cosine of X.  */
__MATHCALL (cosh,, (_Mdouble_ __x));

Powiązane:
acosh(), asinh(), atanh(), cosh(), sinh(), tanh(),

Opis:

Funkcja cosh() (hyperbolic cosinus) oblicza wartość cosinus hiperboliczny dla liczby podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której jest obliczany cosinus hiperboliczny.

Zwracana wartość:
_Mdouble_ - cosinus hiperboliczny dla wartości podanej jako argument wywołania funkcji.

#top div¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji div() znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja funkcji div() jest następująca:

/* Return the `div_t', `ldiv_t' or `lldiv_t' representation
   of the value of NUMER over DENOM. */
/* GCC may have built-ins for these someday.  */
extern div_t div (int __numer, int __denom)
     __THROW __attribute__ ((__const__)) __wur;

Powiązane:
div(), drem(), fmod(), ldiv(), lldiv(), remainder(), remquo(),

Opis:

Funkcja div() zwraca w strukturze div_t wynik dzielenia (iloraz) liczby przekazanej w argumencie __numer (dzielna) przez liczbę przekazaną w argumencie __denom (dzielnik).

Argumenty:
int __numer - liczba będąca dzielną, która zostanie podzielona przez liczbę przekazaną w argumencie __denom.
int __denom - liczba będąca dzielnikiem, przez który zostanie podzielona liczba przekazana w argumencie __numer.

Zwracana wartość:
div_t - iloraz dzielenia liczby przekazanej w argumencie __numer (dzielna) przez liczbę przekazaną w argumencie __denom (dzielnik), pole quot (ang. quotient) zwrócone struktury zawiera całkowitą wartość z wyniku dzielenia, pole rem (ang. remainder) zawiera resztę z dzielenia.

Example:
zawartość pliku div.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	int numer;
	int denom;
	div_t divval;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage:   %s <numer> <denom>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 123456 1\n", argv[0]);
		printf("         %s 123456 10\n", argv[0]);
		printf("         %s 123456 100\n", argv[0]);
		printf("         %s 123456 1000\n", argv[0]);
		printf("         %s 123456 1000000\n", argv[0]);
		printf("         %s 123456 1000000000\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s argv[2]=%s\n", self, argv[1], argv[2]);
	numer=atoi(argv[1]);
	denom=atoi(argv[2]);
	divval=div(numer, denom);
	printf("%s: divval=div(numer=%d, denom=%d): divval={quot=%d, rem=%d}\n", self, numer, denom, divval.quot, divval.rem);
	printf("%s: (double)divval.quot=%d + (double)divval.rem=%d / %d = %f\n", self, divval.quot, divval.rem, denom, (double)divval.quot+(double)divval.rem/denom);
	printf("%s: (double)%d/%d=%f\n", self, numer, denom, (double)numer/denom);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/div

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/div <numer> <denom>
Examples:
         /home/local/code/ansiccode/math/div 123456 1
         /home/local/code/ansiccode/math/div 123456 10
         /home/local/code/ansiccode/math/div 123456 100
         /home/local/code/ansiccode/math/div 123456 1000
         /home/local/code/ansiccode/math/div 123456 1000000
         /home/local/code/ansiccode/math/div 123456 1000000000

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/div 123456 1
/home/local/code/ansiccode/math/div 123456 10
/home/local/code/ansiccode/math/div 123456 100
/home/local/code/ansiccode/math/div 123456 1000
/home/local/code/ansiccode/math/div 123456 1000000
/home/local/code/ansiccode/math/div 123456 1000000000

rezultat będzie zależny od podanych argumentów wywołania programu:

div: argv[1]=123456 argv[2]=1
div: divval=div(numer=123456, denom=1): divval={quot=123456, rem=0}
div: (double)divval.quot=123456 + (double)divval.rem=0 / 1 = 123456.000000
div: (double)123456/1=123456.000000

div: argv[1]=123456 argv[2]=10
div: divval=div(numer=123456, denom=10): divval={quot=12345, rem=6}
div: (double)divval.quot=12345 + (double)divval.rem=6 / 10 = 12345.600000
div: (double)123456/10=12345.600000

div: argv[1]=123456 argv[2]=100
div: divval=div(numer=123456, denom=100): divval={quot=1234, rem=56}
div: (double)divval.quot=1234 + (double)divval.rem=56 / 100 = 1234.560000
div: (double)123456/100=1234.560000

div: argv[1]=123456 argv[2]=1000
div: divval=div(numer=123456, denom=1000): divval={quot=123, rem=456}
div: (double)divval.quot=123 + (double)divval.rem=456 / 1000 = 123.456000
div: (double)123456/1000=123.456000

div: argv[1]=123456 argv[2]=1000000
div: divval=div(numer=123456, denom=1000000): divval={quot=0, rem=123456}
div: (double)divval.quot=0 + (double)divval.rem=123456 / 1000000 = 0.123456
div: (double)123456/1000000=0.123456

div: argv[1]=123456 argv[2]=1000000000
div: divval=div(numer=123456, denom=1000000000): divval={quot=0, rem=123456}
div: (double)divval.quot=0 + (double)divval.rem=123456 / 1000000000 = 0.000123
div: (double)123456/1000000000=0.000123

#top drem¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji drem() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji drem() jest następująca:

/* Return the remainder of X/Y.  */
__MATHCALL (drem,, (_Mdouble_ __x, _Mdouble_ __y));

Powiązane:
div(), drem(), fmod(), ldiv(), lldiv(), remainder(), remquo(),

Opis:

Funkcja drem() podobnie jak funkcje fmod() i remainder() oraz funkcja div() w strukturze div_t w polu rem zwraca resztę z dzielenia liczby __x (dzielna) przekazanej jako argument wywołania przez liczbę __y (dzielnik) przekazanej jako argument wywołania.

Argumenty:
_Mdouble_ __x - liczba będąca dzielną, która zostanie podzielona przez liczbę przekazaną w argumencie __y.
_Mdouble_ __y - liczba będąca dzielnikiem, przez który zostanie podzielona liczba przekazana w argumencie __x.

Zwracana wartość:
_Mdouble_ - reszta z ilorazu dzielenia liczby przekazanej w argumencie __x (dzielna) przez liczbę przekazaną w argumencie __y (dzielnik).

#top erf¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji erf() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji erf() jest następująca:

/* Error and gamma functions.  */
__MATHCALL (erf,, (_Mdouble_));

Powiązane:
erf(), erfc(), gamma(), lgamma(), tgamma(),

Opis:

Funkcja erf() zwraca zależność obliczoną zgodnie z poniższym wzorem:
$ansiccode-math-erf.png$

Argumenty:
_Mdouble_ __x -

Zwracana wartość:
_Mdouble_ -

#top erfc¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji erfc() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji erfc() jest następująca:

/* Error and gamma functions.  */
__MATHCALL (erfc,, (_Mdouble_));

Powiązane:
erf(), erfc(), gamma(), lgamma(), tgamma(),

Opis:

Funkcja erfc() zwraca zależność obliczoną zgodnie z poniższym wzorem:
$ansiccode-math-erfc.png$

Argumenty:
_Mdouble_ __x -

Zwracana wartość:
_Mdouble_ -

#top exp¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji exp() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji exp() jest następująca:

/* Exponential function of X.  */
__MATHCALL (exp,, (_Mdouble_ __x));

Powiązane:
exp(), exp10(), exp2(), expm1(), frexp(), ldexp(),

Opis:

Funkcja exp() zwraca wartość exponent (stałą e (M_E)) podniesioną do potęgi o wartości __x przekazanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wykładnik potęgi dla podstawy potęgi o wartości exponent (stałej e (M_E)).

Zwracana wartość:
_Mdouble_ - wynik potęgowania wartości exponent (stałej e (M_E)), dla wykładnika będącej liczbą __x przekazaną jako argument wywołania funkcji.

Example:
zawartość pliku exp.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double value;
	double result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage:   %s <value>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 0.0\n", argv[0]);
		printf("         %s 1.0\n", argv[0]);
		printf("         %s 2.0\n", argv[0]);
		printf("         %s 5.0\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value=atof(argv[1]);
	printf("%s: value=atof(argv[1]=%s): value=%f\n", self, argv[1], value);
	
	result=exp(value);
	printf("%s: result=exp(value=%f): result=%f\n", self, value, result);
	
#if defined(HAVE_EXP2)
	result=exp2(value);
	printf("%s: result=exp2(value=%f): result=%f\n", self, value, result);
#else
	/* exp2() is not available on this OS platform !!! */
	printf("%s: unameexp2() is not available on this OS platform !!!\n", argv[0]);
#endif
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/exp

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/exp <value>
Examples:
         /home/local/code/ansiccode/math/exp 0.0
         /home/local/code/ansiccode/math/exp 1.0
         /home/local/code/ansiccode/math/exp 2.0
         /home/local/code/ansiccode/math/exp 5.0

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/exp 0.0
/home/local/code/ansiccode/math/exp 1.0
/home/local/code/ansiccode/math/exp 2.0
/home/local/code/ansiccode/math/exp 5.0

rezultat będzie zależny od podanych argumentów wywołania programu:

exp: argv[1]=0.0
exp: value=atof(argv[1]=0.0): value=0.000000
exp: result=exp(value=0.000000): result=1.000000
exp: result=exp2(value=0.000000): result=1.000000

exp: argv[1]=1.0
exp: value=atof(argv[1]=1.0): value=1.000000
exp: result=exp(value=1.000000): result=2.718282
exp: result=exp2(value=1.000000): result=2.000000

exp: argv[1]=2.0
exp: value=atof(argv[1]=2.0): value=2.000000
exp: result=exp(value=2.000000): result=7.389056
exp: result=exp2(value=2.000000): result=4.000000

exp: argv[1]=5.0
exp: value=atof(argv[1]=5.0): value=5.000000
exp: result=exp(value=5.000000): result=148.413159
exp: result=exp2(value=5.000000): result=32.000000

#top exp10¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji exp10() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji exp10() jest następująca:

/* A function missing in all standards: compute exponent to base ten.  */
__MATHCALL (exp10,, (_Mdouble_ __x));

Powiązane:
exp(), exp10(), exp2(), expm1(), frexp(), ldexp(),

Opis:

Funkcja exp10() zwraca wartość liczby 10 podniesioną do potęgi o wartości __x przekazanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wykładnik potęgi dla podstawy potęgi o wartości równiej 10.

Zwracana wartość:
_Mdouble_ - wynik potęgowania liczby 10, dla wykładnika będącej liczbą __x przekazaną jako argument wywołania funkcji.

#top exp2¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji exp2() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji exp2() jest następująca:

/* Compute base-2 exponential of X.  */
__MATHCALL (exp2,, (_Mdouble_ __x));

Powiązane:
exp(), exp10(), exp2(), expm1(), frexp(), ldexp(),

Opis:

Funkcja exp2() zwraca wartość liczby 2 podniesioną do potęgi o wartości __x przekazanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wykładnik potęgi dla podstawy potęgi o wartości równiej 2.

Zwracana wartość:
_Mdouble_ - wynik potęgowania liczby 2, dla wykładnika będącej liczbą __x przekazaną jako argument wywołania funkcji.

#top expm1¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji expm1() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji expm1() jest następująca:

/* Return exp(X) - 1.  */
__MATHCALL (expm1,, (_Mdouble_ __x));

Powiązane:
exp(), exp10(), exp2(), expm1(), frexp(), ldexp(),

Opis:

Funkcja expm1() analogicznie jak funkcja exp() zwraca wartość exponent (stałą e (M_E)) podniesioną do potęgi o wartości __x przekazanej jako argument wywołania funkcji, jednakże w odróżnieniu od funkcji exp() zwrócona wartość jest pomniejszona o jeden.

Argumenty:
_Mdouble_ __x - wykładnik potęgi dla podstawy potęgi o wartości exponent (stałej e (M_E)).

Zwracana wartość:
_Mdouble_ - wynik potęgowania wartości exponent (stałej e (M_E)) pomniejszonej o jeden, dla wykładnika będącej liczbą __x przekazaną jako argument wywołania funkcji.

#top fabs¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji fabs() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji fabs() jest następująca:

/* Absolute value of X.  */
__MATHCALLX (fabs,, (_Mdouble_ __x), (__const__));

Powiązane:
abs(), fabs(), labs(), llabs(),

Opis:

Funkcja fabs() zwraca wartość bezwględną (wartość bez znaku) liczby zmiennoprzecinkowej typu double przekazanej jako argument.

Argumenty:
_Mdouble_ __x - liczba zmiennoprzecinkowa dla której zostanie zwrócona wartość bezwględna (wartość bez znaku).

Zwracana wartość:
_Mdouble_ - wartość bezwzględna (wartość bez znaku) liczby zmiennoprzecinkowej przekazanej jako argument.

Example:
zawartość pliku fabs.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double value;
	double result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage:   %s <double-value>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 123.123\n", argv[0]);
		printf("         %s -123.123\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value=atof(argv[1]);
	printf("%s: value=atol(argv[1]=%s): value=%f\n", self, argv[1], value);
	
	result=fabs(value);
	printf("%s: result=fabs(value=%f): result=%f\n", self, value, result);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/fabs

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/fabs <double-value>
Examples:
         /home/local/code/ansiccode/math/fabs 123.123
         /home/local/code/ansiccode/math/fabs -123.123

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/fabs 123.123
/home/local/code/ansiccode/math/fabs -123.123

rezultat będzie zależny od podanych argumentów wywołania programu:

fabs: argv[1]=123.123
fabs: value=atol(argv[1]=123.123): value=123.123000
fabs: result=fabs(value=123.123000): result=123.123000

fabs: argv[1]=-123.123
fabs: value=atol(argv[1]=-123.123): value=-123.123000
fabs: result=fabs(value=-123.123000): result=123.123000

#top fdim¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji fdim() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji fdim() jest następująca:

/* Return positive difference between X and Y.  */
__MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));

Powiązane:
fdim(), fmax(), fmin(), modf(),

Opis:

Funkcja fdim() zwraca różnice pomiędzy liczbami podanymi jako argumenty wywołania __x (odjemna) oraz __y (odjemnik) tylko w przypadku gdy argument __x jest większy od argumentu __y, w przeciwnym przypadku zwraca wartość +0.

Argumenty:
_Mdouble_ __x - (odjemna) liczba od której odejmowana jest liczba podana jako drugi argument wywołania funkcji.
_Mdouble_ __y - (odjemnik)liczba która odejmowana jest od liczby podanej jako pierwszy argument wywołania funkcji.

Zwracana wartość:
_Mdouble_ - wynik odejmowania będący różnicą liczb podanych jako argumenty wywołania funkcji.

Example:
zawartość pliku fdim.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double value1;
	double value2;
	double result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage:   %s <value1> <value2>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 2.0 1.0\n", argv[0]);
		printf("         %s 1.0 2.0\n", argv[0]);
		printf("         %s -2.0 -1.0\n", argv[0]);
		printf("         %s -1.0 -2.0\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value1=atof(argv[1]);
	printf("%s: value1=atol(argv[1]=%s): value1=%f\n", self, argv[1], value1);
	
	printf("%s: argv[2]=%s\n", self, argv[1]);
	value2=atof(argv[2]);
	printf("%s: value2=atol(argv[2]=%s): value2=%f\n", self, argv[2], value2);
	
	result=0;
	
#if defined(HAVE_FDIM)
	result=fdim(value1, value2);
	printf("%s: result=fdim(value1=%f, value2=%f): result=%f\n", self, value1, value2, result);
#else
	/* fdim() is not available on this OS platform !!! */
	printf("%s: fdim() is not available on this OS platform !!!\n", argv[0]);
#endif
	
#if defined(HAVE_FMIN)
	result=fmin(value1, value2);
	printf("%s: result=fmin(value1=%f, value2=%f): result=%f\n", self, value1, value2, result);
#else
	/* fmin() is not available on this OS platform !!! */
	printf("%s: fmin() is not available on this OS platform !!!\n", argv[0]);
#endif
	
#if defined(HAVE_FMAX)
	result=fmax(value1, value2);
	printf("%s: result=fmax(value1=%f, value2=%f): result=%f\n", self, value1, value2, result);
#else
	/* fmax() is not available on this OS platform !!! */
	printf("%s: fmax() is not available on this OS platform !!!\n", argv[0]);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/fdim

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/fdim <value1> <value2>
Examples:
         /home/local/code/ansiccode/math/fdim 2.0 1.0
         /home/local/code/ansiccode/math/fdim 1.0 2.0
         /home/local/code/ansiccode/math/fdim -2.0 -1.0
         /home/local/code/ansiccode/math/fdim -1.0 -2.0

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/fdim 2.0 1.0
/home/local/code/ansiccode/math/fdim 1.0 2.0
/home/local/code/ansiccode/math/fdim -2.0 -1.0
/home/local/code/ansiccode/math/fdim -1.0 -2.0

rezultat będzie zależny od podanych argumentów wywołania programu:

fdim: argv[1]=2.0
fdim: value1=atol(argv[1]=2.0): value1=2.000000
fdim: argv[2]=2.0
fdim: value2=atol(argv[2]=1.0): value2=1.000000
fdim: result=fdim(value1=2.000000, value2=1.000000): result=1.000000
fdim: result=fmin(value1=2.000000, value2=1.000000): result=1.000000
fdim: result=fmax(value1=2.000000, value2=1.000000): result=2.000000

fdim: argv[1]=1.0
fdim: value1=atol(argv[1]=1.0): value1=1.000000
fdim: argv[2]=1.0
fdim: value2=atol(argv[2]=2.0): value2=2.000000
fdim: result=fdim(value1=1.000000, value2=2.000000): result=0.000000
fdim: result=fmin(value1=1.000000, value2=2.000000): result=1.000000
fdim: result=fmax(value1=1.000000, value2=2.000000): result=2.000000

fdim: argv[1]=-2.0
fdim: value1=atol(argv[1]=-2.0): value1=-2.000000
fdim: argv[2]=-2.0
fdim: value2=atol(argv[2]=-1.0): value2=-1.000000
fdim: result=fdim(value1=-2.000000, value2=-1.000000): result=0.000000
fdim: result=fmin(value1=-2.000000, value2=-1.000000): result=-2.000000
fdim: result=fmax(value1=-2.000000, value2=-1.000000): result=-1.000000

fdim: argv[1]=-1.0
fdim: value1=atol(argv[1]=-1.0): value1=-1.000000
fdim: argv[2]=-1.0
fdim: value2=atol(argv[2]=-2.0): value2=-2.000000
fdim: result=fdim(value1=-1.000000, value2=-2.000000): result=1.000000
fdim: result=fmin(value1=-1.000000, value2=-2.000000): result=-2.000000
fdim: result=fmax(value1=-1.000000, value2=-2.000000): result=-1.000000

#top floor¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji floor() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji floor() jest następująca:

/* Largest integer not greater than X.  */
__MATHCALLX (floor,, (_Mdouble_ __x), (__const__));

Powiązane:
ceil(), floor(), llrint(), llround(), lrint(), lround(), nearbyint(), rint(), round(), trunc(),

Opis:

Funkcja floor() zwraca najmniejszą możliwą wartość zaokrągloną do wartości całkowitej, jednakże nie mniejszą niż liczba przekazana w argumencie __x (wartość jest zaokrąglana "w górę" do najbliższej wartości całkowitej). Jeśli przekazana wartość jako argument jest całkowita lub nieskończona to zwracana jest przekazan wartość bez modyfikacji. Jeśli przekazana wartość jako argument jest całkowita lub nieskończona to zwracana jest przekazan wartość bez modyfikacji. W przypadku wystąpienia błędu ustawiana jest globalna zmienna errno zawierająca powód występienia błędu. W przypadku, gdy przekazana wartość jako argument jest nieskończona kod występienia błędu to EDOM, funkcja może również ustawić kod występienia błędu na ERANGE.

Argumenty:
_Mdouble_ __x - wartość która ma zostać zaokrąglona "w górę" do najbliższej wartości całkowitej.

Zwracana wartość:
_Mdouble_ - wartość zaokrąglona "w górę" do najbliższej wartości całkowitej liczby przekazanej jako argument wywołania.

#top fma¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji fma() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji fma() jest następująca:

/* Multiply-add function computed as a ternary operation.  */
__MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));

Powiązane:

Opis:

Funkcja fma() zwraca iloczyn argumentów __x i __y dodany do argumentu __z. Operacja wykonywana przez funkcję fma() jest wykonywana z większą dokładnością niż wykonanie analogicznej operacji matematycznej mnożenia i dodawania na liczbach przekazanych jako argumenty wywołania funkcji: __x * __y + __z.

Argumenty:
_Mdouble_ __x - argument, którego iloczyn z drugim argumentem zostanie dodany do trzeciego argumentu wywołania funkcji.
_Mdouble_ __y - argument, którego iloczyn z pierwszym argumentem zostanie dodany do trzeciego argumentu wywołania funkcji.
_Mdouble_ __z - argument, który sumowany jest iloczynem dwóch pierwszych argumentów wywołania funkcji.

Zwracana wartość:
_Mdouble_ - suma iloczynu dwóch pierwszych argumentów z trzecim argumentem wywołania funkcji.

#top fmax¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji fmax() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji fmax() jest następująca:

/* Return maximum numeric value from X and Y.  */
__MATHCALL (fmax,, (_Mdouble_ __x, _Mdouble_ __y));

Powiązane:
fdim(), fmax(), fmin(), modf(),

Opis:

Funkcja fmax() zwraca liczbę o największej wartości spośród liczb przekazanych jako argumenty wywołania funkcji.

Argumenty:
_Mdouble_ __x - liczba, która zostanie zwrócona, jeśli jest większa od argumentu __y.
_Mdouble_ __y - liczba, która zostanie zwrócona, jeśli jest większa od argumentu __x.

Zwracana wartość:
_Mdouble_ - liczba o największej wartości spośród liczb przekazanych jako argumenty wywołania funkcji.

#top fmin¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji fmin() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji fmin() jest następująca:

/* Return minimum numeric value from X and Y.  */
__MATHCALL (fmin,, (_Mdouble_ __x, _Mdouble_ __y));

Powiązane:
fdim(), fmax(), fmin(), modf(),

Opis:

Funkcja fmin() zwraca liczbę o najmniejszej wartości spośród liczb przekazanych jako argumenty wywołania funkcji.

Argumenty:
_Mdouble_ __x - liczba, która zostanie zwrócona, jeśli jest mniejsza od argumentu __y.
_Mdouble_ __y - liczba, która zostanie zwrócona, jeśli jest mniejsza od argumentu __x.

Zwracana wartość:
_Mdouble_ - liczba o najmniejszej wartości spośród liczb przekazanych jako argumenty wywołania funkcji.

#top fmod¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji fmod() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji fmod() jest następująca:

/* Floating-point modulo remainder of X/Y.  */
__MATHCALL (fmod,, (_Mdouble_ __x, _Mdouble_ __y));

Powiązane:
div(), drem(), fmod(), ldiv(), lldiv(), remainder(), remquo(),

Opis:

Funkcja fmod() podobnie jak funkcje drem() i remainder() oraz funkcja div() w strukturze div_t w polu rem zwraca resztę z dzielenia argumentu __x (dzielna) przez argument __y (dzielnik).

Argumenty:
_Mdouble_ __x - liczba będąca dzielną, która zostanie podzielona przez argument __y wywołania funkcji.
_Mdouble_ __y - liczba będąca dzielnikiem, przez który zostanie podzielona liczba przekazana w argumencie __x.

Zwracana wartość:
_Mdouble_ - reszta z ilorazu dzielenia liczby przekazanej w argumencie __x (dzielna) przez liczbę przekazaną w argumencie __y (dzielnik).

Example:
zawartość pliku fmod.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double value1;
	double value2;
	double result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage:   %s <value1> <value2>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 5.3 2.0\n", argv[0]);
		printf("         %s 18.5 4.2\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value1=atof(argv[1]);
	printf("%s: value1=atol(argv[1]=%s): value1=%f\n", self, argv[1], value1);
	
	printf("%s: argv[2]=%s\n", self, argv[1]);
	value2=atof(argv[2]);
	printf("%s: value2=atol(argv[2]=%s): value2=%f\n", self, argv[2], value2);
	
	result=fmod(value1, value2);
	printf("%s: result=fmod(value1=%f, value2=%f): result=%f\n", self, value1, value2, result);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/fmod

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/fmod <value1> <value2>
Examples:
         /home/local/code/ansiccode/math/fmod 5.3 2.0
         /home/local/code/ansiccode/math/fmod 18.5 4.2

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/fmod 5.3 2.0
/home/local/code/ansiccode/math/fmod 18.5 4.2

rezultat będzie zależny od podanych argumentów wywołania programu:

fmod: argv[1]=5.3
fmod: value1=atol(argv[1]=5.3): value1=5.300000
fmod: argv[2]=5.3
fmod: value2=atol(argv[2]=2.0): value2=2.000000
fmod: result=fmod(value1=5.300000, value2=2.000000): result=1.300000

fmod: argv[1]=18.5
fmod: value1=atol(argv[1]=18.5): value1=18.500000
fmod: argv[2]=18.5
fmod: value2=atol(argv[2]=4.2): value2=4.200000
fmod: result=fmod(value1=18.500000, value2=4.200000): result=1.700000

#top fpclassify¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji fpclassify() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji fpclassify() jest następująca:

/* Classify given number.  */
__MATHDECL_1 (int, __fpclassify,, (_Mdouble_ __value))
     __attribute__ ((__const__));

Powiązane:
fpclassify(), isfinite(), isinf(), isnan(), isnormal(), signbit(),

Opis:

Funkcja fpclassify()

Argumenty:
_Mdouble_ __x -

Zwracana wartość:
_Mdouble_ -

#top frexp¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji frexp() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji frexp() jest następująca:

/* Break VALUE into a normalized fraction and an integral power of 2.  */
__MATHCALL (frexp,, (_Mdouble_ __x, int *__exponent));

Powiązane:
exp(), exp10(), exp2(), expm1(), frexp(), ldexp(),

Opis:

Funkcja frexp() zwraca znormalizowaną postać liczby __x w postaci składników, których iloczyn wartości zwróconej przez funkcję frexp() i liczby dwa podniesionej do potęgi zwróconej we wskaźniku do wykładnika jest równy wartości argumentu wywołania funkcji frexp(). Funkcja frexp() zwraca składniki tworzące następującą zależność z argumentem: __x = result * 2 ^ __exponent.

Argumenty:
_Mdouble_ __x - wartość, która zostanie zwrócona w postaci znormalizowanej.

Zwracana wartość:
_Mdouble_ - znormalizowana postać liczby __x przekazanej jako argument wywołania funkcji.

#top gamma¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji gamma() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji gamma() jest następująca:

/* Obsolete alias for `lgamma'.  */
__MATHCALL (gamma,, (_Mdouble_));

Powiązane:
erf(), erfc(), gamma(), lgamma(), tgamma(),

Opis:

Funkcja gamma() zwraca tę samą wartość co funkcja lgamma() (jest aliasem dla tej funkcji).

Argumenty:
_Mdouble_ __x -

Zwracana wartość:
_Mdouble_ -

#top hypot¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji hypot() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji hypot() jest następująca:

/* Return `sqrt(X*X + Y*Y)'.  */
__MATHCALL (hypot,, (_Mdouble_ __x, _Mdouble_ __y));

Powiązane:
cbrt(), hypot(), pow(), pow10(), sqrt(),

Opis:

Funkcja hypot() zwraca pierwiastek kwadratowy z sumy argumentów podniesionych do potęgi 2 (pierwiastek kwadratowy z sumy kwadratów). Funkcja realizuje operację matematyczną zgodnie ze wzorem sqrt(X*X + Y*Y) jednakże zwracany wynik jest obliczony z większą dokładnością niż wykonanie analogicznej operacji matematycznej.

Argumenty:
_Mdouble_ __x - pierwszy składnik sumy liczb podniesionych do potęgi 2, z których zwrócony zostanie pierwiastek kwadratowy.
_Mdouble_ __y - drugi składnik sumy liczb podniesionych do potęgi 2, z których zwrócony zostanie pierwiastek kwadratowy.

Zwracana wartość:
_Mdouble_ - pierwiastek kwadratowy z sumy kwadratów liczb przekazanych jako argumenty wywołania funkcji.

#top initstate¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji initstate() znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja funkcji initstate() jest następująca:

/* Initialize the random number generator to use state buffer STATEBUF,
   of length STATELEN, and seed it with SEED.  Optimal lengths are 8, 16,
   32, 64, 128 and 256, the bigger the better; values less than 8 will
   cause an error and values greater than 256 will be rounded down.  */
extern char *initstate (unsigned int __seed, char *__statebuf,
            size_t __statelen) __THROW __nonnull ((2));

Powiązane:
initstate(), rand(), random(), setstate(), srand(), srandom(),

Opis:

Funkcja initstate()

Argumenty:
unsigned int __seed -
char *__statebuf -
size_t __statelen -

Zwracana wartość:
char * -

#top isfinite¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji isfinite() znajduje się w pliku nagłówkowym math.h.
Deklaracja funkcji isfinite() jest następująca:

/* Return nonzero value if X is not +-Inf or NaN.  */
# ifdef __NO_LONG_DOUBLE_MATH
#  define isfinite(x) \
     (sizeof (x) == sizeof (float) ? __finitef (x) : __finite (x))
# else
#  define isfinite(x) \
     (sizeof (x) == sizeof (float)                        \
      ? __finitef (x)                                 \
      : sizeof (x) == sizeof (double)                         \
      ? __finite (x) : __finitel (x))
# endif

Powiązane:
fpclassify(), isfinite(), isinf(), isnan(), isnormal(), signbit(),

Opis:

Funkcja isfinite()

Argumenty:
x -

Zwracana wartość:
y -

#top isinf¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji isinf() znajduje się w pliku nagłówkowym math.h.
Deklaracja funkcji isinf() jest następująca:

/* Return nonzero value is X is positive or negative infinity.  */
# ifdef __NO_LONG_DOUBLE_MATH
#  define isinf(x) \
     (sizeof (x) == sizeof (float) ? __isinff (x) : __isinf (x))
# else
#  define isinf(x) \
     (sizeof (x) == sizeof (float)                        \
      ? __isinff (x)                                  \
      : sizeof (x) == sizeof (double)                         \
      ? __isinf (x) : __isinfl (x))
# endif

Powiązane:
fpclassify(), isfinite(), isinf(), isnan(), isnormal(), signbit(),

Opis:

Funkcja isinf()

Argumenty:
x -

Zwracana wartość:
y -

#top isnan¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji isnan() znajduje się w pliku nagłówkowym math.h.
Deklaracja funkcji isnan() jest następująca:

/* Return nonzero value if X is a NaN.  We could use `fpclassify' but
   we already have this functions `__isnan' and it is faster.  */
# ifdef __NO_LONG_DOUBLE_MATH
#  define isnan(x) \
     (sizeof (x) == sizeof (float) ? __isnanf (x) : __isnan (x))
# else
#  define isnan(x) \
     (sizeof (x) == sizeof (float)                        \
      ? __isnanf (x)                                  \
      : sizeof (x) == sizeof (double)                         \
      ? __isnan (x) : __isnanl (x))
# endif

Powiązane:
fpclassify(), isfinite(), isinf(), isnan(), isnormal(), signbit(),

Opis:

Funkcja isnan()

Argumenty:
x -

Zwracana wartość:
y -

Example:
zawartość pliku isnan.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double value1;
	double value2;
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage:   %s <value1> <value2>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 1.0 1.0\n", argv[0]);
		printf("         %s -1.0 -1.0\n", argv[0]);
		printf("         %s 0.0 1.0\n", argv[0]);
		printf("         %s 1.0 0.0\n", argv[0]);
		printf("         %s 0.0 0.0\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value1=atof(argv[1]);
	printf("%s: value1=atof(argv[1]=%s): value1=%f\n", self, argv[1], value1);
	
	printf("%s: argv[2]=%s\n", self, argv[2]);
	value2=atof(argv[2]);
	printf("%s: value2=atof(argv[2]=%s): value2=%f\n", self, argv[2], value2);
	
	
#if defined(HAVE_ISFINITE)
	result=isfinite(value1/value2);
	printf("%s: result=isfinite(value1=%f / value2=%f): result=%d\n", self, value1, value2, result);
#else
	/* isfinite() is not available on this OS platform !!! */
	printf("%s: isfinite() is not available on this OS platform !!!\n", argv[0]);
#endif
	
#if defined(HAVE_ISNORMAL)
	result=isnormal(value1/value2);
	printf("%s: result=isnormal(value1=%f / value2=%f): result=%d\n", self, value1, value2, result);
#else
	/* isnormal() is not available on this OS platform !!! */
	printf("%s: isnormal() is not available on this OS platform !!!\n", argv[0]);
#endif
	
#if defined(HAVE_ISNAN)
	result=isnan(value1/value2);
	printf("%s: result=isnan(value1=%f / value2=%f): result=%d\n", self, value1, value2, result);
#else
	/* isnan() is not available on this OS platform !!! */
	printf("%s: isnan() is not available on this OS platform !!!\n", argv[0]);
#endif
	
#if defined(HAVE_ISINF)
	result=isinf(value1/value2);
	printf("%s: result=isinf(value1=%f / value2=%f): result=%d\n", self, value1, value2, result);
#else
	/* isinf() is not available on this OS platform !!! */
	printf("%s: isinf() is not available on this OS platform !!!\n", argv[0]);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/isnan

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/isnan <value1> <value2>
Examples:
         /home/local/code/ansiccode/math/isnan 1.0 1.0
         /home/local/code/ansiccode/math/isnan -1.0 -1.0
         /home/local/code/ansiccode/math/isnan 0.0 1.0
         /home/local/code/ansiccode/math/isnan 1.0 0.0
         /home/local/code/ansiccode/math/isnan 0.0 0.0

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/isnan 1.0 1.0
/home/local/code/ansiccode/math/isnan -1.0 -1.0
/home/local/code/ansiccode/math/isnan 0.0 1.0
/home/local/code/ansiccode/math/isnan 1.0 0.0
/home/local/code/ansiccode/math/isnan 0.0 0.0

rezultat będzie zależny od podanych argumentów wywołania programu:

isnan: argv[1]=1.0
isnan: value1=atof(argv[1]=1.0): value1=1.000000
isnan: argv[2]=1.0
isnan: value2=atof(argv[2]=1.0): value2=1.000000
isnan: result=isfinite(value1=1.000000 / value2=1.000000): result=1
isnan: result=isnormal(value1=1.000000 / value2=1.000000): result=1
isnan: result=isnan(value1=1.000000 / value2=1.000000): result=0
isnan: result=isinf(value1=1.000000 / value2=1.000000): result=0

isnan: argv[1]=-1.0
isnan: value1=atof(argv[1]=-1.0): value1=-1.000000
isnan: argv[2]=-1.0
isnan: value2=atof(argv[2]=-1.0): value2=-1.000000
isnan: result=isfinite(value1=-1.000000 / value2=-1.000000): result=1
isnan: result=isnormal(value1=-1.000000 / value2=-1.000000): result=1
isnan: result=isnan(value1=-1.000000 / value2=-1.000000): result=0
isnan: result=isinf(value1=-1.000000 / value2=-1.000000): result=0

isnan: argv[1]=0.0
isnan: value1=atof(argv[1]=0.0): value1=0.000000
isnan: argv[2]=1.0
isnan: value2=atof(argv[2]=1.0): value2=1.000000
isnan: result=isfinite(value1=0.000000 / value2=1.000000): result=1
isnan: result=isnormal(value1=0.000000 / value2=1.000000): result=0
isnan: result=isnan(value1=0.000000 / value2=1.000000): result=0
isnan: result=isinf(value1=0.000000 / value2=1.000000): result=0

isnan: argv[1]=1.0
isnan: value1=atof(argv[1]=1.0): value1=1.000000
isnan: argv[2]=0.0
isnan: value2=atof(argv[2]=0.0): value2=0.000000
isnan: result=isfinite(value1=1.000000 / value2=0.000000): result=0
isnan: result=isnormal(value1=1.000000 / value2=0.000000): result=0
isnan: result=isnan(value1=1.000000 / value2=0.000000): result=0
isnan: result=isinf(value1=1.000000 / value2=0.000000): result=1

isnan: argv[1]=0.0
isnan: value1=atof(argv[1]=0.0): value1=0.000000
isnan: argv[2]=0.0
isnan: value2=atof(argv[2]=0.0): value2=0.000000
isnan: result=isfinite(value1=0.000000 / value2=0.000000): result=0
isnan: result=isnormal(value1=0.000000 / value2=0.000000): result=0
isnan: result=isnan(value1=0.000000 / value2=0.000000): result=1
isnan: result=isinf(value1=0.000000 / value2=0.000000): result=0

#top isnormal¶

/* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN.  */
# define isnormal(x) (fpclassify (x) == FP_NORMAL)

Powiązane:
fpclassify(), isfinite(), isinf(), isnan(), isnormal(), signbit(),

Opis:

Funkcja isnormal()

Argumenty:
x -

Zwracana wartość:
y -

#top labs¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji labs() znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja funkcji labs() jest następująca:

/* Return the absolute value of X.  */
extern long int labs (long int __x) __THROW __attribute__ ((__const__)) __wur;

Powiązane:
abs(), fabs(), labs(), llabs(),

Opis:

Funkcja labs() zwraca wartość bezwględną (wartość bez znaku) liczby całkowitej przekazanej jako argument.

Argumenty:
long int __x - liczba całkowita dla której zostanie zwrócona wartość bezwględna (wartość bez znaku).

Zwracana wartość:
long int - wartość bezwzględna (wartość bez znaku) liczby całkowitej przekazanej jako argument.

Example:
zawartość pliku labs.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	long int value;
	long int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage:   %s <long-int-value>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 123\n", argv[0]);
		printf("         %s -123\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value=atol(argv[1]);
	printf("%s: value=atol(argv[1]=%s): value=%ld\n", self, argv[1], value);
	
	result=labs(value);
	printf("%s: result=labs(value=%ld): result=%ld\n", self, value, result);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/labs

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/labs <long-int-value>
Examples:
         /home/local/code/ansiccode/math/labs 123
         /home/local/code/ansiccode/math/labs -123

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/labs 123
/home/local/code/ansiccode/math/labs +123
/home/local/code/ansiccode/math/labs ++123
/home/local/code/ansiccode/math/labs -123
/home/local/code/ansiccode/math/labs --123
/home/local/code/ansiccode/math/labs +-123
/home/local/code/ansiccode/math/labs -+123

rezultat będzie zależny od podanych argumentów wywołania programu:

labs: argv[1]=123
labs: value=atol(argv[1]=123): value=123
labs: result=labs(value=123): result=123

labs: argv[1]=+123
labs: value=atol(argv[1]=+123): value=123
labs: result=labs(value=123): result=123

labs: argv[1]=++123
labs: value=atol(argv[1]=++123): value=0
labs: result=labs(value=0): result=0

labs: argv[1]=-123
labs: value=atol(argv[1]=-123): value=-123
labs: result=labs(value=-123): result=123

labs: argv[1]=--123
labs: value=atol(argv[1]=--123): value=0
labs: result=labs(value=0): result=0

labs: argv[1]=+-123
labs: value=atol(argv[1]=+-123): value=0
labs: result=labs(value=0): result=0

labs: argv[1]=-+123
labs: value=atol(argv[1]=-+123): value=0
labs: result=labs(value=0): result=0

#top ldexp¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji ldexp() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji ldexp() jest następująca:

/* X times (two to the EXP power).  */
__MATHCALL (ldexp,, (_Mdouble_ __x, int __exponent));

Powiązane:
exp(), exp10(), exp2(), expm1(), frexp(), ldexp(),

Opis:

Funkcja ldexp() zwraca iloczyn liczby __x przekazanej jako argument wywołania oraz liczby 2 podniesionej do potęgi określonej w argumencie __exponent.

Argumenty:
_Mdouble_ __x - pierwszy składnik iloczynu liczb, który zostanie pomnożony przez liczbę 2 podniesioną do potęgi określonej w drugim argumencie wywołania funkcji.
int __exponent - wykładnik liczby 2, która po podniesieniu do potęgi określonej wykładnikiem zostanie pomnożona przez pierwszy argument wywołania funkcji.

Zwracana wartość:
_Mdouble_ - iloczyn pierwszego argumentu oraz liczby 2 podniesionej do potęgi określonej drugim argumentem wywołania funkcji.

#top ldiv¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji ldiv() znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja funkcji ldiv() jest następująca:

/* Return the `div_t', `ldiv_t' or `lldiv_t' representation
   of the value of NUMER over DENOM. */
/* GCC may have built-ins for these someday.  */
extern ldiv_t ldiv (long int __numer, long int __denom)
     __THROW __attribute__ ((__const__)) __wur;

Powiązane:
div(), drem(), fmod(), ldiv(), lldiv(), remainder(), remquo(),

Opis:

Funkcja ldiv() zwraca w strukturze ldiv_t wynik dzielenia (iloraz) liczby przekazanej w argumencie __numer (dzielna) przez liczbę przekazaną w argumencie __denom (dzielnik).

Argumenty:
long int __numer - liczba będąca dzielną, która zostanie podzielona przez wartość przekazaną w argumencie __denom.
long int __denom - liczba będąca dzielnikiem, przez którą zostanie podzielona wartość przekazana w argumencie __numer.

Zwracana wartość:
ldiv_t - iloraz dzielenia liczby przekazanej w argumencie __numer (dzielna) przez liczbę przekazaną w argumencie __denom (dzielnik), pole quot (ang. quotient) zwrócone struktury zawiera całkowitą wartość z wyniku dzielenia, pole rem (ang. remainder) zawiera resztę z dzielenia.

Example:
zawartość pliku ldiv.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	long int numer;
	long int denom;
	ldiv_t ldivval;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage:   %s <long-numer> <long-denom>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 123456 1\n", argv[0]);
		printf("         %s 123456 10\n", argv[0]);
		printf("         %s 123456 100\n", argv[0]);
		printf("         %s 123456 1000\n", argv[0]);
		printf("         %s 123456 1000000\n", argv[0]);
		printf("         %s 123456 1000000000\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s argv[2]=%s\n", self, argv[1], argv[2]);
	numer=atol(argv[1]);
	denom=atol(argv[2]);
	ldivval=ldiv(numer, denom);
	printf("%s: ldivval=ldiv(numer=%ld, denom=%ld): ldivval={quot=%ld, rem=%ld}\n", self, numer, denom, ldivval.quot, ldivval.rem);
	printf("%s: (double)ldivval.quot=%d + (double)ldivval.rem=%d / %d = %f\n", self, ldivval.quot, ldivval.rem, denom, (double)ldivval.quot+(double)ldivval.rem/denom);
	printf("%s: (double)%d/%d=%f\n", self, numer, denom, (double)numer/denom);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/ldiv

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/ldiv <long-numer> <long-denom>
Examples:
         /home/local/code/ansiccode/math/ldiv 123456 1
         /home/local/code/ansiccode/math/ldiv 123456 10
         /home/local/code/ansiccode/math/ldiv 123456 100
         /home/local/code/ansiccode/math/ldiv 123456 1000
         /home/local/code/ansiccode/math/ldiv 123456 1000000
         /home/local/code/ansiccode/math/ldiv 123456 1000000000

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/ldiv 123456 1
/home/local/code/ansiccode/math/ldiv 123456 10
/home/local/code/ansiccode/math/ldiv 123456 100
/home/local/code/ansiccode/math/ldiv 123456 1000
/home/local/code/ansiccode/math/ldiv 123456 1000000
/home/local/code/ansiccode/math/ldiv 123456 1000000000

rezultat będzie zależny od podanych argumentów wywołania programu:

ldiv: argv[1]=123456 argv[2]=1
ldiv: ldivval=ldiv(numer=123456, denom=1): ldivval={quot=123456, rem=0}
ldiv: (double)ldivval.quot=123456 + (double)ldivval.rem=0 / 1 = 123456.000000
ldiv: (double)123456/1=123456.000000

ldiv: argv[1]=123456 argv[2]=10
ldiv: ldivval=ldiv(numer=123456, denom=10): ldivval={quot=12345, rem=6}
ldiv: (double)ldivval.quot=12345 + (double)ldivval.rem=6 / 10 = 12345.600000
ldiv: (double)123456/10=12345.600000

ldiv: argv[1]=123456 argv[2]=100
ldiv: ldivval=ldiv(numer=123456, denom=100): ldivval={quot=1234, rem=56}
ldiv: (double)ldivval.quot=1234 + (double)ldivval.rem=56 / 100 = 1234.560000
ldiv: (double)123456/100=1234.560000

ldiv: argv[1]=123456 argv[2]=1000
ldiv: ldivval=ldiv(numer=123456, denom=1000): ldivval={quot=123, rem=456}
ldiv: (double)ldivval.quot=123 + (double)ldivval.rem=456 / 1000 = 123.456000
ldiv: (double)123456/1000=123.456000

ldiv: argv[1]=123456 argv[2]=1000000
ldiv: ldivval=ldiv(numer=123456, denom=1000000): ldivval={quot=0, rem=123456}
ldiv: (double)ldivval.quot=0 + (double)ldivval.rem=123456 / 1000000 = 0.123456
ldiv: (double)123456/1000000=0.123456

ldiv: argv[1]=123456 argv[2]=1000000000
ldiv: ldivval=ldiv(numer=123456, denom=1000000000): ldivval={quot=0, rem=123456}
ldiv: (double)ldivval.quot=0 + (double)ldivval.rem=123456 / 1000000000 = 0.000123
ldiv: (double)123456/1000000000=0.000123

#top lgamma¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji lgamma() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji lgamma() jest następująca:

/* Error and gamma functions.  */
__MATHCALL (lgamma,, (_Mdouble_));

Powiązane:
erf(), erfc(), gamma(), lgamma(), tgamma(),

Opis:

Funkcja lgamma() zwraca log funkcji gamma |signgam|
$ansiccode-math-lgamma1.png$
funkcja gamma
$ansiccode-math-lgamma3.png$
zdefiniowana jest następująco
$ansiccode-math-lgamma4.png$
czyli funkcja lgamma zwraca wartość obliczoną jako wyrażenie
$ansiccode-math-lgamma2.png$

Argumenty:
_Mdouble_ __x -

Zwracana wartość:
_Mdouble_ -

Example:
zawartość pliku lgamma.c

SELECT ALL

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

program wyświetli informacje o sposobie uruchamiania programu:

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

rezultat będzie zależny od podanych argumentów wywołania programu:

#top llabs¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji llabs() znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja funkcji llabs() jest następująca:

/* Return the absolute value of X.  */
__extension__ extern long long int llabs (long long int __x)
     __THROW __attribute__ ((__const__)) __wur;

Powiązane:
abs(), fabs(), labs(), llabs(),

Opis:

Funkcja llabs() zwraca wartość bezwględną (wartość bez znaku) liczby całkowitej przekazanej jako argument.

Argumenty:
long long int __x - liczba całkowita dla której zostanie zwrócona wartość bezwględna (wartość bez znaku).

Zwracana wartość:
long long int - wartość bezwzględna (wartość bez znaku) liczby całkowitej przekazanej jako argument.

Example:
zawartość pliku llabs.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	long long int value;
	long long int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage:   %s <long-long-int-value>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 123\n", argv[0]);
		printf("         %s -123\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value=atoll(argv[1]);
	printf("%s: value=atoll(argv[1]=%s): value=%lld\n", self, argv[1], value);
	
	result=llabs(value);
	printf("%s: result=llabs(value=%lld): result=%lld\n", self, value, result);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/llabs

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/llabs <long-long-int-value>
Examples:
         /home/local/code/ansiccode/math/llabs 123
         /home/local/code/ansiccode/math/llabs -123

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/llabs 123
/home/local/code/ansiccode/math/llabs +123
/home/local/code/ansiccode/math/llabs ++123
/home/local/code/ansiccode/math/llabs -123
/home/local/code/ansiccode/math/llabs --123
/home/local/code/ansiccode/math/llabs +-123
/home/local/code/ansiccode/math/llabs -+123

rezultat będzie zależny od podanych argumentów wywołania programu:

llabs: argv[1]=123
llabs: value=atoll(argv[1]=123): value=123
llabs: result=llabs(value=123): result=123

llabs: argv[1]=+123
llabs: value=atoll(argv[1]=+123): value=123
llabs: result=llabs(value=123): result=123

llabs: argv[1]=++123
llabs: value=atoll(argv[1]=++123): value=0
llabs: result=llabs(value=0): result=0

llabs: argv[1]=-123
llabs: value=atoll(argv[1]=-123): value=-123
llabs: result=llabs(value=-123): result=123

llabs: argv[1]=--123
llabs: value=atoll(argv[1]=--123): value=0
llabs: result=llabs(value=0): result=0

llabs: argv[1]=+-123
llabs: value=atoll(argv[1]=+-123): value=0
llabs: result=llabs(value=0): result=0

llabs: argv[1]=-+123
llabs: value=atoll(argv[1]=-+123): value=0
llabs: result=llabs(value=0): result=0

#top lldiv¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji lldiv() znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja funkcji lldiv() jest następująca:

/* Return the `div_t', `ldiv_t' or `lldiv_t' representation
   of the value of NUMER over DENOM. */
/* GCC may have built-ins for these someday.  */
__extension__ extern lldiv_t lldiv (long long int __numer,
                    long long int __denom)
     __THROW __attribute__ ((__const__)) __wur;

Powiązane:
div(), drem(), fmod(), ldiv(), lldiv(), remainder(), remquo(),

Opis:

Funkcja lldiv() zwraca w strukturze lldiv_t wynik dzielenia (iloraz) liczby przekazanej w argumencie __numer (dzielna) przez liczbę przekazaną w argumencie __denom (dzielnik).

Argumenty:
long long int __numer - liczba będąca dzielną, która zostanie podzielona przez wartość przekazaną w argumencie __denom.
long long int __denom - liczba będąca dzielnikiem, przez który zostanie podzielona wartość przekazana w argumentcie __numer.

Zwracana wartość:
lldiv_t - iloraz dzielenia liczby przekazanej w argumencie __numer (dzielna) przez liczbę przekazaną w argumencie __denom (dzielnik), pole quot (ang. quotient) zwrócone struktury zawiera całkowitą wartość z wyniku dzielenia, pole rem (ang. remainder) zawiera resztę z dzielenia.

Example:
zawartość pliku lldiv.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	long long int numer;
	long long int denom;
	lldiv_t lldivval;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage:   %s <long-long-numer> <long-long-denom>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 123456 1\n", argv[0]);
		printf("         %s 123456 10\n", argv[0]);
		printf("         %s 123456 100\n", argv[0]);
		printf("         %s 123456 1000\n", argv[0]);
		printf("         %s 123456 1000000\n", argv[0]);
		printf("         %s 123456 1000000000\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s argv[2]=%s\n", self, argv[1], argv[2]);
	numer=atoll(argv[1]);
	denom=atoll(argv[2]);
	lldivval=lldiv(numer, denom);
	printf("%s: lldivval=lldiv(numer=%lld, denom=%lld): lldivval={quot=%lld, rem=%lld}\n", self, numer, denom, lldivval.quot, lldivval.rem);
	printf("%s: (double)lldivval.quot=%d + (double)lldivval.rem=%d / %d = %f\n", self, lldivval.quot, lldivval.rem, denom, (double)lldivval.quot+(double)lldivval.rem/denom);
	printf("%s: (double)%d/%d=%f\n", self, numer, denom, (double)numer/denom);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/lldiv

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/lldiv <long-long-numer> <long-long-denom>
Examples:
         /home/local/code/ansiccode/math/lldiv 123456 1
         /home/local/code/ansiccode/math/lldiv 123456 10
         /home/local/code/ansiccode/math/lldiv 123456 100
         /home/local/code/ansiccode/math/lldiv 123456 1000
         /home/local/code/ansiccode/math/lldiv 123456 1000000
         /home/local/code/ansiccode/math/lldiv 123456 1000000000

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/lldiv 123456 1
/home/local/code/ansiccode/math/lldiv 123456 10
/home/local/code/ansiccode/math/lldiv 123456 100
/home/local/code/ansiccode/math/lldiv 123456 1000
/home/local/code/ansiccode/math/lldiv 123456 1000000
/home/local/code/ansiccode/math/lldiv 123456 1000000000

rezultat będzie zależny od podanych argumentów wywołania programu:

lldiv: argv[1]=123456 argv[2]=1
lldiv: lldivval=lldiv(numer=123456, denom=1): lldivval={quot=123456, rem=0}
lldiv: (double)lldivval.quot=123456 + (double)lldivval.rem=0 / 1 = 123456.000000
lldiv: (double)123456/1=123456.000000

lldiv: argv[1]=123456 argv[2]=10
lldiv: lldivval=lldiv(numer=123456, denom=10): lldivval={quot=12345, rem=6}
lldiv: (double)lldivval.quot=12345 + (double)lldivval.rem=6 / 10 = 12345.600000
lldiv: (double)123456/10=12345.600000

lldiv: argv[1]=123456 argv[2]=100
lldiv: lldivval=lldiv(numer=123456, denom=100): lldivval={quot=1234, rem=56}
lldiv: (double)lldivval.quot=1234 + (double)lldivval.rem=56 / 100 = 1234.560000
lldiv: (double)123456/100=1234.560000

lldiv: argv[1]=123456 argv[2]=1000
lldiv: lldivval=lldiv(numer=123456, denom=1000): lldivval={quot=123, rem=456}
lldiv: (double)lldivval.quot=123 + (double)lldivval.rem=456 / 1000 = 123.456000
lldiv: (double)123456/1000=123.456000

lldiv: argv[1]=123456 argv[2]=1000000
lldiv: lldivval=lldiv(numer=123456, denom=1000000): lldivval={quot=0, rem=123456}
lldiv: (double)lldivval.quot=0 + (double)lldivval.rem=123456 / 1000000 = 0.123456
lldiv: (double)123456/1000000=0.123456

lldiv: argv[1]=123456 argv[2]=1000000000
lldiv: lldivval=lldiv(numer=123456, denom=1000000000): lldivval={quot=0, rem=123456}
lldiv: (double)lldivval.quot=0 + (double)lldivval.rem=123456 / 1000000000 = 0.000123
lldiv: (double)123456/1000000000=0.000123

#top llrint¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji llrint() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji llrint() jest następująca:

/* Round X to nearest integral value according to current rounding
   direction.  */
__MATHDECL (long long int,llrint,, (_Mdouble_ __x));

Powiązane:
ceil(), floor(), llrint(), llround(), lrint(), lround(), nearbyint(), rint(), round(), trunc(),

Opis:

Funkcja llrint() podobnie jak funkcja llround() zwraca argument __x zaokrąglony do wartości całkowitej "w górę" lub "w dół". W przypadku gdy część ułamkowa argumentu __x jest mniejsza od wartości 0.5 argument zaokrąglany jest "w dół" do najbliższej wartości całkowitej, w przeciwnym przypadku, gdy część ułamkowa argumentu jest równa lub większa od wartości 0.5 argument zaokrąglany jest "w górę" do najbliższej wartości całkowitej.

Argumenty:
double __x - wartość która ma zostać zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej w zależności od wartości przekazanej w argumencie.

Zwracana wartość:
long long int - wartość zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej.

#top llround¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji llround() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji llround() jest następująca:

/* Round X to nearest integral value, rounding halfway cases away from
   zero.  */
__MATHCALL (long long int,llround,, (_Mdouble_ __x));

Powiązane:
ceil(), floor(), llrint(), llround(), lrint(), lround(), nearbyint(), rint(), round(), trunc(),

Opis:

Funkcja llround() zwraca argument __x zaokrąglony do wartości całkowitej "w górę" lub "w dół". W przypadku gdy część ułamkowa argumentu __x jest mniejsza od wartości 0.5 argument zaokrąglany jest "w dół" do najbliższej wartości całkowitej, w przeciwnym przypadku, gdy część ułamkowa argumentu jest równa lub większa od wartości 0.5 argument zaokrąglany jest "w górę" do najbliższej wartości całkowitej. W przypadku wystąpienia błędu ustawiana jest globalna zmienna errno zawierająca powód występienia błędu. W przypadku, gdy przekazana wartość jako argument jest nieskończona kod występienia błędu to EDOM, funkcja może również ustawić kod występienia błędu na ERANGE.

Argumenty:
double __x - wartość która ma zostać zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej w zależności od wartości przekazanej w argumencie.

Zwracana wartość:
long long int - wartość zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej.

Example:
zawartość pliku llround.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double value;
	long long int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage:   %s <value>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 1.0\n", argv[0]);
		printf("         %s 1.2\n", argv[0]);
		printf("         %s 1.4\n", argv[0]);
		printf("         %s 1.499\n", argv[0]);
		printf("         %s -1.499\n", argv[0]);
		printf("         %s 1.500\n", argv[0]);
		printf("         %s -1.500\n", argv[0]);
		printf("         %s 1.6\n", argv[0]);
		printf("         %s 1.8\n", argv[0]);
		printf("         %s 2.0\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value=atof(argv[1]);
	printf("%s: value=atof(argv[1]=%s): value=%f\n", self, argv[1], value);
	
	result=llround(value);
	printf("%s: result=llround(value=%f): result=%lld\n", self, value, result);
	
	result=llrint(value);
	printf("%s: result=llrint(value=%f): result=%lld\n", self, value, result);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/llround

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/llround <value>
Examples:
         /home/local/code/ansiccode/math/llround 1.0
         /home/local/code/ansiccode/math/llround 1.2
         /home/local/code/ansiccode/math/llround 1.4
         /home/local/code/ansiccode/math/llround 1.499
         /home/local/code/ansiccode/math/llround -1.499
         /home/local/code/ansiccode/math/llround 1.500
         /home/local/code/ansiccode/math/llround -1.500
         /home/local/code/ansiccode/math/llround 1.6
         /home/local/code/ansiccode/math/llround 1.8
         /home/local/code/ansiccode/math/llround 2.0

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/llround 1.0
/home/local/code/ansiccode/math/llround 1.2
/home/local/code/ansiccode/math/llround 1.4
/home/local/code/ansiccode/math/llround 1.499
/home/local/code/ansiccode/math/llround -1.499
/home/local/code/ansiccode/math/llround 1.500
/home/local/code/ansiccode/math/llround -1.500
/home/local/code/ansiccode/math/llround 1.6
/home/local/code/ansiccode/math/llround 1.8
/home/local/code/ansiccode/math/llround 2.0

rezultat będzie zależny od podanych argumentów wywołania programu:

llround: argv[1]=1.0
llround: value=atof(argv[1]=1.0): value=1.000000
llround: result=round(value=1.000000): result=1

llround: argv[1]=1.2
llround: value=atof(argv[1]=1.2): value=1.200000
llround: result=round(value=1.200000): result=1

llround: argv[1]=1.4
llround: value=atof(argv[1]=1.4): value=1.400000
llround: result=round(value=1.400000): result=1

llround: argv[1]=1.499
llround: value=atof(argv[1]=1.499): value=1.499000
llround: result=round(value=1.499000): result=1

llround: argv[1]=-1.499
llround: value=atof(argv[1]=-1.499): value=-1.499000
llround: result=round(value=-1.499000): result=-1

llround: argv[1]=1.500
llround: value=atof(argv[1]=1.500): value=1.500000
llround: result=round(value=1.500000): result=2

llround: argv[1]=-1.500
llround: value=atof(argv[1]=-1.500): value=-1.500000
llround: result=round(value=-1.500000): result=-2

llround: argv[1]=1.6
llround: value=atof(argv[1]=1.6): value=1.600000
llround: result=round(value=1.600000): result=2

llround: argv[1]=1.8
llround: value=atof(argv[1]=1.8): value=1.800000
llround: result=round(value=1.800000): result=2

llround: argv[1]=2.0
llround: value=atof(argv[1]=2.0): value=2.000000
llround: result=round(value=2.000000): result=2

#top log¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji log() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji log() jest następująca:

/* Natural logarithm of X.  */
__MATHCALL (log,, (_Mdouble_ __x));

Powiązane:
log(), log10(), log1p(), log2(), logb(),

Opis:

Funkcja log() zwraca logarytm naturany dla wartości __x podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której zostanie zwrócony logarytm naturalny.

Zwracana wartość:
_Mdouble_ - logarytm naturalny dla wartości __x podanej jako argument wywołania.

Example:
zawartość pliku log.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double value;
	double result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage:   %s <value>\n", argv[0]);
		printf("Examples:\n");
        printf("         %s 2.718281828\n", argv[0]);
        printf("         %s 1.718281828\n", argv[0]);
        printf("         %s 1.0\n", argv[0]);
        printf("         %s 10.0\n", argv[0]);
        printf("         %s 100.0\n", argv[0]);
        printf("         %s 1000.0\n", argv[0]);
        printf("         %s 2.0\n", argv[0]);
        printf("         %s 4.0\n", argv[0]);
        printf("         %s 16.0\n", argv[0]);
        printf("         %s 1024.0\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value=atof(argv[1]);
	printf("%s: value=atof(argv[1]=%s): value=%f\n", self, argv[1], value);
	
	result=0;
	
	result=log(value);
	printf("%s: result=log(value=%f): result=%f\n", self, value, result);
	
#if defined(DHAVE_LOG2)
	result=log2(value);
	printf("%s: result=log2(value=%f): result=%f\n", self, value, result);
#else
	/* log2() is not available on this OS platform !!! */
	printf("%s: log2() is not available on this OS platform !!!\n", argv[0]);
#endif
	
	result=log10(value);
	printf("%s: result=log10(value=%f): result=%f\n", self, value, result);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/log

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/log <value>
Examples:
         /home/local/code/ansiccode/math/log 2.718281828
         /home/local/code/ansiccode/math/log 1.718281828
         /home/local/code/ansiccode/math/log 1.0
         /home/local/code/ansiccode/math/log 10.0
         /home/local/code/ansiccode/math/log 100.0
         /home/local/code/ansiccode/math/log 1000.0
         /home/local/code/ansiccode/math/log 2.0
         /home/local/code/ansiccode/math/log 4.0
         /home/local/code/ansiccode/math/log 16.0
         /home/local/code/ansiccode/math/log 1024.0

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/log 2.718281828
/home/local/code/ansiccode/math/log 1.718281828
/home/local/code/ansiccode/math/log 1.0
/home/local/code/ansiccode/math/log 10.0
/home/local/code/ansiccode/math/log 100.0
/home/local/code/ansiccode/math/log 1000.0
/home/local/code/ansiccode/math/log 2.0
/home/local/code/ansiccode/math/log 4.0
/home/local/code/ansiccode/math/log 16.0
/home/local/code/ansiccode/math/log 1024.0

rezultat będzie zależny od podanych argumentów wywołania programu:

log: argv[1]=2.718281828
log: value=atof(argv[1]=2.718281828): value=2.718282
log: result=log(value=2.718282): result=1.000000
log: result=log1p(value=2.718282): result=1.313262
log: result=log10(value=2.718282): result=0.434294
log: log2() is not available on this OS platform !!!
log: result=logb(value=2.718282): result=1.000000

log: argv[1]=1.718281828
log: value=atof(argv[1]=1.718281828): value=1.718282
log: result=log(value=1.718282): result=0.541325
log: result=log1p(value=1.718282): result=1.000000
log: result=log10(value=1.718282): result=0.235094
log: log2() is not available on this OS platform !!!
log: result=logb(value=1.718282): result=0.000000

log: argv[1]=1.0
log: value=atof(argv[1]=1.0): value=1.000000
log: result=log(value=1.000000): result=0.000000
log: result=log1p(value=1.000000): result=0.693147
log: result=log10(value=1.000000): result=0.000000
log: log2() is not available on this OS platform !!!
log: result=logb(value=1.000000): result=0.000000

log: argv[1]=10.0
log: value=atof(argv[1]=10.0): value=10.000000
log: result=log(value=10.000000): result=2.302585
log: result=log1p(value=10.000000): result=2.397895
log: result=log10(value=10.000000): result=1.000000
log: log2() is not available on this OS platform !!!
log: result=logb(value=10.000000): result=3.000000

log: argv[1]=100.0
log: value=atof(argv[1]=100.0): value=100.000000
log: result=log(value=100.000000): result=4.605170
log: result=log1p(value=100.000000): result=4.615121
log: result=log10(value=100.000000): result=2.000000
log: log2() is not available on this OS platform !!!
log: result=logb(value=100.000000): result=6.000000

log: argv[1]=1000.0
log: value=atof(argv[1]=1000.0): value=1000.000000
log: result=log(value=1000.000000): result=6.907755
log: result=log1p(value=1000.000000): result=6.908755
log: result=log10(value=1000.000000): result=3.000000
log: log2() is not available on this OS platform !!!
log: result=logb(value=1000.000000): result=9.000000

log: argv[1]=2.0
log: value=atof(argv[1]=2.0): value=2.000000
log: result=log(value=2.000000): result=0.693147
log: result=log1p(value=2.000000): result=1.098612
log: result=log10(value=2.000000): result=0.301030
log: log2() is not available on this OS platform !!!
log: result=logb(value=2.000000): result=1.000000

log: argv[1]=4.0
log: value=atof(argv[1]=4.0): value=4.000000
log: result=log(value=4.000000): result=1.386294
log: result=log1p(value=4.000000): result=1.609438
log: result=log10(value=4.000000): result=0.602060
log: log2() is not available on this OS platform !!!
log: result=logb(value=4.000000): result=2.000000

log: argv[1]=16.0
log: value=atof(argv[1]=16.0): value=16.000000
log: result=log(value=16.000000): result=2.772589
log: result=log1p(value=16.000000): result=2.833213
log: result=log10(value=16.000000): result=1.204120
log: log2() is not available on this OS platform !!!
log: result=logb(value=16.000000): result=4.000000

log: argv[1]=1024.0
log: value=atof(argv[1]=1024.0): value=1024.000000
log: result=log(value=1024.000000): result=6.931472
log: result=log1p(value=1024.000000): result=6.932448
log: result=log10(value=1024.000000): result=3.010300
log: log2() is not available on this OS platform !!!
log: result=logb(value=1024.000000): result=10.000000

#top log10¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji log10() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji log10() jest następująca:

/* Base-ten logarithm of X.  */
__MATHCALL (log10,, (_Mdouble_ __x));

Powiązane:
log(), log10(), log1p(), log2(), logb(),

Opis:

Funkcja log10() zwraca logarytm dziesiętny dla wartości __x podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której zostanie zwrócony logarytm dziesiętny.

Zwracana wartość:
_Mdouble_ - logarytm dziesiętny dla wartości __x podanej jako argument wywołania.

#top log1p¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji log1p() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji log1p() jest następująca:

/* Return log(1 + X).  */
__MATHCALL (log1p,, (_Mdouble_ __x));

Powiązane:
log(), log10(), log1p(), log2(), logb(),

Opis:

Funkcja log1p() powobnie jak funkcja log zwraca logarytm naturany dla wartości __x podanej jako argument wywołania funkcji, jednakże w odróżnieniu od funkcji log zwrócona wartość jest powiększona o jeden.

Argumenty:
_Mdouble_ __x - wartość dla której zostanie zwrócony logarytm naturalny powiększony o jeden.

Zwracana wartość:
_Mdouble_ - logarytm naturalny dla wartości __x podanej jako argument wywołania powiększony o jeden.

#top log2¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji log2() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji log2() jest następująca:

/* Compute base-2 logarithm of X.  */
__MATHCALL (log2,, (_Mdouble_ __x));

Powiązane:
log(), log10(), log1p(), log2(), logb(),

Opis:

Funkcja log2() zwraca logarytm o podstawie 2 dla wartości __x podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której zostanie zwrócony logarytm o podstawie 2.

Zwracana wartość:
_Mdouble_ - logarytm o podstawie 2 dla wartości __x podanej jako argument wywołania.

#top logb¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji logb() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji logb() jest następująca:

/* Return the base 2 signed integral exponent of X.  */
__MATHCALL (logb,, (_Mdouble_ __x));

Powiązane:
log(), log10(), log1p(), log2(), logb(),

Opis:

Funkcja logb()(en.wiki:Logarytm binarny, pl.wiki:Logarytm binarny) zwraca wykładnik dla wartości podanej jako argument wywołania funkcji spełniający równość: 2^logb(__x) = __x (liczba 2 podniesiona do potęgi zwróconej przez funkcji będzie równa podanemu argumentowi __x wywołania funkcji).

Argumenty:
_Mdouble_ __x - wartość dla której zostanie zwrócony logarytm binarny.

Zwracana wartość:
_Mdouble_ - logarytm binarny dla argumentu __x.

#top lrint¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji lrint() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji lrint() jest następująca:

/* Round X to nearest integral value according to current rounding
   direction.  */
__MATHDECL (long int,lrint,, (_Mdouble_ __x));

Powiązane:
ceil(), floor(), llrint(), llround(), lrint(), lround(), nearbyint(), rint(), round(), trunc(),

Opis:

Funkcja lrint() podobnie jak funkcja lround() zwraca argument __x zaokrąglony do wartości całkowitej "w górę" lub "w dół". W przypadku gdy część ułamkowa argumentu __x jest mniejsza od wartości 0.5 argument zaokrąglany jest "w dół" do najbliższej wartości całkowitej, w przeciwnym przypadku, gdy część ułamkowa argumentu jest równa lub większa od wartości 0.5 argument zaokrąglany jest "w górę" do najbliższej wartości całkowitej.

Argumenty:
_Mdouble_ __x - wartość która ma zostać zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej w zależności od wartości przekazanej w argumencie.

Zwracana wartość:
long int - wartość zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej.

#top lround¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji lround() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji lround() jest następująca:

/* Round X to nearest integral value, rounding halfway cases away from
   zero.  */
__MATHDECL (long int,lround,, (_Mdouble_ __x));

Powiązane:
ceil(), floor(), llrint(), llround(), lrint(), lround(), nearbyint(), rint(), round(), trunc(),

Opis:

Funkcja lround() zwraca argument __x zaokrąglony do wartości całkowitej "w górę" lub "w dół". W przypadku gdy część ułamkowa argumentu __x jest mniejsza od wartości 0.5 argument zaokrąglany jest "w dół" do najbliższej wartości całkowitej, w przeciwnym przypadku, gdy część ułamkowa argumentu jest równa lub większa od wartości 0.5 argument zaokrąglany jest "w górę" do najbliższej wartości całkowitej. W przypadku wystąpienia błędu ustawiana jest globalna zmienna errno zawierająca powód występienia błędu. W przypadku, gdy przekazana wartość jako argument jest nieskończona kod występienia błędu to EDOM, funkcja może również ustawić kod występienia błędu na ERANGE.

Argumenty:
_Mdouble_ __x - wartość która ma zostać zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej w zależności od wartości przekazanej w argumencie.

Zwracana wartość:
long int - wartość zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej.

Example:
zawartość pliku lround.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double value;
	long int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage:   %s <value>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 1.0\n", argv[0]);
		printf("         %s 1.2\n", argv[0]);
		printf("         %s 1.4\n", argv[0]);
		printf("         %s 1.499\n", argv[0]);
		printf("         %s -1.499\n", argv[0]);
		printf("         %s 1.500\n", argv[0]);
		printf("         %s -1.500\n", argv[0]);
		printf("         %s 1.6\n", argv[0]);
		printf("         %s 1.8\n", argv[0]);
		printf("         %s 2.0\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value=atof(argv[1]);
	printf("%s: value=atof(argv[1]=%s): value=%f\n", self, argv[1], value);
	
	result=lround(value);
	printf("%s: result=lround(value=%f): result=%ld\n", self, value, result);
	
	result=lrint(value);
	printf("%s: result=lrint(value=%f): result=%ld\n", self, value, result);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/lround

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/lround <value>
Examples:
         /home/local/code/ansiccode/math/lround 1.0
         /home/local/code/ansiccode/math/lround 1.2
         /home/local/code/ansiccode/math/lround 1.4
         /home/local/code/ansiccode/math/lround 1.499
         /home/local/code/ansiccode/math/lround -1.499
         /home/local/code/ansiccode/math/lround 1.500
         /home/local/code/ansiccode/math/lround -1.500
         /home/local/code/ansiccode/math/lround 1.6
         /home/local/code/ansiccode/math/lround 1.8
         /home/local/code/ansiccode/math/lround 2.0

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/lround 1.0
/home/local/code/ansiccode/math/lround 1.2
/home/local/code/ansiccode/math/lround 1.4
/home/local/code/ansiccode/math/lround 1.499
/home/local/code/ansiccode/math/lround -1.499
/home/local/code/ansiccode/math/lround 1.500
/home/local/code/ansiccode/math/lround -1.500
/home/local/code/ansiccode/math/lround 1.6
/home/local/code/ansiccode/math/lround 1.8
/home/local/code/ansiccode/math/lround 2.0

rezultat będzie zależny od podanych argumentów wywołania programu:

lround: argv[1]=1.0
lround: value=atof(argv[1]=1.0): value=1.000000
lround: result=round(value=1.000000): result=1

lround: argv[1]=1.2
lround: value=atof(argv[1]=1.2): value=1.200000
lround: result=round(value=1.200000): result=1

lround: argv[1]=1.4
lround: value=atof(argv[1]=1.4): value=1.400000
lround: result=round(value=1.400000): result=1

lround: argv[1]=1.499
lround: value=atof(argv[1]=1.499): value=1.499000
lround: result=round(value=1.499000): result=1

lround: argv[1]=-1.499
lround: value=atof(argv[1]=-1.499): value=-1.499000
lround: result=round(value=-1.499000): result=-1

lround: argv[1]=1.500
lround: value=atof(argv[1]=1.500): value=1.500000
lround: result=round(value=1.500000): result=2

lround: argv[1]=-1.500
lround: value=atof(argv[1]=-1.500): value=-1.500000
lround: result=round(value=-1.500000): result=-2

lround: argv[1]=1.6
lround: value=atof(argv[1]=1.6): value=1.600000
lround: result=round(value=1.600000): result=2

lround: argv[1]=1.8
lround: value=atof(argv[1]=1.8): value=1.800000
lround: result=round(value=1.800000): result=2

lround: argv[1]=2.0
lround: value=atof(argv[1]=2.0): value=2.000000
lround: result=round(value=2.000000): result=2

#top modf¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji modf() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji modf() jest następująca:

/* Break VALUE into integral and fractional parts.  */
__MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr));

Powiązane:
fdim(), fmax(), fmin(), modf(),

Opis:

Funkcja modf() zwraca ułamkową część liczby __x podanej jako wywołania funkcji oraz w argumencie ___iptr przekazanym jako wskaźnik wywołania funkcji zwracana jest część całkowita liczby podanej liczby. Suma zwróconej wartości przez funkcję wraz z wartością zwróconą we wskaźniku __iptr jest równa wartości __x przekazanej jako argument wywołania funkcji, co można wyrazić następującym wzorem: modf(__x,*__iptr) + __iptr = __x

Argumenty:
_Mdouble_ __x - liczba, której część ułamkowa zostanie zwrócona, a część całkowita zostanie ustawiona w argumencie __iptr przekazanym jako wskaźnik.
_Mdouble_ *__iptr - wskaźnik w którym zostanie ustawiona całkowita wartość argumentu __x.

Zwracana wartość:
_Mdouble_ - część ułamkowa argumentu __x.

Example:
zawartość pliku modf.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double value;
	double fractpart;
	double intpart;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage:   %s <value>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 3.141592653\n", argv[0]);
		printf("         %s 2.718281828\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value=atof(argv[1]);
	printf("%s: value=atol(argv[1]=%s): value=%f\n", self, argv[1], value);
	
	fractpart=modf(value, &intpart);
	printf("%s: fractpart=modf(value=%f, intpart=%f): fractpart=%f (intpart=%f + fractpart=%f = value=%f)\n", self, value, intpart, fractpart, intpart, fractpart, value);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/modf

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/modf <value>
Examples:
         /home/local/code/ansiccode/math/modf 3.141592653
         /home/local/code/ansiccode/math/modf 2.718281828

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/modf 3.141592653
/home/local/code/ansiccode/math/modf 2.718281828

rezultat będzie zależny od podanych argumentów wywołania programu:

modf: argv[1]=3.141592653
modf: value=atol(argv[1]=3.141592653): value=3.141593
modf: fractpart=modf(value=3.141593, intpart=3.000000): fractpart=0.141593 (intpart=3.000000 + fractpart=0.141593 = value=3.141593)

modf: argv[1]=2.718281828
modf: value=atol(argv[1]=2.718281828): value=2.718282
modf: fractpart=modf(value=2.718282, intpart=2.000000): fractpart=0.718282 (intpart=2.000000 + fractpart=0.718282 = value=2.718282)

#top nearbyint¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji nearbyint() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji nearbyint() jest następująca:

/* Round X to integral value in floating-point format using current
   rounding direction, but do not raise inexact exception.  */
__MATHCALL (nearbyint,, (_Mdouble_ __x));

Powiązane:
ceil(), floor(), llrint(), llround(), lrint(), lround(), nearbyint(), rint(), round(), trunc(),

Opis:

Funkcja nearbyint() podobnie jak funkcja round() oraz funkcja rint() zwraca argument __x zaokrąglony do wartości całkowitej "w górę" lub "w dół". W przypadku gdy część ułamkowa argumentu __x jest mniejsza od wartości 0.5 argument zaokrąglany jest "w dół" do najbliższej wartości całkowitej, w przeciwnym przypadku, gdy część ułamkowa argumentu jest równa lub większa od wartości 0.5 argument zaokrąglany jest "w górę" do najbliższej wartości całkowitej.

Argumenty:
_Mdouble_ __x - wartość która ma zostać zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej w zależności od wartości przekazanej w argumencie.

Zwracana wartość:
_Mdouble_ - wartość zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej.

#top nextafter¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji nextafter() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji nextafter() jest następująca:

/* Return X + epsilon if X < Y, X - epsilon if X > Y.  */
__MATHCALLX (nextafter,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));

Powiązane:

Opis:

Funkcja nextafter() zwraca

Argumenty:
_Mdouble_ __x -

Zwracana wartość:
_Mdouble_ -

#top nexttoward¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji nexttoward() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji nexttoward() jest następująca:

__MATHCALLX (nexttoward,, (_Mdouble_ __x, long double __y), (__const__));

Powiązane:

Opis:

Funkcja nexttoward() zwraca

Argumenty:
_Mdouble_ __x -

Zwracana wartość:
_Mdouble_ -

#top pow¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji pow() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji pow() jest następująca:

/* Return X to the Y power.  */
__MATHCALL (pow,, (_Mdouble_ __x, _Mdouble_ __y));

Powiązane:
cbrt(), hypot(), pow(), pow10(), sqrt(),

Opis:

Funkcja pow() zwraca argument __x podniesiony do potęgi o wartości argumentu __y. Funkcja oblicza wartość zgodnie ze wzorem __x^__y jednakże zwracany wynik jest obliczony z większą dokładnością niż wykonanie analogicznej operacji matematycznej.

Argumenty:
_Mdouble_ __x - wartość stanowiąca podstawę potęgi dla zwracanej wartości.
_Mdouble_ __y - wartość stanowiąca wykładnik potęgi dla zwracanej wartości.

Zwracana wartość:
_Mdouble_ - wynik potęgowania argumentu __x do wykładnika znajdującego się w argumencie __y.

#top pow10¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji pow10() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji pow10() jest następująca:

/* Another name occasionally used.  */
__MATHCALL (pow10,, (_Mdouble_ __x));

Powiązane:
cbrt(), hypot(), pow(), pow10(), sqrt(),

Opis:

Funkcja pow10() zwraca liczbę 10 podniesioną do potęgi określonej w argumecie __x. Funkcja oblicza wartość zgodnie ze wzorem 10^__x jednakże zwracany wynik jest obliczony z większą dokładnością niż wykonanie analogicznej operacji matematycznej.

Argumenty:
_Mdouble_ __x - wartość stanowiąca wykładnik potęgi dla zwracanej wartości.

Zwracana wartość:
_Mdouble_ - wynik potęgowania liczby 10 do wykładnika określonego w argumencie__x.

#top rand¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji rand() znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja funkcji rand() jest następująca:

/* Return a random integer between 0 and RAND_MAX inclusive.  *:
extern int rand (void) __THROW;

Powiązane:
initstate(), rand(), random(), setstate(), srand(), srandom(),

Opis:

Funkcja rand() zwraca pseudolosową liczbę przedziału 0 do RAND_MAX.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
int - pseudolosową liczba przedziału 0 do RAND_MAX

Example:
zawartość pliku rand.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	long int value;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
	value=rand();
	printf("%s: value=rand(): value=%ld\n", self, value);
	
	value=rand();
	printf("%s: value=rand(): value=%ld\n", self, value);
	
	value=rand();
	printf("%s: value=rand(): value=%ld\n", self, value);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/rand

program wyświetli stosowne informacje o sposobie działania:

rand: value=rand(): value=1804289383
rand: value=rand(): value=846930886
rand: value=rand(): value=1681692777

a następnie ponownie uruchomić bez argumentów:

/home/local/code/ansiccode/math/rand

program ponownie wyświetli stosowne informacje o sposobie działania:

rand: value=rand(): value=1804289383
rand: value=rand(): value=846930886
rand: value=rand(): value=1681692777

Jak widać na powyższym rezultacie program za każdym razem po uruchomieniu wyświetla te same pseudolosowe liczby, wynika to z braku inicjalizacji generatora liczb pseudolosowych.

#top random¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji random() znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja funkcji random() jest następująca:

/* These are the functions that actually do things.  The `random', `srandom',
   `initstate' and `setstate' functions are those from BSD Unices.
   The `rand' and `srand' functions are required by the ANSI standard.
   We provide both interfaces to the same random number generator.  */
/* Return a random long integer between 0 and RAND_MAX inclusive.  *:
extern long int random (void) __THROW;

Powiązane:
initstate(), rand(), random(), setstate(), srand(), srandom(),

Opis:

Funkcja random() podobnie jak funkcja rand() zwraca pseudolosową liczbę przedziału 0 do RAND_MAX.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
long int - pseudolosową liczba przedziału 0 do RAND_MAX

Example:
zawartość pliku random.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	long int value;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* random() is not available on this OS platform !!! */
	printf("%s: uname() is not available on this OS platform !!!\n", argv[0]);
#else
	value=random();
	printf("%s: value=random(): value=%ld\n", self, value);
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* random() is not available on this OS platform !!! */
	printf("%s: uname() is not available on this OS platform !!!\n", argv[0]);
#else
	value=random();
	printf("%s: value=random(): value=%ld\n", self, value);
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* random() is not available on this OS platform !!! */
	printf("%s: uname() is not available on this OS platform !!!\n", argv[0]);
#else
	value=random();
	printf("%s: value=random(): value=%ld\n", self, value);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/random

program wyświetli stosowne informacje o sposobie działania:

random: value=random(): value=1804289383
random: value=random(): value=846930886
random: value=random(): value=1681692777

a następnie ponownie uruchomić bez argumentów:

/home/local/code/ansiccode/math/random

program ponownie wyświetli stosowne informacje o sposobie działania:

random: value=random(): value=1804289383
random: value=random(): value=846930886
random: value=random(): value=1681692777

Jak widać na powyższym rezultacie program za każdym razem po uruchomieniu wyświetla te same pseudolosowe liczby, wynika to z braku inicjalizacji generatora liczb pseudolosowych.

#top remainder¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji remainder() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji remainder() jest następująca:

/* Return the remainder of integer divison X / Y with infinite precision.  */
__MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));

Powiązane:
div(), drem(), fmod(), ldiv(), lldiv(), remainder(), remquo(),

Opis:

Funkcja remainder() podobnie jak funkcje drem() i drem() oraz funkcja div() w strukturze div_t w polu rem zwraca resztę z dzielenia argumentu __x (dzielna) przez argument __y (dzielnik).

Argumenty:
_Mdouble_ __x - liczba będąca dzielną, która zostanie podzielona przez argument __y.
_Mdouble_ __y - liczba będąca dzielnikiem, przez który zostanie podzielona argument __x.

Zwracana wartość:
_Mdouble_ - reszta z ilorazu dzielenia liczby przekazanej w argumencie __x (dzielna) przez liczbę przekazaną w argumencie __y (dzielnik).

#top remquo¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji remquo() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji remquo() jest następująca:

/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
   and magnitude congruent `mod 2^n' to the magnitude of the integral
   quotient x/y, with n >= 3.  */
__MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));

Powiązane:
div(), drem(), fmod(), ldiv(), lldiv(), remainder(), remquo(),

Opis:

Funkcja remquo() zwraca wartość będącą dopełnieniem (sumą) iloczynu wartości __y i wartości zwróconej we wskaźniku __quo. Zwracana wartość tworzy z argumentami zależność, którą można opisać następującym wzorem: __y * __quo + remquo(__x, __y, __quo) = __x.

Argumenty:
_Mdouble_ __x - wartość podlegająca rozkładowi na sumę zwracanej wartości z iloczynem wartości __y z wartością umieszczoną we wskaźniku __quo.
_Mdouble_ __y - wartość, której iloczyn z wartością zwróconą we wskaźniku __quo zsumowanay wartością zwróconą przez funkcję jest równy wartości __x.
int *__quo - wartość, której iloczyn z wartością __y zsumowanay wartością zwróconą przez funkcję jest równy wartości __x.

Zwracana wartość:
_Mdouble_ - wartość będącą dopełnieniem (sumą) iloczynu wartości __y i wartości zwróconej we wskaźniku __quo.

#top rint¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji rint() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji rint() jest następująca:

/* Return the integer nearest X in the direction of the
   prevailing rounding mode.  */
__MATHCALL (rint,, (_Mdouble_ __x));

Powiązane:
ceil(), floor(), llrint(), llround(), lrint(), lround(), nearbyint(), rint(), round(), trunc(),

Opis:

Funkcja rint() podobnie jak funkcja round() oraz funkcja nearbyint() zwraca argument __x zaokrąglony do wartości całkowitej "w górę" lub "w dół". W przypadku gdy część ułamkowa argumentu __x jest mniejsza od wartości 0.5 argument zaokrąglany jest "w dół" do najbliższej wartości całkowitej, w przeciwnym przypadku, gdy część ułamkowa argumentu jest równa lub większa od wartości 0.5 argument zaokrąglany jest "w górę" do najbliższej wartości całkowitej.

Argumenty:
_Mdouble_ __x - wartość która ma zostać zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej w zależności od wartości przekazanej w argumencie.

Zwracana wartość:
_Mdouble_ - wartość zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej.

#top round¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji round() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji round() jest następująca:

/* Round X to nearest integral value, rounding halfway cases away from
   zero.  */
__MATHCALLX (round,, (_Mdouble_ __x), (__const__));

Powiązane:
ceil(), floor(), llrint(), llround(), lrint(), lround(), nearbyint(), rint(), round(), trunc(),

Opis:

Funkcja round() zwraca argument __x zaokrąglony do wartości całkowitej "w górę" lub "w dół". W przypadku gdy część ułamkowa argumentu __x jest mniejsza od wartości 0.5 argument zaokrąglany jest "w dół" do najbliższej wartości całkowitej, w przeciwnym przypadku, gdy część ułamkowa argumentu jest równa lub większa od wartości 0.5 argument zaokrąglany jest "w górę" do najbliższej wartości całkowitej. W przypadku wystąpienia błędu ustawiana jest globalna zmienna errno zawierająca powód występienia błędu. W przypadku, gdy przekazana wartość jako argument jest nieskończona kod występienia błędu to EDOM, funkcja może również ustawić kod występienia błędu na ERANGE.

Argumenty:
_Mdouble_ __x - wartość która ma zostać zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej w zależności od wartości przekazanej w argumencie.

Zwracana wartość:
_Mdouble_ - wartość zaokrąglona "w górę" lub "w dół" do najbliższej wartości całkowitej.

Example:
zawartość pliku round.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double value;
	double result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage:   %s <value>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 1.0\n", argv[0]);
		printf("         %s 1.2\n", argv[0]);
		printf("         %s 1.4\n", argv[0]);
		printf("         %s 1.499\n", argv[0]);
		printf("         %s -1.499\n", argv[0]);
		printf("         %s 1.500\n", argv[0]);
		printf("         %s -1.500\n", argv[0]);
		printf("         %s 1.6\n", argv[0]);
		printf("         %s 1.8\n", argv[0]);
		printf("         %s 2.0\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value=atof(argv[1]);
	printf("%s: value=atof(argv[1]=%s): value=%f\n", self, argv[1], value);
	
	result=floor(value);
	printf("%s: result=floor(value=%f): result=%f\n", self, value, result);
	
	result=round(value);
	printf("%s: result=round(value=%f): result=%f\n", self, value, result);
	
	result=ceil(value);
	printf("%s: result=ceil(value=%f): result=%f\n", self, value, result);
	
	result=trunc(value);
	printf("%s: result=trunc(value=%f): result=%f\n", self, value, result);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/round

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/round <value>
Examples:
         /home/local/code/ansiccode/math/round 1.0
         /home/local/code/ansiccode/math/round 1.2
         /home/local/code/ansiccode/math/round 1.4
         /home/local/code/ansiccode/math/round 1.499
         /home/local/code/ansiccode/math/round -1.499
         /home/local/code/ansiccode/math/round 1.500
         /home/local/code/ansiccode/math/round -1.500
         /home/local/code/ansiccode/math/round 1.6
         /home/local/code/ansiccode/math/round 1.8
         /home/local/code/ansiccode/math/round 2.0

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/round 1.0
/home/local/code/ansiccode/math/round 1.2
/home/local/code/ansiccode/math/round 1.4
/home/local/code/ansiccode/math/round 1.499
/home/local/code/ansiccode/math/round -1.499
/home/local/code/ansiccode/math/round 1.500
/home/local/code/ansiccode/math/round -1.500
/home/local/code/ansiccode/math/round 1.6
/home/local/code/ansiccode/math/round 1.8
/home/local/code/ansiccode/math/round 2.0

rezultat będzie zależny od podanych argumentów wywołania programu:

round: argv[1]=1.0
round: value=atof(argv[1]=1.0): value=1.000000
round: result=floor(value=1.000000): result=1.000000
round: result=round(value=1.000000): result=1.000000
round: result=ceil(value=1.000000): result=1.000000
round: result=trunc(value=1.000000): result=1.000000

round: argv[1]=1.2
round: value=atof(argv[1]=1.2): value=1.200000
round: result=floor(value=1.200000): result=1.000000
round: result=round(value=1.200000): result=1.000000
round: result=ceil(value=1.200000): result=2.000000
round: result=trunc(value=1.200000): result=1.000000

round: argv[1]=1.4
round: value=atof(argv[1]=1.4): value=1.400000
round: result=floor(value=1.400000): result=1.000000
round: result=round(value=1.400000): result=1.000000
round: result=ceil(value=1.400000): result=2.000000
round: result=trunc(value=1.400000): result=1.000000

round: argv[1]=1.499
round: value=atof(argv[1]=1.499): value=1.499000
round: result=floor(value=1.499000): result=1.000000
round: result=round(value=1.499000): result=1.000000
round: result=ceil(value=1.499000): result=2.000000
round: result=trunc(value=1.499000): result=1.000000

round: argv[1]=-1.499
round: value=atof(argv[1]=-1.499): value=-1.499000
round: result=floor(value=-1.499000): result=-2.000000
round: result=round(value=-1.499000): result=-1.000000
round: result=ceil(value=-1.499000): result=-1.000000
round: result=trunc(value=-1.499000): result=-1.000000

round: argv[1]=1.500
round: value=atof(argv[1]=1.500): value=1.500000
round: result=floor(value=1.500000): result=1.000000
round: result=round(value=1.500000): result=2.000000
round: result=ceil(value=1.500000): result=2.000000
round: result=trunc(value=1.500000): result=1.000000

round: argv[1]=-1.500
round: value=atof(argv[1]=-1.500): value=-1.500000
round: result=floor(value=-1.500000): result=-2.000000
round: result=round(value=-1.500000): result=-2.000000
round: result=ceil(value=-1.500000): result=-1.000000
round: result=trunc(value=-1.500000): result=-1.000000

round: argv[1]=1.6
round: value=atof(argv[1]=1.6): value=1.600000
round: result=floor(value=1.600000): result=1.000000
round: result=round(value=1.600000): result=2.000000
round: result=ceil(value=1.600000): result=2.000000
round: result=trunc(value=1.600000): result=1.000000

round: argv[1]=1.8
round: value=atof(argv[1]=1.8): value=1.800000
round: result=floor(value=1.800000): result=1.000000
round: result=round(value=1.800000): result=2.000000
round: result=ceil(value=1.800000): result=2.000000
round: result=trunc(value=1.800000): result=1.000000

round: argv[1]=2.0
round: value=atof(argv[1]=2.0): value=2.000000
round: result=floor(value=2.000000): result=2.000000
round: result=round(value=2.000000): result=2.000000
round: result=ceil(value=2.000000): result=2.000000
round: result=trunc(value=2.000000): result=2.000000

#top scalb¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji scalb() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji scalb() jest następująca:

/* Return X times (2 to the Nth power).  */
__MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n));

Powiązane:
ceil(), floor(), llrint(), llround(), lrint(), lround(), nearbyint(), rint(), round(), trunc(),

Opis:

Funkcja scalb() zwraca iloczyn argumentu __x i liczby 2 podniesionej do potęgi określonej argumentem __n. Funkcja realizuje operację matematyczna, którą można zapisać wzorem: __x + 2^__n.

Argumenty:
_Mdouble_ __x - argument, którego iloczyn z liczbą 2 podniesioną do potęgi __n zostanie zwrócony.
_Mdouble_ __n - wykładnik potęgi o podstawie 2 której iloczyn z liczbą __x zostanie zwrócony.

Zwracana wartość:
_Mdouble_ - iloczyn argumentu __x i liczby 2 podniesionej do potęgi określonej argumentem __n.

#top scalbln¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji scalbln() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji scalbln() jest następująca:

/* Return X times (2 to the Nth power).  */
__MATHCALL (scalbln,, (_Mdouble_ __x, long int __n));

Powiązane:
ceil(), floor(), llrint(), llround(), lrint(), lround(), nearbyint(), rint(), round(), trunc(),

Opis:

Funkcja scalbln() zwraca iloczyn argumentu __x i liczby 2 podniesionej do potęgi określonej argumentem __n. Funkcja realizuje operację matematyczna, którą można zapisać wzorem: __x + 2^__n.

Argumenty:
_Mdouble_ __x - argument, którego iloczyn z liczbą 2 podniesioną do potęgi __n zostanie zwrócony.
long int __n - wykładnik potęgi o podstawie 2 której iloczyn z liczbą __x zostanie zwrócony.

Zwracana wartość:
_Mdouble_ - iloczyn argumentu __x i liczby 2 podniesionej do potęgi określonej argumentem __n.

#top scalbn¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji scalbn() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji scalbn() jest następująca:

/* Return X times (2 to the Nth power).  */
__MATHCALL (scalbn,, (_Mdouble_ __x, int __n));

Powiązane:
ceil(), floor(), llrint(), llround(), lrint(), lround(), nearbyint(), rint(), round(), trunc(),

Opis:

Funkcja scalbn() zwraca iloczyn argumentu __x i liczby 2 podniesionej do potęgi określonej argumentem __n. Funkcja realizuje operację matematyczna, którą można zapisać wzorem: __x + 2^__n.

Argumenty:
_Mdouble_ __x - argument, którego iloczyn z liczbą 2 podniesioną do potęgi __n zostanie zwrócony.
int __n - wykładnik potęgi o podstawie 2 której iloczyn z liczbą __x zostanie zwrócony.

Zwracana wartość:
_Mdouble_ - iloczyn argumentu __x i liczby 2 podniesionej do potęgi określonej argumentem __n.

#top setstate¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji setstate() znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja funkcji setstate() jest następująca:

/* Switch the random number generator to state buffer STATEBUF,
   which should have been previously initialized by `initstate'.  */
extern char *setstate (char *__statebuf) __THROW __nonnull ((1));

Powiązane:
initstate(), rand(), random(), setstate(), srand(), srandom(),

Opis:

Funkcja setstate()

Argumenty:
char *__statebuf -

Zwracana wartość:
char * -

#top signbit¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji signbit() znajduje się w pliku nagłówkowym math.h.
Deklaracja funkcji signbit() jest następująca:

/* Return nonzero value if sign of X is negative.  */
# ifdef __NO_LONG_DOUBLE_MATH
#  define signbit(x) \
     (sizeof (x) == sizeof (float) ? __signbitf (x) : __signbit (x))
# else
#  define signbit(x) \
     (sizeof (x) == sizeof (float)                        \
      ? __signbitf (x)                                \
      : sizeof (x) == sizeof (double)                         \
      ? __signbit (x) : __signbitl (x))
# endif

Powiązane:
fpclassify(), isfinite(), isinf(), isnan(), isnormal(), signbit(),

Opis:

Funkcja signbit() dla wartości ujemnych argumentu x wywołania funkcji zwracana jest wartość niezerową (wartość jeden), w pozostałych przypadkach (dla wartości dodatnich oraz zero) zwracana jest wartość zerowa.

Argumenty:
x - badana wartość, dla której zwracana zerowa lub niezerowa wartość określa znak badanej liczby.

Zwracana wartość:
y - zerowa lub niezerowa wartość określająca znak badanej liczby podanej jako argument wywołania funkcji.

#top sin¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji sin() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji sin() jest następująca:

/* Sine of X.  */
__MATHCALL (sin,, (_Mdouble_ __x));

Powiązane:
acos(), asin(), atan(), atan2(), cos(), sin(), tan(),

Opis:

Funkcja sin() (sinus) oblicza wartość sinus dla liczby podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której jest obliczany sinus.

Zwracana wartość:
_Mdouble_ - sinus dla wartości podanej jako argument wywołania funkcji.

Example:
zawartość pliku sin.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double value1;
	double value2;
	double result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage:   %s <value1> <value2>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 30 0.5\n", argv[0]);
		printf("         %s 60 0.5\n", argv[0]);
		printf("         %s 45 1.0\n", argv[0]);
		return 0;
	}
	
	value1=atof(argv[1]);
	printf("%s: value1=atof(argv[1]=%s): value1=%f\n", self, argv[1], value1);
	
	value2=atof(argv[2]);
	printf("%s: value2=atof(argv[2]=%s): value2=%f\n", self, argv[2], value2);
	
	
	result=sin(value1*M_PI/180);
	printf("%s: result=sin(value1=%f * M_PI=%f / 180): result=%f\n", self, value1, M_PI, result);
	
	result=asin(value2)*180/M_PI;
	printf("%s: result=asin(value2=%f) * 180 / M_PI=%f: result=%f\n", self, value2, M_PI, result);
	
	
	result=cos(value1*M_PI/180);
	printf("%s: result=cos(value1=%f * M_PI=%f / 180): result=%f\n", self, value1, M_PI, result);
	
	result=acos(value2)*180/M_PI;
	printf("%s: result=acos(value2=%f) * 180 / M_PI=%f: result=%f\n", self, value2, M_PI, result);
	
	
	result=tan(value1*M_PI/180);
	printf("%s: result=tan(value1=%f * M_PI=%f / 180): result=%f\n", self, value1, M_PI, result);
	
	result=atan(value2)*180/M_PI;
	printf("%s: result=atan(value2=%f) / 180 * M_PI=%f: result=%f\n", self, value2, M_PI, result);
	
	result=atan2(value2, value2);
	printf("%s: result=atan2(value2=%f, value2=%f): result=%f\n", self, value2, value2, result);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/sin

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/sin <value1> <value2>
Examples:
         /home/local/code/ansiccode/math/sin 30 0.5
         /home/local/code/ansiccode/math/sin 60 0.5
         /home/local/code/ansiccode/math/sin 45 1.0

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/sin 30 0.5
/home/local/code/ansiccode/math/sin 60 0.5
/home/local/code/ansiccode/math/sin 45 1.0

rezultat będzie zależny od podanych argumentów wywołania programu:

sin: value1=atof(argv[1]=30): value1=30.000000
sin: value2=atof(argv[2]=0.5): value2=0.500000
sin: result=sin(value1=30.000000 * M_PI=3.141593 / 180): result=0.500000
sin: result=asin(value2=0.500000) * 180 / M_PI=3.141593: result=30.000000
sin: result=cos(value1=30.000000 * M_PI=3.141593 / 180): result=0.866025
sin: result=acos(value2=0.500000) * 180 / M_PI=3.141593: result=60.000000
sin: result=tan(value1=30.000000 * M_PI=3.141593 / 180): result=0.577350
sin: result=atan(value2=0.500000) / 180 * M_PI=3.141593: result=26.565051
sin: result=atan2(value2=0.500000, value2=0.500000): result=0.785398

sin: value1=atof(argv[1]=60): value1=60.000000
sin: value2=atof(argv[2]=0.5): value2=0.500000
sin: result=sin(value1=60.000000 * M_PI=3.141593 / 180): result=0.866025
sin: result=asin(value2=0.500000) * 180 / M_PI=3.141593: result=30.000000
sin: result=cos(value1=60.000000 * M_PI=3.141593 / 180): result=0.500000
sin: result=acos(value2=0.500000) * 180 / M_PI=3.141593: result=60.000000
sin: result=tan(value1=60.000000 * M_PI=3.141593 / 180): result=1.732051
sin: result=atan(value2=0.500000) / 180 * M_PI=3.141593: result=26.565051
sin: result=atan2(value2=0.500000, value2=0.500000): result=0.785398

sin: value1=atof(argv[1]=45): value1=45.000000
sin: value2=atof(argv[2]=1.0): value2=1.000000
sin: result=sin(value1=45.000000 * M_PI=3.141593 / 180): result=0.707107
sin: result=asin(value2=1.000000) * 180 / M_PI=3.141593: result=90.000000
sin: result=cos(value1=45.000000 * M_PI=3.141593 / 180): result=0.707107
sin: result=acos(value2=1.000000) * 180 / M_PI=3.141593: result=0.000000
sin: result=tan(value1=45.000000 * M_PI=3.141593 / 180): result=1.000000
sin: result=atan(value2=1.000000) / 180 * M_PI=3.141593: result=45.000000
sin: result=atan2(value2=1.000000, value2=1.000000): result=0.785398

#top sinh¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji sinh() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji sinh() jest następująca:

/* Hyperbolic sine of X.  */
__MATHCALL (sinh,, (_Mdouble_ __x));

Powiązane:
acosh(), asinh(), atanh(), cosh(), sinh(), tanh(),

Opis:

Funkcja sinh() (hyperbolic sinus) oblicza wartość sinus hiperboliczny dla liczby podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której jest obliczany sinus hiperboliczny.

Zwracana wartość:
_Mdouble_ - sinus hiperboliczny dla wartości podanej jako argument wywołania funkcji.

Example:
zawartość pliku sinh.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double value1;
	double value2;
	double result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage:   %s <value1> <value2>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 0.693147 0.75000\n", argv[0]);
		printf("         %s 0.693147 1.25000\n", argv[0]);
		printf("         %s 0.693147 3.62686\n", argv[0]);
		printf("         %s 0.693147 3.762196\n", argv[0]);
		printf("         %s 1.000000 0.761594\n", argv[0]);
		return 0;
	}
	
	printf("%s: argv[1]=%s\n", self, argv[1]);
	value1=atof(argv[1]);
	printf("%s: value1=atof(argv[1]=%s): value1=%f\n", self, argv[1], value1);
	
	printf("%s: argv[2]=%s\n", self, argv[2]);
	value2=atof(argv[2]);
	printf("%s: value2=atof(argv[2]=%s): value2=%f\n", self, argv[2], value2);
	
	
	result=sinh(value1);
	printf("%s: result=sinh(value1=%f): result=%f\n", self, value1, result);
	
	result=asinh(value2);
	printf("%s: result=asinh(value2=%f): result=%f\n", self, value2, result);
	
	
	result=cosh(value1);
	printf("%s: result=cosh(value1=%f): result=%f\n", self, value1, result);
	
	result=acosh(value2);
	printf("%s: result=acosh(value2=%f): result=%f\n", self, value2, result);
	
	
	result=tanh(value1);
	printf("%s: result=tanh(value1=%f): result=%f\n", self, value1, result);
	
	result=atanh(value2);
	printf("%s: result=atanh(value2=%f): result=%f\n", self, value2, result);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/sinh

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/sinh <value1> <value2>
Examples:
         /home/local/code/ansiccode/math/sinh 0.693147 0.75000
         /home/local/code/ansiccode/math/sinh 0.693147 1.25000
         /home/local/code/ansiccode/math/sinh 0.693147 3.62686
         /home/local/code/ansiccode/math/sinh 0.693147 3.762196
         /home/local/code/ansiccode/math/sinh 1.000000 0.761594

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/sinh 0.693147 0.75000
/home/local/code/ansiccode/math/sinh 0.693147 1.25000
/home/local/code/ansiccode/math/sinh 0.693147 3.62686
/home/local/code/ansiccode/math/sinh 0.693147 3.762196
/home/local/code/ansiccode/math/sinh 1.000000 0.761594

rezultat będzie zależny od podanych argumentów wywołania programu:

sinh: argv[1]=0.693147
sinh: value1=atof(argv[1]=0.693147): value1=0.693147
sinh: argv[2]=0.75000
sinh: value2=atof(argv[2]=0.75000): value2=0.750000
sinh: result=sinh(value1=0.693147): result=0.750000
sinh: result=asinh(value2=0.750000): result=0.693147
sinh: result=cosh(value1=0.693147): result=1.250000
sinh: result=acosh(value2=0.750000): result=nan
sinh: result=tanh(value1=0.693147): result=0.600000
sinh: result=atanh(value2=0.750000): result=0.972955

sinh: argv[1]=0.693147
sinh: value1=atof(argv[1]=0.693147): value1=0.693147
sinh: argv[2]=1.25000
sinh: value2=atof(argv[2]=1.25000): value2=1.250000
sinh: result=sinh(value1=0.693147): result=0.750000
sinh: result=asinh(value2=1.250000): result=1.047593
sinh: result=cosh(value1=0.693147): result=1.250000
sinh: result=acosh(value2=1.250000): result=0.693147
sinh: result=tanh(value1=0.693147): result=0.600000
sinh: result=atanh(value2=1.250000): result=nan

sinh: argv[1]=0.693147
sinh: value1=atof(argv[1]=0.693147): value1=0.693147
sinh: argv[2]=3.62686
sinh: value2=atof(argv[2]=3.62686): value2=3.626860
sinh: result=sinh(value1=0.693147): result=0.750000
sinh: result=asinh(value2=3.626860): result=2.000000
sinh: result=cosh(value1=0.693147): result=1.250000
sinh: result=acosh(value2=3.626860): result=1.961943
sinh: result=tanh(value1=0.693147): result=0.600000
sinh: result=atanh(value2=3.626860): result=nan

sinh: argv[1]=0.693147
sinh: value1=atof(argv[1]=0.693147): value1=0.693147
sinh: argv[2]=3.762196
sinh: value2=atof(argv[2]=3.762196): value2=3.762196
sinh: result=sinh(value1=0.693147): result=0.750000
sinh: result=asinh(value2=3.762196): result=2.035362
sinh: result=cosh(value1=0.693147): result=1.250000
sinh: result=acosh(value2=3.762196): result=2.000000
sinh: result=tanh(value1=0.693147): result=0.600000
sinh: result=atanh(value2=3.762196): result=nan

sinh: argv[1]=1.000000
sinh: value1=atof(argv[1]=1.000000): value1=1.000000
sinh: argv[2]=0.761594
sinh: value2=atof(argv[2]=0.761594): value2=0.761594
sinh: result=sinh(value1=1.000000): result=1.175201
sinh: result=asinh(value2=0.761594): result=0.702397
sinh: result=cosh(value1=1.000000): result=1.543081
sinh: result=acosh(value2=0.761594): result=nan
sinh: result=tanh(value1=1.000000): result=0.761594
sinh: result=atanh(value2=0.761594): result=1.000000

#top sqrt¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji sqrt() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji sqrt() jest następująca:

/* Return the square root of X.  */
__MATHCALL (sqrt,, (_Mdouble_ __x));

Powiązane:
cbrt(), hypot(), pow(), pow10(), sqrt(),

Opis:

Funkcja sqrt() zwraca pierwiastek kwadratowy liczby __x podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - liczba, której pierwiastek kwadratowy zostanie zwrócony.

Zwracana wartość:
_Mdouble_ - pierwiastek kwadratowy dla liczby __x podanej jako argument wywołania funkcji.

Example:
zawartość pliku sqrt.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <math.h>          /* for matherr(), M_E, M_LOG2E, M_LOG10E, M_LN2, M_LN10, M_PI, M_PI_2, M_PI_4, M_1_PI, M_2_PI, M_SQRT2, */



int main(int argc, char **argv) {
	char *self;
	double base;
	double exponent;
	double value1, value2, value3;
	double result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<5) {
		printf("Usage:   %s <base> <exponent> <value>\n", argv[0]);
		printf("Examples:\n");
		printf("         %s 10 0 2 3 4\n", argv[0]);
		printf("         %s 10 1 4 3 4\n", argv[0]);
		printf("         %s 10 2 8 3 4\n", argv[0]);
		printf("         %s 10 5 16 6 8\n", argv[0]);
		printf("         %s 2 0 64 6 8\n", argv[0]);
		printf("         %s 2 1 10 6 8\n", argv[0]);
		printf("         %s 2 2 100 6 8\n", argv[0]);
		printf("         %s 2 10 1000 6 8\n", argv[0]);
		printf("         %s 1.414213562373095049 2 10000 6 8\n", argv[0]);
		return 0;
	}
	
	base=atof(argv[1]);
	printf("%s: base=atof(argv[1]=%s): base=%f\n", self, argv[1], base);
	exponent=atof(argv[2]);
	printf("%s: exponent=atof(argv[2]=%s): exponent=%f\n", self, argv[2], exponent);
	
	value1=atof(argv[3]);
	printf("%s: value1=atof(argv[3]=%s): value1=%f\n", self, argv[3], value1);
	value2=atof(argv[4]);
	printf("%s: value2=atof(argv[4]=%s): value2=%f\n", self, argv[4], value2);
	value3=atof(argv[5]);
	printf("%s: value3=atof(argv[5]=%s): value3=%f\n", self, argv[5], value3);
	
	result=pow(base, exponent);
	printf("%s: result=pow(base=%f, exponent=%f): result=%f\n", self, base, exponent, result);
	
	result=pow10(exponent);
	printf("%s: result=pow10(exponent=%f): result=%f\n", self, exponent, result);
	
	result=sqrt(value1);
	printf("%s: result=sqrt(value1=%f): result=%f\n", self, value1, result);
	
	result=cbrt(value1);
	printf("%s: result=cbrt(value1=%f): result=%f\n", self, value1, result);
	
	result=hypot(value2, value3);
	printf("%s: result=hypot(value2=%f, value3=%f): result=%f\n", self, value2, value3, result);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/sqrt

program wyświetli informacje o sposobie uruchamiania programu:

Usage:   /home/local/code/ansiccode/math/sqrt <base> <exponent> <value>
Examples:
         /home/local/code/ansiccode/math/sqrt 10 0 2 3 4
         /home/local/code/ansiccode/math/sqrt 10 1 4 3 4
         /home/local/code/ansiccode/math/sqrt 10 2 8 3 4
         /home/local/code/ansiccode/math/sqrt 10 5 16 6 8
         /home/local/code/ansiccode/math/sqrt 2 0 64 6 8
         /home/local/code/ansiccode/math/sqrt 2 1 10 6 8
         /home/local/code/ansiccode/math/sqrt 2 2 100 6 8
         /home/local/code/ansiccode/math/sqrt 2 10 1000 6 8
         /home/local/code/ansiccode/math/sqrt 1.414213562373095049 2 10000 6 8

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/math/sqrt 10 0 2 3 4
/home/local/code/ansiccode/math/sqrt 10 1 4 3 4
/home/local/code/ansiccode/math/sqrt 10 2 8 3 4
/home/local/code/ansiccode/math/sqrt 10 5 16 6 8
/home/local/code/ansiccode/math/sqrt 2 0 64 6 8
/home/local/code/ansiccode/math/sqrt 2 1 10 6 8
/home/local/code/ansiccode/math/sqrt 2 2 100 6 8
/home/local/code/ansiccode/math/sqrt 2 10 1000 6 8
/home/local/code/ansiccode/math/sqrt 1.414213562373095049 2 10000 6 8

rezultat będzie zależny od podanych argumentów wywołania programu:

sqrt: base=atof(argv[1]=10): base=10.000000
sqrt: exponent=atof(argv[2]=0): exponent=0.000000
sqrt: value1=atof(argv[3]=2): value1=2.000000
sqrt: value2=atof(argv[4]=3): value2=3.000000
sqrt: value3=atof(argv[5]=4): value3=4.000000
sqrt: result=pow(base=10.000000, exponent=0.000000): result=1.000000
sqrt: result=pow10(exponent=0.000000): result=1.000000
sqrt: result=sqrt(value1=2.000000): result=1.414214
sqrt: result=cbrt(value1=2.000000): result=1.259921
sqrt: result=hypot(value2=3.000000, value3=4.000000): result=5.000000

sqrt: base=atof(argv[1]=10): base=10.000000
sqrt: exponent=atof(argv[2]=1): exponent=1.000000
sqrt: value1=atof(argv[3]=4): value1=4.000000
sqrt: value2=atof(argv[4]=3): value2=3.000000
sqrt: value3=atof(argv[5]=4): value3=4.000000
sqrt: result=pow(base=10.000000, exponent=1.000000): result=10.000000
sqrt: result=pow10(exponent=1.000000): result=10.000000
sqrt: result=sqrt(value1=4.000000): result=2.000000
sqrt: result=cbrt(value1=4.000000): result=1.587401
sqrt: result=hypot(value2=3.000000, value3=4.000000): result=5.000000

sqrt: base=atof(argv[1]=10): base=10.000000
sqrt: exponent=atof(argv[2]=2): exponent=2.000000
sqrt: value1=atof(argv[3]=8): value1=8.000000
sqrt: value2=atof(argv[4]=3): value2=3.000000
sqrt: value3=atof(argv[5]=4): value3=4.000000
sqrt: result=pow(base=10.000000, exponent=2.000000): result=100.000000
sqrt: result=pow10(exponent=2.000000): result=100.000000
sqrt: result=sqrt(value1=8.000000): result=2.828427
sqrt: result=cbrt(value1=8.000000): result=2.000000
sqrt: result=hypot(value2=3.000000, value3=4.000000): result=5.000000

sqrt: base=atof(argv[1]=10): base=10.000000
sqrt: exponent=atof(argv[2]=5): exponent=5.000000
sqrt: value1=atof(argv[3]=16): value1=16.000000
sqrt: value2=atof(argv[4]=6): value2=6.000000
sqrt: value3=atof(argv[5]=8): value3=8.000000
sqrt: result=pow(base=10.000000, exponent=5.000000): result=100000.000000
sqrt: result=pow10(exponent=5.000000): result=100000.000000
sqrt: result=sqrt(value1=16.000000): result=4.000000
sqrt: result=cbrt(value1=16.000000): result=2.519842
sqrt: result=hypot(value2=6.000000, value3=8.000000): result=10.000000

sqrt: base=atof(argv[1]=2): base=2.000000
sqrt: exponent=atof(argv[2]=0): exponent=0.000000
sqrt: value1=atof(argv[3]=64): value1=64.000000
sqrt: value2=atof(argv[4]=6): value2=6.000000
sqrt: value3=atof(argv[5]=8): value3=8.000000
sqrt: result=pow(base=2.000000, exponent=0.000000): result=1.000000
sqrt: result=pow10(exponent=0.000000): result=1.000000
sqrt: result=sqrt(value1=64.000000): result=8.000000
sqrt: result=cbrt(value1=64.000000): result=4.000000
sqrt: result=hypot(value2=6.000000, value3=8.000000): result=10.000000

sqrt: base=atof(argv[1]=2): base=2.000000
sqrt: exponent=atof(argv[2]=1): exponent=1.000000
sqrt: value1=atof(argv[3]=10): value1=10.000000
sqrt: value2=atof(argv[4]=6): value2=6.000000
sqrt: value3=atof(argv[5]=8): value3=8.000000
sqrt: result=pow(base=2.000000, exponent=1.000000): result=2.000000
sqrt: result=pow10(exponent=1.000000): result=10.000000
sqrt: result=sqrt(value1=10.000000): result=3.162278
sqrt: result=cbrt(value1=10.000000): result=2.154435
sqrt: result=hypot(value2=6.000000, value3=8.000000): result=10.000000

sqrt: base=atof(argv[1]=2): base=2.000000
sqrt: exponent=atof(argv[2]=2): exponent=2.000000
sqrt: value1=atof(argv[3]=100): value1=100.000000
sqrt: value2=atof(argv[4]=6): value2=6.000000
sqrt: value3=atof(argv[5]=8): value3=8.000000
sqrt: result=pow(base=2.000000, exponent=2.000000): result=4.000000
sqrt: result=pow10(exponent=2.000000): result=100.000000
sqrt: result=sqrt(value1=100.000000): result=10.000000
sqrt: result=cbrt(value1=100.000000): result=4.641589
sqrt: result=hypot(value2=6.000000, value3=8.000000): result=10.000000

sqrt: base=atof(argv[1]=2): base=2.000000
sqrt: exponent=atof(argv[2]=10): exponent=10.000000
sqrt: value1=atof(argv[3]=1000): value1=1000.000000
sqrt: value2=atof(argv[4]=6): value2=6.000000
sqrt: value3=atof(argv[5]=8): value3=8.000000
sqrt: result=pow(base=2.000000, exponent=10.000000): result=1024.000000
sqrt: result=pow10(exponent=10.000000): result=10000000000.000000
sqrt: result=sqrt(value1=1000.000000): result=31.622777
sqrt: result=cbrt(value1=1000.000000): result=10.000000
sqrt: result=hypot(value2=6.000000, value3=8.000000): result=10.000000

sqrt: base=atof(argv[1]=1.414213562373095049): base=1.414214
sqrt: exponent=atof(argv[2]=2): exponent=2.000000
sqrt: value1=atof(argv[3]=10000): value1=10000.000000
sqrt: value2=atof(argv[4]=6): value2=6.000000
sqrt: value3=atof(argv[5]=8): value3=8.000000
sqrt: result=pow(base=1.414214, exponent=2.000000): result=2.000000
sqrt: result=pow10(exponent=2.000000): result=100.000000
sqrt: result=sqrt(value1=10000.000000): result=100.000000
sqrt: result=cbrt(value1=10000.000000): result=21.544347
sqrt: result=hypot(value2=6.000000, value3=8.000000): result=10.000000

#top srand¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji srand() znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja funkcji srand() jest następująca:

/* Seed the random number generator with the given number.  */
extern void srand (unsigned int __seed) __THROW;

Powiązane:
initstate(), rand(), random(), setstate(), srand(), srandom(),

Opis:

Funkcja srand() inicjuje generator liczb pseudolosowych zarodkiem __seed podanym jako argument wywołania funkcji. Aby przy każdym uruchomieniu programu uzyskac inny zarodek, a tym samym inny ciąg generowanych liczb pseudolosowych można użyć funkcji time() zwracającej liczbę określającą bieżący czas (en.wiki:timestamp).

Argumenty:
unsigned int __seed - zarodek inicjujący generator liczb pseudolosowych.

Zwracana wartość:
Funkcja nie zwraca żadnej wartości.

Example:
zawartość pliku srand1.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	long int value;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
	srand(123);
	value=rand();
	printf("%s: srand(123); value=rand(): value=%ld\n", self, value);
	
	value=rand();
	printf("%s: value=rand(): value=%ld\n", self, value);
	
	value=rand();
	printf("%s: value=rand(): value=%ld\n", self, value);
	
	srand(123456789);
	value=rand();
	printf("%s: srand(123456789); value=rand(): value=%ld\n", self, value);
	
	value=rand();
	printf("%s: value=rand(): value=%ld\n", self, value);
	
	value=rand();
	printf("%s: value=rand(): value=%ld\n", self, value);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/srand1

program wyświetli stosowne informacje o sposobie działania:

srand1: srand(123); value=rand(): value=128959393
srand1: value=rand(): value=1692901013
srand1: value=rand(): value=436085873
srand1: srand(123456789); value=rand(): value=1965102536
srand1: value=rand(): value=1639725855
srand1: value=rand(): value=706684578

a następnie ponownie uruchomić bez argumentów:

/home/local/code/ansiccode/math/srand1

program ponownie wyświetli stosowne informacje o sposobie działania:

srand1: srand(123); value=rand(): value=128959393
srand1: value=rand(): value=1692901013
srand1: value=rand(): value=436085873
srand1: srand(123456789); value=rand(): value=1965102536
srand1: value=rand(): value=1639725855
srand1: value=rand(): value=706684578

Jak widać na powyższym rezultacie program za każdym razem po uruchomieniu wyświetla te same pseudolosowe liczby, wynika to z inicjalizacji generatora liczb pseudolosowych przy każdym uruchomieniu programu tą samą wartością.

Example:
zawartość pliku srand2.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	long int value;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
	srand(time());
	value=rand();
	printf("%s: srand(time()); value=rand(): value=%ld\n", self, value);
	
	value=rand();
	printf("%s: value=rand(): value=%ld\n", self, value);
	
	value=rand();
	printf("%s: value=rand(): value=%ld\n", self, value);
	
	value=rand();
	printf("%s: value=rand(): value=%ld\n", self, value);
	
	value=rand();
	printf("%s: value=rand(): value=%ld\n", self, value);
	
	value=rand();
	printf("%s: value=rand(): value=%ld\n", self, value);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/srand2

program wyświetli stosowne informacje o sposobie działania:

srand2: srand(time()); value=rand(): value=492336238
srand2: value=rand(): value=427691644
srand2: value=rand(): value=742510541
srand2: value=rand(): value=1797911458
srand2: value=rand(): value=900249802
srand2: value=rand(): value=1926635390

a następnie ponownie uruchomić bez argumentów:

/home/local/code/ansiccode/math/srand2

program ponownie wyświetli stosowne informacje o sposobie działania:

srand2: srand(time()); value=rand(): value=968961703
srand2: value=rand(): value=72147412
srand2: value=rand(): value=2061526420
srand2: value=rand(): value=2112417722
srand2: value=rand(): value=1711248011
srand2: value=rand(): value=1824656924

Jak widać na powyższym rezultacie program za każdym razem po uruchomieniu wyświetla już różne pseudolosowe liczby, wynika to z inicjalizacji generatora liczb pseudolosowych przy każdym uruchomieniu programu innym wartością. Należy pamiętać, że aby uzyskać powyższy efekt niezbędne jest uruchamianie programu w odstepach czasowych większych niż jedna sekunda, gdyż funkcja time() zwraca czas w postaci liczby sekund, więc uruchomienie programu dwa razy w tej samej sekundzie spowoduje zwrócenie tych samych liczb pseudolosowych.

#top srandom¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji srandom() znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja funkcji srandom() jest następująca:

/* These are the functions that actually do things.  The `random', `srandom',
   `initstate' and `setstate' functions are those from BSD Unices.
   The `rand' and `srand' functions are required by the ANSI standard.
   We provide both interfaces to the same random number generator.  */
/* Seed the random number generator with the given number.  */
extern void srandom (unsigned int __seed) __THROW;

Powiązane:
initstate(), rand(), random(), setstate(), srand(), srandom(),

Opis:

Funkcja srandom() podobnie jak funkcja srand() inicjuje generator liczb pseudolosowych zarodkiem __seed podanym jako argument wywołania funkcji.

Argumenty:
unsigned int __seed - zarodek inicjujący generator liczb pseudolosowych.

Zwracana wartość:
Funkcja nie zwraca żadnej wartości.

Example:
zawartość pliku srandom1.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	long int value;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* srandom() is not available on this OS platform !!! */
	printf("%s: uname() is not available on this OS platform !!!\n", argv[0]);
#else
	srandom(123);
	value=random();
	printf("%s: srandom(123); value=random(): value=%ld\n", self, value);
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* srandom() is not available on this OS platform !!! */
	printf("%s: uname() is not available on this OS platform !!!\n", argv[0]);
#else
	srandom(123);
	value=random();
	printf("%s: srandom(123); value=random(): value=%ld\n", self, value);
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* srandom() is not available on this OS platform !!! */
	printf("%s: uname() is not available on this OS platform !!!\n", argv[0]);
#else
	srandom(123456);
	value=random();
	printf("%s: srandom(123456); value=random(): value=%ld\n", self, value);
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* srandom() is not available on this OS platform !!! */
	printf("%s: uname() is not available on this OS platform !!!\n", argv[0]);
#else
	srandom(123456);
	value=random();
	printf("%s: srandom(123456); value=random(): value=%ld\n", self, value);
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* srandom() is not available on this OS platform !!! */
	printf("%s: uname() is not available on this OS platform !!!\n", argv[0]);
#else
	srandom(123456789);
	value=random();
	printf("%s: srandom(123456789); value=random(): value=%ld\n", self, value);
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* srandom() is not available on this OS platform !!! */
	printf("%s: uname() is not available on this OS platform !!!\n", argv[0]);
#else
	srandom(123456789);
	value=random();
	printf("%s: srandom(123456789); value=random(): value=%ld\n", self, value);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/srandom1

program wyświetli stosowne informacje o sposobie działania:

srandom1: srandom(123); value=random(): value=128959393
srandom1: srandom(123); value=random(): value=128959393
srandom1: srandom(123456); value=random(): value=1303402199
srandom1: srandom(123456); value=random(): value=1303402199
srandom1: srandom(123456789); value=random(): value=1965102536
srandom1: srandom(123456789); value=random(): value=1965102536

a następnie ponownie uruchomić bez argumentów:

/home/local/code/ansiccode/math/srandom1

program ponownie wyświetli stosowne informacje o sposobie działania:

srandom1: srandom(123); value=random(): value=128959393
srandom1: srandom(123); value=random(): value=128959393
srandom1: srandom(123456); value=random(): value=1303402199
srandom1: srandom(123456); value=random(): value=1303402199
srandom1: srandom(123456789); value=random(): value=1965102536
srandom1: srandom(123456789); value=random(): value=1965102536

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	long int value;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* srandom() is not available on this OS platform !!! */
	printf("%s: srandom() is not available on this OS platform !!!\n", argv[0]);
#else
	srandom(time());
	value=random();
	printf("%s: srandom(time()); value=random(): value=%ld\n", self, value);
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* srandom() is not available on this OS platform !!! */
	printf("%s: srandom() is not available on this OS platform !!!\n", argv[0]);
#else
	value=random();
	printf("%s: value=random(): value=%ld\n", self, value);
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* srandom() is not available on this OS platform !!! */
	printf("%s: srandom() is not available on this OS platform !!!\n", argv[0]);
#else
	value=random();
	printf("%s: value=random(): value=%ld\n", self, value);
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* srandom() is not available on this OS platform !!! */
	printf("%s: srandom() is not available on this OS platform !!!\n", argv[0]);
#else
	value=random();
	printf("%s: value=random(): value=%ld\n", self, value);
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* srandom() is not available on this OS platform !!! */
	printf("%s: srandom() is not available on this OS platform !!!\n", argv[0]);
#else
	value=random();
	printf("%s: value=random(): value=%ld\n", self, value);
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* srandom() is not available on this OS platform !!! */
	printf("%s: srandom() is not available on this OS platform !!!\n", argv[0]);
#else
	value=random();
	printf("%s: value=random(): value=%ld\n", self, value);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/math/srandom2

program wyświetli stosowne informacje o sposobie działania:

srandom2: srandom(time()); value=random(): value=684609247
srandom2: value=random(): value=174485635
srandom2: value=random(): value=844812840
srandom2: value=random(): value=1347188429
srandom2: value=random(): value=845568449
srandom2: value=random(): value=134597906

a następnie ponownie uruchomić bez argumentów:

/home/local/code/ansiccode/math/srandom2

program ponownie wyświetli stosowne informacje o sposobie działania:

srandom2: srandom(time()); value=random(): value=374366397
srandom2: value=random(): value=1055083771
srandom2: value=random(): value=415297268
srandom2: value=random(): value=953684671
srandom2: value=random(): value=1769821789
srandom2: value=random(): value=1675723937

#top tan¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji tan() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji tan() jest następująca:

/* Tangent of X.  */
__MATHCALL (tan,, (_Mdouble_ __x));

Powiązane:
acos(), asin(), atan(), atan2(), cos(), sin(), tan(),

Opis:

Funkcja tan() (tangens) oblicza wartość tangens dla liczby podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której jest obliczany tangens.

Zwracana wartość:
_Mdouble_ - tangens dla wartości podanej jako argument wywołania funkcji.

#top tanh¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji tanh() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji tanh() jest następująca:

/* Hyperbolic tangent of X.  */
__MATHCALL (tanh,, (_Mdouble_ __x));

Powiązane:
acosh(), asinh(), atanh(), cosh(), sinh(), tanh(),

Opis:

Funkcja tanh() (hyperbolic tangens) oblicza wartość tangens hiperboliczny dla liczby podanej jako argument wywołania funkcji.

Argumenty:
_Mdouble_ __x - wartość dla której jest obliczany tangens hiperboliczny.

Zwracana wartość:
_Mdouble_ - tangens hiperboliczny dla wartości podanej jako argument wywołania funkcji.

#top tgamma¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji tgamma() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji tgamma() jest następująca:

/* True gamma function.  */
__MATHCALL (tgamma,, (_Mdouble_));

Powiązane:
erf(), erfc(), gamma(), lgamma(), tgamma(),

Opis:

Funkcja tgamma() (hyperbolic tangens)
$ansiccode-math-tgamma.png$

Argumenty:
_Mdouble_ __x -

Zwracana wartość:
_Mdouble_ -

#top trunc¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org

Deklaracja funkcji trunc() znajduje się w pliku nagłówkowym bits/mathcalls.h.
Deklaracja funkcji trunc() jest następująca:

/* Round X to the integral value in floating-point format nearest but
   not larger in magnitude.  */
__MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));

Powiązane:
ceil(), floor(), llrint(), llround(), lrint(), lround(), nearbyint(), rint(), round(), trunc(),

Opis:

Funkcja trunc() podobnie jak funkcja ceil() zwraca największą możliwą wartość zaokrągloną do wartości całkowitej, jednakże nie wiekszą niż liczba przekazana w argumencie __x (wartość jest zaokrąglana "w dół" do najbliższej wartości całkowitej).

Argumenty:
_Mdouble_ __x - wartość która ma zostać zaokrąglona "w dół" do najbliższej wartości całkowitej.

Zwracana wartość:
_Mdouble_ - wartość zaokrąglona "w dół" do najbliższej wartości całkowitej liczby przekazanej jako argument wywołania.

Zmodyfikowany ostatnio: 2015/10/01 19:46:10 (8 lat temu), textsize: 369 kB, htmlsize: 514 kB

Zapraszam do komentowania, zgłaszania sugestii, propozycji, własnych przykładów, ...

Dodaj komentarzKomentarze użytkowników