mlmm-toolkit 0.2.2.dev0__py3-none-any.whl

pysisyphus/optimizers/guess_hessians.py

@@ -0,0 +1,311 @@
+# [1] https://www.sciencedirect.com/science/article/pii/000926149500646L
+#     Lindh, 1995
+# [2] https://pubs.acs.org/doi/pdf/10.1021/j100203a036
+#     Fischer, Almlöf, 1992
+# [3] https://onlinelibrary.wiley.com/doi/full/10.1002/qua.21049
+#     Swart, Bickelhaupt, 2006
+# [4] http://dx.doi.org/10.1063/1.4952956
+#     Lee-Ping Wang 2016
+
+from math import exp
+import itertools as it
+from typing import Literal, Optional
+
+import h5py
+import numpy as np
+from numpy.typing import ArrayLike
+from scipy.spatial.distance import pdist, squareform
+
+from pysisyphus.Geometry import Geometry
+from pysisyphus.intcoords.PrimTypes import PrimTypes as PT, Bonds, Bends, Dihedrals
+from pysisyphus.intcoords.setup import get_pair_covalent_radii
+from pysisyphus.io.hessian import save_hessian
+
+import torch
+
+HessInit = Literal[
+    "calc", "unit", "fischer", "lindh", "simple", "swart", "xtb", "xtb1", "xtbff"
+]
+
+
+# See [4], last sentences of III.
+CART_F = 0.05
+# Default force constants
+DEFAULT_F = {
+    PT.BOND: 0.5,
+    PT.AUX_BOND: 0.1,
+    PT.HYDROGEN_BOND: 0.1,
+    PT.INTERFRAG_BOND: 0.1,
+    PT.AUX_INTERFRAG_BOND: 0.05,
+    PT.BEND: 0.2,
+    PT.LINEAR_BEND: 0.1,
+    PT.LINEAR_BEND_COMPLEMENT: 0.1,
+    PT.PROPER_DIHEDRAL: 0.1,
+    PT.IMPROPER_DIHEDRAL: 0.1,
+    PT.OUT_OF_PLANE: 0.1,
+    PT.LINEAR_DISPLACEMENT: 0.1,
+    PT.LINEAR_DISPLACEMENT_COMPLEMENT: 0.1,
+    PT.TRANSLATION_X: CART_F,
+    PT.TRANSLATION_Y: CART_F,
+    PT.TRANSLATION_Z: CART_F,
+    PT.ROTATION_A: CART_F,
+    PT.ROTATION_B: CART_F,
+    PT.ROTATION_C: CART_F,
+    PT.CARTESIAN_X: CART_F,
+    PT.CARTESIAN_Y: CART_F,
+    PT.CARTESIAN_Z: CART_F,
+    PT.BONDED_FRAGMENT: CART_F,
+    PT.DUMMY_TORSION: 0.1,
+    PT.DISTANCE_FUNCTION: 0.1,
+    PT.DUMMY_IMPROPER: 0.1,
+}
+
+
+def simple_guess(geom):
+    """Default force constants."""
+    h_diag = [DEFAULT_F[type_] for type_, *_ in geom.internal.typed_prims]
+    return np.diag(h_diag)
+
+
+def improved_guess(geom, bond_func, bend_func, dihedral_func):
+    H_guess = simple_guess(geom)
+    for i, (pt, *indices) in enumerate(geom.internal.typed_prims):
+        if pt in Bonds:
+            f_func = bond_func
+        elif pt in Bends:
+            f_func = bend_func
+        elif pt in Dihedrals:
+            f_func = dihedral_func
+        else:
+            continue
+        try:
+            new_f = f_func(indices)
+        except ValueError:
+            new_f = DEFAULT_F[pt]
+        H_guess[i, i] = new_f
+    return H_guess
+
+
+def fischer_guess(geom):
+    cdm = pdist(geom.coords3d)
+    pair_cov_radii = get_pair_covalent_radii(geom.atoms)
+
+    # For the dihedral force constants we also have to count the number
+    # of bonds formed with the centrals atoms of the dihedral.
+    central_atoms = [inds[1:3] for inds in geom.internal.dihedral_atom_indices]
+    bond_factor = geom.internal.bond_factor
+    bond_mat = squareform(cdm <= (pair_cov_radii * bond_factor))
+    tors_atom_bonds = dict()
+    for a, b in central_atoms:
+        # Substract 2, as we don't want the bond between a and b,
+        # but this bond will be in both rows of the bond_mat.
+        bond_sum = bond_mat[a].sum() + bond_mat[b].sum() - 2
+        tors_atom_bonds[(a, b)] = bond_sum
+
+    dist_mat = squareform(cdm)
+    pair_cov_radii_mat = squareform(pair_cov_radii)
+
+    def h_bond(indices):
+        a, b = indices[:2]
+        r_ab = dist_mat[a, b]
+        r_ab_cov = pair_cov_radii_mat[a, b]
+        return 0.3601 * exp(-1.944 * (r_ab - r_ab_cov))
+
+    def h_bend(indices):
+        b, a, c = indices
+        r_ab = dist_mat[a, b]
+        r_ac = dist_mat[a, c]
+        r_ab_cov = pair_cov_radii_mat[a, b]
+        r_ac_cov = pair_cov_radii_mat[a, c]
+        return 0.089 + 0.11 / (r_ab_cov * r_ac_cov) ** (-0.42) * exp(
+            -0.44 * (r_ab + r_ac - r_ab_cov - r_ac_cov)
+        )
+
+    def h_dihedral(indices):
+        c, a, b, d = indices
+        r_ab = dist_mat[a, b]
+        r_ab_cov = pair_cov_radii_mat[a, b]
+        bond_sum = max(tors_atom_bonds[(a, b)], 0)
+        return 0.0015 + 14.0 * bond_sum ** 0.57 / (r_ab * r_ab_cov) ** 4.0 * exp(
+            -2.85 * (r_ab - r_ab_cov)
+        )
+
+    H = improved_guess(
+        geom, bond_func=h_bond, bend_func=h_bend, dihedral_func=h_dihedral
+    )
+    return H
+
+
+def lindh_style_guess(geom, ks, rhos):
+    """Approximate force constants according to Lindh.[1]
+
+    Bonds:       k_ij = k_r * rho_ij
+    Bends:      k_ijk = k_b * rho_ij * rho_jk
+    Dihedrals: k_ijkl = k_d * rho_ij * rho_jk * rho_kl
+    """
+
+    def k_func(indices):
+        rho_product = 1
+        inds_len = len(indices)
+        for i, ind in enumerate(indices[:-1], 1):
+            i1, i2 = ind, indices[i]
+            rho_product *= rhos[i1, i2]
+        k = ks[inds_len] * rho_product
+        return k
+
+    H = improved_guess(geom, bond_func=k_func, bend_func=k_func, dihedral_func=k_func)
+    return H
+
+
+def get_lindh_alpha(atom1, atom2):
+    first_period = "h", "he"
+    if (atom1 in first_period) and (atom2 in first_period):
+        return 1.0
+    elif (atom1 in first_period) or (atom2 in first_period):
+        return 0.3949
+    else:
+        return 0.28
+
+
+def lindh_guess(geom):
+    """Slightly modified Lindh model hessian as described in [1].
+
+    Instead of using the tabulated r_ref,ij values from [1] we will use the
+    'true' covalent radii as pyberny. The tabulated r_ref,ij value for two
+    carbons (2nd period) is 2.87 Bohr. Carbons covalent radius is ~ 1.44 Bohr,
+    so 2*1.44 Bohr = 2.88 Bohr which fits nicely with the tabulate value.
+    If values for elements > 3rd are requested the alpha values for the 3rd
+    period will be (re)used.
+    """
+
+    atoms = [a.lower() for a in geom.atoms]
+    alphas = [get_lindh_alpha(a1, a2) for a1, a2 in it.combinations(atoms, 2)]
+    pair_cov_radii = get_pair_covalent_radii(geom.atoms)
+    cdm = pdist(geom.coords3d)
+    rhos = squareform(np.exp(alphas * (pair_cov_radii ** 2 - cdm ** 2)))
+
+    ks = {
+        2: 0.45,  # Stretches/bonds
+        3: 0.15,  # Bends/angles
+        4: 0.005,  # Torsions/dihedrals
+    }
+    return lindh_style_guess(geom, ks, rhos)
+
+
+def swart_guess(geom):
+    pair_cov_radii = get_pair_covalent_radii(geom.atoms)
+    cdm = pdist(geom.coords3d)
+    rhos = squareform(np.exp(-cdm / pair_cov_radii + 1))
+    ks = {
+        2: 0.35,
+        3: 0.15,
+        4: 0.005,
+    }
+    return lindh_style_guess(geom, ks, rhos)
+
+
+def xtb_hessian(geom, gfn=None):
+    from pysisyphus.calculators.XTB import XTB  # Lazy import
+    calc = geom.calculator
+    xtb_kwargs = {"charge": calc.charge, "mult": calc.mult, "pal": calc.pal}
+    if gfn is not None:
+        xtb_kwargs["gfn"] = gfn
+    xtb_calc = XTB(**xtb_kwargs)
+    geom_ = geom.copy()
+    geom_.set_calculator(xtb_calc)
+    return geom_.hessian
+
+
+def get_guess_hessian(
+    geometry: Geometry,
+    hessian_init: HessInit,
+    int_gradient: Optional[ArrayLike] = None,
+    cart_gradient: Optional[ArrayLike] = None,
+    h5_fn: Optional[str] = None,
+):
+    """Obtain/calculate (model) Hessian.
+
+    For hessian_init="calc" the Hessian will be in the coord_type
+    of the geometry, otherwise a Hessian in primitive internals will
+    be returned.
+    """
+    model_hessian = hessian_init in ("fischer", "lindh", "simple", "swart")
+    target_coord_type = geometry.coord_type
+
+    # Recreate geometry with internal coordinates if needed
+    if model_hessian and (geometry.coord_type == "cart"):
+        geometry = geometry.copy(coord_type="redund")
+
+    hess_funcs = {
+        # Calculate true hessian
+        "calc": lambda: (geometry.hessian, "calculated exact"),
+        # Unit hessian
+        "unit": lambda: (np.eye(geometry.coords.size), "unit"),
+        # Fischer model hessian
+        "fischer": lambda: (fischer_guess(geometry), "Fischer"),
+        # Lindh model hessian
+        "lindh": lambda: (lindh_guess(geometry), "Lindh"),
+        # Simple (0.5, 0.2, 0.1) model hessian
+        "simple": lambda: (simple_guess(geometry), "simple"),
+        # Swart model hessian
+        "swart": lambda: (swart_guess(geometry), "Swart"),
+        # XTB hessian using GFN-2
+        "xtb": lambda: (xtb_hessian(geometry, gfn=2), "GFN2-XTB"),
+        # XTB hessian using GFN-1
+        "xtb1": lambda: (xtb_hessian(geometry, gfn=1), "GFN1-XTB"),
+        # XTB hessian using GFN-FF
+        "xtbff": lambda: (xtb_hessian(geometry, gfn="ff"), "GFN-FF"),
+    }
+    try:
+        H, hess_str = hess_funcs[hessian_init]()
+    except KeyError:
+        # Only cartesian hessians can be loaded
+        if str(hessian_init).endswith(".h5"):
+            with h5py.File(hessian_init, "r") as handle:
+                cart_hessian = handle["hessian"][:]
+        # CFOUR Hessians in the form we need are always named "FCMFINAL"
+        elif str(hessian_init).endswith("FCMFINAL"):
+            raw_cart_hessian = np.loadtxt(hessian_init, skiprows=1)
+            nindices = int(np.sqrt(raw_cart_hessian.size))
+            cart_hessian = raw_cart_hessian.reshape((nindices, nindices), order='C')
+        else:
+            cart_hessian = np.loadtxt(hessian_init)
+        geometry.cart_hessian = cart_hessian
+        # Use the previously set hessian in whatever coordinate system we
+        # actually employ.
+        H = geometry.hessian
+        hess_str = "saved"
+
+    # if (h5_fn is not None) and (hessian_init == "calc"):
+    #     save_hessian(h5_fn, geometry)
+
+    if model_hessian and target_coord_type == "cart":
+        if cart_gradient is not None:
+            int_gradient = geometry.internal.transform_forces(cart_gradient)
+        H = geometry.internal.backtransform_hessian(H, int_gradient=int_gradient)
+
+    return H, hess_str
+
+
+def ts_hessian(hessian, coord_inds, damp=0.25):
+    """According to [3]"""
+
+    inds = list(coord_inds)
+
+    # Use a copy as diag returns only a read-only view
+    diag = np.diag(hessian).copy()
+
+    # Reverse sign of reaction coordinates and damp them
+    diag[inds] = -1 * damp * diag[inds]
+    ts_hess = np.diag(diag)
+
+    # Set off-diagonal elements
+    for i, j in it.combinations(inds, 2):
+        # fi = force_constants[i]
+        # fj = force_constants[j]
+        fi = diag[i]
+        fj = diag[j]
+        f = -((2 * fi * fj) ** 0.5)
+        ts_hess[i, j] = f
+        ts_hess[j, i] = f
+    return ts_hess

pysisyphus/optimizers/hessian_updates.py

@@ -0,0 +1,355 @@
+# [1] https://link.springer.com/article/10.1007/s00214-016-1847-3
+#     Birkholz, 2016
+# [2] Geometry optimization in Cartesian coordinates: Constrained optimization
+#     Baker, 1992
+# [3] https://epubs.siam.org/doi/pdf/10.1137/S1052623496306450
+#     BFGS WITH UPDATE SKIPPING AND VARYING MEMORY
+#     Kolda, 1998
+# [4] https://link.springer.com/article/10.1186/1029-242X-2012-241
+#     New cautious BFGS algorithm based on modified Armijo-type line search
+#     Wan, 2012
+# [5] Numerical optimization, 2nd ed.
+#     Nocedal, Wright
+# [6] https://arxiv.org/abs/2006.08877
+#     Goldfarb, 2020
+# [7] https://pubs.acs.org/doi/10.1021/acs.jctc.9b00869
+#     Hermes, Zádor, 2019
+# [8] https://doi.org/10.1002/(SICI)1096-987X(199802)19:3<349::AID-JCC8>3.0.CO;2-T
+#     Bofill, 1998
+# [9] http://dx.doi.org/10.1016/S0166-1280(02)00209-9
+#     Bungay, Poirier
+
+
+import numpy as np
+
+from pysisyphus.optimizers.closures import bfgs_multiply
+
+import torch
+
+
+def _outer(a, b):
+    """Torch based outer product preserving dtype and device."""
+    if isinstance(a, torch.Tensor):
+        b = torch.as_tensor(b, dtype=a.dtype, device=a.device)
+        return torch.outer(a, b)
+    return np.outer(a, b)
+
+def _dot(a, b):
+    """Torch based dot product preserving dtype and device."""
+    if isinstance(a, torch.Tensor):
+        b = torch.as_tensor(b, dtype=a.dtype, device=a.device)
+        return torch.dot(a, b)
+    return np.dot(a, b)
+
+
+def bfgs_update(H, dx, dg):
+    """Standard BFGS Hessian update using torch."""
+    if isinstance(H, torch.Tensor):
+        dx = torch.as_tensor(dx, dtype=H.dtype, device=H.device)
+        dg = torch.as_tensor(dg, dtype=H.dtype, device=H.device)
+
+    Hdx = H @ dx
+    first_term = _outer(dg, dg) / _dot(dg, dx)
+    second_term = _outer(Hdx, Hdx) / _dot(dx, Hdx)
+    update = first_term - second_term
+    if isinstance(H, torch.Tensor):
+        return update.to(dtype=H.dtype, device=H.device), "BFGS"
+    return update, "BFGS"
+
+
+def damped_bfgs_update(H, dx, dg):
+    # if isinstance(H, torch.Tensor):
+    #     dx = torch.as_tensor(dx, dtype=H.dtype, device=H.device)
+    #     dg = torch.as_tensor(dg, dtype=H.dtype, device=H.device)
+
+    #     dxdg  = _dot(dx, dg)
+    #     dxHdx = _dot(dx, H @ dx)
+    #     theta = 1.0
+    #     if dxdg < 0.2 * dxHdx:
+    #         theta = 0.8 * dxHdx / (dxHdx - dxdg)
+    #     r = theta * dg + (1 - theta) * (H @ dx)
+
+    #     first_term  = _outer(r, r) / _dot(r, dx)
+    #     second_term = (H @ _outer(dx, dx) @ H) / dxHdx
+    #     return first_term - second_term, "damped BFGS"
+
+    """See [5]"""
+    dxdg = dx.dot(dg)
+    dxHdx = dx.dot(H).dot(dx)
+    theta = 1
+    if dxdg < 0.2 * dxHdx:
+        theta = 0.8 * dxHdx / (dxHdx - dxdg)
+    r = theta * dg + (1 - theta) * H.dot(dx)
+
+    first_term = np.outer(r, r) / r.dot(dx)
+    second_term = H.dot(np.outer(dx, dx)).dot(H) / dxHdx
+    return first_term - second_term, "damped BFGS"
+
+
+def double_damp(
+    s, y, H=None, s_list=None, y_list=None, mu_1=0.2, mu_2=0.2, logger=None
+):
+    """Double damped step 's' and gradient differences 'y'.
+
+    H is the inverse Hessian!
+    See [6]. Potentially updates s and y. y is only
+    updated if mu_2 is not None.
+
+    Parameters
+    ----------
+    s : np.array, shape (N, ), floats
+        Coordiante differences/step.
+    y : np.array, shape (N, ), floats
+        Gradient differences
+    H : np.array, shape (N, N), floats, optional
+        Inverse Hessian.
+    s_list : list of nd.array, shape (K, N), optional
+        List of K previous steps. If no H is supplied and prev_ys is given
+        the matrix-vector product Hy will be calculated through the
+        two-loop LBFGS-recursion.
+    y_list : list of nd.array, shape (K, N), optional
+        List of K previous gradient differences. See s_list.
+    mu_1 : float, optional
+        Parameter for 's' damping.
+    mu_2 : float, optional
+        Parameter for 'y' damping.
+    logger : logging.Logger, optional
+        Logger to be used.
+
+    Returns
+    -------
+    s : np.array, shape (N, ), floats
+        Damped coordiante differences/step.
+    y : np.array, shape (N, ), floats
+        Damped gradient differences
+    """
+    # if isinstance(H, torch.Tensor):
+    #     s = torch.as_tensor(s, dtype=H.dtype, device=H.device)
+    #     y = torch.as_tensor(y, dtype=H.dtype, device=H.device)
+
+    #     sy  = _dot(s, y)
+    #     Hy  = H @ y
+    #     yHy = _dot(y, Hy)
+
+    #     theta_1 = 1.0
+    #     if sy < mu_1 * yHy:
+    #         theta_1 = (1 - mu_1) * yHy / (yHy - sy)
+    #         s = theta_1 * s + (1 - theta_1) * Hy
+
+    #     # --- 二重 damping ---
+    #     sy   = _dot(s, y)
+    #     ss   = _dot(s, s)
+    #     theta_2 = 1.0
+    #     if mu_2 is not None and sy < mu_2 * ss:
+    #         theta_2 = (1 - mu_2) * ss / (ss - sy)
+    #         y = theta_2 * y + (1 - theta_2) * s
+
+    #     return s, y
+
+    sy = s.dot(y)
+    # Calculate Hy directly
+    if H is not None:
+        Hy = H.dot(y)
+    # Calculate Hy via BFGS_multiply as in LBFGS
+    else:
+        Hy = bfgs_multiply(s_list, y_list, y, logger=logger)
+    yHy = y.dot(Hy)
+
+    theta_1 = 1
+    damped_s = ""
+    if sy < mu_1 * yHy:
+        theta_1 = (1 - mu_1) * yHy / (yHy - sy)
+        s = theta_1 * s + (1 - theta_1) * Hy
+        if theta_1 < 1.0:
+            damped_s = ", damped s"
+    msg = f"damped BFGS\n\ttheta_1={theta_1:.4f} {damped_s}"
+
+    # Double damping
+    damped_y = ""
+    if mu_2 is not None:
+        sy = s.dot(y)
+        ss = s.dot(s)
+        theta_2 = 1
+        if sy < mu_2 * ss:
+            theta_2 = (1 - mu_2) * ss / (ss - sy)
+        y = theta_2 * y + (1 - theta_2) * s
+        if theta_2 < 1.0:
+            damped_y = ", damped y"
+        msg = "double " + msg + f"\n\ttheta_2={theta_2:.4f} {damped_y}"
+
+    if logger is not None:
+        logger.debug(msg.capitalize())
+
+    return s, y
+
+
+def sr1_update(z, dx):
+    """Symmetric rank-one update."""
+    if isinstance(z, torch.Tensor):
+        dx = torch.as_tensor(dx, dtype=z.dtype, device=z.device)
+    update = _outer(z, z) / _dot(z, dx)
+    if isinstance(z, torch.Tensor):
+        return update.to(dtype=z.dtype, device=z.device), "SR1"
+    return update, "SR1"
+
+
+def psb_update(z, dx):
+    """Powell Symmetric Broyden update."""
+    if isinstance(z, torch.Tensor):
+        dx = torch.as_tensor(dx, dtype=z.dtype, device=z.device)
+    first = (_outer(dx, z) + _outer(z, dx)) / _dot(dx, dx)
+    second = _dot(dx, z) * _outer(dx, dx) / (_dot(dx, dx) ** 2)
+    update = first - second
+    if isinstance(z, torch.Tensor):
+        return update.to(dtype=z.dtype, device=z.device), "PSB"
+    return update, "PSB"
+
+
+def flowchart_update(H, dx, dg):
+    # if isinstance(H, torch.Tensor):
+    #     dx = torch.as_tensor(dx, dtype=H.dtype, device=H.device)
+    #     dg = torch.as_tensor(dg, dtype=H.dtype, device=H.device)
+
+    #     z          = dg - H @ dx
+    #     sr1_quot   = _dot(z, dx) / (z.norm() * dx.norm())
+    #     bfgs_quot  = _dot(dg, dx) / (dg.norm() * dx.norm())
+
+    #     if sr1_quot < -0.1:
+    #         update, key = sr1_update(z, dx)
+    #     elif bfgs_quot > 0.1:
+    #         update, key = bfgs_update(H, dx, dg)
+    #     else:
+    #         update, key = psb_update(z, dx)
+    #     return update, key
+
+    # See [1], Sec. 2, equations 1 to 3
+    z = dg - H.dot(dx)
+    sr1_quot = z.dot(dx) / (np.linalg.norm(z) * np.linalg.norm(dx))
+    bfgs_quot = dg.dot(dx) / (np.linalg.norm(dg) * np.linalg.norm(dx))
+    if sr1_quot < -0.1:
+        update, key = sr1_update(z, dx)
+    elif bfgs_quot > 0.1:
+        update, key = bfgs_update(H, dx, dg)
+    else:
+        update, key = psb_update(z, dx)
+    return update, key
+
+
+def mod_flowchart_update(H, dx, dg):
+    # This version seems to work too ... at least for minimizations
+    # starting from a geometry near a transition state. Interesing.
+    z = dg - H.dot(dx)
+    quot = z.dot(dx) / (np.linalg.norm(z) * np.linalg.norm(dx))
+    if quot < -0.1:
+        update, key = bfgs_update(H, dx, dg)
+    elif quot > 0.1:
+        update, key = sr1_update(z, dx)
+    else:
+        update, key = psb_update(z, dx)
+    return update, key
+
+
+def bofill_update(H, dx, dg):
+    """Bofill's combination of SR1 and PSB updates."""
+    if isinstance(H, torch.Tensor):
+        dx = torch.as_tensor(dx, dtype=H.dtype, device=H.device)
+        dg = torch.as_tensor(dg, dtype=H.dtype, device=H.device)
+
+    z = dg - H @ dx
+    sr1 = sr1_update(z, dx)[0]
+    psb = psb_update(z, dx)[0]
+    mix = (_dot(z, dx) ** 2) / (_dot(z, z) * _dot(dx, dx))
+    update = mix * sr1 + (1 - mix) * psb
+    if isinstance(H, torch.Tensor):
+        return update.to(dtype=H.dtype, device=H.device), "Bofill"
+    return update, "Bofill"
+
+
+def ts_bfgs_update(H, dx, dg):
+    # if isinstance(H, torch.Tensor):
+    #     dx = torch.as_tensor(dx, dtype=H.dtype, device=H.device)[:, None]
+    #     dg = torch.as_tensor(dg, dtype=H.dtype, device=H.device)[:, None]
+    #     j   = dg - H @ dx
+    #     jdx = (j.T @ dx)
+
+    #     w, v = torch.linalg.eigh(H)
+    #     Hdx  = torch.abs(w) * (v @ (v.T @ dx))
+    #     M     = dg @ dg.T + Hdx @ Hdx.T
+    #     dxTM  = dx.T @ M
+    #     u     = torch.linalg.solve(dxTM @ dx, dxTM).T
+    #     juT   = j @ u.T
+    #     update = juT + juT.T - jdx * (u @ u.T)
+    #     return update, "TS-BFGS"
+
+    """As described in [7]"""
+    dx = dx[:, None]
+    dg = dg[:, None]
+    j = dg - H @ dx
+    jdx = j.T @ dx
+    # Diagonalize Hessian, to construct positive definite version of it
+    w, v = np.linalg.eigh(H)
+    Hdx = np.abs(w) * v @ (v.T @ dx)
+    M = dg @ dg.T + Hdx @ Hdx.T
+    dxTM = dx.T @ M
+    u = np.linalg.solve(dxTM @ dx, dxTM).T
+    juT = j @ u.T
+    ts_bfgs_update = juT + juT.T - jdx * u @ u.T
+    return ts_bfgs_update, "TS-BFGS"
+
+
+def ts_bfgs_update_org(H, dx, dg):
+    """Do not use! Implemented as described in the 1998 bofill paper [8].
+
+    This does not seem to work too well."""
+    dx = dx[:, None]
+    dg = dg[:, None]
+    u = dg
+    j = H @ dx
+    j = u - j
+    # jTdx = float(j.T @ dx)
+    jTdx = j.T @ dx
+    # dxTdx = float(dx.T @ dx)
+    dxTdx = dx.T @ dx
+    # jTj = float(j.T @ j)
+    jTj = j.T @ j
+    phi = jTdx ** 2 / dxTdx / jTj
+    u = phi * dg * dg.T @ dx
+    w, v = np.linalg.eigh(H)
+    u = u + (1 - phi) * np.abs(w) * v @ (v.T @ dx)
+    u = u / (u.T @ dx)
+    juT = j @ u.T
+    ts_bfgs_update = juT + juT.T - jTdx * u @ u.T
+    return ts_bfgs_update, "TS-BFGS"
+
+
+def ts_bfgs_update_revised(H, dx, dg):
+    """TS-BFGS update as described in [9].
+
+    Better than the original formula of Bofill, worse than the implementation
+    in [7]. a is caluclated as described in the footnote 1 on page 38. Eq. (8)
+    looks suspicious as it contains the inverse of a vector?! As also outlined
+    in the paper abs(a) is used (|a| in the paper)."""
+
+    dx = dx[:, None]
+    dg = dg[:, None]
+    dgTdg = dg.T @ dg
+    dgTdx = dg.T @ dx
+    a = (dgTdg - dg.T @ H @ dx) / (dgTdg * dgTdx)
+    a = abs(a)
+
+    # Diagonalize Hessian, to construct positive definite version of it
+    w, v = np.linalg.eigh(H)
+    H_pos_dx = np.abs(w) * v @ (v.T @ dx)
+    # Mixing factor
+    j = dg - H @ dx
+    jTdx = j.T @ dx
+    dxTdx = dx.T @ dx
+    jTj = j.T @ j
+    phi = jTdx ** 2 / dxTdx / jTj
+    u = ((1 - phi) * H_pos_dx + a * phi * dgTdx * dg) / (
+        (1 - phi) * dx.T @ H_pos_dx + phi * a * dgTdx ** 2
+    )
+
+    juT = j @ u.T
+    ts_bfgs_update = juT + juT.T - jTdx * u @ u.T
+    return ts_bfgs_update, "TS-BFGS"