pyCoDaMath 1.0__tar.gz

pyCoDaMath-1.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyCoDaMath-1.0/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.1
+Name: pyCoDaMath
+Version: 1.0
+Summary: Compositional data (CoDa) analysis tools for Python
+Author-email: Christian Brinch <cbri@food.dtu.dk>
+Project-URL: Homepage, https://bitbucket.org/genomicepidemiology/pycodamath
+Project-URL: Bug Tracker, https://bitbucket.org/genomicepidemiology/pycodamath/issues?status=new&status=open&is_spam=!spam
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+#  pyCoDaMath
+
+[![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/)
+
+
+pyCoDaMath provides compositional data (CoDa) analysis tools for Python
+
+- **Source code:** https://bitbucket.org/genomicepidemiology/pycoda
+
+## Getting Started
+
+This package extends the Pandas dataframe object with various CoDa tools. It also provides a set of plotting functions for CoDa figures.
+
+### Installation
+
+Clone the git repo to your local hard drive:
+
+    git clone https://brinch@bitbucket.org/genomicepidemiology/pycoda.git
+
+Enter pycoda directory and type
+
+    pip install ./
+
+### Usage
+
+The pyCoDaMath module is loaded as
+
+    import pycodamath
+
+At this point, in order to get CLR values from a Pandas DataFrame df, do
+
+    df.coda.clr()
+
+
+## Documentation
+
+### CLR transformation - point estimate
+    df.coda.clr()
+
+Returns centered logratio coefficients. If the data frame contains zeros, values
+will be replaced by the Aitchison mean point estimate.
+
+### CLR transformation - standard deviation
+    df.coda.clr_std(n_samples=5000)
+
+Returns the standard deviation of n_samples random draws in CLR space.
+
+**Parameters**
+
+- n_samples (int) - Number of random draws from a Dirichlet distribution.
+
+
+### ALR transformation - point estimate
+    df.coda.alr(part=None)
+
+Same as clr() but returning additive logratio values. If part is None, then the last part of the composition is used, otherwise part is used as denominator.
+
+**Parameters**
+
+- part (str) - Name of the part to be used as denominator.   
+
+
+### ALR transformation - standard deviation
+    df.coda.alr_std(part=None, n_samples=5000)
+
+Same as clr_std, but in ALR space.
+
+**Parameters**
+
+- part (str) - Name of the part to be used as denominator.   
+
+- n_samples (int) - Number of random draws from a Dirichlet distribution.
+
+
+### ILR transformation - point estimate
+    df.coda.ilr(psi=None)
+
+Same as clr() but for isometric logratio transform. An orthonormal basis can be
+provided as psi. If no basis is given, a default sequential binary partition basis will be used.
+
+**Parameters**
+
+- psi (array_like) - Orthonormal basis.
+
+### ILR transformation - standard deviation
+    df.coda.ilr_std(psi=None, n_samples=5000)
+
+This method does not exist (yet).
+
+
+### Bayesian zero replacement
+    df.coda.zero_replacement(n_samples=5000)
+
+Returns a count table with zero values replaced by finite values using Bayesian inference.
+
+**Parameters**
+
+- n_samples (int) - Number of random draws from a Dirichlet distribution.
+
+
+### Closure
+    df.coda.closure(N)
+
+Apply closure to constant N to the composition.
+
+**Parameters**
+
+- N (int) - Closure constant.
+
+### Total variance
+    df.coda.totvar()
+
+Calculates the total variance of a set of compositions.
+
+### Geometric mean
+    df.coda.gmean()
+
+Calculates the geometric mean of a set of compositions.
+
+### Centering
+    df.coda.center()
+
+Centers (and scales) the composition by dividing by the geometric mean and powering by the reciprocal variance.
+
+
+
+## Plotting functions
+
+### PCA biplot
+    class pycoda.pca.Biplot(data, default=True)
+
+Plots a PCA biplot. Set default to False for an empty plot.
+The parameter data (DataFrame) is the data to be analyzed. Use counts, not CLR values.
+
+A number of methods are available for customizing the biplot:
+
+- plotloadings(cutoff=0, scale=None, labels=None)
+- plotloadinglabels(labels=None)
+- plotscores(group=None, palette=None, legend=True, labels=None)
+- plotscorelables(labels=None)
+- plotellipses(group=None, palette=None)
+- plotcentroids(group=None, palette=None)
+- plothulls(group=None, palette=None)
+- plotcontours(group=None, palette=None, size=None, levels=None)
+- removepatches()
+- removescores()
+- removelabels()
+
+The keyword labels is a list of labelnames. If labels is None, all labels are plottet. Use labels=[] for no labels.
+
+The keyword group is a Pandas dataframe with index equal to the index of data.
+
+The keyword palette is a dict with colors to use to each unique member of group.
+
+Example
+    import pycoda as coda
+    import pandas as pd
+
+    data = pd.read_csv('example/kilauea_iki_chem.csv')
+    mypca = coda.pca.Biplot(data)
+    mypca.plothulls()
+    mypca.removelabels()
+    mypca.plotloadinglabels(['FeO'])
+
+### Ternary diagram
+    pycoda.plot.ternary()

pyCoDaMath-1.0/README.md

@@ -0,0 +1,166 @@
+#  pyCoDaMath
+
+[![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/)
+
+
+pyCoDaMath provides compositional data (CoDa) analysis tools for Python
+
+- **Source code:** https://bitbucket.org/genomicepidemiology/pycoda
+
+## Getting Started
+
+This package extends the Pandas dataframe object with various CoDa tools. It also provides a set of plotting functions for CoDa figures.
+
+### Installation
+
+Clone the git repo to your local hard drive:
+
+    git clone https://brinch@bitbucket.org/genomicepidemiology/pycoda.git
+
+Enter pycoda directory and type
+
+    pip install ./
+
+### Usage
+
+The pyCoDaMath module is loaded as
+
+    import pycodamath
+
+At this point, in order to get CLR values from a Pandas DataFrame df, do
+
+    df.coda.clr()
+
+
+## Documentation
+
+### CLR transformation - point estimate
+    df.coda.clr()
+
+Returns centered logratio coefficients. If the data frame contains zeros, values
+will be replaced by the Aitchison mean point estimate.
+
+### CLR transformation - standard deviation
+    df.coda.clr_std(n_samples=5000)
+
+Returns the standard deviation of n_samples random draws in CLR space.
+
+**Parameters**
+
+- n_samples (int) - Number of random draws from a Dirichlet distribution.
+
+
+### ALR transformation - point estimate
+    df.coda.alr(part=None)
+
+Same as clr() but returning additive logratio values. If part is None, then the last part of the composition is used, otherwise part is used as denominator.
+
+**Parameters**
+
+- part (str) - Name of the part to be used as denominator.   
+
+
+### ALR transformation - standard deviation
+    df.coda.alr_std(part=None, n_samples=5000)
+
+Same as clr_std, but in ALR space.
+
+**Parameters**
+
+- part (str) - Name of the part to be used as denominator.   
+
+- n_samples (int) - Number of random draws from a Dirichlet distribution.
+
+
+### ILR transformation - point estimate
+    df.coda.ilr(psi=None)
+
+Same as clr() but for isometric logratio transform. An orthonormal basis can be
+provided as psi. If no basis is given, a default sequential binary partition basis will be used.
+
+**Parameters**
+
+- psi (array_like) - Orthonormal basis.
+
+### ILR transformation - standard deviation
+    df.coda.ilr_std(psi=None, n_samples=5000)
+
+This method does not exist (yet).
+
+
+### Bayesian zero replacement
+    df.coda.zero_replacement(n_samples=5000)
+
+Returns a count table with zero values replaced by finite values using Bayesian inference.
+
+**Parameters**
+
+- n_samples (int) - Number of random draws from a Dirichlet distribution.
+
+
+### Closure
+    df.coda.closure(N)
+
+Apply closure to constant N to the composition.
+
+**Parameters**
+
+- N (int) - Closure constant.
+
+### Total variance
+    df.coda.totvar()
+
+Calculates the total variance of a set of compositions.
+
+### Geometric mean
+    df.coda.gmean()
+
+Calculates the geometric mean of a set of compositions.
+
+### Centering
+    df.coda.center()
+
+Centers (and scales) the composition by dividing by the geometric mean and powering by the reciprocal variance.
+
+
+
+## Plotting functions
+
+### PCA biplot
+    class pycoda.pca.Biplot(data, default=True)
+
+Plots a PCA biplot. Set default to False for an empty plot.
+The parameter data (DataFrame) is the data to be analyzed. Use counts, not CLR values.
+
+A number of methods are available for customizing the biplot:
+
+- plotloadings(cutoff=0, scale=None, labels=None)
+- plotloadinglabels(labels=None)
+- plotscores(group=None, palette=None, legend=True, labels=None)
+- plotscorelables(labels=None)
+- plotellipses(group=None, palette=None)
+- plotcentroids(group=None, palette=None)
+- plothulls(group=None, palette=None)
+- plotcontours(group=None, palette=None, size=None, levels=None)
+- removepatches()
+- removescores()
+- removelabels()
+
+The keyword labels is a list of labelnames. If labels is None, all labels are plottet. Use labels=[] for no labels.
+
+The keyword group is a Pandas dataframe with index equal to the index of data.
+
+The keyword palette is a dict with colors to use to each unique member of group.
+
+Example
+    import pycoda as coda
+    import pandas as pd
+
+    data = pd.read_csv('example/kilauea_iki_chem.csv')
+    mypca = coda.pca.Biplot(data)
+    mypca.plothulls()
+    mypca.removelabels()
+    mypca.plotloadinglabels(['FeO'])
+
+### Ternary diagram
+    pycoda.plot.ternary()

pyCoDaMath-1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyCoDaMath"
+version = "1.0"
+authors = [
+  { name="Christian Brinch", email="cbri@food.dtu.dk" },
+]
+description = "Compositional data (CoDa) analysis tools for Python"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = ['matplotlib>=3.1.1', 
+                'numpy>=1.17.2', 
+                'pandas>=0.25.1',
+                'python-ternary>=1.0.6', 
+                'scipy>=1.3.1',
+                'webcolors>=1.13',
+                'adjustText==0.7.3',
+                ]
+
+[project.urls]
+"Homepage" = "https://bitbucket.org/genomicepidemiology/pycodamath"
+"Bug Tracker" = "https://bitbucket.org/genomicepidemiology/pycodamath/issues?status=new&status=open&is_spam=!spam"

pyCoDaMath-1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyCoDaMath-1.0/src/pyCoDaMath.egg-info/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.1
+Name: pyCoDaMath
+Version: 1.0
+Summary: Compositional data (CoDa) analysis tools for Python
+Author-email: Christian Brinch <cbri@food.dtu.dk>
+Project-URL: Homepage, https://bitbucket.org/genomicepidemiology/pycodamath
+Project-URL: Bug Tracker, https://bitbucket.org/genomicepidemiology/pycodamath/issues?status=new&status=open&is_spam=!spam
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+#  pyCoDaMath
+
+[![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/)
+
+
+pyCoDaMath provides compositional data (CoDa) analysis tools for Python
+
+- **Source code:** https://bitbucket.org/genomicepidemiology/pycoda
+
+## Getting Started
+
+This package extends the Pandas dataframe object with various CoDa tools. It also provides a set of plotting functions for CoDa figures.
+
+### Installation
+
+Clone the git repo to your local hard drive:
+
+    git clone https://brinch@bitbucket.org/genomicepidemiology/pycoda.git
+
+Enter pycoda directory and type
+
+    pip install ./
+
+### Usage
+
+The pyCoDaMath module is loaded as
+
+    import pycodamath
+
+At this point, in order to get CLR values from a Pandas DataFrame df, do
+
+    df.coda.clr()
+
+
+## Documentation
+
+### CLR transformation - point estimate
+    df.coda.clr()
+
+Returns centered logratio coefficients. If the data frame contains zeros, values
+will be replaced by the Aitchison mean point estimate.
+
+### CLR transformation - standard deviation
+    df.coda.clr_std(n_samples=5000)
+
+Returns the standard deviation of n_samples random draws in CLR space.
+
+**Parameters**
+
+- n_samples (int) - Number of random draws from a Dirichlet distribution.
+
+
+### ALR transformation - point estimate
+    df.coda.alr(part=None)
+
+Same as clr() but returning additive logratio values. If part is None, then the last part of the composition is used, otherwise part is used as denominator.
+
+**Parameters**
+
+- part (str) - Name of the part to be used as denominator.   
+
+
+### ALR transformation - standard deviation
+    df.coda.alr_std(part=None, n_samples=5000)
+
+Same as clr_std, but in ALR space.
+
+**Parameters**
+
+- part (str) - Name of the part to be used as denominator.   
+
+- n_samples (int) - Number of random draws from a Dirichlet distribution.
+
+
+### ILR transformation - point estimate
+    df.coda.ilr(psi=None)
+
+Same as clr() but for isometric logratio transform. An orthonormal basis can be
+provided as psi. If no basis is given, a default sequential binary partition basis will be used.
+
+**Parameters**
+
+- psi (array_like) - Orthonormal basis.
+
+### ILR transformation - standard deviation
+    df.coda.ilr_std(psi=None, n_samples=5000)
+
+This method does not exist (yet).
+
+
+### Bayesian zero replacement
+    df.coda.zero_replacement(n_samples=5000)
+
+Returns a count table with zero values replaced by finite values using Bayesian inference.
+
+**Parameters**
+
+- n_samples (int) - Number of random draws from a Dirichlet distribution.
+
+
+### Closure
+    df.coda.closure(N)
+
+Apply closure to constant N to the composition.
+
+**Parameters**
+
+- N (int) - Closure constant.
+
+### Total variance
+    df.coda.totvar()
+
+Calculates the total variance of a set of compositions.
+
+### Geometric mean
+    df.coda.gmean()
+
+Calculates the geometric mean of a set of compositions.
+
+### Centering
+    df.coda.center()
+
+Centers (and scales) the composition by dividing by the geometric mean and powering by the reciprocal variance.
+
+
+
+## Plotting functions
+
+### PCA biplot
+    class pycoda.pca.Biplot(data, default=True)
+
+Plots a PCA biplot. Set default to False for an empty plot.
+The parameter data (DataFrame) is the data to be analyzed. Use counts, not CLR values.
+
+A number of methods are available for customizing the biplot:
+
+- plotloadings(cutoff=0, scale=None, labels=None)
+- plotloadinglabels(labels=None)
+- plotscores(group=None, palette=None, legend=True, labels=None)
+- plotscorelables(labels=None)
+- plotellipses(group=None, palette=None)
+- plotcentroids(group=None, palette=None)
+- plothulls(group=None, palette=None)
+- plotcontours(group=None, palette=None, size=None, levels=None)
+- removepatches()
+- removescores()
+- removelabels()
+
+The keyword labels is a list of labelnames. If labels is None, all labels are plottet. Use labels=[] for no labels.
+
+The keyword group is a Pandas dataframe with index equal to the index of data.
+
+The keyword palette is a dict with colors to use to each unique member of group.
+
+Example
+    import pycoda as coda
+    import pandas as pd
+
+    data = pd.read_csv('example/kilauea_iki_chem.csv')
+    mypca = coda.pca.Biplot(data)
+    mypca.plothulls()
+    mypca.removelabels()
+    mypca.plotloadinglabels(['FeO'])
+
+### Ternary diagram
+    pycoda.plot.ternary()

pyCoDaMath-1.0/src/pyCoDaMath.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/pyCoDaMath.egg-info/PKG-INFO
+src/pyCoDaMath.egg-info/SOURCES.txt
+src/pyCoDaMath.egg-info/dependency_links.txt
+src/pyCoDaMath.egg-info/requires.txt
+src/pyCoDaMath.egg-info/top_level.txt
+src/pycodamath/__init__.py
+src/pycodamath/extra.py
+src/pycodamath/pca.py
+src/pycodamath/plot.py
+src/pycodamath/pycoda.py

pyCoDaMath-1.0/src/pyCoDaMath.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyCoDaMath-1.0/src/pyCoDaMath.egg-info/requires.txt

@@ -0,0 +1,7 @@
+matplotlib>=3.1.1
+numpy>=1.17.2
+pandas>=0.25.1
+python-ternary>=1.0.6
+scipy>=1.3.1
+webcolors>=1.13
+adjustText==0.7.3

pyCoDaMath-1.0/src/pyCoDaMath.egg-info/top_level.txt

@@ -0,0 +1 @@
+pycodamath

pyCoDaMath-1.0/src/pycodamath/__init__.py

@@ -0,0 +1,13 @@
+'''
+    pyCoDa init script
+'''
+
+__title__ = "pyCoDaMath"
+__author__ = "Christian Brinch"
+__email__ = "cbri@food.dtu.dk"
+__copyright__ = "Copyright 2019 C. Brinch"
+__version__ = 1.0
+__all__ = ['pycoda', 'extra', 'plot', 'pca']
+
+from . import pycoda, pca
+pycoda.init()

pyCoDaMath-1.0/src/pycodamath/extra.py

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+''' Auxilliary functions for pyCoDaMath
+'''
+
+__author__ = "Christian Brinch"
+__copyright__ = "Copyright 2019"
+__credits__ = ["Christian Brinch"]
+__license__ = "AFL 3.0"
+__version__ = "1.0"
+__maintainer__ = "Christian Brinch"
+__email__ = "cbri@food.dtu.dk"
+
+import math
+import numpy as np
+from matplotlib.patches import Ellipse
+
+
+def sbp_basis(obj):
+    ''' Define basis to use in IRL transformation '''
+    dim = np.shape(obj)[1]
+    psi = np.zeros([dim-1, dim])
+    for i in range(dim-1):
+        for j in range(dim):
+            if j+1 <= dim-i-1:
+                psi[i, j] = np.sqrt(1./((dim-i-1)*(dim-i)))
+            elif j+1 == dim-i:
+                psi[i, j] = -np.sqrt((dim-i-1)/(dim-i))
+
+    check_basis(psi)
+    return psi
+
+
+def norm(balances):
+    ''' Normalize a matrix of balances '''
+    psi = []
+    for row in balances:
+        minus = sum(1 for i in row if i < 0)
+        plus = sum(1 for i in row if i > 0)
+        psi.append([1/plus*np.sqrt(plus*minus/(plus+minus)) if i > 0 else -1/minus *
+                    np.sqrt(plus*minus/(plus+minus)) if i < 0 else 0 for i in row])
+
+    psi = np.array(psi)
+    check_basis(psi)
+    return psi
+
+
+def check_basis(psi):
+    ''' Check if basis is orthonormal '''
+    ident = np.matmul(psi, psi.T)
+    if np.trace(ident) != np.shape(ident)[0]:
+        raise AttributeError("Error: Basis is not normalized.")
+    if np.abs(np.sum(ident-np.diag(np.diagonal(ident)))) > 1e-6:
+        raise AttributeError("Error: Basis is not orthogonal.")
+
+
+def points_in_ellipse(ellipse, npoints):
+    ''' Return n points along the edge of an ellipse '''
+    return [(ellipse['shape'][0] * math.cos(x) * math.cos(-ellipse['angle'])
+             - ellipse['shape'][1] * math.sin(x)*math.sin(-ellipse['angle']) + ellipse['center'][0],
+             ellipse['shape'][0] * math.cos(x) * math.sin(-ellipse['angle'])
+             + ellipse['shape'][1] * math.sin(x)*math.cos(-ellipse['angle']) + ellipse['center'][1])
+            for x in np.linspace(0, 2*np.pi, npoints)]
+
+
+def check_point_in_ellipse(scores, ellipse):
+    ''' This function takes a point and checks if it is inside or outside an
+        ellipse
+    '''
+    xcoord = scores[0] - ellipse['center'][0]
+    ycoord = scores[1] - ellipse['center'][1]
+
+    xct = xcoord * np.cos(-ellipse['angle']) - ycoord * np.sin(-ellipse['angle'])
+    yct = xcoord * np.sin(-ellipse['angle']) + ycoord * np.cos(-ellipse['angle'])
+
+    if (xct**2/(ellipse['shape'][0])**2) + (yct**2/(ellipse['shape'][1])**2) > 1.25:
+        return True
+    return False
+
+
+def get_covariance_ellipse(data, conf=95):
+    ''' Return a covariance ellipse object '''
+    if len(data.columns) > 2:
+        raise AttributeError(
+            ("Error: get_covariance_ellipse expects only two columns. " +
+             "Got {0:d}.").format(len(data.columns)))
+
+    lambda_, angle = np.linalg.eig(np.cov(data.loc[:, 0], data.loc[:, 1]))
+    lambda_ = np.sqrt(lambda_)
+
+    if conf == 95:
+        scale = 5.991  # 95% confidence interval
+    elif conf == 90:
+        scale = 4.605  # 90%
+    elif conf == 99:
+        scale = 9.210  # 99%
+    else:
+        raise AttributeError(
+            "Error: get_covariance_ellipse parameter conf can only accept values {90, 95, 99}.")
+
+    return {'shape': (lambda_[0]*np.sqrt(scale), lambda_[1]*np.sqrt(scale)),
+            # 'angle': np.arccos(-angle[0, 0]),
+            'angle': np.arctan(angle[1, 0]/angle[0, 0]),
+            'center': (np.mean(data.loc[:, 0]), np.mean(data.loc[:, 1]))}
+
+
+def plot_covariance_ellipse(axis, ellipse, color=0):
+    ''' plot covariance ellipse '''
+    if color is None:
+        color = 'black'
+    ell = Ellipse(xy=ellipse['center'],
+                  width=2*ellipse['shape'][0],
+                  height=2*ellipse['shape'][1],
+                  angle=np.rad2deg(ellipse['angle']),
+                  alpha=0.5,
+                  edgecolor=color,
+                  fill=False,
+                  lw=1.5,
+                  ls='-')
+    axis.add_artist(ell)
+    ell = Ellipse(xy=ellipse['center'],
+                  width=2*ellipse['shape'][0],
+                  height=2*ellipse['shape'][1],
+                  angle=np.rad2deg(ellipse['angle']),
+                  alpha=0.15,
+                  edgecolor=None,
+                  fill=True,
+                  color=color)
+    axis.add_artist(ell)

pyCoDaMath-1.0/src/pycodamath/pca.py

@@ -0,0 +1,341 @@
+''' Class and methods for making compositional biplots based on PCA '''
+
+import numpy as np
+import matplotlib.pyplot as plt
+import webcolors as wc
+from matplotlib.colors import ListedColormap
+from matplotlib import cm
+import matplotlib.patches as mpatches
+import pandas as pd
+import scipy.stats as st
+from pycodamath import extra
+
+
+class GeomObj():
+    ''' A generic container of geometric objects '''
+
+    def __init__(self, **kwargs):
+        vars(self).update(kwargs)
+        self.area = self.polyarea()
+
+    def polyarea(self):
+        ''' Calculate the area of a polygon given two lists of vertices '''
+        x, y = self.vertices
+        return 0.5*np.abs(np.dot(x, np.roll(y, 1))-np.dot(y, np.roll(x, 1)))
+
+
+def scree_plot(axis, eig_val):
+    ''' Make scree plot from eigen values'''
+    axis.set_xlabel('Component')
+    axis.set_ylabel('Explained varaince')
+    axis.set_xlim(0, min(len(eig_val)+1, 20))
+    axis.bar(np.arange(len(eig_val))+1, (eig_val/np.sum(eig_val))**2)
+    csum = np.cumsum(eig_val**2/np.sum(eig_val**2))
+    for i in range(min(5, len(eig_val))):
+        axis.annotate(str(np.round(csum[i]*100))+'%',
+                      (i+1.2, (eig_val[i]/np.sum(eig_val))**2))
+
+
+def _get_palette(group):
+    cspace = cm.jet(np.linspace(0, 1, len(set(group))))
+    palette = {}
+    for idx, item in enumerate(set(group)):
+        palette[item] = cspace[idx]
+    return palette
+
+
+def _svd(clr):
+    ''' Internal SVD function '''
+    scores, eig_val, loadings = np.linalg.svd(clr)
+    scores = pd.DataFrame(scores.T[0:2, :], columns=clr.index, index=['pc1', 'pc2'])
+    loadings = pd.DataFrame(np.inner(eig_val*np.identity(len(eig_val)),
+                                     loadings.T[0:len(eig_val), 0:len(eig_val)])[0:2],
+                            columns=clr.columns[0:len(eig_val)], index=['pc1', 'pc2'])
+    return scores, eig_val, loadings
+
+
+class Biplot():
+    ''' A class to create and a PCA biplot '''
+
+    def __init__(self, data, axis=None, default=True):
+        if axis is None:
+            _, self.axis = plt.subplots(figsize=(7.8, 7.8))
+        else:
+            self.axis = axis
+        self.axis.set(adjustable='box', aspect='equal')
+        self.scores, eig_val, self.loadings = _svd(data.coda.center().coda.scale().coda.clr())
+        scales = [np.max(np.abs(self.loadings.values)),
+                  [np.max(np.abs(self.scores.loc[idx].values)) for idx in ['pc1', 'pc2']]]
+
+
+        self.axis.set_xlabel(f'P.C. 1 ({np.round(eig_val[0]**2 / np.sum(eig_val**2)*100):.1f}% explained variation)')                             
+        self.axis.set_ylabel(f'P.C. 2 ({np.round(eig_val[1]**2 / np.sum(eig_val**2)*100):.1f}% explained variation)')
+        self.axis.set_xlim(-scales[0]*1.1, scales[0]*1.1)
+        self.axis.set_ylim(-scales[0]*1.1, scales[0]*1.1)
+        self.axis.plot([self.axis.get_xlim()[0], self.axis.get_xlim()[1]],
+                       [0.0, 0.0], '--', color='black', alpha=0.4)
+        self.axis.plot([0.0, 0.0], [self.axis.get_ylim()[0], self.axis.get_ylim()[1]],
+                       '--', color='black', alpha=0.4)
+
+        self.scores = (scales[0]*(self.scores.T/scales[1])).T
+
+        self.patches = []
+        self.geomobj = {}
+        plt.tight_layout()
+
+        if default:
+            self.plotloadings()
+            self.plotscores()
+
+    def plotloadings(self, cutoff=0, scale=None, labels=None):
+        ''' Plot loadings '''
+        if scale is None:
+            scale = np.max(np.abs(self.loadings.values))
+
+        for column in self.loadings:
+            if np.sqrt(pow(self.loadings.loc['pc1', column], 2) +
+                       pow(self.loadings.loc['pc2', column], 2)) > cutoff:
+                self.axis.arrow(0, 0,
+                                self.loadings.loc['pc1', column],
+                                self.loadings.loc['pc2', column],
+                                facecolor='black',
+                                alpha=0.5,
+                                linewidth=0.,
+                                width=scale*0.01,
+                                zorder=2000)
+        self.plotloadinglabels(labels, cutoff)
+
+    def plotloadinglabels(self, labels=None, cutoff=0):
+        ''' Add labels to the loadings '''
+        if labels is None:
+            labels = self.loadings.columns
+
+        for column in labels:
+            if np.sqrt(pow(self.loadings.loc['pc1', column], 2) +
+                       pow(self.loadings.loc['pc2', column], 2)) > cutoff:
+                yoff = 0.  
+                if self.loadings.loc['pc1', column] > 0.9*self.axis.get_xlim()[1]:
+                    xoff = -1.2
+                else:
+                    xoff = 0
+                self.axis.annotate(column, (self.loadings.loc['pc1', column]+xoff,
+                                            self.loadings.loc['pc2', column]+yoff),
+                                   ha='left',
+                                   va='bottom',
+                                   alpha=1.0,
+                                   zorder=2001
+                                   )
+
+    def plotscores(self, group=None, palette=None, legend=True, labels=None):
+        ''' Plot scores as points '''
+        if labels is None:
+            labels = self.scores.columns
+
+        if palette is None:
+            if group is not None:
+                palette = _get_palette(group)
+            else:
+                palette = 'steelblue'
+
+        if group is None:
+            self.axis.plot(*self.scores[labels].values, 'o', alpha=0.5,
+                           color=palette, zorder=7, markeredgewidth=0)
+        else:
+            for item in set(group):
+                idx = group.loc[group == item].index
+                self.axis.plot(*self.scores[idx].values, 'o', alpha=0.5, zorder=7,
+                               label=item, color=palette[item], markeredgewidth=0)
+                if legend:
+                    self.patches.append(mpatches.Patch(color=palette[item], label=item))
+
+    def plotscorelabels(self, labels=None):
+        ''' Add labels to the scores '''
+        if labels is None:
+            labels = self.scores.columns
+
+        for label in labels:
+            self.axis.annotate(label, (self.scores.loc['pc1', label],
+                                       self.scores.loc['pc2', label]),
+                               ha='left',
+                               va='bottom',
+                               alpha=0.8,
+                               zorder=201,
+                               size=8
+                               )
+
+    def plotellipses(self, group, palette=None, legend=False):
+        ''' Plot confidence ellipses '''
+        if palette is None:
+            palette = _get_palette(group)
+
+        for item in set(group):
+            idx = group.loc[group == item].index
+            if len(idx) > 3:
+                ellipse = extra.get_covariance_ellipse(pd.DataFrame(self.scores[idx].values.T),
+                                                       conf=90)
+                extra.plot_covariance_ellipse(self.axis, ellipse, color=palette[item])
+                if legend:
+                    self.patches.append(mpatches.Patch(color=palette[item], label=item))
+
+    def plotcentroids(self, group, palette=None, legend=False):
+        ''' Plot score group centroids '''
+        if palette is None:
+            palette = _get_palette(group)
+
+        for item in set(group):
+            idx = group.loc[group == item].index
+            length = len(self.scores[idx].T)
+            sum_x = np.sum(self.scores.loc['pc1', idx])
+            sum_y = np.sum(self.scores.loc['pc2', idx])
+            self.axis.plot([sum_x/length], [sum_y/length], 'x', alpha=0.7,
+                           label=item, color=palette[item], markersize=24)
+            if legend:
+                self.patches.append(mpatches.Patch(color=palette[item], label=item))
+
+    def plothulls(self, group, palette=None, legend=True):
+        ''' Plot score group hulls '''
+        if palette is None:
+            palette = _get_palette(group)
+
+        self.geomobj = {}
+        for item in set(group):
+            idx = group.loc[group == item].index
+            if len(idx) > 3:
+                # My secret hull construction algorithm
+                idxmin = self.scores.loc['pc1', idx].idxmin()
+                j = self.scores[idx].columns.get_loc(idxmin)
+                hull = [list(self.scores[idxmin])]
+                while (j != self.scores[idx].columns.get_loc(idxmin) or len(hull) == 1):
+                    k = (j + 1) % len(idx)
+                    for i in range(len(idx)):
+                        if (self.scores[idx].iloc[1, k]-self.scores[idx].iloc[1, j]) * \
+                           (self.scores[idx].iloc[0, i]-self.scores[idx].iloc[0, k]) - \
+                           (self.scores[idx].iloc[0, k]-self.scores[idx].iloc[0, j]) * \
+                           (self.scores[idx].iloc[1, i]-self.scores[idx].iloc[1, k]) < 0:
+                            k = i
+                    j = k
+                    hull.append(list(self.scores[self.scores[idx].columns[k]]))
+                self.geomobj[item] = GeomObj(vertices=tuple(map(list, zip(*hull))))
+
+        for idx, item in enumerate(sorted(self.geomobj,
+                                          key=lambda x: self.geomobj[x].area, reverse=True)):
+            self.axis.fill(*self.geomobj[item].vertices,
+                           color=palette[item], alpha=0.7, zorder=10+(2*idx))
+            self.axis.fill(*self.geomobj[item].vertices, facecolor='none',
+                           edgecolor='black', alpha=0.9, linewidth=2.2, zorder=11+(2*idx))
+
+            if legend:
+                self.patches.append(mpatches.Patch(color=palette[item], label=item))
+
+    def plotcontours(self, group, palette=None, legend=True,
+                     plot_outliers=True, percent_outliers=0.1, linewidth=2.2):
+        ''' Plot scores as contours '''
+        if palette is None and group is not None:
+            palette = _get_palette(group)
+        if percent_outliers > 1 or percent_outliers < 0:
+            raise Exception('Percent_outliers has to be between 0 and 1')
+
+        # Build color maps
+        cmap = {}
+        for item in set(group):
+            colorvalues = np.ones((4, 4))
+            if '#' in str(palette[item]):
+                color = wc.hex_to_rgb(palette[item])
+            elif palette[item][-1] != 1:
+                color = wc.name_to_rgb(palette[item])
+            else:
+                color = palette[item]
+
+            for i in range(3):
+                colorvalues[:, i] = np.linspace(1, color[i]/256., 5)[1:]
+            colorvalues[:, 3] = np.linspace(.95, .25, 4)
+            cmap[item] = ListedColormap(colorvalues)
+
+        self.geomobj = {}
+        for item in set(group):
+            minlevel = 0.2
+            diff = 100
+            k = 0
+            while abs(diff) > 0 and k < 25:
+                levels = np.arange(5)*(1.-minlevel)/4.+minlevel
+                idx = group.loc[group == item].index
+                xgrid, ygrid = np.mgrid[self.axis.get_xlim()[0]: self.axis.get_xlim()[1]: 300j,
+                                        self.axis.get_ylim()[0]: self.axis.get_ylim()[1]: 300j]
+                positions = np.vstack([xgrid.ravel(), ygrid.ravel()])
+                values = np.vstack([self.scores.loc['pc1', idx], self.scores.loc['pc2', idx]])
+                kernel = st.gaussian_kde(values)
+                density = np.reshape(kernel(positions).T, xgrid.shape)
+                vals = np.max(density)*levels
+                self.axis.contour(xgrid, ygrid, density, vals)
+                vertices = self.axis.collections[-4].get_paths()[0].vertices.T
+                contained = [False for _ in range(len(idx))]
+                for j in range(len(self.axis.collections[-5].get_paths())):
+                    contained = np.logical_or(contained,
+                                              self.axis.collections[-5].get_paths()[j].contains_points(
+                                                  [[self.scores.loc['pc1', i],
+                                                    self.scores.loc['pc2', i]] for i in idx]))
+                _ = [self.axis.collections[-1].remove() for _ in np.arange(5)]
+                outside = [a for a, b in zip(list(idx), contained) if not b]
+
+                diff = round(percent_outliers*len(idx))-len(outside)
+                minlevel = minlevel+diff/1000.
+                k += 1
+
+            self.geomobj[item] = GeomObj(vertices=vertices, grid=(
+                xgrid, ygrid), density=density, values=vals, outside=outside)
+
+        for idx, item in enumerate(sorted(self.geomobj,
+                                          key=lambda x: self.geomobj[x].area, reverse=True)):
+            self.axis.contourf(*self.geomobj[item].grid, self.geomobj[item].density,
+                               self.geomobj[item].values, antialiased=True,
+                               cmap=cmap[item], alpha=0.9, zorder=10+(2*idx))
+            self.axis.contour(*self.geomobj[item].grid, self.geomobj[item].density,
+                              self.geomobj[item].values, antialiased=True,
+                              colors='black', alpha=0.9, linewidths=linewidth, zorder=11+(2*idx))
+            self.axis.collections[-1].remove()
+
+            if plot_outliers:
+                self.plotscores(None, palette[item], False, self.geomobj[item].outside)
+
+            if legend:
+                self.patches.append(mpatches.Patch(color=palette[item], label=item))
+
+    def labeloutliers(self, group, conf=3.):
+        ''' Print labels on scores that are more than conf away from centroid '''
+        for item in set(group):
+            idx = group.loc[group == item].index
+            length = len(self.scores[idx].T)
+            sum_x = np.sum(self.scores.loc['pc1', idx])
+            sum_y = np.sum(self.scores.loc['pc2', idx])
+
+            pdist = {i: np.sqrt(pow(self.scores.loc['pc1', i]-sum_x/length, 2) +
+                                pow(self.scores.loc['pc2', i]-sum_y/length, 2)) for i in idx}
+            std = np.std(pdist.values())
+
+            outliers = [i for i in pdist.keys() if pdist[i] > conf*std]
+            self.plotscorelabels(outliers)
+
+    def displaylegend(self, loc=2):
+        ''' Display the item legend at location loc '''
+        patches = sorted(self.patches, key=lambda x: x._label)
+        self.axis.legend(handles=patches, fontsize=9, frameon=False, loc=loc)
+
+    def removepatches(self):
+        ''' remove arrows and polygons from plot '''
+        for _ in range(len(self.axis.patches)):
+            self.axis.patches[-1].remove()
+
+    def removelabels(self):
+        ''' remove labels from plot '''
+        for _ in range(len(self.axis.texts)):
+            self.axis.texts[-1].remove()
+
+    def removescores(self):
+        ''' remove points from plot '''
+        for _ in range(len(self.axis.lines)):
+            self.axis.lines[-1].remove()
+
+    def removecontours(self):
+        ''' remove points from plot '''
+        for _ in range(len(self.axis.collections)):
+            self.axis.collections[-1].remove()

pyCoDaMath-1.0/src/pycodamath/plot.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+''' Compositional plot
+'''
+
+__author__ = "Christian Brinch"
+__copyright__ = "Copyright 2019"
+__credits__ = ["Christian Brinch"]
+__license__ = "AFL 3.0"
+__version__ = "1.0"
+__maintainer__ = "Christian Brinch"
+__email__ = "cbri@food.dtu.dk"
+
+import ternary as td
+import numpy as np
+import pandas as pd
+from pycodamath import extra
+
+
+def ternary(data, descr=None, center=False, conf=False):
+    ''' Plot ternary diagram '''
+    if np.shape(data)[1] > 3:
+        raise AttributeError("Error: Too many parts in composition (max. 3).")
+    for column in data.T:
+        if np.abs(data.T[column].sum()-100.) > 1e-6:
+            raise AttributeError("Error: Composition is not closed to 100.")
+
+    _, tax = td.figure(scale=100)
+    tax.boundary(linewidth=1.5)
+    tax.gridlines(color="blue", multiple=10, linewidth=0.5, alpha=0.5)
+    tax.left_axis_label(f"% {data.columns[0]:s}", fontsize=16, offset=0.14)
+    tax.right_axis_label(f"% {data.columns[1]:s}", fontsize=16, offset=0.14)
+    tax.bottom_axis_label(f"% {data.columns[2]:s}", fontsize=16, offset=0.12)
+    tax.ticks(axis='lbr', linewidth=1, multiple=10, offset=0.03)
+    tax.clear_matplotlib_ticks()
+    tax.get_axes().axis('off')
+
+    if center:
+        sdata = (data/data.coda.gmean()).coda.closure(100)
+    else:
+        sdata = data
+
+    if descr is not None:
+        for group in set(descr):
+            idx = descr.loc[descr == group].index
+            tax.scatter(sdata.loc[idx, [sdata.columns[2], sdata.columns[1],
+                                        sdata.columns[0]]].values, alpha=0.7)
+    else:
+        tax.scatter(sdata.loc[:, [sdata.columns[2], sdata.columns[1],
+                                  sdata.columns[0]]].values, alpha=0.7,
+                    color='steelblue')
+
+    if conf:
+        ilr = sdata.coda.ilr().loc[:, [0, 1]]
+        par = extra.get_covariance_ellipse(ilr)
+
+        points = [[par['center'][0] +
+                   par['shape'][0]*np.cos(par['angle'])*np.cos(a) -
+                   par['shape'][1]*np.sin(par['angle'])*np.sin(a),
+                   par['center'][1] +
+                   par['shape'][0]*np.cos(par['angle'])*np.sin(a) +
+                   par['shape'][1]*np.sin(par['angle'])*np.cos(a)]
+                  for a in np.linspace(0, 2*np.pi, 100)]
+
+        psi = extra.sbp_basis(sdata)
+
+        ellipse = pd.DataFrame(np.exp(np.matmul(points, psi))).coda.closure(100)
+        ellipse = ellipse.loc[:, [ellipse.columns[1], ellipse.columns[0],
+                                  ellipse.columns[2]]]
+        tax.plot(ellipse.values, color='black', lw=0.5, ls='-')
+
+    return tax

pyCoDaMath-1.0/src/pycodamath/pycoda.py

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+''' CoDa related extensions to pandas dataframes
+'''
+
+__author__ = "Christian Brinch"
+__copyright__ = "Copyright 2019"
+__credits__ = ["Christian Brinch"]
+__license__ = "AFL 3.0"
+__version__ = "1.0"
+__maintainer__ = "Christian Brinch"
+__email__ = "cbri@food.dtu.dk"
+
+import pandas as pd
+import numpy as np
+import scipy.stats as ss
+import scipy.special as sp
+from pycodamath import extra
+
+
+def _clr_internal(obj):
+    return (np.log(obj.T) - np.mean(np.log(obj.T), axis=0)).T
+
+
+def _alr_internal(obj):
+    return pd.DataFrame(np.log(obj.T/obj.T.loc[obj.columns[-1]])).T.iloc[:, :-1]
+
+
+def _ilr_internal(obj, psi):
+    return pd.DataFrame(np.dot(_clr_internal(obj), psi.T), index=obj.index)
+
+
+def _ilr_inv_internal(obj, psi):
+    return pd.DataFrame(np.exp(np.matmul(obj.values, psi)))
+
+
+def init():
+    ''' Initialize CoDa extension '''
+    @ pd.api.extensions.register_dataframe_accessor("coda")
+    class _:
+        ''' A CoDa extension to pandas objects containing counts '''
+
+        def __init__(self, pandas_obj):
+            self._obj = pandas_obj
+
+        def _check_for_zeros(self):
+            if not self._obj.values.all():
+                print("Dataframe contains zeros. Using Bayesian inference to replace zeros.")
+                return True
+            return False
+
+        def clr(self):
+            ''' Wrapper for CLR '''
+            if self._check_for_zeros():
+                return _clr_internal(self.aitchison_mean())
+
+            return _clr_internal(self._obj)
+
+        def clr_std(self, n_samples=5000):
+            ''' Wrapper for CLR bayesian error estimate'''
+            logratio = pd.DataFrame(index=self._obj.columns)
+            for column in self._obj.T:
+                p_matrix = ss.dirichlet.rvs(self._obj.T[column]+0.5, n_samples)
+                c_matrix = _clr_internal(p_matrix)
+                logratio[column] = [np.std(i) for i in zip(*c_matrix)]
+            return logratio.T
+
+        def alr(self, part=None):
+            ''' Wrapper for ALR '''
+            if part:
+                parts = self._obj.T.index.tolist()
+                parts.remove(part)
+                self._obj = self._obj.T.reindex(parts+[part]).T
+
+            print("Using "+self._obj.columns[-1] + " as denominator.")
+            if self._check_for_zeros():
+                return _alr_internal(self.aitchison_mean())
+
+            return _alr_internal(self._obj)
+
+        def alr_std(self, part=None, n_samples=5000):
+            ''' Wrapper for ALR error estimate'''
+            if part:
+                parts = self._obj.index.tolist()
+                parts.remove(part)
+                self._obj.reindex(parts+[part])
+
+            logratio = pd.DataFrame(index=self._obj.columns)
+            for column in self._obj.T:
+                p_matrix = ss.dirichlet.rvs(self._obj.T[column]+0.5, n_samples)
+                c_matrix = [np.log(i/i[-1]) for i in p_matrix]
+                logratio[column] = [np.std(i) for i in zip(*c_matrix)]
+            return logratio.T.iloc[:, :-1]
+
+        def ilr(self, psi=None):
+            ''' Wrapper for ILR '''
+            if psi is None:
+                psi = extra.sbp_basis(self._obj)
+            else:
+                extra.check_basis(psi)
+
+            if self._check_for_zeros():
+                return _ilr_internal(self.aitchison_mean(), psi)
+
+            return _ilr_internal(self._obj, psi)
+
+        def ilr_inv(self, psi=None):
+            ''' Wrapper for inverse ILR transformation '''
+            if psi is None:
+                psi = extra.sbp_basis(self._obj)
+            else:
+                extra.check_basis(psi)
+
+            return _ilr_inv_internal(self._obj, psi)
+
+        def zero_replacement(self, n_samples=5000):
+            ''' Replace zero values using Dirichlet-multinomial Bayesian inherence '''
+            counts = pd.DataFrame(index=self._obj.columns)
+            for column in self._obj.T:
+                p_matrix = ss.dirichlet.rvs(self._obj.T[column]+0.5, n_samples)
+                counts[column] = [np.mean(i) for i in zip(*p_matrix)]
+            return counts.T
+
+        def aitchison_mean(self):
+            ''' Return the Aitchison mean point estimate '''
+            return np.exp(sp.digamma(self._obj+1.0)).coda.closure(1.0)
+
+        def closure(self, cls_const):
+            ''' Apply Closure to composition '''
+            return cls_const*self._obj.divide(self._obj.sum(axis=1), axis=0)
+
+        def varmatrix(self, nmp=False):
+            '''
+                Calculate the total variation of a composition
+                TODO: for large datasets, this function blows up the memory.
+                This could be overcome by using a clever running variance
+                algorithm, alas I am lazy, so we estimate the variance by only
+                using a maximum of 500 entries. This can still be a problem if
+                dim[0] is large, so something needs to be done here. -- C.B.
+            '''
+            if self._check_for_zeros():
+                comp = self.aitchison_mean()
+            else:
+                comp = self._obj
+
+            # Quick fix: Estimate variance from at most 500 entries.
+            reduc = np.array(comp)[:min(500, np.shape(comp)[0]), :]
+
+            # New vectorized version. Faster than ketchup!
+            vrmtrx = np.var(np.log(reduc[:, :, None]*1./reduc[:, None]), axis=0)
+            if nmp:
+                return vrmtrx
+            return pd.DataFrame(vrmtrx, columns=self._obj.columns, index=self._obj.columns)
+
+        def totvar(self):
+            '''
+                Calculate the total variance from the variance matrix
+            '''
+            var_matrix = self.varmatrix(True)
+            return 1./(2*np.shape(var_matrix)[0]) * np.sum(var_matrix)
+
+        def gmean(self):
+            ''' Calculate the geometric mean '''
+            if self._check_for_zeros():
+                gmean = ss.mstats.gmean(self.aitchison_mean())
+            else:
+                gmean = ss.mstats.gmean(self._obj)
+            return np.array([100 * i / np.sum(gmean) for i in gmean])
+
+        def power(self, alpha):
+            ''' Compositional scalar multiplication'''
+            if self._check_for_zeros():
+                return pow(self.aitchison_mean(), alpha)
+            return pow(self._obj,alpha)
+
+        def perturbation(self, comp):
+            ''' Compositional addition with comp'''
+            if self._check_for_zeros():
+                return self.aitchison_mean()*np.array(comp)
+            return self._obj*np.array(comp)
+
+        def scale(self):
+            ''' Scale composition with total variance '''
+            return self.power(1./np.sqrt(self.totvar()))
+
+        def center(self):
+            ''' Center the composition '''
+            return self.perturbation(1./self.gmean())
+