From 96bee2b33467a1ce54f88c77b8a867ef1f7a9a97 Mon Sep 17 00:00:00 2001 From: Jean-Michel Vedrine Date: Sun, 9 Sep 2012 16:54:35 +0200 Subject: First version of algebra question type initially written by Roger Moore for Moodle 2.3 --- CHANGELOG.txt | 33 + INSTALL.txt | 48 + README.txt | 23 + backup/moodle1/lib.php | 79 + .../moodle2/backup_qtype_algebra_plugin.class.php | 63 + .../moodle2/restore_qtype_algebra_plugin.class.php | 106 ++ db/install.xml | 47 + db/upgrade.php | 59 + db/upgradelib.php | 71 + displayformula.php | 48 + edit_algebra_form.php | 378 +++++ lang/en/qtype_algebra.php | 91 ++ lang/en/qtype_algebra_parser.php | 20 + lib.php | 38 + parser.php | 1721 ++++++++++++++++++++ pix/icon.gif | Bin 0 -> 87 bytes question.php | 356 ++++ questiontype.php | 551 +++++++ renderer.php | 162 ++ sage_server.py | 29 + settings.php | 11 + version.php | 5 + xmlrpc-utils.php | 269 +++ 23 files changed, 4208 insertions(+) create mode 100644 CHANGELOG.txt create mode 100644 INSTALL.txt create mode 100644 README.txt create mode 100644 backup/moodle1/lib.php create mode 100644 backup/moodle2/backup_qtype_algebra_plugin.class.php create mode 100644 backup/moodle2/restore_qtype_algebra_plugin.class.php create mode 100644 db/install.xml create mode 100644 db/upgrade.php create mode 100644 db/upgradelib.php create mode 100644 displayformula.php create mode 100644 edit_algebra_form.php create mode 100644 lang/en/qtype_algebra.php create mode 100644 lang/en/qtype_algebra_parser.php create mode 100644 lib.php create mode 100644 parser.php create mode 100644 pix/icon.gif create mode 100644 question.php create mode 100644 questiontype.php create mode 100644 renderer.php create mode 100644 sage_server.py create mode 100644 settings.php create mode 100644 version.php create mode 100644 xmlrpc-utils.php diff --git a/CHANGELOG.txt b/CHANGELOG.txt new file mode 100644 index 0000000..bb14cb4 --- /dev/null +++ b/CHANGELOG.txt @@ -0,0 +1,33 @@ +Version 0.0.4 +Improvements + - Export and import to Moodle XML format + - Backup and restore functions added +Bug fixes + - Fixed parser problem with negative numbers +Version 0.0.3 +Improvements + - Added danish localizations based on forum feedback: mltiplication now + uses 'cdot' and decimal points are rendered as commas when Danish is + selected as a language +Bug fixes + - Operator priority, BODMAS, not quite implemented correctly. */ and +- not + implemented as equal priority - now fixed +Version 0.0.2 +Significant changes as a result of the first round of feedback! + - Renamed parser classes to conform to coding guidelines + - Moved all parser strings into a language pack + - Switched a lot of double quoted string to single as per guidelines + - added automatic formatted comments as required by coding guidelines + - changed treatment of variable names to help reduce confusion. Now + the first letter is treated as the name and the rest are subscripted. + Greek letter names are treated as a single character i.e. theta1 + becomes \theta_{1} in LaTeX. + - Added option to specify text which goes in front of response box + - Added support for specified variable names in the parser to improve + parsing in some situations e.g. 'xy' will now get treated as 'x * y' if + there are two variables 'x' and 'y' defined. +Bug fixes + - fixed bug when evaluating special constants in the parser + - fixed incorrect rendering of sqrt in LaTeX by the parser + - fixed incorrect sage-server.py file in the ZIP +Version 0.0.1 released diff --git a/INSTALL.txt b/INSTALL.txt new file mode 100644 index 0000000..da45f38 --- /dev/null +++ b/INSTALL.txt @@ -0,0 +1,48 @@ +INSTALLATION INSTRUCTIONS + +Before installation: Please note that this is ALPHA quality software at +the moment. DO NOT install this on your production server - or at least +don't blame me if you do and it all goes horribly wrong! + + +REQUIREMENTS + +To install the algebra based question type you will need the following: + +1) Already installed copy of Moodle 2.1 or higher. It may work with other + Moodle versions but this is the only one I have tested it with. + +2) PHP5: The code uses exceptions and so requires PHP version 5 at a + minimum. I used this since Moodle 2.1 will require it so it should + not be an unusual requirement for long. I used PHP 5.3.5. + +3) If you want to use the SAGE XML-RPC server you will also need XML-RPC + support in PHP5. Most installations include this but the MAMP 1.7.1 + package does not. If you use MAMP you will need to download the MAMP + source code from the MAMP website and recompile PHP making sure you + call the initial configure script with the flag "--with-xmlrpc". + +4) If you want to use the SAGE XML-RPC server you will also need a copy of + SAGE which you can get from here: http://www.sagemath.org/. This should + be installed according to the instructions on their website. + + +INSTALLING + +1) Copy the contents of the "moodle" directory into your top level moodle + directory. Note that all the files are 'new' so there should be no files + overwritten. ('cp -iR' are good options to use). + +2) Go to Site Administration > Notifications and your database should be + configured. You are now ready to write algebra based questions which + use the 'Evaluate' and 'Equivalent' comarison methods. + +3) To run the SAGE XML-RPC server you will need an installed copy of SAGE + (http://www.sagemath.org/). Edit the first line of the 'sage-server.py' + file to point to your installed copy of the sage executable. Then simply + execute the sage-server.py script. It will run a very simple XML-RPC + server. If the machine you run your moodle server on is different from + the machine running your SAGE webserver you will need to edit line 191- + 193 of the file question/type/algebra/question.php to point to the + XML-RPC server. The same applies if you edit the network port. (This + mechanism obviously needs to be improved!) diff --git a/README.txt b/README.txt new file mode 100644 index 0000000..539a0e4 --- /dev/null +++ b/README.txt @@ -0,0 +1,23 @@ +MOODLE ALGEBRA QUESTION TYPE +Updated to Moodle 2.0 by Stefan Raffeiner +Updated to Moodle 2.1 by Jean-Michel Vedrine + +README BY ROGER MOORE: +MOODLE ALGEBRA QUESTION TYPE + +These files implement a algebra based question type for Moodle. +Installation instructions are found in the file INSTALL. + +The code has been tested and used for a large, introductory physics +course (~120 students) at the University of Alberta for several +terms now and is stable and suitable for use in a production +environment. + +The code is all released under the GPL V3. + +Please send any bugs, comments, suggestions for new features etc. +to me. + +Enjoy, + +Roger Moore diff --git a/backup/moodle1/lib.php b/backup/moodle1/lib.php new file mode 100644 index 0000000..d9a6406 --- /dev/null +++ b/backup/moodle1/lib.php @@ -0,0 +1,79 @@ +. + +/** + * @package qtype + * @subpackage algebra + * @copyright 2011 David Mudrak + * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later + */ + +defined('MOODLE_INTERNAL') || die(); + +/** + * Multichoice question type conversion handler + */ +class moodle1_qtype_algebra_handler extends moodle1_qtype_handler { + + /** + * @return array + */ + public function get_question_subpaths() { + return array( + 'ANSWERS/ANSWER', + 'ALGEBRA', + 'ALGEBRA/VARLIST/VARIABLE' + ); + } + + /** + * Appends the algebra specific information to the question + */ + public function process_question(array $data, array $raw) { + // convert and write the answers first + if (isset($data['answers'])) { + $this->write_answers($data['answers'], $this->pluginname); + } + + // convert and write the algebra variables + if (isset($data['algebra'][0]['varlist']['variable'])) { + $variables = $data['algebra'][0]['varlist']['variable']; + } else { + $variables = array(); + } + $this->xmlwriter->begin_tag('algebra_variables'); + foreach ($variables as $variable) { + $this->xmlwriter->begin_tag('algebra_variable', array('id' => $this->converter->get_nextid())); + $this->xmlwriter->full_tag('name', $variable['name']); + $this->xmlwriter->full_tag('min', $variable['min']); + $this->xmlwriter->full_tag('max', $variable['max']); + $this->xmlwriter->end_tag('algebra_variable'); + } + $this->xmlwriter->end_tag('algebra_variables'); + + // and finally the algebra options + $options = $data['algebra'][0]; + $this->xmlwriter->begin_tag('algebra', array('id' => $this->converter->get_nextid())); + $this->xmlwriter->full_tag('compareby', $options['compareby']); + $this->xmlwriter->full_tag('nchecks', $options['nchecks']); + $this->xmlwriter->full_tag('tolerance', $options['tolerance']); + $this->xmlwriter->full_tag('disallow', $options['disallow']); + $this->xmlwriter->full_tag('allowedfuncs', $options['allowedfuncs']); + $this->xmlwriter->full_tag('answerprefix', $options['answerprefix']); + $this->xmlwriter->end_tag('algebra'); + } +} diff --git a/backup/moodle2/backup_qtype_algebra_plugin.class.php b/backup/moodle2/backup_qtype_algebra_plugin.class.php new file mode 100644 index 0000000..9e08467 --- /dev/null +++ b/backup/moodle2/backup_qtype_algebra_plugin.class.php @@ -0,0 +1,63 @@ + + * @license http://www.gnu.org/copyleft/gpl.html GNU Public License version 3 + * @package questionbank + * @subpackage questiontypes + * @copyright 2010 onwards Eloy Lafuente (stronk7) {@link http://stronk7.com} + * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later + */ +defined('MOODLE_INTERNAL') || die(); + +/** + * Provides the information to backup algebra questions + */ +class backup_qtype_algebra_plugin extends backup_qtype_plugin { + + /** + * Returns the qtype information to attach to question element + */ + protected function define_question_plugin_structure() { + + // Define the virtual plugin element with the condition to fulfill + $plugin = $this->get_plugin_element(null, '../../qtype', 'algebra'); + + // Create one standard named plugin element (the visible container) + $pluginwrapper = new backup_nested_element($this->get_recommended_name()); + + // connect the visible container ASAP + $plugin->add_child($pluginwrapper); + + // This qtype uses standard question_answers, add them here + // to the tree before any other information that will use them + $this->add_question_question_answers($pluginwrapper); + + // Now create the qtype own structures + + $algebravariables = new backup_nested_element('algebra_variables'); + + $algebravariable = new backup_nested_element('algebra_variable', array('id'), array( + 'name', 'min', 'max')); + + $algebra = new backup_nested_element('algebra', array('id'), array( + 'compareby', 'nchecks', 'tolerance', + 'disallow', 'allowedfuncs', 'answerprefix')); + + // Now the own qtype tree + $pluginwrapper->add_child($algebravariables); + $algebravariables->add_child($algebravariable); + $pluginwrapper->add_child($algebra); + + // set source to populate the data + $algebra->set_source_table('question_algebra', array('questionid' => backup::VAR_PARENTID)); + $algebravariable->set_source_table('question_algebra_variables', array('question' => backup::VAR_PARENTID)); + + // don't need to annotate ids nor files + + return $plugin; + } +} diff --git a/backup/moodle2/restore_qtype_algebra_plugin.class.php b/backup/moodle2/restore_qtype_algebra_plugin.class.php new file mode 100644 index 0000000..5c2d567 --- /dev/null +++ b/backup/moodle2/restore_qtype_algebra_plugin.class.php @@ -0,0 +1,106 @@ +. + +/** + * @package moodlecore + * @subpackage backup-moodle2 + * @copyright 2010 onwards Eloy Lafuente (stronk7) {@link http://stronk7.com} + * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later + */ + +defined('MOODLE_INTERNAL') || die(); + +/** + * restore plugin class that provides the necessary information + * needed to restore one algebra qtype plugin + */ +class restore_qtype_algebra_plugin extends restore_qtype_plugin { + + /** + * Returns the paths to be handled by the plugin at question level + */ + protected function define_question_plugin_structure() { + + $paths = array(); + + // This qtype uses question_answers, add them + $this->add_question_question_answers($paths); + + // Add own qtype stuff + $elename = 'algebravariable'; + $elepath = $this->get_pathfor('/algebra_variables/algebra_variable'); // we used get_recommended_name() so this works + $paths[] = new restore_path_element($elename, $elepath); + $elename = 'algebra'; + $elepath = $this->get_pathfor('/algebra'); // we used get_recommended_name() so this works + $paths[] = new restore_path_element($elename, $elepath); + + return $paths; // And we return the interesting paths + } + + /** + * Process the qtype/algebra element + */ + public function process_algebra($data) { + global $DB; + + $data = (object)$data; + $oldid = $data->id; + // Detect if the question is created or mapped + $oldquestionid = $this->get_old_parentid('question'); + $newquestionid = $this->get_new_parentid('question'); + $questioncreated = $this->get_mappingid('question_created', $oldquestionid) ? true : false; + + // If the question has been created by restore, we need to create its question_algebra too + if ($questioncreated) { + // Adjust some columns + $data->questionid = $newquestionid; + // Insert record + $newitemid = $DB->insert_record('question_algebra', $data); + // Create mapping (needed for decoding links) + $this->set_mapping('question_algebra', $oldid, $newitemid); + } else { + // Nothing to remap if the question already existed + } + } + + /** + * Process the qtype/algebravariable element + */ + public function process_algebravariable($data) { + global $DB; + + $data = (object)$data; + $oldid = $data->id; + + // Detect if the question is created or mapped + $oldquestionid = $this->get_old_parentid('question'); + $newquestionid = $this->get_new_parentid('question'); + $questioncreated = $this->get_mappingid('question_created', $oldquestionid) ? true : false; + + // If the question has been created by restore, we need to create its question_algebra_variables too + if ($questioncreated) { + // Adjust some columns + $data->question = $newquestionid; + // Insert record + $newitemid = $DB->insert_record('question_algebra_variables', $data); + // Create mapping + $this->set_mapping('question_algebra_variable', $oldid, $newitemid); + } else { + // Nothing to remap if the question already existed + } + } +} diff --git a/db/install.xml b/db/install.xml new file mode 100644 index 0000000..51b8d85 --- /dev/null +++ b/db/install.xml @@ -0,0 +1,47 @@ + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + + +
+ + diff --git a/db/upgrade.php b/db/upgrade.php new file mode 100644 index 0000000..371150b --- /dev/null +++ b/db/upgrade.php @@ -0,0 +1,59 @@ +get_manager(); + +/// And upgrade begins here. For each one, you'll need one +/// block of code similar to the next one. Please, delete +/// this comment lines once this file start handling proper +/// upgrade code. + + // Add the field to store the string which is placed in front of the answer + // box when the question is displayed + if ($oldversion < 2008061500) { + $table = new xmldb_table('question_algebra'); + $field = new xmldb_field('answerprefix', XMLDB_TYPE_TEXT, 'small', null, XMLDB_NOTNULL, null, '', 'allowedfuncs'); + if (!$dbman->field_exists($table, $field)) { + $dbman->add_field($table, $field); + } + upgrade_plugin_savepoint(true, 2008061500, 'qtype', 'algebra'); + } + + // Drop the answers and variables fields wich are totaly redundants + if ($oldversion < 2011072800) { + $table = new xmldb_table('question_algebra'); + $field = new xmldb_field('answers'); + + if ($dbman->field_exists($table, $field)) { + $dbman->drop_field($table, $field); + } + $field = new xmldb_field('variables'); + + if ($dbman->field_exists($table, $field)) { + $dbman->drop_field($table, $field); + } + upgrade_plugin_savepoint(true, 2011072800, 'qtype', 'algebra'); + } + return true; +} + diff --git a/db/upgradelib.php b/db/upgradelib.php new file mode 100644 index 0000000..2f05142 --- /dev/null +++ b/db/upgradelib.php @@ -0,0 +1,71 @@ +. + +/** + * Upgrade library code for the algebra question type. + * + * @package qtype + * @subpackage algebra + * @copyright 2010 The Open University + * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later + */ + + +defined('MOODLE_INTERNAL') || die(); + + +/** + * Class for converting attempt data for algebra questions when upgrading + * attempts to the new question engine. + * + * This class is used by the code in question/engine/upgrade/upgradelib.php. + * + * @copyright 2010 The Open University + * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later + */ +class qtype_algebra_qe2_attempt_updater extends question_qtype_attempt_updater { + public function right_answer() { + foreach ($this->question->options->answers as $ans) { + if ($ans->fraction > 0.999) { + return $ans->answer; + } + } + } + + public function was_answered($state) { + return !empty($state->answer); + } + + public function response_summary($state) { + if (!empty($state->answer)) { + return $state->answer; + } else { + return null; + } + } + + public function set_first_step_data_elements($state, &$data) { + } + + public function supply_missing_first_step_data(&$data) { + } + + public function set_data_elements_for_step($state, &$data) { + if (!empty($state->answer)) { + $data['answer'] = $state->answer; + } + } +} diff --git a/displayformula.php b/displayformula.php new file mode 100644 index 0000000..e5051e5 --- /dev/null +++ b/displayformula.php @@ -0,0 +1,48 @@ + +// License: GNU Public License version 3 + +/** + * Script which converts the given formula text into LaTeX code and then + * displays the appropriate image file. It relies on the LaTeX filter to + * be present. + */ + +require_once('../../../config.php'); +require_once("$CFG->dirroot/question/type/algebra/parser.php"); +global $PAGE; + +$p = new qtype_algebra_parser; +try { + $query=urldecode($_SERVER['QUERY_STRING']); + $m=array(); + + if(!preg_match('/vars=([^&]*)&expr=(.*)$/A',$query,$m)) { + throw new Exception('Invalid query string received from http server!'); + } + $vars=explode(',',$m[1]); + if(empty($m[2])) { + $texexp=''; + } else { + $exp = $p->parse($m[2],$vars); + $texexp = '$$'.$exp->tex().'$$'; + } +} catch(Exception $e) { + $texexp = get_string('parseerror','qtype_algebra',$e->getMessage()); +} +$formatoptions = new stdClass; +$formatoptions->para = false; +$PAGE->set_context(get_context_instance(CONTEXT_SYSTEM)); +$text = format_text($texexp, FORMAT_MOODLE, $formatoptions); +?> + + + Formula + + + + + + diff --git a/edit_algebra_form.php b/edit_algebra_form.php new file mode 100644 index 0000000..eae12bf --- /dev/null +++ b/edit_algebra_form.php @@ -0,0 +1,378 @@ + + * @license http://www.gnu.org/copyleft/gpl.html GNU Public License + * @package questionbank + * @subpackage questiontypes + */ + +require_once($CFG->dirroot . '/question/type/edit_question_form.php'); +require_once($CFG->dirroot . '/question/type/algebra/questiontype.php'); +require_once($CFG->dirroot . '/question/type/algebra/parser.php'); + +// Override the default number of answers and the number to add to avoid clutter. +// Algebra questions will likely not have huge number of different answers... +define("SYMB_QUESTION_NUMANS_START", 2); +define("SYMB_QUESTION_NUMANS_ADD", 1); + +// Override the default number of answers and the number to add to avoid clutter. +// algebra questions will likely not have huge number of different answers... +define("SYMB_QUESTION_NUMVAR_START", 2); +define("SYMB_QUESTION_NUMVAR_ADD", 1); + +/** + * symoblic editing form definition. + */ +class qtype_algebra_edit_form extends question_edit_form { + /** + * Add question-type specific form fields. + * + * @param MoodleQuickForm $mform the form being built. + */ + protected function definition_inner($mform) { + // Add the select control which will select the comparison type to use + $mform->addElement('select', 'compareby', get_string('compareby','qtype_algebra'), + array( "sage" => get_string('comparesage', 'qtype_algebra'), + "eval" => get_string('compareeval', 'qtype_algebra'), + "equiv" => get_string('compareequiv','qtype_algebra') + )); + $mform->addHelpButton('compareby', 'compareby', 'qtype_algebra'); + $mform->setDefault('compareby','eval'); + + + // Add the control to select the number of checks to perform + // First create an array with all the allowed values. We will then use this array + // with the array_combine function to create a single array where the keys are the + // same as the array values + $chk_array=array( '1', '2', '3', '5', '7', + '10', '20', '30', '50', '70', + '100', '200', '300', '500', '700', '1000'); + // Add the select element using the array_combine method discussed above + $mform->addElement('select', 'nchecks', get_string('nchecks','qtype_algebra'), + array_combine($chk_array,$chk_array)); + $mform->addHelpButton('nchecks', 'nchecks', 'qtype_algebra'); + // Set the default number of checks to perform + $mform->setDefault('nchecks','10'); + + + // Add the box to set the tolerance to use when performing evaluation checks + $mform->addElement('text', 'tolerance', get_string('tolerance','qtype_algebra')); + $mform->addHelpButton('tolerance', 'tolerance', 'qtype_algebra'); + $mform->setType('tolerance', PARAM_NUMBER); + $mform->setDefault('tolerance','0.001'); + + // Add an entry for the answer box prefix + $mform->addElement('text', 'answerprefix', get_string('answerprefix','qtype_algebra'),array('size'=>55)); + $mform->addHelpButton('answerprefix', 'answerprefix', 'qtype_algebra'); + $mform->setType('answerprefix', PARAM_RAW); + + // Add an entry for a disallowed expression + $mform->addElement('text', 'disallow', get_string('disallow','qtype_algebra'),array('size'=>55)); + $mform->addHelpButton('disallow', 'disallow', 'qtype_algebra'); + $mform->setType('disallow', PARAM_RAW); + + // Create an array which will store the function checkboxes + $func_group=array(); + // Create an array to add spacers between the boxes + $spacers=array('
'); + // Add the initial all functions box to the list of check boxes + $func_group[] =& $mform->createElement('checkbox','all','',get_string('allfunctions','qtype_algebra')); + // Create a checkbox element for each function understood by the parser + for($i=0;$icreateElement('checkbox',$func,'',$func); + if(($i % 6) == 5) { + $spacers[]='
'; + } else { + $spacers[]=str_repeat(' ',8-strlen($func)); + } + } + // Create and add the group of function controls to the form + $mform->addGroup($func_group,'allowedfuncs',get_string('allowedfuncs','qtype_algebra'),$spacers,true); + $mform->addHelpButton('allowedfuncs', 'allowedfuncs', 'qtype_algebra'); + $mform->disabledIf('allowedfuncs','allowedfuncs[all]','checked'); + $mform->setDefault('allowedfuncs[all]','checked'); + + $mform->addElement('static', 'variablesinstruct', + get_string('variables', 'qtype_algebra'), + get_string('filloutonevariable', 'qtype_algebra')); + $mform->closeHeaderBefore('variablesinstruct'); + // Create the array for the list of variables used in the question + $repeated=array(); + // Create the array for the list of repeated options used by the variable subforms + $repeatedoptions = array(); + + // Add the form elements to enter the variables + $repeated[] =& $mform->createElement('header','variablehdr',get_string('variableno','qtype_algebra','{no}')); + //$repeatedoptions['variablehdr']['helpbutton'] = array('variable',get_string('variable','qtype_algebra'), + // 'qtype_algebra'); + $repeated[] =& $mform->createElement('text','variable',get_string('variablename','qtype_algebra'),array('size'=>20)); + $mform->setType('variable', PARAM_RAW); + $repeated[] =& $mform->createElement('text','varmin',get_string('varmin','qtype_algebra'),array('size'=>20)); + $mform->setType('varmin', PARAM_RAW); + $repeatedoptions['varmin']['default'] = ''; + $repeated[] =& $mform->createElement('text','varmax',get_string('varmax','qtype_algebra'),array('size'=>20)); + $mform->setType('varmax', PARAM_RAW); + $repeatedoptions['varmax']['default'] = ''; + + // Get the current number of variables defined, if any + if (isset($this->question->options)) { + $countvars = count($this->question->options->variables); + } else { + $countvars = 0; + } + // Come up with the number of variable entries to add to the form at the start + if ($this->question->formoptions->repeatelements){ + $repeatsatstart = (SYMB_QUESTION_NUMVAR_START > ($countvars + SYMB_QUESTION_NUMVAR_ADD))? + SYMB_QUESTION_NUMVAR_START : ($countvars + SYMB_QUESTION_NUMVAR_ADD); + } else { + $repeatsatstart = $countvars; + } + $this->repeat_elements($repeated, $repeatsatstart, $repeatedoptions, 'novariables', 'addvariables', + SYMB_QUESTION_NUMVAR_ADD, get_string('addmorevariableblanks', 'qtype_algebra')); + + $mform->addElement('static', 'answersinstruct', + get_string('correctanswers', 'qtype_algebra'), + get_string('filloutoneanswer', 'qtype_algebra')); + $mform->closeHeaderBefore('answersinstruct'); + + $this->add_per_answer_fields($mform, get_string('answerno', 'qtype_algebra', '{no}'), + question_bank::fraction_options(), SYMB_QUESTION_NUMANS_START, SYMB_QUESTION_NUMANS_ADD); + + $this->add_interactive_settings(); + + } + + protected function data_preprocessing($question) { + $question = parent::data_preprocessing($question); + $question = $this->data_preprocessing_answers($question); + $question = $this->data_preprocessing_hints($question); + + if (!empty($question->options)) { + $question->compareby = $question->options->compareby; + $question->nchecks = $question->options->nchecks; + $question->tolerance = $question->options->tolerance; + $question->allowedfuncs = $question->options->allowedfuncs; + $question->disallow = $question->options->disallow; + $question->answerprefix = $question->options->answerprefix; + } + + return $question; + } + /** + * Sets the existing values into the form for the question specific data. + * + * This method copies the data from the existing database record into the form fields as default + * values for the various elements. + * + * @param $question the question object from the database being used to fill the form + */ + function set_data($question) { + // Check to see if there are any existing question options, if not then just call + // the base class set data method and exit + if (!isset($question->options)) { + return parent::set_data($question); + } + + // Now we do exactly the same for the variables... + $vars = $question->options->variables; + // If we found any variables then loop over them using a numerical key to provide an index + // to the arrays we need to access in the form + if (count($vars)) { + $key = 0; + foreach ($vars as $var) { + // For every variable set the default values + $default_values['variable['.$key.']'] = $var->name; + // Only set the min and max defaults if this variable has a range + if($var->min!='') { + $default_values['varmin['.$key.']'] = $var->min; + $default_values['varmax['.$key.']'] = $var->max; + } + $key++; + } + } + + // Add the default values for the allowed functions controls + // First check to see if there are any allowed functions defined + if(count($question->options->allowedfuncs)>0) { + // Clear the 'all functions' flag since functions are restricted + $default_values['allowedfuncs[all]']=0; + // Loop over all the functions which the parser understands + foreach(qtype_algebra_parser::$functions as $func) { + // For each function see if the function is in the allowed function + // list and if so set the check box otherwise remove the check box + if(in_array($func,$question->options->allowedfuncs)) { + $default_values['allowedfuncs['.$func.']']=1; + } else { + $default_values['allowedfuncs['.$func.']']=0; + } + } + } + // There are no allowed functions defined so all functions are allowed + else { + $default_values['allowedfuncs[all]']=1; + } + + // Add the default values to the question object in a form which the parent + // set data method will be able to use to find the default values + $question = (object)((array)$question + $default_values); + + // Finally call the parent set data method to handle everything else + parent::set_data($question); + } + + /** + * Validates the form data ensuring there are no obvious errors in the submitted data. + * + * This method performs some basic sanity checks on the form data before it gets converted + * into a database record. + * + * @param $data the data from the form which needs to be checked + * @param $files some files - I don't know what this is for! - files defined in the form?? + */ + public function validation($data, $files) { + // Call the base class validation method and keep any errors it generates + $errors = parent::validation($data, $files); + + // Regular expression string to match a number + $renumber='/([+-]*(([0-9]+\.[0-9]*)|([0-9]+)|(\.[0-9]+))|'. + '(([0-9]+\.[0-9]*)|([0-9]+)|(\.[0-9]+))E([-+]?\d+))/A'; + + // Perform sanity checks on the variables. + $vars = $data['variable']; + // Create an array of defined variables + $varlist=array(); + foreach ($vars as $key => $var) { + $trimvar = trim($var); + $trimmin = trim($data['varmin'][$key]); + $trimmax = trim($data['varmax'][$key]); + // Check that there is a valid variable name otherwise skip + if ($trimvar == '') { + continue; + } + // Check that this variable does not have the same name as a function + if(in_array($trimvar,qtype_algebra_parser::$functions) or in_array($trimvar,qtype_algebra_parser::$specials)) { + $errors['variable['.$key.']'] = get_string('illegalvarname','qtype_algebra',$trimvar); + } + // Check that this variable has not been defined before + if(in_array($trimvar,$varlist)) { + $errors['variable['.$key.']'] = get_string('duplicatevar','qtype_algebra'); + } else { + // Add the variable to the list of defined variables + $varlist[]=$trimvar; + } + // If the comparison algorithm selected is evaluate then ensure that each variable + // has a valid minimum and maximum defined. For the other types of comparison we can + // ignore the range + if($data['compareby']=='eval') { + // Check that a minimum has been defined + if ($trimmin == '') { + $errors['varmin['.$key.']'] = get_string('novarmin','qtype_algebra'); + } + // If there is one check that it is a number + else if(!preg_match($renumber,$trimmin)) { + $errors['varmin['.$key.']'] = get_string('notanumber','qtype_algebra'); + } + if ($trimmax == '') { + $errors['varmax['.$key.']'] = get_string('novarmax','qtype_algebra'); + } + // If there is one check that it is a number + else if(!preg_match($renumber,$trimmax)) { + $errors['varmax['.$key.']'] = get_string('notanumber','qtype_algebra'); + } + // Check that the minimum is less that the maximum! + if ((float)$trimmin > (float)$trimmax) { + $errors['varmin['.$key.']'] = get_string('varmingtmax','qtype_algebra'); + } + } // end check for eval type + } // end loop over variables + // Check that at least one variable is defined + if (count($varlist)==0) { + $errors['variable[0]'] = get_string('notenoughvars', 'qtype_algebra'); + } + + // Now perform the sanity checks on the answers + // Create a parser which we will use to check that the answers are understandable + $p = new qtype_algebra_parser; + $answers = $data['answer']; + $answercount = 0; + $maxgrade = false; + // Create an empty array to store the used variables + $ansvars=array(); + // Create an empty array to store the used functions + $ansfuncs=array(); + // Loop over all the answers in the form + foreach ($answers as $key => $answer) { + // Try to parse the answer string using the parser. If this fails it will + // throw an exception which we catch to generate the associated error string + // for the expression + try { + $expr=$p->parse($answer); + // Add any new variables to the list we are keeping. First we get the list + // of variables in this answer. Then we get the array of variables which are + // in this answer that are not in any previous answer (using array_diff). + // Finally we merge this difference array with the list of all variables so far + $tmpvars=$expr->get_variables(); + $ansvars=array_merge($ansvars,array_diff($tmpvars,$ansvars)); + // Check that all the variables in this answer have been declared + // Do this by looking for a non-empty array to be returned from the array_diff + // between the list of all declared variables and the variables in this answer + if($d=array_diff($tmpvars,$varlist)) { + $errors['answer['.$key.']'] = get_string('undefinedvar','qtype_algebra',"'".implode("', '",$d)."'"); + } + // Do the same for functions which we did for variables + $ansfuncs=array_merge($ansfuncs,array_diff($expr->get_functions(),$ansfuncs)); + // Check that this is not an empty answer + if (!is_a($expr,"qtype_algebra_parser_nullterm")) { + // Increase the number of answers + $answercount++; + // Check to see if the answer has the maximum grade + if ($data['fraction'][$key] == 1) { + $maxgrade = true; + } + } + } catch (Exception $e) { + $errors['answer['.$key.']']=$e->getMessage(); + // Return here because subsequent errors may be wrong due to not counting the answer + // which just failed to parse + return $errors; + } + } + // Check that we have at least one answer! + if ($answercount==0){ + $errors['answer[0]'] = get_string('notenoughanswers', 'quiz', 1); + } + // Check that at least one question has the maximum possible grade + if ($maxgrade == false) { + $errors['fraction[0]'] = get_string('fractionsnomax', 'question'); + } + + // Check for variables which are defined but never used. + // Do this by looking for a non-empty array to be returned from array_diff. + if($d=array_diff($varlist,$ansvars)) { + // Loop over all the variables in the form + foreach ($vars as $key => $var) { + $trimvar = trim($var); + // If the variable is in the unused array then add the error message to that variable + if(in_array($trimvar,$d)) { + $errors['variable['.$key.']'] = get_string('unusedvar','qtype_algebra'); + } + } + } + + // Check that the tolerance is greater than or equal to zero + if($data['tolerance']<0) { + $errors['tolerance']=get_string('toleranceltzero','qtype_algebra'); + } + + return $errors; + } + + public function qtype() { + return 'algebra'; + } +} + diff --git a/lang/en/qtype_algebra.php b/lang/en/qtype_algebra.php new file mode 100644 index 0000000..814aea8 --- /dev/null +++ b/lang/en/qtype_algebra.php @@ -0,0 +1,91 @@ +SAGE +mathematics software to perform a full symbolic algebraic comparison. + +Evaluation: This method generates random numbers for +the question variables and then evaluates both the student response and the +question\'s answer for that set of values. + +Equivalence: +This is the simplest of all the methods. It will only perform the most basic of +comparisons between expressions.'; +$string['compareby'] = 'Comparison Algorithm'; +$string['comparesage'] = 'SAGE'; +$string['compareeval'] = 'Evaluation'; +$string['compareequiv'] = 'Equivalence'; +$string['correctanswers'] = 'Correct answers'; +$string['correctansweris'] = 'The correct answer is: {$a} giving '; +$string['disallow'] = 'Disallowed Answer'; +$string['disallow_help'] = 'contains an expression which will be disallowed as an answer. +Students entering an answers which matches this will be prevented from +receiving any grade for the question even if the response would match +a given answer for the question.'; +$string['disallowans'] = 'Disallowed Answer'; +$string['disallowanswer'] = 'Disallowed Answer'; +$string['editingalgebra'] = 'Editing an Algebra question'; +$string['evalchecks'] = 'Evaluation Checks'; +$string['filloutoneanswer'] = 'You must provide at least one possible answer. Answers left blank will not be used. \'*\' can be used as a wildcard to match any characters. The first matching answer will be used to determine the score and feedback. Only variables defined above are allowed'; +$string['filloutonevariable'] = 'You must provide at least one variable. All variables used by answers must be entered here. Minimum and a maximum values are only needed if the Evaluation comparison algorithm is used.'; +$string['illegalvarname'] = 'Illegal variable name \'{$a}\': same name as a parser function or special constant'; +$string['nchecks'] = 'Number of Evaluation Checks'; +$string['nchecks_help'] = 'Number of Evaluation Checks used in Evaluation Comparison Algorithm'; +$string['notanumber'] = 'Invalid value: a number is required'; +$string['notenoughvars'] = 'At least one variable is required for all algebra questions'; +$string['novarmax'] = 'No maximum bound specified for variable'; +$string['novarmin'] = 'No minimum bound specified for variable'; +$string['parseerror'] = 'Error parsing function: \'{$a}\''; +$string['restoreqdbfailed'] = 'Restoring algebra question failed: database write error'; +$string['restorevardbfailed'] = 'Restoring algebra question variable failed: database write error'; +$string['tolerance'] = 'Tolerance for Evaluation Checks'; +$string['tolerance_help'] = 'Determines the maximum difference between numerical +evaluations of the student response and question answers which will be +allowed to count as matching.'; +$string['toleranceltzero'] = 'Tolerance must be greater than or equal to zero'; +$string['undefinedvar'] = 'Undefined variable(s) {$a} used in one or more answers'; +$string['unusedvar'] = 'This variable is not used by any answer'; +$string['variable'] = 'Variable Name'; +$string['variablename'] = 'Variable Name'; +$string['variableno'] = 'Variable {$a}'; +$string['variables'] = 'Variables'; +$string['varmin'] = 'Minimum Value'; +$string['varmingtmax'] = 'The minimum value must be less than the maximum value'; +$string['varmax'] = 'Maximum Value'; + +$string['pluginnameadding'] = 'Adding an algebra question'; +$string['pluginnameediting'] = 'Editing an algebra question'; +$string['pluginname_link'] = 'question/type/algebra'; +$string['pluginname_help'] = 'Student enter a formula as response that include one or more variables. Correctness is evaluted using one of 3 differents methods'; +$string['pluginname'] = 'algebra'; +$string['pluginnamesummary'] = 'Student enter a formula that can include one or more variables. Correctness is evaluted using one of 3 differents methods.'; +$string['host'] = 'Host url of SAGE server'; +$string['port'] = 'Port of SAGE server'; +$string['uri'] = 'uri of SAGE server'; diff --git a/lang/en/qtype_algebra_parser.php b/lang/en/qtype_algebra_parser.php new file mode 100644 index 0000000..d4f7241 --- /dev/null +++ b/lang/en/qtype_algebra_parser.php @@ -0,0 +1,20 @@ +. + +/** + * Serve question type files + * + * @since 2.0 + * @package qtype + * @subpackage algebra + * @copyright Dongsheng Cai + * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later + */ + + +defined('MOODLE_INTERNAL') || die(); + + +/** + * Checks file access for algebra questions. + */ +function qtype_algebra_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) { + global $DB, $CFG; + require_once($CFG->libdir . '/questionlib.php'); + question_pluginfile($course, $context, 'qtype_algebra', $filearea, $args, $forcedownload, $options); +} diff --git a/parser.php b/parser.php new file mode 100644 index 0000000..263d951 --- /dev/null +++ b/parser.php @@ -0,0 +1,1721 @@ + +// License: GNU Public License version 3 + + +// From the PHP manual: check for the existance of lcfirst and +// if not found create one. +if(!function_exists('lcfirst')) { + /** + * Make a string's first character lowercase + * + * @param string $str + * @return string the resulting string. + */ + function lcfirst( $str ) { + $str[0] = strtolower($str[0]); + return (string)$str; + } +} + +/** + * Helper function which will compare two strings using their length only. + * + * This function is intended for use in sorting arrays of strings by their string + * length. This is used to order arrays for regular expressions so that the longest + * expressions are checked first. + * + * @param $a first string to compare + * @param $b second string to compare + * @return -1 if $a is longer than $b, 0 if they are the same length and +1 if $a is shorter + */ +function qtype_algebra_parser_strlen_sort($a,$b) { + // Get the two string lengths once so we don't have to repeat the function call + $alen=strlen($a); + $blen=strlen($b); + // If the two lengths are equal return zero + if($alen==$blen) return 0; + // Otherwise return +1 if a>b or -1 if a$blen) ? -1 : +1; +} + + +/** + * Class which represents a single term in an algebraic expression. + * + * A single algebraic term is considered to be either an operation, for example addition, + * subtraction, raising to a power etc. or something operated on, such as a number or + * variable. Each type of term implements a subclass of this base class. + */ +class qtype_algebra_parser_term { + + /** + * Constructor for the generic parser term. + * + * This method is called by all subclasses to initialize the base class for use. + * It initializes the number of arguments required, the format strings to use + * when converting the term in various strng formats, the parser text associated + * with the term and whether the term is one which commutes. + * + * @param $nargs number of arguments which this type of term requires + * @param $formats an array of the format strings for this term keyed by type + * @param $text the text from the expression associated with the array + * @param $commutes if set to true then this term commutes (only for 2 argument terms) + */ + function qtype_algebra_parser_term($nargs,$formats,$text='',$commutes=false) { + $this->_value=$text; + $this->_nargs=$nargs; + $this->_formats=$formats; + $this->_commutes=$commutes; + } + + /** + * Generates the list of arguments needed when converting the term into a string. + * + * This method returns an array with the arguments needed when converting the term + * into a string. The arrys can then be used with a format string to generate the + * string representation. The method is recursive because it needs to convert the + * arguments of the term into strings and so it will walk down the parse tree. + * + * @param $method name of method to call to convert arguments into strings + * @return array of the arguments that, with a format string, can be passed to sprintf + */ + function print_args($method) { + // Create an empty array to store the arguments in + $args=array(); + // Handle zero argument terms differently by making the + // first 'argument' the value of the term itself + if($this->_nargs==0) { + $args[]=$this->_value; + } else { + foreach($this->_arguments as $arg) { + $args[]=$arg->$method(); + } + } + // Return the array of arguments + return $args; + } + + /** + * Produces a 'prettified' string of the expression using the standard input syntax. + * + * This method will use the {@link print_args} method to convert the term and all its + * arguments into a string. + * + * @return input syntax format string of the expression + */ + function str() { + // First check to see if the class has been given all the arguments + $this->check_arguments(); + // Get an array of all the arguments except for the format string + $args=$this->print_args('str'); + // Insert the format string at the front of the argument array + array_unshift($args,$this->_formats['str']); + // Call sprintf using the argument array as the arguments + return call_user_func_array('sprintf',$args); + } + + /** + * Produces a LaTeX formatted string of the expression. + * + * This method will use the {@link print_args} method to convert the term and all its + * arguments into a LaTeX formatted string. This can then be given to the main Moodle + * engine, with TeX filter enabled, to produce a graphical representation of the + * expression. + * + * @return LaTeX format string of the expression + */ + function tex() { + // First check to see if the class has been given all the arguments + $this->check_arguments(); + // Get an array of all the arguments except for the format string + $args=$this->print_args('tex'); + // Insert the format string at the front of the argument array + array_unshift($args,$this->_formats['tex']); + // Call sprintf using the argument array as the arguments + return call_user_func_array('sprintf',$args); + } + + /** + * Produces a SAGE formatted string of the expression. + * + * This method will use the {@link print_args} method to convert the term and all its + * arguments into a SAGE formatted string. This can then be passed to SAGE via XML-RPC + * for symbolic comparisons. The format is very similar to the {@link str} method but + * has all multiplications made explicit with an asterix. + * + * @return SAGE format string of the expression + */ + function sage() { + // First check to see if the class has been given all the arguments + $this->check_arguments(); + // Get an array of all the arguments except for the format string + $args=$this->print_args('sage'); + // Insert the format string at the front of the argument array. First we + // check to see if there is a format element called 'sage' if not then we + // default to the standard string format + if(array_key_exists('sage',$this->_formats)) { + // Insert the sage format string at the front of the argument array + array_unshift($args,$this->_formats['sage']); + } else { + // Insert the normal format string at the front of the argument array + array_unshift($args,$this->_formats['str']); + } + // Call sprintf using the argument array as the arguments + return call_user_func_array('sprintf',$args); + } + + /** + * Returns the list of arguments for the term. + * + * This method provides access to the arguments of the term. Although this should + * ideally be private information it is needed in certain cases to determine + * how neighbouring terms should display themselves. + * + * @return array of arguments for this term + */ + function arguments() { + return $this->_arguments; + } + + /** + * Sets the arguments of the term to the values in the given array. + * + * The code here overrides the base class's method. The code uses this method to actually + * set the arguments in the given array but a second stage to choose the format of the + * multiplication operator is required. This is because a 'x' symbol is required when + * multiplying two numbers. However this can be omitted when multiplying two variables, + * a variable and a function etc. + * + * @param $args array to set the arguments of the term to + */ + function set_arguments($args) { + if (count($args)!=$this->_nargs) { + throw new Exception(get_string('nargswrong','qtype_algebra',$this->_value)); + } + $this->_arguments=$args; + } + + /** + * Checks to ensure that the correct number of arguments are defined. + * + * Note that this method just checks for the number or arguments it does not check + * whether they are valid arguments. If the parameter passed is true (default value) + * an exception will be thrown if the correct number of arguments are not present. Otherwise + * the function returns false. + * + * @param $exc if true then an exception will be thrown if the number of arguments is incorrect + * @return true if the correct number of arguments are present, false otherwise + */ + function check_arguments($exc=true) { + $retval=(count($this->_arguments)==$this->_nargs); + if($exc && !$retval) { + throw new Exception(get_string('nargswrong','qtype_algebra',$this->_value)); + } else { + return $retval; + } + } + + /** + * Returns a list of all the variable names found in the expression. + * + * This method uses the {@link collect} method to walk down the parse tree and collect + * a list of all the variables which the parser has found in the expression. The names + * of the variables are then returned. + * + * @return an array containing all the variables names in the expression + */ + function get_variables() { + $list=array(); + $this->collect($list,'qtype_algebra_parser_variable'); + return array_keys($list); + } + + /** + * Returns a list of all the function names found in the expression. + * + * This method uses the {@link collect} method to walk down the parse tree and collect + * a list of all the functions which the parser has found in the expression. The names + * of the functions are then returned. + * + * @return an array containing all the function names used in the expression + */ + function get_functions() { + $list=array(); + $this->collect($list,'qtype_algebra_parser_function'); + return array_keys($list); + } + + /** + * Collects all the terms of a given type with unique values in the parse tree + * + * This method walks recursively down the parse tree by calling itself for the arguments + * of the current term. The method simply adds the current term to the given imput array + * using a key set to the value of the term but only if the term matches the selected type. + * In this way terms only a single entry per term value is return which is the functionality + * required for the {@link get_variables} and {@link get_functions} methods. + * + * @param $list the array to add the term to if it matches the type + * @param $type the name of the type of term to collect. + * @return an array containing all the terms of the selected type keyed by their value + */ + function collect(&$list,$type) { + // Add this class to the list if of the correct type + if(is_a($this,$type)) { + // Add a key to the array with the value of the term, this means + // that multiple terms with the same value will overwrite each + // other so only one will remain. + $list[$this->_value]=0; + } + // Now loop over all the argument for this term (if any) and check them + foreach($this->_arguments as $arg) { + // Collect terms from the arguments as well + $arg->collect($list,$type); + } + } + + /** + * Checks to see if this term is equal to another term ignoring arguments. + * + * This method compares the current term to another term. The default method simply compares + * the class of each term. Terms which require more than this, for example comparing values + * too, override this method in theor own classes. + * + * @param $term the term to compare to the current one + * @return true if the terms match, false otherwise + */ + function equals($term) { + // Default method just checks to ensure that the Terms are both of the same type + return is_a($term,get_class($this)); + } + + /** + * Compares this term, including any arguments, with another term. + * + * This method uses the {@link equals} method to see if the current and given term match. + * It then looks at any arguments which the two terms have and, recursively, calls their + * compare methods to determine if they also match. For terms with two arguments which + * also commute the reverse ordering of the arguments is also tried if the first order + * fails to match. + * + * @param $expr top level term of an expression to compare against + * @return true if the expressions match, false otherwise + */ + function equivalent($expr) { + // Check that the argument is also a term + if(!is_a($expr,'qtype_algebra_parser_term')) { + throw new Exception(get_string('badequivtype','qtype_algebra')); + } + // Now check that this term is the same as the given term + if(!$this->equals($expr)) { + // Terms are not equal immediately return false since the two do not match + return false; + } + // Now compare the arguments recursively... + switch($this->_nargs) { + case 0: + // For zero arguments we already compared this class and found it the same so + // because there are no arguments to check we are equivalent! + return true; + case 1: + // For one argument we also need to compare the argument of each term + return $this->_arguments[0]->equivalent($expr->_arguments[0]); + case 2: + // Now it gets interesting. First we compare the two arguments in the same + // order and see what we get... + if($this->_arguments[0]->equivalent($expr->_arguments[0]) and + $this->_arguments[1]->equivalent($expr->_arguments[1])) { + // Both arguments are equivalent so we have a match + return true; + } + // Otherwise if the operator commutes we can see if the first argument matches + // the second argument and vice versa + else if($this->_commutes and $this->_arguments[0]->equivalent($expr->_arguments[1]) and + $this->_arguments[1]->equivalent($expr->_arguments[0])) { + return true; + } else { + return false; + } + default: + throw new Exception(get_string('morethantwoargs','qtype_algebra')); + } + } + + /** + * Returns the number of arguments required by the term. + * + * @return the number of arguments required by the term + */ + function n_args() { + return $this->_nargs; + } + + /** + * Evaluates the term numerically using the given variable values. + * + * The given parameter array is keyed by the name of the variable and the numerical + * value to assign it is stored in the array value. This method is an abstract one + * which must be implemented by all subclasses. Failure to do so will generate an + * exception when the method is called. + * + * @param $params array of values keyed by variable name + * @return the numerical value of the term given the provided values for the variables + */ + function evaluate($params) { + throw new Exception(get_string('noevaluate','qtype_algebra',$this->_value)); + } + + /** + * Dumps the term and its arguments to standard out. + * + * This method will recursively call the entire parse tree attached to it and produce + * a nicely formatted dump of the term structure. This is mainly useful for debugging + * purposes. + * + * @param $indent string containing the indentation to use + * @param $params variable values to use if an evaluation is also desired + * @return a string indicating the type of the term + */ + function dump(&$params=array(),$indent='') { + echo "$indent_value; + if(!empty($params)) { + echo ' eval=\''.$this->evaluate($params)."'>\n"; + } else { + echo "'>\n"; + } + foreach($this->_arguments as $arg) { + $arg->dump($params,$indent.' '); + } + } + + /** + * Special casting operator method to convert the term object to a string. + * + * This is primarily a debug method. It is called when the term object is cast into a + * string, such as happens when echoing or printing it. It simply returns a string + * indicating the type of the parser term. + * + * @return a string indicating the type of the term + */ + function __toString() { + return ''; + } + + // Member variables + var $_value; // String of the actual term itself + var $_arguments=array(); // Array of arguments in class form + var $_formats; // Array of format strings + var $_nargs; // Number of arguments for this term +} + +/** + * Class representing a null, or empty, term. + * + * This is the type of term returned when the parser is given an empty string to parse. + * It takes no arguments and will never be found in a parser tree. This term is solely + * to give a valid return type for an empty string condition and so avoids the need to + * throw an exception in such cases. + */ +class qtype_algebra_parser_nullterm extends qtype_algebra_parser_term { + + /** + * Constructs an instance of a null term. + * + * Initializes a null term class. Since this class represents nothing no special + * initialization is required and no arguments are needed. + */ + function qtype_algebra_parser_nullterm() { + parent::qtype_algebra_parser_term(self::NARGS,self::$formats,''); + } + + /** + * Returns the array of arguments needed to convert this class into a string. + * + * Since this class is represented by an empty string which has no formatting fields + * we override the base class method to return an empty array. + * + * @param $method name of method to call to convert arguments into strings + * @return array of the arguments that, with a format string, can be passed to sprintf + */ + function print_args($method) { + return array(); + } + + /** + * Evaluates the term numerically. + * + * Since this is an empty term we define the evaluation as zero regardless of the parameters. + * + * @param $params array of the variable values to use + */ + function evaluate($params) { + // Return something which is not a number + return acos(2.0); + } + + // Static class properties + const NARGS=0; + private static $formats=array('str' => '', + 'tex' => ''); +} + + +/** + * Class representing a number. + * + * All purely numerical quantities will be represented by this type of class. There are + * two basic types of numbers: non-exponential and exponential. Both types are handled by + * this single class. + */ +class qtype_algebra_parser_number extends qtype_algebra_parser_term { + + /** + * Constructs an instance of a number term. + * + * This function initializes an instance of a number term using the string which + * matches the number's regular expression. + * + * @param $text string matching the number regular expression + */ + function qtype_algebra_parser_number($text='') { + // Unfortunately PHP maths will only support a '.' as a decimal point and will not support + // ',' as used in Danish, French etc. To allow for this we always convert any commas into + // decimal points before we parse the string + $text=str_replace(',','.',$text); + $this->_sign=''; + // Now determine whether this is in exponent form or just a plain number + if(preg_match('/([\.0-9]+)E([-+]?\d+)/',$text,$m)) { + $this->_base=$m[1]; + $this->_exp=$m[2]; + $eformats=array('str' => '%sE%s', + 'tex' => '%s '.get_string('multiply','qtype_algebra').' 10^{%s}'); + parent::qtype_algebra_parser_term(self::NARGS,$eformats,$text); + } else { + $this->_base=$text; + $this->_exp=''; + parent::qtype_algebra_parser_term(self::NARGS,self::$formats,$text); + } + } + + /** + * Sets this number to be negative. + * + * This method will convert the number into a nagetive one. It is called when + * the parser finds a subtraction operator in front of the number which does + * not have a variable or another number preceding it. + */ + function set_negative() { + // Prepend a minus sign to both the base and total value strings + $this->_base='-'.$this->_base; + $this->_value='-'.$this->_value; + $this->_sign='-'; + } + + /** + * Checks to see if this number is equal to another number. + * + * This is a two step process. First we use the base class equals method to ensure + * that we are comparing two numbers. Then we check that the two have the same value. + * + * @param $expt the term to compare to the current one + * @return true if the terms match, false otherwise + */ + function equals($expr) { + // Call the default method first to check type + if(parent::equals($expr)) { + return (float)$this->_value==(float)$expr->_value; + } else { + return false; + } + } + + /** + * Generates the list of arguments needed when converting the term into a string. + * + * For number terms there are two possible formats: those with an exponent and those + * without an exponent. This method determines which to use and then pushes the correct + * arguments into the array which is returned. + * + * @param $method name of method to call to convert arguments into strings + * @return array of the arguments that, with a format string, can be passed to sprintf + */ + function print_args($method) { + // When displaying the number we need to worry about whether to use a decimal point + // or a comma depending on the language currently selected/ Do this by replacing the + // decimal point (which we have to use internally because of the PHP math standard) + // with the correct string from the language pack + $base=str_replace('.',get_string('decimal','qtype_algebra'),$this->_base); + // Put the base part of the number into the argument array + $args=array($base); + // Check to see if we have an exponent... + if($this->_exp) { + // ...we do so add it to the argument array as well + $args[]=$this->_exp; + } + // Return the list of arguments + return $args; + } + + /** + * Evaluates the term numerically. + * + * All this method does is return the string representing the number cast as a double + * precision floating point variable. + * + * @param $params array of the variable values to use + */ + function evaluate($params) { + return doubleval($this->_value); + } + + // Static class properties + const NARGS=0; + private static $formats=array('str' => '%s', + 'tex' => '%s '); +} + +/** + * Class representing a variable term in an algebraic expression. + * + * When the parser finds a text string which does not correspond to a function it creates + * this type of term and puts the contents of that text into it. Variables with names + * corresponding to the names of the greek letters are replaced by those letters when + * rendering the term in LaTeX. Other variables display their first letter with all + * subsequent letters being lowercase. This reduces confusion when rendering expressions + * consisting of multiplication of two variables. + */ +class qtype_algebra_parser_variable extends qtype_algebra_parser_term { + // Define the list of variable names which will be replaced by greek letters + public static $greek = array ( + 'alpha', + 'beta', + 'gamma', + 'delta', + 'epsilon', + 'zeta', + 'eta', + 'theta', + 'iota', + 'kappa', + 'lambda', + 'mu', + 'nu', + 'xi', + 'omicron', + 'pi', + 'rho', + 'sigma', + 'tau', + 'upsilon', + 'phi', + 'chi', + 'psi', + 'omega' + ); + + /** + * Constructor for an algebraic term cass representing a variable. + * + * Initializes an instance of the variable term subclass. The method is given the text + * in the expression corresponding to the variable name. This is then parsed to get the + * variable name which is split into a base and subscript. If the start of the string + * matches the name of a greek letter this is taken as the base and the remainder as the + * subscript. Failing that either the subscript must be explicitly specified using an + * underscore character or the first character is taken as the base. + * + * @param $text text matching the variable name + */ + function qtype_algebra_parser_variable($text) { + // Create the array to store the regular expression matches in + $m=array(); + // Set the sign of the variable to be empty + $this->_sign=''; + // Try to match the text to a greek letter + if(preg_match('/('.implode('|',self::$greek).')/A',$text,$m)) { + // Take the base name of the variable to be the greek letter + $this->_base=$m[1]; + // Extract the remaining characters for use as the subscript + $this->_subscript=substr($text,strlen($m[1])); + // If the first letter of the subscript is an underscore then remove it + if($this->_subscript[0] == '_') { + $this->_subscript=substr($this->_subscript,1); + } + // Call the base class constructor with the variable text set to the combination of the + // base name and the subscript without an underscore between them + parent::qtype_algebra_parser_term(self::NARGS,self::$formats['greek'], + $this->_base.$this->_subscript); + } + // Otherwise we have a simple multi-letter variable name. Treat the fist letter as the base + // name and the rest as the subscript + else { + // Get the variable's base name + $this->_base=substr($text,0,1); + // Now set the subscript to the remaining letters + $this->_subscript=substr($text,1); + // If the first letter of the subscript is an underscore then remove it + if($this->_subscript[0] == '_') { + $this->_subscript=substr($this->_subscript,1); + } + // Call the base class constructor with the variable text set to the combination of the + // base name and the subscript without an underscore between them + parent::qtype_algebra_parser_term(self::NARGS,self::$formats['std'], + $this->_base.$this->_subscript); + } + } + + /** + * Sets this variable to be negative. + * + * This method will convert the number into a nagetive one. It is called when + * the parser finds a subtraction operator in front of the number which does + * not have a variable or another number preceding it. + */ + function set_negative() { + // Set the sign to be a '-' + $this->_sign='-'; + } + + /** + * Generates the list of arguments needed when converting the term into a string. + * + * The string of the variable depends solely on the name and subscript and hence these + * are the only two arguments returned in the array. + * + * @param $method name of method to call to convert arguments into strings + * @return array of the arguments that, with a format string, can be passed to sprintf + */ + function print_args($method) { + return array($this->_sign,$this->_base,$this->_subscript); + } + + /** + * Evaluates the number numerically. + * + * Overrides the base class method to simply return the numerical value of the number the + * class represents. + * + * @param $params array of values keyed by variable name + * @return the numerical value of the term given the provided values for the variables + */ + function evaluate($params) { + if($this->_sign=='-') { + $mult=-1; + } else { + $mult=1; + } + if(array_key_exists($this->_value,$params)) { + return $mult*doubleval($params[$this->_value]); + } else { + // Found an indefined variable. Cannot evaluate numerically so throw exception + throw new Exception(get_string('undefinedvariable','qtype_algebra',$this->_value)); + } + } + + /** + * Checks to see if this variable is equal to another variable. + * + * This is a two step process. First we use the base class equals method to ensure + * that we are comparing two variables. Then we check that the two are the same variable. + * + * @param $expr the term to compare to the current one + * @return true if the terms match, false otherwise + */ + function equals($expr) { + // Call the default method first to check type + if(parent::equals($expr)) { + return $this->_value==$expr->_value and $this->_sign==$expr->_sign; + } else { + return false; + } + } + + // Static class properties + const NARGS=0; + private static $formats=array( + 'greek' => array('str' => '%s%s%s', + 'tex' => '%s\%s_{%s}'), + 'std' => array('str' => '%s%s%s', + 'tex' => '%s%s_{%s}') + ); +} + + +/** + * Class representing a power operation in an algebraic expression. + * + * The parser creates an instance of this term when it finds a string matching the power + * operator's syntax. The string which corresponds to the term is passed to the constructor + * of this subclass. + */ +class qtype_algebra_parser_power extends qtype_algebra_parser_term { + + /** + * Constructs an instance of a power operator term. + * + * This function initializes an instance of a power operator term using the string which + * matches the power operator expression. Since this is simply the character representing + * the operator it is not used except when producing a string representation of the term. + * + * @param $text string matching the term's regular expression + */ + function qtype_algebra_parser_power($text) { + parent::qtype_algebra_parser_term(self::NARGS,self::$formats,$text); + } + + /** + * Evaluates the power operation numerically. + * + * Overrides the base class method to simply return the numerical value of the power + * operation. The method evaluates the two arguments of the term and then passes them to + * the 'pow' function from the maths library. + * + * @param $params array of values keyed by variable name + * @return the numerical value of the term given the provided values for the variables + */ + function evaluate($params) { + $this->check_arguments(); + return pow(doubleval($this->_arguments[0]->evaluate($params)), + doubleval($this->_arguments[1]->evaluate($params))); + } + + // Static class properties + const NARGS=2; + private static $formats=array( + 'str' => '%s^%s', + 'tex' => '%s^{%s}' + ); +} + + +/** + * Class representing a divide operation in an algebraic expression. + * + * The parser creates an instance of this term when it finds a string matching the divide + * operator's syntax. The string which corresponds to the term is passed to the constructor + * of this subclass. + */ +class qtype_algebra_parser_divide extends qtype_algebra_parser_term { + + /** + * Constructs an instance of a divide operator term. + * + * This function initializes an instance of a divide operator term using the string which + * matches the divide operator expression. Since this is simply the character representing + * the operator it is not used except when producing a string representation of the term. + * + * @param $text string matching the term's regular expression + */ + function qtype_algebra_parser_divide($text) { + parent::qtype_algebra_parser_term(self::NARGS,self::$formats,$text); + } + + /** + * Evaluates the divide operation numerically. + * + * Overrides the base class method to simply return the numerical value of the divide + * operation. The method evaluates the two arguments of the term and then simply divides + * them to get the return value. + * + * @param $params array of values keyed by variable name + * @return the numerical value of the term given the provided values for the variables + */ + function evaluate($params) { + $this->check_arguments(); + // Get the value we are trying to divide by + $divby=$this->_arguments[1]->evaluate($params); + // Check to see if this is zero + if($divby==0) { + // Check the sign of the other argument and use to determine whether we return + // plus or minus infinity + return INF*$this->_arguments[0]->evaluate($params); + } else { + return $this->_arguments[0]->evaluate($params)/$divby; + } + } + + // Static class properties + const NARGS=2; + private static $formats=array( + 'str' => '%s/%s', + 'tex' => '\\frac{%s}{%s}' + ); +} + + +/** + * Class representing a multiplication operation in an algebraic expression. + * + * The parser creates an instance of this term when it finds a string matching the multiplication + * operator's syntax. The string which corresponds to the term is passed to the constructor + * of this subclass. + */ +class qtype_algebra_parser_multiply extends qtype_algebra_parser_term { + + /** + * Constructs an instance of a multiplication operator term. + * + * This function initializes an instance of a multiplication operator term using the string which + * matches the multiplication operator expression. Since this is simply the character representing + * the operator it is not used except when producing a string representation of the term. + * + * @param $text string matching the term's regular expression + */ + function qtype_algebra_parser_multiply($text) { + $this->mformats=array('*' => array('str' => '%s*%s', + 'tex' => '%s '.get_string('multiply','qtype_algebra').' %s'), + '.' => array('str' => '%s %s', + 'tex' => '%s %s', + 'sage'=> '%s*%s') + ); + parent::qtype_algebra_parser_term(self::NARGS,$this->mformats['*'],$text,true); + } + + /** + * Sets the arguments of the term to the values in the given array. + * + * This method sets the term's arguments to those in the given array. + * + * @param $args array to set the arguments of the term to + */ + function set_arguments($args) { + // First perform default argument setting method. This will generate + // an error if there is a problem with the number of arguments + parent::set_arguments($args); + // Set the default explicit format + $this->_formats=$this->mformats['*']; + // Only allow the implicit multipication if the second argument is either a + // special, variable, function or bracket and not negative. In all other cases the operator must be + // explicitly written + if(is_a($args[1],'qtype_algebra_parser_bracket') or + is_a($args[1],'qtype_algebra_parser_variable') or + is_a($args[1],'qtype_algebra_parser_special') or + is_a($args[1],'qtype_algebra_parser_function')) { + if(!method_exists($args[1],'set_negative') or $args[1]->_sign=='') { + $this->_formats=$this->mformats['.']; + } + } + // Check for one more special exemption: if the second argument is a power expression + // then we use the same criteria on the first argument of it + if(is_a($args[1],'qtype_algebra_parser_power')) { + // Get the arguments from the power term. Note we do not check these since + // power terms are parsed before multiplication ones and are required to + // have two arguments. + $powargs=$args[1]->arguments(); + // Allow the implicit multipication if the power's first argument is either a + // special, variable, function or bracket and not negative. + if(is_a($powargs[0],'qtype_algebra_parser_bracket') or + is_a($powargs[0],'qtype_algebra_parser_variable') or + is_a($powargs[0],'qtype_algebra_parser_special') or + is_a($powargs[0],'qtype_algebra_parser_function')) { + if(!method_exists($powargs[0],'set_negative') or $powargs[0]->_sign=='') { + $this->_formats=$this->mformats['.']; + } + } + } + } + + /** + * Evaluates the multiplication operation numerically. + * + * Overrides the base class method to simply return the numerical value of the multiplication + * operation. The method evaluates the two arguments of the term and then simply multiplies + * them to get the return value. + * + * @param $params array of values keyed by variable name + * @return the numerical value of the term given the provided values for the variables + */ + function evaluate($params) { + $this->check_arguments(); + return $this->_arguments[0]->evaluate($params)* + $this->_arguments[1]->evaluate($params); + } + + // Static class properties + const NARGS=2; +} + + +/** + * Class representing a addition operation in an algebraic expression. + * + * The parser creates an instance of this term when it finds a string matching the addition + * operator's syntax. The string which corresponds to the term is passed to the constructor + * of this subclass. + */ +class qtype_algebra_parser_add extends qtype_algebra_parser_term { + + /** + * Constructs an instance of a addition operator term. + * + * This function initializes an instance of a addition operator term using the string which + * matches the addition operator expression. Since this is simply the character representing + * the operator it is not used except when producing a string representation of the term. + * + * @param $text string matching the term's regular expression + */ + function qtype_algebra_parser_add($text) { + parent::qtype_algebra_parser_term(self::NARGS,self::$formats,$text,true); + } + + /** + * Evaluates the addition operation numerically. + * + * Overrides the base class method to simply return the numerical value of the addition + * operation. The method evaluates the two arguments of the term and then simply adds + * them to get the return value. + * + * @param $params array of values keyed by variable name + * @return the numerical value of the term given the provided values for the variables + */ + function evaluate($params) { + $this->check_arguments(); + return $this->_arguments[0]->evaluate($params)+ + $this->_arguments[1]->evaluate($params); + } + + // Static class properties + const NARGS=2; + private static $formats=array( + 'str' => '%s+%s', + 'tex' => '%s + %s' + ); +} + + +/** + * Class representing a subtraction operation in an algebraic expression. + * + * The parser creates an instance of this term when it finds a string matching the subtraction + * operator's syntax. The string which corresponds to the term is passed to the constructor + * of this subclass. + */ +class qtype_algebra_parser_subtract extends qtype_algebra_parser_term { + + /** + * Constructs an instance of a subtraction operator term. + * + * This function initializes an instance of a subtraction operator term using the string which + * matches the subtraction operator expression. Since this is simply the character representing + * the operator it is not used except when producing a string representation of the term. + * + * @param $text string matching the term's regular expression + */ + function qtype_algebra_parser_subtract($text) { + parent::qtype_algebra_parser_term(self::NARGS,self::$formats,$text); + } + + /** + * Evaluates the subtraction operation numerically. + * + * Overrides the base class method to simply return the numerical value of the subtraction + * operation. The method evaluates the two arguments of the term and then simply subtracts + * them to get the return value. + * + * @param $params array of values keyed by variable name + * @return the numerical value of the term given the provided values for the variables + */ + function evaluate($params) { + $this->check_arguments(); + return $this->_arguments[0]->evaluate($params)- + $this->_arguments[1]->evaluate($params); + } + + // Static class properties + const NARGS=2; + private static $formats=array( + 'str' => '%s-%s', + 'tex' => '%s - %s' + ); +} + + +/** + * Class representing a special constant in an algebraic expression. + * + * The parser creates an instance of this term when it finds a string matching the a predefined + * special constant such as pi or 'e' (from natural logarithms). + */ +class qtype_algebra_parser_special extends qtype_algebra_parser_term { + + /** + * Constructs an instance of a special constant term. + * + * This function initializes an instance of a special term using the string which + * matches the regular expression of a special constant. + * + * @param $text string matching a constant's regular expression + */ + function qtype_algebra_parser_special($text) { + parent::qtype_algebra_parser_term(self::NARGS,self::$formats[$text],$text); + $this->_sign=''; + } + + /** + * Sets this special to be negative. + * + * This method will convert the number into a nagetive one. It is called when + * the parser finds a subtraction operator in front of the number which does + * not have a variable or another number preceding it. + */ + function set_negative() { + // Set the sign to be a '-' + $this->_sign='-'; + } + + /** + * Evaluates the special constant numerically. + * + * Overrides the base class method to simply return the numerical value of the special + * constant which is defined by an internal switch based on the constant's name. + * + * @param $params array of values keyed by variable name + * @return the numerical value of the term given the provided values for the variables + */ + function evaluate($params) { + if($this->_sign=='-') { + $mult=-1; + } else { + $mult=1; + } + switch($this->_value) { + case 'pi': + return $mult*pi(); + case 'e': + return $mult*exp(1); + default: + return 0; + } + } + + /** + * Returns the array of arguments needed to convert this special term into a string. + * + * The special term generally has a fixed, predefined formatting already hard coded so + * the only remaining variable is the sign of the term and this is what this method + * returns. + * + * @param $method name of method to call to convert arguments into strings + * @return array of the arguments that, with a format string, can be passed to sprintf + */ + function print_args($method) { + return array($this->_sign); + } + + /** + * Checks to see if this constant is equal to another term. + * + * This is a two step process. First we use the base class equals method to ensure + * that we are comparing two variables. Then we check that the two are the same constant. + * + * @param $expr the term to compare to the current one + * @return true if the terms match, false otherwise + */ + function equals($expr) { + // Call the default method first to check type + if(parent::equals($expr)) { + return $this->_value==$expr->_value and $this->_sign==$this->_sign; + } else { + return false; + } + } + + // Static class properties + const NARGS=0; + private static $formats=array( + 'pi' => array( 'str' => '%spi', + 'tex' => '%s\\pi'), + 'e' => array( 'str' => '%se', + 'tex' => '%se') + ); +} + + +/** + * Class representing a function in an algebraic expression. + * + * The parser creates an instance of this term when it finds a string matching the function's + * syntax. The string which corresponds to the term is passed to the constructor + * of this subclass. + */ +class qtype_algebra_parser_function extends qtype_algebra_parser_term { + + /** + * Constructs an instance of a function term. + * + * This function initializes an instance of a function term using the string which + * matches the name of a function. + * + * @param $text string matching the function's regular expression + */ + function qtype_algebra_parser_function($text) { + if(!function_exists($text) and !array_key_exists($text,self::$fnmap)) { + throw new Exception(get_string('undefinedfunction','qtype_algebra',$text)); + } + $formats=array( 'str' => '%s'.$text.'%s'); + if(array_key_exists($text,self::$texmap)) { + $formats['tex']='%s'.self::$texmap[$text].' %s'; + } else { + $formats['tex']='%s\\'.$text.' %s'; + } + $this->_sign=''; + parent::qtype_algebra_parser_term(self::NARGS,$formats,$text); + } + + /** + * Sets this function to be negative. + * + * This method will convert the function into a negative one. It is called when + * the parser finds a subtraction operator in front of the function which does + * not have a variable or another number preceding it e.g. 3*-sin(x) + */ + function set_negative() { + // Set the sign to be a '-' + $this->_sign='-'; + } + + /** + * Sets the arguments of the term to the values in the given array. + * + * The code here overrides the base class's method. The code uses this method to actually + * set the arguments in the given array but a second stage to insert brackets around the + * function's argument is required. + * + * @param $args array to set the arguments of the term to + */ + function set_arguments($args) { + if(count($args)!=$this->_nargs) { + throw new Exception(get_string('badfuncargs','qtype_algebra',$this->_value)); + } + if(!is_a($args[0],'qtype_algebra_parser_bracket')) { + // Check to see if this function requires a special bracket + if(in_array($this->_value,self::$bracketmap)) { + $b=new qtype_algebra_parser_bracket('<'); + } + // Does not require special brackets so create normal ones + else { + $b=new qtype_algebra_parser_bracket('('); + } + $b->set_arguments($args); + $this->_arguments=array($b); + } + // First term already a bracket + else { + // Check to see if we need a special bracket + if(in_array($this->_value,self::$bracketmap)) { + // Make the bracket special + $args[0]->make_special(); + } + // Set the arguments to the given type + $this->_arguments=$args; + } + } + + /** + * Generates the list of arguments needed when converting the term into a string. + * + * The string of the function depends solely on the function argument and the sign. + * The name has already been coded in at construction time. + * + * @param $method name of method to call to convert arguments into strings + * @return array of the arguments that, with a format string, can be passed to sprintf + */ + function print_args($method) { + // First ensure that there are the correct number of arguments + $this->check_arguments(); + return array($this->_sign,$this->_arguments[0]->$method()); + } + + /** + * Evaluates the function numerically. + * + * Overrides the base class method to simply return the numerical value of the function. + * Each function name is first checked against an internal map to determine the corresponding + * PHP math function to call. If the function is not in the map it is assumed to already be + * the correct name for a PHP math function. + * + * @param $params array of values keyed by variable name + * @return the numerical value of the term given the provided values for the variables + */ + function evaluate($params) { + // First ensure that there are the correct number of arguments + $this->check_arguments(); + // Get the correct sign to multiply the value by + if($this->_sign=='-') { + $mult=-1; + } else { + $mult=1; + } + // Check to see if there is an entry to map the function name to a PHP function + if(array_key_exists($this->_value,self::$fnmap)) { + $func=self::$fnmap[$this->_value]; + return $mult*$func($this->_arguments[0]->evaluate($params)); + } + // No map entry so the function name must already be a PHP function... + else { + $tmp=$this->_value; + return $mult*$tmp($this->_arguments[0]->evaluate($params)); + } + } + + /** + * Checks to see if this function is equal to another term. + * + * This is a two step process. First we use the base class equals method to ensure + * that we are comparing two variables. Then we check that the two are the same constant. + * + * @param $expr the term to compare to the current one + * @return true if the terms match, false otherwise + */ + function equals($expr) { + // Call the default method first to check type + if(parent::equals($expr)) { + return $this->_value==$expr->_value and $this->_sign==$this->_sign; + } else { + return false; + } + } + + // Static class properties + const NARGS=1; + public static $fnmap = array ('ln' => 'log', + 'log' => 'log10' + ); + public static $texmap = array('asin' => '\\sin^{-1}', + 'acos' => '\\cos^{-1}', + 'atan' => '\\tan^{-1}', + 'sqrt' => '\\sqrt' + ); + // List of functions requiring special brackets + public static $bracketmap = array ('sqrt' + ); +} + + +/** + * Class representing a bracket operation in an algebraic expression. + * + * The parser creates an instance of this term when it finds a string matching the bracket + * operator's syntax. The string which corresponds to the term is passed to the constructor + * of this subclass. Note that a pair of brackets is treated as a single term. There are no + * separate open and close bracket operators. + */ +class qtype_algebra_parser_bracket extends qtype_algebra_parser_term { + + function qtype_algebra_parser_bracket($text) { + parent::qtype_algebra_parser_term(self::NARGS,self::$formats[$text],$text); + $this->_open=$text; + switch($this->_open) { + case '(': + $this->_close=')'; + break; + case '[': + $this->_close=']'; + break; + case '{': + $this->_close='}'; + break; + // Special kind of bracket. This behaves as normal brackets for a string but as invisible + // curly brackets '{}' with LaTeX. + case '<': + $this->_close='>'; + break; + } + } + + /** + * Evaluates the bracket operation numerically. + * + * Overrides the base class method to simply return the numerical value of the bracket + * operation. The method evaluates the argument of the term, i.e. what is inside the + * brackets, and then returns the value. + * + * @param $params array of values keyed by variable name + * @return the numerical value of the term given the provided values for the variables + */ + function evaluate($params) { + if(count($this->_arguments)!=$this->_nargs) { + return 0; + } + return $this->_arguments[0]->evaluate($params); + } + + /** + * Set the bracket type to 'special'. + * + * The method converts the bracket to the special type. The special type appears as a + * normal bracket in string mode but produces the invisible curly brackets for LaTeX. + */ + function make_special() { + $this->_open='<'; + $this->_close='>'; + // Call the base class constructor as if this were a new instance of the bracket + parent::qtype_algebra_parser_term(self::NARGS,self::$formats['<'],'<'); + } + + // Member variables + var $_open='('; + var $_close=')'; + + // Static class properties + const NARGS=1; + private static $formats=array( + '(' => array('str' => '(%s)', + 'tex' => '\\left( %s \\right)'), + '[' => array('str' => '[%s]', + 'tex' => '\\left[ %s \\right]'), + '{' => array('str' => '{%s}', + 'tex' => '\\left\\lbrace %s \\right\\rbrace'), + '<' => array('str' => '(%s)', + 'tex' => '{%s}') + ); +} + + + +/** + * The main parser class. + * + * This class implements the methods needed to parse an expression. It uses a series of + * regular expressions to indentify the different terms in the expression and then creates + * instances of the correct subclass to handle them. + */ +class qtype_algebra_parser { + // Special constants which the parser will understand + public static $specials = array ( + 'pi', + 'e' + ); + + // Functions which the parser will understand. These should all be standard PHP math functions. + public static $functions = array ('sqrt', + 'ln', + 'log', + 'cosh', + 'sinh', + 'sin', + 'cos', + 'tan', + 'asin', + 'acos', + 'atan' + ); + + // Array to define the priority of the different operations. The parser implements the standard BODMAS priority: + // brackets, order (power), division, mulitplication, addition, subtraction + private static $priority = array ( + array('qtype_algebra_parser_power'), + array('qtype_algebra_parser_function'), + array('qtype_algebra_parser_divide','qtype_algebra_parser_multiply'), + array('qtype_algebra_parser_add','qtype_algebra_parser_subtract') + ); + + // Regular experssion to match an open bracket + private static $OPENB = '/[\{\(\[]/A'; + // Regular experssion to match a close bracket + private static $CLOSEB = '/[\}\)\]]/A'; + // Regular expression to match a plain float or integer number without exponent + private static $PLAIN_NUMBER = '(([0-9]+(\.|,)[0-9]*)|([0-9]+)|((\.|,)[0-9]+))'; + // Regular expression to match a float or integer number with an exponent + private static $EXP_NUMBER = '(([0-9]+(\.|,)[0-9]*)|([0-9]+)|((\.|,)[0-9]+))E([-+]?\d+)'; + // Array to associate close brackets with the correct open bracket type + private static $BRACKET_MAP = array(')' => '(', ']' => '[', '}' => '{'); + + /** + * Constructor for the main parser class. + * + * This constructor initializes the token map of the main parser class. It constructs a map of + * regular expressions to class types. As it parses a string it uses these regular expressions to + * find tokens in the input string which are then fed to the corresponding term class for + * interpretation. + */ + function qtype_algebra_parser() { + $this->_tokens = array ( + array ('/(\^|\*\*)/A', 'qtype_algebra_parser_power' ), + array ('/('.implode('|',self::$functions).')/A', 'qtype_algebra_parser_function' ), + array ('/\//A', 'qtype_algebra_parser_divide' ), + array ('/\*/A', 'qtype_algebra_parser_multiply' ), + array ('/\+/A', 'qtype_algebra_parser_add' ), + array ('/-/A', 'qtype_algebra_parser_subtract' ), + array ('/('.implode('|',self::$specials).')/A', 'qtype_algebra_parser_special' ), + array ('/('.self::$EXP_NUMBER.'|'.self::$PLAIN_NUMBER.')/A', 'qtype_algebra_parser_number' ), + array ('/[A-Za-z][A-Za-z0-9_]*/A', 'qtype_algebra_parser_variable' ) + ); + } + + /** + * Parses a given string containing an algebric epxression and returns the corresponding parse tree. + * + * This method loops over the string using the regular expressions in the token map to break down the + * string into tokens. These tokens are arranged into a structured stack, taking account of the + * bracket structure. Finally then method calls the {@link interpret} method to convert the structured + * token strings into a fully parsed term structure. The method can optionally be passed a list of + * variables which are used in the expression. If such a list is passed then the parser will attempt + * to match the current position in the string with one of these given variables before any other + * token. When passing a variable list a third parameter allows a choice of whether to allow additional + * undeclared variables. This defaults to false when a list of variables is passed and is ignored otherwise. + * + * @param $text string containing the expression to parse + * @param $variables array containing known variable names + * @param $undecvars whether to allow (true) undeclared variable names + * @return top term of the parsed expression + */ + function parse($text,$variables=array(),$undecvars=false) { + // Create a regular expression to match the known variables if an array is specified + if(!empty($variables)) { + // Create an empty array to store the list of extra regular expressions to match + $reextra=array(); + // Loop over all the variable names we are given + foreach($variables as $var) { + // Create a temporary varible term using the current name + $tmpvar=new qtype_algebra_parser_variable($var); + // If the variable name has a subscript then create a new regular expression to + // search for which includes an underscore + if(!empty($tmpvar->_subscript)) { + $reextra[]=$tmpvar->_base.'_'.$tmpvar->_subscript; + } + } + // Merge the variable name array with the array of extra regular expressions to match + $variables=array_merge($variables,$reextra); + // Sort the array in order of increasing variable length in order to prevent 'x1' matching + // a variable 'x' before 'x1'. Do this using a helper function, which will compare two + // strings using their length only, and use this with the usort function. + usort($variables,'qtype_algebra_parser_strlen_sort'); + // Generate a single regular expression which will match both all known variables + $revar='/('.implode('|',$variables).')/A'; + } else { + $revar=''; + } + $i=0; + // Create an array to store the parse tree + $tree=array(); + // Create an array to act as a temporary storage stack. This stack is used to + // push higher levels of the parse tree as it is assembled from the expression + $stack=array(); + // Array used to store the match results from regular expression searches + $m=array(); + // Loop over the expression string moving along it using the offset variable $i while + // there are still characters left to parse + while($i0 and (is_array($tree[count($tree)-1]) or + (is_object($tree[count($tree)-1]) + and $tree[count($tree)-1]->n_args()==0))) { + // Make the implicit assumption explicit by adding an appropriate + // multiplication operator + array_push($tree,new qtype_algebra_parser_multiply('*')); + } + // Push the current parse tree onto the stack + array_push($stack,$tree); + // Create a new parse tree starting with a bracket term + $tree=array(new qtype_algebra_parser_bracket($m[0])); + // Increment the string pointer by the length of the string that was matched + $i+=strlen($m[0]); + // Return to the start of the loop + continue; + } + // Now see if we have a close bracket here + if(preg_match(self::$CLOSEB,substr($text,$i),$m)) { + // First check that the current parse tree has at least one term + if(count($tree)==0) { + throw new Exception(get_string('badclosebracket','qtype_algebra')); + } + // Now check that the current tree started with a bracket + if(!is_a($tree[0],'qtype_algebra_parser_bracket')) { + throw new Exception(get_string('mismatchedcloseb','qtype_algebra')); + } + // Check that the open and close bracket are of the same type + else if($tree[0]->_value != self::$BRACKET_MAP[$m[0]]) { + throw new Exception(get_string('mismatchedbracket','qtype_algebra',$tree[0]->_value.$m[0])); + } + // Append the current tree to the tree one level up on the stack + array_push($stack[count($stack)-1],$tree); + // The new tree is the lowest level tree on the stack so we + // pop the new tree off the stack + $tree=array_pop($stack); + $i+=strlen($m[0]); + continue; + } + // If a list of predefined variables was given to the method then check for them here + if(!empty($revar) and preg_match($revar,substr($text,$i),$m)) { + // Check for a zero argument term or brackets preceding the variable and if there is one then + // add the implicit multiplication operation + if(count($tree)>0 and (is_array($tree[count($tree)-1]) or $tree[count($tree)-1]->n_args()==0)) { + array_push($tree,new qtype_algebra_parser_multiply('*')); + } + // Increment the string index by the length of the variable's name + $i+=strlen($m[0]); + // Push a new variable term onto the parse tree + array_push($tree,new qtype_algebra_parser_variable($m[0])); + continue; + } + // Here we have not found any open or close brackets or known variables so we can + // parse the string for a normal token + foreach($this->_tokens as $token) { + //echo 'Looking for token ',$token[1],"\n"; + if(preg_match($token[0],substr($text,$i),$m)) { + //echo 'Found a ',$token[1],"!\n"; + // Check for a variable and throw an exception if undeclared variables are + // not allowed and a list of defined variables was passed + if(!empty($revar) and !$undecvars and $token[1]=='qtype_algebra_parser_variable') { + throw new Exception(get_string('undeclaredvar','qtype_algebra',$m[0])); + } + // Check for a zero argument term preceding a variable, function or special and then + // add the implicit multiplication + if(count($tree)>0 and ($token[1]=='qtype_algebra_parser_variable' or + $token[1]=='qtype_algebra_parser_function' or + $token[1]=='qtype_algebra_parser_special') + and (is_array($tree[count($tree)-1]) or + $tree[count($tree)-1]->n_args()==0)) { + array_push($tree,new qtype_algebra_parser_multiply('*')); + } + $i+=strlen($m[0]); + array_push($tree,new $token[1]($m[0])); + continue 2; + } + } + throw new Exception(get_string('unknownterm','qtype_algebra',substr($text,$i))); + } // end while loop over tokens + // If all the open brackets have been closed then the stack will be empty and the + // tree will contain the entire parsed expression + if(count($stack)>0) { + throw new Exception(get_string('mismatchedopenb','qtype_algebra')); + } + //print_r($tree); + //print_r($stack); + return $this->interpret($tree); + } + + /** + * Takes a structured token map and converts it into a parsed term structure. + * + * This is an internal method of the parser class and is called by the {@link parse} + * method. It performs the final stage of the parsing process and returns the fully + * parsed term structure. + * + * @param $tree structured token array + * @return top term of the fully parsed structure + */ + function interpret($tree) { + // First check to see if we are passed anything at all. If not then simply + // return a qtype_algebra_parser_nullterm + if(count($tree)==0) { + return new qtype_algebra_parser_nullterm(); + } + // Now we check to see if this tree is inside brackets. If so then + // we remove the bracket object from the tree and store it in a + // temporary variable. We will then parse the remainder of the tree + // and make the top level term the bracket's argument if applicable. + if(is_a($tree[0],'qtype_algebra_parser_bracket')) { + $bracket=array_splice($tree,0,1); + $bracket=$bracket[0]; + } else { + $bracket=''; + } + // Next we loop over the tree and look for arrays. These represent + // brackets inside our tree and so we need to process them first. + for($i=0;$iinterpret($tree[$i]); + } + } + // The next job is to check the subtraction operations to determine whether they are + // really subtraction operations or whether they are minus signs for negative numbers + $toremove=array(); + for($i=0;$i0 and (is_a($tree[$i-1],'qtype_algebra_parser_variable') or + is_a($tree[$i-1],'qtype_algebra_parser_number') or + is_a($tree[$i-1],'qtype_algebra_parser_bracket'))) { + continue; + } + // Otherwise we have found a minus sign indicating a positive or negative quantity... + else { + // Check that we do have a number following otherwise generate an exception... + if($i==(count($tree)-1) or !method_exists($tree[$i+1],'set_negative')) { + throw new Exception(get_string('illegalplusminus','qtype_algebra')); + } + // If we have a subtract operation then we need to make the following number negative + if(is_a($tree[$i],'qtype_algebra_parser_subtract')) { + // Set the number to be negative + $tree[$i+1]->set_negative(); + } + // Add the term to the removal list + $toremove[$i]=1; + } + } + } + // Remove the elements from the tree who's keys are found in the removal list + $tree=array_diff_key($tree,$toremove); + // Re-key the tree array so that the keys are sequential + $tree=array_values($tree); + foreach(self::$priority as $ops) { + $i=0; + //echo 'Looking for ',$ops,"\n"; + while($in_args()==1) { + if(($i+1)set_arguments(array_splice($tree,$i+1,1)); + $i++; + continue; + } else { + throw new Exception(get_string('missingonearg','qtype_algebra',$op)); + } + } elseif($tree[$i]->n_args() == 2) { + if($i>0 and $i<(count($tree)-1)) { + $tree[$i]->set_arguments(array($tree[$i-1], + $tree[$i+1])); + array_splice($tree,$i+1,1); + array_splice($tree,$i-1,1); + continue; + } else { + throw new Exception(get_string('missingtwoargs','qtype_algebra',$op)); + } + } + } else { + $i++; + } + } + } + // If there are no terms in the parse tree then we were passed an empty string + // in which case we create a null term and return it + if(count($tree)==0) { + return new qtype_algebra_parser_nullterm(); + } else if(count($tree)!=1) { + //print_r($tree); + throw new Exception(get_string('notopterm','qtype_algebra')); + } + if($bracket) { + $bracket->set_arguments(array($tree[0])); + return $bracket; + } else { + return $tree[0]; + } + } +} + +// Sort static arrays once here by inverse string length +usort(qtype_algebra_parser_variable::$greek,'qtype_algebra_parser_strlen_sort'); +usort(qtype_algebra_parser::$functions,'qtype_algebra_parser_strlen_sort'); + diff --git a/pix/icon.gif b/pix/icon.gif new file mode 100644 index 0000000..0668e33 Binary files /dev/null and b/pix/icon.gif differ diff --git a/question.php b/question.php new file mode 100644 index 0000000..12d27dd --- /dev/null +++ b/question.php @@ -0,0 +1,356 @@ +. + +/** + * algebra answer question definition class. + * + * @package qtype + * @subpackage algebra + * @author Roger Moore + * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later + */ + + +defined('MOODLE_INTERNAL') || die(); + +require_once($CFG->dirroot . '/question/type/algebra/questiontype.php'); +require_once($CFG->dirroot . '/question/type/algebra/parser.php'); +require_once($CFG->dirroot . '/question/type/algebra/xmlrpc-utils.php'); + +/** + * Represents an algebra question. + * + * @copyright 2009 The Open University + * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later + */ +class qtype_algebra_question extends question_graded_by_strategy + implements question_response_answer_comparer { + + /** @var array of question_answer. */ + public $answers = array(); + /** @var array of question_answer. */ + public $variables = array(); + public $compareby; + public $nchecks; + public $tolerance; + public $allowedfuncs; + public $disallow; + public $answerprefix; + + public function __construct() { + parent::__construct(new question_first_matching_answer_grading_strategy($this)); + } + + public function get_expected_data() { + return array('answer' => PARAM_RAW_TRIMMED); + } + + public function summarise_response(array $response) { + if (isset($response['answer'])) { + return $response['answer']; + } else { + return null; + } + } + + public function is_complete_response(array $response) { + return array_key_exists('answer', $response) && + ($response['answer'] || $response['answer'] === '0'); + } + + public function get_validation_error(array $response) { + if ($this->is_gradable_response($response)) { + return ''; + } + return get_string('pleaseenterananswer', 'qtype_algebra'); + } + + /** + * Parses the given expression with the parser if required. + * + * This method will check to see if the argument it is given is already a parsed + * expression and if not will attempt to parse it. + * + * @param $expr expression which will be parsed + * @return top term of the parse tree or a string if an exception is thrown + */ + public function parse_expression($expr) { + // Check to see if this is already a parsed expression + if(is_a($expr,'qtype_algebra_parser_term')) { + // It is a parsed expression so simply return it + return $expr; + } + + // Create an array of variable names for the parser from the question if defined + $varnames=array(); + if(isset($this->variables)) { + foreach($this->variables as $var) { + $varnames[]=$var->name; + } + } + // We now assume that we have a string to parse. Create a parser instance to + // to this and return the parser expression at the top of the parse tree + $p=new qtype_algebra_parser; + // Perform the actual parsing inside a try-catch block so that any exceptions + // can be caught and converted into errors + try { + return $p->parse($expr,$varnames); + } catch(Exception $e) { + // If the expression cannot be parsed then return a null term. This will + // make Moodle treat the answer as wrong. + // TODO: Would be nice to have support for 'invalid answer' in the quiz + // engine since an unparseable response is usually caused by a silly typo + return new qtype_algebra_parser_nullterm; + } + } + + /** + * Parses the given expression with the parser if required. + * + * This method will parse the expression and return a TeX string + * or empty string + * + * @param $expr expression which will be parsed + * @return top term of the parse tree or a string if an exception is thrown + */ + public function formated_expression($text) { + + // Create an array of variable names for the parser from the question if defined + $varnames=array(); + if(isset($this->variables)) { + foreach($this->variables as $var) { + $varnames[]=$var->name; + } + } + // We now assume that we have a string to parse. Create a parser instance to + // to this and return the parser expression at the top of the parse tree + $p=new qtype_algebra_parser; + // Perform the actual parsing inside a try-catch block so that any exceptions + // can be caught and converted into errors + try { + $exp = $p->parse($text, $varnames); + return '$$'.$exp->tex().'$$'; + } catch(Exception $e) { + return ''; + } + } + + public function is_same_response(array $prevresponse, array $newresponse) { + // Check that both states have valid responses + if (!isset($prevresponse['answer']) or !isset($newresponse['answer'])) { + // At last one of the states did not have a response set so return false by default + return false; + } + // Parse the previous response + $expr=$this->parse_expression($prevresponse['answer']); + // Parse the new response + $testexpr=$this->parse_expression($newresponse['answer']); + // The type of comparison done depends on the comparision algorithm selected by + // the question. Use the defined algorithm to select which comparison function + // to call... + if($this->compareby == 'sage') { + // Uses an XML-RPC server with SAGE to perform a full symbollic comparision + return self::test_response_by_sage($expr,$testexpr); + } else if($this->compareby == 'eval') { + // Tests the response by evaluating it for a certain range of each variable + return self::test_response_by_evaluation($expr,$testexpr); + } else { + // Tests the response by performing a simple parse tree equivalence algorithm + return self::test_response_by_equivalence($expr,$testexpr); + } + } + + public function get_answers() { + return $this->answers; + } + + public function compare_response_with_answer(array $response, question_answer $answer) { + // Deal with the match anything answer by returning true + if ($answer->answer == '*') { + return true; + } + $expr=$this->parse_expression($response['answer']); + // Check that there is a response and if not return false. We do this here + // because even an empty response should match a widlcard answer. + if(is_a($expr,'qtype_algebra_parser_nullterm')) { + return false; + } + + // Now parse the answer + $ansexpr=$this->parse_expression($answer->answer); + // The type of comparison done depends on the comparision algorithm selected by + // the question. Use the defined algorithm to select which comparison function + // to call... + if($this->compareby == 'sage') { + // Uses an XML-RPC server with SAGE to perform a full symbollic comparision + return self::test_response_by_sage($expr,$ansexpr); + } else if($this->compareby == 'eval') { + // Tests the response by evaluating it for a certain range of each variable + return self::test_response_by_evaluation($expr,$ansexpr); + } else { + // Tests the response by performing a simple parse tree equivalence algorithm + return self::test_response_by_equivalence($expr,$ansexpr); + } + } + + /** + * Checks whether a response matches a given answer using SAGE + * + * This method will compare the given response to the given answer using the SAGE + * open source algebra computation software. The software is run by a remote + * XML-RPC server which is called with both the asnwer and the response and told to + * compare the two algebraic expressions. + * + * @return boolean true if the response matches the answer, false otherwise + */ + function test_response_by_sage($response, $answer) { + // TODO: Store server information in the Moodle configuration + $request=array( + 'host' => 'localhost', + 'port' => 7777, + 'uri' => '' + ); + // Sets the name of the method to call to full_symbolic_compare + $request['method']='full_symbolic_compare'; + // Get a list of all the variables to declare + $vars=$response->get_variables(); + $vars=array_merge($vars,array_diff($vars,$answer->get_variables())); + // Sets the arguments to the sage string of the response and the list of variables + $request['args']=array($answer->sage(),$response->sage(),$vars); + // Calls the XML-RPC method on the server and returns the response + return xu_rpc_http_concise($request)==0; + } + + /** + * Checks whether a response matches a given answer using an evaluation method + * + * This method will compare the given response to the given answer by evaluating both + * for given values of the variables. Each variable must have a predefined range over + * which it can be checked and then both expressions will be evalutated several times + * using values randomly chosen to be within the range. + * + * @return boolean true if the response matches the answer, false otherwise + */ + function test_response_by_evaluation($response, $answer) { + // Flag used to denote mismatch in response and answer + $same=true; + // Run the evaluation loop 10 times with different random variables... + for($i=0;$i<$this->nchecks;$i++) { + // Create an array to store the values of all the variables + $values=array(); + // Loop over all the variables in the question + foreach($this->variables as $var) { + // Set the value of the variable to a random number between the min and max + $values[$var->name]=$var->min+lcg_value()*abs($var->max-$var->min); + } + $resp_value=$response->evaluate($values); + $ans_value=$answer->evaluate($values); + // Return false if only one of the reponse or answer gives NaN + if(is_nan($resp_value) xor is_nan($ans_value)) { + return false; + } + // Return false if only one of the reponse or answer is infinite + if(is_infinite($resp_value) xor is_infinite($ans_value)) { + return false; + } + // Use the fractional difference method if the answer has a value + // which is clearly distinguishable from zero + if(abs($ans_value)>1e-300) { + // Get the difference between the response and answer evaluations + $diff=abs(($resp_value-$ans_value)/$ans_value); + } + // Otherwise use an arbitrary minimum value + else { + // Get the difference between the response and answer evaluations + $diff=abs(($resp_value-$ans_value)/1e-300); + } + // Check to see if the difference is greater than tolerance + if($diff > $this->tolerance) { + // Return false since the formulae have been shown not to be the same + return false; + } + } + // We made it through the loop so now return true + return true; + } + + /** + * Checks whether a response matches a given answer using a simple equivalence algorithm + * + * This method will compare the given response to the given answer by simply checking to + * see if the two parse trees are equivalent. This allows for a slightly more sophisticated + * check than a simple text compare but will not, neccessarily, catch two equivalent but + * different algebraic expressions. + * + * @return boolean true if the response matches the answer, false otherwise + */ + public function test_response_by_equivalence($response, $answer) { + // Use the parser's equivalent method to see if the response is the same as the answer + return $response->equivalent($answer); + } + + public function check_file_access($qa, $options, $component, $filearea, + $args, $forcedownload) { + if ($component == 'question' && $filearea == 'answerfeedback') { + $currentanswer = $qa->get_last_qt_var('answer'); + $answer = $qa->get_question()->get_matching_answer(array('answer' => $currentanswer)); + $answerid = reset($args); // itemid is answer id. + return $options->feedback && $answerid == $answer->id; + + } else if ($component == 'question' && $filearea == 'hint') { + return $this->check_hint_file_access($qa, $options, $args); + + } else { + return parent::check_file_access($qa, $options, $component, $filearea, + $args, $forcedownload); + } + } +} + +/** + * Class to represent an algebra question variable, loaded from the question_algebra_variables table + * in the database. + * + * @copyright 2009 The Open University + * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later + */ +class question_variable { + /** @var integer the answer id. */ + public $id; + + /** @var string the name. */ + public $name; + + /** @var string minimum value. */ + public $min = '-'; + + /** @var string maximum value. */ + public $max = '-'; + + /** + * Constructor. + * @param int $id the variable. + * @param string $name the name. + * @param string $min the minimum value. + * @param string $maximum value. + */ + public function __construct($id, $name, $min, $max) { + $this->id = $id; + $this->name = $name; + $this->min = $min; + $this->max = $max; + } +} diff --git a/questiontype.php b/questiontype.php new file mode 100644 index 0000000..dfd9f3b --- /dev/null +++ b/questiontype.php @@ -0,0 +1,551 @@ +. + +/** + * Question type class for the algebra question type. + * + * @package qtype + * @subpackage algebra + * @author Roger Moore + * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later + */ + +defined('MOODLE_INTERNAL') || die(); + +require_once($CFG->dirroot . '/question/type/algebra/question.php'); +require_once($CFG->dirroot . '/question/type/algebra/parser.php'); +require_once($CFG->dirroot . '/question/type/algebra/xmlrpc-utils.php'); + +/** + * ALGEBRA QUESTION TYPE CLASS + * + * @package questionbank + * @subpackage questiontypes + */ + +class qtype_algebra extends question_type { + + /** + * Defines the table which extends the question table. This allows the base questiontype + * to automatically save, backup and restore the extra fields. + * + * @return an array with the table name (first) and then the column names (apart from id and questionid) + */ + public function extra_question_fields() { + return array('question_algebra', + 'compareby', // Name of comparison algorithm to use + 'nchecks', // Number of evaluate checks to make when comparing by evaluation + 'tolerance', // Max. fractional difference allowed for evaluation checks + 'allowedfuncs', // Comma separated list of functions allowed in responses + 'disallow', // Response which may be correct but which is not allowed + 'answerprefix' // String which is placed in front of the asnwer box + ); + } + + public function questionid_column_name() { + return 'questionid'; + } + + public function move_files($questionid, $oldcontextid, $newcontextid) { + parent::move_files($questionid, $oldcontextid, $newcontextid); + $this->move_files_in_answers($questionid, $oldcontextid, $newcontextid); + } + + protected function delete_files($questionid, $contextid) { + parent::delete_files($questionid, $contextid); + $this->delete_files_in_answers($questionid, $contextid); + } + + public function delete_question($questionid, $contextid) { + global $DB; + $DB->delete_records('question_algebra', array('questionid' => $questionid)); + $DB->delete_records('question_algebra_variables', array('question' => $questionid)); + + parent::delete_question($questionid, $contextid); + } + + /** + * Saves the questions variables to the database + * + * This is called by {@link save_question_options()} to save the variables of the question to + * the database from the data in the submitted form. The method returns an array of the variables + * IDs written to the database or, in the event of an error, throws an exception. + * + * @param object $question This holds the information from the editing form, + * it is not a standard question object. + * @return array of variable object IDs + */ + public function save_question_variables($question) { + global $DB; + // Create the results class + $result = new stdClass; + // Get all the old answers from the database as an array + if (!$oldvars = $DB->get_records('question_algebra_variables', array('question' => $question->id), 'id ASC')) { + $oldvars = array(); + } + // Create an array of the variable IDs for the question + $variables = array(); + + // Loop over all the answers in the question form and write them to the database + foreach ($question->variable as $key => $varname) { + // Check to see that there is a variable and skip any which are empty + if ($varname == '') { + continue; + } + + // Get the old variable from the array and overwrite what is required, if there + // is no old variable then we skip to the 'else' clause + if ($oldvar = array_shift($oldvars)) { // Existing variable, so reuse it + $var = $oldvar; + $var->name = trim($varname); + $var->min = trim($question->varmin[$key]); + $var->max = trim($question->varmax[$key]); + // Update the record in the database to denote this change. + if (!$DB->update_record('question_algebra_variables', $var)) { + throw new Exception("Could not update algebra question variable (id=$var->id)"); + } + } + // This is a completely new variable so we have to create a new record + else { + $var = new stdClass; + $var->name = trim($varname); + $var->question = $question->id; + $var->min = trim($question->varmin[$key]); + $var->max = trim($question->varmax[$key]); + // Insert a new record into the database table + if (!$var->id = $DB->insert_record('question_algebra_variables', $var)) { + throw new Exception("Could not insert algebra question variable '$varname'!"); + } + } + // Add the variable ID to the array of IDs + $variables[] = $var->id; + } // end loop over variables + + // Delete any left over old variables records. + foreach ($oldvars as $oldvar) { + $DB->delete_records('question_algebra_variables', array('id' => $oldvar->id)); + } + // Finally we are all done so return the result! + return $variables; + } + + /** + * Saves the questions answers to the database + * + * This is called by {@link save_question_options()} to save the answers to the question to + * the database from the data in the submitted form. This method should probably be in the + * questin base class rather than in the algebra subclass since the code is common to multiple + * question types and originally comes from the shortanswer question type. The method returns + * a list of the answer ID written to the database or throws an exception if an error is detected. + * + * @param object $question This holds the information from the editing form, + * it is not a standard question object. + * @return array of answer IDs which were written to the database + */ + public function save_question_answers($question) { + global $CFG, $DB; + + $context = $question->context; + // Create the results class + $result = new stdClass; + + // Get all the old answers from the database as an array + if (!$oldanswers = $DB->get_records('question_answers', array('question' => $question->id), 'id ASC')) { //'question', $question->'id ASC')) { + $oldanswers = array(); + } + // Create an array of the answer IDs for the question + $answers = array(); + // Set the maximum answer fraction to be -1. We will check this at the end of our + // loop over the questions and if it is not 100% (=1.0) then we will flag an error + $maxfraction = -1; + + // Loop over all the answers in the question form and write them to the database + foreach ($question->answer as $key => $answerdata) { + // Check for, and ignore, completely blank answer from the form. + if (trim($answerdata) == '' && $question->fraction[$key] == 0 && + html_is_blank($question->feedback[$key]['text'])) { + continue; + } + // Update an existing answer if possible. + $answer = array_shift($oldanswers); + if (!$answer) { + $answer = new stdClass(); + $answer->question = $question->id; + $answer->answer = ''; + $answer->feedback = ''; + $answer->feedbackformat = FORMAT_HTML; + if (!$answer->id = $DB->insert_record('question_answers', $answer)) { + throw new Exception("Could not create new algebra question answer"); + } + } + + $answer->answer = trim($answerdata); + $answer->fraction = $question->fraction[$key]; + $answer->feedback = $this->import_or_save_files($question->feedback[$key], + $context, 'question', 'answerfeedback', $answer->id); + $answer->feedbackformat = $question->feedback[$key]['format']; + if (!$DB->update_record('question_answers', $answer)) { + throw new Exception("Could not update algebra question answer (id=$answer->id)"); + } + + + $answers[] = $answer->id; + if ($question->fraction[$key] > $maxfraction) { + $maxfraction = $question->fraction[$key]; + } + } // end loop over answers + + // Perform sanity check on the maximum fractional grade which should be 100% + if ($maxfraction != 1) { + $maxfraction = $maxfraction * 100; + throw new Exception(get_string('fractionsnomax', 'quiz', $maxfraction)); + } + + // Delete any left over old answer records. + $fs = get_file_storage(); + foreach ($oldanswers as $oldanswer) { + $fs->delete_area_files($context->id, 'question', 'answerfeedback', $oldanswer->id); + $DB->delete_records('question_answers', array('id' => $oldanswer->id)); + } + + // Finally we are all done so return the result! + return $answers; + } + + /** + * Saves question-type specific options + * + * This is called by {@link save_question()} to save the question-type specific data from a + * submitted form. This method takes the form data and formats into the correct format for + * writing to the database. It then calls the parent method to actually write the data. + * + * @param object $question This holds the information from the editing form, + * it is not a standard question object. + * @return object $result->error or $result->noticeyesno or $result->notice + */ + public function save_question_options($question) { + // Start a try block to catch any exceptions generated when we attempt to parse and + // then add the answers and variables to the database + try { + // First write out all the variables associated with the question + $variables=$this->save_question_variables($question); + + // Loop over all the answers in the question form and parse them to generate + // a parser string. This ensures a constant formatting is stored in the database + foreach ($question->answer as &$answer) { + $expr=$this->parse_expression($answer); + // TODO detect invalid answer and issue a warning + $answer=$expr->sage(); + } + + // Now we need to write out all the answers to the question to the database + $answers=$this->save_question_answers($question); + + } catch (Exception $e) { + // Error when adding answers or variables to the database so create a result class + // and put the error string in the error member funtion and then return the class + // This keeps us compatible with the existing save_question_options methods. + $result=new stdClass; + $result->error=$e->getMessage(); + return $result; + } + + // Process the allowed functions field. This code just sets up the variable, it is saved + // in the parent class' save_question_options method called at the end of this method + // Look for the 'all' option. If we find it then set the string to an empty value + if(array_key_exists('all',$question->allowedfuncs)) { + $question->allowedfuncs=''; + } + // Not all functions are allowed so set allowed functions to those which are + else { + // Create a comma separated string of the function names which are stored in the + // keys of the array + $question->allowedfuncs=implode(',',array_keys($question->allowedfuncs)); + } + + // Call the parent method to write the extensions fields to the database. This either returns null + // or an error object so if we get anything then return it otherwise return our existing + $parentresult = parent::save_question_options($question); + if ($parentresult !== null) { + // Parent function returns null if all is OK + return $parentresult; + } + // Otherwise just return true - this mimics the shortanswer return format + else { + return true; + } + } + + /** + * Loads the question type specific options for the question. + * + * This function loads the compare algorithm type, disallowed strings and variables + * into the class from the database table in which they are stored. It first uses the + * parent class method to get the database information. + * + * @param object $question The question object for the question. This object + * should be updated to include the question type + * specific information (it is passed by reference). + * @return bool Indicates success or failure. + */ + public function get_question_options($question) { + // Get the information from the database table. If this fails then immediately bail. + // Note unlike the save_question_options base class method this method DOES get the question's + // answers along with any answer extensions + global $DB; + if(!parent::get_question_options($question)) { + return false; + } + // Check that we have answers and if not then bail since this question type requires answers + if(count($question->options->answers)==0) { + notify('Failed to load question answers from the table question_answers for questionid ' . + $question->id); + return false; + } + // Now get the variables from the database as well + $question->options->variables = $DB->get_records('question_algebra_variables', array('question' => $question->id)); + + + + //, 'id ASC'); + // Check that we have variables and if not then bail since this question type requires variables + + if(count($question->options->variables)==0) { + notify('Failed to load question variables from the table question_algebra_variables '. + "for questionid $question->id"); + return false; + } + + + // Check to see if there are any allowed functions + if($question->options->allowedfuncs!='') { + // Extract the allowed functions as an array + $question->options->allowedfuncs=explode(',',$question->options->allowedfuncs); + } + // Otherwise just create an empty array + else { + $question->options->allowedfuncs=array(); + } + + // Everything worked so return true + return true; + } + + /** + * Imports the question from Moodle XML format. + * + * This method is called by the format class when importing an algebra question from the + * Moodle XML format. + * + * @param $data structure containing the XML data + * @param $question question object to fill: ignored by this function (assumed to be null) + * @param $format format class importing the question + * @param $extra extra information (not required for importing this question in this format) + * @return text string containing the question data in XML format + */ + public function import_from_xml($data, $question, qformat_xml $format, $extra=null) { + if (!array_key_exists('@', $data)) { + return false; + } + if (!array_key_exists('type', $data['@'])) { + return false; + } + if ($data['@']['type'] == 'algebra') { + // Import the common question headers + $qo = $format->import_headers($data); + // Set the question type + $qo->qtype='algebra'; + + $qo->compareby = $format->getpath($data, array('#','compareby',0,'#'),'eval'); + $qo->tolerance = $format->getpath($data, array('#','tolerance',0,'#'),'0'); + $qo->nchecks = $format->getpath($data, array('#','nchecks',0,'#'),'10'); + $qo->disallow = $format->getpath($data, array('#','disallow',0,'#','text',0,'#'),'',true); + $allowedfuncs = $format->getpath($data, array('#','allowedfuncs',0,'#'), ''); + if($allowedfuncs=='') { + $qo->allowedfuncs=array('all' => 1); + } + // Need to separate the allowed functions into an array of strings and then + // flip the values of this array into the keys because this is what the + // save options method requires + else { + $qo->allowedfuncs=array_flip(explode(',',$allowedfuncs)); + } + $qo->answerprefix = $format->getpath($data, array('#','answerprefix',0,'#','text',0,'#'),'',true); + + // Import all the answers + $answers = $data['#']['answer']; + $a_count = 0; + // Loop over each answer block found in the XML + foreach($answers as $answer) { + // Use the common answer import function in the format class to load the data + $ans = $format->import_answer($answer); + $qo->answer[$a_count] = $ans->answer['text']; + $qo->fraction[$a_count] = $ans->fraction; + $qo->feedback[$a_count] = $ans->feedback; + ++$a_count; + } + + // Import all the variables + $vars = $data['#']['variable']; + $v_count = 0; + // Loop over each answer block found in the XML + foreach($vars as $var) { + $qo->variable[$v_count] = $format->getpath($var, array('@','name'),0); + $qo->varmin[$v_count] = $format->getpath($var, array('#','min',0,'#'),'0',false,get_string('novarmin','qtype_algebra')); + $qo->varmax[$v_count] = $format->getpath($var, array('#','max',0,'#'),'0',false,get_string('novarmax','qtype_algebra')); + ++$v_count; + } + + $format->import_hints($qo, $data); + + return $qo; + } + return false; + } + + + /** + * Exports the question to Moodle XML format. + * + * This method is called by the format class when exporting an algebra question into then + * Moodle XML format. + * + * @param $question question to be exported into XML format + * @param $format format class exporting the question + * @param $extra extra information (not required for exporting this question in this format) + * @return text string containing the question data in XML format + */ + public function export_to_xml($question, qformat_xml $format, $extra=null) { + $expout=''; + // Create a text string of the allowed functions from the array + $allowedfuncs=implode(',',$question->options->allowedfuncs); + // Write out all the extra fields belonging to the algebra question type + $expout .= " {$question->options->compareby}\n"; + $expout .= " {$question->options->tolerance}\n"; + $expout .= " {$question->options->nchecks}\n"; + $expout .= " ".$format->writetext($question->options->disallow,1,true)."\n"; + $expout .= " $allowedfuncs\n"; + $expout .= " ".$format->writetext($question->options->answerprefix,1,true). + "\n"; + // Write out all the answers + $expout .= $format->write_answers($question->options->answers); + // Loop over all the variables for the question and write out all their details + foreach ($question->options->variables as $var) { + $expout .= "name}\">\n"; + $expout .= " {$var->min}\n"; + $expout .= " {$var->max}\n"; + $expout .= "\n"; + } + return $expout; + } + + // Gets all the question responses + public function get_all_responses(&$question, &$state) { + $result = new stdClass; + $answers = array(); + // Loop over all the answers + if (is_array($question->options->answers)) { + foreach ($question->options->answers as $aid=>$answer) { + $r = new stdClass; + $r->answer = $answer->answer; + $r->credit = $answer->fraction; + $answers[$aid] = $r; + } + } + $result->id = $question->id; + $result->responses = $answers; + return $result; + } + + /** + * Parses the given expression with the parser if required. + * + * This method will check to see if the argument it is given is already a parsed + * expression and if not will attempt to parse it. + * + * @param $expr expression which will be parsed + * @param $question question containing the expression or null if none + * @return top term of the parse tree or a string if an exception is thrown + */ + function parse_expression($expr) { + // Check to see if this is already a parsed expression + if(is_a($expr, 'qtype_algebra_parser_term')) { + // It is a parsed expression so simply return it + return $expr; + } + // Check whether we have a state object or a simple string. If a state + // then replace it with the response string + if(isset($expr->responses[''])) { + $expr=$expr->responses['']; + } + // Create an empty array of variable names for the parser (no variable checking here as it is done in the form validation + // TODO see in case of import + $varnames=array(); + + // We now assume that we have a string to parse. Create a parser instance to + // to this and return the parser expression at the top of the parse tree + $p=new qtype_algebra_parser; + // Perform the actual parsing inside a try-catch block so that any exceptions + // can be caught and converted into errors + try { + return $p->parse($expr,$varnames); + } catch(Exception $e) { + // If the expression cannot be parsed then return a null term. This will + // make Moodle treat the answer as wrong. + // TODO: Would be nice to have support for 'invalid answer' in the quiz + // engine since an unparseable response is usually caused by a silly typo + return new qtype_algebra_parser_nullterm; + } + } + + protected function initialise_question_instance(question_definition $question, $questiondata) { + parent::initialise_question_instance($question, $questiondata); + $question->variables = array(); + if (!empty($questiondata->options->variables)) { + foreach ($questiondata->options->variables as $v) { + $question->variables[$v->id] = new question_variable($v->id, $v->name, $v->min, $v->max); + } + } + $question->compareby = $questiondata->options->compareby; + $question->nchecks = $questiondata->options->nchecks; + $question->tolerance = $questiondata->options->tolerance; + $question->allowedfuncs = $questiondata->options->allowedfuncs; + $question->disallow = $questiondata->options->disallow; + $question->answerprefix = $questiondata->options->answerprefix; + $this->initialise_question_answers($question, $questiondata); + } + + public function get_random_guess_score($questiondata) { + foreach ($questiondata->options->answers as $aid => $answer) { + if ('*' == trim($answer->answer)) { + return $answer->fraction; + } + } + return 0; + } + + public function get_possible_responses($questiondata) { + $responses = array(); + + foreach ($questiondata->options->answers as $aid => $answer) { + $responses[$aid] = new question_possible_response($answer->answer, + $answer->fraction); + } + $responses[null] = question_possible_response::no_response(); + + return array($questiondata->id => $responses); + } +} \ No newline at end of file diff --git a/renderer.php b/renderer.php new file mode 100644 index 0000000..4ffe674 --- /dev/null +++ b/renderer.php @@ -0,0 +1,162 @@ +. + +/** + * Algebra question renderer class. + * + * @package qtype + * @subpackage algebra + * @author Roger Moore + * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later + */ + + +defined('MOODLE_INTERNAL') || die(); + + +/** + * Generates the output for algebra questions. + * + * @copyright 2009 The Open University + * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later + */ +class qtype_algebra_renderer extends qtype_renderer { + public function formulation_and_controls(question_attempt $qa, + question_display_options $options) { + global $CFG; + + $question = $qa->get_question(); + + $currentanswer = $qa->get_last_qt_var('answer'); + + $inputname = $qa->get_qt_field_name('answer'); + + $nameprefix = str_replace(':', '_', $inputname); // valid javascript name + $inputattributes = array( + 'type' => 'text', + 'name' => $inputname, + 'value' => $currentanswer, + 'id' => $inputname, + 'size' => 80, + ); + + if ($options->readonly) { + $inputattributes['readonly'] = 'readonly'; + } + + $feedbackimg = ''; + if ($options->correctness) { + $answer = $question->get_matching_answer(array('answer' => $currentanswer)); + if ($answer) { + $fraction = $answer->fraction; + } else { + $fraction = 0; + } + $inputattributes['class'] = $this->feedback_class($fraction); + $feedbackimg = $this->feedback_image($fraction); + } + + $iframename = $nameprefix.'_if'; + // Name of the javascript function which causes the entered formula to be rendered + $df_name = $nameprefix.'_display'; + // Create an array of variable names to use when displaying the function entered + $varnames=array(); + if($question and isset($question->variables)) { + $variables = $question->variables; + foreach($question->variables as $var) { + $varnames[]=$var->name; + } + } + + $varnames=implode(',',$varnames); + // Javascript function which the button uses to display the rendering + // This function sents the source of the iframe to the 'displayformula.php' script giving + // it an argument of the formula entered by the student. + $displayfunction = + 'function '.$df_name."() {\n". + ' var text="vars='.$varnames.'&expr="+escape(document.getElementsByName("'.$inputname.'")[0].value);'."\n". + " if(text.length != 0) {\n". + ' document.getElementsByName("'.$iframename.'")[0].src="'. + $CFG->wwwroot.'/question/type/algebra/displayformula.php?"+'. + 'text.replace(/\+/g,"%2b")'."\n". + " }\n". + " }\n"; + + $questiontext = $question->format_questiontext($qa); + + $input = html_writer::empty_tag('input', $inputattributes) . $feedbackimg; + + + $result = html_writer::tag('div', $questiontext, array('class' => 'qtext')); + + $result .= html_writer::tag('script', $displayfunction, array('type'=>'text/javascript')); + + $result .= html_writer::start_tag('div', array('class' => 'ablock')); + $result .= html_writer::start_tag('div', array('class' => 'prompt', 'style' => 'vertical-align: top')); + if(isset($question->answerprefix) and !empty($question->answerprefix)) { + $opts=new StdClass; + $opts->para=false; + $result .= html_writer::tag('div', format_text($question->answerprefix,FORMAT_MOODLE,$opts).$input, array('class' => 'answer')); + } else { + $result .= get_string('answer', 'qtype_algebra', + html_writer::tag('div', $input, array('class' => 'answer'))); + } + $result .= html_writer::end_tag('div'); + + $result .= html_writer::end_tag('div'); + + + if ($qa->get_state() == question_state::$invalid) { + $result .= html_writer::nonempty_tag('div', + $question->get_validation_error(array('answer' => $currentanswer)), + array('class' => 'validationerror')); + } + $result .= html_writer::start_tag('div', array('class' => 'dispresponse')); + $result .= html_writer::empty_tag('input', array('type'=>'button', 'value'=>'Display Response', 'onclick'=>$df_name.'()')); + $result .= html_writer::start_tag('iframe', array('name'=>$iframename, 'width'=>'60%', 'height'=>60, 'align'=>'middle', 'src'=>'')); + $result .= html_writer::end_tag('iframe'); + $result .= html_writer::tag('script', $df_name.'();', array('type'=>'text/javascript')); + $result .= html_writer::end_tag('div'); + + return $result; + } + + public function specific_feedback(question_attempt $qa) { + $question = $qa->get_question(); + + $answer = $question->get_matching_answer(array('answer' => $qa->get_last_qt_var('answer'))); + if (!$answer || !$answer->feedback) { + return ''; + } + + return $question->format_text($answer->feedback, $answer->feedbackformat, + $qa, 'question', 'answerfeedback', $answer->id); + } + + public function correct_response(question_attempt $qa) { + $question = $qa->get_question(); + + $answer = $question->get_matching_answer($question->get_correct_response()); + if (!$answer) { + return ''; + } + $formatoptions = new stdClass; + $formatoptions->para = false; + $formatoptions->clean = false; + $formattedanswer = format_text($question->formated_expression($answer->answer), FORMAT_MOODLE, $formatoptions); + return get_string('correctansweris', 'qtype_algebra', s($answer->answer)). $formattedanswer; + } +} \ No newline at end of file diff --git a/sage_server.py b/sage_server.py new file mode 100644 index 0000000..8b41bf7 --- /dev/null +++ b/sage_server.py @@ -0,0 +1,29 @@ +#!/usr/bin/env sage -python + +from SimpleXMLRPCServer import SimpleXMLRPCServer + +from sage.all import Sage + +s=Sage() + +server=SimpleXMLRPCServer(("localhost",7777)) +server.register_introspection_functions() + +def full_symbolic_compare(expr1,expr2,vars): + varstr=",".join(vars) + print "Comparing %s to %s with variables %s" % (expr1,expr2,varstr) + s.eval('%s=var("%s")' % (varstr,varstr)) + s.eval("_func=(%s)-(%s)" % (expr1,expr2)) + result=s.eval("_func.simplify_full()") + if result=='0': + print "Equal" + return 0 + else: + print "Not equal" + return 1 + +server.register_function(full_symbolic_compare) + +print full_symbolic_compare('x^2+2*x+1', 'x^2+2*x+1', ['x']) + +server.serve_forever() diff --git a/settings.php b/settings.php new file mode 100644 index 0000000..a0f5423 --- /dev/null +++ b/settings.php @@ -0,0 +1,11 @@ +fulltree) { + //host + $settings->add(new admin_setting_configtext('qtype_algebra_host', get_string('host', 'qtype_algebra'), '', 'localhost', PARAM_TEXT)); + //port + $settings->add(new admin_setting_configtext('qtype_algebra_port', get_string('port', 'qtype_algebra'), '', 7777, PARAM_INT)); + //host + $settings->add(new admin_setting_configtext('qtype_algebra_uri', get_string('uri', 'qtype_algebra'), '', '', PARAM_TEXT)); +} diff --git a/version.php b/version.php new file mode 100644 index 0000000..81af712 --- /dev/null +++ b/version.php @@ -0,0 +1,5 @@ +version = 2011072800; +$plugin->requires = 2011060313; diff --git a/xmlrpc-utils.php b/xmlrpc-utils.php new file mode 100644 index 0000000..a671d75 --- /dev/null +++ b/xmlrpc-utils.php @@ -0,0 +1,269 @@ + \n$http_request\n", $debug); + + fputs($query_fd, $http_request, strlen($http_request)); + + dbg1("receiving response...", $debug); + + $header_parsed = false; + + $line = fgets($query_fd, 4096); + while ($line) { + if (!$header_parsed) { + if ($line === "\r\n" || $line === "\n") { + $header_parsed = 1; + } + dbg2("got header - $line", $debug); + } + else { + $response_buf .= $line; + } + $line = fgets($query_fd, 4096); + } + + fclose($query_fd); + } + else { + dbg1("socket open failed", $debug); + } + } + else { + dbg1("missing param(s)", $debug); + } + + dbg1("got response:. \n$response_buf\n\n", $debug); + + return $response_buf; +} + +function xu_fault_code($code, $string) { + return array('faultCode' => $code, + 'faultString' => $string); +} + + +function find_and_decode_xml($buf, $debug) { + if (strlen($buf)) { + $xml_begin = substr($buf, strpos($buf, " 'xml', + * 'verbosity' => 'pretty', + * 'escaping' => array('markup', 'non-ascii', 'non-print'), + * 'version' => 'xmlrpc', + * 'encoding' => 'utf-8' + * ); + * or + * + * $output_options = array('output_type' => 'php'); + */ +function xu_rpc_http_concise($params) { + $host = $uri = $port = $method = $args = $debug = null; + $timeout = $user = $pass = $secure = $debug = null; + + extract($params); + + // default values + if(!$port) { + $port = 80; + } + if(!$uri) { + $uri = '/'; + } + if(!isset($output)) { + $output = array('version' => 'xmlrpc'); + } + + $response_buf = ""; + if ($host && $uri && $port) { + $request_xml = xmlrpc_encode_request($method, $args, $output); + $response_buf = xu_query_http_post($request_xml, $host, $uri, $port, $debug, + $timeout, $user, $pass, $secure); + + $retval = find_and_decode_xml($response_buf, $debug); + } + return $retval; +} + +/* call an xmlrpc method on a remote http server. legacy support. */ +function xu_rpc_http($method, $args, $host, $uri="/", $port=80, $debug=false, + $timeout=0, $user=false, $pass=false, $secure=false) { + return xu_rpc_http_concise( + array( + method => $method, + args => $args, + host => $host, + uri => $uri, + port => $port, + debug => $debug, + timeout => $timeout, + user => $user, + pass => $pass, + secure => $secure + )); +} + + + +function xu_is_fault($arg) { + // xmlrpc extension finally supports this. + return is_array($arg) ? xmlrpc_is_fault($arg) : false; +} + +/* sets some http headers and prints xml */ +function xu_server_send_http_response($xml) { + header("Content-type: text/xml"); + header("Content-length: " . strlen($xml) ); + echo $xml; +} + + +function dbg($msg) { + echo "

$msg

"; flush(); +} +function dbg1($msg, $debug_level) { + if ($debug_level >= 1) { + dbg($msg); + } +} +function dbg2($msg, $debug_level) { + if ($debug_level >= 2) { + dbg($msg); + } +} + -- cgit v1.2.3