iswprint

Indicates if a wide character is classed as a printing character in the program's current locale.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswprint (wint_t wc);

Arguments

wc

An object of type wint_t . The value of wc must be representable as a wchar_t in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

Return Values

nonzero	If a printing character.
0	If not a printing character.

iswpunct

Indicates if a wide character is classed as a punctuation character in the program's current locale.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswpunct (wint_t wc);

Arguments

wc

An object of type wint_t . The value of wc must be representable as a wchar_t in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

Return Values

nonzero	If a punctuation character.
0	If not a punctuation character.

iswspace

Indicates if a wide character is classed as a space character in the program's current locale.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswspace (wint_t wc);

Arguments

wc

An object of type wint_t . The value of wc must be representable as a wchar_t in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

Return Values

nonzero	If a whitespace character.
0	If not a whitespace character.

iswupper

Indicates if a wide character is classed as an uppercase character in the program's current locale.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswupper (wint_t wc);

Arguments

wc

An object of type wint_t . The value of wc must be representable as a wchar_t in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

Return Values

nonzero	If an uppercase character.
0	If not an uppercase character.

iswxdigit

Indicates if a wide character is a hexadecimal digit (0 to 9, A to F, or a to f) in the program's current locale.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswxdigit (wint_t wc);

Arguments

wc

An object of type wint_t . The value of wc must be representable as a wchar_t in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

Return Values

nonzero	If a hexadecimal digit.
0	If not a hexadecimal digit.

isxdigit

Indicates if a character is a hexadecimal digit (0 to 9, A to F, or a to f) in the program's current locale.

Format

#include <ctype.h>

int isxdigit (int character);

Argument

character

An object of type int . The value of character must be representable as an unsigned char in the current locale, or must equal the value of the macro EOF. If it has any other value, the behavior is undefined.

Return Values

nonzero	If a hexadecimal digit.
0	If not a hexadecimal digit.

j0, j1, jn (ALPHA ONLY)

Compute Bessel functions of the first kind.

Format

#include <math.h>

double j0 (double x);

float j0f (float x);

long double j0l (long double x);

double j1 (double x);

float j1f (float x);

long double j1l (long double x);

double jn (int n, double x);

float jnf (int n, float x);

long double jnl (int n, long double x);

Argument

x

A real value.

n

An integer.

Description

The j0 functions return the value of the Bessel function of the first kind of order 0.

The j1 functions return the value of the Bessel function of the first kind of order 1.

The jn functions return the value of the Bessel function of the first kind of order n.

The j1 and jn functions can result in an underflow as x gets small. The largest value of x for which this occurs is a function of n.

Return Values

x	The relevant Bessel value of x of the first kind.
0	The value of the x argument is too large, or underflow occurred; errno is set to ERANGE.
NaN	x is NaN; errno is set to EDOM.

jrand48

Generate uniformly distributed pseudorandom number sequences. Returns 48-bit signed, long integers.

Format

#include <stdlib.h>

long int jrand48 (unsigned short int xsubi[3]);

Arguments

xsubi

An array of three short int that form a 48-bit integer when concatentated together.

Description

This function generates pseudorandom numbers using the linear congruential algorithm and 48-bit integer arithmetic.

The function returns signed long integers uniformly distributed over the range of y values, such that -2³¹ <= y < 2³¹ .

The function works by generating a sequence of 48-bit integer values, Xi, according to the linear congruential formula:

Xn+1 = (aXn+c)mod m n >= 0

The argument m equals 2⁴⁸ , so 48-bit integer arithmetic is performed. Unless you invoke the lcong48 function, the multiplier value a and the addend value c are:

a = 5DEECE66D16 = 2736731631558 c = B16 = 138

The jrand48 function requires that the calling program pass an array as the xsubi argument, which for the first call must be initialized to the initial value of the pseudorandom number sequence. Unlike the drand48 function, it is not necessary to call an initialization function prior to the first call.

By using different arguments, jrand48 allows separate modules of a large program to generate several independent sequences of pseudorandom numbers. For example, the sequence of numbers that one module generates does not depend upon how many times the function is called by other modules.

Return Values

n	Signed, long integers uniformly distributed over the range -2 31 <= y < 2 31 .

kill

Sends a signal to the process specified by a process ID.

Format

#include <signal.h>

int kill (int pid, int sig);

Arguments

pid

The process ID.

sig

The signal code.

Description

This function is restricted to C and C++ programs that include the main function.

The kill function sends a signal to a process, as if the process had called raise . If the signal is not trapped or ignored by the target program, the program exits.

OpenVMS VAX and Alpha implement different rules about what process you are allowed to send signals to. A program always has privileges to send a signal to a child started with vfork / exec . For other processes, the results are determined by the OpenVMS security model for your system.

Because of an OpenVMS restriction, the kill function cannot deliver a signal to a target process that runs an image installed with privileges.

Unless you have system privileges, the sending and receiving processes must have the same user identification code (UIC).

On OpenVMS systems before Version 7.0, kill treats a signal value of 0 as if SIGKILL were specified.

For OpenVMS Version 7.0 and higher systems, if you include <stdlib.h> and compile with the _POSIX_EXIT feature-test macro set, then:

• If the signal value is 0, kill validates the process ID but does not send any signals.
• If the process ID is not valid, kill returns --1 and sets errno to ESRCH.

Return Values

0	Indicates that kill was successfully queued.
--1	Indicates errors. The receiving process may have a different UIC and you are not a system user, or the receiving process does not exist.

labs

Returns the absolute value of an integer as a long int .

Format

#include <stdlib.h>

long int labs (long int j);

Argument

j

A value of type long int .

lcong48

Initializes a 48-bit uniformly distributed pseudorandom number sequences.

Format

#include <stdlib.h>

void lcong48 (unsigned short int param[7]);

Arguments

param

An array that in turn specifies the initial Xi, the multiplier value a, and the addend value c.

Description

This function generates pseudorandom numbers using the linear congruential algorithm and 48-bit integer arithmetic.

You can use lcong48 to initialize the random number generator before you call any of the following functions:

drand48
lrand48
mrand48

The lcong48 function specifies the initial Xi value, the multiplier value a, and the addend value c. The param array elements specify the following:

param[0-2]	Xi
param[3-5]	Multiplier a value
param[6]	16-bit addend c value

After lcong48 has been called, a subsequent call to either srand48 or seed48 restores the standard a and c as specified previously.

The lcong48 function does not return a value.

See also drand48 , lrand48 , mrand48 , srand48 , and seed48 in this section.

ldexp

Returns its first argument multiplied by 2 raised to the power of its second argument; that is, x(2ⁿ) .

Format

#include <math.h>

double ldexp (double x, int n);

float ldexp (float x, int n); (ALPHA ONLY)

long double ldexp (long double x, int n); (ALPHA ONLY)

Arguments

x

A base value of type double , float , or long double that is to be multiplied by 2ⁿ .

n

The integer exponent value to which 2 is raised.

Return Values

x(2 n)	The first argument multiplied by 2 raised to the power of the second argument.
0	Underflow occurred; errno is set to ERANGE.
HUGE_VAL	Overflow occurred; errno is set to ERANGE.
Nan	x is NaN; errno is set to EDOM.

ldiv

Returns the quotient and the remainder after the division of its arguments.

Format

#include <stdlib.h>

ldiv_t ldiv (long int numer, long int denom);

Arguments

numer

A numerator of type long int .

denom

A denominator of type long int .

Description

The type ldiv_t is defined in the <stdlib.h> header file as follows:

typedef struct { long quot, rem; } ldiv_t;

See also div in this section.

leaveok

Signals Curses to leave the cursor at the current coordinates after an update to the window.

Format

#include <curses.h>

leaveok (WINDOW *win, bool boolf);

Arguments

win

A pointer to the window.

boolf

A Boolean TRUE or FALSE value. If boolf is TRUE, the cursor remains in place after the last update and the coordinate setting on win changes accordingly. If boolf is FALSE, the cursor moves to the currently specified (y,x) coordinates of win.

Description

This function defaults to moving the cursor to the current coordinates of win. The bool type is defined in the <curses.h> header file as follows:

#define bool int

lgamma (ALPHA ONLY)

Computes the logarithm of the gamma function.

Format

#include <math.h>

double lgamma (double x);

float lgammaf (float x);

long double lgammal (long double x);

Argument

x

A real number. x cannot be 0, a negative integer, or Infinity.

Description

The lgamma functions return the logarithm of the absolute value of gamma of x, or ln(|G(x)|), where G is the gamma function.

The sign of gamma of x is returned in the external integer variable signgam . The x argument cannot be 0, a negative integer, or Infinity.

Return Values

x	The logarithmic gamma of the x argument.
-HUGE_VAL	The x argument is a negative integer; errno is set to ERANGE.
NaN	The x argument is NaN; errno is set to EDOM.
0	Underflow occurred; errno is set to ERANGE.
HUGE_VAL	Overflow occurred; errno is set to ERANGE.

link

Creates a new link (directory entry) for an existing file. This function is supported only on volumes that have hard link counts enabled.

Format

#include <unistd.h>

link (const char *path1, const char *path2);

Arguments

path1

Pointer to a path name naming an existing file.

path2

Pointer to a path name naming the new directory entry to be created.

Description

The link function atomically creates a new link for the existing file, and the link count of the file is incremented by one.

The link function can be used on directory files.

If link fails, no link is created and the link count of the file remains unchanged.

Return Values

0

Successful completion.

--1

Indicates an error. The function sets errno to one of the following values: EEXIST -- The link named by path2 exists. EFTYPE -- Wildcards appear in either path1 or path2. EINVAL -- One or both arguments specify a syntactically invalid path name. ENAMETOOLONG -- The length of path1 or path2 exceeds {PATH_MAX}, or a path name component is longer than {NAME_MAX}. EXDEV -- The link named by path2 and the file named by path1 are on different devices.

localeconv

Sets the members of a structure of type struct lconv with values appropriate for formatting numeric quantities according to the rules of the current locale.

Format

#include <locale.h>

struct lconv *localeconv (void);

Description

This function returns a pointer to the lconv structure defined in the <locale.h> header file. This structure should not be modified by the program. It is overwritten by calls to localeconv , or by calls to the setlocale function that change the LC_NUMERIC, LC_MONETARY, or LC_ALL categories.

The members of the structure are:

Member	Description
char *decimal_point	The radix character
char *thousands_sep	The character used to separate groups of digits
char *grouping	The string that defines how digits are grouped in non-monetary values.
char *int_curr_symbol	The international currency symbol
char *currency_symbol	The local currency symbol
char *mon_decimal_point	The radix character used to format monetary values
char *mon_thousands_sep	The character used to separate groups of digits in monetary values
char *mon_grouping	The string that defines how digits are grouped in a monetary value
char *positive_sign	The string used to indicate a non-negative monetary value
char *negative_sign	The string used to indicate a negative monetary value
char int_frac_digits	The number of digits displayed after the radix character in a monetary value formatted with the international currency symbol.
char frac_digits	The number of digits displayed after the radix character in a monetary value
char p_cs_precedes	For positive monetary values, this is set to 1 if the local or international currency symbol precedes the number, and it is set to 0 if the symbol succeeds the number.
char p_sep_by_space	For positive monetary values, this is set to 0 if there is no space between the currency symbol and the number. It is set to 1 if there is a space, and it is set to 2 if there is a space between the symbol and the sign string.
char n_cs_precedes	For negative monetary values, this is set to 1 if the local or international currency symbol precedes the number, and it is set to 0 if the symbol succeeds the number.
char n_sep_by_space	For negative monetary values, this is set to 0 if there is no space between the currency symbol and the number. It is set to 1 if there is a space, and it is set to 2 if there is a space between the symbol and the sign string.
char p_sign_posn	An integer used to indicate where the positive_sign string should be placed for a non-negative monetary quantity.
char n_sign_posn	An integer used to indicate where the negative_sign string should be placed for a negative monetary quantity.

Members of the structure of type char * are pointers to strings, any of which (except decimal_point) can point to "", indicating that the associated value is not available in the current locale or is zero length. Members of the structure of type char are positive numbers, any of which can be CHAR_MAX, indicating that the associated value is not available in the current locale. CHAR_MAX is defined in the <limits.h> header file.

Be aware that the value of the CHAR_MAX macro in the <limits.h> header depends on whether the program is compiled with the /UNSIGNED_CHAR qualifier:

• Use the CHAR_MAX macro as an indicator of a non-available value in the current locale only if the program is compiled without /UNSIGNED_CHAR (/NOUNSIGNED_CHAR is the default).
• If the program is compiled with /UNSIGNED_CHAR, use the SCHAR_MAX macro instead of the CHAR_MAX macro.

---

Previous

Next

Contents

Index