optimtool 2.8.0__tar.gz → 2.8.2__tar.gz

{optimtool-2.8.0 → optimtool-2.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: optimtool
-Version: 2.8.0
+Version: 2.8.2
 Summary: The fundamental package for scientific research in optimization.
 Home-page: https://github.com/linjing-lab/optimtool
 Download-URL: https://github.com/linjing-lab/optimtool/tags

{optimtool-2.8.0 → optimtool-2.8.2}/optimtool/__init__.py

@@ -32,4 +32,4 @@ from .base import MATPLOTLIB_VERSION
 from ._version import __version__
 
 if sys.version_info < (3, 7, 0):
-    raise OSError(f'optimtool-2.8.0 requires Python >=3.7, but yours is {sys.version}')
+    raise OSError(f'optimtool-2.8.2 requires Python >=3.7, but yours is {sys.version}')

{optimtool-2.8.0 → optimtool-2.8.2}/optimtool/_convert.py

@@ -66,7 +66,7 @@ def h2h(hessian: NDArray) -> NDArray:
     '''
     :param hessian: NDArray, hessian matrix with format at `numpy.ndarray`.
 
-    :return: returns a reversible hessian matrix.
+    :return: returns a positive definite and reversible hessian matrix.
     '''
     l = hessian.shape[0] # hessian.shape = (l, l)
     while 1:

{optimtool-2.8.0 → optimtool-2.8.2}/optimtool/_drive.py

@@ -32,7 +32,7 @@ def C_k(funcs: SympyMutableDenseMatrix,
         eta: float, 
         k: int) -> DataType:
     assert k >= 0
-    return np.array(funcs.subs(dict(zip(args, point[0])))).astype(DataType) if k == 0 else (1 / (Q_k(eta, k))) * (eta * Q_k(eta, k-1) * C_k(funcs, args, point, eta, k - 1) + np.array(funcs.subs(dict(zip(args, point[k])))).astype(DataType))
+    return np.array(funcs.subs(dict(zip(args, point[0])))).astype(DataType) if k == 0 else (1 / (Q_k(eta, k))) * (eta * Q_k(eta, k-1) * C_k(funcs, args, point, eta, k-1) + np.array(funcs.subs(dict(zip(args, point[k])))).astype(DataType))
 
 def get_f_delta_gradient(resv: NDArray, 
                          argsv: NDArray, 

{optimtool-2.8.0 → optimtool-2.8.2}/optimtool/_search.py

@@ -1,252 +1,251 @@
-# Copyright (c) 2021 linjing-lab
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-from .base import np
-from ._typing import List, NDArray, SympyMutableDenseMatrix, DataType, IterPointType
-
-__all__ = ["armijo", "goldstein", "wolfe", "Grippo", "ZhangHanger"]
-
-def armijo(funcs: SympyMutableDenseMatrix, 
-           args: SympyMutableDenseMatrix, 
-           x_0: IterPointType, 
-           d: NDArray, 
-           gamma: float=0.5, 
-           c: float=0.1) -> float:
-    '''
-    :param funcs: SympyMutableDenseMatrix, objective function with `convert` process used for search alpha.
-    :param args: SympyMutableDenseMatrix, symbolic set with order in a list to construct `dict(zip(args, x_0))`.
-    :param x_0: IterPointType, numerical values in a 'list` or 'tuple` according to the order of `args`.
-    :param d: NDArray, current gradient descent direction with format at `numpy.ndarray`.
-    :param gamma: float, factor used to adjust alpha with interval at (0, 1). default: float=0.5.
-    :param c: float, constant used to constrain alpha adjusted frequency with interval at (0, 1). default: float=0.1.
-
-    :return: best alpha with format at `float`.
-    '''
-    assert gamma > 0
-    assert gamma < 1
-    assert c > 0
-    assert c < 1
-    alpha = 1
-    res = funcs.jacobian(args)
-    reps = dict(zip(args, x_0))
-    f0 = np.array(funcs.subs(reps)).astype(DataType)
-    res0 = np.array(res.subs(reps)).astype(DataType)
-    while 1:
-        x = x_0 + (alpha*d)[0]
-        f1 = np.array(funcs.subs(dict(zip(args, x)))).astype(DataType)
-        if f1 <= f0 + c*alpha*res0.dot(d.T):
-            break
-        else:
-            alpha *= gamma
-    return alpha
-
-def goldstein(funcs: SympyMutableDenseMatrix, 
-              args: SympyMutableDenseMatrix, 
-              x_0: IterPointType, 
-              d: NDArray, 
-              c: float=0.2, 
-              alphas: float=0., 
-              alphae: float=10., 
-              t: float=1.2, 
-              eps: float=1e-3) -> float:
-    '''
-    :param funcs: SympyMutableDenseMatrix, objective function with `convert` process used for search alpha.
-    :param args: SympyMutableDenseMatrix, symbolic set with order in a list to construct `dict(zip(args, x_0))`.
-    :param x_0: IterPointType, numerical values in a 'list` or 'tuple` according to the order of `args`.
-    :param d: NDArray, current gradient descent direction with format at `numpy.ndarray`.
-    :param c: float, constant used to constrain alpha adjusted frequency with interval at (0, 0.5). default: float=0.2.
-    :param alphas: float, left search endpoint for alpha with value assert as `> 0`. default: float=0.
-    :param alphae: float, right search endpoint for alpha with value assert as `> alphas`. default: float=10.
-    :param t: float, factor used to expand alpha for adapting to alphas interval. default: float=1.2.
-    :param eps: float, the precision set to stopp search alpha in (alphas, alphae). default: float=1e-3.
-
-    :return: best alpha with format at `float`.
-    '''
-    assert c > 0
-    assert c < 0.5
-    assert alphas >= 0
-    assert alphas < alphae
-    assert t > 0
-    assert eps > 0
-    alpha = 1
-    res = funcs.jacobian(args)
-    reps = dict(zip(args, x_0))
-    f0 = np.array(funcs.subs(reps)).astype(DataType)
-    res0 = np.array(res.subs(reps)).astype(DataType)
-    while alphas < alphae:
-        x = x_0 + (alpha*d)[0]
-        f1 = np.array(funcs.subs(dict(zip(args, x)))).astype(DataType)
-        if f1 <= f0 + c*alpha*res0.dot(d.T):
-            if f1 >= f0 + (1 - c)*alpha*res0.dot(d.T):
-                break
-            else:
-                alphas = alpha
-                alpha = 0.5 * (alphas + alphae)
-                if alphae < np.inf:
-                    alpha = 0.5 * (alphas + alphae)
-                else:
-                    alpha *= t
-        else:
-            alphae = alpha
-            alpha = 0.5 * (alphas + alphae)
-        if np.abs(alphas - alphae) < eps:
-            break
-    return alpha
-
-def wolfe(funcs: SympyMutableDenseMatrix, 
-          args: SympyMutableDenseMatrix, 
-          x_0: IterPointType, 
-          d: NDArray, 
-          c1: float=0.3, 
-          c2: float=0.5, 
-          alphas: float=0., 
-          alphae: float=2., 
-          eps: float=1e-3) -> float:
-    '''
-    :param funcs: SympyMutableDenseMatrix, objective function with `convert` process used for search alpha.
-    :param args: SympyMutableDenseMatrix, symbolic set with order in a list to construct `dict(zip(args, x_0))`.
-    :param x_0: IterPointType, numerical values in a 'list` or 'tuple` according to the order of `args`.
-    :param d: NDArray, current gradient descent direction with format at `numpy.ndarray`.
-    :param c1: float, first constant used to constrain alpha adjusted frequency with interval at (0, 1). default: float=0.3.
-    :param c2: float, second constant used to constrain alpha adjusted frequency with interval at (0, 1). default: float=0.5.
-    :param alphas: float, left search endpoint for alpha with value assert as `> 0`. default: float=0.
-    :param alphae: float, right search endpoint for alpha with value assert as `> alphas`. default: float=2.
-    :param eps: float, the precision set to stopp search alpha in (alphas, alphae). default: float=1e-3.
-
-    :return: best alpha with format at `float`.
-    '''
-    assert c1 > 0
-    assert c1 < 1
-    assert c2 > 0
-    assert c2 < 1
-    assert c1 < c2
-    assert alphas >= 0
-    assert alphas < alphae
-    assert eps > 0
-    alpha = 1
-    res = funcs.jacobian(args)
-    reps = dict(zip(args, x_0))
-    f0 = np.array(funcs.subs(reps)).astype(DataType)
-    res0 = np.array(res.subs(reps)).astype(DataType)
-    while alphas < alphae:
-        x = x_0 + (alpha*d)[0]
-        f1 = np.array(funcs.subs(dict(zip(args, x)))).astype(DataType)
-        if f1 <= f0 + c1*alpha*res0.dot(d.T):
-            res1 = np.array(res.subs(dict(zip(args, x)))).astype(DataType)
-            if res1.dot(d.T) >= c2*res0.dot(d.T):
-                break
-            else:
-                alphas = alpha
-                alpha = 0.5 * (alphas + alphae)
-        else:
-            alphae = alpha
-            alpha = 0.5 * (alphas + alphae)
-        if np.abs(alphas - alphae) < eps:
-            break
-    return alpha
-
-# coordinate with `barzilar_borwein`.
-def Grippo(funcs: SympyMutableDenseMatrix, 
-           args: SympyMutableDenseMatrix, 
-           x_0: IterPointType, 
-           d: NDArray, 
-           k: int, 
-           point: List[IterPointType], 
-           c1: float, 
-           beta: float, 
-           alpha: float, 
-           M: int) -> float:
-    '''
-    :param funcs: SympyMutableDenseMatrix, objective function with `convert` process used for search alpha.
-    :param args: SympyMutableDenseMatrix, symbolic set with order in a list to construct `dict(zip(args, x_0))`.
-    :param x_0: IterPointType, numerical values in a 'list` or 'tuple` according to the order of `args`.
-    :param d: NDArray, current gradient descent direction with format at `numpy.ndarray`.
-    :param k: int, current number of iterative process in `barzilar_borwein` method.
-    :param c1: float, constant used to constrain alpha adjusted frequency with interval at (0, 1).
-    :param beta: float, factor used to expand alpha for adapting to alphas interval.
-    :param alpha: float, initial step size for nonmonotonic line search method with assert `> 0`.
-    :param M: int, constant to control the inner `max` proccess with assert `>= 0`.
-
-    :return: best alpha with format at `float`.
-    '''
-    assert M > 0
-    assert alpha > 0
-    assert c1 > 0
-    assert c1 < 1
-    assert beta > 0
-    assert beta < 1
-    reps = dict(zip(args, x_0))
-    res = funcs.jacobian(args)
-    res0 = np.array(res.subs(reps)).astype(DataType)
-    while 1:
-        x = x_0 + (alpha*d)[0]
-        f1 = np.array(funcs.subs(dict(zip(args, x)))).astype(DataType)
-        fk = -np.inf
-        for j in range(min(k, M) + 1):
-            fk = max(fk, np.array(funcs.subs(dict(zip(args, point[k-j])))).astype(DataType))
-        if f1 <= fk + c1 * alpha * res0.dot(d.T):
-            break
-        else:
-            alpha *= beta
-    return alpha
-
-def ZhangHanger(funcs: SympyMutableDenseMatrix, 
-                args: SympyMutableDenseMatrix, 
-                x_0: IterPointType, 
-                d: NDArray, 
-                k: int, 
-                point: List[IterPointType], 
-                c1: float, 
-                beta: float, 
-                alpha: float, 
-                eta: float) -> float:
-    '''
-    :param funcs: SympyMutableDenseMatrix, objective function with `convert` process used for search alpha.
-    :param args: SympyMutableDenseMatrix, symbolic set with order in a list to construct `dict(zip(args, x_0))`.
-    :param x_0: IterPointType, numerical values in a 'list` or 'tuple` according to the order of `args`.
-    :param d: NDArray, current gradient descent direction with format at `numpy.ndarray`.
-    :param k: int, current number of iterative process in `barzilar_borwein` method.
-    :param c1: float, constant used to constrain alpha adjusted frequency with interval at (0, 1).
-    :param beta: float, factor used to expand alpha for adapting to alphas interval.
-    :param alpha: float, initial step size for nonmonotonic line search method with assert `> 0`.
-    :param eta: float, constant used to control `C_k` process with interval at (0, 1).
-
-    :return: best alpha with format at `float`.
-    '''
-    assert alpha > 0
-    assert eta > 0
-    assert eta < 1
-    assert c1 > 0
-    assert c1 < 1
-    assert beta > 0
-    assert beta < 1
-    from ._drive import C_k
-    reps = dict(zip(args, x_0))
-    res = funcs.jacobian(args)
-    res0 = np.array(res.subs(reps)).astype(DataType)
-    while 1:
-        x = x_0 + (alpha*d)[0]
-        f1 = np.array(funcs.subs(dict(zip(args, x)))).astype(DataType)
-        Ck = C_k(funcs, args, point, eta, k)
-        if f1 <= Ck + c1 * alpha * res0.dot(d.T):
-            break
-        else:
-            alpha *= beta
+# Copyright (c) 2021 linjing-lab
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from .base import np
+from ._typing import List, NDArray, SympyMutableDenseMatrix, DataType, IterPointType
+
+__all__ = ["armijo", "goldstein", "wolfe", "Grippo", "ZhangHanger"]
+
+def armijo(funcs: SympyMutableDenseMatrix,
+           res: SympyMutableDenseMatrix,
+           args: SympyMutableDenseMatrix, 
+           x_0: IterPointType, 
+           d: NDArray, 
+           gamma: float=0.5, 
+           c: float=0.1) -> float:
+    '''
+    :param funcs: SympyMutableDenseMatrix, objective function with `convert` process used for search alpha.
+    :param res: SympyMutableDenseMatrix, gradient function computed by .jacobian function.
+    :param args: SympyMutableDenseMatrix, symbolic set with order in a list to construct `dict(zip(args, x_0))`.
+    :param x_0: IterPointType, numerical values in a 'list` or 'tuple` according to the order of `args`.
+    :param d: NDArray, current gradient descent direction with format at `numpy.ndarray`.
+    :param gamma: float, factor used to adjust alpha with interval at (0, 1). default: float=0.5.
+    :param c: float, constant used to constrain alpha adjusted frequency with interval at (0, 1). default: float=0.1.
+
+    :return: best alpha with format at `float`.
+    '''
+    assert gamma > 0
+    assert gamma < 1
+    assert c > 0
+    assert c < 1
+    alpha = 1
+    reps = dict(zip(args, x_0))
+    f0 = np.array(funcs.subs(reps)).astype(DataType)
+    res0 = np.array(res.subs(reps)).astype(DataType)
+    while 1:
+        x = x_0 + (alpha*d)[0]
+        f1 = np.array(funcs.subs(dict(zip(args, x)))).astype(DataType)
+        if f1 <= f0 + c*alpha*res0.dot(d.T):
+            break
+        else:
+            alpha *= gamma
+    return alpha
+
+def goldstein(funcs: SympyMutableDenseMatrix, 
+              res: SympyMutableDenseMatrix,
+              args: SympyMutableDenseMatrix, 
+              x_0: IterPointType, 
+              d: NDArray, 
+              c: float=0.2, 
+              alphas: float=0., 
+              alphae: float=10., 
+              t: float=1.2, 
+              eps: float=1e-3) -> float:
+    '''
+    :param funcs: SympyMutableDenseMatrix, objective function with `convert` process used for search alpha.
+    :param res: SympyMutableDenseMatrix, gradient function computed by .jacobian function.
+    :param args: SympyMutableDenseMatrix, symbolic set with order in a list to construct `dict(zip(args, x_0))`.
+    :param x_0: IterPointType, numerical values in a 'list` or 'tuple` according to the order of `args`.
+    :param d: NDArray, current gradient descent direction with format at `numpy.ndarray`.
+    :param c: float, constant used to constrain alpha adjusted frequency with interval at (0, 0.5). default: float=0.2.
+    :param alphas: float, left search endpoint for alpha with value assert as `> 0`. default: float=0.
+    :param alphae: float, right search endpoint for alpha with value assert as `> alphas`. default: float=10.
+    :param t: float, factor used to expand alpha for adapting to alphas interval. default: float=1.2.
+    :param eps: float, the precision set to stopp search alpha in (alphas, alphae). default: float=1e-3.
+
+    :return: best alpha with format at `float`.
+    '''
+    assert c > 0
+    assert c < 0.5
+    assert alphas >= 0
+    assert alphas < alphae
+    assert t > 0
+    assert eps > 0
+    alpha = 1
+    reps = dict(zip(args, x_0))
+    f0 = np.array(funcs.subs(reps)).astype(DataType)
+    res0 = np.array(res.subs(reps)).astype(DataType)
+    while alphas < alphae:
+        x = x_0 + (alpha*d)[0]
+        f1 = np.array(funcs.subs(dict(zip(args, x)))).astype(DataType)
+        if f1 <= f0 + c*alpha*res0.dot(d.T):
+            if f1 >= f0 + (1 - c)*alpha*res0.dot(d.T):
+                break
+            else:
+                alphas = alpha
+                alpha = 0.5 * (alphas + alphae)
+                if alphae < np.inf:
+                    alpha = 0.5 * (alphas + alphae)
+                else:
+                    alpha *= t
+        else:
+            alphae = alpha
+            alpha = 0.5 * (alphas + alphae)
+        if np.abs(alphas - alphae) < eps:
+            break
+    return alpha
+
+def wolfe(funcs: SympyMutableDenseMatrix,
+          res: SympyMutableDenseMatrix, 
+          args: SympyMutableDenseMatrix, 
+          x_0: IterPointType, 
+          d: NDArray, 
+          c1: float=0.3, 
+          c2: float=0.5, 
+          alphas: float=0., 
+          alphae: float=2., 
+          eps: float=1e-3) -> float:
+    '''
+    :param funcs: SympyMutableDenseMatrix, objective function with `convert` process used for search alpha.
+    :param res: SympyMutableDenseMatrix, gradient function computed by .jacobian function.
+    :param args: SympyMutableDenseMatrix, symbolic set with order in a list to construct `dict(zip(args, x_0))`.
+    :param x_0: IterPointType, numerical values in a 'list` or 'tuple` according to the order of `args`.
+    :param d: NDArray, current gradient descent direction with format at `numpy.ndarray`.
+    :param c1: float, first constant used to constrain alpha adjusted frequency with interval at (0, 1). default: float=0.3.
+    :param c2: float, second constant used to constrain alpha adjusted frequency with interval at (0, 1). default: float=0.5.
+    :param alphas: float, left search endpoint for alpha with value assert as `> 0`. default: float=0.
+    :param alphae: float, right search endpoint for alpha with value assert as `> alphas`. default: float=2.
+    :param eps: float, the precision set to stopp search alpha in (alphas, alphae). default: float=1e-3.
+
+    :return: best alpha with format at `float`.
+    '''
+    assert c1 > 0
+    assert c1 < 1
+    assert c2 > 0
+    assert c2 < 1
+    assert c1 < c2
+    assert alphas >= 0
+    assert alphas < alphae
+    assert eps > 0
+    alpha = 1
+    reps = dict(zip(args, x_0))
+    f0 = np.array(funcs.subs(reps)).astype(DataType)
+    res0 = np.array(res.subs(reps)).astype(DataType)
+    while alphas < alphae:
+        x = x_0 + (alpha*d)[0]
+        f1 = np.array(funcs.subs(dict(zip(args, x)))).astype(DataType)
+        if f1 <= f0 + c1*alpha*res0.dot(d.T):
+            res1 = np.array(res.subs(dict(zip(args, x)))).astype(DataType)
+            if res1.dot(d.T) >= c2*res0.dot(d.T):
+                break
+            else:
+                alphas = alpha
+                alpha = 0.5 * (alphas + alphae)
+        else:
+            alphae = alpha
+            alpha = 0.5 * (alphas + alphae)
+        if np.abs(alphas - alphae) < eps:
+            break
+    return alpha
+
+# coordinate with `barzilar_borwein`.
+def Grippo(funcs: SympyMutableDenseMatrix,
+           args: SympyMutableDenseMatrix, 
+           x_0: IterPointType, 
+           d: NDArray, 
+           k: int, 
+           point: List[IterPointType], 
+           c1: float, 
+           beta: float, 
+           alpha: float, 
+           M: int) -> float:
+    '''
+    :param funcs: SympyMutableDenseMatrix, objective function with `convert` process used for search alpha.
+    :param args: SympyMutableDenseMatrix, symbolic set with order in a list to construct `dict(zip(args, x_0))`.
+    :param x_0: IterPointType, numerical values in a 'list` or 'tuple` according to the order of `args`.
+    :param d: NDArray, current gradient descent direction with format at `numpy.ndarray`.
+    :param k: int, current number of iterative process in `barzilar_borwein` method.
+    :param point: List[IterPointType], contains current iteration points in a list.
+    :param c1: float, constant used to constrain alpha adjusted frequency with interval at (0, 1).
+    :param beta: float, factor used to expand alpha for adapting to alphas interval.
+    :param alpha: float, initial step size for nonmonotonic line search method with assert `> 0`.
+    :param M: int, constant to control the inner `max` proccess with assert `>= 0`.
+
+    :return: best alpha with format at `float`.
+    '''
+    assert M > 0
+    assert alpha > 0
+    assert c1 > 0
+    assert c1 < 1
+    assert beta > 0
+    assert beta < 1
+    while 1:
+        x = x_0 + (alpha*d)[0]
+        f1 = np.array(funcs.subs(dict(zip(args, x)))).astype(DataType)
+        fk = -np.inf
+        for j in range(min(k, M) + 1):
+            fk = max(fk, np.array(funcs.subs(dict(zip(args, point[k-j])))).astype(DataType))
+        if f1 <= fk + c1 * alpha * (-d).dot(d.T):
+            break
+        else:
+            alpha *= beta
+    return alpha
+
+def ZhangHanger(funcs: SympyMutableDenseMatrix, 
+                args: SympyMutableDenseMatrix, 
+                x_0: IterPointType, 
+                d: NDArray, 
+                k: int, 
+                point: List[IterPointType], 
+                c1: float, 
+                beta: float, 
+                alpha: float, 
+                eta: float) -> float:
+    '''
+    :param funcs: SympyMutableDenseMatrix, objective function with `convert` process used for search alpha.
+    :param args: SympyMutableDenseMatrix, symbolic set with order in a list to construct `dict(zip(args, x_0))`.
+    :param x_0: IterPointType, numerical values in a 'list` or 'tuple` according to the order of `args`.
+    :param d: NDArray, current gradient descent direction with format at `numpy.ndarray`.
+    :param k: int, current number of iterative process in `barzilar_borwein` method.
+    :param point: List[IterPointType], contains current iteration points in a list.
+    :param c1: float, constant used to constrain alpha adjusted frequency with interval at (0, 1).
+    :param beta: float, factor used to expand alpha for adapting to alphas interval.
+    :param alpha: float, initial step size for nonmonotonic line search method with assert `> 0`.
+    :param eta: float, constant used to control `C_k` process with interval at (0, 1).
+
+    :return: best alpha with format at `float`.
+    '''
+    assert alpha > 0
+    assert eta > 0
+    assert eta < 1
+    assert c1 > 0
+    assert c1 < 1
+    assert beta > 0
+    assert beta < 1
+    from ._drive import C_k
+    while 1:
+        x = x_0 + (alpha*d)[0]
+        f1 = np.array(funcs.subs(dict(zip(args, x)))).astype(DataType)
+        Ck = C_k(funcs, args, point, eta, k)
+        if f1 <= Ck + c1 * alpha * (-d).dot(d.T):
+            break
+        else:
+            alpha *= beta
     return alpha

{optimtool-2.8.0 → optimtool-2.8.2}/optimtool/_utils.py

@@ -29,7 +29,7 @@ def get_value(funcs: SympyMutableDenseMatrix, args: SympyMutableDenseMatrix, x_0
     :param args: SympyMutableDenseMatrix, symbolic set after `convert` with order.
     :param x_0: IterPointType, numpy.ndarray or List[PointType] or Tuple[PointType].
     :param mu: float | None, parameters collaborate with the problems applied in `Lasso`. default=None.
-    :param proxim: str | None, parameter indicate the type of proximity operators. default==None.
+    :param proxim: str | None, parameter indicate the type of proximity operators. default=None.
 
     :return: functional value with DataType.
     '''

{optimtool-2.8.0 → optimtool-2.8.2}/optimtool/_version.py

@@ -18,4 +18,4 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-__version__ = '2.8.0'
+__version__ = '2.8.2'

{optimtool-2.8.0 → optimtool-2.8.2}/optimtool/unconstrain/gradient_descent.py

@@ -102,7 +102,7 @@ def steepest(funcs: FuncArray,
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         dk = -np.array(res.subs(reps)).astype(DataType)
         if np.linalg.norm(dk) >= epsilon:
-            alpha = search(funcs, args, x_0, dk)
+            alpha = search(funcs, res, args, x_0, dk)
             x_0 += alpha * dk[0]
             k += 1
         else:

{optimtool-2.8.0 → optimtool-2.8.2}/optimtool/unconstrain/newton.py

@@ -104,7 +104,7 @@ def modified(funcs: FuncArray,
         hessian = h2h(hessian)
         dk = -np.linalg.inv(hessian).dot(gradient.T).reshape(1, -1)
         if np.linalg.norm(dk) >= epsilon:
-            alpha = search(funcs, args, x_0, dk)
+            alpha = search(funcs, res, args, x_0, dk)
             x_0 += alpha * dk[0]
             k += 1
         else:
@@ -152,7 +152,7 @@ def CG(funcs: FuncArray,
         hessian = np.array(hes.subs(reps)).astype(DataType)
         dk = conjugate(hessian, -gradient, dk0, eps).reshape(1, -1)
         if np.linalg.norm(dk) >= epsilon:
-            alpha = search(funcs, args, x_0, dk)
+            alpha = search(funcs, res, args, x_0, dk)
             x_0 += alpha * dk[0]
             k += 1
         else:

{optimtool-2.8.0 → optimtool-2.8.2}/optimtool/unconstrain/newton_quasi.py

@@ -64,7 +64,7 @@ def bfgs(funcs: FuncArray,
         gradient = np.array(res.subs(reps)).astype(DataType)
         dk = -np.linalg.inv(hessian).dot(gradient.T).reshape(1, -1)
         if np.linalg.norm(dk) >= epsilon:
-            alpha = search(funcs, args, x_0, dk)
+            alpha = search(funcs, res, args, x_0, dk)
             delta = alpha * dk # sk
             x_0 += delta[0]
             yk = np.array(res.subs(dict(zip(args, x_0)))).astype(DataType) - np.array(res.subs(reps)).astype(DataType)
@@ -116,7 +116,7 @@ def dfp(funcs: FuncArray,
         gradient = np.array(res.subs(reps)).astype(DataType)
         dk = -hessiani.dot(gradient.T).reshape(1, -1)
         if np.linalg.norm(dk) >= epsilon:
-            alpha = search(funcs, args, x_0, dk)
+            alpha = search(funcs, res, args, x_0, dk)
             delta = alpha * dk # sk
             x_0 += delta[0]
             yk = np.array(res.subs(dict(zip(args, x_0)))).astype(DataType) - np.array(res.subs(reps)).astype(DataType)
@@ -174,7 +174,7 @@ def L_BFGS(funcs: FuncArray,
         grad = np.array(res.subs(reps)).astype(DataType)
         dk = -double_loop(grad, p, s, y, m, k, Hkm).reshape(1, -1)
         if np.linalg.norm(dk) >= epsilon:
-            alphak = search(funcs, args, x_0, dk)
+            alphak = search(funcs, res, args, x_0, dk)
             delta = alphak * dk # sk
             x_0 += delta[0]
             if k > m:

{optimtool-2.8.0 → optimtool-2.8.2}/optimtool/unconstrain/nonlinear_least_square.py

@@ -52,18 +52,19 @@ def gauss_newton(funcr: FuncArray,
     funcr, args, x_0 = f2m(funcr), a2m(args), p2t(x_0)
     assert funcr.shape[0] > 1 and funcr.shape[1] ==1 and args.shape[0] == len(x_0)
     search, f = linear_search(method), []
-    res, funcs = funcr.jacobian(args), sp.Matrix([(1/2)*funcr.T*funcr])
+    resr, funcs = funcr.jacobian(args), sp.Matrix([(1/2)*funcr.T*funcr])
+    res = funcs.jacobian(args)
     while 1:
         reps = dict(zip(args, x_0))
         rk = np.array(funcr.subs(reps)).astype(DataType)
         f.append(get_value(funcs, args, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
-        jk = np.array(res.subs(reps)).astype(DataType)
+        jk = np.array(resr.subs(reps)).astype(DataType)
         q, r = np.linalg.qr(jk)
         dk = np.linalg.inv(r).dot(-(q.T).dot(rk)).reshape(1,-1) # operate with x_0
         if np.linalg.norm(dk) > epsilon:
-            alpha = search(funcs, args, x_0, dk)
+            alpha = search(funcs, res, args, x_0, dk)
             x_0 += alpha * dk[0]
             k += 1
         else:

{optimtool-2.8.0 → optimtool-2.8.2}/optimtool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: optimtool
-Version: 2.8.0
+Version: 2.8.2
 Summary: The fundamental package for scientific research in optimization.
 Home-page: https://github.com/linjing-lab/optimtool
 Download-URL: https://github.com/linjing-lab/optimtool/tags

{optimtool-2.8.0 → optimtool-2.8.2}/setup.py

@@ -4,7 +4,7 @@ import sys
 from setuptools import setup
 
 if sys.version_info < (3, 7, 0):
-    raise OSError(f'optimtool-2.8.0 requires Python >=3.7, but yours is {sys.version}')
+    raise OSError(f'optimtool-2.8.2 requires Python >=3.7, but yours is {sys.version}')
 
 if (3, 7, 0) <= sys.version_info < (3, 8, 0):
     # https://github.com/pypa/setuptools/issues/926#issuecomment-294369342