Header comment

Tests if c is alphanumeric.

Tests if c is alphabetic.

Tests if c is within the 7-bit US-ASCII range.

Tests if c is a blank or tab character.

Tests if c is a control character.

Tests if c is a decimal digit.

Tests if c is a printable character excluding the space.

Tests if c is a lowercase letter.

Tests if c is a printable character including the space.

Tests if c is a punctuation character.

Tests if c is a whitespace character.

Tests if c is an uppercase letter.

Converts c to a character in the 7-bit US-ASCII character set.

Converts c to lowercase.

Converts c to uppercase.

double acos(double x);

Calculates the arc cosine of x.

double asin(double x);

Calculates the arc sine of x.

double atan(double x);

Calculates the arc tangent of x.

double atan2(double y, double x);

Calculates the arc tangent of y/x.

double ceil(double x);

Calculates the double value representing the smallest integer that is greater than or equal to x.

double cos(double x);

Calculates the cosine of x.

double cosh(double x);

Calculates the hyperbolic cosine of x.

double erf(double x);

Calculates the error function of x.

double erfc(double x);

Calculates the error function for large values of x.

double exp(double x);

Calculates the exponential function of a floating-point argument x.

double fabs(double x);

Calculates the absolute value of a floating-point argument x.

double floor(double x);

Calculates the floating-point value representing the largest integer less than or equal to x.

double fmod(double x, double y);

Calculates the floating-point remainder of x/y.

double frexp(double x, int *expptr);

Separates a floating-point number into its mantissa and exponent.

double gamma(double x);

Computes the Gamma Function

double hypot(double side1, double side2);

Calculates the hypotenuse of a right-angled triangle with sides of length side1 and side2.

double hypot_wrap(double side1, double side2){
return hypot(side1,side2);
}

double j0(double x);

Calculates the Bessel function value of the first kind of order 0.

double j1(double x);

Calculates the Bessel function value of the first kind of order 1.

double jn(int n, double x);

Calculates the Bessel function value of the first kind of order n.

double ldexp(double x, int exp);

Returns the value of x multiplied by (2 to the power of exp).

double log(double x);

Calculates the natural logarithm of x.

double log10(double x);

Calculates the base 10 logarithm of x.

double modf(double x, double *intptr);

Breaks down the floating-point value x into fractional and integral parts.

double nextafter(double x, double y);

Calculates the next representable value after x in the direction of y.

long double nextafterl(long double x, long double y);

Calculates the next representable value after x in the direction of y.

long double nextafterl_wrap(long double x, long double y){
return nextafterl(x,y);
}

double nexttoward(double x, long double y);

Calculates the next representable value after x in the direction of y.

double nexttoward_wrap(double x, long double y){
return nexttoward(x,y);
}

long double nexttowardl(long double x, long double y);

Calculates the next representable value after x in the direction of y.

long double nexttowardl_wrap(long double x, long double y){
return nexttowardl(x,y);
}

double pow(double x, double y);

Calculates the value x to the power y.

double sin(double x);

Calculates the sine of x.

double sinh(double x);

Calculates the hyperbolic sine of x.

double sqrt(double x);

Calculates the square root of x.

double tan(double x);

Calculates the tangent of x.

double tanh(double x);

Calculates the hyperbolic tangent of x.

double y0(double x);

Calculates the Bessel function value of the second kind of order 0.

double y1(double x);

Calculates the Bessel function value of the second kind of order 1.

double yn(int n, double x);

Calculates the Bessel function value of the second kind of order n.

Reads a single character from stdin.

void perror(const char *string);

Prints an error message to stderr.

int printf(const char *format_string, ...);

Formats and prints characters and values to stdout.

Prints c to stdout.

int puts(const char *string);

Prints a string to stdout.

int remove(const char *filename);

Deletes the file specified by filename.

int rename(const char *oldname, const char *newname);

Renames the specified file.

int rename_wrap(const char *oldname, const char *newname){
return rename(oldname,newname);
}

int scanf(const char *format_string, ...);

Reads data from stdin into locations given by arg-list.

int snprintf(char *outbuf, size_t n, const char*, ...);

Same as sprintf except that the function will stop after n characters have been written to outbuf.

/*
int snprintf_wrap(char *outbuf, size_t n, const char*, ...){
return snprintf(outbuf,n,char*, ...);
}*/

int sprintf(char *buffer, const char *format_string, ...);

Formats and stores characters and values in buffer.

/*
int sprintf_wrap(char *buffer, const char *format_string, ...){
return sprintf(buffer,format_string, ...);
}*/

int sscanf(const char *buffer, const char *format, ...);

int sscanf(const char *buffer, const char *format, ...);

/*
int sscanf_wrap(const char *buffer, const char *format, ...){
return sscanf(buffer,format, ...);
}*/

char *tmpnam(char *string);

Generates a temporary file name.

Stops a program abnormally.

Calculates the absolute value of an integer argument n.

double atof(const char *string);

Converts string to a double-precision floating-point value.

int atoi(const char *string);

Converts string to an integer.

long int atol(const char *string);

Converts string to a long integer.

void *calloc(size_t num, size_t size);

Reserves storage space for an array of num elements, each of size size, and initializes the values of all elements to 0.

void exit(int status);

Ends a program normally.

void free(void *ptr);

Frees a block of storage.

char *getenv(const char *varname);

Searches environment variables for varname.

long int labs(long int n);

Calculates the absolute value of n.

ldiv_t ldiv(long int numerator, long int denominator);

Calculates the quotient and remainder of numerator/denominator.

ldiv_t ldiv_wrap(long int numerator, long int denominator){
return ldiv(numerator,denominator);
}

void *malloc(size_t size);

Reserves a block of storage.

int mblen(const char *string, size_t n);

Determines the length of a multibyte character string.

Returns a pseudo-random integer.

void *realloc(void *ptr, size_t size);

Changes the size of a previously reserved storage block.

void srand(unsigned int seed);

Sets the seed for the pseudo-random number generator.

double strtod(const char *nptr, char **endptr);

Converts nptr to a double precision value.

double strtod_wrap(const char *nptr, char **endptr){
return strtod(nptr,endptr);
}

float strtof(const char *nptr, char **endptr);

Converts nptr to a float value.

float strtof_wrap(const char *nptr, char **endptr){
return strtof(nptr,endptr);
}

long int strtol(const char *nptr, char **endptr, int base);

Converts nptr to a signed long integer.

long int strtol_wrap(const char *nptr, char **endptr, int base){
return strtol(nptr,endptr,base);
}

long double strtold(const char *nptr, char **endptr);

Converts nptr to a long double value.

long double strtold_wrap(const char *nptr, char **endptr){
return strtold(nptr,endptr);
}

unsigned long int strtoul(const char *string1, char **string2, int base);

Converts string1 to an unsigned long integer.

unsigned long int strtoul_wrap(const char *string1, char **string2, int base){
return strtoul(string1,string2,base);
}

int system(const char *string);

Passes string to the system command analyzer.

void *memchr(const void *buf, int c, size_t count);

Searches the first count bytes of buf for the first occurrence of c converted to an unsigned character.

///
/// string.h
///

#include <string.h>

void *memchr_wrap(const void *buf, int c, size_t count){
return memchr(buf,c,count);
}

int memcmp(const void *buf1, const void *buf2, size_t count);

Compares up to count bytes of buf1 and buf2.

int memcmp_wrap(const void *buf1, const void *buf2, size_t count){
return memcmp(buf1,buf2,count);
}

void *memcpy(void *dest, const void *src, size_t count);

Copies count bytes of src to dest.

void *memcpy_wrap(void *dest, const void *src, size_t count){
return memcpy(dest,src,count);
}

void *memmove(void *dest, const void *src, size_t count);

Copies count bytes of src to dest. Allows copying between objects that overlap.

void *memmove_wrap(void *dest, const void *src, size_t count){
return memmove(dest,src,count);
}

void *memset(void *dest, int c, size_t count);

Sets count bytes of dest to a value c.

void *memset_wrap(void *dest, int c, size_t count){
return memset(dest,c,count);
}

char *strcat(char *string1, const char *string2);

Concatenates string2 to string1.

char *strcat_wrap(char *string1, const char *string2){
return strcat(string1,string2);
}

char *strchr(const char *string, int c);

Locates the first occurrence of c in string.

int strcmp(const char *string1, const char *string2);

Compares the value of string1 to string2.

int strcmp_wrap(const char *string1, const char *string2){
return strcmp(string1,string2);
}

int strcoll(const char *string1, const char *string2);

Compares two strings using the collating sequence in the current locale.

int strcoll_wrap(const char *string1, const char *string2){
return strcoll(string1,string2);
}

char *strcpy(char *string1, const char *string2);

Copies string2 into string1.

char *strcpy_wrap(char *string1, const char *string2){
return strcpy(string1,string2);
}

size_t strcspn(const char *string1, const char *string2);

Returns the length of the initial substring of string1 consisting of characters not contained in string2.

size_t strcspn_wrap(const char *string1, const char *string2){
return strcspn(string1,string2);
}

char *strerror(int errnum);

Maps the error number in errnum to an error message string.

size_t strlen(const char *string);

Calculates the length of string.

char *strncat(char *string1, const char *string2, size_t count);

Concatenates up to count characters of string2 to string1.

char *strncat_wrap(char *string1, const char *string2, size_t count){
return strncat(string1,string2,count);
}