I’m working on a program to keep track of paired trades with trailing stops. I need to download stock prices, so I thought I might reuse some old code of mine. Here is the updated framework.
The last post is here. In this post we’ll look at how things work under the cover and to why I came to believe that they shouldn’t work this way.
First of all each one of the functions to create charts looks something like this:
static member bar (?y,?x, ?isValueShownAsLabel, ?markerSize, ?markerStyle, ?color, ?xname, ?yname, ?seriesName, ?title, ?drawingStyle) = let c = Create (SeriesChartType.Bar, x, y, isValueShownAsLabel, markerSize, markerStyle, color, xname, yname, seriesName, title) c.Series..["DrawingStyle"] <- defaultArg drawingStyle (c.Series..["DrawingStyle"]) c
This returns an object of type lc (this is the type of ‘c’). But lc inherits from Chart which is the main class in the Microsoft Chart Controls.
type lc() = inherit Chart()
I should have said at the start that you need to reference such controls.
#r "System.Windows.Forms.DataVisualization.dll" open System.Collections open System.Drawing open System.IO open System.Windows.Forms open System.Windows.Forms.DataVisualization.Charting open System.Windows.Forms.DataVisualization.Charting.Utilities open System
It is convenient that the return value of each function is a subtype of Chart. You can then go and customize this object as you like (i.e. changing graphical appearance) before calling display. Given the Chart inherits from Control you can code the display method as follows:
let display (c:lc) = let copy () = let stream = new MemoryStream() c.SaveImage(stream, Imaging.ImageFormat.Bmp) let bmp = new Bitmap(stream) Clipboard.SetDataObject(bmp) c.KeyDown.Add(fun e -> if e.Control = true && e.KeyCode = Keys.C then copy ()) let pressToCopy = "(press CTRL+C to copy)" let name = if c.Titles.Count = 0 then sprintf "%s %s " "lc" pressToCopy else sprintf "%s %s " c.Titles..Text pressToCopy let f = new Form(Text = name, Size = new Size(800,600), TopMost = true) c.Dock <- DockStyle.Fill f.Controls.Add(c) f.Show() c
Apart from a bit of convolutions to implement a Copy function, this just put the Chart control on a newly created Form. The Create method called inside bar looks like the following.
static let Create (chartType, x, y, isValueShownAsLabel, markerSize, markerStyle, color, xname, yname, seriesName, title) = let c = new lc() let a = new ChartArea() let s = new Series() s.ChartType <- chartType c.ChartAreas.Add(a) c.Series.Add(s) match x, y with | Some(x), None -> failwith "You cannot pass only x to a chart drawing function" | Some(x), Some(y) -> s.Points.DataBindXY(x, [|y|]) | None, Some(y) -> s.Points.DataBindY([|y|]) | None, None -> () s.IsValueShownAsLabel <- defaultArg isValueShownAsLabel s.IsValueShownAsLabel s.MarkerSize <- defaultArg markerSize s.MarkerSize s.MarkerStyle <- defaultArg markerStyle s.MarkerStyle s.Color <- defaultArg color s.Color a.AxisX.MajorGrid.Enabled <- false a.AxisY.MajorGrid.Enabled <- false match xname with | Some(xname) -> a.AxisX.Title <- xname a.AxisX.TitleFont <- axisFont a.AxisX.TitleForeColor <- axisColor | _ -> () match yname with | Some(yname) -> a.AxisY.Title <- yname a.AxisY.TitleFont <- axisFont a.AxisY.TitleForeColor <- axisColor | _ -> () match seriesName with | Some(seriesName) -> s.Name <- seriesName | _ -> () match title with | Some(title) -> let t = c.Titles.Add(title: string) t.Font <- titleFont t.ForeColor <- titleColor | _ -> () c
Pretty standard imperative code here. Creating a chart and assigning its properties. Read the documentation for the Chart Control to understand what I’m doing here. I’m not even sure I remember what I’m doing. Given that we have our own lc class (which is a type of Chart) we can then override the ‘+’ operator and ‘++’ operator to do what is needed.
static member (+) (c1:lc, c2:lc) = let c = copyChart(c1) c1.ChartAreas |> Seq.iter (fun a -> addAreaAndSeries c a c1.Series) let lastArea = c.ChartAreas |> Seq.nth ((c.ChartAreas |> Seq.length) - 1) c2.Series |> Seq.iter(fun s -> c.Series.Add(copySeries s c lastArea.Name)) let l = c.Legends.Add("") l.Font <- legendFont c static member (++) (c1:lc, c2:lc) = let c = copyChart(c1) c1.ChartAreas |> Seq.iter (fun a -> addAreaAndSeries c a c1.Series) let lastArea = c.ChartAreas |> Seq.nth ((c.ChartAreas |> Seq.length) - 1) addAreaAndSeries c c2.ChartAreas. c2.Series let firstArea = c.ChartAreas |> Seq.nth ((c.ChartAreas |> Seq.length) - 1) c2.ChartAreas |> Seq.skip 1 |> Seq.iter (fun a -> addAreaAndSeries c a c2.Series) c
Apart from some other utility functions, this is how it all works. Why do I say that it is wrong? It is my opinion that the right way to do it would be to use ‘+’, ‘++’ and all the lc.XXX functions to create an object model that is completely independent from the Microsoft Chart controls. The display method would then translate it to the appropriate displayable Chart. It would work like a compiler translating to IL and then a Jitter producing native code. This would:
- Make possible to do more interesting compositions of graphs. Now I’m very constrained in what I can do by the fact that I’m working directly with Chart objects
- Make possible to change the backend. Using something different than Microsoft Chart controls to draw the chart
Why I have not done it? I didn’t know that was the right design until I used the wrong one. Now that I know, I have no time to do it.
FYI I imported all the posts from the old MSDN blog to this one. Hence this post doesn’t make sense anymore. I left it here for memory sake. BTW: I am also back in msft now (30/11/2018).
This is my last post on this blog. My new blog is here: https://lucabolognese.wordpress.com/
I accepted a role as Director for Credit Suisse in London. I’m excited by the opportunity to work in the financial industry, a long-standing desire of mine. I’m also excited to write more F# code and to be closer to Italy, where my extended family is.
The past ten years in Microsoft have been a wild ride. I’m proud to have been part of ObjectSpaces, Generics, LINQ and F# (and much more …). I’ve been lucky to be able to post on this blog and present at conferences about such innovative technologies. It has all been a lot of fun. I’m sure the next ten years will be as good.
I’ll see you guys on my new blog.
In the previous post on my old blog I showed how to display simple charts with LChart. In this one we’ll talk about more complex charts. I wanted to define a little language for graphs for the sake of creating a more complex chart in a single line of code. Remember, the scenario here is: I got some data, I want to display it quickly in the fsi. The language has two operators: ‘+’ and ‘++’.
‘+’ allows you to to superimpose things on a chart as in the following example.
lc.scatter(y) + lc.line(y) |> display
Notice how I can superimpose two graphs of a different type and display the result.
Notice on the upper right corner a bizarre (Series1, Series2) legend. What I wanted to do, but didn’t get around to do, was to allow a syntax like
lc.scatter(y) + lc.line(y) + lc.legend(“Players”) |> display
It should be relatively trivial to add it to the code. Also notice that the ‘y’ parameter in the second chart is not needed. Data flows freely from left to right. So you can write the equivalent code below. This is a feature that caused all sort of grief. With hindsight it’s not worth the hassle. That’s why you always need to write your code at least twice to get it right.
lc.scatter(y) + lc.line() |> display
Some other, more elaborate charts follows. Notice how data flows from left to right until I introduce a new variable (i.e. the two lc.boxplot instructions plot different boxplots)
lc.scatter(y, markerSize = 10) + lc.column() + lc.boxplot() + lc.line() + lc.column(x) + lc.boxplot()|> display
Things would be better with names for axis, titles and such. I’m not including them for the sake of simplicity.
lc.scatter(y, markerSize = 10) + lc.column() + (lc.line(x) + lc.column()) + lc.scatter(markerSize = 20) |> display
If you remember the previous post, we talked about boxplots and how you generally want to have more than one on a graph. You can do that with the ‘+’ operator and get this ugly chart. More work is needed here.
lc.boxplot(y = y, xname = "Players", yname = "Ratings", title = "Players' Ratings", color = Color.Blue, whiskerPercentile = 5, percentile = 30, showAverage = false, showMedian = false, showUnusualValues = true) + lc.boxplot(y = x) |> display
‘++’ allows you to create new charts below the chart you already have as in:
let h = [1.;2.5;3.1;4.;4.8;6.0;7.5;8.;9.1;15.] let w = h |> List.map (fun h -> h * 1.2) lc.line(h) + lc.column() ++ lc.line(w) ++ lc.bubble() |> display
Notice the left to right flowing of information here as well. In the next installment we’ll take a look at how things are implemented and why it’s all wrong.
I want to use F# as a exploratory data analysis language (like R). But I don’t know how to get the same nice graphic capabilities. So I decided to create them. Here is a library to draw charts in F#. It steals ideas from this book and this R package. It is nothing more than a wrapper on top of the Microsoft Chart Controls to give it a more ‘exploratory’ one line calling syntax. It is also rough work in progress: I don’t wrap all the chart types and there are bugs in the ones I wrap. Also the architecture is all wrong (more on this in another post). But it’s a start and it kind of works. Attached the full code.
I will continue this series in my new blog at wordpress: https://lucabolognese.wordpress.com/. The reason I need a new blog will be explained in an upcoming post.
Part II is now here.
Ok, let’s start. How do I draw a chart?
let x = [1.;2.5;3.1;4.;4.8;6.0;7.5;8.;9.1;15.]
let y = [1.6;2.1;1.4;4.;2.3;1.9;2.4;1.4;5.;2.9]
lc.scatter(x, y) |> display
X and Y are just some make up data. lc is the name of a class (????) and scatter is a static method on it. scatter doesn’t display the chart, it just produces a an object that represents the chart. Display displays the chart. The reason for using the bizarre lc static class is that I want it to be short so that it is easy to type in the fsi.exe. At the same time it needs to support optional parameters (which are not supported on top level functions in F#).
You get a window with this chart on it. You can press CTRL+C to copy it (as I did to post it here).
You might want to customize the chart a bit by passing some of these famous optional parameters:
lc.scatter(x = x, y = y, markerSize = 10, markerStyle = MarkerStyle.Diamond,
xname = “Players”, yname = “Ratings”, title = “Players’ Ratings”) |> display
Or you might want to print different types of charts:
lc.line(y = y, markerSize = 10, markerStyle = MarkerStyle.Diamond, xname = “Players”, yname = “Ratings”, title = “Players’ Ratings”, isValueShownAsLabel = true,
color = Color.Red) |> display
lc.spline(x = x, y = y, markerSize = 10, markerStyle = MarkerStyle.Diamond, xname = “Players”, yname = “Ratings”,
title = “Players’ Ratings”, isValueShownAsLabel = true, color = Color.Red) |> display
lc.stepline(x = x, y = y, markerSize = 10, markerStyle = MarkerStyle.Diamond, xname = “Players”, yname = “Ratings”,
title = “Players’ Ratings”, isValueShownAsLabel = true, color = Color.Red) |> display
lc.bar(y = y, xname = “Players”, yname = “Ratings”, title = “Players’ Ratings”, isValueShownAsLabel = true,
drawingStyle = “Emboss”) |> display
lc.column(y = y, xname = “Players”, yname = “Ratings”, title = “Players’ Ratings”,
isValueShownAsLabel = true, drawingStyle = “Cylinder”) |> display
lc.boxplot(y = y, xname = “Players”, yname = “Ratings”, title = “Players’ Ratings”, color = Color.Blue, whiskerPercentile = 5, percentile = 30,
showAverage = false, showMedian = false, showUnusualValues = true) |> display
Ok, the last one is weird. You probably want more than one boxplot in a chart. I’ll show you how to do that in the next post.
The next post will be on how to have more than one series on the same chart and more than one chart in the same windows. Something like the below:
Here is a link to the home page: http://code.msdn.microsoft.com/FinancialFunctions/Wiki/View.aspx?title=Home