pyANOVAapprox 2.0.6__tar.gz → 2.0.7__tar.gz

{pyanovaapprox-2.0.6 → pyanovaapprox-2.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyANOVAapprox
-Version: 2.0.6
+Version: 2.0.7
 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.6 → pyanovaapprox-2.0.7}/pyproject.toml

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

{pyanovaapprox-2.0.6 → pyanovaapprox-2.0.7}/src/pyANOVAapprox/approx.py

@@ -419,6 +419,8 @@ 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])
+        fix = dict([(u, tuple([False] * len(u))) for u in setting.U])
+        bw =  [tuple([0] * len(u)) for u in setting.U]
 
         if verbosity > 3:
             if not os.path.exists("log"):
@@ -430,7 +432,7 @@ class approx:
         for idx in range(maxiter):
             if verbosity > 0:
                 print("===== Iteration ", str(idx + 1), " =====")
-            bw = compute_bandwidth(B, D, t)
+            bw, fix = compute_bandwidth(B, D, t, fix, bw)
             if setting.N is not None:
                 self.addSetting(setting)
                 settingnr = self.aktsetting

{pyanovaapprox-2.0.6 → pyanovaapprox-2.0.7}/src/pyANOVAapprox/bandwidth.py

@@ -9,6 +9,8 @@ def getfcu(ghat, u):
     # fcu = np.permute_dims(fcu, range(len(bws))[::-1])
     fcu = ghat[u].reshape(bws - 1)
     fcu = np.permute_dims(fcu, range(len(bws)))
+    #if(u == (3,7)):
+    #    print(fcu)
 
     return fcu
 
@@ -30,50 +32,90 @@ 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]
+    #if(u == (3,7)):
+    #    print(j,fcuj)
 
     return fcuj
 
-
-def compute_bandwidth(B, D, t):
+def compute_bandwidth(B, D, t, fix, oldbw):
     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)
+    # fix erweitern: NaN-Einträge in t werden automatisch fixiert
+    fix = {u: list(fix[u]) for u in us}  # deep copy
+    for u in us:
+        for j in range(len(u)):
+            if math.isnan(t[u][j]):
+                fix[u][j] = True
+
+    # Für fixierte Einträge: Bandbreite aus oldbw übernehmen
+    for u in us:
+        for j in range(len(u)):
+            if fix[u][j]:
+                bw[u][j] = oldbw[u][j]
+
+    minfreqs = sum(
+        math.prod(
+            (oldbw[u][j] - 1) if fix[u][j] else (6 - 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 not math.isnan(t[u][j]))
+    def A_u(u):
+        return sum(
+            0.5 / t[u][j]
+            for j in range(len(u))
+            if not fix[u][j]
+        )
 
-        p2 = math.prod(
-            ((2 * t[u][j] * D[u][j]) / lmbda) ** (0.5 / t[u][j])
+    def B_u(u):
+        prod_C = math.prod(
+            D[u][j] ** (0.5 / t[u][j])
             for j in range(len(u))
-            if not math.isnan(t[u][j])
+            if not fix[u][j]
         )
-        denom_exp = 1 + sum(
-            0.5 / t[u][j] for j in range(len(u)) if not math.isnan(t[u][j])
+        prod_fix = math.prod(
+            (bw[u][j] - 1)
+            for j in range(len(u))
+            if fix[u][j]
         )
-        return (p1 * p2) ** (1 / denom_exp)
-
-    def fun_lmbda(lmbda, B):
-        total = 0.0
-        for u in us:
-            total += fun_lmbda_u(math.exp(lmbda), u)
-        return total - B
-
-    lmbda = math.exp(bisect(lambda t: fun_lmbda(t, B), -100, 100))
+        return prod_C * prod_fix
 
+    def fun_lmbda_u(lmbda, u):
+        Au = A_u(u)
+        Bu = B_u(u)
+        if Au == 0:
+            # Alle Einträge in u sind fixiert: kein Beitrag zur Optimierung
+            return 0.0
+        exp = 1.0 / (1.0 + Au)
+        return Bu ** exp * (lmbda * Au) ** (-Au * exp)
+
+    def fun_lmbda(log_lmbda):
+        lmbda = math.exp(log_lmbda)
+        return sum(fun_lmbda_u(lmbda, u) for u in us) - (B - 1)
+
+    log_lmbda = bisect(fun_lmbda, -100, 100)
+    lmbda = math.exp(log_lmbda)
+
+    # Optimale Bandbreiten berechnen
     for u in us:
+        Au = A_u(u)
+        Bu = B_u(u)
+        if Au == 0:
+            continue  # alle fixiert, bw[u] bereits gesetzt
         sizeIu = fun_lmbda_u(lmbda, u)
         for j in range(len(u)):
-            if not math.isnan(t[u][j]):
-                bwuj = ((2 * t[u][j] * D[u][j]) / (lmbda * sizeIu)) ** (
+            if not fix[u][j]:
+                bwuj = (D[u][j] / (lmbda * Bu * Au) ** (1.0 / (1.0 + Au))) ** (
                     0.5 / t[u][j]
                 ) + 1
                 bw[u][j] = max(6, 2 * round(0.5 * bwuj))
 
-    return bw
+    return bw, fix
 
 
 def fitrate_log(y):
@@ -158,7 +200,7 @@ def estimate_rates(self, lam, settingnr=None, verbosity=0):
 
             if verbosity > 5:
 
-                y = np.cumsum(axissum)[::-1]
+                y = np.cumsum(axissum[::-1])[::-1]
                 ax.plot(
                     range(1, len(y) + 1),
                     y,
@@ -171,9 +213,9 @@ def estimate_rates(self, lam, settingnr=None, verbosity=0):
                 t[u][j] = math.nan
             else:
                 idx = min(len(axissum), len(axissum) - idx + 2)
-                Duj, tuj = fitrate_log((np.cumsum(axissum)[::-1])[0:idx])
-                
-                if tuj < 0.004:
+                Duj, tuj = fitrate_log((np.cumsum(axissum[::-1])[::-1])[0:idx])
+                #print(u,j,tuj)
+                if abs(tuj) < 0.004:
                     D[u][j] = math.nan
                     t[u][j] = math.nan
                 else: