程序包 org.hipparchus.analysis.solvers

类 UnivariateSolverUtils

java.lang.Object
org.hipparchus.analysis.solvers.UnivariateSolverUtils
public class UnivariateSolverUtils extends Object
UnivariateSolver对象的实用程序例程。

  • 方法详细资料

    • solve

      public static double solve(UnivariateFunction function, double x0, double x1) throws MathIllegalArgumentException, NullArgumentException
      查找一元实函数的零点的便利方法。使用默认求解器。
      参数:
      function - 函数。
      x0 - 区间的下界。
      x1 - 区间的上界。
      返回:
      使函数为零的值。
      抛出:
      MathIllegalArgumentException - 如果函数在端点处具有相同的符号。
      NullArgumentException - 如果 function 为 null。

    • solve

      public static double solve(UnivariateFunction function, double x0, double x1, double absoluteAccuracy) throws MathIllegalArgumentException, NullArgumentException
      查找一元实函数的零点的便利方法。使用默认求解器。
      参数:
      function - 函数。
      x0 - 区间的下界。
      x1 - 区间的上界。
      absoluteAccuracy - 求解器使用的精度。
      返回:
      使函数为零的值。
      抛出:
      MathIllegalArgumentException - 如果函数在端点处具有相同的符号。
      NullArgumentException - 如果 function 为 null。

    • forceSide

      public static double forceSide(int maxEval, UnivariateFunction f, BracketedUnivariateSolver<UnivariateFunction> bracketing, double baseRoot, double min, double max, AllowedSolution allowedSolution) throws MathIllegalArgumentException
      强制非括号求解器找到的根位于指定侧，就像求解器是括号求解器一样。
      参数:
      maxEval - 函数的最大新评估次数（用于找到根的评估应该已经从此数字中减去）
      f - 要解决的函数
      bracketing - 用于移动根的括号求解器
      baseRoot - 先前非括号求解器找到的原始根
      min - 搜索区间的最小边界
      max - 搜索区间的最大边界
      allowedSolution - 根查找算法可能接受的解的类型。
      返回:
      一个根的近似值，在指定的根的一侧
      抛出:
      MathIllegalArgumentException - 如果函数在端点处具有相同的符号。

    • bracket

      public static double[] bracket(UnivariateFunction function, double initial, double lowerBound, double upperBound) throws MathIllegalArgumentException, NullArgumentException
      该方法简单地调用 bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)，其中 q 和 r 设置为 1.0，maximumIterations 设置为 Integer.MAX_VALUE。

      注意：该方法可能需要 Integer.MAX_VALUE 次迭代才会抛出 MathIllegalStateException。除非您确信在 lowerBound 和 upperBound 之间的 initial 附近存在一个根，否则最好使用 bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)，明确指定最大迭代次数。

      参数:
      function - 函数。
      initial - 被扩展以括号根的区间的初始中点。
      lowerBound - 下界（a 永远不低于此值）
      upperBound - 上界（b 永远不大于此值）。
      返回:
      一个包含 a 和 b 的两个元素数组。
      抛出:
      MathIllegalArgumentException - 如果无法括号化根。
      MathIllegalArgumentException - 如果 maximumIterations <= 0。
      NullArgumentException - 如果 function 为 null。

    • bracket

      public static double[] bracket(UnivariateFunction function, double initial, double lowerBound, double upperBound, int maximumIterations) throws MathIllegalArgumentException, NullArgumentException
      该方法简单地调用 bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)，其中 q 和 r 设置为 1.0。
      参数:
      function - 函数。
      initial - 被扩展以括号根的区间的初始中点。
      lowerBound - 下界（a 永远不低于此值）。
      upperBound - 上界（b 永远不大于此值）。
      maximumIterations - 执行的最大迭代次数
      返回:
      一个包含 a 和 b 的两个元素数组。
      抛出:
      MathIllegalArgumentException - 如果算法无法找到满足所需条件的 a 和 b。
      MathIllegalArgumentException - 如果 maximumIterations <= 0。
      NullArgumentException - 如果 function 为 null。

    • bracket

      public static double[] bracket(UnivariateFunction function, double initial, double lowerBound, double upperBound, double q, double r, int maximumIterations) throws MathIllegalArgumentException
      这个方法尝试找到两个值a和b，满足
      • lowerBound <= a < initial < b <= upperBound
      • f(a) * f(b) <= 0
      如果f在[a,b]上连续，这意味着a和b夹住了f的一个根。

      该算法检查\( f(l_k) \)和\( f(u_k) \)的符号，其中k的值递增，其中\( l_k = max(lower, initial - \delta_k) \)，\( u_k = min(upper, initial + \delta_k) \)，使用递归\( \delta_{k+1} = r \delta_k + q, \delta_0 = 0\)并从\( k=1 \)开始搜索。当发生以下情况之一时，算法停止：

      • 找到至少一个正值和一个负值--成功！
      • 两个端点都达到了各自的限制--MathIllegalArgumentException
      • maximumIterations次迭代已经过去--MathIllegalArgumentException

      如果在第一次迭代（k=1）找到不同的符号，则返回的区间将是\( [a, b] = [l_1, u_1] \)。如果在后续迭代k>1中找到不同的符号，则返回的区间将是\( [a, b] = [l_{k+1}, l_{k}] \)或\( [a, b] = [u_{k}, u_{k+1}] \)。因此，使用这些参数调用的根求解器将从此步骤已知的最小夹逼区间开始。

      通过改变递归参数r和q来调整区间扩展速率。当乘法因子r设置为1时，序列是一个简单的算术序列，具有线性增长。当乘法因子r大于1时，序列具有渐近指数增长率。请注意，加法参数q不应设置为零，否则区间将退化为所有k值的单个初始点。

      作为一个经验法则，当根的位置预计在某个误差范围内已知时，r应设置为1，q应设置为误差范围的数量级。当根的位置真的是一个猜测时，r应设置为大于1的值（通常为2，以便在每次迭代中将区间长度加倍），q应根据初始搜索区间长度的一半进行设置。

      例如，如果我们考虑一个简单的函数f(x) = 1 - x并使用initial = 4，r = 1，q = 2，算法将计算f(4-2) = f(2) = -1和f(4+2) = f(6) = -5对于k = 1，然后f(4-4) = f(0) = +1和f(4+4) = f(8) = -7对于k = 2。然后它将返回区间[0, 2]作为已知夹逼根的最小区间。正如这个例子所示，初始值（这里是4）可能位于返回的夹逼区间之外。

      参数:
      function - 要检查的函数
      initial - 被扩展以夹住根的区间的初始中点
      lowerBound - 下限（a永远不会低于此值）
      upperBound - 上限（b永远不会大于此值）
      q - 用于计算边界序列的加法偏移量（必须严格为正）
      r - 用于计算边界序列的乘法因子
      maximumIterations - 要执行的最大迭代次数
      返回:
      一个包含夹逼值的两个元素数组
      抛出:
      MathIllegalArgumentException - 如果在搜索区间内无法夹住函数

    • bracket

      public static <T extends CalculusFieldElement<T>> T[] bracket(CalculusFieldUnivariateFunction<T> function, T initial, T lowerBound, T upperBound) throws MathIllegalArgumentException, NullArgumentException
      这个方法简单地调用bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)，其中q和r设置为1.0，maximumIterations设置为Integer.MAX_VALUE。

      注意：这个方法可能需要Integer.MAX_VALUE次迭代才会抛出一个MathIllegalStateException。除非您确信在lowerBound和upperBound之间的initial附近有一个根，否则最好使用bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)，明确指定最大迭代次数。

      类型参数:
      T - 字段元素的类型
      参数:
      function - 函数
      initial - 被扩展以夹住根的区间的初始中点
      lowerBound - 下限（a永远不会低于此值）
      upperBound - 上限（b永远不会大于此值）
      返回:
      一个包含a和b的两个元素数组
      抛出:
      MathIllegalArgumentException - 如果无法夹住a和b满足所需条件
      MathIllegalArgumentException - 如果maximumIterations <= 0
      NullArgumentException - 如果function为null
      从以下版本开始:
      1.2

    • bracket

      public static <T extends CalculusFieldElement<T>> T[] bracket(CalculusFieldUnivariateFunction<T> function, T initial, T lowerBound, T upperBound, int maximumIterations) throws MathIllegalArgumentException, NullArgumentException
      这个方法简单地调用bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)，其中q和r设置为1.0。
      类型参数:
      T - 字段元素的类型
      参数:
      function - 函数
      initial - 被扩展以夹住根的区间的初始中点
      lowerBound - 下限（a永远不会低于此值）
      upperBound - 上限（b永远不会大于此值）
      maximumIterations - 要执行的最大迭代次数
      返回:
      一个包含a和b的两个元素数组
      抛出:
      MathIllegalArgumentException - 如果算法无法找到满足所需条件的a和b
      MathIllegalArgumentException - 如果maximumIterations <= 0
      NullArgumentException - 如果function为null
      从以下版本开始:
      1.2

    • bracket

      public static <T extends CalculusFieldElement<T>> T[] bracket(CalculusFieldUnivariateFunction<T> function, T initial, T lowerBound, T upperBound, T q, T r, int maximumIterations) throws MathIllegalArgumentException
      这个方法尝试找到两个值a和b，满足
      • lowerBound <= a < initial < b <= upperBound
      • f(a) * f(b) <= 0
      如果f在[a,b]上连续，这意味着a和b夹住了f的一个根。

      该算法检查\( f(l_k) \)和\( f(u_k) \)的符号，其中k的值递增，其中\( l_k = max(lower, initial - \delta_k) \)，\( u_k = min(upper, initial + \delta_k) \)，使用递归\( \delta_{k+1} = r \delta_k + q, \delta_0 = 0\)并从\( k=1 \)开始搜索。当发生以下情况之一时，算法停止：

      • 找到至少一个正值和一个负值--成功！
      • 两个端点都达到了各自的限制--MathIllegalArgumentException
      • maximumIterations次迭代已经过去--MathIllegalArgumentException

      如果在第一次迭代（k=1）找到不同的符号，则返回的区间将是\( [a, b] = [l_1, u_1] \)。如果在后续迭代k>1中找到不同的符号，则返回的区间将是\( [a, b] = [l_{k+1}, l_{k}] \)或\( [a, b] = [u_{k}, u_{k+1}] \)。因此，使用这些参数调用的根求解器将从此步骤已知的最小夹逼区间开始。

      区间扩展速率通过改变递归参数r和q来调整。当乘法因子r设置为1时，序列是一个简单的算术序列，具有线性增长。当乘法因子r大于1时，序列具有渐近指数增长率。请注意，加法参数q不应设置为零，否则区间将退化为所有k值的单个初始点。

      作为一个经验法则，当根的位置预计在某个误差范围内已知时，r应设置为1，q应设置为误差范围的数量级。当根的位置真的是一个猜测时，r应设置为大于1的值（通常为2，以便在每次迭代中将区间长度加倍），q应根据初始搜索区间长度的一半进行设置。

      例如，如果我们考虑一个简单的函数f(x) = 1 - x并使用initial = 4，r = 1，q = 2，算法将计算f(4-2) = f(2) = -1和f(4+2) = f(6) = -5对于k = 1，然后f(4-4) = f(0) = +1和f(4+4) = f(8) = -7对于k = 2。然后它将返回区间[0, 2]作为已知夹逼根的最小区间。正如这个例子所示，初始值（这里是4）可能位于返回的夹逼区间之外。

      类型参数:
      T - 字段元素的类型
      参数:
      function - 要检查的函数
      initial - 被扩展以夹住根的区间的初始中点
      lowerBound - 下限（a永远不会低于此值）
      upperBound - 上限（b永远不会大于此值）
      q - 用于计算边界序列的加法偏移量（必须严格为正）
      r - 用于计算边界序列的乘法因子
      maximumIterations - 要执行的最大迭代次数
      返回:
      一个包含夹逼值的两个元素数组
      抛出:
      MathIllegalArgumentException - 如果在搜索区间内无法夹住函数
      从以下版本开始:
      1.2

    • midpoint

      public static double midpoint(double a, double b)
      计算两个值的中点。
      参数:
      a - 第一个值。
      b - 第二个值。
      返回:
      中点。

    • isBracketing

      public static boolean isBracketing(UnivariateFunction function, double lower, double upper) throws NullArgumentException
      检查区间边界是否包围根。也就是说，如果端点的值不等于零，则函数在端点处取相反的符号。
      参数:
      function - 函数。
      lower - 下限端点。
      upper - 上限端点。
      返回:
      如果给定点处的函数值具有相反的符号，则返回true。
      抛出:
      NullArgumentException - 如果function为null。

    • isSequence

      public static boolean isSequence(double start, double mid, double end)
      检查参数是否形成（严格）递增序列。
      参数:
      start - 第一个数字。
      mid - 第二个数字。
      end - 第三个数字。
      返回:
      如果参数形成递增序列，则返回true。

    • verifyInterval

      public static void verifyInterval(double lower, double upper) throws MathIllegalArgumentException
      检查端点是否指定一个区间。
      参数:
      lower - 下限端点。
      upper - 上限端点。
      抛出:
      MathIllegalArgumentException - 如果lower >= upper。

    • verifySequence

      public static void verifySequence(double lower, double initial, double upper) throws MathIllegalArgumentException
      检查lower < initial < upper。
      参数:
      lower - 下限端点。
      initial - 初始值。
      upper - 上限端点。
      抛出:
      MathIllegalArgumentException - 如果lower >= initial或initial >= upper。

    • verifyBracketing

      public static void verifyBracketing(UnivariateFunction function, double lower, double upper) throws MathIllegalArgumentException, NullArgumentException
      检查端点是否指定一个区间，并且端点包围一个根。
      参数:
      function - 函数。
      lower - 下限端点。
      upper - 上限端点。
      抛出:
      MathIllegalArgumentException - 如果函数在端点处具有相同的符号。
      NullArgumentException - 如果function为null。