adjust default epsilon

Author: linjing-lab

README.md

@@ -231,9 +231,9 @@ oe.Lasso.[函数名]([矩阵A], [矩阵b], [因子mu], [参数表], [初始迭
 
 | 方法头                                                                                                                                                                                                                   | 解释                        |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- |
-| gradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, delta: float=10., alp: float=1e-3, epsilon: float=1e-2, k: int=0) -> OutputType | 光滑化Lasso函数法           |
+| gradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, delta: float=10., alp: float=1e-3, epsilon: float=1e-3, k: int=0) -> OutputType | 光滑化Lasso函数法           |
 | subgradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, alphak: float=2e-2, epsilon: float=1e-3, k: int=0) -> OutputType             | 次梯度法Lasso避免一阶不可导 |
-| approximate_point(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType                           | 邻近算子更新                |
+| approximate_point(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-3, k: int=0) -> OutputType                           | 邻近算子更新                |
 
 #### 曲线相切问题（WanYuan）
 

README_en.md

@@ -232,9 +232,9 @@ oe.Lasso.[Function Name]([Matrxi A], [Matrix b], [Factor mu], [Parameters], [Ini
 
 | head method                                                                                                                                                                                                              | explain                                                              |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------- |
-| gradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, delta: float=10., alp: float=1e-3, epsilon: float=1e-2, k: int=0) -> OutputType | Smoothing Lasso Function Method                                      |
+| gradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, delta: float=10., alp: float=1e-3, epsilon: float=1e-3, k: int=0) -> OutputType | Smoothing Lasso Function Method                                      |
 | subgradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, alphak: float=2e-2, epsilon: float=1e-3, k: int=0) -> OutputType             | Sub gradient method Lasso: avoiding first order nondifferentiability |
-| approximate_point(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType                           | Adjacent operator updating                                           |
+| approximate_point(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-3, k: int=0) -> OutputType                           | Adjacent operator updating                                           |
 
 #### Curve Tangency Problem(WanYuan)
 

examples/doc/_example.md

@@ -20,11 +20,11 @@ $$
 
 给定$A_{m \times n}$，$x_{n \times 1}$，$b_{m \times 1}$，正则化常数$\mu$。解决该无约束最优化问题，该问题目标函数一阶不可导。
 
-| 方法头                                                                                                     | 解释               |
-| ------------------------------------------------------------------------------------------------------- | ---------------- |
-| gradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, delta: float=10., alp: float=1e-3, epsilon: float=1e-2, k: int=0) -> OutputType | 光滑化Lasso函数法      |
+| 方法头                                                                                                                                                                                                                   | 解释                        |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- |
+| gradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, delta: float=10., alp: float=1e-3, epsilon: float=1e-3, k: int=0) -> OutputType | 光滑化Lasso函数法           |
 | subgradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, alphak: float=2e-2, epsilon: float=1e-3, k: int=0) -> OutputType             | 次梯度法Lasso避免一阶不可导 |
-| approximate_point(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 邻近算子更新 |
+| approximate_point(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-3, k: int=0) -> OutputType                           | 邻近算子更新                |
 
 
 ```python
@@ -62,8 +62,8 @@ oe.WanYuan.[函数名]([直线的斜率], [直线的截距], [二次项系数],
 给定直线的斜率和截距，给定一个抛物线函数的二次项系数，一次项系数与常数项。 要求解一个给定圆心的圆，该圆同时与抛物线、直线相切，若存在可行方案，请给出切点的坐标。
 ```
 
-| 方法头                                                             | 解释                   |
-| --------------------------------------------------------------- | -------------------- |
+| 方法头                                                                                                                                                       | 解释                                   |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------- |
 | solution(m: float, n: float, a: float, b: float, c: float, x3: float, y3: float, x_0: tuple, verbose: bool=False, draw: bool=False, eps: float=1e-10) -> str | 使用高斯-牛顿方法求解构造的7个残差函数 |
 
 

optimtool/constrain/equal.py

@@ -107,7 +107,7 @@ def lagrange_augmentede(funcs: FuncArray,
     :param lamk: float, the initial value of the elements in the initial penalty vector. default: float=6.0.
     :param sigma: float, penalty factor used to set the degree of convergence of `funcs`. default: float=10.0.
     :param p: float, parameter to adjust the degree value of convergence named `sigma`. default: float=2.0.
-    :param epak: float, used to set the precision to accelerate the completion of kernel. default: float=1e-4.
+    :param etak: float, used to set the precision to accelerate the completion of kernel. default: float=1e-4.
     :param epsilon: float, used to set the precision of stopping the overall algorithm. default: float=1e-6.
     :param k: int, iterative times is used to measure the difficulty of learning the `funcs` in the algorithm. default: int=0.
 

optimtool/example/Lasso.py

@@ -36,7 +36,7 @@ def gradient(A: NDArray,
              output_f: bool=False, 
              delta: float=10., 
              alp: float=1e-3, 
-             epsilon: float=1e-2, 
+             epsilon: float=1e-3, 
              k: int=0) -> OutputType:
     '''
     :param A: NDArray, matrix A with size m*n acting on x.
@@ -49,7 +49,7 @@ def gradient(A: NDArray,
     :param output_f: bool, use `bool` to control whether to obtain iterative values of `funcs`. default: bool=False.
     :param delta: float, value used to adjust the constant influence of mu. default: float=10.0.
     :param alp: float, initial update step size acting on smooth gradient. default: float=1e-3.
-    :param epsilon: float, used to set the precision of stopping the overall algorithm. default: float=1e-2
+    :param epsilon: float, used to set the precision of stopping the overall algorithm. default: float=1e-3.
     :param k: int, iterative times is used to measure the difficulty of learning the `funcs` in the algorithm. default: int=0.
 
     :return: final convergenced point and iterative times, (iterative values in a list).
@@ -146,7 +146,7 @@ def approximate_point(A: NDArray,
                       verbose: bool=False, 
                       draw: bool=True, 
                       output_f: bool=False, 
-                      epsilon: float=1e-4, 
+                      epsilon: float=1e-3, 
                       k: int=0) -> OutputType:
     '''
     :param A: NDArray, matrix A with size m*n acting on x.
@@ -157,7 +157,7 @@ def approximate_point(A: NDArray,
     :param verbose: bool, iteration point, function value, numbers of iteration after the k-th iteration. default: bool=False.
     :param draw: bool, use `bool` to control whether to draw visual images. default: bool=True.
     :param output_f: bool, use `bool` to control whether to obtain iterative values of `funcs`. default: bool=False.
-    :param epsilon: float, used to set the precision of stopping the overall algorithm. default: float=1e-4.
+    :param epsilon: float, used to set the precision of stopping the overall algorithm. default: float=1e-3.
     :param k: int, iterative times is used to measure the difficulty of learning the `funcs` in the algorithm. default: int=0.
 
     :return: final convergenced point and iterative times, (iterative values in a list).

tests/example/_example.ipynb.txt

@@ -47,9 +47,9 @@
     "\n",
     "| 方法头                                                                                                     | 解释               |\n",
     "| ------------------------------------------------------------------------------------------------------- | ---------------- |\n",
-    "| gradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, delta: float=10., alp: float=1e-3, epsilon: float=1e-2, k: int=0) -> OutputType | 光滑化Lasso函数法      |\n",
+    "| gradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, delta: float=10., alp: float=1e-3, epsilon: float=1e-3, k: int=0) -> OutputType | 光滑化Lasso函数法      |\n",
     "| subgradient(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, alphak: float=2e-2, epsilon: float=1e-3, k: int=0) -> OutputType             | 次梯度法Lasso避免一阶不可导 |\n",
-    "| approximate_point(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-4, k: int=0) -> OutputType | 邻近算子更新 |"
+    "| approximate_point(A: NDArray, b: NDArray, mu: float, args: ArgArray, x_0: PointArray, verbose: bool=False, draw: bool=True, output_f: bool=False, epsilon: float=1e-3, k: int=0) -> OutputType | 邻近算子更新 |"
    ]
   },
   {