F# for Quantitative Finance. An introductory guide to utilizing F# for quantitative finance leveraging the .NET platform - Helion
ebook
Autor: Johan AstborgTytuł oryginału: F# for Quantitative Finance. An introductory guide to utilizing F# for quantitative finance leveraging the .NET platform
ISBN: 9781782164630
stron: 286, Format: ebook
Data wydania: 2013-12-26
Księgarnia: Helion
Cena książki: 139,00 zł
F# is a functional programming language that allows you to write simple code for complex problems. Currently, it is most commonly used in the financial sector. Quantitative finance makes heavy use of mathematics to model various parts of finance in the real world. If you are interested in using F# for your day-to-day work or research in quantitative finance, this book is a must-have.This book will cover everything you need to know about using functional programming for quantitative finance. Using a functional programming language will enable you to concentrate more on the problem itself rather than implementation details. Tutorials and snippets are summarized into an automated trading system throughout the book.This book will introduce you to F#, using Visual Studio, and provide examples with functional programming and finance combined. The book also covers topics such as downloading, visualizing and calculating statistics from data.
F# is a first class programming language for the financial domain.
Osoby które kupowały "F# for Quantitative Finance. An introductory guide to utilizing F# for quantitative finance leveraging the .NET platform", wybierały także:
- Windows Media Center. Domowe centrum rozrywki 66,67 zł, (8,00 zł -88%)
- Ruby on Rails. Ćwiczenia 18,75 zł, (3,00 zł -84%)
- DevOps w praktyce. Kurs video. Jenkins, Ansible, Terraform i Docker 190,00 zł, (39,90 zł -79%)
- Przywództwo w świecie VUCA. Jak być skutecznym liderem w niepewnym środowisku 58,64 zł, (12,90 zł -78%)
- Scrum. O zwinnym zarządzaniu projektami. Wydanie II rozszerzone 58,64 zł, (12,90 zł -78%)
Spis treści
F# for Quantitative Finance. An introductory guide to utilizing F# for quantitative finance leveraging the .NET platform eBook -- spis treści
- F# for Quantitative Finance
- Table of Contents
- F# for Quantitative Finance
- Credits
- About the Author
- About the Reviewers
- www.PacktPub.com
- Support files, eBooks, discount offers, and more
- Why Subscribe?
- Free Access for Packt account holders
- Support files, eBooks, discount offers, and more
- Preface
- What this book covers
- What you need for this book
- Who this book is for
- Conventions
- Reader feedback
- Customer support
- Downloading the example code
- Errata
- Piracy
- Questions
- 1. Introducing F# Using Visual Studio
- Introduction
- Getting started with Visual Studio
- Creating a new F# project
- Creating a new project in Visual Studio
- Understanding the program template
- Adding an F# script file
- Creating a new F# project
- Understanding F# Interactive
- Language overview
- Explaining mutability and immutability
- Primitive types
- Explaining type inference
- Explaining functions
- Learning about anonymous functions
- Explaining higher-order functions
- Currying
- Investigating lists
- Concatenating lists
- Tuples
- The pipe operator
- Documenting your code
- Your first application
- The whole program
- Understanding the program
- Extending the example program
- The entire program
- The power of prototyping
- Functional languages in quantitative finance
- Understanding the imperative code and interoperability
- Summary
- 2. Learning More About F#
- Structuring your F# program
- Looking into modules
- Using functions and values in modules
- Namespaces
- Looking into modules
- Looking deeper inside data structures
- Record types
- Discriminated unions
- Enumerations
- Arrays
- Interesting functions in an array module
- Lists
- Pattern matching and lists
- Interesting functions in a list module
- Sequences
- Interesting functions in the sequence module
- Sets
- Maps
- Interesting functions in the map module
- Options
- Strings
- Interesting functions in the string module
- Choosing data structures
- Arrays
- Lists
- Sets
- Maps
- More on functional programming
- Recursive functions
- Tail recursion
- Pattern matching
- Incomplete pattern matching
- Using guards
- Pattern matching in assignment and input parameters
- Active patterns
- Introducing generics
- Lazy evaluation
- Units of measure
- Asynchronous and parallel programming
- Events
- Background workers
- Threads
- Thread pools
- Asynchronous programming
- The F# asynchronous workflows
- Asynchronous binding
- Examples of using an async workflow
- Parallel programming using TPL
- MailboxProcessor
- A brief look at imperative programming
- Object-oriented programming
- Classes
- Objects and members
- Methods and properties
- Overloaded operators
- Object-oriented programming
- Using XML documentation
- Useful XML tags
- Typical XML documentation
- Summary
- Structuring your F# program
- 3. Financial Mathematics and Numerical Analysis
- Understanding the number representation
- Integers
- Twos complement
- Floating-point numbers
- The IEEE 754 floating-point standard
- Integers
- Learning about numerical types in F#
- Arithmetic operators
- Learning about arithmetic comparisons
- Math operators
- Conversion functions
- Introducing statistics
- Aggregate statistics
- Calculating the sum of a sequence
- Calculating the average of a sequence
- Calculating the minimum of a sequence
- Calculating the maximum of a sequence
- Calculating the variance and standard deviation of a sequence
- Calculating variance
- Calculating standard deviation
- Looking at an example application
- Aggregate statistics
- Using the Math.NET library
- Installing the Math.NET library
- Introduction to random number generation
- Pseudo-random numbers
- Mersenne Twister
- Probability distributions
- Normal distribution
- Statistics
- Linear regression
- Using the least squares method
- Using polynomial regression
- Learning about root-finding algorithms
- The bisection method
- Looking at an example
- Finding roots using the NewtonRaphson method
- Looking at an example
- Finding roots using the secant method
- Looking at an example
- The bisection method
- Summary
- Understanding the number representation
- 4. Getting Started with Data Visualization
- Making your first GUI in F#
- Composing interfaces
- More about agents
- The user interface
- The main application
- Learning about event handling
- Displaying data
- Extending the form to use a table
- Displaying financial data from Yahoo! Finance
- Understanding the application code
- Extending the application to use Bollinger bands
- Using FSharp.Charting
- Creating a candlestick chart from stock prices
- Creating a bar chart
- Summary
- 5. Learning Option Pricing
- Introduction to options
- Looking into contract specifications
- European options
- American options
- Exotic options
- Learning about Wiener processes
- Learning the Black-Scholes formula
- Implementing Black-Scholes in F#
- Using Black-Scholes together with charts
- Introducing the greeks
- First-order greeks
- Second-order greeks
- Implementing the greeks in F#
- Delta
- Gamma
- Vega
- Theta
- Rho
- Investigating the sensitivity of the greeks
- Code listing for visualizing the four greeks
- The Monte Carlo method
- Summary
- Introduction to options
- 6. Exploring Volatility
- Introduction to volatility
- Actual volatility
- Implied volatility
- Exploring volatility in F#
- The complete application
- Learning about implied volatility
- Solving for implied volatility
- Delta hedging using Black-Scholes
- Exploring the volatility smile
- Summary
- Introduction to volatility
- 7. Getting Started with Order Types and Market Data
- Introducing orders
- Order types
- Market orders
- Limit orders
- Conditional and stop-orders
- Order properties
- Order types
- Understanding order execution
- Introducing market data
- Implementing simple pretrade risk analysis
- Validating orders
- Introducing FIX and QuickFIX/N
- Using FIX 4.2
- Configuring QuickFIX to use the simulator
- Using FIX 4.2
- Summary
- Introducing orders
- 8. Setting Up the Trading System Project
- Explaining automated trading
- Understanding software testing and test-driven development
- Understanding NUnit and FsUnit
- Requirements for the system
- Setting up the project
- Installing the NUnit and FsUnit frameworks
- Connecting to Microsoft SQL Server
- Introducing type providers
- Using LINQ and F#
- Explaining sample code using type providers and LINQ
- Creating the remaining table for our project
- Using LINQ and F#
- Writing test cases
- Details about the setup
- Summary
- 9. Trading Volatility for Profit
- Trading the volatility
- Plotting payoff diagrams with FSharpCharts
- Learning directional trading strategies
- Trading volatility using options
- Trading the straddle
- Long straddle
- Short straddle
- Trading the straddle
- Trading the butterfly spread
- The long butterfly spread
- The short butterfly spread
- Trading the VIX
- Trading the delta neutral portfolio
- Trading volatility using options
- Deriving the mathematics
- Hedging with implied volatility
- Implementing the mathematics
- Learning relative value trading strategies
- Trading the slope of the smile
- Defining the trading strategy
- Case 1 increasing the slope
- Case 2 decreasing the slope
- Defining the entry rules
- Defining the exit rules
- Summary
- 10. Putting the Pieces Together
- Understanding the requirements
- Revisiting the structure of the system
- Understanding the Model-View-Controller pattern
- The model
- The view
- The controller
- Executing the trading strategy using a framework
- Building the GUI
- Presenting information in the GUI
- Adding support for downloading the data
- Looking at possible additions to the system
- Improving the data feed
- Support for backtesting
- Extending the GUI
- Converting to the client-server architecture
- Summary
- Index