Abs

ACos

ASin

ATan

CosH

DToR

Exp

Exponent

Fact

Floor

GetPrec

RToD

SetPrec

Tan

TanH

# Mod()

### MOD()

Return the modulus of two numbers.

Syntax

`      MOD( <nNumber>, <nNumber1> ) -->  <nRemainder>`

Arguments

<nNumber> Numerator in a divisional expression.

<nNumber1> Denominator in a divisional expression.

Returns

<nRemainder> The remainder after the division operation.

Description

This functuion returns the remainder of one number divided by another.

Examples

```      ? Mod( 12, 8.521 )
? Mod( 12, 0 )
? Mod( 62412.5142, 4522114.12014 )```

Compliance

Clipper

Platforms

All

Files

Library is rtl

Seealso

%

# C5_MOD

``` MOD()*
Return the dBASE III PLUS modulus of two numbers
------------------------------------------------------------------------------
Syntax

MOD(<nDividend>, <nDivisor>) --> nRemainder

Arguments

<nDividend> is the dividend of the division operation.

<nDivisor> is the divisor of the division operation.

Returns

MOD() returns a number representing the remainder of <nDividend> divided
by <nDivisor>.

Description

MOD() is a numeric function that emulates the dBASE III PLUS MOD()
function.  It is implemented using the Clipper modulus operator (%).
Note that there are differences between the dBASE III PLUS MOD()
function and the Clipper modulus operator which are described in the
following table:

Differences Between dBASE III PLUS MOD() Function and the
Clipper Modulus Operator
------------------------------------------------------------------------
Dividend     Divisor   Modulus Operator    MOD()     dBASE III PLUS
MOD() function
------------------------------------------------------------------------
3             0            Error          Error           3
3            -2             1             -1             -1
-3             2            -1              1              1
-3             0            Error          Error          -3
-1             3            -1              2              2
-2             3            -2              1              1
2            -3             2             -1             -1
1            -3             1             -2             -2
------------------------------------------------------------------------

MOD() is supplied as a compatibility function and therefore not
recommended.  It is superseded entirely by the modulus operator (%).

Notes

.  Zero divisor in dBASE III PLUS: In dBASE III PLUS, a zero
divisor returns the dividend for every value of the dividend.  In
Clipper, by contrast, the modulus of any dividend using a zero
divisor causes a runtime error.

.  Zero divisor in earlier versions: In versions of Clipper
prior to Summer '87, a modulus operation with a zero divisor returned
zero for all dividends.  In Summer '87 and later versions, it returns
a runtime error.

Files   Library is EXTEND.LIB, source file is SOURCE\SAMPLE\MOD.PRG.```

# C5 Data Manipulation Functions

### Array :

Add a new element to the end of an array

`AADD( <aTarget>, <expValue> ) --> Value`

#### ACLONE() :

Duplicate a nested or multidimensional array

`ACLONE( <aSource> ) --> aDuplicate`

#### ACOPY() :

Copy elements from one array to another

```ACOPY( <aSource>, <aTarget>, [ <nStart> ], [ <nCount> ],
[ <nTargetPos> ] ) --> aTarget```

Delete an array element

`ADEL( <aTarget>, <nPosition> ) --> aTarget`

Fill a series of arrays with directory information

```ADIR([ <cFilespec> ],
[ <aFilenames> ],
[ <aSizes> ],
[ <aTimes> ],
[ <aAttributes> ] ) --> nFiles```

#### AEVAL() :

Execute a code block for each element in an array

`AEVAL( <aArray>, <bBlock>, [ <nStart> ], [ <nCount> ] ) --> aArray`

#### AFILL() :

Fill an array with a specified value

`AFILL( <aTarget>, <expValue>, [ <nStart> ], [ <nCount> ] )`
`       --> aTarget`

#### AINS() :

Insert a NIL element into an array

`AINS( <aTarget>, <nPosition> ) --> aTarget`

#### ARRAY() :

Create an uninitialized array of specified length

`ARRAY( <nElements> [, <nElements>...] ) --> aArray`

#### ASCAN() :

Scan an array for a value or until a block returns (.T.)

`ASCAN( <aTarget>, <expSearch>, [ <nStart> ], [ <nCount> ] )`
`      --> nStoppedAt`

#### ASIZE() :

Grow or shrink an array

`ASIZE( <aTarget>, <nLength> ) --> aTarget`

#### ASORT() :

Sort an array

`ASORT( <aTarget>, [ <nStart> ], [ <nCount> ], [ <bOrder> ] )`
`       --> aTarget`

#### ATAIL() :

Return value of the highest numbered (last) element of an array

`ATAIL( <aArray> ) --> Element`

### Common :

#### EMPTY() :

Determine if the result of an expression is empty

`EMPTY( <exp> ) --> lEmpty`

#### LEN() :

Return the length of a character string or array size

`LEN( <cString> | <aArray> ) --> nCount`

#### MAX() :

Return the larger of two numeric or date values

```MAX( <nExp1>, <nExp2> ) --> nLarger
MAX( <dExp1>, <dExp2> ) --> dLarger```

#### MIN() :

Return the smaller of two numeric or date values

```MIN( <nExp1>, <nExp2> ) --> nSmaller
MIN( <dExp1>, <dExp2> ) --> dSmaller```

Pad character, date or numeric values with a fill character

```PADL( <exp>, <nLength>, [ <cFillChar> ] ) --> cPaddedString

#### TRANSFORM() :

Convert any value into a formatted character string

`TRANSFORM( <exp>, <cSayPicture> ) --> cFormatString`

#### TYPE() :

Determine the type of an expression

`TYPE( <cExp> ) --> cType`

#### VALTYPE() :

Determine the data type returned by an expression

`VALTYPE( <exp> ) --> cType`

### Date & Time :

#### CDOW() :

Convert a date value to a character day of the week

`CDOW( <dExp> ) --> cDayName`

#### CMONTH() :

Convert a date to a character month name

`CMONTH( <dDate> ) --> cMonth`

#### CTOD() :

Convert a date string to a date value

`CTOD( <cDate> ) --> dDate`

#### DATE() :

Return the system date as a date value

`DATE() --> dSystem`

#### DAY() :

Return the day of the month as a numeric value

`DAY( <dDate> ) --> nDay`

#### DOW() :

Convert a date value to a numeric day of the week

`DOW( <dDate> ) --> nDay`

#### DTOC() :

Convert a date value to a character string

`DTOC( <dDate> ) --> cDate`

#### DTOS() :

Convert a date value to a string formatted as yyyymmdd

`DTOS( <dDate> ) --> cDate`

#### MONTH() :

Convert a date value to the number of the month

`MONTH( <dDate> ) --> nMonth`

#### SECONDS() :

Return the number of seconds elapsed since midnight

`SECONDS() --> nSeconds`

#### TIME() :

Return the system time

`TIME() --> cTimeString`

#### YEAR() :

Convert a date value to the year as a numeric value

`YEAR( <dDate> ) --> nYear`

#### ABS() :

Return the absolute value of a numeric expression

`ABS( <nExp> ) --> nPositive`

#### BIN2I() :

Convert a 16-bit signed integer to a numeric value

`BIN2I( <cSignedInt> ) --> nNumber`

#### BIN2L() :

Convert a 32-bit signed integer to a numeric value

`BIN2L( <cSignedInt> ) --> nNumber`

#### BIN2W() :

Convert a 16-bit unsigned integer to a numeric value

`BIN2W( <cUnsignedInt> ) --> nNumber`

#### EXP() :

Calculate e**x

`EXP( <nExponent> ) --> nAntilogarithm`

#### INT() :

Convert a numeric value to an integer

`INT( <nExp> ) --> nInteger`

#### I2BIN() :

Convert a numeric to a 16-bit binary integer

`I2BIN( <nInteger> ) --> cBinaryInteger`

#### LOG() :

Calculate the natural logarithm of a numeric value

`LOG( <nExp> ) --> nNaturalLog`

#### L2BIN() :

Convert a numeric value to a 32-bit binary integer

`L2BIN( <nExp> ) --> cBinaryInteger`

#### MOD()* :

Return dBASE III PLUS modulus of two numbers

`MOD( <nDividend>, <nDivisor> ) --> nRemainder`

#### ROUND() :

Return a value rounded to a specified number of digits

`ROUND( <nNumber>, <nDecimals> ) --> nRounded`

#### SQRT() :

Return the square root of a positive number

`SQRT( <nNumber> ) --> nRoot`

#### VAL() :

Convert a character number to numeric type

`VAL( <cNumber> ) --> nNumber`

### String & Memo :

#### ALLTRIM() :

Remove leading and trailing spaces from character string

`ALLTRIM( <cString> ) --> cTrimString`

#### ASC() :

Convert a character to its ASCII value

`ASC( <cExp> ) --> nCode`

#### AT() :

Return the position of a substring within a string

`AT( <cSearch>, <cTarget> ) --> nPosition`

#### CHR() :

Convert an ASCII code to a character value

`CHR( <nCode> ) --> cChar`

#### HARDCR() :

Replace all soft CRs with hard CRs

`HARDCR( <cString> ) --> cConvertedString`

#### ISALPHA() :

Determine if the leftmost character is alphabetic

`ISALPHA( <cString> ) --> lBoolean`

#### ISDIGIT() :

Determine if the leftmost character is a digit

`ISDIGIT( <cString> ) --> lBoolean`

#### ISLOWER() :

Determine if the leftmost character is a lower case letter

`ISLOWER( <cString> ) --> lBoolean`

#### ISUPPER() :

Determine if the leftmost character is upper case

`ISUPPER( <cString> ) --> lBoolean`

#### LEFT() :

Extract a substring beginning with the first character

`LEFT( <cString>, <nCount> ) --> cSubString`

#### LOWER() :

Convert uppercase characters to lowercase

`LOWER( <cString> ) --> cLowerString`

#### LTRIM() :

Remove leading spaces from a character string

`LTRIM( <cString> ) --> cTrimString`

#### MEMOEDIT() :

Display or edit character strings and memo fields

```MEMOEDIT( [ <cString> ],
[ <nTop> ], [ <nLeft> ],
[ <nBottom> ], [ <nRight> ],
[ <lEditMode> ],
[ <cUserFunction> ],
[ <nLineLength> ],
[ <nTabSize> ],
[ <nTextBufferRow> ],
[ <nTextBufferColumn> ],
[ <nWindowRow> ],
[ <nWindowColumn> ] ) --> cTextBuffer```

#### MEMOLINE() :

Extract a line of text from character string or memo field

```MEMOLINE( <cString>,
[ <nLineLength> ],
[ <nLineNumber> ],
[ <nTabSize> ],
[ <lWrap> ] ) --> cLine```

Return the contents of a disk file as a character string

`MEMOREAD( <cFile> ) --> cString`

#### MEMOTRAN() :

Replace carriage return/line feeds in character strings

```MEMOTRAN( <cString>,
[ <cReplaceHardCR> ],
[ <cReplaceSoftCR> ] ) --> cNewString```

#### MEMOWRIT() :

Write a character string or memo field to a disk file

`MEMOWRIT( <cFile>, <cString> ) --> lSuccess`

#### MLCOUNT() :

Count the lines in a character string or memo field

`MLCOUNT( <cString>, [ <nLineLength> ],  [ <nTabSize> ],`
`         [ <lWrap> ] ) --> nLines`

#### MLCTOPOS() :

Return byte position based on line and column position

```MLCTOPOS( <cText>, <nWidth>, <nLine>,
<nCol>, [ <nTabSize> ], [ <lWrap> ] ) --> nPosition```

#### MLPOS() :

Determine the position of a line in a memo field

```MLPOS( <cString>, <nLineLength>,
<nLine>, [ <nTabSize> ], [ <lWrap> ] ) --> nPosition```

#### MPOSTOLC() :

Return line and column position based on byte position

```MPOSTOLC( <cText>, <nWidth>, <nPos>,
[ <nTabSize> ], [ <lWrap> ] ) --> aLineColumn```

#### RAT() :

Return the position of the last occurrence of a substring

`RAT( <cSearch>, <cTarget> ) --> nPosition`

#### REPLICATE() :

Return a string repeated a specified number of times

`REPLICATE( <cString>, <nCount> ) --> cRepeatedString`

#### RIGHT() :

Return a substring beginning with rightmost character

`RIGHT( <cString>, <nCount> ) --> cSubString`

#### RTRIM() :

Remove trailing spaces from a character string

`RTRIM( <cString> ) --> cTrimString`

#### SET EXACT* :

Toggle exact matches for character strings

`SET EXACT on | OFF | <xlToggle>`

#### SOUNDEX() :

Convert a character string to soundex form

`SOUNDEX( <cString> ) --> cSoundexString`

#### SPACE() :

Return a string of spaces

`SPACE( <nCount> ) --> cSpaces`

#### STR() :

Convert a numeric expression to a character string

`STR( <nNumber>, [ <nLength> ], [ <nDecimals> ] ) --> cNumber`

#### STRTRAN() :

Search and replace characters within a character string

`STRTRAN( <cString>, <cSearch>, [ <cReplace> ],`
`    [ <nStart> ], [ <nCount> ] ) --> cNewString`

#### STUFF() :

Delete and insert characters in a string

`STUFF( <cString>, <nStart>, <nDelete>, <cInsert> ) --> cNewString`

#### SUBSTR() :

Extract a substring from a character string

`SUBSTR( <cString>, <nStart>, [ <nCount> ] ) --> cSubstring`

#### TRIM() :

Remove trailing spaces from a character string

`TRIM( <cString> ) --> cTrimString`

#### UPPER() :

Convert lowercase characters to uppercase

`UPPER( <cString> ) --> cUpperString`