def subs(self, *args):
        """Substitute a symbolic expression in ``['x', 'y', 'z']``

        This is a wrapper around the substitution mechanism of
        `sympy <http://docs.sympy.org/latest/tutorial/basic_operations.html>`_.
        Any symbolic expression in the columns
        ``['x', 'y', 'z']`` of ``self`` will be substituted
        with value.

        Args:
            symb_expr (sympy expression):
            value :
            perform_checks (bool): If ``perform_checks is True``,
                it is asserted, that the resulting Zmatrix can be converted
                to cartesian coordinates.
                Dummy atoms will be inserted automatically if necessary.

        Returns:
            Cartesian: Cartesian with substituted symbolic expressions.
            If all resulting sympy expressions in a column are numbers,
            the column is recasted to 64bit float.
        """
        cols = ['x', 'y', 'z']
        out = self.copy()

        def get_subs_f(*args):
            def subs_function(x):
                if hasattr(x, 'subs'):
                    x = x.subs(*args)
                    try:
                        x = float(x)
                    except TypeError:
                        pass
                return x
            return subs_function

        for col in cols:
            if out.loc[:, col].dtype is np.dtype('O'):
                out.loc[:, col] = out.loc[:, col].map(get_subs_f(*args))
                try:
                    out.loc[:, col] = out.loc[:, col].astype('f8')
                except (SystemError, TypeError):
                    pass
        return out