F# for Quantitative Finance. An introductory guide to utilizing F# for quantitative finance leveraging the .NET platform

Spis treści książki

• 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
  • 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
    • 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 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
    • Using XML documentation
      • Useful XML tags
      • Typical XML documentation
    • Summary
  • 3. Financial Mathematics and Numerical Analysis
    • Understanding the number representation
      • Integers
        • Twos complement
      • Floating-point numbers
        • The IEEE 754 floating-point standard
    • 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
    • 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
    • Summary
  • 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
  • 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
  • 7. Getting Started with Order Types and Market Data
    • Introducing orders
      • Order types
        • Market orders
        • Limit orders
        • Conditional and stop-orders
      • Order properties
    • 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
    • Summary
  • 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
    • 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 butterfly spread
        • The long butterfly spread
        • The short butterfly spread
      • Trading the VIX
      • Trading the delta neutral portfolio
    • 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

pokaż cały spis treści

ukryj recenzje