Introduction to Contexts
(→Producing "TeX" strings) 

Line 38:  Line 38:  
Normally "$f" emits the string <code>"sin(3x^2)/cos(x)"</code>  Normally "$f" emits the string <code>"sin(3x^2)/cos(x)"</code>  
which defines the function. However if you set  which defines the function. However if you set  
−  the current context to "texStrings":  +  the current context to "texStrings": <code>Context()>texStrings;</code> 
−  +  
−  Context()>texStrings;  +  
−  +  
then "$f" produces the TeX string used to typeset the function:  then "$f" produces the TeX string used to typeset the function:  
+  <code>"\frac{ \sin(3x^2) }{\cos(x) } "</code>  
−  +  In practice this means that virtually every  
−  +  occurence of a BEGIN_TEXT/END_TEXT block should be written as  
−  In practice this means that virtually every occurence of a BEGIN_TEXT/END_TEXT block should be written as  +  
Context()>texStrings;  Context()>texStrings;  
Line 55:  Line 52:  
Context()>normalStrings;  Context()>normalStrings;  
−  It is a good idea to return to "normalStrings" outside BEGIN_TEXT blocks since the normal string representation  +  This means that the "$f" is replaced by TeX code placed between the "LaTeX math" symbols \( and \) 
+  and is then transformed into a typeset representation of the formula "$f".  
+  
+  It is a good idea to return to "normalStrings" outside BEGIN_TEXT  
+  blocks since the normal string representation  
of $f may be required inside perl macros in the rest of the problem.  of $f may be required inside perl macros in the rest of the problem.  
−  
====Context changes for Formulas====  ====Context changes for Formulas==== 
Revision as of 07:44, 16 June 2008
Contents 
Contexts
The Context of a problem determines how variables are interpreted, sets the default variable(s), determines default constants available in the problem, and sets appropriate default system values such as the tolerance for student errors, etc. It also adjusts the error messages for student responses so that, for example, "4i +5j +6k" will result in a syntax error message in "Numeric" context but not in "Vector" context.
List of Basic Contexts
Usually we select a Context by including
Context("name");
at the top of a problem file, where name
is one of:

Numeric
(variable x, no complex numbers, points, etc.)  this is the default context 
Complex
(variable z, i = \sqrt{1}, no points, etc.) 
Point
(another name for Vector context, but angle brackets are not allowed) 
Vector
(variables x, y, z, angle brackets form vectors, i, j, k are unit coordinate vectors, etc.) 
Vector2D
(same as Vector, but with i and j in 2D) 
Matrix
(square brackets form matrices: [[0,1],[1,0]] ) 
Interval
(subsets of the real line: parens and brackets form intervals, finite subsets, (5,6] ,(infinity,6), {5,6} etc. )
Another method of selecting a more nuanced context is to include one of the "context" macro packages using the syntax.
loadMacros("contextLimitedPolynomials.pl");
This example would specify that only "simplified" polynomials in a_n x^n + ... +a_0
would be allowed as answers. Inspecting the file "contextLimitedPolynomials.pl" is one way to learn how to modify a context to meet your
requirements.
Common Context methods
Producing "TeX" strings
This is the most common use of a Context method. Suppose that you have a formula such as
$f = Formula("sin(3x^2)/cos(x)");
Normally "$f" emits the string "sin(3x^2)/cos(x)"
which defines the function. However if you set
the current context to "texStrings": Context()>texStrings;
then "$f" produces the TeX string used to typeset the function:
"\frac{ \sin(3x^2) }{\cos(x) } "
In practice this means that virtually every occurence of a BEGIN_TEXT/END_TEXT block should be written as
Context()>texStrings; BEGIN_TEXT Differentiate the function \( $f\) ... ...... END_TEXT Context()>normalStrings;
This means that the "$f" is replaced by TeX code placed between the "LaTeX math" symbols \( and \) and is then transformed into a typeset representation of the formula "$f".
It is a good idea to return to "normalStrings" outside BEGIN_TEXT blocks since the normal string representation of $f may be required inside perl macros in the rest of the problem.
Context changes for Formulas
 Adding variables
 In the Numeric Context, the default variable is
x
. Use thevariables>add(y=>'Real')
method to specify additional legitimate variables and their type in the current context.
For example: 
Context()>variables>add(y=>'Real');

Context()>variables>add(y=>'Real',z=>'Real');

Context()>variables>add(z=>'Complex');
 Setting variables
 To set the variable(s) in the current Context (replacing the default variable(s)), use the
variables>are()
method, as shown in the following: 
Context()>variables>are(y=>'Real');

Context()>variables>are(y=>'Real',z=>'Real');

Context()>variables>are(z=>'Complex');
 Setting variable limits
 The limits for the variables in the Context determine the values that may be used to determine the correctness of a Formula. If a Formula is not welldefined on the default range [2,2], it may be useful to set a different range for the variable(s) in the Context:
 If the only variable in the Context is
x
,
Context()>variables>set(x=>{limits=>[1,1]});

 We can similarly set limits for several variables at once, if they have been defined in the Context:

Context()>variables>set(x=>{limits=>[1,1]},y=>{limits=>[1,1]});

Context changes for Strings
 Adding Strings to the Context
By default there are a limited number of Strings that are predefined in the Context. In the Numeric Context (the default) these includeinf
,infinity
, andDNE
. Because they exist in the Context, students can enter these as answers without generating error messages (though, of course, the answer may be incorrect). To add other Strings to the Context, we use thestrings>add()
method: To add the string "Continuous" to the Context, </dt>

Context()>strings>add(Continuous=>{});
</dd>  To add the strings "True" and "T" to the Context, making "T" be an alias for "True" (so that a student could enter either "True" or "T" as an answer and have either marked correct),</dt>

Context()>strings>add(True=>{},T=>{alias=>'True'});
</dd>  And to add "True", "False" and aliases for both,</dt>

Context()>strings>add(True=>{},False=>{},T=>{alias=>'True'},F=>{alias=>'False'});
</dd>
 Changing casesensitivity of Strings
By default, !WeBWorK regards String objects as being caseinsensitive. Thus if the correct answer to a problem is the String object "True", a student could respond "True" or "true" and have either answer marked correct. To change this behavior, we set thecaseSensitive
flag when adding the variable to the Context:
Context()>strings>add(True=>{caseSensitive=>1});
</dd>

Other useful Context changes
 Preserving constant values in Formulas
By default, !WeBWorK will reduce constant expressions that are substituted into Formulas, which is not always what we want to do. This is a somewhat subtle point, which may be easiest to consider in the context of an example. Suppose that we have the !WeBWorK code </dt>

$f = Formula("sin(x)");
</dd>
$f0 = $f>eval(x=>pi/6);  Then we are substituting the Real value pi/6 into the sine function, and
$f0
is accordingly a Real value (0.5) which will be displayed as a decimal. We can make !WeBWorK display the unreduced expression sin(pi/6) by setting thereduceConstants
flag in the Context and substituting a Formula forx
instead of evaluating the expression: </dt> 
Context()>flags>set(reduceConstants=>0);
</dd>
$f = Formula("sin(x)")
$f0 = $f>substitute(x=>Formula("pi/6"));  will result in the Formula for pi/6 being substituted into the function
$f
to obtain a new Formula, and when it is shown in the problem the expression will be displayed assin(pi/6)
, not in the reduced form (0.5). </dt>