source: geniuswebcore/geniusweb/bidspace/IssueInfo.py@ 100

from decimal import Decimal
from geniusweb.issuevalue.ValueSet import ValueSet
from geniusweb.profile.utilityspace.ValueSetUtilities import ValueSetUtilities
from geniusweb.bidspace.Interval import Interval
from geniusweb.issuevalue.Value import Value
from typing import List, Dict, Optional

class IssueInfo:
        '''
         Tool class to collect all relevant info about one issue (from LinearAdditive)
         in one class. Used for internally grouping data for more efficient
         processing. This class may change in the future, not recommended for direct
         use.
         <p>
         immutable
        '''

        def __init__(self, name:str, values:ValueSet ,  utils:ValueSetUtilities,
                        weight:Decimal , precision:int ) :
                '''
                @param name      the issue name
                @param values    the {@link ValueSet} of the issue
                @param utils     the {@link ValueSetUtilities} of the issue profile
                @param weight    the weight of the {@link ValueSetUtilities}
                @param precision the precision to compute with. Basically the number of
                         decimal places used for the computations.
                '''
                self._name = name;
                self._values = values;
                self._weightedUtils = self._computeWeightedUtils(utils, weight, precision);
                self._interval = self._getRange();

        def getValues(self) ->ValueSet :
                return self._values

        def getName(self)->str:
                return self._name;

        def getInterval(self)->Interval:
                '''
                @return weighted minimum and maximum utility achievable with this issue,
                    rounded to the requested precision.
                '''
                return self._interval;

        def getExtreme(self, isMax:bool)->Value :
                '''
                @param isMax if true the max {@link Value} is returned, else the min is
                             returned.
                @return the extreme value, either the minimum if isMax=false or maximum
                        if isMax=true
                '''
                extremeutil:Decimal = None #type:ignore
                extremeval:Decimal = None #type:ignore
                for val in self._values:
                        util = self._weightedUtils.get(val)
                        if extremeval == None:
                                extremeutil = self._weightedUtils.get(val) #type:ignore
                                extremeval = val
                        else:
                                if isMax:
                                        if util > extremeutil: #type:ignore
                                                extremeutil = util #type:ignore
                                                extremeval = val
                                else:
                                        if util<extremeutil: #type:ignore
                                                extremeutil = util #type:ignore
                                                extremeval = val
                return extremeval #type:ignore

        def getWeightedUtil(self, val:Value ) -> Decimal :
                '''
                @param val the issue value to be evaluated
                @return weighted utility of given value, rounded to nearest value with
                        the requested precision number of digits.
                '''
                return self._weightedUtils.get(val) #type:ignore

        def _subset(self,  interval:Interval) -> List[Value]:
                '''
                @param interval an {@link Interval} of utility values.
                @return all values that are inside the interval.
                '''

                selection:List[Value]  = []
                for value in self._values:
                        if interval.contains(self.getWeightedUtil(value)):
                                selection.append(value);
                return selection

        def _subsetSize( self, interval:Interval) ->int:
                '''
                Faster way to determine subset size, it does not create a list
                
                @param interval an {@link Interval} of utility values.
                @return size of the subset that you will get from calling subset
                '''
                n = 0
                for value in self._values:
                        if interval.contains(self.getWeightedUtil(value)):
                                n=n+1
                return n

        def _getRange(self)->Interval :
                '''
                @return the {@link Interval} (minimum and maximum) of the utility of the
                        weighted utility of this issue, properly rounded to the
                        {@link #precision}/

                '''
                min = Decimal(1)
                max = Decimal(0)
                for value in  self._values:
                        util = self.getWeightedUtil(value)
                        if util < min:
                                min = util
                        if util > max:
                                max = util
                return Interval(min, max)

        def _computeWeightedUtils(self, utilities:ValueSetUtilities, w:Decimal, prec:int) \
                                -> Dict[Value, Decimal] :
                map:Dict[Value, Decimal]  = {}

                for val in self._values:
                        map[val] = round(utilities.getUtility(val)* w, prec)
                return map