+ 
+
+
\ No newline at end of file
diff --git a/build.cmd b/build.cmd
new file mode 100644
index 00000000..fdddf6a5
--- /dev/null
+++ b/build.cmd
@@ -0,0 +1,7 @@
+@echo off
+cls
+if not exist tools\FAKE\tools\Fake.exe (
+ .nuget\nuget.exe install FAKE -OutputDirectory tools -ExcludeVersion -Prerelease
+)
+tools\FAKE\tools\FAKE.exe build.fsx %*
+pause
\ No newline at end of file
diff --git a/build.fsx b/build.fsx
new file mode 100644
index 00000000..de930f71
--- /dev/null
+++ b/build.fsx
@@ -0,0 +1,189 @@
+// --------------------------------------------------------------------------------------
+// FAKE build script
+// --------------------------------------------------------------------------------------
+
+#r "tools/FAKE/tools/FakeLib.dll"
+open System
+open System.IO
+open Fake
+open Fake.Git
+open Fake.AssemblyInfoFile
+
+Environment.CurrentDirectory <- __SOURCE_DIRECTORY__
+
+let files includes =
+ { BaseDirectories = [__SOURCE_DIRECTORY__]
+ Includes = includes
+ Excludes = [] } |> Scan
+
+// Information about the project to be used at NuGet and in AssemblyInfo files
+let projectName = "RProvider"
+let projectSummary = "An F# Type Provider providing strongly typed access to the R statistical package."
+let projectDescription = """
+ An F# Type Provider providing strongly typed access to the R statistical package.
+ The type provider automatically discovers available R packages and makes them
+ easily accessible from F#, so you can easily call powerful packages and
+ visualization libraries from code running on the .NET platform."""
+let authors = ["BlueMountain Capital"]
+let companyName = "BlueMountain Capital"
+let tags = "F# fsharp R TypeProvider visualization statistics"
+
+// Read additional information from the release notes document
+// Expected format: "0.9.0-beta - Foo bar." or just "0.9.0 - Foo bar."
+// (We need to extract just the number for AssemblyInfo & all version for NuGet
+let versionAsm, versionNuGet, releaseNotes =
+ let lastItem = File.ReadLines "RELEASE_NOTES.md" |> Seq.last
+ let firstDash = lastItem.IndexOf(" - ")
+ let notes = lastItem.Substring(firstDash + 2).Trim()
+ let version = lastItem.Substring(0, firstDash).Trim([|'*'|]).Trim()
+ // Get just numeric version, if it contains dash
+ let versionDash = version.IndexOf('-')
+ if versionDash = -1 then version, version, notes
+ else version.Substring(0, versionDash), version, notes
+
+// --------------------------------------------------------------------------------------
+// Generate assembly info files with the right version & up-to-date information
+
+Target "AssemblyInfo" (fun _ ->
+ let fileName = "src/Common/AssemblyInfo.fs"
+ CreateFSharpAssemblyInfo fileName
+ [ Attribute.Title projectName
+ Attribute.Company companyName
+ Attribute.Product projectName
+ Attribute.Description projectSummary
+ Attribute.Version versionAsm
+ Attribute.FileVersion versionAsm ]
+)
+
+// --------------------------------------------------------------------------------------
+// Clean build results & restore NuGet packages
+
+Target "RestorePackages" (fun _ ->
+ !! "./**/packages.config"
+ |> Seq.iter (RestorePackage (fun p -> { p with ToolPath = "./.nuget/NuGet.exe" }))
+)
+
+Target "Clean" (fun _ ->
+ CleanDirs ["build"; "gh-pages"; "release" ]
+)
+
+Target "CleanDocs" (fun _ ->
+ CleanDirs ["generated"]
+)
+
+// --------------------------------------------------------------------------------------
+// Build library & test project
+
+Target "Build" (fun _ ->
+ (files ["RProvider.sln"; "RProvider.Tests.sln"])
+ |> MSBuildRelease "" "Rebuild"
+ |> Log "AppBuild-Output: "
+)
+
+// --------------------------------------------------------------------------------------
+// Run the unit tests using test runner & kill test runner when complete
+//
+// TODO: The tests are using xUnit, so tests are not run as part of FAKE currently :-(
+//
+(*
+
+Target "RunTests" (fun _ ->
+ let nunitVersion = GetPackageVersion "packages" "NUnit.Runners"
+ let nunitPath = sprintf "packages/NUnit.Runners.%s/Tools" nunitVersion
+
+ ActivateFinalTarget "CloseTestRunner"
+
+ (files ["tests/*/bin/Release/Test.RProvider.dll"])
+ |> NUnit (fun p ->
+ { p with
+ ToolPath = nunitPath
+ DisableShadowCopy = true
+ TimeOut = TimeSpan.FromMinutes 20.
+ OutputFile = "TestResults.xml" })
+)
+
+FinalTarget "CloseTestRunner" (fun _ ->
+ ProcessHelper.killProcess "nunit-agent.exe"
+)
+*)
+Target "RunTests" DoNothing
+
+// --------------------------------------------------------------------------------------
+// Build a NuGet package
+
+Target "NuGet" (fun _ ->
+ // Format the description to fit on a single line (remove \r\n and double-spaces)
+ let projectDescription = projectDescription.Replace("\r", "").Replace("\n", "").Replace(" ", " ")
+ let nugetPath = ".nuget/nuget.exe"
+ NuGet (fun p ->
+ { p with
+ Authors = authors
+ Project = projectName
+ Summary = projectSummary
+ Description = projectDescription
+ Version = versionNuGet
+ ReleaseNotes = releaseNotes
+ Tags = tags
+ OutputPath = "build"
+ ToolPath = nugetPath
+ AccessKey = getBuildParamOrDefault "nugetkey" ""
+ Publish = hasBuildParam "nugetkey" })
+ "nuget/RProvider.nuspec"
+)
+
+// --------------------------------------------------------------------------------------
+// Generate the documentation
+
+Target "JustGenerateDocs" (fun _ ->
+ executeFSI "tools" "build.fsx" [] |> ignore
+)
+
+Target "GenerateDocs" DoNothing
+"CleanDocs" ==> "JustGenerateDocs" ==> "GenerateDocs"
+
+// --------------------------------------------------------------------------------------
+// Release Scripts
+
+let gitHome = "https://github.com/tpetricek" // TODO: Use "BlueMountainCapital"
+
+Target "ReleaseDocs" (fun _ ->
+ Repository.clone "" (gitHome + "/FSharp.RProvider.git") "gh-pages" // TODO: Use "FSharpRProvider"
+ Branches.checkoutBranch "gh-pages" "gh-pages"
+ CopyRecursive "generated" "gh-pages" true |> printfn "%A"
+ CommandHelper.runSimpleGitCommand "gh-pages" "add ." |> printfn "%s"
+ let cmd = sprintf """commit -a -m "Update generated documentation for version %s""" versionNuGet
+ CommandHelper.runSimpleGitCommand "gh-pages" cmd |> printfn "%s"
+ Branches.push "gh-pages"
+)
+
+Target "ReleaseBinaries" (fun _ ->
+ Repository.clone "" (gitHome + "/FSharp.RProvider.git") "release" // dtto.
+ Branches.checkoutBranch "release" "release"
+ CopyRecursive "build" "release" true |> printfn "%A"
+ let cmd = sprintf """commit -a -m "Update binaries for version %s""" versionNuGet
+ CommandHelper.runSimpleGitCommand "release" cmd |> printfn "%s"
+ Branches.push "release"
+)
+
+Target "Release" DoNothing
+
+// --------------------------------------------------------------------------------------
+// Run all targets by default. Invoke 'build 
+
+The F# Type Provider is a mechanism that enables smooth interoperability
+between F# and [R](http://www.r-project.org/).
+The Type Provider discovers R packages that are available
+in your R installation and makes them available as .NET namespaces
+underneath the parent namespace `RProvider`.
+
+The Type Provider makes it possible to use
+all of R capabilities, from the F# interactive environment.
+It enables on-the-fly charting and data analysis using R packages,
+with the added benefit of IntelliSense over R,
+and compile-time type-checking that the R functions you are using exist.
+It allows you to leverage all of .NET libraries,
+as well as F# unique capabilities to access and manipulate data
+from a wide variety of sources via Type Providers.
+
+### A Quick Demo
+
+
+
+
+
+## What are R and F#?
+
+[F#](http://msdn.microsoft.com/en-us/vstudio/hh388569) is a mixed-paradigm language
+that supports functional, object-oriented and imperative programming,
+with the emphasis on functional. F# runs on the .NET runtime and is a compiled,
+statically typed language with a strong type system and type inference.
+F# is a general purpose programming language,
+and is particularly well-suited for scientific/numerical computing.
+
+[R](http://www.r-project.org/) is an Open Source language for statistical computing.
+R offers a wide range of high-quality, community-developed packages,
+covering virtually every area of statistics, econometrics or machine learning.
+It is also famous for its charting capabilities, making it a great tool
+to produce publication-quality graphics.
+R is an interpreted, dynamically typed language that is typically used
+from its GUI, [RStudio](http://www.rstudio.com/), or command line interactive environment.
+
+## Using the R Type Provider
+
+
+
+
+
+### Pre-requisites
+
+The R Provider requires an installation of R for Windows, downloadable from
+[here](http://cran.cnr.berkeley.edu/bin/windows/base/). RProvider uses the R registry key
+`SOFTWARE\R-core` to locate the R binary directory, in order to load `R.dll`. It will also
+locate `R.dll` if it is on the path. If run from a 32-bit process, RProvider will use
+the 32-bit `R.dll`, and if run from a 64-bit process, it will load the 64-bit version.
+
+If you are using R 2.15 or later, you should not try to load the RProvider inside a script
+that is passed to FSI via the `--use` flag. It seems that something about the way R
+initializes causes it to hang in that context. Works fine if you load later.
+
+For compilation you will need VS2012 / F# 3.0 or later. For runtime you'll need .NET 4.5.
+
+Contributing and copyright
+--------------------------
+
+The project has been developed by [BlueMountain Capital](https://www.bluemountaincapital.com/)
+and contributors. It is available under the BSD license. The library uses
+[RDotNet](http://rdotnet.codeplex.com/) which is also covered by the BSD license.
+For more information see the [License file][license] in the GitHub repository.
+
+The project is hosted on [GitHub][gh] where you can [report issues][issues], fork
+the project and submit pull requests.
+Many thanks to Mathias Brandewinder for producing the [FAKE](https://github.com/fsharp/FAKE) script
+to build the NuGet package, and to Steffen Forkman for writing [FAKE](https://github.com/fsharp/FAKE).
+
+[gh]: https://github.com/blueMountainCapital/FSharpRProvider
+[issues]: https://github.com/blueMountainCapital/FSharpRProvider/issues
+[license]: https://github.com/blueMountainCapital/FSharpRProvider/blob/master/LICENSE.md
diff --git a/docs/internals.md b/docs/internals.md
new file mode 100644
index 00000000..cf24126f
--- /dev/null
+++ b/docs/internals.md
@@ -0,0 +1,22 @@
+# How does it work?
+
+## How do we call into R?
+The RProvider loads the R.DLL (which contains the core of R) into the calling process, via [RDotNet](http://rdotnet.codeplex.com/). This will happen in several places:
+
+* In the IDE, to provide IntelliSense for packages/functions/parameters.
+* In the F# compiler, to generate code that calls the R functionality you are calling.
+* In your resulting binary, to execute the generated code.
+* In F# Interactive, to do all of the above interactively.
+
+## How does RDotNet help?
+RDotNet allows R functionality to be called from .NET, and exposes an object model for representing R values (based on the type RDotNet.SymbolExpression). Using RDotNet, one executes R code by passing strings of R code into an Evaluate method. From the RProvider, we introspect on available R packages and functions and expose them as members of provided types. You can then call them just like regular .NET functions, with IntelliSense and compile-time checking. RDotNet.SymbolicExpression provides a nice OO model of the R native SEXP type, so we simply expose results using that type. To make it more friendly from F#, we extend it with some extension members and active patterns.
+
+## How do we expose R packages?
+RProvider determines the set of installed packages in your R installation and exposes them as namespaces under the root RProvider namespace. This allows you to 'open' the namespaces you want to use as if they were regular .NET namespaces.
+
+Under the namespace for a given package, RProvider exposes a single static type called "R", which contains static methods mirroring each of the functions and values that exist in the package. This means that the members under "R." will be the union of available functions in all of the package namespaces you have opened.
+
+## Is it Statically Typed?
+Kind of. It is statically type checked to the extent that it can be given the type information available from R. In practice, this means that the F# compiler and IDE statically checks that the function you are calling exists in the package you are calling. In some cases, we can also determine that you are not passing too many arguments to the function, though common use of ... (aka varargs/params) in R functions defeats that in many cases.
+
+R is dynamically typed, so we cannot determine what the types of function arguments are supposed to be. So all arguments are of type obj. R functions can also be written such that they will work even if arguments that do not have default values are omitted, so we expose each argument as optional. And for R functions that accept a ... argument, we expose a paramarray argument that allows any number of additional arguments to be passed. In that case, you can basically pass any number of arguments to the function.
\ No newline at end of file
diff --git a/Documentation/misc/logo.pdn b/docs/misc/logo.pdn
old mode 100755
new mode 100644
similarity index 100%
rename from Documentation/misc/logo.pdn
rename to docs/misc/logo.pdn
diff --git a/Documentation/misc/logo.png b/docs/misc/logo.png
old mode 100755
new mode 100644
similarity index 100%
rename from Documentation/misc/logo.png
rename to docs/misc/logo.png
diff --git a/docs/packages.config b/docs/packages.config
new file mode 100644
index 00000000..2b3c0ed9
--- /dev/null
+++ b/docs/packages.config
@@ -0,0 +1,5 @@
+
+
+
+
+
+ Install using the NuGet package.
+ Run the following command in the Package Manager Console:
+
+ PM> Install-Package RProvider+
| R Type | F#/.NET Type |
|---|---|
| character | string or string[] |
| complex | System.Numerics.Complex or Complex[] |
| integer | int or int[] |
| logical | bool or bool[] |
| numeric | double or double[] |
| list | Call R.list, passing the values as separate arguments |
| dataframe | Call R.data_frame, passing column vectors in a dictionary |
| R Type | Requested F#/.NET Type |
|---|---|
| character (when vector is length 1) | string |
| character | string[] |
| complex (when vector is length 1) | Complex |
| complex | Complex[] |
| integer (when vector is length 1) | int |
| integer | int[] |
| logical (when vector is length 1) | bool |
| logical | bool[] |
| numeric (when vector is length 1) | double |
| numeric | double[] |
| R Type | F#/.NET Type |
|---|---|
| character | string[] |
| complex | Complex[] |
| integer | int[] |
| logical | bool[] |
| numeric | double[] |
+
+
+
+Finally, we can obtain data for multiple different indicators and use the `R.pairs` function
+to produce a matrix of scatter plots:
+*)
+
+// Build a list of tickers and get diff of logs of prices for each one
+let tickers =
+ [ "MSFT"; "AAPL"; "X"; "VXX"; "SPX"; "GLD" ]
+let data =
+ [ for t in tickers ->
+ printfn "got one!"
+ t, getStockPrices t 255 |> R.log |> R.diff ]
+
+// Create an R data frame with the data and call 'R.pairs'
+let df = R.data_frame(namedParams data)
+R.pairs(df)
+
+(**
+As a result, you should see a window showing results similar to these:
+
+
+
+
+
+
+*)
diff --git a/docs/whatwhy.md b/docs/whatwhy.md
new file mode 100644
index 00000000..a067eeae
--- /dev/null
+++ b/docs/whatwhy.md
@@ -0,0 +1,27 @@
+# Whats and Whys
+
+## What is R?
+
+[R](http://www.r-project.org/) is an Open Source package for statistical computing. There are a wide range of community-developed packages available that are very useful in the statistical computing/econometrics space.
+
+R is an interpreted, dynamically typed language that is typically used from its GUI or command line interactive environment. But R is also embeddable using the R.DLL.
+
+## What is F#?
+
+[F#](http://msdn.microsoft.com/en-us/vstudio/hh388569) is a mixed-paradigm language that supports functional, object-oriented and imperative programming, with the emphasis on functional. F# runs on the .NET runtime and is a compiled, statically typed language with a strong type system and type inference. F# is typically used in the scientific/numerical computing space, though is quite widely applicable.
+
+## Why use R with F#?
+
+While there are a number of math/statistical packages available for the .NET platform, none of the approach the power of the packages that are available for R. R also includes versatile packages for visualization which are hard to match on .NET.
+
+## What is a Type Provider?
+
+F# 3.0 supports a new feature called [Type Providers](http://msdn.microsoft.com/en-us/library/hh156509.aspx) which allow a set of types and members to be determined at compile time (or in the IDE) based on statically known parameters and (optionally) access to some external resource. The primary purpose of Type Providers is to support strongly-typed access to external data sources, without the additional step of code generation, which adds friction to the development process and is sometimes impractical due to the size of the type space. Type Providers can also be used to interoperate with another language or runtime environment, by introspecting on constructs available in that environment during compile time and making equivalent constructs available to F#.
+
+## Why not just use R directly?
+
+In some cases, this will make a lot of sense, but there are a number of reasons why it might not:
+
+1. F# is particularly well-suited for the retrieval and manipulation/cleansing of data, which we will subsequently want to use in statistical models.
+2. We can combine functionality in .NET libraries (or otherwise callable from F#) with R functionality in a low-friction way.
+3. F# is well-suited to building scalable production applications, and using the R type provider allows us to use R functionality from those applications?
diff --git a/RProvider.nuspec b/nuget/RProvider.nuspec
similarity index 64%
rename from RProvider.nuspec
rename to nuget/RProvider.nuspec
index a10e07a7..81cda46a 100644
--- a/RProvider.nuspec
+++ b/nuget/RProvider.nuspec
@@ -1,19 +1,28 @@
+