lessPython 0.1.0__py3-none-any.whl

lessPy/corRead.py

@@ -0,0 +1,48 @@
+# corRead.py — analog of corRead.R.
+#
+# corRead(): read a correlation matrix from a text file that
+# holds only the coefficients — no header row, no row labels,
+# whitespace- (or sep-) delimited. Validates that the values are
+# numeric and the matrix is square, then labels the rows/columns
+# from var_names, or X1..Xn by default. Returns the matrix as a
+# DataFrame, ready for corEFA / corCFA / corScree, etc.
+
+import numpy as np
+import pandas as pd
+
+
+def corRead(file=None, var_names=None, sep=None):
+    """Read a square correlation matrix of coefficients (no
+    header, no row labels) from a text file, whitespace-delimited
+    unless sep= is given. Names the variables from var_names, or
+    X1..Xn. Returns the matrix as a DataFrame. R analog: corRead()
+    (its `from` argument is this `file`; there is no interactive
+    file chooser)."""
+    if file is None:
+        raise ValueError(
+            "file= is required: the path to a text file of "
+            "correlation coefficients (Python has no interactive "
+            "file chooser)")
+    df = pd.read_csv(file, sep=r"\s+" if sep is None else sep,
+                     header=None, engine="python")
+    if not all(pd.api.types.is_numeric_dtype(df[c])
+               for c in df.columns):
+        raise ValueError(
+            "the correlation matrix must be numeric; the file "
+            "has non-numeric values. Check that it contains only "
+            "coefficients, with no variable names or row labels.")
+    myc = df.to_numpy(dtype=float)
+    if myc.shape[0] != myc.shape[1]:
+        raise ValueError(
+            "the correlation matrix must be square; the read "
+            f"matrix is {myc.shape[0]} x {myc.shape[1]}.")
+    n = myc.shape[1]
+    if var_names is not None:
+        if len(var_names) != n:
+            raise ValueError(
+                f"var_names length ({len(var_names)}) must equal "
+                f"the number of variables ({n}).")
+        names = [str(v) for v in var_names]
+    else:
+        names = [f"X{i}" for i in range(1, n + 1)]
+    return pd.DataFrame(myc, index=names, columns=names)

lessPy/corReflect.py

@@ -0,0 +1,72 @@
+# corReflect.py — analog of corReflect.R.
+#
+# corReflect(): reverse the sign of the correlations of the named
+# variables, to flip reverse-scored items so they correlate
+# positively with the rest of a scale. Reflecting a variable
+# negates all its off-diagonal correlations; reflecting two of
+# them leaves their mutual correlation unchanged (it flips twice).
+# Returns the reflected correlation matrix; the heat map is on the
+# returned frame's .attrs["plots"].
+
+import numpy as np
+import pandas as pd
+
+from .utils import get_option
+
+
+def corReflect(R, vars, main=None, heat_map=True):
+    """Reflect (negate) the correlations of the variables named
+    in vars within the correlation matrix R (a DataFrame or
+    array; raw data is correlated first). Returns the reflected
+    correlation-matrix DataFrame; its .attrs["plots"] holds the
+    heat map. R analog: corReflect()"""
+    Rm = pd.DataFrame(R)
+    vals = Rm.to_numpy(dtype=float)
+    if (Rm.shape[0] != Rm.shape[1]
+            or not np.allclose(vals, vals.T, atol=1e-8)):
+        Rm = Rm.select_dtypes("number").corr()
+    Rm.index = Rm.columns = [str(c) for c in Rm.columns]
+    names = list(Rm.columns)
+    vars = [vars] if isinstance(vars, str) else list(vars)
+    bad = [str(v) for v in vars if str(v) not in names]
+    if bad:
+        raise ValueError(
+            f"variables not in the matrix: {', '.join(bad)}")
+
+    # sign vector: -1 for a reflected variable. The outer product
+    # negates each reflected variable's off-diagonal row/col and
+    # leaves the diagonal (sign^2 = 1) and any pair of reflected
+    # variables (two flips) unchanged. ~ corReflect.R loop
+    s = np.ones(len(names))
+    for v in vars:
+        s[names.index(str(v))] = -1.0
+    out = pd.DataFrame(np.outer(s, s) * Rm.to_numpy(dtype=float),
+                       index=Rm.index, columns=Rm.columns)
+
+    plots = {}
+    if heat_map:
+        plots["heatmap"] = _heatmap(out, main)
+    out.attrs["plots"] = plots
+    return out
+
+
+def _heatmap(df, main):
+    import plotly.graph_objects as go
+
+    from .plotly_utils import plotly_style, to_hex
+    labels = list(df.columns)
+    Z = df.to_numpy(dtype=float).copy()
+    np.fill_diagonal(Z, np.nan)
+    style = plotly_style()
+    fig = go.Figure(go.Heatmap(
+        z=Z, x=labels, y=labels, zmin=-1, zmax=1,
+        colorscale="RdBu", reversescale=True,
+        colorbar=dict(title="r")))
+    fig.update_yaxes(autorange="reversed")
+    fig.update_layout(
+        template=None, paper_bgcolor=to_hex(style["window_fill"]),
+        title=dict(text=main or "With Reflected Item Coefficients",
+                   x=0.5, xanchor="center",
+                   font=dict(size=round(
+                       16 * get_option("main_size", 1)))))
+    return fig

lessPy/corReorder.py

@@ -0,0 +1,161 @@
+# corReorder.py — analog of corReorder.R.
+#
+# corReorder(): reorder the variables of a correlation matrix so
+# that related variables are adjacent, by hierarchical clustering
+# (the default), the Hunter (1973) chaining algorithm, a manual
+# order, or as-is. Returns the reordered correlation matrix (a
+# DataFrame); the heat map and, for hclust, the dendrogram are on
+# the returned frame's .attrs["plots"]. Useful before corCFA or a
+# heat map, to reveal the cluster structure.
+
+import numpy as np
+import pandas as pd
+
+from .utils import get_option
+
+# R hclust method -> scipy linkage method. scipy 'ward' is R's
+# ward.D2 (squared updates); ward.D has no scipy equivalent, so
+# it maps to ward with a note. 'weighted' is R's mcquitty.
+_LINKAGE = {"complete": "complete", "single": "single",
+            "average": "average", "mcquitty": "weighted",
+            "centroid": "centroid", "median": "median",
+            "ward.D2": "ward", "ward.D": "ward"}
+
+
+def corReorder(R, order="hclust", hclust_type="complete",
+               dist_type="R", n_clusters=None, vars=None,
+               chain_first=0, heat_map=True, dendrogram=True,
+               diagonal_new=True, main=None):
+    """Reorder the variables of a correlation matrix R (a
+    DataFrame or array; raw data is correlated first).
+    order="hclust" (default), "chain", "manual" (vars=[...]), or
+    "as_is". Returns the reordered correlation-matrix DataFrame;
+    its .attrs["plots"] holds the heat map (and dendrogram).
+    R analog: corReorder()"""
+    if order not in ("hclust", "chain", "manual", "as_is"):
+        raise ValueError('order: "hclust", "chain", "manual", '
+                         '"as_is"')
+    Rm = pd.DataFrame(R)
+    vals = Rm.to_numpy(dtype=float)
+    if (Rm.shape[0] != Rm.shape[1]
+            or not np.allclose(vals, vals.T, atol=1e-8)):
+        Rm = Rm.select_dtypes("number").corr()
+    Rm.index = Rm.columns = [str(c) for c in Rm.columns]
+    S = Rm.to_numpy(dtype=float)
+    names = list(Rm.columns)
+    nv = len(names)
+    if vars is not None:
+        order = "manual"
+
+    Z = None
+    if order == "manual":
+        label = [names.index(str(v)) for v in vars]
+    elif order == "as_is":
+        diagonal_new = False
+        label = list(range(nv))
+    elif order == "chain":
+        label = _chain(S, nv, int(chain_first))
+    else:                                  # hclust
+        label, Z = _hclust(S, hclust_type, dist_type, n_clusters,
+                           names)
+
+    out = Rm.iloc[label, label]
+    plots = {}
+    if heat_map:
+        plots["heatmap"] = _heatmap(out, diagonal_new, main)
+    if order == "hclust" and dendrogram and Z is not None:
+        try:
+            plots["dendrogram"] = _dendrogram(Z, names, label)
+        except Exception:                  # optional; skip if it fails
+            pass
+    out.attrs["plots"] = plots
+    out.attrs["order"] = label
+    return out
+
+
+def _chain(S, nv, first):
+    """Hunter (1973) chaining: start with the variable of largest
+    summed squared correlation (or the user's chain_first), then
+    repeatedly append the unselected variable most correlated (in
+    absolute value) with the last one. ~ corReorder.R chain."""
+    if first == 0:
+        first = int(np.argmax((S ** 2).sum(axis=1)))
+    else:
+        first = first - 1                  # 1-based -> 0-based
+    label = [first]
+    remaining = set(range(nv)) - {first}
+    while remaining:
+        k = label[-1]
+        nxt = max(remaining, key=lambda j: abs(S[k, j]))
+        label.append(nxt)
+        remaining.discard(nxt)
+    return label
+
+
+def _hclust(S, method, dist_type, n_clusters, names):
+    from scipy.cluster.hierarchy import (
+        fcluster, leaves_list, linkage)
+    from scipy.spatial.distance import squareform
+    if method not in _LINKAGE:
+        raise ValueError(f"hclust_type: {', '.join(_LINKAGE)}")
+    D = S if dist_type == "dist" else 1 - S
+    cond = squareform(D, checks=False)
+    Z = linkage(cond, method=_LINKAGE[method])
+    label = leaves_list(Z).tolist()
+    if n_clusters is not None:
+        cl = fcluster(Z, t=n_clusters, criterion="maxclust")
+        # renumber clusters by first appearance in the original
+        # variable order, as R's cutree
+        seen = {}
+        cl = [seen.setdefault(c, len(seen) + 1) for c in cl]
+        ttl = f"{n_clusters} Cluster Solution"
+        print(f"\n{ttl}\n" + "-" * len(ttl))
+        for nm, c in sorted(zip(names, cl), key=lambda p: p[1]):
+            print(f"{nm}: {c}")
+    return label, Z
+
+
+def _apply_diag(M):
+    """Replace the diagonal with the average of its adjacent
+    off-diagonal values, for a cleaner heat map. ~ diagonal_new."""
+    nv = M.shape[0]
+    D = M.copy()
+    if nv >= 2:
+        D[0, 0] = M[0, 1]
+        for i in range(1, nv - 1):
+            D[i, i] = round((M[i, i - 1] + M[i, i + 1]) / 2, 2)
+        D[nv - 1, nv - 1] = M[nv - 1, nv - 2]
+    return D
+
+
+def _heatmap(df, diagonal_new, main):
+    import plotly.graph_objects as go
+    from .plotly_utils import plotly_style, to_hex
+    Z = df.to_numpy(dtype=float).copy()
+    if diagonal_new:
+        Z = _apply_diag(Z)
+    labels = list(df.columns)
+    style = plotly_style()
+    fig = go.Figure(go.Heatmap(
+        z=Z, x=labels, y=labels, zmin=-1, zmax=1,
+        colorscale="RdBu", reversescale=True,
+        colorbar=dict(title="r")))
+    fig.update_yaxes(autorange="reversed")
+    fig.update_layout(
+        template=None, paper_bgcolor=to_hex(style["window_fill"]),
+        title=dict(text=main or "Reordered Correlations", x=0.5,
+                   xanchor="center",
+                   font=dict(size=round(
+                       16 * get_option("main_size", 1)))))
+    return fig
+
+
+def _dendrogram(Z, names, label):
+    from plotly.figure_factory import create_dendrogram
+    fig = create_dendrogram(
+        np.zeros((len(names), 1)), labels=names,
+        linkagefun=lambda _x: Z)
+    fig.update_layout(
+        title=dict(text="Cluster Dendrogram", x=0.5,
+                   xanchor="center"))
+    return fig

lessPy/corScree.py

@@ -0,0 +1,87 @@
+# corScree.py — analog of corScree.R.
+#
+# corScree(): the scree plots for deciding the number of factors
+# — the eigenvalues of a correlation matrix against their index,
+# and the differences of successive eigenvalues. Prints both
+# sequences and returns them with the two plotly figures.
+
+import numpy as np
+import pandas as pd
+
+from .plotly_utils import (
+    axis_format, axis_num, plot_border, plotly_style, to_hex,
+    x_grid)
+from .utils import fmt, get_option, pretty
+
+
+class corScreeResults:
+    """Results of corScree(): the eigenvalues, the differences of
+    successive eigenvalues, and the two plotly figures in
+    .plots."""
+
+    def __init__(self, **kw):
+        self.__dict__.update(kw)
+
+    def __repr__(self):
+        return f"<lessPy corScree: {len(self.eigenvalues)} vars>"
+
+
+def corScree(R, main=None):
+    """Scree analysis of a correlation matrix R (a DataFrame or
+    array; raw data is correlated first): its eigenvalues and
+    their successive differences, each printed and plotted.
+    Returns a corScreeResults with the figures in .plots.
+    R analog: corScree()"""
+    Rm = pd.DataFrame(R)
+    vals = Rm.to_numpy(dtype=float)
+    if (Rm.shape[0] != Rm.shape[1]
+            or not np.allclose(vals, vals.T, atol=1e-8)):
+        Rm = Rm.select_dtypes("number").corr()
+    S = Rm.to_numpy(dtype=float)
+
+    ev = np.linalg.eigvalsh(S)[::-1]       # descending
+    ev_diff = ev[:-1] - ev[1:]             # -diff(ev)
+
+    def line(seq):
+        return " ".join(fmt(v, 3) for v in seq)
+
+    print("\nEigenvalues\n" + "-" * 11 + "\n" + line(ev)
+          + "\n\nDifferences of Successive Eigenvalues\n"
+          + "-" * 37 + "\n" + line(ev_diff) + "\n")
+
+    plots = {
+        "scree": _scree_plot(ev, "Eigenvalues", main),
+        "differences": _scree_plot(
+            ev_diff, "Differences of Successive Eigenvalues",
+            main)}
+    return corScreeResults(eigenvalues=ev, differences=ev_diff,
+                           plots=plots)
+
+
+def _scree_plot(y, y_lab, main):
+    """A line-with-markers plot of y against its 1-based index.
+    ~ .plt.main segments plot in corScree.R"""
+    import plotly.graph_objects as go
+    style = plotly_style()
+    x = np.arange(1, len(y) + 1)
+    col = to_hex(get_option("fit_color", "#5C4032"))
+    fig = go.Figure(go.Scatter(
+        x=x, y=y, mode="lines+markers",
+        line=dict(color=col, width=1.5),
+        marker=dict(size=7, color=col), hoverinfo="x+y",
+        showlegend=False))
+    axT2 = pretty(float(min(y.min(), 0)), float(y.max()))
+    ax_x = axis_num("Index", list(x), [str(i) for i in x])
+    ax_y = axis_num(y_lab, axT2, axis_format(axT2, 2))
+    ax_y.update(showgrid=True,
+                gridcolor=to_hex(style["grid_col"]),
+                gridwidth=1, griddash="dot")
+    fig.update_layout(
+        xaxis=ax_x, yaxis=ax_y,
+        shapes=x_grid(list(x)) + plot_border(), template=None,
+        plot_bgcolor=to_hex(style["panel_fill"]),
+        paper_bgcolor=to_hex(style["window_fill"]),
+        title=dict(text=main or "", x=0.5, xanchor="center",
+                   font=dict(size=round(
+                       16 * get_option("main_size", 1)))))
+    return fig

lessPy/data/Anova_1way.csv

@@ -0,0 +1,25 @@
+"Dosage","Time"
+"00mg",25.6
+"00mg",25.8
+"00mg",25.5
+"00mg",23.3
+"00mg",26.5
+"00mg",26
+"00mg",18.4
+"00mg",23
+"05mg",23.4
+"05mg",21.9
+"05mg",24.8
+"05mg",24
+"05mg",28.2
+"05mg",25.2
+"05mg",19
+"05mg",20.8
+"10mg",24.2
+"10mg",19
+"10mg",16.4
+"10mg",19.4
+"10mg",18.5
+"10mg",20.1
+"10mg",13.1
+"10mg",11.9

lessPy/data/Anova_2way.csv

@@ -0,0 +1,49 @@
+"Difficulty","Dosage","Time"
+"Easy","00mg",25.6
+"Easy","00mg",25.8
+"Easy","00mg",25.5
+"Easy","00mg",23.3
+"Easy","00mg",26.5
+"Easy","00mg",26
+"Easy","00mg",18.4
+"Easy","00mg",23
+"Easy","05mg",23.4
+"Easy","05mg",21.9
+"Easy","05mg",24.8
+"Easy","05mg",24
+"Easy","05mg",28.2
+"Easy","05mg",25.2
+"Easy","05mg",19
+"Easy","05mg",20.8
+"Easy","10mg",24.2
+"Easy","10mg",19
+"Easy","10mg",16.4
+"Easy","10mg",19.4
+"Easy","10mg",18.5
+"Easy","10mg",20.1
+"Easy","10mg",13.1
+"Easy","10mg",11.9
+"Hard","00mg",40.5
+"Hard","00mg",36
+"Hard","00mg",26.7
+"Hard","00mg",41.3
+"Hard","00mg",36.2
+"Hard","00mg",32.8
+"Hard","00mg",34.2
+"Hard","00mg",30.1
+"Hard","05mg",40.3
+"Hard","05mg",36
+"Hard","05mg",31.8
+"Hard","05mg",32.2
+"Hard","05mg",28.4
+"Hard","05mg",32.2
+"Hard","05mg",25.4
+"Hard","05mg",27.4
+"Hard","10mg",46.7
+"Hard","10mg",38.5
+"Hard","10mg",32.8
+"Hard","10mg",39
+"Hard","10mg",40.8
+"Hard","10mg",34.7
+"Hard","10mg",39.3
+"Hard","10mg",43

lessPy/data/Anova_rb.csv

@@ -0,0 +1,8 @@
+"Person","sup1","sup2","sup3","sup4"
+"p1",2,4,4,3
+"p2",2,5,4,6
+"p3",8,6,7,9
+"p4",4,3,5,7
+"p5",2,1,2,3
+"p6",5,5,6,8
+"p7",2,3,2,4

lessPy/data/Anova_rbf.csv

@@ -0,0 +1,49 @@
+"Difficulty","Dosage","Block","Time"
+"Easy","mg00","Blck1",25.6
+"Easy","mg05","Blck1",23.4
+"Easy","mg10","Blck1",24.2
+"Hard","mg00","Blck1",40.5
+"Hard","mg05","Blck1",40.3
+"Hard","mg10","Blck1",46.7
+"Easy","mg00","Blck2",25.8
+"Easy","mg05","Blck2",21.9
+"Easy","mg10","Blck2",19
+"Hard","mg00","Blck2",36
+"Hard","mg05","Blck2",36
+"Hard","mg10","Blck2",38.5
+"Easy","mg00","Blck3",25.5
+"Easy","mg05","Blck3",24.8
+"Easy","mg10","Blck3",16.4
+"Hard","mg00","Blck3",26.7
+"Hard","mg05","Blck3",31.8
+"Hard","mg10","Blck3",32.8
+"Easy","mg00","Blck4",23.3
+"Easy","mg05","Blck4",24
+"Easy","mg10","Blck4",19.4
+"Hard","mg00","Blck4",41.3
+"Hard","mg05","Blck4",32.2
+"Hard","mg10","Blck4",39
+"Easy","mg00","Blck5",26.5
+"Easy","mg05","Blck5",28.2
+"Easy","mg10","Blck5",18.5
+"Hard","mg00","Blck5",36.2
+"Hard","mg05","Blck5",28.4
+"Hard","mg10","Blck5",40.8
+"Easy","mg00","Blck6",26
+"Easy","mg05","Blck6",25.2
+"Easy","mg10","Blck6",20.1
+"Hard","mg00","Blck6",32.8
+"Hard","mg05","Blck6",32.2
+"Hard","mg10","Blck6",34.7
+"Easy","mg00","Blck7",18.4
+"Easy","mg05","Blck7",19
+"Easy","mg10","Blck7",13.1
+"Hard","mg00","Blck7",34.2
+"Hard","mg05","Blck7",25.4
+"Hard","mg10","Blck7",39.3
+"Easy","mg00","Blck8",23
+"Easy","mg05","Blck8",20.8
+"Easy","mg10","Blck8",11.9
+"Hard","mg00","Blck8",30.1
+"Hard","mg05","Blck8",27.4
+"Hard","mg10","Blck8",43

lessPy/data/Anova_sp.csv

@@ -0,0 +1,57 @@
+"Person","Food","Supplement","Reps"
+"p1","Hi","sup1",2
+"p1","Hi","sup2",4
+"p1","Hi","sup3",4
+"p1","Hi","sup4",3
+"p2","Hi","sup1",2
+"p2","Hi","sup2",5
+"p2","Hi","sup3",4
+"p2","Hi","sup4",6
+"p3","Hi","sup1",8
+"p3","Hi","sup2",6
+"p3","Hi","sup3",7
+"p3","Hi","sup4",9
+"p4","Hi","sup1",4
+"p4","Hi","sup2",3
+"p4","Hi","sup3",5
+"p4","Hi","sup4",7
+"p5","Hi","sup1",2
+"p5","Hi","sup2",1
+"p5","Hi","sup3",2
+"p5","Hi","sup4",3
+"p6","Hi","sup2",5
+"p6","Hi","sup1",5
+"p6","Hi","sup3",6
+"p6","Hi","sup4",8
+"p7","Hi","sup1",2
+"p7","Hi","sup2",3
+"p7","Hi","sup3",2
+"p7","Hi","sup4",4
+"p1","Low","sup1",2
+"p1","Low","sup2",2
+"p1","Low","sup3",3
+"p1","Low","sup4",3
+"p2","Low","sup1",1
+"p2","Low","sup2",4
+"p2","Low","sup3",3
+"p2","Low","sup4",4
+"p3","Low","sup1",6
+"p3","Low","sup2",3
+"p3","Low","sup3",7
+"p3","Low","sup4",8
+"p4","Low","sup1",2
+"p4","Low","sup2",3
+"p4","Low","sup3",4
+"p4","Low","sup4",5
+"p5","Low","sup1",1
+"p5","Low","sup2",1
+"p5","Low","sup3",2
+"p5","Low","sup4",3
+"p6","Low","sup2",5
+"p6","Low","sup1",5
+"p6","Low","sup3",7
+"p6","Low","sup4",8
+"p7","Low","sup1",3
+"p7","Low","sup2",2
+"p7","Low","sup3",2
+"p7","Low","sup4",4