Clojure for Finance

Leverage the power and flexibility of the Clojure language for finance

Clojure for Finance

This ebook is included in a Mapt subscription
Timothy Washington

Leverage the power and flexibility of the Clojure language for finance
$0.00
$27.99
$34.99
$29.99p/m after trial
RRP $27.99
RRP $34.99
Subscription
eBook
Print + eBook
Start 30 Day Trial
Subscribe and access every Packt eBook & Video.
 
  • 4,000+ eBooks & Videos
  • 40+ New titles a month
  • 1 Free eBook/Video to keep every month
Start Free Trial
 
Preview in Mapt

Book Details

ISBN 139781785289286
Paperback188 pages

Book Description

Clojure is a dynamic programming language with an emphasis on functional programming. Clojure is well suited to financial modeling as it is a functional programming language. Such languages help developers work with high-level mathematical abstractions without having to implement low-level code that handles the arithmetic operations.

Starting with the importance of representing data and calculations effectively, this book will take you all the way to being competent in financial analytics and building financial applications.

First, we introduce the notions of computation and finance, which will help you understand Clojure's utility to solve real-world problems in many domains, especially finance. Next, we will show you how to develop the simple-moving-average function by using the more advanced partition Clojure data transformation function. This function, along with others, will be used to calculate and manipulate data.

You will then learn to implement slightly more complicated equations, how to traverse data, and deal with branching and conditional dispatch. Then, the concept of side-effecting and its various approaches are introduced, along with the strategy of how to use data as the interface to other systems. Finally, you will discover how to build algorithms while manipulating and composing functions.

Table of Contents

Chapter 1: Orientation – Addressing the Questions Clojure Answers
Notions of computation
Notions of finance
Concrete types of computation
Tooling
A first look at Clojure's core functions
Summary
Chapter 2: First Principles and a Useful Way to Think
Modeling stock price activity
Function evaluation
First-class functions
Lazy evaluation
Basic Clojure functions and immutability
Namespaces and creating our first function
Basic data structures
Summary
Chapter 3: Developing the Simple Moving Average
Perception and representation
Knowing the data input
Knowing the data output
Reasoning about the equation needed to achieve our output
Understanding Vars and bindings
Working with lazy sequences
Implementing our equation
Destructuring
Summary
Chapter 4: Strategies for Calculating and Manipulating Data
Our first refactor – the price list
The exponential moving average
The Bollinger Bands
Summary
Chapter 5: Traversing Data, Branching, and Conditional Dispatch
Our second refactor – the generate prices function
Polynomial expressions
A sine wave
Stitching the pieces together
Surveying the function landscape
First order functions
Applying functions
Summary
Chapter 6: Surveying the Landscape
Scalar data types
Numbers and precision
A review of collections
Data transformation patterns and principles
Clojure's model of state and identity
Introducing side effects
Concurrency and parallelism
Type systems
Comparing Clojure with object orientation
Comparing Clojure with FP and strong typing
Summary
Chapter 7: Dealing with Side Effects
Simple writing
Extensible Data Notation
Devising a persistence strategy
Consuming from a data stream
Using a componentized architecture
Summary
Chapter 8: Strategies for Using Macros
Simple reading
Functions for querying a system
Separate OR AND lookups
Deriving a query language using macros
Summary
Chapter 9: Building Algorithms – Strategies to Manipulate and Compose Functions
Structuring our data for further analysis
A third refactor of the analytic functions
Signals using moving averages
The Relative Strength Index
Bollinger Band signals
Summary

What You Will Learn

  • Quickly and effectively represent data and calculations using Clojure
  • Use Clojure’s basic language tools such as laziness, immutability, and first­class functions to solve real-world problems
  • Explore mathematical derivatives to generate different wave forms
  • Get acquainted with the advanced approaches to calculating and transforming data, and building algorithms
  • Use Clojure's functions to access, update, and compose data structures
  • Be introduced to the concept of side­effecting behavior and the different ways to handle it
  • Compose simple and exponential functions together to get a buy or sell signal

Authors

Table of Contents

Chapter 1: Orientation – Addressing the Questions Clojure Answers
Notions of computation
Notions of finance
Concrete types of computation
Tooling
A first look at Clojure's core functions
Summary
Chapter 2: First Principles and a Useful Way to Think
Modeling stock price activity
Function evaluation
First-class functions
Lazy evaluation
Basic Clojure functions and immutability
Namespaces and creating our first function
Basic data structures
Summary
Chapter 3: Developing the Simple Moving Average
Perception and representation
Knowing the data input
Knowing the data output
Reasoning about the equation needed to achieve our output
Understanding Vars and bindings
Working with lazy sequences
Implementing our equation
Destructuring
Summary
Chapter 4: Strategies for Calculating and Manipulating Data
Our first refactor – the price list
The exponential moving average
The Bollinger Bands
Summary
Chapter 5: Traversing Data, Branching, and Conditional Dispatch
Our second refactor – the generate prices function
Polynomial expressions
A sine wave
Stitching the pieces together
Surveying the function landscape
First order functions
Applying functions
Summary
Chapter 6: Surveying the Landscape
Scalar data types
Numbers and precision
A review of collections
Data transformation patterns and principles
Clojure's model of state and identity
Introducing side effects
Concurrency and parallelism
Type systems
Comparing Clojure with object orientation
Comparing Clojure with FP and strong typing
Summary
Chapter 7: Dealing with Side Effects
Simple writing
Extensible Data Notation
Devising a persistence strategy
Consuming from a data stream
Using a componentized architecture
Summary
Chapter 8: Strategies for Using Macros
Simple reading
Functions for querying a system
Separate OR AND lookups
Deriving a query language using macros
Summary
Chapter 9: Building Algorithms – Strategies to Manipulate and Compose Functions
Structuring our data for further analysis
A third refactor of the analytic functions
Signals using moving averages
The Relative Strength Index
Bollinger Band signals
Summary

Book Details

ISBN 139781785289286
Paperback188 pages
Read More

Read More Reviews