/**

public function get_log();

/**

public function log($heading = '', $message = '');

// phpcs:ignore moodle.Commenting.VariableComment.Missing

protected $debuginfo = '';

/**

public function get_log() {

return $this->debuginfo;

}

/**

public function log($heading = '', $message = '') {

if ($heading) {

$this->debuginfo .= html_writer::tag('h3', $heading);

}

if ($message) {

$this->debuginfo .= html_writer::tag('pre', s($message));

}

}

/**

public function get_log() {

return '';

}

/**

public function log($heading = '', $message = '') {

// Do nothing.

}

/** @var object the STACK config data, so we only ever have to load it from the DB once. */

protected static $config = null;

/** @var A list of mathematics environments we search for, from AMSmath package 2.0. */

protected static $mathdelimiters = ['equation', 'align', 'gather', 'flalign', 'multline', 'alignat', 'split'];

/**

const VALID_NAME_REGEX = '[a-zA-Z][a-zA-Z0-9_]*';

/**

private function __construct() {

throw new stack_exception('stack_utils: you cannot create instances of this class.');

}

/**

public static function make_debug_log($debugenabled = true) {

if ($debugenabled) {

return new stack_debug_log_base();

} else {

return new stack_debug_log_null();

}

}

/**

public static function check_bookends($string, $left, $right) {

$leftcount = substr_count($string, $left);

$rightcount = substr_count($string, $right);

if ($leftcount == $rightcount) {

return true;

} else if ($leftcount > $rightcount) {

return 'right';

} else {

return 'left';

}

}

/**

public static function check_nested_bookends($string, $lefts = '([{', $rights = ')]}') {

$openstack = [];

$length = strlen($string);

for ($i = 0; $i < $length; $i++) {

$char = $string[$i];

if (strpos($lefts, $char) !== false) {

array_push($openstack, $char);

} else if (($closerpos = strpos($rights, $char)) !== false) {

$opener = array_pop($openstack); // NULL if array is empty, which works.

if ($opener !== $lefts[$closerpos]) {

return false;

}

}

}

return empty($openstack);

}

/**

public static function substring_between($string, $left, $right, $start = 0) {

$start = strpos($string, $left, $start);

if ($start === false) {

return ['', -1, 0];

}

if ($left == $right) {

// Left and right are the same.

$end = strpos($string, $right, $start + 1); // Just go for the next one.

if ($end === false) {

return ['', $start, -1];

}

$end += 1;

} else {

$length = strlen($string);

$nesting = 1;

$end = $start + 1;

while ($nesting > 0 && $end < $length) {

if ($string[$end] == $left) {

$nesting += 1;

} else if ($string[$end] == $right) {

$nesting -= 1;

}

$end++;

}

if ($nesting > 0) {

return ['', -1, -1];

}

}

return [substr($string, $start, $end - $start), $start, $end - 1];

}

/**

public static function all_substring_between($string, $left, $right = null, $skipempty = false) {

if ($right == null) {

$right = $left;

}

$char = str_split($string);

$length = count($char);

$var = [];

$j = 0;

$i = 0;

$start = false;

$found = '';

while ($i < $length) {

if ($start == false) {

// Find starting @.

if ($char[$i] == $left) {

$start = true;

$found .= $char[$i];

}

} else {

// We have the first @ find ending @.

if ($char[$i] == $right) {

// End of cas command found.

$found .= $char[$i];

$found = str_replace($left, '', $found);

$found = str_replace($right, '', $found);

$found = trim($found);

if (!$skipempty || $found) {

$var[$j] = $found;

}

$j++;

$found = '';

$start = false;

} else {

$found .= $char[$i];

}

}

$i++;

}

return $var;

}

/**

public static function replace_between($string, $left, $right, $replacements, $skipempty = false) {

// Do error checking.

$leftcount = substr_count($string, $left);

$rightcount = substr_count($string, $right);

$replacecount = count($replacements);

if ($left != $right && $leftcount != $rightcount) {

throw new stack_exception('replace_between: delimiters don\'t match.');

}

$result = '';

$matches = 0;

$char = str_split($string);

$length = count($char);

$i = 0;

$searching = true;

while ($i < $length) {

if ($searching) {

// Trying to find startchar.

if ($char[$i] == $left) {

$searching = false;

$empty = true;

}

$result .= $char[$i];

} else {

// Found startchar, looking for end.

if ($char[$i] == $right) {

// phpcs:disable

if ($skipempty && $empty) {

// Do nothing.

} else if (!isset($replacements[$matches])) {

throw new stack_exception('replace_between: not enough replacements.');

} else {

$result .= $replacements[$matches];

$matches++;

}

// phpcs:enable

$searching = true;

$result .= $char[$i];

}

$empty = false;

}

$i++;

}

if ($matches != count($replacements)) {

throw new stack_exception('replace_between: too many replacements.');

}

return $result;

}

/**

public static function underscore($string, $toreplace = []) {

$toreplace[] = '-';

$toreplace[] = ' ';

return str_replace($toreplace, '_', $string);

}

/**

public static function convert_slash_paths($string) {

$in = trim($string);

$length = strlen($in);

$lastchar = $in[($length - 1)];

$trailingslash = false;

if ($lastchar == '\\') {

$trailingslash = true;

}

$patharray = self::cvs_to_array($string, "\\");

if (!empty($patharray)) {

$newpath = $patharray[0];

for ($i = 1; $i < count($patharray); $i++) {

$newpath .= "/" . $patharray[$i];

}

if ($trailingslash == true) {

return $newpath . '/';

} else {

return $newpath;

}

} else {

return null;

}

}

/**

public static function all_substring_strings($string) {

$strings = [];

$i = 0;

$lastslash = false;

$instring = false;

$stringentry = -1;

while ($i < strlen($string)) {

$c = $string[$i];

$i++;

if ($instring) {

if ($c == '"' && !$lastslash) {

$instring = false;

// Last -1 to drop the quote.

$s = substr($string, $stringentry, ($i - $stringentry) - 1);

$strings[] = $s;

} else if ($c == "\\") {

$lastslash = !$lastslash;

} else if ($lastslash) {

$lastslash = false;

}

} else if ($c == '"') {

$instring = true;

$lastslash = false;

$stringentry = $i;

}

}

return $strings;

}

/**

public static function eliminate_strings($string) {

$cleared = '';

$i = 0;

$lastslash = false;

$instring = false;

$laststringexit = 0;

while ($i < strlen($string)) {

$c = $string[$i];

$i++;

if ($instring) {

if ($c == '"' && !$lastslash) {

$instring = false;

$laststringexit = $i - 1;

} else if ($c == "\\") {

$lastslash = !$lastslash;

} else if ($lastslash) {

$lastslash = false;

}

} else if ($c == '"') {

$instring = true;

$lastslash = false;

$cleared .= substr($string, $laststringexit, $i - $laststringexit);

}

}

$cleared .= substr($string, $laststringexit);

return $cleared;

}

/**

public static function protect_backslash_latex($string) {

$string = addslashes($string);

// We don't want to add slashes to strings within strings.

$string = str_replace('\\\\\"', '\"', $string);

return($string);

}

/**

public static function cvs_to_array($string, $token = ',') {

$exploded = explode($token, $string);

// Remove any null entries.

for ($i = 0; $i < count($exploded); $i++) {

$trim = trim($exploded[$i]);

if (!empty($trim)) {

$toreturn[] = $exploded[$i];

}

}

return $toreturn;

}

/**

public static function array_to_cvs($array) {

if (!empty($array)) {

$string = '';

$i = 0;

foreach ($array as $element) {

if ($i > 0) {

$string .= ', ';

}

if (is_bool($element)) {

if ($element) {

$string .= 'TRUE';

} else {

$string .= 'FALSE';

}

} else {

$string .= $element;

}

$i++;

}

return $string;

} else {

return '';

}

}

/**

private static function next_element($list, $delim) {

if ($list == '') {

return null;

}

// Do we have a string, which might contain commas, protected quotes and random brackets?

if (substr(trim($list), 0, 1) === '"') {

$startchar = strpos($list, '"'); // Start of the string.

$foundend = false;

for ($i = $startchar + 1; $i < strlen($list); $i++) {

if ($list[$i] == '"' && $list[$i - 1] != '\\') {

$foundend = true;

}

if ($foundend && $list[$i] == $delim) {

return substr($list, 0, $i);

}

}

// We started a string, but never ended with a comma.

return $list;

}

// Delimited by next comma at same degree of nesting.

$startdelimiter = "[({";

$enddelimiter = "])}";

$nesting = [0 => 0, 1 => 0, 2 => 0]; // Stores nesting for delimiters above.

for ($i = 0; $i < strlen($list); $i++) {

$startchar = strpos($startdelimiter, $list[$i]); // Which start delimiter.

$endchar = strpos($enddelimiter, $list[$i]); // Which end delimiter (if any).

// Change nesting for delimiter if specified.

if ($startchar !== false) {

$nesting[$startchar]++;

} else if ($endchar !== false) {

$nesting[$endchar]--;

} else if ($list[$i] == $delim && $nesting[0] == 0 && $nesting[1] == 0 && $nesting[2] == 0) {

// Otherwise, return element if all nestings are zero.

return substr($list, 0, $i);

}

}

// End of list reached.

if ($nesting[0] == 0 && $nesting[1] == 0 && $nesting[2] == 0) {

return $list;

} else {

return null;

}

}

// phpcs:ignore moodle.Commenting.MissingDocblock.Function

private static function list_to_array_workhorse($list, $rec = true, $delim = ',') {

$array = [];

$list = trim($list);

$list = substr($list, 1, strlen($list) - 2); // Trims outermost [] only.

$e = self::next_element($list, $delim);

while ($e !== null) {

if ($e[0] == '[') {

if ($rec) {

$array[] = self::list_to_array_workhorse($e, $rec, $delim);

} else {

$array[] = $e;

}

} else {

$array[] = $e;

}

$list = substr($list, strlen($e) + 1);

$e = self::next_element($list, $delim);

}

return $array;

}

/**

public static function list_to_array($string, $rec = true, $delim = ',') {

return self::list_to_array_workhorse($string, $rec, $delim);

}

/**

public static function extract_placeholders($text, $type) {

if (!$text) {

return [];

}

preg_match_all(

'~\[\[' . $type . ':(' . self::VALID_NAME_REGEX . ')\]\]~',

$text,

$matches

);

return $matches[1];

}

/**

public static function extract_placeholders_sloppy($text, $type) {

preg_match_all(

'~\[\[' . $type . ':(' . self::VALID_NAME_REGEX . ')\]\]~',

$text,

$matches1

);

preg_match_all(

'~\[\[\s*' . $type . '\s*:(\s*' . self::VALID_NAME_REGEX . ')\s*\]\]~',

$text,

$matches2

);

$ret = [];

foreach ($matches2[1] as $key => $name) {

if (!in_array(trim($name), $matches1[1])) {

$ret[] = $matches2[0][$key];

}

}

return($ret);

}

/**

public static function is_valid_name($name) {

return preg_match('~^' . self::VALID_NAME_REGEX . '$~', $name);

}

/**

public static function get_config() {

if (is_null(self::$config)) {

self::$config = get_config('qtype_stack');

}

return self::$config;

}

// phpcs:ignore moodle.Commenting.MissingDocblock.Function

public static function clear_config_cache() {

self::$config = null;

}

/**

public static function decompose_rename_operation(array $renamemap) {

$nontrivialmap = [];

$usednames = [];

foreach ($renamemap as $from => $to) {

$usednames[(string) $from] = 1;

$usednames[(string) $to] = 1;

if ((string) $from !== (string) $to) {

$nontrivialmap[(string) $from] = (string) $to;

}

}

if (empty($nontrivialmap)) {

return [];

}

// First we deal with all renames that are not part of cycles.

// This bit is O(n^2) and it ought to be possible to do better,

// but it does not seem worth the effort.

$saferenames = [];

$todocount = count($nontrivialmap) + 1;

while (count($nontrivialmap) < $todocount) {

$todocount = count($nontrivialmap);

foreach ($nontrivialmap as $from => $to) {

if (array_key_exists($to, $nontrivialmap)) {

continue; // Cannot currenly do this rename.

}

// Is safe to do this rename now.

$saferenames[$from] = $to;

unset($nontrivialmap[$from]);

}

}

// Are we done?

if (empty($nontrivialmap)) {

return $saferenames;

}

// Now, what is left in $nontrivialmap will permutation, which must be a

// combination of distinct cycles. We need to break them.

$tempname = self::get_next_unused_name($usednames);

while (!empty($nontrivialmap)) {

// Extract the first cycle.

reset($nontrivialmap);

$current = $cyclestart = (string) key($nontrivialmap);

$cycle = [];

do {

$cycle[] = $current;

$next = $nontrivialmap[$current];

unset($nontrivialmap[$current]);

$current = $next;

} while ($current !== $cyclestart);

// Now convert it to a sequence of safe renames by using a temp.

$saferenames[$cyclestart] = $tempname;

$cycle[0] = $tempname;

$to = $cyclestart;

while ($from = array_pop($cycle)) {

$saferenames[$from] = $to;

$to = $from;

}

$tempname = self::get_next_unused_name($usednames, ++$tempname);

}

return $saferenames;

}

/**

protected static function get_next_unused_name($usednames, $suggestedname = 'temp1') {

while (array_key_exists($suggestedname, $usednames)) {

$suggestedname++;

}

return $suggestedname;

}

/**

public static function sort_array(&$array) {

if (class_exists('core_collator')) {

core_collator::asort($array);

} else {

collatorlib::asort($array);

}

}

/**

public static function sort_array_by_key(&$array) {

if (class_exists('core_collator')) {

core_collator::ksort($array);

} else {

collatorlib::ksort($array);

}

}

/**

public static function php_string_to_maxima_string($string) {

$converted = str_replace("\\", "\\\\", $string);

$converted = str_replace("\"", "\\\"", $converted);

return '"' . $converted . '"';

}

/**

public static function maxima_string_to_php_string($string) {

$converted = str_replace("\\\\", "\\", $string);

$converted = str_replace("\\\"", '"', $converted);

return substr($converted, 1, -1);

}

/**

public static function maxima_string_strip_mbox($string) {

$converted = trim($string);

if (substr($converted, 0, 2) == '\(' || substr($converted, 0, 2) == '\[') {

$converted = substr($converted, 2, -2);

}

if (substr(trim($converted), 0, 6) == '\text{') {

return substr(trim($converted), 6, -1);

}

return $string;

}

/**

public static function maxima_translate_string(string $string) {

$fixed = $string;

if (strpos($string, '0 to a negative exponent') !== false) {

$fixed = stack_string('Maxima_DivisionZero');

} else if (strpos($string, 'args: argument must be a non-atomic expression;') !== false) {

$fixed = stack_string('Maxima_Args');

}

return $fixed;

}

/**

public static function rational_approximation(float $n, int $accuracy) {

$accuracy = pow(10, -$accuracy);

// Handle sign.

$sign = ($n < 0) ? -1 : 1;

$n = abs($n);

// Handle integers directly.

if (floor($n) == $n) {

return [$sign * $n, 1];

}

// Continued fraction expansion with convergents.

$p0 = 1;

$q0 = 0;

$p1 = floor($n);

$q1 = 1;

$x1 = $n;

$steps = 0;

// The algorithm converges quickly, so no need for more than 100 here.

while ($steps < 100) {

$steps++;

// Current approximation.

$approx = $p1 / $q1;

if (abs($approx - $n) <= $accuracy) {

break;

}

// Prevent division by zero.

$frac = $x1 - floor($x1);

if ($frac == 0.0) {

break;

}

// Next term in continued fraction.

$x1 = 1.0 / $frac;

$a = floor($x1);

// Recurrence.

$p2 = $a * $p1 + $p0;

$q2 = $a * $q1 + $q0;

// Shift.

$p0 = $p1;

$q0 = $q1;

$p1 = $p2;

$q1 = $q2;

}

return [$sign * $p1, $q1];

}

// phpcs:ignore moodle.Commenting.MissingDocblock.Function

public static function fix_to_continued_fraction($n, $accuracy) {

$frac = self::rational_approximation($n, $accuracy);

return $frac[0] / $frac[1];

}

/**

public static function fix_approximate_thirds($fraction) {

if (!is_numeric($fraction)) {

return $fraction;

}

$fraction = (float) $fraction;

if ($fraction >= 0.33 && $fraction <= 0.34) {

return 0.3333333;

} else if ($fraction >= 0.66 && $fraction <= 0.67) {

return 0.6666667;

} else {

return $fraction;

}

}

/**

public static function fix_trailing_zeros($str) {

if (!is_numeric($str)) {

return $str;

}

return 0 + $str;

}

/**

public static function parse_option($option) {

$arg = '';

if (!(strpos($option, ':') === false)) {

$ops = explode(':', $option);

$option = $ops[0];

$arg = trim($ops[1]);

}

return([$option, $arg]);

}

/**

public static function count_missing_alttext($text) {

$missingalt = 0;

// Yes, regular expressions can't parse html, but this should be good-enough to help users for now.

$matchentireimagetags = '