lessPython 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

lessPy/details.py

@@ -129,6 +129,11 @@ def details(data=None, n_mcut=1, max_lines=30, miss_show=30,
 
     names = list(data.columns)
     types = [_type_label(data[c]) for c in names]
+    # whole numbers that pandas stores as float64 (a pandas integer
+    # column cannot hold NaN): reported as integer, as lessR does,
+    # but flagged so the report states what pandas actually stores
+    stored_float = [t == "integer" and pdt.is_float_dtype(data[c].dtype)
+                    for c, t in zip(names, types)]
     n_val = [int(data[c].notna().sum()) for c in names]
     n_miss = [int(data[c].isna().sum()) for c in names]
     n_uniq = [int(data[c].dropna().nunique()) for c in names]
@@ -137,7 +142,8 @@ def details(data=None, n_mcut=1, max_lines=30, miss_show=30,
     _print_types(types)
     first_last = [_first_last(data[c], n_obs) for c in names]
     maybe_id, id_col = _print_table(names, types, n_val, n_miss,
-                                    n_uniq, first_last, n_var)
+                                    n_uniq, first_last, n_var,
+                                    stored_float)
 
     if maybe_id is not None and not var_labels:
         _print_id_note(maybe_id, id_col)
@@ -196,10 +202,13 @@ def _print_types(types):
 
 
 def _print_table(names, types, n_val, n_miss, n_uniq, first_last,
-                 n_var):
+                 n_var, stored_float=None):
+    if stored_float is None:
+        stored_float = [False] * n_var
+    shown = [t + "*" if f else t for t, f in zip(types, stored_float)]
     w_num = max(2, len(str(n_var)))
     w_nam = max(len("Variable"), *(len(x) for x in names))
-    w_typ = max(len("Type"), *(len(t) for t in types))
+    w_typ = max(len("Type"), *(len(t) for t in shown))
     w_val = max(len("Values"), *(len(str(x)) for x in n_val))
     w_mis = max(len("Missing"), *(len(str(x)) for x in n_miss))
     w_uni = max(len("Unique"), *(len(str(x)) for x in n_uniq))
@@ -215,7 +224,7 @@ def _print_table(names, types, n_val, n_miss, n_uniq, first_last,
     maybe_id, id_col = None, 0
     for i in range(n_var):
         print(f"{i + 1:>{w_num}}  {names[i]:<{w_nam}}  "
-              f"{types[i]:<{w_typ}}  {n_val[i]:>{w_val}}  "
+              f"{shown[i]:<{w_typ}}  {n_val[i]:>{w_val}}  "
               f"{n_miss[i]:>{w_mis}}  {n_uniq[i]:>{w_uni}}  "
               f"{first_last[i]}")
         if (n_uniq[i] == n_val[i]
@@ -223,6 +232,10 @@ def _print_table(names, types, n_val, n_miss, n_uniq, first_last,
                                  "character")):
             maybe_id, id_col = names[i], i + 1
     _dash(len(hdr))
+    if any(stored_float):
+        print("* Whole numbers stored by Pandas as float64 (double), "
+              "usually because\n  the column had missing values, NaN, "
+              "which a Pandas integer column\n  cannot hold.")
     return maybe_id, id_col
 
 

lessPy/dn_plotly.py

@@ -58,11 +58,13 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
         from .utils import bw_nrd0
         bw = bw_nrd0(x)
     h = bw * adjust
+    from .stats_out import record_stats
+    record_stats(bw=float(h))
 
     if facet is not None:
         if fill_miss and by is not None:
-            from .plotly_utils import BASE_COLORS
-            fill = BASE_COLORS
+            from .plotly_utils import by_colors
+            fill = by_colors(len(pd.Series(by).dropna().unique()))
         return _dn_facet(x, facet, facet_order, x_name,
                          facet_name, fill, x_lab, y_lab, main,
                          h, n, fill_area, style_opts,
@@ -91,8 +93,8 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
 
     # groups need distinguishable hues: default to the palette
     if fill_miss and G > 1:
-        from .plotly_utils import BASE_COLORS
-        fill = BASE_COLORS
+        from .plotly_utils import by_colors
+        fill = by_colors(G)
 
     def group_x(gname):
         xg = x if by is None else x[(by == gname).to_numpy()]
@@ -124,6 +126,11 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
     dx = grid[1] - grid[0]
 
     # --- densities per group -------------------------------------
+    # R analog: dn.plotly.R — kind "normal"/"both" adds the normal
+    # fit to each group by its own mean and sd on the shared grid;
+    # a group of identical values has no normal to draw
+    do_gen = kind in ("general", "both")
+    do_nrm = kind in ("normal", "both")
     dens = []
     ymax = 0.0
     for gname in groups:
@@ -133,19 +140,21 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
             [[0], np.cumsum((y[1:] + y[:-1]) * 0.5 * dx)])
         if cum[-1] > 0:
             cum = cum / cum[-1]
-        dens.append(dict(y=y, cum=cum, mn=float(xg.mean())))
-        ymax = max(ymax, float(y.max()))
-
-    # --- normal curve and background histogram --------------------
-    # R analog: dn.main.R — kind "normal"/"both" adds the normal
-    # curve at the sample mean and sd; show_histogram draws a
-    # faint density-scaled histogram behind the curves
-    d_nrm = None
-    if kind in ("normal", "both"):
-        xg0 = group_x(groups[0])
-        mu, sd = float(xg0.mean()), float(xg0.std(ddof=1))
-        z = (grid - mu) / sd
-        d_nrm = np.exp(-0.5 * z * z) / (sd * np.sqrt(2 * np.pi))
+        sd = float(xg.std(ddof=1))
+        nrm = None
+        if do_nrm and np.isfinite(sd) and sd > 0:
+            z = (grid - float(xg.mean())) / sd
+            nrm = np.exp(-0.5 * z * z) / (sd * np.sqrt(2 * np.pi))
+        dens.append(dict(y=y, cum=cum, mn=float(xg.mean()), nrm=nrm))
+        # only a curve that is drawn sets the height of the y-axis
+        if do_gen:
+            ymax = max(ymax, float(y.max()))
+        if nrm is not None:
+            ymax = max(ymax, float(nrm.max()))
+
+    # --- background histogram -------------------------------------
+    # show_histogram draws a faint density-scaled histogram behind
+    # the curves (dn.main.R)
     hist_y = None
     if show_histogram and hist_edges is not None:
         e = np.asarray(hist_edges, dtype=float)
@@ -155,10 +164,6 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
             hist_w = np.diff(e)
             hist_y = cnt / (tot * hist_w)  # density scale
             hist_mids = (e[:-1] + e[1:]) / 2
-    if kind == "normal":               # general curve not drawn
-        ymax = 0.0
-    if d_nrm is not None:
-        ymax = max(ymax, float(d_nrm.max()))
     if hist_y is not None:
         ymax = max(ymax, float(hist_y.max()))
 
@@ -195,12 +200,16 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
                 if fill_hist is None else fill_hist),
                 line=dict(width=0)),
             hoverinfo="skip", showlegend=False))
-    if kind in ("general", "both"):
-        for g, gname in enumerate(groups):
-            d = dens[g]
-            hv = hover(d)
-            if G > 1 and by_name:
-                hv = [f"{by_name}: {gname}<br>{t}" for t in hv]
+    # the normal curve: its own color for a single distribution, but
+    # the group's color when there are groups to keep apart, dashed
+    # beside that group's general curve (dn.plotly.R)
+    nrm_fill = (None if fill_normal in (None, "transparent")
+                else as_plotly_color(fill_normal))
+    for g, gname in enumerate(groups):
+        d = dens[g]
+        pre = (f"{by_name}: {gname}<br>"
+               if G > 1 and by_name else "")
+        if do_gen:
             fig.add_trace(go.Scatter(
                 mode="lines",
                 x=grid, y=d["y"],
@@ -209,29 +218,40 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
                 fill="tozeroy" if fill_area else "none",
                 fillcolor=fill_rgba[g] if fill_area else None,
                 hoverinfo="text",
-                hovertext=hv,
+                hovertext=[pre + t for t in hover(d)],
                 showlegend=G > 1,
             ))
-            # vertical line at the group mean, up to the curve
-            y_mn = float(np.interp(d["mn"], grid, d["y"]))
-            mean_line = dict(color=line_rgba[g], dash="dash",
-                             width=1.4 if fill_area else 0.7)
+        if d["nrm"] is not None:
+            nrm_col = line_rgba[g] if G > 1 else to_hex(color_normal)
+            filled = fill_area and G == 1 and nrm_fill is not None
             fig.add_trace(go.Scatter(
-                mode="lines",
-                x=[d["mn"], d["mn"]], y=[0, y_mn],
-                line=mean_line,
-                hoverinfo="skip", showlegend=False,
+                mode="lines", x=grid, y=d["nrm"],
+                name=(None if G == 1 else
+                      f"{gname} normal" if do_gen else gname),
+                showlegend=G > 1 and not do_gen,
+                line=dict(color=nrm_col, width=1.4,
+                          dash="dash" if do_gen and G > 1
+                          else "solid"),
+                fill="tozeroy" if filled else "none",
+                fillcolor=nrm_fill if filled else None,
+                hoverinfo="text",
+                hovertext=[
+                    f"{pre}{x_name}: {grid[i]:.6g}"
+                    f"<br>Normal density="
+                    f"{round(float(d['nrm'][i]), 6):g}"
+                    for i in range(n)],
             ))
-    if d_nrm is not None:              # normal curve
-        nrm_fill = (None if fill_normal in (None, "transparent")
-                    else as_plotly_color(fill_normal))
+        # vertical line at the group mean, up to whichever curve
+        # is drawn
+        curve = d["y"] if do_gen or d["nrm"] is None else d["nrm"]
+        y_mn = float(np.interp(d["mn"], grid, curve))
         fig.add_trace(go.Scatter(
-            mode="lines", x=grid, y=d_nrm,
-            line=dict(color=to_hex(color_normal),
-                      width=1.35 if nrm_fill is None else 1),
-            fill="none" if nrm_fill is None else "tozeroy",
-            fillcolor=nrm_fill,
-            hoverinfo="skip", showlegend=False))
+            mode="lines",
+            x=[d["mn"], d["mn"]], y=[0, y_mn],
+            line=dict(color=line_rgba[g], dash="dash",
+                      width=1.4 if fill_area else 0.7),
+            hoverinfo="skip", showlegend=False,
+        ))
     if rug:                            # ticks at each data value
         xr, yr = [], []
         y1r = -0.05 * ymax

lessPy/freq_poly_plotly.py

@@ -48,6 +48,7 @@ def freq_poly_plotly(x, by=None, x_name=None, by_name=None,
                      facet2=None, facet2_order=None,
                      facet2_name=None,
                      breaks=None, proportion=False,
+                     cumulate=False,
                      fill=None, fill_area=True,
                      x_lab=None, y_lab=None, main=None,
                      n_col=1, axis_fmt="K", axis_x_pre="",
@@ -65,6 +66,8 @@ def freq_poly_plotly(x, by=None, x_name=None, by_name=None,
     if y_lab is None:
         y_lab = (f"Proportion of {x_name}" if proportion
                  else f"Count of {x_name}")
+        if cumulate:
+            y_lab = f"Cumulative {y_lab}"
 
     if facet is not None:
         return _fp_facet(x, facet, facet_order, x_name,
@@ -90,8 +93,8 @@ def freq_poly_plotly(x, by=None, x_name=None, by_name=None,
     # groups need distinguishable hues: default to the palette
     if fill is None:
         if G > 1:
-            from .plotly_utils import BASE_COLORS
-            fill = BASE_COLORS
+            from .plotly_utils import by_colors
+            fill = by_colors(G)
         else:
             fill = get_option("bar_fill_cont", "#96AAC3")
 
@@ -107,6 +110,8 @@ def freq_poly_plotly(x, by=None, x_name=None, by_name=None,
         xg = x if by is None else x[(by == gname).to_numpy()]
         xg = xg[np.isfinite(xg)]
         yv = _poly_counts(xg, breaks, proportion)
+        if cumulate:                   # running total over the bins
+            yv = np.cumsum(yv)
         polys.append(yv)
         ymax = max(ymax, float(yv.max()))
 
@@ -133,7 +138,9 @@ def freq_poly_plotly(x, by=None, x_name=None, by_name=None,
     for g, gname in enumerate(groups):
         xx = np.concatenate([[mids[0] - step], mids,
                              [mids[-1] + step]])
-        yy = np.concatenate([[0], polys[g], [0]])
+        # a cumulative polygon (ogive) holds its total at the right
+        yy = np.concatenate([[0], polys[g],
+                             [polys[g][-1] if cumulate else 0]])
         hover = [
             (f"{x_name}: {xv:.6g}"
              f"<br>{y_lab}: {round(float(yv), digits_d):g}")
@@ -221,8 +228,8 @@ def _fp_facet(x, facet, facet_order, x_name, facet_name, breaks,
 
     if fill is None:
         if G > 1:
-            from .plotly_utils import BASE_COLORS
-            fill = BASE_COLORS
+            from .plotly_utils import by_colors
+            fill = by_colors(G)
         else:
             fill = get_option("bar_fill_cont", "#96AAC3")
 

lessPy/getColors.py

@@ -5,7 +5,9 @@
 # The HCL families (hues/qualitative, sequential, divergent) are
 # reproduced exactly from R's grDevices HCL and colorspace
 # trajectories; the manual families interpolate in RGB; Okabe-Ito,
-# Tableau and "distinct" are fixed lists. The viridis family maps
+# Tableau and "distinct" are fixed lists. The R palettes "rainbow",
+# "heat", "terrain" (grDevices HSV) and their colorspace "_hcl"
+# counterparts are computed exactly as R does. The viridis family maps
 # to plotly's built-in colorscales (a documented approximation),
 # and R's wesanderson palettes are not ported (external package).
 
@@ -37,6 +39,9 @@ _SEQ_HUE = {
     "magentas": 330, "grays": 0,
 }
 _SEQ_NAMES = list(_SEQ_HUE)
+# R's own palettes, grDevices and colorspace. R analog: nmR
+_SEQ_R = ("rainbow", "heat", "terrain",
+          "rainbow_hcl", "heat_hcl", "terrain_hcl")
 _VIRIDIS = {"viridis": "Viridis", "cividis": "Cividis",
             "plasma": "Plasma", "inferno": "Inferno",
             "spectral": "Spectral"}
@@ -151,20 +156,63 @@ def _rgb_to_hcl(r, g, b):
     return math.degrees(math.atan2(V, U)) % 360, math.hypot(U, V), L
 
 
+def _xy_to_xyz(x, y):
+    return (x / y, 1.0, (1 - x - y) / y)
+
+
+def _srgb_to_luv_matrix():
+    """R's make.rgb() for sRGB: primaries and the D65 white (x, y),
+    the matrix scaled so that white maps to white. R's white.points
+    table gives D65 as (0.3137, 0.3291), not the CIE (0.3127,
+    0.3290), so that is the white used, as convertColor() uses it."""
+    import numpy as np
+    prim = np.array([_xy_to_xyz(0.64, 0.33), _xy_to_xyz(0.30, 0.60),
+                     _xy_to_xyz(0.15, 0.06)]).T
+    white = np.array(_xy_to_xyz(0.3137, 0.3291))
+    scale = np.linalg.solve(prim, white)
+    return prim * scale, white
+
+
 def _color_hc(col):
-    h, c, _ = _rgb_to_hcl(*_to_rgb(col))
-    return h, c
+    """Hue and chroma of a color in CIE Luv, as R's .getHC() reads
+    them with grDevices::convertColor(from="sRGB", to="Luv")."""
+    import math
+    import numpy as np
+    r, g, b = (v / 255 for v in _to_rgb(col))
+    lin = [v / 12.92 if v <= 0.04045 else ((v + 0.055) / 1.055) ** 2.4
+           for v in (r, g, b)]
+    M, (Xn, Yn, Zn) = _srgb_to_luv_matrix()
+    X, Y, Z = M @ np.array(lin)
+    yr = Y / Yn
+    eps, kappa = 216 / 24389, 24389 / 27
+    L = 116 * yr ** (1 / 3) - 16 if yr > eps else kappa * yr
+    den, den_n = X + 15 * Y + 3 * Z, Xn + 15 * Yn + 3 * Zn
+    if den == 0:
+        return 0.0, 0.0
+    u = 13 * L * (4 * X / den - 4 * Xn / den_n)
+    v = 13 * L * (9 * Y / den - 9 * Yn / den_n)
+    return math.degrees(math.atan2(v, u)) % 360, math.hypot(u, v)
+
+
+# hue of each theme. R analog: .get.h()
+_THEME_HUE = {"gray": 0, "white": 0, "colors": 240, "lightbronze": 240,
+              "dodgerblue": 240, "blue": 240, "gold": 60, "brown": 60,
+              "sienna": 60, "orange": 30, "darkred": 0, "red": 0,
+              "rose": 0, "slatered": 0, "darkgreen": 120, "green": 120,
+              "purple": 300}
 
 
 def bar_fill_colors(values, fill, fill_split, fill_scaled,
-                    fill_chroma=75):
+                    fill_chroma=75, theme=None):
     """Per-bar fill colors for a numeric bar chart, keyed to the bar
     values. fill_split gives a two-color split at that value (below
     -> first color, above -> second). fill_scaled makes an HCL
     gradient: chroma and darkness rise with distance from the split
     (default 0), hue by side. A faithful approximation of R's
-    .scale.clr, not colorspace-exact. R analog: fill_split /
-    fill_scaled."""
+    .scale.clr: with no fill, the theme's hue at fill_chroma (gray
+    for the gray and white themes); with one fill color, that
+    color's hue and chroma, the luminance alone varying. R analog:
+    fill_split / fill_scaled, .scale.clr()"""
     import numpy as np
     from .plotly_utils import to_hex
     x = np.asarray(values, dtype=float)
@@ -184,12 +232,17 @@ def bar_fill_colors(values, fill, fill_split, fill_scaled,
     normed = dist / mx
     lum = 27 + (1 - normed) * 53           # near split light, far dark
 
-    if fills is None or len(fills) > 2:
-        h1 = h2 = 255.0
-        c1 = c2 = float(fill_chroma)
-    elif len(fills) == 1:
-        h1, c1 = _color_hc(fills[0])
-        h2, c2 = h1, c1
+    if fills is None or len(fills) > 2 or len(fills) == 1:
+        # one hue and chroma for every bar, only the luminance
+        #   following the value, as R's .scale.clr()
+        if fills is None or len(fills) > 2:
+            gray = theme in ("gray", "white")
+            hue = 0.0 if gray else float(_THEME_HUE.get(theme or
+                                                        "colors", 240))
+            chroma = 0.0 if gray else float(fill_chroma)
+        else:
+            hue, chroma = _color_hc(fills[0])
+        return [hcl(hue, chroma, L) for L in lum]
     else:
         h1, c1 = _color_hc(fills[0])
         h2, c2 = _color_hc(fills[1])
@@ -227,18 +280,185 @@ def _ramp(colors, n):
     return out
 
 
+# grDevices .hcl_colors_parameters for the viridis family that lessR
+#   draws from hcl.colors(): type, h1 h2 h3, c1 c2 c3, l1 l2 l3,
+#   p1 p2 p3 p4, cmax1 cmax2 (None = NA)
+_HCL_PARAMS = {
+    "viridis": ("sequential", 300, 75, None, 40, 95, None, 15, 90,
+                None, 1.0, 1.1, None, None, None, None),
+    "plasma": ("sequential", -100, 100, None, 60, 100, None, 15, 95,
+               None, 2.0, 0.9, None, None, None, None),
+    "inferno": ("sequential", -100, 85, None, 0, 65, None, 1, 98,
+                None, 1.1, 0.9, None, None, 120, None),
+    "cividis": ("divergingx", 255, None, 75, 30, 0, 95, 13, 52, 92,
+                1.1, 1.0, 1, None, 47, None),
+    "spectral": ("divergingx", 0, 85, 270, 90, 45, 65, 37, 98, 37,
+                 1, 1.2, 1, 1.2, 120, None),
+}
+
+
+def _hcl_seq(i, h1, h2, c1, c2, l1, l2, p1, p2, cmax):
+    """grDevices hcl.colors() seqhcl: hue linear, chroma linear or
+    triangular through cmax, luminance by power."""
+    def lin(t, a, b):
+        return b - (b - a) * t
+    j = None
+    if cmax is not None:
+        try:
+            j = 1 / (1 + abs(cmax - c1) / abs(cmax - c2))
+        except ZeroDivisionError:
+            j = None
+        if j is not None and (j <= 0 or j >= 1):
+            j = None
+    out = []
+    for t in i:
+        tp = t ** p1
+        if j is None:
+            c = lin(tp, c1, c2)
+        elif tp <= j:
+            c = c2 - (c2 - cmax) * tp / j
+        else:
+            c = cmax - (cmax - c1) * abs((tp - j) / (1 - j))
+        out.append(hcl(lin(t, h1, h2), c, lin(t ** p2, l1, l2)))
+    return out
+
+
 def _viridis(name, n):
-    from plotly.colors import sample_colorscale
-    xs = [0.0] if n == 1 else [i / (n - 1) for i in range(n)]
-    cols = sample_colorscale(_VIRIDIS[name], xs, colortype="rgb")
+    """n colors of a viridis-family palette exactly as R's
+    hcl.colors(n, name). R analog: grDevices::hcl.colors()"""
+    (typ, h1, h2, h3, c1, c2, c3, l1, l2, l3,
+     p1, p2, p3, p4, cmax1, cmax2) = _HCL_PARAMS[name]
+    if typ == "sequential":
+        h2 = h1 if h2 is None else h2
+        c2 = 0 if c2 is None else c2
+        p2 = p1 if p2 is None else p2
+        i = [1.0] if n == 1 else [1 - k / (n - 1) for k in range(n)]
+        return _hcl_seq(i, h1, h2, c1, c2, l1, l2, p1, p2, cmax1)
+    # divergingx: two sequential arms meeting at the center
+    p2 = p1 if p2 is None else p2
+    p4 = p2 if p4 is None else p4
+    n2 = -(-n // 2)
+    i = [0.0] if n == 1 else [1 - k * 2 / (n - 1) for k in range(n2)]
+    left = _hcl_seq(i, h1, h1 if h2 is None else h2, c1, c2, l1, l2,
+                    p1, p2, cmax1)
+    right = _hcl_seq(i, h3, h3 if h2 is None else h2, c3, c2, l3, l2,
+                     p3, p4, cmax2)
+    col = left + right[::-1]
+    if n // 2 < n2:
+        del col[n2 - 1]
+    return col
+
+
+# --- R's own palettes: grDevices HSV and colorspace HCL ------------
+
+def _hsv(h, s, v):
+    """One HSV color as hex, as grDevices hsv(): R's hsv2rgb() and
+    its rounding of each channel, (int)(255 * x + 0.5)."""
+    if s == 0:
+        r = g = b = v
+    else:
+        t = 6 * math.fmod(h, 1.0)
+        i = math.floor(t)
+        f = t - i
+        p, q, u = v * (1 - s), v * (1 - s * f), v * (1 - s * (1 - f))
+        r, g, b = [(v, u, p), (q, v, p), (p, v, u),
+                   (p, q, v), (u, p, v), (v, p, q)][int(i) % 6]
+    return "#{:02X}{:02X}{:02X}".format(
+        *(int(255 * x + 0.5) for x in (r, g, b)))
+
+
+def _seq_int(a, b, n):
+    """seq.int(a, b, length.out=n)"""
+    if n == 1:
+        return [a]
+    by = (b - a) / (n - 1)
+    return [a + k * by for k in range(n)]
+
+
+def _rainbow(n, start=0.0, end=None):
+    """grDevices rainbow(): HSV hues from start to end."""
+    if end is None:
+        end = max(1, n - 1) / n
+    hs = _seq_int(start, (1 if start > end else 0) + end, n)
+    return [_hsv(math.fmod(h, 1.0), 1, 1) for h in hs]
+
+
+def _heat(n):
+    """grDevices heat.colors(): red to yellow, then the yellows
+    lighten for the last quarter."""
+    j = n // 4
+    i = n - j
+    cols = _rainbow(i, 0, 1 / 6)
+    if j > 0:
+        cols += [_hsv(1 / 6, s, 1)
+                 for s in _seq_int(1 - 1 / (2 * j), 1 / (2 * j), j)]
+    return cols
+
+
+def _terrain(n):
+    """grDevices terrain.colors(): green to yellow to near white."""
+    k = n // 2
+    h, s, v = (4 / 12, 2 / 12, 0 / 12), (1, 1, 0), (0.65, 0.9, 0.95)
+    first = [_hsv(a, b, c) for a, b, c in zip(
+        _seq_int(h[0], h[1], k), _seq_int(s[0], s[1], k),
+        _seq_int(v[0], v[1], k))] if k > 0 else []
+    m = n - k + 1
+    second = [_hsv(a, b, c) for a, b, c in zip(
+        _seq_int(h[1], h[2], m)[1:], _seq_int(s[1], s[2], m)[1:],
+        _seq_int(v[1], v[2], m)[1:])]
+    return first + second
+
+
+def _colorspace_seq(n, h, c, l, power):
+    """colorspace sequential_hcl() with explicit pairs: h, c, l,
+    power each (first, last). Hue moves linearly, chroma and
+    luminance by their powers, as colorspace seqhcl()."""
     out = []
-    for c in cols:
-        r, g, b = (round(float(v)) for v in
-                   c[c.find("(") + 1:c.find(")")].split(","))
-        out.append("#{:02X}{:02X}{:02X}".format(r, g, b))
+    for i in _seq_int(1.0, 0.0, n):
+        H = h[1] - (h[1] - h[0]) * i
+        C = c[1] - (c[1] - c[0]) * i ** power[0]
+        L = l[1] - (l[1] - l[0]) * i ** power[1]
+        out.append(hcl(H, C, L))
     return out
 
 
+# colorspace's heat_hcl() and terrain_hcl(): h, c., l, power pairs
+_CS_SEQ = {
+    "heat_hcl": ((0, 90), (100, 30), (50, 90), (1 / 5, 1)),
+    "terrain_hcl": ((130, 0), (80, 0), (60, 95), (1 / 10, 1)),
+}
+
+
+def _pair(v):
+    return tuple(v) if isinstance(v, (tuple, list)) else None
+
+
+def _seq_r(name, n, c, l):
+    """n colors of one of R's own palettes, as lessR's getColors()
+    computes them. "heat_hcl" and "terrain_hcl" follow colorspace's
+    own chroma and luminance trajectories, replaced only by a c or l
+    given: a single c ramps from c to 0, a single l is constant, as
+    colorspace reads them. "rainbow_hcl" is lessR's qualitative c=65
+    and l=60 unless given. R analog: getColors(), kind seq.R"""
+    if name == "rainbow":
+        return _rainbow(n)
+    if name == "heat":
+        return _heat(n)
+    if name == "terrain":
+        return _terrain(n)
+    if name == "rainbow_hcl":            # colorspace qualitative_hcl
+        c = 65 if c is None else c
+        l = 60 if l is None else l
+        hs = _seq_int(0, 360 * (n - 1) / n, n)
+        return [hcl(h, c, l) for h in hs]
+    h, cc, ll, p = _CS_SEQ[name]
+    if c is not None:
+        cc = _pair(c) or (c, 0)
+    if l is not None:
+        ll = _pair(l) or (l, l)
+    return _colorspace_seq(n, h, cc, ll, p)
+
+
 # the fixed mixed hues for a qualitative palette (n <= 24)
 _MIX = [240, 60, 120, 0, 275, 180, 30, 90, 210, 330, 150, 300]
 
@@ -251,7 +471,8 @@ def getColors(pal=None, end_pal=None, n=None, h=0, h2=None, c=None,
 
     pal: a palette name ("hues", a sequential name such as "blues",
     "viridis"/"cividis"/"plasma"/"spectral", "Okabe-Ito", "Tableau",
-    "distinct") or one or more explicit colors. end_pal: an ending
+    "distinct", R's "rainbow"/"heat"/"terrain" and their "_hcl"
+    versions) or one or more explicit colors. end_pal: an ending
     color/name for a divergent (two sequential names) or manual
     (two colors) gradient. h/h2, c, l, power: HCL parameters.
     R analog: getColors()"""
@@ -284,6 +505,8 @@ def getColors(pal=None, end_pal=None, n=None, h=0, h2=None, c=None,
             kind = "divergent" if (end_pal is not None and
                                    end_pal[0] in _SEQ_NAMES) \
                 else "sequential"
+        elif p0 in _SEQ_R:
+            kind = "seq.R"
         elif p0 == "hues":
             kind = "qualitative"
         elif p0 in _VIRIDIS:
@@ -350,6 +573,10 @@ def getColors(pal=None, end_pal=None, n=None, h=0, h2=None, c=None,
         pw = 0.75 if power is None else power
         pal = _diverging_hcl(n, h, h2, cc, ll, pw, fixup)
 
+    elif kind == "seq.R":
+        pal = _seq_r(pal[0], n, None if c_miss else c,
+                     None if l_miss else l)
+
     elif kind == "viridis":
         ttl = "Viridis Style Palette: " + pal[0]
         pal = _viridis(pal[0], n)