Patterns#

The official documentation on patterns can be found here.

WARNING: Patterns are currently a beta feature, so be careful while using them. For advanced pattern usage, take a look at the Desmos CL forums here.

Brief Introduction#

The different patterns in Desmos CL are tools which can be used to require student answers in certain formats or to parse complex student inputs. Some of these patterns can themselves contain other patterns, like the fraction pattern which requires a pattern for the numerator and denominator.

Generating Patterns#

I personally think that examples are the best way to learn the peculiar format for defining patterns. Let's say that we want to make a pattern that matches a basic fraction in the format \(\frac{a}{b}\). We could define that as:

frac_pattern = patterns.fraction(patterns.number, patterns.number)

Then, let's say that students are putting their answer (as a fraction) into a math response component named math_resp. Then we could get the numerator of their response with:

frac_pattern.parse(math_resp.latex).numerator().latex

The parse method parses the student response and returns an object which we can get the numerator, denominator, or latex from. Note that each pattern object will have different things you can parse out of it (fractions have numerators and denominators, exponents have bases and exponents, etc.).

For a more complex pattern example, let's say that we gave our students the challenge of converting \(\left(\frac{a}{b}\right)^5\) into a fraction, with an expected answer of \(\frac{a^5}{b^5}\). This would correspond to the following pattern. Note that we can assign patterns to a shorthand variable to reduce the size of our pattern definition.

p = patterns
ans_pattern = p.fraction(p.exponent(p.literal("a"), p.integer), p.exponent(p.literal("b"), p.integer))

Now that we have the answer, we can first check that the student answer is in this format. To do this, we would use matches like so:

ans_matches = ans_pattern.matches(math_resp.latex)

Once we've checked that, we can confirm that the exponents are correct by using multiple applications of parse like so:

a_exp = ans_pattern.parse(math_resp.latex).numerator().exponent().numericValue
b_exp = ans_pattern.parse(math_resp.latex).denominator().exponent().numericValue

is_correct = (a_exp = 5) and (b_exp = 5)

Pattern Playground#

If you want to play around with the different patterns that are possible, below you can find a kind of "pattern playground" which will render the latex that corresponds to the kind of pattern you are constructing. Note that "patterns." or "p." both work as prefixes, though only "patterns." will work as a prefix in the CL editor (unless you've included the line p = patterns). Additionally, this playground only includes a set of the more common patterns (the ones with explanations currently in this documentation).

Input your pattern here:

Pattern Preview

Pattern Warnings

Kinds of Patterns#

pattern.number#

Pattern Attributes#

numberPattern

neg_int = patterns.integer.satisfies(`x < 0`)

Match Attributes#

numberPatternMatch

pattern.integer#

Pattern Attributes#

numberPattern

neg_int = patterns.integer.satisfies(`x < 0`)

Match Attributes#

numberPatternMatch

pattern.mixedNumber#

Pattern Attributes#

mixedNumberPattern

Match Attributes#

mixedNumberPatternMatch

pattern.scientific#

Pattern Attributes#

scientificPattern

Match Attributes#

scientificPatternMatch

pattern.literal#

patterns.literal(ltx::latex)::literalPattern

Pattern Attributes#

literalPattern

Match Attributes#

literalPatternMatch

pattern.expression#

Pattern Attributes#

expressionPattern

Match Attributes#

expressionPatternMatch

pattern.anyOf#

patterns.anyOf(term1::pattern, term2::pattern, ...)::orPattern

anyOf accepts any number of terms, and will match any of them.

Pattern Attributes#

orPattern

Match Attributes#

orPatternMatch

pattern.sum#

patterns.sum(term1::pattern, term2::pattern, ...)::sumPattern

sum accepts any number of terms, and will match their addition.

Pattern Attributes#

sumPattern

Match Attributes#

sumPatternMatch

patterns.sum(patterns.integer, patterns.integer).parse(`1+2`).term1

pattern.contains#

Pattern Attributes#

containsPattern

Match Attributes#

containsPatternMatch

pattern.product#

patterns.product(term1::pattern, term2::pattern, ...)::productPattern

product accepts any number of terms, and will match their product.

Pattern Attributes#

productPattern

Match Attributes#

productPatternMatch

patterns.product(patterns.integer, patterns.integer).parse(`1*2`).term1

pattern.juxt#

patterns.juxt(term1::pattern, term2::pattern, ...)::juxtPattern

juxt accepts any number of terms, and will match their juxtaposition.

WARNING: juxt will not recognize the juxtaposition of two numbers (as these are often parsed as a single number) and in general is not completely intuitive. Make sure to test thoroughly when using this feature.

Pattern Attributes#

juxtPattern

Match Attributes#

juxtPatternMatch

patterns.juxt(patterns.integer, patterns.literal(`x`)).parse(`1x`).term1

pattern.fraction#

patterns.fraction(numerator::pattern, denominator::pattern)::fractionPattern

Pattern Attributes#

fractionPattern

Match Attributes#

fractionPatternMatch

pattern.division#

patterns.division(dividend::pattern, divisor::pattern)::divisionPattern

Pattern Attributes#

divisionPattern

Match Attributes#

divisionPatternMatch

pattern.radical#

patterns.radical(radicand::pattern, degree::pattern)::radicalPattern

Pattern Attributes#

radicalPattern

Match Attributes#

radicalPatternMatch

pattern.overLine#

Description Needed

pattern.overArc#

Description Needed

pattern.overRightArrow#

Description Needed

pattern.overLeftArrow#

Description Needed

pattern.difference#

patterns.difference(minuend::pattern, subtrahend::pattern)::pattern

Pattern Attributes#

differencePattern

Match Attributes#

differencePatternMatch

pattern.repeat#

Description Needed

pattern.optional#

Description Needed

pattern.functionCall#

Description Needed

pattern.prime#

Description Needed

pattern.exponent#

patterns.exponent(base::pattern, exponent::pattern)::exponentPattern

Pattern Attributes#

exponentPattern

Match Attributes#

exponentPatternMatch

pattern.comparator#

Description Needed

pattern.comparatorChain#

Description Needed

pattern.symbol#

Description Needed