Calculate the inverse of the range.

        Returns:
            New VersionRange object representing the inverse of this range, or
            None if there is no inverse (ie, this range is the any range).
7688
def inverse(self):
        
        if self.is_any():
            return None
        else:
            bounds = self._inverse(self.bounds)
            range = VersionRange(None)
            range.bounds = bounds
            return range
857843
def range(self, axis=None):
        
        return (self.min(axis=axis), self.max(axis=axis))
729450
def calculateRange(self, values):
        
        self.reset()
        self._values = list(set(values))
        self._values.sort(key=lambda x: values.index(x))
434333
def calculateRange(self):
        
        if not self.autoRangeCti or not self.autoRangeCti.configValue:
            return (self.rangeMinCti.data, self.rangeMaxCti.data)
        else:
            rangeFunction = self._rangeFunctions[self.autoRangeMethod]
            return rangeFunction()
1094797
def range(self, count):
        
        if count <= 1:
            raise ValueError("Range size must be greater than 1.")
        dom = self._domain
        distance = dom[-1] - dom[0]
        props = [ self(dom[0] + distance * float(x)/(count-1))
            for x in range(count) ]
        return props
487677
public IVersion getVersion(String vstring) throws InvalidRangeException
  {
    IVersionRange range = getRange(vstring);
    if (range == null) {
      return null;
    }
    return range.getMinimum();
  }
724199
def get_lipd_version(L):
    
    version = 1.0
    _keys = ["LipdVersion", "LiPDVersion", "lipdVersion", "liPDVersion"]
    for _key in _keys:
        if _key in L:
            version = L[_key]
            # Cast the version number to a float
            try:
                version = float(version)
            except AttributeError:
                # If the casting failed, then something is wrong with the key so assume version is 1.0
                version = 1.0
            L.pop(_key)
    return L, version
638679
def range(self):
        
        data = clips.data.DataObject(self._env)

        lib.EnvSlotRange(self._env, self._cls, self._name, data.byref)

        return tuple(data.value) if isinstance(data.value, list) else ()
678982
def inverse(self):
        
        return OperatorComp(self.right.inverse, self.left.inverse,
                            self.__tmp)
217183
def selection_range(self):  # XXX: shouldn't this return `None` if there is no selection???
        
        if self.selection:
            from_, to = sorted([self.cursor_position, self.selection.original_cursor_position])
        else:
            from_, to = self.cursor_position, self.cursor_position

        return from_, to
1083243
def inverse(self):
        
        data = np.zeros(self.shape).astype(np.uint8)
        ind = np.where(self.data == 0)
        data[ind[0], ind[1], ...] = BINARY_IM_MAX_VAL
        return BinaryImage(data, self._frame)
230404
def range( initial = nil )
      min( initial ? initial.min : nil ) .. max( initial ? initial.max : nil )
    end
227173
def get_transform(self):
        
        return _InterpolatedInverseTransform(transform=self._transform,
                                             smin=0,
                                             smax=self._transform._M)
1030709
def _ranging(self):
        
        agg_ranges = []
        for i, val in enumerate(self.range_list):
            if i == 0:
                agg_ranges.append({"to": val})
            else:
                previous = self.range_list[i - 1]
                agg_ranges.append({"from": previous, "to": val})

            if i + 1 == len(self.range_list):
                agg_ranges.append({"from": val})
        return agg_ranges
972210
def pseudoinverse(self):
        
        transform = False
        if self.get_width() > self.get_height():
            transform = True
            u, sigma, v = self.transform().svd()
        else:
            u, sigma, v = self.svd()
        # calculate inverse of sigma
        for i in xrange(min(sigma.get_height(), sigma.get_width())):
            val = sigma.get_value(i, i)
            # divide only if the value is not 0 or close to zero (rounding errors)
            eps = 1.e-15
            if eps < val or val < -eps:
                sigma.set_value(i, i, 1 / val)
        if transform:
            return (v * sigma * u.transform()).transform()
        else:
            return v * sigma * u.transform()
1111719
def _inverse_i(self, y, i):
        """"""
        lb = self._lb[self._index(i)]
        ub = self._ub[self._index(i)]
        al = self._al[self._index(i)]
        au = self._au[self._index(i)]
        if 1 < 3:
            if not lb <= y <= ub:
                raise ValueError('argument of inverse must be within the given bounds')
        if y < lb + al:
            return (lb - al) + 2 * (al * (y - lb))**0.5
        elif y < ub - au:
            return y
        else:
            return (ub + au) - 2 * (au * (ub - y))**0.5
69902
def select_version(self, version_range):
        
        row = -1
        version = None
        for i, package in self.packages.iteritems():
            if package.version in version_range \
                    and (version is None or version < package.version):
                version = package.version
                row = i

        self.clearSelection()
        if row != -1:
            self.selectRow(row)
        return version