Hedge Fund Modelling and Analysis (eBook)

An Object Oriented Approach Using C++

Paul Darbyshire, David Hampton (Autoren)

eBook Download: EPUB

2016
John Wiley & Sons (Verlag)
978-1-118-87956-6 (ISBN)

Infos

Use powerful C# algorithms and Object Oriented Programming (OOP) to aid in hedge fund decision making

Hedge fund managers cannot afford to ignore their risk/return profiles, and taking advantage of new technologies is an excellent way to minimize risk and capitalize on various investment styles. As Hedge Fund Analysis and Modeling Using C# demonstrates, the C# programming language is perfectly suited to hedge fund analysis. This book serves as a complete course in hedge fund modeling and provides a primer on C# and Object Oritented Programming (OOP) that will allow you to manage risk easily and make the most of key statistics.

Covering both basic and risk-adjusted performance measures, Hedge Fund Analysis and Modeling Using C# moves from simple to sophisticated analysis techniques, using worked examples to show you exactly how to manage return in an era of volatility and financial risk. You'll have access to:

• Complete guidance on using C# and Objected Oriented Programming (OOP) for analysis using non-normal returns data and other key statistics
• Bonus content on a companion website containing C# programs, algorithms, and data available for download
• Real world modeling exercises that demonstrate the identification of risk and return factors
• Complete guidance for optimizing hedge fund decisions using quantitative strategies

This is the only book on the market that guides you through using C# to model hedge fund risks and returns. Along with its companion titles on Excel/VBA analysis and MATLAB analysis, Hedge Fund Analysis and Modeling Using C# contributes important guidance for hedge fund managers who want to take advantage of technological platforms for optimal fund performance.

---

Use powerful C++ algorithms and Object Oriented Programming (OOP) to aid in hedge fund decision making Low interest rates, overcrowded markets and greater regulatory oversight are just some of the many reasons it is close to impossible for hedge funds to draw competitive returns. The solution for many hedge fund managers, quantitative investment analysts and risk managers is to adopt new technologies, platforms and programming languages to better manage their risks and maximise the benefits of their return profiles. Hedge Fund Modelling and Analysis is a full course in the latest analytic strategies for hedge fund investing, complete with a one-of-a-kind primer on both C++ and object oriented programming (OOP). Covering both basic and risk-adjusted performance measures, this practitioner's guide enables you to manage risk easily and make the most of key statistics with simple and advanced analysis techniques. This highly anticipated third book in the widely used Hedge Fund Modelling and Analysis series is the only guide available for applying the powerful C++ language to revolutionise hedge fund trading. Even if you've never worked with code before, the focused overview of C++ gives you everything you need to navigate the technical aspects of object oriented programming, which enables you to build sophisticated analysis programs from small units of reusable code. This book is your breakthrough introduction to winning with hedge funds in the new reality of trading. Jumpstart your new approach to beating the markets with: All the guidance and hands-on support you need to use quantitative strategies to optimise hedge fund decision-making. Illustrative modelling exercises and worked-out problems demonstrating what to expect when assessing risk and return factors in the real world. A companion website offering additional C++ programs, algorithms and data to download. Make reading Hedge Fund Modelling and Analysis your new routine and gain all the insight and relevant information you need to beat the markets.

Autor

PAUL DARBYSHIRE gained his PhD in Theoretical Physics from King's College London and then began his career working as a Quantitative Analyst and Trader at HSBC on the Exotic Derivatives and Structured Products desk. He has subsequently been involved in the development and implementation of a variety of trading and risk management platforms for a number of major investent banks around the globe. Since 2005, Paul has been responsible for the analysis and design of cutting-edge algorithms in the development of behavioural finance and decision-making models at the University of Oxford. Paul also provides many private equity firms, hedge funds and investment management companies with senior consultancy in areas such as dynamic portfolio optimisation, trading platform design, software engineering and risk management. DAVID HAMPTON gained his PhD in Electrical Engineering from the Queen's University of Belfast and an international MBA from Institut Superieur de Gestion in Paris, New York and Tokyo before joining Bank of America Capital Markets in London. David was previously an Adjunct Finance Professor at Skema Business School in Sophia Antipolis where he taught Financial Engineering and Excel/VBA Programming at the MSc level. At EDHEC Business School in Nice, he was responsible for managing their range of five MSc courses as Assistant Dean of the Financial Economics Track. An NFA registered CTA since 1996, David has been active as a consultant to the hedge fund community and as a Hedge Fund Manager with particular expertise in Global Macro Managed Futures and Long Short Equity investment styles. This is the third book in the authorial team's popular Hedge Fund Modelling and Analysis series, which includes Hedge Fund Modelling and Analysis using MATLAB and Hedge Fund Modelling and Analysis Using Excel and VBA.

Textauszug

CHAPTER 1
Essential C++

This chapter covers the fundamental requirements necessary to allow the reader to get up and running building quantitative models using the C++ programming language. This introduction is in no way intended to be an in-depth treatment of the C++ programming language but more an overview of the basics required to build your own efficient and adaptable programs. Once the key concepts have been developed, object-oriented principles are introduced and many of the advantages of building quantitative systems using such programming approaches are outlined. It is assumed that the reader will have some prerequisite knowledge of a low-level programming language and the necessary computation skills to effectively grasp and apply the material presented here.

1.1 A Brief History of C and C++

C is a procedural1 programming language developed at Bell Laboratories between 1969 and 1973 for the UNIX operating system. Early versions of C were known as K&R C after the publication of the book The C Programming Language written by Brian Kernighan and Dennis Ritchie in 1978. However, as the language developed and became more standardised, a version known as ANSI2 C became more prominent. Although C is no longer the choice of many developers, there is still a huge amount of legacy software coded in it that is actively maintained. Indeed, C has greatly influenced other programming languages, in particular C++ which began purely as an extension of C.

Often described as a superset of the C language, C++ uses an entirely different set of programming concepts designed around the Object-Oriented Programming (OOP) paradigm. Solving a computer problem with OOP involves the design of so-called classes that are abstractions of physical objects containing the state, members, capabilities and methods of the object. C++ was initially developed by Bjarne Stroustrup in 1979 whilst at Bell Laboratories as an enhancement to C; originally known as C with Classes. The language was renamed C++ in the early 80s and by 1998, C++ was standardised as ANSI/ISO3 C++. During this time several new features were added to the language, including virtual functions, operator overloading, multiple inheritance and exception handling. The ANSI/ISO standard is based on two main components: the core language and the C++ Standard Library that incorporates the C Standard Library with a number of modifications optimised for use with the C++ language. The C++ Standard Library also includes most of the Standard Template Library (STL); a set of tools, such as containers and iterators that provide array-like functionality, as well as algorithms designed specifically for sorting and searching tasks. C++11 is the most recent complete overhaul of the C++ programming language approved by ANSI/ISO on 12 August 2011, replacing C++03, and superseded by C++14 on 18 August 2014. The naming convention follows the tradition of naming language versions by the year of the specification's publication, although it was formerly known as C++0x to take into account many publication delays. C++14 is the informal name for the most recent revision of the C++ ANSI/ISO standard, intended to be a small extension over C++11, featuring mainly bug fixes and small syntax improvements.

1.2 A Basic C++ Program

Without doubt the best method of learning a programming language is to actually start by writing and analysing programs. Source 1.1 implements a basic C++ program that simply outputs a string of text, once the program has been compiled and executed, to the console window. Although the program looks very simple it nevertheless contains many of the fundamental components that every C++ program generally requires.

Source 1.1: A basic C++ program

Statements beginning with a hash symbol (#) indicate directives to the preprocessor that initialise when the compiler is first invoked, in this case, to inform the compiler that certain functions from the C++ Standard Library must be included. #include <windows.h> gives the program access to certain functions in the library, such as SetConsoleTitle() whilst #include <iostream> enables console input and output (I/O). Typical objects in the iostream library include cin and cout which are explicitly included through the using statement at the top of the program. Writing using std::cout at the top of the program avoids the need to keep retyping std through the scope resolution operator (::) every time cout is used. For example, if we had not specified using std::cout we would have to explicitly write std in front of each usage throughout the program, that is:

std::cout << "/n " << "Hedge Fund Modelling and Analysis: An Object Oriented Approach Using C++"; std::cin.get();

Although in this case there are only two occasions where we need std, you can imagine how this could quickly clog up code for very large programs. Note also that all C++ statements must end with a semi-colon (;).

A commonly identified problem with the C language is the issue of running out of names for definitions and functions when programs reach very large sizes eventually resulting in name clashes. Standard C++ has a mechanism to prevent such a clash through the use of the namespace keyword. Each set of C++ definitions in a library or program is wrapped into a namespace, and if some other definition has an identical name, but is in a different namespace, then there is no conflict. All Standard C++ libraries are wrapped in a single namespace called std and invoked with the using keyword:

using namespace std;

Whether to use using namespace std or explicitly state their use through using std::cout, for example, is purely a preference of programming style. The main reason we do not invoke using namespace std in our programs is that this leaves us the opportunity of defining our own namespaces if we wish and it is generally good practice to have only one namespace invocation in each program.

The main() function is the point at which all C++ programs start their execution even if there are several other functions declared in the same program. For this reason, it is an essential requirement that all C++ programs have a main() function within the body at some point in the program. Once the text is output to the console window, cin.get() is used to cause the program to pause so that the user can read the output and then close and exit the window by pressing any key. Technically, in C or C++ the main() function must return a value because it is declared as int i.e. the main function should return an integer data type. The int value that main() returns is usually the value that will be passed back to the operating system; in this case it is 0i.e. return 0 which indicates that the program ran successfully. It is not necessary to state return 0 explicitly, because the compiler invokes this automatically when main() terminates, but it is good practice to include a return type for all functions (including main()).

1.3 Variables

A variable is a name associated with a portion of memory used to store and manipulate the data associated with that variable. The compiler sets aside a specific amount of memory space to store the data assigned to the variable and associates the variable name with that memory address. As the name implies, variables can be changed within a program as and when required. When new data is assigned to the same variable, the old data is overwritten and restored in the same memory address. The data stored in a variable is only temporary and only exists as long as the variable itself exists (defined by the scope of the variable). If the data stored in a variable is required beyond its existence then it must be written to a permanent storage device, such as a disk or file.

A variable name can be any length and composed of lower and upper case letters, numbers and the underscore (_) character, but keep in mind that variables are case-sensitive. In practice, a programmer will usually develop their own variable naming convention but bear in mind that C++ reserves certain keywords for variable names so try not to clash with these. Table 1.1 shows a list of reserved C++ keywords.

Table 1.1 Reserved C++ keywords

asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while

There are sevenal built-in data types...

Produkt-Details

• Erscheint lt. Verlag: 26.10.2016
• Reihe/Serie: The Wiley Finance Series
• Reihe/Serie: Wiley Finance Series
• Reihe/Serie: Wiley Finance Series
• Sprache: englisch
• Themenwelt: Recht / Steuern ► Wirtschaftsrecht
• Themenwelt: Wirtschaft ► Betriebswirtschaft / Management ► Finanzierung
• Schlagworte: C# • C# algorithms • Code • C# programming language • David Hampton • Excel/VBA analysis • Finance & Investments • Financial Risk • Finanz- u. Anlagewesen • Finanzwesen • Hedge Fund • hedge fund analysis • Hedge Fund Analysis and Modeling Using C# • hedge fund decision making • hedge fund managers • hedge fund modeling • hedge fund risks • Hedge Funds • investment styles • manage return • manage risk • MATLAB analysis • minimize risk • New Technologies • non-normal returns data • Object oriented programming (OOP) • optimal fund performance • optimizing hedge fund decisions • Paul Darbyshire • Quantitative Strategies • return factors • risk-adjusted performance measures • risk/return profiles • sophisticated analysis • Statistics • technological platforms • Volatility
• ISBN-10: 1-118-87956-2 / 1118879562
• ISBN-13: 978-1-118-87956-6 / 9781118879566