Unit of Y-axis index

        :type: `~astropy.units.Unit`
492173
def yunit(self):
        
        try:
            return self._dy.unit
        except AttributeError:
            try:
                return self._y0.unit
            except AttributeError:
                return self._default_yunit
398796
def get_unit(a):
    """"""
    typestr = a.dtype.str
    i = typestr.find('[')
    if i == -1:
        raise TypeError("Expected a datetime64 array, not %s", a.dtype)
    return typestr[i + 1: -1]
955017
def serialize_quantity(o):
    
    return dict(
        _type='astropy.units.Quantity',
        value=o.value,
        unit=o.unit.to_string())
482596
def unit_tangent(self, t):
        """"""
        dseg = self.derivative(t)
        return dseg/abs(dseg)
1075610
def convert_units(self, from_units, to_units):
        '''
        

        '''
        from blmath import units
        factor = units.factor(
            from_units=from_units,
            to_units=to_units,
            units_class='length'
        )
        self.scale(factor)
25099
def unit(self, parameter):
        ""
        parameter = self._get_parameter_name(parameter).lower()
        return self._parameters[parameter]['Unit']
449720
def unit_poly_verts(theta):
    
    x0, y0, r = [0.5] * 3
    verts = [(r*np.cos(t) + x0, r*np.sin(t) + y0) for t in theta]
    return verts
237403
def get_units(self,*args,**kwargs):
        
        if len(args) == 1:
            return self.spike_times.get_label(args[0]).units
        return [self.spike_times.get_label(a).units for a in args]
501714
def expected_magy(RAW_IMU, ATTITUDE, inclination, declination):
    ''''''
    v = expected_mag(RAW_IMU, ATTITUDE, inclination, declination)
    return v.y
540219
def abs_unit(self):
        """"""
        s = self.x * self.x + self.y * self.y
        if s < 1e-5:
            return Point(0,0)
        s = math.sqrt(s)
        return Point(abs(self.x) / s, abs(self.y) / s)
670697
def to(self, unit):
        """"""
        from astropy.units import au
        return (self.au * au).to(unit)
503815
def unit_vector(self):
        """"""
        return Point2D( self.x / self.magnitude, self.y / self.magnitude )
363199
def obfn_g(self, Y):
        
        """

        return self.obfn_g0(self.obfn_g0var()) + \
            self.obfn_g1(self.obfn_g1var())
142220
def to_skycoord(self, unit=None):
        """"""
        from astropy.coordinates import SkyCoord
        from astropy.units import au
        x, y, z = self.position.au
        return SkyCoord(representation='cartesian', x=x, y=y, z=z, unit=au)
111666
def unit_vector(self):
        """"""
        x = -math.cos(self.rpitch) * math.sin(self.ryaw)
        y = -math.sin(self.rpitch)
        z = math.cos(self.rpitch) * math.cos(self.ryaw)
        return Vector3(x, y, z)
604532
def index_to_coordinates(self, index):
        
        self.validate_index(index)
        x = int(index % self.length)
        y = int((index - x) / self.length)
        return x, y
126097
def frequency_axis(self):
        
        return numpy.linspace(-self.sw / 2, self.sw / 2, self.np, endpoint=False)