MultiOptPy 1.20.2__py3-none-any.whl

multioptpy/Optimizer/linesearch.py

@@ -0,0 +1,236 @@
+import numpy as np
+import scipy.linalg # Keep for potential future use, though not needed now
+from scipy.optimize import minimize # Keep for potential future use
+from typing import List, Tuple, Optional
+
+
+class LineSearch:
+    """
+    Stateful line search using simple energy decrease and extrapolation.
+    Accepts the last step that showed energy decrease.
+    Terminates if energy increases or if gradient becomes orthogonal (cosine < threshold).
+    Returns incremental steps compatible with cumulative updates.
+    """
+    def __init__(self,
+                 cos_threshold: float = 0.05, # Threshold for |cos(g_k, p)| to terminate
+                 maxstep: float = 0.2,
+                 damping: float = 0.8, # Start with a smaller initial step
+                 stpmin: float = 1e-8, # Minimum allowed *incremental* alpha for extrapolation
+                 stpmax: float = 5.0, # Max total alpha allowed
+                 max_iterations: int = 10,
+                 extrapolation_factor: float = 1.5 # Factor to increase alpha
+                 ):
+        """Initializes the Simple Extrapolation LineSearch configuration."""
+        
+        # --- Configuration ---
+        self.condition_type = 'simple_decrease_and_cosine' # Indicate the strategy
+        self.cos_threshold = cos_threshold # Cosine orthogonality condition
+        self.maxstep = maxstep
+        self.damping = damping
+        self.stpmin = stpmin
+        self.stpmax = stpmax
+        self.max_iterations = max_iterations
+        self.extrapolation_factor = extrapolation_factor
+
+        # --- Internal State ---
+        self.active_search = False
+        self.p = None           # Fixed search direction vector
+        self.p_norm = None      # Norm of the search direction vector
+        self.g0 = None          # Gradient at geom0 (stored for info)
+        self.e0 = None          # Energy at geom0
+        self.derphi0 = None     # Directional derivative at geom0 (stored for info)
+        self.current_total_alpha = 0.0 # Total alpha from geom0 for the point *being evaluated*
+        self.current_iteration = 0
+        self.ITR = 0
+        self.geom0 = None       # Coordinates at the start of the line search (x_k)
+        self.last_returned_total_alpha = 0.0 # Total alpha corresponding to the previous *returned* step
+
+        # --- State for this strategy ---
+        self.best_valid_total_alpha = 0.0 # Best total alpha found so far (energy decreased)
+        self.best_valid_phi = np.inf    # Energy corresponding to best_valid_total_alpha
+
+        # --- Observation Lists (for debugging/record-keeping) ---
+        self.observed_alphas = []
+        self.observed_phis = []
+        self.observed_phi_primes = []
+
+
+    def _add_observation(self, total_alpha: float, phi: float, phi_prime: float) -> bool:
+        """Adds observation (primarily for record keeping/debugging now)."""
+        
+        if any(abs(total_alpha - a_obs) < np.finfo(float).eps * 10 for a_obs in self.observed_alphas):
+            return False
+            
+        self.observed_alphas.append(total_alpha)
+        self.observed_phis.append(phi)
+        self.observed_phi_primes.append(phi_prime)
+        
+        data = sorted(zip(self.observed_alphas, self.observed_phis, self.observed_phi_primes))
+        self.observed_alphas, self.observed_phis, self.observed_phi_primes = [list(t) for t in zip(*data)]
+        
+        return True
+
+
+    def run(self, geom_num_list, gradient, prev_gradient, energy, prev_energy, move_vector):
+        """
+        Performs one stateful iteration of the simple extrapolation line search.
+        Returns the INCREMENTAL step vector.
+        """
+
+        if not self.active_search:
+            # --- Start a New Line Search ---
+            print(f"\n===== Starting Line Search (Cosine Thresh={self.cos_threshold}, damp={self.damping}) =====")
+            
+            self.active_search = True
+            self.current_iteration = 0
+            self.p = np.asarray(move_vector).reshape(-1)
+            self.g0 = np.asarray(prev_gradient).reshape(-1)
+            self.e0 = float(prev_energy)
+            self.geom0 = np.asarray(geom_num_list).reshape(-1)
+            self.derphi0 = np.dot(self.g0, self.p) 
+
+          
+            # Store the norm of the (final) search direction
+            self.p_norm = np.linalg.norm(self.p)
+
+            # --- Initialize Search State ---
+            self.best_valid_total_alpha = 0.0
+            self.best_valid_phi = self.e0
+            self.last_returned_total_alpha = 0.0
+
+            self.observed_alphas = []
+            self.observed_phis = []
+            self.observed_phi_primes = []
+            self._add_observation(0.0, self.e0, self.derphi0)
+
+            # --- Calculate Initial Step ---
+            p_norm_max = np.max(np.abs(self.p)) # Use max component for scaling
+            if p_norm_max < 1e-10:
+                print("Warning: Move vector max component is zero.")
+                self.active_search = False
+                self.geom0 = None
+                return np.zeros_like(self.p.reshape(-1, 1))
+
+            scale = abs(self.maxstep / p_norm_max)
+            
+            next_total_alpha = min(1.0, scale) * self.damping
+            
+            next_total_alpha = np.clip(next_total_alpha, self.stpmin, self.stpmax) 
+
+            print(f"Start E: {self.e0:.6f}, Deriv (g0.p): {self.derphi0:.6f}")
+            print(f"Initial trial total alpha: {next_total_alpha:.6f} (using damping={self.damping})")
+
+            self.current_total_alpha = next_total_alpha
+            incremental_alpha = self.current_total_alpha - self.last_returned_total_alpha
+            
+            return incremental_alpha * self.p.reshape(-1, 1)
+
+        
+        # --- Continue Existing Line Search Iteration ---
+        print(f"\n--- Line Search Iteration {self.current_iteration} (eval total alpha={self.current_total_alpha:.6f}) ---")
+        
+        self.current_iteration += 1
+        current_geom = np.asarray(geom_num_list).reshape(-1)
+        e_curr = float(energy) 
+        g_curr = np.asarray(gradient).reshape(-1)
+        
+        derphi_curr = np.dot(g_curr, self.p) 
+
+        _ = self._add_observation(self.current_total_alpha, e_curr, derphi_curr)
+
+        print(f"E_curr: {e_curr:.6f}") 
+        if self.geom0 is not None:
+             norm_diff = np.linalg.norm(current_geom - self.geom0)
+             print(f"   Norm diff from start: {norm_diff:.6f}")
+
+        terminate = False
+        accepted_total_alpha = 0.0
+
+        # --- Check Conditions ---
+        
+        if e_curr < self.best_valid_phi:
+            # --- Energy Decreased: Update best and check cosine condition ---
+            print(f"Energy decreased to {e_curr:.6f}.")
+            
+            self.best_valid_total_alpha = self.current_total_alpha
+            self.best_valid_phi = e_curr
+            
+            # --- NEW: Check cosine condition (g_k orthogonal to p) ---
+            g_norm = np.linalg.norm(g_curr)
+            denominator = g_norm * self.p_norm
+
+            cosine_theta = 0.0
+            if denominator < 1e-15:
+                # Gradient norm or p norm is zero.
+                # If g_norm is zero, we are at a minimum, so accept.
+                cosine_theta = 0.0
+                print("   Note: Gradient norm is near zero.")
+            else:
+                # cosine_theta = (g_k . p) / (||g_k|| * ||p||)
+                cosine_theta = derphi_curr / denominator
+            
+            print(f"   Checking cosine(g_curr, p): |cos(theta)|={abs(cosine_theta):.6f} vs threshold={self.cos_threshold:.6f}")
+            
+            if abs(cosine_theta) < self.cos_threshold:
+                print("   Cosine condition met (gradient orthogonal to search). Accepting this step.")
+                terminate = True
+                accepted_total_alpha = self.current_total_alpha
+            
+            else:
+                # --- Cosine NOT met: Extrapolate ---
+                print("   Cosine not met. Extrapolating.")
+                
+                next_total_alpha = self.current_total_alpha * self.extrapolation_factor
+                next_total_alpha = np.clip(next_total_alpha, self.stpmin, self.stpmax)
+
+                next_incremental_alpha = next_total_alpha - self.current_total_alpha
+
+                if abs(next_incremental_alpha) < self.stpmin:
+                    print(f"Warning: Extrapolation step too small ({next_incremental_alpha:.2e}). Accepting current best step.")
+                    terminate = True
+                    accepted_total_alpha = self.best_valid_total_alpha
+                elif self.current_iteration >= self.max_iterations:
+                     print("Warning: Max iterations reached during extrapolation. Accepting last successful step.")
+                     terminate = True
+                     accepted_total_alpha = self.best_valid_total_alpha
+
+                if not terminate:
+                    self.last_returned_total_alpha = self.current_total_alpha 
+                    self.current_total_alpha = next_total_alpha 
+                    return next_incremental_alpha * self.p.reshape(-1, 1)
+
+        else:
+            # --- Energy Increased: Terminate ---
+            print(f"Energy increased or stalled (E_curr={e_curr:.6f} >= E_best={self.best_valid_phi:.6f}). Accepting previous best step.")
+            terminate = True
+            accepted_total_alpha = self.best_valid_total_alpha
+            
+        # --- Handle Termination ---
+        if terminate:
+            if accepted_total_alpha <= 0: 
+                 print("No energy decrease found compared to start. Returning zero incremental step.")
+                 incremental_alpha = 0.0 - self.current_total_alpha
+                 accepted_phi = self.e0
+            else:
+                 print(f"Accepting total alpha: {accepted_total_alpha:.6f} with E={self.best_valid_phi:.6f}")
+                 incremental_alpha = accepted_total_alpha - self.current_total_alpha
+                 accepted_phi = self.best_valid_phi
+
+
+            print(f"===== Line Search Complete =====")
+            print(f"Final total alpha: {accepted_total_alpha:.6f}")
+            print(f"Final energy: {accepted_phi:.6f} (improvement: {self.e0 - accepted_phi:.6f})")
+            
+            self.ITR += 1
+            print(f"Total line searches completed: {self.ITR}")
+            
+            self.active_search = False
+            self.geom0 = None
+            
+            return incremental_alpha * self.p.reshape(-1, 1)
+
+            
+        print("Error: Line search reached unexpected state.")
+        self.active_search = False
+        self.geom0 = None
+        return np.zeros_like(self.p.reshape(-1, 1))

multioptpy/Optimizer/lookahead.py

@@ -0,0 +1,40 @@
+import numpy as np
+import copy
+
+class LookAhead:
+    def __init__(self, k=10, alpha=0.5, **config):
+        #LookAhead algorithm
+        #ref. arXiv:1907.08610
+        self.iter = 0
+        self.alpha = alpha
+        self.k = k
+        self.config = config
+        self.slow_geom_num_list = []
+        self.fast_geom_num_list_history = []
+        self.fast_energy_history = []
+        
+        return
+    
+    def run(self, geom_num_list, B_g, pre_B_g, pre_geom, B_e, pre_B_e, pre_move_vector, initial_geom_num_list, g, pre_g, move_vector):
+        print("LookAhead")
+        if self.iter % self.k != 0 or self.iter == 0:
+            self.slow_geom_num_list = geom_num_list
+            self.fast_geom_num_list_history.append(geom_num_list)
+            self.fast_energy_history.append(B_e)
+            
+        else:
+            print("update slow geometry...")
+            move_vector = []
+            self.fast_geom_num_list_history.append(geom_num_list)
+            self.fast_energy_history.append(B_e)
+            best_fast_geom_num_list = self.fast_geom_num_list_history[np.argmin(self.fast_energy_history)]
+            new_geom_num_list = self.alpha * self.slow_geom_num_list + (1.0-self.alpha) * best_fast_geom_num_list
+            
+            move_vector = -1 * (new_geom_num_list - geom_num_list)
+            
+            self.slow_geom_num_list = best_fast_geom_num_list
+            self.fast_geom_num_list_history = []
+            self.fast_energy_history = []
+        
+        self.iter += 1
+        return move_vector#Bohr

multioptpy/Optimizer/nadam.py

@@ -0,0 +1,64 @@
+import numpy as np
+import copy
+
+
+
+class NAdam:
+    def __init__(self, **config):
+        #https://cs229.stanford.edu/proj2015/054_report.pdf
+        self.adam_count = 1
+        self.DELTA = 0.06
+        self.beta_m = 0.9
+        self.beta_v = 0.999
+        self.Epsilon = 1e-8
+        self.Initialization = True
+        self.mu = 0.975
+        self.nu = 0.999
+        self.config = config
+        self.hessian = None
+        self.bias_hessian = None
+   
+        return
+    
+    def run(self, geom_num_list, B_g, pre_B_g=[], pre_geom=[], B_e=0.0, pre_B_e=0.0, pre_move_vector=[], initial_geom_num_list=[], g=[], pre_g=[]):
+        print("NAdam")
+        if self.Initialization:
+            self.adam_m = geom_num_list * 0.0
+            self.adam_v = geom_num_list * 0.0
+            self.Initialization = False
+        
+        adam_count = self.adam_count
+        adam_m = self.adam_m
+        adam_v = self.adam_v
+        new_adam_m = adam_m*0.0
+        new_adam_v = adam_v*0.0
+        
+        new_adam_m_hat = []
+        new_adam_v_hat = []
+        for i in range(len(geom_num_list)):
+            new_adam_m[i] = copy.copy(self.mu*adam_m[i] + (1.0 - self.mu)*(B_g[i]))
+            new_adam_v[i] = copy.copy((self.nu*adam_v[i]) + (1.0 - self.nu)*(B_g[i]) ** 2)
+            new_adam_m_hat.append(np.array(new_adam_m[i], dtype="float64") * ( self.mu / (1.0 - self.mu ** adam_count)) + np.array(B_g[i], dtype="float64") * ((1.0 - self.mu)/(1.0 - self.mu ** adam_count)))        
+            new_adam_v_hat.append(np.array(new_adam_v[i], dtype="float64") * (self.nu / (1.0 - self.nu ** adam_count)))
+        
+        move_vector = []
+        for i in range(len(geom_num_list)):
+            move_vector.append( (self.DELTA*new_adam_m_hat[i]) / (np.sqrt(new_adam_v_hat[i] + self.Epsilon)))
+        self.adam_m = new_adam_m
+        self.adam_v = new_adam_v
+        self.adam_count += 1
+        
+        return move_vector#Bohr
+    def set_hessian(self, hessian):
+        self.hessian = hessian
+        return
+
+    def set_bias_hessian(self, bias_hessian):
+        self.bias_hessian = bias_hessian
+        return
+    
+    def get_hessian(self):
+        return self.hessian
+    
+    def get_bias_hessian(self):
+        return self.bias_hessian

multioptpy/Optimizer/newton.py

@@ -0,0 +1,200 @@
+from .linesearch import LineSearch
+from .hessian_update import ModelHessianUpdate
+import numpy as np
+
+class Newton:
+    def __init__(self, **config):
+        self.config = config
+        self.hess_update = ModelHessianUpdate()
+        self.Initialization = True
+        self.linesearchflag = False
+        self.optimal_step_flag = False
+        self.DELTA = 0.5
+        self.FC_COUNT = -1 #
+        self.saddle_order = 0 #
+        self.iter = 0 #
+        self.beta = 0.5
+        self.hessian = None
+        self.bias_hessian = None
+   
+        return
+            
+    def project_out_hess_tr_and_rot_for_coord(self, hessian, geomerty):#do not consider atomic mass
+        natoms = len(geomerty)
+       
+        geomerty -= self.calc_center(geomerty)
+        
+    
+        tr_x = (np.tile(np.array([1, 0, 0]), natoms)).reshape(-1, 3)
+        tr_y = (np.tile(np.array([0, 1, 0]), natoms)).reshape(-1, 3)
+        tr_z = (np.tile(np.array([0, 0, 1]), natoms)).reshape(-1, 3)
+
+        rot_x = np.cross(geomerty, tr_x).flatten()
+        rot_y = np.cross(geomerty, tr_y).flatten() 
+        rot_z = np.cross(geomerty, tr_z).flatten()
+        tr_x = tr_x.flatten()
+        tr_y = tr_y.flatten()
+        tr_z = tr_z.flatten()
+
+        TR_vectors = np.vstack([tr_x, tr_y, tr_z, rot_x, rot_y, rot_z])
+        
+        Q, R = np.linalg.qr(TR_vectors.T)
+        keep_indices = ~np.isclose(np.diag(R), 0, atol=1e-6, rtol=0)
+        TR_vectors = Q.T[keep_indices]
+        n_tr = len(TR_vectors)
+
+        P = np.identity(natoms * 3)
+        for vector in TR_vectors:
+            P -= np.outer(vector, vector)
+
+        hess_proj = np.dot(np.dot(P.T, hessian), P)
+
+        return hess_proj    
+    
+    def calc_center(self, geomerty, element_list=[]):#geomerty:Bohr
+        center = np.array([0.0, 0.0, 0.0], dtype="float64")
+        for i in range(len(geomerty)):
+            
+            center += geomerty[i] 
+        center /= float(len(geomerty))
+        
+        return center
+    
+    def set_hessian(self, hessian):
+        self.hessian = hessian
+        return
+
+    def set_bias_hessian(self, bias_hessian):
+        self.bias_hessian = bias_hessian
+        return
+    
+    def get_hessian(self):
+        return self.hessian
+    
+    def get_bias_hessian(self):
+        return self.bias_hessian
+    
+    def hessian_update(self, displacement, delta_grad):
+        if "msp" in self.config["method"].lower():
+            print("MSP_quasi_newton_method")
+            delta_hess = self.hess_update.MSP_hessian_update(self.hessian, displacement, delta_grad)
+        elif "bfgs" in self.config["method"].lower():
+            print("BFGS_quasi_newton_method")
+            delta_hess = self.hess_update.BFGS_hessian_update(self.hessian, displacement, delta_grad)
+        elif "fsb" in self.config["method"].lower():
+            print("FSB_quasi_newton_method")
+            delta_hess = self.hess_update.FSB_hessian_update(self.hessian, displacement, delta_grad)
+        elif "bofill" in self.config["method"].lower():
+            print("Bofill_quasi_newton_method")
+            delta_hess = self.hess_update.Bofill_hessian_update(self.hessian, displacement, delta_grad)
+        else:
+            raise "method error"
+        return delta_hess
+    
+    def normal(self, geom_num_list, B_g, pre_B_g, pre_geom, B_e, pre_B_e, pre_g, g):
+        
+        if self.linesearchflag:
+            print("linesearch mode")
+        else:
+            print("normal mode")
+        if self.Initialization:
+            self.Initialization = False
+            return self.DELTA*B_g
+        
+        delta_grad = (g - pre_g).reshape(len(geom_num_list), 1)
+        displacement = (geom_num_list - pre_geom).reshape(len(geom_num_list), 1)
+        
+        
+        delta_hess = self.hessian_update(displacement, delta_grad)
+
+
+        if self.iter % self.FC_COUNT != 0 or self.FC_COUNT == -1:
+            new_hess = self.hessian + delta_hess + self.bias_hessian
+        else:
+            new_hess = self.hessian + self.bias_hessian
+            
+        DELTA_for_QNM = self.DELTA
+        
+        move_vector = DELTA_for_QNM * np.linalg.solve(new_hess, B_g.reshape(len(geom_num_list), 1))
+        
+        if self.iter > 1 and self.linesearchflag:
+            if self.FC_COUNT != -1:
+                tmp_hess = self.project_out_hess_tr_and_rot_for_coord(new_hess, geom_num_list.reshape(-1, 3))  
+            else:
+                tmp_hess = None
+            if self.optimal_step_flag or self.iter == 2:
+                self.LS = LineSearch(self.prev_move_vector, move_vector, B_g, pre_B_g, B_e, pre_B_e, tmp_hess)
+            
+            new_move_vector, self.optimal_step_flag = self.LS.linesearch(self.prev_move_vector, move_vector, B_g, pre_B_g, B_e, pre_B_e, tmp_hess)
+        else:
+            new_move_vector = move_vector
+            self.optimal_step_flag = True
+        
+        print("step size: ",DELTA_for_QNM,"\n")
+
+
+        if self.iter > 0 and self.linesearchflag:
+            move_vector = -new_move_vector
+            if self.optimal_step_flag or self.iter == 1:
+                self.prev_move_vector = move_vector    
+                
+        if not self.linesearchflag or np.linalg.norm(move_vector) > 1e-4:
+            self.hessian += delta_hess       
+            
+        self.iter += 1
+        return move_vector#Bohr
+  
+    # arXiv:2307.13744v1
+    def moment(self, geom_num_list, B_g, pre_B_g, pre_geom, B_e, pre_B_e, pre_g, g):
+        print("moment mode")
+        if self.Initialization:
+            self.momentum_disp = geom_num_list * 0.0
+            self.momentum_grad = geom_num_list * 0.0
+            self.Initialization = False
+            return self.DELTA*B_g
+        
+        if self.iter == 1:
+            self.momentum_disp = geom_num_list - pre_geom
+            self.momentum_grad = B_g - pre_B_g
+
+        
+        delta_grad = (B_g - pre_B_g).reshape(len(geom_num_list), 1)
+        displacement = (geom_num_list - pre_geom).reshape(len(geom_num_list), 1)
+        
+        
+
+        new_momentum_disp = self.beta * self.momentum_disp + (1.0 - self.beta) * geom_num_list
+        new_momentum_grad = self.beta * self.momentum_grad + (1.0 - self.beta) * B_g
+        
+        delta_momentum_disp = (new_momentum_disp - self.momentum_disp).reshape(len(geom_num_list), 1)
+        delta_momentum_grad = (new_momentum_grad - self.momentum_grad).reshape(len(geom_num_list), 1)
+        
+
+        delta_hess = self.hessian_update(delta_momentum_disp, delta_momentum_grad)
+
+
+        if self.iter % self.FC_COUNT != 0 or self.FC_COUNT == -1:
+            new_hess = self.hessian + delta_hess + self.bias_hessian
+        else:
+            new_hess = self.hessian + self.bias_hessian
+        
+        DELTA_for_QNM = self.DELTA
+        
+        
+        #move_vector = (DELTA_for_QNM*np.dot(np.linalg.inv(new_hess), B_g.reshape(len(geom_num_list), 1))).reshape(len(geom_num_list), 3)
+        move_vector = DELTA_for_QNM * np.linalg.solve(new_hess, B_g.reshape(len(geom_num_list), 1))
+
+        
+        print("step size: ",DELTA_for_QNM,"\n")
+        self.hessian += delta_hess
+        self.iter += 1
+        self.momentum_disp = new_momentum_disp
+        self.momentum_grad = new_momentum_grad
+        return move_vector 
+    
+    def run(self, geom_num_list, B_g, pre_B_g, pre_geom, B_e, pre_B_e, pre_move_vector, initial_geom_num_list, g, pre_g):
+        if self.config["method"] == "mBFGS" or self.config["method"] == "mFSB" or self.config["method"] == "mMSP" or self.config["method"] == "mBofill":
+            move_vector = self.moment(geom_num_list, B_g, pre_B_g, pre_geom, B_e, pre_B_e, pre_g, g)
+        else:
+            move_vector = self.normal(geom_num_list, B_g, pre_B_g, pre_geom, B_e, pre_B_e, pre_g, g)
+        return move_vector

multioptpy/Optimizer/prodigy.py

@@ -0,0 +1,70 @@
+import numpy as np
+import copy
+
+ 
+class Prodigy:    
+    def __init__(self, **config):
+        #Prodigy
+        #arXiv:2306.06101v1
+        self.adam_count = 1
+        self.d = 0.03
+        self.beta_m = 0.9
+        self.beta_v = 0.999
+        self.DELTA = 0.1
+        self.Epsilon = 1e-12
+        self.Initialization = True
+        self.config = config
+        self.hessian = None
+        self.bias_hessian = None
+   
+        return
+    
+    def run(self, geom_num_list, B_g, pre_B_g, pre_geom, B_e, pre_B_e, pre_move_vector, initial_geom_num_list, g=[], pre_g=[]):
+        print("Prodigy")
+        
+        if self.Initialization:
+            self.adam_m = geom_num_list * 0.0
+            self.adam_v = geom_num_list * 0.0        
+            self.adam_s = geom_num_list * 0.0
+            self.adam_r = 0.0
+            new_d = self.d
+            self.initial_geom_num_list = geom_num_list
+            self.Initialization = False
+            
+        new_adam_m = self.adam_m*0.0
+        new_adam_v = self.adam_v*0.0
+        new_adam_s = self.adam_s*0.0
+        
+        for i in range(len(geom_num_list)):
+            new_adam_m[i] = copy.copy(self.beta_m*self.adam_m[i] + (1.0-self.beta_m)*(B_g[i]*self.d))
+            new_adam_v[i] = copy.copy(self.beta_v*self.adam_v[i] + (1.0-self.beta_v)*(B_g[i]*self.d)**2)
+            new_adam_s[i] = np.sqrt(self.beta_v)*self.adam_s[i] + (1.0 - np.sqrt(self.beta_v))*self.DELTA*B_g[i]*self.d**2  
+        
+        new_adam_r = np.sqrt(self.beta_v)*self.adam_r + (1.0 - np.sqrt(self.beta_v))*(np.dot(B_g.reshape(1,len(B_g)), (self.initial_geom_num_list - geom_num_list).reshape(len(B_g),1)))*self.DELTA*self.d**2
+        
+        new_d = float(max((new_adam_r / np.linalg.norm(new_adam_s ,ord=1)), self.d))
+        move_vector = []
+
+        for i in range(len(geom_num_list)):
+            move_vector.append(self.DELTA*new_d*new_adam_m[i]/(np.sqrt(new_adam_v[i])+self.Epsilon*self.d))
+        
+        self.adam_m = new_adam_m
+        self.adam_v = new_adam_v
+        self.adam_r = new_adam_r
+        self.d = new_d
+        self.adam_count += 1
+        return move_vector
+    
+    def set_hessian(self, hessian):
+        self.hessian = hessian
+        return
+
+    def set_bias_hessian(self, bias_hessian):
+        self.bias_hessian = bias_hessian
+        return
+    
+    def get_hessian(self):
+        return self.hessian
+    
+    def get_bias_hessian(self):
+        return self.bias_hessian

multioptpy/Optimizer/purtubation.py

@@ -0,0 +1,16 @@
+import numpy as np
+
+class Perturbation:
+    def __init__(self, **config):
+        self.config = config
+        self.DELTA = 0.06
+        self.Boltzmann_constant = 3.16681*10**(-6) # hartree/K
+        self.damping_coefficient = 10.0
+        self.temperature = self.config["temperature"]
+        return
+    def boltzmann_dist_perturb(self, move_vector):#This function is just for fun. Thus, it is no scientific basis.
+
+        temperature = self.temperature
+        perturbation = self.DELTA * np.sqrt(2.0 * self.damping_coefficient * self.Boltzmann_constant * temperature) * np.random.normal(loc=0.0, scale=1.0, size=len(move_vector)).reshape(len(move_vector), 1)
+
+        return perturbation