** Using WeBWorK **

One simple thing you can do to force them to write their answer in terms of "sin" is to disable "cos" in the context (see http://webwork.maa.org/wiki/Introduction_to_Contexts#Functions) using

You can use a custom checker to do this kind of ad hoc testing, even when there is no specific context that handles the answer form directly.

Here is an example:

ANS($f->cmp(checker=>sub {
  my ($c,$s,$ans) = @_;
  return 0 unless $c == $s;
  return 1 if $s->{tree}->class eq 'Function' && $s->{tree}{name} eq 'sin';
  Value->Error('Your answer should be the sine of something');
  return 0;
}));

This one checks that the answer is correct, and is sin(...). If you need to check for a constant times the sine of something, then you need to walk the tree a little further (check that the top node is of class BOP with its bop equal to *, and the its lop or rop is the sine function, and the other is of class Number.

As I said, it takes a bit more work.

It might be possible to overwrite the functions for sine and cosine as Davide did for handling square root simplifications (just do this for sine and cosine instead of sqrt):

# code essentially from Davide Cervone 4/25/10

###########################

#

# Subclass the numeric functions

#

package my::Function::numeric;

our @ISA = ('Parser::Function::numeric');

#

# Override sqrt() to return a special value (usually 1) when evaluated

# effectively eliminating it from the product.

#

sub sqrt {

my $self = shift;

my $value = $self->context->flag("setSqrt");

return $value+2 if $value && $_[0] == 1; # force sqrt(1) to be incorrect

return $value if $value;

return $self->SUPER::sqrt(@_);

}

#

# end of subclass

#

package main;

Context("Numeric")->variables->are(

x => ["Real", limits => [0,2]], # only needed if x is used in the square roots

);

#

# make sqrt() use our subclass

#

Context()->functions->set(sqrt=>{class=>'my::Function::numeric'});

Context()->flags->set(reduceConstantFunctions=>0);

#

#

# Don't allow fractional powers (avoids 1/2 power)

# [Could subclass exponentiation to handle that as well]

#

LimitedPowers::OnlyPositiveIntegers();

$reducedSqrt = sub {

my ($correct,$student,$ans) = @_;

return 0 if $ans->{isPreview} || $correct != $student;

#

# Get parsed formula for student and correct answers

#

$student = $ans->{student_formula};

$correct = $correct->{original_formula} if defined $correct->{original_formula};

#

# check if equal when sqrt's are replaced by 1

#

Context()->flags->set(setSqrt => 1);

delete $correct->{test_values}, $student->{test_values};

my $OK = ($correct == $student);

Context()->flags->set(setSqrt => 0);

#

Value::Error("Check to see if your answer is simplified.") unless $OK;

return $OK;

};

ANS($ans1->cmp(checker => $reducedSqrt,formatStudentAnswer=>"reduced"));