:return: Line

        Returns a Line normal (perpendicular) to this Line.
173147
def normal(self):
        '''
        
        '''

        d = self.B - self.A

        return Line([-d.y, d.x], [d.y, -d.x])
784967
def __process_line(line, strip_eol, strip):
    
    if strip:
        line = line.strip()
    elif strip_eol and line.endswith('\n'):
        line = line[:-1]
    return line
118553
def iline(self):
        

        if self.unstructured:
            raise ValueError(self._unstructured_errmsg)

        if self._iline is not None:
            return self._iline

        self._iline = Line(self,
                           self.ilines,
                           self._iline_length,
                           self._iline_stride,
                           self.offsets,
                           'inline',
                          )
        return self._iline
469680
def _t_normals(self):
        
        """
        verts = self['throat.vertices']
        value = sp.zeros([len(verts), 3])
        for i in range(len(verts)):
            if len(sp.unique(verts[i][:, 0])) == 1:
                verts_2d = sp.vstack((verts[i][:, 1], verts[i][:, 2])).T
            elif len(sp.unique(verts[i][:, 1])) == 1:
                verts_2d = sp.vstack((verts[i][:, 0], verts[i][:, 2])).T
            else:
                verts_2d = sp.vstack((verts[i][:, 0], verts[i][:, 1])).T
            hull = sptl.ConvexHull(verts_2d, qhull_options='QJ Pp')
            sorted_verts = verts[i][hull.vertices].astype(float)
            v1 = sorted_verts[-1]-sorted_verts[0]
            v2 = sorted_verts[1]-sorted_verts[0]
            value[i] = tr.unit_vector(sp.cross(v1, v2))
        return value
374001
def input_line_to_visible_line(self):
        
        result = {}
        for k, v in self.visible_line_to_input_line.items():
            if v in result:
                result[v] = min(result[v], k)
            else:
                result[v] = k
        return result
379757
def line(y, thickness, gaussian_width):
    
    distance_from_line = abs(y)
    gaussian_y_coord = distance_from_line - thickness/2.0
    sigmasq = gaussian_width*gaussian_width

    if sigmasq==0.0:
        falloff = y*0.0
    else:
        with float_error_ignore():
            falloff = np.exp(np.divide(-gaussian_y_coord*gaussian_y_coord,2*sigmasq))

    return np.where(gaussian_y_coord<=0, 1.0, falloff)
1103130
def readline(self):
        
        data = self._file.readline()
        s = self.parse(data)
        return s
65567
public void lineToCoordinate(LineParametric2D_F32 line , Point2D_F64 coordinate ) {
		line = line.copy();
		line.p.x -= originX;
		line.p.y -= originY;
		LinePolar2D_F32 polar = new LinePolar2D_F32();
		UtilLine2D_F32.convert(line,polar);

		if( polar.angle < 0 ) {
			polar.distance = -polar.distance;
			polar.angle = UtilAngle.toHalfCircle(polar.angle);
		}

		int w2 = transform.width/2;

		coordinate.x = (int)Math.floor(polar.distance*w2/r_max) + w2;
		coordinate.y = polar.angle*transform.height/Math.PI;
	}
712382
def slope (self):
    
    return (self.p.y - self.q.y) / (self.p.x - self.q.x)
756374
def get_lines(self):
        
        with open(self.path, "r") as data:
            self.lines = data.readlines()  # store data in arrays

        return self.lines
31224
def parse(self, line):
        
        tree = list(self.parser.raw_parse(line))[0]
        tree = tree[0]
        return tree
1353992
def getline(self):
        """"""
        if self.index >= len(self.lines):
            line = ''
        else:
            line = self.lines[self.index]
            self.index += 1
        return line
379287
def xline(self):
        
        if self.unstructured:
            raise ValueError(self._unstructured_errmsg)

        if self._xline is not None:
            return self._xline

        self._xline = Line(self,
                           self.xlines,
                           self._xline_length,
                           self._xline_stride,
                           self.offsets,
                           'crossline',
                          )
        return self._xline
891407
def inline(self):
        """"""
        tp_lines, tp_decl = self.get_decl_pair()
        tp_lines = " ".join(tp_lines)
        if tp_decl is None:
            return tp_lines
        else:
            return "%s %s" % (tp_lines, tp_decl)
802890
def lines(self):
        
        # Cache, because this one is reused very often.
        if self._cache.lines is None:
            self._cache.lines = _ImmutableLineList(self.text.split('\n'))

        return self._cache.lines
1236534
def readline(self):
        """"""
        line = self.fd.__class__.readline(self.fd)
        if isinstance(line, bytes):
            line = line.decode()
        return line
309611
def line_is_continuation(line: str) -> bool:
    

    llstr = line.lstrip()
    return len(llstr) > 0 and llstr[0] == "&"