Transcript Exploring libraries Math.NET Numerics

F# FOR SCIENTIFIC
COMPUTING
VITALII ZAKHAROV
QUICK INTRODUCTION TO F#
F# uses an open development and engineering process. The language evolution process is managed by
Don Syme from Microsoft Research as the BDFL(Benevolent dictator for life) for the language design in
conjunction with the F# Software Foundation. Earlier versions of the F# language were designed by
Microsoft and Microsoft Research using a closed development process.
QUICK INTRODUCTION TO F#: CONTINUATION
F# originates from Microsoft Research, Cambridge, and the language was originally designed and
implemented by Don Syme. Andrew Kennedy contributed to the design of units of measure. The Visual F#
Tools for Visual Studio are developed by Microsoft. The F# Software Foundation developed the F# opensource compiler and tools, incorporating the open-source compiler implementation provided by the
Microsoft Visual F# Tools team.
WHAT MOTIVATED DON SYME AND HIS TEAM AT
MICROSOFT RESEARCH TO PURSUE F# DEVELOPMENT
The F# research project sought to create a variant of the OCaml language running on top of the .Net
platform. A related project at MSR Cambridge, SML.NET, did the same for Standard ML. (OCaml and
Standard ML are both variants of the ML language.) The motivations for this might have included:
• Showing it can be done.
• Publishing scientific papers showing it can be done.
• Because ML is incredibly cool.
DIVE INTO F#
FUNCTIONAL PROGRAMMING
• F# is a strongly typed functional-first language that uses type inference. The programmer does not need
to declare types—the compiler deduces types during compilation. F# also allows explicit type
annotations, and requires them in some situations.
• F# is an expression-based language using eager evaluation. Every statement in F#, including if
expressions, try expressions and loops, is a composable expression with a static type. Functions and
expressions that do not return any value have a return type of unit. F# uses the let keyword for binding
values to a name.
For example:
binds the value 7 to the name x.
DIVE INTO F#: CONTINUATION
FUNCTIONAL PROGRAMMING
• New types are defined using the type keyword. For functional programming, F# provides tuple, record,
discriminated union, list and option types. A tuple represents a collection of n values, where n ≥ 0. The
value n is called the arity of the tuple. A 3-tuple would be represented as (A, B, C), where A, B and C are
values of possibly different types. A tuple can be used to store values only when the number of values is
known at design-time and stays constant throughout execution.
• A record is a type where the data members are named, as in { Name:string; Age:int }. Records can be
created as { Name="AB"; Age=42 }. The with keyword is used to create a copy of a record, as in { r with
Name="CD" }, which creates a new record by copying r and changing the value of the Name field
(assuming the record created in the last example was named r).
• A discriminated union type is a type-safe version of C unions. For example,
DIVE INTO F#: CONTINUATION
FUNCTIONAL PROGRAMMING
• Values of the union type can correspond to either union case. The types of the values carried by each
union case is included in the definition of each case.
• The list type is an immutable linked list represented either using a head::tail notation (:: is the cons
operator) or a shorthand as [item1; item2; item3]. An empty list is written []. The option type is a
discriminated union type with choices Some(x) or None. F# types may be generic, implemented as
generic .NET types.
• F# supports lambda functions and closures. All functions in F# are first class values and are immutable.
Functions can be curried. Being first-class values, functions can be passed as arguments to other
functions. Like other functional programming languages, F# allows function composition using the >>
and << operators.
DIVE INTO F#: CONTINUATION
FUNCTIONAL PROGRAMMING
• F# provides sequence expressions that define a sequence seq { ... }, list [ ... ] or array [| ... |] through code that
generates values. For example,
• forms a sequence of squares of numbers from 0 to 14 by filtering out numbers from the range of numbers
from 0 to 25. Sequences are generators – values are generated on-demand (i.e. are lazily evaluated) – while
lists and arrays are evaluated eagerly.
• F# uses pattern matching to bind values to names. Pattern matching is also used when accessing discriminated
unions - the union is value matched against pattern rules and a rule is selected when a match succeeds. F#
also supports Active Patterns as a form of extensible pattern matching. It is used, for example, when multiple
ways of matching on a type exist.
• F# supports a general syntax for defining compositional computations called computation expressions.
Sequence expressions, asynchronous computations and queries are particular kinds of computation
expressions. Computation expressions are an implementation of the monad pattern.
DIVE INTO F#: CONTINUATION
IMPERATIVE PROGRAMMING
F# support for imperative programming includes
•
for loops
•
while loops
•
arrays, created with the [| ... |] syntax
•
hash table, created with the dict [ ... ] syntax or System.Collections.Generic.Dictionary<_,_> type).
•
Values and record fields can also be labelled as mutable. For example:
In addition, F# supports access to all CLI types and objects such as those defined in the System.Collections.Generic
namespace defining imperative data structures.
DIVE INTO F#: CONTINUATION
OBJECT PROGRAMMING
F#, like other CLI languages, can use CLI types and objects through object programming. F# support for
object programming in expressions includes:
• Dot-notation (e.g., x.Name)
• Object expressions (e.g., { new obj() with member x.ToString() = "hello" })
• Object construction (e.g., new Form())
• Type tests (e.g. x :? string)
• Type coercions (e.g., x :?> string)
• named arguments (e.g., x.Method(someArgument=1))
• Named setters (e.g., new Form(Text="Hello"))
• Optional arguments (e.g., x.Method(OptionalArgument=1)
DIVE INTO F#: CONTINUATION
IMPERATIVE PROGRAMMING
Support for object programming in patterns includes
•
Type tests (e.g., :? string as s)
•
Active patterns, which can be defined over object types
F# object type definitions can be class, struct, interface, enum or delegate type definitions, corresponding
to the definition forms found in the C#. For example, here is a class with a constructor taking a name and
age, and declaring two properties.
DIVE INTO F#: CONTINUATION
ASYNCHRONOUS PROGRAMMING
F# supports asynchronous programming through asynchronous workflows. An asynchronous workflow is
defined as a sequence of commands inside an async{ ... }, as in
DIVE INTO F#: CONTINUATION
PARALLEL PROGRAMMING
Parallel programming is supported partly through the Async.Parallel, Async.Start and other operations that
run asynchronous blocks in parallel.
Parallel programming is also supported through the Array.Parallel functional programming operators in the
F# standard library, direct use of the System.Threading.Tasks task programming model, the direct use of
.NET thread pool and .NET threads and through dynamic translation of F# code to alternative parallel
execution engines such as GPU code.
DIVE INTO F#: CONTINUATION
UNITS OF MEASURE
The F# type system supports units of measure checking for numbers. The units of measure feature
integrates with F# type inference to require minimal type annotations in user code.
Unit of measurement
A unit of measurement is a definite magnitude of a physical quantity, defined and adopted by convention
or by law, that is used as a standard for measurement of the same physical quantity. Any other value of the
physical quantity can be expressed as a simple multiple of the unit of measurement.
The following line defines the measure ml (milliliter) as a cubic centimeter (cm^3).
DIVE INTO F#: CONTINUATION
METAPROGRAMMING
F# allows some forms of syntax customization to support embedding custom domain-specific languages
within the F# language itself, particularly through computation expressions.
F# includes a feature for run-time meta-programming called quotations. A quotation expression evaluates
to an abstract syntax representation of F# expressions. A definition labelled with the
[<ReflectedDefinition>] attribute can also be accessed in its quotation form. F# quotations are used for
various purposes including to compile F# code to JavaScript and GPU code.
DIVE INTO F#: CONTINUATION
INFORMATION RICH PROGRAMMING
F# 3.0 introduced a form of compile-time meta-programming through statically extensible type generation called F# type
providers. F# type providers allow the F# compiler and tools to be extended with components that provide type information to
the compiler on-demand at compile time. F# type providers have been used to give strongly typed access to connected
information sources in a scalable way, including to the Freebase knowledge graph.
The combination of type providers, queries and strongly typed functional programming is known as information rich
programming.
DIVE INTO F#: CONTINUATION
AGENT PROGRAMMING
F# supports a variation of the Actor programming model through the in-memory implementation of
lightweight asynchronous agents. For example, the following code defines an agent and posts 2 messages:
DIVE INTO F#: CONTINUATION
EXAMPLES - HELLO WORLD
DIVE INTO F#: CONTINUATION
EXAMPLES - A PERSON CLASS WITH A CONSTRUCTOR TAKING A NAME AND AGE AND TWO
PROPERTIES
DIVE INTO F#: CONTINUATION
EXAMPLES - THE FACTORIAL FUNCTION FOR NON-NEGATIVE 32-BIT INTEGERS (OFTEN USED TO
DEMONSTRATE THE SYNTAX OF FUNCTIONAL LANGUAGES)
DIVE INTO F#: CONTINUATION
EXAMPLES - ITERATION EXAMPLES
DIVE INTO F#: CONTINUATION
EXAMPLES - FIBONACCI EXAMPLES
DIVE INTO F#
DEVELOPMENT TOOLS
• The Visual F# tools from Microsoft include full IDE integration in Visual Studio. With the language service
installed, Visual Studio can be used to create F# projects and the Visual Studio debugger used to debug F#
code. In addition, the Visual F# tools comes with a Visual Studio-hosted REPL interactive console that can be
used to execute F# code as it is being written.
• F# can be developed with any text editor. Specific support exists in editors such as Emacs.
• WebSharper is a framework for cross-tier JavaScript and HTML5 development with F#.
• MonoDevelop is an integrated development environment supporting F# programming on Linux, Mac and
Windows including support for the interactive console as used by Visual Studio.
• SharpDevelop has supported F# since version 3.0.
• MBrace is a framework and runtime for the development of applications with F# for the cloud.
• LINQPad has supported F# since version 2.x.
• Xamarin Studio supports F# since version 3.0.
FEATURES
NOT AVAILABLE IN OTHER PROGRAMMING LANGUAGES IN .NET WORLD?
• Algebraic datatypes
• Pattern matching
• Type inference
• Succinct syntax
• Sequence expressions
• Asynchronous workflows
• Units of measure
FEATURES: CONTINUATION
ALGEBRAIC DATA TYPES
Conversely, F# has a full support for ADT's and makes it possible to describe business entities more
accurately in terms of data structures reducing the chance of misinterpreting the data and resulting in
higher quality of code. Basically in F# one can avoid unwanted situations by making them unpresentable,
that is simply by leaving no chance to write inappropriate code.
FEATURES: CONTINUATION
TRANSFORMATIONS VS. MUTATIONS
On the other hand, F# encourages using transformations rather than mutations. A transformation doesn't
modify the object, and thus doesn't change the state. It just creates a new object and passes it on keeping
the original object intact. Which means that the object can always be in one single state that was given to
it at birth. Having to deal with just one state greatly simplifies the development process and reduces the
amount of code, because whenever we see an object we know it's in the only state possible and it's safe to
use it without doing extra checks.
FEATURES: CONTINUATION
EXPRESSIONS VS. STATEMENTS
Program in F# is essentially a big expression (a formula) composed of smaller expressions that map the
input values to some output values. The order in which different parts of the expression are evaluated is
not important, because in side-effects-free calculation model the order of evaluation doesn't change the
result. So switching from using statements to programming with expressions results in safer code free of
bugs caused by the wrong order of statements.
FEATURES: CONTINUATION
KEEPING DATA AND LOGIC SEPARATELY
Functional programming suggests that you don’t mix data with logic; as a result the serialization to JSON or
XML is much easier and straightforward.
FEATURES: CONTINUATION
TYPE INFERENCE AND CONCISE SYNTAX
F# has an advanced type inference system that deduces types of values from how these values are used, so
in most cases it is recommended to omit types in your code letting F# to figure them out. Having to type
less results in higher productivity and better maintainability of the code. Some people find F# syntax more
elegant and easier to read.
FEATURES: CONTINUATION
UP-DOWN LEFT-TO-RIGHT EVALUATION
In F# the order of declaration is strictly up to the order of files, so you cannot refer to or use something
that hasn't been declared before. While this may seem an unnecessary complication, it is rather a good
thing, because it imposes more discipline on the developer and makes his intentions explicit.
FEATURES: CONTINUATION
INHERENT TESTABILITY AND GOOD DESIGN
Modern object oriented design principles known as SOLID can be easily violated in C#; that’s why it is
important to know them and follow them closely. However, the very same principles are in the nature of
the functional programming. So the F# language encourages you to code the right way from the start and it
takes some deliberate effort to mess things up in F#.
FEATURES: CONTINUATION
RUNNING IN PARALLEL AT LOW EXPENSE
F# eliminates the problem when 2 threads are trying to modify the same object simultaneously completely
by disallowing objects from being modified after creation, whenever a change is needed a new object is
constructed by applying a transformation on the original object. This means that the code written in F# can
naturally be run in parallel with little additional efforts.
FEATURES: CONTINUATION
BETTER MODULARITY
A basic unit of logic in F# is a function. Functions in F# are first-class citizens which can be passed as
parameters to other functions and be returned as a result of a function. Writing functions takes less effort
than writing classes. This enables a finer level of modularity and more sophisticated composition scenarios
at lower cost.
FEATURES: CONTINUATION
FOCUSING ON SOLVING GENERIC PROBLEMS INSTEAD OF SPECIFIC ONES
F# encourages you to use generic data-types instead of concrete ones. The same algorithm written for
generics will work on different concrete types like numbers or strings or complex objects. Having just one
generic implementation for different types makes the code more reusable and leaves less room for a
mistake.
FEATURES: CONTINUATION
TYPE PROVIDERS
F# has a unique mechanism for working with heterogeneous sources of data in a convenient unified way
called type providers. Type providers abstract the implementation details of various sources of data,
ensure the type safety and expose standard well-defined interfaces. They also feature on-demand type
discovery when new types are loaded only when needed. There is a repository of type providers to various
sources of data, which is constantly updated and contributed to by the community. Type providers enable
information-rich programming by making it easier to consume the data from different sources.
FEATURES: CONTINUATION
STANDARD TOOLS FOR GENERATING PARSERS
F# has 2 standard tools FsLex and FsYacc for generating parsers based on a formal grammar. These tools are
named after Lex and Yacc the popular parser generator utilities in the Unix world. FsLex and FsYacc have
rich diagnostic capabilities and can be incorporated in the build process helping to streamline the
development.
FEATURES: CONTINUATION
OTHER LANGUAGES SIMILAR TO F#
• Standard ML
• OCaml
• Haskell
• Clojure
FEATURES: CONTINUATION
NULL
• Options Instead of NULL References
• F# doesn't allow NULL's, instead the options have to be used. They guarantee safety and serve the same
purpose of representing missing objects just like NULL's do in C#.
USE F# ON LINUX
OPTION 1: USE THE F# DEBIAN/UBUNTU PACKAGES
F# is available as a Debian package.
It is highly recommended (albeit optional) that you add the Xamarin Mono package repository to your sources to
get a much more up-to-date version of the Mono runtime used by F#.
•
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF
•
echo "deb http://download.mono-project.com/repo/debian wheezy main" | sudo tee /etc/apt/sources.list.d/monoxamarin.list
For Ubuntu 12.04 and 12.10 you will need an additional repository as well, see these instrutions. Older F# and
Mono packages are available in Debian testing and Ubuntu 14.04 (trusty/universe).
Regardless of which repository source you are using, proceed to install the fsharp & mono packages
•
sudo apt-get update
•
sudo apt-get install mono-complete fsharp
USE F# ON LINUX
OPTION 2: BUILD AND INSTALL THE F# RUNTIME, COMPILER AND TOOLS
•
•
Get Mono, the cross-platform, open source .NET runtime implementation used by F#. Preferably use a package from your distribution
or Xamarin. If this is not possible, install from source by following these instructions.
Note that if you are installing to a private prefix, follow these instructions and ensure LD_LIBRARY_PATH includes the “lib” directory of
that prefix location and PKG_CONFIG_PATH includes the “lib/pkgconfig” directory of that prefix location, e.g.
•
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/user/mono/lib/
•
export PKG_CONFIG_PATH=/home/user/mono/lib/pkgconfig/
Build and install the F# Compiler (open edition) from source. If using a VM or other memory-constrained system, be aware that errors
during compilation may be due to insufficient memory (in particular error 137).
•
sudo apt-get install autoconf libtool pkg-config make git automake
•
git clone https://github.com/fsharp/fsharp
•
cd fsharp
•
./autogen.sh --prefix /usr
•
make
•
sudo make install
USE F# ON MAC OSX
• Option 1: Install F# with Xamarin Studio
•
Xamarin Studio is a free IDE for general purpose development, with freemium add-ins for mobile development.
•
Install Xamarin Studio
• Option 2: Install F# alone
•
To use the F# command-line compiler and tools on Mac OSX:
•
Install Mono. Use version 4.2.0 or later.
• Option 3: Install F# via Homebrew
•
F# is installed as part of the Mono homebrew formula:
•
brew install mono
USE F# ON MAC OSX: CONTINUATION
OPTION 4: INSTALL F# (64-BIT)
To use the F# command-line compiler and tools on Mac OSX in 64-bit mode:
• Get and build a 64-bit installation of the runtime used by F# from source.
Set the “–prefix” flag, e.g. “–prefix=/mono64”
•
git clone https://github.com/mono/mono
•
cd mono
•
./autogen.sh --prefix=/mono64 --enable-nls=no
•
make
•
sudo make install
USE F# ON MAC OSX: CONTINUATION
OPTION 4: INSTALL F# (64-BIT)
•
Compile F# from source
Set the “–prefix” flag, e.g. “–prefix=/mono64”
•
git clone https://github.com/fsharp/fsharp
•
cd fsharp
•
./autogen.sh --prefix=/mono64
•
make
•
sudo make install
USE F# ON MAC OSX: CONTINUATION
OPTION 4: INSTALL F# (64-BIT)
• When you run mono, use /mono64/bin/mono and put /mono64/bin on your path. Adjust other
applications that launch mono to use this location.
• Xamarin Studio and MonoDevelop run applications in 32-bit mode by default. You will need to run
programs from the command line to benefit from 64-bit execution.
GUIDE - CROSS-PLATFORM DEVELOPMENT WITH F#
• To get started with F#, please refer to the following documents:
•
Getting Started with F# on Mac
•
Getting Started with F# on Linux
•
Getting Started with F# on Windows
•
Getting Started with F# for iOS Programming
•
Getting Started with F# for Android Programming
COMMAND LINE TOOLS
You can start F# Interactive using:
$ fsharpi
> 1+1;;
val it : int = 2
You’re off! Some common commands are:
fsharpi
(starts F# interactive)
fsharpc file.fs
(F# compiler)
xbuild
(builds .fsproj projects and .sln files)
mono file.exe arg1 ... argN
(runs a compiled F# program)
mkbundle --static file.exe -o file (makes a static native image, including the F# runtime)
EXPLORING LIBRARIES
MATH.NET NUMERICS
• Math.NET Numerics aims to be the standard open source math library for .NET Framework. It is
released under the MIT license and so it can be used in both commercial and noncommercial projects,
as well as modified and redistributed. This tutorial gives an introduction on how to use the various
components of this library.
• Currently, Math.NET Numerics is the most actively developed part of Math.NET. Among others, it
contains a wide range of numerical algorithms including:
•
Types representing dense as well sparse vectors and matrices.
•
A library containing a full set of standard linear algebra routines.
•
A range of random number generators with different strengths.
•
Additional features that include support for certain numerical integration and statistical functions.
EXPLORING LIBRARIES
MATH.NET NUMERICS
The Math.NET Numerics library is implemented in the safe subset of C# language, which makes it very
portable. The library runs on a wide range of platforms, including Microsoft .NET Framework (for
developing web, server, and desktop applications), Silverlight (for developing rich client-side and Windows
Phone 7 applications), and Mono as well as Moonlight (for developing cross-platform applications).
Another important feature of Math.NET Numerics is that it provides wrappers for highly-optimized native
math libraries such as Intel MKL and AMD ACML. This makes it possible to utilize specialized CPU
instruction sets when they are available. For example, the matrix multiplication in Intel MKL runs several
times faster than portable C# code.
EXPLORING LIBRARIES
MATH.NET NUMERICS
USAGE
• The Math.NET Numerics library can be downloaded from the official homepage at CodePlex. The two
assemblies
that need
to be
referenced
when
using
the
library
from
F#
are MathNet.Numerics.dll and MathNet.Numerics.FSharp.dll. When using Math.NET Numerics on
others from Windows platforms, the library may need to be compiled from the source.
• The F# support for interactive scripting makes it more convenient to write and explore mathematical
problems using an F# Script File and F# Interactive in Visual Studio.
• The MathNet.Numerics.dll assembly contains types for vectors and matrices, linear algebra routines,
and others. TheMathNet.Numerics.FSharp.dll assembly is a small F# wrapper for Math.NET Numerics,
which helps to create vectors and matrices using basic F# types such as sequences and lists. The
distribution also comes with documentation (MathNet.Numerics.chm) and a comprehensive set of
examples in C#.
EXPLORING LIBRARIES
MATH.NET NUMERICS
USAGE
Math.NET Numerics can be referenced from an F# Script File using the following commands:
EXPLORING LIBRARIES
MATH.NET NUMERICS
CREATING AND ACCESSING VECTORS AND MATRICES
The most fundamental data structures of a numerical library are types representing vectors and matrices.
In Math.NET Numerics, there are four kinds of vectors and matrices for different numeric types (float,
double, complex32, and 64-bit complex). The types are located in four sub-namespaces of
the MathNet.Numerics.LinearAlgebra namespace. A script file typically imports vectors and matrices from
one of the four sub-namespaces (Single, Double, Complex32 or Complex). The following snippet shows
how to use vectors from the Double namespace. For historical reasons, F# calls the double type float, and
the single type is called float32.
EXPLORING LIBRARIES
MATH.NET NUMERICS
CREATING AND ACCESSING VECTORS AND MATRICES
The DenseVector type can be created using an overloaded constructor. When provided with an integer, it
creates a zero vector of the specified size. The second example creates a vector of the given size with each
element set to 3.0. Finally, the last two examples create a vector from the data contained in an array or
another vector, respectively.
EXPLORING LIBRARIES
MATH.NET NUMERICS
CREATING AND ACCESSING VECTORS AND MATRICES
A vector is a mutable type, so it is possible to change its values. The following snippet shows several
examples of reading and writing vector elements:
EXPLORING LIBRARIES
MATH.NET NUMERICS
CREATING AND ACCESSING VECTORS AND MATRICES
Similarly to the DenseVector type, there are also four different DenseMatrix types defined in the same four
namespaces. The following listing shows how to create double matrices using the constructors
of DenseMatrix.
EXPLORING LIBRARIES
MATH.NET NUMERICS
CREATING AND ACCESSING VECTORS AND MATRICES
Similarly to vectors, matrices are mutable types and the elements can be accessed or modified using the
indexer and methods of the Matrix type:
EXPLORING LIBRARIES
MATH.NET NUMERICS
USING F# EXTENSIONS
Math.NET Numerics comes with a small assembly MathNet.Numerics.FSharp.dll that contains several
extensions designed especially for F#. Functions from this assembly make creating vectors and matrices in
F# even easier. After referencing the assembly, F# functionality can be found in
the MathNet.Numerics.FSharp namespace:
EXPLORING LIBRARIES
MATH.NET NUMERICS
USING LINEAR ALGEBRA ROUTINES
WRITING LINEAR ALGEBRA CALCULATIONS
Working with linear algebra in the Math.NET Numerics library is very easy. Most of the important
operations are available as members of the matrixtype. The following code example shows how to create a
random matrix and calculate its inverse:
EXPLORING LIBRARIES
MATH.NET NUMERICS
USING LINEAR ALGEBRA ROUTINES
WRITING LINEAR ALGEBRA CALCULATIONS
An inverse matrix can be calculated using the Inverse member. Other linear algebra operations can be accessed
using the same syntax. The next three snippets show how to decompose a matrix using the QR decomposition,
Eigenvalue Decomposition (EVD), and Singular Value Decomposition (SVD) algorithms:
The first two lines show how to calculate the QR decomposition on a dense matrix A. QR decomposition is often
used for solving linear least squares problems. The following two lines show how to perform the Eigen
decomposition of a matrix, which has many applications, such as face recognition and Principal Components
Analysis (PCA). The final two lines show how to calculate the SVD.
EXPLORING LIBRARIES
MATH.NET NUMERICS
USING LINEAR ALGEBRA ROUTINES
WRITING LINEAR ALGEBRA CALCULATIONS
Math.NET Numerics uses an extensibility model that can be used to provide an alternative implementation
of basic linear algebra operations. The extensibility model is based on the concept of the linear algebra
provider. Technically, a provider is a .NET interface that is similar to the standard linear algebra operations
defined in LAPAK. The following F# code snippet shows a part of the interface:
The above listing shows that the style of parameters is very similar to that of LAPAK library.
EXPLORING LIBRARIES
MATH.NET NUMERICS
USING LINEAR ALGEBRA ROUTINES
WRITING LINEAR ALGEBRA CALCULATIONS
After the steps needed to compile Acml done, the Math.NET Numerics library can be configured to use the
newly compiled provider. This can be done using the following snippet:
The performance of the two implementations can be compared by measuring the time needed to execute
the examples. The easiest way to do that is to use the #time directive in F# Interactive.
EXPLORING LIBRARIES
MATH.NET NUMERICS
USING PROBABILITY AND STATISTICS APIS
The support for probability and statistics is one distinguishing features of the Math.NET Numerics library.
The library contains a wide range of probability distributions, samplers, as well as functions for descriptive
statistics.
EXPLORING LIBRARIES
MATH.NET NUMERICS
USING PROBABILITY AND STATISTICS APIS
WORKING WITH PROBABILITY DISTRIBUTIONS
Math.NET Numerics implements a large number of probability distributions, both continuous (represented
using the IContinuousDistribution interface) and discrete (the IDiscreteDistribution interface). There are
about thirty different univariate distributions and six multivariate distributions.
Each distribution is represented by an object that has a constructor to create a distribution using the
specified parameters. The distribution object implements one of the interfaces and provides properties to
get the basic statistics such as the mean and standard deviation of the distribution. Both interfaces also
provide a method Sample that generates a random sample from this distribution. This is a very important
operation required by many algorithms such as Markov chain Monte Carlo (MCMC) methods.
EXPLORING LIBRARIES
MATH.NET NUMERICS
USING PROBABILITY AND STATISTICS APIS
WORKING WITH PROBABILITY DISTRIBUTIONS
The following listing creates a normal distribution and uses it to generate two random samples:
The objects representing probability distributions can be found in
the MathNet.Numerics.Distributions namespace. When creating a Normaldistribution, the constructor
expects a mean and a standard deviation as arguments. After creating the distribution, the Sample method
can be used to generate random samples.
EXPLORING LIBRARIES
MATH.NET NUMERICS
USING PROBABILITY AND STATISTICS APIS
WORKING WITH PROBABILITY DISTRIBUTIONS
The next snippet shows how to obtain basic statistics about the distribution:
The first line shows the density value at 5.0 for normal. The second line shows how to get the right point
value (7.579) given a cumulative sum (0.95) of a normal distribution. Finally, the Samples member can be
used to generate an infinite sequence of random samples. The snippet uses Seq.takeand Seq.toList to take
first 10 samples and convert them to an F# list.
EXPLORING LIBRARIES
MATH.NET NUMERICS
USING PROBABILITY AND STATISTICS APIS
USING DESCRIPTIVE STATISTICS
Another feature that the library provides is a set of extension methods for calculating descriptive statistics of data
collections such as mean, variance, maximum, and minimum. The methods are implemented in a Statistics class
in the MathNet.Numerics.Statistics namespace. They can be called either directly or using the dot-notation on
any type that implements IEnumerable<float>:
The snippet uses the normal distribution from the previous section to generate a random sequence of numbers
using a normal distribution with mean 1.0 and a standard deviation 4.0. As expected, the statistics calculated
from the data using the Mean and StandardDeviation extension methods are quite close to the properties of the
distribution.
EXPLORING LIBRARIES
MATH.NET NUMERICS
USING PROBABILITY AND STATISTICS APIS
USING DESCRIPTIVE STATISTICS
In addition, the library also provides a DescriptiveStatistics object that can be created from a collection and
precomputes all the statistics at once:
The listing uses the DescriptiveStatstics type to calculate the mean, standard deviation as well as numerous other
statistics from the data. Since the snippet uses the same dataset, the results are the same as the values
calculated using extension methods. The main benefit of using the DescriptiveStatstics type is that it processes
the data only once.
EXPLORING LIBRARIES
MATH.NET NUMERICS
SUMMARY
This section introduced various components of the Math.NET Numerics library. It discussed how to work
with matrices and vectors using the .NET API provided by the library as well as using F# wrappers. It also
demonstrated how to use linear algebra functionality of the library. The basic implementation is fully
managed, but it is possible to use native libraries such as Intel MKL or AMD ACML.
Finally, the section looked at several topics from the area of probability and statistics. It demonstrated how
to construct and sample a distribution and how to calculate basic descriptive statistics. Some of the topics
that were not covered, but are supported by Math.NET Numerics, include numerical integration and
interpolation.
EXPLORING LIBRARIES
ACCORD.NET MACHINE LEARNING FRAMEWORK (CLUSTERING, CLASSIFICATION, REGRESSION).
Accord.NET is a framework for scientific computing in .NET. The framework is comprised of multiple
libraries encompassing a wide range of scientific computing applications, such as statistical data
processing, machine learning, pattern recognition, including but not limited to, computer vision and
computer audition. The framework offers a large number of probability distributions, hypothesis tests,
kernel functions and support for most popular performance measurements techniques.
EXPLORING LIBRARIES
ACCORD.NET MACHINE LEARNING FRAMEWORK (CLUSTERING, CLASSIFICATION, REGRESSION).
HOW TO USE
LOADING DATA
If you plan to load data into your application (which is most likely the case), then you should consider
adding a reference to the Accord.IO library into your project. This library provides data readers for formats
like Excel, comma-separated values, matlab matrix files, LibSVM and LibLinear's data formats, and others. If
you are interested in loading sounds into your application, consider adding a reference to
the Accord.Audio.Formats library.
EXPLORING LIBRARIES
ACCORD.NET MACHINE LEARNING FRAMEWORK (CLUSTERING, CLASSIFICATION, REGRESSION).
TABLES(EXCEL AND EXCEL COMPATIBLE FILES (SUCH AS .CSV)
To import a table from Excel or .CSV files, you can use the ExcelReader class class. To load the contents of
"Sheet1" located in "worksheet.xlsx", use:
In order to convert a DataTable to a framework matrix, we can use
EXPLORING LIBRARIES
ACCORD.NET MACHINE LEARNING FRAMEWORK (CLUSTERING, CLASSIFICATION, REGRESSION).
MATRICES
The framework can load any MATLAB-compatible .mat file using the MatReader class. It can also parse
matrices written in MATLAB, Octave, Mathematica and C#/NET formats directly from text. Examples are
shown below.
EXPLORING LIBRARIES
ACCORD.NET MACHINE LEARNING FRAMEWORK (CLUSTERING, CLASSIFICATION,
REGRESSION).MANIPULATING MATRICES
The framework provides matrix manipulation routines through extension methods. Just import the
Accord.Math namespace into your source file and all common .NET datatypes will be extended with
several extension methods related to mathematics. Please see the Mathematics page for more examples
and details.
EXPLORING LIBRARIES
ACCORD.NET MACHINE LEARNING FRAMEWORK (CLUSTERING, CLASSIFICATION, REGRESSION).
MANIPULATING MATRICES
One common task in matrix manipulation is to decompose a matrix into various forms. Some examples of
the decompositions supported by the framework are listed below. Those decompositions can be used to
solve linear systems, compute matrix inverses and pseudo-inverses and extract other useful information
about data.
EXPLORING LIBRARIES
ACCORD.NET MACHINE LEARNING FRAMEWORK (CLUSTERING, CLASSIFICATION, REGRESSION).
DATA PREPROCESSING
Before attempting to learn a machine learning model, a good practice is to preprocess, normalize and
clean your data. One of the simplest ways to normalize data is by transforming them to Z-scores. In order
to transform your data to Z-Scores, you can use the following method:
In case you would like to subtract the mean from your data, you can use the Center method
And to divide by the standard deviation you can use the Standardize method
EXPLORING LIBRARIES
ACCORD.NET MACHINE LEARNING FRAMEWORK (CLUSTERING, CLASSIFICATION, REGRESSION).
SOME OTHER CATEGORIES
• Learning from input and output pairs
• Finding similarity groups in data
• Visualizing your results
F# AND PYTHON
PYTHON FOR .NET
Python for .NET - Allows Python to be integrated into F# and C# programs
Embedding Python
Note: because Python code running under Python for .NET is inherently unverifiable, it runs totally under
the radar of the security infrastructure of the CLR so you should restrict use of the Python assembly to
trusted code.
The Python runtime assembly defines a number of public classes that provide a subset of the functionality
provided by the Python C API.
These classes include PyObject, PyList, PyDict, etc. The source and the unit tests are currently the only API
documentation.. The rhythym is very similar to using Python C++ wrapper solutions such as CXX.
F# AND PYTHON
PYTHON FOR .NET
At a very high level, to embed Python in your application you will need to:
• Reference Python.Runtime.dll in your build environment
• Call PythonEngine.Intialize() to initialize Python
• Call PythonEngine.ImportModule(name) to import a module
The module you import can either start working with your managed app environment at the time its
imported, or you can explicitly lookup and call objects in a module you import.
F# AND PYTHON
PYTHON FOR .NET
For general-purpose information on embedding Python in applications, use www.python.org or Google to
find (C) examples. Because Python for .NET is so closely integrated with the managed environment, you
will generally be better off importing a module and deferring to Python code as early as possible rather
than writing a lot of managed embedding code.
Important Note for embedders: Python is not free-threaded and uses a global interpreter lock to allow
multi-threaded applications to interact safely with the Python interpreter. Much more information about
this is available in the Python C API documentation on the www.python.org Website.
When embedding Python in a managed application, you have to manage the GIL in just the same way you
would when embedding Python in a C or C++ application.
F# AND PYTHON
PYTHON FOR .NET
Before interacting with any of the objects or APIs provided by the Python.Runtime namespace, calling code
must have acquired the Python global interpreter lock by calling the PythonEngine.AcquireLock method.
The only exception to this rule is the PythonEngine.Initialize method, which may be called at startup
without having acquired the GIL.
When finished using Python APIs, managed code must call a corresponding PythonEngine.ReleaseLock to
release the GIL and allow other threads to use Python.
The AcquireLock and ReleaseLock methods are thin wrappers over the unmanaged PyGILState_Ensure and
PyGILState_Release functions from the Python API, and the documentation for those APIs applies to the
managed versions.
WHAT IS R?
R is an Open Source language for statistical computing. R offers a wide range of high-quality, communitydeveloped 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, or command line
interactive environment.
F# AND R
R.NET
R.NET enables the .NET Framework to interoperate with the R statistical language in the same process.
R.NET requires the .NET Framework 4 and the native R shared libraries installed with the R environment.
You can use R.NET from any language targeting .NET (it has been used at least from C#, F#, Vb.NET,
IronPython). For F#, you probably should consider F# R Provider. One motivation for releasing 1.5.13 is for
the RProvider to more easily manage dependency on R.NET.
F# AND R
R.NET
• As of version 1.5.10 or later, R.NET binaries are platform independent. You might need to set up a small
add-on workaround on some Linux distributions (CentOS a known one), but otherwise you can just
move and use the same R.NET binaries across platforms.
• As of July 2015, NuGet is the strongly recommended way to manage dependencies on R.NET in its
binary distribution form. You can find more general information about NuGet at the NuGet
F# AND R
R.NET
EXAMPLES - HELLO WORLD
The following "Hello World" sample illustrates how the new API is simpler in 90% of use cases on Windows
(on Linux you may need to set up an environment variable, see thereafter):
F# AND R
R.NET
You retrieve a single REngine object instance, after setting the necessary environmental variables. Even the
call to REngine.SetEnvironmentVariables() can be omitted, though we'd advise you keep it explicit.
SetEnvironmentVariables, on Windows, looks at the Registry settings set up by the R installer.
If R.NET complains about not being able to find one of the paths to R, see . This can happen due to the
many variations of states of Windows Registries and environment variables. If need be, you can override
the behaviours setting the environment variables and engine initialization with your own steps.
On Linux/MacOS, the path to libR.so (for Linux) must be in the environment variable {"LD_LIBRARY_PATH"}
before the process start, otherwise the R.NET engine will not properly initialize. If this is not set up, R.NET
will throw an exception with a detailed message giving users hints as to what to do. Read the Appendix at
the end of this page if R.NET complains about your {"LD_LIBRARY_PATH"}.
F# AND R
F# R TYPE PROVIDER
The F# Type Provider is a mechanism that enables smooth interoperability between F# and R. 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.
F# AND R
F# R TYPE PROVIDER
EXAMPLES - PASSING DATA FROM R TO F#
Let's say that you have some data in R and want to pass them to F#. To do that, you can use the save
function in R. The following R snippet creates a simple *.rdata file containing a couple of symbols from the
sample volcano data set:
• To import the data on the F# side, you can use the RData type provider that is available in the RProvider
namespace. It takes a static parameter specifying the path of the file (absolute or relative) and
generates a type that exposes all the saved values as static members:
F# AND R
F# R TYPE PROVIDER
EXAMPLES - PASSING DATA FROM R TO F#
If you perform data acquisition in F# and then want to pass the data to R, you can use the standard R
functions for saving the *.rdata files. The easiest option is to call the R.assign function to define named
values in the R environment and then use R.save to save the environment to a file:
COMPARISON OF PRODUCTIVITY
REFERENCES
• F# Software Foundation and individual contributors (http://fsharp.org/)
• F Sharp (programming language) (https://en.wikipedia.org/wiki/F_Sharp_(programming_language))
• Using Math.NET Numerics in F# (https://msdn.microsoft.com/en-us/library/hh304363.aspx)
• The Accord.NET Framework (https://github.com/accord-net/framework/wiki)
• Python for .NET (http://pythonnet.sourceforge.net/readme.html)
• R.NET (http://jmp75.github.io/rdotnet/)
• F# R Type Provider (http://bluemountaincapital.github.io/FSharpRProvider/)
• Efficiency comparison of scientific computing among different languages
(https://prezi.com/6wpbvnq56ddn/efficiency-comparison-of-scientific-computing-among-differentlanguages/)
• Scientific Computing with F# (https://confengine.com/functional-conf-2015/proposal/1436/scientificcomputing-with-f)
THANK YOU FOR ATTENTION!