## But why Oanda?

**NOTE**I now post my

**into my personal FACEBOOK ACCOUNT and TWITTER. Don't worry as I don't post stupid cat videos or what I eat!**

*TRADING ALERTS*Comparing trading platforms and brokers on Google Trends

I compare all the popular trading platforms including Tradestation, Multicharts, MT4, Ninja Trader and even MotiveWave. It seems that MT4 is easily #1 but Tradestation is quite popular with Ninja Trader trading.

I am somehow started glancing at brokers and even crypto currency/Bitcoin exchanges. It seems Crypto exchanges was very very popular a year ago but quickly died off. When you look at the brokers like Interactive Brokers, Oanda, Dukascopy, and other crypto exchanges. I broke down the analysis down by city and event country or region.

You can clearly see Oanda is the dominant force. globally. This is another reason I found MT4 (Metatrader 4) is popular. MT5 is up there swell. When you look at the region what is driving Oanda, it seems be out of Hong Kong and Asia but it still dominates on Google Trend audience share. Also, when you look at the similar terms as Oanda. I found mysteries around PostFinance.ch (a digital bank out of Switzerland) and Sweden and Norway regions. It seems that some West African countries were in there as well. Maybe someone can explain this relationship I am seeing.

JP Morgan quant drop whole market comparing to 1987

Blame it on low volatility

http://www.cnbc.com/2017/07/27/jpmorgan-quant-drops-the-whole-market-with-report-comparing-to-1987.html

Comparing any 2 stock or assets performance with multi timeframe

A useful chart comparison for my Quant Analytics members

From a new Twitter follower so many thanks to them for sending

http://www.quantschool.com/home/programming-2/comparing_inmemory_data_stores

Join my our FREE to learn about trading database usage

Thoughts on Erlang stellar potential while comparing to FSharp and Google Go or even Java

This is an awesome langiage for concurrency, message queueing, and even database potential.** It also mission critical** as well but would be top contender for within a Linux or UNIX environment.

I want option integrate with .NET

ttp://www.ndcmagazine.com/erlang-c-developers/

http://blog.aumcode.com/2013/10/nfx-native-interoperability-of-net-with.html <– no library released yet even up until a couple of weeks ago but has potential

https://github.com/saleyn/otp.net <- Could use this for now but swtiching to NFX could be a pain once the code is written

http://itadapter.com/nfxHelp/html/N_NFX_Erlang.htm

Note statement: [This is preliminary documentation and is subject to change.]

http://stackoverflow.com/questions/2214954/is-f-really-faster-than-erlang-at-spawning-and-killing-processes

http://www.csc.kth.se/utbildning/kth/kurser/DD143X/dkand12/Group6Alexander/anders_jarleberg_kim_nilsson.rapport.pdf

Note in conclusion: Erlang best for fault tolerance, Java fastest but hard to implement and maintain, F# scales better than Erlang at 4 cores

http://strangelights.com/blog/archive/2007/10/24/1601.aspx

Meet Cap-n-Proto who will instantly speed up your trading system via C++ and Erlang

http://kentonv.github.io/capnproto/otherlang.html

http://ecapnp.astekk.se/

For 2008 a comment of:

In short I’m not trying to pretend that F# concurrency story is anywhere near as good as Erlang’s, but I feel its asynchronous workflows are a small step in the right direction.

It is now late 2014 but let’s see what potential of F# brings moving forward

**UPDATES:** (not mentioned in summary video)

http://codeswamp.com/ <— Potentially best site for info on integrating Erlang and .NET

http://www.erlang-factory.com/upload/presentations/518/Erlangfor.NETDevelopersv3.pdf

https://github.com/saleyn/otp.net <– potential .net with Erlang integration

https://github.com/takayuki/Erlang.NET <–unmentioned library for .NET with Erlang but not updated in 5 years

More options:

https://www.scss.tcd.ie/~htewari/4D1/erlang/lib/odbc-0.9.4/doc/html/OdbcCompileWindows.html

http://stackoverflow.com/questions/1811516/integrating-erlang-with-c

Join my FREE newsletter to see which language I go with

My summary video:

An old movie shows use case with a PBX minus the Monty Python cheese factor

A presentation we did with Phil Trefold for finance with F#:

July 18. Comparing distributed databases with the London Cassandra User Group. Free talk.

It’s an interesting month for anyone who is currently evaluating NoSQL solutions — come along to the London Cassandra User Group where this month we’re focusing on analysing other distributed databases to see how they compare to Cassandra.

Get more info and sign up here: http://skillsmatter.com/podcast/nosql/mongodb/js-433

Matlab Demo of comparing Euribor vs France’s CAC 40 spanning 5 years

This is a demo excersise of Matlab’s help:

1.

Load the data. Load a daily historical data set containing 3-month Euribor rates and closing index levels of France’s CAC 40 spanning the time interval February 7, 2001 to April 24, 2006:

load Data_GlobalIdx2

2.

Simulate risk-neutral sample paths. Simulate risk-neutral sample paths of the CAC 40 index using a geometric Brownian motion (GBM) model:

where r(t) represents evolution of the risk-free rate of return.

Furthermore, assume that you need to annualize the relevant information derived from the daily data (annualizing the data is optional, but is useful for comparison to other examples), and that each calendar year comprises 250 trading days:

dt = 1 / 250;

returns = price2ret(Dataset.CAC);

sigma = std(returns) * sqrt(250);

yields = Dataset.EB3M;

yields = 360 * log(1 + yields);

3.

Compare the sample paths from two risk-neutral historical simulation approaches. Compare the resulting sample paths obtained from two risk-neutral historical simulation approaches, where the daily Euribor yields serve as a proxy for the risk-free rate of return.

1.

The first approach specifies the risk-neutral return as the sample average of Euribor yields, and therefore assumes a constant (non-dynamic) risk-free return:

nPeriods = length(yields); % Simulated observations

strm = RandStream(‘mt19937ar’,’Seed’,5713);

RandStream.setDefaultStream(strm);

obj = gbm(mean(yields), diag(sigma), ‘StartState’, 100)

[X1,T] = obj.simulate(nPeriods, ‘DeltaTime’, dt);

obj =

Class GBM: Generalized Geometric Brownian Motion

————————————————

Dimensions: State = 1, Brownian = 1

————————————————

StartTime: 0

StartState: 100

Correlation: 1

Drift: drift rate function F(t,X(t))

Diffusion: diffusion rate function G(t,X(t))

Simulation: simulation method/function simByEuler

Return: 0.0278117

Sigma: 0.231875

2.

In contrast, the second approach specifies the risk-neutral return as the historical time series of Euribor yields. It therefore assumes a dynamic, yet deterministic, rate of return; this example does not illustrate stochastic interest rates. To illustrate this dynamic effect, use the ts2func utility:

r = ts2func(yields, ‘Times’, (0:nPeriods – 1)’);

ts2func packages a specified time series array inside a callable function of time and state, and synchronizes it with an optional time vector. For instance:

r(0,100)

ans =

0.0470

evaluates the function at (t = 0, X t = 100) and returns the first observed Euribor yield. However, you can also evaluate the resulting function at any intermediate time t and state Xt:

r(7.5,200)

ans =

0.0472

Furthermore, the following command produces the same result when called with time alone:

r(7.5)

ans =

0.0472

The equivalence of these last two commands highlights some important features.

When you specify parameters as functions, they must evaluate properly when passed a scalar, real-valued sample time (t), and a NVARS-by-1 state vector (Xt). They must also generate an array of appropriate dimensions, which in the first case is a scalar constant, and in the second case is a scalar, piecewise constant function of time alone.

You are not required to use either time (t) or state (Xt). In the current example, the function evaluates properly when passed time followed by state, thereby satisfying the minimal requirements. The fact that it also evaluates correctly when passed only time simply indicates that the function does not require the state vector Xt. The important point to make is that it works when you pass it (t, Xt).

Furthermore, the ts2func function performs a zero-order-hold (ZOH) piecewise constant interpolation. The notion of piecewise constant parameters is pervasive throughout the SDE architecture, and is discussed in more detail in Optimizing Accuracy: About Solution Precision and Error.

4.

Perform a second simulation using the same initial random number state. Complete the comparison by performing the second simulation using the same initial random number state:

strm = RandStream(‘mt19937ar’,’Seed’,5713);

RandStream.setDefaultStream(strm);

obj = gbm(r, diag(sigma), ‘StartState’, 100)

X2 = obj.simulate(nPeriods, ‘DeltaTime’, dt);

obj =

Class GBM: Generalized Geometric Brownian Motion

————————————————

Dimensions: State = 1, Brownian = 1

————————————————

StartTime: 0

StartState: 100

Correlation: 1

Drift: drift rate function F(t,X(t))

Diffusion: diffusion rate function G(t,X(t))

Simulation: simulation method/function simByEuler

Return: function ts2func/vector2Function

Sigma: 0.231875

5.

Compare the two simulation trials. Plot the series of risk-free reference rates to compare the two simulation trials:

subplot(2,1,1)

plot(dates, 100 * yields)

datetick(‘x’), xlabel(‘Date’), …

ylabel(‘Annualized Yield (%)’)

title(‘Risk Free Rate(3-Mo Euribor Continuously-Compounded)’)

subplot(2,1,2)

plot(T, X1, ‘red’, T, X2, ‘blue’)

xlabel(‘Time (Years)’), ylabel(‘Index Level’)

title(‘Constant vs. Dynamic Rate of Return: CAC 40’)

legend({‘Constant Interest Rates’ ‘Dynamic Interest Rates’}, …

‘Location’, ‘Best’)

The paths are close but not exact. The blue line in the last plot uses all the historical Euribor data, and illustrates a single trial of a historical simulation.