biplotpy 0.4.0__py3-none-any.whl

biplotpy/__init__.py

@@ -0,0 +1,69 @@
+"""biplotpy: biplot methods of the Salamanca school for Python.
+
+Classical biplots (GH, JK, SQRT and HJ-Biplot), canonical/MANOVA biplot with
+confidence circles and MANOVA tests, bootstrap of the PCA biplot,
+supplementary variables and calibrated axes; logistic biplots (binary,
+ordinal, nominal), STATIS-ACT, dual and canonical STATIS, dynamic biplot,
+metric unfolding, GGE and AMMI; DISTATIS and CDPCA; Mardia's test,
+heteroscedastic MANOVA (WTS/MATS with bootstrap) and HE plots (one or several
+factors); constrained logistic biplots (binary and ordinal), external ordinal
+logistic biplot, PLS regression with binary responses (PLSR1Bin, BinaryPLSR),
+log-frequency biplot, bootstrap of principal coordinates and of MDS. Ported from the R package
+MultBiplotR (Vicente-Villardón, Vicente-González and Frutos-Bernal) and
+validated numerically against it.
+"""
+from .transforms import initial_transform, TRANSFORMS, FIXES
+from .classical import ContinuousBiplot, pca_biplot, hj_biplot, gh_biplot, jk_biplot, sqrt_biplot
+from .canonical import CanonicalBiplot, canonical_biplot, canonical_variate_analysis
+from .extras import pca_bootstrap, add_continuous_variables, project_rows, biplot_scales, calibrated_axis
+from .utils import r_pretty, matrix_sqrt
+from .datasets import load_iris, load_mtcars
+from .logistic import (LogisticBiplot, binary_logistic_biplot, ordinal_logistic_biplot, ordinal_logistic_fit,
+                       nominal_logistic_biplot, nominal_logistic_fit)
+from .statis import StatisResult, statis, dual_statis, canonical_statis
+from .dynamic import dynamic_biplot
+from .unfolding import unfolding
+from .gxe import gge_model, ammi
+from .multitest import (mardia, manova_wts, he_matrices, he_ellipses, he_plot, roy_crit, hlt_crit, manova_terms,
+                        he_plot_terms)
+from .restricted import (constrained_logistic_biplot, constrained_ordinal_logistic_biplot,
+                         external_ordinal_logistic_biplot, ridge_ordinal_logistic)
+from .plsbin import plsr1_bin, binary_plsr
+from .logfreq import criss_cross, log_frequency_biplot
+from .bootdist import OrdinationBootstrap, bootstrap_pcoa, bootstrap_mds, simple_procrustes
+from .rrng import RRNG
+from .roptim import optim_cg
+from .distatis import distatis
+from .cdpca import cdpca
+from .correspondence import OrdinationBiplot, ca, mca, cca, rda, indicator_matrix
+from .distances import (binary_distances, binary_similarity, continuous_distances, gower_distances, pcoa, mds,
+                        ridge_logistic, external_logistic_biplot, canonical_distance_analysis)
+from .factor import (rotate, fa_biplot, nipals, nipals_biplot, pls_regression, pls_biplot, coinertia, polychoric,
+                     polychoric_biplot)
+from .plot import (plot_biplot, plot_canonical, plot_correlation_circle, plot_scree, plot_contributions,
+                   plot_biplot_3d, plot_bootstrap, plot_logistic, plot_nominal_regions, plot_statis, plot_dynamic,
+                   plot_unfolding, plot_distatis, plot_cdpca, plot_gge, plot_ammi, plot_ordination, plot_coinertia,
+                   concentration_ellipse, convex_hull, alpha_bag, plot_bootstrap_ordination, plot_plsbin)
+
+__version__ = "0.4.0"
+__all__ = ["initial_transform", "TRANSFORMS", "FIXES", "ContinuousBiplot", "pca_biplot", "hj_biplot",
+           "gh_biplot", "jk_biplot", "sqrt_biplot", "CanonicalBiplot", "canonical_biplot",
+           "canonical_variate_analysis", "pca_bootstrap", "add_continuous_variables", "project_rows",
+           "biplot_scales", "calibrated_axis", "r_pretty", "matrix_sqrt", "load_iris", "load_mtcars",
+           "LogisticBiplot", "binary_logistic_biplot", "ordinal_logistic_biplot", "ordinal_logistic_fit",
+           "nominal_logistic_biplot", "nominal_logistic_fit", "StatisResult", "statis", "dual_statis",
+           "canonical_statis", "dynamic_biplot", "unfolding", "gge_model", "ammi",
+           "mardia", "manova_wts", "he_matrices", "he_ellipses", "he_plot", "roy_crit", "hlt_crit",
+           "distatis", "cdpca",
+           "OrdinationBiplot", "ca", "mca", "cca", "rda", "indicator_matrix", "binary_distances",
+           "binary_similarity", "continuous_distances", "gower_distances", "pcoa", "mds", "ridge_logistic",
+           "external_logistic_biplot", "canonical_distance_analysis", "rotate", "fa_biplot", "nipals",
+           "nipals_biplot", "pls_regression", "pls_biplot", "coinertia", "polychoric", "polychoric_biplot",
+           "plot_biplot", "plot_canonical", "plot_correlation_circle", "plot_scree", "plot_contributions",
+           "plot_biplot_3d", "plot_bootstrap", "plot_logistic", "plot_nominal_regions", "plot_statis",
+           "plot_dynamic", "plot_unfolding", "plot_distatis", "plot_cdpca", "plot_gge", "plot_ammi",
+           "plot_ordination", "plot_coinertia", "concentration_ellipse", "convex_hull", "alpha_bag",
+           "manova_terms", "he_plot_terms", "constrained_logistic_biplot", "constrained_ordinal_logistic_biplot",
+           "external_ordinal_logistic_biplot", "ridge_ordinal_logistic", "plsr1_bin", "binary_plsr", "criss_cross",
+           "log_frequency_biplot", "OrdinationBootstrap", "bootstrap_pcoa", "bootstrap_mds", "simple_procrustes",
+           "RRNG", "optim_cg", "plot_bootstrap_ordination", "plot_plsbin"]

biplotpy/bootdist.py

@@ -0,0 +1,174 @@
+"""Bootstrap of distance-based ordinations: principal coordinates
+(``MultBiplotR::BootstrapDistance``) and SMACOF multidimensional scaling.
+
+Both resample the residuals between the observed dissimilarities and the
+distances fitted by the ordination (with replacement, ``method='sampling'``, or
+by permutation), add them to the fitted distances, refit the ordination and
+align each replicate to the original configuration by Procrustes. The cloud of
+replicates of each individual gives its stability (confidence ellipses or
+convex hulls in ``plot_bootstrap_ordination``)."""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+from .distances import mds
+from .rrng import RRNG
+
+
+def _dist_vec(M):
+    """Lower triangle of a square matrix in R's ``dist`` order (by columns)."""
+    n = M.shape[0]
+    return np.concatenate([M[j + 1:, j] for j in range(n - 1)])
+
+
+def _vec_to_mat(v, n):
+    M = np.zeros((n, n))
+    k = 0
+    for j in range(n - 1):
+        M[j + 1:, j] = v[k:k + n - 1 - j]
+        k += n - 1 - j
+    return M + M.T
+
+
+def _euclid(X):
+    return np.sqrt(((X[:, None, :] - X[None, :, :]) ** 2).sum(2))
+
+
+def simple_procrustes(X, Y, mode="orthogonal"):
+    """Align ``Y`` to ``X`` (rotation/reflection, scale and translation).
+
+    ``mode='orthogonal'``: least-squares orthogonal Procrustes, rotation
+    ``V U'`` from the SVD ``X'JY = U D V'``. ``mode='MultBiplotR'`` uses the
+    rotation ``U V'`` of ``MultBiplotR::SimpleProcrustes``, which is the
+    transpose of the optimal one (it fixes reflections but turns small
+    rotations the wrong way); it is kept only to reproduce R's results."""
+    n = X.shape[0]
+    J = np.eye(n) - 1.0 / n
+    C = X.T @ J @ Y
+    U, d, Vt = np.linalg.svd(C)
+    T = U @ Vt if mode == "MultBiplotR" else Vt.T @ U.T
+    s = np.trace(C @ T) / np.trace(Y.T @ J @ Y)
+    t = (X - s * Y @ T).sum(0) / n
+    return s * Y @ T + t
+
+
+def _resample(Er, rng, method):
+    m = len(Er)
+    if method == "sampling":
+        return Er[rng.sample_replace(m, m)]
+    return Er[rng.sample_noreplace(m, m)]
+
+
+class OrdinationBootstrap:
+    """Replicates of a bootstrapped ordination."""
+
+    def __init__(self, **kw):
+        self.__dict__.update(kw)
+
+    def ellipses(self, level=0.95):
+        """Centre and covariance of the replicates of each individual (first two dims)."""
+        return [(c[:, :2].mean(0), np.cov(c[:, :2], rowvar=False)) for c in self.coordinates]
+
+    def summary(self) -> pd.DataFrame:
+        sd = np.array([c.std(0, ddof=1) for c in self.coordinates])
+        return pd.DataFrame(sd, index=self.row_names, columns=[f"sd Dim {k + 1}" for k in range(sd.shape[1])])
+
+    def plot(self, *args, **kwargs):
+        from .plot import plot_bootstrap_ordination
+        return plot_bootstrap_ordination(self, *args, **kwargs)
+
+
+def bootstrap_pcoa(D, nB=200, dim=2, weights=None, method="sampling", procrustes="orthogonal", seed=None,
+                   row_names=None) -> OrdinationBootstrap:
+    """Bootstrap of principal coordinates analysis (``MultBiplotR::BootstrapDistance``).
+
+    Residuals ``D - D_hat`` (``D_hat``: distances between the principal
+    coordinates in ``dim`` dimensions) are resampled, added to ``D_hat`` and the
+    PCoA is recomputed. ``seed`` uses R's generator (``set.seed(seed)``), so with
+    ``procrustes='MultBiplotR'`` the replicates are those of R. Returns, for each
+    replicate, the eigenvalues, the inertia (%), the aligned coordinates and the
+    qualities of representation (%) of each individual."""
+    if isinstance(D, pd.DataFrame):
+        row_names = row_names or [str(i) for i in D.index]
+    D = np.asarray(D, float)
+    n = D.shape[0]
+    if D.shape[1] != n:
+        raise ValueError("The distance matrix must be square")
+    if np.trace(D) > 0:
+        raise ValueError("That is not a distance matrix (no zeros in the diagonal)")
+    method = method.lower()
+    Wd = np.eye(n) if weights is None else np.diag(np.asarray(weights, float))
+    sW = np.sqrt(Wd); sWi = np.linalg.inv(sW)
+    J = np.eye(n) - 1.0 / n
+
+    def pco(Dm):
+        B = -0.5 * J @ (Dm ** 2) @ J
+        U, d, Vt = np.linalg.svd(sW @ B @ sW)
+        return sWi @ U @ np.diag(np.sqrt(d)), d
+    PO, d0 = pco(D)
+    PO = PO[:, :dim]
+    Dhat = _euclid(PO)
+    Er = _dist_vec(D - Dhat)
+    rng = RRNG(0 if seed is None else seed) if seed is not None else None
+    g = np.random.default_rng()
+    lam = np.zeros((n, nB)); inert = np.zeros((n, nB))
+    coords = np.zeros((n, nB, dim)); qual = np.zeros((n, nB, dim))
+    for b in range(nB):
+        if rng is not None:
+            ErE = _resample(Er, rng, method)
+        else:
+            ErE = Er[g.integers(0, len(Er), len(Er))] if method == "sampling" else g.permutation(Er)
+        DE = _vec_to_mat(ErE, n) + Dhat
+        POE, d = pco(DE)
+        lam[:, b] = d; inert[:, b] = d / d.sum() * 100
+        tot = (POE ** 2).sum(1)
+        POE = POE[:, :dim]
+        if procrustes:
+            POE = simple_procrustes(PO, POE, procrustes)
+        coords[:, b] = POE
+        qual[:, b] = POE ** 2 / tot[:, None] * 100
+    return OrdinationBootstrap(title=f"Bootstrap of PCoA ({method} of residuals)", method=method, nB=nB,
+                               reference=PO, eigenvalues0=d0, eigenvalues=lam, inertia=inert,
+                               coordinates=[coords[i] for i in range(n)], qualities=[qual[i] for i in range(n)],
+                               row_names=row_names or [f"I{i + 1}" for i in range(n)])
+
+
+def bootstrap_mds(D, nB=200, dim=2, type="ratio", method="sampling", seed=None, itmax=1000, eps=1e-10,
+                  row_names=None) -> OrdinationBootstrap:
+    """Bootstrap of SMACOF multidimensional scaling (``mds``).
+
+    The residuals between the disparities and the configuration distances of
+    the MDS (both on the normalized scale of SMACOF) are resampled and added to
+    the configuration distances; negative values are set to 0. Each replicate
+    is refitted from the original configuration and aligned to it by
+    orthogonal Procrustes (rotation and reflection only). ``seed`` uses R's
+    generator. MultBiplotR's ``BootstrapSmacof`` cannot be used as a reference
+    (it reads ``Sol$Dhat``, which its ``SMACOF`` does not return); the
+    reference is the same scheme run in R on ``smacof::mds``."""
+    if isinstance(D, pd.DataFrame):
+        row_names = row_names or [str(i) for i in D.index]
+    D = np.asarray(D, float)
+    n = D.shape[0]
+    m0 = mds(D, dim=dim, type=type, itmax=itmax, eps=eps)
+    X0 = m0.row_coordinates
+    Dh = m0.config_distances
+    Er = _dist_vec(m0.disparities - Dh)
+    rng = RRNG(seed) if seed is not None else None
+    g = np.random.default_rng()
+    coords = np.zeros((n, nB, dim)); stress = np.zeros(nB)
+    for b in range(nB):
+        if rng is not None:
+            ErE = _resample(Er, rng, method.lower())
+        else:
+            ErE = Er[g.integers(0, len(Er), len(Er))] if method.lower() == "sampling" else g.permutation(Er)
+        DE = _vec_to_mat(ErE, n) + Dh
+        DE[DE < 0] = 0
+        mi = mds(DE, dim=dim, type=type, init=X0, itmax=itmax, eps=eps)
+        U, d, Vt = np.linalg.svd(mi.row_coordinates.T @ X0)
+        coords[:, b] = mi.row_coordinates @ (U @ Vt)
+        stress[b] = mi.stress
+    return OrdinationBootstrap(title=f"Bootstrap of MDS ({type}, {method} of residuals)", method=method, nB=nB,
+                               reference=X0, stress0=m0.stress, stress=stress,
+                               coordinates=[coords[i] for i in range(n)],
+                               row_names=row_names or [f"I{i + 1}" for i in range(n)])

biplotpy/canonical.py

@@ -0,0 +1,198 @@
+"""Canonical / MANOVA biplot (port of MultBiplotR::CanonicalBiplot and
+Canonical.Variate.Analysis; Gabriel, 1972; Amaro, Vicente-Villardón and
+Galindo-Villardón, 2004).
+
+The group means are represented with the within-groups metric. With Z the
+indicator matrix, Xb the group means, S11 = Z'Z, B = Xb' S11 Xb and
+S = X'X - B (within sums of squares and products):
+Y = S11^{1/2} Xb S^{-1/2} = U D V'; variable markers H = S^{1/2} V, canonical
+weights B = S^{-1/2} V, group markers J = Xb B and individuals X B.
+"""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from scipy import stats as sps
+
+from .transforms import initial_transform, transform_name
+from .utils import matrix_sqrt
+
+
+class CanonicalBiplot:
+    def __init__(self, **kw):
+        self.__dict__.update(kw)
+
+    def _df(self, M, idx):
+        return pd.DataFrame(M, index=idx, columns=[f"Dim {d + 1}" for d in range(M.shape[1])])
+
+    @property
+    def groups(self):
+        return self._df(self.group_coordinates, self.group_names)
+
+    @property
+    def variables(self):
+        return self._df(self.col_coordinates, self.col_names)
+
+    def radii(self, kind="bonferroni"):
+        """Radii of the confidence circles for the group means:
+        ``'univariate'`` (t), ``'bonferroni'``, ``'multivariate'`` (Hotelling) or ``'chisq'``."""
+        return pd.Series({"univariate": self.univ_rad, "bonferroni": self.bonf_rad,
+                          "multivariate": self.mult_rad, "chisq": self.chis_rad}[kind], index=self.group_names)
+
+    def predict(self, Xnew):
+        """Classify new (untransformed) observations by linear discriminant analysis
+        with priors equal to the group proportions."""
+        Z = (np.asarray(Xnew, float) - self._t_center) / self._t_scale
+        return self._classify(Z @ self.canonical_weights_full)
+
+    def summary(self) -> dict:
+        r = len(self.eigenvalues)
+        return {"eigen": pd.DataFrame({"Eigenvalue": self.eigenvalues, "Explained": self.inertia,
+                                       "Cumulative": self.cum_inertia}, index=[f"Dim {i + 1}" for i in range(r)]),
+                "manova": self.manova, "anovas": self.anovas,
+                "group_contributions": self._df(self.group_contributions, self.group_names),
+                "variable_quality": self._df(self.qlr_vars, self.col_names),
+                "structure": self._df(self.structure, self.col_names)}
+
+    def plot(self, *args, **kwargs):
+        from .plot import plot_canonical
+        return plot_canonical(self, *args, **kwargs)
+
+    def __repr__(self):
+        s = self.summary()
+        return (f"Canonical/MANOVA Biplot; transformation: {self.transformation}\n{s['eigen'].round(4).to_string()}\n\n"
+                f"MANOVA:\n{self.manova.round(4).to_string()}\n\nGroup markers:\n{self.groups.round(4).to_string()}")
+
+
+def _manova(lam, n, g, m):
+    """Wilks, Pillai, Hotelling-Lawley and Roy from the eigenvalues of S^-1 B."""
+    s = min(m, g - 1)
+    dfh, dfe = g - 1, n - g
+    wilks = np.prod(1 / (1 + lam))
+    t = np.sqrt((dfh ** 2 * m ** 2 - 4) / (m ** 2 + dfh ** 2 - 5)) if (m ** 2 + dfh ** 2 - 5) > 0 else 1.0
+    w = dfe + dfh - 0.5 * (m + dfh + 1)
+    df1 = m * dfh
+    df2 = w * t - 0.5 * (m * dfh - 2)
+    Fw = (1 - wilks ** (1 / t)) / wilks ** (1 / t) * df2 / df1
+    pillai = np.sum(lam / (1 + lam))
+    mm, nn = 0.5 * (abs(m - dfh) - 1), 0.5 * (dfe - m - 1)
+    Fp = (2 * nn + s + 1) / (2 * mm + s + 1) * pillai / (s - pillai)
+    dfp = (s * (2 * mm + s + 1), s * (2 * nn + s + 1))
+    hl = np.sum(lam)
+    b = 2 * (s * nn + 1)
+    Fh = 2 * (s * nn + 1) * hl / (s ** 2 * (2 * mm + s + 1))
+    dfh_ = (s * (2 * mm + s + 1), b)
+    roy = lam.max()
+    q = max(m, dfh)
+    Fr = roy * (dfe - q + dfh) / q
+    dfr = (q, dfe - q + dfh)
+    tab = pd.DataFrame({
+        "Statistic": [wilks, pillai, hl, roy],
+        "F": [Fw, Fp, Fh, Fr],
+        "df1": [df1, dfp[0], dfh_[0], dfr[0]],
+        "df2": [df2, dfp[1], dfh_[1], dfr[1]]}, index=["Wilks", "Pillai", "Hotelling-Lawley", "Roy"])
+    tab["p"] = sps.f.sf(tab["F"], tab["df1"], tab["df2"])
+    return tab
+
+
+def canonical_biplot(X, group, sup=None, transform=5, row_names=None, col_names=None) -> CanonicalBiplot:
+    """Canonical (MANOVA) biplot of the groups defined by ``group``.
+
+    ``transform``: initial transformation (5 = standardize columns, as in
+    MultBiplotR). ``sup``: supplementary individuals (raw scale).
+    """
+    if isinstance(X, pd.DataFrame):
+        row_names = row_names or [str(i) for i in X.index]
+        col_names = col_names or [str(c) for c in X.columns]
+        X = X.to_numpy(float)
+    X0 = np.array(X, float)
+    n, m = X0.shape
+    col_names = list(col_names) if col_names is not None else [f"V{j + 1}" for j in range(m)]
+    row_names = list(row_names) if row_names is not None else [f"I{i + 1}" for i in range(n)]
+    grp = np.asarray(group)
+    if hasattr(group, "cat"):
+        levels = [str(c) for c in group.cat.categories]
+    elif hasattr(group, "categories"):
+        levels = [str(c) for c in group.categories]
+    else:
+        levels = sorted({str(v) for v in grp})
+    grp = np.array([str(v) for v in grp])
+    tr = initial_transform(X0, transform_name(transform))
+    Xs = tr["X"]
+    name = transform_name(transform)
+    t_center = tr["col_means"] if name in ("Standardize columns", "Column centering") else np.zeros(m)
+    t_scale = tr["col_sds"] if name == "Standardize columns" else np.ones(m)
+    g = len(levels)
+    r = min(g - 1, m)
+    Z = np.column_stack([(grp == lev).astype(float) for lev in levels])
+    ng = Z.sum(0)
+    S11 = np.diag(ng)
+    Xb = (Z.T @ Xs) / ng[:, None]
+    Bm = Xb.T @ S11 @ Xb
+    S = Xs.T @ Xs - Bm
+    Y = np.diag(np.sqrt(ng)) @ Xb @ matrix_sqrt(S, inverse=True)
+    U, d, Vt = np.linalg.svd(Y, full_matrices=False)
+    Vv = Vt.T
+    H = matrix_sqrt(S) @ Vv[:, :r]
+    Bw = matrix_sqrt(S, inverse=True) @ Vv[:, :r]
+    J = Xb @ Bw
+    Vi = Xs @ Bw
+    VS = None if sup is None else ((np.asarray(sup, float) - t_center) / t_scale) @ Bw
+    vprop = d[:r]
+    iner = vprop ** 2 / np.sum(vprop ** 2) * 100
+    lam = vprop ** 2
+    manova = _manova(lam, n, g, m)
+    # contributions and qualities
+    gcontr = J ** 2 / (J ** 2).sum(1, keepdims=True)
+    ccontr = H ** 2 / (H ** 2).sum(1, keepdims=True)
+    SCT = (Xs ** 2).sum()
+    SCRows, SCCols = (Xs ** 2).sum(1), (Xs ** 2).sum(0)
+    expl = np.zeros(r); rowc = np.zeros((n, r)); qlr = np.zeros((m, r))
+    for j in range(r):
+        res = Xs - Vi[:, :j + 1] @ H[:, :j + 1].T
+        expl[j] = 1 - (res ** 2).sum() / SCT
+        rowc[:, j] = 1 - (res ** 2).sum(1) / SCRows
+        qlr[:, j] = 1 - (res ** 2).sum(0) / SCCols
+    sctotal = np.diag(Xs.T @ Xs)
+    scdentro = np.diag(S)
+    scentre = sctotal - scdentro
+    glh, gle = g - 1, n - g
+    fs = (scentre / glh) / (scdentro / gle)
+    anovas = pd.DataFrame({"Total": sctotal, "Groups": scentre, "Error": scdentro, "F": fs,
+                           "p-val": sps.f.sf(fs, glh, gle)}, index=col_names)
+    base = 1 / np.sqrt(ng) / np.sqrt(n - g)
+    univ = sps.t.ppf(1 - 0.025, n - g) * base
+    bonf = sps.t.ppf(1 - 0.025 / (g * m), n - g) * base
+    mult = np.sqrt(sps.f.ppf(0.95, m, n - g - m + 1) * ((n - g) * m) / (n - g - m + 1)) * base
+    chis = np.sqrt(sps.chi2.ppf(0.95, 2)) * base
+    structure = np.corrcoef(np.column_stack([Xs, Vi]), rowvar=False)[:m, m:]
+    # LDA classification in the full canonical space (within covariance = S/(n-g))
+    Bfull = matrix_sqrt(S, inverse=True) @ Vv[:, :r] * np.sqrt(n - g)
+    Jf = Xb @ Bfull
+    logp = np.log(ng / n)
+
+    def classify(Zc):
+        d2 = ((Zc[:, None, :] - Jf[None, :, :]) ** 2).sum(2)
+        return np.array(levels)[np.argmax(-0.5 * d2 + logp, axis=1)]
+
+    pred = classify(Xs @ Bfull)
+    ct = pd.crosstab(pd.Series(grp, name="group"), pd.Series(pred, name="predicted"))
+    return CanonicalBiplot(
+        title="Canonical/MANOVA Biplot", transformation=name, n=n, p=m, g=g, dim=r, group=grp,
+        group_names=levels, col_names=col_names, row_names=row_names, scaled_data=Xs,
+        eigenvalues=vprop, inertia=iner, cum_inertia=np.cumsum(iner), wilks_f=manova.loc["Wilks", "F"],
+        wilks_p=manova.loc["Wilks", "p"], manova=manova, anovas=anovas,
+        group_coordinates=J, col_coordinates=H, canonical_weights=Bw, row_coordinates=Vi,
+        sup_coordinates=VS, structure=structure, group_contributions=gcontr, col_contributions=ccontr,
+        qlr_vars=qlr, row_contributions=rowc, expl_total=expl,
+        univ_rad=univ, bonf_rad=bonf, mult_rad=mult, chis_rad=chis,
+        predicted=pred, classification_table=ct,
+        percent_correct=float(np.mean(pred == grp)),
+        canonical_weights_full=Bfull, _classify=classify, _t_center=t_center, _t_scale=t_scale)
+
+
+def canonical_variate_analysis(X, group, transform=5, **kw) -> CanonicalBiplot:
+    """Canonical variate analysis (same solution, MANOVA and classification)."""
+    res = canonical_biplot(X, group, transform=transform, **kw)
+    res.title = "Canonical Analysis"
+    return res

biplotpy/cdpca.py

@@ -0,0 +1,121 @@
+"""Clustering and Disjoint Principal Component Analysis (CDPCA; Vichi &
+Saporta, 2009; Macedo & Freitas, 2015). Port of ``biplotbootGUI::CDpca``.
+
+Simultaneously partitions the I objects into P clusters (membership U) and
+the J variables into Q disjoint groups (membership V), each group defining one
+component (loadings A, non-zero only on its variables), maximizing the
+between-cluster deviance in the reduced space, F = ||U Ybar||^2."""
+from __future__ import annotations
+
+import numpy as np
+
+
+def _rand_mat(rng, d1, d2):
+    U = np.zeros((d1, d2))
+    U[:d2, :d2] = np.eye(d2)
+    for j in range(d2, d1):
+        U[j, rng.integers(d2)] = 1
+    return U
+
+
+def _lead(Xg, idx, I):
+    """Loading vector of a group of variables (first eigenvector, sign with positive sum)."""
+    if len(idx) == 1:
+        return np.ones(1)
+    if I >= len(idx):
+        w, v = np.linalg.eigh(Xg[:, idx].T @ Xg[:, idx]); a = v[:, -1]
+    else:
+        w, v = np.linalg.eigh(Xg[:, idx] @ Xg[:, idx].T)
+        a = Xg[:, idx].T @ v[:, -1] / np.sqrt(w[-1])
+    return a if a.sum() >= 0 else -a
+
+
+def _loadings(Xg, V, J, Q, I):
+    A = np.zeros((J, Q))
+    for j in range(Q):
+        idx = np.where(V[:, j] == 1)[0]
+        if len(idx):
+            A[idx, j] = _lead(Xg, idx, I)
+    return A
+
+
+def _one_run(Xs, P, Q, U, V, tol, maxit):
+    I, J = Xs.shape
+    Xbar = (U.T @ Xs) / U.sum(0)[:, None]
+    Xg = U @ Xbar
+    A = _loadings(Xg, V, J, Q, I)
+    A0 = A.copy()
+    Ybar = Xbar @ A
+    F0 = np.sum((U @ Ybar) ** 2)
+    Fmax = F0
+    it = 0
+    while True:
+        it += 1
+        Y = Xs @ A
+        U = np.zeros((I, P))
+        U[np.arange(I), ((Y[:, None, :] - Ybar[None, :, :]) ** 2).sum(2).argmin(1)] = 1
+        su = U.sum(0)
+        while (su == 0).any():                    # empty cluster: move half of the largest
+            imax, imin = su.argmax(), su.argmin()
+            sel = np.where(U[:, imax] == 1)[0][:int(su[imax]) // 2]
+            U[sel, imin] = 1; U[sel, imax] = 0
+            su = U.sum(0)
+        Xbar = (U.T @ Xs) / U.sum(0)[:, None]
+        Ybar = Xbar @ A
+        Xg = U @ Xbar
+        for j in range(J):
+            posmax = int(np.where(V[j] == 1)[0][0])
+            for g in range(Q):
+                V[j] = np.eye(Q)[g]
+                if g != posmax:
+                    for gg in (g, posmax):
+                        idx = np.where(V[:, gg] == 1)[0]
+                        A[:, gg] = 0
+                        if len(idx):
+                            A[idx, gg] = _lead(Xg, idx, I)
+                Ybar = Xbar @ A
+                F = np.sum((U @ Ybar) ** 2)
+                if F > Fmax:
+                    Fmax, posmax, A0 = F, g, A.copy()
+                else:
+                    A = A0.copy()
+            V[j] = np.eye(Q)[posmax]
+        Y = Xs @ A
+        Ybar = Xbar @ A
+        F = np.sum((U @ Ybar) ** 2)
+        conv = F - F0
+        if conv > tol:
+            F0, A0 = F, A.copy()
+        else:
+            break
+        if it == maxit:
+            break
+    return {"U": U, "V": V, "A": A, "F": F, "iter": it, "Xbar": Xbar}
+
+
+def cdpca(X, P: int, Q: int, nstart: int = 20, tol: float = 1e-5, maxit: int = 100, seed=None, init=None) -> dict:
+    """CDPCA with ``nstart`` random starts (``init`` = (U0, V0) for a single
+    given start). Data are standardized with variance divided by I, as in the
+    original. Components are ordered by explained variance."""
+    X = np.asarray(X, float)
+    I, J = X.shape
+    Xs = (X - X.mean(0)) / X.std(0, ddof=1) * np.sqrt(I / (I - 1))
+    rng = np.random.default_rng(seed)
+    best = None
+    starts = [init] if init is not None else [None] * nstart
+    for st in starts:
+        U0, V0 = (np.array(st[0], float), np.array(st[1], float)) if st is not None else \
+            (_rand_mat(rng, I, P), _rand_mat(rng, J, Q))
+        r = _one_run(Xs, P, Q, U0, V0, tol, maxit)
+        if best is None or r["F"] > best["F"]:
+            best = r
+    U, V, A = best["U"], best["V"], best["A"]
+    Y = Xs @ A
+    Ybar = best["Xbar"] @ A
+    var = np.var(Y, axis=0, ddof=1) * 100 / J
+    o = np.argsort(-var, kind="stable")
+    return {"U": U, "cluster": U.argmax(1) + 1, "V": V[:, o], "A": A[:, o], "Y": Y[:, o], "Ybar": Ybar[:, o],
+            "F": best["F"], "iter": best["iter"], "var_percent": var[o],
+            "bcdev_total": best["F"] / (I * J) * 100,
+            "bcdev": np.sum((U @ Ybar) ** 2) / np.sum(Y ** 2) * 100,
+            "Enorm": np.linalg.norm(Xs - U @ Ybar @ A.T) / I}