Ejemplo n.º 1
0
 def view_limits(self, dmin, dmax):
     if self._symmetric:
         maxabs = max(abs(dmin), abs(dmax))
         dmin = -maxabs
         dmax = maxabs
     dmin, dmax = mtransforms.nonsingular(dmin, dmax, expander = 0.05)
     return np.take(self.bin_boundaries(dmin, dmax), [0,-1])
Ejemplo n.º 2
0
    def autoscale(self):
        'Try to choose the view limits intelligently'
        b = self._transform.base
        vmin, vmax = self.axis.get_data_interval()
        if vmax < vmin:
            vmin, vmax = vmax, vmin

        if not is_decade(abs(vmin), b):
            if vmin < 0:
                vmin = -decade_up(-vmin, b)
            else:
                vmin = decade_down(vmin, b)
        if not is_decade(abs(vmax), b):
            if vmax < 0:
                vmax = -decade_down(-vmax, b)
            else:
                vmax = decade_up(vmax, b)

        if vmin == vmax:
            if vmin < 0:
                vmin = -decade_up(-vmin, b)
                vmax = -decade_down(-vmax, b)
            else:
                vmin = decade_down(vmin, b)
                vmax = decade_up(vmax, b)
        result = mtransforms.nonsingular(vmin, vmax)
        return result
Ejemplo n.º 3
0
    def view_limits(self, vmin, vmax):
        """
        Try to choose the view limits intelligently. In contrast to the stock
        LogLocator, this version always pads by one decade so that the contents
        of the largest and smallest histogram bins can be seen even if they
        fall on a decade.
        """
        b = self._base

        if vmax < vmin:
            vmin, vmax = vmax, vmin

        if self.axis.axes.name == 'polar':
            vmax = math.ceil(math.log(vmax) / math.log(b))
            vmin = b**(vmax - self.numdecs)
            return vmin, vmax

        minpos = self.axis.get_minpos()

        if minpos <= 0 or not np.isfinite(minpos):
            raise ValueError(
                "Data has no positive values, and therefore can not be "
                "log-scaled.")

        if vmin <= minpos:
            vmin = minpos

        vmin = mticker.decade_down(vmin * (1 - 1e-10), self._base)
        vmax = mticker.decade_up(vmax * (1 + 1e-10), self._base)

        if vmin == vmax:
            vmin = mticker.decade_down(vmin, self._base)
            vmax = mticker.decade_up(vmax, self._base)
        result = mtransforms.nonsingular(vmin, vmax)
        return result
Ejemplo n.º 4
0
    def autoscale(self):
        "Try to choose the view limits intelligently"
        b = self._transform.base
        vmin, vmax = self.axis.get_data_interval()
        if vmax < vmin:
            vmin, vmax = vmax, vmin

        if not is_decade(abs(vmin), b):
            if vmin < 0:
                vmin = -decade_up(-vmin, b)
            else:
                vmin = decade_down(vmin, b)
        if not is_decade(abs(vmax), b):
            if vmax < 0:
                vmax = -decade_down(-vmax, b)
            else:
                vmax = decade_up(vmax, b)

        if vmin == vmax:
            if vmin < 0:
                vmin = -decade_up(-vmin, b)
                vmax = -decade_down(-vmax, b)
            else:
                vmin = decade_down(vmin, b)
                vmax = decade_up(vmax, b)
        result = mtransforms.nonsingular(vmin, vmax)
        return result
Ejemplo n.º 5
0
    def view_limits(self, vmin, vmax):
        'Try to choose the view limits intelligently'
        b = self._transform.base
        if vmax<vmin:
            vmin, vmax = vmax, vmin

        if not is_decade(abs(vmin), b):
            if vmin < 0:
                vmin = -decade_up(-vmin, b)
            else:
                vmin = decade_down(vmin, b)
        if not is_decade(abs(vmax), b):
            if vmax < 0:
                vmax = -decade_down(-vmax, b)
            else:
                vmax = decade_up(vmax, b)

        if vmin == vmax:
            if vmin < 0:
                vmin = -decade_up(-vmin, b)
                vmax = -decade_down(-vmax, b)
            else:
                vmin = decade_down(vmin, b)
                vmax = decade_up(vmax, b)
        result = mtransforms.nonsingular(vmin, vmax)
        return result
Ejemplo n.º 6
0
 def zoom(self, direction):
     "Zoom in/out on axis; if direction is >0 zoom in, else zoom out"
     vmin, vmax = self.axis.get_view_interval()
     vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander = 0.05)
     interval = abs(vmax-vmin)
     step = 0.1*interval*direction
     self.axis.set_view_interval(vmin + step, vmax - step, ignore=True)
Ejemplo n.º 7
0
 def view_limits(self, dmin, dmax):
     if self._symmetric:
         maxabs = max(abs(dmin), abs(dmax))
         dmin = -maxabs
         dmax = maxabs
     dmin, dmax = mtransforms.nonsingular(dmin, dmax, expander=0.05)
     return np.take(self.bin_boundaries(dmin, dmax), [0, -1])
Ejemplo n.º 8
0
    def view_limits(self, vmin, vmax):
        'Try to choose the view limits intelligently'
        b = self._transform.base
        if vmax < vmin:
            vmin, vmax = vmax, vmin

        if not is_decade(abs(vmin), b):
            if vmin < 0:
                vmin = -decade_up(-vmin, b)
            else:
                vmin = decade_down(vmin, b)
        if not is_decade(abs(vmax), b):
            if vmax < 0:
                vmax = -decade_down(-vmax, b)
            else:
                vmax = decade_up(vmax, b)

        if vmin == vmax:
            if vmin < 0:
                vmin = -decade_up(-vmin, b)
                vmax = -decade_down(-vmax, b)
            else:
                vmin = decade_down(vmin, b)
                vmax = decade_up(vmax, b)
        result = mtransforms.nonsingular(vmin, vmax)
        return result
Ejemplo n.º 9
0
def test_nonsingular():
    # test for zero-expansion type cases; other cases may be added later
    zero_expansion = np.array([-0.001, 0.001])
    cases = [(0, np.nan), (0, 0), (0, 7.9e-317)]
    for args in cases:
        out = np.array(mtransforms.nonsingular(*args))
        assert_array_equal(out, zero_expansion)
Ejemplo n.º 10
0
    def autoscale(self):
        'Try to choose the view limits intelligently'
        vmin, vmax = self.axis.get_data_interval()
        if vmax < vmin:
            vmin, vmax = vmax, vmin

        minpos = self.axis.get_minpos()

        if minpos <= 0:
            raise ValueError(
                "Data has no positive values, and therefore can not be log-scaled."
            )

        if vmin <= minpos:
            vmin = minpos

        if not is_decade(vmin, self._base):
            vmin = decade_down(vmin, self._base)
        if not is_decade(vmax, self._base): vmax = decade_up(vmax, self._base)

        if vmin == vmax:
            vmin = decade_down(vmin, self._base)
            vmax = decade_up(vmax, self._base)
        result = mtransforms.nonsingular(vmin, vmax)
        return result
Ejemplo n.º 11
0
    def __call__(self, x, pos=None):
        "Return the format for tick val x at position pos"

        vmin, vmax = self.axis.get_view_interval()
        vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander=0.05)
        d = abs(vmax - vmin)
        b = self._base
        if x == 0:
            return "0"
        sign = np.sign(x)
        # only label the decades
        fx = math.log(abs(x)) / math.log(b)
        isDecade = self.is_decade(fx)
        if not isDecade and self.labelOnlyBase:
            s = ""
        # if 0: pass
        elif fx > 10000:
            s = "%1.0e" % fx
        # elif x<1: s = '$10^{%d}$'%fx
        # elif x<1: s =  '10^%d'%fx
        elif fx < 1:
            s = "%1.0e" % fx
        else:
            s = self.pprint_val(fx, d)
        if sign == -1:
            s = "-%s" % s

        return self.fix_minus(s)
Ejemplo n.º 12
0
    def view_limits(self, vmin, vmax):
        'Try to choose the view limits intelligently'
        b = self._base

        if vmax<vmin:
            vmin, vmax = vmax, vmin

        if self.axis.axes.name == 'polar':
            vmax = math.ceil(math.log(vmax) / math.log(b))
            vmin = b ** (vmax - self.numdecs)
            return vmin, vmax

        minpos = self.axis.get_minpos()

        if minpos<=0 or not np.isfinite(minpos):
            raise ValueError(
                "Data has no positive values, and therefore can not be log-scaled.")

        if vmin <= minpos:
            vmin = minpos

        if not is_decade(vmin,self._base): vmin = decade_down(vmin,self._base)
        if not is_decade(vmax,self._base): vmax = decade_up(vmax,self._base)

        if vmin==vmax:
            vmin = decade_down(vmin,self._base)
            vmax = decade_up(vmax,self._base)
        result = mtransforms.nonsingular(vmin, vmax)
        return result
Ejemplo n.º 13
0
    def __call__(self, x, pos=None):
        'Return the format for tick val x at position pos'


        vmin, vmax = self.axis.get_view_interval()
        vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander = 0.05)
        d = abs(vmax-vmin)
        b=self._base
        if x == 0:
            return '0'
        sign = np.sign(x)
        # only label the decades
        fx = math.log(abs(x))/math.log(b)
        isDecade = self.is_decade(fx)
        if not isDecade and self.labelOnlyBase: s = ''
        #if 0: pass
        elif fx>10000: s= '%1.0e'%fx
        #elif x<1: s = '$10^{%d}$'%fx
        #elif x<1: s =  '10^%d'%fx
        elif fx<1: s =  '%1.0e'%fx
        else        : s =  self.pprint_val(fx,d)
        if sign == -1:
            s =  '-%s' % s

        return self.fix_minus(s)
Ejemplo n.º 14
0
def test_nonsingular():
    # test for zero-expansion type cases; other cases may be added later
    zero_expansion = np.array([-0.001, 0.001])
    cases = [(0, np.nan), (0, 0), (0, 7.9e-317)]
    for args in cases:
        out = np.array(mtrans.nonsingular(*args))
        assert_array_equal(out, zero_expansion)
Ejemplo n.º 15
0
    def view_limits(self, vmin, vmax):
        'Try to choose the view limits intelligently'
        b = self._base

        if vmax < vmin:
            vmin, vmax = vmax, vmin

        if self.axis.axes.name == 'polar':
            vmax = math.ceil(math.log(vmax) / math.log(b))
            vmin = b**(vmax - self.numdecs)
            return vmin, vmax

        minpos = self.axis.get_minpos()

        if minpos <= 0 or not np.isfinite(minpos):
            raise ValueError(
                "Data has no positive values, and therefore can not be log-scaled."
            )

        if vmin <= minpos:
            vmin = minpos

        if not is_decade(vmin, self._base):
            vmin = decade_down(vmin, self._base)
        if not is_decade(vmax, self._base): vmax = decade_up(vmax, self._base)

        if vmin == vmax:
            vmin = decade_down(vmin, self._base)
            vmax = decade_up(vmax, self._base)
        result = mtransforms.nonsingular(vmin, vmax)
        return result
Ejemplo n.º 16
0
    def __call__(self, x, pos=None):
        'Return the format for tick val *x* at position *pos*'


        vmin, vmax = self.axis.get_view_interval()
        vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander = 0.05)
        d = abs(vmax-vmin)
        b=self._base
        if x == 0:
            return '0'
        sign = np.sign(x)
        # only label the decades
        fx = math.log(abs(x))/math.log(b)
        isDecade = is_close_to_int(fx)
        if not isDecade and self.labelOnlyBase: s = ''
        #if 0: pass
        elif fx>10000: s= '%1.0e'%fx
        #elif x<1: s = '$10^{%d}$'%fx
        #elif x<1: s =  '10^%d'%fx
        elif fx<1: s =  '%1.0e'%fx
        else        : s =  self.pprint_val(fx,d)
        if sign == -1:
            s =  '-%s' % s

        return self.fix_minus(s)
Ejemplo n.º 17
0
    def view_limits(self, vmin, vmax):
        """
        select a scale for the range from vmin to vmax

        Normally This will be overridden.
        """
        return mtransforms.nonsingular(vmin, vmax)
Ejemplo n.º 18
0
    def view_limits(self, vmin, vmax):
        """
        select a scale for the range from vmin to vmax

        Normally This will be overridden.
        """
        return mtransforms.nonsingular(vmin, vmax)
Ejemplo n.º 19
0
    def view_limits(self, vmin, vmax):
        """
        Try to choose the view limits intelligently. In contrast to the stock
        LogLocator, this version always pads by one decade so that the contents
        of the largest and smallest histogram bins can be seen even if they
        fall on a decade.
        """
        b = self._base

        if vmax < vmin:
            vmin, vmax = vmax, vmin

        if self.axis.axes.name == 'polar':
            vmax = math.ceil(math.log(vmax) / math.log(b))
            vmin = b ** (vmax - self.numdecs)
            return vmin, vmax

        minpos = self.axis.get_minpos()

        if minpos <= 0 or not np.isfinite(minpos):
            raise ValueError(
                "Data has no positive values, and therefore can not be "
                "log-scaled.")

        if vmin <= minpos:
            vmin = minpos
        
        vmin = mticker.decade_down(vmin*(1-1e-10), self._base)
        vmax = mticker.decade_up(vmax*(1+1e-10), self._base)

        if vmin == vmax:
            vmin = mticker.decade_down(vmin, self._base)
            vmax = mticker.decade_up(vmax, self._base)
        result = mtransforms.nonsingular(vmin, vmax)
        return result
Ejemplo n.º 20
0
    def __init__(self, x, y, ids, nx, malicious_ids):

        self.malicious_ids = malicious_ids

        self.x = np.array(x, float)
        self.y = np.array(y, float)
        self.ids = ids

        self.xmin = np.amin(x)
        self.xmax = np.amax(x)
        self.ymin = np.amin(y)
        self.ymax = np.amax(y)

        # to avoid issues with singular data, expand the min/max pairs
        self.xmin, self.xmax = mtrans.nonsingular(
                self.xmin,
                self.xmax,
                expander=0.1)
        self.ymin, self.ymax = mtrans.nonsingular(
                self.ymin,
                self.ymax,
                expander=0.1)

        # In the x-direction, the hexagons exactly cover the region from
        # xmin to xmax. Need some padding to avoid roundoff errors.
        padding = 1.e-9 * (self.xmax - self.xmin)
        self.xmin -= padding
        self.xmax += padding

        ## Deal with very small values
        if self.xmax - self.xmin < epsilon:
            self.xmin -= epsilon / 2
            self.xmax += epsilon / 2
        if self.ymax - self.ymin < epsilon:
            self.ymin -= epsilon / 2
            self.ymax += epsilon / 2

        self.nx = nx
        self.size = (self.xmax - self.xmin) / self.nx
        self.nx = int(math.ceil((self.xmax - self.xmin) /
            (math.sqrt(3) * self.size))) + 1
        self.ny = int(math.ceil((self.ymax - self.ymin) /
            self.size)) + 1

        self.x_scale = (self.x - self.xmin) / (self.size * math.sqrt(3))
        self.y_scale = (self.y - self.ymin) / self.size
Ejemplo n.º 21
0
    def zoom(self, direction):
        "Zoom in/out on axis; if direction is >0 zoom in, else zoom out"

        vmin, vmax = self.axis.get_view_interval()
        vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander = 0.05)
        interval = abs(vmax-vmin)
        step = 0.1*interval*direction
        self.axis.set_view_interval(vmin + step, vmax - step, ignore=True)
Ejemplo n.º 22
0
 def autoscale(self):
     dmin, dmax = self.axis.get_data_interval()
     if self._symmetric:
         maxabs = max(abs(dmin), abs(dmax))
         dmin = -maxabs
         dmax = maxabs
     dmin, dmax = mtransforms.nonsingular(dmin, dmax, expander=0.05)
     return np.take(self.bin_boundaries(dmin, dmax), [0, -1])
Ejemplo n.º 23
0
 def autoscale(self):
     dmin, dmax = self.axis.get_data_interval()
     if self._symmetric:
         maxabs = max(abs(dmin), abs(dmax))
         dmin = -maxabs
         dmax = maxabs
     dmin, dmax = mtransforms.nonsingular(dmin, dmax, expander=0.05)
     return np.take(self.bin_boundaries(dmin, dmax), [0, -1])
Ejemplo n.º 24
0
    def tick_values(self, vmin, vmax):
        vmin, vmax = mtransforms.nonsingular(vmin,
                                             vmax,
                                             expander=1e-7,
                                             tiny=1e-13)

        self.ndays = float(abs(vmax - vmin))

        utime = netcdftime.utime(self.date_unit, self.calendar)
        lower = utime.num2date(vmin)
        upper = utime.num2date(vmax)

        resolution, n = self.compute_resolution(vmin, vmax, lower, upper)

        if resolution == 'YEARLY':
            # TODO START AT THE BEGINNING OF A DECADE/CENTURY/MILLENIUM as
            # appropriate.
            years = self._max_n_locator.tick_values(lower.year, upper.year)
            ticks = [netcdftime.datetime(int(year), 1, 1) for year in years]
        elif resolution == 'MONTHLY':
            # TODO START AT THE BEGINNING OF A DECADE/CENTURY/MILLENIUM as
            # appropriate.
            months_offset = self._max_n_locator.tick_values(0, n)
            ticks = []
            for offset in months_offset:
                year = lower.year + np.floor((lower.month + offset) / 12)
                month = ((lower.month + offset) % 12) + 1
                ticks.append(netcdftime.datetime(int(year), int(month), 1))
        elif resolution == 'DAILY':
            # TODO: It would be great if this favoured multiples of 7.
            days = self._max_n_locator_days.tick_values(vmin, vmax)
            ticks = [utime.num2date(dt) for dt in days]
        elif resolution == 'HOURLY':
            hour_unit = 'hours since 2000-01-01'
            hour_utime = netcdftime.utime(hour_unit, self.calendar)
            in_hours = hour_utime.date2num([lower, upper])
            hours = self._max_n_locator.tick_values(in_hours[0], in_hours[1])
            ticks = [hour_utime.num2date(dt) for dt in hours]
        elif resolution == 'MINUTELY':
            minute_unit = 'minutes since 2000-01-01'
            minute_utime = netcdftime.utime(minute_unit, self.calendar)
            in_minutes = minute_utime.date2num([lower, upper])
            minutes = self._max_n_locator.tick_values(in_minutes[0],
                                                      in_minutes[1])
            ticks = [minute_utime.num2date(dt) for dt in minutes]
        elif resolution == 'SECONDLY':
            second_unit = 'seconds since 2000-01-01'
            second_utime = netcdftime.utime(second_unit, self.calendar)
            in_seconds = second_utime.date2num([lower, upper])
            seconds = self._max_n_locator.tick_values(in_seconds[0],
                                                      in_seconds[1])
            ticks = [second_utime.num2date(dt) for dt in seconds]
        else:
            msg = 'Resolution {} not implemented yet.'.format(resolution)
            raise ValueError(msg)

        return utime.date2num(ticks)
Ejemplo n.º 25
0
 def get_view_interval(self):
     vmin, vmax = self.axis.get_view_interval()
     if self.epoch:
         vmin -= float(self.epoch.gps)
         vmax -= float(self.epoch.gps)
     if self._scale:
         vmin /= self._scale
         vmax /= self._scale
     return mtransforms.nonsingular(vmin, vmax, expander = 0.05)
Ejemplo n.º 26
0
    def __call__(self):
        vmin, vmax = self.axis.get_view_interval()
        vmin, vmax = nonsingular(vmin, vmax, expander = 0.05)
        vmin = vmin ** self.exponent
        vmax = vmax ** self.exponent
        if vmax<vmin:
            vmin, vmax = vmax, vmin

        ticklocs = np.linspace(vmin, vmax, num=self.numticks, endpoint=True)
        return self.raise_if_exceeds(ticklocs ** (1.0 / self.exponent))
Ejemplo n.º 27
0
    def __call__(self):
        vmin, vmax = self.axis.get_view_interval()
        vmin, vmax = nonsingular(vmin, vmax, expander=0.05)
        vmin = vmin**self.exponent
        vmax = vmax**self.exponent
        if vmax < vmin:
            vmin, vmax = vmax, vmin

        ticklocs = np.linspace(vmin, vmax, num=self.numticks, endpoint=True)
        return self.raise_if_exceeds(ticklocs**(1.0 / self.exponent))
Ejemplo n.º 28
0
    def tick_values(self, vmin, vmax):
        vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander=1e-7,
                                             tiny=1e-13)

        self.ndays = float(abs(vmax - vmin))

        utime = cftime.utime(self.date_unit, self.calendar)
        lower = utime.num2date(vmin)
        upper = utime.num2date(vmax)

        resolution, n = self.compute_resolution(vmin, vmax, lower, upper)

        if resolution == 'YEARLY':
            # TODO START AT THE BEGINNING OF A DECADE/CENTURY/MILLENIUM as
            # appropriate.
            years = self._max_n_locator.tick_values(lower.year, upper.year)
            ticks = [cftime.datetime(int(year), 1, 1) for year in years]
        elif resolution == 'MONTHLY':
            # TODO START AT THE BEGINNING OF A DECADE/CENTURY/MILLENIUM as
            # appropriate.
            months_offset = self._max_n_locator.tick_values(0, n)
            ticks = []
            for offset in months_offset:
                year = lower.year + np.floor((lower.month + offset) / 12)
                month = ((lower.month + offset) % 12) + 1
                ticks.append(cftime.datetime(int(year), int(month), 1))
        elif resolution == 'DAILY':
            # TODO: It would be great if this favoured multiples of 7.
            days = self._max_n_locator_days.tick_values(vmin, vmax)
            ticks = [utime.num2date(dt) for dt in days]
        elif resolution == 'HOURLY':
            hour_unit = 'hours since 2000-01-01'
            hour_utime = cftime.utime(hour_unit, self.calendar)
            in_hours = hour_utime.date2num([lower, upper])
            hours = self._max_n_locator.tick_values(in_hours[0], in_hours[1])
            ticks = [hour_utime.num2date(dt) for dt in hours]
        elif resolution == 'MINUTELY':
            minute_unit = 'minutes since 2000-01-01'
            minute_utime = cftime.utime(minute_unit, self.calendar)
            in_minutes = minute_utime.date2num([lower, upper])
            minutes = self._max_n_locator.tick_values(in_minutes[0],
                                                      in_minutes[1])
            ticks = [minute_utime.num2date(dt) for dt in minutes]
        elif resolution == 'SECONDLY':
            second_unit = 'seconds since 2000-01-01'
            second_utime = cftime.utime(second_unit, self.calendar)
            in_seconds = second_utime.date2num([lower, upper])
            seconds = self._max_n_locator.tick_values(in_seconds[0],
                                                      in_seconds[1])
            ticks = [second_utime.num2date(dt) for dt in seconds]
        else:
            msg = 'Resolution {} not implemented yet.'.format(resolution)
            raise ValueError(msg)

        return utime.date2num(ticks)
Ejemplo n.º 29
0
 def view_limits(self, dmin, dmax):
     """
     Set the view limits to the nearest multiples of base that
     contain the data
     """
     vmin = self._base.le(dmin)
     vmax = self._base.ge(dmax)
     if vmin==vmax:
         vmin -=1
         vmax +=1
     return mtransforms.nonsingular(vmin, vmax)
Ejemplo n.º 30
0
 def __call__(self):
     vmin, vmax = self.axis.get_view_interval()
     vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander=0.05)
     locs = self.bin_boundaries(vmin, vmax)
     prune = self._prune
     if prune == "lower":
         locs = locs[1:]
     elif prune == "upper":
         locs = locs[:-1]
     elif prune == "both":
         locs = locs[1:-1]
     return locs
Ejemplo n.º 31
0
    def view_limits(self, dmin, dmax):
        """
        Set the view limits to the nearest multiples of base that
        contain the data
        """
        vmin = self._base.le(dmin)
        vmax = self._base.ge(dmax)
        if vmin == vmax:
            vmin -= 1
            vmax += 1

        return mtransforms.nonsingular(vmin, vmax)
Ejemplo n.º 32
0
    def view_limits(self, dmin, dmax):
        """
        Set the view limits to the nearest multiples of base that
        contain the data
        """
        vmin = self._base.le(math.copysign(math.sqrt(abs(dmin)), dmin))
        vmax = self._base.ge(math.sqrt(dmax))
        if vmin == vmax:
            vmin -= 1
            vmax += 1

        return mtransforms.nonsingular(math.copysign(vmin**2, vmin), vmax**2)
Ejemplo n.º 33
0
 def __call__(self):
     vmin, vmax = self.axis.get_view_interval()
     vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander = 0.05)
     locs = self.bin_boundaries(vmin, vmax)
     prune = self._prune
     if prune=='lower':
         locs = locs[1:]
     elif prune=='upper':
         locs = locs[:-1]
     elif prune=='both':
         locs = locs[1:-1]
     return self.raise_if_exceeds(locs)
Ejemplo n.º 34
0
 def __call__(self):
     'Return the locations of the ticks'
     vmin, vmax = self.axis.get_view_interval()
     vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander = 0.05)
     if vmax<vmin:
         vmin, vmax = vmax, vmin
     if (vmin, vmax) in self.presets:
         return self.presets[(vmin, vmax)]
     if self.numticks is None:
         self._set_numticks()
     if self.numticks==0: return []
     ticklocs = np.linspace(vmin, vmax, self.numticks)
     return self.raise_if_exceeds(ticklocs)
Ejemplo n.º 35
0
    def autoscale(self):
        """
    Sets the view limits to the nearest multiples of base that contain the data.
        """
        # requires matplotlib >= 0.98.0
        (vmin, vmax) = self.axis.get_data_interval()

        locs = self._get_default_locs(vmin, vmax)
        (vmin, vmax) = locs[[0, -1]]
        if vmin == vmax:
            vmin -= 1
            vmax += 1
        return nonsingular(vmin, vmax)
Ejemplo n.º 36
0
    def autoscale(self):
        """
    Sets the view limits to the nearest multiples of base that contain the data.
        """
        # requires matplotlib >= 0.98.0
        (vmin, vmax) = self.axis.get_data_interval()

        locs = self._get_default_locs(vmin, vmax)
        (vmin, vmax) = locs[[0, -1]]
        if vmin == vmax:
            vmin -= 1
            vmax += 1
        return nonsingular(vmin, vmax)
Ejemplo n.º 37
0
    def __call__(self, x, pos=None):
        """
        Return the format for tick val *x*.
        """
        if x == 0.0:  # Symlog
            return '0'

        x = abs(x)

        vmin, vmax = self.axis.get_view_interval()
        vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander=0.05)
        s = self._num_to_string(x, vmin, vmax)
        return self.fix_minus(s)
Ejemplo n.º 38
0
 def __call__(self):
     vmin, vmax = self.axis.get_view_interval()
     vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander=0.05)
     locs = self.bin_boundaries(vmin, vmax)
     #print 'locs=', locs
     prune = self._prune
     if prune == 'lower':
         locs = locs[1:]
     elif prune == 'upper':
         locs = locs[:-1]
     elif prune == 'both':
         locs = locs[1:-1]
     return self.raise_if_exceeds(locs)
Ejemplo n.º 39
0
 def view_limits(self, vmin, vmax):
     'Try to choose the view limits intelligently'
     if vmax<vmin:
         vmin, vmax = vmax, vmin
     if vmin==vmax:
         vmin-=1
         vmax+=1
     exponent, remainder = divmod(math.log10(vmax - vmin), 1)
     if remainder < 0.5:
         exponent -= 1
     scale = 10**(-exponent)
     vmin = math.floor(scale*vmin)/scale
     vmax = math.ceil(scale*vmax)/scale
     return mtransforms.nonsingular(vmin, vmax)
Ejemplo n.º 40
0
 def tick_values(self, vmin, vmax):
     """Return the ticks for this axis
     """
     vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander=1e-13,
                                                      tiny=1e-14)
     locs = self.bin_boundaries(vmin, vmax)
     prune = self._prune
     if prune == 'lower':
         locs = locs[1:]
     elif prune == 'upper':
         locs = locs[:-1]
     elif prune == 'both':
         locs = locs[1:-1]
     return self.raise_if_exceeds(locs)
Ejemplo n.º 41
0
 def pan(self, numsteps):
     'Pan numticks (can be positive or negative)'
     ticks = self()
     numticks = len(ticks)
     vmin, vmax = self.axis.get_view_interval()
     vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander = 0.05)
     if numticks>2:
         step = numsteps*abs(ticks[0]-ticks[1])
     else:
         d = abs(vmax-vmin)
         step = numsteps*d/6.
     vmin += step
     vmax += step
     self.axis.set_view_interval(vmin, vmax, ignore=True)
Ejemplo n.º 42
0
    def autoscale(self):
        """
        Set the view limits to the nearest multiples of base that
        contain the data
        """
        dmin, dmax = self.axis.get_data_interval()

        vmin = self._base.le(dmin)
        vmax = self._base.ge(dmax)
        if vmin == vmax:
            vmin -= 1
            vmax += 1

        return mtransforms.nonsingular(vmin, vmax)
Ejemplo n.º 43
0
    def autoscale(self):
        """
        Set the view limits to the nearest multiples of base that
        contain the data
        """
        dmin, dmax = self.axis.get_data_interval()

        vmin = self._base.le(dmin)
        vmax = self._base.ge(dmax)
        if vmin == vmax:
            vmin -= 1
            vmax += 1

        return mtransforms.nonsingular(vmin, vmax)
Ejemplo n.º 44
0
 def autoscale(self):
   self.verify_intervals()
   dmin, dmax = self.axis.get_data_interval()
   if dmin > dmax:
     dmin, dmax = dmax, dmin
   if dmin == dmax:
     dmin -= 1
     dmax += 1
   exp, rem = divmod(math.log(dmax - dmin, 2), 1)
   if rem > 0.5:
     exp -= 1
   scale = 2**(-exp)
   dmin = math.floor(scale*dmin)/scale
   dmax = math.ceil(scale*dmax)/scale
   return nonsingular(dmin, dmax)
Ejemplo n.º 45
0
    def plot(self, experiment, **kwargs):
        """Plot a faceted histogram view of a channel"""
        
        #kwargs.setdefault('histtype', 'stepfilled')
        #kwargs.setdefault('alpha', 0.5)
        kwargs.setdefault('edgecolor', 'none')
        #kwargs.setdefault('mincnt', 1)
        #kwargs.setdefault('bins', 'log')
        kwargs.setdefault('antialiased', True)
        
        if not self.subset:
            x = experiment.data
        else:
            x = experiment.query(self.subset)
            
        xmin, xmax = (np.amin(x[self.xchannel]), np.amax(x[self.xchannel]))
        ymin, ymax = (np.amin(x[self.ychannel]), np.amax(x[self.ychannel]))
        # to avoid issues with singular data, expand the min/max pairs
        xmin, xmax = mtrans.nonsingular(xmin, xmax, expander=0.1)
        ymin, ymax = mtrans.nonsingular(ymin, ymax, expander=0.1)
        
        extent = (xmin, xmax, ymin, ymax)
        kwargs.setdefault('extent', extent)
        
        xbins = num_hist_bins(experiment[self.xchannel])
        ybins = num_hist_bins(experiment[self.ychannel])
        bins = np.mean([xbins, ybins])
        
        kwargs.setdefault('bins', bins) # Do not move above.  don't ask.

        g = sns.FacetGrid(x, 
                          col = (self.xfacet if self.xfacet else None),
                          row = (self.yfacet if self.yfacet else None),
                          hue = (self.huefacet if self.huefacet else None))
        
        g.map(plt.hexbin, self.xchannel, self.ychannel, **kwargs)
Ejemplo n.º 46
0
    def autoscale(self):
        """
        Set the view limits to the nearest multiples of base that
        contain the data
        """

        self.verify_intervals()
        dmin, dmax = self.dataInterval.get_bounds()

        vmin = self._base.le(dmin)
        vmax = self._base.ge(dmax)
        if vmin == vmax:
            vmin -= 1
            vmax += 1

        return mtrans.nonsingular(vmin, vmax)
Ejemplo n.º 47
0
    def pan(self, numsteps):
        'Pan numticks (can be positive or negative)'
        ticks = self()
        numticks = len(ticks)

        vmin, vmax = self.axis.get_view_interval()
        vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander = 0.05)
        if numticks>2:
            step = numsteps*abs(ticks[0]-ticks[1])
        else:
            d = abs(vmax-vmin)
            step = numsteps*d/6.

        vmin += step
        vmax += step
        self.axis.set_view_interval(vmin, vmax, ignore=True)
Ejemplo n.º 48
0
    def autoscale(self):
        """
        Set the view limits to the nearest multiples of base that
        contain the data
        """

        self.verify_intervals()
        dmin, dmax = self.dataInterval.get_bounds()

        vmin = self._base.le(dmin)
        vmax = self._base.ge(dmax)
        if vmin==vmax:
            vmin -=1
            vmax +=1

        return mtrans.nonsingular(vmin, vmax)
Ejemplo n.º 49
0
 def view_limits(self, vmin, vmax):
     'Try to choose the view limits intelligently'
     if vmax<vmin:
         vmin, vmax = vmax, vmin
     minpos = self.axis.get_minpos()
     if minpos<=0:
         raise ValueError(
             "Data has no positive values, and therefore can not be log-scaled.")
     if vmin <= minpos:
         vmin = minpos
     if not is_decade(vmin,self._base): vmin = decade_down(vmin,self._base)
     if not is_decade(vmax,self._base): vmax = decade_up(vmax,self._base)
     if vmin==vmax:
         vmin = decade_down(vmin,self._base)
         vmax = decade_up(vmax,self._base)
     result = mtransforms.nonsingular(vmin, vmax)
     return result
Ejemplo n.º 50
0
    def view_limits(self, dmin, dmax):
        """
        Set the view limits to the nearest multiples of base that
        contain the data
        """
        base = self._select_base(dmin, dmax)
        if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':
            vmin = base.le(dmin)
            vmax = base.ge(dmax)
            if vmin == vmax:
                vmin -= 1
                vmax += 1
        else:
            vmin = dmin
            vmax = dmax

        return mtransforms.nonsingular(vmin, vmax)
Ejemplo n.º 51
0
    def view_limits(self, vmin, vmax):
        'Try to choose the view limits intelligently'
        b = self._base
        
        if vmax < vmin:
            vmin, vmax = vmax, vmin

        if self.axis.axes.name == 'polar':
            vmax = math.ceil(math.log(vmax - self.zero) / math.log(b))
            vmin = b ** (vmax - self.numdecs)
            return vmin, vmax

        minpos = self.axis.get_minpos()

        if (self.sign > 0.0) :
            if vmax <= self.zero or not np.isfinite(minpos):
                raise ValueError(
                    "Data has no positive values, and therefore can not be "
                    "log-scaled.")
        else:
            if vmin >= self.zero or not np.isfinite(minpos):
                raise ValueError(
                    "Data has no positive values, and therefore can not be "
                    "log-scaled.")
            
        if not is_decade((vmin - self.zero) * self.sign, self._base):
            if self.sign > 0.0:
                vmin = decade_down((vmin - self.zero) * self.sign, self._base) + self.zero
            else:
                vmin = decade_up((vmin - self.zero) * self.sign, self._base) * self.sign + self.zero
        if not is_decade((vmax - self.zero) * self.sign, self._base):
            if self.sign > 0.0:
                vmax = decade_up((vmax - self.zero) * self.sign, self._base) + self.zero
            else:
                vmax = decade_down((vmax - self.zero) * self.sign, self._base) * self.sign + self.zero
        if vmin == vmax:
            if (self.sign > 0.0):
                vmin = decade_down((vmin - self.zero) * self.sign, self._base) + self.zero
                vmax = decade_up((vmax - self.zero) * self.sign, self._base) + self.zero
            else:
                vmin = decade_up((vmin - self.zero) * self.sign, self._base) * self.sign + self.zero
                vmax = decade_down((vmax - self.zero) * self.sign, self._base) * self.sign + self.zero
            
        result = mtransforms.nonsingular(vmin, vmax)
        return result
Ejemplo n.º 52
0
    def __call__(self):
        'Return the locations of the ticks'

        vmin, vmax = self.axis.get_view_interval()
        vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander=0.05)
        if vmax < vmin:
            vmin, vmax = vmax, vmin

        if (vmin, vmax) in self.presets:
            return self.presets[(vmin, vmax)]

        if self.numticks is None:
            self._set_numticks()

        if self.numticks == 0: return []
        ticklocs = np.linspace(vmin, vmax, self.numticks)

        return ticklocs
Ejemplo n.º 53
0
    def __call__(self):
        "Return the locations of the ticks"

        vmin, vmax = self.axis.get_view_interval()
        vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander=0.05)
        if vmax < vmin:
            vmin, vmax = vmax, vmin

        if self.presets.has_key((vmin, vmax)):
            return self.presets[(vmin, vmax)]

        if self.numticks is None:
            self._set_numticks()

        if self.numticks == 0:
            return []
        ticklocs = np.linspace(vmin, vmax, self.numticks)

        return ticklocs
Ejemplo n.º 54
0
    def view_limits(self, vmin, vmax):
        'Try to choose the view limits intelligently'

        if vmax < vmin:
            vmin, vmax = vmax, vmin

        if vmin == vmax:
            vmin -= 1
            vmax += 1

        exponent, remainder = divmod(math.log10(vmax - vmin), 1)

        if remainder < 0.5:
            exponent -= 1
        scale = 10**(-exponent)
        vmin = math.floor(scale * vmin) / scale
        vmax = math.ceil(scale * vmax) / scale

        return mtransforms.nonsingular(vmin, vmax)
Ejemplo n.º 55
0
    def autoscale(self):
        'Try to choose the view limits intelligently'
        self.verify_intervals()

        vmin, vmax = self.dataInterval.get_bounds()
        if vmax<vmin:
            vmin, vmax = vmax, vmin

        minpos = self.dataInterval.minpos()

        if minpos<=0:
            raise RuntimeError('No positive data to plot')
        if vmin<=0:
            vmin = minpos
        if not is_decade(vmin,self._base): vmin = decade_down(vmin,self._base)
        if not is_decade(vmax,self._base): vmax = decade_up(vmax,self._base)
        if vmin==vmax:
            vmin = decade_down(vmin,self._base)
            vmax = decade_up(vmax,self._base)
        return mtrans.nonsingular(vmin, vmax)
Ejemplo n.º 56
0
    def view_limits(self, data_min, data_max):
        'Try to choose the view limits intelligently'

        if data_max < data_min:
            data_min, data_max = data_max, data_min

        # get the nearest tenth-decade that contains the data

        if data_max > 0:
            logs = np.ceil(np.log10(data_max))
            vmax = np.ceil(data_max / (10**(logs - 1))) * (10**(logs - 1))
        else:
            vmax = 100

        if data_min >= 0:
            vmin = 0
        else:
            logs = np.ceil(np.log10(-1.0 * data_min))
            vmin = np.floor(data_min / (10**(logs - 1))) * (10**(logs - 1))

        return transforms.nonsingular(vmin, vmax)
Ejemplo n.º 57
0
    def autoscale(self):
        'Try to choose the view limits intelligently'
        self.verify_intervals()

        vmin, vmax = self.dataInterval.get_bounds()
        if vmax < vmin:
            vmin, vmax = vmax, vmin

        minpos = self.dataInterval.minpos()

        if minpos <= 0:
            raise RuntimeError('No positive data to plot')
        if vmin <= 0:
            vmin = minpos
        if not is_decade(vmin, self._base):
            vmin = decade_down(vmin, self._base)
        if not is_decade(vmax, self._base): vmax = decade_up(vmax, self._base)
        if vmin == vmax:
            vmin = decade_down(vmin, self._base)
            vmax = decade_up(vmax, self._base)
        return mtrans.nonsingular(vmin, vmax)
Ejemplo n.º 58
0
 def view_limits(self, dmin, dmax):
     # begin partial duplication of MaxNLocator.view_limits
     if self._symmetric:
         maxabs = max(abs(dmin), abs(dmax))
         dmin = -maxabs
         dmax = maxabs
     dmin, dmax = mtransforms.nonsingular(dmin, dmax, expander=0.05)
     # end duplication
     margin = self._margin * (dmax - dmin)  # fraction of data range
     vmin = dmin - margin  # expand the view
     vmax = dmax + margin
     bin_boundaries = self.bin_boundaries(vmin, vmax)
     # locate ticks with MaxNLocator
     # Note: If the lines below change vmin or vmax, the bin boundaries
     # later calculated by MaxNLocator.__call__ may differ from those
     # calculated here.
     vmin = min(vmin, max(bin_boundaries[bin_boundaries <= dmin]))
     # expand view to the highest tick below or touching the data
     vmax = max(vmax, min(bin_boundaries[bin_boundaries >= dmax]))
     # expand view to the lowest tick above or touching the data
     return np.array([vmin, vmax])
Ejemplo n.º 59
0
    def autoscale(self):
        'Try to choose the view limits intelligently'
        self.verify_intervals()
        vmin, vmax = self.dataInterval.get_bounds()

        if vmax < vmin:
            vmin, vmax = vmax, vmin

        if vmin == vmax:
            vmin -= 1
            vmax += 1

        exponent, remainder = divmod(math.log10(vmax - vmin), 1)

        if remainder < 0.5:
            exponent -= 1
        scale = 10**(-exponent)
        vmin = math.floor(scale * vmin) / scale
        vmax = math.ceil(scale * vmax) / scale

        return mtransforms.nonsingular(vmin, vmax)