金融工程中的Java方法：应用与投资指南

需积分: 13 89 浏览量更新于2024-07-17 收藏 2.05MB PDF 举报

《Java方法在金融工程中的应用》(Java Methods for Financial Engineering, Springer, 2007)是由Philip Barker撰写的一本专业书籍，专注于探索如何利用Java编程语言进行金融工程实践。该书不仅涵盖了金融领域的核心概念，还介绍了在投资和金融分析中实际运用Java技术的方法和工具。作者Philipp Barker持有BSc(HONS)、MBCS和MCMI资格，他在BWATechnologies Ltd.位于苏格兰罗斯林的Midlothian工作。这本书的主题涵盖了以下几个关键知识点： 1. **Java编程基础与金融工程结合**：书中首先介绍了Java的基础知识，包括类、对象、数据结构和控制流等，然后逐步将这些元素应用于金融工程，如期权定价模型、风险管理、衍生品交易系统等。 2. **金融模型实现**：作者展示了如何用Java构建和实现复杂的金融模型，例如Black-Scholes期权定价模型、蒙特卡洛模拟、VaR（Value at Risk）计算等，让读者理解金融工具背后的数学原理和编程实现。 3. **金融数据处理与分析**：书中强调了Java在大数据处理和金融数据管理方面的应用，如时间序列分析、回归分析和统计建模，以及如何利用Java处理实时市场数据。 4. **投资策略与算法交易**：读者可以学习到如何利用Java开发交易算法，包括高频交易、量化投资策略的编写和回测，以及如何确保算法的执行效率和稳定性。 5. **合规与安全性**：书中还涉及金融软件开发中的法律和监管要求，特别是在处理敏感金融数据时，如何保证代码的安全性和符合行业标准。 6. **版权与授权**：在版权方面，该书强调了复制、存储和传输的合法途径，提醒读者在遵循版权法和许可证规定的前提下合理使用内容。通过《Java Methods for Financial Engineering》，读者不仅能提升金融专业知识，还能掌握如何将Java这一通用编程语言转化为强大的金融工程工具，对于金融从业者和对金融编程感兴趣的开发者来说，这是一本极具价值的参考教材。

1.2. Core Math’s Classes 3

Figure 1.1. Bisection on y =2 −e

has at least one zero. The method takes the first approximation x

to the root by

halving the initial range. So

X

 (1.2.1)

The function fx

 is evaluated; there are three possible outcomes. First, in the

interval, [x

x

. fx

fx

<0. Means there is at least one root between these

endpoints. Second, fx

fx

 = 0 (we assume that fx

 = 0. This indicates

that we have found the root fx

. Third, fx

fx > 0. This means the root

is in the other interval half, [x

x

]. Given that the second outcome is not

initially achieved we continue with the process of halving the uncertainty until

a root is found within the desired precision. From Figure 1.1 we see that the

initial range, shown by arrow (1) is halved at x =05. The function evaluates

to 0.351, the function evaluates to −07183 at x = 10. The root therefore lies

within the range shown by arrow (2). The halved value is at x = 075. The

function evaluates to −0117. The root therefore lies within the range now in the

direction shown by arrow (3). The halved value is evaluated to be 0.131. The

range is now in the direction shown by arrow (4) This process is continued until

the desired precision is reached. The data in Table 1.1 shows the convergence

for the function of Figure 1.1.

Listing 1.1 shows the method evaluateRoot in the abstract class Inter-

valBisection. The abstract method ComputeFunction is implemented in the

extending class. The method evaluateRoot provides functionality for the bisection

algorithm. This is outlined below in Listing 1.1.

4 1. Introduction

Table 1.1. Interval Bisection on y = 2 −e

higher

n−1

−lower

n−1

lower

higher

0500000000000 1000000000000 0500000000000 1000000000000

0750000000000 0500000000000 0500000000000 0750000000000

0625000000000 0250000000000 0625000000000 0750000000000

0687500000000 0125000000000 0687500000000 0750000000000

0718750000000 0062500000000 0687500000000 0718750000000

0703125000000 0031250000000 0687500000000 0703125000000

0695312500000 0015625000000 0687500000000 0695312500000

0691406250000 0007812500000 0691406250000 0695312500000

0693359375000 0003906250000 0691406250000 0693359375000

0692382812500 0001953125000 0692382812500 0693359375000

0692871093750 0000976562500 0692871093750 0693359375000

0

693115234375 0000488281250 0693115234375 0693359375000

0693237304688 0000244140625 0693115234375 0693237304688

0693176269531 0000122070312 0693115234375 0693176269531

0693145751953 0000061035156 0693145751953 0693176269531

0693161010742 0000030517578 0693145751953 0693161010742

0693153381348 0000015258789 0693145751953 0693153381348

0693149566650 0000007629395 0693145751953 0693149566650

0693147659302 0000003814697 0693145751953 0693147659302

0693146705627 0000001907349 0693146705627 0693147659302

public double evaluateRoot(double lower, double higher)

//lower and higher are the initial estimates//

{

double fa; //fa and fb are the initial ‘guess’ values.//

double fb;

double fc; //fc is the function evaluation , fx//

double midvalue=0;

double precvalue=0;

fa=computeFunction(lower); //ComputeFunction is implemented

//by the caller//

fb=computeFunction(higher);

//Check to see if we have the root within the range bounds//

if (fa

∗

fb>0)

{ //If fa

∗

fb>0 then both are either positive//

//or negative and don’t bracket zero.//

midvalue=0;//Terminate program//

}

else

{

precvalue=midvalue;//preceding value for testing

//relative precision//

midvalue=lower+0.5*(higher-lower);

fc=computeFunction(midvalue) //Computes the fx//

//for the mid value//

1.2. Core Math’s Classes 5

if(fa

∗

fc<0)

{

higher=midvalue;

}

else

if(fa

∗

fc>0)

{

lower=midvalue;

}

} while((abs(fc)>precisionvalue&i<iterations));

//loops until desired number of iterations or precision is reached//

return midvalue;

}

Listing 1.1. Method evaluateRoot from class IntervalBisection in package CoreMath

The return value, midvalue in this case is output when the converging solution is

< 0001. Note we might have used different precision criteria that would rely on

the relative change in precision from one evaluation to the other. For example

using the loop: while((abs(midvalue-precvalue)>precisionvalue&i<iterations));

would terminate when successive values of the intermediate evaluations

are < 0001.

Table 1.1 shows the output from IntervalBisection when evaluating the

equation y = 2 −e

Column one shows the approximation output from the computation. Column

two shows previous higher estimate minus the previous lower estimate. Columns

three and four show the high and low estimates. For our example the initial

‘guesses’ were higher =10 and lower = 05.

The approximation after 19 iterations reaches the desired precision to 1E-06,

which is accurate to the ‘real’ solution by around -1E-07.

Listing 1.2 shows the complete class for IntervalBisection. ComputeFunction

is an abstract method which has to be implemented in the calling class (which

provides the actual function, in our example this is y = 2 −e

). The constructor

defaults to 20 iterations of the algorithm and the precision is set to 1e-3. The

using class can pass other values through the alternate constructor (int iterations,

double precisionvalue). Access to the internal values is via the get methods.

public abstract class IntervalBisection

{

//computeFunction is implemented to evaluate successive root estimates//

public abstract double computeFunction(double rootvalue);

protected double precisionvalue;

protected int iterations;

protected double lowerBound;

protected double upperBound;

//default constructor//

protected IntervalBisection()

{

iterations=20;

1.2. Core Math’s Classes 7

A class such as IntervalBisection has its core functionality controlled by the

using class. To compute the function y = 2 −e

we had to use an application

class which extended the abstract method ComputeFunction. The using class

provided the controlling logic to provide the equation into IntervalBisection.

The abstract class is there to provide a core technique (interval bisection) and not

to perform other functionality. The strategy of keeping core functionality within

static or abstract classes allows us to re-use the class in a variety of applications

without the need to re-design or add to the core.

In this example we have used the class IntervalBisection to implement interval

bisection on the function y = 2 −e

. Later we will use this same class to

implement interval bisection on a yield equation. It will perform exactly the

same functionality on a completely different equation; the controlling class (an

application class) will implement the abstract method computeFunction with the

various input equations.

We will see later that more than one class is often required before we can

implement an application. The interval bisection algorithm although generally

robust is slower to converge than other root finding algorithms. The Newton

Raphson algorithm (abbreviated to Newton’s method) is a method for a root

finding algorithm which converges to a root much more quickly than interval

bisection. Although the Newton method is quicker to converge, it requires the

derivative of the function to be used in the solution. This is a good example of

a series of classes being used to implement an application.

1.2.2. Newton’s Method

To use Newton’s method we will need to use the class Derivative from the

CoreMath package. This abstract class provides the method derivation to provide

functionality for providing the derivative of a single function. The class has

its abstract method deriveFunction extended by the using class which provides

the controlling logic to provide the single functions for evaluation. Listing 1.3

provides the complete abstract class for Derivative.

The method derivation uses the technique of difference quotients to arrive at

an approximation of a function. The method being implemented is based on the

general definition of the derivative.



x = lim

h→0

fx +h −fx

(1.2.2)

The implementation used is based on the approximation which gives best

accuracy with lower computational cost:



x =

fx +h −fx −h

(1.2.3)

The method which implements algorithm 1.1.3 is given below in Listing 1.3.

剩余560页未读，继续阅读

amiwho1

粉丝: 0
资源: 2

金融工程中的Java方法：应用与投资指南

Springer Java Methods for Financial Engineering

Springer.-.Java.Methods.for.Financial.Engineering.pdf

Java Methods for Financial Engineering Applications in Finance and Investment

statistical Models and Methods for Financial Markets

Statistical Models and Methods for Financial Markets

Statistics and Data Analysis for Financial Engineering

Springer的金融工程的入门教材，不过是英文的-Mathematics for Finance, Introduction to financial engineering

Artificial intelligence methods and tools for systems biology Springer; 2004

Python For ArcGIS(Springer,2015)

Machine Learning for Text-Springer(2018).pdf

最新资源