File size: 2,797 Bytes
5543795
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
from __future__ import annotations

from typing import Dict, Sequence, Tuple

import networkx as nx
import numpy as np


def estimate_bath_correlation_length(
    G: nx.Graph,
    boundary_nodes: Sequence[int],
    max_pairs: int = 200,
    min_xi: float = 0.5,
    max_xi: float = 100.0,
    factor: float = 4.0,
) -> float:
    """
    Schätze eine sinnvolle Korrelationlänge ξ_bad aus den Graph-Distanzen der Randknoten.

    Idee:
    - Bestimme typische kürzeste Pfadlängen d(i,j) zwischen Randknoten i,j.
    - Verwende den Mittelwert dieser Distanzen, geteilt durch einen Faktor ``factor``,
      als Schätzer für ξ_bad.
    - Beschneide den Wert auf das Intervall [min_xi, max_xi].

    Die Berechnung verwendet aus Effizienzgründen maximal ``max_pairs`` Randknoten-Paare.
    """
    bnodes = list(boundary_nodes)
    if len(bnodes) < 2:
        # Fallback: neutraler Wert im Sliderbereich
        return 1.0

    pairs: list[Tuple[int, int]] = []
    for i, u in enumerate(bnodes):
        for v in bnodes[i + 1 :]:
            pairs.append((u, v))

    if not pairs:
        return 1.0

    if len(pairs) > max_pairs:
        rng = np.random.default_rng(0)
        idx = rng.choice(len(pairs), size=max_pairs, replace=False)
        pairs = [pairs[int(k)] for k in idx]

    dists = [nx.shortest_path_length(G, u, v) for (u, v) in pairs]
    if not dists:
        return 1.0

    d_mean = float(np.mean(dists))
    if d_mean <= 0.0 or not np.isfinite(d_mean):
        return 1.0

    xi = d_mean / float(factor)
    xi = float(np.clip(xi, min_xi, max_xi))
    return xi


def estimate_alpha_beta(
    edge_energies: Dict[Tuple[int, int], float],
    min_alpha: float = 0.05,
    max_alpha: float = 1.5,
    min_beta: float = 0.1,
    max_beta: float = 5.0,
) -> tuple[float, float]:
    """
    Schätze (α, β) aus der Verteilung der Kantenergien.

    Heuristik:
    - β wächst mit dem Logarithmus des Dynamikbereichs R = E_max / E_mean.
    - α wächst mit der relativen Streuung (Coefficient of Variation) CV = E_std / E_mean.

    Die Rückgabewerte werden auf die Intervalle [min_alpha, max_alpha] bzw.
    [min_beta, max_beta] beschränkt.
    """
    if not edge_energies:
        return 0.5, 1.5

    E = np.fromiter(edge_energies.values(), dtype=float)
    if E.size == 0:
        return 0.5, 1.5

    E_mean = float(E.mean())
    E_std = float(E.std())
    E_max = float(E.max())

    ref = E_mean
    if abs(ref) < 1e-12:
        ref = E_std if abs(E_std) > 1e-12 else 1.0

    R = abs(E_max / ref) if ref != 0.0 else 1.0
    beta = 0.5 * float(np.log1p(R))
    beta = float(np.clip(beta, min_beta, max_beta))

    CV = abs(E_std / ref) if ref != 0.0 else 0.0
    alpha = 0.3 * CV
    alpha = float(np.clip(alpha, min_alpha, max_alpha))

    return alpha, beta