In a dynamic expression, you can make the pattern that you want `regexp`

to match dependent on the content of the input text. In this way, you can more closely match varying input patterns in the text being parsed. You can also use dynamic expressions in replacement terms for use with the `regexprep`

function. This gives you the ability to adapt the replacement text to the parsed input.

You can include any number of dynamic expressions in the `match_expr`

or `replace_expr`

arguments of these commands:

regexp(text, match_expr) regexpi(text, match_expr) regexprep(text, match_expr, replace_expr)

As an example of a dynamic expression, the following `regexprep`

command correctly replaces the term `internationalization`

with its abbreviated form, `i18n`

. However, to use it on a different term such as `globalization`

, you have to use a different replacement expression:

match_expr = '(^\w)(\w*)(\w$)'; replace_expr1 = '$118$3'; regexprep('internationalization', match_expr, replace_expr1)

ans = 'i18n'

replace_expr2 = '$111$3'; regexprep('globalization', match_expr, replace_expr2)

ans = 'g11n'

Using a dynamic expression `${num2str(length($2))}`

enables you to base the replacement expression on the input text so that you do not have to change the expression each time. This example uses the dynamic replacement syntax `${cmd}`

.

match_expr = '(^\w)(\w*)(\w$)'; replace_expr = '$1${num2str(length($2))}$3'; regexprep('internationalization', match_expr, replace_expr)

ans = 'i18n'

```
regexprep('globalization', match_expr, replace_expr)
```

ans = 'g11n'

When parsed, a dynamic expression must correspond to a complete, valid regular expression. In addition, dynamic match expressions that use the backslash escape character (`\`

) require two backslashes: one for the initial parsing of the expression, and one for the complete match. The parentheses that enclose dynamic expressions do *not* create a capturing group.

There are three forms of dynamic expressions that you can use in match expressions, and one form for replacement expressions, as described in the following sections

The `(??expr)`

operator parses expression `expr`

, and inserts the results back into the match expression. MATLAB^{®} then evaluates the modified match expression.

Here is an example of the type of expression that you can use with this operator:

chr = {'5XXXXX', '8XXXXXXXX', '1X'}; regexp(chr, '^(\d+)(??X{$1})$', 'match', 'once');

The purpose of this particular command is to locate a series of `X`

characters in each of the character vectors stored in the input cell array. Note however that the number of `X`

s varies in each character vector. If the count did not vary, you could use the expression `X{n}`

to indicate that you want to match `n`

of these characters. But, a constant value of `n`

does not work in this case.

The solution used here is to capture the leading count number (e.g., the `5`

in the first character vector of the cell array) in a token, and then to use that count in a dynamic expression. The dynamic expression in this example is `(??X{$1})`

, where `$1`

is the value captured by the token `\d+`

. The operator `{$1}`

makes a quantifier of that token value. Because the expression is dynamic, the same pattern works on all three of the input vectors in the cell array. With the first input character vector, `regexp`

looks for five `X`

characters; with the second, it looks for eight, and with the third, it looks for just one:

regexp(chr, '^(\d+)(??X{$1})$', 'match', 'once')

ans = 1×3 cell array {'5XXXXX'} {'8XXXXXXXX'} {'1X'}

MATLAB uses the `(??@cmd)`

operator to include the results of a MATLAB command in the match expression. This command must return a term that can be used within the match expression.

For example, use the dynamic expression `(??@flilplr($1))`

to locate a palindrome, “Never Odd or Even”, that has been embedded into a larger character vector.

First, create the input string. Make sure that all letters are lowercase, and remove all nonword characters.

chr = lower(... 'Find the palindrome Never Odd or Even in this string'); chr = regexprep(chr, '\W*', '')

chr = 'findthepalindromeneveroddoreveninthisstring'

Locate the palindrome within the character vector using the dynamic expression:

palindrome = regexp(chr, '(.{3,}).?(??@fliplr($1))', 'match')

palindrome = 1×1 cell array {'neveroddoreven'}

The dynamic expression reverses the order of the letters that make up the character vector, and then attempts to match as much of the reversed-order vector as possible. This requires a dynamic expression because the value for `$1`

relies on the value of the token `(.{3,})`

.

Dynamic expressions in MATLAB have access to the currently active workspace. This means that you can change any of the functions or variables used in a dynamic expression just by changing variables in the workspace. Repeat the last command of the example above, but this time define the function to be called within the expression using a function handle stored in the base workspace:

fun = @fliplr; palindrome = regexp(chr, '(.{3,}).?(??@fun($1))', 'match')

palindrome = 1×1 cell array {'neveroddoreven'}

The `(?@cmd)`

operator specifies a MATLAB command that `regexp`

or `regexprep`

is to run while parsing the overall match expression. Unlike the other dynamic expressions in MATLAB, this operator does not alter the contents of the expression it is used in. Instead, you can use this functionality to get MATLAB to report just what steps it is taking as it parses the contents of one of your regular expressions. This functionality can be useful in diagnosing your regular expressions.

The following example parses a word for zero or more characters followed by two identical characters followed again by zero or more characters:

regexp('mississippi', '\w*(\w)\1\w*', 'match')

ans = 1×1 cell array {'mississippi'}

To track the exact steps that MATLAB takes in determining the match, the example inserts a short script `(?@disp($1))`

in the expression to display the characters that finally constitute the match. Because the example uses greedy quantifiers, MATLAB attempts to match as much of the character vector as possible. So, even though MATLAB finds a match toward the beginning of the string, it continues to look for more matches until it arrives at the very end of the string. From there, it backs up through the letters `i`

then `p`

and the next `p`

, stopping at that point because the match is finally satisfied:

regexp('mississippi', '\w*(\w)(?@disp($1))\1\w*', 'match')

i p p ans = 1×1 cell array {'mississippi'}

Now try the same example again, this time making the first quantifier lazy (`*?`

). Again, MATLAB makes the same match:

regexp('mississippi', '\w*?(\w)\1\w*', 'match')

ans = 1×1 cell array {'mississippi'}

But by inserting a dynamic script, you can see that this time, MATLAB has matched the text quite differently. In this case, MATLAB uses the very first match it can find, and does not even consider the rest of the text:

regexp('mississippi', '\w*?(\w)(?@disp($1))\1\w*', 'match')

m i s ans = 1×1 cell array {'mississippi'}

To demonstrate how versatile this type of dynamic expression can be, consider the next example that progressively assembles a cell array as MATLAB iteratively parses the input text. The `(?!)`

operator found at the end of the expression is actually an empty lookahead operator, and forces a failure at each iteration. This forced failure is necessary if you want to trace the steps that MATLAB is taking to resolve the expression.

MATLAB makes a number of passes through the input text, each time trying another combination of letters to see if a fit better than last match can be found. On any passes in which no matches are found, the test results in an empty character vector. The dynamic script `(?@if(~isempty($&)))`

serves to omit the empty character vectors from the `matches`

cell array:

matches = {}; expr = ['(Euler\s)?(Cauchy\s)?(Boole)?(?@if(~isempty($&)),' ... 'matches{end+1}=$&;end)(?!)']; regexp('Euler Cauchy Boole', expr); matches

matches = 1×6 cell array {'Euler Cauchy Bo…'} {'Euler Cauchy '} {'Euler '} {'Cauchy Boole'} {'Cauchy '} {'Boole'}

The operators `$&`

(or the equivalent `$0`

), `$``

, and `$'`

refer to that part of the input text that is currently a match, all characters that precede the current match, and all characters to follow the current match, respectively. These operators are sometimes useful when working with dynamic expressions, particularly those that employ the `(?@cmd)`

operator.

This example parses the input text looking for the letter `g`

. At each iteration through the text, `regexp`

compares the current character with `g`

, and not finding it, advances to the next character. The example tracks the progress of scan through the text by marking the current location being parsed with a `^`

character.

(The `$``

and `$´`

operators capture that part of the text that precedes and follows the current parsing location. You need two single-quotation marks (`$''`

) to express the sequence `$´`

when it appears within text.)

chr = 'abcdefghij'; expr = '(?@disp(sprintf(''starting match: [%s^%s]'',$`,$'')))g'; regexp(chr, expr, 'once');

starting match: [^abcdefghij] starting match: [a^bcdefghij] starting match: [ab^cdefghij] starting match: [abc^defghij] starting match: [abcd^efghij] starting match: [abcde^fghij] starting match: [abcdef^ghij]

The `${cmd}`

operator modifies the contents of a regular expression replacement pattern, making this pattern adaptable to parameters in the input text that might vary from one use to the next. As with the other dynamic expressions used in MATLAB, you can include any number of these expressions within the overall replacement expression.

In the `regexprep`

call shown here, the replacement pattern is `'${convertMe($1,$2)}'`

. In this case, the entire replacement pattern is a dynamic expression:

regexprep('This highway is 125 miles long', ... '(\d+\.?\d*)\W(\w+)', '${convertMe($1,$2)}');

The dynamic expression tells MATLAB to execute a function named `convertMe`

using the two tokens `(\d+\.?\d*)`

and `(\w+)`

, derived from the text being matched, as input arguments in the call to `convertMe`

. The replacement pattern requires a dynamic expression because the values of `$1`

and `$2`

are generated at runtime.

The following example defines the file named `convertMe`

that converts measurements from imperial units to metric.

function valout = convertMe(valin, units) switch(units) case 'inches' fun = @(in)in .* 2.54; uout = 'centimeters'; case 'miles' fun = @(mi)mi .* 1.6093; uout = 'kilometers'; case 'pounds' fun = @(lb)lb .* 0.4536; uout = 'kilograms'; case 'pints' fun = @(pt)pt .* 0.4731; uout = 'litres'; case 'ounces' fun = @(oz)oz .* 28.35; uout = 'grams'; end val = fun(str2num(valin)); valout = [num2str(val) ' ' uout]; end

At the command line, call the `convertMe`

function from `regexprep`

, passing in values for the quantity to be converted and name of the imperial unit:

regexprep('This highway is 125 miles long', ... '(\d+\.?\d*)\W(\w+)', '${convertMe($1,$2)}')

ans = 'This highway is 201.1625 kilometers long'

regexprep('This pitcher holds 2.5 pints of water', ... '(\d+\.?\d*)\W(\w+)', '${convertMe($1,$2)}')

ans = 'This pitcher holds 1.1828 litres of water'

regexprep('This stone weighs about 10 pounds', ... '(\d+\.?\d*)\W(\w+)', '${convertMe($1,$2)}')

ans = 'This stone weighs about 4.536 kilograms'

As with the `(??@ )`

operator discussed in an earlier section, the `${ }`

operator has access to variables in the currently active workspace. The following `regexprep`

command uses the array `A`

defined in the base workspace:

A = magic(3)

A = 8 1 6 3 5 7 4 9 2

regexprep('The columns of matrix _nam are _val', ... {'_nam', '_val'}, ... {'A', '${sprintf(''%d%d%d '', A)}'})

ans = 'The columns of matrix A are 834 159 672'