Discount to $1.99

For a short time only! $1.99.

You get the full package.

Introduction to downloading financial data added

A short introduction to downloading financial data has been posted. It's available at http://quantlua.com/WP/2013/07/05/downloading-financial-data/

Six Reasons to get QuantLua

QuantLua is a new app available on the app store. It is made especially for people in quantitative finance, or learning finance and financial engineering, but useful for others too. It consists of two main parts: the QuantLib/Lua programming environment and the historical stock simulator. These two components can be used separately, but have been built to work together well. With QuantLua you are able to download historical data, analyze it and display it in various ways.

Here are 6 good reasons why you want to get QuantLua.

1. The graphics are impressive. What other app allows you construct your own plots to analyze various aspects of the stock market? You are not constrained by the graphs provided, you can take the examples provided and make them suit you.

2. There are many functions at your disposal, and many more to come. QuantLua is built on two well tested pillars, Lua and QuantLib. Lua is a full fledged programming language with features not found in other languages. QuantLib is a powerful computational finance library providing with lots of functionality. If you do not find the function you need, you can create it yourself or ask.

3. It is fun and educational. The stock simulator can be used to teach about how the stock market works. It can be used as game to test how good a trader you are (or were) compared to your friends.

4. It is cheap. There is no other program on any platform with as much functionality as QuantLua at such a low low price. Only custom built platforms costing tons of money can provide such functionality.

5. You are in control. We have provided examples of what you can do, but ultimately you are not hemmed in by our examples. You can try your own ideas, including things we have never imagined.

6. There is support. QuantLib has a very strong online community where you can learn more on how to use it. Lua has been around for a very long time and has gathered a huge following due to its versatility. As always, we are always here to help.


So don't hesitate: head over to the iTunes App store and grab yourself a copy

Introduction to the plot command.

An introduction to the plot command is now up at the quantlua support site

This is one of the most important commands as it enables you to create a wide range of plots.

Discount for a limited time.

QuantLua will be selling at 40% discount from now until the end of the month.

Hurry while offer lasts!

QuantLua now approved for the iTunes App store.

QuantLua has been approved for the app store and is scheduled to appear shortly.

The app is available here



QuantLua is the most comprehensive financial application available for the iPhone. It has these main features: 

-A programmable historical stock simulator for select US stocks 

-The most comprehensive finance calculator available, incorporating the QuantLib quantitative finance library and the programming language Lua. 

-Excellent graphics library for building your own plots. It includes line graphs, bar graphs and pie charts. 


The historical stock market simulator is for select US stocks. It enables you to build a portfolio and see how the strategy would have performed over time. It is also fully programmable, enabling the analysis of dynamic strategies. 

Also included is a historical stock and currency data feed. This imports stock data from Yahoo Finance and currency data from OANDA directly into the Lua programming engine. 

All this is powered by Lua, an intuitive and complete programming language well suited to financial analysis.

Small fix for an example script

The script "UserScripts/Graphics/Function" has a small bug. It should be

-- define function

local function fc(x)

  return math.cos(x)

end

 

local function fs(x)

  return math.sin(x)

end

 

plot({f=fs,x={0.5,4},p=20,r=1,w=1,c=2},

{f=fc,x={1,5},c=1,r=1,w=1})

QuantLua submitted to app store

Now awaiting approval. :-)

Call for testers!

I am in the process of testing the application QuantLua in preparation for release in the next few weeks. If you would like to test it then please contact me on tgwena(a)gmail.com and we can make arrangements.

Hurry! Space is limited (by Apple)

Life on the big(ger) screen (iPhone 5)

The iPhone 5 display provides more space for bigger, better graphs. Look at the examples below:

iPhone 5 and instruction manual

Just completed porting to iPhone 5. Running on a dual core machine presented interesting challenges.

Also put up a draft of the instruction manual.

Feature list.

This is a comprehensive summary of the features found in Financial Game (provisional name, subject to change)

1. A programmable simulation engine using historical stock prices

2. A comprehensive calculator with the following

      a. Programmable in Lua, a stable mature language well suited to financial calculations.

      b. Full access to the QuantLib financial library

     c. Extensive graphics capabilities, including line graphs, pie charts, bar graphs.

     d. Access to historical stock and currency data

Running two historical simulations

Running two simulations of IBM starting from 1981 going through the 1987 crash.

The code for the first simulation:

local s=stock("ibm")

local p=currpf()

if s:price(-1)>s:price() and p/s<10 then

  _=p+10*s

end


if s:price(-1) <s:price() and p/s>0 then

  _=p-10*s

end

This code is run daily and does the following: Buy 10 IBM stock if yesterday's price is higher than today, otherwise sell if yesterday's price is lower. This is essentially bucking the trend. This is the blue line.

The second simulation does the opposite (this is the red line):

local s=stock("ibm")

local P=currpf()

if s:price()>s:price(-1) and P/s<10 then

  _=P+10*s

end

if s:price()<s:price(-1) and P/s>0 then

  _=P-10*s

end 

The results of the simulation are in the graph below:

A note on the code.

A stock object is created simply by saying 'stock(symbolstring)' e.g. 'stock("ibm")'. Adding or subtracting assets to a portfolio is done by a regular +, so the line

       _=P+10*s

simply adds ten shares of s to the portfolio P.

Dividing a portfolio by a stock give a count of how many shares are in that portfolio.
P/s is the count of the number of share in P.

Latest screenshot:

2012 video showing graphics capabilities

A video of an early 2012 edition of the program:

Images from most recent build

Reading Yahoo/Fed data directly

I can now use Lua to read in Federal-H15 data and Yahoo stock data. directly into QuantLib/Lua. I just wish I could read bond data from somewhere :-(

QuantLib, Lua on iPhone

Pricing a bond using QuantLib/Lua

Here is an example of pricing a bond using QuantLib/Lua on the iPhone

--Simple bond pricing

--http://tgwena.blogspot.com

ql=QuantLib

Date=ql.Date

local sDD=Date(17,5,1998)

local eDD=Date(17,5,2001)

local r=0.04 --interest rate

local c=0.06 --coupon

ql.Settings_instance():setEvaluationDate(sDD)

sched=ql.Schedule(sDD,eDD,ql.Period(2),ql.NullCalendar(),ql.Unadjusted,ql.Unadjusted,0,false)

ufixQ=ql.SimpleQuote(r)

ufixH=ql.QuoteHandle(ufixQ)

curve=ql.FlatForward(0,ql.NullCalendar(),ufixH,ql.SimpleDayCounter())

flatTS=ql.YieldTermStructureHandle(curve)

bondEngine=ql.DiscountingBondEngine(flatTS)

bond=ql.FixedRateBond(0,100,sched,ql.DoubleVector(1,c),ql.SimpleDayCounter(),ql.Unadjusted, 100, sDD)

bond:setPricingEngine(bondEngine)

print(bond:dirtyPrice())

A sample Lua/QuantLib program

This example is a rip of the Python Lua example for European options:

It returns the values 0.030342732609191 and 0.030027071770314 respectively

-- Mostly ripped from Python European Example

-- makes life a little simpler

QL=QuantLib

Date=QL.Date

tD=Date(15,QuantLib.May,1998)

sD=Date(17,QuantLib.May,1998)

QL.Settings_instance():setEvaluationDate(tD)

print(QL.Settings_instance():getEvaluationDate())

riskFreeRate = QL.FlatForward(sD, 0.05, QL.Actual365Fixed())

exercise = QL.EuropeanExercise(Date(17,5,1999))

payoff = QL.PlainVanillaPayoff(QL.Option_Call, 8.0)

underlying = QL.SimpleQuote(7.0)

volatility = QL.BlackConstantVol(tD, QL.TARGET(), 0.10, QL.Actual365Fixed())

dividendYield = QL.FlatForward(sD, 0.05, QL.Actual365Fixed())

process = QL.BlackScholesMertonProcess(QL.QuoteHandle(underlying),QL.YieldTermStructureHandle(dividendYield),QL.YieldTermStructureHandle(riskFreeRate),QL.BlackVolTermStructureHandle(volatility))

option = QL.VanillaOption(payoff, exercise)

option:setPricingEngine(QL.AnalyticEuropeanEngine(process))

-- Analytic

print ("Analytic Price",option:NPV())

-- Finite Difference

-- method: finite differences

timeSteps = 801

gridPoints = 800

option:setPricingEngine(QL.FDEuropeanEngine(process,timeSteps,gridPoints))

print("finite diff.",option:NPV())