source: geniuswebcore/geniusweb/profile/utilityspace/NumberValueSetUtilities.py@ 100

from decimal import Decimal, ROUND_HALF_UP
from typing import cast, Optional

from geniusweb.issuevalue.NumberValue import NumberValue
from geniusweb.issuevalue.NumberValueSet import NumberValueSet
from geniusweb.issuevalue.Value import Value
from geniusweb.issuevalue.ValueSet import ValueSet
from geniusweb.profile.utilityspace.ValueSetUtilities import ValueSetUtilities


class NumberValueSetUtilities (ValueSetUtilities ):
        '''
        The low and high values (from a {@link NumberValueSet} are given each a
        different utility. This linearly interpolates in-between utility values.
        '''


        def __init__(self,  lowValue:Decimal,\
                        lowUtility:Decimal,  highValue: Decimal, highUtility:Decimal) :
                '''
                @param lowValue    the low value of the {@link Range}
                @param lowUtility  the utility of the {@link #lowValue}
                @param highValue   the high value of the {@link Range}. Must be
                                   >lowValue.
                @param highUtility the utility of the {@link #highValue}
                '''
                if lowValue == None or highValue == None or lowUtility == None \
                                or highUtility == None :
                        raise ValueError(\
                                        "arguments lowValue, lowUtility, highValue and highUtility must be non-null");
                
                if not self._isInZeroOne(lowUtility):
                        raise ValueError("lowUtility must be in [0,1]")
                
                if not self._isInZeroOne(highUtility):
                        raise ValueError("highUtility must be in [0,1]")
                
                if highValue<=lowValue:
                        raise ValueError("highValue must be > lowValue")
                
                self._lowValue = lowValue
                self._highValue = highValue
                self._lowUtility = lowUtility
                self._highUtility = highUtility

        #Override
        def getUtility(self, value:Optional[Value] ) -> Decimal :
                if not isinstance(value, NumberValue):
                        return Decimal("0");

                x:Decimal  = value.getValue()
                if x<self._lowValue or x>self._highValue:
                        return Decimal("0")
                # we need to be careful to avoid round errors from divides.
                # so we return lowU + deltaU * (x-lowV) /deltaV
                deltaU:Decimal  = self._highUtility- self._lowUtility
                deltaV:Decimal = self._highValue-self._lowValue

                return (self._lowUtility + deltaU *(x-self._lowValue)/deltaV )\
                        .quantize(Decimal('1.00000000'), rounding=ROUND_HALF_UP)
        

        #Override
        def isFitting(self, valueset: ValueSet ) -> Optional[str]:
                if not isinstance(valueset, NumberValueSet):
                        return "The utilities are for a number valueset but the given values are "\
                                        + str(valueset);
                
                numvalset= cast(NumberValueSet, valueset)
                if numvalset.getRange().getLow() != self._lowValue:
                        return "the utilities are specified down to " + str(self._lowValue) \
                                        + " but the valueset starts at " \
                                        + str(numvalset.getRange().getLow())
                
                if numvalset.getRange().getHigh() != self._highValue:
                        return "the utilities are specified up to " + str(self._highValue) \
                                        + " but the valueset ends at " \
                                        + str(numvalset.getRange().getHigh())
                return None

        def getLowValue(self) -> Decimal  :
                '''
                @return the lowest value
                '''
                return self._lowValue;


        def getHighValue(self) ->Decimal :
                '''
                @return the highest value
                '''
                return self._highValue

        def  getLowUtility(self) ->Decimal :
                '''
                @return the utility of the lowest value
                '''
                return self._lowUtility;

        def  getHighUtility(self) ->Decimal:
                '''
                @return the utility of the highest value
                '''
                return self._highUtility

        def __repr__(self):
                return "NumberValueSetUtilities[" + str(self._lowValue) + "->" + str(self._lowUtility) + "," \
                                + str(self._highValue) + "->" + str(self._highUtility) + "]"

        def __hash__(self):
                return hash((self._lowUtility, self._lowValue,self._highUtility, self._highValue))

        def __eq__(self, other):
                return isinstance(other, self.__class__) \
                         and self._highUtility == other._highUtility \
                         and self._highValue == other._highValue \
                         and self._lowUtility == other._lowUtility \
                         and self._lowValue == other._lowValue 

        def _isInZeroOne(self  ,  value:Decimal) -> bool:
                '''
                Check if value is in range [0,1]
                
                @param value
                @return true if in range.
                '''
                return value >= Decimal("0") and value <= Decimal("1")