pyANOVAapprox 2.0.2__tar.gz → 2.0.4__tar.gz

{pyanovaapprox-2.0.2 → pyanovaapprox-2.0.4}/.github/workflows/documentation.yml

@@ -10,20 +10,28 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+
       - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
       - name: Install dependencies
         run: |
           pip install sphinx sphinx_rtd_theme myst_parser
+          # WICHTIG: Wenn dein Code Abhängigkeiten hat (z.B. numpy, scipy), 
+          # installiere sie hier, sonst kann 'autodoc' den Code nicht importieren!
+          # pip install -e . 
+
       - name: Sphinx build
         run: |
           cd docs
           sphinx-apidoc -o ./source ../src -f
           make html
+
       - name: Deploy to GitHub Pages
-        uses: peaceiris/actions-gh-pages@v3
+        uses: peaceiris/actions-gh-pages@v4
         if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
         with:
-          publish_branch: gh-pages
           github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: docs/build/html
-          force_orphan: true
+          publish_dir: docs/build/html 
+          force_orphan: true

pyanovaapprox-2.0.4/.github/workflows/format.yml

@@ -0,0 +1,42 @@
+name: Format Python Code
+
+on:
+  push:
+    branches:
+      - '**'        # Läuft bei jedem Push auf absolut jeden Branch...
+    tags-ignore:
+      - '**'        # ...ABER ignoriert jeden Push, der ein Tag (Release) ist.
+
+jobs:
+  python-code-format:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4 
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          architecture: "x64"
+          
+      - name: Display Python version
+        run: python --version
+        
+      - name: Install packages
+        run: pip install black isort
+        
+      - name: Formatter
+        run: |
+          black .
+          isort .
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v6
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          commit-message: "style: auto code format"
+          title: "Fixes by format action"
+          body: "This is an auto-generated PR with code formatting fixes."
+          labels: automated pr
+          branch: python-code-format-patches

{pyanovaapprox-2.0.2 → pyanovaapprox-2.0.4}/.gitignore

@@ -7,6 +7,7 @@ dist/
 __pycache__/
 venv/
 venv2/
+.venv/
 
 bin/
 /lib64/
@@ -17,4 +18,6 @@ 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
+bandwidth_detection*
+cross_validation*
+/src/pyANOVAapprox/.ipynb_checkpoints/

{pyanovaapprox-2.0.2 → pyanovaapprox-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyANOVAapprox
-Version: 2.0.2
+Version: 2.0.4
 Summary: Approximation Package for High-Dimensional Functions
 Project-URL: Homepage, https://github.com/NFFT/pyGroupedTransforms
 Author-email: Felix Wirth <fwi012001@gmail.com>

{pyanovaapprox-2.0.2 → pyanovaapprox-2.0.4}/docs/source/conf.py

@@ -3,6 +3,13 @@
 # For the full list of built-in configuration values, see the documentation:
 # https://www.sphinx-doc.org/en/master/usage/configuration.html
 
+import os
+import sys
+
+# -- Path setup --------------------------------------------------------------
+# Macht den src-Ordner für Sphinx und autodoc auffindbar
+sys.path.insert(0, os.path.abspath("../../src"))
+
 # -- Project information -----------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
@@ -14,7 +21,13 @@ release = "29.07.2025"
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
 
-extensions = ["sphinx.ext.mathjax"]
+# Erweiterungen hinzugefügt, damit automodule, Mathe und Markdown funktionieren
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.napoleon",  # Unterstützt Google/NumPy-Style Docstrings
+    "sphinx.ext.mathjax",
+    "myst_parser",
+]
 
 templates_path = ["_templates"]
 exclude_patterns = []
@@ -23,5 +36,6 @@ exclude_patterns = []
 # -- Options for HTML output -------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
 
-html_theme = "alabaster"
+# Auf das im Workflow genutzte Theme umgestellt
+html_theme = "sphinx_rtd_theme"
 html_static_path = ["_static"]

{pyanovaapprox-2.0.2 → pyanovaapprox-2.0.4}/docs/source/index.rst

@@ -16,6 +16,5 @@ documentation for details.
    :caption: Contents:
 
    Analysis
-   Approximation
-   Errors
-
+   modules
+   Errors

{pyanovaapprox-2.0.2 → pyanovaapprox-2.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyANOVAapprox"
-version = "2.0.2"
+version = "2.0.4"
 authors = [
   { name="Felix Wirth", email="fwi012001@gmail.com" },
 ]

{pyanovaapprox-2.0.2 → pyanovaapprox-2.0.4}/simpleTest/exampleNonPeriodic.py

@@ -150,7 +150,9 @@ print(
 ################################################
 
 Umask = np.append(np.array([True]), gsis > 1e-2)
-U = [ads.getSetting().U[i] for i in np.arange(0, len(Umask))[Umask]]  # get important subsets
+U = [
+    ads.getSetting().U[i] for i in np.arange(0, len(Umask))[Umask]
+]  # get important subsets
 bws = M / (math.log10(M) * (len(U) - 1))  # calculate frequencies per subset
 N = [
     math.floor(bws ** (1 / max(1, len(u))) / 2) * 2 for u in U

{pyanovaapprox-2.0.2 → pyanovaapprox-2.0.4}/simpleTest/exampleWavelet.py

@@ -74,20 +74,23 @@ anova_model = ANOVAapprox.approx(X, y, ds=q, basis=basis, N=N)
 
 ####  Do approximation by least-squares ###
 anova_model.approximate(lam=lambdas, solver="lsqr")
-print("Total number of used parameters = " + str(len(anova_model.fc[lambdas[0]].vec())))
+print(
+    "Total number of used parameters = "
+    + str(len(anova_model.getFc()[lambdas[0]].vec()))
+)
 
 #######################
 ## Analyze the model ##
 #######################
 
 ### Do sensitivity analysis ####
-anova_model.get_GSI(
-  lam=0.0
-)  # calculates indices for importance of terms (gsis is vector, with indices belonging to terms in anova_model.U)
-anova_model.get_GSI(lam=0.0, Dict=true)
+gsis = anova_model.get_GSI(
+    lam=0.0
+)  # calculates indices for importance of terms (gsis is vector, with indices belonging to terms in anova_model.getSetting().U)
+anova_model.get_GSI(lam=0.0, Dict=True)
 
 y_min_calc = 10 ** (np.min(np.log10(gsis)) - 0.5)
-label = list(anova_model.U[1:])
+label = list(anova_model.getSetting().U[1:])
 l = len(label)
 plt.figure()
 x_values = np.arange(1, l + 1)
@@ -128,7 +131,10 @@ anova_model = anova_model.approx(
     X=X, y=y, U=U, N=[i + 2 for i in N], basis=basis
 )  # increase number of paramers in N for the important terms
 anova_model.approximate(lam=lambdas)
-print("Total number of used parameters = " + str(len(anova_model.fc[lambdas[0]].vec())))
+print(
+    "Total number of used parameters = "
+    + str(len(anova_model.getFc()[lambdas[0]].vec()))
+)
 mse_train = anova_model.get_mse(lam=0.0)
 mse_test = anova_model.get_mse(X=X_test, y=y_test, lam=0.0)
 print("MSE on test points after ANOVA truncation: " + str(mse_test))

{pyanovaapprox-2.0.2 → pyanovaapprox-2.0.4}/src/pyANOVAapprox/analysis.py

@@ -3,22 +3,22 @@ import numpy as np
 
 
 def _variances(self, settingnr, lam, Dict):  # helpfunction for get_variances
-    setting = self.getSetting(settingnr)
+    setting = self.getSetting(settingnr, lam)
     if setting.basis.startswith("chui"):
-        variances = self.getFc(settingnr)[lam].norms(
+        variances = self.getFc(settingnr, lam)[lam].norms(
             Dict=False, m=int(setting.basis[-1])
         )
     else:
-        variances = self.getFc(settingnr)[lam].norms()
+        variances = self.getFc(settingnr, lam)[lam].norms()
 
     variances = variances[1:]
     if Dict:
         if a.basis.startswith("chui"):
-            variances = self.getFc(settingnr)[lam].norms(
+            variances = self.getFc(settingnr, lam)[lam].norms(
                 Dict=True, m=int(setting.basis[-1])
             )
         else:
-            variances = self.getFc(settingnr)[lam].norms(Dict=True)
+            variances = self.getFc(settingnr, lam)[lam].norms(Dict=True)
 
         return {u: variances[u] for u in list(variances)}
     else:
@@ -37,31 +37,28 @@ def get_variances(self, settingnr=None, lam=None, Dict=False):
     elif (
         lam == None
     ):  # get_variances( a::approx; dict::Bool = false )::Dict{Float64,Union{Vector{Float64},Dict{Vector{Int},Float64}}}
-        return {
-            l: self._variances(settingnr, l, Dict)
-            for l in self.getSetting(settingnr).lam
-        }
+        return {l: self._variances(settingnr, l, Dict) for l in self.lam.keys()}
 
 
 def _GSI(self, settingnr, lam, Dict):  # helpfunction for get_GSI
-    setting = self.getSetting(settingnr)
+    setting = self.getSetting(settingnr, lam)
     if setting.basis.startswith("chui"):
         variances = np.square(
-            self.getFc(settingnr)[lam].norms(Dict=False, m=int(setting.basis[-1]))
+            self.getFc(settingnr, lam)[lam].norms(Dict=False, m=int(setting.basis[-1]))
         )
     else:
-        variances = np.square(self.getFc(settingnr)[lam].norms())
+        variances = np.square(self.getFc(settingnr, lam)[lam].norms())
 
     variances = variances[1:]
     variance_f = sum(variances)
 
     if Dict:
         if setting.basis.startswith("chui"):
-            variances = self.getFc(settingnr)[lam].norms(
+            variances = self.getFc(settingnr, lam)[lam].norms(
                 Dict=True, m=int(setting.basis[-1])
             )
         else:
-            variances = self.getFc(settingnr)[lam].norms(Dict=True)
+            variances = self.getFc(settingnr, lam)[lam].norms(Dict=True)
         return {u: (variances[u] ** 2) / variance_f for u in list(variances)}
 
     else:
@@ -78,9 +75,7 @@ def get_GSI(self, settingnr=None, lam=None, Dict=False):
     ):  # get_GSI(a::approx, λ::Float64; dict::Bool = false,)::Union{Vector{Float64},Dict{Vector{Int},Float64}}
         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: self._GSI(settingnr, l, Dict) for l in self.getSetting(settingnr).lam
-        }
+        return {l: self._GSI(settingnr, l, Dict) for l in self.lam.keys()}
 
 
 def _AttributeRanking(self, settingnr, lam):  # helpfunction for get_AttributeRanking
@@ -120,17 +115,14 @@ def get_AttributeRanking(self, settingnr=None, lam=None):
     if (
         lam is None
     ):  # get_AttributeRanking( a::approx, λ::Float64 )::Dict{Float64,Vector{Float64}}
-        return {
-            l: self._AttributeRanking(settingnr, l)
-            for l in self.getSetting(settingnr).lam
-        }
+        return {l: self._AttributeRanking(settingnr, l) for l in self.lam.keys()}
     else:  # get_AttributeRanking( a::approx, λ::Float64 )::Vector{Float64}
         return self._AttributeRanking(settingnr, lam)
 
 
 def _ActiveSet(self, eps, settingnr, lam):  # helpfunction for get_ActiveSet
 
-    U = self.getSetting(settingnr).U[1:]
+    U = self.getSetting(settingnr, lam).U[1:]
     lengths = [len(u) for u in U]
     ds = max(lengths)
 
@@ -162,10 +154,7 @@ def get_ActiveSet(self, eps, settingnr=None, lam=None):
     if (
         lam is None
     ):  # get_ActiveSet(a::approx, eps::Vector{Float64})::Dict{Float64,Vector{Vector{Int}}}
-        return {
-            l: self._ActiveSet(eps, settingnr, l)
-            for l in self.getSetting(settingnr).lam
-        }
+        return {l: self._ActiveSet(eps, settingnr, l) for l in self.lam.keys()}
     else:  # get_ActiveSet(a::approx, eps::Vector{Float64}, λ::Float64)::Vector{Vector{Int}}
         return self._ActiveSet(eps, settingnr, lam)
 
@@ -190,9 +179,7 @@ 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 is None:  # get_ShapleyValues(a::approx)::Dict{Float64,Vector{Float64}}
-        return {
-            l: self._ShapleyValues(settingnr, l) for l in self.getSetting(settingnr).lam
-        }
+        return {l: self._ShapleyValues(settingnr, l) for l in self.lam.keys()}
     else:  # get_ShapleyValues(a::approx, λ::Float64)::Vector{Float64}
         return self._ShapleyValues(settingnr, lam)
 

{pyanovaapprox-2.0.2 → pyanovaapprox-2.0.4}/src/pyANOVAapprox/approx.py

@@ -1,4 +1,5 @@
 import copy
+import warnings
 
 import pyANOVAapprox.analysis as ANOVAanalysis
 import pyANOVAapprox.bandwidth as ANOVAbandwidth
@@ -186,8 +187,13 @@ class approx:
         lam={0.0},
     ):
 
+        if type(lam) is np.ndarray:
+            lam = {float(i) for i in lam}
+        if type(lam) is list:
+            lam = set(lam)
+
         self.X = X
-        
+
         if X.shape[0] != y.shape[0]:
             raise ValueError("X and y have different lengths.")
 
@@ -222,6 +228,9 @@ class approx:
         self.trafo = [None]
         self.fc = [{}]
         self.aktsetting = 0
+        self.lam = {}
+        for i in lam:
+            self.lam[i] = [0]
 
         if setting.N is not None:
             self.addTrafo()
@@ -233,17 +242,24 @@ class approx:
         self.trafo.append(None)
         self.fc.append({})
 
-    def getSettingNr(self, settingnr=None):
-        return self.aktsetting if settingnr is None else settingnr
+    def getSettingNr(self, settingnr=None, lam=None, warn=True):
+        if lam is None:
+            return self.aktsetting if settingnr is None else settingnr
+        else:
+            if lam in self.lam.keys():
+                return self.lam[lam][-1] if settingnr is None else settingnr
+            else:
+                warnings.warn("Not yet approximated for this lambda")
+                return self.aktsetting if settingnr is None else settingnr
 
-    def getSetting(self, settingnr=None):
-        return self.setting[self.getSettingNr(settingnr)]
+    def getSetting(self, settingnr=None, lam=None):
+        return self.setting[self.getSettingNr(settingnr, lam)]
 
-    def getTrafo(self, settingnr=None):
-        return self.trafo[self.getSettingNr(settingnr)]
+    def getTrafo(self, settingnr=None, lam=None):
+        return self.trafo[self.getSettingNr(settingnr, lam)]
 
-    def getFc(self, settingnr=None):
-        return self.fc[self.getSettingNr(settingnr)]
+    def getFc(self, settingnr=None, lam=None):
+        return self.fc[self.getSettingNr(settingnr, lam)]
 
     def addTrafo(self, settingnr=None):
         setting = self.getSetting(settingnr)
@@ -356,6 +372,7 @@ class approx:
         If lam is a np.ndarray of dtype float, this function computes the approximation for the regularization parameters contained in lam.
         If lam is a float, this function computes the approximation for the regularization parameter lam.
         """
+
         setting = self.getSetting(settingnr)
 
         if lam is None:
@@ -393,6 +410,7 @@ class approx:
         solver_verbose,
         solver_tol,
     ):
+        settingnrs = []
         setting = self.getSetting(settingnr)
 
         n = len(self.y)
@@ -401,13 +419,14 @@ class approx:
 
         D = dict([(u, tuple([1.0] * len(u))) for u in setting.U])
         t = dict([(u, tuple([1.0] * len(u))) for u in setting.U])
-        
-        if verbosity>3:
+
+        if verbosity > 3:
             if not os.path.exists("log"):
                 os.mkdir("log")
-            with open('log/log.csv', 'w', newline='') as csvfile:
-                csv.writer(csvfile, delimiter=',').writerow(["it"] + setting.U)
-
+            with open("log/log.csv", "w", newline="") as csvfile:
+                csv.writer(csvfile, delimiter=",").writerow(["it"] + setting.U)
+        if verbosity > 2:
+            print("B =", B)
         for idx in range(maxiter):
             if verbosity > 0:
                 print("===== Iteration ", str(idx + 1), " =====")
@@ -415,6 +434,7 @@ class approx:
             if setting.N is not None:
                 self.addSetting(setting)
                 settingnr = self.aktsetting
+                settingnrs = settingnrs + [settingnr]
                 setting = self.getSetting(settingnr)
 
             setting.N = [bw[i] for i in setting.U]
@@ -423,11 +443,13 @@ class approx:
             if verbosity > 0:
                 for i in setting.U:
                     print("bw in", str(i), ":", bw[i])
-                #print("bw in iteration", str(idx + 1), "are", str(bw))
+                # print("bw in iteration", str(idx + 1), "are", str(bw))
                 print()
             if verbosity > 3:
-                with open('log/log.csv', 'a', newline='') as csvfile:
-                    csv.writer(csvfile, delimiter=',').writerow(["bw in it"+str(idx+1)] + [str(bw[i]) for i in setting.U])
+                with open("log/log.csv", "a", newline="") as csvfile:
+                    csv.writer(csvfile, delimiter=",").writerow(
+                        ["bw in it" + str(idx + 1)] + [str(bw[i]) for i in setting.U]
+                    )
             self.approximate(
                 lam=lam,
                 solver=solver,
@@ -440,23 +462,39 @@ class approx:
             D, t = self.estimate_rates(lam=lam, verbosity=verbosity)
             if verbosity > 1:
                 for i in setting.U:
-                    print("estimated rates for", str(i), ": D = ", str(D[i]), "and t = ", str(t[i]) )
+                    print(
+                        "estimated rates for",
+                        str(i),
+                        ": D = ",
+                        str(D[i]),
+                        "and t = ",
+                        str(t[i]),
+                    )
                 print()
-                
-                #print(
+
+                # print(
                 #    "estimated rates in iteration",
                 #    str(idx + 1),
                 #    "are D =",
                 #    str(D),
                 #    "and t =",
                 #    str(t),
-                #)
+                # )
             if verbosity > 3:
-                with open('log/log.csv', 'a', newline='') as csvfile:
-                    wr = csv.writer(csvfile, delimiter=',')
-                    wr.writerow(["D in it"+str(idx+1)] + [str(D[i]) for i in setting.U])
-                    wr.writerow(["t in it"+str(idx+1)] + [str(t[i]) for i in setting.U])
-        return D, t
+                with open("log/log.csv", "a", newline="") as csvfile:
+                    wr = csv.writer(csvfile, delimiter=",")
+                    wr.writerow(
+                        ["D in it" + str(idx + 1)] + [str(D[i]) for i in setting.U]
+                    )
+                    wr.writerow(
+                        ["t in it" + str(idx + 1)] + [str(t[i]) for i in setting.U]
+                    )
+
+            if all([math.isnan(j) for j in sum([D[i] for i in D], [])]) and all(
+                [math.isnan(j) for j in sum([t[i] for i in D], [])]
+            ):
+                break
+        return settingnrs
 
     def autoapproximate(
         self,
@@ -471,18 +509,21 @@ class approx:
         solver_verbose=False,
         solver_tol=1e-8,
     ):
+        settingnr = self.getSettingNr(settingnr)
         setting = self.getSetting(settingnr)
 
         if lam is None:
             lam = setting.lam
         else:
+            if isinstance(lam, np.ndarray):
+                lam = {float(l) for l in lam}
             if not isinstance(lam, set):
                 lam = {lam}
             setting.lam = lam
 
-        if len(lam) == 1:
-            return self._autoapproximate(
-                lam.pop(),
+        for l in lam:
+            settingnrs = self._autoapproximate(
+                l,
                 settingnr=settingnr,
                 B=B,
                 maxiter=maxiter,
@@ -493,22 +534,7 @@ class approx:
                 solver_verbose=solver_verbose,
                 solver_tol=solver_tol,
             )
-        else:
-            return {
-                l: self._autoapproximate(
-                    l,
-                    settingnr=settingnr,
-                    B=B,
-                    maxiter=maxiter,
-                    solver=solver,
-                    verbosity=verbosity,
-                    solver_max_iter=solver_max_iter,
-                    solver_weights=solver_weights,
-                    solver_verbose=solver_verbose,
-                    solver_tol=solver_tol,
-                )
-                for l in lam
-            }
+            self.lam[l] = self.lam[l] + settingnrs
 
     def evaluate(self, settingnr=None, lam=None, X=None):
         """
@@ -519,7 +545,7 @@ class approx:
         - If only lam is given: evaluate at self.X for specific lam.
         - If neither are given: evaluate at self.X for all lam.
         """
-        setting = self.getSetting(settingnr)
+        setting = self.getSetting(settingnr, lam)
 
         if X is not None:
             if setting.basis == "per" and (np.min(X) < -0.5 or np.max(X) >= 0.5):
@@ -537,14 +563,14 @@ class approx:
                 basis_vect=setting.basis_vect,
             )
         else:
-            trafo = self.getTrafo(settingnr)
+            trafo = self.getTrafo(settingnr, lam)
 
         if (
             lam is not None
         ):  # evaluate( a::approx; X::Matrix{Float64}, λ::Float64 )::Union{Vector{ComplexF64},Vector{Float64}}
-            return trafo @ self.getFc(settingnr)[lam]
+            return trafo @ self.getFc(settingnr, lam)[lam]
         else:  # evaluate( a::approx; X::Matrix{Float64} )::Dict{Float64,Union{Vector{ComplexF64},Vector{Float64}}}
-            return {λ: trafo @ self.getFc(settingnr)[λ] for λ in setting.lam}
+            return {λ: trafo @ self.getFc(settingnr, lam)[λ] for λ in self.lam.keys()}
 
     def evaluateANOVAterms(self, settingnr=None, X=None, lam=None):
         """
@@ -553,7 +579,7 @@ class approx:
         - If lam is given: evaluate at X for specific lam.
         - If lam is not given: evaluate at X for all lam.
         """
-        setting = self.getSetting(settingnr)
+        setting = self.getSetting(settingnr, lam)
         if X is None:
             X = self.X
 
@@ -567,9 +593,11 @@ class approx:
         Xt = transformX(X, setting.basis)
 
         if self.getSetting(settingnr).basis == "per":
-            values = np.zeros((Xt.shape[0], len(self.setting[settingnr].U)), "complex")
+            values = np.zeros(
+                (Xt.shape[0], len(self.getSetting(settingnr).U)), "complex"
+            )
         else:
-            values = np.zeros((Xt.shape[0], len(self.setting[settingnr].U)), "float")
+            values = np.zeros((Xt.shape[0], len(self.getSetting(settingnr).U)), "float")
 
         trafo = GroupedTransform(
             system=gt_systems[setting.basis],
@@ -583,14 +611,14 @@ class approx:
             lam is not None
         ):  # evaluateANOVAterms( a::approx; X::Matrix{Float64}, λ::Float64 )::Union{Matrix{ComplexF64},Matrix{Float64}}
             for j, u in enumerate(setting.U):
-                values[:, j] = trafo[u] @ self.getFc(settingnr)[lam][u]
+                values[:, j] = trafo[u] @ self.getFc(settingnr, lam)[lam][u]
             return values
         else:  # evaluateANOVAterms( a::approx; X::Matrix{Float64} )::Dict{Float64,Union{Matrix{ComplexF64},Matrix{Float64}}}
             results = {}
-            for λ in setting.lam:
+            for λ in self.lam.keys():
                 vals = np.zeros_like(values)
                 for j, u in enumerate(setting.U):
-                    vals[:, j] = trafo[u] @ self.getFc(settingnr)[λ][u]
+                    vals[:, j] = trafo[u] @ self.getFc(settingnr, lam)[λ][u]
                 results[λ] = vals
             return results
 
@@ -601,7 +629,7 @@ class approx:
         - If lam is given: evaluate at X for specific lam.
         - If lam is not given: evaluate at X for all lam.
         """
-        setting = self.getSetting(settingnr)
+        setting = self.getSetting(settingnr, lam)
 
         if X is None:
             X = self.X
@@ -631,7 +659,7 @@ class approx:
 
         else:  # evaluateSHAPterms( a::approx; X::Matrix{Float64} )::Dict{Float64,Union{Matrix{ComplexF64},Matrix{Float64}}}
             results = {}
-            for l in setting.lam:
+            for l in self.lam.keys():
                 terms = self.evaluateANOVAterms(X, l)
 
                 Dtype = np.complex128 if setting.basis == "per" else np.float64

{pyanovaapprox-2.0.2 → pyanovaapprox-2.0.4}/src/pyANOVAapprox/bandwidth.py

@@ -5,11 +5,11 @@ def getfcu(ghat, u):
     idx = [s.u for s in ghat.settings].index(u)
     bws = ghat.settings[idx].bandwidths
 
-    #fcu = ghat[u].reshape(bws[::-1] - 1)
-    #fcu = np.permute_dims(fcu, range(len(bws))[::-1])
+    # fcu = ghat[u].reshape(bws[::-1] - 1)
+    # fcu = np.permute_dims(fcu, range(len(bws))[::-1])
     fcu = ghat[u].reshape(bws - 1)
     fcu = np.permute_dims(fcu, range(len(bws)))
-    
+
     return fcu
 
 
@@ -30,6 +30,9 @@ def getaxissum(ghat, u, j, system):
     else:
         raise ValueError("For this basis is estimate rates not implemented")
     # fcuj = np.concatenate(fcuj[math.ceil(bws[j]/2):] + [fcuj[0]]) + fcuj[math.ceil(bws[j]/2)-1::-1]
+
+    fcuj = np.cumsum(fcuj[::-1])[::-1]
+
     return fcuj
 
 
@@ -37,13 +40,14 @@ def compute_bandwidth(B, D, t):
     us = set(D.keys()) - {()}
     bw = {u: [6] * len(u) for u in us}
     bw[()] = []
-    
+
     minfreqs = sum(math.prod((bw[u][j] - 1) for j in range(len(u))) for u in us)
     if B < minfreqs:
         raise ValueError(f"Budget too small: {B} < {minfreqs}")
 
     def fun_lmbda_u(lmbda, u):
-        p1 = math.prod((bw[u][j] - 1) for j in range(len(u)) if math.isnan(t[u][j]))
+        p1 = math.prod((bw[u][j] - 1) for j in range(len(u)) if not math.isnan(t[u][j]))
+
         p2 = math.prod(
             ((2 * t[u][j] * D[u][j]) / lmbda) ** (0.5 / t[u][j])
             for j in range(len(u))
@@ -69,7 +73,7 @@ def compute_bandwidth(B, D, t):
                 bwuj = ((2 * t[u][j] * D[u][j]) / (lmbda * sizeIu)) ** (
                     0.5 / t[u][j]
                 ) + 1
-                bw[u][j] = 2 * round(0.5 * bwuj)
+                bw[u][j] = max(6, 2 * round(0.5 * bwuj))
 
     return bw
 
@@ -123,19 +127,19 @@ def estimate_rates(self, lam, settingnr=None, verbosity=0):
 
     mcl = np.exp(most_common_value(np.log(abs(self.getFc(settingnr)[lam].data))))
     threshold = 100 * mcl**2
-    
-    if verbosity>5:
-        if not os.path.exists(os.path.join("log","figures")):
-            os.mkdir(os.path.join("log","figures"))
+
+    if verbosity > 5:
+        if not os.path.exists(os.path.join("log", "figures")):
+            os.mkdir(os.path.join("log", "figures"))
         num = 0
-        
+
     system = self.getTrafo(settingnr).system
 
     for u in us:
         if len(u) == 0:
             continue
 
-        if verbosity>5:
+        if verbosity > 5:
             fig, ax = plt.subplots()
             ax.set_xscale("log")
             ax.set_yscale("log")
@@ -154,17 +158,16 @@ def estimate_rates(self, lam, settingnr=None, verbosity=0):
                 None,
             )
 
-            if verbosity>5:
+            if verbosity > 5:
 
                 y = np.cumsum(axissum[::-1])[::-1]
                 ax.plot(
-                    range(1, len(y) + 1),
-                    y,
+                    axissumnum,
+                    axissum,
                     label=u[j],
                     marker="o",
                     #                    color=j
                 )
-
             if (idx is None) or idx >= len(axissum):
                 D[u][j] = math.nan
                 t[u][j] = math.nan
@@ -174,7 +177,7 @@ def estimate_rates(self, lam, settingnr=None, verbosity=0):
                 D[u][j] = Duj
                 t[u][j] = -tuj / 2
 
-                if verbosity>5:
+                if verbosity > 5:
                     x = np.arange(1, idx + 1)
                     ax.plot(
                         x,
@@ -182,12 +185,23 @@ def estimate_rates(self, lam, settingnr=None, verbosity=0):
                         linewidth=2,
                         #                        color=j
                     )
-        if verbosity>5:
-            #plt.figure(figsize=(12, 9))
-            #for ax in ps:
+        if verbosity > 5:
+            # plt.figure(figsize=(12, 9))
+            # for ax in ps:
             #    plt.sca(ax)
-            fig.savefig(os.path.join("log","figures", str(num).strip()+ "_rates_" + str(u).strip() + ".png"))
+            time = ""
+            if verbosity > 8:
+                from datetime import datetime
+
+                time = str(round(datetime.timestamp(datetime.now())))
+            fig.savefig(
+                os.path.join(
+                    "log",
+                    "figures",
+                    time + "_" + str(num).strip() + "_rates_" + str(u).strip() + ".png",
+                )
+            )
             num = num + 1
-            plt.close(fig) 
+            plt.close(fig)
 
     return D, t

{pyanovaapprox-2.0.2 → pyanovaapprox-2.0.4}/src/pyANOVAapprox/errors.py

@@ -37,10 +37,7 @@ def get_l2_error(self, settingnr=None, X=None, y=None, lam=None):
     if lam is not None:
         return self._l2_error(settingnr, lam, X, y)
     else:
-        return {
-            l: self._l2_error(settingnr, l, X, y)
-            for l in self.getSetting(settingnr).lam
-        }
+        return {l: self._l2_error(settingnr, l, X, y) for l in self.lam.keys()}
 
 
 def _mse(self, settingnr, lam, X, y):  # helpfunction for get_mse
@@ -77,9 +74,7 @@ def get_mse(self, settingnr=None, X=None, y=None, lam=None):
     if lam is not None:
         return self._mse(settingnr, lam, X, y)
     else:
-        return {
-            l: self._mse(settingnr, l, X, y) for l in self.getSetting(settingnr).lam
-        }
+        return {l: self._mse(settingnr, l, X, y) for l in self.lam.keys()}
 
 
 def _mad(self, settingnr, lam, X, y):  # helpfunction for get_mad
@@ -116,21 +111,21 @@ def get_mad(self, settingnr=None, X=None, y=None, lam=None):
     if lam is not None:
         return self._mad(settingnr, lam, X, y)
     else:
-        return {
-            l: self._mad(settingnr, l, X, y) for l in self.getSetting(settingnr).lam
-        }
+        return {l: self._mad(settingnr, l, X, y) for l in self.lam.keys()}
 
 
 def _L2_error(self, norm, bc_fun, settingnr, lam):
     # print(settingnr)
-    if self.getSetting(settingnr).basis in {"per", "cos", "cheb", "std", "mixed"}:
+    if self.getSetting(settingnr, lam).basis in {"per", "cos", "cheb", "std", "mixed"}:
         error = norm**2
-        index_set = gt.get_IndexSet(self.getTrafo(settingnr).settings, self.X.shape[1])
+        index_set = gt.get_IndexSet(
+            self.getTrafo(settingnr, lam).settings, self.X.shape[1]
+        )
 
         for i in range(index_set.shape[1]):
             k = index_set[:, i]
             error += (
-                abs(bc_fun(k) - self.getFc(settingnr)[lam][i]) ** 2
+                abs(bc_fun(k) - self.getFc(settingnr, lam)[lam][i]) ** 2
                 - abs(bc_fun(k)) ** 2
             )
 
@@ -153,10 +148,7 @@ def get_L2_error(self, norm, bc_fun, settingnr=None, lam=None):
     if lam is not None:
         return self._L2_error(norm, bc_fun, settingnr, lam)
     else:
-        return {
-            l: self._L2_error(norm, bc_fun, settingnr, l)
-            for l in self.getSetting(settingnr).lam
-        }
+        return {l: self._L2_error(norm, bc_fun, settingnr, l) for l in self.lam.keys()}
 
 
 def _acc(self, settingnr, lam, X, y):  # helpfunction for get_acc
@@ -176,9 +168,7 @@ def get_acc(self, settingnr=None, X=None, y=None, lam=None):
     if lam is not None:
         return self._acc(settingnr, lam, X, y)
     else:
-        return {
-            l: self._acc(settingnr, l, X, y) for l in self.getSetting(settingnr).lam
-        }
+        return {l: self._acc(settingnr, l, X, y) for l in self.lam.keys()}
 
 
 def auc_score(y_true, y_pred_proba):
@@ -240,9 +230,7 @@ def get_auc(self, settingnr=None, X=None, y=None, lam=None):
     if lam is not None:
         return self._auc(settingnr, lam, X, y)
     else:
-        return {
-            l: self._auc(settingnr, l, X, y) for l in self.getSetting(settingnr).lam
-        }
+        return {l: self._auc(settingnr, l, X, y) for l in self.lam.keys()}
 
 
 __all__ = [

pyanovaapprox-2.0.2/.github/workflows/format.yml

@@ -1,27 +0,0 @@
-name: Format Python Code
-on: push
-jobs:
-  python-code-format:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v4
-        with:
-          python-version: "3.12"
-          architecture: "x64"
-      - name: Display Python version
-        run: python --version
-      - name: Install packages
-        run: pip install black isort
-      - name: Formatter
-        run: |
-          black .
-          isort .
-      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v3
-        with:
-          commit-message: Auto code format
-          title: Fixes by format action
-          body: This is an auto-generated PR with fixes.
-          labels: automated pr
-          branch: python-code-format-patches

{pyanovaapprox-2.0.2 → pyanovaapprox-2.0.4}/src/pyANOVAapprox/__init__.py

@@ -1,4 +1,6 @@
+import csv
 import math
+import os
 import threading
 from math import acos, isnan
 
@@ -8,8 +10,6 @@ from pyGroupedTransforms import *
 from scipy.optimize import bisect
 from scipy.sparse.linalg import lsqr
 from scipy.special import erf
-import csv
-import os
 
 # from sklearn.metrics import roc_auc_score