pyANOVAapprox 0.2.3__tar.gz → 2.0.0__tar.gz

{pyanovaapprox-0.2.3 → pyanovaapprox-2.0.0}/.github/workflows/ci.yml

@@ -27,6 +27,7 @@ jobs:
           pip install pyGroupedTransforms
           pip install numpy
           pip install scipy
+          pip install matplotlib
       - name: Run tests
         run: |
           python -m tests.run_tests

{pyanovaapprox-0.2.3 → pyanovaapprox-2.0.0}/.gitignore

@@ -6,6 +6,7 @@ dist/
 *.py[cod]
 __pycache__/
 venv/
+venv2/
 
 bin/
 /lib64/
@@ -16,3 +17,4 @@ src/pyNFFT3/lib/AVX2/libgomp-1.dll
 src/pyNFFT3/lib/AVX2/libgcc_s_seh-1.dll
 src/pyNFFT3/lib/AVX2/libwinpthread-1.dll
 simpleTest/venv/
+bandwidth_detection.py

{pyanovaapprox-0.2.3 → pyanovaapprox-2.0.0}/PKG-INFO

@@ -1,14 +1,15 @@
 Metadata-Version: 2.4
 Name: pyANOVAapprox
-Version: 0.2.3
+Version: 2.0.0
 Summary: Approximation Package for High-Dimensional Functions
 Project-URL: Homepage, https://github.com/NFFT/pyGroupedTransforms
 Author-email: Felix Wirth <fwi012001@gmail.com>
 Maintainer-email: Pascal Schröter <pascal.schroeter@mathematik.tu-chemnitz.de>
 License-File: LICENSE
 Requires-Python: >=3.9
+Requires-Dist: matplotlib>=3.5
 Requires-Dist: numpy>=2.0.0
-Requires-Dist: pygroupedtransforms>=0.1.0
+Requires-Dist: pygroupedtransforms>=1.1.0
 Requires-Dist: scipy>=1.16.0
 Description-Content-Type: text/markdown
 
@@ -67,3 +68,4 @@ Requirements
 - pyGroupedTransforms 0.1.0 or greater
 - NumPy 2.0.0 or greater
 - SciPy 1.16.0 or greater
+- Matplotlib 3.5 or greater

{pyanovaapprox-0.2.3 → pyanovaapprox-2.0.0}/README.md

@@ -53,3 +53,4 @@ Requirements
 - pyGroupedTransforms 0.1.0 or greater
 - NumPy 2.0.0 or greater
 - SciPy 1.16.0 or greater
+- Matplotlib 3.5 or greater

{pyanovaapprox-0.2.3 → pyanovaapprox-2.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyANOVAapprox"
-version = "0.2.3"
+version = "2.0.0"
 authors = [
   { name="Felix Wirth", email="fwi012001@gmail.com" },
 ]
@@ -15,9 +15,10 @@ description = "Approximation Package for High-Dimensional Functions"
 readme = "README.md"
 requires-python = ">=3.9"
 dependencies = [
-  "pyGroupedTransforms>=0.1.0",
+  "pyGroupedTransforms>=1.1.0",
   "numpy>=2.0.0",
   "scipy>=1.16.0",
+  "matplotlib>=3.5"
 ]
 
 [project.urls]

pyanovaapprox-2.0.0/simpleTest/exampleAutoapproximate.py

@@ -0,0 +1,66 @@
+# pip install pyANOVAapprox
+
+# Example for approximating an periodic function
+
+import math
+
+import matplotlib.pyplot as plt
+import numpy as np
+from TestFunctionPeriodic import *
+
+import pyANOVAapprox as ANOVAapprox
+
+
+def TestFunction(x):
+    return b_spline_2(x[0]) * b_spline_4(x[1]) * b_spline_6(x[2])
+
+
+rng = np.random.default_rng(1234)
+
+##################################
+## Definition of the parameters ##
+##################################
+
+d = 3  # dimension
+
+M = 100000  # number of used evaluation points to train the model
+M_test = 100000  # number of used evaluation points to test the accuracity the model
+
+U = [(), (0,), (1,), (2,), (0, 1), (0, 2), (1, 2), (0, 1, 2)]
+
+lambdas = np.array([0.0])  # used regularisation parameters λ
+
+############################
+## Generation of the data ##
+############################
+
+X = rng.random((M, d))  # construct the evaluation points for training
+y = np.array(
+    [TestFunction(X[i, :].T) for i in range(M)], dtype=complex
+)  # evaluate the function at these points
+X = X - 0.5
+X_test = rng.random((M_test, d))
+y_test = np.array(
+    [TestFunction(X_test[i, :].T) for i in range(M_test)], dtype=complex
+)  # the same for the test points
+X_test = X_test - 0.5
+
+##########################
+## Do the approximation ##
+##########################
+
+ads = ANOVAapprox.approx(X, y, U=U, basis="per")
+ads.autoapproximate()
+
+################################
+## get approximation accuracy ##
+################################
+
+# mse = ANOVAapprox.get_mse(ads) # get mse error at the given training points
+mse = ads.get_mse(X=X_test, y=y_test)  # get mse error at the test points
+λ_min = min(
+    mse, key=mse.get
+)  # get the regularisation parameter which leads to the minimal error
+mse_min = mse[λ_min]
+
+print("mse = " + str(mse_min))

{pyanovaapprox-0.2.3 → pyanovaapprox-2.0.0}/simpleTest/exampleCheb.py

@@ -103,7 +103,7 @@ print("mse = " + str(mse_min))
 ar = ANOVAapprox.get_AttributeRanking(ads, λ_min)  # get the attrbute ranking
 
 plt.figure()
-(markers, stemlines, baseline) = plt.stem(
+markers, stemlines, baseline = plt.stem(
     np.arange(1, d + 1),  # x-Werte (1:d)
     ar,  # y-Werte (ar)
     linefmt="C0-",  # Stil der Stiele
@@ -126,7 +126,7 @@ label = list(ads.U[1:])
 l = len(label)
 plt.figure()
 x_values = np.arange(1, l + 1)
-(markers, stemlines, baseline) = plt.stem(
+markers, stemlines, baseline = plt.stem(
     x_values,  # X-Werte: 1 bis l
     gsis,  # Y-Werte: gsis
     linefmt="C0-",  # Stil der Stiele

{pyanovaapprox-0.2.3 → pyanovaapprox-2.0.0}/simpleTest/exampleClassification.py

@@ -100,7 +100,7 @@ print("accuracity = " + str(acc))
 ar = ANOVAapprox.get_AttributeRanking(ads, 0.0)  # get the attrbute ranking
 
 plt.figure()
-(markers, stemlines, baseline) = plt.stem(
+markers, stemlines, baseline = plt.stem(
     np.arange(1, d + 1),  # x-Werte (1:d)
     ar,  # y-Werte (ar)
     linefmt="C0-",  # Stil der Stiele
@@ -123,7 +123,7 @@ label = list(ads.U[1:])
 l = len(label)
 plt.figure()
 x_values = np.arange(1, l + 1)
-(markers, stemlines, baseline) = plt.stem(
+markers, stemlines, baseline = plt.stem(
     x_values,  # X-Werte: 1 bis l
     gsis,  # Y-Werte: gsis
     linefmt="C0-",  # Stil der Stiele

{pyanovaapprox-0.2.3 → pyanovaapprox-2.0.0}/simpleTest/exampleNonPeriodic.py

@@ -101,7 +101,7 @@ print("mse = " + str(mse_min))
 ar = ANOVAapprox.get_AttributeRanking(ads, λ_min)  # get the attrbute ranking
 
 plt.figure()
-(markers, stemlines, baseline) = plt.stem(
+markers, stemlines, baseline = plt.stem(
     np.arange(1, d + 1),  # x-Werte (1:d)
     ar,  # y-Werte (ar)
     linefmt="C0-",  # Stil der Stiele
@@ -124,7 +124,7 @@ label = list(ads.U[1:])
 l = len(label)
 plt.figure()
 x_values = np.arange(1, l + 1)
-(markers, stemlines, baseline) = plt.stem(
+markers, stemlines, baseline = plt.stem(
     x_values,  # X-Werte: 1 bis l
     gsis,  # Y-Werte: gsis
     linefmt="C0-",  # Stil der Stiele

{pyanovaapprox-0.2.3 → pyanovaapprox-2.0.0}/simpleTest/examplePeriodic.py

@@ -90,7 +90,7 @@ ads.approximate(lam=lambdas, max_iter=max_iter, solver="lsqr")
 ################################
 
 # mse = ANOVAapprox.get_mse(ads) # get mse error at the given training points
-mse = ANOVAapprox.get_mse(ads, X_test, y_test)  # get mse error at the test points
+mse = ads.get_mse(X=X_test, y=y_test)  # get mse error at the test points
 λ_min = min(
     mse, key=mse.get
 )  # get the regularisation parameter which leads to the minimal error
@@ -103,10 +103,10 @@ print("mse = " + str(mse_min))
 ###############################################
 
 
-ar = ANOVAapprox.get_AttributeRanking(ads, λ_min)  # get the attrbute ranking
+ar = ads.get_AttributeRanking(lam=λ_min)  # get the attrbute ranking
 
 plt.figure()
-(markers, stemlines, baseline) = plt.stem(
+markers, stemlines, baseline = plt.stem(
     np.arange(1, d + 1),  # x-Werte (1:d)
     ar,  # y-Werte (ar)
     linefmt="C0-",  # Stil der Stiele
@@ -124,12 +124,12 @@ plt.grid(True, which="both", ls="--", linewidth=0.5)
 plt.show()  # plot the arrtibute ranking in an logplot
 print("active dimensions: " + str(ar[ar > 1e-2]))
 
-gsis = ANOVAapprox.get_GSI(ads, λ_min)
+gsis = ads.get_GSI(lam=λ_min)
 label = list(ads.U[1:])
 l = len(label)
 plt.figure()
 x_values = np.arange(1, l + 1)
-(markers, stemlines, baseline) = plt.stem(
+markers, stemlines, baseline = plt.stem(
     x_values,  # X-Werte: 1 bis l
     gsis,  # Y-Werte: gsis
     linefmt="C0-",  # Stil der Stiele
@@ -169,7 +169,7 @@ a.approximate(
     lam=lambdas, max_iter=max_iter, solver="lsqr"
 )  # do the approximation for all specified regularisation parameters
 
-mse = ANOVAapprox.get_mse(a, X_test, y_test)  # get mse error at the test points
+mse = a.get_mse(X=X_test, y=y_test)  # get mse error at the test points
 λ_min = min(
     mse, key=mse.get
 )  # get the regularisation parameter which leads to the minimal error

{pyanovaapprox-0.2.3 → pyanovaapprox-2.0.0}/simpleTest/exampleWavelet.py

@@ -84,14 +84,14 @@ print("Total number of used parameters = " + str(len(anova_model.fc[lambdas[0]].
 gsis = ANOVAapprox.get_GSI(
     anova_model, 0.0
 )  # calculates indices for importance of terms (gsis is vector, with indices belonging to terms in anova_model.U)
-gsis_as_dict = ANOVAapprox.get_GSI(anova_model,0.0,dict=true)
+gsis_as_dict = ANOVAapprox.get_GSI(anova_model, 0.0, dict=true)
 
 y_min_calc = 10 ** (np.min(np.log10(gsis)) - 0.5)
 label = list(anova_model.U[1:])
 l = len(label)
 plt.figure()
 x_values = np.arange(1, l + 1)
-(markers, stemlines, baseline) = plt.stem(
+markers, stemlines, baseline = plt.stem(
     x_values,  # X-Werte: 1 bis l
     gsis,  # Y-Werte: gsis
     linefmt="C0-",  # Stil der Stiele

pyanovaapprox-2.0.0/src/pyANOVAapprox/__init__.py

@@ -0,0 +1,165 @@
+import math
+import threading
+from math import acos, isnan
+
+import matplotlib.pyplot as plt
+import numpy as np
+from pyGroupedTransforms import *
+from scipy.optimize import bisect
+from scipy.sparse.linalg import lsqr
+from scipy.special import erf
+
+# from sklearn.metrics import roc_auc_score
+
+
+def bisection(l, r, fun, maxiter=1000):
+    lval = fun(l)
+    rval = fun(r)
+
+    if np.sign(lval) * np.sign(rval) == 1:
+        raise ValueError("bisection: root is not between l and r")
+
+    if lval > 0:
+        gun = fun
+        fun = lambda t: -gun(t)
+
+    m = 0.0
+    for _ in range(maxiter):
+        m = (l + r) / 2
+        mval = fun(m)
+        if abs(mval) < 1e-16:
+            break
+        if mval < 0:
+            l = m
+            lval = mval
+        else:
+            r = m
+            rval = mval
+
+    return m
+
+
+# from .analysis import *
+from .approx import *
+# from .errors import *
+# from .fista import *
+from .trafos import *
+
+# from .bandwidth import *
+
+
+def approximate(
+    a, lam=None, max_iter=50, weights=None, verbose=False, solver=None, tol=1e-8
+):
+    a.approximate(lam, max_iter, weights, verbose, solver, tol)
+
+
+def autoapproximate(
+    a,
+    settingnr=None,
+    B=None,
+    maxiter=2,
+    lmbda=0.0,
+    solver="lsqr",
+    verbose=False,
+    solver_max_iter=50,
+    solver_weights=None,
+    solver_verbose=False,
+    solver_tol=1e-8,
+):
+    a.autoapproximate(settingnr, B, maxiter, lmbda, solver, verbose)
+
+
+def evaluate(a, settingnr=None, lam=None, X=None):
+    return a.evaluate(settingnr, lam, X)
+
+
+def evaluateANOVAterms(a, settingnr=None, X=None, lam=None):
+    return a.evaluateANOVAterms(settingnr, X, lam)
+
+
+def evaluateSHAPterms(a, settingnr=None, X=None, lam=None):
+    return a.evaluateSHAPterms(settingnr, X, lam)
+
+
+def get_l2_error(a, settingnr=None, X=None, y=None, lam=None):
+    return a.get_l2_error(settingnr, X, y, lam)
+
+
+def get_mse(a, settingnr=None, X=None, y=None, lam=None):
+    return a.get_mse(settingnr, X, y, lam)
+
+
+def get_mad(a, settingnr=None, X=None, y=None, lam=None):
+    return a.get_mad(settingnr, X, y, lam)
+
+
+def get_L2_error(a, norm, bc_fun, settingnr=None, lam=None):
+    return a.get_L2_error(settingnr, norm, bc_fun, lam)
+
+
+def get_acc(a, settingnr=None, X=None, y=None, lam=None):
+    return a.get_acc(settingnr, X, y, lam)
+
+
+def get_auc(a, settingnr=None, X=None, y=None, lam=None):
+    return a.get_auc(settingnr, X, y, lam)
+
+
+def estimate_rates(a, lam, settingnr=None, verbose=False):
+    return a.estimate_rates(lam, settingnr, verbose)
+
+
+def get_variances(a, settingnr=None, lam=None, Dict=False):
+    return a.get_variances(settingnr, lam, Dict)
+
+
+def get_GSI(a, settingnr=None, lam=None, Dict=False):
+    return a.get_GSI(settingnr, lam, Dict)
+
+
+def get_AttributeRanking(a, settingnr=None, lam=None):
+    return a.get_AttributeRanking(settingnr, lam)
+
+
+def get_ActiveSet(a, eps, settingnr=None, lam=None):
+    return a.get_ActiveSet(eps, settingnr, lam)
+
+
+def get_ShapleyValues(a, settingnr=None, lam=None):
+    return a.get_ShapleyValues(settingnr, lam)
+
+
+# Export functions and classes:
+__all__ = [
+    # from Analysis.py:
+    "get_variances",
+    "get_GSI",
+    "get_AttributeRanking",
+    "get_ActiveSet",
+    "get_ShapleyValues",
+    # from approx.py:
+    "approx",
+    "approximate",
+    "autoapproximate",
+    "evaluate",
+    "evaluateANOVAterms",
+    # from Errors.py:
+    "get_l2_error",
+    "get_mse",
+    "get_mad",
+    "get_L2_error",
+    "get_acc",
+    "get_auc",
+    # from trafo.py:
+    "transform_cube",
+    "transform_R",
+    # from fista.py:
+    # "bisection",
+    # "newton",
+    # "λ2ξ",
+    # "fista",
+    # from bandwidth.py:
+    "compute_bandwidth",
+    "estimate_rates",
+]

{pyanovaapprox-0.2.3 → pyanovaapprox-2.0.0}/src/pyANOVAapprox/analysis.py

@@ -1,62 +1,74 @@
-from pyANOVAapprox import *
+# from pyANOVAapprox import *
+import numpy as np
 
 
-def get_variance(a, lam, Dict):  # helpfunction for get_variances
-
-    if a.basis.startswith("chui"):
-        variances = a.fc[lam].norms(Dict=False, m=int(a.basis[-1]))
+def _variances(self, settingnr, lam, Dict):  # helpfunction for get_variances
+    setting = self.getSetting(settingnr)
+    if setting.basis.startswith("chui"):
+        variances = self.getFc(settingnr)[lam].norms(
+            Dict=False, m=int(setting.basis[-1])
+        )
     else:
-        variances = a.fc[lam].norms()
+        variances = self.getFc(settingnr)[lam].norms()
 
     variances = variances[1:]
     if Dict:
         if a.basis.startswith("chui"):
-            variances = a.fc[lam].norms(Dict=True, m=int(a.basis[-1]))
+            variances = self.getFc(settingnr)[lam].norms(
+                Dict=True, m=int(setting.basis[-1])
+            )
         else:
-            variances = a.fc[lam].norms(Dict=True)
+            variances = self.getFc(settingnr)[lam].norms(Dict=True)
 
         return {u: variances[u] for u in list(variances)}
     else:
         return variances
 
 
-def get_variances(a, lam=None, Dict=False):
+def get_variances(self, settingnr=None, lam=None, Dict=False):
     """
     This function returns the variances of the approximated ANOVA terms for all ``\lambda``, if lam == None. Otherwise for the provided lam. Depending on Dict, it returns the approximated ANOVA terms as a vector or as a dict.
     """
     if isinstance(lam, float):
-        return get_variance(
-            a=a, lam=lam, Dict=Dict
+        return self._variances(
+            settingnr, lam, Dict
         )  # get_variances(a::approx, λ::Float64; dict::Bool=false,)::Union{Vector{Float64},Dict{Vector{Int},Float64}}
 
     elif (
         lam == None
     ):  # get_variances( a::approx; dict::Bool = false )::Dict{Float64,Union{Vector{Float64},Dict{Vector{Int},Float64}}}
-        return {l: get_variance(a=a, lam=l, Dict=Dict) for l in list(a.fc)}
-
-
-def _GSI(a, lam, Dict):  # helpfunction for get_GSI
-
-    if a.basis.startswith("chui"):
-        variances = np.square(a.fc[lam].norms(Dict=False, m=int(a.basis[-1])))
+        return {
+            l: self._variances(settingnr, l, Dict)
+            for l in self.getSetting(settingnr).lam
+        }
+
+
+def _GSI(self, settingnr, lam, Dict):  # helpfunction for get_GSI
+    setting = self.getSetting(settingnr)
+    if setting.basis.startswith("chui"):
+        variances = np.square(
+            self.getFc(settingnr)[lam].norms(Dict=False, m=int(setting.basis[-1]))
+        )
     else:
-        variances = np.square(a.fc[lam].norms())
+        variances = np.square(self.getFc(settingnr)[lam].norms())
 
     variances = variances[1:]
     variance_f = sum(variances)
 
     if Dict:
-        if a.basis.startswith("chui"):
-            variances = a.fc[lam].norms(Dict=True, m=int(a.basis[-1]))
+        if setting.basis.startswith("chui"):
+            variances = self.getFc(settingnr)[lam].norms(
+                Dict=True, m=int(setting.basis[-1])
+            )
         else:
-            variances = a.fc[lam].norms(Dict=True)
+            variances = self.getFc(settingnr)[lam].norms(Dict=True)
         return {u: (variances[u] ** 2) / variance_f for u in list(variances)}
 
     else:
         return variances / variance_f
 
 
-def get_GSI(a, lam=None, Dict=False):
+def get_GSI(self, settingnr=None, lam=None, Dict=False):
     """
     This function returns the global sensitivity indices of the approximation for all ``\lambda``, if lam == None. Otherwise for the provided lam. Depending on Dict, it returns the approximated ANOVA terms as a vector or as a dict.
     """
@@ -64,15 +76,17 @@ def get_GSI(a, lam=None, Dict=False):
     if (
         lam is not None
     ):  # get_GSI(a::approx, λ::Float64; dict::Bool = false,)::Union{Vector{Float64},Dict{Vector{Int},Float64}}
-        return _GSI(a=a, lam=lam, Dict=Dict)
+        return self._GSI(settingnr, lam, Dict)
     else:  # get_GSI( a::approx; dict::Bool = false )::Dict{Float64,Union{Vector{Float64},Dict{Vector{Int},Float64}}}
-        return {l: _GSI(a, l, Dict) for l in list(a.fc)}
+        return {
+            l: self._GSI(settingnr, l, Dict) for l in self.getSetting(settingnr).lam
+        }
 
 
-def lam_AttributeRanking(a, lam):  # helpfunction foor get_AttributeRanking
+def _AttributeRanking(self, settingnr, lam):  # helpfunction for get_AttributeRanking
 
-    d = a.X.shape[1]
-    gsis = get_GSI(a, lam, Dict=True)
+    d = self.X.shape[1]
+    gsis = self.get_GSI(settingnr, lam, Dict=True)
     U = list(gsis)
     lengths = [len(u) for u in U]
     ds = max(lengths)
@@ -99,28 +113,31 @@ def lam_AttributeRanking(a, lam):  # helpfunction foor get_AttributeRanking
     return r / nf
 
 
-def get_AttributeRanking(a, lam=None):
+def get_AttributeRanking(self, settingnr=None, lam=None):
     """
     This function returns the attribute ranking of the approximation for all reg. parameters ``\lambda``, if lam == None, as a dictionary of vectors of length `a.d`. Otherwise for the provided lam as a vector of length `a.d`.
     """
     if (
-        lam == None
+        lam is None
     ):  # get_AttributeRanking( a::approx, λ::Float64 )::Dict{Float64,Vector{Float64}}
-        return {l: get_AttributeRanking(a, l) for l in list(a.fc)}
+        return {
+            l: self._AttributeRanking(settingnr, l)
+            for l in self.getSetting(settingnr).lam
+        }
     else:  # get_AttributeRanking( a::approx, λ::Float64 )::Vector{Float64}
-        return lam_AttributeRanking(a=a, lam=lam)
+        return self._AttributeRanking(settingnr, lam)
 
 
-def lam_ActiveSet(a, eps, lam):  # helpfunction for get_ActiveSet
+def _ActiveSet(self, eps, settingnr, lam):  # helpfunction for get_ActiveSet
 
-    U = a.U[1:]
+    U = self.getSetting(settingnr).U[1:]
     lengths = [len(u) for u in U]
     ds = max(lengths)
 
     if len(eps) != ds:
         raise ValueError("Entries in vector eps have to be ds.")
 
-    gsi = get_GSI(a, lam)
+    gsi = self.get_GSI(settingnr, lam)
 
     n = 0
 
@@ -140,20 +157,23 @@ def lam_ActiveSet(a, eps, lam):  # helpfunction for get_ActiveSet
     return U_active
 
 
-def get_ActiveSet(a, eps, lam=None):
+def get_ActiveSet(self, eps, settingnr=None, lam=None):
 
     if (
-        lam == None
+        lam is None
     ):  # get_ActiveSet(a::approx, eps::Vector{Float64})::Dict{Float64,Vector{Vector{Int}}}
-        return {l: lam_ActiveSet(a=a, eps=eps, lam=l) for l in list(a.fc)}
+        return {
+            l: self._ActiveSet(eps, settingnr, l)
+            for l in self.getSetting(settingnr).lam
+        }
     else:  # get_ActiveSet(a::approx, eps::Vector{Float64}, λ::Float64)::Vector{Vector{Int}}
-        return lam_ActiveSet(a=a, eps=eps, lam=lam)
+        return self._ActiveSet(eps, settingnr, lam)
 
 
-def lam_ShapleyValues(a, lam):  # helpfunction for get_ShapleyValues
+def _ShapleyValues(self, settingnr, lam):  # helpfunction for get_ShapleyValues
 
-    d = a.X.shape[1]
-    vars_dict = get_variances(a, lam, Dict=True)
+    d = self.X.shape[1]
+    vars_dict = get_variances(self, settingnr, lam, Dict=True)
     U = list(vars_dict)
     r = np.zeros(d)
 
@@ -165,11 +185,27 @@ def lam_ShapleyValues(a, lam):  # helpfunction for get_ShapleyValues
     return r
 
 
-def get_ShapleyValues(a, lam=None):
+def get_ShapleyValues(self, settingnr=None, lam=None):
     """
     This function returns the Shapley values of the approximation for all reg. parameters ``\lambda``, if lam == None, as a dictionary of vectors of length `a.d`. Otherwise for the provided lam as a vector of length `a.d`.
     """
-    if lam == None:  # get_ShapleyValues(a::approx)::Dict{Float64,Vector{Float64}}
-        return {l: lam_ShapleyValues(a=a, lam=l) for l in list(a.fc)}
+    if lam is None:  # get_ShapleyValues(a::approx)::Dict{Float64,Vector{Float64}}
+        return {
+            l: self._ShapleyValues(settingnr, l) for l in self.getSetting(settingnr).lam
+        }
     else:  # get_ShapleyValues(a::approx, λ::Float64)::Vector{Float64}
-        return lam_ShapleyValues(a=a, lam=lam)
+        return self._ShapleyValues(settingnr, lam)
+
+
+_all = [
+    "_variances",
+    "get_variances",
+    "_GSI",
+    "get_GSI",
+    "_AttributeRanking",
+    "get_AttributeRanking",
+    "_ActiveSet",
+    "get_ActiveSet",
+    "_ShapleyValues",
+    "get_ShapleyValues",
+]