Apache Commons Math3学习之数值积分实例代码

网友投稿 657 2023-03-25


Apache Commons Math3学习之数值积分实例代码

Apache.Commons.Math3里面的数值积分支持类采用的是“逼近法”,即,先对大区间做一次积分,再对小区间做一次积分,若两次积分结果的差值小于某一设定的误差值,则认为积分完成。否则,将区间再次细分,对细分后的区间进行积分,与前一次积分相比较,如此反复迭代,直至最近的两次积分差值足够小。这样的结果,有可能会导致无法收敛。

为了使用org.apache.commons.math3.analysis.integration包中的积分器类,需要先实现UnivariateFunction接口(本文以MyFunction为例),实现其value方法。然后创建指定的积分器对象,本文以SimpsonIntegrator为例,最后调用其integrate(...)方法即可算出MyFunction的积分。

调用integrate(...)方法时需要提供4个参数:

第1个是最大逼近次数,要适当大一些,否则可能会无法收敛;

第2个是MyFunction类的实例;

第3个是积分区间下限;

第4个是积分区间上限。

SimpsonIntegrator在第一次迭代时一定是分别以积分下限和积分上限作为x调用连词MyFunction.value(...)方法,下一次则会将区间分成2份(除上下限x值之外,还有一个中间x值),再下一次则是分成4份……

以下是使用辛普森积分类的例子:

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.math3.analysis.UnivariateFunction;

import org.apache.commons.math3.analysis.integration.SimpsonIntegrator;

import org.apache.commons.math3.analysis.integration.UnivariateIntegrator;

interface TestCase

{

public Object run(List params) throws Exception;

public List getParams();

public void printResult(Object result) throws Exception;

}

public class TimeCostCalculator

{

public TimeCostCalculator()

{

}

/**

* 计算指定对象的运行时间开销。

*

* @param testCase 指定被测对象。

* @return 返回sub.run的时间开销,单位为s。

* @throws Exception

*/

private double calcTimeCost(TestCase testCase) throws Exception

{

List params = testCase.getParams();

long startTime = System.nanoTime();

Object result = testCase.run(params);

long stopTime = System.nanoTime();

testCase.printResult(result);

double timeCost = (stopTime - startTime) * 1.0e-9;

return timeCost;

}

public void runTest(TestCase testCase) throws Exception

{

double timeCost = calcTimeCost(testCase);

System.out.println("时间开销:: " + timeCost + "s");

System.out.println("-------------------------------------------------------------------------------");

}http://

public static void main(String[] args) throws Exception

{

TimeCostCalculator tcc = new TimeCostCalculator();

tcc.runTest(new CalcSimpsonIntegrator());

}

}

/**

* 使用辛普森法求解数值积分。Apache.Common.Math3中所用的辛普森法是采用逼近法,即先对整个积分区间用矩形积分,然后将区间分解为4份,再次积分,比较两次积分的差值,若想对误差大于某个预订数值,

* 则认为还需要继续细分区间,因此会将区间以2倍再次细分后求积分,并将结果与前一次积分的结果比较,直至差值小于指定的误差,就停止。

* @author kingfox

*

*/

class CalcSimpsonIntegrator implements TestCase

{

public CalcSimpsonIntegrator(http://)

{

System.out.print("本算例用于测试使用辛普森法计算积分。正在初始化计算数据 ... ...");

inputData = new double[arrayLength];

for (int index = 0; index < inputData.length; index++) // 鏂滃潯鍑芥暟

{

inputData[index] = Math.sin(2 * Math.PI * index * MyFunction.factor * 4);

}

func = new MyFunction();

integrator = new SimpsonIntegrator();

System.out.println("初始化完成!");

}

@Override

public Object run(List params) throws Exception

{

double result = ((SimpsonIntegrator)(params.get(1))).integrate(steps, (UnivariateFunction)(params.get(0)), lower, upper);

return result;

}

/**

* 获取运行参数

* @return List对象,第一个元素是求积函数,第二个参数是积分器。

*/

@Override

public List getParams()

{

List params = new ArrayList();

params.add(func);

params.add(integrator);

return params;

}

@Override

public void printResult(Object result) throws Exception

{

System.out.println(">>> integration value: " + result);

}

UnivariateFunction func = null;

UnivariateIntegrator integrator = null;

class MyFunction implements UnivariateFunction

{

@Override

public double value(double x)

{

// double y = x * factor; // 1.

// double y = 4.0 * x * x * x - 3.0 * x * x + 2.0 * x - 1.0; // 2.

// double y = -1.0 * Math.sin(x) + 2.0 * Math.cos(x) - 3.0; // 3.

double y = inputData[(int)(x / factor)];

// 4.

// System.out.println(x + ", " + y);

return y;

}

private static final double factor = 0.0001;

}

private double[] inputData = null;

private static final int arrayLength = 5000;

private static final double lower = 0.0;

// private static final double upper = 2.0 * Math.PI; // 3.

private static final double upper = (arrayLength - 1) * MyFunction.factor;

// 1. 2. 4.

private static final int steps = 1000000;

}

上述代码中,注释为1. 2. 3.的可以正常计算出结果,但注释为4.的就无法收敛。

基于org.apache.commons.math3.analysis.integration.UnivariateIntegrator的积分器的另一个局限性在于必须编写一个继承于UnivariateFunction的函数类,实现其value方法(根据输入的x值计算出y值),这种做法有利于可用解析式表达的情况,不利于对存放于外存的大量数据做积分处理。

总结

Java初级开发工程师面试题汇总.PDF

//jb51.net/books/576989.html

java JDK1.9 API 中文参考文档+原版文档 高清完整版 CHM

//jb51.net/books/575482.html

希望大家能够喜欢,希望对本站多多支持!


版权声明:本文内容由网络用户投稿,版权归原作者所有,本站不拥有其著作权,亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容,请联系我们jiasou666@gmail.com 处理,核实后本网站将在24小时内删除侵权内容。

上一篇:Apache Commons Math3探索之快速傅立叶变换代码示例
下一篇:管理后端接口的平台有哪些(后端权限管理使用什么技术实现)
相关文章

 发表评论

暂时没有评论,来抢沙发吧~