Ticket #11273: trac-11273-riemann_upgrade_part3.patch

File trac-11273-riemann_upgrade_part3.patch, 22.1 KB (added by evanandel, 10 years ago)

Formatting Fixes

  • sage/calculus/riemann.pyx

    # HG changeset patch
    # User Ethan Van Andel <evlutte@gmail.com>
    # Date 1311270131 14400
    # Node ID eb019dc2d8a6f2db9f1ae66377d38eb6025eb08a
    # Parent  89043440f58380e7007e30d0e991351c3d2224c3
    Trac 11273: additional patch, formatting fixes
    
    diff -r 89043440f583 -r eb019dc2d8a6 sage/calculus/riemann.pyx
    a b  
    7272
    7373cdef class Riemann_Map:
    7474    """
    75     The ``Riemann_Map`` class computes an interior or exterior Riemann map, or
    76     an Ahlfors map of a region given by the supplied boundary curve(s) and center '
    77     point. The class also provides various methods to evaluate, visualize, or extract
    78     data from the map.
     75   
     76    The ``Riemann_Map`` class computes an interior or exterior Riemann map,
     77    or an Ahlfors map of a region given by the supplied boundary curve(s)
     78    and center ' point. The class also provides various methods to
     79    evaluate, visualize, or extract data from the map.
    7980   
    8081    A Riemann map conformally maps a simply connected region in
    8182    the complex plane to the unit disc. The Ahlfors map does the same thing
    8283    for multiply connected regions.
    8384   
    84     Note that all the methods are numerical. As a result all answers have some
    85     imprecision. Moreover, maps computed with small number of collocation points, or
    86     for unusually shaped regions may be very inaccurate. Error computations for the
    87     ellipse can be found in the documentation for ``analytic_boundary()`` and
    88     ``analytic_interior()``.
     85    Note that all the methods are numerical. As a result all answers have
     86    some imprecision. Moreover, maps computed with small number of
     87    collocation points, or for unusually shaped regions may be very
     88    inaccurate. Error computations for the ellipse can be found in the
     89    documentation for ``analytic_boundary()`` and ``analytic_interior()``.
    8990   
    9091    [BSV] provides an overview of the Riemann map and discusses the research
    9192    that lead to the creation of this module.
     
    9394    INPUT:
    9495
    9596    - ``fs`` -- A list of the boundaries of the region, given as
    96       complex-valued functions with domain ``0`` to ``2*pi``. Note that the
     97      complex-valued functions with domain `0` to `2*pi`. Note that the
    9798      outer boundary must be parameterized counter clockwise
    9899      (i.e. ``e^(I*t)``) while the inner boundaries must be clockwise
    99100      (i.e. ``e^(-I*t)``).
     
    115116      exterior map will be computed, mapping the exterior of the region to the
    116117      exterior of the unit circle.
    117118   
    118     The following inputs may be passed as named parameters in unusual circumstances:
     119    The following inputs may be passed as named parameters in unusual
     120    circumstances:
    119121   
    120122    - ``ncorners`` -- integer (default: ``4``), if mapping a figure with
    121123      (equally t-spaced) corners--corners that make a significant change in
     
    182184    cdef x_range, y_range
    183185    cdef exterior
    184186
    185     def __init__(self, fs, fprimes, COMPLEX_T a, int N=500, int ncorners=4, opp=False, exterior = False):
     187    def __init__(self, fs, fprimes, COMPLEX_T a, int N=500, int ncorners=4,
     188        opp=False, exterior = False):
     189       
    186190        """
    187191        Initializes the ``Riemann_Map`` class. See the class ``Riemann_Map``
    188192        for full documentation on the input of this initialization method.
     
    221225        if exterior and (self.B > 1):
    222226            raise ValueError(
    223227                "The exterior map is undefined for multiply connected domains")
    224         cdef np.ndarray[COMPLEX_T,ndim=2] cps = np.zeros([self.B, N], dtype=COMPLEX)
    225         cdef np.ndarray[COMPLEX_T,ndim=2] dps = np.zeros([self.B, N], dtype=COMPLEX)
     228        cdef np.ndarray[COMPLEX_T,ndim=2] cps = np.zeros([self.B, N],
     229            dtype=COMPLEX)
     230        cdef np.ndarray[COMPLEX_T,ndim=2] dps = np.zeros([self.B, N],
     231            dtype=COMPLEX)
    226232        # Find the points on the boundaries and their derivatives.
    227233        if self.exterior:
    228234            for k in xrange(self.B):
     
    301307        normalized_dp=dp/adp
    302308        C = I / N * sadp # equivalent to -TWOPI / N * 1 / (TWOPI * I) * sadp
    303309        olderr = np.geterr()['invalid'] # checks the current error handling
    304         np.seterr(invalid='ignore') #there are some 0 divides that get over written later
    305         K = np.array(
    306             [C * sadp[t] *
    307              (normalized_dp/(cp-cp[t]) - (normalized_dp[t]/(cp-cp[t])).conjugate())
     310        #there are some 0 divides that get over written later
     311        np.seterr(invalid='ignore')
     312        K = np.array([C * sadp[t] * (normalized_dp/(cp-cp[t]) -
     313             (normalized_dp[t]/(cp-cp[t])).conjugate())
    308314              for t in np.arange(NB)], dtype=COMPLEX)
    309315        np.seterr(invalid=olderr) # resets the error handling
    310316        for i in xrange(NB):
    311317            K[i, i] = 1
    312         phi = np.linalg.solve(K, g) / NB * TWOPI  # Nystrom Method for solvin 2nd kind integrals
     318        # Nystrom Method for solvin 2nd kind integrals
     319        phi = np.linalg.solve(K, g) / NB * TWOPI 
    313320        # the all-important Szego kernel
    314321        szego = np.array(phi.flatten() / np.sqrt(dp), dtype=COMPLEX)
    315322        self.szego = szego.reshape([B, N])
     
    632639    cpdef inverse_riemann_map(self, COMPLEX_T pt):
    633640        """
    634641        Returns the inverse Riemann mapping of a point. That is, given ``pt``
    635         on the interior of the unit disc, ``inverse_riemann_map()`` will
    636         return the point on the original region that would be Riemann
    637         mapped to ``pt``. Note that this method does not work for multiply connected
    638         domains.
     642        on the interior of the unit disc, ``inverse_riemann_map()`` will 
     643        return the point on the original region that would be Riemann 
     644        mapped to ``pt``. Note that this method does not work for multiply
     645        connected domains.
    639646
    640647        INPUT:
    641648
     
    721728        """
    722729        plots = range(self.B)
    723730        for k in xrange(self.B):
    724             # This conditional should be eliminated when the thickness/pointsize issue
    725             # is resolved later. Same for the others in plot_spiderweb().
     731            # This conditional should be eliminated when the thickness/pointsize
     732            # issue is resolved later. Same for the others in plot_spiderweb().
    726733            if plotjoined:
    727734                plots[k] = list_plot(
    728735                    comp_pt(self.cps[k], 1), plotjoined=True,
     
    750757       
    751758        OUTPUT:
    752759       
    753         - a tuple containing [z_values, xmin, xmax, ymin, ymax] where z_values is
    754           the evaluation of the map on the specified grid.
     760        - a tuple containing [z_values, xmin, xmax, ymin, ymax] where z_values
     761          is the evaluation of the map on the specified grid.
    755762           
    756763        EXAMPLES:
    757764
     
    800807       
    801808    @options(interpolation='catrom')
    802809    def plot_spiderweb(self, spokes=16, circles=4, pts=32, linescale=0.99,
    803                        rgbcolor=[0,0,0], thickness=1, plotjoined=True, withcolor = False,plot_points = 200, **options):
     810            rgbcolor=[0,0,0], thickness=1, plotjoined=True, withcolor = False,
     811            plot_points = 200, **options):
    804812        """
    805813        Generates a traditional "spiderweb plot" of the Riemann map. Shows
    806814        what concentric circles and radial lines map to. The radial lines
     
    878886        """
    879887        cdef int k, i
    880888        if self.B == 1: #The efficient simply connected
    881             edge = self.plot_boundaries(plotjoined=plotjoined, rgbcolor=rgbcolor,
    882                                         thickness=thickness)
     889            edge = self.plot_boundaries(plotjoined=plotjoined,
     890                rgbcolor=rgbcolor, thickness=thickness)
    883891            circle_list = range(circles)
    884892            theta_array = self.theta_array[0]
    885893            s = spline(np.column_stack([self.theta_array[0], self.tk2]).tolist())
     
    891899                    temp[i] = self.inverse_riemann_map(
    892900                        (k + 1) / (circles + 1.0) * exp(I*i * TWOPI / (2*pts)))
    893901                if plotjoined:
    894                     circle_list[k] = list_plot(
    895                         comp_pt(temp, 1), rgbcolor=rgbcolor, thickness=thickness,
    896                         plotjoined=True)
     902                    circle_list[k] = list_plot(comp_pt(temp, 1),
     903                        rgbcolor=rgbcolor, thickness=thickness, plotjoined=True)
    897904                else:
    898                     circle_list[k] = list_plot(
    899                         comp_pt(temp, 1), rgbcolor=rgbcolor, pointsize=thickness)
     905                    circle_list[k] = list_plot(comp_pt(temp, 1),
     906                        rgbcolor=rgbcolor, pointsize=thickness)
    900907            line_list = range(spokes)
    901908            for k in xrange(spokes):
    902909                temp = range(pts)
     
    918925                    line_list[k] = list_plot(
    919926                        comp_pt(temp, 0), rgbcolor=rgbcolor, pointsize=thickness)
    920927            if withcolor:
    921                 return edge + sum(circle_list) + sum(line_list) + self.plot_colored(plot_points=plot_points)
     928                return edge + sum(circle_list) + sum(line_list) + \
     929                    self.plot_colored(plot_points=plot_points)
    922930            else:
    923931                return edge + sum(circle_list) + sum(line_list)
    924932        else: # The more difficult multiply connected
    925             z_values, xmin, xmax, ymin, ymax = self.compute_on_grid([], plot_points)
     933            z_values, xmin, xmax, ymin, ymax = self.compute_on_grid([],
     934                plot_points)
    926935            xstep = (xmax-xmin)/plot_points
    927936            ystep = (ymax-ymin)/plot_points
    928937            dr, dtheta= get_derivatives(z_values, xstep, ystep) # clean later
    929938           
    930939            g = Graphics()
    931             g.add_primitive(ComplexPlot(complex_to_spiderweb(z_values,dr,dtheta, spokes, circles, rgbcolor,thickness, withcolor), (xmin, xmax), (ymin, ymax),options))
     940            g.add_primitive(ComplexPlot(complex_to_spiderweb(z_values,dr,dtheta,
     941                spokes, circles, rgbcolor,thickness, withcolor),
     942                (xmin, xmax), (ymin, ymax),options))
    932943            return g + self.plot_boundaries(thickness = thickness)
    933944           
    934945
     
    946957          ``(xmin, xmax, ymin, ymax)``. Declare if you do not want the plot
    947958          to use the default range for the figure.
    948959
    949         - ``plot_points`` -- integer (default: ``100``), number of points to plot in
    950           the x direction. Points in the y direction are scaled accordingly.
    951           Note that very large values can cause this function to run slowly.
     960        - ``plot_points`` -- integer (default: ``100``), number of points to
     961          plot in the x direction. Points in the y direction are scaled
     962          accordingly. Note that very large values can cause this function to
     963          run slowly.
    952964         
    953965
    954966        EXAMPLES:
     
    976988            sage: m = Riemann_Map([f], [fprime], 0, 1000)
    977989            sage: m.plot_colored()
    978990        """
    979         z_values, xmin, xmax, ymin, ymax = self.compute_on_grid(plot_range, plot_points)
     991        z_values, xmin, xmax, ymin, ymax = self.compute_on_grid(plot_range,
     992            plot_points)
    980993        g = Graphics()
    981         g.add_primitive(ComplexPlot(complex_to_rgb(z_values), (xmin, xmax), (ymin, ymax),options))
     994        g.add_primitive(ComplexPlot(complex_to_rgb(z_values), (xmin, xmax),
     995            (ymin, ymax),options))
    982996        return g
    983997
    984998cdef comp_pt(clist, loop=True):
     
    10101024        list2[len(clist)] = list2[0]
    10111025    return list2
    10121026   
    1013 cpdef get_derivatives(np.ndarray[COMPLEX_T, ndim=2]z_values, FLOAT_T xstep, FLOAT_T ystep):
     1027cpdef get_derivatives(np.ndarray[COMPLEX_T, ndim=2]z_values, FLOAT_T xstep,
     1028    FLOAT_T ystep):
    10141029    """
    1015     Computes the r*e^(I*theta) form derivatives from the grid of points.
    1016     The derivatives are computed using quick-and-dirty taylor expansion and assuming analyticy.
    1017     As such ``get_derivatives`` is primarily intended to be used for comparisions in
    1018     ``plot_spiderweb`` and not for applications that require great precision.
     1030    Computes the r*e^(I*theta) form derivatives from the grid of points. The
     1031    derivatives are computed using quick-and-dirty taylor expansion and
     1032    assuming analyticy. As such ``get_derivatives`` is primarily intended
     1033    to be used for comparisions in ``plot_spiderweb`` and not for
     1034    applications that require great precision.
    10191035   
    10201036    INPUT:
    1021     - ``z_values`` -- The values for a complex function evaluated on a grid in the complex
    1022       plane, usually from ``compute_on_grid``.
     1037    - ``z_values`` -- The values for a complex function evaluated on a grid
     1038      in the complexplane, usually from ``compute_on_grid``.
    10231039     
    10241040    - ``xstep`` -- float, the spacing of the grid points in the real direction
    10251041   
    10261042    OUTPUT:
    10271043   
    1028     - A tuple of arrays, [``dr``, ``dtheta``], each array is 2 less in both dimensions
    1029       than ``z_values``
    1030       ``dr`` - the absolute value of the derivative of the function in the +r direction
     1044    - A tuple of arrays, [``dr``, ``dtheta``], each array is 2 less in both
     1045      dimensions than ``z_values``
     1046      ``dr`` - the abs of the derivative of the function in the +r direction
    10311047      ``dtheta`` - the rate of accumulation of angle in the +theta direction
    10321048     
    10331049    EXAMPLES:
    10341050       
    10351051        Standard usage with compute_on_grid::
     1052       
    10361053            sage: from sage.calculus.riemann import get_derivatives
    10371054            sage: f(t) = e^(I*t) - 0.5*e^(-I*t)
    10381055            sage: fprime(t) = I*e^(I*t) + 0.5*I*e^(-I*t)
     
    10511068    cdef np.ndarray[FLOAT_T, ndim = 2] dr, dtheta, zabs
    10521069    imax = len(z_values)-2
    10531070    jmax = len(z_values[0])-2
    1054     xderiv = (z_values[1:-1,2:]-z_values[1:-1,:-2])/(2*xstep) #(f(x+delta)-f(x-delta))/2delta
    1055     dr = np.abs(xderiv) #b/c the function is analytic, we know it's abs(derivative) is equal in all directions
    1056     zabs = np.abs(z_values[1:-1,1:-1]) # the abs(derivative) scaled by distance from origin
     1071    #(f(x+delta)-f(x-delta))/2delta
     1072    xderiv = (z_values[1:-1,2:]-z_values[1:-1,:-2])/(2*xstep)
     1073    #b/c the function is analytic, we know it's abs(derivative) is equal
     1074    #in all directions
     1075    dr = np.abs(xderiv)
     1076    # the abs(derivative) scaled by distance from origin
     1077    zabs = np.abs(z_values[1:-1,1:-1])
    10571078    dtheta = np.divide(dr,zabs)
    10581079    return dr, dtheta
    10591080
    1060 cpdef complex_to_spiderweb(np.ndarray[COMPLEX_T, ndim = 2]z_values, np.ndarray[FLOAT_T, ndim = 2] dr, np.ndarray[FLOAT_T, ndim = 2] dtheta, spokes, circles, rgbcolor, thickness, withcolor):
     1081cpdef complex_to_spiderweb(np.ndarray[COMPLEX_T, ndim = 2]z_values,
     1082    np.ndarray[FLOAT_T, ndim = 2] dr, np.ndarray[FLOAT_T, ndim = 2] dtheta,
     1083    spokes, circles, rgbcolor, thickness, withcolor):
    10611084    """
    10621085    Converts a grid of complex numbers into a matrix containing rgb data
    10631086    for the Riemann spiderweb plot.
     
    10741097     
    10751098    - ``spokes`` -- integer the number of equallyspaced radial lines to plot.
    10761099
    1077     - ``circles`` -- integer the number of equally spaced circles about the center to plot.
     1100    - ``circles`` -- integer the number of equally spaced circles about the
     1101      center to plot.
    10781102
    1079     - ``rgbcolor`` -- float array the red-green-blue color of the lines of the spiderweb.
     1103    - ``rgbcolor`` -- float array the red-green-blue color of the lines of the
     1104      spiderweb.
    10801105
    1081     - ``thickness`` -- positive float the thickness of the lines or points in the spiderweb.
     1106    - ``thickness`` -- positive float the thickness of the lines or points in
     1107      the spiderweb.
    10821108     
    1083     - ``withcolor`` -- boolean If ``True`` the spiderweb will be overlaid on the basic color plot.
     1109    - ``withcolor`` -- boolean If ``True`` the spiderweb will be overlaid on
     1110      the basic color plot.
    10841111    OUTPUT:
    10851112
    10861113    An `N x M x 3` floating point Numpy array ``X``, where
    10871114    ``X[i,j]`` is an (r,g,b) tuple.
    10881115   
    1089     EXAMPLES:
     1116    EXAMPLES::
     1117   
    10901118        sage: from sage.calculus.riemann import complex_to_spiderweb
    10911119        sage: import numpy
    10921120        sage: zval = numpy.array([[0, 1, 1000],[.2+.3j,1,-.3j],[0,0,0]],dtype = numpy.complex128)
     
    11371165    else:
    11381166        circ_radii = []
    11391167    if spokes != 0:
    1140         spoke_angles = srange(-PI,PI+TWOPI/spokes,TWOPI/spokes) # both -pi and pi are included
     1168        # both -pi and pi are included
     1169        spoke_angles = srange(-PI,PI+TWOPI/spokes,TWOPI/spokes)
    11411170    else:
    11421171        spoke_angles = []
    11431172    for i in xrange(imax-2): # the d arrays are 1 smaller on each side
     
    11471176            arg = phase(z)
    11481177            dmag = dr[i,j]
    11491178            darg = dtheta[i,j]
    1150             if darg < DMAX and mag > MMIN: #points that change too rapidly are presumed to be borders, points that are too small are presumed to be outside
     1179            #points that change too rapidly are presumed to be borders,
     1180            #points that are too small are presumed to be outside
     1181            if darg < DMAX and mag > MMIN:
    11511182                for target in circ_radii:
    11521183                    if abs(mag - target)/dmag < precision:
    11531184                        rgb[i+1,j+1] = rgbcolor
     
    11731204    ``X[i,j]`` is an (r,g,b) tuple.
    11741205
    11751206    EXAMPLES::
     1207   
    11761208        sage: from sage.calculus.riemann import complex_to_rgb
    11771209        sage: import numpy
    1178         sage: complex_to_rgb(numpy.array([[0, 1, 1000]],dtype = numpy.complex128))
     1210        sage: complex_to_rgb(numpy.array([[0, 1, 1000]], dtype = numpy.complex128))
    11791211        array([[[ 1.        ,  1.        ,  1.        ],
    11801212                [ 1.        ,  0.05558355,  0.05558355],
    11811213                [ 0.17301243,  0.        ,  0.        ]]])
    11821214
    11831215
    1184         sage: complex_to_rgb(numpy.array([[0, 1j, 1000j]],dtype = numpy.complex128))
     1216        sage: complex_to_rgb(numpy.array([[0, 1j, 1000j]], dtype = numpy.complex128))
    11851217        array([[[ 1.        ,  1.        ,  1.        ],
    11861218                [ 0.52779177,  1.        ,  0.05558355],
    11871219                [ 0.08650622,  0.17301243,  0.        ]]])
     
    12581290    """
    12591291    Provides an exact (for n = infinity) riemann boundary
    12601292    correspondence for the ellipse with axes 1 + epsilon and 1 - epsilon. The
    1261     boundary is therefore given by e^(I*t)+epsilon*e^(-I*t). It is primarily useful
    1262     for testing the accuracy of the numerical Riemann Map.
     1293    boundary is therefore given by e^(I*t)+epsilon*e^(-I*t). It is primarily
     1294    useful for testing the accuracy of the numerical Riemann Map.
    12631295   
    12641296    INPUT:
    12651297   
     
    12701302       
    12711303    OUTPUT:
    12721304   
    1273     A theta value from 0 to 2*pi, corresponding to the point on the circle e^(I*theta)
     1305    A theta value from 0 to 2*pi, corresponding to the point on the
     1306    circle e^(I*theta)
    12741307   
    12751308    TESTS:
    12761309   
    12771310    Checking the accuracy for different n values::
     1311   
    12781312        sage: from sage.calculus.riemann import analytic_boundary
    12791313        sage: t100 = analytic_boundary(pi/2,100)
    12801314        sage: abs(analytic_boundary(pi/2,10) - t100) < 10^-8
     
    12831317        True
    12841318       
    12851319    Using this to check the accuracy of the Riemann_Map boundary::
     1320   
    12861321        sage: f(t) = e^(I*t)+.3*e^(-I*t)
    12871322        sage: fp(t) = I*e^(I*t)-I*.3*e^(-I*t)
    12881323        sage: m = Riemann_Map([f], [fp],0,200)
     
    13081343    - ``t`` -- The boundary parameter, meant to be integrated over
    13091344   
    13101345    - ``args`` -- a tuple containing:
     1346   
    13111347        - ``z`` -- Complex, the point to be mapped.
    13121348       
    1313         - ``n`` -- Integer, The number of terms to include. 10 is fairly accurate,
    1314             20 is very accurate.
     1349        - ``n`` -- Integer, The number of terms to include. 10 is fairly
     1350          accurate, 20 is very accurate.
    13151351           
    1316         - ``part`` -- will return the real ('r'), imaginary ('i') or complex ('c')
    1317         value of the kernel
     1352        - ``part`` -- will return the real ('r'), imaginary ('i') or
     1353          complex ('c') value of the kernel
    13181354   
    13191355    TESTS:
    1320         Primarily tested implicitly by analytic_interior,
     1356        Primarily tested implicitly by analytic_interior
    13211357       
    13221358        Simple test::
     1359       
    13231360        sage: from sage.calculus.riemann import cauchy_kernel
    13241361        sage: cauchy_kernel(.5,(.1+.2*I, 10,'c'))
    13251362        (-0.584136405997...+0.5948650858950...j)
     
    13301367    cdef COMPLEX_T z = args[0]
    13311368    cdef int n = args[1]
    13321369    part = args[2]
    1333     result = exp(I*analytic_boundary(t,n))/(exp(I*t)+.3*exp(-I*t)-z)*(I*exp(I*t)-I*.3*exp(-I*t))
     1370    result = exp(I*analytic_boundary(t,n))/(exp(I*t)+.3*exp(-I*t)-z) *  \
     1371        (I*exp(I*t)-I*.3*exp(-I*t))
    13341372    if part == 'c':
    13351373        return result
    13361374    elif part == 'r':
     
    13421380cpdef analytic_interior(COMPLEX_T z, int n):
    13431381    """
    13441382    Provides a nearly exact compuation of the Riemann Map of an interior
    1345     point of the ellipse with axes 1 + epsilon and 1 - epsilon. It is primarily useful
    1346     for testing the accuracy of the numerical Riemann Map.
     1383    point of the ellipse with axes 1 + epsilon and 1 - epsilon. It is
     1384    primarily useful for testing the accuracy of the numerical Riemann Map.
    13471385   
    13481386    INPUT:
    13491387   
     
    13531391        20 is very accurate.
    13541392
    13551393    TESTS:
     1394   
    13561395        Testing the accuracy of Riemann_Map::
     1396       
    13571397        sage: from sage.calculus.riemann import analytic_interior
    13581398        sage: f(t) = e^(I*t)+.3*e^(-I*t)
    13591399        sage: fp(t) = I*e^(I*t)-I*.3*e^(-I*t)
     
    13661406    """
    13671407    # evaluates the cauchy integral of the boundary, split into the real
    13681408    # and imaginary results because numerical_integral can't handle complex data.
    1369     rp = 1/(TWOPI)*numerical_integral(cauchy_kernel,0,2*pi, params = [z,n,'i'])[0]
    1370     ip = 1/(TWOPI*I)*numerical_integral(cauchy_kernel,0,2*pi, params = [z,n,'r'])[0]
     1409    rp = 1/(TWOPI)*numerical_integral(cauchy_kernel,0,2*pi,
     1410        params = [z,n,'i'])[0]
     1411    ip = 1/(TWOPI*I)*numerical_integral(cauchy_kernel,0,2*pi,
     1412        params = [z,n,'r'])[0]
    13711413    return rp + ip
  • sage/plot/complex_plot.pyx

    diff -r 89043440f583 -r eb019dc2d8a6 sage/plot/complex_plot.pyx
    a b  
    172172        """
    173173        self.xrange = xrange
    174174        self.yrange = yrange
    175         #self.z_values = z_values
    176175        self.x_count = len(rgb_data)
    177176        self.y_count = len(rgb_data[0])
    178177        self.rgb_data = rgb_data