<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
* Calculated question definition class.
*
* @package qtype
* @subpackage calculated
* @copyright 2011 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die();
require_once($CFG->dirroot . '/question/type/questionbase.php');
require_once($CFG->dirroot . '/question/type/numerical/question.php');
require_once($CFG->dirroot . '/question/type/calculated/questiontype.php');
/**
* Represents a calculated question.
*
* @copyright 2011 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class qtype_calculated_question extends qtype_numerical_question
implements qtype_calculated_question_with_expressions {
/** @var qtype_calculated_dataset_loader helper for loading the dataset. */
public $datasetloader;
/** @var qtype_calculated_variable_substituter stores the dataset we are using. */
public $vs;
/**
* @var bool wheter the dataset item to use should be chose based on attempt
* start time, rather than randomly.
*/
public $synchronised;
public function start_attempt(question_attempt_step $step, $variant) {
qtype_calculated_question_helper::start_attempt($this, $step, $variant);
parent::start_attempt($step, $variant);
}
public function apply_attempt_state(question_attempt_step $step) {
qtype_calculated_question_helper::apply_attempt_state($this, $step);
parent::apply_attempt_state($step);
}
public function calculate_all_expressions() {
$this->questiontext = $this->vs->replace_expressions_in_text($this->questiontext);
$this->generalfeedback = $this->vs->replace_expressions_in_text($this->generalfeedback);
foreach ($this->answers as $ans) {
if ($ans->answer && $ans->answer !== '*') {
$ans->answer = $this->vs->calculate($ans->answer,
$ans->correctanswerlength, $ans->correctanswerformat);
}
$ans->feedback = $this->vs->replace_expressions_in_text($ans->feedback,
$ans->correctanswerlength, $ans->correctanswerformat);
}
}
public function get_num_variants() {
return $this->datasetloader->get_number_of_items();
}
public function get_variants_selection_seed() {
if (!empty($this->synchronised) &&
$this->datasetloader->datasets_are_synchronised($this->category)) {
return 'category' . $this->category;
} else {
return parent::get_variants_selection_seed();
}
}
public function get_correct_response() {
$answer = $this->get_correct_answer();
if (!$answer) {
return array();
}
$response = array('answer' => $this->vs->format_float($answer->answer,
$answer->correctanswerlength, $answer->correctanswerformat));
if ($this->has_separate_unit_field()) {
$response['unit'] = $this->ap->get_default_unit();
} else if ($this->unitdisplay == qtype_numerical::UNITINPUT) {
$response['answer'] = $this->ap->add_unit($response['answer']);
}
return $response;
}
}
/**
* This interface defines the method that a quetsion type must implement if it
* is to work with {@link qtype_calculated_question_helper}.
*
* As well as this method, the class that implements this interface must have
* fields
* public $datasetloader; // of type qtype_calculated_dataset_loader
* public $vs; // of type qtype_calculated_variable_substituter
*
* @copyright 2011 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
interface qtype_calculated_question_with_expressions {
/**
* Replace all the expression in the question definition with the values
* computed from the selected dataset by calling $this->vs->calculate() and
* $this->vs->replace_expressions_in_text() on the parts of the question
* that require it.
*/
public function calculate_all_expressions();
}
/**
* Helper class for questions that use datasets. Works with the interface
* {@link qtype_calculated_question_with_expressions} and the class
* {@link qtype_calculated_dataset_loader} to set up the value of each variable
* in start_attempt, and restore that in apply_attempt_state.
*
* @copyright 2011 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
abstract class qtype_calculated_question_helper {
public static function start_attempt(
qtype_calculated_question_with_expressions $question,
question_attempt_step $step, $variant) {
$question->vs = new qtype_calculated_variable_substituter(
$question->datasetloader->get_values($variant),
get_string('decsep', 'langconfig'));
$question->calculate_all_expressions();
foreach ($question->vs->get_values() as $name => $value) {
$step->set_qt_var('_var_' . $name, $value);
}
}
public static function apply_attempt_state(
qtype_calculated_question_with_expressions $question, question_attempt_step $step) {
$values = array();
foreach ($step->get_qt_data() as $name => $value) {
if (substr($name, 0, 5) === '_var_') {
$values[substr($name, 5)] = $value;
}
}
$question->vs = new qtype_calculated_variable_substituter(
$values, get_string('decsep', 'langconfig'));
$question->calculate_all_expressions();
}
}
/**
* This class is responsible for loading the dataset that a question needs from
* the database.
*
* @copyright 2011 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class qtype_calculated_dataset_loader {
/** @var int the id of the question we are helping. */
protected $questionid;
/** @var int the id of the question we are helping. */
protected $itemsavailable = null;
/**
* Constructor
* @param int $questionid the question to load datasets for.
*/
public function __construct($questionid) {
$this->questionid = $questionid;
}
/**
* Get the number of items (different values) in each dataset used by this
* question. This is the minimum number of items in any dataset used by this
* question.
* @return int the number of items available.
*/
public function get_number_of_items() {
global $DB;
if (is_null($this->itemsavailable)) {
$this->itemsavailable = $DB->get_field_sql('
SELECT MIN(qdd.itemcount)
FROM {question_dataset_definitions} qdd
JOIN {question_datasets} qd ON qdd.id = qd.datasetdefinition
WHERE qd.question = ?
', array($this->questionid), MUST_EXIST);
}
return $this->itemsavailable;
}
/**
* Actually query the database for the values.
* @param int $itemnumber which set of values to load.
* @return array name => value;
*/
protected function load_values($itemnumber) {
global $DB;
return $DB->get_records_sql_menu('
SELECT qdd.name, qdi.value
FROM {question_dataset_items} qdi
JOIN {question_dataset_definitions} qdd ON qdd.id = qdi.definition
JOIN {question_datasets} qd ON qdd.id = qd.datasetdefinition
WHERE qd.question = ?
AND qdi.itemnumber = ?
', array($this->questionid, $itemnumber));
}
/**
* Load a particular set of values for each dataset used by this question.
* @param int $itemnumber which set of values to load.
* 0 < $itemnumber <= {@link get_number_of_items()}.
* @return array name => value.
*/
public function get_values($itemnumber) {
if ($itemnumber <= 0 || $itemnumber > $this->get_number_of_items()) {
$a = new stdClass();
$a->id = $this->questionid;
$a->item = $itemnumber;
throw new moodle_exception('cannotgetdsfordependent', 'question', '', $a);
}
return $this->load_values($itemnumber);
}
public function datasets_are_synchronised($category) {
global $DB;
// We need to ensure that there are synchronised datasets, and that they
// all use the right category.
$categories = $DB->get_record_sql('
SELECT MAX(qdd.category) AS max,
MIN(qdd.category) AS min
FROM {question_dataset_definitions} qdd
JOIN {question_datasets} qd ON qdd.id = qd.datasetdefinition
WHERE qd.question = ?
AND qdd.category <> 0
', array($this->questionid));
return $categories && $categories->max == $category && $categories->min == $category;
}
}
/**
* This class holds the current values of all the variables used by a calculated
* question.
*
* It can compute formulae using those values, and can substitute equations
* embedded in text.
*
* @copyright 2011 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class qtype_calculated_variable_substituter {
/** @var array variable name => value */
protected $values;
/** @var string character to use for the decimal point in displayed numbers. */
protected $decimalpoint;
/** @var array variable names wrapped in {...}. Used by {@link substitute_values()}. */
protected $search;
/**
* @var array variable values, with negative numbers wrapped in (...).
* Used by {@link substitute_values()}.
*/
protected $safevalue;
/**
* @var array variable values, with negative numbers wrapped in (...).
* Used by {@link substitute_values()}.
*/
protected $prettyvalue;
/**
* Constructor
* @param array $values variable name => value.
*/
public function __construct(array $values, $decimalpoint) {
$this->values = $values;
$this->decimalpoint = $decimalpoint;
// Prepare an array for {@link substitute_values()}.
$this->search = array();
$this->replace = array();
foreach ($values as $name => $value) {
if (!is_numeric($value)) {
$a = new stdClass();
$a->name = '{' . $name . '}';
$a->value = $value;
throw new moodle_exception('notvalidnumber', 'qtype_calculated', '', $a);
}
$this->search[] = '{' . $name . '}';
$this->safevalue[] = '(' . $value . ')';
$this->prettyvalue[] = $this->format_float($value);
}
}
/**
* Display a float properly formatted with a certain number of decimal places.
* @param number $x the number to format
* @param int $length restrict to this many decimal places or significant
* figures. If null, the number is not rounded.
* @param int format 1 => decimalformat, 2 => significantfigures.
* @return string formtted number.
*/
public function format_float($x, $length = null, $format = null) {
< if (!is_null($length) && !is_null($format)) {
> if (is_nan($x)) {
> $x = 'NAN';
> } else if (is_infinite($x)) {
> $x = ($x < 0) ? '-INF' : 'INF';
> } else if (!is_null($length) && !is_null($format)) {
if ($format == '1' ) { // Answer is to have $length decimals.
// Decimal places.
$x = sprintf('%.' . $length . 'F', $x);
} else if ($x) { // Significant figures does only apply if the result is non-zero.
$answer = $x;
// Convert to positive answer.
if ($answer < 0) {
$answer = -$answer;
$sign = '-';
} else {
$sign = '';
}
// Determine the format 0.[1-9][0-9]* for the answer...
$p10 = 0;
while ($answer < 1) {
--$p10;
$answer *= 10;
}
while ($answer >= 1) {
++$p10;
$answer /= 10;
}
// ... and have the answer rounded of to the correct length.
$answer = round($answer, $length);
// If we rounded up to 1.0, place the answer back into 0.[1-9][0-9]* format.
if ($answer >= 1) {
++$p10;
$answer /= 10;
}
// Have the answer written on a suitable format.
// Either scientific or plain numeric.
if (-2 > $p10 || 4 < $p10) {
// Use scientific format.
$exponent = 'e'.--$p10;
$answer *= 10;
if (1 == $length) {
$x = $sign.$answer.$exponent;
} else {
// Attach additional zeros at the end of $answer.
$answer .= (1 == strlen($answer) ? '.' : '')
. '00000000000000000000000000000000000000000x';
$x = $sign
.substr($answer, 0, $length +1).$exponent;
}
} else {
// Stick to plain numeric format.
$answer *= "1e{$p10}";
if (0.1 <= $answer / "1e{$length}") {
$x = $sign.$answer;
} else {
// Could be an idea to add some zeros here.
$answer .= (preg_match('~^[0-9]*$~', $answer) ? '.' : '')
. '00000000000000000000000000000000000000000x';
$oklen = $length + ($p10 < 1 ? 2-$p10 : 1);
$x = $sign.substr($answer, 0, $oklen);
}
}
} else {
$x = 0.0;
}
}
return str_replace('.', $this->decimalpoint, $x);
}
/**
* Return an array of the variables and their values.
* @return array name => value.
*/
public function get_values() {
return $this->values;
}
/**
* Evaluate an expression using the variable values.
* @param string $expression the expression. A PHP expression with placeholders
* like {a} for where the variables need to go.
* @return float the computed result.
*/
public function calculate($expression) {
// Make sure no malicious code is present in the expression. Refer MDL-46148 for details.
if ($error = qtype_calculated_find_formula_errors($expression)) {
throw new moodle_exception('illegalformulasyntax', 'qtype_calculated', '', $error);
}
$expression = $this->substitute_values_for_eval($expression);
if ($datasets = question_bank::get_qtype('calculated')->find_dataset_names($expression)) {
// Some placeholders were not substituted.
throw new moodle_exception('illegalformulasyntax', 'qtype_calculated', '',
'{' . reset($datasets) . '}');
}
return $this->calculate_raw($expression);
}
/**
* Evaluate an expression after the variable values have been substituted.
* @param string $expression the expression. A PHP expression with placeholders
* like {a} for where the variables need to go.
* @return float the computed result.
*/
protected function calculate_raw($expression) {
try {
// In older PHP versions this this is a way to validate code passed to eval.
// The trick came from http://php.net/manual/en/function.eval.php.
if (@eval('return true; $result = ' . $expression . ';')) {
return eval('return ' . $expression . ';');
}
} catch (Throwable $e) {
// PHP7 and later now throws ParseException and friends from eval(),
// which is much better.
}
// In either case of an invalid $expression, we end here.
throw new moodle_exception('illegalformulasyntax', 'qtype_calculated', '', $expression);
}
/**
* Substitute variable placehodlers like {a} with their value wrapped in ().
* @param string $expression the expression. A PHP expression with placeholders
* like {a} for where the variables need to go.
* @return string the expression with each placeholder replaced by the
* corresponding value.
*/
protected function substitute_values_for_eval($expression) {
return str_replace($this->search, $this->safevalue, $expression);
}
/**
* Substitute variable placehodlers like {a} with their value without wrapping
* the value in anything.
* @param string $text some content with placeholders
* like {a} for where the variables need to go.
* @return string the expression with each placeholder replaced by the
* corresponding value.
*/
protected function substitute_values_pretty($text) {
return str_replace($this->search, $this->prettyvalue, $text);
}
/**
* Replace any embedded variables (like {a}) or formulae (like {={a} + {b}})
* in some text with the corresponding values.
* @param string $text the text to process.
* @return string the text with values substituted.
*/
public function replace_expressions_in_text($text, $length = null, $format = null) {
$vs = $this; // Can't use $this in a PHP closure.
$text = preg_replace_callback(qtype_calculated::FORMULAS_IN_TEXT_REGEX,
function ($matches) use ($vs, $format, $length) {
return $vs->format_float($vs->calculate($matches[1]), $length, $format);
}, $text);
return $this->substitute_values_pretty($text);
}
}