class.assClozeGap.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */
 
include_once "./Modules/Test/classes/inc.AssessmentConstants.php";
 
class assClozeGap
{
    const TYPE_TEXT = 0;
    const TYPE_SELECT = 1;
    const TYPE_NUMERIC = 2;
 
    public $type;
 
    public $items;
 
    public $shuffle;
 
    private $shuffler;
 
    private $gap_size = 0;
 
    public function __construct($a_type)
    {
        $this->type = (int) $a_type;
        $this->items = array();
        $this->shuffle = true;
    }
 
    public function getType()
    {
        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)
    {
        $this->type = $a_type;
    }
 
    public function getItems(ilArrayElementShuffler $shuffler, ?int $gap_index = null) : array
    {
        if (!$this->getShuffle()) {
            return $this->items;
        }
 
        if ($gap_index === null) {
            return $shuffler->shuffle($this->items);
        }
 
        $items = $this->items;
        for ($i = -2; $i < $gap_index; $i++) {
            $items = $shuffler->shuffle($items);
        }
 
        return $items;
    }
 
    public function getItemsRaw()
    {
        return $this->items;
    }
 
    public function getItemCount()
    {
        return count($this->items);
    }
 
    public function addItem($a_item)
    {
        $order = $a_item->getOrder();
        if (array_key_exists($order, $this->items)) {
            $newitems = array();
            for ($i = 0; $i < $order; $i++) {
                array_push($newitems, $this->items[$i]);
            }
            array_push($newitems, $a_item);
            for ($i = $order; $i < count($this->items); $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)
    {
        foreach ($this->items as $key => $item) {
            if ($item->getOrder() == $order) {
                $item->setPoints($points);
            }
        }
    }
 
    public function deleteItem($order)
    {
        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)
    {
        foreach ($this->items as $key => $item) {
            if ($item->getOrder() == $order) {
                $item->setLowerBound($bound);
            }
        }
    }
 
    public function setItemUpperBound($order, $bound)
    {
        foreach ($this->items as $key => $item) {
            if ($item->getOrder() == $order) {
                $item->setUpperBound($bound);
            }
        }
    }
 
    public function getItem($a_index)
    {
        if (array_key_exists($a_index, $this->items)) {
            return $this->items[$a_index];
        } else {
            return null;
        }
    }
 
    public function clearItems()
    {
        $this->items = array();
    }
 
    public function setShuffle($a_shuffle = true)
    {
        $this->shuffle = (bool) $a_shuffle;
    }
 
    public function getShuffle()
    {
        return $this->shuffle;
    }
 
    public function setShuffler(ilArrayElementShuffler $shuffler = null)
    {
        if ($shuffler == null) {
            require_once 'Services/Randomization/classes/class.ilArrayElementShuffler.php';
            $shuffler = new ilArrayElementShuffler();
            $seed = $shuffler->buildRandomSeed();
            $shuffler->setSeed($seed);
        }
        $this->shuffler = $shuffler;
    }
 
    public function getShuffler() : ilArrayElementShuffler
    {
        if ($this->shuffler == null) {
            $this->setShuffler();
        }
        return $this->shuffler;
    }
 
 
 
    public function getMaxWidth()
    {
        $maxwidth = 0;
        foreach ($this->items as $item) {
            if (strlen($item->getAnswertext()) > $maxwidth) {
                $maxwidth = strlen($item->getAnswertext());
            }
        }
        return $maxwidth;
    }
 
    public function getBestSolutionIndexes()
    {
        $maxpoints = 0;
        foreach ($this->items as $key => $item) {
            if ($item->getPoints() > $maxpoints) {
                $maxpoints = $item->getPoints();
            }
        }
        $keys = array();
        foreach ($this->items as $key => $item) {
            if ($item->getPoints() == $maxpoints) {
                array_push($keys, $key);
            }
        }
        return $keys;
    }
 
    public function getBestSolutionOutput(ilArrayElementShuffler $shuffler, $combinations = null)
    {
        global $DIC;
        $lng = $DIC['lng'];
        switch ($this->getType()) {
            case CLOZE_TEXT:
            case CLOZE_SELECT:
                $best_solutions = array();
                if ($combinations !== null && $combinations['best_solution'] == 1) {
                    $best_solutions[$combinations['points']] = array();
                    array_push($best_solutions[$combinations['points']], $combinations['answer']);
                } else {
                    foreach ($this->getItems($shuffler) as $answer) {
                        if (isset($best_solutions[$answer->getPoints()]) && is_array($best_solutions[$answer->getPoints()])) {
                            array_push($best_solutions[$answer->getPoints()], $answer->getAnswertext());
                        } else {
                            $best_solutions[$answer->getPoints()] = array();
                            array_push($best_solutions[$answer->getPoints()], $answer->getAnswertext());
                        }
                    }
                }
 
                krsort($best_solutions, SORT_NUMERIC);
                reset($best_solutions);
                $found = current($best_solutions);
                return join(" " . $lng->txt("or") . " ", $found);
                break;
            case CLOZE_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($gap_size)
    {
        $this->gap_size = $gap_size;
    }
 
    public function getGapSize()
    {
        return $this->gap_size;
    }
 
    public function numericRangeExists()
    {
        if ($this->getType() != CLOZE_NUMERIC) {
            return false;
        }
 
        require_once 'Services/Math/classes/class.EvalMath.php';
        $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;
    }
}