class.assClozeGap.php

Go to the documentation of this file.

<?php
use ILIAS\Refinery\Transformation;
use ILIAS\Refinery\Random\Transformation\ShuffleTransformation;
 
class assClozeGap
{
    public const TYPE_TEXT = 0;
    public const TYPE_SELECT = 1;
    public const TYPE_NUMERIC = 2;
 
    public const TEXTGAP_RATING_CASEINSENSITIVE = "ci";
    public const TEXTGAP_RATING_CASESENSITIVE = "cs";
    public const TEXTGAP_RATING_LEVENSHTEIN1 = "l1";
    public const TEXTGAP_RATING_LEVENSHTEIN2 = "l2";
    public const TEXTGAP_RATING_LEVENSHTEIN3 = "l3";
    public const TEXTGAP_RATING_LEVENSHTEIN4 = "l4";
    public const TEXTGAP_RATING_LEVENSHTEIN5 = "l5";
 
    private ?Transformation $shuffler = null;
 
    public int $type;
 
    public $items;
 
    public $shuffle;
 
    private $gap_size = 0;
 
    public function __construct($a_type)
    {
        $this->type = (int) $a_type;
        $this->items = [];
        $this->shuffle = true;
    }
 
    public function getType(): int
    {
        return $this->type;
    }
 
    public function isTextGap(): bool
    {
        return $this->type === self::TYPE_TEXT;
    }
 
    public function isSelectGap(): bool
    {
        return $this->type === self::TYPE_SELECT;
    }
 
    public function isNumericGap(): bool
    {
        return $this->type === self::TYPE_NUMERIC;
    }
 
    public function setType($a_type = 0): void
    {
        $this->type = $a_type;
    }
 
    public function getItems(Transformation $shuffler, ?int $gap_index = null): array
    {
        if (!$this->getShuffle()) {
            return $this->items;
        }
 
        if ($gap_index === null) {
            return $shuffler->transform($this->items);
        }
 
        $items = $this->items;
        for ($i = -2; $i < $gap_index; $i++) {
            $items = $shuffler->transform($items);
        }
 
        return $items;
    }
 
    public function getItemsRaw(): array
    {
        return $this->items;
    }
 
    public function getItemCount(): int
    {
        return count($this->items);
    }
 
    public function addItem($a_item): void
    {
        $order = $a_item->getOrder();
        if (array_key_exists($order, $this->items)) {
            $newitems = [];
            for ($i = 0; $i < $order; $i++) {
                array_push($newitems, $this->items[$i]);
            }
            array_push($newitems, $a_item);
            for ($i = $order, $iMax = count($this->items); $i < $iMax; $i++) {
                array_push($newitems, $this->items[$i]);
            }
            $i = 0;
            foreach ($newitems as $idx => $item) {
                $newitems[$idx]->setOrder($i);
                $i++;
            }
            $this->items = $newitems;
        } else {
            array_push($this->items, $a_item);
        }
    }
 
    public function setItemPoints($order, $points): void
    {
        foreach ($this->items as $key => $item) {
            if ($item->getOrder() == $order) {
                $item->setPoints($points);
            }
        }
    }
 
    public function deleteItem($order): void
    {
        if (array_key_exists($order, $this->items)) {
            unset($this->items[$order]);
            $order = 0;
            foreach ($this->items as $key => $item) {
                $this->items[$key]->setOrder($order);
                $order++;
            }
        }
    }
 
    public function setItemLowerBound($order, $bound): void
    {
        foreach ($this->items as $key => $item) {
            if ($item->getOrder() == $order) {
                $item->setLowerBound($bound);
            }
        }
    }
 
    public function setItemUpperBound($order, $bound): void
    {
        foreach ($this->items as $key => $item) {
            if ($item->getOrder() == $order) {
                $item->setUpperBound($bound);
            }
        }
    }
 
    public function getItem($a_index): ?assAnswerCloze
    {
        if (array_key_exists($a_index, $this->items)) {
            return $this->items[$a_index];
        } else {
            return null;
        }
    }
 
    public function clearItems(): void
    {
        $this->items = [];
    }
 
    public function setShuffle($a_shuffle = true): void
    {
        $this->shuffle = (bool) $a_shuffle;
    }
 
    public function getShuffle(): bool
    {
        return $this->shuffle;
    }
 
    public function getMaxWidth(): int
    {
        $maxwidth = 0;
        foreach ($this->items as $item) {
            if (strlen($item->getAnswertext()) > $maxwidth) {
                $maxwidth = strlen($item->getAnswertext());
            }
        }
        return $maxwidth;
    }
 
    public function getBestSolutionIndexes(): array
    {
        $maxpoints = 0;
        foreach ($this->items as $key => $item) {
            if ($item->getPoints() > $maxpoints) {
                $maxpoints = $item->getPoints();
            }
        }
        $keys = [];
        foreach ($this->items as $key => $item) {
            if ($item->getPoints() == $maxpoints) {
                array_push($keys, $key);
            }
        }
        return $keys;
    }
 
    public function getBestSolutionOutput(Transformation $shuffler, $combinations = null): string
    {
        global $DIC;
        $lng = $DIC['lng'];
        switch ($this->getType()) {
            case self::TYPE_TEXT:
            case self::TYPE_SELECT:
                $best_solutions = [];
                if ($combinations !== null && $combinations['best_solution'] === 1) {
                    $points_string_for_key = (string) $combinations['points'];
                    $best_solutions[$points_string_for_key] = [];
                    array_push($best_solutions[$points_string_for_key], $combinations['answer']);
                } else {
                    foreach ($this->getItems($shuffler) as $answer) {
                        $points_string_for_key = (string) $answer->getPoints();
                        if (isset($best_solutions[$points_string_for_key]) && is_array($best_solutions[$points_string_for_key])) {
                            array_push($best_solutions[$points_string_for_key], $answer->getAnswertext());
                        } else {
                            $best_solutions[$points_string_for_key] = [];
                            array_push($best_solutions[$points_string_for_key], $answer->getAnswertext());
                        }
                    }
                }
 
                krsort($best_solutions, SORT_NUMERIC);
                reset($best_solutions);
                $found = current($best_solutions);
                return join(" " . $lng->txt("or") . " ", $found);
                break;
            case self::TYPE_NUMERIC:
                $maxpoints = 0;
                $foundvalue = "";
                foreach ($this->getItems($shuffler) as $answer) {
                    if ($answer->getPoints() >= $maxpoints) {
                        $maxpoints = $answer->getPoints();
                        $foundvalue = $answer->getAnswertext();
                    }
                }
                return $foundvalue;
                break;
            default:
                return "";
        }
    }
 
    public function setGapSize(int $gap_size): void
    {
        $this->gap_size = $gap_size;
    }
 
    public function getGapSize(): int
    {
        return (int) $this->gap_size;
    }
 
    public function numericRangeExists(): bool
    {
        if ($this->getType() != self::TYPE_NUMERIC) {
            return false;
        }
 
        $math = new EvalMath();
 
        $item = $this->getItem(0);
        $lowerBound = $math->evaluate($item->getLowerBound());
        $upperBound = $math->evaluate($item->getUpperBound());
        $preciseValue = $math->evaluate($item->getAnswertext());
 
        if ($lowerBound < $preciseValue || $upperBound > $preciseValue) {
            return true;
        }
 
        return false;
    }
}