# HeavisideStep1

Jump to: navigation, search

## Using the Heaviside Step Function

This PG code shows how to add a the Heaviside step function step(x), which takes the value 1 if x > 0, and the value 0 if x ≤ 0, to the context. It also shows how to add a named function u(x) to the context that has a reliable answer checker and can stand in for the Heaviside step function when the student answer is a function.

PG problem file Explanation

Problem tagging:

DOCUMENT();

loadMacros(
"PGstandard.pl",
"MathObjects.pl",
"AnswerFormatHelp.pl",
"parserFunction.pl",
);

TEXT(beginproblem());


Initialization: We load parserFunction.pl to make adding a named function to the context easier. Please see the POD documentation parserFunction.pl.html.

Context("Numeric");
Context()->variables->are(t=>"Real");
Context()->functions->add(
step => {
class => 'Parser::Legacy::Numeric',
perl => 'Parser::Legacy::Numeric::do_step'
},
);

$a = 3;$ftex  = "5 u(t-$a)";$fstep = Formula("5*step(t-$a)");$answer1 = List($fstep->eval(t=>2),$fstep->eval(t=>3),$fstep->eval(t=>4));  Setup 1: We add the step function to the context with the name step. The function step(t) is the Heaviside function and takes the value 1 when t > 0, and the value 0 when t ≤ 0. We will use the function step when evaluating the Heaviside function to obtain an answer that is a number. For more details on adding the Heaviside function to the context, see the forum discussion on the Heaviside step function Context()->texStrings; BEGIN_TEXT Let $$u(t)$$ be the Heaviside step function defined by $$\displaystyle u(t) = \left\lbrace \begin{array}{lcl} 0 && \mbox{ if } x \leq 0, \\ 1 && \mbox{ if } x > 0. \end{array} \right.$$$BR
$BR (a) Evaluate the function $$ftex$$ when $$t$$ is $$2$$, $$3$$, and $$4$$ and enter your answers as a comma separated list.$BR
\{ ans_rule(20) \}
\{ AnswerFormatHelp("numbers") \}
END_TEXT
Context()->normalStrings;


Main Text 1:

$showPartialCorrectAnswers=1; ANS($answer1->cmp(ordered=>1) );


Answer Evaluation 1:

Context("Numeric");
Context()->variables->are(t=>"Real");
Context()->functions->add(
step => {
class => 'Parser::Legacy::Numeric',
perl => 'Parser::Legacy::Numeric::do_step'
},
);

parserFunction("u(t)" => "step(t)");
$f = Formula("5 u(t-$a)");

$answer2 =$f->with(
limits=>[$a-5,$a+5],
test_at => [[$a-1],[$a],[$a+0.0000001],[$a+1]],
num_points=>10,
);


Setup 2: We reset the context using Context("Numeric") and add the function step(t) as before. The reason for resetting the context is that in part (a) of the question we don't want to allow students to type in u(2),u(3),u(4) and get the right answer, because we want students to evaluate the Heaviside function themselves.

Using a different method for adding functions to the context, we add the named function u(t) using parserFunction and make it identical to the function step(t). The reason for adding u(t) to the context is that students will then be able to enter it as a named function in their answer.

Since answers are checked numerically by comparing the student answer to the correct answer at several randomly points in the domain (the default is 5 points) in an interval (the default is [-1,1]), the function step(t) = u(t) is not very robust when checking answers using these defaults. For example, if a student types in the answer u(t-0.1) and the correct answer is u(t), there is a good chance that the student's answer will be marked correct, since the probability that a test point was chosen in the interval (0,0.1) is much less than 100%. Also, if the correct answer were u(t-5), then a student could enter the answer 0 and be marked correct because the correct answer is identically zero on the interval [-1,1].

To make the answer checking robust, in $answer2 we specify a larger domain centered at $a using limits, we require four of the test points always be used, and that there should be 10 test points total (the four we specified and six others generated at random). Notice that we used the construction $f->with(...) to do this (using $f->{test_at} = [,] would generate an error because the functions we added to the context aren't "blessed" with enough permissions to modify $f in that way). In part (b), since the students never actually see the values of the function u(t), we could have defined the function as parserFunction("u(t)" => "1.5 * sin(e*t) + 5*pi/3 + arctan(t)" );  If we had defined u(t) this way, we would not have had to add the function step(t) to the context and we could have used the defaults for the answer checker. Notice that the function u(t) is never zero, is not constant, is differentiable, and takes moderately sized values, which makes its answer checking very robust using the defaults for the answer checker. Further, because of the arctangent, it is not periodic and so u(t)-u(t-a) should never be identically zero. Also, the formula for u(t) is not something students are likely to input as an answer out of nowhere. The function u(t) is great as a named function that stands in for the Heaviside function when the answer is a function. However, if the answer is a number obtained by evaluating the Heaviside function, then step(t) should be used or the function u(t) should be properly defined as the Heaviside function for obvious reasons. Context()->texStrings; BEGIN_TEXT$BR
$BR (b) Suppose the answer is the function $$ftex$$.$BR
\{ ans_rule(20) \}
\{ AnswerFormatHelp("formulas") \}
END_TEXT
Context()->normalStrings;


Main Text 2:

ANS( \$answer2->cmp() );


Answer Evaluation 2:

Context()->texStrings;
BEGIN_SOLUTION
Solution explanation goes here.
END_SOLUTION
Context()->normalStrings;

COMMENT('MathObject version.');

ENDDOCUMENT();


Solution: