optimtool 2.8.3__tar.gz → 2.9.1__tar.gz

{optimtool-2.8.3 → optimtool-2.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: optimtool
-Version: 2.8.3
+Version: 2.9.1
 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
@@ -52,12 +52,22 @@ License-File: LICENSE
 
 ## 项目介绍
 
-  optimtool采用了北京大学出版的《最优化：建模、算法与理论》这本书中的部分理论方法框架，运用了`Numpy`包高效处理数组间运算等的特性，巧妙地应用了`Sympy`内部支持的jacobian等方法，并结合Python内置函数dict与zip实现了Sympy矩阵到Numpy矩阵的转换，最终设计的用在最优化科学研究的Python工具包。
+  optimtool采用了北京大学出版的《最优化：建模、算法与理论》这本书中的部分理论方法框架，运用了`Numpy`包高效处理数组间运算等的特性，巧妙地应用了`Sympy`内部支持的jacobian等方法，并结合sp.lambdify实现了高效地数值矩阵的运算，最终设计的用在最优化科学研究的Python工具包。
 
 如果你在研究中使用 **optimtool**，欢迎引用它在你的参考资料中（按照下面的格式）。
 
-```text
-林景. optimtool: The fundamental package for scientific research in optimization. 2021. https://pypi.org/project/optimtool/.
+```bibtex
+@software{Lin2021optimtool,
+  author       = {Lin, Jing},
+  title        = {optimtool: The fundamental package for scientific research in optimization.},
+  year         = {2021},
+  version      = {2.9.1},
+  publisher    = {PyPI},
+  organization = {linjing-lab},
+  url          = {https://pypi.org/project/optimtool/},
+  license      = {MIT},
+  note         = {Source code available at \url{https://github.com/linjing-lab/optimtool}},
+}
 ```
 
 下载最新版：

{optimtool-2.8.3 → optimtool-2.9.1}/README.md

@@ -23,12 +23,22 @@
 
 ## 项目介绍
 
-  optimtool采用了北京大学出版的《最优化：建模、算法与理论》这本书中的部分理论方法框架，运用了`Numpy`包高效处理数组间运算等的特性，巧妙地应用了`Sympy`内部支持的jacobian等方法，并结合Python内置函数dict与zip实现了Sympy矩阵到Numpy矩阵的转换，最终设计的用在最优化科学研究的Python工具包。
+  optimtool采用了北京大学出版的《最优化：建模、算法与理论》这本书中的部分理论方法框架，运用了`Numpy`包高效处理数组间运算等的特性，巧妙地应用了`Sympy`内部支持的jacobian等方法，并结合sp.lambdify实现了高效地数值矩阵的运算，最终设计的用在最优化科学研究的Python工具包。
 
 如果你在研究中使用 **optimtool**，欢迎引用它在你的参考资料中（按照下面的格式）。
 
-```text
-林景. optimtool: The fundamental package for scientific research in optimization. 2021. https://pypi.org/project/optimtool/.
+```bibtex
+@software{Lin2021optimtool,
+  author       = {Lin, Jing},
+  title        = {optimtool: The fundamental package for scientific research in optimization.},
+  year         = {2021},
+  version      = {2.9.1},
+  publisher    = {PyPI},
+  organization = {linjing-lab},
+  url          = {https://pypi.org/project/optimtool/},
+  license      = {MIT},
+  note         = {Source code available at \url{https://github.com/linjing-lab/optimtool}},
+}
 ```
 
 下载最新版：

{optimtool-2.8.3 → optimtool-2.9.1}/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.2 requires Python >=3.7, but yours is {sys.version}')
+    raise OSError(f'optimtool-2.9.1 requires Python >=3.7, but yours is {sys.version}')

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/_drive.py

@@ -26,16 +26,14 @@ def Q_k(eta: float,
     assert k >= 0
     return 1 if k == 0 else eta * Q_k(eta, k-1) + 1
 
-def C_k(funcs: SympyMutableDenseMatrix, 
-        args: SympyMutableDenseMatrix, 
+def C_k(funcs_num, 
         point: List[IterPointType], 
         eta: float, 
         k: int) -> DataType:
     assert k >= 0
-    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     temp0 = funcs_num(*point[0])
     tempk = funcs_num(*point[k])
-    return temp0 if k == 0 else (1 / (Q_k(eta, k))) * (eta * Q_k(eta, k-1) * C_k(funcs, args, point, eta, k-1) + tempk)
+    return temp0 if k == 0 else (1 / (Q_k(eta, k))) * (eta * Q_k(eta, k-1) * C_k(funcs_num, point, eta, k-1) + tempk)
     # 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, 
@@ -169,40 +167,35 @@ def cons_unequal_L(cons_unequal: SympyMutableDenseMatrix,
             sub = sub - (muk[i] / sigma)**2
     return sp.Matrix([sub])
 
-def v_k(cons_equal: SympyMutableDenseMatrix, 
-        cons_unequal: SympyMutableDenseMatrix, 
-        args: SympyMutableDenseMatrix, 
+def v_k(cons_equal_num, 
+        cons_unequal_num, 
+        len_cons: int,
         muk: NDArray, 
         sigma: float, 
         x_0: IterPointType) -> DataType:
     sub = 0.
     # reps = dict(zip(args, x_0))
-    len_unequal = cons_unequal.shape[0]
-    cons_unequal_num = sp.lambdify(args, cons_unequal, modules='numpy')
     consv_unequal = cons_unequal_num(*x_0)
     # consv_unequal = np.array(cons_unequal.subs(reps)).astype(DataType)
-    if cons_equal is not None:
-        cons_equal_num = sp.lambdify(args, cons_equal, modules='numpy')
+    if cons_equal_num is not None:
         consv_equal = cons_equal_num(*x_0)
         # consv_equal = np.array(cons_equal.subs(reps)).astype(DataType)
         sub += (consv_equal.T).dot(consv_equal)
-        for i in range(len_unequal):
+        for i in range(len_cons):
             sub += (max(consv_unequal[i], - muk[i] / sigma))**2
     else:
-        for i in range(len_unequal):
+        for i in range(len_cons):
             sub += (max(consv_unequal[i], - muk[i] / sigma))**2
     return np.sqrt(sub)
 
-def renew_mu_k(cons_unequal: SympyMutableDenseMatrix, 
-               args: SympyMutableDenseMatrix, 
+def renew_mu_k(cons_unequal_num,
+               len_cons: int, 
                muk: NDArray, 
                sigma: float, 
                x_0: IterPointType) -> NDArray:
     # reps = dict(zip(args, x_0))
-    len_unequal = cons_unequal.shape[0]
-    cons_unequal_num = sp.lambdify(args, cons_unequal, modules='numpy')
     consv_unequal = cons_unequal_num(*x_0)
-    for i in range(len_unequal):
+    for i in range(len_cons):
         muk[i] = max(muk[i] + sigma * consv_unequal[i], 0)
     return muk
 

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/_search.py

@@ -23,17 +23,15 @@ from ._typing import List, NDArray, SympyMutableDenseMatrix, DataType, IterPoint
 
 __all__ = ["armijo", "goldstein", "wolfe", "Grippo", "ZhangHanger"]
 
-def armijo(funcs: SympyMutableDenseMatrix,
-           res: SympyMutableDenseMatrix,
-           args: SympyMutableDenseMatrix, 
+def armijo(funcs_num,
+           res_num,
            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 funcs_num, objective function with `convert` process used for search alpha.
+    :param res_num:, gradient function computed by .jacobian function.
     :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.
@@ -46,9 +44,7 @@ def armijo(funcs: SympyMutableDenseMatrix,
     assert c > 0
     assert c < 1
     alpha = 1
-    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     f0 = funcs_num(*x_0)
-    res_num = sp.lambdify(args, res, modules='numpy')
     res0 = res_num(*x_0)
     # reps = dict(zip(args, x_0))
     # f0 = np.array(funcs.subs(reps)).astype(DataType)
@@ -63,9 +59,8 @@ def armijo(funcs: SympyMutableDenseMatrix,
             alpha *= gamma
     return alpha
 
-def goldstein(funcs: SympyMutableDenseMatrix, 
-              res: SympyMutableDenseMatrix,
-              args: SympyMutableDenseMatrix, 
+def goldstein(funcs_num, 
+              res_num,
               x_0: IterPointType, 
               d: NDArray, 
               c: float=0.2, 
@@ -74,8 +69,8 @@ def goldstein(funcs: SympyMutableDenseMatrix,
               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 funcs_num: SympyMutableDenseMatrix, objective function with `convert` process used for search alpha.
+    :param res_num: 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`.
@@ -94,9 +89,7 @@ def goldstein(funcs: SympyMutableDenseMatrix,
     assert t > 0
     assert eps > 0
     alpha = 1
-    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     f0 = funcs_num(*x_0)
-    res_num = sp.lambdify(args, res, modules='numpy')
     res0 = res_num(*x_0)
     # reps = dict(zip(args, x_0))
     # f0 = np.array(funcs.subs(reps)).astype(DataType)
@@ -122,9 +115,8 @@ def goldstein(funcs: SympyMutableDenseMatrix,
             break
     return alpha
 
-def wolfe(funcs: SympyMutableDenseMatrix,
-          res: SympyMutableDenseMatrix, 
-          args: SympyMutableDenseMatrix, 
+def wolfe(funcs_num,
+          res_num,
           x_0: IterPointType, 
           d: NDArray, 
           c1: float=0.3, 
@@ -133,9 +125,8 @@ def wolfe(funcs: SympyMutableDenseMatrix,
           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 funcs_num, objective function with `convert` process used for search alpha.
+    :param res_num, gradient function computed by .jacobian function.
     :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.
@@ -155,9 +146,7 @@ def wolfe(funcs: SympyMutableDenseMatrix,
     assert alphas < alphae
     assert eps > 0
     alpha = 1
-    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     f0 = funcs_num(*x_0)
-    res_num = sp.lambdify(args, res, modules='numpy')
     res0 = res_num(*x_0)
     # reps = dict(zip(args, x_0))
     # f0 = np.array(funcs.subs(reps)).astype(DataType)
@@ -182,8 +171,7 @@ def wolfe(funcs: SympyMutableDenseMatrix,
     return alpha
 
 # coordinate with `barzilar_borwein`.
-def Grippo(funcs: SympyMutableDenseMatrix,
-           args: SympyMutableDenseMatrix, 
+def Grippo(funcs_num,
            x_0: IterPointType, 
            d: NDArray, 
            k: int, 
@@ -193,8 +181,7 @@ def Grippo(funcs: SympyMutableDenseMatrix,
            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 funcs_num, objective function with `convert` process used for search alpha.
     :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.
@@ -211,7 +198,6 @@ def Grippo(funcs: SympyMutableDenseMatrix,
     assert c1 < 1
     assert beta > 0
     assert beta < 1
-    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     while 1:
         x = x_0 + (alpha*d)[0]
         f1 = funcs_num(*x)
@@ -227,8 +213,7 @@ def Grippo(funcs: SympyMutableDenseMatrix,
             alpha *= beta
     return alpha
 
-def ZhangHanger(funcs: SympyMutableDenseMatrix, 
-                args: SympyMutableDenseMatrix, 
+def ZhangHanger(funcs_num, 
                 x_0: IterPointType, 
                 d: NDArray, 
                 k: int, 
@@ -238,8 +223,7 @@ def ZhangHanger(funcs: SympyMutableDenseMatrix,
                 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 funcs_num, objective function with `convert` process used for search alpha.
     :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.
@@ -259,12 +243,11 @@ def ZhangHanger(funcs: SympyMutableDenseMatrix,
     assert beta > 0
     assert beta < 1
     from ._drive import C_k
-    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     while 1:
         x = x_0 + (alpha*d)[0]
         f1 = funcs_num(*x)
         # f1 = np.array(funcs.subs(dict(zip(args, x)))).astype(DataType)
-        Ck = C_k(funcs, args, point, eta, k)
+        Ck = C_k(funcs_num, point, eta, k)
         if f1 <= Ck + c1 * alpha * (-d).dot(d.T):
             break
         else:

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/_utils.py

@@ -19,21 +19,19 @@
 # SOFTWARE.
 
 from .base import np, sp, plt
-from ._typing import DataType, Optional, SympyMutableDenseMatrix, List, IterPointType
+from ._typing import DataType, Optional, List, IterPointType
 
 __all__ = ["get_value", "plot_iteration"]
 
-def get_value(funcs: SympyMutableDenseMatrix, args: SympyMutableDenseMatrix, x_0: IterPointType, mu: Optional[float]=None, proxim: Optional[str]=None) -> DataType:
+def get_value(funcs_num, x_0: IterPointType, mu: Optional[float]=None, proxim: Optional[str]=None) -> DataType:
     '''
-    :param funcs: SympyMutableDenseMatrix, objective function after `convert`.
-    :param args: SympyMutableDenseMatrix, symbolic set after `convert` with order.
+    :param funcs_num, objective function after `convert`.
     :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.
 
     :return: functional value with DataType.
     '''
-    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     funcsv = funcs_num(*x_0)
     # funcsv = np.array(funcs.subs(dict(zip(args, x_0)))).astype(DataType)
     if mu is not None:

{optimtool-2.8.3 → optimtool-2.9.1}/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.3'
+__version__ = '2.9.1'

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/constrain/equal.py

@@ -60,12 +60,13 @@ def penalty_quadratice(funcs: FuncArray,
     assert p > 1
     from .._kernel import kernel
     funcs, args, x_0, cons = f2m(funcs), a2m(args), p2t(x_0), f2m(cons)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     search, point, f = kernel(method), [], []
     sig = sp.symbols("sig")
     pen = funcs + (sig / 2) * cons.T * cons
     while 1:
         point.append(np.array(x_0))
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         pe = pen.subs(sig, sigma)
@@ -74,7 +75,7 @@ def penalty_quadratice(funcs: FuncArray,
         sigma *= p
         if np.linalg.norm(x_0 - point[k - 1]) < epsilon:
             point.append(np.array(x_0))
-            f.append(get_value(funcs, args, x_0))
+            f.append(get_value(funcs_num, x_0))
             if verbose:
                 print("{}\t{}\t{}".format(x_0, f[-1], k))
             break
@@ -118,10 +119,11 @@ def lagrange_augmentede(funcs: FuncArray,
     from .._kernel import kernel
     search, f = kernel(method), []
     funcs, args, x_0, cons = f2m(funcs), a2m(args), p2t(x_0), f2m(cons)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     lamk = np.array([lamk for _ in range(cons.shape[0])]).reshape(cons.shape[0], 1)
     cons_num = sp.lambdify(args, cons, modules='numpy')
     while 1:
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         L = sp.Matrix([funcs + (sigma / 2) * cons.T * cons + cons.T * lamk])
@@ -133,7 +135,7 @@ def lagrange_augmentede(funcs: FuncArray,
         k += 1
         sigma *= p
         if np.linalg.norm(consv) <= epsilon:
-            f.append(get_value(funcs, args, x_0))
+            f.append(get_value(funcs_num, x_0))
             if verbose:
                 print("{}\t{}\t{}".format(x_0, f[-1], k))
             break

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/constrain/mixequal.py

@@ -62,11 +62,12 @@ def penalty_quadraticm(funcs: FuncArray,
     assert p > 0
     from .._kernel import kernel
     funcs, args, cons_equal, cons_unequal, x_0 = f2m(funcs), a2m(args), f2m(cons_equal), f2m(cons_unequal), p2t(x_0)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     search, point, f = kernel(method), [], []
     cons_unequal_num = sp.lambdify(args, cons_unequal, modules='numpy')
     while 1:
         point.append(np.array(x_0))
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         # reps = dict(zip(args, x_0))
@@ -80,7 +81,7 @@ def penalty_quadraticm(funcs: FuncArray,
         sigma *= p
         if np.linalg.norm(x_0 - point[k - 1]) < epsilon:
             point.append(np.array(x_0))
-            f.append(get_value(funcs, args, x_0))
+            f.append(get_value(funcs_num, x_0))
             if verbose:
                 print("{}\t{}\t{}".format(x_0, f[-1], k))
             break
@@ -123,15 +124,16 @@ def penalty_L1(funcs: FuncArray,
     assert p > 0
     from .._kernel import kernel
     funcs, args, cons_equal, cons_unequal, x_0 = f2m(funcs), a2m(args), f2m(cons_equal), f2m(cons_unequal), p2t(x_0)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     search, point, f = kernel(method), [], []
     cons_unequal_num = sp.lambdify(args, cons_unequal, modules='numpy')
     cons_equal_num = sp.lambdify(args, cons_equal, modules='numpy')
     while 1:
         point.append(np.array(x_0))
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
-        reps = dict(zip(args, x_0))
+        # reps = dict(zip(args, x_0))
         consv_unequal = cons_unequal_num(*x_0)
         # consv_unequal = np.array(cons_unequal.subs(reps)).astype(DataType)
         consv_unequal = np.where(consv_unequal <= 0, consv_unequal, 1)
@@ -146,7 +148,7 @@ def penalty_L1(funcs: FuncArray,
         sigma *= p
         if np.linalg.norm(x_0 - point[k - 1]) < epsilon:
             point.append(np.array(x_0))
-            f.append(get_value(funcs, args, x_0))
+            f.append(get_value(funcs_num, x_0))
             if verbose:
                 print("{}\t{}\t{}".format(x_0, f[-1], k))
             break
@@ -201,12 +203,15 @@ def lagrange_augmentedm(funcs: FuncArray,
     from .._kernel import kernel
     from .._drive import cons_unequal_L, v_k, renew_mu_k
     funcs, args, cons_equal, cons_unequal, x_0 = f2m(funcs), a2m(args), f2m(cons_equal), f2m(cons_unequal), p2t(x_0)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     search, f = kernel(method), []
     lamk = np.array([lamk for _ in range(cons_equal.shape[0])]).reshape(cons_equal.shape[0], 1)
     muk = np.array([muk for _ in range(cons_unequal.shape[0])]).reshape(cons_unequal.shape[0], 1)
     cons_equal_num = sp.lambdify(args, cons_equal, modules='numpy')
+    len_cons_unequal = len(cons_unequal)
+    cons_unequal_num = sp.lambdify(args, cons_unequal, modules='numpy')
     while 1:
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         etak = 1 / sigma
@@ -215,19 +220,19 @@ def lagrange_augmentedm(funcs: FuncArray,
         L = sp.Matrix([funcs + (sigma / 2) * (cons_equal.T * cons_equal + cons_uneuqal_modifyed) + cons_equal.T * lamk])
         x_0, _ = search(L, args, tuple(x_0), draw=False, epsilon=epsilonk)
         k += 1
-        vkx = v_k(cons_equal, cons_unequal, args, muk, sigma, x_0)
+        vkx = v_k(cons_equal_num, cons_unequal_num, len_cons_unequal, muk, sigma, x_0)
         if vkx <= epsilonk:
             res = L.jacobian(args)
             res_num = sp.lambdify(args, res, modules='numpy')
             if (vkx <= epsilon) and (np.linalg.norm(res_num(*x_0)) <= etak):
-                f.append(get_value(funcs, args, x_0))
+                f.append(get_value(funcs_num, x_0))
                 if verbose:
                     print("{}\t{}\t{}".format(x_0, f[-1], k))
                 break
             else:
                 consv_equal = cons_equal_num(*x_0)
                 lamk += sigma * consv_equal
-                muk = renew_mu_k(cons_unequal, args, muk, sigma, x_0)
+                muk = renew_mu_k(cons_unequal_num, len_cons_unequal, muk, sigma, x_0)
                 etak /= sigma
                 epsilonk /= sigma**beta
         else:

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/constrain/unequal.py

@@ -61,11 +61,12 @@ def penalty_quadraticu(funcs: FuncArray,
     assert p < 1
     from .._kernel import kernel
     funcs, args, x_0, cons = f2m(funcs), a2m(args), p2t(x_0), f2m(cons)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     search, point, f = kernel(method), [], []
     cons_num = sp.lambdify(args, cons, modules='numpy')
     while 1:
         point.append(np.array(x_0))
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         # reps = dict(zip(args, x_0))
@@ -79,7 +80,7 @@ def penalty_quadraticu(funcs: FuncArray,
         sigma *= p
         if np.linalg.norm(x_0 - point[k - 1]) < epsilon:
             point.append(np.array(x_0))
-            f.append(get_value(funcs, args, x_0))
+            f.append(get_value(funcs_num, x_0))
             if verbose:
                 print("{}\t{}\t{}".format(x_0, f[-1], k))
             break
@@ -131,10 +132,13 @@ def lagrange_augmentedu(funcs: FuncArray,
     from .._kernel import kernel
     from .._drive import cons_unequal_L, renew_mu_k, v_k
     funcs, args, x_0, cons = f2m(funcs), a2m(args), p2t(x_0), f2m(cons)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     search, f = kernel(method), []
     muk = np.array([muk for _ in range(cons.shape[0])]).reshape(cons.shape[0], 1)
+    len_cons = len(cons)
+    cons_unequal_num = sp.lambdify(args, cons, modules='numpy')
     while 1:
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         etak = 1 / sigma
@@ -143,17 +147,17 @@ def lagrange_augmentedu(funcs: FuncArray,
         L = sp.Matrix([funcs + (sigma / 2) * cons_uneuqal_modifyed])
         x_0, _ = search(L, args, tuple(x_0), draw=False, epsilon=epsilonk)
         k += 1
-        vkx = v_k(None, cons, args, muk, sigma, x_0)
+        vkx = v_k(None, cons_unequal_num, len_cons, muk, sigma, x_0)
         if vkx <= epsilonk:
             res = L.jacobian(args)
             res_num = sp.lambdify(args, res, modules='numpy')
             if (vkx <= epsilon) and (np.linalg.norm(res_num(*x_0)) <= eta):
-                f.append(get_value(funcs, args, x_0))
+                f.append(get_value(funcs_num, x_0))
                 if verbose:
                     print("{}\t{}\t{}".format(x_0, f[-1], k))
                 break
             else:
-                muk = renew_mu_k(cons, args, muk, sigma, x_0)
+                muk = renew_mu_k(cons_unequal_num, len_cons, muk, sigma, x_0)
                 etak /= sigma
                 epsilonk /= sigma**beta
         else:

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/example/Lasso.py

@@ -60,6 +60,7 @@ def gradient(A: NDArray,
     args, x_0 = a2m(args), p2t(x_0)
     assert args.shape[0] == len(x_0)
     funcs = sp.Matrix([0.5*((A*args - b).T)*(A*args - b)])
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     res = funcs.jacobian(args)
     res_num = sp.lambdify(args, res, modules='numpy')
     args_num = sp.lambdify(args, args, modules='numpy')
@@ -69,7 +70,7 @@ def gradient(A: NDArray,
     while 1:
         # reps = dict(zip(args, x_0))
         point.append(np.array(x_0))
-        f.append(get_value(funcs, args, x_0, mu, "L1"))
+        f.append(get_value(funcs_num, x_0, mu, "L1"))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         resv = res_num(*x_0)
@@ -79,7 +80,7 @@ def gradient(A: NDArray,
         k = k + 1
         if np.linalg.norm(x_0 - point[k - 1]) <= epsilon:
             point.append(np.array(x_0))
-            f.append(get_value(funcs, args, x_0, mu, "L1"))
+            f.append(get_value(funcs_num, x_0, mu, "L1"))
             if verbose:
                 print("{}\t{}\t{}".format(x_0, f[-1], k))
             break
@@ -117,14 +118,15 @@ def subgradient(A: NDArray,
     args, x_0 = a2m(args), p2t(x_0)
     assert args.shape[0] == len(x_0)
     funcs = sp.Matrix([0.5*((A*args - b).T)*(A*args - b)])
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     res = funcs.jacobian(args)
     res_num = sp.lambdify(args, res, modules='numpy')
     args_num = sp.lambdify(args, args, modules='numpy')
     point, f = [], []
     while 1:
-        reps = dict(zip(args, x_0))
+        # reps = dict(zip(args, x_0))
         point.append(np.array(x_0))
-        f.append(get_value(funcs, args, x_0, mu, "L1"))
+        f.append(get_value(funcs_num, x_0, mu, "L1"))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         resv = res_num(*x_0)
@@ -135,7 +137,7 @@ def subgradient(A: NDArray,
         k = k + 1
         if np.linalg.norm(x_0 - point[k - 1]) <= epsilon:
             point.append(np.array(x_0))
-            f.append(get_value(funcs, args, x_0, mu, "L1"))
+            f.append(get_value(funcs_num, x_0, mu, "L1"))
             if verbose:
                 print("{}\t{}\t{}".format(x_0, f[-1], k))
             break
@@ -172,13 +174,14 @@ def approximate_point(A: NDArray,
     lambda_ma = max(values)
     tk = 1 / np.real(lambda_ma) if isinstance(lambda_ma, complex) else 1 / lambda_ma
     funcs = sp.Matrix([0.5*((A*args - b).T)*(A*args - b)])
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     res = funcs.jacobian(args)
     res_num = sp.lambdify(args, res, modules='numpy')
     point, f = [], []
     while 1:
         # reps = dict(zip(args, x_0))
         point.append(x_0)
-        f.append(get_value(funcs, args, x_0, mu, "L1"))
+        f.append(get_value(funcs_num, x_0, mu, "L1"))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         grad = res_num(*x_0)
@@ -187,7 +190,7 @@ def approximate_point(A: NDArray,
         k = k + 1
         if np.linalg.norm(x_0 - point[k - 1]) < epsilon:
             point.append(x_0)
-            f.append(get_value(funcs, args, x_0, mu, "L1"))
+            f.append(get_value(funcs_num, x_0, mu, "L1"))
             if verbose:
                 print("{}\t{}\t{}".format(x_0, f[-1], k))
             break

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/hybrid/approt.py

@@ -58,11 +58,12 @@ def grad(funcs: FuncArray,
     assert all(funcs.shape) == 1 and args.shape[0] == len(x_0)
     from .._kernel import set_proxim
     proximo, f = set_proxim(proxim), []
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     res = funcs.jacobian(args) # gradient
     res_num = sp.lambdify(args, res, modules='numpy')
     while 1:
         # reps = dict(zip(args, x_0))
-        f.append(get_value(funcs, args, x_0, mu, proxim))
+        f.append(get_value(funcs_num, x_0, mu, proxim))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         dk = -res_num(*x_0)

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/hybrid/fista.py

@@ -58,11 +58,12 @@ def normal(funcs: FuncArray,
     assert all(funcs.shape) == 1 and args.shape[0] == len(x_0)
     from .._kernel import set_proxim
     proximo, point, f = set_proxim(proxim), [], []
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     res = funcs.jacobian(args) # gradient
     res_num = sp.lambdify(args, res, modules='numpy')
     while 1:
         point.append(np.array(x_0))
-        f.append(get_value(funcs, args, x_0, mu, proxim))
+        f.append(get_value(funcs_num, x_0, mu, proxim))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         dk = -res_num(*x_0)
@@ -110,12 +111,13 @@ def variant(funcs: FuncArray,
     from .._kernel import set_proxim
     from .._drive import gammak
     proximo, point, f = set_proxim(proxim), [], []
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     res = funcs.jacobian(args) # gradient
     res_num = sp.lambdify(args, res, modules='numpy')
     vkx = lambda k: x_0 if k == 0 else point[k-1] + (x_0 - point[k-1]) / gk
     while 1:
         point.append(np.array(x_0))
-        f.append(get_value(funcs, args, x_0, mu, proxim))
+        f.append(get_value(funcs_num, x_0, mu, proxim))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         dk = -res_num(*x_0)
@@ -164,12 +166,13 @@ def decline(funcs: FuncArray,
     from .._kernel import set_proxim
     from .._drive import gammak
     proximo, point, f = set_proxim(proxim), [], []
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     res = funcs.jacobian(args) # gradient
     res_num = sp.lambdify(args, res, modules='numpy')
     vkx = lambda k: x_0 if k == 0 else point[k-1] + (x_0 - point[k-1]) / gk
     while 1:
         point.append(np.array(x_0))
-        f.append(get_value(funcs, args, x_0, mu, proxim))
+        f.append(get_value(funcs_num, x_0, mu, proxim))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         dk = -res_num(*x_0)
@@ -179,7 +182,7 @@ def decline(funcs: FuncArray,
             dky = -res_num(*yk)
             delta = yk + tk * dky[0]
             u = proximo(delta, mu, tk)
-            phiu = get_value(funcs, args, u, mu, proxim)
+            phiu = get_value(funcs_num, u, mu, proxim)
             x_0 = u if phiu <= f[-1] else x_0
             k += 1
         else:

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/hybrid/nesterov.py

@@ -59,10 +59,11 @@ def seckin(funcs: FuncArray,
     from .._kernel import set_proxim
     from .._drive import gammak
     proximo, f = set_proxim(proxim), []
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     res, yk = funcs.jacobian(args), x_0 # gradient
     res_num = sp.lambdify(args, res, modules='numpy')
     while 1:
-        f.append(get_value(funcs, args, x_0, mu, proxim))
+        f.append(get_value(funcs_num, x_0, mu, proxim))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         dk = -res_num(*x_0)
@@ -115,10 +116,11 @@ def accer(funcs: FuncArray,
     from .._kernel import set_proxim
     from .._drive import gammak
     proximo, f = set_proxim(proxim), []
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     res, yk = funcs.jacobian(args), x_0 # gradient
     res_num = sp.lambdify(args, res, modules='numpy')
     while 1:
-        f.append(get_value(funcs, args, x_0, mu, proxim))
+        f.append(get_value(funcs_num, x_0, mu, proxim))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         dk = -res_num(*x_0)

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/unconstrain/gradient_descent.py

@@ -48,13 +48,14 @@ def solve(funcs: FuncArray,
     '''
     funcs, args, x_0 = f2m(funcs), a2m(args), p2t(x_0)
     assert all(funcs.shape) == 1 and args.shape[0] == len(x_0)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     res = funcs.jacobian(args) # gradient
     m = sp.symbols("m")
     arg, f = sp.Matrix([m]), []
     res_num = sp.lambdify(args, res, modules='numpy')
     while 1:
         # reps = dict(zip(args, x_0))
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         dk = -res_num(*x_0)
@@ -96,17 +97,18 @@ def steepest(funcs: FuncArray,
     assert all(funcs.shape) == 1 and args.shape[0] == len(x_0)
     from .._kernel import linear_search
     search, f = linear_search(method), []
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     res = funcs.jacobian(args) # gradient
     res_num = sp.lambdify(args, res, modules='numpy')
     while 1:
         # reps = dict(zip(args, x_0))
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         dk = -res_num(*x_0)
         # dk = -np.array(res.subs(reps)).astype(DataType)
         if np.linalg.norm(dk) >= epsilon:
-            alpha = search(funcs, res, args, x_0, dk)
+            alpha = search(funcs_num, res_num, x_0, dk)
             x_0 += alpha * dk[0]
             k += 1
         else:
@@ -157,25 +159,26 @@ def barzilar_borwein(funcs: FuncArray,
     funcs, args, x_0 = f2m(funcs), a2m(args), p2t(x_0)
     assert all(funcs.shape) == 1 and args.shape[0] == len(x_0)
     from .._kernel import nonmonotonic_search
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     search, constant = nonmonotonic_search(method, M, eta)
     res, point, f = funcs.jacobian(args), [], []
     res_num = sp.lambdify(args, res, modules='numpy')
     while 1: # while k < max_iters when constraint optimization
         point.append(x_0)
         # reps = dict(zip(args, x_0))
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         dk = -res_num(*x_0)
         # dk = -np.array(res.subs(reps)).astype(DataType)
         if np.linalg.norm(dk) >= epsilon:
-            alpha = search(funcs, args, x_0, dk, k, point, c1, beta, alpha, constant)
+            alpha = search(funcs_num, x_0, dk, k, point, c1, beta, alpha, constant)
             delta = alpha * dk[0]
             x_0 = x_0 + delta
             yk = res_num(*x_0) + dk
             alpha_up = delta.dot(delta.T)
             alpha_down = (delta.dot(yk.T))[0]
-            if alpha_down != 0:
+            if alpha_down > 0:
                 alpha = alpha_up / alpha_down
             k += 1
         else:

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/unconstrain/newton.py

@@ -48,13 +48,14 @@ def classic(funcs: FuncArray,
     '''
     funcs, args, x_0 = f2m(funcs), a2m(args), p2t(x_0)
     assert all(funcs.shape) == 1 and args.shape[0] == len(x_0)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     res = funcs.jacobian(args) # gradient
     res_num = sp.lambdify(args, res, modules='numpy')
-    hes, f = res.jacobian(args), []
+    hes, f = sp.hessian(funcs, args), []
     hes_num = sp.lambdify(args, hes, modules='numpy')
     while 1:
         # reps = dict(zip(args, x_0))
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         gradient = res_num(*x_0)
@@ -95,14 +96,15 @@ def modified(funcs: FuncArray,
     from .._kernel import linear_search
     funcs, args, x_0 = f2m(funcs), a2m(args), p2t(x_0)
     assert all(funcs.shape) == 1 and args.shape[0] == len(x_0)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     search, f = linear_search(method), []
     res = funcs.jacobian(args) # graident
     res_num = sp.lambdify(args, res, modules='numpy')
-    hes = res.jacobian(args) # hessian
+    hes = sp.hessian(funcs, args) # hessian
     hes_num = sp.lambdify(args, hes, modules='numpy')
     while 1:
         # reps = dict(zip(args, x_0))
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         gradient = res_num(*x_0)
@@ -112,7 +114,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, res, args, x_0, dk)
+            alpha = search(funcs_num, res_num, x_0, dk)
             x_0 += alpha * dk[0]
             k += 1
         else:
@@ -148,14 +150,15 @@ def CG(funcs: FuncArray,
     from .._kernel import linear_search
     funcs, args, x_0 = f2m(funcs), a2m(args), p2t(x_0)
     assert all(funcs.shape) == 1 and args.shape[0] == len(x_0)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     search, f = linear_search(method), []
     res = funcs.jacobian(args) # gradient
     res_num = sp.lambdify(args, res, modules='numpy')
-    hes, dk0 = res.jacobian(args), np.zeros((args.shape[0], 1)) # hessian and initial dk
+    hes, dk0 = sp.hessian(funcs, args), np.zeros((args.shape[0], 1)) # hessian and initial dk
     hes_num = sp.lambdify(args, hes, modules='numpy')
     while 1: # while k < max_iters when constraint optimization
         # reps = dict(zip(args, x_0))
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         gradient = res_num(*x_0)
@@ -164,7 +167,7 @@ def CG(funcs: FuncArray,
         hessian = hes_num(*x_0)
         dk = conjugate(hessian, -gradient, dk0, eps).reshape(1, -1)
         if np.linalg.norm(dk) >= epsilon:
-            alpha = search(funcs, res, args, x_0, dk)
+            alpha = search(funcs_num, res_num, x_0, dk)
             x_0 += alpha * dk[0]
             k += 1
         else:

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/unconstrain/newton_quasi.py

@@ -51,24 +51,25 @@ def bfgs(funcs: FuncArray,
     from .._kernel import linear_search
     funcs, args, x_0 = f2m(funcs), a2m(args), p2t(x_0)
     assert all(funcs.shape) == 1 and args.shape[0] == len(x_0)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     search, f = linear_search(method), []
     res = funcs.jacobian(args)
     res_num = sp.lambdify(args, res, modules='numpy')
-    hes = res.jacobian(args)
+    hes = sp.hessian(funcs, args)
     hes_num = sp.lambdify(args, hes, modules='numpy')
     hessian = hes_num(*x_0)
     # hessian = np.array(hes.subs(dict(zip(args, x_0)))).astype(DataType)
     hessian = h2h(hessian)
     while 1: # while k < max_iters when constraint optimization
         # reps = dict(zip(args, x_0))
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         gradient = res_num(*x_0)
         # 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, res, args, x_0, dk)
+            alpha = search(funcs_num, res_num, x_0, dk)
             delta = alpha * dk # sk
             x_0 += delta[0]
             yk = res_num(*x_0) - gradient
@@ -106,10 +107,11 @@ def dfp(funcs: FuncArray,
     from .._kernel import linear_search
     funcs, args, x_0 = f2m(funcs), a2m(args), p2t(x_0)
     assert all(funcs.shape) == 1 and args.shape[0] == len(x_0)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     search, f = linear_search(method), []
     res = funcs.jacobian(args)
     res_num = sp.lambdify(args, res, modules='numpy')
-    hes = res.jacobian(args)
+    hes = sp.hessian(funcs, args)
     hes_num = sp.lambdify(args, hes, modules='numpy')
     hessian = hes_num(*x_0)
     # hessian = np.array(hes.subs(dict(zip(args, x_0)))).astype(DataType)
@@ -117,13 +119,13 @@ def dfp(funcs: FuncArray,
     hessiani = np.linalg.inv(hessian)
     while 1:
         # reps = dict(zip(args, x_0))
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         gradient = res_num(*x_0)
         dk = -hessiani.dot(gradient.T).reshape(1, -1)
         if np.linalg.norm(dk) >= epsilon:
-            alpha = search(funcs, res, args, x_0, dk)
+            alpha = search(funcs_num, res_num, x_0, dk)
             delta = alpha * dk # sk
             x_0 += delta[0]
             yk = res_num(*x_0) - gradient
@@ -165,17 +167,18 @@ def L_BFGS(funcs: FuncArray,
     from .._kernel import linear_search
     funcs, args, x_0 = f2m(funcs), a2m(args), p2t(x_0)
     assert all(funcs.shape) == 1 and args.shape[0] == len(x_0)
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     search = linear_search(method)
     res = funcs.jacobian(args)
     res_num = sp.lambdify(args, res, modules='numpy')
-    hes = res.jacobian(args)
+    hes = sp.hessian(funcs, args)
     l = hes.shape[0]
     f, s, y, p = [], [], [], []
     gamma = []
     gamma.append(1)
     while 1:
         # reps = dict(zip(args, x_0))
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         Hkm = gamma[k] * np.identity(l)
@@ -183,7 +186,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, res, args, x_0, dk)
+            alphak = search(funcs_num, res_num, x_0, dk)
             delta = alphak * dk # sk
             x_0 += delta[0]
             if k > m:

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/unconstrain/nonlinear_least_square.py

@@ -53,14 +53,16 @@ def gauss_newton(funcr: FuncArray,
     assert funcr.shape[0] > 1 and funcr.shape[1] ==1 and args.shape[0] == len(x_0)
     search, f = linear_search(method), []
     resr, funcs = funcr.jacobian(args), sp.Matrix([(1/2)*funcr.T*funcr])
+    funcs_num = sp.lambdify(args, funcs, modules='numpy')
     funcr_num = sp.lambdify(args, funcr, modules='numpy')
     res = funcs.jacobian(args)
+    res_num = sp.lambdify(args, res, modules='numpy')
     resr_num = sp.lambdify(args, resr, modules='numpy')
     while 1:
         # reps = dict(zip(args, x_0))
         rk = funcr_num(*x_0)
         # rk = np.array(funcr.subs(reps)).astype(DataType)
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         jk = resr_num(*x_0)
@@ -68,7 +70,7 @@ def gauss_newton(funcr: FuncArray,
         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, res, args, x_0, dk)
+            alpha = search(funcs_num, res_num, x_0, dk)
             x_0 += alpha * dk[0]
             k += 1
         else:
@@ -121,7 +123,7 @@ def levenberg_marquardt(funcr: FuncArray,
     assert funcr.shape[0] > 1 and funcr.shape[1] ==1 and args.shape[0] == len(x_0)
     res, funcs = funcr.jacobian(args), sp.Matrix([(1/2)*funcr.T*funcr])
     resf = funcs.jacobian(args)
-    hess, dk0, f = resf.jacobian(args), np.zeros((args.shape[0], 1)), []
+    hess, dk0, f = sp.hessian(funcs, args), np.zeros((args.shape[0], 1)), []
     funcr_num = sp.lambdify(args, funcr, modules='numpy')
     res_num = sp.lambdify(args, res, modules='numpy')
     funcs_num = sp.lambdify(args, funcs, modules='numpy')
@@ -131,7 +133,7 @@ def levenberg_marquardt(funcr: FuncArray,
         # reps = dict(zip(args, x_0))
         rk = funcr_num(*x_0)
         # rk = np.array(funcr.subs(reps)).astype(DataType)
-        f.append(get_value(funcs, args, x_0))
+        f.append(get_value(funcs_num, x_0))
         if verbose:
             print("{}\t{}\t{}".format(x_0, f[-1], k))
         jk = res_num(*x_0)

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool/unconstrain/trust_region.py

@@ -73,7 +73,7 @@ def steihaug_CG(funcs: FuncArray,
     funcs, args, x_0 = f2m(funcs), a2m(args), p2t(x_0)
     assert all(funcs.shape) == 1 and args.shape[0] == len(x_0)
     res = funcs.jacobian(args)
-    hes = res.jacobian(args)
+    hes = sp.hessian(funcs, args)
     s0, f = [0 for _ in range(args.shape[0])], []
     funcs_num = sp.lambdify(args, funcs, modules='numpy')
     res_num = sp.lambdify(args, res, modules='numpy')

{optimtool-2.8.3 → optimtool-2.9.1}/optimtool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: optimtool
-Version: 2.8.3
+Version: 2.9.1
 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
@@ -52,12 +52,22 @@ License-File: LICENSE
 
 ## 项目介绍
 
-  optimtool采用了北京大学出版的《最优化：建模、算法与理论》这本书中的部分理论方法框架，运用了`Numpy`包高效处理数组间运算等的特性，巧妙地应用了`Sympy`内部支持的jacobian等方法，并结合Python内置函数dict与zip实现了Sympy矩阵到Numpy矩阵的转换，最终设计的用在最优化科学研究的Python工具包。
+  optimtool采用了北京大学出版的《最优化：建模、算法与理论》这本书中的部分理论方法框架，运用了`Numpy`包高效处理数组间运算等的特性，巧妙地应用了`Sympy`内部支持的jacobian等方法，并结合sp.lambdify实现了高效地数值矩阵的运算，最终设计的用在最优化科学研究的Python工具包。
 
 如果你在研究中使用 **optimtool**，欢迎引用它在你的参考资料中（按照下面的格式）。
 
-```text
-林景. optimtool: The fundamental package for scientific research in optimization. 2021. https://pypi.org/project/optimtool/.
+```bibtex
+@software{Lin2021optimtool,
+  author       = {Lin, Jing},
+  title        = {optimtool: The fundamental package for scientific research in optimization.},
+  year         = {2021},
+  version      = {2.9.1},
+  publisher    = {PyPI},
+  organization = {linjing-lab},
+  url          = {https://pypi.org/project/optimtool/},
+  license      = {MIT},
+  note         = {Source code available at \url{https://github.com/linjing-lab/optimtool}},
+}
 ```
 
 下载最新版：

{optimtool-2.8.3 → optimtool-2.9.1}/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.2 requires Python >=3.7, but yours is {sys.version}')
+    raise OSError(f'optimtool-2.9.1 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