AACalc is an asset allocation and consumption planning calculator
Java HTML Python Gnuplot R CSS Shell
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
opal
web
.gitignore
LICENSE
README
agpl-3.0.txt

README

AACalc comprises a pair of asset allocation and consumption planning
calculators based on scientific principles, plus a SPIA pricing
calulator.

AACalc Alloc uses Merton's approach. It is fast, and easy to use.

AACalc Opal is a research calculator. It is complex, and
computationally demanding.

The SPIA pricing calculator computes actuarially fair SPIA prices
using up to date real, nominal, or corporate bond yield curves
obtained from the U.S. Treasury.

Notable featurss of AACalc Alloc:

  - A balance sheet approach - asset allocation can't be performed in
    isolation, but must be performed by taking into account the
    presence and size of Social Security, Pensions, 401(k)s, and
    income annuities.

  - Future contributions - the impact of any possible future
    contributions is handled by entering their expected annual amount,
    growth rate, and volatility.

  - Liability matching bonds - inflation indexed zero coupon bonds
    with a duration matching that of anticipated retirement cash flows
    are used as the risk free asset.

  - Income annuities - income annuitiesa are a valuable tool in the
    retirement toolbox. This caluclator optionally recommends the
    purchase of inflation indexed income annuities, that is single
    premium immediate annuities or deferred income annuities.

  - Admit what we don't know - returns from the stock market are
    unpredictable. We generate a range of results for different
    plausable scenarios.

Notable features of AACalc Opal:

  - A stochastic dynamic programming module to compute optimal asset
    allocation and consumption strategies assuming time-wise
    independent returns.

  - A Monte-Carlo simulator to assess strategy performance.

  - A variety of pre-computed strategies: age in bonds, consensus
    target date, fixed, fixed with guaranteed income treated as a
    bond, 4% rule, constant percentage, VPW, RMD, 1/life etc.

  - A variety of correlation preserving bootstraping and synthetic
    return generation options for the Monte Carlo simulator.

  - The ability to report the odds of portfolio failure, the time
    spent in the portfolio failure state, and certainty equivalent
    consumption metrics.

  - Optional handling of taxation in the Monte Carlo simulator using a
    variety of lot based accounting modules.

  - Mortality handled stochastically using mortality tables.

  - When computing or simulating the performance of a strategy, the
    ability to use consumption utility functions indicative of floor
    and upside consumption preferences.

  - In addition to the standard asset classes, the ability to handle
    liability mathing bonds, real annuties, and nominal annuities.

  - When handling 3 or more asset classes the ability to speed up
    performance in exchange for some loss of optimality by using mean
    variance optimization thanks to the Systematic Investor Toolbox.

  - Graphical display of the optimal strategy and its performance
    thanks to GNUPLOT.

  - An optional web based front end to the program.

Demo:

  - See https://www.aacalc.com/

AACalc implementation:

  - Open source. Licensed under the GNU Affero GPL. See the file
    agpl-3.0.txt for details. I am experimenting with business models,
    and other licensing terms may be available.

  - Runs on Ubuntu 14.04 Linux and possibly other systems. The Opal backend
    should be readily portable to other *nix systems. Frontend should
    be readily portable to other systems running Django 1.6.

  - Opal backend written in Java with call outs to R and GNUPLOT.

  - The Opal backend is able to take advantage of multicore computers
    for performance.  On a 20 core m4.10xlarge instance computing the
    optimal asset allocation takes a few seconds in the absence of
    annuities, or half an hour in their presence.

  - Web frontend written in Python using the Django framework.

  - Opal backend can be either run standalone, or in a server
    configuration talking to the frontend.

  - Opal backend capable of running in an autoscaling load balancing
    framework.

  - Opal backend performs minimal input sanity checking;
    responsibility for input sanity checking pushed on to frontend.

  - Opal backend uses hill climbing to avoid exhaustive search of the
    solution space.

  - Opal backend uses Shiller and a variety of other returns datasets.
    Opal backend and Alloc use Social Security cohort mortality and a
    variety of other mortality datasets.

To do:

  - Full scale optimization rather than MVO.

  - Handle returns from a distribution. (Like risk_free but with a
    mean, standard deviation, and distribution class such as
    log_normal).

  - Possibly support sticky market parameters (current value depends
    on prior years value): volatily, correlations, inflation, interest
    rate, etc. Sticky volatility doesn't look all that
    promising. Ability to predict volatility on an annual basis is
    probably 20-40%. See a 10% gain in metrics for expected versus
    unexpected 200% volatility. If occurs 25% of the time, net gain
    would only be 0.5-1%. Suspect stock-bond correlation is always
    low, so little advantage except if have other asset
    classes. Sticky inflation might influence nominal bond returns and
    SPIA prices. Sticky interest rates might influence bond returns
    and SPIA prices. Usually probably doesn't influence bond returns
    much, the one exception being the present regime, in which nominal
    interest rates can't fall much lower, so bond returns are at best
    only likely to be weakly positive.

  - Explore implications of using prospect theory to compute the
    optimal strategy (treat previous consumption level as an extra
    "wealth" dimension); will be slow.

Getting started:

  - It is suggested that Amazon EC2 be used for development work. A
    Ubuntu 16.04 t2.nano instance works fine for Alloc. A c3.xlarge
    instance is recommended for running Opal without annuities, or a
    m4.10xlarge with annuities. Opal runs on Ubuntu 14.04, but hasn't
    been tested on 16.04 or later. The same instance can be used to
    run the web server and the Opal backend server. In production the
    load can be larger, and it may be necessary to run a separate web
    server and run multiple Opal backend servers behind a load
    balancer.

  - Obtain the sources:

        sudo apt-get install git-core
        git clone https://github.com/gordoni/aacalc.git

  - If might do developement work:
        cd aacalc
        git config --global user.name "<FirstName> <LastName>"
        git config --global user.email "<user@email.com>"

  - See web/README for the web based Python Django frontend.

  - Optionally see opal/README for the Opal Java backend.