Character Functions

Reinterpret binary data as a Unicode string.

a binary large object.

encoding

Optional quoted string that specifies an encoding. The default encoding for the character string is utf-8. utf-16le, utf-16be, us-ascii, iso-8859-1, ascii-hex, shift-jis, and euc-jp are also supported.

Blob To Matrix(blob, "type", bytes, "endian", <nCols>)

The optional argument ascii is intended to make conversions of blobs containing normal ASCII data simpler when the data might contain CR, LF, or TAB characters (for example) and those characters do not need any special attention.

Creates a matrix by converting each byte in the blob to numbers.

A matrix that represents the blob.

A blob or reference to a blob.

blob

type

A quoted string that contains the named type of number. The options are int, uint, or float.

bytes

Byte size of the data in the blob. Options are 1, 2, 4, or 8.

endian

A quoted string that contains a named type that indicates whether the first byte is the most significant. Options are as follows:

–	"big" indicates that the first byte is the most significant.

–	"little" indicates that the first byte is the least significant.

–	"native" indicates that the machine’s native format should be used.

nCols

Optional. Specify the number of columns in the matrix. The default value is 1.

Char(x, <width>, <decimal>)

Converts an expression or numeric value into a character string.

A string.

optional number that sets the maximum number of characters in the string.

an expression or a numeric value. An expression must be quoted with Expr(). Otherwise, its evaluated value is converted to a string.

width

decimal

optional number that sets the maximum number of places after the decimal that is included in the string.

The width argument overrides the decimal argument.

Char To Blob(string, <"encoding">)

Char( Pi(), 10, 4)

"3.1416"

Char( Pi(), 3, 4)

"3.1"

Converts a string of characters into a binary (blob).

Quoted string or a reference to a string.

encoding

Optional quoted string that specifies an encoding. The default encoding for the blob is utf-8. utf-16le, utf-16be, us-ascii, iso-8859-1, ascii-hex, shift-jis, and euc-jp are also supported.

Char To Hex(value, <"integer" | "encoding">)

Converting BLOBS into printable format escapes \ (in addition to ~ " ! and characters outside of the printable ASCII range) into hex notation (~5C for the backslash character).

x = Char To Blob( "abc\def\!n" );

y = Blob To Char( x, encoding = "ASCII~HEX" );

If(

	y == "abc~5Cdef~0A", "JMP 12.2 and later behavior",

	y == "abc\def~0A", "Pre-JMP 12.2 behavior"

);

"JMP 12.2 and later behavior" // output

Hex(value, <"integer" | "encoding">)

Converts the given value and encoding into its hexadecimal representation.

A hexadecimal string.

Any number, quoted string, or blob.

value

integer

Switch that causes the value to be interpreted as an integer.

encoding

Optional quoted string that specifies an encoding. The default encoding is utf-8. utf-16le, utf-16be, us-ascii, iso-8859-1, ascii-hex, shift-jis, and euc-jp are also supported.

Collapse Whitespace("text")

For matrices: Horizontal concatenation of two matrices, A and B.

Trims leading and trailing whitespace and replaces interior whitespace with a single space. That is, if more than one white space character is present, the Collapse Whitespace function replaces the two spaces with one space.

For strings: Appends the string b to the string a. Neither argument is changed.

For lists: Appends the list b to the list a. Neither argument is changed.

For strings: A string composed of the string a directly followed by the string b.

For lists: A list composed of the list a directly followed by the list b.

For matrices: A matrix.

Two or more strings, string variables, lists, or matrices.

More than two arguments can be strung together. Each additional string is appended to the end, in left to right order. Each additional matrix is appended in left to right order.

See Concat Items({string1, string2, ...}, <delimiter>}).

a = "Hello"; b = " "; c = "World"; a || b || c;

"Hello World"

d = {"apples", "bananas"}; e = {"peaches", "pears"}; Concat( d, e );

{"apples", "bananas", "peaches", "pears"}

A = [1 2 3]; B = [4 5 6]; Concat( A, B );

[1 2 3 4 5 6]

Concat Items

For strings: Appends the string b to the string a and places the new concatenated string into a.

For matrices: Appends the matrix b to the matrix a and places the new concatenated matrix into a.

For strings: A string composed of the string a directly followed by the string b.

For matrices: A matrix.

Two or more strings, string variables, or matrices. The first variable must be a variable whose value can be changed.

More than two arguments can be strung together. Each additional string or matrix is appended to the end, in left to right order.

Contains(whole, part, <start>)

a = "Hello"; b = " "; c = "World"; Concat To( a, b, c ); Show( a );

a = "Hello World"

A = [1 2 3]; B = [4 5 6]; Concat To( A, B ); Show( A );

A = [1 2 3 4 5 6];

Determines whether part is contained within whole.

If part is found: For lists, strings, and namespaces, the numeric position where the first occurrence of part is located. For associative arrays, 1.

If part is not found, 0 is returned in all cases.

A string, list, namespace, or associative array.

whole

part

For a string or namespace, a string that can be part of the string whole. For a list, an item that can be an item in the list whole. For an associative array, a key that can be one of the keys in the map whole.

start

An optional numeric argument that specifies a starting point. within whole. If start is negative, contains searches whole for part backwards, beginning with the position specified by the length of whole – start. Note that start is meaningless for associative arrays and is ignored.

The example returns a 1 because “Katie” is the first item in the list.

nameList={"Katie", "Louise", "Jane", "Jaclyn"};

r = Contains(nameList, "Katie");

Contains Item(x, <item | list | pattern>, <delimiter>)

Identifies multiple responses by searching for the specified item, list, pattern, or delimiter. The function can be used on columns with the Multiple Response modeling type or column property.

Returns a Boolean that indicates whether the word (item), one of a list of words (list), or pattern (pattern) matches one of the words in the text represented by x. Words are delimited by the characters in the optional delimiter (delimiter) string. A comma, ",", character is the default delimiter. Blanks are trimmed from the ends of each extracted word from the input text string (x).

Ends With(string, substring)

The following example searches for “pots” followed by a comma and then outputs the result.

x = "Franklin Garden Supply is a leading online store featuring garden decor, statues, pots, shovels, benches, and much more.";

b = Contains Item( x, "pots", "," );

If( b,

	Write( "The specified items were found."  ), "No match."

);

The specified items were found.

Determines whether substring appears at the end of string.

1 if string ends with substring, otherwise 0.

A quoted string or a string variable. Can also be a list.

string

substring

A quoted string or a string variable. Can also be a list.

Equivalent Expression

Right(string, Length(substring)) == substring

Hex(value, <"integer" | encoding="enc")

See Char To Hex(value, <"integer" | "encoding">).

Hex To Blob(string)

Converts the quoted hexadecimal string (including whitespace characters) to a blob (binary large object).

Hex To Char(string, <encoding>)

Hex To Blob( "4A4D50" );

Char To Blob("JMP", "ascii~hex")

Converts the quoted hexadecimal string to its character equivalent.

Hex To Char( "30" ) results in “0”.

The default encoding for character string is utf-8. utf-16le, utf-16be, us-ascii, iso-8859-1, ascii-hex, shift-jis, and euc-jp are also supported.

Hex To Number(string)

Converts the quoted hexadecimal string to its integer or its floating number equivalent.

Hex To Number( "80" );

16-digit hexadecimal numbers are converted as IEEE 754 64-bit floating point numbers.

Whitespace between bytes (or pairs of digits) and in the middle of bytes is permitted (for example, FF 1919 and F F1919).

Insert

See Insert(source, item, <position>).

Insert Into

See Insert Into(source, item, <position>).

Item(n, string, <delimiters>)

Extracts the nth word from a quoted string according to the quoted string delimiters given. The default delimiter is space. If you include a third argument, any and all characters in that argument are taken to be delimiters.

Left(string, n, <filler>)

Item() is the same as Word() except that Item() treats each delimiter character as a separate delimiter, and Word() treats several adjacent delimiters as a single delimiter.

Item( 4,"the quick, brown fox", ", " );

"brown"

Word( 4,"the quick, brown fox", ", " );

"fox"

Left(list, n, <filler>)

Returns a truncated or padded version of the original string or list. The result contains the left n characters or list items, padded with any filler on the right if the length of string is less than n.

Length(string)

Calculates the number of characters (length) of the quoted string.

Lowercase(string)

Munger(string, offset, find|length)

Converts any upper case character found in quoted string to the equivalent lowercase character.

Munger(string, offset, find, replace)

Computes new character strings from the quoted string by inserting or deleting characters. It can also produce substrings, calculate indexes, and perform other tasks depending on how you specify its arguments.

Offset is a numeric expression indicating the starting position to search in the string. If the offset is greater than the position of the first instance of the find argument, the first instance is disregarded. If the offset is greater than the search string’s length, Munger uses the string’s length as the offset.

Num(string)

Converts a character string into a number.

Regex("source", "pattern", (<replacementString>, <GLOBALREPLACE>), <format>, <IGNORECASE>)

Searches for the pattern within the source string.

The matched text as a string or numeric missing if there was no match.

A quoted regular expression.

format

Optional. A backreference to the capturing group. The default is /0, which is the entire matched string. /n returns the nth match.

IGNORECASE

Optional. The search is case sensitive, unless you specify IGNORECASE.

GLOBALREPLACE

Optional with a replacement string. Applies the regular expression to the source string repeatedly until all matches are found.

Remove

See Remove(source, position, <n>).

Remove From

See Remove From(source, position, <n>).

Repeat(source, a)

Repeat(matrix, a, b)

See Reverse Into(source).

Returns a copy of source concatenated with itself a times. Or returns a matrix composed of a row repeats and b column repeats. The source can be text, a matrix, or a list.

Reverse

See Reverse(source).

Reverse Into

Right(string, n, <filler>)

Right(list, n, <filler>)

See Shift Into(source, <n>).

Returns a truncated or padded version of the original string or list. The result contains the right n characters or list items, padded with any filler on the left if the length of string is less than n.

Shift

See Shift(source, <n>).

Shift Into

Starts With(string, substring)

Determines whether substring appears at the start of string.

1 if string starts with substring, otherwise 0.

A quoted string or a reference to one. Can also be a list.

string

substring

A quoted string or a reference to one. Can also be a list.

Equivalent Expression

Left(string, Length(substring)) = = substring

Substitute

See Substitute(string, substring, replacementString, ...).

Substitute Into

See Substitute Into(string, substring, replacementString, ...).

Substr(string, start, length)

Extracts the characters that are the portion of the first argument beginning at the position given by the second argument and ending based on the number of characters specified in the third argument. The first argument can be a character column or value, or an expression evaluating to same. The starting argument and the length argument can be numbers or expressions that evaluate to numbers.

This example extracts the first name:

Substr( "Katie Layman", 1, 5 );

The function starts at position 1, reads through position 5, and ignores the remaining characters, which yields “Katie.”

Titlecase("text")

Converts the string to title case, that is, each word in the string has an initial uppercase character and subsequent lowercase characters.

For example, the following function:

Titlecase( "veronica layman ")

returns the following string:

"Veronica Layman"

Trim("text",<left|right|both>)

Trim Whitespace("text",<left|right|both>)

Removes leading and trailing whitespace.

The second argument determines if whitespace is removed from the left, the right, or both ends of the string. If no second argument is used, whitespace is removed from both ends.

For example, the following command:

Trim( "  John    ", both )

returns the following string:

"John"

Uppercase(string)

Word(n, "text", <"delimiters">)

Converts any lower case character found in the quoted string to the equivalent uppercase character.

This example returns the last name:

Extracts the nth word from a character string according to the delimiters given. The default delimiter is space. If you include a third argument, any and all characters in that argument are taken to be delimiters.

Examples

Word( 2, "Katie Layman" );

See Words("text", <"delimiters">).

Word() is the same as Item(), except that Item() treats each delimiter character as a separate delimiter, and Word() treats several adjacent delimiters as a single delimiter.

Item( 4,"the quick brown fox" );

"brown"

Word( 4,"the quick brown fox" );

"fox"

Words

XPath Query( xml, "xpath_expression")

Runs an XPath expression on an XML document.

A valid XML document.

xpath_expression

A quoted XPath 1.0 expression.