Jump to: Site Navigation


        Macros for complex numbers for the PG language




 #      This subroutine compares complex numbers.
 #      Available prefilters include:
 #      each of these are called by cplx_cmp( answer, mode => '(prefilter name)' )
 #      'std'                   The standard comparison method for complex numbers. This option it the default
 #                              and works with any combination of cartesian numbers, polar numbers, and
 #                              functions. The default display method is cartesian, for all methods, but if
 #                              the student answer is polar, even in part, then their answer will be displayed
 #                              that way.
 #      'strict_polar'          This is still under developement. The idea is to check to make sure that there
 #                              only a single term in front of the e and after it... but the method does not
 #                              check to make sure that the i is in the exponent, nor does it handle cases
 #                              where the polar has e** coefficients.
 #      'strict_num_cartesian'  This prefilter allows only complex numbers of the form "a+bi" where a and b
 #                              are strictly numbers.
 #      'strict_num_polar'      This prefilter allows only complex numbers of the form "ae^(bi)" where a and b
 #                              are strictly numbers.
 #      'strict'                This is a combination of strict_num_cartesian and strict_num_polar, so it
 #                              allows complex numbers of either the form "a+bi" or "ae^(bi)" where a and b
 #                              are strictly numbers.


 #      This is a filter: it accepts and returns an AnswerHash object.
 #              Usage:  compare_cplx(ans_hash, %options)
 #      Compares two complex numbers by comparing their real and imaginary parts


 #      Checks a comma separated string of  items against an array of evaluators.
 #      For example this is useful for checking all of the complex roots of an equation.
 #      Each student answer must be evaluated as correct by a DISTINCT answer evalutor.
 #      This answer checker will only work reliably if each answer checker corresponds
 #      to a distinct correct answer.  For example if one answer checker requires
 #      any positive number, and the second requires the answer 1, then 1,2 might
 #      be judged incorrect since 1, satisifes the first answer checker, but 2 doesn't
 #      satisfy the second.  2,1 would work however. Avoid this type of use!!
 #      Including backtracking to fit the answers as best possible to each answer evaluator
 #      in the best possible way, is beyond the ambitions of this evaluator.

Utility functions

 #      for checking the form of a number or of the C<student_ans> field in an answer hash


 #      This subroutine takes in a string, which is a mathematical expresion, and determines whether or not
 #      it is a single term. This is accoplished using a stack. Open parenthesis pluses and minuses are all
 #      added onto the stack, and when a closed parenthesis is reached, the stack is popped untill the open
 #      parenthesis is found. If the original was a single term, the stack should be empty after
 #      evaluation. If there is anything left ( + or - ) then false is returned.
 #      Of course, the unary operator "-" must be handled... if it is a unary operator, and not a regular -
 #      the only place it could occur unambiguously without being surrounded by parenthesis, is the very
 #      first position. So that case is checked before the loop begins.

Site Navigation