def PureStrategyDominance(game, conditional=True, weak=False):
	"""
	pure-strategy dominance criterion for IEDS

	conditional==0==False --> unconditional dominance
	conditional==1==True ---> conditional dominance
	conditional==2 ---------> extra-conservative conditional dominance
	"""
	undominated = {r:set(game.strategies[r]) for r in game.roles}
	for r in game.roles:
		for dominant, dominated in product(game.strategies[r], repeat=2):
			if dominant == dominated or dominated not in undominated[r]:
				continue
			dominance_proved = False
			for profile in game:
				if dominated in profile[r]:
					reg = regret(game, profile, r, dominated, dominant)
					if reg > 0 and not isinf(reg):
						dominance_proved = True
					elif (reg < 0) or (reg == 0 and not weak) or \
							(isinf(reg) and conditional):
						dominance_proved = False
						break
				elif dominant in profile[r] and conditional > 1:
					if profile.deviate(r, dominant, dominated) not in game:
						dominance_proved = False
						break
			if dominance_proved:
				undominated[r].remove(dominated)
	return Subgame(game, undominated)

def xsString(xc, p, source):
    if isinstance(source,bool):
        return 'true' if source else 'false'
    elif isinstance(source,float):
        if isnan(source):
            return "NaN"
        elif isinf(source):
            return "INF"
        '''
        numMagnitude = fabs(source)
        if numMagnitude < 1000000 and numMagnitude > .000001:
            # don't want floating notation which python does for more than 4 decimal places
            s = 
        '''
        s = str(source)
        if s.endswith(".0"):
            s = s[:-2]
        return s
    elif isinstance(source,Decimal):
        if isnan(source):
            return "NaN"
        elif isinf(source):
            return "INF"
        return str(source)
    elif isinstance(source,ModelValue.DateTime):
        return ('{0:%Y-%m-%d}' if source.dateOnly else '{0:%Y-%m-%dT%H:%M:%S}').format(source)
    return str(source)

    def test_pow(self):
        import math

        def pw(x, y):
            return x ** y
        def espeq(x, y):
            return not abs(x-y) > 1e05
        raises(ZeroDivisionError, pw, 0.0, -1)
        assert pw(0, 0.5) == 0.0
        assert espeq(pw(4.0, 0.5), 2.0)
        assert pw(4.0, 0) == 1.0
        assert pw(-4.0, 0) == 1.0
        assert type(pw(-1.0, 0.5)) == complex
        assert pw(-1.0, 2.0) == 1.0
        assert pw(-1.0, 3.0) == -1.0
        assert pw(-1.0, 1e200) == 1.0
        if self.py26:
            assert pw(0.0, float("-inf")) == float("inf")
            assert math.isnan(pw(-3, float("nan")))
            assert math.isnan(pw(-3., float("nan")))
            assert pw(-1.0, -float('inf')) == 1.0
            assert pw(-1.0, float('inf')) == 1.0
            assert pw(float('inf'), 0) == 1.0
            assert pw(float('nan'), 0) == 1.0

            assert math.isinf(pw(-0.5, float('-inf')))
            assert math.isinf(pw(+0.5, float('-inf')))
            assert pw(-1.5, float('-inf')) == 0.0
            assert pw(+1.5, float('-inf')) == 0.0

            assert str(pw(float('-inf'), -0.5)) == '0.0'
            assert str(pw(float('-inf'), -2.0)) == '0.0'
            assert str(pw(float('-inf'), -1.0)) == '-0.0'
            assert str(pw(float('-inf'), 1.0)) == '-inf'
            assert str(pw(float('-inf'), 2.0)) == 'inf'

    def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
        """
        Determine whether two floating point numbers are close in value.

        rel_tol
           maximum difference for being considered "close", relative to the
           magnitude of the input values
        abs_tol
           maximum difference for being considered "close", regardless of the
           magnitude of the input values

        Return True if a is close in value to b, and False otherwise.

        For the values to be considered close, the difference between them
        must be smaller than at least one of the tolerances.

        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That
        is, NaN is not close to anything, even itself.  inf and -inf are
        only close to themselves.
        """

        if rel_tol < 0.0 or abs_tol < 0.0:
            raise ValueError('error tolerances must be non-negative')

        if a == b:  # short-circuit exact equality
            return True
        if math.isinf(a) or math.isinf(b):
            # This includes the case of two infinities of opposite sign, or
            # one infinity and one finite number. Two infinities of opposite sign
            # would otherwise have an infinite relative tolerance.
            return False
        diff = abs(b - a)
        return (((diff <= abs(rel_tol * b)) and
                 (diff <= abs(rel_tol * a))) or
                (diff <= abs_tol))

def combine_rshift(range1, range2):
    """
    Combiner for Right shift operation.

    >>> import ast
    >>> combine(Range(10, 100), Range(3, 8), ast.RShift())
    Range(low=0, high=12)
    >>> combine(Range(10, float("inf")), Range(3, 8),
    ...                       ast.RShift())
    Range(low=0, high=inf)
    >>> combine(Range(-float("inf"), 0), Range(3, 8),
    ...                       ast.RShift())
    Range(low=-inf, high=0)
    >>> combine(Range(-30, 10), Range(3, float('inf')),
    ...                       ast.RShift())
    Range(low=-4, high=1)
    """
    if range1.low <= 0:
        if isinf(range1.low):
            min_ = range1.low
        else:
            min_ = range1.low >> range2.low
    elif isinf(range2.high):
        min_ = 0
    else:
        min_ = range1.low >> range2.high
    if isinf(range1.high):
        max_ = range1.high
    elif isinf(range2.low):
        max_ = 0
    else:
        max_ = range1.high >> range2.low
    return Range(min_, max_)

    def retreive_WMS_metadata(typename):
        workspace, layername = decodeTypeName(typename)

        # workspace is hard-coded in the importer
        url = settings.OGC_SERVER['default']['LOCATION'] + workspace+"/"
        url += layername + "/wms?request=GetCapabilities&version=1.1.1"

        get_cap_data = CreateStoryLayerThumbnailTask.request_geoserver_with_credentials(
            url)
        wms = WebMapService(url, xml=get_cap_data)

        # I found that some dataset advertise illegal bounds - fix them up
        xmin = wms[layername].boundingBoxWGS84[0]
        if math.isnan(xmin) or math.isinf(xmin) or xmin < -180:
            xmin = -180

        ymin = wms[layername].boundingBoxWGS84[1]
        if math.isnan(ymin) or math.isinf(ymin) or ymin < -90:
            ymin = -90

        xmax = wms[layername].boundingBoxWGS84[2]
        if math.isnan(xmax) or math.isinf(xmax) or xmax > 180:
            xmax = 180

        ymax = wms[layername].boundingBoxWGS84[3]
        if math.isnan(ymax) or math.isinf(ymax) or ymax > 90:
            ymax = 90

        return [xmin, ymin, xmax, ymax], wms[layername].timepositions

    def toVector(longitude, latitude):
        """Converts a set of spherical coordinates to a 3-vector.

        The conversion shall not be performed by any library, to ensure
        that the test case does not duplicate the code being tested.

        Parameters
        ----------
        longitude : `Angle`
            The longitude (right ascension, azimuth, etc.) of the
            position.
        latitude : `Angle`
            The latitude (declination, elevation, etc.) of the
            position.

        Returns
        -------
        x, y, z : `number`
            Components of the unit vector representation of
            `(longitude, latitude)`
        """
        alpha = longitude.asRadians()
        delta = latitude.asRadians()
        if math.isnan(alpha) or math.isinf(alpha) or math.isnan(delta) or math.isinf(delta):
            return (nan, nan, nan)

        x = math.cos(alpha)*math.cos(delta)
        y = math.sin(alpha)*math.cos(delta)
        z = math.sin(delta)
        return (x, y, z)

def parallel_line2d(m, b, d):
    b_ = None
    if math.isinf(m) or math.isinf(-m):
        b_ = d
    else:
        b_ = b + d * math.sqrt(m * m + 1)
    return m, b_

    def add_point(self, label, pos, setpos, dmin, dmax):
        point = dict()
        point['pos'] = int(pos)
        label = label.upper()
        # Calculate point calibration if required
        if self.has_calibration():
            # Set to current physical position if no value supplied as argument
            if math.isinf(setpos):
                point['set'] = self.motor.position
            else:
                point['set'] = float(setpos)
            # If point exists, we use current min, max values
            if label in self.keys() and math.isinf(dmin) and math.isinf(dmax):
                p = self[label]
                min_pos = point['set'] + p['set'] - p['min']
                max_pos = point['set'] + p['set'] - p['max']
            # else, new point has new calibration,
            elif math.isinf(dmin) and math.isinf(dmax):
                min_pos = point['set']
                max_pos = point['set']
            else:
                min_pos = point['set'] + dmin
                max_pos = point['set'] + dmax

            point['min'] = min_pos
            point['max'] = max_pos

        self[label] = point
        self._update()

	def getBoundingBox2D(self):
		"""
		 Returns the bounding box of all active process elements in their 2D coordinate system.

		@return  :
		@author
		"""
		#Helper variables
		maxX = float("-inf")
		maxY = float("-inf")
		minX = float("inf")
		minY = float("inf")
		#Now iterate over all active process components
		for active in (self.activeProcessComponents + self.messageExchanges):
			if(hasattr(active, "hasAbstractVisualRepresentation")):
				point = active.hasAbstractVisualRepresentation.getPoint2D()
				#Max tests
				if(maxX < point[0]):
					maxX = point[0]
				if(maxY < point[1]):
					maxY = point[1]
				#Min tests
				if(minX > point[0]):
					minX = point[0]
				if(minY > point[1]):
					minY = point[1]
		#inf tests
		if(math.isinf(maxX)):
			maxX = 0
			minX = 0
		if(math.isinf(maxY)):
			maxY = 0
			minY = 0
		return [[minX, minY], [maxX, maxY]]

def lgamma(x):
    """Compute the natural logarithm of the gamma function for x."""
    if isnan(x):
        return x
    if isinf(x):
        return INFINITY
    if x == math.floor(x) and x <= 2.0:
        if x <= 0.0:
            raise ValueError("math range error")
        return 0.0
    absx = abs(x)
    if absx < 1e-20:
        return -math.log(absx)
    if x > 0.0:
        r = math.log(_lanczos_sum(x)) - _lanczos_g + (x - 0.5) * (math.log(x + _lanczos_g - 0.5) - 1)
    else:
        r = (
            math.log(math.pi)
            - math.log(abs(_sinpi(absx)))
            - math.log(absx)
            - (math.log(_lanczos_sum(absx)) - _lanczos_g + (absx - 0.5) * (math.log(absx + _lanczos_g - 0.5) - 1))
        )
    if isinf(r):
        raise OverflowError("math domain error")
    return r

    def normalize(self):
        "It recovers the values got bad during the GML write-read cycle."
        if "normalized" in dir(self) and self.normalized:
            return
        if "type" in self.vs.attributes():
            virtual = self.vs.select(type=1)
            for vertex in virtual:
                for attr in ("priority", "filesize",
                             "section", "summary", "version"):
                    vertex[attr] = None
                if "architecture" in self.vs.attributes():
                    vertex["architecture"] = None
        if "revision" in self.attributes():
            revision = self["revision"]
            if isinstance(revision, float) and not math.isnan(revision):
                self["revision"] = int(revision)

        del self.vs["id"]
        integer_attributes = (
            ("type", self.vs),
            ("filesize", self.vs),
            ("type", self.es),
        )
        for attr, object_ in integer_attributes:
            if attr in object_.attributes():
                for item in object_:
                    value = item[attr]
                    if isinstance(value, float) and\
                            not math.isinf(value) and not math.isnan(value):
                        item[attr] = int(value)
                    elif value is not None and (math.isinf(value) or math.isnan(value)):
                        print("The value of the {0} attribute is {1} ({2})."
                              .format(attr, value, item["name"]))
        self.normalized = True

 def dataToScreen(self, values):
     results = []
     if not isinstance(values,list):
         values = [values]
     for value in values:
         try:
             value = float(value)
             if math.isinf(value):
                 value = 'Missing'
             elif math.isinf(value):
                 value = 'Allele Masked'
         except (ValueError,TypeError):
             if value == variant.MISSING or value == None:
                 value = 'Missing'
             elif value == variant.ALLELE_MASKED:
                 value = 'Allele Masked'
         
         if isinstance(value,str):
             index = self.cats.get(value,len(self.cats)-1)
             if index < 0:
                 results.append(self.labelTop)
             elif index > self.latticeLength:
                 results.append(self.labelBottom)
             else:
                 results.append(self.labelTop + (index+0.5)*self.cellSize)
         else:
             results.append(self.numericPixelLow + (value-self.numericDataLow)*self.dataToPixelRatio)
     return results

    def SetNuisanceBkgValue(self, nuisname, value, bkg_name, year=None):
        if self.split_bkg_by_year and year is None:
            raise Exception("ERROR: backgrounds are split by year, you must specify which year you're doing!")        
        if year not in self.years:
            raise Exception("ERROR: year {0} not in list of years!".format(year))
        if bkg_name not in self.bkg_names:
            raise Exception("ERROR: bkg {0} not in list of backgrounds!".format(bkg_name))

        fullname = self.GetFullNuisName(nuisname, year)
        fullbkg = bkg_name + (str(year) if year is not None else "")
        fullidx = self.split_bkg_names.index(fullbkg)

        if type(value)==tuple:
            if self.nuisances[fullname].type not in  ["lnN","lnU"]:
                raise Exception("ERROR: only lnN/lnU nuisances support 2-sided values!")
            if value[0]>2.05 or value[1]>2.05 or value[0]<0.3 or value[1]<0.3:
                print "WARNING: nuisance {0} has a large value {1} (year {2}). Card: {3}".format(fullname, value, year, self.name)
            if isnan(value[0]) or isinf(value[0]) or isnan(value[1]) or isinf(value[1]):
                raise Exception("ERROR: nuisance value is nan or inf for nuis {0}, background {1}, year {2}".format(nuisname, bkg_name, year))
        elif type(value)==float:
            if self.nuisances[fullname].type in ["lnN","lnU"] and (value > 2.05 or value < 0.3):
                print "WARNING: nuisance {0} has a large value {1} (year {2}). Card: {3}".format(fullname, value, year, self.name)
            if isnan(value) or isinf(value):
                raise Exception("ERROR: nuisance value is nan or inf for nuis {0}, background {1}, year {2}".format(nuisname, bkg_name, year))
        else:
            raise Exception("ERROR: value must be a float or tuple of 2 float (upper,lower) (lnN/lnU only)")

        self.nuisances[fullname].bkg_values[fullidx] = value

def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
    '''
    Python 2 implementation of Python 3.5 math.isclose()
    https://hg.python.org/cpython/file/tip/Modules/mathmodule.c#l1993
    '''
    # sanity check on the inputs
    if rel_tol < 0 or abs_tol < 0:
        raise ValueError("tolerances must be non-negative")

    # short circuit exact equality -- needed to catch two infinities of
    # the same sign. And perhaps speeds things up a bit sometimes.
    if a == b:
        return True

    # This catches the case of two infinities of opposite sign, or
    # one infinity and one finite number. Two infinities of opposite
    # sign would otherwise have an infinite relative tolerance.
    # Two infinities of the same sign are caught by the equality check
    # above.
    if math.isinf(a) or math.isinf(b):
        return False

    # equality check above would return false for nan, but we want
    # to return true
    if math.isnan(a) and math.isnan(b):
        return True

    # now do the regular computation
    # this is essentially the "weak" test from the Boost library
    diff = math.fabs(b - a)
    result = (((diff <= math.fabs(rel_tol * b)) or
               (diff <= math.fabs(rel_tol * a))) or
              (diff <= abs_tol))
    return result

    def weigh_objects(self, weighed_obj_list, weight_properties):
        """Override the weigh objects.


        This override calls the parent to do the weigh objects and then
        replaces any infinite weights with a value that is a multiple of the
        delta between the min and max values.

        NOTE(jecarey): the infinite weight value is only used when the
        smallest value is being favored (negative multiplier).  When the
        largest weight value is being used a weight of -1 is used instead.
        See _weigh_object method.
        """
        tmp_weights = super(CapacityWeigher, self).weigh_objects(
            weighed_obj_list, weight_properties)

        if math.isinf(self.maxval):
            # NOTE(jecarey): if all weights were infinite then parent
            # method returns 0 for all of the weights.  Thus self.minval
            # cannot be infinite at this point
            copy_weights = [w for w in tmp_weights if not math.isinf(w)]
            self.maxval = max(copy_weights)
            offset = (self.maxval - self.minval) * OFFSET_MULT
            self.maxval += OFFSET_MIN if offset == 0.0 else offset
            tmp_weights = [self.maxval if math.isinf(w) else w
                           for w in tmp_weights]

        return tmp_weights

def test_floats_in_tiny_interval_within_bounds(data, center):
    assume(not (math.isinf(next_down(center)) or math.isinf(next_up(center))))
    lo = Decimal.from_float(next_down(center)).next_plus()
    hi = Decimal.from_float(next_up(center)).next_minus()
    assert float(lo) < lo < center < hi < float(hi)
    val = data.draw(st.floats(lo, hi))
    assert lo < val < hi

def sqrt(x):
    sqrt_special = [
        [inf-infj, 0-infj, 0-infj, infj, infj, inf+infj, nan+infj],
        [inf-infj, None, None, None, None, inf+infj, nan+nanj],
        [inf-infj, None, 0-0j, 0+0j, None, inf+infj, nan+nanj],
        [inf-infj, None, 0-0j, 0+0j, None, inf+infj, nan+nanj],
        [inf-infj, None, None, None, None, inf+infj, nan+nanj],
        [inf-infj, complex(float("inf"), -0.0), complex(float("inf"), -0.0), inf, inf, inf+infj, inf+nanj],
        [inf-infj, nan+nanj, nan+nanj, nan+nanj, nan+nanj, inf+infj, nan+nanj]
    ]

    z = _make_complex(x)

    if math.isinf(z.real) or math.isinf(z.imag):
        return sqrt_special[_special_type(z.real)][_special_type(z.imag)]

    abs_x, abs_y = abs(z.real), abs(z.imag)
    if abs_x < _DBL_MIN and abs_y < _DBL_MIN:
        if abs_x > 0 or abs_y > 0:
            abs_x = math.ldexp(abs_x, _CM_SCALE_UP)
            s = math.ldexp(math.sqrt(abs_x +
                                     math.hypot(abs_x,
                                                math.ldexp(abs_y,
                                                           _CM_SCALE_UP))),
                           _CM_SCALE_DOWN)
        else:
            return complex(0, z.imag)
    else:
        abs_x /= 8
        s = 2 * math.sqrt(abs_x + math.hypot(abs_x, abs_y/8))

    if z.real >= 0:
        return complex(s, math.copysign(abs_y/(2*s), z.imag))
    return complex(abs_y/(2*s), math.copysign(s, z.imag))

    def __rshift__(range1, range2):
        """
        Combiner for Right shift operation.

        >>> Interval(10, 100) >> Interval(3, 8)
        Interval(low=0, high=12)
        >>> Interval(10, float("inf")) >> Interval(3, 8)
        Interval(low=0, high=inf)
        >>> Interval(-float("inf"), 0) >> Interval(3, 8)
        Interval(low=-inf, high=0)
        >>> Interval(-30, 10) >> Interval(3, float('inf'))
        Interval(low=-4, high=1)
        """
        if range1.low <= 0:
            if isinf(range1.low):
                min_ = range1.low
            else:
                min_ = range1.low >> range2.low
        elif isinf(range2.high):
            min_ = 0
        else:
            min_ = range1.low >> range2.high
        if isinf(range1.high):
            max_ = range1.high
        elif isinf(range2.low):
            max_ = 0
        else:
            max_ = range1.high >> range2.low
        return Interval(min_, max_)

def cosh(x):
    _cosh_special = [
        [inf+nanj, None, inf, complex(float("inf"), -0.0), None, inf+nanj, inf+nanj],
        [nan+nanj, None, None, None, None, nan+nanj, nan+nanj],
        [nan, None, 1, complex(1, -0.0), None, nan, nan],
        [nan, None, complex(1, -0.0), 1, None, nan, nan],
        [nan+nanj, None, None, None, None, nan+nanj, nan+nanj],
        [inf+nanj, None, complex(float("inf"), -0.0), inf, None, inf+nanj, inf+nanj],
        [nan+nanj, nan+nanj, nan, nan, nan+nanj, nan+nanj, nan+nanj]
    ]

    z = _make_complex(x)

    if not isfinite(z):
        if math.isinf(z.imag) and not math.isnan(z.real):
            raise ValueError
        if math.isinf(z.real) and math.isfinite(z.imag) and z.imag != 0:
            if z.real > 0:
                return complex(math.copysign(inf, math.cos(z.imag)),
                               math.copysign(inf, math.sin(z.imag)))
            return complex(math.copysign(inf, math.cos(z.imag)),
                           -math.copysign(inf, math.sin(z.imag)))
        return _cosh_special[_special_type(z.real)][_special_type(z.imag)]

    if abs(z.real) > _LOG_LARGE_DOUBLE:
        x_minus_one = z.real - math.copysign(1, z.real)
        ret = complex(e * math.cos(z.imag) * math.cosh(x_minus_one),
                      e * math.sin(z.imag) * math.sinh(x_minus_one))
    else:
        ret = complex(math.cos(z.imag) * math.cosh(z.real),
                      math.sin(z.imag) * math.sinh(z.real))
    if math.isinf(ret.real) or math.isinf(ret.imag):
        raise OverflowError

    return ret